Squashed 'dotnet-symbol-service/' changes from bffd9aa..3db2eb5

3db2eb5 Merges dev/initial-effort into master
4ed597d Supports C# async and yield keywords
292a5a8 Return symbol data for nested types

git-subtree-dir: dotnet-symbol-service
git-subtree-split: 3db2eb5bb295350f95604adc85076757137a9502

Author: Steve Salas

SymbolService/Controllers/MethodsController.cs

@@ -20,6 +20,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using System.IO;
+using System.Runtime.CompilerServices;
 using Mono.Cecil;
 using Mono.Cecil.Pdb;
 using SymbolService.Model;
@@ -49,8 +50,38 @@ public IActionResult Methods(IFormFile assemblyFile, IFormFile symbolsFile)
 
                 using (var module = LoadModule(assemblyPath, symbolsPath))
                 {
-                    var methodInfos = module.Types.SelectMany(type => type.Methods).Select(GetMethodInfo);
-                    return new JsonResult(methodInfos.ToArray()); // materialize collection prior to module disposal
+                    var methodDefinitions = GetMethodDefinitions(module, out var methodInfoMap);
+
+                    var stateMachineAttributeTypes = new List<string>(new []
+                    {
+                        typeof(AsyncStateMachineAttribute).FullName,
+                        typeof(IteratorStateMachineAttribute).FullName
+                    });
+
+                    var stateMachineSupportedMethods =
+                        methodDefinitions.Where(x => !x.DebugInformation.HasSequencePoints &&
+                                                      x.HasCustomAttributes && x.CustomAttributes.Any(y =>
+                                                      stateMachineAttributeTypes.Contains(y.AttributeType.FullName))).ToArray();
+
+                    foreach (var stateMachineSupportedMethod in stateMachineSupportedMethods)
+                    {
+                        var stateMachineTypeDefinition = (TypeDefinition) stateMachineSupportedMethod.CustomAttributes
+                            .Single(x => stateMachineAttributeTypes.Contains(x.AttributeType.FullName))
+                            .ConstructorArguments.Single().Value;
+
+                        foreach (var stateMachineMethod in stateMachineTypeDefinition.Methods.Where(x => x.DebugInformation.HasSequencePoints))
+                        {
+                            if (!methodInfoMap.TryGetValue(stateMachineSupportedMethod.FullName, out var stateMachineSupportedMethodInfo))
+                            {
+                                stateMachineSupportedMethodInfo = GetMethodInfo(stateMachineSupportedMethod);
+                                methodInfoMap[stateMachineSupportedMethod.FullName] = stateMachineSupportedMethodInfo;
+                            }
+
+                            methodInfoMap[stateMachineMethod.FullName].SurrogateFor = methodInfoMap[stateMachineSupportedMethod.FullName].Id;
+                        }
+                    }
+
+                    return new JsonResult(methodInfoMap.Values);
                 }
             }
             catch
@@ -92,6 +123,38 @@ private ModuleDefinition LoadModule(string assemblyPath, string symbolsPath)
             }
         }
 
+        private List<MethodDefinition> GetMethodDefinitions(ModuleDefinition module, out Dictionary<string, MethodInfo> methodInfoMap)
+        {
+            var allMethodDefinitions = new List<MethodDefinition>();
+            methodInfoMap = new Dictionary<string, MethodInfo>();
+            foreach (var type in module.Types)
+            {
+                allMethodDefinitions.AddRange(GetMethodDefinitions(type, ref methodInfoMap));
+            }
+            return allMethodDefinitions;
+        }
+
+        private IEnumerable<MethodDefinition> GetMethodDefinitions(TypeDefinition typeDefinition, ref Dictionary<string, MethodInfo> methodInfoMap)
+        {
+            var definitions = new List<MethodDefinition>();
+            foreach (var type in typeDefinition.NestedTypes)
+            {
+                definitions.AddRange(GetMethodDefinitions(type, ref methodInfoMap));
+            }
+
+            foreach (var method in typeDefinition.Methods)
+            {
+                definitions.Add(method);
+
+                if (method.DebugInformation.HasSequencePoints)
+                {
+                    methodInfoMap[method.FullName] = GetMethodInfo(method);
+                }
+            }
+
+            return definitions;
+        }
+
         private MethodInfo GetMethodInfo(MethodDefinition method)
         {
             return new MethodInfo

SymbolService/Model/MethodInfo.cs

@@ -21,6 +21,8 @@ namespace SymbolService.Model
 {
 	public class MethodInfo
 	{
+        public Guid Id { get; }
+
 		public String FullyQualifiedName { get; set; }
 
 		public String ContainingClass { get; set; }
@@ -32,5 +34,12 @@ public class MethodInfo
 		public String ReturnType { get; set; }
 
 		public int Instructions { get; set; }
+
+        public Guid SurrogateFor { get; set; }
+
+	    public MethodInfo()
+	    {
+	        Id = Guid.NewGuid();
+	    }
     }
 }