Merge pull request #15577 from vslsnap/merge-dev15-rc2-into-master-20161129-160029

Merge dev15-rc2 into master

src/ExpressionEvaluator/Core/Source/FunctionResolver/FunctionResolver.cs

@@ -5,11 +5,11 @@
 using Microsoft.VisualStudio.Debugger.ComponentInterfaces;
 using Microsoft.VisualStudio.Debugger.Evaluation;
 using Microsoft.VisualStudio.Debugger.FunctionResolution;
+using Microsoft.VisualStudio.Debugger.Symbols;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection.Metadata;
-using Microsoft.VisualStudio.Debugger.Symbols;
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator
 {
@@ -39,12 +39,12 @@ void IDkmRuntimeFunctionResolver.EnableResolution(DkmRuntimeFunctionResolutionRe
                 // (see https://github.com/dotnet/roslyn/issues/15119).
             }
 
-            EnableResolution(request.Process, request);
+            EnableResolution(request.Process, request, OnFunctionResolved(workList));
         }
 
         void IDkmModuleInstanceLoadNotification.OnModuleInstanceLoad(DkmModuleInstance moduleInstance, DkmWorkList workList, DkmEventDescriptorS eventDescriptor)
         {
-            OnModuleLoad(moduleInstance);
+            OnModuleLoad(moduleInstance, workList);
         }
 
         void IDkmModuleInstanceUnloadNotification.OnModuleInstanceUnload(DkmModuleInstance moduleInstance, DkmWorkList workList, DkmEventDescriptor eventDescriptor)
@@ -63,10 +63,10 @@ void IDkmModuleModifiedNotification.OnModuleModified(DkmModuleInstance moduleIns
 
         void IDkmModuleSymbolsLoadedNotification.OnModuleSymbolsLoaded(DkmModuleInstance moduleInstance, DkmModule module, bool isReload, DkmWorkList workList, DkmEventDescriptor eventDescriptor)
         {
-            OnModuleLoad(moduleInstance);
+            OnModuleLoad(moduleInstance, workList);
         }
 
-        private void OnModuleLoad(DkmModuleInstance moduleInstance)
+        private void OnModuleLoad(DkmModuleInstance moduleInstance, DkmWorkList workList)
         {
             var module = moduleInstance as DkmClrModuleInstance;
             Debug.Assert(module != null); // <Filter><RuntimeId RequiredValue="DkmRuntimeId.Clr"/></Filter> should ensure this.
@@ -82,7 +82,7 @@ private void OnModuleLoad(DkmModuleInstance moduleInstance)
                 return;
             }
 
-            OnModuleLoad(module.Process, module);
+            OnModuleLoad(module.Process, module, OnFunctionResolved(workList));
         }
 
         internal override bool ShouldEnableFunctionResolver(DkmProcess process)
@@ -152,21 +152,24 @@ internal override string GetRequestModuleName(DkmRuntimeFunctionResolutionReques
             return request.ModuleName;
         }
 
-        internal override void OnFunctionResolved(
-            DkmClrModuleInstance module,
+        private static OnFunctionResolvedDelegate<DkmClrModuleInstance, DkmRuntimeFunctionResolutionRequest> OnFunctionResolved(DkmWorkList workList)
+        {
+            return (DkmClrModuleInstance module,
                         DkmRuntimeFunctionResolutionRequest request,
                         int token,
                         int version,
-            int ilOffset)
+                        int ilOffset) =>
             {
                 var address = DkmClrInstructionAddress.Create(
                     module.RuntimeInstance,
                     module,
                     new DkmClrMethodId(Token: token, Version: (uint)version),
-                NativeOffset: uint.MaxValue,
+                    NativeOffset: 0,
                     ILOffset: (uint)ilOffset,
                     CPUInstruction: null);
-            request.OnFunctionResolved(address);
+                // Use async overload of OnFunctionResolved to avoid deadlock.
+                request.OnFunctionResolved(workList, address, result => { });
+            };
         }
 
         private static readonly Guid s_messageSourceId = new Guid("ac353c9b-c599-427b-9424-cbe1ad19f81e");

