Only disable widening when the expression is contextually typed

weswigham · weswigham · commit 27b0c39138ed · 2018-01-10T18:22:44.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -18251,7 +18251,7 @@ namespace ts {
                 type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
             }
 
-            const widenedType = (isFunctionExpression(func) && !func.name) || isArrowFunction(func) ? type : getWidenedType(type);
+            const widenedType = ((isFunctionExpression(func) && !func.name) || isArrowFunction(func)) && getContextualType(func) ? type : getWidenedType(type);
             switch (functionFlags & FunctionFlags.AsyncGenerator) {
                 case FunctionFlags.AsyncGenerator:
                     return createAsyncIterableIteratorType(widenedType);
diff --git a/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types b/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types
@@ -14,15 +14,15 @@ var r = f<string>(1);
 >1 : 1
 
 var f2 = (x: number) => { return null; }
->f2 : (x: number) => null
->(x: number) => { return null; } : (x: number) => null
+>f2 : (x: number) => any
+>(x: number) => { return null; } : (x: number) => any
 >x : number
 >null : null
 
 var r2 = f2<string>(1);
 >r2 : any
->f2<string>(1) : null
->f2 : (x: number) => null
+>f2<string>(1) : any
+>f2 : (x: number) => any
 >1 : 1
 
 var f3: { (x: number): any; }
diff --git a/tests/baselines/reference/declarationEmitAliasExportStar.js b/tests/baselines/reference/declarationEmitAliasExportStar.js
@@ -28,4 +28,4 @@ export interface ThingB {
 export * from "./thingB";
 //// [index.d.ts]
 import * as things from "./things";
-export declare const thing2: (param: things.ThingB) => null;
+export declare const thing2: (param: things.ThingB) => any;
diff --git a/tests/baselines/reference/declarationEmitAliasExportStar.types b/tests/baselines/reference/declarationEmitAliasExportStar.types
@@ -9,8 +9,8 @@ import * as things from "./things";
 >things : typeof things
 
 export const thing2 = (param: things.ThingB) => null;
->thing2 : (param: things.ThingB) => null
->(param: things.ThingB) => null : (param: things.ThingB) => null
+>thing2 : (param: things.ThingB) => any
+>(param: things.ThingB) => null : (param: things.ThingB) => any
 >param : things.ThingB
 >things : any
 >ThingB : things.ThingB
diff --git a/tests/baselines/reference/decoratorMetadataNoStrictNull.types b/tests/baselines/reference/decoratorMetadataNoStrictNull.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/decoratorMetadataNoStrictNull.ts ===
 const dec = (obj: {}, prop: string) => undefined
->dec : (obj: {}, prop: string) => undefined
->(obj: {}, prop: string) => undefined : (obj: {}, prop: string) => undefined
+>dec : (obj: {}, prop: string) => any
+>(obj: {}, prop: string) => undefined : (obj: {}, prop: string) => any
 >obj : {}
 >prop : string
 >undefined : undefined
@@ -10,11 +10,11 @@ class Foo {
 >Foo : Foo
 
   @dec public foo: string | null;
->dec : (obj: {}, prop: string) => undefined
+>dec : (obj: {}, prop: string) => any
 >foo : string
 >null : null
 
   @dec public bar: string;
->dec : (obj: {}, prop: string) => undefined
+>dec : (obj: {}, prop: string) => any
 >bar : string
 }
diff --git a/tests/baselines/reference/fatarrowfunctionsErrors.types b/tests/baselines/reference/fatarrowfunctionsErrors.types
@@ -39,10 +39,10 @@ var y = x:number => x*x;
 >x : any
 
 false? (() => null): null;
->false? (() => null): null : () => null
+>false? (() => null): null : () => any
 >false : false
->(() => null) : () => null
->() => null : () => null
+>(() => null) : () => any
+>() => null : () => any
 >null : null
 >null : null
 
diff --git a/tests/baselines/reference/functionExpressionReturnTypeNotFresh.js b/tests/baselines/reference/functionExpressionReturnTypeNotFresh.js
@@ -0,0 +1,16 @@
+//// [functionExpressionReturnTypeNotFresh.ts]
+const a = () => ({
+    a: 12,
+    b: 11
+});
+
+declare function f(arg: {a: number}): void;
+f(a());
+
+//// [functionExpressionReturnTypeNotFresh.js]
+"use strict";
+var a = function () { return ({
+    a: 12,
+    b: 11
+}); };
+f(a());
diff --git a/tests/baselines/reference/functionExpressionReturnTypeNotFresh.symbols b/tests/baselines/reference/functionExpressionReturnTypeNotFresh.symbols
@@ -0,0 +1,21 @@
+=== tests/cases/compiler/functionExpressionReturnTypeNotFresh.ts ===
+const a = () => ({
+>a : Symbol(a, Decl(functionExpressionReturnTypeNotFresh.ts, 0, 5))
+
+    a: 12,
+>a : Symbol(a, Decl(functionExpressionReturnTypeNotFresh.ts, 0, 18))
+
+    b: 11
+>b : Symbol(b, Decl(functionExpressionReturnTypeNotFresh.ts, 1, 10))
+
+});
+
+declare function f(arg: {a: number}): void;
+>f : Symbol(f, Decl(functionExpressionReturnTypeNotFresh.ts, 3, 3))
+>arg : Symbol(arg, Decl(functionExpressionReturnTypeNotFresh.ts, 5, 19))
+>a : Symbol(a, Decl(functionExpressionReturnTypeNotFresh.ts, 5, 25))
+
+f(a());
+>f : Symbol(f, Decl(functionExpressionReturnTypeNotFresh.ts, 3, 3))
+>a : Symbol(a, Decl(functionExpressionReturnTypeNotFresh.ts, 0, 5))
+
diff --git a/tests/baselines/reference/functionExpressionReturnTypeNotFresh.types b/tests/baselines/reference/functionExpressionReturnTypeNotFresh.types
@@ -0,0 +1,28 @@
+=== tests/cases/compiler/functionExpressionReturnTypeNotFresh.ts ===
+const a = () => ({
+>a : () => { a: number; b: number; }
+>() => ({    a: 12,    b: 11}) : () => { a: number; b: number; }
+>({    a: 12,    b: 11}) : { a: number; b: number; }
+>{    a: 12,    b: 11} : { a: number; b: number; }
+
+    a: 12,
+>a : number
+>12 : 12
+
+    b: 11
+>b : number
+>11 : 11
+
+});
+
+declare function f(arg: {a: number}): void;
+>f : (arg: { a: number; }) => void
+>arg : { a: number; }
+>a : number
+
+f(a());
+>f(a()) : void
+>f : (arg: { a: number; }) => void
+>a() : { a: number; b: number; }
+>a : () => { a: number; b: number; }
+
diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types
@@ -112,8 +112,8 @@ var nu = null;
 
 var nu = function () {
 >nu : any
->function () {    return null;} () : null
->function () {    return null;} : () => null
+>function () {    return null;} () : any
+>function () {    return null;} : () => any
 
     return null;
 >null : null
@@ -127,8 +127,8 @@ var un = undefined;
 
 var un = function () {
 >un : any
->function () {    return undefined;} () : undefined
->function () {    return undefined;} : () => undefined
+>function () {    return undefined;} () : any
+>function () {    return undefined;} : () => any
 
     return undefined;
 >undefined : undefined
diff --git a/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types b/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types
@@ -34,8 +34,8 @@ class Foo<T> {
 >null : null
 
     static e = function (x: T) { return null; }
->e : (x: any) => null
->function (x: T) { return null; } : (x: any) => null
+>e : (x: any) => any
+>function (x: T) { return null; } : (x: any) => any
 >x : any
 >T : No type information available!
 >null : null
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.types b/tests/baselines/reference/heterogeneousArrayLiterals.types
@@ -88,21 +88,21 @@ var k = [() => 1, () => 1]; // { (): number }[]
 >1 : 1
 
 var l = [() => 1, () => null]; // { (): any }[]
->l : (() => number)[]
->[() => 1, () => null] : (() => number)[]
+>l : (() => any)[]
+>[() => 1, () => null] : (() => any)[]
 >() => 1 : () => number
 >1 : 1
->() => null : () => null
+>() => null : () => any
 >null : null
 
 var m = [() => 1, () => '', () => null]; // { (): any }[]
->m : ((() => number) | (() => string))[]
->[() => 1, () => '', () => null] : ((() => number) | (() => string))[]
+>m : (() => any)[]
+>[() => 1, () => '', () => null] : (() => any)[]
 >() => 1 : () => number
 >1 : 1
 >() => '' : () => string
 >'' : ""
->() => null : () => null
+>() => null : () => any
 >null : null
 
 var n = [[() => 1], [() => '']]; // {}[]
@@ -185,21 +185,21 @@ module Derived {
 >1 : 1
 
     var l = [() => base, () => null]; // { (): any }[]
->l : (() => Base)[]
->[() => base, () => null] : (() => Base)[]
+>l : (() => any)[]
+>[() => base, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
->() => null : () => null
+>() => null : () => any
 >null : null
 
     var m = [() => base, () => derived, () => null]; // { (): any }[]
->m : (() => Base)[]
->[() => base, () => derived, () => null] : (() => Base)[]
+>m : (() => any)[]
+>[() => base, () => derived, () => null] : (() => any)[]
 >() => base : () => Base
 >base : Base
 >() => derived : () => Derived
 >derived : Derived
->() => null : () => null
+>() => null : () => any
 >null : null
 
     var n = [[() => base], [() => derived]]; // { (): Base }[]
@@ -310,13 +310,13 @@ function foo<T, U>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
->() => null : () => null
+>() => null : () => any
 >null : null
 }
 
@@ -364,13 +364,13 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
->() => null : () => null
+>() => null : () => any
 >null : null
 
     var g = [t, base]; // Base[]
@@ -442,13 +442,13 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
->() => null : () => null
+>() => null : () => any
 >null : null
 
     var g = [t, base]; // Base[]
@@ -520,13 +520,13 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >u : U
 
     var f = [() => t, () => u, () => null]; // { (): any }[]
->f : ((() => T) | (() => U))[]
->[() => t, () => u, () => null] : ((() => T) | (() => U))[]
+>f : (() => any)[]
+>[() => t, () => u, () => null] : (() => any)[]
 >() => t : () => T
 >t : T
 >() => u : () => U
 >u : U
->() => null : () => null
+>() => null : () => any
 >null : null
 
     var g = [t, base]; // Base[]
diff --git a/tests/baselines/reference/implicitAnyDeclareFunctionExprWithoutFormalType.types b/tests/baselines/reference/implicitAnyDeclareFunctionExprWithoutFormalType.types
@@ -18,8 +18,8 @@ var lamda3 = function myLambda3(myParam) { }
 >myParam : any
 
 var lamda4 = () => { return null };
->lamda4 : () => null
->() => { return null } : () => null
+>lamda4 : () => any
+>() => { return null } : () => any
 >null : null
 
 // these should be error for implicit any return type
@@ -30,8 +30,8 @@ var lambda5 = function temp() { return null; }
 >null : null
 
 var lambda6 = () => { return null; }
->lambda6 : () => null
->() => { return null; } : () => null
+>lambda6 : () => any
+>() => { return null; } : () => any
 >null : null
 
 var lambda7 = function temp() { return undefined; }
@@ -41,8 +41,8 @@ var lambda7 = function temp() { return undefined; }
 >undefined : undefined
 
 var lambda8 = () => { return undefined; }
->lambda8 : () => undefined
->() => { return undefined; } : () => undefined
+>lambda8 : () => any
+>() => { return undefined; } : () => any
 >undefined : undefined
 
 // this shouldn't be an error
diff --git a/tests/baselines/reference/indirectTypeParameterReferences.types b/tests/baselines/reference/indirectTypeParameterReferences.types
diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
diff --git a/tests/baselines/reference/tsxSfcReturnNull.types b/tests/baselines/reference/tsxSfcReturnNull.types
diff --git a/tests/baselines/reference/typeCheckReturnExpression.types b/tests/baselines/reference/typeCheckReturnExpression.types
diff --git a/tests/baselines/reference/unusedParametersWithUnderscore.types b/tests/baselines/reference/unusedParametersWithUnderscore.types

Original file line number	Diff line number	Diff line change
`@@ -18251,7 +18251,7 @@ namespace ts {`
`18251`	`18251`	`type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);`
`18252`	`18252`	`}`
`18253`	`18253`
`18254`		`- const widenedType = (isFunctionExpression(func) && !func.name) \|\| isArrowFunction(func) ? type : getWidenedType(type);`
	`18254`	`+ const widenedType = ((isFunctionExpression(func) && !func.name) \|\| isArrowFunction(func)) && getContextualType(func) ? type : getWidenedType(type);`
`18255`	`18255`	`switch (functionFlags & FunctionFlags.AsyncGenerator) {`
`18256`	`18256`	`case FunctionFlags.AsyncGenerator:`
`18257`	`18257`	`return createAsyncIterableIteratorType(widenedType);`