Merge branch 'master' into fixCurrentDirectoryForRwc

src/compiler/checker.ts

@@ -3337,6 +3337,8 @@ module ts {
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.MethodSignature:
                     return isContextSensitiveFunctionLikeDeclaration(<MethodDeclaration>node);
+                case SyntaxKind.ParenthesizedExpression:
+                    return isContextSensitive((<ParenthesizedExpression>node).expression);
             }
 
             return false;
@@ -5229,6 +5231,8 @@ module ts {
                 case SyntaxKind.TemplateSpan:
                     Debug.assert(parent.parent.kind === SyntaxKind.TemplateExpression);
                     return getContextualTypeForSubstitutionExpression(<TemplateExpression>parent.parent, node);
+                case SyntaxKind.ParenthesizedExpression:
+                    return getContextualType(<ParenthesizedExpression>parent);
             }
             return undefined;
         }

tests/baselines/reference/castTest.types

@@ -65,8 +65,8 @@ var p_cast = <Point> ({
 >p_cast : Point
 ><Point> ({    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }}) : Point
 >Point : Point
->({    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }}) : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
->{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }} : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
+>({    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }}) : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; }
+>{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    },    mult: function(p) { return p; }} : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; }
 
     x: 0,
 >x : number
@@ -75,10 +75,10 @@ var p_cast = <Point> ({
 >y : number
 
     add: function(dx, dy) {
->add : (dx: any, dy: any) => Point
->function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : (dx: any, dy: any) => Point
->dx : any
->dy : any
+>add : (dx: number, dy: number) => Point
+>function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : (dx: number, dy: number) => Point
+>dx : number
+>dy : number
 
         return new Point(this.x + dx, this.y + dy);
 >new Point(this.x + dx, this.y + dy) : Point
@@ -87,19 +87,19 @@ var p_cast = <Point> ({
 >this.x : any
 >this : any
 >x : any
->dx : any
+>dx : number
 >this.y + dy : any
 >this.y : any
 >this : any
 >y : any
->dy : any
+>dy : number
 
     },
     mult: function(p) { return p; }
->mult : (p: any) => any
->function(p) { return p; } : (p: any) => any
->p : any
->p : any
+>mult : (p: Point) => Point
+>function(p) { return p; } : (p: Point) => Point
+>p : Point
+>p : Point
 
 })
 

tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt

@@ -1,9 +1,17 @@
 tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(2,22): error TS2339: Property 'foo' does not exist on type 'string'.
+tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(3,10): 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 'T'.
+tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(3,32): error TS2339: Property 'foo' does not exist on type 'T'.
 
 
-==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (1 errors) ====
+==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (3 errors) ====
     var f10: <T>(x: T, b: () => (a: T) => void, y: T) => T;
     f10('', () => a => a.foo, ''); // a is string
                          ~~~
 !!! error TS2339: Property 'foo' does not exist on type 'string'.
-    var r9 = f10('', () => (a => a.foo), 1); // error
+    var r9 = f10('', () => (a => a.foo), 1); // error
+             ~~~
+!!! 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 'T'.
+                                   ~~~
+!!! error TS2339: Property 'foo' does not exist on type 'T'.

tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.types

@@ -11,14 +11,14 @@ var a: (a: string) => string;
 
 // bug 786110
 var r = a || ((a) => a.toLowerCase());
->r : (a: any) => any
->a || ((a) => a.toLowerCase()) : (a: any) => any
+>r : (a: string) => string
+>a || ((a) => a.toLowerCase()) : (a: string) => string
 >a : (a: string) => string
->((a) => a.toLowerCase()) : (a: any) => any
->(a) => a.toLowerCase() : (a: any) => any
->a : any
->a.toLowerCase() : any
->a.toLowerCase : any
->a : any
->toLowerCase : any
+>((a) => a.toLowerCase()) : (a: string) => string
+>(a) => a.toLowerCase() : (a: string) => string
+>a : string
+>a.toLowerCase() : string
+>a.toLowerCase : () => string
+>a : string
+>toLowerCase : () => string
 

tests/baselines/reference/parenthesizedContexualTyping1.js

@@ -0,0 +1,52 @@
+//// [parenthesizedContexualTyping1.ts]
+
+function fun<T>(g: (x: T) => T, x: T): T;
+function fun<T>(g: (x: T) => T, h: (y: T) => T, x: T): T;
+function fun<T>(g: (x: T) => T, x: T): T {
+    return g(x);
+}
+
+var a = fun(x => x, 10);
+var b = fun((x => x), 10);
+var c = fun(((x => x)), 10);
+var d = fun((((x => x))), 10);
+
+var e = fun(x => x, x => x, 10);
+var f = fun((x => x), (x => x), 10);
+var g = fun(((x => x)), ((x => x)), 10);
+var h = fun((((x => x))), ((x => x)), 10);
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
+var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
+var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
+var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10);
+
+var lambda1: (x: number) => number = x => x;
+var lambda2: (x: number) => number = (x => x);
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
+
+//// [parenthesizedContexualTyping1.js]
+function fun(g, x) {
+    return g(x);
+}
+var a = fun(function (x) { return x; }, 10);
+var b = fun((function (x) { return x; }), 10);
+var c = fun(((function (x) { return x; })), 10);
+var d = fun((((function (x) { return x; }))), 10);
+var e = fun(function (x) { return x; }, function (x) { return x; }, 10);
+var f = fun((function (x) { return x; }), (function (x) { return x; }), 10);
+var g = fun(((function (x) { return x; })), ((function (x) { return x; })), 10);
+var h = fun((((function (x) { return x; }))), ((function (x) { return x; })), 10);
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? function (x) { return x; } : function (x) { return undefined; }), 10);
+var j = fun((Math.random() < 0.5 ? (function (x) { return x; }) : (function (x) { return undefined; })), 10);
+var k = fun((Math.random() < 0.5 ? (function (x) { return x; }) : (function (x) { return undefined; })), function (x) { return x; }, 10);
+var l = fun(((Math.random() < 0.5 ? ((function (x) { return x; })) : ((function (x) { return undefined; })))), ((function (x) { return x; })), 10);
+var lambda1 = function (x) { return x; };
+var lambda2 = (function (x) { return x; });
+var obj1 = { x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } };
+var obj2 = ({ x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } });

