From 7e4ea6efb73e58128ec26b645de53bc444583227 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 8 Nov 2016 12:16:44 -0800
Subject: [PATCH] Moving IsDeconstructionDeclarationLeft method

---
 .../CSharp/Portable/Parser/LanguageParser.cs  | 24 +------------------
 .../Portable/Syntax/SyntaxExtensions.cs       | 22 +++++++++++++++++
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index b05b4e5c2c176..e3ad397ba8b2a 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -7541,7 +7541,7 @@ private StatementSyntax ParseEmbeddedStatement(bool complexCheck)
                     if (expression.Kind == SyntaxKind.SimpleAssignmentExpression)
                     {
                         var assignment = (AssignmentExpressionSyntax)expression;
-                        if (IsDeconstructionDeclarationLeft(assignment.Left))
+                        if (assignment.Left.IsDeconstructionDeclarationLeft())
                         {
                             statement = this.AddError(statement, ErrorCode.ERR_BadEmbeddedStmt);
                         }
@@ -8667,28 +8667,6 @@ private static bool TypeFoundInDeconstructionDeclarationVariables(ExpressionSynt
             }
         }
 
-        /// <summary>
-        /// Returns true if the expression is composed only of nested tuple and declaration expressions.
-        /// </summary>
-        private static bool IsDeconstructionDeclarationLeft(ExpressionSyntax node)
-        {
-            switch (node.Kind)
-            {
-                case SyntaxKind.TupleExpression:
-                    var arguments = ((TupleExpressionSyntax)node).Arguments;
-                    for (int i = 0; i < arguments.Count; i++)
-                    {
-                        if (!IsDeconstructionDeclarationLeft(arguments[i].Expression)) return false;
-                    }
-
-                    return true;
-                case SyntaxKind.DeclarationExpression:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
         private VariableDesignationSyntax ParseDeconstructionDesignation(bool topLevel = false)
         {
             // the two forms of designation are
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs
index 33a7df4b0cdd4..965ec4b2db4e6 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs
@@ -223,6 +223,28 @@ private static bool IsDeconstructionDeclarationLeft(this ExpressionSyntax self)
             }
         }
 
+        /// <summary>
+        /// Returns true if the expression is composed only of nested tuple and declaration expressions.
+        /// </summary>
+        internal static bool IsDeconstructionDeclarationLeft(this Syntax.InternalSyntax.ExpressionSyntax node)
+        {
+            switch (node.Kind)
+            {
+                case SyntaxKind.TupleExpression:
+                    var arguments = ((Syntax.InternalSyntax.TupleExpressionSyntax)node).Arguments;
+                    for (int i = 0; i < arguments.Count; i++)
+                    {
+                        if (!IsDeconstructionDeclarationLeft(arguments[i].Expression)) return false;
+                    }
+
+                    return true;
+                case SyntaxKind.DeclarationExpression:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
         internal static bool IsDeconstructionDeclaration(this AssignmentExpressionSyntax self)
         {
             return self.Left.IsDeconstructionDeclarationLeft();