more refactoring

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

@@ -664,7 +664,7 @@ private BoundTupleLiteral DeconstructionVariablesAsTuple(CSharpSyntaxNode syntax
                     }
                 default:
                     var boundVariable = BindExpression(node, diagnostics, invoked: false, indexed: false);
-                    var checkedVariable = CheckValue(boundVariable, BindValueKind.Assignment, diagnostics);
+                    var checkedVariable = CheckValue(boundVariable, BindValueKind.Assignable, diagnostics);
                     if (expression == null && checkedVariable.Kind != BoundKind.DiscardExpression)
                     {
                         expression = node;

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

@@ -3683,7 +3683,7 @@ private BoundExpression MakeBadExpressionForObjectCreation(ObjectCreationExpress
             BoundKind boundMemberKind = boundMember.Kind;
             SyntaxKind rhsKind = namedAssignment.Right.Kind();
             bool isRhsNestedInitializer = rhsKind == SyntaxKind.ObjectInitializerExpression || rhsKind == SyntaxKind.CollectionInitializerExpression;
-            BindValueKind valueKind = isRhsNestedInitializer ? BindValueKind.RValue : BindValueKind.Assignment;
+            BindValueKind valueKind = isRhsNestedInitializer ? BindValueKind.RValue : BindValueKind.Assignable;
 
             ImmutableArray<BoundExpression> arguments = ImmutableArray<BoundExpression>.Empty;
             ImmutableArray<string> argumentNamesOpt = default(ImmutableArray<string>);

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

@@ -75,7 +75,7 @@ private BoundExpression BindCompoundAssignment(AssignmentExpressionSyntax node,
                 }
             }
 
-            if (left.Kind == BoundKind.EventAccess && !CheckEventValueKind((BoundEventAccess)left, BindValueKind.Assignment, diagnostics))
+            if (left.Kind == BoundKind.EventAccess && !CheckEventValueKind((BoundEventAccess)left, BindValueKind.Assignable, diagnostics))
             {
                 // If we're in a place where the event can be assigned, then continue so that we give errors
                 // about the types and operator not lining up.  Otherwise, just report that the event can't
@@ -2437,7 +2437,7 @@ private static BindValueKind GetBinaryAssignmentKind(SyntaxKind kind)
             switch (kind)
             {
                 case SyntaxKind.SimpleAssignmentExpression:
-                    return BindValueKind.Assignment;
+                    return BindValueKind.Assignable;
                 case SyntaxKind.AddAssignmentExpression:
                 case SyntaxKind.AndAssignmentExpression:
                 case SyntaxKind.DivideAssignmentExpression:

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

@@ -1127,7 +1127,7 @@ private BoundExpression BindAssignment(AssignmentExpressionSyntax node, Diagnost
                 return BindDeconstruction(node, diagnostics);
             }
 
-            var op1 = BindValue(node.Left, diagnostics, BindValueKind.Assignment); // , BIND_MEMBERSET);
+            var op1 = BindValue(node.Left, diagnostics, BindValueKind.Assignable); // , BIND_MEMBERSET);
             var op2 = BindValue(node.Right, diagnostics, BindValueKind.RValue); // , BIND_RVALUEREQUIRED);
 
             if (op1.Kind == BoundKind.DiscardExpression)

src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/CompilationContext.cs

@@ -616,7 +616,7 @@ private static bool IsAssignableExpression(Binder binder, BoundExpression expres
             // Presumably, this is done to avoid producing a confusing error message about the
             // field not being an lvalue.
             var diagnostics = DiagnosticBag.GetInstance();
-            var result = binder.CheckValueKind(expression.Syntax, expression, Binder.BindValueKind.Assignment, checkingReceiver: false, diagnostics: diagnostics) &&
+            var result = binder.CheckValueKind(expression.Syntax, expression, Binder.BindValueKind.Assignable, checkingReceiver: false, diagnostics: diagnostics) &&
                 !diagnostics.HasAnyErrors();
             diagnostics.Free();
             return result;