Changed tests to error when actual contextual typing is broken.

2014-12-15 17:09:56 -08:00 · 2014-12-15 17:09:56 -08:00 · 1f6cd941fd
parent e3848b98b1
commit 1f6cd941fd
6 changed files with 228 additions and 105 deletions
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.js
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.js
@ -1,15 +1,20 @@
 //// [taggedTemplateContextualTyping1.ts]

-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T;
-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T;
+type FuncType = (x: <T>(p: T) => T) => typeof x;
+
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, x: T): T;
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T;
 function tempTag1<T>(...rest: any[]): T {
    return undefined;
 }

-tempTag1 `${ x => x }${ 10 }`;
-tempTag1 `${ x => x }${ y => y }${ 10 }`;
-tempTag1 `${ x => x }${ (y: number) => y }${ undefined }`;
-tempTag1 `${ (x: number) => x }${ y => y }${ undefined }`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y => { y<number>(undefined); return y; }                  }${ 10 }`;
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y: <T>(p: T) => T) => { y<number>(undefined); return y } }${ undefined }`;
+tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y => { y<number>(undefined); return y; }                  }${ undefined }`;


 //// [taggedTemplateContextualTyping1.js]
@ -20,7 +25,28 @@ function tempTag1() {
    }
    return undefined;
 }
-tempTag1 `${function (x) { return x; }}${10}`;
-tempTag1 `${function (x) { return x; }}${function (y) { return y; }}${10}`;
-tempTag1 `${function (x) { return x; }}${function (y) { return y; }}${undefined}`;
-tempTag1 `${function (x) { return x; }}${function (y) { return y; }}${undefined}`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag1 `${function (x) {
+    x(undefined);
+    return x;
+}}${function (y) {
+    y(undefined);
+    return y;
+}}${10}`;
+tempTag1 `${function (x) {
+    x(undefined);
+    return x;
+}}${function (y) {
+    y(undefined);
+    return y;
+}}${undefined}`;
+tempTag1 `${function (x) {
+    x(undefined);
+    return x;
+}}${function (y) {
+    y(undefined);
+    return y;
+}}${undefined}`;
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.types
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types
@ -1,37 +1,40 @@
 === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts ===

-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
+type FuncType = (x: <T>(p: T) => T) => typeof x;
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>T : T
+>p : T
+>T : T
+>T : T
+>x : <T>(p: T) => T
+
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, x: T): T;
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
 >T : T
 >templateStrs : TemplateStringsArray
 >TemplateStringsArray : TemplateStringsArray
->f : (x: T) => T
->x : T
->T : T
->T : T
+>f : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : T
 >T : T
 >T : T

-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T;
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
 >T : T
 >templateStrs : TemplateStringsArray
 >TemplateStringsArray : TemplateStringsArray
->f : (x: T) => T
->x : T
->T : T
->T : T
->h : (y: T) => T
->y : T
->T : T
->T : T
+>f : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
+>h : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : T
 >T : T
 >T : T

 function tempTag1<T>(...rest: any[]): T {
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
 >T : T
 >rest : any[]
 >T : T
@ -40,38 +43,62 @@ function tempTag1<T>(...rest: any[]): T {
 >undefined : undefined
 }

-tempTag1 `${ x => x }${ 10 }`;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
->x => x : (x: number) => number
->x : number
->x : number
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y => { y<number>(undefined); return y; }                  }${ 10 }`;
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>x => { x<number>(undefined); return x; } : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>x<number>(undefined) : number
+>x : <T>(p: T) => T
+>undefined : undefined
+>x : <T>(p: T) => T
+>y => { y<number>(undefined); return y; } : (y: <T>(p: T) => T) => <T>(p: T) => T
+>y : <T>(p: T) => T
+>y<number>(undefined) : number
+>y : <T>(p: T) => T
+>undefined : undefined
+>y : <T>(p: T) => T