tests/baselines/reference/parenthesizedContexualTyping1.types

@@ -0,0 +1,289 @@
+=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts ===
+
+function fun<T>(g: (x: T) => T, x: T): T;
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+function fun<T>(g: (x: T) => T, h: (y: T) => T, x: T): T;
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>h : (y: T) => T
+>y : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+function fun<T>(g: (x: T) => T, x: T): T {
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+    return g(x);
+>g(x) : T
+>g : (x: T) => T
+>x : T
+}
+
+var a = fun(x => x, 10);
+>a : number
+>fun(x => x, 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var b = fun((x => x), 10);
+>b : number
+>fun((x => x), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var c = fun(((x => x)), 10);
+>c : number
+>fun(((x => x)), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var d = fun((((x => x))), 10);
+>d : number
+>fun((((x => x))), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(((x => x))) : (x: number) => number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var e = fun(x => x, x => x, 10);
+>e : number
+>fun(x => x, x => x, 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var f = fun((x => x), (x => x), 10);
+>f : number
+>fun((x => x), (x => x), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var g = fun(((x => x)), ((x => x)), 10);
+>g : number
+>fun(((x => x)), ((x => x)), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var h = fun((((x => x))), ((x => x)), 10);
+>h : number
+>fun((((x => x))), ((x => x)), 10) : number
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(((x => x))) : (x: number) => number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
+>i : any
+>fun((Math.random() < 0.5 ? x => x : x => undefined), 10) : any
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? x => x : x => undefined) : (x: number) => any
+>Math.random() < 0.5 ? x => x : x => undefined : (x: number) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>x => undefined : (x: number) => any
+>x : number
+>undefined : undefined
+
+var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
+>j : any
+>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10) : any
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any
+>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>(x => undefined) : (x: number) => any
+>x => undefined : (x: number) => any
+>x : number
+>undefined : undefined
+
+var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
+>k : any
+>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10) : any
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any
+>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>(x => undefined) : (x: number) => any
+>x => undefined : (x: number) => any
+>x : number
+>undefined : undefined
+>x => x : (x: any) => any
+>x : any
+>x : any
+
+var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10);
+>l : any
+>fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10) : any
+>fun : { <T>(g: (x: T) => T, x: T): T; <T>(g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))) : (x: number) => any
+>(Math.random() < 0.5 ? ((x => x)) : ((x => undefined))) : (x: number) => any
+>Math.random() < 0.5 ? ((x => x)) : ((x => undefined)) : (x: number) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>((x => undefined)) : (x: number) => any
+>(x => undefined) : (x: number) => any
+>x => undefined : (x: number) => any
+>x : number
+>undefined : undefined
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var lambda1: (x: number) => number = x => x;
+>lambda1 : (x: number) => number
+>x : number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var lambda2: (x: number) => number = (x => x);
+>lambda2 : (x: number) => number
+>x : number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>x : (p: number) => string
+>p : number
+>y : (p: string) => number
+>p : string
+
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+>obj1 : { x: (p: number) => string; y: (p: string) => number; }
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; }
+>x : (x: number) => any
+>x => (x, undefined) : (x: number) => any
+>x : number
+>(x, undefined) : undefined
+>x, undefined : undefined
+>x : number
+>undefined : undefined
+>y : (y: string) => any
+>y => (y, undefined) : (y: string) => any
+>y : string
+>(y, undefined) : undefined
+>y, undefined : undefined
+>y : string
+>undefined : undefined
+
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
+>obj2 : { x: (p: number) => string; y: (p: string) => number; }
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>({ x: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => any; y: (y: string) => any; }
+>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; }
+>x : (x: number) => any
+>x => (x, undefined) : (x: number) => any
+>x : number
+>(x, undefined) : undefined
+>x, undefined : undefined
+>x : number
+>undefined : undefined
+>y : (y: string) => any
+>y => (y, undefined) : (y: string) => any
+>y : string
+>(y, undefined) : undefined
+>y, undefined : undefined
+>y : string
+>undefined : undefined
+

