microsoft · sandersn · Feb 5, 2020 · May 1, 2018 · May 1, 2018 · May 2, 2018
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -1095,8 +1095,8 @@ namespace ts {
             return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
         }
 
-        function reScanTemplateHead(): SyntaxKind {
-            return currentToken = scanner.reScanTemplateHead();
+        function reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind {
+            return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
         }
 
         function scanJsxIdentifier(): SyntaxKind {
@@ -2168,6 +2168,13 @@ namespace ts {
             return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
         }
 
+        function parseNoSubstitutionTemplate(isTaggedTemplate?: boolean) {
+            if (isTaggedTemplate) {
+                reScanTemplateHeadOrNoSubstitutionTemplate();
+            }
+            return <NoSubstitutionTemplateLiteral>parseLiteralNode();
+        }
+
         function parseTemplateExpression(isTaggedTemplate?: boolean): TemplateExpression {
             const template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
 
@@ -2210,7 +2217,7 @@ namespace ts {
 
         function parseTemplateHead(isTaggedTemplate?: boolean): TemplateHead {
             if (isTaggedTemplate) {
-                reScanTemplateHead();
+                reScanTemplateHeadOrNoSubstitutionTemplate();
             }
             const fragment = parseLiteralLikeNode(token());
             Debug.assert(fragment.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
@@ -2246,8 +2253,8 @@ namespace ts {
                 (<NumericLiteral>node).numericLiteralFlags = scanner.getTokenFlags() & TokenFlags.NumericLiteralFlags;
             }
 
-            if (node.kind === SyntaxKind.TemplateHead || node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail) {
-                (<TemplateHead | TemplateMiddle | TemplateTail>node).notEscapeFlags = scanner.getTokenFlags() & TokenFlags.NotEscape;
+            if (isTemplateLiteralKind(node.kind)) {
+                (<TemplateHead | TemplateMiddle | TemplateTail | NoSubstitutionTemplateLiteral>node).templateFlags = scanner.getTokenFlags() & TokenFlags.ContainsInvalidEscape;
             }
 
             nextToken();
@@ -4498,7 +4505,7 @@ namespace ts {
             tagExpression.tag = tag;
             tagExpression.typeArguments = typeArguments;
             tagExpression.template = token() === SyntaxKind.NoSubstitutionTemplateLiteral
-                ? <NoSubstitutionTemplateLiteral>parseLiteralNode()
+                ? parseNoSubstitutionTemplate(/*isTaggedTemplate*/ true)
                 : parseTemplateExpression(/*isTaggedTemplate*/ true);
             return finishNode(tagExpression);
         }

diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
@@ -28,7 +28,7 @@ namespace ts {
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
         reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
-        reScanTemplateHead(): SyntaxKind;
+        reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
         scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): JsxTokenSyntaxKind;
@@ -424,19 +424,17 @@ namespace ts {
           return ch >= CharacterCodes._0 && ch <= CharacterCodes._9;
       }
 
-      /* @internal */
-      export function isOctalDigit(ch: number): boolean {
-          return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
+      function isHexDigit(ch: number): boolean {
+        return isDigit(ch) || ch >= CharacterCodes.A && ch <= CharacterCodes.F || ch >= CharacterCodes.a && ch <= CharacterCodes.f;
       }
 
-      /* @internal */
-      export function isHexDigit(ch: number): boolean {
-          return isDigit(ch) || ch >= CharacterCodes.A && ch <= CharacterCodes.F || ch >= CharacterCodes.a && ch <= CharacterCodes.f;
+      function isCodePoint(code: number): boolean {
+        return code <= 0x10FFFF;
       }
 
       /* @internal */
-      export function isCodePoint(code: number): boolean {
-          return code <= 0x10FFFF;
+      export function isOctalDigit(ch: number): boolean {
+          return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
       }
 
       export function couldStartTrivia(text: string, pos: number): boolean {
@@ -852,7 +850,7 @@ namespace ts {
             reScanGreaterToken,
             reScanSlashToken,
             reScanTemplateToken,
-            reScanTemplateHead,
+            reScanTemplateHeadOrNoSubstitutionTemplate,
             scanJsxIdentifier,
             scanJsxAttributeValue,
             reScanJsxToken,
@@ -1150,7 +1148,7 @@ namespace ts {
                     // '\01'
                     if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
                         pos++;
-                        tokenFlags |= TokenFlags.NotEscape;
+                        tokenFlags |= TokenFlags.ContainsInvalidEscape;
                         return text.substring(start, pos);
                     }
                     return "\0";
@@ -1174,15 +1172,15 @@ namespace ts {
                     if (isTaggedTemplate) {
                         // '\u'
                         if (pos < end && !isHexDigit(text.charCodeAt(pos)) && text.charCodeAt(pos) !== CharacterCodes.openBrace) {
-                            tokenFlags |= TokenFlags.NotEscape;
+                            tokenFlags |= TokenFlags.ContainsInvalidEscape;
                             return text.substring(start, pos);
                         }
 
                         // '\u0' or '\u00' or '\u000'
                         for (let i = 0; i < 3; i++) {
                             if (pos + i + 1 < end && isHexDigit(text.charCodeAt(pos + i)) &&  !isHexDigit(text.charCodeAt(pos + i + 1)) && text.charCodeAt(pos + i + 1) !== CharacterCodes.openBrace) {
                                 pos += i;
-                                tokenFlags |= TokenFlags.NotEscape;
+                                tokenFlags |= TokenFlags.ContainsInvalidEscape;
                                 return text.substring(start, pos);
                             }
                         }
@@ -1193,15 +1191,15 @@ namespace ts {
 
                         // '\u{'
                         if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
-                            tokenFlags |= TokenFlags.NotEscape;
+                            tokenFlags |= TokenFlags.ContainsInvalidEscape;
                             return text.substring(start, pos);
                         }
 
                         const escapedValue = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false);
                         if (isTaggedTemplate) {
                             // '\u{Not Code Point' or '\u{CodePoint'
                             if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== CharacterCodes.closeBrace) {
-                                tokenFlags |= TokenFlags.NotEscape;
+                                tokenFlags |= TokenFlags.ContainsInvalidEscape;
                                 return text.substring(start, pos);
                             }
                         }
@@ -1215,12 +1213,12 @@ namespace ts {
                 case CharacterCodes.x:
                     if (isTaggedTemplate) {
                         if (!isHexDigit(text.charCodeAt(pos))) {
-                            tokenFlags |= TokenFlags.NotEscape;
+                            tokenFlags |= TokenFlags.ContainsInvalidEscape;
                             return text.substring(start, pos);
                         }
                         else if (!isHexDigit(text.charCodeAt(pos + 1))) {
                             pos++;
-                            tokenFlags |= TokenFlags.NotEscape;
+                            tokenFlags |= TokenFlags.ContainsInvalidEscape;
                             return text.substring(start, pos);
                         }
                     }
@@ -1894,7 +1892,7 @@ namespace ts {
             return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
         }
 
-        function reScanTemplateHead(): SyntaxKind {
+        function reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind {
             pos = tokenPos;
             return token = scanTemplateAndSetTokenValue(/* isTaggedTemplate */ true);
         }

diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
@@ -3654,14 +3654,14 @@ namespace ts {
             const rawStrings: Expression[] = [];
             const template = node.template;
             if (isNoSubstitutionTemplateLiteral(template)) {
-                cookedStrings.push(createLiteral(template.text));
+                cookedStrings.push(template.templateFlags ? createIdentifier("undefined") : createLiteral(template.text));
                 rawStrings.push(getRawLiteral(template));
             }
             else {
-                cookedStrings.push(template.head.notEscapeFlags ? createIdentifier("undefined") : createLiteral(template.head.text));
+                cookedStrings.push(template.head.templateFlags ? createIdentifier("undefined") : createLiteral(template.head.text));
                 rawStrings.push(getRawLiteral(template.head));
                 for (const templateSpan of template.templateSpans) {
-                    cookedStrings.push(templateSpan.literal.notEscapeFlags ? createIdentifier("undefined") : createLiteral(templateSpan.literal.text));
+                    cookedStrings.push(templateSpan.literal.templateFlags ? createIdentifier("undefined") : createLiteral(templateSpan.literal.text));
                     rawStrings.push(getRawLiteral(templateSpan.literal));
                     templateArguments.push(visitNode(templateSpan.expression, visitor, isExpression));
                 }

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1582,6 +1582,8 @@ namespace ts {
 
     export interface NoSubstitutionTemplateLiteral extends LiteralExpression {
         kind: SyntaxKind.NoSubstitutionTemplateLiteral;
+        /* @internal */
+        templateFlags?: TokenFlags;
     }
 
     /* @internal */
@@ -1591,13 +1593,13 @@ namespace ts {
         PrecedingJSDocComment = 1 << 1,
         Unterminated = 1 << 2,
         ExtendedUnicodeEscape = 1 << 3,
-        Scientific = 1 << 4,        // e.g. `10e2`
-        Octal = 1 << 5,             // e.g. `0777`
-        HexSpecifier = 1 << 6,      // e.g. `0x00000000`
-        BinarySpecifier = 1 << 7,   // e.g. `0b0110010000000000`
-        OctalSpecifier = 1 << 8,    // e.g. `0o777`
-        ContainsSeparator = 1 << 9, // e.g. `0b1100_0101`
-        NotEscape = 1 << 10,        // e.g. `\uhello`
+        Scientific = 1 << 4,                // e.g. `10e2`
+        Octal = 1 << 5,                     // e.g. `0777`
+        HexSpecifier = 1 << 6,              // e.g. `0x00000000`
+        BinarySpecifier = 1 << 7,           // e.g. `0b0110010000000000`
+        OctalSpecifier = 1 << 8,            // e.g. `0o777`
+        ContainsSeparator = 1 << 9,         // e.g. `0b1100_0101`
+        ContainsInvalidEscape = 1 << 10,    // e.g. `\uhello`
         BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier,
         NumericLiteralFlags = Scientific | Octal | HexSpecifier | BinarySpecifier | OctalSpecifier | ContainsSeparator
     }
@@ -1612,21 +1614,21 @@ namespace ts {
         kind: SyntaxKind.TemplateHead;
         parent: TemplateExpression;
         /* @internal */
-        notEscapeFlags?: TokenFlags;
+        templateFlags?: TokenFlags;
     }
 
     export interface TemplateMiddle extends LiteralLikeNode {
         kind: SyntaxKind.TemplateMiddle;
         parent: TemplateSpan;
         /* @internal */
-        notEscapeFlags?: TokenFlags;
+        templateFlags?: TokenFlags;
     }
 
     export interface TemplateTail extends LiteralLikeNode {
         kind: SyntaxKind.TemplateTail;
         parent: TemplateSpan;
         /* @internal */
-        notEscapeFlags?: TokenFlags;
+        templateFlags?: TokenFlags;
     }
 
     export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;

diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -3042,7 +3042,7 @@ declare namespace ts {
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
         reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
-        reScanTemplateHead(): SyntaxKind;
+        reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
         scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): JsxTokenSyntaxKind;

diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -3042,7 +3042,7 @@ declare namespace ts {
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
         reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
-        reScanTemplateHead(): SyntaxKind;
+        reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
         scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): JsxTokenSyntaxKind;

diff --git a/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.errors.txt b/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.errors.txt
@@ -2,9 +2,12 @@ tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(5,18): er
 tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,15): error TS1125: Hexadecimal digit expected.
 tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,33): error TS1125: Hexadecimal digit expected.
 tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,75): error TS1125: Hexadecimal digit expected.
+tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,18): error TS1125: Hexadecimal digit expected.
+tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,27): error TS1125: Hexadecimal digit expected.
+tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,51): error TS1125: Hexadecimal digit expected.
 
 
-==== tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts (4 errors) ====
+==== tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts (7 errors) ====
     function tag (str: any, ...args: any[]): string {
       return str
     }
@@ -18,6 +21,13 @@ tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,75): er
 
 !!! error TS1125: Hexadecimal digit expected.
 
+!!! error TS1125: Hexadecimal digit expected.
+    const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
+
+!!! error TS1125: Hexadecimal digit expected.
+
+!!! error TS1125: Hexadecimal digit expected.
+
 !!! error TS1125: Hexadecimal digit expected.
 
     const a1 = tag`${ 100 }\0` // \0

diff --git a/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.js b/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.js
@@ -5,6 +5,7 @@ function tag (str: any, ...args: any[]): string {
 
 const x = tag`\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
 const y = `\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
+const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
 
 const a1 = tag`${ 100 }\0` // \0
 const a2 = tag`${ 100 }\00` // \\00
@@ -36,6 +37,7 @@ function tag(str) {
 }
 var x = tag(__makeTemplateObject([undefined, undefined, " wonderful ", undefined], ["\\u{hello} ", " \\xtraordinary ", " wonderful ", " \\uworld"]), 100, 200, 300);
 var y = "hello} " + 100 + " traordinary " + 200 + " wonderful " + 300 + " world";
+var z = tag(__makeTemplateObject([undefined], ["\\u{hello} \\xtraordinary wonderful \\uworld"])); // should work with Tagged NoSubstitutionTemplate
 var a1 = tag(__makeTemplateObject(["", "\0"], ["", "\\0"]), 100); // \0
 var a2 = tag(__makeTemplateObject(["", undefined], ["", "\\00"]), 100); // \\00
 var a3 = tag(__makeTemplateObject(["", undefined], ["", "\\u"]), 100); // \\u

diff --git a/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.symbols b/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.symbols
@@ -15,59 +15,63 @@ const x = tag`\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uwor
 const y = `\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
 >y : Symbol(y, Decl(invalidTaggedTemplateEscapeSequences.ts, 5, 5))
 
+const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
+>z : Symbol(z, Decl(invalidTaggedTemplateEscapeSequences.ts, 6, 5))
+>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
+
 const a1 = tag`${ 100 }\0` // \0
->a1 : Symbol(a1, Decl(invalidTaggedTemplateEscapeSequences.ts, 7, 5))
+>a1 : Symbol(a1, Decl(invalidTaggedTemplateEscapeSequences.ts, 8, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a2 = tag`${ 100 }\00` // \\00
->a2 : Symbol(a2, Decl(invalidTaggedTemplateEscapeSequences.ts, 8, 5))
+>a2 : Symbol(a2, Decl(invalidTaggedTemplateEscapeSequences.ts, 9, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a3 = tag`${ 100 }\u` // \\u
->a3 : Symbol(a3, Decl(invalidTaggedTemplateEscapeSequences.ts, 9, 5))
+>a3 : Symbol(a3, Decl(invalidTaggedTemplateEscapeSequences.ts, 10, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a4 = tag`${ 100 }\u0` // \\u0
->a4 : Symbol(a4, Decl(invalidTaggedTemplateEscapeSequences.ts, 10, 5))
+>a4 : Symbol(a4, Decl(invalidTaggedTemplateEscapeSequences.ts, 11, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a5 = tag`${ 100 }\u00` // \\u00
->a5 : Symbol(a5, Decl(invalidTaggedTemplateEscapeSequences.ts, 11, 5))
+>a5 : Symbol(a5, Decl(invalidTaggedTemplateEscapeSequences.ts, 12, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a6 = tag`${ 100 }\u000` // \\u000
->a6 : Symbol(a6, Decl(invalidTaggedTemplateEscapeSequences.ts, 12, 5))
+>a6 : Symbol(a6, Decl(invalidTaggedTemplateEscapeSequences.ts, 13, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a7 = tag`${ 100 }\u0000` // \u0000
->a7 : Symbol(a7, Decl(invalidTaggedTemplateEscapeSequences.ts, 13, 5))
+>a7 : Symbol(a7, Decl(invalidTaggedTemplateEscapeSequences.ts, 14, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a8 = tag`${ 100 }\u{` // \\u{
->a8 : Symbol(a8, Decl(invalidTaggedTemplateEscapeSequences.ts, 14, 5))
+>a8 : Symbol(a8, Decl(invalidTaggedTemplateEscapeSequences.ts, 15, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a9 = tag`${ 100 }\u{10FFFF}` // \\u{10FFFF
->a9 : Symbol(a9, Decl(invalidTaggedTemplateEscapeSequences.ts, 15, 5))
+>a9 : Symbol(a9, Decl(invalidTaggedTemplateEscapeSequences.ts, 16, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a10 = tag`${ 100 }\u{1f622` // \\u{1f622
->a10 : Symbol(a10, Decl(invalidTaggedTemplateEscapeSequences.ts, 16, 5))
+>a10 : Symbol(a10, Decl(invalidTaggedTemplateEscapeSequences.ts, 17, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a11 = tag`${ 100 }\u{1f622}` // \u{1f622}
->a11 : Symbol(a11, Decl(invalidTaggedTemplateEscapeSequences.ts, 17, 5))
+>a11 : Symbol(a11, Decl(invalidTaggedTemplateEscapeSequences.ts, 18, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a12 = tag`${ 100 }\x` // \\x
->a12 : Symbol(a12, Decl(invalidTaggedTemplateEscapeSequences.ts, 18, 5))
+>a12 : Symbol(a12, Decl(invalidTaggedTemplateEscapeSequences.ts, 19, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a13 = tag`${ 100 }\x0` // \\x0
->a13 : Symbol(a13, Decl(invalidTaggedTemplateEscapeSequences.ts, 19, 5))
+>a13 : Symbol(a13, Decl(invalidTaggedTemplateEscapeSequences.ts, 20, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
 
 const a14 = tag`${ 100 }\x00` // \x00
->a14 : Symbol(a14, Decl(invalidTaggedTemplateEscapeSequences.ts, 20, 5))
+>a14 : Symbol(a14, Decl(invalidTaggedTemplateEscapeSequences.ts, 21, 5))
 >tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))