Skip to content

Commit c642abe

Browse files
KingwlKingwl
committed
Merge branch 'Lift-Template-Literal-Restriction' of https://github.com/Kingwl/TypeScript into Lift-Template-Literal-Restriction
2 parents dbbcdae + 3932d20 commit c642abe

11 files changed

+84
-54
lines changed

‎src/compiler/parser.ts

Lines changed: 13 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1095,8 +1095,8 @@ namespace ts {
10951095
return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
10961096
}
10971097

1098-
function reScanTemplateHead(): SyntaxKind {
1099-
return currentToken = scanner.reScanTemplateHead();
1098+
function reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind {
1099+
return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
11001100
}
11011101

11021102
function scanJsxIdentifier(): SyntaxKind {
@@ -2168,6 +2168,13 @@ namespace ts {
21682168
return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
21692169
}
21702170

2171+
function parseNoSubstitutionTemplate(isTaggedTemplate?: boolean) {
2172+
if (isTaggedTemplate) {
2173+
reScanTemplateHeadOrNoSubstitutionTemplate();
2174+
}
2175+
return <NoSubstitutionTemplateLiteral>parseLiteralNode();
2176+
}
2177+
21712178
function parseTemplateExpression(isTaggedTemplate?: boolean): TemplateExpression {
21722179
const template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
21732180

@@ -2210,7 +2217,7 @@ namespace ts {
22102217

22112218
function parseTemplateHead(isTaggedTemplate?: boolean): TemplateHead {
22122219
if (isTaggedTemplate) {
2213-
reScanTemplateHead();
2220+
reScanTemplateHeadOrNoSubstitutionTemplate();
22142221
}
22152222
const fragment = parseLiteralLikeNode(token());
22162223
Debug.assert(fragment.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
@@ -2246,8 +2253,8 @@ namespace ts {
22462253
(<NumericLiteral>node).numericLiteralFlags = scanner.getTokenFlags() & TokenFlags.NumericLiteralFlags;
22472254
}
22482255

2249-
if (node.kind === SyntaxKind.TemplateHead || node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail) {
2250-
(<TemplateHead | TemplateMiddle | TemplateTail>node).notEscapeFlags = scanner.getTokenFlags() & TokenFlags.NotEscape;
2256+
if (isTemplateLiteralKind(node.kind)) {
2257+
(<TemplateHead | TemplateMiddle | TemplateTail | NoSubstitutionTemplateLiteral>node).templateFlags = scanner.getTokenFlags() & TokenFlags.ContainsInvalidEscape;
22512258
}
22522259

22532260
nextToken();
@@ -4498,7 +4505,7 @@ namespace ts {
44984505
tagExpression.tag = tag;
44994506
tagExpression.typeArguments = typeArguments;
45004507
tagExpression.template = token() === SyntaxKind.NoSubstitutionTemplateLiteral
4501-
? <NoSubstitutionTemplateLiteral>parseLiteralNode()
4508+
? parseNoSubstitutionTemplate(/*isTaggedTemplate*/ true)
45024509
: parseTemplateExpression(/*isTaggedTemplate*/ true);
45034510
return finishNode(tagExpression);
45044511
}

‎src/compiler/scanner.ts

Lines changed: 16 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ namespace ts {
2828
reScanGreaterToken(): SyntaxKind;
2929
reScanSlashToken(): SyntaxKind;
3030
reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
31-
reScanTemplateHead(): SyntaxKind;
31+
reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
3232
scanJsxIdentifier(): SyntaxKind;
3333
scanJsxAttributeValue(): SyntaxKind;
3434
reScanJsxToken(): JsxTokenSyntaxKind;
@@ -424,19 +424,17 @@ namespace ts {
424424
return ch >= CharacterCodes._0 && ch <= CharacterCodes._9;
425425
}
426426

427-
/* @internal */
428-
export function isOctalDigit(ch: number): boolean {
429-
return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
427+
function isHexDigit(ch: number): boolean {
428+
return isDigit(ch) || ch >= CharacterCodes.A && ch <= CharacterCodes.F || ch >= CharacterCodes.a && ch <= CharacterCodes.f;
430429
}
431430

432-
/* @internal */
433-
export function isHexDigit(ch: number): boolean {
434-
return isDigit(ch) || ch >= CharacterCodes.A && ch <= CharacterCodes.F || ch >= CharacterCodes.a && ch <= CharacterCodes.f;
431+
function isCodePoint(code: number): boolean {
432+
return code <= 0x10FFFF;
435433
}
436434

437435
/* @internal */
438-
export function isCodePoint(code: number): boolean {
439-
return code <= 0x10FFFF;
436+
export function isOctalDigit(ch: number): boolean {
437+
return ch >= CharacterCodes._0 && ch <= CharacterCodes._7;
440438
}
441439

442440
export function couldStartTrivia(text: string, pos: number): boolean {
@@ -852,7 +850,7 @@ namespace ts {
852850
reScanGreaterToken,
853851
reScanSlashToken,
854852
reScanTemplateToken,
855-
reScanTemplateHead,
853+
reScanTemplateHeadOrNoSubstitutionTemplate,
856854
scanJsxIdentifier,
857855
scanJsxAttributeValue,
858856
reScanJsxToken,
@@ -1150,7 +1148,7 @@ namespace ts {
11501148
// '\01'
11511149
if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
11521150
pos++;
1153-
tokenFlags |= TokenFlags.NotEscape;
1151+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
11541152
return text.substring(start, pos);
11551153
}
11561154
return "\0";
@@ -1174,15 +1172,15 @@ namespace ts {
11741172
if (isTaggedTemplate) {
11751173
// '\u'
11761174
if (pos < end && !isHexDigit(text.charCodeAt(pos)) && text.charCodeAt(pos) !== CharacterCodes.openBrace) {
1177-
tokenFlags |= TokenFlags.NotEscape;
1175+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
11781176
return text.substring(start, pos);
11791177
}
11801178

11811179
// '\u0' or '\u00' or '\u000'
11821180
for (let i = 0; i < 3; i++) {
11831181
if (pos + i + 1 < end && isHexDigit(text.charCodeAt(pos + i)) && !isHexDigit(text.charCodeAt(pos + i + 1)) && text.charCodeAt(pos + i + 1) !== CharacterCodes.openBrace) {
11841182
pos += i;
1185-
tokenFlags |= TokenFlags.NotEscape;
1183+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
11861184
return text.substring(start, pos);
11871185
}
11881186
}
@@ -1193,15 +1191,15 @@ namespace ts {
11931191

11941192
// '\u{'
11951193
if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
1196-
tokenFlags |= TokenFlags.NotEscape;
1194+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
11971195
return text.substring(start, pos);
11981196
}
11991197

12001198
const escapedValue = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false);
12011199
if (isTaggedTemplate) {
12021200
// '\u{Not Code Point' or '\u{CodePoint'
12031201
if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== CharacterCodes.closeBrace) {
1204-
tokenFlags |= TokenFlags.NotEscape;
1202+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
12051203
return text.substring(start, pos);
12061204
}
12071205
}
@@ -1215,12 +1213,12 @@ namespace ts {
12151213
case CharacterCodes.x:
12161214
if (isTaggedTemplate) {
12171215
if (!isHexDigit(text.charCodeAt(pos))) {
1218-
tokenFlags |= TokenFlags.NotEscape;
1216+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
12191217
return text.substring(start, pos);
12201218
}
12211219
else if (!isHexDigit(text.charCodeAt(pos + 1))) {
12221220
pos++;
1223-
tokenFlags |= TokenFlags.NotEscape;
1221+
tokenFlags |= TokenFlags.ContainsInvalidEscape;
12241222
return text.substring(start, pos);
12251223
}
12261224
}
@@ -1894,7 +1892,7 @@ namespace ts {
18941892
return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
18951893
}
18961894

1897-
function reScanTemplateHead(): SyntaxKind {
1895+
function reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind {
18981896
pos = tokenPos;
18991897
return token = scanTemplateAndSetTokenValue(/* isTaggedTemplate */ true);
19001898
}

‎src/compiler/transformers/es2015.ts

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3654,14 +3654,14 @@ namespace ts {
36543654
const rawStrings: Expression[] = [];
36553655
const template = node.template;
36563656
if (isNoSubstitutionTemplateLiteral(template)) {
3657-
cookedStrings.push(createLiteral(template.text));
3657+
cookedStrings.push(template.templateFlags ? createIdentifier("undefined") : createLiteral(template.text));
36583658
rawStrings.push(getRawLiteral(template));
36593659
}
36603660
else {
3661-
cookedStrings.push(template.head.notEscapeFlags ? createIdentifier("undefined") : createLiteral(template.head.text));
3661+
cookedStrings.push(template.head.templateFlags ? createIdentifier("undefined") : createLiteral(template.head.text));
36623662
rawStrings.push(getRawLiteral(template.head));
36633663
for (const templateSpan of template.templateSpans) {
3664-
cookedStrings.push(templateSpan.literal.notEscapeFlags ? createIdentifier("undefined") : createLiteral(templateSpan.literal.text));
3664+
cookedStrings.push(templateSpan.literal.templateFlags ? createIdentifier("undefined") : createLiteral(templateSpan.literal.text));
36653665
rawStrings.push(getRawLiteral(templateSpan.literal));
36663666
templateArguments.push(visitNode(templateSpan.expression, visitor, isExpression));
36673667
}

‎src/compiler/types.ts

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1582,6 +1582,8 @@ namespace ts {
15821582

15831583
export interface NoSubstitutionTemplateLiteral extends LiteralExpression {
15841584
kind: SyntaxKind.NoSubstitutionTemplateLiteral;
1585+
/* @internal */
1586+
templateFlags?: TokenFlags;
15851587
}
15861588

15871589
/* @internal */
@@ -1591,13 +1593,13 @@ namespace ts {
15911593
PrecedingJSDocComment = 1 << 1,
15921594
Unterminated = 1 << 2,
15931595
ExtendedUnicodeEscape = 1 << 3,
1594-
Scientific = 1 << 4, // e.g. `10e2`
1595-
Octal = 1 << 5, // e.g. `0777`
1596-
HexSpecifier = 1 << 6, // e.g. `0x00000000`
1597-
BinarySpecifier = 1 << 7, // e.g. `0b0110010000000000`
1598-
OctalSpecifier = 1 << 8, // e.g. `0o777`
1599-
ContainsSeparator = 1 << 9, // e.g. `0b1100_0101`
1600-
NotEscape = 1 << 10, // e.g. `\uhello`
1596+
Scientific = 1 << 4, // e.g. `10e2`
1597+
Octal = 1 << 5, // e.g. `0777`
1598+
HexSpecifier = 1 << 6, // e.g. `0x00000000`
1599+
BinarySpecifier = 1 << 7, // e.g. `0b0110010000000000`
1600+
OctalSpecifier = 1 << 8, // e.g. `0o777`
1601+
ContainsSeparator = 1 << 9, // e.g. `0b1100_0101`
1602+
ContainsInvalidEscape = 1 << 10, // e.g. `\uhello`
16011603
BinaryOrOctalSpecifier = BinarySpecifier | OctalSpecifier,
16021604
NumericLiteralFlags = Scientific | Octal | HexSpecifier | BinarySpecifier | OctalSpecifier | ContainsSeparator
16031605
}
@@ -1612,21 +1614,21 @@ namespace ts {
16121614
kind: SyntaxKind.TemplateHead;
16131615
parent: TemplateExpression;
16141616
/* @internal */
1615-
notEscapeFlags?: TokenFlags;
1617+
templateFlags?: TokenFlags;
16161618
}
16171619

16181620
export interface TemplateMiddle extends LiteralLikeNode {
16191621
kind: SyntaxKind.TemplateMiddle;
16201622
parent: TemplateSpan;
16211623
/* @internal */
1622-
notEscapeFlags?: TokenFlags;
1624+
templateFlags?: TokenFlags;
16231625
}
16241626

16251627
export interface TemplateTail extends LiteralLikeNode {
16261628
kind: SyntaxKind.TemplateTail;
16271629
parent: TemplateSpan;
16281630
/* @internal */
1629-
notEscapeFlags?: TokenFlags;
1631+
templateFlags?: TokenFlags;
16301632
}
16311633

16321634
export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;

‎tests/baselines/reference/api/tsserverlibrary.d.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3042,7 +3042,7 @@ declare namespace ts {
30423042
reScanGreaterToken(): SyntaxKind;
30433043
reScanSlashToken(): SyntaxKind;
30443044
reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
3045-
reScanTemplateHead(): SyntaxKind;
3045+
reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
30463046
scanJsxIdentifier(): SyntaxKind;
30473047
scanJsxAttributeValue(): SyntaxKind;
30483048
reScanJsxToken(): JsxTokenSyntaxKind;

‎tests/baselines/reference/api/typescript.d.ts

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3042,7 +3042,7 @@ declare namespace ts {
30423042
reScanGreaterToken(): SyntaxKind;
30433043
reScanSlashToken(): SyntaxKind;
30443044
reScanTemplateToken(isTaggedTemplate?: boolean): SyntaxKind;
3045-
reScanTemplateHead(): SyntaxKind;
3045+
reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
30463046
scanJsxIdentifier(): SyntaxKind;
30473047
scanJsxAttributeValue(): SyntaxKind;
30483048
reScanJsxToken(): JsxTokenSyntaxKind;

‎tests/baselines/reference/invalidTaggedTemplateEscapeSequences.errors.txt

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,12 @@ tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(5,18): er
22
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,15): error TS1125: Hexadecimal digit expected.
33
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,33): error TS1125: Hexadecimal digit expected.
44
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,75): error TS1125: Hexadecimal digit expected.
5+
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,18): error TS1125: Hexadecimal digit expected.
6+
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,27): error TS1125: Hexadecimal digit expected.
7+
tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(7,51): error TS1125: Hexadecimal digit expected.
58

69

7-
==== tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts (4 errors) ====
10+
==== tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts (7 errors) ====
811
function tag (str: any, ...args: any[]): string {
912
return str
1013
}
@@ -18,6 +21,13 @@ tests/cases/conformance/es2018/invalidTaggedTemplateEscapeSequences.ts(6,75): er
1821

1922
!!! error TS1125: Hexadecimal digit expected.
2023

24+
!!! error TS1125: Hexadecimal digit expected.
25+
const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
26+
27+
!!! error TS1125: Hexadecimal digit expected.
28+
29+
!!! error TS1125: Hexadecimal digit expected.
30+
2131
!!! error TS1125: Hexadecimal digit expected.
2232

2333
const a1 = tag`${ 100 }\0` // \0

‎tests/baselines/reference/invalidTaggedTemplateEscapeSequences.js

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ function tag (str: any, ...args: any[]): string {
55

66
const x = tag`\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
77
const y = `\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
8+
const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
89
910
const a1 = tag`${ 100 }\0` // \0
1011
const a2 = tag`${ 100 }\00` // \\00
@@ -36,6 +37,7 @@ function tag(str) {
3637
}
3738
var x = tag(__makeTemplateObject([undefined, undefined, " wonderful ", undefined], ["\\u{hello} ", " \\xtraordinary ", " wonderful ", " \\uworld"]), 100, 200, 300);
3839
var y = "hello} " + 100 + " traordinary " + 200 + " wonderful " + 300 + " world";
40+
var z = tag(__makeTemplateObject([undefined], ["\\u{hello} \\xtraordinary wonderful \\uworld"])); // should work with Tagged NoSubstitutionTemplate
3941
var a1 = tag(__makeTemplateObject(["", "\0"], ["", "\\0"]), 100); // \0
4042
var a2 = tag(__makeTemplateObject(["", undefined], ["", "\\00"]), 100); // \\00
4143
var a3 = tag(__makeTemplateObject(["", undefined], ["", "\\u"]), 100); // \\u

‎tests/baselines/reference/invalidTaggedTemplateEscapeSequences.symbols

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -15,59 +15,63 @@ const x = tag`\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uwor
1515
const y = `\u{hello} ${ 100 } \xtraordinary ${ 200 } wonderful ${ 300 } \uworld`;
1616
>y : Symbol(y, Decl(invalidTaggedTemplateEscapeSequences.ts, 5, 5))
1717

18+
const z = tag`\u{hello} \xtraordinary wonderful \uworld` // should work with Tagged NoSubstitutionTemplate
19+
>z : Symbol(z, Decl(invalidTaggedTemplateEscapeSequences.ts, 6, 5))
20+
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
21+
1822
const a1 = tag`${ 100 }\0` // \0
19-
>a1 : Symbol(a1, Decl(invalidTaggedTemplateEscapeSequences.ts, 7, 5))
23+
>a1 : Symbol(a1, Decl(invalidTaggedTemplateEscapeSequences.ts, 8, 5))
2024
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
2125

2226
const a2 = tag`${ 100 }\00` // \\00
23-
>a2 : Symbol(a2, Decl(invalidTaggedTemplateEscapeSequences.ts, 8, 5))
27+
>a2 : Symbol(a2, Decl(invalidTaggedTemplateEscapeSequences.ts, 9, 5))
2428
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
2529

2630
const a3 = tag`${ 100 }\u` // \\u
27-
>a3 : Symbol(a3, Decl(invalidTaggedTemplateEscapeSequences.ts, 9, 5))
31+
>a3 : Symbol(a3, Decl(invalidTaggedTemplateEscapeSequences.ts, 10, 5))
2832
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
2933

3034
const a4 = tag`${ 100 }\u0` // \\u0
31-
>a4 : Symbol(a4, Decl(invalidTaggedTemplateEscapeSequences.ts, 10, 5))
35+
>a4 : Symbol(a4, Decl(invalidTaggedTemplateEscapeSequences.ts, 11, 5))
3236
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
3337

3438
const a5 = tag`${ 100 }\u00` // \\u00
35-
>a5 : Symbol(a5, Decl(invalidTaggedTemplateEscapeSequences.ts, 11, 5))
39+
>a5 : Symbol(a5, Decl(invalidTaggedTemplateEscapeSequences.ts, 12, 5))
3640
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
3741

3842
const a6 = tag`${ 100 }\u000` // \\u000
39-
>a6 : Symbol(a6, Decl(invalidTaggedTemplateEscapeSequences.ts, 12, 5))
43+
>a6 : Symbol(a6, Decl(invalidTaggedTemplateEscapeSequences.ts, 13, 5))
4044
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
4145

4246
const a7 = tag`${ 100 }\u0000` // \u0000
43-
>a7 : Symbol(a7, Decl(invalidTaggedTemplateEscapeSequences.ts, 13, 5))
47+
>a7 : Symbol(a7, Decl(invalidTaggedTemplateEscapeSequences.ts, 14, 5))
4448
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
4549

4650
const a8 = tag`${ 100 }\u{` // \\u{
47-
>a8 : Symbol(a8, Decl(invalidTaggedTemplateEscapeSequences.ts, 14, 5))
51+
>a8 : Symbol(a8, Decl(invalidTaggedTemplateEscapeSequences.ts, 15, 5))
4852
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
4953

5054
const a9 = tag`${ 100 }\u{10FFFF}` // \\u{10FFFF
51-
>a9 : Symbol(a9, Decl(invalidTaggedTemplateEscapeSequences.ts, 15, 5))
55+
>a9 : Symbol(a9, Decl(invalidTaggedTemplateEscapeSequences.ts, 16, 5))
5256
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
5357

5458
const a10 = tag`${ 100 }\u{1f622` // \\u{1f622
55-
>a10 : Symbol(a10, Decl(invalidTaggedTemplateEscapeSequences.ts, 16, 5))
59+
>a10 : Symbol(a10, Decl(invalidTaggedTemplateEscapeSequences.ts, 17, 5))
5660
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
5761

5862
const a11 = tag`${ 100 }\u{1f622}` // \u{1f622}
59-
>a11 : Symbol(a11, Decl(invalidTaggedTemplateEscapeSequences.ts, 17, 5))
63+
>a11 : Symbol(a11, Decl(invalidTaggedTemplateEscapeSequences.ts, 18, 5))
6064
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
6165

6266
const a12 = tag`${ 100 }\x` // \\x
63-
>a12 : Symbol(a12, Decl(invalidTaggedTemplateEscapeSequences.ts, 18, 5))
67+
>a12 : Symbol(a12, Decl(invalidTaggedTemplateEscapeSequences.ts, 19, 5))
6468
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
6569

6670
const a13 = tag`${ 100 }\x0` // \\x0
67-
>a13 : Symbol(a13, Decl(invalidTaggedTemplateEscapeSequences.ts, 19, 5))
71+
>a13 : Symbol(a13, Decl(invalidTaggedTemplateEscapeSequences.ts, 20, 5))
6872
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
6973

7074
const a14 = tag`${ 100 }\x00` // \x00
71-
>a14 : Symbol(a14, Decl(invalidTaggedTemplateEscapeSequences.ts, 20, 5))
75+
>a14 : Symbol(a14, Decl(invalidTaggedTemplateEscapeSequences.ts, 21, 5))
7276
>tag : Symbol(tag, Decl(invalidTaggedTemplateEscapeSequences.ts, 0, 0))
7377

0 commit comments

Comments
 (0)