tests/baselines/reference/parenthesizedContexualTyping2.js

@@ -0,0 +1,128 @@
+//// [parenthesizedContexualTyping2.ts]
+// These tests ensure that in cases where it may *appear* that a value has a type,
+// they actually are properly being contextually typed. The way we test this is
+// that we invoke contextually typed arguments with type arguments.
+// Since 'any' cannot be invoked with type arguments, we should get errors
+// back if contextual typing is not taking effect.
+
+type FuncType = (x: <T>(p: T) => T) => typeof x;
+
+function fun<T>(f: FuncType, x: T): T;
+function fun<T>(f: FuncType, g: FuncType, x: T): T;
+function fun<T>(...rest: any[]): T {
+    return undefined;
+}
+
+var a = fun(x => { x<number>(undefined); return x; }, 10);
+var b = fun((x => { x<number>(undefined); return x; }), 10);
+var c = fun(((x => { x<number>(undefined); return x; })), 10);
+var d = fun((((x => { x<number>(undefined); return x; }))), 10);
+
+var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10);
+var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10);
+var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10);
+var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10);
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10);
+var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10);
+var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10);
+var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10);
+
+var lambda1: FuncType = x => { x<number>(undefined); return x; };
+var lambda2: FuncType = (x => { x<number>(undefined); return x; });
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
+
+//// [parenthesizedContexualTyping2.js]
+// These tests ensure that in cases where it may *appear* that a value has a type,
+// they actually are properly being contextually typed. The way we test this is
+// that we invoke contextually typed arguments with type arguments.
+// Since 'any' cannot be invoked with type arguments, we should get errors
+// back if contextual typing is not taking effect.
+function fun() {
+    var rest = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        rest[_i - 0] = arguments[_i];
+    }
+    return undefined;
+}
+var a = fun(function (x) {
+    x(undefined);
+    return x;
+}, 10);
+var b = fun((function (x) {
+    x(undefined);
+    return x;
+}), 10);
+var c = fun(((function (x) {
+    x(undefined);
+    return x;
+})), 10);
+var d = fun((((function (x) {
+    x(undefined);
+    return x;
+}))), 10);
+var e = fun(function (x) {
+    x(undefined);
+    return x;
+}, function (x) {
+    x(undefined);
+    return x;
+}, 10);
+var f = fun((function (x) {
+    x(undefined);
+    return x;
+}), (function (x) {
+    x(undefined);
+    return x;
+}), 10);
+var g = fun(((function (x) {
+    x(undefined);
+    return x;
+})), ((function (x) {
+    x(undefined);
+    return x;
+})), 10);
+var h = fun((((function (x) {
+    x(undefined);
+    return x;
+}))), ((function (x) {
+    x(undefined);
+    return x;
+})), 10);
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? function (x) {
+    x(undefined);
+    return x;
+} : function (x) { return undefined; }), 10);
+var j = fun((Math.random() < 0.5 ? (function (x) {
+    x(undefined);
+    return x;
+}) : (function (x) { return undefined; })), 10);
+var k = fun((Math.random() < 0.5 ? (function (x) {
+    x(undefined);
+    return x;
+}) : (function (x) { return undefined; })), function (x) {
+    x(undefined);
+    return x;
+}, 10);
+var l = fun(((Math.random() < 0.5 ? ((function (x) {
+    x(undefined);
+    return x;
+})) : ((function (x) { return undefined; })))), ((function (x) {
+    x(undefined);
+    return x;
+})), 10);
+var lambda1 = function (x) {
+    x(undefined);
+    return x;
+};
+var lambda2 = (function (x) {
+    x(undefined);
+    return x;
+});
+var obj1 = { x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } };
+var obj2 = ({ x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } });

