From a7d564d3bbe184d088b4d58c354c3754e4a1798d Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 28 Aug 2020 22:42:57 +0000 Subject: [PATCH 1/6] Added test. --- ...opertyErrorForFunctionExpressionReturns.ts | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts diff --git a/tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts b/tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts new file mode 100644 index 0000000000000..e3428b5653c74 --- /dev/null +++ b/tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts @@ -0,0 +1,97 @@ +// @strict: true + +export type SomeObj1 = { a: number, b: number }; + +declare function valueOrGetter(x: T, f: () => T): T; + +namespace arrows { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(() => ({ + a: 100, + b: 200, + c: 300, + })); + + function obj1FactoryFactory(): () => SomeObj1 { + return () => ({ + a: 100, + b: 200, + c: 300, + }); + } + + valueOrGetter({ a: 100, b: 200 }, () => ({ + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + a: 100, + b: 200, + })); + + valueOrGetter({ a: 100, b: 200 }, () => ({ + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + a: 100, + b: 200, + })); +} + +namespace funcExprs { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + function obj1FactoryFactory(): () => SomeObj1 { + return function() { + return { + a: 100, + b: 200, + c: 300, + } + }; + } + + valueOrGetter({ a: 100, b: 200 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); +} \ No newline at end of file From 44c5d87184506df18bde32bd911b7ffeb3a43956 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 28 Aug 2020 22:45:12 +0000 Subject: [PATCH 2/6] Accepted baselines. --- ...rorForFunctionExpressionReturns.errors.txt | 125 +++++++ ...opertyErrorForFunctionExpressionReturns.js | 180 ++++++++++ ...yErrorForFunctionExpressionReturns.symbols | 235 ++++++++++++ ...rtyErrorForFunctionExpressionReturns.types | 333 ++++++++++++++++++ 4 files changed, 873 insertions(+) create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.js create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.symbols create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt new file mode 100644 index 0000000000000..1551f6dd5d8ab --- /dev/null +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt @@ -0,0 +1,125 @@ +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(21,19): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. + Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(27,47): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(38,37): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type '{ a: number; b: number; }'. + Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; b: number; }'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(64,19): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. + Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. + + +==== tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts (5 errors) ==== + export type SomeObj1 = { a: number, b: number }; + + declare function valueOrGetter(x: T, f: () => T): T; + + namespace arrows { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(() => ({ + a: 100, + b: 200, + c: 300, + })); + + function obj1FactoryFactory(): () => SomeObj1 { + return () => ({ + a: 100, + b: 200, + c: 300, + }); + } + + valueOrGetter({ a: 100, b: 200 }, () => ({ + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. +!!! error TS2345: Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +!!! related TS2728 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:24:9: 'c' is declared here. + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + ~~~~~~ +!!! error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. +!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. + a: 100, + b: 200, + })); + + valueOrGetter({ a: 100, b: 200 }, () => ({ + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + ~~~~~~ +!!! error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type '{ a: number; b: number; }'. +!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; b: number; }'. + a: 100, + b: 200, + })); + } + + namespace funcExprs { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + function obj1FactoryFactory(): () => SomeObj1 { + return function() { + return { + a: 100, + b: 200, + c: 300, + } + }; + } + + valueOrGetter({ a: 100, b: 200 }, function() { + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. +!!! error TS2345: Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +!!! related TS2728 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:68:13: 'c' is declared here. + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + ~~~~~~ +!!! error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. +!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + } \ No newline at end of file diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.js b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.js new file mode 100644 index 0000000000000..92f183f5b8656 --- /dev/null +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.js @@ -0,0 +1,180 @@ +//// [excessPropertyErrorForFunctionExpressionReturns.ts] +export type SomeObj1 = { a: number, b: number }; + +declare function valueOrGetter(x: T, f: () => T): T; + +namespace arrows { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(() => ({ + a: 100, + b: 200, + c: 300, + })); + + function obj1FactoryFactory(): () => SomeObj1 { + return () => ({ + a: 100, + b: 200, + c: 300, + }); + } + + valueOrGetter({ a: 100, b: 200 }, () => ({ + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + a: 100, + b: 200, + })); + + valueOrGetter({ a: 100, b: 200 }, () => ({ + a: 100, + b: 200, + c: 300, + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ + a: 100, + b: 200, + })); +} + +namespace funcExprs { + declare function consumeObj1(f: () => SomeObj1): void; + consumeObj1(function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + function obj1FactoryFactory(): () => SomeObj1 { + return function() { + return { + a: 100, + b: 200, + c: 300, + } + }; + } + + valueOrGetter({ a: 100, b: 200 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { + return { + a: 100, + b: 200, + c: 300, + }; + }); +} + +//// [excessPropertyErrorForFunctionExpressionReturns.js] +"use strict"; +exports.__esModule = true; +var arrows; +(function (arrows) { + consumeObj1(function () { return ({ + a: 100, + b: 200, + c: 300 + }); }); + function obj1FactoryFactory() { + return function () { return ({ + a: 100, + b: 200, + c: 300 + }); }; + } + valueOrGetter({ a: 100, b: 200 }, function () { return ({ + a: 100, + b: 200, + c: 300 + }); }); + valueOrGetter({ a: 100, b: 200, c: 300 }, function () { return ({ + a: 100, + b: 200 + }); }); + valueOrGetter({ a: 100, b: 200 }, function () { return ({ + a: 100, + b: 200, + c: 300 + }); }); + valueOrGetter({ a: 100, b: 200, c: 300 }, function () { return ({ + a: 100, + b: 200 + }); }); +})(arrows || (arrows = {})); +var funcExprs; +(function (funcExprs) { + consumeObj1(function () { + return { + a: 100, + b: 200, + c: 300 + }; + }); + function obj1FactoryFactory() { + return function () { + return { + a: 100, + b: 200, + c: 300 + }; + }; + } + valueOrGetter({ a: 100, b: 200 }, function () { + return { + a: 100, + b: 200, + c: 300 + }; + }); + valueOrGetter({ a: 100, b: 200, c: 300 }, function () { + return { + a: 100, + b: 200, + c: 300 + }; + }); + valueOrGetter({ a: 100, b: 200 }, function () { + return { + a: 100, + b: 200, + c: 300 + }; + }); + valueOrGetter({ a: 100, b: 200, c: 300 }, function () { + return { + a: 100, + b: 200, + c: 300 + }; + }); +})(funcExprs || (funcExprs = {})); diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.symbols b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.symbols new file mode 100644 index 0000000000000..e9ebe3d1e9053 --- /dev/null +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.symbols @@ -0,0 +1,235 @@ +=== tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts === +export type SomeObj1 = { a: number, b: number }; +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 24)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 35)) + +declare function valueOrGetter(x: T, f: () => T): T; +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>T : Symbol(T, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 31)) +>x : Symbol(x, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 34)) +>T : Symbol(T, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 31)) +>f : Symbol(f, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 39)) +>T : Symbol(T, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 31)) +>T : Symbol(T, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 31)) + +namespace arrows { +>arrows : Symbol(arrows, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 2, 55)) + + declare function consumeObj1(f: () => SomeObj1): void; +>consumeObj1 : Symbol(consumeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 4, 18)) +>f : Symbol(f, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 5, 33)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) + + consumeObj1(() => ({ +>consumeObj1 : Symbol(consumeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 4, 18)) + + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 6, 24)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 7, 15)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 8, 15)) + + })); + + function obj1FactoryFactory(): () => SomeObj1 { +>obj1FactoryFactory : Symbol(obj1FactoryFactory, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 10, 8)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) + + return () => ({ + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 13, 23)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 14, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 15, 19)) + + }); + } + + valueOrGetter({ a: 100, b: 200 }, () => ({ +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 20, 19)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 20, 27)) + + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 20, 46)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 21, 15)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 22, 15)) + + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 26, 29)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 26, 37)) +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 26, 45)) + + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 26, 64)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 27, 15)) + + })); + + valueOrGetter({ a: 100, b: 200 }, () => ({ +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 31, 29)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 31, 37)) + + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 31, 56)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 32, 15)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 33, 15)) + + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 37, 19)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 37, 27)) +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 37, 35)) + + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 37, 54)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 38, 15)) + + })); +} + +namespace funcExprs { +>funcExprs : Symbol(funcExprs, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 41, 1)) + + declare function consumeObj1(f: () => SomeObj1): void; +>consumeObj1 : Symbol(consumeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 43, 21)) +>f : Symbol(f, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 44, 33)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) + + consumeObj1(function() { +>consumeObj1 : Symbol(consumeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 43, 21)) + + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 46, 16)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 47, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 48, 19)) + + }; + }); + + function obj1FactoryFactory(): () => SomeObj1 { +>obj1FactoryFactory : Symbol(obj1FactoryFactory, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 51, 7)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) + + return function() { + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 55, 20)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 56, 23)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 57, 23)) + } + }; + } + + valueOrGetter({ a: 100, b: 200 }, function() { +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 63, 19)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 63, 27)) + + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 64, 16)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 65, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 66, 19)) + + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 71, 29)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 71, 37)) +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 71, 45)) + + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 72, 16)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 73, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 74, 19)) + + }; + }); + + valueOrGetter({ a: 100, b: 200 }, function() { +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>SomeObj1 : Symbol(SomeObj1, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 0)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 79, 29)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 79, 37)) + + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 80, 16)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 81, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 82, 19)) + + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { +>valueOrGetter : Symbol(valueOrGetter, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 0, 48)) +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 87, 19)) +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 87, 27)) +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 87, 35)) + + return { + a: 100, +>a : Symbol(a, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 88, 16)) + + b: 200, +>b : Symbol(b, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 89, 19)) + + c: 300, +>c : Symbol(c, Decl(excessPropertyErrorForFunctionExpressionReturns.ts, 90, 19)) + + }; + }); +} diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types new file mode 100644 index 0000000000000..379bb4dd44fc2 --- /dev/null +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types @@ -0,0 +1,333 @@ +=== tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts === +export type SomeObj1 = { a: number, b: number }; +>SomeObj1 : SomeObj1 +>a : number +>b : number + +declare function valueOrGetter(x: T, f: () => T): T; +>valueOrGetter : (x: T, f: () => T) => T +>x : T +>f : () => T + +namespace arrows { +>arrows : typeof arrows + + declare function consumeObj1(f: () => SomeObj1): void; +>consumeObj1 : (f: () => SomeObj1) => void +>f : () => SomeObj1 + + consumeObj1(() => ({ +>consumeObj1(() => ({ a: 100, b: 200, c: 300, })) : void +>consumeObj1 : (f: () => SomeObj1) => void +>() => ({ a: 100, b: 200, c: 300, }) : () => { a: number; b: number; c: number; } +>({ a: 100, b: 200, c: 300, }) : { a: number; b: number; c: number; } +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + })); + + function obj1FactoryFactory(): () => SomeObj1 { +>obj1FactoryFactory : () => () => SomeObj1 + + return () => ({ +>() => ({ a: 100, b: 200, c: 300, }) : () => { a: number; b: number; c: number; } +>({ a: 100, b: 200, c: 300, }) : { a: number; b: number; c: number; } +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }); + } + + valueOrGetter({ a: 100, b: 200 }, () => ({ +>valueOrGetter({ a: 100, b: 200 }, () => ({ a: 100, b: 200, c: 300, })) : { a: number; b: number; c: number; } +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200 } : { a: number; b: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>() => ({ a: 100, b: 200, c: 300, }) : () => { a: number; b: number; c: number; } +>({ a: 100, b: 200, c: 300, }) : { a: number; b: number; c: number; } +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ +>valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ a: 100, b: 200, })) : SomeObj1 +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200, c: 300 } : { a: number; b: number; c: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>c : number +>300 : 300 +>() => ({ a: 100, b: 200, }) : () => { a: number; b: number; } +>({ a: 100, b: 200, }) : { a: number; b: number; } +>{ a: 100, b: 200, } : { a: number; b: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + })); + + valueOrGetter({ a: 100, b: 200 }, () => ({ +>valueOrGetter({ a: 100, b: 200 }, () => ({ a: 100, b: 200, c: 300, })) : SomeObj1 +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200 } : { a: number; b: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>() => ({ a: 100, b: 200, c: 300, }) : () => { a: number; b: number; c: number; } +>({ a: 100, b: 200, c: 300, }) : { a: number; b: number; c: number; } +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + })); + + valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ +>valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ a: 100, b: 200, })) : { a: number; b: number; } +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200, c: 300 } : { a: number; b: number; c: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>c : number +>300 : 300 +>() => ({ a: 100, b: 200, }) : () => { a: number; b: number; } +>({ a: 100, b: 200, }) : { a: number; b: number; } +>{ a: 100, b: 200, } : { a: number; b: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + })); +} + +namespace funcExprs { +>funcExprs : typeof funcExprs + + declare function consumeObj1(f: () => SomeObj1): void; +>consumeObj1 : (f: () => SomeObj1) => void +>f : () => SomeObj1 + + consumeObj1(function() { +>consumeObj1(function() { return { a: 100, b: 200, c: 300, }; }) : void +>consumeObj1 : (f: () => SomeObj1) => void +>function() { return { a: 100, b: 200, c: 300, }; } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }; + }); + + function obj1FactoryFactory(): () => SomeObj1 { +>obj1FactoryFactory : () => () => SomeObj1 + + return function() { +>function() { return { a: 100, b: 200, c: 300, } } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + } + }; + } + + valueOrGetter({ a: 100, b: 200 }, function() { +>valueOrGetter({ a: 100, b: 200 }, function() { return { a: 100, b: 200, c: 300, }; }) : { a: number; b: number; } +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200 } : { a: number; b: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>function() { return { a: 100, b: 200, c: 300, }; } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { +>valueOrGetter({ a: 100, b: 200, c: 300 }, function() { return { a: 100, b: 200, c: 300, }; }) : SomeObj1 +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200, c: 300 } : { a: number; b: number; c: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>c : number +>300 : 300 +>function() { return { a: 100, b: 200, c: 300, }; } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }; + }); + + valueOrGetter({ a: 100, b: 200 }, function() { +>valueOrGetter({ a: 100, b: 200 }, function() { return { a: 100, b: 200, c: 300, }; }) : SomeObj1 +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200 } : { a: number; b: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>function() { return { a: 100, b: 200, c: 300, }; } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }; + }); + + valueOrGetter({ a: 100, b: 200, c: 300 }, function() { +>valueOrGetter({ a: 100, b: 200, c: 300 }, function() { return { a: 100, b: 200, c: 300, }; }) : { a: number; b: number; c: number; } +>valueOrGetter : (x: T, f: () => T) => T +>{ a: 100, b: 200, c: 300 } : { a: number; b: number; c: number; } +>a : number +>100 : 100 +>b : number +>200 : 200 +>c : number +>300 : 300 +>function() { return { a: 100, b: 200, c: 300, }; } : () => { a: number; b: number; c: number; } + + return { +>{ a: 100, b: 200, c: 300, } : { a: number; b: number; c: number; } + + a: 100, +>a : number +>100 : 100 + + b: 200, +>b : number +>200 : 200 + + c: 300, +>c : number +>300 : 300 + + }; + }); +} From 8f45d2367ae859ce8267f8c85e2a3e719a4e31e2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 28 Aug 2020 23:56:43 +0000 Subject: [PATCH 3/6] Only widen return types of function expressions in the absence of a contextual signature. --- src/compiler/checker.ts | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0b1804c926a22..46485f24d3687 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -28295,14 +28295,16 @@ namespace ts { returnType = getUnionType(types, UnionReduction.Subtype); } + const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); if (returnType || yieldType || nextType) { - if (yieldType) reportErrorsFromWidening(func, yieldType, WideningKind.GeneratorYield); - if (returnType) reportErrorsFromWidening(func, returnType, WideningKind.FunctionReturn); - if (nextType) reportErrorsFromWidening(func, nextType, WideningKind.GeneratorNext); + if (!contextualSignature) { + if (yieldType) reportErrorsFromWidening(func, yieldType, WideningKind.GeneratorYield); + if (returnType) reportErrorsFromWidening(func, returnType, WideningKind.FunctionReturn); + if (nextType) reportErrorsFromWidening(func, nextType, WideningKind.GeneratorNext); + } if (returnType && isUnitType(returnType) || yieldType && isUnitType(yieldType) || nextType && isUnitType(nextType)) { - const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); const contextualType = !contextualSignature ? undefined : contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType : instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func); @@ -28316,9 +28318,11 @@ namespace ts { } } - if (yieldType) yieldType = getWidenedType(yieldType); - if (returnType) returnType = getWidenedType(returnType); - if (nextType) nextType = getWidenedType(nextType); + if (!contextualSignature) { + if (yieldType) yieldType = getWidenedType(yieldType); + if (returnType) returnType = getWidenedType(returnType); + if (nextType) nextType = getWidenedType(nextType); + } } if (isGenerator) { From e9b467ae4f4ccc8fea84a6f0c0c7380ba6a5ce9f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Sat, 29 Aug 2020 00:12:51 +0000 Subject: [PATCH 4/6] Accepted baselines. --- .../reference/assignmentCompatBug2.errors.txt | 4 +- .../reference/assignmentCompatBug2.types | 16 +-- ...CallSignaturesWithOptionalParameters.types | 128 +++++++++--------- .../contextualTypeArrayReturnType.types | 6 +- ...ertyCheckingWhenTargetIsIntersection.types | 4 +- ...rorForFunctionExpressionReturns.errors.txt | 58 +++++--- ...rtyErrorForFunctionExpressionReturns.types | 6 +- .../expandoFunctionContextualTypesJs.types | 2 +- .../fixingTypeParametersRepeatedly1.types | 6 +- ...functionTypeArgumentAssignmentCompat.types | 2 +- .../reference/generatedContextualTyping.types | 70 +++++----- .../reference/generatorTypeCheck45.types | 2 +- .../reference/generatorTypeCheck46.types | 2 +- .../reference/generatorTypeCheck62.types | 4 +- ...ricCallWithGenericSignatureArguments.types | 12 +- ...icCallWithGenericSignatureArguments3.types | 14 +- .../reference/genericTypeAssertions3.types | 8 +- ...FromGenericFunctionReturnTypes3.errors.txt | 14 +- ...inferFromGenericFunctionReturnTypes3.types | 2 +- ...nferentialTypingObjectLiteralMethod1.types | 4 +- ...nferentialTypingObjectLiteralMethod2.types | 4 +- ...nsFunctionClassesCjsExportAssignment.types | 2 +- ...moduleAugmentationImportsAndExports1.types | 4 +- ...moduleAugmentationImportsAndExports3.types | 4 +- ...moduleAugmentationImportsAndExports4.types | 4 +- ...moduleAugmentationImportsAndExports5.types | 4 +- ...moduleAugmentationImportsAndExports6.types | 4 +- .../moduleAugmentationsImports1.types | 8 +- .../moduleAugmentationsImports2.types | 8 +- .../moduleAugmentationsImports3.types | 4 +- ...licitAnyFunctionExpressionAssignment.types | 6 +- .../parenthesizedContexualTyping1.types | 72 +++++----- .../parenthesizedContexualTyping2.types | 56 ++++---- tests/baselines/reference/promiseType.types | 88 ++++++------ .../reference/restArgAssignmentCompat.types | 2 +- ...TemplateStringsTypeArgumentInference.types | 6 +- ...plateStringsTypeArgumentInferenceES6.types | 6 +- .../reference/typeArgumentInference.types | 6 +- ...ArgumentInferenceConstructSignatures.types | 6 +- ...typeArgumentInferenceWithConstraints.types | 6 +- .../typeParameterFixingWithConstraints.types | 4 +- .../reference/typeReferenceDirectives12.types | 4 +- .../reference/typeReferenceDirectives9.types | 4 +- .../reference/wideningTuples2.errors.txt | 11 ++ .../baselines/reference/wideningTuples2.types | 8 +- 45 files changed, 358 insertions(+), 337 deletions(-) create mode 100644 tests/baselines/reference/wideningTuples2.errors.txt diff --git a/tests/baselines/reference/assignmentCompatBug2.errors.txt b/tests/baselines/reference/assignmentCompatBug2.errors.txt index b8bd7d4847347..776d2b61c96bb 100644 --- a/tests/baselines/reference/assignmentCompatBug2.errors.txt +++ b/tests/baselines/reference/assignmentCompatBug2.errors.txt @@ -6,7 +6,7 @@ tests/cases/compiler/assignmentCompatBug2.ts(5,13): error TS2322: Type '{ b: num Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'. tests/cases/compiler/assignmentCompatBug2.ts(15,1): error TS2741: Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. tests/cases/compiler/assignmentCompatBug2.ts(20,1): error TS2741: Property 'g' is missing in type '{ f: (n: number) => number; m: number; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. -tests/cases/compiler/assignmentCompatBug2.ts(33,1): error TS2741: Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. +tests/cases/compiler/assignmentCompatBug2.ts(33,1): error TS2741: Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => null; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. ==== tests/cases/compiler/assignmentCompatBug2.ts (6 errors) ==== @@ -59,7 +59,7 @@ tests/cases/compiler/assignmentCompatBug2.ts(33,1): error TS2741: Property 'm' i b3 = { ~~ -!!! error TS2741: Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. +!!! error TS2741: Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => null; }' but required in type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'. !!! related TS2728 tests/cases/compiler/assignmentCompatBug2.ts:7:55: 'm' is declared here. f: (n) => { return 0; }, g: (s) => { return 0; }, diff --git a/tests/baselines/reference/assignmentCompatBug2.types b/tests/baselines/reference/assignmentCompatBug2.types index 414f91b5bdcfd..cce5a09461d64 100644 --- a/tests/baselines/reference/assignmentCompatBug2.types +++ b/tests/baselines/reference/assignmentCompatBug2.types @@ -93,9 +93,9 @@ b3 = { }; // error b3 = { ->b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; } +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => null; } >b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } ->{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => null; } f: (n) => { return 0; }, >f : (n: number) => number @@ -118,17 +118,17 @@ b3 = { >0 : 0 k: (a) =>{ return null; }, ->k : (a: any) => any ->(a) =>{ return null; } : (a: any) => any +>k : (a: any) => null +>(a) =>{ return null; } : (a: any) => null >a : any >null : null }; // ok b3 = { ->b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; } +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => null; } >b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } ->{ f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => null; } f: (n) => { return 0; }, >f : (n: number) => number @@ -147,8 +147,8 @@ b3 = { >0 : 0 k: (a) =>{ return null; }, ->k : (a: any) => any ->(a) =>{ return null; } : (a: any) => any +>k : (a: any) => null +>(a) =>{ return null; } : (a: any) => null >a : any >null : null diff --git a/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types index 8f4ff9898751a..5ff4703d9286d 100644 --- a/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types +++ b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types @@ -33,19 +33,19 @@ module ClassTypeParam { >() => { this.a = () => null; // ok, same T of required params this.a = (x?: T) => null; // ok, same T of required params this.a = (x: T) => null; // error, too many required params this.a2 = () => null; // ok, same T of required params this.a2 = (x?: T) => null; // ok, same T of required params this.a2 = (x: T) => null; // ok, same number of params this.a3 = () => null; // ok, fewer required params this.a3 = (x?: T) => null; // ok, fewer required params this.a3 = (x: T) => null; // ok, same T of required params this.a3 = (x: T, y: T) => null; // error, too many required params this.a4 = () => null; // ok, fewer required params this.a4 = (x?: T, y?: T) => null; // ok, fewer required params this.a4 = (x: T) => null; // ok, same T of required params this.a4 = (x: T, y: T) => null; // ok, same number of params this.a5 = () => null; // ok, fewer required params this.a5 = (x?: T, y?: T) => null; // ok, fewer required params this.a5 = (x: T) => null; // ok, all present params match this.a5 = (x: T, y: T) => null; // ok, same number of params } : () => void this.a = () => null; // ok, same T of required params ->this.a = () => null : () => any +>this.a = () => null : () => null >this.a : () => T >this : this >a : () => T ->() => null : () => any +>() => null : () => null >null : null this.a = (x?: T) => null; // ok, same T of required params ->this.a = (x?: T) => null : (x?: T) => any +>this.a = (x?: T) => null : (x?: T) => null >this.a : () => T >this : this >a : () => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null @@ -59,54 +59,54 @@ module ClassTypeParam { >null : null this.a2 = () => null; // ok, same T of required params ->this.a2 = () => null : () => any +>this.a2 = () => null : () => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a2 = (x?: T) => null; // ok, same T of required params ->this.a2 = (x?: T) => null : (x?: T) => any +>this.a2 = (x?: T) => null : (x?: T) => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null this.a2 = (x: T) => null; // ok, same number of params ->this.a2 = (x: T) => null : (x: T) => any +>this.a2 = (x: T) => null : (x: T) => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a3 = () => null; // ok, fewer required params ->this.a3 = () => null : () => any +>this.a3 = () => null : () => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a3 = (x?: T) => null; // ok, fewer required params ->this.a3 = (x?: T) => null : (x?: T) => any +>this.a3 = (x?: T) => null : (x?: T) => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null this.a3 = (x: T) => null; // ok, same T of required params ->this.a3 = (x: T) => null : (x: T) => any +>this.a3 = (x: T) => null : (x: T) => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null @@ -121,76 +121,76 @@ module ClassTypeParam { >null : null this.a4 = () => null; // ok, fewer required params ->this.a4 = () => null : () => any +>this.a4 = () => null : () => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a4 = (x?: T, y?: T) => null; // ok, fewer required params ->this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x?: T, y?: T) => null : (x?: T, y?: T) => any +>(x?: T, y?: T) => null : (x?: T, y?: T) => null >x : T >y : T >null : null this.a4 = (x: T) => null; // ok, same T of required params ->this.a4 = (x: T) => null : (x: T) => any +>this.a4 = (x: T) => null : (x: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a4 = (x: T, y: T) => null; // ok, same number of params ->this.a4 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a4 = (x: T, y: T) => null : (x: T, y: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x: T, y: T) => null : (x: T, y: T) => any +>(x: T, y: T) => null : (x: T, y: T) => null >x : T >y : T >null : null this.a5 = () => null; // ok, fewer required params ->this.a5 = () => null : () => any +>this.a5 = () => null : () => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a5 = (x?: T, y?: T) => null; // ok, fewer required params ->this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x?: T, y?: T) => null : (x?: T, y?: T) => any +>(x?: T, y?: T) => null : (x?: T, y?: T) => null >x : T >y : T >null : null this.a5 = (x: T) => null; // ok, all present params match ->this.a5 = (x: T) => null : (x: T) => any +>this.a5 = (x: T) => null : (x: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a5 = (x: T, y: T) => null; // ok, same number of params ->this.a5 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a5 = (x: T, y: T) => null : (x: T, y: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x: T, y: T) => null : (x: T, y: T) => any +>(x: T, y: T) => null : (x: T, y: T) => null >x : T >y : T >null : null @@ -521,19 +521,19 @@ module GenericSignaturesValid { >() => { this.a = () => null; // ok, same T of required params this.a = (x?: T) => null; // ok, same T of required params this.a = (x: T) => null; // error, too many required params this.a2 = () => null; // ok, same T of required params this.a2 = (x?: T) => null; // ok, same T of required params this.a2 = (x: T) => null; // ok, same number of params this.a3 = () => null; // ok, fewer required params this.a3 = (x?: T) => null; // ok, fewer required params this.a3 = (x: T) => null; // ok, same T of required params this.a3 = (x: T, y: T) => null; // error, too many required params this.a4 = () => null; // ok, fewer required params this.a4 = (x?: T, y?: T) => null; // ok, fewer required params this.a4 = (x: T) => null; // ok, same T of required params this.a4 = (x: T, y: T) => null; // ok, same number of params this.a5 = () => null; // ok, fewer required params this.a5 = (x?: T, y?: T) => null; // ok, fewer required params this.a5 = (x: T) => null; // ok, all present params match this.a5 = (x: T, y: T) => null; // ok, same number of params } : () => void this.a = () => null; // ok, same T of required params ->this.a = () => null : () => any +>this.a = () => null : () => null >this.a : () => T >this : this >a : () => T ->() => null : () => any +>() => null : () => null >null : null this.a = (x?: T) => null; // ok, same T of required params ->this.a = (x?: T) => null : (x?: T) => any +>this.a = (x?: T) => null : (x?: T) => null >this.a : () => T >this : this >a : () => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null @@ -547,54 +547,54 @@ module GenericSignaturesValid { >null : null this.a2 = () => null; // ok, same T of required params ->this.a2 = () => null : () => any +>this.a2 = () => null : () => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a2 = (x?: T) => null; // ok, same T of required params ->this.a2 = (x?: T) => null : (x?: T) => any +>this.a2 = (x?: T) => null : (x?: T) => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null this.a2 = (x: T) => null; // ok, same number of params ->this.a2 = (x: T) => null : (x: T) => any +>this.a2 = (x: T) => null : (x: T) => null >this.a2 : (x?: T) => T >this : this >a2 : (x?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a3 = () => null; // ok, fewer required params ->this.a3 = () => null : () => any +>this.a3 = () => null : () => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a3 = (x?: T) => null; // ok, fewer required params ->this.a3 = (x?: T) => null : (x?: T) => any +>this.a3 = (x?: T) => null : (x?: T) => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->(x?: T) => null : (x?: T) => any +>(x?: T) => null : (x?: T) => null >x : T >null : null this.a3 = (x: T) => null; // ok, same T of required params ->this.a3 = (x: T) => null : (x: T) => any +>this.a3 = (x: T) => null : (x: T) => null >this.a3 : (x: T) => T >this : this >a3 : (x: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null @@ -609,76 +609,76 @@ module GenericSignaturesValid { >null : null this.a4 = () => null; // ok, fewer required params ->this.a4 = () => null : () => any +>this.a4 = () => null : () => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a4 = (x?: T, y?: T) => null; // ok, fewer required params ->this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x?: T, y?: T) => null : (x?: T, y?: T) => any +>(x?: T, y?: T) => null : (x?: T, y?: T) => null >x : T >y : T >null : null this.a4 = (x: T) => null; // ok, same T of required params ->this.a4 = (x: T) => null : (x: T) => any +>this.a4 = (x: T) => null : (x: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a4 = (x: T, y: T) => null; // ok, same number of params ->this.a4 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a4 = (x: T, y: T) => null : (x: T, y: T) => null >this.a4 : (x: T, y?: T) => T >this : this >a4 : (x: T, y?: T) => T ->(x: T, y: T) => null : (x: T, y: T) => any +>(x: T, y: T) => null : (x: T, y: T) => null >x : T >y : T >null : null this.a5 = () => null; // ok, fewer required params ->this.a5 = () => null : () => any +>this.a5 = () => null : () => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->() => null : () => any +>() => null : () => null >null : null this.a5 = (x?: T, y?: T) => null; // ok, fewer required params ->this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x?: T, y?: T) => null : (x?: T, y?: T) => any +>(x?: T, y?: T) => null : (x?: T, y?: T) => null >x : T >y : T >null : null this.a5 = (x: T) => null; // ok, all present params match ->this.a5 = (x: T) => null : (x: T) => any +>this.a5 = (x: T) => null : (x: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x: T) => null : (x: T) => any +>(x: T) => null : (x: T) => null >x : T >null : null this.a5 = (x: T, y: T) => null; // ok, same number of params ->this.a5 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a5 = (x: T, y: T) => null : (x: T, y: T) => null >this.a5 : (x?: T, y?: T) => T >this : this >a5 : (x?: T, y?: T) => T ->(x: T, y: T) => null : (x: T, y: T) => any +>(x: T, y: T) => null : (x: T, y: T) => null >x : T >y : T >null : null diff --git a/tests/baselines/reference/contextualTypeArrayReturnType.types b/tests/baselines/reference/contextualTypeArrayReturnType.types index a782dcbf82486..9c1f4123fcd41 100644 --- a/tests/baselines/reference/contextualTypeArrayReturnType.types +++ b/tests/baselines/reference/contextualTypeArrayReturnType.types @@ -17,11 +17,11 @@ interface Transform3D { var style: IBookStyle = { >style : IBookStyle ->{ initialLeftPageTransforms: (width: number) => { return [ {'ry': null } ]; }} : { initialLeftPageTransforms: (width: number) => { ry: any; }[]; } +>{ initialLeftPageTransforms: (width: number) => { return [ {'ry': null } ]; }} : { initialLeftPageTransforms: (width: number) => { ry: null; }[]; } initialLeftPageTransforms: (width: number) => { ->initialLeftPageTransforms : (width: number) => { ry: any; }[] ->(width: number) => { return [ {'ry': null } ]; } : (width: number) => { ry: any; }[] +>initialLeftPageTransforms : (width: number) => { ry: null; }[] +>(width: number) => { return [ {'ry': null } ]; } : (width: number) => { ry: null; }[] >width : number return [ diff --git a/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.types b/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.types index e00f87383c6b6..d656d058e482b 100644 --- a/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.types +++ b/tests/baselines/reference/deepExcessPropertyCheckingWhenTargetIsIntersection.types @@ -9,7 +9,7 @@ interface StatelessComponent

