microsoft
diff --git a/‎src/compiler/binder.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎src/compiler/binder.ts
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
-5Lines changed: 0 additions & 5 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
-5Lines changed: 0 additions & 5 deletions
diff --git a/‎src/compiler/diagnosticInformationMap.generated.ts
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎src/compiler/diagnosticInformationMap.generated.ts
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
-4Lines changed: 0 additions & 4 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
-4Lines changed: 0 additions & 4 deletions
diff --git a/‎src/compiler/emitter.ts
Copy file name to clipboard
+80-8Lines changed: 80 additions & 8 deletions b/‎src/compiler/emitter.ts
Copy file name to clipboard
+80-8Lines changed: 80 additions & 8 deletions
diff --git a/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapes.js
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions b/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapes.js
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions
diff --git a/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapes.types
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions b/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapes.types
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions
diff --git a/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapesES6.js
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions b/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapesES6.js
Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
diff --git a/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapesES6.types
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions b/‎tests/baselines/reference/taggedTemplateStringsHexadecimalEscapesES6.types
Copy file name to clipboard
+9Lines changed: 9 additions & 0 deletions
diff --git a/‎tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.errors.txt
Copy file name to clipboard
-13Lines changed: 0 additions & 13 deletions b/‎tests/baselines/reference/taggedTemplateStringsPlainCharactersThatArePartsOfEscapes01.errors.txt
Copy file name to clipboard
-13Lines changed: 0 additions & 13 deletions
@@ -377,6 +377,7 @@ module ts {
 
         function bind(node: Node) {
             node.parent = parent;
+            
             switch (node.kind) {
                 case SyntaxKind.TypeParameter:
                     bindDeclaration(<Declaration>node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes, /*isBlockScopeContainer*/ false);
 
@@ -6759,11 +6759,6 @@ module ts {
         }
 
         function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
-            // Grammar checking
-            if (languageVersion < ScriptTarget.ES6) {
-                grammarErrorOnFirstToken(node.template, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);
-            }
-
             return getReturnTypeOfSignature(getResolvedSignature(node));
         }
 
 
@@ -117,7 +117,6 @@ module ts {
         const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized" },
         const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." },
         let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." },
-        Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1159, category: DiagnosticCategory.Error, key: "Tagged templates are only available when targeting ECMAScript 6 and higher." },
         Unterminated_template_literal: { code: 1160, category: DiagnosticCategory.Error, key: "Unterminated template literal." },
         Unterminated_regular_expression_literal: { code: 1161, category: DiagnosticCategory.Error, key: "Unterminated regular expression literal." },
         An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional." },
 
@@ -459,10 +459,6 @@
         "category": "Error",
         "code": 1157
     },
-    "Tagged templates are only available when targeting ECMAScript 6 and higher.": {
-        "category": "Error",
-        "code": 1159
-    },
     "Unterminated template literal.": {
         "category": "Error",
         "code": 1160
 
@@ -2072,7 +2072,7 @@ module ts {
                 }
             }
 
-            function emitParenthesized(node: Node, parenthesized: boolean) {
+            function emitParenthesizedIf(node: Node, parenthesized: boolean) {
                 if (parenthesized) {
                     write("(");
                 }
@@ -2205,6 +2205,72 @@ module ts {
             function getTemplateLiteralAsStringLiteral(node: LiteralExpression): string {
                 return '"' + escapeString(node.text) + '"';
             }
+            
+            function emitDownlevelRawTemplateLiteral(node: LiteralExpression) {
+                // Find original source text, since we need to emit the raw strings of the tagged template.
+                // The raw strings contain the (escaped) strings of what the user wrote.
+                // Examples: `\n` is converted to "\\n", a template string with a newline to "\n".
+                var text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node);
+                
+                // text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"),
+                // thus we need to remove those characters.
+                // First template piece starts with "`", others with "}"
+                // Last template piece ends with "`", others with "${"
+                var isLast = node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail;
+                text = text.substring(1, text.length - (isLast ? 1 : 2));
+                
+                // Newline normalization:
+                // ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's
+                // <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for both TV and TRV.
+                text = text.replace(/\r\n?/g, "\n");
+                text = escapeString(text);
+                
+                write('"' + text + '"');
+            }
+            
+            function emitDownlevelTaggedTemplateArray(node: TaggedTemplateExpression, literalEmitter: (literal: LiteralExpression) => void) {
+                write("[");
+                if (node.template.kind === SyntaxKind.NoSubstitutionTemplateLiteral) {
+                    literalEmitter(<LiteralExpression>node.template);
+                }
+                else {
+                    literalEmitter((<TemplateExpression>node.template).head);
+                    forEach((<TemplateExpression>node.template).templateSpans, (child) => {
+                        write(", ");
+                        literalEmitter(child.literal);
+                    });
+                }
+                write("]");
+            }
+            
+            function emitDownlevelTaggedTemplate(node: TaggedTemplateExpression) {
+                var tempVariable = createAndRecordTempVariable(node);
+                write("(");
+                emit(tempVariable);
+                write(" = ");
+                emitDownlevelTaggedTemplateArray(node, emit);
+                write(", ");
+                
+                emit(tempVariable);
+                write(".raw = ");
+                emitDownlevelTaggedTemplateArray(node, emitDownlevelRawTemplateLiteral);
+                write(", ");
+                
+                emitParenthesizedIf(node.tag, needsParenthesisForPropertyAccessOrInvocation(node.tag));
+                write("(");
+                emit(tempVariable);
+                
+                // Now we emit the expressions
+                if (node.template.kind === SyntaxKind.TemplateExpression) {
+                    forEach((<TemplateExpression>node.template).templateSpans, templateSpan => {
+                        write(", ");
+                        var needsParens = templateSpan.expression.kind === SyntaxKind.BinaryExpression
+                            && (<BinaryExpression>templateSpan.expression).operatorToken.kind === SyntaxKind.CommaToken;
+                        emitParenthesizedIf(templateSpan.expression, needsParens);
+                    });
+                }
+                write("))");
+            }
 
             function emitTemplateExpression(node: TemplateExpression): void {
                 // In ES6 mode and above, we can simply emit each portion of a template in order, but in
@@ -2249,7 +2315,8 @@ module ts {
                         write(" + ");
                     }
 
-                    emitParenthesized(templateSpan.expression, needsParens);
+                    emitParenthesizedIf(templateSpan.expression, needsParens);
+
                     // Only emit if the literal is non-empty.
                     // The binary '+' operator is left-associative, so the first string concatenation
                     // with the head will force the result up to this point to be a string.
@@ -2479,7 +2546,7 @@ module ts {
                 emit((<SpreadElementExpression>node).expression);
             }
 
-            function needsParenthesisForPropertyAccess(node: Expression) {
+            function needsParenthesisForPropertyAccessOrInvocation(node: Expression) {
                 switch (node.kind) {
                     case SyntaxKind.Identifier:
                     case SyntaxKind.ArrayLiteralExpression:
@@ -2509,7 +2576,7 @@ module ts {
                     var e = elements[pos];
                     if (e.kind === SyntaxKind.SpreadElementExpression) {
                         e = (<SpreadElementExpression>e).expression;
-                        emitParenthesized(e, /*parenthesized*/ group === 0 && needsParenthesisForPropertyAccess(e));
+                        emitParenthesizedIf(e, /*parenthesized*/ group === 0 && needsParenthesisForPropertyAccessOrInvocation(e));
                         pos++;
                     }
                     else {
@@ -2985,9 +3052,14 @@ module ts {
             }
 
             function emitTaggedTemplateExpression(node: TaggedTemplateExpression): void {
-                emit(node.tag);
-                write(" ");
-                emit(node.template);
+                if (compilerOptions.target >= ScriptTarget.ES6) {
+                    emit(node.tag);
+                    write(" ");
+                    emit(node.template);
+                }
+                else {
+                    emitDownlevelTaggedTemplate(node);
+                }
             }
 
             function emitParenExpression(node: ParenthesizedExpression) {
@@ -3157,7 +3229,7 @@ module ts {
             }
 
             function emitExpressionStatement(node: ExpressionStatement) {
-                emitParenthesized(node.expression, /*parenthesized*/ node.expression.kind === SyntaxKind.ArrowFunction);
+                emitParenthesizedIf(node.expression, /*parenthesized*/ node.expression.kind === SyntaxKind.ArrowFunction);
                 write(";");
             }
 
 
@@ -0,0 +1,15 @@
+//// [taggedTemplateStringsHexadecimalEscapes.ts]
+function f(...args: any[]) {
+}
+
+f `\x0D${ "Interrupted CRLF" }\x0A`;
+
+//// [taggedTemplateStringsHexadecimalEscapes.js]
+function f() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i - 0] = arguments[_i];
+    }
+}
+(_a = ["\r", "\n"], _a.raw = ["\\x0D", "\\x0A"], f(_a, "Interrupted CRLF"));
+var _a;
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/taggedTemplateStringsHexadecimalEscapes.ts ===
+function f(...args: any[]) {
+>f : (...args: any[]) => void
+>args : any[]
+}
+
+f `\x0D${ "Interrupted CRLF" }\x0A`;
+>f : (...args: any[]) => void
+
@@ -0,0 +1,10 @@
+//// [taggedTemplateStringsHexadecimalEscapesES6.ts]
+function f(...args: any[]) {
+}
+
+f `\x0D${ "Interrupted CRLF" }\x0A`;
+
+//// [taggedTemplateStringsHexadecimalEscapesES6.js]
+function f(...args) {
+}
+f `\x0D${"Interrupted CRLF"}\x0A`;
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/taggedTemplateStringsHexadecimalEscapesES6.ts ===
+function f(...args: any[]) {
+>f : (...args: any[]) => void
+>args : any[]
+}
+
+f `\x0D${ "Interrupted CRLF" }\x0A`;
+>f : (...args: any[]) => void
+
Original file line number	Diff line number	Diff line change
`@@ -6759,11 +6759,6 @@ module ts {`
`6759`	`6759`	`}`
`6760`	`6760`
`6761`	`6761`	`function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {`
`6762`		`- // Grammar checking`
`6763`		`- if (languageVersion < ScriptTarget.ES6) {`
`6764`		`- grammarErrorOnFirstToken(node.template, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);`
`6765`		`- }`
`6766`		`-`
`6767`	`6762`	`return getReturnTypeOfSignature(getResolvedSignature(node));`
`6768`	`6763`	`}`
`6769`	`6764`