src/ExpressionEvaluator/Core/Source/FunctionResolver/FunctionResolverBase.cs

@@ -11,17 +11,6 @@ internal abstract class FunctionResolverBase<TProcess, TModule, TRequest>
         where TModule : class
         where TRequest : class
     {
-        internal void EnableResolution(TProcess process, TRequest request)
-        {
-            ResolveRequest(process, request);
-        }
-
-        internal void OnModuleLoad(TProcess process, TModule module)
-        {
-            var requests = GetRequests(process);
-            ResolveRequests(process, module, requests);
-        }
-
         internal abstract bool ShouldEnableFunctionResolver(TProcess process);
         internal abstract IEnumerable<TModule> GetAllModules(TProcess process);
         internal abstract string GetModuleName(TModule module);
@@ -29,9 +18,8 @@ internal void OnModuleLoad(TProcess process, TModule module)
         internal abstract TRequest[] GetRequests(TProcess process);
         internal abstract string GetRequestModuleName(TRequest request);
         internal abstract RequestSignature GetParsedSignature(TRequest request);
-        internal abstract void OnFunctionResolved(TModule module, TRequest request, int token, int version, int ilOffset);
 
-        private void ResolveRequest(TProcess process, TRequest request)
+        internal void EnableResolution(TProcess process, TRequest request, OnFunctionResolvedDelegate<TModule, TRequest> onFunctionResolved)
         {
             var moduleName = GetRequestModuleName(request);
             var signature = GetParsedSignature(request);
@@ -51,6 +39,7 @@ private void ResolveRequest(TProcess process, TRequest request)
                     }
                     checkEnabled = false;
                 }
+
                 if (!ShouldModuleHandleRequest(module, moduleName))
                 {
                     continue;
@@ -60,12 +49,12 @@ private void ResolveRequest(TProcess process, TRequest request)
                 {
                     continue;
                 }
-                var resolver = new MetadataResolver<TProcess, TModule, TRequest>(this, process, module, reader);
+                var resolver = new MetadataResolver<TProcess, TModule, TRequest>(process, module, reader, onFunctionResolved);
                 resolver.Resolve(request, signature);
             }
         }
 
