Merge pull request #2315 from KevinH-MS/LocalsInAsyncLambdas

Fix Locals in async lambdas...

src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs

@@ -619,7 +619,7 @@ private static BoundStatement BindAssignment(Binder binder, ExpressionSyntax syn
                 BinderFlags.UncheckedRegion |
                 BinderFlags.AllowManagedAddressOf |
                 BinderFlags.AllowAwaitInUnsafeContext);
-            var hasImports = !importRecordGroups.IsDefault;
+            var hasImports = !importRecordGroups.IsDefaultOrEmpty;
             var numImportStringGroups = hasImports ? importRecordGroups.Length : 0;
             var currentStringGroup = numImportStringGroups - 1;
 

src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/SymUnmanagedReaderExtensions.cs

@@ -21,12 +21,11 @@ internal static class SymUnmanagedReaderExtensions
             var importStringGroups = reader.GetCSharpGroupedImportStrings(methodToken, methodVersion, out externAliasStrings);
             Debug.Assert(importStringGroups.IsDefault == externAliasStrings.IsDefault);
 
-            if (importStringGroups.IsDefault)
+            ArrayBuilder<ImmutableArray<ImportRecord>> importRecordGroupBuilder = null;
+            ArrayBuilder<ExternAliasRecord> externAliasRecordBuilder = null;
+            if (!importStringGroups.IsDefault)
             {
-                return default(MethodDebugInfo);
-            }
-
-            var importRecordGroupBuilder = ArrayBuilder<ImmutableArray<ImportRecord>>.GetInstance(importStringGroups.Length);
+                importRecordGroupBuilder = ArrayBuilder<ImmutableArray<ImportRecord>>.GetInstance(importStringGroups.Length);
                 foreach (var importStringGroup in importStringGroups)
                 {
                     var groupBuilder = ArrayBuilder<ImportRecord>.GetInstance(importStringGroup.Length);
@@ -45,7 +44,9 @@ internal static class SymUnmanagedReaderExtensions
                     importRecordGroupBuilder.Add(groupBuilder.ToImmutableAndFree());
                 }
 
-            var externAliasRecordBuilder = ArrayBuilder<ExternAliasRecord>.GetInstance(externAliasStrings.Length);
+                if (!externAliasStrings.IsDefault)
+                {
+                    externAliasRecordBuilder = ArrayBuilder<ExternAliasRecord>.GetInstance(externAliasStrings.Length);
                     foreach (string externAliasString in externAliasStrings)
                     {
                         string alias;
@@ -72,6 +73,8 @@ internal static class SymUnmanagedReaderExtensions
 
                         externAliasRecordBuilder.Add(new NativeExternAliasRecord<AssemblySymbol>(alias, targetIdentity));
                     }
+                }
+            }
 
             var hoistedLocalScopeRecords = ImmutableArray<HoistedLocalScopeRecord>.Empty;
             var dynamicLocalMap = ImmutableDictionary<int, ImmutableArray<bool>>.Empty;
@@ -97,11 +100,10 @@ internal static class SymUnmanagedReaderExtensions
                     out dynamicLocalConstantMap);
             }
 
-
             return new MethodDebugInfo(
                 hoistedLocalScopeRecords,
-                importRecordGroupBuilder.ToImmutableAndFree(),
-                externAliasRecordBuilder.ToImmutableAndFree(),
+                importRecordGroupBuilder?.ToImmutableAndFree() ?? ImmutableArray<ImmutableArray<ImportRecord>>.Empty,
+                externAliasRecordBuilder?.ToImmutableAndFree() ?? ImmutableArray<ExternAliasRecord>.Empty,
                 dynamicLocalMap,
                 dynamicLocalConstantMap,
                 defaultNamespaceName: ""); // Unused in C#.

src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs

@@ -1588,6 +1588,54 @@ .maxstack  1
             locals.Free();
         }
 
+        [WorkItem(2240)]
+        [Fact]
+        public void AsyncLambda()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+class C
+{
+    static void M()
+    {
+        Func<int, Task> f = async (x) =>
+        {
+            var y = 42;
+        };
+    }
+}";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugDll);
+            var runtime = CreateRuntimeInstance(compilation);
+            var context = CreateMethodContext(runtime, methodName: "C.<>c.<<M>b__0_0>d.MoveNext");
+            var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+            string typeName;
+            var testData = new CompilationTestData();
+            context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+            Assert.Equal(locals.Count, 2);
+            VerifyLocal(testData, "<>x", locals[0], "<>m0", "x", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Exception V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C.<>c.<<M>b__0_0>d.x""
+  IL_0006:  ret
+}");
+            VerifyLocal(testData, "<>x", locals[1], "<>m1", "y", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Exception V_1)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C.<>c.<<M>b__0_0>d.<y>5__1""
+  IL_0006:  ret
+}");
+            locals.Free();
+        }        
+
         [WorkItem(996571)]
         [Fact]
         public void MissingReference()

src/ExpressionEvaluator/VisualBasic/Test/ExpressionCompiler/LocalsTests.vb

@@ -1647,6 +1647,58 @@ End Class"
             locals.Free()
         End Sub
 
+        <WorkItem(2240)>
+        <Fact>
+        Public Sub AsyncLambda()
+            Const source =
+"Imports System
+Imports System.Threading.Tasks
+Class C
+    Shared Sub M()
+        Dim f As Func(Of Integer, Task) = Async Function (x)
+            Dim y = 42
+        End Function
+    End Sub
+End Class"
+            Dim comp = CreateCompilationWithReferences(
+                MakeSources(source),
+                {MscorlibRef_v4_0_30316_17626, MsvbRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929},
+                TestOptions.DebugDll)
+
+            Dim runtime = CreateRuntimeInstance(comp)
+            Dim context = CreateMethodContext(
+                runtime,
+                methodName:="C._Closure$__.VB$StateMachine___Lambda$__1-0.MoveNext")
+            Dim testData As New CompilationTestData()
+            Dim locals = ArrayBuilder(Of LocalAndMethod).GetInstance()
+            Dim typeName As String = Nothing
+            context.CompileGetLocals(locals, argumentsOnly:=False, typeName:=typeName, testData:=testData)
+            Assert.Equal(2, locals.Count)
+            VerifyLocal(testData, typeName, locals(0), "<>m0", "x", expectedILOpt:=
+"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (Integer V_0,
+                System.Threading.Tasks.Task V_1,
+                System.Exception V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C._Closure$__.VB$StateMachine___Lambda$__1-0.$VB$Local_x As Integer""
+  IL_0006:  ret
+}")
+            VerifyLocal(testData, typeName, locals(1), "<>m1", "y", expectedILOpt:=
+"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (Integer V_0,
+                System.Threading.Tasks.Task V_1,
+                System.Exception V_2)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C._Closure$__.VB$StateMachine___Lambda$__1-0.$VB$ResumableLocal_y$0 As Integer""
+  IL_0006:  ret
+}")
+            locals.Free()
+        End Sub
+
         <WorkItem(996571)>
         <Fact>
         Public Sub MissingReference()