Merge pull request #3919 from VSadov/fix3906

Lambda rewriter should rewrite method/property symbols when rewriting…

src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs

@@ -558,6 +558,33 @@ private PropertySymbol VisitPropertySymbol(PropertySymbol property)
             throw ExceptionUtilities.Unreachable;
         }
 
+        private FieldSymbol VisitFieldSymbol(FieldSymbol field)
+        {
+            //  Property of a regular type
+            return ((FieldSymbol)field.OriginalDefinition)
+                .AsMember((NamedTypeSymbol)TypeMap.SubstituteType(field.ContainingType));
+        }
+
+        public override BoundNode VisitObjectInitializerMember(BoundObjectInitializerMember node)
+        {
+            ImmutableArray<BoundExpression> arguments = (ImmutableArray<BoundExpression>)this.VisitList(node.Arguments);
+            TypeSymbol type = this.VisitType(node.Type);
+
+            var member = node.MemberSymbol;
+
+            switch (member.Kind)
+            {
+                case SymbolKind.Field:
+                    member = VisitFieldSymbol((FieldSymbol)member);
+                    break;
+                case SymbolKind.Property:
+                    member = VisitPropertySymbol((PropertySymbol)member);
+                    break;
+            }
+
+            return node.Update(member, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.ResultKind, type);
+        }
+
         private static bool BaseReferenceInReceiverWasRewritten(BoundExpression originalReceiver, BoundExpression rewrittenReceiver)
         {
             return originalReceiver != null && originalReceiver.Kind == BoundKind.BaseReference &&

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenExprLambdaTests.cs

@@ -2586,6 +2586,84 @@ public static void Main()
                 new[] { ExpressionAssemblyRef }, expectedOutput: TrimExpectedOutput(expectedOutput));
         }
 
+        [WorkItem(3906, "https://github.com/dotnet/roslyn/issues/3906")]
+        [Fact]
+        public void GenericField01()
+        {
+            var text =
+@"
+using System;
+
+public class M
+{
+
+    public class S<T>
+    {
+        public T x;
+    }
+
+    public static object SomeFunc<A>(System.Linq.Expressions.Expression<Func<object, A>> selector)
+    { return null; }
+
+    public static void CallIt<T>(T t)
+    {
+        Func<object, object> goodF = xs => SomeFunc<S<T>>(e => new S<T>());
+        var z1 = goodF(3);
+
+        Func<object, object> badF = xs => SomeFunc<S<T>>(e => new S<T> { x = t });
+        var z2 = badF(3);
+    }
+
+    public static void Main()
+    {
+        CallIt<int>(3);
+    }
+}
+";
+            CompileAndVerify(
+                new[] { text, ExpressionTestLibrary },
+                new[] { ExpressionAssemblyRef }, expectedOutput: "");
+        }
+
+        [WorkItem(3906, "https://github.com/dotnet/roslyn/issues/3906")]
+        [Fact]
+        public void GenericProperty01()
+        {
+            var text =
+@"
+using System;
+
+public class M
+{
+
+    public class S<T>
+    {
+        public T x{get; set;}
+    }
+
+    public static object SomeFunc<A>(System.Linq.Expressions.Expression<Func<object, A>> selector)
+    { return null; }
+
+    public static void CallIt<T>(T t)
+    {
+        Func<object, object> goodF = xs => SomeFunc<S<T>>(e => new S<T>());
+        var z1 = goodF(3);
+
+        Func<object, object> badF = xs => SomeFunc<S<T>>(e => new S<T> { x = t });
+        var z2 = badF(3);
+    }
+
+    public static void Main()
+    {
+        CallIt<int>(3);
+    }
+}
+";
+            CompileAndVerify(
+                new[] { text, ExpressionTestLibrary },
+                new[] { ExpressionAssemblyRef }, expectedOutput: "");
+        }
+
         [WorkItem(544304, "DevDiv")]
         [Fact]
         public void CheckedEnumAddition()

src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb

@@ -6805,6 +6805,46 @@ end class
                  expectedOutput:="m => m").VerifyDiagnostics()
         End Sub
 
+
+        <WorkItem(3906, "https://github.com/dotnet/roslyn/issues/3906")>
+        <Fact()>
+        Public Sub GenericField01()
+            Dim source = <compilation>
+                             <file name="a.vb"><![CDATA[
+Imports System
+
+Public Class Module1
+    Public Class S(Of T)
+        Public x As T
+    End Class
+
+    Public Shared Function SomeFunc(Of A)(selector As System.Linq.Expressions.Expression(Of Func(Of Object, A))) As Object
+        Return Nothing
+    End Function
+
+    Public Shared Sub CallIt(Of T)(p As T)
+        Dim goodF As Func(Of Object, Object) = Function(xs) SomeFunc(Of S(Of T))(Function(e) New S(Of T)())
+        Dim z1 = goodF(3)
+
+        Dim badF As Func(Of Object, Object) = Function(xs)
+                                                  Return SomeFunc(Of S(Of T))(Function(e) New S(Of T) With {.x = p})
+                                              End Function
+        Dim z2 = badF(3)
+    End Sub
+
+    Public Shared Sub Main()
+        CallIt(Of Integer)(3)
+    End Sub
+End Class
+
+                            ]]></file>
+                         </compilation>
+
+            CompileAndVerify(source,
+                 additionalRefs:={SystemCoreRef},
+                 expectedOutput:="").VerifyDiagnostics()
+        End Sub
+
         <Fact()>
         Public Sub ExpressionTrees_MyBaseMyClass()
             Dim file = <file name="expr.vb"><![CDATA[