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
@@ -1034,8 +1034,12 @@ namespace ts {
             return currentToken = scanner.reScanSlashToken();
         }
 
-        function reScanTemplateToken(): SyntaxKind {
-            return currentToken = scanner.reScanTemplateToken();
+        function reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind {
+            return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
+        }
+
+        function reScanTemplateHead(): SyntaxKind {
+            return currentToken = scanner.reScanTemplateHead();
         }
 
         function scanJsxIdentifier(): SyntaxKind {
@@ -2104,17 +2108,17 @@ namespace ts {
             return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
         }
 
-        function parseTemplateExpression(): TemplateExpression {
+        function parseTemplateExpression(isTaggedTemplate?: boolean): TemplateExpression {
             const template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
 
-            template.head = parseTemplateHead();
+            template.head = parseTemplateHead(isTaggedTemplate);
             Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
 
             const list = [];
             const listPos = getNodePos();
 
             do {
-                list.push(parseTemplateSpan());
+                list.push(parseTemplateSpan(isTaggedTemplate));
             }
             while (lastOrUndefined(list).literal.kind === SyntaxKind.TemplateMiddle);
 
@@ -2123,13 +2127,13 @@ namespace ts {
             return finishNode(template);
         }
 
-        function parseTemplateSpan(): TemplateSpan {
+        function parseTemplateSpan(isTaggedTemplate?: boolean): TemplateSpan {
             const span = <TemplateSpan>createNode(SyntaxKind.TemplateSpan);
             span.expression = allowInAnd(parseExpression);
 
             let literal: TemplateMiddle | TemplateTail;
             if (token() === SyntaxKind.CloseBraceToken) {
-                reScanTemplateToken();
+                reScanTemplateToken(isTaggedTemplate);
                 literal = parseTemplateMiddleOrTemplateTail();
             }
             else {
@@ -2144,7 +2148,10 @@ namespace ts {
             return <LiteralExpression>parseLiteralLikeNode(token());
         }
 
-        function parseTemplateHead(): TemplateHead {
+        function parseTemplateHead(isTaggedTemplate?: boolean): TemplateHead {
+            if (isTaggedTemplate) {
+                reScanTemplateHead();
+            }
             const fragment = parseLiteralLikeNode(token());
             Debug.assert(fragment.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
             return <TemplateHead>fragment;
@@ -2157,7 +2164,7 @@ namespace ts {
         }
 
         function parseLiteralLikeNode(kind: SyntaxKind): LiteralExpression | LiteralLikeNode {
-            const node = <LiteralExpression>createNode(kind);
+            const node = <LiteralExpression | LiteralLikeNode>createNode(kind);
             const text = scanner.getTokenValue();
             node.text = text;
 
@@ -2179,6 +2186,10 @@ 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;
+            }
+
             nextToken();
             finishNode(node);
 
@@ -4414,7 +4425,7 @@ namespace ts {
             tagExpression.typeArguments = typeArguments;
             tagExpression.template = token() === SyntaxKind.NoSubstitutionTemplateLiteral
                 ? <NoSubstitutionTemplateLiteral>parseLiteralNode()
-                : parseTemplateExpression();
+                : parseTemplateExpression(/*isTaggedTemplate*/ true);
             return finishNode(tagExpression);
         }
 

diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
@@ -27,7 +27,8 @@ namespace ts {
         getTokenFlags(): TokenFlags;
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
-        reScanTemplateToken(): SyntaxKind;
+        reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
+        reScanTemplateHead(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
         scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): JsxTokenSyntaxKind;
@@ -428,6 +429,16 @@ namespace ts {
           return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
       }
 
+      /* @internal */
+      export function isHexDigit(ch: number): boolean {
+          return isDigit(ch) || ch >= CharacterCodes.A && ch <= CharacterCodes.F || ch >= CharacterCodes.a && ch <= CharacterCodes.f;
+      }
+
+      /* @internal */
+      export function isCodePoint(code: number): boolean {
+          return code <= 0x10FFFF;
+      }
+
       export function couldStartTrivia(text: string, pos: number): boolean {
           // Keep in sync with skipTrivia
           const ch = text.charCodeAt(pos);
@@ -838,6 +849,7 @@ namespace ts {
             reScanGreaterToken,
             reScanSlashToken,
             reScanTemplateToken,
+            reScanTemplateHead,
             scanJsxIdentifier,
             scanJsxAttributeValue,
             reScanJsxToken,
@@ -1054,7 +1066,7 @@ namespace ts {
          * Sets the current 'tokenValue' and returns a NoSubstitutionTemplateLiteral or
          * a literal component of a TemplateExpression.
          */
-        function scanTemplateAndSetTokenValue(): SyntaxKind {
+        function scanTemplateAndSetTokenValue(isTaggedTemplate?: boolean): SyntaxKind {
             const startedWithBacktick = text.charCodeAt(pos) === CharacterCodes.backtick;
 
             pos++;
@@ -1092,7 +1104,7 @@ namespace ts {
                 // Escape character
                 if (currChar === CharacterCodes.backslash) {
                     contents += text.substring(start, pos);
-                    contents += scanEscapeSequence();
+                    contents += scanEscapeSequence(isTaggedTemplate);
                     start = pos;
                     continue;
                 }
@@ -1121,7 +1133,8 @@ namespace ts {
             return resultingToken;
         }
 
-        function scanEscapeSequence(): string {
+        function scanEscapeSequence(isTaggedTemplate?: boolean): string {
+            const start = pos;
             pos++;
             if (pos >= end) {
                 error(Diagnostics.Unexpected_end_of_text);
@@ -1131,6 +1144,12 @@ namespace ts {
             pos++;
             switch (ch) {
                 case CharacterCodes._0:
+                    // '\01'
+                    if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
+                        pos++;
+                        tokenFlags |= TokenFlags.NotEscape;
+                        return text.substring(start, pos);
+                    }
                     return "\0";
                 case CharacterCodes.b:
                     return "\b";
@@ -1149,17 +1168,59 @@ namespace ts {
                 case CharacterCodes.doubleQuote:
                     return "\"";
                 case CharacterCodes.u:
+                    if (isTaggedTemplate) {
+                        // '\u'
+                        if (pos < end && !isHexDigit(text.charCodeAt(pos)) && text.charCodeAt(pos) !== CharacterCodes.openBrace) {
+                            tokenFlags |= TokenFlags.NotEscape;
+                            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;
+                                return text.substring(start, pos);
+                            }
+                        }
+                    }
                     // '\u{DDDDDDDD}'
                     if (pos < end && text.charCodeAt(pos) === CharacterCodes.openBrace) {
-                        tokenFlags |= TokenFlags.ExtendedUnicodeEscape;
                         pos++;
-                        return scanExtendedUnicodeEscape();
+
+                        // '\u{'
+                        if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
+                            tokenFlags |= TokenFlags.NotEscape;
+                            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;
+                                return text.substring(start, pos);
+                            }
+                        }
+                        tokenFlags |= TokenFlags.ExtendedUnicodeEscape;
+                        return scanExtendedUnicodeEscape(escapedValue);
                     }
 
                     // '\uDDDD'
                     return scanHexadecimalEscape(/*numDigits*/ 4);
 
                 case CharacterCodes.x:
+                    if (isTaggedTemplate) {
+                        if (!isHexDigit(text.charCodeAt(pos))) {
+                            tokenFlags |= TokenFlags.NotEscape;
+                            return text.substring(start, pos);
+                        }
+                        else if (!isHexDigit(text.charCodeAt(pos + 1))) {
+                            pos++;
+                            tokenFlags |= TokenFlags.NotEscape;
+                            return text.substring(start, pos);
+                        }
+                    }
                     // '\xDD'
                     return scanHexadecimalEscape(/*numDigits*/ 2);
 
@@ -1191,8 +1252,7 @@ namespace ts {
             }
         }
 
-        function scanExtendedUnicodeEscape(): string {
-            const escapedValue = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false);
+        function scanExtendedUnicodeEscape(escapedValue: number): string {
             let isInvalidExtendedEscape = false;
 
             // Validate the value of the digit
@@ -1825,10 +1885,15 @@ namespace ts {
         /**
          * Unconditionally back up and scan a template expression portion.
          */
-        function reScanTemplateToken(): SyntaxKind {
+        function reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind {
             Debug.assert(token === SyntaxKind.CloseBraceToken, "'reScanTemplateToken' should only be called on a '}'");
             pos = tokenPos;
-            return token = scanTemplateAndSetTokenValue();
+            return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
+        }
+
+        function reScanTemplateHead(): SyntaxKind {
+            pos = tokenPos;
+            return token = scanTemplateAndSetTokenValue(/* isTaggedTemplate */ true);
         }
 
         function reScanJsxToken(): JsxTokenSyntaxKind {

diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
@@ -3656,10 +3656,10 @@ namespace ts {
                 rawStrings.push(getRawLiteral(template));
             }
             else {
-                cookedStrings.push(createLiteral(template.head.text));
+                cookedStrings.push(template.head.notEscapeFlags ? createIdentifier("undefined") : createLiteral(template.head.text));
                 rawStrings.push(getRawLiteral(template.head));
                 for (const templateSpan of template.templateSpans) {
-                    cookedStrings.push(createLiteral(templateSpan.literal.text));
+                    cookedStrings.push(templateSpan.literal.notEscapeFlags ? 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
@@ -1593,6 +1593,7 @@ namespace ts {
         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`
         BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier,
         NumericLiteralFlags = Scientific | Octal | HexSpecifier | BinarySpecifier | OctalSpecifier | ContainsSeparator
     }
@@ -1606,16 +1607,22 @@ namespace ts {
     export interface TemplateHead extends LiteralLikeNode {
         kind: SyntaxKind.TemplateHead;
         parent?: TemplateExpression;
+        /* @internal */
+        notEscapeFlags?: TokenFlags;
     }
 
     export interface TemplateMiddle extends LiteralLikeNode {
         kind: SyntaxKind.TemplateMiddle;
         parent?: TemplateSpan;
+        /* @internal */
+        notEscapeFlags?: TokenFlags;
     }
 
     export interface TemplateTail extends LiteralLikeNode {
         kind: SyntaxKind.TemplateTail;
         parent?: TemplateSpan;
+        /* @internal */
+        notEscapeFlags?: TokenFlags;
     }
 
     export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;

diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2953,7 +2953,8 @@ declare namespace ts {
         isUnterminated(): boolean;
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
-        reScanTemplateToken(): SyntaxKind;
+        reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
+        reScanTemplateHead(): 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
@@ -2953,7 +2953,8 @@ declare namespace ts {
         isUnterminated(): boolean;
         reScanGreaterToken(): SyntaxKind;
         reScanSlashToken(): SyntaxKind;
-        reScanTemplateToken(): SyntaxKind;
+        reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
+        reScanTemplateHead(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
         scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): JsxTokenSyntaxKind;

diff --git a/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.errors.txt b/tests/baselines/reference/invalidTaggedTemplateEscapeSequences.errors.txt
@@ -0,0 +1,37 @@
+tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(5,18): error TS1125: Hexadecimal digit expected.
+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 (4 errors) ====
+    function tag (str: any, ...args: any[]): string {
+      return str
+    }
+
+    const x = tag`\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
+
+!!! error TS1125: Hexadecimal digit expected.
+    const y = `\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
+
+!!! error TS1125: Hexadecimal digit expected.
+
+!!! error TS1125: Hexadecimal digit expected.
+
+!!! error TS1125: Hexadecimal digit expected.
+
+    const a1 = tag`${ 100 }\0` // \0
+    const a2 = tag`${ 100 }\00` // \\00
+    const a3 = tag`${ 100 }\u` // \\u
+    const a4 = tag`${ 100 }\u0` // \\u0
+    const a5 = tag`${ 100 }\u00` // \\u00
+    const a6 = tag`${ 100 }\u000` // \\u000
+    const a7 = tag`${ 100 }\u0000` // \u0000
+    const a8 = tag`${ 100 }\u{` // \\u{
+    const a9 = tag`${ 100 }\u{10FFFF}` // \\u{10FFFF
+    const a10 = tag`${ 100 }\u{1f622` // \\u{1f622
+    const a11 = tag`${ 100 }\u{1f622}` // \u{1f622}
+    const a12 = tag`${ 100 }\x` // \\x
+    const a13 = tag`${ 100 }\x0` // \\x0
+    const a14 = tag`${ 100 }\x00` // \x00
+