-tempTag1 `${ x => x }${ y => y }${ 10 }`;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
->x => x : (x: number) => number
->x : number
->x : number
->y => y : (y: number) => number
->y : number
->y : number
-
-tempTag1 `${ x => x }${ (y: number) => y }${ undefined }`;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
->x => x : (x: number) => number
->x : number
->x : number
->(y: number) => y : (y: number) => number
->y : number
->y : number
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y: <T>(p: T) => T) => { y<number>(undefined); return y } }${ undefined }`;
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>x => { x<number>(undefined); return x; } : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>x<number>(undefined) : number
+>x : <T>(p: T) => T
+>undefined : undefined
+>x : <T>(p: T) => T
+>(y: <T>(p: T) => T) => { y<number>(undefined); return y } : (y: <T>(p: T) => T) => <T>(p: T) => T
+>y : <T>(p: T) => T
+>T : T
+>p : T
+>T : T
+>T : T
+>y<number>(undefined) : number
+>y : <T>(p: T) => T
+>undefined : undefined
+>y : <T>(p: T) => T
 >undefined : undefined

-tempTag1 `${ (x: number) => x }${ y => y }${ undefined }`;
->tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T; }
->(x: number) => x : (x: number) => number
->x : number
->x : number
->y => y : (y: number) => number
->y : number
->y : number
+tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y => { y<number>(undefined); return y; }                  }${ undefined }`;
+>tempTag1 : { <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, h: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>(x: <T>(p: T) => T) => { x<number>(undefined); return x; } : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>T : T
+>p : T
+>T : T
+>T : T
+>x<number>(undefined) : number
+>x : <T>(p: T) => T
+>undefined : undefined
+>x : <T>(p: T) => T
+>y => { y<number>(undefined); return y; } : (y: <T>(p: T) => T) => <T>(p: T) => T
+>y : <T>(p: T) => T
+>y<number>(undefined) : number
+>y : <T>(p: T) => T
+>undefined : undefined
+>y : <T>(p: T) => T
 >undefined : undefined

--- a/tests/baselines/reference/taggedTemplateContextualTyping2.js
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.js
@ -1,14 +1,21 @@
 //// [taggedTemplateContextualTyping2.ts]

-function tempTag2(templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number;
-function tempTag2(templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string;
+type FuncType1 = (x: <T>(p: T) => T) => typeof x;
+type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
+
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number;
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string;
 function tempTag2(...rest: any[]): any {
    return undefined;
 }

-tempTag2 `${ x => x }${ 0 }`;
-tempTag2 `${ x => x }${ y => y }${ "hello" }`;
-tempTag2 `${ x => x }${ 0 }`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ y => { y<string, number>(null); return y; } }${ "hello" }`;
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ undefined }${ "hello" }`;

 //// [taggedTemplateContextualTyping2.js]
 function tempTag2() {
@ -18,6 +25,22 @@ function tempTag2() {
    }
    return undefined;
 }
-tempTag2 `${function (x) { return x; }}${0}`;
-tempTag2 `${function (x) { return x; }}${function (y) { return y; }}${"hello"}`;
-tempTag2 `${function (x) { return x; }}${0}`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag2 `${function (x) {
+    x(undefined);
+    return x;
+}}${0}`;
+tempTag2 `${function (x) {
+    x(undefined);
+    return x;
+}}${function (y) {
+    y(null);
+    return y;
+}}${"hello"}`;
+tempTag2 `${function (x) {
+    x(undefined);
+    return x;
+}}${undefined}${"hello"}`;
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.types
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.types
@ -1,49 +1,84 @@
 === tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts ===

-function tempTag2(templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number;
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
+type FuncType1 = (x: <T>(p: T) => T) => typeof x;
+>FuncType1 : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>T : T
+>p : T
+>T : T
+>T : T
+>x : <T>(p: T) => T
+
+type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
+>FuncType2 : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>x : <S, T>(p: T) => T
+>S : S
+>T : T
+>p : T
+>T : T
+>T : T
+>x : <S, T>(p: T) => T
+
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number;
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
 >templateStrs : TemplateStringsArray
 >TemplateStringsArray : TemplateStringsArray
->f : (x: number) => number
->x : number
+>f : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType1 : (x: <T>(p: T) => T) => <T>(p: T) => T
 >x : number

-function tempTag2(templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string;
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string;
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
 >templateStrs : TemplateStringsArray
 >TemplateStringsArray : TemplateStringsArray
->f : (x: string) => string
->x : string
->h : (y: string) => string
->y : string
+>f : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>FuncType2 : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>h : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>FuncType2 : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
 >x : string

 function tempTag2(...rest: any[]): any {
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
 >rest : any[]

    return undefined;
 >undefined : undefined
 }

-tempTag2 `${ x => x }${ 0 }`;
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
->x => x : (x: number) => number
->x : number
->x : number
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
+>x => { x<number>(undefined); return x; } : (x: <T>(p: T) => T) => <T>(p: T) => T
+>x : <T>(p: T) => T
+>x<number>(undefined) : number
+>x : <T>(p: T) => T
+>undefined : undefined
+>x : <T>(p: T) => T

-tempTag2 `${ x => x }${ y => y }${ "hello" }`;
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
->x => x : (x: string) => string
->x : string
->x : string
->y => y : (y: string) => string
->y : string
->y : string
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ y => { y<string, number>(null); return y; } }${ "hello" }`;
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
+>x => { x<number, string>(undefined); return x; } : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>x : <S, T>(p: T) => T
+>x<number, string>(undefined) : string
+>x : <S, T>(p: T) => T
+>undefined : undefined
+>x : <S, T>(p: T) => T
+>y => { y<string, number>(null); return y; } : (y: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>y : <S, T>(p: T) => T
+>y<string, number>(null) : number
+>y : <S, T>(p: T) => T
+>y : <S, T>(p: T) => T

-tempTag2 `${ x => x }${ 0 }`;
->tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number; (templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string; }
->x => x : (x: number) => number
->x : number
->x : number
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ undefined }${ "hello" }`;
+>tempTag2 : { (templateStrs: TemplateStringsArray, f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: number): number; (templateStrs: TemplateStringsArray, f: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, h: (x: <S, T>(p: T) => T) => <S, T>(p: T) => T, x: string): string; }
+>x => { x<number, string>(undefined); return x; } : (x: <S, T>(p: T) => T) => <S, T>(p: T) => T
+>x : <S, T>(p: T) => T
+>x<number, string>(undefined) : string
+>x : <S, T>(p: T) => T
+>undefined : undefined
+>x : <S, T>(p: T) => T
+>undefined : undefined

--- a/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts
+++ b/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts
@ -1,12 +1,17 @@
 // @target: ES6

-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, x: T): T;
-function tempTag1<T>(templateStrs: TemplateStringsArray, f: (x: T) => T, h: (y: T) => T, x: T): T;
+type FuncType = (x: <T>(p: T) => T) => typeof x;
+
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, x: T): T;
+function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, h: FuncType, x: T): T;
 function tempTag1<T>(...rest: any[]): T {
    return undefined;
 }

