Deconstruction-assignment for tuples

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

@@ -1715,6 +1715,13 @@ private BoundExpression BindAssignment(AssignmentExpressionSyntax node, Diagnost
             return BindAssignment(node, op1, op2, diagnostics);
         }
 
+        /// <summary>
+        /// There are two kinds of deconstruction-assignments which this binding handles: tuple and non-tuple.
+        ///
+        /// Returns a BoundDeconstructionAssignmentOperator
+        ///     - with all the fields populated except deconstructMember, for the tuple case
+        ///     - with all the fields populated, for a non-tuple case
+        /// </summary>
         private BoundExpression BindDeconstructionAssignment(AssignmentExpressionSyntax node, DiagnosticBag diagnostics)
         {
             SeparatedSyntaxList<ArgumentSyntax> arguments = ((TupleExpressionSyntax)node.Left).Arguments;
@@ -1737,6 +1744,52 @@ private BoundExpression BindDeconstructionAssignment(AssignmentExpressionSyntax
 
             var checkedVariables = checkedVariablesBuilder.ToImmutableAndFree();
 
+            // tuple literal such as `(1, 2)`, `(null, null)`, `(x.P, y.M())`
+            if (boundRHS.Kind == BoundKind.TupleLiteral || ((object)boundRHS.Type != null && boundRHS.Type.IsTupleType))
+            {
+                return BindDeconstructWithTuple(node, diagnostics, boundRHS, checkedVariables);
+            }
+
+            // expression without type such as `null`
+            if (boundRHS.Type == null)
+            {
+                Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, node);
+                return BadExpression(node, new[] { boundRHS });
+            }
+
+            return BindDeconstructWithDeconstruct(node, diagnostics, boundRHS, checkedVariables);
+        }
+
+        private BoundExpression BindDeconstructWithTuple(AssignmentExpressionSyntax node, DiagnosticBag diagnostics, BoundExpression boundRHS, ImmutableArray<BoundExpression> checkedVariables)
+        {
+            // patch up the tuple literal so that it has a type, based on the LHS information
+            var lhsTypes = checkedVariables.SelectAsArray(v => v.Type);
+            TypeSymbol lhsAsTuple = TupleTypeSymbol.Create(locationOpt: null, elementTypes: lhsTypes, elementLocations: default(ImmutableArray<Location>), elementNames: default(ImmutableArray<string>), compilation: Compilation, diagnostics: diagnostics);
+            var typedRHS = GenerateConversionForAssignment(lhsAsTuple, boundRHS, diagnostics);
+
+            ImmutableArray<TypeSymbol> tupleTypes = typedRHS.Type.TupleElementTypes;
+
+            // figure out the pairwise conversions
+            var assignmentsBuilder = ArrayBuilder<BoundDeconstructionAssignmentOperator.AssignmentInfo>.GetInstance(checkedVariables.Length);
+
+            for (int i = 0; i < checkedVariables.Length; i++)
+            {
+                var leftPlaceholder = new BoundLValuePlaceholder(checkedVariables[i].Syntax, checkedVariables[i].Type) { WasCompilerGenerated = true };
+                var rightPlaceholder = new BoundRValuePlaceholder(node.Right, tupleTypes[i]) { WasCompilerGenerated = true };
+
+                // each assignment has a placeholder for a receiver and another for the source
+                BoundAssignmentOperator op = BindAssignment(node, leftPlaceholder, rightPlaceholder, diagnostics);
+                assignmentsBuilder.Add(new BoundDeconstructionAssignmentOperator.AssignmentInfo() { Assignment = op, LValuePlaceholder = leftPlaceholder, RValuePlaceholder = rightPlaceholder });
+            }
+
+            var assignments = assignmentsBuilder.ToImmutableAndFree();
+
+            TypeSymbol lastType = tupleTypes.Last();
+            return new BoundDeconstructionAssignmentOperator(node, checkedVariables, typedRHS, deconstructMemberOpt: null, assignments: assignments, type: lastType);
+        }
+
+        private BoundExpression BindDeconstructWithDeconstruct(AssignmentExpressionSyntax node, DiagnosticBag diagnostics, BoundExpression boundRHS, ImmutableArray<BoundExpression> checkedVariables)
+        {
             // symbol and parameters for Deconstruct
             DiagnosticBag bag = new DiagnosticBag();
             MethodSymbol deconstructMethod = FindDeconstruct(checkedVariables, boundRHS, node, bag);
@@ -1754,7 +1807,7 @@ private BoundExpression BindDeconstructionAssignment(AssignmentExpressionSyntax
             }
 
             // figure out the pairwise conversions
-            var assignmentsBuilder = ArrayBuilder<BoundDeconstructionAssignmentOperator.AssignmentInfo>.GetInstance(numElements);
+            var assignmentsBuilder = ArrayBuilder<BoundDeconstructionAssignmentOperator.AssignmentInfo>.GetInstance(checkedVariables.Length);
             var deconstructParameters = deconstructMethod.Parameters;
             for (int i = 0; i < checkedVariables.Length; i++)
             {

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -397,7 +397,7 @@
     <Field Name="LeftVariables" Type="ImmutableArray&lt;BoundExpression&gt;"/>
 
     <Field Name="Right" Type="BoundExpression"/>
-    <Field Name="DeconstructMember" Type="MethodSymbol" Null="disallow"/>
+    <Field Name="DeconstructMemberOpt" Type="MethodSymbol" Null="allow"/>
 
     <!-- The assignments have placeholders for the left and right part of the assignment -->
     <Field Name="Assignments" Type="ImmutableArray&lt;BoundDeconstructionAssignmentOperator.AssignmentInfo&gt;" Null="NotApplicable" SkipInVisitor="true"/>

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -4884,4 +4884,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_MissingDeconstruct" xml:space="preserve">
     <value>No Deconstruct instance or extension method was found for type '{0}'.</value>
   </data>
+  <data name="ERR_DeconstructRequiresExpression" xml:space="preserve">
+    <value>Deconstruct assignment requires an expression with a type on the right-hand-side.</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1395,5 +1395,6 @@ internal enum ErrorCode
         ERR_AmbiguousDeconstruct = 8207,
         ERR_DeconstructRequiresOutParams = 8208,
         ERR_DeconstructWrongParams = 8209,
+        ERR_DeconstructRequiresExpression = 8210,
     }
 }

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_DeconstructionAssignmentOperator.cs