tests/baselines/reference/parenthesizedContexualTyping2.types

@@ -0,0 +1,350 @@
+=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts ===
+// These tests ensure that in cases where it may *appear* that a value has a type,
+// they actually are properly being contextually typed. The way we test this is
+// that we invoke contextually typed arguments with type arguments.
+// Since 'any' cannot be invoked with type arguments, we should get errors
+// back if contextual typing is not taking effect.
+
+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 fun<T>(f: FuncType, x: T): T;
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: 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 fun<T>(f: FuncType, g: FuncType, x: T): T;
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>T : T
+>f : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
+>g : (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 fun<T>(...rest: any[]): T {
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>T : T
+>rest : any[]
+>T : T
+
+    return undefined;
+>undefined : undefined
+}
+
+var a = fun(x => { x<number>(undefined); return x; }, 10);
+>a : number
+>fun(x => { x<number>(undefined); return x; }, 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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
+
+var b = fun((x => { x<number>(undefined); return x; }), 10);
+>b : number
+>fun((x => { x<number>(undefined); return x; }), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { 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
+
+var c = fun(((x => { x<number>(undefined); return x; })), 10);
+>c : number
+>fun(((x => { x<number>(undefined); return x; })), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+var d = fun((((x => { x<number>(undefined); return x; }))), 10);
+>d : number
+>fun((((x => { x<number>(undefined); return x; }))), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10);
+>e : number
+>fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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
+>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
+
+var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10);
+>f : number
+>fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { 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
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10);
+>g : number
+>fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+>((x => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10);
+>h : number
+>fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (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 => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+>((x => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10);
+>i : number
+>fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>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
+>x => undefined : (x: <T>(p: T) => T) => any
+>x : <T>(p: T) => T
+>undefined : undefined
+
+var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10);
+>j : number
+>fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+>(x => undefined) : (x: <T>(p: T) => T) => any
+>x => undefined : (x: <T>(p: T) => T) => any
+>x : <T>(p: T) => T
+>undefined : undefined
+
+var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10);
+>k : number
+>fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>(Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+>(x => undefined) : (x: <T>(p: T) => T) => any
+>x => undefined : (x: <T>(p: T) => T) => any
+>x : <T>(p: T) => T
+>undefined : undefined
+>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
+
+var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10);
+>l : number
+>fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10) : number
+>fun : { <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; <T>(f: (x: <T>(p: T) => T) => <T>(p: T) => T, g: (x: <T>(p: T) => T) => <T>(p: T) => T, x: T): T; }
+>((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))) : (x: <T>(p: T) => T) => any
+>(Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined))) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)) : (x: <T>(p: T) => T) => any
+>Math.random() < 0.5 : boolean
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>((x => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+>((x => undefined)) : (x: <T>(p: T) => T) => any
+>(x => undefined) : (x: <T>(p: T) => T) => any
+>x => undefined : (x: <T>(p: T) => T) => any
+>x : <T>(p: T) => T
+>undefined : undefined
+>((x => { x<number>(undefined); return x; })) : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+var lambda1: FuncType = x => { x<number>(undefined); return x; };
+>lambda1 : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: 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
+
+var lambda2: FuncType = (x => { x<number>(undefined); return x; });
+>lambda2 : (x: <T>(p: T) => T) => <T>(p: T) => T
+>FuncType : (x: <T>(p: T) => T) => <T>(p: T) => T
+>(x => { x<number>(undefined); return x; }) : (x: <T>(p: T) => T) => <T>(p: 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
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>x : (p: number) => string
+>p : number
+>y : (p: string) => number
+>p : string
+
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+>obj1 : { x: (p: number) => string; y: (p: string) => number; }
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; }
+>x : (x: number) => any
+>x => (x, undefined) : (x: number) => any
+>x : number
+>(x, undefined) : undefined
+>x, undefined : undefined
+>x : number
+>undefined : undefined
+>y : (y: string) => any
+>y => (y, undefined) : (y: string) => any
+>y : string
+>(y, undefined) : undefined
+>y, undefined : undefined
+>y : string
+>undefined : undefined
+
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });
+>obj2 : { x: (p: number) => string; y: (p: string) => number; }
+>ObjType : { x: (p: number) => string; y: (p: string) => number; }
+>({ x: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => any; y: (y: string) => any; }
+>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; }
+>x : (x: number) => any
+>x => (x, undefined) : (x: number) => any
+>x : number
+>(x, undefined) : undefined
+>x, undefined : undefined
+>x : number
+>undefined : undefined
+>y : (y: string) => any
+>y => (y, undefined) : (y: string) => any
+>y : string
+>(y, undefined) : undefined
+>y, undefined : undefined
+>y : string
+>undefined : undefined
+