-tempTag1 `${ x => x }${ 10 }`;
-tempTag1 `${ x => x }${ y => y }${ 10 }`;
-tempTag1 `${ x => x }${ (y: number) => y }${ undefined }`;
-tempTag1 `${ (x: number) => x }${ y => y }${ undefined }`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ y => { y<number>(undefined); return y; }                  }${ 10 }`;
+tempTag1 `${ x => { x<number>(undefined); return x; }                   }${ (y: <T>(p: T) => T) => { y<number>(undefined); return y } }${ undefined }`;
+tempTag1 `${ (x: <T>(p: T) => T) => { x<number>(undefined); return x; } }${ y => { y<number>(undefined); return y; }                  }${ undefined }`;
--- a/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts
+++ b/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping2.ts
@ -1,11 +1,18 @@
 // @target: ES6

-function tempTag2(templateStrs: TemplateStringsArray, f: (x: number) => number, x: number): number;
-function tempTag2(templateStrs: TemplateStringsArray, f: (x: string) => string, h: (y: string) => string, x: string): string;
+type FuncType1 = (x: <T>(p: T) => T) => typeof x;
+type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
+
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number;
+function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string;
 function tempTag2(...rest: any[]): any {
    return undefined;
 }

-tempTag2 `${ x => x }${ 0 }`;
-tempTag2 `${ x => x }${ y => y }${ "hello" }`;
-tempTag2 `${ x => x }${ 0 }`;
+// If contextual typing takes place, these functions should work.
+// Otherwise, the arrow functions' parameters will be typed as 'any',
+// and it is an error to invoke an any-typed value with type arguments,
+// so this test will error.
+tempTag2 `${ x => { x<number>(undefined); return x; }         }${ 0 }`;
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ y => { y<string, number>(null); return y; } }${ "hello" }`;
+tempTag2 `${ x => { x<number, string>(undefined); return x; } }${ undefined }${ "hello" }`;