From 56027663bf8010e80ba3ce29a0f642a3adcd6642 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Tue, 4 Nov 2014 15:05:05 -0800
Subject: [PATCH 1/7] Initial work on overload resolution with tagged
 templates.

Currently type argument inference breaks hard when the first parameter of a tag has a generic type.
---
 src/compiler/checker.ts                       | 206 +++++++++++++-----
 src/compiler/core.ts                          |  11 +
 src/lib/core.d.ts                             |   4 +
 .../reference/noDefaultLib.errors.txt         |   2 +
 .../reference/parser509698.errors.txt         |   2 +
 .../noDefaultLib/amd/noDefaultLib.errors.txt  |   2 +
 .../noDefaultLib/node/noDefaultLib.errors.txt |   2 +
 ...tringsWithIncompatibleTypedTags.errors.txt |  28 ++-
 ...ngsWithIncompatibleTypedTagsES6.errors.txt |  53 +++++
 ...lateStringsWithIncompatibleTypedTagsES6.js |   6 +-
 ...eStringsWithIncompatibleTypedTagsES6.types |  82 -------
 ...ithManyCallAndMemberExpressions.errors.txt |   2 +-
 ...ingsWithManyCallAndMemberExpressionsES6.js |   2 +-
 ...sWithManyCallAndMemberExpressionsES6.types |  12 +-
 ...eStringsWithOverloadResolution1.errors.txt |  55 +++++
 ...ingsWithOverloadResolution1_ES6.errors.txt |  37 ++++
 ...plateStringsWithOverloadResolution1_ES6.js |  44 ++++
 ...aggedTemplateStringsWithTypedTagsES6.types |  24 +-
 .../templateStringInObjectLiteral.errors.txt  |   7 +-
 ...emplateStringInObjectLiteralES6.errors.txt |   7 +-
 .../templateStringInPropertyName1.errors.txt  |   6 +-
 .../templateStringInPropertyName2.errors.txt  |   6 +-
 ...mplateStringInPropertyNameES6_1.errors.txt |   6 +-
 ...mplateStringInPropertyNameES6_2.errors.txt |   6 +-
 .../typeCheckTypeArgument.errors.txt          |   2 +
 ...emplateStringsWithIncompatibleTypedTags.ts |   2 +
 ...lateStringsWithIncompatibleTypedTagsES6.ts |   4 +-
 ...StringsWithManyCallAndMemberExpressions.ts |   2 +-
 ...ingsWithManyCallAndMemberExpressionsES6.ts |   2 +-
 ...dTemplateStringsWithOverloadResolution1.ts |  21 ++
 ...plateStringsWithOverloadResolution1_ES6.ts |  22 ++
 31 files changed, 500 insertions(+), 167 deletions(-)
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt
 delete mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 9f612e11673b6..7b49753577821 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -147,6 +147,7 @@ module ts {
         var globalNumberType: ObjectType;
         var globalBooleanType: ObjectType;
         var globalRegExpType: ObjectType;
+        var globalTemplateStringsArrayType: ObjectType;
 
         var tupleTypes: Map<TupleType> = {};
         var unionTypes: Map<UnionType> = {};
@@ -5155,23 +5156,31 @@ module ts {
             return unknownType;
         }
 
-        function resolveUntypedCall(node: CallExpression): Signature {
-            forEach(node.arguments, argument => {
-                checkExpression(argument);
-            });
+        function resolveUntypedCall(node: CallExpression | TaggedTemplateExpression): Signature {
+            if (node.kind === SyntaxKind.TaggedTemplateExpression) {
+                checkExpression((<TaggedTemplateExpression>node).template);
+            }
+            else {
+                forEach((<CallExpression>node).arguments, argument => {
+                    checkExpression(argument);
+                });
+            }
             return anySignature;
         }
 
-        function resolveErrorCall(node: CallExpression): Signature {
+        function resolveErrorCall(node: CallExpression | TaggedTemplateExpression): Signature {
             resolveUntypedCall(node);
             return unknownSignature;
         }
 
-        function signatureHasCorrectArity(node: CallExpression, signature: Signature): boolean {
-            if (!node.arguments) {
+        function signatureHasCorrectArity(node: CallExpression | TaggedTemplateExpression, args: Expression[], signature: Signature): boolean {
+            var isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
+
+            if (!isTaggedTemplate && !(<CallExpression>node).arguments) {
                 // This only happens when we have something of the form:
                 //     new C
                 //
+                Debug.assert(node.kind === SyntaxKind.NewExpression);
                 return signature.minArgumentCount === 0;
             }
 
@@ -5179,11 +5188,12 @@ module ts {
             // to arity checking.
             //    1. A trailing comma is tantamount to adding another argument
             //    2. If the call is incomplete (no closing paren) allow fewer arguments than expected
-            var args = node.arguments;
-            var numberOfArgs = args.hasTrailingComma ? args.length + 1 : args.length;
+            var numberOfArgs = !isTaggedTemplate && (<CallExpression>node).arguments.hasTrailingComma
+                ? args.length + 1
+                : args.length;
             var hasTooManyArguments = !signature.hasRestParameter && numberOfArgs > signature.parameters.length;
-            var hasRightNumberOfTypeArguments = !node.typeArguments ||
-                (signature.typeParameters && node.typeArguments.length === signature.typeParameters.length);
+            var hasRightNumberOfTypeArguments = !(<CallExpression>node).typeArguments ||
+                (signature.typeParameters && (<CallExpression>node).typeArguments.length === signature.typeParameters.length);
 
             if (hasTooManyArguments || !hasRightNumberOfTypeArguments) {
                 return false;
@@ -5191,7 +5201,17 @@ module ts {
 
             // If we are missing the close paren, the call is incomplete, and we should skip
             // the lower bound check.
-            var callIsIncomplete = args.end === node.end;
+            var callIsIncomplete = false;
+            if (isTaggedTemplate) {
+                var template = (<TaggedTemplateExpression>node).template;
+                if (template.kind === SyntaxKind.TemplateExpression) {
+                    var lastSpan = lastOrUndefined((<TemplateExpression>template).templateSpans)
+                    callIsIncomplete = lastSpan === undefined || lastSpan.literal.kind !== SyntaxKind.TemplateTail;
+                }
+            }
+            else {
+                callIsIncomplete = (<CallExpression>node).arguments.end === node.end;
+            }
             var hasEnoughArguments = numberOfArgs >= signature.minArgumentCount;
             return callIsIncomplete || hasEnoughArguments;
         }
@@ -5224,6 +5244,7 @@ module ts {
             var mapper = createInferenceMapper(context);
             // First infer from arguments that are not context sensitive
             for (var i = 0; i < args.length; i++) {
+                // TODO (drosen): This breaks hard when inferring on a tagged template.
                 if (args[i].kind === SyntaxKind.OmittedExpression) {
                     continue;
                 }
@@ -5277,31 +5298,69 @@ module ts {
             return typeArgumentsAreAssignable;
         }
 
-        function checkApplicableSignature(node: CallExpression, signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
-            if (node.arguments) {
-                for (var i = 0; i < node.arguments.length; i++) {
-                    var arg = node.arguments[i];
-                    if (arg.kind === SyntaxKind.OmittedExpression) {
-                        continue;
-                    }
-                    var paramType = getTypeAtPosition(signature, i);
+        function checkApplicableSignature(node: CallExpression | TaggedTemplateExpression, callArguments: Node[], signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
+            for (var i = 0; i < callArguments.length; i++) {
+                var arg = callArguments[i];
+                var argType: Type;
+
+                if (arg && arg.kind === SyntaxKind.OmittedExpression) {
+                    continue;
+                }
+
+                var paramType = getTypeAtPosition(signature, i);
+
+                if (i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression) {
+                    arg = (<TaggedTemplateExpression>node).template; // just to report an error on the template
+                    argType = globalTemplateStringsArrayType;
+                }
+                else {
                     // String literals get string literal types unless we're reporting errors
-                    var argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors ?
-                        getStringLiteralType(<LiteralExpression>arg) :
-                        checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined);
-                    // Use argument expression as error location when reporting errors
-                    var isValidArgument = checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined,
-                        Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1);
-                    if (!isValidArgument) {
-                        return false;
-                    }
+                    argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors
+                        ? getStringLiteralType(<LiteralExpression>arg)
+                        : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined);
+                }
+
+                // Use argument expression as error location when reporting errors
+                var isValidArgument = checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined,
+                    Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1);
+                if (!isValidArgument) {
+                    return false;
                 }
             }
+
             return true;
         }
 
-        function resolveCall(node: CallExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
-            forEach(node.typeArguments, checkSourceElement);
+        /**
+         * Returns the effective arguments for an expression that works like a function invokation.
+         *
+         * If 'node' is a CallExpression or a NewExpression, then its argument list is returned.
+         * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution
+         *    expressions, where the first element of the argument list is 'undefined' to represent the "cooked" strings array.
+         */
+        function getEffectiveCallArguments(node: CallExpression | TaggedTemplateExpression): Expression[] {
+            var args: Expression[];
+            if (node.kind === SyntaxKind.TaggedTemplateExpression) {
+                var template = (<TaggedTemplateExpression>node).template;
+                // REVIEW: Should this be undefined or template?
+                //         I currently use 'undefined' mostly to catch places we are not accounting for.
+                args = [undefined];
+
+                if (template.kind === SyntaxKind.TemplateExpression) {
+                    args.push.apply(args, map((<TemplateExpression>template).templateSpans, span => span.expression));
+                }
+            }
+            else {
+                args = (<CallExpression>node).arguments || emptyArray;
+            }
+
+            return args;
+        }
+
+        function resolveCall(node: CallExpression | TaggedTemplateExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
+            var typeArguments = (<CallExpression>node).typeArguments;
+            forEach(typeArguments, checkSourceElement);
+
             var candidates = candidatesOutArray || [];
             // collectCandidates fills up the candidates array directly
             collectCandidates();
@@ -5309,11 +5368,22 @@ module ts {
                 error(node, Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
                 return resolveErrorCall(node);
             }
-            var args = node.arguments || emptyArray;
+
+            var args = getEffectiveCallArguments(node);
+            var isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
+            
+            // The following applies to any value of 'excludeArgument[i]':
+            //    - true:      the argument at 'i' is susceptible to a one-time permanent contextual typing.
+            //    - undefined: the argument at 'i' is *not* susceptible to permanent contextual typing.
+            //    - false:     the argument at 'i' *was* and *has been* permanently contextually typed.
+            //
+            // If the expression is a tagged template, then the first argument is implicitly the "cooked" strings array.
             var excludeArgument: boolean[];
-            for (var i = 0; i < args.length; i++) {
+            for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) {
                 if (isContextSensitiveExpression(args[i])) {
-                    if (!excludeArgument) excludeArgument = new Array(args.length);
+                    if (!excludeArgument) {
+                        excludeArgument = new Array(args.length);
+                    }
                     excludeArgument[i] = true;
                 }
             }
@@ -5378,11 +5448,11 @@ module ts {
                 // in arguments too early. If possible, we'd like to only type them once we know the correct
                 // overload. However, this matters for the case where the call is correct. When the call is
                 // an error, we don't need to exclude any arguments, although it would cause no harm to do so.
-                checkApplicableSignature(node, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
+                checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
             }
             else if (candidateForTypeArgumentError) {
-                if (node.typeArguments) {
-                    checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], /*reportErrors*/ true)
+                if ((<CallExpression>node).typeArguments) {
+                    checkTypeArguments(candidateForTypeArgumentError, (<CallExpression>node).typeArguments, [], /*reportErrors*/ true)
                 }
                 else {
                     Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0);
@@ -5393,7 +5463,7 @@ module ts {
                         Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
                         typeToString(failedTypeParameter));
 
-                    reportNoCommonSupertypeError(inferenceCandidates, node.func, diagnosticChainHead);
+                    reportNoCommonSupertypeError(inferenceCandidates, (<CallExpression>node).func || (<TaggedTemplateExpression>node).tag, diagnosticChainHead);
                 }
             }
             else {
@@ -5407,7 +5477,7 @@ module ts {
             //  f({ |
             if (!fullTypeCheck) {
                 for (var i = 0, n = candidates.length; i < n; i++) {
-                    if (signatureHasCorrectArity(node, candidates[i])) {
+                    if (signatureHasCorrectArity(node, args, candidates[i])) {
                         return candidates[i];
                     }
                 }
@@ -5417,7 +5487,7 @@ module ts {
 
             function chooseOverload(candidates: Signature[], relation: Map<Ternary>, excludeArgument: boolean[]) {
                 for (var i = 0; i < candidates.length; i++) {
-                    if (!signatureHasCorrectArity(node, candidates[i])) {
+                    if (!signatureHasCorrectArity(node, args, candidates[i])) {
                         continue;
                     }
 
@@ -5429,9 +5499,9 @@ module ts {
                         if (candidate.typeParameters) {
                             var typeArgumentTypes: Type[];
                             var typeArgumentsAreValid: boolean;
-                            if (node.typeArguments) {
+                            if ((<CallExpression>node).typeArguments) {
                                 typeArgumentTypes = new Array<Type>(candidate.typeParameters.length);
-                                typeArgumentsAreValid = checkTypeArguments(candidate, node.typeArguments, typeArgumentTypes, /*reportErrors*/ false)
+                                typeArgumentsAreValid = checkTypeArguments(candidate, (<CallExpression>node).typeArguments, typeArgumentTypes, /*reportErrors*/ false)
                             }
                             else {
                                 inferenceResult = inferTypeArguments(candidate, args, excludeArgument);
@@ -5443,7 +5513,7 @@ module ts {
                             }
                             candidate = getSignatureInstantiation(candidate, typeArgumentTypes);
                         }
-                        if (!checkApplicableSignature(node, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
+                        if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
                             break;
                         }
                         var index = excludeArgument ? indexOf(excludeArgument, true) : -1;
@@ -5465,7 +5535,7 @@ module ts {
                         }
                         else {
                             candidateForTypeArgumentError = originalCandidate;
-                            if (!node.typeArguments) {
+                            if (!(<CallExpression>node).typeArguments) {
                                 resultOfFailedInference = inferenceResult;
                             }
                         }
@@ -5576,7 +5646,6 @@ module ts {
 
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
             var expressionType = checkExpression(node.func);
-
             // TS 1.0 spec: 4.11
             // If ConstructExpr is of type Any, Args can be any argument
             // list and the result of the operation is of type Any.
@@ -5624,9 +5693,32 @@ module ts {
             return resolveErrorCall(node);
         }
 
+        function resolveTaggedTemplateExpression(node: TaggedTemplateExpression, candidatesOutArray: Signature[]): Signature {
+            var tagType = checkExpression(node.tag);
+            var apparentType = getApparentType(tagType);
+
+            if (apparentType === unknownType) {
+                // Another error has already been reported
+                return resolveErrorCall(node);
+            }
+
+            var callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+
+            if (tagType === anyType || (!callSignatures.length && !(tagType.flags & TypeFlags.Union) && isTypeAssignableTo(tagType, globalFunctionType))) {
+                return resolveUntypedCall(node);
+            }
+
+            if (!callSignatures.length) {
+                error(node, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature);
+                return resolveErrorCall(node);
+            }
+
+            return resolveCall(node, callSignatures, candidatesOutArray);
+        }
+
         // candidatesOutArray is passed by signature help in the language service, and collectCandidates
         // must fill it up with the appropriate candidate signatures
-        function getResolvedSignature(node: CallExpression, candidatesOutArray?: Signature[]): Signature {
+        function getResolvedSignature(node: CallExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]): Signature {
             var links = getNodeLinks(node);
             // If getResolvedSignature has already been called, we will have cached the resolvedSignature.
             // However, it is possible that either candidatesOutArray was not passed in the first time,
@@ -5634,9 +5726,19 @@ module ts {
             // to correctly fill the candidatesOutArray.
             if (!links.resolvedSignature || candidatesOutArray) {
                 links.resolvedSignature = anySignature;
-                links.resolvedSignature = node.kind === SyntaxKind.CallExpression
-                    ? resolveCallExpression(node, candidatesOutArray)
-                    : resolveNewExpression(node, candidatesOutArray);
+
+                if (node.kind === SyntaxKind.CallExpression) {
+                    links.resolvedSignature = resolveCallExpression(<CallExpression>node, candidatesOutArray);
+                }
+                else if (node.kind === SyntaxKind.NewExpression) {
+                    links.resolvedSignature = resolveNewExpression(<NewExpression>node, candidatesOutArray);
+                }
+                else if (node.kind === SyntaxKind.TaggedTemplateExpression) {
+                    links.resolvedSignature = resolveTaggedTemplateExpression(<TaggedTemplateExpression>node, candidatesOutArray);
+                }
+                else {
+                    Debug.fail("Branch in 'getResolvedSignature' should be unreachable.");
+                }
             }
             return links.resolvedSignature;
         }
@@ -5660,10 +5762,7 @@ module ts {
         }
 
         function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
-            // TODO (drosen): Make sure substitutions are assignable to the tag's arguments.
-            checkExpression(node.tag);
-            checkExpression(node.template);
-            return anyType;
+            return getReturnTypeOfSignature(getResolvedSignature(node));
         }
 
         function checkTypeAssertion(node: TypeAssertion): Type {
@@ -8752,6 +8851,7 @@ module ts {
             globalNumberType = getGlobalType("Number");
             globalBooleanType = getGlobalType("Boolean");
             globalRegExpType = getGlobalType("RegExp");
+            globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray");
         }
 
         initializeTypeChecker();
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 6fd07fe4a6a89..8056dc0d44929 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -122,6 +122,17 @@ module ts {
         return result;
     }
 
+    /**
+     * Returns the last element of an array if non-empty, undefined otherwise.
+     */
+    export function lastOrUndefined<T>(array: T[]): T {
+        if (array.length === 0) {
+            return undefined;
+        }
+
+        return array[array.length - 1];
+    }
+
     export function binarySearch(array: number[], value: number): number {
         var low = 0;
         var high = array.length - 1;
diff --git a/src/lib/core.d.ts b/src/lib/core.d.ts
index 8e16e4bdd6cd5..7f498488f2136 100644
--- a/src/lib/core.d.ts
+++ b/src/lib/core.d.ts
@@ -484,6 +484,10 @@ declare var Number: {
     POSITIVE_INFINITY: number;
 }
 
+interface TemplateStringsArray extends Array<string> {
+    raw: string[];
+}
+
 interface Math {
     /** The mathematical constant e. This is Euler's number, the base of natural logarithms. */
     E: number;
diff --git a/tests/baselines/reference/noDefaultLib.errors.txt b/tests/baselines/reference/noDefaultLib.errors.txt
index 020989500556d..f2c23d56d25ff 100644
--- a/tests/baselines/reference/noDefaultLib.errors.txt
+++ b/tests/baselines/reference/noDefaultLib.errors.txt
@@ -1,10 +1,12 @@
 error TS2318: Cannot find global type 'Boolean'.
 error TS2318: Cannot find global type 'IArguments'.
+error TS2318: Cannot find global type 'TemplateStringsArray'.
 tests/cases/compiler/noDefaultLib.ts(4,11): error TS2317: Global type 'Array' must have 1 type parameter(s).
 
 
 !!! error TS2318: Cannot find global type 'Boolean'.
 !!! error TS2318: Cannot find global type 'IArguments'.
+!!! error TS2318: Cannot find global type 'TemplateStringsArray'.
 ==== tests/cases/compiler/noDefaultLib.ts (1 errors) ====
     /// <reference no-default-lib="true"/>
     var x;
diff --git a/tests/baselines/reference/parser509698.errors.txt b/tests/baselines/reference/parser509698.errors.txt
index 2aaaec18dc29c..2a8cc607e1e7a 100644
--- a/tests/baselines/reference/parser509698.errors.txt
+++ b/tests/baselines/reference/parser509698.errors.txt
@@ -6,6 +6,7 @@ error TS2318: Cannot find global type 'Number'.
 error TS2318: Cannot find global type 'Object'.
 error TS2318: Cannot find global type 'RegExp'.
 error TS2318: Cannot find global type 'String'.
+error TS2318: Cannot find global type 'TemplateStringsArray'.
 
 
 !!! error TS2318: Cannot find global type 'Array'.
@@ -16,6 +17,7 @@ error TS2318: Cannot find global type 'String'.
 !!! error TS2318: Cannot find global type 'Object'.
 !!! error TS2318: Cannot find global type 'RegExp'.
 !!! error TS2318: Cannot find global type 'String'.
+!!! error TS2318: Cannot find global type 'TemplateStringsArray'.
 ==== tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509698.ts (0 errors) ====
     /// <style requireSemi="on" />
     /// <reference no-default-lib="true"/>
diff --git a/tests/baselines/reference/project/noDefaultLib/amd/noDefaultLib.errors.txt b/tests/baselines/reference/project/noDefaultLib/amd/noDefaultLib.errors.txt
index eeaf52ba72a99..908fe85e3da42 100644
--- a/tests/baselines/reference/project/noDefaultLib/amd/noDefaultLib.errors.txt
+++ b/tests/baselines/reference/project/noDefaultLib/amd/noDefaultLib.errors.txt
@@ -6,6 +6,7 @@ error TS2318: Cannot find global type 'Number'.
 error TS2318: Cannot find global type 'Object'.
 error TS2318: Cannot find global type 'RegExp'.
 error TS2318: Cannot find global type 'String'.
+error TS2318: Cannot find global type 'TemplateStringsArray'.
 test.ts(3,8): error TS2304: Cannot find name 'Array'.
 
 
@@ -17,6 +18,7 @@ test.ts(3,8): error TS2304: Cannot find name 'Array'.
 !!! error TS2318: Cannot find global type 'Object'.
 !!! error TS2318: Cannot find global type 'RegExp'.
 !!! error TS2318: Cannot find global type 'String'.
+!!! error TS2318: Cannot find global type 'TemplateStringsArray'.
 ==== test.ts (1 errors) ====
     /// <reference no-default-lib="true"/>
     
diff --git a/tests/baselines/reference/project/noDefaultLib/node/noDefaultLib.errors.txt b/tests/baselines/reference/project/noDefaultLib/node/noDefaultLib.errors.txt
index eeaf52ba72a99..908fe85e3da42 100644
--- a/tests/baselines/reference/project/noDefaultLib/node/noDefaultLib.errors.txt
+++ b/tests/baselines/reference/project/noDefaultLib/node/noDefaultLib.errors.txt
@@ -6,6 +6,7 @@ error TS2318: Cannot find global type 'Number'.
 error TS2318: Cannot find global type 'Object'.
 error TS2318: Cannot find global type 'RegExp'.
 error TS2318: Cannot find global type 'String'.
+error TS2318: Cannot find global type 'TemplateStringsArray'.
 test.ts(3,8): error TS2304: Cannot find name 'Array'.
 
 
@@ -17,6 +18,7 @@ test.ts(3,8): error TS2304: Cannot find name 'Array'.
 !!! error TS2318: Cannot find global type 'Object'.
 !!! error TS2318: Cannot find global type 'RegExp'.
 !!! error TS2318: Cannot find global type 'String'.
+!!! error TS2318: Cannot find global type 'TemplateStringsArray'.
 ==== test.ts (1 errors) ====
     /// <reference no-default-lib="true"/>
     
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
index a9f4be155d9a4..461a47c52a856 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
@@ -8,9 +8,17 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,1): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(14,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(18,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(22,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,25): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,57): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
 
 
-==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (10 errors) ====
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (18 errors) ====
     interface I {
         (stringParts: string[], ...rest: boolean[]): I;
         g: I;
@@ -29,6 +37,8 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
     f `abc${1}def${2}ghi`;
     ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc`.member
     ~~~~~~~
@@ -37,6 +47,8 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
     f `abc${1}def${2}ghi`.member;
     ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc`["member"];
     ~~~~~~~
@@ -45,18 +57,32 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
     f `abc${1}def${2}ghi`["member"];
     ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc`[0].member `abc${1}def${2}ghi`;
     ~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
     ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                                                            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f.thisIsNotATag(`abc`);
     
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt
new file mode 100644
index 0000000000000..89b48b0193cee
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.errors.txt
@@ -0,0 +1,53 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(14,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(18,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(22,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(24,25): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(26,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts(28,57): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts (6 errors) ====
+    interface I {
+        (stringParts: string[], ...rest: boolean[]): I;
+        g: I;
+        h: I;
+        member: I;
+        thisIsNotATag(x: string): void
+        [x: number]: I;
+    }
+    
+    var f: I;
+    
+    f `abc`
+    
+    f `abc${1}def${2}ghi`;
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc`.member
+    
+    f `abc${1}def${2}ghi`.member;
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc`["member"];
+    
+    f `abc${1}def${2}ghi`["member"];
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc`[0].member `abc${1}def${2}ghi`;
+                            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+                                                            ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+    
+    f.thisIsNotATag(`abc`);
+    
+    f.thisIsNotATag(`abc${1}def${2}ghi`);
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js
index db68e950c342c..8b63635606802 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.js
@@ -26,10 +26,11 @@ f `abc`[0].member `abc${1}def${2}ghi`;
 
 f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
 
+f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+
 f.thisIsNotATag(`abc`);
 
-f.thisIsNotATag(`abc${1}def${2}ghi`);
-
+f.thisIsNotATag(`abc${1}def${2}ghi`);
 
 //// [taggedTemplateStringsWithIncompatibleTypedTagsES6.js]
 var f;
@@ -41,5 +42,6 @@ f `abc`["member"];
 f `abc${1}def${2}ghi`["member"];
 f `abc`[0].member `abc${1}def${2}ghi`;
 f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+f `abc${true}def${true}ghi`["member"].member `abc${1}def${2}ghi`;
 f.thisIsNotATag(`abc`);
 f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types
deleted file mode 100644
index 572c3c1a8d157..0000000000000
--- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types
+++ /dev/null
@@ -1,82 +0,0 @@
-=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts ===
-interface I {
->I : I
-
-    (stringParts: string[], ...rest: boolean[]): I;
->stringParts : string[]
->rest : boolean[]
->I : I
-
-    g: I;
->g : I
->I : I
-
-    h: I;
->h : I
->I : I
-
-    member: I;
->member : I
->I : I
-
-    thisIsNotATag(x: string): void
->thisIsNotATag : (x: string) => void
->x : string
-
-    [x: number]: I;
->x : number
->I : I
-}
-
-var f: I;
->f : I
->I : I
-
-f `abc`
->f : I
-
-f `abc${1}def${2}ghi`;
->f : I
-
-f `abc`.member
->f `abc`.member : any
->f : I
->member : any
-
-f `abc${1}def${2}ghi`.member;
->f `abc${1}def${2}ghi`.member : any
->f : I
->member : any
-
-f `abc`["member"];
->f `abc`["member"] : any
->f : I
-
-f `abc${1}def${2}ghi`["member"];
->f `abc${1}def${2}ghi`["member"] : any
->f : I
-
-f `abc`[0].member `abc${1}def${2}ghi`;
->f `abc`[0].member : any
->f `abc`[0] : any
->f : I
->member : any
-
-f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
->f `abc${1}def${2}ghi`["member"].member : any
->f `abc${1}def${2}ghi`["member"] : any
->f : I
->member : any
-
-f.thisIsNotATag(`abc`);
->f.thisIsNotATag(`abc`) : void
->f.thisIsNotATag : (x: string) => void
->f : I
->thisIsNotATag : (x: string) => void
-
-f.thisIsNotATag(`abc${1}def${2}ghi`);
->f.thisIsNotATag(`abc${1}def${2}ghi`) : void
->f.thisIsNotATag : (x: string) => void
->f : I
->thisIsNotATag : (x: string) => void
-
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt
index 4813fe5a23934..f6a80a7301367 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressions.errors.txt
@@ -3,7 +3,7 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMember
 
 ==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts (1 errors) ====
     interface I {
-        (strs: string[], subs: number[]): I;
+        (strs: string[], ...subs: number[]): I;
         member: {
             new (s: string): {
                 new (n: number): {
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js
index 4d6a68a921a6c..b985860f0650a 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.js
@@ -1,6 +1,6 @@
 //// [taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts]
 interface I {
-    (strs: string[], subs: number[]): I;
+    (strs: string[], ...subs: number[]): I;
     member: {
         new (s: string): {
             new (n: number): {
diff --git a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types
index b8fb33771967c..29a429a1435de 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types
+++ b/tests/baselines/reference/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.types
@@ -2,7 +2,7 @@
 interface I {
 >I : I
 
-    (strs: string[], subs: number[]): I;
+    (strs: string[], ...subs: number[]): I;
 >strs : string[]
 >subs : number[]
 >I : I
@@ -28,11 +28,11 @@ var f: I;
 var x = new new new f `abc${ 0 }def`.member("hello")(42) === true;
 >x : boolean
 >new new new f `abc${ 0 }def`.member("hello")(42) === true : boolean
->new new new f `abc${ 0 }def`.member("hello")(42) : any
->new new f `abc${ 0 }def`.member("hello")(42) : any
->new f `abc${ 0 }def`.member("hello") : any
->f `abc${ 0 }def`.member : any
+>new new new f `abc${ 0 }def`.member("hello")(42) : boolean
+>new new f `abc${ 0 }def`.member("hello")(42) : new () => boolean
+>new f `abc${ 0 }def`.member("hello") : new (n: number) => new () => boolean
+>f `abc${ 0 }def`.member : new (s: string) => new (n: number) => new () => boolean
 >f : I
->member : any
+>member : new (s: string) => new (n: number) => new () => boolean
 
 
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt
new file mode 100644
index 0000000000000..9847ead783b94
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.errors.txt
@@ -0,0 +1,55 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(16,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(17,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(18,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(19,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(20,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(21,9): error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(12,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(14,9): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(19,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts(21,9): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts (10 errors) ====
+    function foo(strs: string[]): number;
+    function foo(strs: string[], x: number): string;
+    function foo(strs: string[], x: number, y: number): boolean;
+    function foo(strs: string[], x: number, y: string): {};
+    function foo(...stuff: any[]): any {
+        return undefined;
+    }
+    
+    var a = foo([]);             // number
+    var b = foo([], 1);          // string
+    var c = foo([], 1, 2);       // boolean
+    var d = foo([], 1, true);    // boolean (with error)
+                       ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    var e = foo([], 1, "2");     // {}
+    var f = foo([], 1, 2, 3);    // any (with error)
+            ~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    var u = foo ``;              // number
+            ~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var v = foo `${1}`;          // string
+            ~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var w = foo `${1}${2}`;      // boolean
+            ~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var x = foo `${1}${true}`;   // boolean (with error)
+            ~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                       ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    var y = foo `${1}${"2"}`;    // {}
+            ~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var z = foo `${1}${2}${3}`;  // any (with error)
+            ~~~~~~~~~~~~~~~~~~
+!!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt
new file mode 100644
index 0000000000000..53361f2052d7e
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.errors.txt
@@ -0,0 +1,37 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(12,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(14,9): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(19,20): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts(21,9): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts (4 errors) ====
+    function foo(strs: string[]): number;
+    function foo(strs: string[], x: number): string;
+    function foo(strs: string[], x: number, y: number): boolean;
+    function foo(strs: string[], x: number, y: string): {};
+    function foo(...stuff: any[]): any {
+        return undefined;
+    }
+    
+    var a = foo([]);             // number
+    var b = foo([], 1);          // string
+    var c = foo([], 1, 2);       // boolean
+    var d = foo([], 1, true);    // boolean (with error)
+                       ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    var e = foo([], 1, "2");     // {}
+    var f = foo([], 1, 2, 3);    // any (with error)
+            ~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    var u = foo ``;              // number
+    var v = foo `${1}`;          // string
+    var w = foo `${1}${2}`;      // boolean
+    var x = foo `${1}${true}`;   // boolean (with error)
+                       ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    var y = foo `${1}${"2"}`;    // {}
+    var z = foo `${1}${2}${3}`;  // any (with error)
+            ~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js
new file mode 100644
index 0000000000000..a2a96168fd8c8
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.js
@@ -0,0 +1,44 @@
+//// [taggedTemplateStringsWithOverloadResolution1_ES6.ts]
+function foo(strs: string[]): number;
+function foo(strs: string[], x: number): string;
+function foo(strs: string[], x: number, y: number): boolean;
+function foo(strs: string[], x: number, y: string): {};
+function foo(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo([]);             // number
+var b = foo([], 1);          // string
+var c = foo([], 1, 2);       // boolean
+var d = foo([], 1, true);    // boolean (with error)
+var e = foo([], 1, "2");     // {}
+var f = foo([], 1, 2, 3);    // any (with error)
+
+var u = foo ``;              // number
+var v = foo `${1}`;          // string
+var w = foo `${1}${2}`;      // boolean
+var x = foo `${1}${true}`;   // boolean (with error)
+var y = foo `${1}${"2"}`;    // {}
+var z = foo `${1}${2}${3}`;  // any (with error)
+
+
+//// [taggedTemplateStringsWithOverloadResolution1_ES6.js]
+function foo() {
+    var stuff = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        stuff[_i - 0] = arguments[_i];
+    }
+    return undefined;
+}
+var a = foo([]); // number
+var b = foo([], 1); // string
+var c = foo([], 1, 2); // boolean
+var d = foo([], 1, true); // boolean (with error)
+var e = foo([], 1, "2"); // {}
+var f = foo([], 1, 2, 3); // any (with error)
+var u = foo ``; // number
+var v = foo `${1}`; // string
+var w = foo `${1}${2}`; // boolean
+var x = foo `${1}${true}`; // boolean (with error)
+var y = foo `${1}${"2"}`; // {}
+var z = foo `${1}${2}${3}`; // any (with error)
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types
index 9745320b39752..e0b16ebe392dc 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTagsES6.types
@@ -39,34 +39,34 @@ f `abc${1}def${2}ghi`;
 >f : I
 
 f `abc`.member
->f `abc`.member : any
+>f `abc`.member : I
 >f : I
->member : any
+>member : I
 
 f `abc${1}def${2}ghi`.member;
->f `abc${1}def${2}ghi`.member : any
+>f `abc${1}def${2}ghi`.member : I
 >f : I
->member : any
+>member : I
 
 f `abc`["member"];
->f `abc`["member"] : any
+>f `abc`["member"] : I
 >f : I
 
 f `abc${1}def${2}ghi`["member"];
->f `abc${1}def${2}ghi`["member"] : any
+>f `abc${1}def${2}ghi`["member"] : I
 >f : I
 
 f `abc`[0].member `abc${1}def${2}ghi`;
->f `abc`[0].member : any
->f `abc`[0] : any
+>f `abc`[0].member : I
+>f `abc`[0] : I
 >f : I
->member : any
+>member : I
 
 f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
->f `abc${1}def${2}ghi`["member"].member : any
->f `abc${1}def${2}ghi`["member"] : any
+>f `abc${1}def${2}ghi`["member"].member : I
+>f `abc${1}def${2}ghi`["member"] : I
 >f : I
->member : any
+>member : I
 
 f.thisIsNotATag(`abc`);
 >f.thisIsNotATag(`abc`) : void
diff --git a/tests/baselines/reference/templateStringInObjectLiteral.errors.txt b/tests/baselines/reference/templateStringInObjectLiteral.errors.txt
index 8604338d6788a..29580e2fa7710 100644
--- a/tests/baselines/reference/templateStringInObjectLiteral.errors.txt
+++ b/tests/baselines/reference/templateStringInObjectLiteral.errors.txt
@@ -3,12 +3,15 @@ tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,5): err
 tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,8): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(3,10): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(4,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts (5 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts (6 errors) ====
     var x = {
             ~
+            ~
         a: `abc${ 123 }def`,
+    ~~~~~~~~~~~~~~~~~~~~~~~~
     ~~~~~~~~~~~~~~~~~~~~~~~~
         `b`: 321
     ~~~~~~~
@@ -19,6 +22,8 @@ tests/cases/conformance/es6/templates/templateStringInObjectLiteral.ts(4,1): err
 !!! error TS1005: ',' expected.
              ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt b/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt
index ae21ecd4739c7..c633d61afb577 100644
--- a/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt
+++ b/tests/baselines/reference/templateStringInObjectLiteralES6.errors.txt
@@ -2,11 +2,14 @@ tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,5):
 tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,8): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(3,10): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(4,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts (4 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts (5 errors) ====
     var x = {
+            ~
         a: `abc${ 123 }def`,
+    ~~~~~~~~~~~~~~~~~~~~~~~~
         `b`: 321
         ~~~
 !!! error TS1136: Property assignment expected.
@@ -14,6 +17,8 @@ tests/cases/conformance/es6/templates/templateStringInObjectLiteralES6.ts(4,1):
 !!! error TS1005: ',' expected.
              ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyName1.errors.txt b/tests/baselines/reference/templateStringInPropertyName1.errors.txt
index 0e7dc998046b4..80742d2871eb5 100644
--- a/tests/baselines/reference/templateStringInPropertyName1.errors.txt
+++ b/tests/baselines/reference/templateStringInPropertyName1.errors.txt
@@ -3,11 +3,13 @@ tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,5): err
 tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,8): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(2,10): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(3,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts (5 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts (6 errors) ====
     var x = {
             ~
+            ~
         `a`: 321
     ~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
@@ -17,6 +19,8 @@ tests/cases/conformance/es6/templates/templateStringInPropertyName1.ts(3,1): err
 !!! error TS1005: ',' expected.
              ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyName2.errors.txt b/tests/baselines/reference/templateStringInPropertyName2.errors.txt
index a20d09f401f63..6126039596961 100644
--- a/tests/baselines/reference/templateStringInPropertyName2.errors.txt
+++ b/tests/baselines/reference/templateStringInPropertyName2.errors.txt
@@ -3,11 +3,13 @@ tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,5): err
 tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,32): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(2,34): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(3,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts (5 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts (6 errors) ====
     var x = {
             ~
+            ~
         `abc${ 123 }def${ 456 }ghi`: 321
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1160: Tagged templates are only available when targeting ECMAScript 6 and higher.
@@ -17,6 +19,8 @@ tests/cases/conformance/es6/templates/templateStringInPropertyName2.ts(3,1): err
 !!! error TS1005: ',' expected.
                                      ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt b/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt
index b45de2faaa1d8..f6e1bfc4206b3 100644
--- a/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt
+++ b/tests/baselines/reference/templateStringInPropertyNameES6_1.errors.txt
@@ -2,10 +2,12 @@ tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,5):
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,8): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(2,10): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(3,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts (4 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts (5 errors) ====
     var x = {
+            ~
         `a`: 321
         ~~~
 !!! error TS1136: Property assignment expected.
@@ -13,6 +15,8 @@ tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_1.ts(3,1):
 !!! error TS1005: ',' expected.
              ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt b/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt
index 6b28fe2c71c06..2ce2e8aac8884 100644
--- a/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt
+++ b/tests/baselines/reference/templateStringInPropertyNameES6_2.errors.txt
@@ -2,10 +2,12 @@ tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,5):
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,32): error TS1005: ',' expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(2,34): error TS1134: Variable declaration expected.
 tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(3,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(1,9): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts (4 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts (5 errors) ====
     var x = {
+            ~
         `abc${ 123 }def${ 456 }ghi`: 321
         ~~~~~~
 !!! error TS1136: Property assignment expected.
@@ -13,6 +15,8 @@ tests/cases/conformance/es6/templates/templateStringInPropertyNameES6_2.ts(3,1):
 !!! error TS1005: ',' expected.
                                      ~~~
 !!! error TS1134: Variable declaration expected.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeCheckTypeArgument.errors.txt b/tests/baselines/reference/typeCheckTypeArgument.errors.txt
index bf3e8bfdb9b2a..71ba09d44fc6a 100644
--- a/tests/baselines/reference/typeCheckTypeArgument.errors.txt
+++ b/tests/baselines/reference/typeCheckTypeArgument.errors.txt
@@ -6,6 +6,7 @@ error TS2318: Cannot find global type 'Number'.
 error TS2318: Cannot find global type 'Object'.
 error TS2318: Cannot find global type 'RegExp'.
 error TS2318: Cannot find global type 'String'.
+error TS2318: Cannot find global type 'TemplateStringsArray'.
 tests/cases/compiler/typeCheckTypeArgument.ts(3,19): error TS2304: Cannot find name 'UNKNOWN'.
 tests/cases/compiler/typeCheckTypeArgument.ts(5,26): error TS2304: Cannot find name 'UNKNOWN'.
 tests/cases/compiler/typeCheckTypeArgument.ts(7,21): error TS2304: Cannot find name 'UNKNOWN'.
@@ -22,6 +23,7 @@ tests/cases/compiler/typeCheckTypeArgument.ts(15,13): error TS2304: Cannot find
 !!! error TS2318: Cannot find global type 'Object'.
 !!! error TS2318: Cannot find global type 'RegExp'.
 !!! error TS2318: Cannot find global type 'String'.
+!!! error TS2318: Cannot find global type 'TemplateStringsArray'.
 ==== tests/cases/compiler/typeCheckTypeArgument.ts (6 errors) ====
     /// <reference no-default-lib="true"/>
     
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts
index cd9da4e43e40b..0f5d203d60b0f 100644
--- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts
@@ -25,6 +25,8 @@ f `abc`[0].member `abc${1}def${2}ghi`;
 
 f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
 
+f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+
 f.thisIsNotATag(`abc`);
 
 f.thisIsNotATag(`abc${1}def${2}ghi`);
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts
index 2e8cbf3a1fafe..36dc249f67276 100644
--- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTagsES6.ts
@@ -26,6 +26,8 @@ f `abc`[0].member `abc${1}def${2}ghi`;
 
 f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
 
+f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+
 f.thisIsNotATag(`abc`);
 
-f.thisIsNotATag(`abc${1}def${2}ghi`);
+f.thisIsNotATag(`abc${1}def${2}ghi`);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts
index b86996a53f3ac..d96196ee26e54 100644
--- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressions.ts
@@ -1,5 +1,5 @@
 interface I {
-    (strs: string[], subs: number[]): I;
+    (strs: string[], ...subs: number[]): I;
     member: {
         new (s: string): {
             new (n: number): {
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts
index 0fe9ad566a9de..d0d6604cfde58 100644
--- a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithManyCallAndMemberExpressionsES6.ts
@@ -1,6 +1,6 @@
 // @target: ES6
 interface I {
-    (strs: string[], subs: number[]): I;
+    (strs: string[], ...subs: number[]): I;
     member: {
         new (s: string): {
             new (n: number): {
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts
new file mode 100644
index 0000000000000..5b29beddd480b
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1.ts
@@ -0,0 +1,21 @@
+function foo(strs: string[]): number;
+function foo(strs: string[], x: number): string;
+function foo(strs: string[], x: number, y: number): boolean;
+function foo(strs: string[], x: number, y: string): {};
+function foo(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo([]);             // number
+var b = foo([], 1);          // string
+var c = foo([], 1, 2);       // boolean
+var d = foo([], 1, true);    // boolean (with error)
+var e = foo([], 1, "2");     // {}
+var f = foo([], 1, 2, 3);    // any (with error)
+
+var u = foo ``;              // number
+var v = foo `${1}`;          // string
+var w = foo `${1}${2}`;      // boolean
+var x = foo `${1}${true}`;   // boolean (with error)
+var y = foo `${1}${"2"}`;    // {}
+var z = foo `${1}${2}${3}`;  // any (with error)
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts
new file mode 100644
index 0000000000000..f821d84fbdd40
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution1_ES6.ts
@@ -0,0 +1,22 @@
+//@target: es6
+function foo(strs: string[]): number;
+function foo(strs: string[], x: number): string;
+function foo(strs: string[], x: number, y: number): boolean;
+function foo(strs: string[], x: number, y: string): {};
+function foo(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo([]);             // number
+var b = foo([], 1);          // string
+var c = foo([], 1, 2);       // boolean
+var d = foo([], 1, true);    // boolean (with error)
+var e = foo([], 1, "2");     // {}
+var f = foo([], 1, 2, 3);    // any (with error)
+
+var u = foo ``;              // number
+var v = foo `${1}`;          // string
+var w = foo `${1}${2}`;      // boolean
+var x = foo `${1}${true}`;   // boolean (with error)
+var y = foo `${1}${"2"}`;    // {}
+var z = foo `${1}${2}${3}`;  // any (with error)

From bcddb101aa2a8c683c984e9a73c5c5444b063c35 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 5 Nov 2014 18:20:40 -0800
Subject: [PATCH 2/7] Proper type arg inference with apppropriate overload res
 tests.

---
 src/compiler/checker.ts                       |  24 ++-
 ...ateStringsTypeArgumentInference.errors.txt | 190 ++++++++++++++++++
 ...StringsTypeArgumentInferenceES6.errors.txt | 105 ++++++++++
 ...TemplateStringsTypeArgumentInferenceES6.js | 171 ++++++++++++++++
 ...eStringsWithOverloadResolution2.errors.txt |  27 +++
 ...plateStringsWithOverloadResolution2_ES6.js |  38 ++++
 ...teStringsWithOverloadResolution2_ES6.types |  59 ++++++
 ...eStringsWithOverloadResolution3.errors.txt | 160 +++++++++++++++
 ...ingsWithOverloadResolution3_ES6.errors.txt |  93 +++++++++
 ...plateStringsWithOverloadResolution3_ES6.js | 122 +++++++++++
 ...gedTemplateStringsTypeArgumentInference.ts |  92 +++++++++
 ...TemplateStringsTypeArgumentInferenceES6.ts |  92 +++++++++
 ...dTemplateStringsWithOverloadResolution2.ts |  18 ++
 ...plateStringsWithOverloadResolution2_ES6.ts |  18 ++
 ...dTemplateStringsWithOverloadResolution3.ts |  72 +++++++
 ...plateStringsWithOverloadResolution3_ES6.ts |  72 +++++++
 16 files changed, 1344 insertions(+), 9 deletions(-)
 create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.js
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts
 create mode 100644 tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index bd373006299ca..805a96a6b8487 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5271,21 +5271,28 @@ module ts {
             var mapper = createInferenceMapper(context);
             // First infer from arguments that are not context sensitive
             for (var i = 0; i < args.length; i++) {
-                // TODO (drosen): This breaks hard when inferring on a tagged template.
                 if (args[i].kind === SyntaxKind.OmittedExpression) {
                     continue;
                 }
                 if (!excludeArgument || excludeArgument[i] === undefined) {
                     var parameterType = getTypeAtPosition(signature, i);
+
+                    if (i === 0 && args[i].parent.kind === SyntaxKind.TaggedTemplateExpression) {
+                        inferTypes(context, globalTemplateStringsArrayType, parameterType);
+                        continue;
+                    }
+
                     inferTypes(context, checkExpressionWithContextualType(args[i], parameterType, mapper), parameterType);
                 }
             }
+
             // Next, infer from those context sensitive arguments that are no longer excluded
             if (excludeArgument) {
                 for (var i = 0; i < args.length; i++) {
                     if (args[i].kind === SyntaxKind.OmittedExpression) {
                         continue;
                     }
+                    // No need to special-case tagged templates; their excludeArgument value will be 'undefined'.
                     if (excludeArgument[i] === false) {
                         var parameterType = getTypeAtPosition(signature, i);
                         inferTypes(context, checkExpressionWithContextualType(args[i], parameterType, mapper), parameterType);
@@ -5325,19 +5332,20 @@ module ts {
             return typeArgumentsAreAssignable;
         }
 
-        function checkApplicableSignature(node: CallExpression | TaggedTemplateExpression, callArguments: Node[], signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
-            for (var i = 0; i < callArguments.length; i++) {
-                var arg = callArguments[i];
+        function checkApplicableSignature(node: CallExpression | TaggedTemplateExpression, args: Node[], signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
+            for (var i = 0; i < args.length; i++) {
+                var arg = args[i];
                 var argType: Type;
 
-                if (arg && arg.kind === SyntaxKind.OmittedExpression) {
+                if (arg.kind === SyntaxKind.OmittedExpression) {
                     continue;
                 }
 
                 var paramType = getTypeAtPosition(signature, i);
 
                 if (i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression) {
-                    arg = (<TaggedTemplateExpression>node).template; // just to report an error on the template
+                    // A tagged template expression has something of a
+                    // "virtual" parameter with the "cooked" strings array type.
                     argType = globalTemplateStringsArrayType;
                 }
                 else {
@@ -5369,9 +5377,7 @@ module ts {
             var args: Expression[];
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
                 var template = (<TaggedTemplateExpression>node).template;
-                // REVIEW: Should this be undefined or template?
-                //         I currently use 'undefined' mostly to catch places we are not accounting for.
-                args = [undefined];
+                args = [template];
 
                 if (template.kind === SyntaxKind.TemplateExpression) {
                     args.push.apply(args, map((<TemplateExpression>template).templateSpans, span => span.expression));
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
new file mode 100644
index 0000000000000..c4a34fccd9588
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.errors.txt
@@ -0,0 +1,190 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(5,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(9,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(13,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(16,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(20,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(23,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(27,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(28,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(29,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(33,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(34,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(35,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(39,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(40,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(41,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(45,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(46,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(47,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(51,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(52,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(53,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(57,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(58,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(64,11): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,11): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(81,11): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(86,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(90,11): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(64,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts(77,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts (30 errors) ====
+    
+    
+    // Generic tag with one parameter
+    function noParams<T>(n: T) { }
+    noParams ``;
+    ~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with parameter which does not use type parameter
+    function noGenericParams<T>(n: string[]) { }
+    noGenericParams ``;
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with multiple type parameters and only one used in parameter type annotation
+    function someGenerics1a<T, U>(n: T, m: number) { }
+    someGenerics1a `${3}`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    function someGenerics1b<T, U>(n: string[], m: U) { }
+    someGenerics1b `${3}`;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with argument of function type whose parameter is of type parameter type
+    function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+    someGenerics2a `${(n: string) => n}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+    someGenerics2b `${ (n: string, x: number) => n }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+    function someGenerics3<T>(strs: string[], producer: () => T) { }
+    someGenerics3 `${() => ''}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics3 `${() => undefined}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics3 `${() => 3}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+    function someGenerics4<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+    someGenerics4 `${4}${ () => null }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics4 `${''}${ () => 3 }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics4 `${ null }${ null }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+    function someGenerics5<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+    someGenerics5 `${ 4 } ${ () => null }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics5 `${ '' }${ () => 3 }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics5 `${null}${null}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with multiple arguments of function types that each have parameters of the same generic type
+    function someGenerics6<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+    someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with multiple arguments of function types that each have parameters of different generic type
+    function someGenerics7<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+    someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with argument of generic function type
+    function someGenerics8<T>(strs: string[], n: T): T { return n; }
+    var x = someGenerics8 `${ someGenerics7 }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    x `${null}${null}${null}`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic tag with multiple parameters of generic type passed arguments with no best common type
+    function someGenerics9<T>(strs: string[], a: T, b: T, c: T): T {
+        return null;
+    }
+    var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+              ~~~~~~~~~~~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
+    var a9a: {};
+    
+    // Generic tag with multiple parameters of generic type passed arguments with multiple best common types
+    interface A91 {
+        x: number;
+        y?: string;
+    }
+    interface A92 {
+        x: number;
+        z?: Date;
+    }
+    
+    var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+              ~~~~~~~~~~~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
+    var a9e: {};
+    
+    // Generic tag with multiple parameters of generic type passed arguments with a single best common type
+    var a9d = someGenerics9 `${ { x: 3 }}${ { x: 6 }}${ { x: 6 } }`;
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var a9d: { x: number; };
+    
+    // Generic tag with multiple parameters of generic type where one argument is of type 'any'
+    var anyVar: any;
+    var a = someGenerics9 `${ 7 }${ anyVar }${ 4 }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var a: any;
+    
+    // Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+    var arr = someGenerics9 `${ [] }${ null }${ undefined }`;
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var arr: any[];
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
new file mode 100644
index 0000000000000..170c10c73817b
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.errors.txt
@@ -0,0 +1,105 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(63,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts(76,11): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts (2 errors) ====
+    
+    // Generic tag with one parameter
+    function noParams<T>(n: T) { }
+    noParams ``;
+    
+    // Generic tag with parameter which does not use type parameter
+    function noGenericParams<T>(n: string[]) { }
+    noGenericParams ``;
+    
+    // Generic tag with multiple type parameters and only one used in parameter type annotation
+    function someGenerics1a<T, U>(n: T, m: number) { }
+    someGenerics1a `${3}`;
+    
+    function someGenerics1b<T, U>(n: string[], m: U) { }
+    someGenerics1b `${3}`;
+    
+    // Generic tag with argument of function type whose parameter is of type parameter type
+    function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+    someGenerics2a `${(n: string) => n}`;
+    
+    function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+    someGenerics2b `${ (n: string, x: number) => n }`;
+    
+    // Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+    function someGenerics3<T>(strs: string[], producer: () => T) { }
+    someGenerics3 `${() => ''}`;
+    someGenerics3 `${() => undefined}`;
+    someGenerics3 `${() => 3}`;
+    
+    // 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+    function someGenerics4<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+    someGenerics4 `${4}${ () => null }`;
+    someGenerics4 `${''}${ () => 3 }`;
+    someGenerics4 `${ null }${ null }`;
+    
+    // 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+    function someGenerics5<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+    someGenerics5 `${ 4 } ${ () => null }`;
+    someGenerics5 `${ '' }${ () => 3 }`;
+    someGenerics5 `${null}${null}`;
+    
+    // Generic tag with multiple arguments of function types that each have parameters of the same generic type
+    function someGenerics6<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+    someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+    someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+    someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`;
+    
+    // Generic tag with multiple arguments of function types that each have parameters of different generic type
+    function someGenerics7<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+    someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+    someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+    someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`;
+    
+    // Generic tag with argument of generic function type
+    function someGenerics8<T>(strs: string[], n: T): T { return n; }
+    var x = someGenerics8 `${ someGenerics7 }`;
+    x `${null}${null}${null}`;
+    
+    // Generic tag with multiple parameters of generic type passed arguments with no best common type
+    function someGenerics9<T>(strs: string[], a: T, b: T, c: T): T {
+        return null;
+    }
+    var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;
+              ~~~~~~~~~~~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'number'.
+    var a9a: {};
+    
+    // Generic tag with multiple parameters of generic type passed arguments with multiple best common types
+    interface A91 {
+        x: number;
+        y?: string;
+    }
+    interface A92 {
+        x: number;
+        z?: Date;
+    }
+    
+    var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
+              ~~~~~~~~~~~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate '{ x: number; z: Date; }' is not a valid type argument because it is not a supertype of candidate '{ x: number; y: string; }'.
+    var a9e: {};
+    
+    // Generic tag with multiple parameters of generic type passed arguments with a single best common type
+    var a9d = someGenerics9 `${ { x: 3 }}${ { x: 6 }}${ { x: 6 } }`;
+    var a9d: { x: number; };
+    
+    // Generic tag with multiple parameters of generic type where one argument is of type 'any'
+    var anyVar: any;
+    var a = someGenerics9 `${ 7 }${ anyVar }${ 4 }`;
+    var a: any;
+    
+    // Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+    var arr = someGenerics9 `${ [] }${ null }${ undefined }`;
+    var arr: any[];
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js
new file mode 100644
index 0000000000000..b88eadfd80ba8
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.js
@@ -0,0 +1,171 @@
+//// [taggedTemplateStringsTypeArgumentInferenceES6.ts]
+
+// Generic tag with one parameter
+function noParams<T>(n: T) { }
+noParams ``;
+
+// Generic tag with parameter which does not use type parameter
+function noGenericParams<T>(n: string[]) { }
+noGenericParams ``;
+
+// Generic tag with multiple type parameters and only one used in parameter type annotation
+function someGenerics1a<T, U>(n: T, m: number) { }
+someGenerics1a `${3}`;
+
+function someGenerics1b<T, U>(n: string[], m: U) { }
+someGenerics1b `${3}`;
+
+// Generic tag with argument of function type whose parameter is of type parameter type
+function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+someGenerics2a `${(n: string) => n}`;
+
+function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+someGenerics2b `${ (n: string, x: number) => n }`;
+
+// Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+function someGenerics3<T>(strs: string[], producer: () => T) { }
+someGenerics3 `${() => ''}`;
+someGenerics3 `${() => undefined}`;
+someGenerics3 `${() => 3}`;
+
+// 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+function someGenerics4<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics4 `${4}${ () => null }`;
+someGenerics4 `${''}${ () => 3 }`;
+someGenerics4 `${ null }${ null }`;
+
+// 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+function someGenerics5<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics5 `${ 4 } ${ () => null }`;
+someGenerics5 `${ '' }${ () => 3 }`;
+someGenerics5 `${null}${null}`;
+
+// Generic tag with multiple arguments of function types that each have parameters of the same generic type
+function someGenerics6<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`;
+
+// Generic tag with multiple arguments of function types that each have parameters of different generic type
+function someGenerics7<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`;
+
+// Generic tag with argument of generic function type
+function someGenerics8<T>(strs: string[], n: T): T { return n; }
+var x = someGenerics8 `${ someGenerics7 }`;
+x `${null}${null}${null}`;
+
+// Generic tag with multiple parameters of generic type passed arguments with no best common type
+function someGenerics9<T>(strs: string[], a: T, b: T, c: T): T {
+    return null;
+}
+var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;
+var a9a: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with multiple best common types
+interface A91 {
+    x: number;
+    y?: string;
+}
+interface A92 {
+    x: number;
+    z?: Date;
+}
+
+var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
+var a9e: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with a single best common type
+var a9d = someGenerics9 `${ { x: 3 }}${ { x: 6 }}${ { x: 6 } }`;
+var a9d: { x: number; };
+
+// Generic tag with multiple parameters of generic type where one argument is of type 'any'
+var anyVar: any;
+var a = someGenerics9 `${ 7 }${ anyVar }${ 4 }`;
+var a: any;
+
+// Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+var arr = someGenerics9 `${ [] }${ null }${ undefined }`;
+var arr: any[];
+
+
+
+//// [taggedTemplateStringsTypeArgumentInferenceES6.js]
+// Generic tag with one parameter
+function noParams(n) {
+}
+noParams ``;
+// Generic tag with parameter which does not use type parameter
+function noGenericParams(n) {
+}
+noGenericParams ``;
+// Generic tag with multiple type parameters and only one used in parameter type annotation
+function someGenerics1a(n, m) {
+}
+someGenerics1a `${3}`;
+function someGenerics1b(n, m) {
+}
+someGenerics1b `${3}`;
+// Generic tag with argument of function type whose parameter is of type parameter type
+function someGenerics2a(strs, n) {
+}
+someGenerics2a `${function (n) { return n; }}`;
+function someGenerics2b(strs, n) {
+}
+someGenerics2b `${function (n, x) { return n; }}`;
+// Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+function someGenerics3(strs, producer) {
+}
+someGenerics3 `${function () { return ''; }}`;
+someGenerics3 `${function () { return undefined; }}`;
+someGenerics3 `${function () { return 3; }}`;
+// 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+function someGenerics4(strs, n, f) {
+}
+someGenerics4 `${4}${function () { return null; }}`;
+someGenerics4 `${''}${function () { return 3; }}`;
+someGenerics4 `${null}${null}`;
+// 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+function someGenerics5(strs, n, f) {
+}
+someGenerics5 `${4} ${function () { return null; }}`;
+someGenerics5 `${''}${function () { return 3; }}`;
+someGenerics5 `${null}${null}`;
+// Generic tag with multiple arguments of function types that each have parameters of the same generic type
+function someGenerics6(strs, a, b, c) {
+}
+someGenerics6 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+someGenerics6 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+someGenerics6 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+// Generic tag with multiple arguments of function types that each have parameters of different generic type
+function someGenerics7(strs, a, b, c) {
+}
+someGenerics7 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+someGenerics7 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+someGenerics7 `${function (n) { return n; }}${function (n) { return n; }}${function (n) { return n; }}`;
+// Generic tag with argument of generic function type
+function someGenerics8(strs, n) {
+    return n;
+}
+var x = someGenerics8 `${someGenerics7}`;
+x `${null}${null}${null}`;
+// Generic tag with multiple parameters of generic type passed arguments with no best common type
+function someGenerics9(strs, a, b, c) {
+    return null;
+}
+var a9a = someGenerics9 `${''}${0}${[]}`;
+var a9a;
+var a9e = someGenerics9 `${undefined}${{ x: 6, z: new Date() }}${{ x: 6, y: '' }}`;
+var a9e;
+// Generic tag with multiple parameters of generic type passed arguments with a single best common type
+var a9d = someGenerics9 `${{ x: 3 }}${{ x: 6 }}${{ x: 6 }}`;
+var a9d;
+// Generic tag with multiple parameters of generic type where one argument is of type 'any'
+var anyVar;
+var a = someGenerics9 `${7}${anyVar}${4}`;
+var a;
+// Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+var arr = someGenerics9 `${[]}${null}${undefined}`;
+var arr;
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.errors.txt
new file mode 100644
index 0000000000000..fcde15afc2745
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts(8,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts(17,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts (2 errors) ====
+    
+    function foo1(strs: TemplateStringsArray, x: number): string;
+    function foo1(strs: string[], x: number): number;
+    function foo1(...stuff: any[]): any {
+        return undefined;
+    }
+    
+    var a = foo1 `${1}`;          // string
+            ~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var b = foo1([], 1);          // number
+    
+    function foo2(strs: string[], x: number): number;
+    function foo2(strs: TemplateStringsArray, x: number): string;
+    function foo2(...stuff: any[]): any {
+        return undefined;
+    }
+    
+    var c = foo2 `${1}`;          // number
+            ~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var d = foo2([], 1);          // number
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js
new file mode 100644
index 0000000000000..44da93f8041b5
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.js
@@ -0,0 +1,38 @@
+//// [taggedTemplateStringsWithOverloadResolution2_ES6.ts]
+function foo1(strs: TemplateStringsArray, x: number): string;
+function foo1(strs: string[], x: number): number;
+function foo1(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo1 `${1}`;          // string
+var b = foo1([], 1);          // number
+
+function foo2(strs: string[], x: number): number;
+function foo2(strs: TemplateStringsArray, x: number): string;
+function foo2(...stuff: any[]): any {
+    return undefined;
+}
+
+var c = foo2 `${1}`;          // number
+var d = foo2([], 1);          // number
+
+//// [taggedTemplateStringsWithOverloadResolution2_ES6.js]
+function foo1() {
+    var stuff = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        stuff[_i - 0] = arguments[_i];
+    }
+    return undefined;
+}
+var a = foo1 `${1}`; // string
+var b = foo1([], 1); // number
+function foo2() {
+    var stuff = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        stuff[_i - 0] = arguments[_i];
+    }
+    return undefined;
+}
+var c = foo2 `${1}`; // number
+var d = foo2([], 1); // number
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types
new file mode 100644
index 0000000000000..d9d918b37bd28
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.types
@@ -0,0 +1,59 @@
+=== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts ===
+function foo1(strs: TemplateStringsArray, x: number): string;
+>foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; }
+>strs : TemplateStringsArray
+>TemplateStringsArray : TemplateStringsArray
+>x : number
+
+function foo1(strs: string[], x: number): number;
+>foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; }
+>strs : string[]
+>x : number
+
+function foo1(...stuff: any[]): any {
+>foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; }
+>stuff : any[]
+
+    return undefined;
+>undefined : undefined
+}
+
+var a = foo1 `${1}`;          // string
+>a : string
+>foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; }
+
+var b = foo1([], 1);          // number
+>b : number
+>foo1([], 1) : number
+>foo1 : { (strs: TemplateStringsArray, x: number): string; (strs: string[], x: number): number; }
+>[] : undefined[]
+
+function foo2(strs: string[], x: number): number;
+>foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; }
+>strs : string[]
+>x : number
+
+function foo2(strs: TemplateStringsArray, x: number): string;
+>foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; }
+>strs : TemplateStringsArray
+>TemplateStringsArray : TemplateStringsArray
+>x : number
+
+function foo2(...stuff: any[]): any {
+>foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; }
+>stuff : any[]
+
+    return undefined;
+>undefined : undefined
+}
+
+var c = foo2 `${1}`;          // number
+>c : number
+>foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; }
+
+var d = foo2([], 1);          // number
+>d : number
+>foo2([], 1) : number
+>foo2 : { (strs: string[], x: number): number; (strs: TemplateStringsArray, x: number): string; }
+>[] : undefined[]
+
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt
new file mode 100644
index 0000000000000..dd943e518f3e7
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.errors.txt
@@ -0,0 +1,160 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(7,17): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(10,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(16,16): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(17,16): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(23,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(26,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(34,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(35,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(36,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(40,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(41,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(42,9): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(45,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(54,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(55,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(56,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(57,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(60,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(64,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(70,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(71,1): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(10,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(19,4): error TS2339: Property 'foo' does not exist on type 'Date'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(45,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(63,9): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(64,18): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts(70,18): error TS2339: Property 'toFixed' does not exist on type 'string'.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts (28 errors) ====
+    
+    // Ambiguous call picks the first overload in declaration order
+    function fn1(strs: TemplateStringsArray, s: string): string;
+    function fn1(strs: TemplateStringsArray, n: number): number;
+    function fn1() { return null; }
+    
+    var s: string = fn1 `${ undefined }`;
+                    ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // No candidate overloads found
+    fn1 `${ {} }`; // Error
+    ~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~~
+!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'.
+    
+    function fn2(strs: TemplateStringsArray, s: string, n: number): number;
+    function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
+    function fn2() { return undefined; }
+    
+    var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
+                   ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var d2       = fn2 `${ 0 }${ undefined }`; // any
+                   ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    d1.foo(); // error
+       ~~~
+!!! error TS2339: Property 'foo' does not exist on type 'Date'.
+    d2();     // no error (typed as any)
+    
+    // Generic and non-generic overload where generic overload is the only candidate
+    fn2 `${ 0 }${ '' }`; // OK
+    ~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic and non-generic overload where non-generic overload is the only candidate
+    fn2 `${ '' }${ 0 }`; // OK
+    ~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic overloads with differing arity
+    function fn3<T>(strs: TemplateStringsArray, n: T): string;
+    function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
+    function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
+    function fn3() { return null; }
+    
+    var s = fn3 `${ 3 }`;
+            ~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var s = fn3 `${'' }${ 3 }${ '' }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var n = fn3 `${ 5 }${ 5 }${ 5 }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var n: number;
+    
+    // Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+    var s = fn3 `${ 4 }`
+            ~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var s = fn3 `${ '' }${ '' }${ '' }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    var n = fn3 `${ '' }${ '' }${ 3 }`;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic overloads with differing arity tagging with argument count that doesn't match any overload
+    fn3 ``; // Error
+    ~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    ~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    // Generic overloads with constraints
+    function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n: T, m: U);
+    function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n: T, m: U);
+    function fn4(strs: TemplateStringsArray)
+    function fn4() { }
+    
+    // Generic overloads with constraints tagged with types that satisfy the constraints
+    fn4 `${ '' }${ 3  }`;
+    ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    fn4 `${ 3  }${ '' }`;
+    ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    fn4 `${ 3  }${ undefined }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    fn4 `${ '' }${ null }`;
+    ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic overloads with constraints called with type arguments that do not satisfy the constraints
+    fn4 `${ null }${ null }`; // Error
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    // Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+    fn4 `${ true }${ null }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+            ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'number'.
+    fn4 `${ null }${ true }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                     ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    
+    // Non - generic overloads where contextual typing of function arguments has errors
+    function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
+    function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
+    function fn5() { return undefined; }
+    fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+                     ~~~~~~~
+!!! error TS2339: Property 'toFixed' does not exist on type 'string'.
+    fn5 `${ (n) => n.substr(0) }`;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.errors.txt
new file mode 100644
index 0000000000000..e65acdee835bf
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.errors.txt
@@ -0,0 +1,93 @@
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(9,9): error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(18,4): error TS2339: Property 'foo' does not exist on type 'Date'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(44,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(62,9): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'number'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(63,18): error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts(69,18): error TS2339: Property 'toFixed' does not exist on type 'string'.
+
+
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts (6 errors) ====
+    // Ambiguous call picks the first overload in declaration order
+    function fn1(strs: TemplateStringsArray, s: string): string;
+    function fn1(strs: TemplateStringsArray, n: number): number;
+    function fn1() { return null; }
+    
+    var s: string = fn1 `${ undefined }`;
+    
+    // No candidate overloads found
+    fn1 `${ {} }`; // Error
+            ~~
+!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'number'.
+    
+    function fn2(strs: TemplateStringsArray, s: string, n: number): number;
+    function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
+    function fn2() { return undefined; }
+    
+    var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
+    var d2 = fn2 `${ 0 }${ undefined }`; // any
+    
+    d1.foo(); // error
+       ~~~
+!!! error TS2339: Property 'foo' does not exist on type 'Date'.
+    d2();     // no error (typed as any)
+    
+    // Generic and non-generic overload where generic overload is the only candidate
+    fn2 `${ 0 }${ '' }`; // OK
+    
+    // Generic and non-generic overload where non-generic overload is the only candidate
+    fn2 `${ '' }${ 0 }`; // OK
+    
+    // Generic overloads with differing arity
+    function fn3<T>(strs: TemplateStringsArray, n: T): string;
+    function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
+    function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
+    function fn3() { return null; }
+    
+    var s = fn3 `${ 3 }`;
+    var s = fn3 `${'' }${ 3 }${ '' }`;
+    var n = fn3 `${ 5 }${ 5 }${ 5 }`;
+    var n: number;
+    
+    // Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+    var s = fn3 `${ 4 }`
+    var s = fn3 `${ '' }${ '' }${ '' }`;
+    var n = fn3 `${ '' }${ '' }${ 3 }`;
+    
+    // Generic overloads with differing arity tagging with argument count that doesn't match any overload
+    fn3 ``; // Error
+    ~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    // Generic overloads with constraints
+    function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n: T, m: U);
+    function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n: T, m: U);
+    function fn4(strs: TemplateStringsArray)
+    function fn4() { }
+    
+    // Generic overloads with constraints tagged with types that satisfy the constraints
+    fn4 `${ '' }${ 3  }`;
+    fn4 `${ 3  }${ '' }`;
+    fn4 `${ 3  }${ undefined }`;
+    fn4 `${ '' }${ null }`;
+    
+    // Generic overloads with constraints called with type arguments that do not satisfy the constraints
+    fn4 `${ null }${ null }`; // Error
+    
+    // Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+    fn4 `${ true }${ null }`;
+            ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'number'.
+    fn4 `${ null }${ true }`;
+                     ~~~~
+!!! error TS2345: Argument of type 'boolean' is not assignable to parameter of type 'string'.
+    
+    // Non - generic overloads where contextual typing of function arguments has errors
+    function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
+    function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
+    function fn5() { return undefined; }
+    fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
+                     ~~~~~~~
+!!! error TS2339: Property 'toFixed' does not exist on type 'string'.
+    fn5 `${ (n) => n.substr(0) }`;
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.js b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.js
new file mode 100644
index 0000000000000..48af9403a7949
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.js
@@ -0,0 +1,122 @@
+//// [taggedTemplateStringsWithOverloadResolution3_ES6.ts]
+// Ambiguous call picks the first overload in declaration order
+function fn1(strs: TemplateStringsArray, s: string): string;
+function fn1(strs: TemplateStringsArray, n: number): number;
+function fn1() { return null; }
+
+var s: string = fn1 `${ undefined }`;
+
+// No candidate overloads found
+fn1 `${ {} }`; // Error
+
+function fn2(strs: TemplateStringsArray, s: string, n: number): number;
+function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
+function fn2() { return undefined; }
+
+var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
+var d2 = fn2 `${ 0 }${ undefined }`; // any
+
+d1.foo(); // error
+d2();     // no error (typed as any)
+
+// Generic and non-generic overload where generic overload is the only candidate
+fn2 `${ 0 }${ '' }`; // OK
+
+// Generic and non-generic overload where non-generic overload is the only candidate
+fn2 `${ '' }${ 0 }`; // OK
+
+// Generic overloads with differing arity
+function fn3<T>(strs: TemplateStringsArray, n: T): string;
+function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
+function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
+function fn3() { return null; }
+
+var s = fn3 `${ 3 }`;
+var s = fn3 `${'' }${ 3 }${ '' }`;
+var n = fn3 `${ 5 }${ 5 }${ 5 }`;
+var n: number;
+
+// Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+var s = fn3 `${ 4 }`
+var s = fn3 `${ '' }${ '' }${ '' }`;
+var n = fn3 `${ '' }${ '' }${ 3 }`;
+
+// Generic overloads with differing arity tagging with argument count that doesn't match any overload
+fn3 ``; // Error
+
+// Generic overloads with constraints
+function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n: T, m: U);
+function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n: T, m: U);
+function fn4(strs: TemplateStringsArray)
+function fn4() { }
+
+// Generic overloads with constraints tagged with types that satisfy the constraints
+fn4 `${ '' }${ 3  }`;
+fn4 `${ 3  }${ '' }`;
+fn4 `${ 3  }${ undefined }`;
+fn4 `${ '' }${ null }`;
+
+// Generic overloads with constraints called with type arguments that do not satisfy the constraints
+fn4 `${ null }${ null }`; // Error
+
+// Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+fn4 `${ true }${ null }`;
+fn4 `${ null }${ true }`;
+
+// Non - generic overloads where contextual typing of function arguments has errors
+function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
+function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
+function fn5() { return undefined; }
+fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
+fn5 `${ (n) => n.substr(0) }`;
+
+
+
+//// [taggedTemplateStringsWithOverloadResolution3_ES6.js]
+function fn1() {
+    return null;
+}
+var s = fn1 `${undefined}`;
+// No candidate overloads found
+fn1 `${{}}`; // Error
+function fn2() {
+    return undefined;
+}
+var d1 = fn2 `${0}${undefined}`; // contextually typed
+var d2 = fn2 `${0}${undefined}`; // any
+d1.foo(); // error
+d2(); // no error (typed as any)
+// Generic and non-generic overload where generic overload is the only candidate
+fn2 `${0}${''}`; // OK
+// Generic and non-generic overload where non-generic overload is the only candidate
+fn2 `${''}${0}`; // OK
+function fn3() {
+    return null;
+}
+var s = fn3 `${3}`;
+var s = fn3 `${''}${3}${''}`;
+var n = fn3 `${5}${5}${5}`;
+var n;
+// Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+var s = fn3 `${4}`;
+var s = fn3 `${''}${''}${''}`;
+var n = fn3 `${''}${''}${3}`;
+// Generic overloads with differing arity tagging with argument count that doesn't match any overload
+fn3 ``; // Error
+function fn4() {
+}
+// Generic overloads with constraints tagged with types that satisfy the constraints
+fn4 `${''}${3}`;
+fn4 `${3}${''}`;
+fn4 `${3}${undefined}`;
+fn4 `${''}${null}`;
+// Generic overloads with constraints called with type arguments that do not satisfy the constraints
+fn4 `${null}${null}`; // Error
+// Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+fn4 `${true}${null}`;
+fn4 `${null}${true}`;
+function fn5() {
+    return undefined;
+}
+fn5 `${function (n) { return n.toFixed(); }}`; // will error; 'n' should have type 'string'.
+fn5 `${function (n) { return n.substr(0); }}`;
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts
new file mode 100644
index 0000000000000..961544f309a6f
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInference.ts
@@ -0,0 +1,92 @@
+
+
+// Generic tag with one parameter
+function noParams<T>(n: T) { }
+noParams ``;
+
+// Generic tag with parameter which does not use type parameter
+function noGenericParams<T>(n: string[]) { }
+noGenericParams ``;
+
+// Generic tag with multiple type parameters and only one used in parameter type annotation
+function someGenerics1a<T, U>(n: T, m: number) { }
+someGenerics1a `${3}`;
+
+function someGenerics1b<T, U>(n: string[], m: U) { }
+someGenerics1b `${3}`;
+
+// Generic tag with argument of function type whose parameter is of type parameter type
+function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+someGenerics2a `${(n: string) => n}`;
+
+function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+someGenerics2b `${ (n: string, x: number) => n }`;
+
+// Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+function someGenerics3<T>(strs: string[], producer: () => T) { }
+someGenerics3 `${() => ''}`;
+someGenerics3 `${() => undefined}`;
+someGenerics3 `${() => 3}`;
+
+// 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+function someGenerics4<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics4 `${4}${ () => null }`;
+someGenerics4 `${''}${ () => 3 }`;
+someGenerics4 `${ null }${ null }`;
+
+// 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+function someGenerics5<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics5 `${ 4 } ${ () => null }`;
+someGenerics5 `${ '' }${ () => 3 }`;
+someGenerics5 `${null}${null}`;
+
+// Generic tag with multiple arguments of function types that each have parameters of the same generic type
+function someGenerics6<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`;
+
+// Generic tag with multiple arguments of function types that each have parameters of different generic type
+function someGenerics7<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`;
+
+// Generic tag with argument of generic function type
+function someGenerics8<T>(strs: string[], n: T): T { return n; }
+var x = someGenerics8 `${ someGenerics7 }`;
+x `${null}${null}${null}`;
+
+// Generic tag with multiple parameters of generic type passed arguments with no best common type
+function someGenerics9<T>(strs: string[], a: T, b: T, c: T): T {
+    return null;
+}
+var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;
+var a9a: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with multiple best common types
+interface A91 {
+    x: number;
+    y?: string;
+}
+interface A92 {
+    x: number;
+    z?: Date;
+}
+
+var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
+var a9e: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with a single best common type
+var a9d = someGenerics9 `${ { x: 3 }}${ { x: 6 }}${ { x: 6 } }`;
+var a9d: { x: number; };
+
+// Generic tag with multiple parameters of generic type where one argument is of type 'any'
+var anyVar: any;
+var a = someGenerics9 `${ 7 }${ anyVar }${ 4 }`;
+var a: any;
+
+// Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+var arr = someGenerics9 `${ [] }${ null }${ undefined }`;
+var arr: any[];
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts
new file mode 100644
index 0000000000000..bc9fd75cac93c
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsTypeArgumentInferenceES6.ts
@@ -0,0 +1,92 @@
+//@target: es6
+
+// Generic tag with one parameter
+function noParams<T>(n: T) { }
+noParams ``;
+
+// Generic tag with parameter which does not use type parameter
+function noGenericParams<T>(n: string[]) { }
+noGenericParams ``;
+
+// Generic tag with multiple type parameters and only one used in parameter type annotation
+function someGenerics1a<T, U>(n: T, m: number) { }
+someGenerics1a `${3}`;
+
+function someGenerics1b<T, U>(n: string[], m: U) { }
+someGenerics1b `${3}`;
+
+// Generic tag with argument of function type whose parameter is of type parameter type
+function someGenerics2a<T>(strs: string[], n: (x: T) => void) { }
+someGenerics2a `${(n: string) => n}`;
+
+function someGenerics2b<T, U>(strs: string[], n: (x: T, y: U) => void) { }
+someGenerics2b `${ (n: string, x: number) => n }`;
+
+// Generic tag with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+function someGenerics3<T>(strs: string[], producer: () => T) { }
+someGenerics3 `${() => ''}`;
+someGenerics3 `${() => undefined}`;
+someGenerics3 `${() => 3}`;
+
+// 2 parameter generic tag with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+function someGenerics4<T, U>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics4 `${4}${ () => null }`;
+someGenerics4 `${''}${ () => 3 }`;
+someGenerics4 `${ null }${ null }`;
+
+// 2 parameter generic tag with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+function someGenerics5<U, T>(strs: string[], n: T, f: (x: U) => void) { }
+someGenerics5 `${ 4 } ${ () => null }`;
+someGenerics5 `${ '' }${ () => 3 }`;
+someGenerics5 `${null}${null}`;
+
+// Generic tag with multiple arguments of function types that each have parameters of the same generic type
+function someGenerics6<A>(strs: string[], a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ n => n }${ n => n}${ n => n}`;
+someGenerics6 `${ (n: number) => n }${ (n: number) => n }${ (n: number) => n }`;
+
+// Generic tag with multiple arguments of function types that each have parameters of different generic type
+function someGenerics7<A, B, C>(strs: string[], a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${ n => n }${ n => n }${ n => n }`;
+someGenerics7 `${(n: number) => n}${ (n: string) => n}${ (n: number) => n}`;
+
+// Generic tag with argument of generic function type
+function someGenerics8<T>(strs: string[], n: T): T { return n; }
+var x = someGenerics8 `${ someGenerics7 }`;
+x `${null}${null}${null}`;
+
+// Generic tag with multiple parameters of generic type passed arguments with no best common type
+function someGenerics9<T>(strs: string[], a: T, b: T, c: T): T {
+    return null;
+}
+var a9a = someGenerics9 `${ '' }${ 0 }${ [] }`;
+var a9a: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with multiple best common types
+interface A91 {
+    x: number;
+    y?: string;
+}
+interface A92 {
+    x: number;
+    z?: Date;
+}
+
+var a9e = someGenerics9 `${ undefined }${ { x: 6, z: new Date() } }${ { x: 6, y: '' } }`;
+var a9e: {};
+
+// Generic tag with multiple parameters of generic type passed arguments with a single best common type
+var a9d = someGenerics9 `${ { x: 3 }}${ { x: 6 }}${ { x: 6 } }`;
+var a9d: { x: number; };
+
+// Generic tag with multiple parameters of generic type where one argument is of type 'any'
+var anyVar: any;
+var a = someGenerics9 `${ 7 }${ anyVar }${ 4 }`;
+var a: any;
+
+// Generic tag with multiple parameters of generic type where one argument is [] and the other is not 'any'
+var arr = someGenerics9 `${ [] }${ null }${ undefined }`;
+var arr: any[];
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts
new file mode 100644
index 0000000000000..0ed9b86128b02
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2.ts
@@ -0,0 +1,18 @@
+
+function foo1(strs: TemplateStringsArray, x: number): string;
+function foo1(strs: string[], x: number): number;
+function foo1(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo1 `${1}`;          // string
+var b = foo1([], 1);          // number
+
+function foo2(strs: string[], x: number): number;
+function foo2(strs: TemplateStringsArray, x: number): string;
+function foo2(...stuff: any[]): any {
+    return undefined;
+}
+
+var c = foo2 `${1}`;          // number
+var d = foo2([], 1);          // number
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts
new file mode 100644
index 0000000000000..6c67de325e25a
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution2_ES6.ts
@@ -0,0 +1,18 @@
+//@target: es6
+function foo1(strs: TemplateStringsArray, x: number): string;
+function foo1(strs: string[], x: number): number;
+function foo1(...stuff: any[]): any {
+    return undefined;
+}
+
+var a = foo1 `${1}`;          // string
+var b = foo1([], 1);          // number
+
+function foo2(strs: string[], x: number): number;
+function foo2(strs: TemplateStringsArray, x: number): string;
+function foo2(...stuff: any[]): any {
+    return undefined;
+}
+
+var c = foo2 `${1}`;          // number
+var d = foo2([], 1);          // number
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts
new file mode 100644
index 0000000000000..c390e92de56e3
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3.ts
@@ -0,0 +1,72 @@
+
+// Ambiguous call picks the first overload in declaration order
+function fn1(strs: TemplateStringsArray, s: string): string;
+function fn1(strs: TemplateStringsArray, n: number): number;
+function fn1() { return null; }
+
+var s: string = fn1 `${ undefined }`;
+
+// No candidate overloads found
+fn1 `${ {} }`; // Error
+
+function fn2(strs: TemplateStringsArray, s: string, n: number): number;
+function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
+function fn2() { return undefined; }
+
+var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
+var d2       = fn2 `${ 0 }${ undefined }`; // any
+
+d1.foo(); // error
+d2();     // no error (typed as any)
+
+// Generic and non-generic overload where generic overload is the only candidate
+fn2 `${ 0 }${ '' }`; // OK
+
+// Generic and non-generic overload where non-generic overload is the only candidate
+fn2 `${ '' }${ 0 }`; // OK
+
+// Generic overloads with differing arity
+function fn3<T>(strs: TemplateStringsArray, n: T): string;
+function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
+function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
+function fn3() { return null; }
+
+var s = fn3 `${ 3 }`;
+var s = fn3 `${'' }${ 3 }${ '' }`;
+var n = fn3 `${ 5 }${ 5 }${ 5 }`;
+var n: number;
+
+// Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+var s = fn3 `${ 4 }`
+var s = fn3 `${ '' }${ '' }${ '' }`;
+var n = fn3 `${ '' }${ '' }${ 3 }`;
+
+// Generic overloads with differing arity tagging with argument count that doesn't match any overload
+fn3 ``; // Error
+
+// Generic overloads with constraints
+function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n: T, m: U);
+function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n: T, m: U);
+function fn4(strs: TemplateStringsArray)
+function fn4() { }
+
+// Generic overloads with constraints tagged with types that satisfy the constraints
+fn4 `${ '' }${ 3  }`;
+fn4 `${ 3  }${ '' }`;
+fn4 `${ 3  }${ undefined }`;
+fn4 `${ '' }${ null }`;
+
+// Generic overloads with constraints called with type arguments that do not satisfy the constraints
+fn4 `${ null }${ null }`; // Error
+
+// Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+fn4 `${ true }${ null }`;
+fn4 `${ null }${ true }`;
+
+// Non - generic overloads where contextual typing of function arguments has errors
+function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
+function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
+function fn5() { return undefined; }
+fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
+fn5 `${ (n) => n.substr(0) }`;
+
diff --git a/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts
new file mode 100644
index 0000000000000..a3267e7f0aef7
--- /dev/null
+++ b/tests/cases/conformance/es6/templates/taggedTemplateStringsWithOverloadResolution3_ES6.ts
@@ -0,0 +1,72 @@
+//@target: es6
+// Ambiguous call picks the first overload in declaration order
+function fn1(strs: TemplateStringsArray, s: string): string;
+function fn1(strs: TemplateStringsArray, n: number): number;
+function fn1() { return null; }
+
+var s: string = fn1 `${ undefined }`;
+
+// No candidate overloads found
+fn1 `${ {} }`; // Error
+
+function fn2(strs: TemplateStringsArray, s: string, n: number): number;
+function fn2<T>(strs: TemplateStringsArray, n: number, t: T): T;
+function fn2() { return undefined; }
+
+var d1: Date = fn2 `${ 0 }${ undefined }`; // contextually typed
+var d2 = fn2 `${ 0 }${ undefined }`; // any
+
+d1.foo(); // error
+d2();     // no error (typed as any)
+
+// Generic and non-generic overload where generic overload is the only candidate
+fn2 `${ 0 }${ '' }`; // OK
+
+// Generic and non-generic overload where non-generic overload is the only candidate
+fn2 `${ '' }${ 0 }`; // OK
+
+// Generic overloads with differing arity
+function fn3<T>(strs: TemplateStringsArray, n: T): string;
+function fn3<T, U>(strs: TemplateStringsArray, s: string, t: T, u: U): U;
+function fn3<T, U, V>(strs: TemplateStringsArray, v: V, u: U, t: T): number;
+function fn3() { return null; }
+
+var s = fn3 `${ 3 }`;
+var s = fn3 `${'' }${ 3 }${ '' }`;
+var n = fn3 `${ 5 }${ 5 }${ 5 }`;
+var n: number;
+
+// Generic overloads with differing arity tagging with arguments matching each overload type parameter count
+var s = fn3 `${ 4 }`
+var s = fn3 `${ '' }${ '' }${ '' }`;
+var n = fn3 `${ '' }${ '' }${ 3 }`;
+
+// Generic overloads with differing arity tagging with argument count that doesn't match any overload
+fn3 ``; // Error
+
+// Generic overloads with constraints
+function fn4<T extends string, U extends number>(strs: TemplateStringsArray, n: T, m: U);
+function fn4<T extends number, U extends string>(strs: TemplateStringsArray, n: T, m: U);
+function fn4(strs: TemplateStringsArray)
+function fn4() { }
+
+// Generic overloads with constraints tagged with types that satisfy the constraints
+fn4 `${ '' }${ 3  }`;
+fn4 `${ 3  }${ '' }`;
+fn4 `${ 3  }${ undefined }`;
+fn4 `${ '' }${ null }`;
+
+// Generic overloads with constraints called with type arguments that do not satisfy the constraints
+fn4 `${ null }${ null }`; // Error
+
+// Generic overloads with constraints called without type arguments but with types that do not satisfy the constraints
+fn4 `${ true }${ null }`;
+fn4 `${ null }${ true }`;
+
+// Non - generic overloads where contextual typing of function arguments has errors
+function fn5(strs: TemplateStringsArray, f: (n: string) => void): string;
+function fn5(strs: TemplateStringsArray, f: (n: number) => void): number;
+function fn5() { return undefined; }
+fn5 `${ (n) => n.toFixed() }`; // will error; 'n' should have type 'string'.
+fn5 `${ (n) => n.substr(0) }`;
+

From 652b7f890970e9a25492bb0b5a7d58e66e9eb0cc Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 5 Nov 2014 18:34:53 -0800
Subject: [PATCH 3/7] Corrected comment.

---
 src/compiler/checker.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 805a96a6b8487..504d3ce474dde 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5371,7 +5371,7 @@ module ts {
          *
          * If 'node' is a CallExpression or a NewExpression, then its argument list is returned.
          * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution
-         *    expressions, where the first element of the argument list is 'undefined' to represent the "cooked" strings array.
+         *    expressions, where the first element of the argument list is the template portion for error reporting purposes.
          */
         function getEffectiveCallArguments(node: CallExpression | TaggedTemplateExpression): Expression[] {
             var args: Expression[];

From 80b8062a01ee4d79d9d7e696e6aca0a57e4b0a19 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Thu, 6 Nov 2014 17:58:21 -0800
Subject: [PATCH 4/7] Addressed CR feedback.

---
 src/compiler/checker.ts | 128 +++++++++++++++++++++++++---------------
 1 file changed, 81 insertions(+), 47 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 504d3ce474dde..bacce85a34fac 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6,7 +6,6 @@
 /// <reference path="emitter.ts"/>
 
 module ts {
-
     var nextSymbolId = 1;
     var nextNodeId = 1;
     var nextMergeId = 1;
@@ -57,6 +56,8 @@ module ts {
         return stringWriters.pop();
     }
 
+    type CallLikeExpression = CallExpression | TaggedTemplateExpression;
+
     /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
     /// If fullTypeCheck === true,  then the typechecker should do every possible check to produce all errors
     /// If fullTypeCheck === false, the typechecker can take shortcuts and skip checks that only produce errors.
@@ -5183,7 +5184,7 @@ module ts {
             return unknownType;
         }
 
-        function resolveUntypedCall(node: CallExpression | TaggedTemplateExpression): Signature {
+        function resolveUntypedCall(node: CallLikeExpression): Signature {
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
                 checkExpression((<TaggedTemplateExpression>node).template);
             }
@@ -5195,52 +5196,78 @@ module ts {
             return anySignature;
         }
 
-        function resolveErrorCall(node: CallExpression | TaggedTemplateExpression): Signature {
+        function resolveErrorCall(node: CallLikeExpression): Signature {
             resolveUntypedCall(node);
             return unknownSignature;
         }
 
-        function signatureHasCorrectArity(node: CallExpression | TaggedTemplateExpression, args: Expression[], signature: Signature): boolean {
-            var isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
+        function hasCorrectArity(node: CallLikeExpression, args: Expression[], signature: Signature) {
+            var adjustedArgCount: number;
+            var typeArguments: NodeArray<TypeNode>;
+            var callIsIncomplete = false;
 
-            if (!isTaggedTemplate && !(<CallExpression>node).arguments) {
-                // This only happens when we have something of the form:
-                //     new C
-                //
-                Debug.assert(node.kind === SyntaxKind.NewExpression);
-                return signature.minArgumentCount === 0;
-            }
-
-            // For IDE scenarios, since we may have an incomplete call, we make two modifications
-            // to arity checking.
-            //    1. A trailing comma is tantamount to adding another argument
-            //    2. If the call is incomplete (no closing paren) allow fewer arguments than expected
-            var numberOfArgs = !isTaggedTemplate && (<CallExpression>node).arguments.hasTrailingComma
-                ? args.length + 1
-                : args.length;
-            var hasTooManyArguments = !signature.hasRestParameter && numberOfArgs > signature.parameters.length;
-            var hasRightNumberOfTypeArguments = !(<CallExpression>node).typeArguments ||
-                (signature.typeParameters && (<CallExpression>node).typeArguments.length === signature.typeParameters.length);
-
-            if (hasTooManyArguments || !hasRightNumberOfTypeArguments) {
-                return false;
-            }
+            if (node.kind === SyntaxKind.TaggedTemplateExpression) {
+                var tagExpression = <TaggedTemplateExpression>node;
 
-            // If we are missing the close paren, the call is incomplete, and we should skip
-            // the lower bound check.
-            var callIsIncomplete = false;
-            if (isTaggedTemplate) {
-                var template = (<TaggedTemplateExpression>node).template;
-                if (template.kind === SyntaxKind.TemplateExpression) {
-                    var lastSpan = lastOrUndefined((<TemplateExpression>template).templateSpans)
+                adjustedArgCount = args.length;
+                typeArguments = undefined;
+
+                if (tagExpression.kind === SyntaxKind.TemplateExpression) {
+                    // If a tagged template expression lacks a tail literal, the call is incomplete.
+                    var template = <TemplateExpression>tagExpression.template;
+                    var lastSpan = lastOrUndefined(template.templateSpans);
+                    Debug.assert(lastSpan !== undefined); // we should always have at least one span.
                     callIsIncomplete = lastSpan === undefined || lastSpan.literal.kind !== SyntaxKind.TemplateTail;
                 }
             }
             else {
-                callIsIncomplete = (<CallExpression>node).arguments.end === node.end;
+                var callExpression = <CallExpression>node;
+                if (!callExpression.arguments) {
+                    // This only happens when we have something of the form: 'new C'
+                    Debug.assert(callExpression.kind === SyntaxKind.NewExpression);
+
+                    return signature.minArgumentCount === 0;
+                }
+                else {
+                    // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument.
+                    adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length;
+
+                    // If we are missing the close paren, the call is incomplete.
+                    callIsIncomplete = (<CallExpression>callExpression).arguments.end === callExpression.end;
+                }
+
+                typeArguments = callExpression.typeArguments;
+            }
+
+            return checkArity(adjustedArgCount, typeArguments, callIsIncomplete, signature);
+
+            /**
+             * @param adjustedArgCount The "apparent" number of arguments that we will have in this call.
+             * @param typeArguments    Type arguments node of the call if it exists; undefined otherwise.
+             * @param callIsIncomplete Whether or not a call is unfinished, and we should be "lenient" when we have too few arguments.
+             * @param signature        The signature whose arity we are comparing.
+             */
+            function checkArity(adjustedArgCount: number,
+                                typeArguments: NodeArray<TypeNode>,
+                                callIsIncomplete: boolean,
+                                signature: Signature): boolean {
+                // Too many arguments implies incorrect arity.
+                if (!signature.hasRestParameter && adjustedArgCount > signature.parameters.length) {
+                    return false;
+                }
+
+                // If the user supplied type arguments, but the number of type arguments does not match
+                // the declared number of type parameters, the call has an incorrect arity.
+                var hasRightNumberOfTypeArgs = !typeArguments ||
+                    (signature.typeParameters && typeArguments.length === signature.typeParameters.length);
+                if (!hasRightNumberOfTypeArgs) {
+                    return false;
+                }
+
+                // If the call is incomplete, we should skip the lower bound check.
+                var hasEnoughArguments = adjustedArgCount >= signature.minArgumentCount;
+                return callIsIncomplete || hasEnoughArguments;
             }
-            var hasEnoughArguments = numberOfArgs >= signature.minArgumentCount;
-            return callIsIncomplete || hasEnoughArguments;
         }
 
         // If type has a single call signature and no other members, return that signature. Otherwise, return undefined.
@@ -5332,7 +5359,7 @@ module ts {
             return typeArgumentsAreAssignable;
         }
 
-        function checkApplicableSignature(node: CallExpression | TaggedTemplateExpression, args: Node[], signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
+        function checkApplicableSignature(node: CallLikeExpression, args: Node[], signature: Signature, relation: Map<Ternary>, excludeArgument: boolean[], reportErrors: boolean) {
             for (var i = 0; i < args.length; i++) {
                 var arg = args[i];
                 var argType: Type;
@@ -5371,16 +5398,18 @@ module ts {
          *
          * If 'node' is a CallExpression or a NewExpression, then its argument list is returned.
          * If 'node' is a TaggedTemplateExpression, a new argument list is constructed from the substitution
-         *    expressions, where the first element of the argument list is the template portion for error reporting purposes.
+         *    expressions, where the first element of the list is the template for error reporting purposes.
          */
-        function getEffectiveCallArguments(node: CallExpression | TaggedTemplateExpression): Expression[] {
+        function getEffectiveCallArguments(node: CallLikeExpression): Expression[] {
             var args: Expression[];
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
                 var template = (<TaggedTemplateExpression>node).template;
                 args = [template];
 
                 if (template.kind === SyntaxKind.TemplateExpression) {
-                    args.push.apply(args, map((<TemplateExpression>template).templateSpans, span => span.expression));
+                    forEach((<TemplateExpression>template).templateSpans, span => {
+                        args.push(span.expression);
+                    });
                 }
             }
             else {
@@ -5390,7 +5419,7 @@ module ts {
             return args;
         }
 
-        function resolveCall(node: CallExpression | TaggedTemplateExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
+        function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
             var typeArguments = (<CallExpression>node).typeArguments;
             forEach(typeArguments, checkSourceElement);
 
@@ -5410,7 +5439,12 @@ module ts {
             //    - undefined: the argument at 'i' is *not* susceptible to permanent contextual typing.
             //    - false:     the argument at 'i' *was* and *has been* permanently contextually typed.
             //
-            // If the expression is a tagged template, then the first argument is implicitly the "cooked" strings array.
+            // The idea is that we will perform type argument inference & assignability checking once
+            // without using the susceptible parameters, and once more for each susceptible parameter,
+            // contextually typing each as we go along.
+            //
+            // For a tagged template, then the first argument be 'undefined' if necessary
+            // because it represents a TemplateStringsArray.
             var excludeArgument: boolean[];
             for (var i = isTaggedTemplate ? 1 : 0; i < args.length; i++) {
                 if (isContextSensitiveExpression(args[i])) {
@@ -5484,7 +5518,7 @@ module ts {
                 checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
             }
             else if (candidateForTypeArgumentError) {
-                if ((<CallExpression>node).typeArguments) {
+                if (!isTaggedTemplate && (<CallExpression>node).typeArguments) {
                     checkTypeArguments(candidateForTypeArgumentError, (<CallExpression>node).typeArguments, [], /*reportErrors*/ true)
                 }
                 else {
@@ -5510,7 +5544,7 @@ module ts {
             //  f({ |
             if (!fullTypeCheck) {
                 for (var i = 0, n = candidates.length; i < n; i++) {
-                    if (signatureHasCorrectArity(node, args, candidates[i])) {
+                    if (hasCorrectArity(node, args, candidates[i])) {
                         return candidates[i];
                     }
                 }
@@ -5520,7 +5554,7 @@ module ts {
 
             function chooseOverload(candidates: Signature[], relation: Map<Ternary>, excludeArgument: boolean[]) {
                 for (var i = 0; i < candidates.length; i++) {
-                    if (!signatureHasCorrectArity(node, args, candidates[i])) {
+                    if (!hasCorrectArity(node, args, candidates[i])) {
                         continue;
                     }
 
@@ -5751,7 +5785,7 @@ module ts {
 
         // candidatesOutArray is passed by signature help in the language service, and collectCandidates
         // must fill it up with the appropriate candidate signatures
-        function getResolvedSignature(node: CallExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]): Signature {
+        function getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature {
             var links = getNodeLinks(node);
             // If getResolvedSignature has already been called, we will have cached the resolvedSignature.
             // However, it is possible that either candidatesOutArray was not passed in the first time,

From 986a0b7343d6211fb51673f06a2ecf1a2f5f507a Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Fri, 7 Nov 2014 16:23:59 -0800
Subject: [PATCH 5/7] Fixed issues with incomplete calls, cleaned some code up.

---
 src/compiler/checker.ts                       | 55 +++++++++++--------
 src/compiler/parser.ts                        | 15 ++++-
 src/compiler/types.ts                         |  2 +
 ...completeNoSubstitutionTemplate1.errors.txt | 12 ++++
 ...completeNoSubstitutionTemplate2.errors.txt | 12 ++++
 ...hIncompleteTemplateExpressions1.errors.txt | 12 ++++
 ...hIncompleteTemplateExpressions2.errors.txt | 15 +++++
 ...hIncompleteTemplateExpressions3.errors.txt | 15 +++++
 ...hIncompleteTemplateExpressions4.errors.txt | 18 ++++++
 ...hIncompleteTemplateExpressions5.errors.txt | 15 +++++
 ...hIncompleteTemplateExpressions6.errors.txt | 15 +++++
 ...esWithIncompleteNoSubstitutionTemplate1.ts |  7 +++
 ...esWithIncompleteNoSubstitutionTemplate2.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions1.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions2.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions3.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions4.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions5.ts |  7 +++
 ...latesWithIncompleteTemplateExpressions6.ts |  7 +++
 19 files changed, 218 insertions(+), 24 deletions(-)
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt
 create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts
 create mode 100644 tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index bacce85a34fac..436200d94bc62 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -56,8 +56,6 @@ module ts {
         return stringWriters.pop();
     }
 
-    type CallLikeExpression = CallExpression | TaggedTemplateExpression;
-
     /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
     /// If fullTypeCheck === true,  then the typechecker should do every possible check to produce all errors
     /// If fullTypeCheck === false, the typechecker can take shortcuts and skip checks that only produce errors.
@@ -5204,20 +5202,30 @@ module ts {
         function hasCorrectArity(node: CallLikeExpression, args: Expression[], signature: Signature) {
             var adjustedArgCount: number;
             var typeArguments: NodeArray<TypeNode>;
-            var callIsIncomplete = false;
+            var callIsIncomplete: boolean;
 
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
                 var tagExpression = <TaggedTemplateExpression>node;
 
+                // Even if the call is incomplete, we'll have a missing expression as our last argument,
+                // so we can say the count is just the arg list length
                 adjustedArgCount = args.length;
                 typeArguments = undefined;
 
-                if (tagExpression.kind === SyntaxKind.TemplateExpression) {
+                if (tagExpression.template.kind === SyntaxKind.TemplateExpression) {
                     // If a tagged template expression lacks a tail literal, the call is incomplete.
-                    var template = <TemplateExpression>tagExpression.template;
-                    var lastSpan = lastOrUndefined(template.templateSpans);
+                    // Specifically, a template only can end in a TemplateTail or a Missing literal.
+                    var templateExpression = <TemplateExpression>tagExpression.template;
+                    var lastSpan = lastOrUndefined(templateExpression.templateSpans);
                     Debug.assert(lastSpan !== undefined); // we should always have at least one span.
-                    callIsIncomplete = lastSpan === undefined || lastSpan.literal.kind !== SyntaxKind.TemplateTail;
+                    callIsIncomplete = lastSpan.literal.kind === SyntaxKind.Missing || isUnterminatedTemplateEnd(lastSpan.literal);
+                }
+                else {
+                    // If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
+                    // then this might actually turn out to be a TemplateHead in the future;
+                    // so we consider the call to be incomplete.
+                    var templateLiteral = <LiteralExpression>tagExpression.template;
+                    callIsIncomplete = isUnterminatedTemplateEnd(templateLiteral);
                 }
             }
             else {
@@ -5228,17 +5236,17 @@ module ts {
 
                     return signature.minArgumentCount === 0;
                 }
-                else {
-                    // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument.
-                    adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length;
+                
+                // For IDE scenarios we may have an incomplete call, so a trailing comma is tantamount to adding another argument.
+                adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length;
 
-                    // If we are missing the close paren, the call is incomplete.
-                    callIsIncomplete = (<CallExpression>callExpression).arguments.end === callExpression.end;
-                }
+                // If we are missing the close paren, the call is incomplete.
+                callIsIncomplete = (<CallExpression>callExpression).arguments.end === callExpression.end;
 
                 typeArguments = callExpression.typeArguments;
             }
 
+
             return checkArity(adjustedArgCount, typeArguments, callIsIncomplete, signature);
 
             /**
@@ -5420,7 +5428,9 @@ module ts {
         }
 
         function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
-            var typeArguments = (<CallExpression>node).typeArguments;
+            var isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
+
+            var typeArguments = isTaggedTemplate ? undefined : (<CallExpression>node).typeArguments;
             forEach(typeArguments, checkSourceElement);
 
             var candidates = candidatesOutArray || [];
@@ -5432,7 +5442,6 @@ module ts {
             }
 
             var args = getEffectiveCallArguments(node);
-            var isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
             
             // The following applies to any value of 'excludeArgument[i]':
             //    - true:      the argument at 'i' is susceptible to a one-time permanent contextual typing.
@@ -5440,8 +5449,8 @@ module ts {
             //    - false:     the argument at 'i' *was* and *has been* permanently contextually typed.
             //
             // The idea is that we will perform type argument inference & assignability checking once
-            // without using the susceptible parameters, and once more for each susceptible parameter,
-            // contextually typing each as we go along.
+            // without using the susceptible parameters that are functions, and once more for each of those
+            // parameters, contextually typing each as we go along.
             //
             // For a tagged template, then the first argument be 'undefined' if necessary
             // because it represents a TemplateStringsArray.
@@ -5492,14 +5501,14 @@ module ts {
             // is just important for choosing the best signature. So in the case where there is only one
             // signature, the subtype pass is useless. So skipping it is an optimization.
             if (candidates.length > 1) {
-                result = chooseOverload(candidates, subtypeRelation, excludeArgument);
+                result = chooseOverload(candidates, subtypeRelation);
             }
             if (!result) {
                 // Reinitialize these pointers for round two
                 candidateForArgumentError = undefined;
                 candidateForTypeArgumentError = undefined;
                 resultOfFailedInference = undefined;
-                result = chooseOverload(candidates, assignableRelation, excludeArgument);
+                result = chooseOverload(candidates, assignableRelation);
             }
             if (result) {
                 return result;
@@ -5552,7 +5561,7 @@ module ts {
 
             return resolveErrorCall(node);
 
-            function chooseOverload(candidates: Signature[], relation: Map<Ternary>, excludeArgument: boolean[]) {
+            function chooseOverload(candidates: Signature[], relation: Map<Ternary>) {
                 for (var i = 0; i < candidates.length; i++) {
                     if (!hasCorrectArity(node, args, candidates[i])) {
                         continue;
@@ -5566,9 +5575,9 @@ module ts {
                         if (candidate.typeParameters) {
                             var typeArgumentTypes: Type[];
                             var typeArgumentsAreValid: boolean;
-                            if ((<CallExpression>node).typeArguments) {
+                            if (typeArguments) {
                                 typeArgumentTypes = new Array<Type>(candidate.typeParameters.length);
-                                typeArgumentsAreValid = checkTypeArguments(candidate, (<CallExpression>node).typeArguments, typeArgumentTypes, /*reportErrors*/ false)
+                                typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, /*reportErrors*/ false)
                             }
                             else {
                                 inferenceResult = inferTypeArguments(candidate, args, excludeArgument);
@@ -5602,7 +5611,7 @@ module ts {
                         }
                         else {
                             candidateForTypeArgumentError = originalCandidate;
-                            if (!(<CallExpression>node).typeArguments) {
+                            if (!typeArguments) {
                                 resultOfFailedInference = inferenceResult;
                             }
                         }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 5da1952ab2731..1a33b69a706f1 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -564,7 +564,6 @@ module ts {
         return false;
     }
 
-
     export function isDeclaration(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.TypeParameter:
@@ -752,6 +751,20 @@ module ts {
         return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
     }
 
+    export function isUnterminatedTemplateEnd(node: LiteralExpression) {
+        Debug.assert(node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail);
+        var sourceText = getSourceFileOfNode(node).text;
+
+        // If we're not at the EOF, we know we must be terminated.
+        if (node.end !== sourceText.length) {
+            return false;
+        }
+
+        // If we didn't end in a backtick, we must still be in the middle of a template.
+        // If we did, make sure that it's not the *initial* backtick.
+        return sourceText.charCodeAt(node.end - 1) !== CharacterCodes.backtick || node.text.length === 0;
+    }
+
     export function isModifier(token: SyntaxKind): boolean {
         switch (token) {
             case SyntaxKind.PublicKeyword:
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 421f142c2510a..586f8249688e1 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -445,6 +445,8 @@ module ts {
         template: LiteralExpression | TemplateExpression;
     }
 
+    export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;
+
     export interface TypeAssertion extends Expression {
         type: TypeNode;
         operand: Expression;
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt
new file mode 100644
index 0000000000000..51e362deb5d3f
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts(6,15): error TS1126: Unexpected end of text.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts (1 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, not enough parameters.
+    f `123qdawdrqw
+                  
+!!! error TS1126: Unexpected end of text.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt
new file mode 100644
index 0000000000000..1aa00658d8015
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts(6,4): error TS1126: Unexpected end of text.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts (1 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, not enough parameters, at EOF.
+    f `
+       
+!!! error TS1126: Unexpected end of text.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt
new file mode 100644
index 0000000000000..56a557e1a8c05
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts(6,17): error TS1109: Expression expected.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts (1 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, not enough parameters.
+    f `123qdawdrqw${
+                    
+!!! error TS1109: Expression expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt
new file mode 100644
index 0000000000000..065cc2f4787d5
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,18): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts(6,21): error TS1109: Expression expected.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts (2 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, enough parameters.
+    f `123qdawdrqw${ }${
+                     ~
+!!! error TS1109: Expression expected.
+                        
+!!! error TS1109: Expression expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt
new file mode 100644
index 0000000000000..deb8b166699f2
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,23): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts(6,18): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts (2 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, not enough parameters.
+    f `123qdawdrqw${ 1 }${
+                          
+!!! error TS1109: Expression expected.
+                     ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt
new file mode 100644
index 0000000000000..49d55dc2bfd8e
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,24): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,28): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts (3 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, but too many parameters.
+    f `123qdawdrqw${ 1 }${ }${ 
+                           ~
+!!! error TS1109: Expression expected.
+                               
+!!! error TS1109: Expression expected.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt
new file mode 100644
index 0000000000000..27a6263c39198
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,30): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts(6,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts (2 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, but too many parameters.
+    f `123qdawdrqw${ 1 }${ 2 }${ 
+                                 
+!!! error TS1109: Expression expected.
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt
new file mode 100644
index 0000000000000..d8a045b0615c9
--- /dev/null
+++ b/tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,23): error TS1109: Expression expected.
+tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts(6,18): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
+
+
+==== tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts (2 errors) ====
+    
+    function f(x: TemplateStringsArray, y: string, z: string) {
+    }
+    
+    // Incomplete call, not enough parameters, at EOF.
+    f `123qdawdrqw${ 1 }${
+                          
+!!! error TS1109: Expression expected.
+                     ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts
new file mode 100644
index 0000000000000..bc28c710eed54
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, not enough parameters.
+f `123qdawdrqw
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts
new file mode 100644
index 0000000000000..45e2581ce9cb6
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, not enough parameters, at EOF.
+f `
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts
new file mode 100644
index 0000000000000..3fa8bd95d5653
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions1.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, not enough parameters.
+f `123qdawdrqw${
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts
new file mode 100644
index 0000000000000..7af49303c875f
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions2.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, enough parameters.
+f `123qdawdrqw${ }${
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts
new file mode 100644
index 0000000000000..5333686cc2da1
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions3.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, not enough parameters.
+f `123qdawdrqw${ 1 }${
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts
new file mode 100644
index 0000000000000..742c469530334
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions4.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, but too many parameters.
+f `123qdawdrqw${ 1 }${ }${ 
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts
new file mode 100644
index 0000000000000..ce806d202ed40
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions5.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, but too many parameters.
+f `123qdawdrqw${ 1 }${ 2 }${ 
\ No newline at end of file
diff --git a/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts
new file mode 100644
index 0000000000000..e73b0d704663f
--- /dev/null
+++ b/tests/cases/compiler/taggedTemplatesWithIncompleteTemplateExpressions6.ts
@@ -0,0 +1,7 @@
+// @target: es6
+
+function f(x: TemplateStringsArray, y: string, z: string) {
+}
+
+// Incomplete call, not enough parameters, at EOF.
+f `123qdawdrqw${ 1 }${
\ No newline at end of file

From 9880f935eeb6627e04926d79995a9d90a6355495 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Tue, 11 Nov 2014 13:15:32 -0800
Subject: [PATCH 6/7] Asserting myself.

---
 src/compiler/checker.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2b9f7d5eb6b8f..2b8a74a525783 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5249,6 +5249,7 @@ module ts {
                     // then this might actually turn out to be a TemplateHead in the future;
                     // so we consider the call to be incomplete.
                     var templateLiteral = <LiteralExpression>tagExpression.template;
+                    Debug.assert(templateLiteral.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
                     callIsIncomplete = isUnterminatedTemplateEnd(templateLiteral);
                 }
             }

From 3113429de3f7441662ee1757be08ea6bec794842 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Tue, 11 Nov 2014 13:30:10 -0800
Subject: [PATCH 7/7] Asserting myself more.

---
 src/compiler/checker.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 269693f3142ec..5602d1208f97f 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -5271,6 +5271,8 @@ module ts {
                 typeArguments = callExpression.typeArguments;
             }
 
+            Debug.assert(adjustedArgCount !== undefined, "'adjustedArgCount' undefined");
+            Debug.assert(callIsIncomplete !== undefined, "'callIsIncomplete' undefined");
 
             return checkArity(adjustedArgCount, typeArguments, callIsIncomplete, signature);