-        private void ResolveRequests(TProcess process, TModule module, TRequest[] requests)
+        internal void OnModuleLoad(TProcess process, TModule module, OnFunctionResolvedDelegate<TModule, TRequest> onFunctionResolved)
         {
             if (!ShouldEnableFunctionResolver(process))
             {
@@ -73,6 +62,7 @@ private void ResolveRequests(TProcess process, TModule module, TRequest[] reques
             }
 
             MetadataResolver<TProcess, TModule, TRequest> resolver = null;
+            var requests = GetRequests(process);
 
             foreach (var request in requests)
             {
@@ -95,7 +85,7 @@ private void ResolveRequests(TProcess process, TModule module, TRequest[] reques
                     {
                         return;
                     }
-                    resolver = new MetadataResolver<TProcess, TModule, TRequest>(this, process, module, reader);
+                    resolver = new MetadataResolver<TProcess, TModule, TRequest>(process, module, reader, onFunctionResolved);
                 }
 
                 resolver.Resolve(request, signature);

src/ExpressionEvaluator/Core/Source/FunctionResolver/MetadataResolver.cs

@@ -11,6 +11,8 @@
 
 namespace Microsoft.CodeAnalysis.ExpressionEvaluator
 {
+    internal delegate void OnFunctionResolvedDelegate<TModule, TRequest>(TModule module, TRequest request, int token, int version, int ilOffset);
+
     internal sealed class MetadataResolver<TProcess, TModule, TRequest>
         where TProcess : class
         where TModule : class
@@ -18,21 +20,21 @@ internal sealed class MetadataResolver<TProcess, TModule, TRequest>
     {
         private static readonly StringComparer s_stringComparer = StringComparer.Ordinal;
 
-        private readonly FunctionResolverBase<TProcess, TModule, TRequest> _resolver;
         private readonly TProcess _process;
         private readonly TModule _module;
         private readonly MetadataReader _reader;
+        private readonly OnFunctionResolvedDelegate<TModule, TRequest> _onFunctionResolved;
 
         internal MetadataResolver(
-            FunctionResolverBase<TProcess, TModule, TRequest> resolver,
             TProcess process,
             TModule module,
-            MetadataReader reader)
+            MetadataReader reader,
+            OnFunctionResolvedDelegate<TModule, TRequest> onFunctionResolved)
         {
-            _resolver = resolver;
             _process = process;
             _module = module;
             _reader = reader;
+            _onFunctionResolved = onFunctionResolved;
         }
 
         internal void Resolve(TRequest request, RequestSignature signature)
@@ -293,7 +295,7 @@ private void GetAllGenericTypeParameters(Name typeName, ImmutableArray<string>.B
             MethodDefinitionHandle handle)
         {
             Debug.Assert(!handle.IsNil);
-            _resolver.OnFunctionResolved(_module, request, token: MetadataTokens.GetToken(handle), version: 1, ilOffset: 0);
+            _onFunctionResolved(_module, request, token: MetadataTokens.GetToken(handle), version: 1, ilOffset: 0);
         }
 
         private void OnAccessorResolved(

src/ExpressionEvaluator/Core/Test/FunctionResolver/CSharpFunctionResolverTests.cs

@@ -174,7 +174,7 @@ public void ShouldEnableFunctionResolver()
                 VerifySignatures(requestG);
             }
 
-            // Two modules after after two requests for same module,
+            // Two modules after two requests for same module,
             // ... resolver enabled.
             moduleA = new Module(bytesA, name: "A.dll");
             moduleB = new Module(bytesB, name: "B.dll");

src/ExpressionEvaluator/Core/Test/FunctionResolver/Request.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
@@ -23,7 +24,7 @@ internal Address(Module module, int token, int version, int ilOffset)
 
     internal sealed class Request
     {
-        internal readonly List<Address> _resolvedAddresses;
+        private readonly List<Address> _resolvedAddresses;
 
         internal Request(string moduleName, RequestSignature signature)
         {

src/ExpressionEvaluator/Core/Test/FunctionResolver/Resolver.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Reflection.Metadata;
 
@@ -14,7 +15,7 @@ internal Resolver()
             _requests = new Dictionary<Process, List<Request>>();
         }
 
-        internal new void EnableResolution(Process process, Request request)
+        internal void EnableResolution(Process process, Request request)
         {
             List<Request> requests;
             if (!_requests.TryGetValue(process, out requests))
@@ -23,7 +24,12 @@ internal new void EnableResolution(Process process, Request request)
                 _requests.Add(process, requests);
             }
             requests.Add(request);
-            base.EnableResolution(process, request);
+            base.EnableResolution(process, request, OnFunctionResolved);
+        }
+
+        internal void OnModuleLoad(Process process, Module module)
+        {
+            base.OnModuleLoad(process, module, OnFunctionResolved);
         }
 
         internal override bool ShouldEnableFunctionResolver(Process process)
@@ -66,14 +72,9 @@ internal override RequestSignature GetParsedSignature(Request request)
             return request.Signature;
         }
 
-        internal override void OnFunctionResolved(Module module, Request request, int token, int version, int ilOffset)
+        private static void OnFunctionResolved(Module module, Request request, int token, int version, int ilOffset)
         {
             request.OnFunctionResolved(module, token, version, ilOffset);
         }
-
-        private void OnModuleLoaded(object sender, Module e)
-        {
-            OnModuleLoad((Process)sender, e);
-        }
     }
 }