tests/baselines/reference/parenthesizedContexualTyping3.js

@@ -0,0 +1,35 @@
+//// [parenthesizedContexualTyping3.ts]
+
+// Contextual typing for parenthesized substitution expressions in tagged templates.
+
+/**
+ * tempFun - Can't have fun for too long.
+ */
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T;
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T;
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
+    return g(x);
+}
+
+var a = tempFun `${ x => x }  ${ 10 }`
+var b = tempFun `${ (x => x) }  ${ 10 }`
+var c = tempFun `${ ((x => x)) } ${ 10 }`
+var d = tempFun `${ x => x } ${ x => x } ${ 10 }`
+var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }`
+var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }`
+var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }`
+var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }`
+
+//// [parenthesizedContexualTyping3.js]
+// Contextual typing for parenthesized substitution expressions in tagged templates.
+function tempFun(tempStrs, g, x) {
+    return g(x);
+}
+var a = tempFun `${function (x) { return x; }}  ${10}`;
+var b = tempFun `${(function (x) { return x; })}  ${10}`;
+var c = tempFun `${((function (x) { return x; }))} ${10}`;
+var d = tempFun `${function (x) { return x; }} ${function (x) { return x; }} ${10}`;
+var e = tempFun `${function (x) { return x; }} ${(function (x) { return x; })} ${10}`;
+var f = tempFun `${function (x) { return x; }} ${((function (x) { return x; }))} ${10}`;
+var g = tempFun `${(function (x) { return x; })} ${(((function (x) { return x; })))} ${10}`;
+var h = tempFun `${(function (x) { return x; })} ${(((function (x) { return x; })))} ${undefined}`;

tests/baselines/reference/parenthesizedContexualTyping3.types