@@ -1,6 +1,9 @@
 // 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.Immutable;
 using System.Diagnostics;
+using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -9,9 +12,6 @@ internal sealed partial class LocalRewriter
     {
         public override BoundNode VisitDeconstructionAssignmentOperator(BoundDeconstructionAssignmentOperator node)
         {
-            CSharpSyntaxNode syntax = node.Syntax;
-            int numVariables = node.LeftVariables.Length;
-
             var temps = ArrayBuilder<LocalSymbol>.GetInstance();
             var stores = ArrayBuilder<BoundExpression>.GetInstance();
 
@@ -24,40 +24,27 @@ public override BoundNode VisitDeconstructionAssignmentOperator(BoundDeconstruct
             }
 
             BoundExpression loweredRight = VisitExpression(node.Right);
+            ImmutableArray<BoundExpression> rhsValues;
 
-            // prepare out parameters for Deconstruct
-            var deconstructParameters = node.DeconstructMember.Parameters;
-            var outParametersBuilder = ArrayBuilder<BoundExpression>.GetInstance(deconstructParameters.Length);
-            Debug.Assert(deconstructParameters.Length == node.LeftVariables.Length);
-
-            for (int i = 0; i < numVariables; i++)
+            // get or make right-hand-side values
+            if (node.Right.Type.IsTupleType)
             {
-                var localSymbol = new SynthesizedLocal(_factory.CurrentMethod, deconstructParameters[i].Type, SynthesizedLocalKind.LoweringTemp);
-
-                var localBound = new BoundLocal(syntax,
-                                                localSymbol,
-                                                null,
-                                                deconstructParameters[i].Type
-                                                ) { WasCompilerGenerated = true };
-
-                temps.Add(localSymbol);
-                outParametersBuilder.Add(localBound);
+                rhsValues = AccessTupleFields(node, loweredRight, temps, stores);
+            }
+            else
+            {
+                rhsValues = CallDeconstruct(node, loweredRight, temps, stores);
             }
 
-            var outParameters = outParametersBuilder.ToImmutableAndFree();
-
-            // invoke Deconstruct
-            var invokeDeconstruct = MakeCall(syntax, loweredRight, node.DeconstructMember, outParameters, node.DeconstructMember.ReturnType);
-            stores.Add(invokeDeconstruct);
-
-            // assign from out temps to lhs receivers
-            for (int i = 0; i < numVariables; i++)
+            // assign from rhs values to lhs receivers
+            int numAssignments = node.Assignments.Length;
+            for (int i = 0; i < numAssignments; i++)
             {
                 // lower the assignment and replace the placeholders for source and target in the process
                 var assignmentInfo = node.Assignments[i];
 
                 AddPlaceholderReplacement(assignmentInfo.LValuePlaceholder, lhsReceivers[i]);
-                AddPlaceholderReplacement(assignmentInfo.RValuePlaceholder, outParameters[i]);
+                AddPlaceholderReplacement(assignmentInfo.RValuePlaceholder, rhsValues[i]);
 
                 var assignment = VisitExpression(assignmentInfo.Assignment);
 
@@ -75,5 +62,76 @@ public override BoundNode VisitDeconstructionAssignmentOperator(BoundDeconstruct
 
             return result;
         }
+
+        private ImmutableArray<BoundExpression> AccessTupleFields(BoundDeconstructionAssignmentOperator node, BoundExpression loweredRight, ArrayBuilder<LocalSymbol> temps, ArrayBuilder<BoundExpression> stores)
+        {
+            var tupleType = loweredRight.Type.IsTupleType ? loweredRight.Type : TupleTypeSymbol.Create((NamedTypeSymbol)loweredRight.Type);
+            var tupleElementTypes = tupleType.TupleElementTypes;
+
+            var numElements = tupleElementTypes.Length;
+            Debug.Assert(numElements == node.LeftVariables.Length);
+
+            CSharpSyntaxNode syntax = node.Syntax;
+
+            // save the loweredRight as we need to access it multiple times 
+            BoundAssignmentOperator assignmentToTemp;
+            var savedTuple = _factory.StoreToTemp(loweredRight, out assignmentToTemp);
+            stores.Add(assignmentToTemp);
+            temps.Add(savedTuple.LocalSymbol);
+
+            // list the tuple fields
+            var fieldAccessorsBuilder = ArrayBuilder<BoundExpression>.GetInstance(numElements);
+
+            for (int i = 0; i < numElements; i++)
+            {
+                var fields = tupleType.GetMembers(TupleTypeSymbol.TupleMemberName(i + 1)).OfType<FieldSymbol>();
+                var field = fields.Single();
+                var fieldAccess = MakeTupleFieldAccess(syntax, field, savedTuple, null, LookupResultKind.Empty, tupleElementTypes[i]);
+                fieldAccessorsBuilder.Add(fieldAccess);
+            }
+
+            return fieldAccessorsBuilder.ToImmutableAndFree();
+        }
+
+        /// <summary>
+        /// Prepares local variables to be used in Deconstruct call
+        /// Adds a invocation of Deconstruct with those as out parameters onto the 'stores' sequence
+        /// Returns the expressions for those out parameters
+        /// </summary>
+        private ImmutableArray<BoundExpression> CallDeconstruct(BoundDeconstructionAssignmentOperator node, BoundExpression loweredRight, ArrayBuilder<LocalSymbol> temps, ArrayBuilder<BoundExpression> stores)
+        {
+            Debug.Assert((object)node.DeconstructMemberOpt != null);
+
+            int numVariables = node.LeftVariables.Length;
+            CSharpSyntaxNode syntax = node.Syntax;
+
+            // prepare out parameters for Deconstruct
+            var deconstructParameters = node.DeconstructMemberOpt.Parameters;
+            var outParametersBuilder = ArrayBuilder<BoundExpression>.GetInstance(deconstructParameters.Length);
+            Debug.Assert(deconstructParameters.Length == node.LeftVariables.Length);
+
+            for (int i = 0; i < numVariables; i++)
+            {
+                var localSymbol = new SynthesizedLocal(_factory.CurrentMethod, deconstructParameters[i].Type, SynthesizedLocalKind.LoweringTemp);
+
+                var localBound = new BoundLocal(syntax,
+                                                localSymbol,
+                                                null,
+                                                deconstructParameters[i].Type
+                                                )
+                { WasCompilerGenerated = true };
+
+                temps.Add(localSymbol);
+                outParametersBuilder.Add(localBound);
+            }
+
+            var outParameters = outParametersBuilder.ToImmutableAndFree();
+
+            // invoke Deconstruct
+            var invokeDeconstruct = MakeCall(syntax, loweredRight, node.DeconstructMemberOpt, outParameters, node.DeconstructMemberOpt.ReturnType);
+            stores.Add(invokeDeconstruct);
+
+            return outParameters;
+        }
     }
 }