Merge pull request #13079 from AlekseyTs/Restore

Follow-up on some recent changes in C# compiler.

src/Compilers/CSharp/Portable/Binder/Binder_Query.cs

@@ -648,7 +648,7 @@ private UnboundLambda MakeQueryUnboundLambda(RangeVariableMap qvm, ImmutableArra
         {
             return MakeQueryUnboundLambda(expression, new QueryUnboundLambdaState(this, qvm, parameters, (LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, DiagnosticBag diagnostics) =>
             {
-                return lambdaBodyBinder.BindLambdaExpressionAsBlock(RefKind.None, expression, diagnostics);
+                return lambdaBodyBinder.BindLambdaExpressionAsBlock(expression, diagnostics);
             }));
         }
 

src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs

@@ -3661,13 +3661,15 @@ internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableAr
         /// <summary>
         /// Binds a lambda with expression e as either { return e;} or { e; }.
         /// </summary>
-        public BoundBlock BindLambdaExpressionAsBlock(RefKind refKind, ExpressionSyntax body, DiagnosticBag diagnostics)
+        public BoundBlock BindLambdaExpressionAsBlock(ExpressionSyntax body, DiagnosticBag diagnostics)
         {
-            Binder bodyBinder = this.GetBinder(refKind != RefKind.None ? body.Parent : body);
+            Binder bodyBinder = this.GetBinder(body);
             Debug.Assert(bodyBinder != null);
 
-            BoundExpression expression = bodyBinder.BindValue(body, diagnostics, refKind != RefKind.None ? BindValueKind.RefReturn : BindValueKind.RValue);
-            return bodyBinder.CreateBlockFromExpression(body, bodyBinder.GetDeclaredLocalsForScope(body), refKind, expression, body, diagnostics);
+            RefKind refKind;
+            var expressionSyntax = ((ExpressionSyntax)body).SkipRef(out refKind);
+            BoundExpression expression = bodyBinder.BindValue(expressionSyntax, diagnostics, refKind != RefKind.None ? BindValueKind.RefReturn : BindValueKind.RValue);
+            return bodyBinder.CreateBlockFromExpression(body, bodyBinder.GetDeclaredLocalsForScope(body), refKind, expression, expressionSyntax, diagnostics);
         }
 
         internal virtual ImmutableArray<LocalSymbol> Locals

src/Compilers/CSharp/Portable/Binder/ExpressionVariableBinder.cs

@@ -27,8 +27,7 @@ protected override ImmutableArray<LocalSymbol> BuildLocals()
 
         internal override ImmutableArray<LocalSymbol> GetDeclaredLocalsForScope(CSharpSyntaxNode scopeDesignator)
         {
-            if (ScopeDesignator == scopeDesignator ||
-                ScopeDesignator.Kind() == SyntaxKind.RefExpression && ScopeDesignator == scopeDesignator.Parent)
+            if (ScopeDesignator == scopeDesignator)
             {
                 return this.Locals;
             }

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -890,9 +890,7 @@ protected override BoundBlock BindLambdaBody(LambdaSymbol lambdaSymbol, Binder l
         {
             if (this.IsExpressionLambda)
             {
-                var refKind = CodeAnalysis.RefKind.None;
-                var body = ((ExpressionSyntax)this.Body).SkipRef(out refKind);
-                return lambdaBodyBinder.BindLambdaExpressionAsBlock(refKind, body, diagnostics);
+                return lambdaBodyBinder.BindLambdaExpressionAsBlock((ExpressionSyntax)this.Body, diagnostics);
             }
             else
             {

src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs

@@ -121,6 +121,17 @@ internal Binder Binder
             return new LocalWithInitializer(containingSymbol, binder, typeSyntax, identifierToken, initializer, declarationKind);
         }
 
+        /// <param name="containingSymbol"></param>
+        /// <param name="scopeBinder">
+        /// Binder that owns the scope for the local, the one that returns it in its <see cref="Binder.Locals"/> array.
+        /// </param>
+        /// <param name="enclosingBinderOpt">
+        /// Enclosing binder for the location where the local is declared, if different from the <paramref name="scopeBinder"/>.
+        /// It should be used to bind something at that location.
+        /// </param>
+        /// <param name="typeSyntax"></param>
+        /// <param name="identifierToken"></param>
+        /// <param name="context"></param>
         public static SourceLocalSymbol MakeOutVariable(
             Symbol containingSymbol,
             Binder scopeBinder,
@@ -129,7 +140,12 @@ internal Binder Binder
             SyntaxToken identifierToken,
             CSharpSyntaxNode context)
         {
-            return new OutLocalSymbol(containingSymbol, scopeBinder, enclosingBinderOpt, typeSyntax, identifierToken, context);
+            if (typeSyntax.IsVar)
+            {
+                return new PossiblyImplicitlyTypedOutVarLocalSymbol(containingSymbol, scopeBinder, enclosingBinderOpt, typeSyntax, identifierToken, context);
+            }
+
+            return new SourceLocalSymbol(containingSymbol, scopeBinder, false, typeSyntax, identifierToken, LocalDeclarationKind.RegularVariable);
         }
 
         internal override bool IsImportedFromMetadata
@@ -581,14 +597,15 @@ protected override TypeSymbol InferTypeOfVarVariable(DiagnosticBag diagnostics)
         }
 
         /// <summary>
-        /// Symbol for an out variable local.
+        /// Symbol for an out variable local that might require type inference during overload resolution, i.e.
+        /// its type is syntactically 'var'.
         /// </summary>
-        private class OutLocalSymbol : SourceLocalSymbol
+        private class PossiblyImplicitlyTypedOutVarLocalSymbol : SourceLocalSymbol
         {
             private readonly CSharpSyntaxNode _containingInvocation;
             private readonly Binder _enclosingBinderOpt;
 
-            public OutLocalSymbol(
+            public PossiblyImplicitlyTypedOutVarLocalSymbol(
                 Symbol containingSymbol,
                 Binder scopeBinder,
                 Binder enclosingBinderOpt,