@@ -0,0 +1,142 @@
+=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts ===
+
+// Contextual typing for parenthesized substitution expressions in tagged templates.
+
+/**
+ * tempFun - Can't have fun for too long.
+ */
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T;
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>tempStrs : TemplateStringsArray
+>TemplateStringsArray : TemplateStringsArray
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T;
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>tempStrs : TemplateStringsArray
+>TemplateStringsArray : TemplateStringsArray
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>h : (y: T) => T
+>y : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>T : T
+>tempStrs : TemplateStringsArray
+>TemplateStringsArray : TemplateStringsArray
+>g : (x: T) => T
+>x : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+    return g(x);
+>g(x) : T
+>g : (x: T) => T
+>x : T
+}
+
+var a = tempFun `${ x => x }  ${ 10 }`
+>a : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var b = tempFun `${ (x => x) }  ${ 10 }`
+>b : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var c = tempFun `${ ((x => x)) } ${ 10 }`
+>c : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var d = tempFun `${ x => x } ${ x => x } ${ 10 }`
+>d : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }`
+>e : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }`
+>f : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>x => x : (x: number) => number
+>x : number
+>x : number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }`
+>g : number
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+>(((x => x))) : (x: number) => number
+>((x => x)) : (x: number) => number
+>(x => x) : (x: number) => number
+>x => x : (x: number) => number
+>x : number
+>x : number
+
+var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }`
+>h : any
+>tempFun : { <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; <T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; }
+>(x => x) : (x: any) => any
+>x => x : (x: any) => any
+>x : any
+>x : any
+>(((x => x))) : (x: any) => any
+>((x => x)) : (x: any) => any
+>(x => x) : (x: any) => any
+>x => x : (x: any) => any
+>x : any
+>x : any
+>undefined : undefined
+

tests/baselines/reference/taggedTemplateContextualTyping1.js

