Merge pull request microsoft#13127 from arusakov/old_style_literal_types_in_enums

mhegazy · web-flow · commit e1872dfdaad4 · 2016-12-22T10:00:33.000-08:00
Disallow old style octal literals in enums
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -18582,6 +18582,7 @@ namespace ts {
                             }
                             return undefined;
                         case SyntaxKind.NumericLiteral:
+                            checkGrammarNumericLiteral(<NumericLiteral>e);
                             return +(<NumericLiteral>e).text;
                         case SyntaxKind.ParenthesizedExpression:
                             return evalConstant((<ParenthesizedExpression>e).expression);
@@ -21885,9 +21886,12 @@ namespace ts {
                 if (languageVersion >= ScriptTarget.ES5) {
                     diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
                 }
-                else if (isChildOfLiteralType(node)) {
+                else if (isChildOfNodeWithKind(node, SyntaxKind.LiteralType)) {
                     diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
                 }
+                else if (isChildOfNodeWithKind(node, SyntaxKind.EnumMember)) {
+                    diagnosticMessage = Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
+                }
                 if (diagnosticMessage) {
                     const withMinus = isPrefixUnaryExpression(node.parent) && node.parent.operator === SyntaxKind.MinusToken;
                     const literal = `${withMinus ? "-" : ""}0o${node.text}`;
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -3246,5 +3246,9 @@
     "Octal literal types must use ES2015 syntax. Use the syntax '{0}'.": {
         "category": "Error",
         "code": 8017
+    },
+    "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'.": {
+        "category": "Error",
+        "code": 8018
     }
 }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -732,9 +732,9 @@ namespace ts {
         return false;
     }
 
-    export function isChildOfLiteralType(node: Node): boolean {
+    export function isChildOfNodeWithKind(node: Node, kind: SyntaxKind): boolean {
         while (node) {
-            if (node.kind === SyntaxKind.LiteralType) {
+            if (node.kind === kind) {
                 return true;
             }
             node = node.parent;
diff --git a/tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.errors.txt b/tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/compiler/es3-oldStyleOctalLiteralInEnums.ts(2,7): error TS8018: Octal literals are not allowed in enums members initializer. Use the syntax '-0o1'.
+tests/cases/compiler/es3-oldStyleOctalLiteralInEnums.ts(3,7): error TS8018: Octal literals are not allowed in enums members initializer. Use the syntax '0o2'.
+
+
+==== tests/cases/compiler/es3-oldStyleOctalLiteralInEnums.ts (2 errors) ====
+    enum E {
+      x = -01,
+          ~~~
+!!! error TS8018: Octal literals are not allowed in enums members initializer. Use the syntax '-0o1'.
+      y = 02,
+          ~~
+!!! error TS8018: Octal literals are not allowed in enums members initializer. Use the syntax '0o2'.
+    }
diff --git a/tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.js b/tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.js
@@ -0,0 +1,12 @@
+//// [es3-oldStyleOctalLiteralInEnums.ts]
+enum E {
+  x = -01,
+  y = 02,
+}
+
+//// [es3-oldStyleOctalLiteralInEnums.js]
+var E;
+(function (E) {
+    E[E["x"] = -1] = "x";
+    E[E["y"] = 2] = "y";
+})(E || (E = {}));
diff --git a/tests/baselines/reference/es3-oldStyleOctalLiteralTypes.errors.txt b/tests/baselines/reference/es3-oldStyleOctalLiteralTypes.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/es3-oldStyleOctalLiteralTypes.ts(1,8): error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o10'.
+tests/cases/compiler/es3-oldStyleOctalLiteralTypes.ts(2,8): error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '-0o20'.
+
+
+==== tests/cases/compiler/es3-oldStyleOctalLiteralTypes.ts (2 errors) ====
+    let x: 010;
+           ~~~
+!!! error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '0o10'.
+    let y: -020;
+           ~~~~
+!!! error TS8017: Octal literal types must use ES2015 syntax. Use the syntax '-0o20'.
+    
diff --git a/tests/baselines/reference/es3-oldStyleOctalLiteralTypes.js b/tests/baselines/reference/es3-oldStyleOctalLiteralTypes.js
@@ -0,0 +1,8 @@
+//// [es3-oldStyleOctalLiteralTypes.ts]
+let x: 010;
+let y: -020;
+
+
+//// [es3-oldStyleOctalLiteralTypes.js]
+var x;
+var y;
diff --git a/tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.errors.txt b/tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/compiler/es5-oldStyleOctalLiteralInEnums.ts(2,7): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o1'.
+tests/cases/compiler/es5-oldStyleOctalLiteralInEnums.ts(3,7): error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o2'.
+
+
+==== tests/cases/compiler/es5-oldStyleOctalLiteralInEnums.ts (2 errors) ====
+    enum E {
+      x = -01,
+          ~~~
+!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '-0o1'.
+      y = 02,
+          ~~
+!!! error TS1085: Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '0o2'.
+    }
diff --git a/tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.js b/tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.js
@@ -0,0 +1,12 @@
+//// [es5-oldStyleOctalLiteralInEnums.ts]
+enum E {
+  x = -01,
+  y = 02,
+}
+
+//// [es5-oldStyleOctalLiteralInEnums.js]
+var E;
+(function (E) {
+    E[E["x"] = -1] = "x";
+    E[E["y"] = 2] = "y";
+})(E || (E = {}));
diff --git a/tests/cases/compiler/es3-oldStyleOctalLiteralInEnums.ts b/tests/cases/compiler/es3-oldStyleOctalLiteralInEnums.ts
@@ -0,0 +1,5 @@
+// @target: ES3
+enum E {
+  x = -01,
+  y = 02,
+}
diff --git a/tests/cases/compiler/es3-oldStyleOctalLiteralTypes.ts b/tests/cases/compiler/es3-oldStyleOctalLiteralTypes.ts
diff --git a/tests/cases/compiler/es5-oldStyleOctalLiteralInEnums.ts b/tests/cases/compiler/es5-oldStyleOctalLiteralInEnums.ts
@@ -0,0 +1,5 @@
+// @target: ES5
+enum E {
+  x = -01,
+  y = 02,
+}

Original file line number	Diff line number	Diff line change
`@@ -3246,5 +3246,9 @@`
`3246`	`3246`	`"Octal literal types must use ES2015 syntax. Use the syntax '{0}'.": {`
`3247`	`3247`	`"category": "Error",`
`3248`	`3248`	`"code": 8017`
	`3249`	`+ },`
	`3250`	`+ "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'.": {`
	`3251`	`+ "category": "Error",`
	`3252`	`+ "code": 8018`
`3249`	`3253`	`}`
`3250`	`3254`	`}`
Original file line number	Diff line number	Diff line change
`@@ -732,9 +732,9 @@ namespace ts {`
`732`	`732`	`return false;`
`733`	`733`	`}`
`734`	`734`
`735`		`- export function isChildOfLiteralType(node: Node): boolean {`
	`735`	`+ export function isChildOfNodeWithKind(node: Node, kind: SyntaxKind): boolean {`
`736`	`736`	`while (node) {`
`737`		`- if (node.kind === SyntaxKind.LiteralType) {`
	`737`	`+ if (node.kind === kind) {`
`738`	`738`	`return true;`
`739`	`739`	`}`
`740`	`740`	`node = node.parent;`