Lookup for Deconstruct method

docs/features/deconstruction.md

@@ -41,6 +41,8 @@ It will be updated to support deconstruction-assignment, ie. when the left-hand-
 - Each item on the left needs to be assignable and needs to be compatible with corresponding position on the right (resulting from previous step).
 - Needs to handle nesting case such as `(x, (y, z)) = M();`, but note that the second item in the top-level group has no discernable type.
 
+#### Evaluation order
+
 The evaluation order can be summarized as: (1) all the side-effects on the left-hand-side, (2) all the Deconstruct invocations (if not tuple), (3) conversions (if needed), and (4) assignments.
 
 In the general case, the lowering for deconstruction-assignment would translate: `(expressionX, expressionY, expressionZ) = expressionRight` into:
@@ -100,7 +102,17 @@ evaluate the right-hand-side and do a tuple conversion (using a fake tuple repre
 assign element-wise from the right to the left
 ```
 
-Note that tuples (`System.ValueTuple` and `System.Tuple`) don't need to invoke Deconstruct.
+#### Resolution of the Deconstruct method
+
+The resolution is equivalent to typing `rhs.Deconstruct(out var x1, out var x2, ...);` with the appropriate number of parameters to deconstruct into.
+It is based on normal overload resolution.
+This implies that `rhs` cannot be dynamic.
+Also, the `Deconstruct` method must be an instance method or an extension (but not a static method).
+
+#### Tuple Deconstruction
+
+Note that tuples (`System.ValueTuple`) don't need to invoke Deconstruct.
+`System.Tuple` are not recognized as tuples, and so will rely on Deconstruct (which will be provided for up to 3 nestings deep, that is 21 elements)
 
 
 ###Deconstruction-declaration (deconstruction into new variables):

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

@@ -345,7 +345,7 @@ internal BoundExpression BindValueAllowArgList(ExpressionSyntax node, Diagnostic
             if (isMemberInitializer)
             {
                 initializer = initializerBinder.WrapWithVariablesIfAny(initializerOpt, initializer);
-        }
+            }
 
             return initializer;
         }
@@ -1389,8 +1389,8 @@ private BoundExpression BindNonMethod(SimpleNameSyntax node, Symbol symbol, Diag
                         var parameter = (ParameterSymbol)symbol;
                         if (IsBadLocalOrParameterCapture(parameter, parameter.RefKind))
                         {
-                                    Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name);
-                                }
+                            Error(diagnostics, ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name);
+                        }
                         return new BoundParameter(node, parameter, hasErrors: isError);
                     }
 
@@ -1829,7 +1829,7 @@ private BoundExpression BindOriginal(OriginalExpressionSyntax syntax, Diagnostic
                     {
                         var replacedProperty = (PropertySymbol)replaced;
                         Debug.Assert((object)replacedProperty != null);
-                        if (replacedProperty.IsIndexer || replacedProperty.IsIndexedProperty) 
+                        if (replacedProperty.IsIndexer || replacedProperty.IsIndexedProperty)
                         {
                             return new BoundPropertyGroup(
                                 syntax,
@@ -2230,6 +2230,11 @@ private bool RefMustBeObeyed(bool isDelegateCreation, ArgumentSyntax argumentSyn
 
                     arguments[arg] = CreateConversion(argument.Syntax, argument, kind, false, type, diagnostics);
                 }
+                else if (argument.Kind == BoundKind.OutDeconstructVarPendingInference)
+                {
+                    TypeSymbol parameterType = GetCorrespondingParameterType(ref result, parameters, arg);
+                    arguments[arg] = ((OutDeconstructVarPendingInference)argument).SetInferredType(parameterType, success: true);
+                }
             }
         }
 

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

@@ -114,6 +114,7 @@ private static ImmutableArray<MethodSymbol> GetOriginalMethods(OverloadResolutio
 
             var analyzedArguments = AnalyzedArguments.GetInstance();
             analyzedArguments.Arguments.AddRange(args);
+            Debug.Assert(!args.Any(e => e.Kind == BoundKind.OutDeconstructVarPendingInference));
             BoundExpression result = BindInvocationExpression(
                 node, node, methodName, boundExpression, analyzedArguments, diagnostics, queryClause,
                 allowUnexpandedForm: allowUnexpandedForm);
@@ -1100,7 +1101,8 @@ private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedA
             {
                 BoundKind argumentKind = oldArguments[i].Kind;
 
-                if (argumentKind == BoundKind.UnboundLambda && i < parameterCount)
+                if (argumentKind == BoundKind.OutDeconstructVarPendingInference ||
+                    (argumentKind == BoundKind.UnboundLambda && i < parameterCount))
                 {
                     ArrayBuilder<BoundExpression> newArguments = ArrayBuilder<BoundExpression>.GetInstance(argumentCount);
                     newArguments.AddRange(oldArguments);
@@ -1120,8 +1122,15 @@ private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedA
                                         newArguments[i] = ((UnboundLambda)oldArgument).Bind(parameterType);
                                     }
                                     break;
+                                case BoundKind.OutDeconstructVarPendingInference:
+                                    newArguments[i] = ((OutDeconstructVarPendingInference)oldArgument).SetInferredType(parameters[i].Type, success: true);
+                                    break;
                             }
                         }
+                        else if (oldArgument.Kind == BoundKind.OutDeconstructVarPendingInference)
+                        {
+                            newArguments[i] = ((OutDeconstructVarPendingInference)oldArgument).FailInference(this);
+                        }
 
                         i++;
                     }

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

@@ -1,6 +1,5 @@
 // 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;
 using System.Diagnostics;
@@ -1831,7 +1830,7 @@ private BoundExpression BindDeconstructionAssignment(AssignmentExpressionSyntax
         /// This will generate and stack appropriate deconstruction and assignment steps for a non-tuple type.
         /// Returns null if there was an error (if a suitable Deconstruct method was not found).
         /// </summary>
-        static private BoundDeconstructionDeconstructStep MakeNonTupleDeconstructStep(
+        private BoundDeconstructionDeconstructStep MakeNonTupleDeconstructStep(
                                                             BoundDeconstructValuePlaceholder targetPlaceholder,
                                                             AssignmentExpressionSyntax syntax,
                                                             DiagnosticBag diagnostics,
@@ -1840,16 +1839,22 @@ private BoundExpression BindDeconstructionAssignment(AssignmentExpressionSyntax
                                                             ArrayBuilder<BoundDeconstructionAssignmentStep> assignmentSteps)
         {
             // symbol and parameters for Deconstruct
-            MethodSymbol deconstructMethod = FindDeconstruct(variables.Length, targetPlaceholder, syntax, diagnostics);
+            ImmutableArray<BoundDeconstructValuePlaceholder> outPlaceholders;
+            var deconstructInvocation = MakeDeconstructInvocationExpression(variables.Length, targetPlaceholder, syntax, diagnostics, out outPlaceholders);
 
-            if ((object)deconstructMethod == null)
+            if (deconstructInvocation.HasAnyErrors)
             {
                 return null;
             }
-
-            return new BoundDeconstructionDeconstructStep(syntax, deconstructMethod, targetPlaceholder, deconstructMethod.Parameters.SelectAsArray((p, s) => new BoundDeconstructValuePlaceholder(s, p.Type), syntax));
+            else
+            {
+                return new BoundDeconstructionDeconstructStep(syntax, deconstructInvocation, targetPlaceholder, outPlaceholders);
+            }
         }
 
+        /// <summary>
+        /// Holds the variables on the LHS of a deconstruction as a tree of bound expressions.
+        /// </summary>
         private class DeconstructionVariable
         {
             public readonly BoundExpression Single;
@@ -1898,7 +1903,7 @@ public DeconstructionVariable(ImmutableArray<DeconstructionVariable> variables)
                 }
                 else
                 {
-                    var assignment = MakeAssignmentInfo(variable.Single, valuePlaceholder.Type, valuePlaceholder, syntax, diagnostics);
+                    var assignment = MakeDeconstructionAssignmentStep(variable.Single, valuePlaceholder.Type, valuePlaceholder, syntax, diagnostics);
                     assignmentSteps.Add(assignment);
                 }
             }
@@ -1962,7 +1967,9 @@ private ImmutableArray<DeconstructionVariable> BindDeconstructionVariables(Separ
         /// <summary>
         /// Figures out how to assign from sourceType into receivingVariable and bundles the information (leaving holes for the actual source and receiver) into an AssignmentInfo.
         /// </summary>
-        private BoundDeconstructionAssignmentStep MakeAssignmentInfo(BoundExpression receivingVariable, TypeSymbol sourceType, BoundDeconstructValuePlaceholder inputPlaceholder, AssignmentExpressionSyntax node, DiagnosticBag diagnostics)
+        private BoundDeconstructionAssignmentStep MakeDeconstructionAssignmentStep(
+                                                    BoundExpression receivingVariable, TypeSymbol sourceType, BoundDeconstructValuePlaceholder inputPlaceholder, 
+                                                    AssignmentExpressionSyntax node, DiagnosticBag diagnostics)
         {
             var outputPlaceholder = new BoundDeconstructValuePlaceholder(receivingVariable.Syntax, receivingVariable.Type) { WasCompilerGenerated = true };
 
@@ -1996,55 +2003,69 @@ static private void FlattenDeconstructVariables(ImmutableArray<DeconstructionVar
         }
 
         /// <summary>
-        /// Find the Deconstruct method for the expression on the right, that will fit the assignable bound expressions on the left.
-        /// Returns true if the Deconstruct method is found.
-        ///     If so, it outputs the method.
+        /// Find the Deconstruct method for the expression on the right, that will fit the number of assignable variables on the left.
+        /// Returns an invocation expression if the Deconstruct method is found.
+        ///     If so, it outputs placeholders that were coerced to the output types of the resolved Deconstruct method.
+        /// The overload resolution is similar to writing `receiver.Deconstruct(out var x1, out var x2, ...)`.
         /// </summary>
-        private static MethodSymbol FindDeconstruct(int numCheckedVariables, BoundExpression boundRHS, SyntaxNode node, DiagnosticBag diagnostics)
+        private BoundExpression MakeDeconstructInvocationExpression(
+                                    int numCheckedVariables, BoundExpression receiver, AssignmentExpressionSyntax assignmentSyntax,
+                                    DiagnosticBag diagnostics, out ImmutableArray<BoundDeconstructValuePlaceholder> outPlaceholders)
         {
-            // find symbol for Deconstruct member
-            ImmutableArray<Symbol> candidates = boundRHS.Type.GetMembers("Deconstruct");
-            switch (candidates.Length)
+            var receiverSyntax = receiver.Syntax;
+
+            if (receiver.Type.IsDynamic())
             {
-                case 0:
-                    Error(diagnostics, ErrorCode.ERR_MissingDeconstruct, boundRHS.Syntax, boundRHS.Type);
-                    return null;
-                case 1:
-                    break;
-                default:
-                    Error(diagnostics, ErrorCode.ERR_AmbiguousDeconstruct, boundRHS.Syntax, boundRHS.Type);
-                    return null;
+                Error(diagnostics, ErrorCode.ERR_CannotDeconstructDynamic, receiverSyntax);
+                outPlaceholders = default(ImmutableArray<BoundDeconstructValuePlaceholder>);
+
+                return BadExpression(receiverSyntax, receiver);
             }
 
-            Symbol deconstructMember = candidates[0];
+            var analyzedArguments = AnalyzedArguments.GetInstance();
+            var outVars = ArrayBuilder<OutDeconstructVarPendingInference>.GetInstance(numCheckedVariables);
 
-            // check that the deconstruct fits
-            if (deconstructMember.Kind != SymbolKind.Method)
+            try
             {
-                Error(diagnostics, ErrorCode.ERR_MissingDeconstruct, boundRHS.Syntax, boundRHS.Type);
-                return null;
-            }
+                for (int i = 0; i < numCheckedVariables; i++)
+                {
+                    var variable = new OutDeconstructVarPendingInference(assignmentSyntax);
+                    analyzedArguments.Arguments.Add(variable);
+                    analyzedArguments.RefKinds.Add(RefKind.Out);
+                    outVars.Add(variable);
+                }
 
-            MethodSymbol deconstructMethod = (MethodSymbol)deconstructMember;
-            if (deconstructMethod.MethodKind != MethodKind.Ordinary)
-            {
-                Error(diagnostics, ErrorCode.ERR_MissingDeconstruct, boundRHS.Syntax, boundRHS.Type);
-                return null;
-            }
+                string methodName = "Deconstruct";
+                var boundExpression = BindInstanceMemberAccess(
+                                        receiverSyntax, receiverSyntax, receiver, methodName, rightArity: 0,
+                                        typeArgumentsSyntax: default(SeparatedSyntaxList<TypeSyntax>), typeArguments: default(ImmutableArray<TypeSymbol>),
+                                        invoked: true, diagnostics: diagnostics);
 
-            if (deconstructMethod.ParameterCount != numCheckedVariables)
-            {
-                Error(diagnostics, ErrorCode.ERR_DeconstructWrongParams, boundRHS.Syntax, deconstructMethod, numCheckedVariables);
-                return null;
-            }
+                boundExpression = CheckValue(boundExpression, BindValueKind.RValueOrMethodGroup, diagnostics);
+                boundExpression.WasCompilerGenerated = true;
+
+                BoundExpression result = BindInvocationExpression(
+                                            receiverSyntax, receiverSyntax, methodName, boundExpression, analyzedArguments, diagnostics, queryClause: null,
+                                            allowUnexpandedForm: true);
 
-            if (deconstructMethod.Parameters.Any(p => p.RefKind != RefKind.Out))
+                result.WasCompilerGenerated = true;
+
+                if (result.HasAnyErrors)
+                {
+                    outPlaceholders = default(ImmutableArray<BoundDeconstructValuePlaceholder>);
+                    return BadExpression(assignmentSyntax, result);
+                }
+
+                outPlaceholders = outVars.SelectAsArray(v => v.Placeholder);
+
+                return result;
+            }
+            finally
             {
-                Error(diagnostics, ErrorCode.ERR_DeconstructRequiresOutParams, boundRHS.Syntax, deconstructMethod);
-                return null;
+                analyzedArguments.Free();
+                outVars.Free();
             }
 
-            return deconstructMethod;
         }
 
         private BoundAssignmentOperator BindAssignment(AssignmentExpressionSyntax node, BoundExpression op1, BoundExpression op2, DiagnosticBag diagnostics)
@@ -2196,6 +2217,10 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                 case BoundKind.PropertyGroup:
                     expr = BindIndexedPropertyAccess((BoundPropertyGroup)expr, mustHaveAllOptionalParameters: false, diagnostics: diagnostics);
                     break;
+
+                case BoundKind.OutDeconstructVarPendingInference:
+                    Debug.Assert(valueKind == BindValueKind.RefOrOut);
+                    return expr;
             }
 
             bool hasResolutionErrors = false;

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs

@@ -6,7 +6,6 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Roslyn.Utilities;
-using System;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -1230,7 +1229,18 @@ private static TypeSymbol GetParameterType(int argIndex, MemberAnalysisResult re
                 var type2 = GetParameterType(i, m2.Result, m2.LeastOverriddenMember.GetParameters(), out refKind2);
 
                 bool okToDowngradeToNeither;
-                var r = BetterConversionFromExpression(arguments[i],
+                BetterResult r;
+
+                if (argumentKind == BoundKind.OutDeconstructVarPendingInference)
+                {
+                    // If argument is an out variable that needs type inference,
+                    // neither candidate is better in this argument.
+                    r = BetterResult.Neither;
+                    okToDowngradeToNeither = false;
+                }
+                else
+                {
+                    r = BetterConversionFromExpression(arguments[i],
                                                        type1,
                                                        m1.Result.ConversionForArg(i),
                                                        refKind1,
@@ -1240,6 +1250,7 @@ private static TypeSymbol GetParameterType(int argIndex, MemberAnalysisResult re
                                                        considerRefKinds,
                                                        ref useSiteDiagnostics,
                                                        out okToDowngradeToNeither);
+                }
 
                 if (r == BetterResult.Neither)
                 {
@@ -2906,6 +2917,14 @@ private RefKind GetEffectiveParameterRefKind(ParameterSymbol parameter, RefKind
                 return Conversion.ImplicitDynamic;
             }
 
+            if (argument.Kind == BoundKind.OutDeconstructVarPendingInference)
+            {
+                Debug.Assert(argRefKind != RefKind.None);
+
+                // Any parameter type is good, we'll use it for the var local.
+                return Conversion.Identity;
+            }
+
             if (argRefKind == RefKind.None)
             {
                 var conversion = Conversions.ClassifyImplicitConversionFromExpression(argument, parameterType, ref useSiteDiagnostics);

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs

@@ -924,7 +924,7 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed
             // If the expression is untyped because it is a lambda, anonymous method, method group or null
             // then we never want to report the error "you need a ref on that thing". Rather, we want to
             // say that you can't convert "null" to "ref int".
-            if (!argument.HasExpressionType())
+            if (!argument.HasExpressionType() && argument.Kind != BoundKind.OutDeconstructVarPendingInference)
             {
                 // If the problem is that a lambda isn't convertible to the given type, also report why.
                 // The argument and parameter type might match, but may not have same in/out modifiers
@@ -971,6 +971,8 @@ private static bool HadLambdaConversionError(DiagnosticBag diagnostics, Analyzed
             }
             else
             {
+                Debug.Assert(argument.Kind != BoundKind.OutDeconstructVarPendingInference);
+
                 TypeSymbol argType = argument.Display as TypeSymbol;
                 Debug.Assert((object)argType != null);