@@ -12,6 +12,7 @@ function tempTag1<T>(...rest: any[]): T {
 // 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; }                   }${ 10 }`;
 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 }`;
@@ -25,6 +26,10 @@ function tempTag1(...rest) {
 // 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;
+}}${10}`;
 tempTag1 `${function (x) {
     x(undefined);
     return x;

tests/baselines/reference/taggedTemplateContextualTyping1.types

@@ -47,6 +47,15 @@ function tempTag1<T>(...rest: any[]): T {
 // 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; }                   }${ 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
+
 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

tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts

@@ -0,0 +1,29 @@
+
+function fun<T>(g: (x: T) => T, x: T): T;
+function fun<T>(g: (x: T) => T, h: (y: T) => T, x: T): T;
+function fun<T>(g: (x: T) => T, x: T): T {
+    return g(x);
+}
+
+var a = fun(x => x, 10);
+var b = fun((x => x), 10);
+var c = fun(((x => x)), 10);
+var d = fun((((x => x))), 10);
+
+var e = fun(x => x, x => x, 10);
+var f = fun((x => x), (x => x), 10);
+var g = fun(((x => x)), ((x => x)), 10);
+var h = fun((((x => x))), ((x => x)), 10);
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
+var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
+var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
+var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10);
+
+var lambda1: (x: number) => number = x => x;
+var lambda2: (x: number) => number = (x => x);
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });

tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts

@@ -0,0 +1,36 @@
+// These tests ensure that in cases where it may *appear* that a value has a type,
+// they actually are properly being contextually typed. The way we test this is
+// that we invoke contextually typed arguments with type arguments.
+// Since 'any' cannot be invoked with type arguments, we should get errors
+// back if contextual typing is not taking effect.
+
+type FuncType = (x: <T>(p: T) => T) => typeof x;
+
+function fun<T>(f: FuncType, x: T): T;
+function fun<T>(f: FuncType, g: FuncType, x: T): T;
+function fun<T>(...rest: any[]): T {
+    return undefined;
+}
+
+var a = fun(x => { x<number>(undefined); return x; }, 10);
+var b = fun((x => { x<number>(undefined); return x; }), 10);
+var c = fun(((x => { x<number>(undefined); return x; })), 10);
+var d = fun((((x => { x<number>(undefined); return x; }))), 10);
+
+var e = fun(x => { x<number>(undefined); return x; }, x => { x<number>(undefined); return x; }, 10);
+var f = fun((x => { x<number>(undefined); return x; }),(x => { x<number>(undefined); return x; }), 10);
+var g = fun(((x => { x<number>(undefined); return x; })),((x => { x<number>(undefined); return x; })), 10);
+var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(undefined); return x; })), 10);
+
+// Ternaries in parens
+var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10);
+var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10);
+var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10);
+var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10);
+
+var lambda1: FuncType = x => { x<number>(undefined); return x; };
+var lambda2: FuncType = (x => { x<number>(undefined); return x; });
+
+type ObjType = { x: (p: number) => string; y: (p: string) => number };
+var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) };
+var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) });

tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts

@@ -0,0 +1,21 @@
+// @target: ES6
+
+// Contextual typing for parenthesized substitution expressions in tagged templates.
+
+/**
+ * tempFun - Can't have fun for too long.
+ */
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T;
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T;
+function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
+    return g(x);
+}
+
+var a = tempFun `${ x => x }  ${ 10 }`
+var b = tempFun `${ (x => x) }  ${ 10 }`
+var c = tempFun `${ ((x => x)) } ${ 10 }`
+var d = tempFun `${ x => x } ${ x => x } ${ 10 }`
+var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }`
+var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }`
+var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }`
+var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }`

tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts

@@ -12,6 +12,7 @@ function tempTag1<T>(...rest: any[]): T {
 // 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; }                   }${ 10 }`;
 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 }`;

tests/cases/fourslash/assertContextualType.ts

@@ -2,8 +2,5 @@
 
 ////<(aa: number) =>void >(function myFn(b/**/b) { });
 
-// this line triggers a semantic/syntactic error check, remove line when 788570 is fixed
-edit.insert('');
-
 goTo.marker();
-verify.quickInfoIs('(parameter) bb: any');
+verify.quickInfoIs('(parameter) bb: number');

tests/cases/fourslash/contextualTyping.ts

@@ -212,9 +212,9 @@ verify.quickInfoIs("(parameter) i: number");
 goTo.marker('7');
 verify.quickInfoIs("(var) c3t1: (s: string) => string");
 goTo.marker('8');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('9');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('10');
 verify.quickInfoIs("(var) c3t2: IFoo");
 goTo.marker('11');
@@ -254,11 +254,11 @@ verify.quickInfoIs("(property) foo: IFoo");
 goTo.marker('29');
 verify.quickInfoIs("(var) c3t13: IFoo");
 goTo.marker('30');
-verify.quickInfoIs("(property) f: (i: any, s: any) => any");
+verify.quickInfoIs("(property) f: (i: number, s: string) => string");
 goTo.marker('31');
-verify.quickInfoIs("(parameter) i: any");
+verify.quickInfoIs("(parameter) i: number");
 goTo.marker('32');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('33');
 verify.quickInfoIs("(var) c3t14: IFoo");
 goTo.marker('34');
@@ -286,7 +286,7 @@ verify.quickInfoIs("(var) c7t2: IFoo[]");
 goTo.marker('45');
 verify.quickInfoIs("(property) t1: (s: string) => string");
 goTo.marker('46');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('47');
 verify.quickInfoIs("(property) t2: IFoo");
 goTo.marker('48');
@@ -326,11 +326,11 @@ verify.quickInfoIs("(property) foo: IFoo");
 goTo.marker('65');
 verify.quickInfoIs("(property) t13: IFoo");
 goTo.marker('66');
-verify.quickInfoIs("(property) f: (i: any, s: any) => any");
+verify.quickInfoIs("(property) f: (i: number, s: string) => string");
 goTo.marker('67');
-verify.quickInfoIs("(parameter) i: any");
+verify.quickInfoIs("(parameter) i: number");
 goTo.marker('68');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('69');
 verify.quickInfoIs("(property) t14: IFoo");
 goTo.marker('70');
@@ -346,7 +346,7 @@ verify.quickInfoIs("(parameter) n: number");
 goTo.marker('75');
 verify.quickInfoIs("(var) c12t1: (s: string) => string");
 goTo.marker('76');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('77');
 verify.quickInfoIs("(var) c12t2: IFoo");
 goTo.marker('78');
@@ -386,11 +386,11 @@ verify.quickInfoIs("(property) foo: IFoo");
 goTo.marker('95');
 verify.quickInfoIs("(var) c12t13: IFoo");
 goTo.marker('96');
-verify.quickInfoIs("(property) f: (i: any, s: any) => any");
+verify.quickInfoIs("(property) f: (i: number, s: string) => string");
 goTo.marker('97');
-verify.quickInfoIs("(parameter) i: any");
+verify.quickInfoIs("(parameter) i: number");
 goTo.marker('98');
-verify.quickInfoIs("(parameter) s: any");
+verify.quickInfoIs("(parameter) s: string");
 goTo.marker('99');
 verify.quickInfoIs("(var) c12t14: IFoo");
 goTo.marker('100');