Remove strict mode and target check; Refactoring

Author: graphemecluster

src/compiler/binder.ts

@@ -237,7 +237,6 @@ import {
     nodeIsPresent,
     NonNullChain,
     NonNullExpression,
-    NumericLiteral,
     objectAllocator,
     ObjectLiteralExpression,
     OptionalChain,
@@ -278,7 +277,6 @@ import {
     SyntaxKind,
     TextRange,
     ThrowStatement,
-    TokenFlags,
     tokenToString,
     tracing,
     TracingNode,
@@ -2627,19 +2625,6 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
         }
     }
 
-    function checkStrictModeStringLiteral(node: StringLiteral) {
-        if (languageVersion >= ScriptTarget.ES5 && inStrictMode && node.rangesOfOctalSequences) {
-            file.bindDiagnostics.push(...node.rangesOfOctalSequences.map(
-                range => createFileDiagnostic(file, range.pos, range.end - range.pos, Diagnostics.Octal_escape_sequences_are_not_allowed_in_strict_mode)));
-        }
-    }
-
-    function checkStrictModeNumericLiteral(node: NumericLiteral) {
-        if (languageVersion >= ScriptTarget.ES5 && inStrictMode && node.numericLiteralFlags & TokenFlags.Octal) {
-            file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
-        }
-    }
-
     function checkStrictModePostfixUnaryExpression(node: PostfixUnaryExpression) {
         // Grammar checking
         // The identifier eval or arguments may not appear as the LeftHandSideExpression of an
@@ -2882,10 +2867,6 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
                 return checkStrictModeCatchClause(node as CatchClause);
             case SyntaxKind.DeleteExpression:
                 return checkStrictModeDeleteExpression(node as DeleteExpression);
-            case SyntaxKind.StringLiteral:
-                return checkStrictModeStringLiteral(node as StringLiteral);
-            case SyntaxKind.NumericLiteral:
-                return checkStrictModeNumericLiteral(node as NumericLiteral);
             case SyntaxKind.PostfixUnaryExpression:
                 return checkStrictModePostfixUnaryExpression(node as PostfixUnaryExpression);
             case SyntaxKind.PrefixUnaryExpression:

src/compiler/checker.ts

@@ -434,7 +434,6 @@ import {
     isCatchClause,
     isCatchClauseVariableDeclarationOrBindingElement,
     isCheckJsEnabledForFile,
-    isChildOfNodeWithKind,
     isClassDeclaration,
     isClassElement,
     isClassExpression,
@@ -46922,33 +46921,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return false;
     }
 
-    function checkGrammarNumericLiteral(node: NumericLiteral): boolean {
-        // Grammar checking
-        if (node.numericLiteralFlags & TokenFlags.Octal) {
-            let diagnosticMessage: DiagnosticMessage | undefined;
-            if (languageVersion >= ScriptTarget.ES5) {
-                diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
-            }
-            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;
-                return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
-            }
-        }
-
+    function checkGrammarNumericLiteral(node: NumericLiteral) {
         // Realism (size) checking
-        checkNumericLiteralValueSize(node);
-
-        return false;
-    }
-
-    function checkNumericLiteralValueSize(node: NumericLiteral) {
         // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
         // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
         const isFractional = getTextOfNode(node).indexOf(".") !== -1;

src/compiler/diagnosticMessages.json

@@ -227,10 +227,6 @@
         "category": "Error",
         "code": 1084
     },
-    "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'.": {
-        "category": "Error",
-        "code": 1085
-    },
     "'{0}' modifier cannot appear on a constructor declaration.": {
         "category": "Error",
         "code": 1089
@@ -351,7 +347,7 @@
         "category": "Error",
         "code": 1120
     },
-    "Octal literals are not allowed in strict mode.": {
+    "Octal literals are not allowed. Use the syntax '{0}'.": {
         "category": "Error",
         "code": 1121
     },
@@ -1549,14 +1545,18 @@
         "category": "Message",
         "code": 1483
     },
-    "Octal escape sequences are not allowed in strict mode.": {
+    "Octal escape sequences are not allowed. Use the syntax '{0}'.": {
         "category": "Error",
         "code": 1484
     },
-    "Octal escape sequences are not allowed in template strings.": {
+    "'{0}' is not allowed.": {
         "category": "Error",
         "code": 1485
     },
+    "Decimals with leading zeros are not allowed.": {
+        "category": "Error",
+        "code": 1486
+    },
 
     "The types of '{0}' are incompatible between these types.": {
         "category": "Error",
@@ -6332,14 +6332,6 @@
         "category": "Error",
         "code": 8016
     },
-    "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
-    },
     "Report errors in .js files.": {
         "category": "Message",
         "code": 8019

src/compiler/factory/nodeFactory.ts

@@ -374,7 +374,6 @@ import {
     QuestionDotToken,
     QuestionToken,
     ReadonlyKeyword,
-    ReadonlyTextRange,
     reduceLeft,
     RegularExpressionLiteral,
     RestTypeNode,
@@ -1293,11 +1292,10 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
-    function createStringLiteral(text: string, isSingleQuote?: boolean, hasExtendedUnicodeEscape?: boolean, rangesOfOctalSequences?: ReadonlyTextRange[]): StringLiteral {
+    function createStringLiteral(text: string, isSingleQuote?: boolean, hasExtendedUnicodeEscape?: boolean): StringLiteral {
         const node = createBaseStringLiteral(text, isSingleQuote);
         node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
         if (hasExtendedUnicodeEscape) node.transformFlags |= TransformFlags.ContainsES2015;
-        node.rangesOfOctalSequences = rangesOfOctalSequences;
         return node;
     }
 

src/compiler/parser.ts

@@ -2097,8 +2097,8 @@ namespace Parser {
         parseErrorAt(range.pos, range.end, message, arg0);
     }
 
-    function scanError(message: DiagnosticMessage, length: number): void {
-        parseErrorAtPosition(scanner.getTextPos(), length, message);
+    function scanError(message: DiagnosticMessage, length: number, arg0?: any): void {
+        parseErrorAtPosition(scanner.getTextPos(), length, message, arg0);
     }
 
     function getNodePos(): number {
@@ -2153,6 +2153,10 @@ namespace Parser {
         return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
     }
 
+    function reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind {
+        return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
+    }
+
     function reScanLessThanToken(): SyntaxKind {
         return currentToken = scanner.reScanLessThanToken();
     }
@@ -3602,7 +3606,9 @@ namespace Parser {
     }
 
     function parseTemplateHead(isTaggedTemplate: boolean): TemplateHead {
-        reScanTemplateToken(isTaggedTemplate);
+        if (!isTaggedTemplate && scanner.getTokenFlags() & TokenFlags.ContainsInvalidEscape) {
+            reScanTemplateHeadOrNoSubstitutionTemplate();
+        }
         const fragment = parseLiteralLikeNode(token());
         Debug.assert(fragment.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
         return fragment as TemplateHead;
@@ -3630,7 +3636,7 @@ namespace Parser {
             // We also do not need to check for negatives because any prefix operator would be part of a
             // parent unary expression.
             kind === SyntaxKind.NumericLiteral ? factory.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) :
-            kind === SyntaxKind.StringLiteral ? factory.createStringLiteral(scanner.getTokenValue(), /*isSingleQuote*/ undefined, scanner.hasExtendedUnicodeEscape(), scanner.getRangesOfOctalSequences()) :
+            kind === SyntaxKind.StringLiteral ? factory.createStringLiteral(scanner.getTokenValue(), /*isSingleQuote*/ undefined, scanner.hasExtendedUnicodeEscape()) :
             isLiteralKind(kind) ? factory.createLiteralLikeNode(kind, scanner.getTokenValue()) :
             Debug.fail();
 
@@ -6408,8 +6414,8 @@ namespace Parser {
     function parsePrimaryExpression(): PrimaryExpression {
         switch (token()) {
             case SyntaxKind.NoSubstitutionTemplateLiteral:
-                if (scanner.getTokenFlags() & TokenFlags.ContainsOctalOrInvalidEscape) {
-                    reScanTemplateToken(/* isTaggedTemplate */ false);
+                if (scanner.getTokenFlags() & TokenFlags.ContainsInvalidEscape) {
+                    reScanTemplateHeadOrNoSubstitutionTemplate();
                 }
             // falls through
             case SyntaxKind.NumericLiteral:

src/compiler/program.ts

@@ -1297,7 +1297,6 @@ export const plainJSErrors: Set<number> = new Set([
     Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
     Diagnostics.Invalid_use_of_0_in_strict_mode.code,
     Diagnostics.A_label_is_not_allowed_here.code,
-    Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
     Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
     // grammar errors
     Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code,