{ const TestComponent: StatelessComponent = (props) => { >TestComponent : StatelessComponent ->(props) => { return null;} : (props: TestProps & { children?: number; }) => any +>(props) => { return null;} : (props: TestProps & { children?: number; }) => null >props : TestProps & { children?: number; } return null; @@ -48,7 +48,7 @@ const TestComponent2: StatelessComponent = (p >TestComponent2 : StatelessComponent >props2 : { x: number; } >x : number ->(props) => { return null;} : (props: (TestProps & { children?: number; }) | ({ props2: { x: number;}; } & { children?: number; })) => any +>(props) => { return null;} : (props: (TestProps & { children?: number; }) | ({ props2: { x: number;}; } & { children?: number; })) => null >props : (TestProps & { children?: number; }) | ({ props2: { x: number; }; } & { children?: number; }) return null; diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt index 1551f6dd5d8ab..4047161bc5e09 100644 --- a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.errors.txt @@ -1,16 +1,25 @@ -tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(21,19): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. - Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(10,9): error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(17,13): error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(27,47): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. -tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(38,37): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type '{ a: number; b: number; }'. - Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; b: number; }'. -tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(64,19): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. - Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(35,9): error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(50,13): error TS2345: Argument of type '() => { a: number; b: number; c: number; }' is not assignable to parameter of type '() => SomeObj1'. + Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(59,17): error TS2322: Type '() => { a: number; b: number; c: number; }' is not assignable to type '() => SomeObj1'. + Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type 'SomeObj1'. Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(84,13): error TS2345: Argument of type '() => { a: number; b: number; c: number; }' is not assignable to parameter of type '() => SomeObj1'. + Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. + Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. -==== tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts (5 errors) ==== +==== tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts (8 errors) ==== export type SomeObj1 = { a: number, b: number }; declare function valueOrGetter(x: T, f: () => T): T; @@ -21,6 +30,10 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2322: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +!!! related TS6502 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:6:37: The expected type comes from the return type of this signature. })); function obj1FactoryFactory(): () => SomeObj1 { @@ -28,14 +41,14 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2322: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +!!! related TS6502 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:13:36: The expected type comes from the return type of this signature. }); } valueOrGetter({ a: 100, b: 200 }, () => ({ - ~~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. -!!! error TS2345: Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. -!!! related TS2728 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:24:9: 'c' is declared here. a: 100, b: 200, c: 300, @@ -53,12 +66,13 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2322: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. +!!! related TS6502 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:3:44: The expected type comes from the return type of this signature. })); valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ - ~~~~~~ -!!! error TS2345: Argument of type '{ a: number; b: number; c: number; }' is not assignable to parameter of type '{ a: number; b: number; }'. -!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type '{ a: number; b: number; }'. a: 100, b: 200, })); @@ -71,6 +85,10 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2345: Argument of type '() => { a: number; b: number; c: number; }' is not assignable to parameter of type '() => SomeObj1'. +!!! error TS2345: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. }; }); @@ -80,15 +98,15 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2322: Type '() => { a: number; b: number; c: number; }' is not assignable to type '() => SomeObj1'. +!!! error TS2322: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2322: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. } }; } valueOrGetter({ a: 100, b: 200 }, function() { - ~~~~~~~~~~~~~~~~~~ -!!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type '{ a: number; b: number; c: number; }'. -!!! error TS2345: Property 'c' is missing in type '{ a: number; b: number; }' but required in type '{ a: number; b: number; c: number; }'. -!!! related TS2728 tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts:68:13: 'c' is declared here. return { a: 100, b: 200, @@ -112,6 +130,10 @@ tests/cases/compiler/excessPropertyErrorForFunctionExpressionReturns.ts(72,47): a: 100, b: 200, c: 300, + ~~~~~~ +!!! error TS2345: Argument of type '() => { a: number; b: number; c: number; }' is not assignable to parameter of type '() => SomeObj1'. +!!! error TS2345: Type '{ a: number; b: number; c: number; }' is not assignable to type 'SomeObj1'. +!!! error TS2345: Object literal may only specify known properties, and 'c' does not exist in type 'SomeObj1'. }; }); diff --git a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types index 379bb4dd44fc2..fb7726f2d83a3 100644 --- a/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types +++ b/tests/baselines/reference/excessPropertyErrorForFunctionExpressionReturns.types @@ -61,7 +61,7 @@ namespace arrows { } valueOrGetter({ a: 100, b: 200 }, () => ({ ->valueOrGetter({ a: 100, b: 200 }, () => ({ a: 100, b: 200, c: 300, })) : { a: number; b: number; c: number; } +>valueOrGetter({ a: 100, b: 200 }, () => ({ a: 100, b: 200, c: 300, })) : { a: number; b: number; c?: undefined; } | { a: number; b: number; c: number; } >valueOrGetter : (x: T, f: () => T) => T >{ a: 100, b: 200 } : { a: number; b: number; } >a : number @@ -137,7 +137,7 @@ namespace arrows { })); valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ ->valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ a: 100, b: 200, })) : { a: number; b: number; } +>valueOrGetter({ a: 100, b: 200, c: 300 }, () => ({ a: 100, b: 200, })) : { a: number; b: number; c: number; } | { a: number; b: number; c?: undefined; } >valueOrGetter : (x: T, f: () => T) => T >{ a: 100, b: 200, c: 300 } : { a: number; b: number; c: number; } >a : number @@ -216,7 +216,7 @@ namespace funcExprs { } valueOrGetter({ a: 100, b: 200 }, function() { ->valueOrGetter({ a: 100, b: 200 }, function() { return { a: 100, b: 200, c: 300, }; }) : { a: number; b: number; } +>valueOrGetter({ a: 100, b: 200 }, function() { return { a: 100, b: 200, c: 300, }; }) : { a: number; b: number; c?: undefined; } | { a: number; b: number; c: number; } >valueOrGetter : (x: T, f: () => T) => T >{ a: 100, b: 200 } : { a: number; b: number; } >a : number diff --git a/tests/baselines/reference/expandoFunctionContextualTypesJs.types b/tests/baselines/reference/expandoFunctionContextualTypesJs.types index 5c314a28cbaf1..7a96534e10a28 100644 --- a/tests/baselines/reference/expandoFunctionContextualTypesJs.types +++ b/tests/baselines/reference/expandoFunctionContextualTypesJs.types @@ -10,7 +10,7 @@ */ const MyComponent = () => /* @type {any} */(null); >MyComponent : { (): any; defaultProps?: Partial<{ color: "red" | "blue"; }>; } ->() => /* @type {any} */(null) : { (): any; defaultProps: Partial<{ color: "red" | "blue"; }>; } +>() => /* @type {any} */(null) : { (): null; defaultProps: Partial<{ color: "red" | "blue"; }>; } >(null) : null >null : null diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.types b/tests/baselines/reference/fixingTypeParametersRepeatedly1.types index 2b7ec19849956..6b2ebf9964a20 100644 --- a/tests/baselines/reference/fixingTypeParametersRepeatedly1.types +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.types @@ -11,7 +11,7 @@ f("", x => null, x => x.toLowerCase()); >f("", x => null, x => x.toLowerCase()) : string >f : (x: T, y: (p: T) => T, z: (p: T) => T) => T >"" : "" ->x => null : (x: string) => any +>x => null : (x: string) => null >x : string >null : null >x => x.toLowerCase() : (x: string) => string @@ -34,10 +34,10 @@ declare function g(); >g : { (x: T, y: (p: T) => T, z: (p: T) => T): T; (): any; } g("", x => null, x => x.toLowerCase()); ->g("", x => null, x => x.toLowerCase()) : any +>g("", x => null, x => x.toLowerCase()) : string >g : { (x: T, y: (p: T) => T, z: (p: T) => T): T; (): any; } >"" : "" ->x => null : (x: string) => any +>x => null : (x: string) => null >x : string >null : null >x => x.toLowerCase() : (x: string) => string diff --git a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types index 00f645e4560c8..5f0971b5f7173 100644 --- a/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types +++ b/tests/baselines/reference/functionTypeArgumentAssignmentCompat.types @@ -11,7 +11,7 @@ var g : { () : S[]; } = () => []; ->() => [] : () => any[] +>() => [] : () => undefined[] >[] : undefined[] f = g; diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types index adfd9b9407f7e..b64d2dfa13da5 100644 --- a/tests/baselines/reference/generatedContextualTyping.types +++ b/tests/baselines/reference/generatedContextualTyping.types @@ -103,7 +103,7 @@ var x10: {n: Base[]; } = { n: [d1, d2] }; var x11: (s: Base[]) => any = n => { var n: Base[]; return null; }; >x11 : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -204,7 +204,7 @@ class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } } >x23 : x23 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -306,7 +306,7 @@ class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return nu >x35 : x35 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -408,7 +408,7 @@ class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return nul >x47 : x47 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -510,7 +510,7 @@ class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return nul >x59 : x59 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -612,7 +612,7 @@ class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; re >x71 : x71 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -714,7 +714,7 @@ class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; ret >x83 : x83 >member : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -816,7 +816,7 @@ class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return >x95 : x95 >parm : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -918,7 +918,7 @@ class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; >x107 : x107 >parm : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1020,7 +1020,7 @@ class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[] >x119 : x119 >parm : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1122,7 +1122,7 @@ function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { >x131 : (parm?: (s: Base[]) => any) => void >parm : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1213,7 +1213,7 @@ function x142(): {n: Base[]; } { return { n: [d1, d2] }; } function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; } >x143 : () => (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1343,11 +1343,11 @@ function x154(): {n: Base[]; } { return { n: [d1, d2] }; return { n: [d1, d2] } function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; } >x155 : () => (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1454,8 +1454,8 @@ var x166: () => {n: Base[]; } = () => { return { n: [d1, d2] }; }; var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; }; >x167 : () => (s: Base[]) => any >s : Base[] ->() => { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => any ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>() => { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => null +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1556,8 +1556,8 @@ var x178: () => {n: Base[]; } = function() { return { n: [d1, d2] }; }; var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; }; >x179 : () => (s: Base[]) => any >s : Base[] ->function() { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => any ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>function() { return n => { var n: Base[]; return null; }; } : () => (n: Base[]) => null +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1659,7 +1659,7 @@ module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; >x191 : typeof x191 >t : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -1761,7 +1761,7 @@ module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return nu >x203 : typeof x203 >t : (s: Base[]) => any >s : Base[] ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -2039,9 +2039,9 @@ var x234: {n: Base[]; } ; x234 = { n: [d1, d2] }; var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; }; >x235 : (s: Base[]) => any >s : Base[] ->x235 = n => { var n: Base[]; return null; } : (n: Base[]) => any +>x235 = n => { var n: Base[]; return null; } : (n: Base[]) => null >x235 : (s: Base[]) => any ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -2164,9 +2164,9 @@ var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } >x247 : { n: (s: Base[]) => any; } >n : (s: Base[]) => any >s : Base[] ->{ n: n => { var n: Base[]; return null; } } : { n: (n: Base[]) => any; } ->n : (n: Base[]) => any ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>{ n: n => { var n: Base[]; return null; } } : { n: (n: Base[]) => null; } +>n : (n: Base[]) => null +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -2633,13 +2633,13 @@ var x294: {n: Base[]; } = true ? { n: [d1, d2] } : { n: [d1, d2] }; var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; }; >x295 : (s: Base[]) => any >s : Base[] ->true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; } : (n: Base[]) => any +>true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; } : (n: Base[]) => null >true : true ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -2768,10 +2768,10 @@ var x306: {n: Base[]; } = true ? undefined : { n: [d1, d2] }; var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; }; >x307 : (s: Base[]) => any >s : Base[] ->true ? undefined : n => { var n: Base[]; return null; } : (n: Base[]) => any +>true ? undefined : n => { var n: Base[]; return null; } : (n: Base[]) => null >true : true >undefined : undefined ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -2894,9 +2894,9 @@ var x318: {n: Base[]; } = true ? { n: [d1, d2] } : undefined; var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined; >x319 : (s: Base[]) => any >s : Base[] ->true ? n => { var n: Base[]; return null; } : undefined : (n: Base[]) => any +>true ? n => { var n: Base[]; return null; } : undefined : (n: Base[]) => null >true : true ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -3023,7 +3023,7 @@ function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null >s : Base[] >x331(n => { var n: Base[]; return null; }) : void >x331 : (n: (s: Base[]) => any) => void ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -3171,7 +3171,7 @@ var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; >n : (s: Base[]) => any >x343(n => { var n: Base[]; return null; }) : (s: Base[]) => any >x343 : (n: (s: Base[]) => any) => (s: Base[]) => any ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null @@ -3310,7 +3310,7 @@ var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; retur >s : Base[] >x355(n => { var n: Base[]; return null; }) : void >x355 : (n: (s: Base[]) => any) => void ->n => { var n: Base[]; return null; } : (n: Base[]) => any +>n => { var n: Base[]; return null; } : (n: Base[]) => null >n : Base[] >n : Base[] >null : null diff --git a/tests/baselines/reference/generatorTypeCheck45.types b/tests/baselines/reference/generatorTypeCheck45.types index f8f88191e563e..89bb08f394c22 100644 --- a/tests/baselines/reference/generatorTypeCheck45.types +++ b/tests/baselines/reference/generatorTypeCheck45.types @@ -18,7 +18,7 @@ foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, sh >x.length : number >x : string >length : number ->p => undefined : (p: number) => any +>p => undefined : (p: number) => undefined >p : number >undefined : undefined diff --git a/tests/baselines/reference/generatorTypeCheck46.types b/tests/baselines/reference/generatorTypeCheck46.types index 3beb73892cef8..76c6af4a259ff 100644 --- a/tests/baselines/reference/generatorTypeCheck46.types +++ b/tests/baselines/reference/generatorTypeCheck46.types @@ -33,7 +33,7 @@ foo("", function* () { } } }, p => undefined); // T is fixed, should be string ->p => undefined : (p: number) => any +>p => undefined : (p: number) => undefined >p : number >undefined : undefined diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types index 398d225676795..d075715fa4327 100644 --- a/tests/baselines/reference/generatorTypeCheck62.types +++ b/tests/baselines/reference/generatorTypeCheck62.types @@ -77,10 +77,10 @@ export const Nothing2: Strategy = strategy("Nothing", function*(state: St export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { >Nothing3 : Strategy ->strategy("Nothing", function* (state: State) { yield ; return state;}) : (a: any) => IterableIterator +>strategy("Nothing", function* (state: State) { yield ; return state;}) : (a: State) => IterableIterator >strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator >"Nothing" : "Nothing" ->function* (state: State) { yield ; return state;} : (state: State) => Generator +>function* (state: State) { yield ; return state;} : (state: State) => Generator >state : State yield ; diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments.types index 6eb4586461e41..0bab81581135f 100644 --- a/tests/baselines/reference/genericCallWithGenericSignatureArguments.types +++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments.types @@ -30,10 +30,10 @@ var r1b = foo((x) => 1, (x) => ''); // {} => {} >'' : "" var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object ->r2 : (x: any) => any ->foo((x: Object) => null, (x: string) => '') : (x: any) => any +>r2 : (x: Object) => Object +>foo((x: Object) => null, (x: string) => '') : (x: Object) => Object >foo : (a: (x: T) => T, b: (x: T) => T) => (x: T) => T ->(x: Object) => null : (x: Object) => any +>(x: Object) => null : (x: Object) => null >x : Object >null : null >(x: string) => '' : (x: string) => string @@ -41,13 +41,13 @@ var r2 = foo((x: Object) => null, (x: string) => ''); // Object => Object >'' : "" var r3 = foo((x: number) => 1, (x: Object) => null); // number => number ->r3 : (x: any) => any ->foo((x: number) => 1, (x: Object) => null) : (x: any) => any +>r3 : (x: Object) => Object +>foo((x: number) => 1, (x: Object) => null) : (x: Object) => Object >foo : (a: (x: T) => T, b: (x: T) => T) => (x: T) => T >(x: number) => 1 : (x: number) => number >x : number >1 : 1 ->(x: Object) => null : (x: Object) => any +>(x: Object) => null : (x: Object) => null >x : Object >null : null diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types index 531225ad6b25f..259b2bc6d3237 100644 --- a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types +++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types @@ -19,14 +19,14 @@ function foo(x: T, a: (x: T) => T, b: (x: T) => T) { } var r1 = foo('', (x: string) => '', (x: Object) => null); // any => any ->r1 : (x: any) => any ->foo('', (x: string) => '', (x: Object) => null) : (x: any) => any +>r1 : (x: Object) => Object +>foo('', (x: string) => '', (x: Object) => null) : (x: Object) => Object >foo : (x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T >'' : "" >(x: string) => '' : (x: string) => string >x : string >'' : "" ->(x: Object) => null : (x: Object) => any +>(x: Object) => null : (x: Object) => null >x : Object >null : null @@ -38,7 +38,7 @@ var r1ii = foo('', (x) => '', (x) => null); // string => string >(x) => '' : (x: string) => string >x : string >'' : "" ->(x) => null : (x: string) => any +>(x) => null : (x: string) => null >x : string >null : null @@ -135,14 +135,14 @@ function foo2(x: T, a: (x: T) => U, b: (x: T) => U) { } var r8 = foo2('', (x) => '', (x) => null); // string => string ->r8 : (x: string) => any ->foo2('', (x) => '', (x) => null) : (x: string) => any +>r8 : (x: string) => string +>foo2('', (x) => '', (x) => null) : (x: string) => string >foo2 : (x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U >'' : "" >(x) => '' : (x: string) => string >x : string >'' : "" ->(x) => null : (x: string) => any +>(x) => null : (x: string) => null >x : string >null : null diff --git a/tests/baselines/reference/genericTypeAssertions3.types b/tests/baselines/reference/genericTypeAssertions3.types index d4d9c3459a199..095dbc0643e06 100644 --- a/tests/baselines/reference/genericTypeAssertions3.types +++ b/tests/baselines/reference/genericTypeAssertions3.types @@ -3,8 +3,8 @@ var r = < (x: T) => T > ((x) => { return null; }); // bug was 'could not find >r : (x: T) => T >< (x: T) => T > ((x) => { return null; }) : (x: T) => T >x : T ->((x) => { return null; }) : (x: T) => any ->(x) => { return null; } : (x: T) => any +>((x) => { return null; }) : (x: T) => null +>(x) => { return null; } : (x: T) => null >x : T >null : null @@ -12,8 +12,8 @@ var s = < (x: T) => T > ((x: any) => { return null; }); // no error >s : (x: T) => T >< (x: T) => T > ((x: any) => { return null; }) : (x: T) => T >x : T ->((x: any) => { return null; }) : (x: any) => any ->(x: any) => { return null; } : (x: any) => any +>((x: any) => { return null; }) : (x: any) => null +>(x: any) => { return null; } : (x: any) => null >x : any >null : null diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt index aea21ac2504ac..610d59dd3d5f2 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.errors.txt @@ -1,13 +1,8 @@ tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts(28,30): error TS2345: Argument of type 'string' is not assignable to parameter of type '"bar"'. tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts(175,47): error TS2322: Type 'boolean' is not assignable to type 'true'. -tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts(180,26): error TS2322: Type '{ state: State.A; }[] | { state: State.B; }[]' is not assignable to type '{ state: State.A; }[]'. - Type '{ state: State.B; }[]' is not assignable to type '{ state: State.A; }[]'. - Type '{ state: State.B; }' is not assignable to type '{ state: State.A; }'. - Types of property 'state' are incompatible. - Type 'State.B' is not assignable to type 'State.A'. -==== tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts (3 errors) ==== +==== tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts (2 errors) ==== // Repros from #5487 function truePromise(): Promise { @@ -193,13 +188,6 @@ tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts(180,26): error TS23 type Foo = { state: State } declare function bar(f: () => T[]): T[]; let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); // Error - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2322: Type '{ state: State.A; }[] | { state: State.B; }[]' is not assignable to type '{ state: State.A; }[]'. -!!! error TS2322: Type '{ state: State.B; }[]' is not assignable to type '{ state: State.A; }[]'. -!!! error TS2322: Type '{ state: State.B; }' is not assignable to type '{ state: State.A; }'. -!!! error TS2322: Types of property 'state' are incompatible. -!!! error TS2322: Type 'State.B' is not assignable to type 'State.A'. -!!! related TS6502 tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts:179:28: The expected type comes from the return type of this signature. // Repros from #31443 diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types index deb0288d52567..3ed3882c2c16a 100644 --- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types +++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types @@ -486,7 +486,7 @@ declare function bar(f: () => T[]): T[]; let x: Foo[] = bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]); // Error >x : Foo[] ->bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]) : { state: State.A; }[] +>bar(() => !!true ? [{ state: State.A }] : [{ state: State.B }]) : ({ state: State.A; } | { state: State.B; })[] >bar : (f: () => T[]) => T[] >() => !!true ? [{ state: State.A }] : [{ state: State.B }] : () => { state: State.A; }[] | { state: State.B; }[] >!!true ? [{ state: State.A }] : [{ state: State.B }] : { state: State.A; }[] | { state: State.B; }[] diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types index 139558bf729e1..9a970c05dbba1 100644 --- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types +++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types @@ -20,8 +20,8 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } } >p1.length : number >p1 : string >length : number ->{ method(p2) { return undefined } } : { method(p2: number): any; } ->method : (p2: number) => any +>{ method(p2) { return undefined } } : { method(p2: number): undefined; } +>method : (p2: number) => undefined >p2 : number >undefined : undefined diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types index e87eb4482b84e..065c6d59d3a2d 100644 --- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types +++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types @@ -20,8 +20,8 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } } >p1.length : number >p1 : string >length : number ->{ method(p2) { return undefined } } : { method(p2: number): any; } ->method : (p2: number) => any +>{ method(p2) { return undefined } } : { method(p2: number): undefined; } +>method : (p2: number) => undefined >p2 : number >undefined : undefined diff --git a/tests/baselines/reference/jsDeclarationsFunctionClassesCjsExportAssignment.types b/tests/baselines/reference/jsDeclarationsFunctionClassesCjsExportAssignment.types index b374a4617523f..30c05fc1b76b5 100644 --- a/tests/baselines/reference/jsDeclarationsFunctionClassesCjsExportAssignment.types +++ b/tests/baselines/reference/jsDeclarationsFunctionClassesCjsExportAssignment.types @@ -120,7 +120,7 @@ Context.prototype = { >construct : (input: Input, handle?: HookHandler | undefined) => State >input : Input >handle : (arg: Context) => void ->() => void 0 : () => any +>() => void 0 : () => undefined >void 0 : undefined >0 : 0 diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types index b02e6da832597..f46c1bdeedb69 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports1.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports1.types @@ -18,13 +18,13 @@ import {B} from "./f2"; >B : typeof B A.prototype.foo = function () { return undefined; } ->A.prototype.foo = function () { return undefined; } : () => any +>A.prototype.foo = function () { return undefined; } : () => undefined >A.prototype.foo : () => B >A.prototype : A >A : typeof A >prototype : A >foo : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined declare module "./f1" { diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports3.types b/tests/baselines/reference/moduleAugmentationImportsAndExports3.types index 5cb8516c6dbda..041bb35441c36 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports3.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports3.types @@ -15,13 +15,13 @@ import {A} from "./f1"; >A : typeof A A.prototype.foo = function () { return undefined; } ->A.prototype.foo = function () { return undefined; } : () => any +>A.prototype.foo = function () { return undefined; } : () => undefined >A.prototype.foo : () => any >A.prototype : A >A : typeof A >prototype : A >foo : () => any ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined namespace N { diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types index f37b65554a2f0..2755d3b7c5d5e 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports4.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports4.types @@ -18,13 +18,13 @@ import {B} from "./f2"; >B : typeof B A.prototype.foo = function () { return undefined; } ->A.prototype.foo = function () { return undefined; } : () => any +>A.prototype.foo = function () { return undefined; } : () => undefined >A.prototype.foo : () => B >A.prototype : A >A : typeof A >prototype : A >foo : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined namespace N { diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports5.types b/tests/baselines/reference/moduleAugmentationImportsAndExports5.types index f37b65554a2f0..2755d3b7c5d5e 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports5.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports5.types @@ -18,13 +18,13 @@ import {B} from "./f2"; >B : typeof B A.prototype.foo = function () { return undefined; } ->A.prototype.foo = function () { return undefined; } : () => any +>A.prototype.foo = function () { return undefined; } : () => undefined >A.prototype.foo : () => B >A.prototype : A >A : typeof A >prototype : A >foo : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined namespace N { diff --git a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types index 826911e6b1bc5..d77620b0101b2 100644 --- a/tests/baselines/reference/moduleAugmentationImportsAndExports6.types +++ b/tests/baselines/reference/moduleAugmentationImportsAndExports6.types @@ -18,13 +18,13 @@ import {B} from "./f2"; >B : typeof B A.prototype.foo = function () { return undefined; } ->A.prototype.foo = function () { return undefined; } : () => any +>A.prototype.foo = function () { return undefined; } : () => undefined >A.prototype.foo : () => B >A.prototype : A >A : typeof A >prototype : A >foo : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined export namespace N { diff --git a/tests/baselines/reference/moduleAugmentationsImports1.types b/tests/baselines/reference/moduleAugmentationsImports1.types index 0ed67442c6469..bed27981798c3 100644 --- a/tests/baselines/reference/moduleAugmentationsImports1.types +++ b/tests/baselines/reference/moduleAugmentationsImports1.types @@ -29,23 +29,23 @@ import {Cls} from "C"; >Cls : typeof Cls A.prototype.getB = function () { return undefined; } ->A.prototype.getB = function () { return undefined; } : () => any +>A.prototype.getB = function () { return undefined; } : () => undefined >A.prototype.getB : () => B >A.prototype : A >A : typeof A >prototype : A >getB : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined A.prototype.getCls = function () { return undefined; } ->A.prototype.getCls = function () { return undefined; } : () => any +>A.prototype.getCls = function () { return undefined; } : () => undefined >A.prototype.getCls : () => Cls >A.prototype : A >A : typeof A >prototype : A >getCls : () => Cls ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined declare module "./a" { diff --git a/tests/baselines/reference/moduleAugmentationsImports2.types b/tests/baselines/reference/moduleAugmentationsImports2.types index 1e6abb0803fd5..8ab96f76e793c 100644 --- a/tests/baselines/reference/moduleAugmentationsImports2.types +++ b/tests/baselines/reference/moduleAugmentationsImports2.types @@ -26,13 +26,13 @@ import {B} from "./b"; >B : typeof B A.prototype.getB = function () { return undefined; } ->A.prototype.getB = function () { return undefined; } : () => any +>A.prototype.getB = function () { return undefined; } : () => undefined >A.prototype.getB : () => B >A.prototype : A >A : typeof A >prototype : A >getB : () => B ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined declare module "./a" { @@ -52,13 +52,13 @@ import {Cls} from "C"; >Cls : typeof Cls A.prototype.getCls = function () { return undefined; } ->A.prototype.getCls = function () { return undefined; } : () => any +>A.prototype.getCls = function () { return undefined; } : () => undefined >A.prototype.getCls : () => Cls >A.prototype : A >A : typeof A >prototype : A >getCls : () => Cls ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined declare module "./a" { diff --git a/tests/baselines/reference/moduleAugmentationsImports3.types b/tests/baselines/reference/moduleAugmentationsImports3.types index 5c370b4b74178..9e119049f4616 100644 --- a/tests/baselines/reference/moduleAugmentationsImports3.types +++ b/tests/baselines/reference/moduleAugmentationsImports3.types @@ -80,13 +80,13 @@ import {Cls} from "C"; >Cls : typeof Cls A.prototype.getCls = function () { return undefined; } ->A.prototype.getCls = function () { return undefined; } : () => any +>A.prototype.getCls = function () { return undefined; } : () => undefined >A.prototype.getCls : () => Cls >A.prototype : A >A : typeof A >prototype : A >getCls : () => Cls ->function () { return undefined; } : () => any +>function () { return undefined; } : () => undefined >undefined : undefined declare module "./a" { diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types index cee308ba0fc90..acc17c59c8bc2 100644 --- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types +++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types @@ -2,7 +2,7 @@ var x: (a: any) => void = function (x: T) { >x : (a: any) => void >a : any ->function (x: T) { return null;} : (x: T) => any +>function (x: T) { return null;} : (x: T) => null >x : T return null; @@ -13,8 +13,8 @@ var x: (a: any) => void = function (x: T) { var x2: (a: any) => void = function f(x: T) { >x2 : (a: any) => void >a : any ->function f(x: T) { return null;} : (x: T) => any ->f : (x: T) => any +>function f(x: T) { return null;} : (x: T) => null +>f : (x: T) => null >x : T return null; diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.types b/tests/baselines/reference/parenthesizedContexualTyping1.types index 30c8dab626240..7e921bc605945 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.types +++ b/tests/baselines/reference/parenthesizedContexualTyping1.types @@ -128,11 +128,11 @@ var h = fun((((x => x))), ((x => x)), 10); // 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 +>i : number +>fun((Math.random() < 0.5 ? x => x : x => undefined), 10) : number >fun : { (g: (x: T) => T, x: 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) => number +>Math.random() < 0.5 ? x => x : x => undefined : (x: number) => number >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -142,17 +142,17 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); >x => x : (x: number) => number >x : number >x : number ->x => undefined : (x: number) => any +>x => undefined : (x: number) => undefined >x : number >undefined : undefined >10 : 10 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 +>j : number +>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10) : number >fun : { (g: (x: T) => T, x: 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) => number +>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => number >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -163,18 +163,18 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); >x => x : (x: number) => number >x : number >x : number ->(x => undefined) : (x: number) => any ->x => undefined : (x: number) => any +>(x => undefined) : (x: number) => undefined +>x => undefined : (x: number) => undefined >x : number >undefined : undefined >10 : 10 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 +>k : number +>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10) : number >fun : { (g: (x: T) => T, x: 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) => number +>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => number >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -185,8 +185,8 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); >x => x : (x: number) => number >x : number >x : number ->(x => undefined) : (x: number) => any ->x => undefined : (x: number) => any +>(x => undefined) : (x: number) => undefined +>x => undefined : (x: number) => undefined >x : number >undefined : undefined >x => x : (x: number) => number @@ -195,12 +195,12 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); >10 : 10 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 +>l : number +>fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10) : number >fun : { (g: (x: T) => T, x: 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 ? ((x => x)) : ((x => undefined)))) : (x: number) => number +>(Math.random() < 0.5 ? ((x => x)) : ((x => undefined))) : (x: number) => number +>Math.random() < 0.5 ? ((x => x)) : ((x => undefined)) : (x: number) => number >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -212,9 +212,9 @@ var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x) >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 => undefined)) : (x: number) => undefined +>(x => undefined) : (x: number) => undefined +>x => undefined : (x: number) => undefined >x : number >undefined : undefined >((x => x)) : (x: number) => number @@ -248,16 +248,16 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number }; var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; >obj1 : ObjType ->{ 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: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => undefined; y: (y: string) => undefined; } +>x : (x: number) => undefined +>x => (x, undefined) : (x: number) => undefined >x : number >(x, undefined) : undefined >x, undefined : undefined >x : number >undefined : undefined ->y : (y: string) => any ->y => (y, undefined) : (y: string) => any +>y : (y: string) => undefined +>y => (y, undefined) : (y: string) => undefined >y : string >(y, undefined) : undefined >y, undefined : undefined @@ -266,17 +266,17 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); >obj2 : ObjType ->({ 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: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => undefined; y: (y: string) => undefined; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => undefined; y: (y: string) => undefined; } +>x : (x: number) => undefined +>x => (x, undefined) : (x: number) => undefined >x : number >(x, undefined) : undefined >x, undefined : undefined >x : number >undefined : undefined ->y : (y: string) => any ->y => (y, undefined) : (y: string) => any +>y : (y: string) => undefined +>y => (y, undefined) : (y: string) => undefined >y : string >(y, undefined) : undefined >y, undefined : undefined diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.types b/tests/baselines/reference/parenthesizedContexualTyping2.types index d8927c336d09d..a7d293c188285 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping2.types +++ b/tests/baselines/reference/parenthesizedContexualTyping2.types @@ -172,8 +172,8 @@ var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x >i : number >fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10) : 10 >fun : { (f: FuncType, x: T): T; (f: FuncType, g: FuncType, x: T): T; } ->(Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined) : (x: (p: T) => T) => any ->Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined : (x: (p: T) => T) => any +>(Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined) : (x: (p: T) => T) => (p: T) => T +>Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined : (x: (p: T) => T) => (p: T) => T >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -186,7 +186,7 @@ var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x >x : (p: T) => T >undefined : undefined >x : (p: T) => T ->x => undefined : (x: (p: T) => T) => any +>x => undefined : (x: (p: T) => T) => undefined >x : (p: T) => T >undefined : undefined >10 : 10 @@ -195,8 +195,8 @@ var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : >j : number >fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10) : 10 >fun : { (f: FuncType, x: T): T; (f: FuncType, g: FuncType, x: T): T; } ->(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => any ->Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => any +>(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => (p: T) => T +>Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => (p: T) => T >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -210,8 +210,8 @@ var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : >x : (p: T) => T >undefined : undefined >x : (p: T) => T ->(x => undefined) : (x: (p: T) => T) => any ->x => undefined : (x: (p: T) => T) => any +>(x => undefined) : (x: (p: T) => T) => undefined +>x => undefined : (x: (p: T) => T) => undefined >x : (p: T) => T >undefined : undefined >10 : 10 @@ -220,8 +220,8 @@ var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : >k : number >fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10) : 10 >fun : { (f: FuncType, x: T): T; (f: FuncType, g: FuncType, x: T): T; } ->(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => any ->Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => any +>(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => (p: T) => T +>Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => (p: T) => T >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -235,8 +235,8 @@ var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : >x : (p: T) => T >undefined : undefined >x : (p: T) => T ->(x => undefined) : (x: (p: T) => T) => any ->x => undefined : (x: (p: T) => T) => any +>(x => undefined) : (x: (p: T) => T) => undefined +>x => undefined : (x: (p: T) => T) => undefined >x : (p: T) => T >undefined : undefined >x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T @@ -251,9 +251,9 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) >l : number >fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10) : 10 >fun : { (f: FuncType, x: T): T; (f: FuncType, g: FuncType, x: T): T; } ->((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))) : (x: (p: T) => T) => any ->(Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined))) : (x: (p: T) => T) => any ->Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)) : (x: (p: T) => T) => any +>((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))) : (x: (p: T) => T) => (p: T) => T +>(Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined))) : (x: (p: T) => T) => (p: T) => T +>Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)) : (x: (p: T) => T) => (p: T) => T >Math.random() < 0.5 : boolean >Math.random() : number >Math.random : () => number @@ -268,9 +268,9 @@ var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) >x : (p: T) => T >undefined : undefined >x : (p: T) => T ->((x => undefined)) : (x: (p: T) => T) => any ->(x => undefined) : (x: (p: T) => T) => any ->x => undefined : (x: (p: T) => T) => any +>((x => undefined)) : (x: (p: T) => T) => undefined +>(x => undefined) : (x: (p: T) => T) => undefined +>x => undefined : (x: (p: T) => T) => undefined >x : (p: T) => T >undefined : undefined >((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T @@ -311,16 +311,16 @@ type ObjType = { x: (p: number) => string; y: (p: string) => number }; var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; >obj1 : ObjType ->{ 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: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => undefined; y: (y: string) => undefined; } +>x : (x: number) => undefined +>x => (x, undefined) : (x: number) => undefined >x : number >(x, undefined) : undefined >x, undefined : undefined >x : number >undefined : undefined ->y : (y: string) => any ->y => (y, undefined) : (y: string) => any +>y : (y: string) => undefined +>y => (y, undefined) : (y: string) => undefined >y : string >(y, undefined) : undefined >y, undefined : undefined @@ -329,17 +329,17 @@ var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); >obj2 : ObjType ->({ 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: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => undefined; y: (y: string) => undefined; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => undefined; y: (y: string) => undefined; } +>x : (x: number) => undefined +>x => (x, undefined) : (x: number) => undefined >x : number >(x, undefined) : undefined >x, undefined : undefined >x : number >undefined : undefined ->y : (y: string) => any ->y => (y, undefined) : (y: string) => any +>y : (y: string) => undefined +>y => (y, undefined) : (y: string) => undefined >y : string >(y, undefined) : undefined >y, undefined : undefined diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types index c459a02d36b13..00a872ea281ee 100644 --- a/tests/baselines/reference/promiseType.types +++ b/tests/baselines/reference/promiseType.types @@ -233,7 +233,7 @@ const p14 = p.catch(() => undefined); >p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise >p : Promise >catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p15 = p.catch(() => null); @@ -242,7 +242,7 @@ const p15 = p.catch(() => null); >p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise >p : Promise >catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null const p16 = p.catch(() => {}); @@ -328,7 +328,7 @@ const p24 = p.then(() => undefined); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p25 = p.then(() => null); @@ -337,7 +337,7 @@ const p25 = p.then(() => null); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null const p26 = p.then(() => {}); @@ -428,7 +428,7 @@ const p34 = p.then(undefined, () => undefined); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >undefined : undefined ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p35 = p.then(undefined, () => null); @@ -438,7 +438,7 @@ const p35 = p.then(undefined, () => null); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >undefined : undefined ->() => null : () => any +>() => null : () => null >null : null const p36 = p.then(undefined, () => {}); @@ -533,7 +533,7 @@ const p44 = p.then(null, () => undefined); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >null : null ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p45 = p.then(null, () => null); @@ -543,7 +543,7 @@ const p45 = p.then(null, () => null); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >null : null ->() => null : () => any +>() => null : () => null >null : null const p46 = p.then(null, () => {}); @@ -643,7 +643,7 @@ const p54 = p.then(() => "1", () => undefined); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => "1" : () => string >"1" : "1" ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p55 = p.then(() => "1", () => null); @@ -654,7 +654,7 @@ const p55 = p.then(() => "1", () => null); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => "1" : () => string >"1" : "1" ->() => null : () => any +>() => null : () => null >null : null const p56 = p.then(() => "1", () => {}); @@ -758,7 +758,7 @@ const p64 = p.then(() => x, () => undefined); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => x : () => any >x : any ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p65 = p.then(() => x, () => null); @@ -769,7 +769,7 @@ const p65 = p.then(() => x, () => null); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => x : () => any >x : any ->() => null : () => any +>() => null : () => null >null : null const p66 = p.then(() => x, () => {}); @@ -829,7 +829,7 @@ const p70 = p.then(() => undefined, undefined); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >undefined : undefined @@ -839,7 +839,7 @@ const p71 = p.then(() => undefined, null); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >null : null @@ -849,7 +849,7 @@ const p72 = p.then(() => undefined, () => 1); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => 1 : () => number >1 : 1 @@ -860,7 +860,7 @@ const p73 = p.then(() => undefined, () => x); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => x : () => any >x : any @@ -871,9 +871,9 @@ const p74 = p.then(() => undefined, () => undefined); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p75 = p.then(() => undefined, () => null); @@ -882,9 +882,9 @@ const p75 = p.then(() => undefined, () => null); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined ->() => null : () => any +>() => null : () => null >null : null const p76 = p.then(() => undefined, () => {}); @@ -893,7 +893,7 @@ const p76 = p.then(() => undefined, () => {}); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => {} : () => void @@ -903,7 +903,7 @@ const p77 = p.then(() => undefined, () => {throw 1}); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => {throw 1} : () => never >1 : 1 @@ -914,7 +914,7 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1)); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => Promise.resolve(1) : () => Promise >Promise.resolve(1) : Promise @@ -929,7 +929,7 @@ const p79 = p.then(() => undefined, () => Promise.reject(1)); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined >() => Promise.reject(1) : () => Promise >Promise.reject(1) : Promise @@ -944,7 +944,7 @@ const p80 = p.then(() => null, undefined); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >undefined : undefined @@ -954,7 +954,7 @@ const p81 = p.then(() => null, null); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >null : null @@ -964,7 +964,7 @@ const p82 = p.then(() => null, () => 1); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => 1 : () => number >1 : 1 @@ -975,7 +975,7 @@ const p83 = p.then(() => null, () => x); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => x : () => any >x : any @@ -986,9 +986,9 @@ const p84 = p.then(() => null, () => undefined); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p85 = p.then(() => null, () => null); @@ -997,9 +997,9 @@ const p85 = p.then(() => null, () => null); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null ->() => null : () => any +>() => null : () => null >null : null const p86 = p.then(() => null, () => {}); @@ -1008,7 +1008,7 @@ const p86 = p.then(() => null, () => {}); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => {} : () => void @@ -1018,7 +1018,7 @@ const p87 = p.then(() => null, () => {throw 1}); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => {throw 1} : () => never >1 : 1 @@ -1029,7 +1029,7 @@ const p88 = p.then(() => null, () => Promise.resolve(1)); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => Promise.resolve(1) : () => Promise >Promise.resolve(1) : Promise @@ -1044,7 +1044,7 @@ const p89 = p.then(() => null, () => Promise.reject(1)); >p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise ->() => null : () => any +>() => null : () => null >null : null >() => Promise.reject(1) : () => Promise >Promise.reject(1) : Promise @@ -1098,7 +1098,7 @@ const p94 = p.then(() => {}, () => undefined); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => {} : () => void ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const p95 = p.then(() => {}, () => null); @@ -1108,7 +1108,7 @@ const p95 = p.then(() => {}, () => null); >p : Promise >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => {} : () => void ->() => null : () => any +>() => null : () => null >null : null const p96 = p.then(() => {}, () => {}); @@ -1208,7 +1208,7 @@ const pa4 = p.then(() => {throw 1}, () => undefined); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => {throw 1} : () => never >1 : 1 ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const pa5 = p.then(() => {throw 1}, () => null); @@ -1219,7 +1219,7 @@ const pa5 = p.then(() => {throw 1}, () => null); >then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise >() => {throw 1} : () => never >1 : 1 ->() => null : () => any +>() => null : () => null >null : null const pa6 = p.then(() => {throw 1}, () => {}); @@ -1343,7 +1343,7 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined); >Promise : PromiseConstructor >resolve : { (): Promise; (value: T | PromiseLike): Promise; } >"1" : "1" ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const pb5 = p.then(() => Promise.resolve("1"), () => null); @@ -1358,7 +1358,7 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null); >Promise : PromiseConstructor >resolve : { (): Promise; (value: T | PromiseLike): Promise; } >"1" : "1" ->() => null : () => any +>() => null : () => null >null : null const pb6 = p.then(() => Promise.resolve("1"), () => {}); @@ -1498,7 +1498,7 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined); >Promise : PromiseConstructor >reject : (reason?: any) => Promise >"1" : "1" ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined const pc5 = p.then(() => Promise.reject("1"), () => null); @@ -1513,7 +1513,7 @@ const pc5 = p.then(() => Promise.reject("1"), () => null); >Promise : PromiseConstructor >reject : (reason?: any) => Promise >"1" : "1" ->() => null : () => any +>() => null : () => null >null : null const pc6 = p.then(() => Promise.reject("1"), () => {}); diff --git a/tests/baselines/reference/restArgAssignmentCompat.types b/tests/baselines/reference/restArgAssignmentCompat.types index ccccb83134939..7c8fafaa258d1 100644 --- a/tests/baselines/reference/restArgAssignmentCompat.types +++ b/tests/baselines/reference/restArgAssignmentCompat.types @@ -8,7 +8,7 @@ function f(...x: number[]) { >x.forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void >x : number[] >forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void ->(n, i) => void ('item ' + i + ' = ' + n) : (n: number, i: number) => any +>(n, i) => void ('item ' + i + ' = ' + n) : (n: number, i: number) => undefined >n : number >i : number >void ('item ' + i + ' = ' + n) : undefined diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.types b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.types index 114b37d1cf2e2..7e916314e5f5a 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.types +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.types @@ -90,7 +90,7 @@ someGenerics3 `${() => undefined}`; >someGenerics3 `${() => undefined}` : void >someGenerics3 : (strs: TemplateStringsArray, producer: () => T) => void >`${() => undefined}` : string ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined someGenerics3 `${() => 3}`; @@ -113,7 +113,7 @@ someGenerics4 `${4}${ () => null }`; >someGenerics4 : (strs: TemplateStringsArray, n: T, f: (x: U) => void) => void >`${4}${ () => null }` : string >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics4 `${''}${ () => 3 }`; @@ -144,7 +144,7 @@ someGenerics5 `${ 4 } ${ () => null }`; >someGenerics5 : (strs: TemplateStringsArray, n: T, f: (x: U) => void) => void >`${ 4 } ${ () => null }` : string >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics5 `${ '' }${ () => 3 }`; diff --git a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.types b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.types index 1953bde609932..2fea269e0d63e 100644 --- a/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.types +++ b/tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.types @@ -90,7 +90,7 @@ someGenerics3 `${() => undefined}`; >someGenerics3 `${() => undefined}` : void >someGenerics3 : (strs: TemplateStringsArray, producer: () => T) => void >`${() => undefined}` : string ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined someGenerics3 `${() => 3}`; @@ -113,7 +113,7 @@ someGenerics4 `${4}${ () => null }`; >someGenerics4 : (strs: TemplateStringsArray, n: T, f: (x: U) => void) => void >`${4}${ () => null }` : string >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics4 `${''}${ () => 3 }`; @@ -144,7 +144,7 @@ someGenerics5 `${ 4 } ${ () => null }`; >someGenerics5 : (strs: TemplateStringsArray, n: T, f: (x: U) => void) => void >`${ 4 } ${ () => null }` : string >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics5 `${ '' }${ () => 3 }`; diff --git a/tests/baselines/reference/typeArgumentInference.types b/tests/baselines/reference/typeArgumentInference.types index 12fa09f616e21..8a7e36de13cea 100644 --- a/tests/baselines/reference/typeArgumentInference.types +++ b/tests/baselines/reference/typeArgumentInference.types @@ -134,7 +134,7 @@ someGenerics3(() => ''); someGenerics3(() => undefined); >someGenerics3(() => undefined) : void >someGenerics3 : (producer: () => T) => void ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined someGenerics3(() => 3); @@ -154,7 +154,7 @@ someGenerics4(4, () => null); >someGenerics4(4, () => null) : void >someGenerics4 : (n: T, f: (x: U) => void) => void >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics4('', () => 3); @@ -181,7 +181,7 @@ someGenerics5(4, () => null); >someGenerics5(4, () => null) : void >someGenerics5 : (n: T, f: (x: U) => void) => void >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics5('', () => 3); diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types index 70ee543c1f772..d2054d4bace19 100644 --- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types +++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.types @@ -158,7 +158,7 @@ new someGenerics3(() => ''); new someGenerics3(() => undefined); >new someGenerics3(() => undefined) : any >someGenerics3 : someGenerics3 ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined new someGenerics3(() => 3); @@ -181,7 +181,7 @@ new someGenerics4(4, () => null); >new someGenerics4(4, () => null) : any >someGenerics4 : someGenerics4 >4 : 4 ->() => null : () => any +>() => null : () => null >null : null new someGenerics4('', () => 3); @@ -219,7 +219,7 @@ new someGenerics5(4, () => null); >new someGenerics5(4, () => null) : any >someGenerics5 : someGenerics5 >4 : 4 ->() => null : () => any +>() => null : () => null >null : null new someGenerics5('', () => 3); diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.types b/tests/baselines/reference/typeArgumentInferenceWithConstraints.types index 332d463ad72d5..9131197261f86 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.types +++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.types @@ -146,7 +146,7 @@ someGenerics3(() => ''); // Error someGenerics3(() => undefined); >someGenerics3(() => undefined) : void >someGenerics3 : (producer: () => T) => void ->() => undefined : () => any +>() => undefined : () => undefined >undefined : undefined someGenerics3(() => 3); // Error @@ -166,7 +166,7 @@ someGenerics4(4, () => null); // Valid >someGenerics4(4, () => null) : void >someGenerics4 : (n: T, f: (x: U) => void) => void >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics4('', () => 3); @@ -201,7 +201,7 @@ someGenerics5(4, () => null); // Valid >someGenerics5(4, () => null) : void >someGenerics5 : (n: T, f: (x: U) => void) => void >4 : 4 ->() => null : () => any +>() => null : () => null >null : null someGenerics5('', () => 3); diff --git a/tests/baselines/reference/typeParameterFixingWithConstraints.types b/tests/baselines/reference/typeParameterFixingWithConstraints.types index 9c26e8436db59..8e1e375ad3b03 100644 --- a/tests/baselines/reference/typeParameterFixingWithConstraints.types +++ b/tests/baselines/reference/typeParameterFixingWithConstraints.types @@ -25,10 +25,10 @@ foo.foo({ bar: null }, bar => null, bar => null); >{ bar: null } : { bar: null; } >bar : null >null : null ->bar => null : (bar: { bar: any; }) => any +>bar => null : (bar: { bar: any; }) => null >bar : { bar: any; } >null : null ->bar => null : (bar: { bar: any; }) => any +>bar => null : (bar: { bar: any; }) => null >bar : { bar: any; } >null : null diff --git a/tests/baselines/reference/typeReferenceDirectives12.types b/tests/baselines/reference/typeReferenceDirectives12.types index 3ee1ab5d8aef5..02db690118b80 100644 --- a/tests/baselines/reference/typeReferenceDirectives12.types +++ b/tests/baselines/reference/typeReferenceDirectives12.types @@ -42,13 +42,13 @@ import {Cls} from "./main"; >Cls : typeof Cls Cls.prototype.foo = function() { return undefined; } ->Cls.prototype.foo = function() { return undefined; } : () => any +>Cls.prototype.foo = function() { return undefined; } : () => undefined >Cls.prototype.foo : () => Lib >Cls.prototype : Cls >Cls : typeof Cls >prototype : Cls >foo : () => Lib ->function() { return undefined; } : () => any +>function() { return undefined; } : () => undefined >undefined : undefined declare module "./main" { diff --git a/tests/baselines/reference/typeReferenceDirectives9.types b/tests/baselines/reference/typeReferenceDirectives9.types index 3ee1ab5d8aef5..02db690118b80 100644 --- a/tests/baselines/reference/typeReferenceDirectives9.types +++ b/tests/baselines/reference/typeReferenceDirectives9.types @@ -42,13 +42,13 @@ import {Cls} from "./main"; >Cls : typeof Cls Cls.prototype.foo = function() { return undefined; } ->Cls.prototype.foo = function() { return undefined; } : () => any +>Cls.prototype.foo = function() { return undefined; } : () => undefined >Cls.prototype.foo : () => Lib >Cls.prototype : Cls >Cls : typeof Cls >prototype : Cls >foo : () => Lib ->function() { return undefined; } : () => any +>function() { return undefined; } : () => undefined >undefined : undefined declare module "./main" { diff --git a/tests/baselines/reference/wideningTuples2.errors.txt b/tests/baselines/reference/wideningTuples2.errors.txt new file mode 100644 index 0000000000000..423f2036460d4 --- /dev/null +++ b/tests/baselines/reference/wideningTuples2.errors.txt @@ -0,0 +1,11 @@ +tests/cases/conformance/types/tuple/wideningTuples2.ts(2,9): error TS7005: Variable 'intermediate' implicitly has an '[any]' type. + + +==== tests/cases/conformance/types/tuple/wideningTuples2.ts (1 errors) ==== + var foo: () => [any] = function bar() { + let intermediate = bar(); + ~~~~~~~~~~~~ +!!! error TS7005: Variable 'intermediate' implicitly has an '[any]' type. + intermediate = [""]; + return [undefined]; + }; \ No newline at end of file diff --git a/tests/baselines/reference/wideningTuples2.types b/tests/baselines/reference/wideningTuples2.types index afe564e3bab08..c41ce26660619 100644 --- a/tests/baselines/reference/wideningTuples2.types +++ b/tests/baselines/reference/wideningTuples2.types @@ -1,13 +1,13 @@ === tests/cases/conformance/types/tuple/wideningTuples2.ts === var foo: () => [any] = function bar() { >foo : () => [any] ->function bar() { let intermediate = bar(); intermediate = [""]; return [undefined];} : () => [any] ->bar : () => [any] +>function bar() { let intermediate = bar(); intermediate = [""]; return [undefined];} : () => [undefined] +>bar : () => [undefined] let intermediate = bar(); >intermediate : [any] ->bar() : [any] ->bar : () => [any] +>bar() : [undefined] +>bar : () => [undefined] intermediate = [""]; >intermediate = [""] : [string] From a8aa336df85d35e82704e003605e196310323eb4 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Sat, 29 Aug 2020 00:54:49 +0000 Subject: [PATCH 5/6] Added missing 'source' property to 'DiagnosticWithLinePosition'. --- src/server/protocol.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/server/protocol.ts b/src/server/protocol.ts index b288124049e67..83f0fad1f45ef 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -511,6 +511,7 @@ namespace ts.server.protocol { endLocation: Location; category: string; code: number; + source?: string; /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */ reportsUnnecessary?: {}; reportsDeprecated?: {}; From 4f30b405e9564e4f105cd3ef279af3c0dae814e8 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Sat, 29 Aug 2020 07:51:56 +0000 Subject: [PATCH 6/6] Update baselines. --- tests/baselines/reference/api/tsserverlibrary.d.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 142dc3a9e7d29..d9265b00e5109 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -6791,6 +6791,7 @@ declare namespace ts.server.protocol { endLocation: Location; category: string; code: number; + source?: string; /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */ reportsUnnecessary?: {}; reportsDeprecated?: {};