Implement type merging in deconstruction with tuple literal

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

@@ -61,7 +61,7 @@ private BoundDeconstructionAssignmentOperator BindDeconstructionAssignment(CShar
                     // Let's fix the literal up by figuring out its type
                     // For declarations, that means merging type information from the LHS and RHS
                     // For assignments, only the LHS side matters since it is necessarily typed
-                    TypeSymbol lhsAsTuple = MakeMergedTupleType(checkedVariables, (BoundTupleLiteral)boundRHS, node, diagnostics, Compilation);
+                    TypeSymbol lhsAsTuple = MakeMergedTupleType(checkedVariables, (BoundTupleLiteral)boundRHS, node, Compilation, diagnostics);
                     if (lhsAsTuple != null)
                     {
                         boundRHS = GenerateConversionForAssignment(lhsAsTuple, boundRHS, diagnostics);
@@ -294,7 +294,7 @@ private bool DeconstructOrAssignOutputs(
         /// For cases where the RHS of a deconstruction-assignment is a tuple literal, the type information from the LHS determines the merged type, since all variables have a type.
         /// Returns null if a merged tuple type could not be fabricated.
         /// </summary>
-        private static TypeSymbol MakeMergedTupleType(ArrayBuilder<DeconstructionVariable> lhsVariables, BoundTupleLiteral rhsLiteral, CSharpSyntaxNode syntax, DiagnosticBag diagnostics, CSharpCompilation compilation)
+        private static TypeSymbol MakeMergedTupleType(ArrayBuilder<DeconstructionVariable> lhsVariables, BoundTupleLiteral rhsLiteral, CSharpSyntaxNode syntax, CSharpCompilation compilation, DiagnosticBag diagnostics)
         {
             int leftLength = lhsVariables.Count;
             int rightLength = rhsLiteral.Arguments.Length;
@@ -313,28 +313,36 @@ private static TypeSymbol MakeMergedTupleType(ArrayBuilder<DeconstructionVariabl
                         if (element.Kind == BoundKind.TupleLiteral)
                         {
                             // (variables) on the left and (elements) on the right
-                            mergedType = MakeMergedTupleType(variable.NestedVariables, (BoundTupleLiteral)element, syntax, diagnostics, compilation);
+                            mergedType = MakeMergedTupleType(variable.NestedVariables, (BoundTupleLiteral)element, syntax, compilation, diagnostics);
                         }
-                        else if (element.Type == null)
+                        else if ((object)mergedType == null)
                         {
                             // (variables) on the left and null on the right
                             Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax);
                         }
                     }
                     else
                     {
-                        if (variable.Single.Type != null)
+                        if ((object)variable.Single.Type != null)
                         {
                             // typed-variable on the left
                             mergedType = variable.Single.Type;
                         }
-                        else if (element.Type == null)
+                        else if ((object)mergedType == null)
                         {
                             // typeless-variable on the left and typeless-element on the right
                             Error(diagnostics, ErrorCode.ERR_DeconstructCouldNotInferMergedType, syntax, variable.Syntax, element.Syntax);
                         }
                     }
                 }
+                else
+                {
+                    if ((object)element.Type == null)
+                    {
+                        // a typeless element on the right, matching no variable on the left
+                        Error(diagnostics, ErrorCode.ERR_DeconstructRequiresExpression, element.Syntax);
+                    }
+                }
 
                 typesBuilder.Add(mergedType);
             }

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

@@ -3168,22 +3168,26 @@ static void Main()
         }
 
         [Fact]
-        public void TypeMergingWithTooManyRightVariables()
+        public void TypeMergingWithTooManyRightElements()
         {
             string source = @"
 class C
 {
     static void Main()
     {
-        (string x1, var x2) = (null, ""hello"", 3);
+        (string x1, var y1) = (null, ""hello"", 3);
+        (string x2, var y2) = (null, ""hello"", null);
     }
 }
 ";
             var comp = CreateCompilationWithMscorlib(source, references: new[] { ValueTupleRef, SystemRuntimeFacadeRef });
             comp.VerifyDiagnostics(
                 // (6,9): error CS8211: Cannot deconstruct a tuple of '3' elements into '2' variables.
-                //         (string x1, var x2) = (null, "hello", 3);
-                Diagnostic(ErrorCode.ERR_DeconstructWrongCardinality, @"(string x1, var x2) = (null, ""hello"", 3);").WithArguments("3", "2").WithLocation(6, 9)
+                //         (string x1, var y1) = (null, "hello", 3);
+                Diagnostic(ErrorCode.ERR_DeconstructWrongCardinality, @"(string x1, var y1) = (null, ""hello"", 3);").WithArguments("3", "2").WithLocation(6, 9),
+                // (7,47): error CS8210: Deconstruct assignment requires an expression with a type on the right-hand-side.
+                //         (string x2, var y2) = (null, "hello", null);
+                Diagnostic(ErrorCode.ERR_DeconstructRequiresExpression, "null").WithLocation(7, 47)
                 );
         }