Flag assignments to a const

Author: mhegazy

src/compiler/checker.ts

@@ -318,7 +318,9 @@ module ts {
                 if (!s && nameNotFoundMessage) {
                     error(errorLocation, nameNotFoundMessage, nameArg);
                 }
+
                 if (s && s.flags & SymbolFlags.BlockScoped) {
+                    // Block-scoped variables can not be used before thier definition
                     var declaration = forEach(s.declarations, d => d.flags & NodeFlags.BlockScoped ? d : undefined);
                     Debug.assert(declaration, "Bock-scoped variable declaration is undefined");
                     var declarationSourceFile = getSourceFileOfNode(declaration);
@@ -4923,7 +4925,7 @@ module ts {
             return true;
         }
 
-        function checkReferenceExpression(n: Node, message: DiagnosticMessage): boolean {
+        function checkReferenceExpression(n: Node, invalidReferenceMessage: DiagnosticMessage, constantVarianleMessage: DiagnosticMessage): boolean {
             function findSymbol(n: Node): Symbol {
                 var symbol = getNodeLinks(n).resolvedSymbol;
                 // Because we got the symbol from the resolvedSymbol property, it might be of kind
@@ -4962,8 +4964,20 @@ module ts {
                 }
             }
 
+            function isConstVariableReference(n: Node) {
+                if (n.kind === SyntaxKind.Identifier) {
+                    var symbol = findSymbol(n);
+                    return symbol && (symbol.flags & SymbolFlags.Variable) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & NodeFlags.Const) !== 0;
+                }
+                return false;
+            }
+
             if (!isReferenceOrErrorExpression(n)) {
-                error(n, message);
+                error(n, invalidReferenceMessage);
+                return false;
+            }
+            if (isConstVariableReference(n)) {
+                error(n, constantVarianleMessage);
                 return false;
             }
             return true;
@@ -4988,7 +5002,9 @@ module ts {
                     var ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
                     if (ok) {
                         // run check only if former checks succeeded to avoid reporting cascading errors
-                        checkReferenceExpression(node.operand, Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer);
+                        checkReferenceExpression(node.operand,
+                            Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer,
+                            Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant);
                     }
                     return numberType;
             }
@@ -5000,7 +5016,9 @@ module ts {
             var ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
             if (ok) {
                 // run check only if former checks succeeded to avoid reporting cascading errors
-                checkReferenceExpression(node.operand, Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer);
+                checkReferenceExpression(node.operand,
+                    Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer,
+                    Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant);
             }
             return numberType;
         }
@@ -5177,7 +5195,7 @@ module ts {
                     // requires VarExpr to be classified as a reference
                     // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1) 
                     // and the type of the non - compound operation to be assignable to the type of VarExpr.
-                    var ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression);
+                    var ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
                     // Use default messages
                     if (ok) {
                         // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
@@ -6252,7 +6270,7 @@ module ts {
                 }
                 else {
                     // run check only former check succeeded to avoid cascading errors
-                    checkReferenceExpression(node.variable, Diagnostics.Invalid_left_hand_side_in_for_in_statement); 
+                    checkReferenceExpression(node.variable, Diagnostics.Invalid_left_hand_side_in_for_in_statement, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); 
                 }
             }
 

src/compiler/diagnosticInformationMap.generated.ts

@@ -270,6 +270,8 @@ module ts {
         Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: { code: 2446, category: DiagnosticCategory.Error, key: "Property '{0}' is protected and only accessible through an instance of class '{1}'." },
         The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: { code: 2447, category: DiagnosticCategory.Error, key: "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead." },
         Block_scoped_variable_0_used_before_its_declaration: { code: 2448, category: DiagnosticCategory.Error, key: "Block-scoped variable '{0}' used before its declaration." },
+        The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant: { code: 2449, category: DiagnosticCategory.Error, key: "The operand of an increment or decrement operator cannot be a constant." },
+        Left_hand_side_of_assignment_expression_cannot_be_a_constant: { code: 2450, category: DiagnosticCategory.Error, key: "Left-hand side of assignment expression cannot be a constant." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4001, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },

src/compiler/diagnosticMessages.json

@@ -1072,6 +1072,14 @@
         "category": "Error",
         "code": 2448
     },
+    "The operand of an increment or decrement operator cannot be a constant.": {
+        "category": "Error",
+        "code": 2449
+    },
+    "Left-hand side of assignment expression cannot be a constant.": {
+        "category": "Error",
+        "code": 2450
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

tests/baselines/reference/constDeclarations-access.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/file2.ts(1,1): error TS2449: The operand of an increment or decrement operator cannot be a constant.
+
+
+==== tests/cases/compiler/file1.ts (0 errors) ====
+    
+    const x = 0
+    
+==== tests/cases/compiler/file2.ts (1 errors) ====
+    x++;
+    ~
+!!! error TS2449: The operand of an increment or decrement operator cannot be a constant.

tests/baselines/reference/constDeclarations-access.js

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/constDeclarations-access.ts] ////
+
+//// [file1.ts]
+
+const x = 0
+
+//// [file2.ts]
+x++;
+
+//// [file1.js]
+const x = 0;
+//// [file2.js]
+x++;

tests/baselines/reference/constDeclarations-access2.errors.txt

@@ -0,0 +1,89 @@
+tests/cases/compiler/constDeclarations-access2.ts(5,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(6,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(7,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(8,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(9,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(10,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(11,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(12,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(13,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(14,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(15,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(16,1): error TS2450: Left-hand side of assignment expression cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(18,1): error TS2449: The operand of an increment or decrement operator cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(19,1): error TS2449: The operand of an increment or decrement operator cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(20,3): error TS2449: The operand of an increment or decrement operator cannot be a constant.
+tests/cases/compiler/constDeclarations-access2.ts(21,3): error TS2449: The operand of an increment or decrement operator cannot be a constant.
+
+
+==== tests/cases/compiler/constDeclarations-access2.ts (16 errors) ====
+    
+    const x = 0
+    
+    // Errors
+    x = 1;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x += 2;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x -= 3;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x *= 4;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x /= 5;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x %= 6;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x <<= 7;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x >>= 8;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x >>>= 9;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x &= 10;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x |= 11;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    x ^= 12;
+    ~
+!!! error TS2450: Left-hand side of assignment expression cannot be a constant.
+    
+    x++;
+    ~
+!!! error TS2449: The operand of an increment or decrement operator cannot be a constant.
+    x--;
+    ~
+!!! error TS2449: The operand of an increment or decrement operator cannot be a constant.
+    ++x;
+      ~
+!!! error TS2449: The operand of an increment or decrement operator cannot be a constant.
+    --x;
+      ~
+!!! error TS2449: The operand of an increment or decrement operator cannot be a constant.
+    
+    // OK
+    var a = x + 1;
+    
+    function f(v: number) { }
+    f(x);
+    
+    if (x) { }
+    
+    x;
+    (x);
+    
+    -x;
+    +x;
+    
+    x.toString();
+    

tests/baselines/reference/constDeclarations-access2.js

@@ -0,0 +1,71 @@
+//// [constDeclarations-access2.ts]
+
+const x = 0
+
+// Errors
+x = 1;
+x += 2;
+x -= 3;
+x *= 4;
+x /= 5;
+x %= 6;
+x <<= 7;
+x >>= 8;
+x >>>= 9;
+x &= 10;
+x |= 11;
+x ^= 12;
+
+x++;
+x--;
+++x;
+--x;
+
+// OK
+var a = x + 1;
+
+function f(v: number) { }
+f(x);
+
+if (x) { }
+
+x;
+(x);
+
+-x;
++x;
+
+x.toString();
+
+
+//// [constDeclarations-access2.js]
+const x = 0;
+// Errors
+x = 1;
+x += 2;
+x -= 3;
+x *= 4;
+x /= 5;
+x %= 6;
+x <<= 7;
+x >>= 8;
+x >>>= 9;
+x &= 10;
+x |= 11;
+x ^= 12;
+x++;
+x--;
+++x;
+--x;
+// OK
+var a = x + 1;
+function f(v) {
+}
+f(x);
+if (x) {
+}
+x;
+(x);
+-x;
++x;
+x.toString();

tests/baselines/reference/letDeclarations-access.js

@@ -0,0 +1,70 @@
+//// [letDeclarations-access.ts]
+
+let x = 0
+
+// No errors
+
+x = 1;
+x += 2;
+x -= 3;
+x *= 4;
+x /= 5;
+x %= 6;
+x <<= 7;
+x >>= 8;
+x >>>= 9;
+x &= 10;
+x |= 11;
+x ^= 12;
+
+x++;
+x--;
+++x;
+--x;
+
+var a = x + 1;
+
+function f(v: number) { }
+f(x);
+
+if (x) { }
+
+x;
+(x);
+
+-x;
++x;
+
+x.toString();
+
+
+//// [letDeclarations-access.js]
+let x = 0;
+// No errors
+x = 1;
+x += 2;
+x -= 3;
+x *= 4;
+x /= 5;
+x %= 6;
+x <<= 7;
+x >>= 8;
+x >>>= 9;
+x &= 10;
+x |= 11;
+x ^= 12;
+x++;
+x--;
+++x;
+--x;
+var a = x + 1;
+function f(v) {
+}
+f(x);
+if (x) {
+}
+x;
+(x);
+-x;
++x;
+x.toString();