microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-12 11:08:26 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Accepting new baselines

Browse Source
This commit is contained in:
Anders Hejlsberg
2015-08-06 15:21:53 -07:00
parent d317bd1340
commit e0cb1603e2
21 changed files with 2352 additions and 454 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
View File

@@ -82,5 +82,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
>IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
>IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
>a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
>a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))

12
tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types
View File

@@ -90,10 +90,10 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
>x4 : IWithCallSignatures | IWithCallSignatures4
>IWithCallSignatures : IWithCallSignatures
>IWithCallSignatures4 : IWithCallSignatures4
>a => /*here a should be any*/ a.toString() : (a: any) => any
>a : any
>a.toString() : any
>a.toString : any
>a : any
>toString : any
>a => /*here a should be any*/ a.toString() : (a: number) => string
>a : number
>a.toString() : string
>a.toString : (radix?: number) => string
>a : number
>toString : (radix?: number) => string

5
tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
View File

@@ -1,11 +1,10 @@
tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(7,30): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type '(number | string)[]' is not assignable to parameter of type 'number[]'.
Type 'number | string' is not assignable to type 'number'.
Type 'string' is not assignable to type 'number'.
tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): error TS2346: Supplied parameters do not match any signature of call target.
==== tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts (3 errors) ====
==== tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts (2 errors) ====
function map<T, U>(xs: T[], f: (x: T) => U) {
var ys: U[] = [];
xs.forEach(x => ys.push(f(x)));
@@ -13,8 +12,6 @@ tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): e
}
var r0 = map([1, ""], (x) => x.toString());
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
var r5 = map<any, any>([1, ""], (x) => x.toString());
var r6 = map<Object, Object>([1, ""], (x) => x.toString());
var r7 = map<number, string>([1, ""], (x) => x.toString()); // error

103
tests/baselines/reference/typeGuardsInConditionalExpression.errors.txt
View File

@@ -1,103 +0,0 @@
tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts(93,22): error TS2349: Cannot invoke an expression whose type lacks a call signature.
==== tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts (1 errors) ====
// In the true expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when true,
// provided the true expression contains no assignments to the variable or parameter.
// In the false expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when false,
// provided the false expression contains no assignments to the variable or parameter.
function foo(x: number | string) {
return typeof x === "string"
? x.length // string
: x++; // number
}
function foo2(x: number | string) {
// x is assigned in the if true branch, the type is not narrowed
return typeof x === "string"
? (x = 10 && x)// string | number
: x; // string | number
}
function foo3(x: number | string) {
// x is assigned in the if false branch, the type is not narrowed
// even though assigned using same type as narrowed expression
return typeof x === "string"
? (x = "Hello" && x) // string | number
: x; // string | number
}
function foo4(x: number | string) {
// false branch updates the variable - so here it is not number
// even though assigned using same type as narrowed expression
return typeof x === "string"
? x // string | number
: (x = 10 && x); // string | number
}
function foo5(x: number | string) {
// false branch updates the variable - so here it is not number
return typeof x === "string"
? x // string | number
: (x = "hello" && x); // string | number
}
function foo6(x: number | string) {
// Modify in both branches
return typeof x === "string"
? (x = 10 && x) // string | number
: (x = "hello" && x); // string | number
}
function foo7(x: number | string | boolean) {
return typeof x === "string"
? x === "hello" // string
: typeof x === "boolean"
? x // boolean
: x == 10; // number
}
function foo8(x: number | string | boolean) {
var b: number | boolean;
return typeof x === "string"
? x === "hello"
: ((b = x) && // number | boolean
(typeof x === "boolean"
? x // boolean
: x == 10)); // number
}
function foo9(x: number | string) {
var y = 10;
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
return typeof x === "string"
? ((y = x.length) && x === "hello") // string
: x === 10; // number
}
function foo10(x: number | string | boolean) {
// Mixing typeguards
var b: boolean | number;
return typeof x === "string"
? x // string
: ((b = x) // x is number | boolean
&& typeof x === "number"
&& x.toString()); // x is number
}
function foo11(x: number | string | boolean) {
// Mixing typeguards
// Assigning value to x deep inside another guard stops narrowing of type too
var b: number | boolean | string;
return typeof x === "string"
? x // number | boolean | string - changed in the false branch
: ((b = x) // x is number | boolean | string - because the assignment changed it
&& typeof x === "number"
&& (x = 10) // assignment to x
&& x); // x is number | boolean | string
}
function foo12(x: number | string | boolean) {
// Mixing typeguards
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
var b: number | boolean | string;
return typeof x === "string"
? (x = 10 && x.toString().length) // number | boolean | string - changed here
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
: ((b = x) // x is number | boolean | string - changed in true branch
&& typeof x === "number"
&& x); // x is number
}

251
tests/baselines/reference/typeGuardsInConditionalExpression.symbols Normal file
View File

@@ -0,0 +1,251 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts ===
// In the true expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when true,
// provided the true expression contains no assignments to the variable or parameter.
// In the false expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when false,
// provided the false expression contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : Symbol(foo, Decl(typeGuardsInConditionalExpression.ts, 0, 0))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
? x.length // string
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
: x++; // number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
}
function foo2(x: number | string) {
>foo2 : Symbol(foo2, Decl(typeGuardsInConditionalExpression.ts, 11, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 12, 14))
// x is assigned in the if true branch, the type is not narrowed
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 12, 14))
? (x = 10 && x)// string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 12, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 12, 14))
: x; // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 12, 14))
}
function foo3(x: number | string) {
>foo3 : Symbol(foo3, Decl(typeGuardsInConditionalExpression.ts, 17, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 18, 14))
// x is assigned in the if false branch, the type is not narrowed
// even though assigned using same type as narrowed expression
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 18, 14))
? (x = "Hello" && x) // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 18, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 18, 14))
: x; // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 18, 14))
}
function foo4(x: number | string) {
>foo4 : Symbol(foo4, Decl(typeGuardsInConditionalExpression.ts, 24, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 25, 14))
// false branch updates the variable - so here it is not number
// even though assigned using same type as narrowed expression
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 25, 14))
? x // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 25, 14))
: (x = 10 && x); // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 25, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 25, 14))
}
function foo5(x: number | string) {
>foo5 : Symbol(foo5, Decl(typeGuardsInConditionalExpression.ts, 31, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 32, 14))
// false branch updates the variable - so here it is not number
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 32, 14))
? x // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 32, 14))
: (x = "hello" && x); // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 32, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 32, 14))
}
function foo6(x: number | string) {
>foo6 : Symbol(foo6, Decl(typeGuardsInConditionalExpression.ts, 37, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
// Modify in both branches
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
? (x = 10 && x) // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
: (x = "hello" && x); // string | number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 38, 14))
}
function foo7(x: number | string | boolean) {
>foo7 : Symbol(foo7, Decl(typeGuardsInConditionalExpression.ts, 43, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
? x === "hello" // string
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
: typeof x === "boolean"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
? x // boolean
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
: x == 10; // number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 44, 14))
}
function foo8(x: number | string | boolean) {
>foo8 : Symbol(foo8, Decl(typeGuardsInConditionalExpression.ts, 50, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
var b: number | boolean;
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 52, 7))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
? x === "hello"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
: ((b = x) && // number | boolean
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 52, 7))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
(typeof x === "boolean"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
? x // boolean
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
: x == 10)); // number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 51, 14))
}
function foo9(x: number | string) {
>foo9 : Symbol(foo9, Decl(typeGuardsInConditionalExpression.ts, 59, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
var y = 10;
>y : Symbol(y, Decl(typeGuardsInConditionalExpression.ts, 61, 7))
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
? ((y = x.length) && x === "hello") // string
>y : Symbol(y, Decl(typeGuardsInConditionalExpression.ts, 61, 7))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
: x === 10; // number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
}
function foo10(x: number | string | boolean) {
>foo10 : Symbol(foo10, Decl(typeGuardsInConditionalExpression.ts, 66, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
// Mixing typeguards
var b: boolean | number;
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 69, 7))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
? x // string
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
: ((b = x) // x is number | boolean
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 69, 7))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
&& typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
&& x.toString()); // x is number
>x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
}
function foo11(x: number | string | boolean) {
>foo11 : Symbol(foo11, Decl(typeGuardsInConditionalExpression.ts, 75, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
// Mixing typeguards
// Assigning value to x deep inside another guard stops narrowing of type too
var b: number | boolean | string;
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 79, 7))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
? x // number | boolean | string - changed in the false branch
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
: ((b = x) // x is number | boolean | string - because the assignment changed it
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 79, 7))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
&& typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
&& (x = 10) // assignment to x
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
&& x); // x is number | boolean | string
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 76, 15))
}
function foo12(x: number | string | boolean) {
>foo12 : Symbol(foo12, Decl(typeGuardsInConditionalExpression.ts, 86, 1))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
// Mixing typeguards
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
var b: number | boolean | string;
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 90, 7))
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
? (x = 10 && x.toString().length) // number | boolean | string - changed here
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
>x.toString().length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
: ((b = x) // x is number | boolean | string - changed in true branch
>b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 90, 7))
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
&& typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
&& x); // x is number
>x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
}

388
tests/baselines/reference/typeGuardsInConditionalExpression.types Normal file
View File

@@ -0,0 +1,388 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts ===
// In the true expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when true,
// provided the true expression contains no assignments to the variable or parameter.
// In the false expression of a conditional expression,
// the type of a variable or parameter is narrowed by any type guard in the condition when false,
// provided the false expression contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : (x: number | string) => number
>x : number | string
return typeof x === "string"
>typeof x === "string" ? x.length // string : x++ : number
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? x.length // string
>x.length : number
>x : string
>length : number
: x++; // number
>x++ : number
>x : number
}
function foo2(x: number | string) {
>foo2 : (x: number | string) => number | string
>x : number | string
// x is assigned in the if true branch, the type is not narrowed
return typeof x === "string"
>typeof x === "string" ? (x = 10 && x)// string | number : x : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? (x = 10 && x)// string | number
>(x = 10 && x) : number | string
>x = 10 && x : number | string
>x : number | string
>10 && x : number | string
>10 : number
>x : number | string
: x; // string | number
>x : number | string
}
function foo3(x: number | string) {
>foo3 : (x: number | string) => number | string
>x : number | string
// x is assigned in the if false branch, the type is not narrowed
// even though assigned using same type as narrowed expression
return typeof x === "string"
>typeof x === "string" ? (x = "Hello" && x) // string | number : x : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? (x = "Hello" && x) // string | number
>(x = "Hello" && x) : number | string
>x = "Hello" && x : number | string
>x : number | string
>"Hello" && x : number | string
>"Hello" : string
>x : number | string
: x; // string | number
>x : number | string
}
function foo4(x: number | string) {
>foo4 : (x: number | string) => number | string
>x : number | string
// false branch updates the variable - so here it is not number
// even though assigned using same type as narrowed expression
return typeof x === "string"
>typeof x === "string" ? x // string | number : (x = 10 && x) : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? x // string | number
>x : number | string
: (x = 10 && x); // string | number
>(x = 10 && x) : number | string
>x = 10 && x : number | string
>x : number | string
>10 && x : number | string
>10 : number
>x : number | string
}
function foo5(x: number | string) {
>foo5 : (x: number | string) => number | string
>x : number | string
// false branch updates the variable - so here it is not number
return typeof x === "string"
>typeof x === "string" ? x // string | number : (x = "hello" && x) : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? x // string | number
>x : number | string
: (x = "hello" && x); // string | number
>(x = "hello" && x) : number | string
>x = "hello" && x : number | string
>x : number | string
>"hello" && x : number | string
>"hello" : string
>x : number | string
}
function foo6(x: number | string) {
>foo6 : (x: number | string) => number | string
>x : number | string
// Modify in both branches
return typeof x === "string"
>typeof x === "string" ? (x = 10 && x) // string | number : (x = "hello" && x) : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? (x = 10 && x) // string | number
>(x = 10 && x) : number | string
>x = 10 && x : number | string
>x : number | string
>10 && x : number | string
>10 : number
>x : number | string
: (x = "hello" && x); // string | number
>(x = "hello" && x) : number | string
>x = "hello" && x : number | string
>x : number | string
>"hello" && x : number | string
>"hello" : string
>x : number | string
}
function foo7(x: number | string | boolean) {
>foo7 : (x: number | string | boolean) => boolean
>x : number | string | boolean
return typeof x === "string"
>typeof x === "string" ? x === "hello" // string : typeof x === "boolean" ? x // boolean : x == 10 : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
? x === "hello" // string
>x === "hello" : boolean
>x : string
>"hello" : string
: typeof x === "boolean"
>typeof x === "boolean" ? x // boolean : x == 10 : boolean
>typeof x === "boolean" : boolean
>typeof x : string
>x : number | boolean
>"boolean" : string
? x // boolean
>x : boolean
: x == 10; // number
>x == 10 : boolean
>x : number
>10 : number
}
function foo8(x: number | string | boolean) {
>foo8 : (x: number | string | boolean) => boolean
>x : number | string | boolean
var b: number | boolean;
>b : number | boolean
return typeof x === "string"
>typeof x === "string" ? x === "hello" : ((b = x) && // number | boolean (typeof x === "boolean" ? x // boolean : x == 10)) : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
? x === "hello"
>x === "hello" : boolean
>x : string
>"hello" : string
: ((b = x) && // number | boolean
>((b = x) && // number | boolean (typeof x === "boolean" ? x // boolean : x == 10)) : boolean
>(b = x) && // number | boolean (typeof x === "boolean" ? x // boolean : x == 10) : boolean
>(b = x) : number | boolean
>b = x : number | boolean
>b : number | boolean
>x : number | boolean
(typeof x === "boolean"
>(typeof x === "boolean" ? x // boolean : x == 10) : boolean
>typeof x === "boolean" ? x // boolean : x == 10 : boolean
>typeof x === "boolean" : boolean
>typeof x : string
>x : number | boolean
>"boolean" : string
? x // boolean
>x : boolean
: x == 10)); // number
>x == 10 : boolean
>x : number
>10 : number
}
function foo9(x: number | string) {
>foo9 : (x: number | string) => boolean
>x : number | string
var y = 10;
>y : number
>10 : number
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
return typeof x === "string"
>typeof x === "string" ? ((y = x.length) && x === "hello") // string : x === 10 : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
? ((y = x.length) && x === "hello") // string
>((y = x.length) && x === "hello") : boolean
>(y = x.length) && x === "hello" : boolean
>(y = x.length) : number
>y = x.length : number
>y : number
>x.length : number
>x : string
>length : number
>x === "hello" : boolean
>x : string
>"hello" : string
: x === 10; // number
>x === 10 : boolean
>x : number
>10 : number
}
function foo10(x: number | string | boolean) {
>foo10 : (x: number | string | boolean) => string
>x : number | string | boolean
// Mixing typeguards
var b: boolean | number;
>b : boolean | number
return typeof x === "string"
>typeof x === "string" ? x // string : ((b = x) // x is number | boolean && typeof x === "number" && x.toString()) : string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
? x // string
>x : string
: ((b = x) // x is number | boolean
>((b = x) // x is number | boolean && typeof x === "number" && x.toString()) : string
>(b = x) // x is number | boolean && typeof x === "number" && x.toString() : string
>(b = x) // x is number | boolean && typeof x === "number" : boolean
>(b = x) : number | boolean
>b = x : number | boolean
>b : boolean | number
>x : number | boolean
&& typeof x === "number"
>typeof x === "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
&& x.toString()); // x is number
>x.toString() : string
>x.toString : (radix?: number) => string
>x : number
>toString : (radix?: number) => string
}
function foo11(x: number | string | boolean) {
>foo11 : (x: number | string | boolean) => number | string | boolean
>x : number | string | boolean
// Mixing typeguards
// Assigning value to x deep inside another guard stops narrowing of type too
var b: number | boolean | string;
>b : number | boolean | string
return typeof x === "string"
>typeof x === "string" ? x // number | boolean | string - changed in the false branch : ((b = x) // x is number | boolean | string - because the assignment changed it && typeof x === "number" && (x = 10) // assignment to x && x) : number | string | boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
? x // number | boolean | string - changed in the false branch
>x : number | string | boolean
: ((b = x) // x is number | boolean | string - because the assignment changed it
>((b = x) // x is number | boolean | string - because the assignment changed it && typeof x === "number" && (x = 10) // assignment to x && x) : number | string | boolean
>(b = x) // x is number | boolean | string - because the assignment changed it && typeof x === "number" && (x = 10) // assignment to x && x : number | string | boolean
>(b = x) // x is number | boolean | string - because the assignment changed it && typeof x === "number" && (x = 10) : number
>(b = x) // x is number | boolean | string - because the assignment changed it && typeof x === "number" : boolean
>(b = x) : number | string | boolean
>b = x : number | string | boolean
>b : number | boolean | string
>x : number | string | boolean
&& typeof x === "number"
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
&& (x = 10) // assignment to x
>(x = 10) : number
>x = 10 : number
>x : number | string | boolean
>10 : number
&& x); // x is number | boolean | string
>x : number | string | boolean
}
function foo12(x: number | string | boolean) {
>foo12 : (x: number | string | boolean) => number
>x : number | string | boolean
// Mixing typeguards
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
var b: number | boolean | string;
>b : number | boolean | string
return typeof x === "string"
>typeof x === "string" ? (x = 10 && x.toString().length) // number | boolean | string - changed here : ((b = x) // x is number | boolean | string - changed in true branch && typeof x === "number" && x) : number
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
? (x = 10 && x.toString().length) // number | boolean | string - changed here
>(x = 10 && x.toString().length) : number
>x = 10 && x.toString().length : number
>x : number | string | boolean
>10 && x.toString().length : number
>10 : number
>x.toString().length : number
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
>length : number
: ((b = x) // x is number | boolean | string - changed in true branch
>((b = x) // x is number | boolean | string - changed in true branch && typeof x === "number" && x) : number
>(b = x) // x is number | boolean | string - changed in true branch && typeof x === "number" && x : number
>(b = x) // x is number | boolean | string - changed in true branch && typeof x === "number" : boolean
>(b = x) : number | string | boolean
>b = x : number | string | boolean
>b : number | boolean | string
>x : number | string | boolean
&& typeof x === "number"
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
&& x); // x is number
>x : number
}

160
tests/baselines/reference/typeGuardsInIfStatement.errors.txt
View File

@@ -1,160 +0,0 @@
tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts(127,23): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts(131,22): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts(139,16): error TS2349: Cannot invoke an expression whose type lacks a call signature.
==== tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts (3 errors) ====
// In the true branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when true,
// provided the true branch statement contains no assignments to the variable or parameter.
// In the false branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when false,
// provided the false branch statement contains no assignments to the variable or parameter
function foo(x: number | string) {
if (typeof x === "string") {
return x.length; // string
}
else {
return x++; // number
}
}
function foo2(x: number | string) {
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
x = 10;
return x; // string | number
}
else {
return x; // string | number
}
}
function foo3(x: number | string) {
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
x = "Hello"; // even though assigned using same type as narrowed expression
return x; // string | number
}
else {
return x; // string | number
}
}
function foo4(x: number | string) {
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
return x; // string | number
}
else {
x = 10; // even though assigned number - this should result in x to be string | number
return x; // string | number
}
}
function foo5(x: number | string) {
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
return x; // string | number
}
else {
x = "hello";
return x; // string | number
}
}
function foo6(x: number | string) {
// Modify in both branches
if (typeof x === "string") {
x = 10;
return x; // string | number
}
else {
x = "hello";
return x; // string | number
}
}
function foo7(x: number | string | boolean) {
if (typeof x === "string") {
return x === "hello"; // string
}
else if (typeof x === "boolean") {
return x; // boolean
}
else {
return x == 10; // number
}
}
function foo8(x: number | string | boolean) {
if (typeof x === "string") {
return x === "hello"; // string
}
else {
var b: number | boolean = x; // number | boolean
if (typeof x === "boolean") {
return x; // boolean
}
else {
return x == 10; // number
}
}
}
function foo9(x: number | string) {
var y = 10;
if (typeof x === "string") {
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
y = x.length;
return x === "hello"; // string
}
else {
return x == 10; // number
}
}
function foo10(x: number | string | boolean) {
// Mixing typeguard narrowing in if statement with conditional expression typeguard
if (typeof x === "string") {
return x === "hello"; // string
}
else {
var y: boolean | string;
var b = x; // number | boolean
return typeof x === "number"
? x === 10 // number
: x; // x should be boolean
}
}
function foo11(x: number | string | boolean) {
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x deep inside another guard stops narrowing of type too
if (typeof x === "string") {
return x; // string | number | boolean - x changed in else branch
}
else {
var y: number| boolean | string;
var b = x; // number | boolean | string - because below we are changing value of x in if statement
return typeof x === "number"
? (
// change value of x
x = 10 && x.toString() // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
)
: (
// do not change value
y = x && x.toString() // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
);
}
}
function foo12(x: number | string | boolean) {
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
if (typeof x === "string") {
return x.toString(); // string | number | boolean - x changed in else branch
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
}
else {
x = 10;
var b = x; // number | boolean | string
return typeof x === "number"
? x.toString() // number
: x.toString(); // boolean | string
}
}

304
tests/baselines/reference/typeGuardsInIfStatement.symbols Normal file
View File

@@ -0,0 +1,304 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts ===
// In the true branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when true,
// provided the true branch statement contains no assignments to the variable or parameter.
// In the false branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when false,
// provided the false branch statement contains no assignments to the variable or parameter
function foo(x: number | string) {
>foo : Symbol(foo, Decl(typeGuardsInIfStatement.ts, 0, 0))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
return x.length; // string
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
}
else {
return x++; // number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
}
}
function foo2(x: number | string) {
>foo2 : Symbol(foo2, Decl(typeGuardsInIfStatement.ts, 13, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 14, 14))
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 14, 14))
x = 10;
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 14, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 14, 14))
}
else {
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 14, 14))
}
}
function foo3(x: number | string) {
>foo3 : Symbol(foo3, Decl(typeGuardsInIfStatement.ts, 23, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 24, 14))
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 24, 14))
x = "Hello"; // even though assigned using same type as narrowed expression
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 24, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 24, 14))
}
else {
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 24, 14))
}
}
function foo4(x: number | string) {
>foo4 : Symbol(foo4, Decl(typeGuardsInIfStatement.ts, 33, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 34, 14))
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 34, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 34, 14))
}
else {
x = 10; // even though assigned number - this should result in x to be string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 34, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 34, 14))
}
}
function foo5(x: number | string) {
>foo5 : Symbol(foo5, Decl(typeGuardsInIfStatement.ts, 43, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 44, 14))
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 44, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 44, 14))
}
else {
x = "hello";
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 44, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 44, 14))
}
}
function foo6(x: number | string) {
>foo6 : Symbol(foo6, Decl(typeGuardsInIfStatement.ts, 53, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
// Modify in both branches
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
x = 10;
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
}
else {
x = "hello";
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
return x; // string | number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 54, 14))
}
}
function foo7(x: number | string | boolean) {
>foo7 : Symbol(foo7, Decl(typeGuardsInIfStatement.ts, 64, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
return x === "hello"; // string
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
}
else if (typeof x === "boolean") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
return x; // boolean
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
}
else {
return x == 10; // number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 65, 14))
}
}
function foo8(x: number | string | boolean) {
>foo8 : Symbol(foo8, Decl(typeGuardsInIfStatement.ts, 75, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
return x === "hello"; // string
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
}
else {
var b: number | boolean = x; // number | boolean
>b : Symbol(b, Decl(typeGuardsInIfStatement.ts, 81, 11))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
if (typeof x === "boolean") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
return x; // boolean
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
}
else {
return x == 10; // number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 76, 14))
}
}
}
function foo9(x: number | string) {
>foo9 : Symbol(foo9, Decl(typeGuardsInIfStatement.ts, 89, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
var y = 10;
>y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 91, 7))
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
y = x.length;
>y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 91, 7))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
return x === "hello"; // string
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
}
else {
return x == 10; // number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
}
}
function foo10(x: number | string | boolean) {
>foo10 : Symbol(foo10, Decl(typeGuardsInIfStatement.ts, 100, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
// Mixing typeguard narrowing in if statement with conditional expression typeguard
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
return x === "hello"; // string
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
}
else {
var y: boolean | string;
>y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 107, 11))
var b = x; // number | boolean
>b : Symbol(b, Decl(typeGuardsInIfStatement.ts, 108, 11))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
return typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
? x === 10 // number
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
: x; // x should be boolean
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 101, 15))
}
}
function foo11(x: number | string | boolean) {
>foo11 : Symbol(foo11, Decl(typeGuardsInIfStatement.ts, 113, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x deep inside another guard stops narrowing of type too
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
return x; // string | number | boolean - x changed in else branch
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
}
else {
var y: number| boolean | string;
>y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 121, 11))
var b = x; // number | boolean | string - because below we are changing value of x in if statement
>b : Symbol(b, Decl(typeGuardsInIfStatement.ts, 122, 11))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
return typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
? (
// change value of x
x = 10 && x.toString() // number | boolean | string
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
)
: (
// do not change value
y = x && x.toString() // number | boolean | string
>y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 121, 11))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
);
}
}
function foo12(x: number | string | boolean) {
>foo12 : Symbol(foo12, Decl(typeGuardsInIfStatement.ts, 133, 1))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
if (typeof x === "string") {
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
return x.toString(); // string | number | boolean - x changed in else branch
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
}
else {
x = 10;
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
var b = x; // number | boolean | string
>b : Symbol(b, Decl(typeGuardsInIfStatement.ts, 142, 11))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
return typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
? x.toString() // number
>x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
: x.toString(); // boolean | string
>x.toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
>toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
}
}

405
tests/baselines/reference/typeGuardsInIfStatement.types Normal file
View File

@@ -0,0 +1,405 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInIfStatement.ts ===
// In the true branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when true,
// provided the true branch statement contains no assignments to the variable or parameter.
// In the false branch statement of an <20>if<69> statement,
// the type of a variable or parameter is narrowed by any type guard in the <20>if<69> condition when false,
// provided the false branch statement contains no assignments to the variable or parameter
function foo(x: number | string) {
>foo : (x: number | string) => number
>x : number | string
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
return x.length; // string
>x.length : number
>x : string
>length : number
}
else {
return x++; // number
>x++ : number
>x : number
}
}
function foo2(x: number | string) {
>foo2 : (x: number | string) => number | string
>x : number | string
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
x = 10;
>x = 10 : number
>x : number | string
>10 : number
return x; // string | number
>x : number | string
}
else {
return x; // string | number
>x : number | string
}
}
function foo3(x: number | string) {
>foo3 : (x: number | string) => number | string
>x : number | string
// x is assigned in the if true branch, the type is not narrowed
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
x = "Hello"; // even though assigned using same type as narrowed expression
>x = "Hello" : string
>x : number | string
>"Hello" : string
return x; // string | number
>x : number | string
}
else {
return x; // string | number
>x : number | string
}
}
function foo4(x: number | string) {
>foo4 : (x: number | string) => number | string
>x : number | string
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
return x; // string | number
>x : number | string
}
else {
x = 10; // even though assigned number - this should result in x to be string | number
>x = 10 : number
>x : number | string
>10 : number
return x; // string | number
>x : number | string
}
}
function foo5(x: number | string) {
>foo5 : (x: number | string) => number | string
>x : number | string
// false branch updates the variable - so here it is not number
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
return x; // string | number
>x : number | string
}
else {
x = "hello";
>x = "hello" : string
>x : number | string
>"hello" : string
return x; // string | number
>x : number | string
}
}
function foo6(x: number | string) {
>foo6 : (x: number | string) => number | string
>x : number | string
// Modify in both branches
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
x = 10;
>x = 10 : number
>x : number | string
>10 : number
return x; // string | number
>x : number | string
}
else {
x = "hello";
>x = "hello" : string
>x : number | string
>"hello" : string
return x; // string | number
>x : number | string
}
}
function foo7(x: number | string | boolean) {
>foo7 : (x: number | string | boolean) => boolean
>x : number | string | boolean
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
return x === "hello"; // string
>x === "hello" : boolean
>x : string
>"hello" : string
}
else if (typeof x === "boolean") {
>typeof x === "boolean" : boolean
>typeof x : string
>x : number | boolean
>"boolean" : string
return x; // boolean
>x : boolean
}
else {
return x == 10; // number
>x == 10 : boolean
>x : number
>10 : number
}
}
function foo8(x: number | string | boolean) {
>foo8 : (x: number | string | boolean) => boolean
>x : number | string | boolean
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
return x === "hello"; // string
>x === "hello" : boolean
>x : string
>"hello" : string
}
else {
var b: number | boolean = x; // number | boolean
>b : number | boolean
>x : number | boolean
if (typeof x === "boolean") {
>typeof x === "boolean" : boolean
>typeof x : string
>x : number | boolean
>"boolean" : string
return x; // boolean
>x : boolean
}
else {
return x == 10; // number
>x == 10 : boolean
>x : number
>10 : number
}
}
}
function foo9(x: number | string) {
>foo9 : (x: number | string) => boolean
>x : number | string
var y = 10;
>y : number
>10 : number
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
y = x.length;
>y = x.length : number
>y : number
>x.length : number
>x : string
>length : number
return x === "hello"; // string
>x === "hello" : boolean
>x : string
>"hello" : string
}
else {
return x == 10; // number
>x == 10 : boolean
>x : number
>10 : number
}
}
function foo10(x: number | string | boolean) {
>foo10 : (x: number | string | boolean) => boolean
>x : number | string | boolean
// Mixing typeguard narrowing in if statement with conditional expression typeguard
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
return x === "hello"; // string
>x === "hello" : boolean
>x : string
>"hello" : string
}
else {
var y: boolean | string;
>y : boolean | string
var b = x; // number | boolean
>b : number | boolean
>x : number | boolean
return typeof x === "number"
>typeof x === "number" ? x === 10 // number : x : boolean
>typeof x === "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
? x === 10 // number
>x === 10 : boolean
>x : number
>10 : number
: x; // x should be boolean
>x : boolean
}
}
function foo11(x: number | string | boolean) {
>foo11 : (x: number | string | boolean) => number | string | boolean
>x : number | string | boolean
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x deep inside another guard stops narrowing of type too
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
return x; // string | number | boolean - x changed in else branch
>x : number | string | boolean
}
else {
var y: number| boolean | string;
>y : number | boolean | string
var b = x; // number | boolean | string - because below we are changing value of x in if statement
>b : number | string | boolean
>x : number | string | boolean
return typeof x === "number"
>typeof x === "number" ? ( // change value of x x = 10 && x.toString() // number | boolean | string ) : ( // do not change value y = x && x.toString() // number | boolean | string ) : string
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
? (
>( // change value of x x = 10 && x.toString() // number | boolean | string ) : string
// change value of x
x = 10 && x.toString() // number | boolean | string
>x = 10 && x.toString() : string
>x : number | string | boolean
>10 && x.toString() : string
>10 : number
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
)
: (
>( // do not change value y = x && x.toString() // number | boolean | string ) : string
// do not change value
y = x && x.toString() // number | boolean | string
>y = x && x.toString() : string
>y : number | boolean | string
>x && x.toString() : string
>x : number | string | boolean
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
);
}
}
function foo12(x: number | string | boolean) {
>foo12 : (x: number | string | boolean) => string
>x : number | string | boolean
// Mixing typeguard narrowing in if statement with conditional expression typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
return x.toString(); // string | number | boolean - x changed in else branch
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
}
else {
x = 10;
>x = 10 : number
>x : number | string | boolean
>10 : number
var b = x; // number | boolean | string
>b : number | string | boolean
>x : number | string | boolean
return typeof x === "number"
>typeof x === "number" ? x.toString() // number : x.toString() : string
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
? x.toString() // number
>x.toString() : string
>x.toString : (radix?: number) => string
>x : number
>toString : (radix?: number) => string
: x.toString(); // boolean | string
>x.toString() : string
>x.toString : () => string
>x : string | boolean
>toString : () => string
}
}

64
tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.errors.txt
View File

@@ -1,64 +0,0 @@
tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfAndAndOperator.ts(43,22): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfAndAndOperator.ts(45,21): error TS2349: Cannot invoke an expression whose type lacks a call signature.
==== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfAndAndOperator.ts (2 errors) ====
// In the right operand of a && operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when true,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
return typeof x === "string" && x.length === 10; // string
}
function foo2(x: number | string) {
// modify x in right hand operand
return typeof x === "string" && ((x = 10) && x); // string | number
}
function foo3(x: number | string) {
// modify x in right hand operand with string type itself
return typeof x === "string" && ((x = "hello") && x); // string | number
}
function foo4(x: number | string | boolean) {
return typeof x !== "string" // string | number | boolean
&& typeof x !== "number" // number | boolean
&& x; // boolean
}
function foo5(x: number | string | boolean) {
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
return typeof x !== "string" // string | number | boolean
&& ((b = x) && (typeof x !== "number" // number | boolean
&& x)); // boolean
}
function foo6(x: number | string | boolean) {
// Mixing typeguard narrowing in if statement with conditional expression typeguard
return typeof x !== "string" // string | number | boolean
&& (typeof x !== "number" // number | boolean
? x // boolean
: x === 10) // number
}
function foo7(x: number | string | boolean) {
var y: number| boolean | string;
var z: number| boolean | string;
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x !== "string"
&& ((z = x) // string | number | boolean - x changed deeper in conditional expression
&& (typeof x === "number"
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
// do not change value
: (y = x && x.toString()))); // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
}
function foo8(x: number | string) {
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x !== "string"
&& (x = 10) // change x - number| string
&& (typeof x === "number"
? x // number
: x.length); // string
}

143
tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols Normal file
View File

@@ -0,0 +1,143 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfAndAndOperator.ts ===
// In the right operand of a && operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when true,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : Symbol(foo, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 0, 0))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13))
return typeof x === "string" && x.length === 10; // string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
}
function foo2(x: number | string) {
>foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 5, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 6, 14))
// modify x in right hand operand
return typeof x === "string" && ((x = 10) && x); // string | number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 6, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 6, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 6, 14))
}
function foo3(x: number | string) {
>foo3 : Symbol(foo3, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 9, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 10, 14))
// modify x in right hand operand with string type itself
return typeof x === "string" && ((x = "hello") && x); // string | number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 10, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 10, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 10, 14))
}
function foo4(x: number | string | boolean) {
>foo4 : Symbol(foo4, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 13, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 14, 14))
return typeof x !== "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 14, 14))
&& typeof x !== "number" // number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 14, 14))
&& x; // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 14, 14))
}
function foo5(x: number | string | boolean) {
>foo5 : Symbol(foo5, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 18, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 19, 14))
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
>b : Symbol(b, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 21, 7))
return typeof x !== "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 19, 14))
&& ((b = x) && (typeof x !== "number" // number | boolean
>b : Symbol(b, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 21, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 19, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 19, 14))
&& x)); // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 19, 14))
}
function foo6(x: number | string | boolean) {
>foo6 : Symbol(foo6, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 25, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 26, 14))
// Mixing typeguard narrowing in if statement with conditional expression typeguard
return typeof x !== "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 26, 14))
&& (typeof x !== "number" // number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 26, 14))
? x // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 26, 14))
: x === 10) // number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 26, 14))
}
function foo7(x: number | string | boolean) {
>foo7 : Symbol(foo7, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 32, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
var y: number| boolean | string;
>y : Symbol(y, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 34, 7))
var z: number| boolean | string;
>z : Symbol(z, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 35, 7))
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x !== "string"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
&& ((z = x) // string | number | boolean - x changed deeper in conditional expression
>z : Symbol(z, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 35, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
&& (typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
// do not change value
: (y = x && x.toString()))); // number | boolean | string
>y : Symbol(y, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 34, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
}
function foo8(x: number | string) {
>foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 45, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x !== "string"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
&& (x = 10) // change x - number| string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
&& (typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
? x // number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
: x.length); // string
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
}

234
tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.types Normal file
View File

@@ -0,0 +1,234 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfAndAndOperator.ts ===
// In the right operand of a && operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when true,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : (x: number | string) => boolean
>x : number | string
return typeof x === "string" && x.length === 10; // string
>typeof x === "string" && x.length === 10 : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>x.length === 10 : boolean
>x.length : number
>x : string
>length : number
>10 : number
}
function foo2(x: number | string) {
>foo2 : (x: number | string) => number | string
>x : number | string
// modify x in right hand operand
return typeof x === "string" && ((x = 10) && x); // string | number
>typeof x === "string" && ((x = 10) && x) : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>((x = 10) && x) : number | string
>(x = 10) && x : number | string
>(x = 10) : number
>x = 10 : number
>x : number | string
>10 : number
>x : number | string
}
function foo3(x: number | string) {
>foo3 : (x: number | string) => number | string
>x : number | string
// modify x in right hand operand with string type itself
return typeof x === "string" && ((x = "hello") && x); // string | number
>typeof x === "string" && ((x = "hello") && x) : number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>((x = "hello") && x) : number | string
>(x = "hello") && x : number | string
>(x = "hello") : string
>x = "hello" : string
>x : number | string
>"hello" : string
>x : number | string
}
function foo4(x: number | string | boolean) {
>foo4 : (x: number | string | boolean) => boolean
>x : number | string | boolean
return typeof x !== "string" // string | number | boolean
>typeof x !== "string" // string | number | boolean && typeof x !== "number" // number | boolean && x : boolean
>typeof x !== "string" // string | number | boolean && typeof x !== "number" : boolean
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
&& typeof x !== "number" // number | boolean
>typeof x !== "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
&& x; // boolean
>x : boolean
}
function foo5(x: number | string | boolean) {
>foo5 : (x: number | string | boolean) => boolean
>x : number | string | boolean
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
>b : number | boolean
return typeof x !== "string" // string | number | boolean
>typeof x !== "string" // string | number | boolean && ((b = x) && (typeof x !== "number" // number | boolean && x)) : boolean
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
&& ((b = x) && (typeof x !== "number" // number | boolean
>((b = x) && (typeof x !== "number" // number | boolean && x)) : boolean
>(b = x) && (typeof x !== "number" // number | boolean && x) : boolean
>(b = x) : number | boolean
>b = x : number | boolean
>b : number | boolean
>x : number | boolean
>(typeof x !== "number" // number | boolean && x) : boolean
>typeof x !== "number" // number | boolean && x : boolean
>typeof x !== "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
&& x)); // boolean
>x : boolean
}
function foo6(x: number | string | boolean) {
>foo6 : (x: number | string | boolean) => boolean
>x : number | string | boolean
// Mixing typeguard narrowing in if statement with conditional expression typeguard
return typeof x !== "string" // string | number | boolean
>typeof x !== "string" // string | number | boolean && (typeof x !== "number" // number | boolean ? x // boolean : x === 10) : boolean
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
&& (typeof x !== "number" // number | boolean
>(typeof x !== "number" // number | boolean ? x // boolean : x === 10) : boolean
>typeof x !== "number" // number | boolean ? x // boolean : x === 10 : boolean
>typeof x !== "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
? x // boolean
>x : boolean
: x === 10) // number
>x === 10 : boolean
>x : number
>10 : number
}
function foo7(x: number | string | boolean) {
>foo7 : (x: number | string | boolean) => string
>x : number | string | boolean
var y: number| boolean | string;
>y : number | boolean | string
var z: number| boolean | string;
>z : number | boolean | string
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x !== "string"
>typeof x !== "string" && ((z = x) // string | number | boolean - x changed deeper in conditional expression && (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()))) : string
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
&& ((z = x) // string | number | boolean - x changed deeper in conditional expression
>((z = x) // string | number | boolean - x changed deeper in conditional expression && (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()))) : string
>(z = x) // string | number | boolean - x changed deeper in conditional expression && (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString())) : string
>(z = x) : number | string | boolean
>z = x : number | string | boolean
>z : number | boolean | string
>x : number | string | boolean
&& (typeof x === "number"
>(typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString())) : string
>typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()) : string
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
>(x = 10 && x.toString()) : string
>x = 10 && x.toString() : string
>x : number | string | boolean
>10 && x.toString() : string
>10 : number
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
// do not change value
: (y = x && x.toString()))); // number | boolean | string
>(y = x && x.toString()) : string
>y = x && x.toString() : string
>y : number | boolean | string
>x && x.toString() : string
>x : number | string | boolean
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
}
function foo8(x: number | string) {
>foo8 : (x: number | string) => number
>x : number | string
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x !== "string"
>typeof x !== "string" && (x = 10) // change x - number| string && (typeof x === "number" ? x // number : x.length) : number
>typeof x !== "string" && (x = 10) : number
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
&& (x = 10) // change x - number| string
>(x = 10) : number
>x = 10 : number
>x : number | string
>10 : number
&& (typeof x === "number"
>(typeof x === "number" ? x // number : x.length) : number
>typeof x === "number" ? x // number : x.length : number
>typeof x === "number" : boolean
>typeof x : string
>x : number | string
>"number" : string
? x // number
>x : number
: x.length); // string
>x.length : number
>x : string
>length : number
}

64
tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.errors.txt
View File

@@ -1,64 +0,0 @@
tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfOrOrOperator.ts(43,22): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfOrOrOperator.ts(45,21): error TS2349: Cannot invoke an expression whose type lacks a call signature.
==== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfOrOrOperator.ts (2 errors) ====
// In the right operand of a || operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when false,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
return typeof x !== "string" || x.length === 10; // string
}
function foo2(x: number | string) {
// modify x in right hand operand
return typeof x !== "string" || ((x = 10) || x); // string | number
}
function foo3(x: number | string) {
// modify x in right hand operand with string type itself
return typeof x !== "string" || ((x = "hello") || x); // string | number
}
function foo4(x: number | string | boolean) {
return typeof x === "string" // string | number | boolean
|| typeof x === "number" // number | boolean
|| x; // boolean
}
function foo5(x: number | string | boolean) {
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
return typeof x === "string" // string | number | boolean
|| ((b = x) || (typeof x === "number" // number | boolean
|| x)); // boolean
}
function foo6(x: number | string | boolean) {
// Mixing typeguard
return typeof x === "string" // string | number | boolean
|| (typeof x !== "number" // number | boolean
? x // boolean
: x === 10) // number
}
function foo7(x: number | string | boolean) {
var y: number| boolean | string;
var z: number| boolean | string;
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x === "string"
|| ((z = x) // string | number | boolean - x changed deeper in conditional expression
|| (typeof x === "number"
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
// do not change value
: (y = x && x.toString()))); // number | boolean | string
~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
}
function foo8(x: number | string) {
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x === "string"
|| (x = 10) // change x - number| string
|| (typeof x === "number"
? x // number
: x.length); // string
}

143
tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols Normal file
View File

@@ -0,0 +1,143 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfOrOrOperator.ts ===
// In the right operand of a || operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when false,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : Symbol(foo, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 0, 0))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13))
return typeof x !== "string" || x.length === 10; // string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13))
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
}
function foo2(x: number | string) {
>foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 5, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 6, 14))
// modify x in right hand operand
return typeof x !== "string" || ((x = 10) || x); // string | number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 6, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 6, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 6, 14))
}
function foo3(x: number | string) {
>foo3 : Symbol(foo3, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 9, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 10, 14))
// modify x in right hand operand with string type itself
return typeof x !== "string" || ((x = "hello") || x); // string | number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 10, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 10, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 10, 14))
}
function foo4(x: number | string | boolean) {
>foo4 : Symbol(foo4, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 13, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 14, 14))
return typeof x === "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 14, 14))
|| typeof x === "number" // number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 14, 14))
|| x; // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 14, 14))
}
function foo5(x: number | string | boolean) {
>foo5 : Symbol(foo5, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 18, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 19, 14))
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
>b : Symbol(b, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 21, 7))
return typeof x === "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 19, 14))
|| ((b = x) || (typeof x === "number" // number | boolean
>b : Symbol(b, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 21, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 19, 14))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 19, 14))
|| x)); // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 19, 14))
}
function foo6(x: number | string | boolean) {
>foo6 : Symbol(foo6, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 25, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 26, 14))
// Mixing typeguard
return typeof x === "string" // string | number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 26, 14))
|| (typeof x !== "number" // number | boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 26, 14))
? x // boolean
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 26, 14))
: x === 10) // number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 26, 14))
}
function foo7(x: number | string | boolean) {
>foo7 : Symbol(foo7, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 32, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
var y: number| boolean | string;
>y : Symbol(y, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 34, 7))
var z: number| boolean | string;
>z : Symbol(z, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 35, 7))
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
|| ((z = x) // string | number | boolean - x changed deeper in conditional expression
>z : Symbol(z, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 35, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
|| (typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
// do not change value
: (y = x && x.toString()))); // number | boolean | string
>y : Symbol(y, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 34, 7))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
>x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
>toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
}
function foo8(x: number | string) {
>foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 45, 1))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x === "string"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
|| (x = 10) // change x - number| string
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
|| (typeof x === "number"
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
? x // number
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
: x.length); // string
>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
>x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
}

234
tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.types Normal file
View File

@@ -0,0 +1,234 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardsInRightOperandOfOrOrOperator.ts ===
// In the right operand of a || operation,
// the type of a variable or parameter is narrowed by any type guard in the left operand when false,
// provided the right operand contains no assignments to the variable or parameter.
function foo(x: number | string) {
>foo : (x: number | string) => boolean
>x : number | string
return typeof x !== "string" || x.length === 10; // string
>typeof x !== "string" || x.length === 10 : boolean
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>x.length === 10 : boolean
>x.length : number
>x : string
>length : number
>10 : number
}
function foo2(x: number | string) {
>foo2 : (x: number | string) => boolean | number | string
>x : number | string
// modify x in right hand operand
return typeof x !== "string" || ((x = 10) || x); // string | number
>typeof x !== "string" || ((x = 10) || x) : boolean | number | string
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>((x = 10) || x) : number | string
>(x = 10) || x : number | string
>(x = 10) : number
>x = 10 : number
>x : number | string
>10 : number
>x : number | string
}
function foo3(x: number | string) {
>foo3 : (x: number | string) => boolean | string | number
>x : number | string
// modify x in right hand operand with string type itself
return typeof x !== "string" || ((x = "hello") || x); // string | number
>typeof x !== "string" || ((x = "hello") || x) : boolean | string | number
>typeof x !== "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
>((x = "hello") || x) : string | number
>(x = "hello") || x : string | number
>(x = "hello") : string
>x = "hello" : string
>x : number | string
>"hello" : string
>x : number | string
}
function foo4(x: number | string | boolean) {
>foo4 : (x: number | string | boolean) => boolean
>x : number | string | boolean
return typeof x === "string" // string | number | boolean
>typeof x === "string" // string | number | boolean || typeof x === "number" // number | boolean || x : boolean
>typeof x === "string" // string | number | boolean || typeof x === "number" : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
|| typeof x === "number" // number | boolean
>typeof x === "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
|| x; // boolean
>x : boolean
}
function foo5(x: number | string | boolean) {
>foo5 : (x: number | string | boolean) => boolean | number
>x : number | string | boolean
// usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
var b: number | boolean;
>b : number | boolean
return typeof x === "string" // string | number | boolean
>typeof x === "string" // string | number | boolean || ((b = x) || (typeof x === "number" // number | boolean || x)) : boolean | number
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
|| ((b = x) || (typeof x === "number" // number | boolean
>((b = x) || (typeof x === "number" // number | boolean || x)) : number | boolean
>(b = x) || (typeof x === "number" // number | boolean || x) : number | boolean
>(b = x) : number | boolean
>b = x : number | boolean
>b : number | boolean
>x : number | boolean
>(typeof x === "number" // number | boolean || x) : boolean
>typeof x === "number" // number | boolean || x : boolean
>typeof x === "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
|| x)); // boolean
>x : boolean
}
function foo6(x: number | string | boolean) {
>foo6 : (x: number | string | boolean) => boolean
>x : number | string | boolean
// Mixing typeguard
return typeof x === "string" // string | number | boolean
>typeof x === "string" // string | number | boolean || (typeof x !== "number" // number | boolean ? x // boolean : x === 10) : boolean
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
|| (typeof x !== "number" // number | boolean
>(typeof x !== "number" // number | boolean ? x // boolean : x === 10) : boolean
>typeof x !== "number" // number | boolean ? x // boolean : x === 10 : boolean
>typeof x !== "number" : boolean
>typeof x : string
>x : number | boolean
>"number" : string
? x // boolean
>x : boolean
: x === 10) // number
>x === 10 : boolean
>x : number
>10 : number
}
function foo7(x: number | string | boolean) {
>foo7 : (x: number | string | boolean) => boolean | number | string
>x : number | string | boolean
var y: number| boolean | string;
>y : number | boolean | string
var z: number| boolean | string;
>z : number | boolean | string
// Mixing typeguard narrowing
// Assigning value to x deep inside another guard stops narrowing of type too
return typeof x === "string"
>typeof x === "string" || ((z = x) // string | number | boolean - x changed deeper in conditional expression || (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()))) : boolean | number | string
>typeof x === "string" : boolean
>typeof x : string
>x : number | string | boolean
>"string" : string
|| ((z = x) // string | number | boolean - x changed deeper in conditional expression
>((z = x) // string | number | boolean - x changed deeper in conditional expression || (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()))) : number | string | boolean
>(z = x) // string | number | boolean - x changed deeper in conditional expression || (typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString())) : number | string | boolean
>(z = x) : number | string | boolean
>z = x : number | string | boolean
>z : number | boolean | string
>x : number | string | boolean
|| (typeof x === "number"
>(typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString())) : string
>typeof x === "number" // change value of x ? (x = 10 && x.toString()) // number | boolean | string // do not change value : (y = x && x.toString()) : string
>typeof x === "number" : boolean
>typeof x : string
>x : number | string | boolean
>"number" : string
// change value of x
? (x = 10 && x.toString()) // number | boolean | string
>(x = 10 && x.toString()) : string
>x = 10 && x.toString() : string
>x : number | string | boolean
>10 && x.toString() : string
>10 : number
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
// do not change value
: (y = x && x.toString()))); // number | boolean | string
>(y = x && x.toString()) : string
>y = x && x.toString() : string
>y : number | boolean | string
>x && x.toString() : string
>x : number | string | boolean
>x.toString() : string
>x.toString : ((radix?: number) => string) | (() => string)
>x : number | string | boolean
>toString : ((radix?: number) => string) | (() => string)
}
function foo8(x: number | string) {
>foo8 : (x: number | string) => boolean | number
>x : number | string
// Mixing typeguard
// Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
return typeof x === "string"
>typeof x === "string" || (x = 10) // change x - number| string || (typeof x === "number" ? x // number : x.length) : boolean | number
>typeof x === "string" || (x = 10) : boolean | number
>typeof x === "string" : boolean
>typeof x : string
>x : number | string
>"string" : string
|| (x = 10) // change x - number| string
>(x = 10) : number
>x = 10 : number
>x : number | string
>10 : number
|| (typeof x === "number"
>(typeof x === "number" ? x // number : x.length) : number
>typeof x === "number" ? x // number : x.length : number
>typeof x === "number" : boolean
>typeof x : string
>x : number | string
>"number" : string
? x // number
>x : number
: x.length); // string
>x.length : number
>x : string
>length : number
}

46
tests/baselines/reference/unionTypeCallSignatures.errors.txt
View File

@@ -16,10 +16,9 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(40,12): error TS2
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(41,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(42,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(43,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(46,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(47,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(48,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(49,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(47,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(48,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(49,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(55,45): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(56,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(59,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
@@ -27,14 +26,13 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(60,12): error TS2
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(61,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(62,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(63,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(66,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(67,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(68,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(69,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2349: Cannot invoke an expression whose type lacks a call signature.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(67,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(68,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(69,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2346: Supplied parameters do not match any signature of call target.
==== tests/cases/conformance/types/union/unionTypeCallSignatures.ts (34 errors) ====
==== tests/cases/conformance/types/union/unionTypeCallSignatures.ts (32 errors) ====
var numOrDate: number | Date;
var strOrBoolean: string | boolean;
var strOrNum: string | number;
@@ -80,7 +78,7 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2
~~~~~~~
!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
var unionWithDifferentParameterCount: { (a: string): string; } | { (a: string, b: number): number; } ;
var unionWithDifferentParameterCount: { (a: string): string; } | { (a: string, b: number): number; } ;
unionWithDifferentParameterCount();// no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
@@ -91,7 +89,7 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
var unionWithOptionalParameter1: { (a: string, b?: number): string; } | { (a: string, b?: number): number; };
var unionWithOptionalParameter1: { (a: string, b?: number): string; } | { (a: string, b?: number): number; };
strOrNum = unionWithOptionalParameter1('hello');
strOrNum = unionWithOptionalParameter1('hello', 10);
strOrNum = unionWithOptionalParameter1('hello', "hello"); // error in parameter type
@@ -116,18 +114,16 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
var unionWithOptionalParameter3: { (a: string, b?: number): string; } | { (a: string): number; };
strOrNum = unionWithOptionalParameter3('hello'); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
strOrNum = unionWithOptionalParameter3('hello');
strOrNum = unionWithOptionalParameter3('hello', 10); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = unionWithOptionalParameter3('hello', "hello"); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = unionWithOptionalParameter3(); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
var unionWithRestParameter1: { (a: string, ...b: number[]): string; } | { (a: string, ...b: number[]): number };
strOrNum = unionWithRestParameter1('hello');
@@ -158,18 +154,18 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
var unionWithRestParameter3: { (a: string, ...b: number[]): string; } | { (a: string): number };
strOrNum = unionWithRestParameter3('hello'); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
strOrNum = unionWithRestParameter3('hello');
strOrNum = unionWithRestParameter3('hello', 10); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = unionWithRestParameter3(); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.

16
tests/baselines/reference/unionTypeCallSignatures.js
View File

@@ -26,12 +26,12 @@ unionOfDifferentNumberOfSignatures(); // error - no call signatures
unionOfDifferentNumberOfSignatures(10); // error - no call signatures
unionOfDifferentNumberOfSignatures("hello"); // error - no call signatures
var unionWithDifferentParameterCount: { (a: string): string; } | { (a: string, b: number): number; } ;
var unionWithDifferentParameterCount: { (a: string): string; } | { (a: string, b: number): number; } ;
unionWithDifferentParameterCount();// no call signature
unionWithDifferentParameterCount("hello");// no call signature
unionWithDifferentParameterCount("hello", 10);// no call signature
var unionWithOptionalParameter1: { (a: string, b?: number): string; } | { (a: string, b?: number): number; };
var unionWithOptionalParameter1: { (a: string, b?: number): string; } | { (a: string, b?: number): number; };
strOrNum = unionWithOptionalParameter1('hello');
strOrNum = unionWithOptionalParameter1('hello', 10);
strOrNum = unionWithOptionalParameter1('hello', "hello"); // error in parameter type
@@ -44,7 +44,7 @@ strOrNum = unionWithOptionalParameter2('hello', "hello"); // error no call signa
strOrNum = unionWithOptionalParameter2(); // error no call signature
var unionWithOptionalParameter3: { (a: string, b?: number): string; } | { (a: string): number; };
strOrNum = unionWithOptionalParameter3('hello'); // error no call signature
strOrNum = unionWithOptionalParameter3('hello');
strOrNum = unionWithOptionalParameter3('hello', 10); // error no call signature
strOrNum = unionWithOptionalParameter3('hello', "hello"); // error no call signature
strOrNum = unionWithOptionalParameter3(); // error no call signature
@@ -64,11 +64,13 @@ strOrNum = unionWithRestParameter2('hello', "hello"); // error no call signature
strOrNum = unionWithRestParameter2(); // error no call signature
var unionWithRestParameter3: { (a: string, ...b: number[]): string; } | { (a: string): number };
strOrNum = unionWithRestParameter3('hello'); // error no call signature
strOrNum = unionWithRestParameter3('hello');
strOrNum = unionWithRestParameter3('hello', 10); // error no call signature
strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature
strOrNum = unionWithRestParameter3(); // error no call signature
strOrNum = unionWithRestParameter3(); // error no call signature
//// [unionTypeCallSignatures.js]
var numOrDate;
@@ -108,7 +110,7 @@ strOrNum = unionWithOptionalParameter2('hello', 10); // error no call signature
strOrNum = unionWithOptionalParameter2('hello', "hello"); // error no call signature
strOrNum = unionWithOptionalParameter2(); // error no call signature
var unionWithOptionalParameter3;
strOrNum = unionWithOptionalParameter3('hello'); // error no call signature
strOrNum = unionWithOptionalParameter3('hello');
strOrNum = unionWithOptionalParameter3('hello', 10); // error no call signature
strOrNum = unionWithOptionalParameter3('hello', "hello"); // error no call signature
strOrNum = unionWithOptionalParameter3(); // error no call signature
@@ -125,7 +127,7 @@ strOrNum = unionWithRestParameter2('hello', 10, 11); // error no call signature
strOrNum = unionWithRestParameter2('hello', "hello"); // error no call signature
strOrNum = unionWithRestParameter2(); // error no call signature
var unionWithRestParameter3;
strOrNum = unionWithRestParameter3('hello'); // error no call signature
strOrNum = unionWithRestParameter3('hello');
strOrNum = unionWithRestParameter3('hello', 10); // error no call signature
strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature

32
tests/baselines/reference/unionTypeCallSignatures2.js Normal file
View File

@@ -0,0 +1,32 @@
//// [unionTypeCallSignatures2.ts]
interface A {
(x: number): number;
(x: string, y?: string): boolean;
(x: Date): void;
<T>(x: T[]): T[];
}
interface B {
(x: number): number;
(x: string): string;
(x: Date): void;
<T>(x: T[]): T[];
}
interface C {
(x: string, ...y: string[]): number;
(x: number, s?: string): number;
<T>(x: T[]): T[];
}
var f: A | B | C;
var n = f(42); // number
var s = f("abc"); // boolean | string | number
var a = f([true, false]); // boolean[]
//// [unionTypeCallSignatures2.js]
var f;
var n = f(42); // number
var s = f("abc"); // boolean | string | number
var a = f([true, false]); // boolean[]

78
tests/baselines/reference/unionTypeCallSignatures2.symbols Normal file
View File

@@ -0,0 +1,78 @@
=== tests/cases/conformance/types/union/unionTypeCallSignatures2.ts ===
interface A {
>A : Symbol(A, Decl(unionTypeCallSignatures2.ts, 0, 0))
(x: number): number;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 1, 5))
(x: string, y?: string): boolean;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 2, 5))
>y : Symbol(y, Decl(unionTypeCallSignatures2.ts, 2, 15))
(x: Date): void;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 3, 5))
>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
<T>(x: T[]): T[];
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5))
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 4, 8))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5))
}
interface B {
>B : Symbol(B, Decl(unionTypeCallSignatures2.ts, 5, 1))
(x: number): number;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 8, 5))
(x: string): string;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 9, 5))
(x: Date): void;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 10, 5))
>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
<T>(x: T[]): T[];
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5))
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 11, 8))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5))
}
interface C {
>C : Symbol(C, Decl(unionTypeCallSignatures2.ts, 12, 1))
(x: string, ...y: string[]): number;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 15, 5))
>y : Symbol(y, Decl(unionTypeCallSignatures2.ts, 15, 15))
(x: number, s?: string): number;
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 16, 5))
>s : Symbol(s, Decl(unionTypeCallSignatures2.ts, 16, 15))
<T>(x: T[]): T[];
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 17, 5))
>x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 17, 8))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 17, 5))
>T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 17, 5))
}
var f: A | B | C;
>f : Symbol(f, Decl(unionTypeCallSignatures2.ts, 20, 3))
>A : Symbol(A, Decl(unionTypeCallSignatures2.ts, 0, 0))
>B : Symbol(B, Decl(unionTypeCallSignatures2.ts, 5, 1))
>C : Symbol(C, Decl(unionTypeCallSignatures2.ts, 12, 1))
var n = f(42); // number
>n : Symbol(n, Decl(unionTypeCallSignatures2.ts, 21, 3))
>f : Symbol(f, Decl(unionTypeCallSignatures2.ts, 20, 3))
var s = f("abc"); // boolean | string | number
>s : Symbol(s, Decl(unionTypeCallSignatures2.ts, 22, 3))
>f : Symbol(f, Decl(unionTypeCallSignatures2.ts, 20, 3))
var a = f([true, false]); // boolean[]
>a : Symbol(a, Decl(unionTypeCallSignatures2.ts, 23, 3))
>f : Symbol(f, Decl(unionTypeCallSignatures2.ts, 20, 3))

86
tests/baselines/reference/unionTypeCallSignatures2.types Normal file
View File

@@ -0,0 +1,86 @@
=== tests/cases/conformance/types/union/unionTypeCallSignatures2.ts ===
interface A {
>A : A
(x: number): number;
>x : number
(x: string, y?: string): boolean;
>x : string
>y : string
(x: Date): void;
>x : Date
>Date : Date
<T>(x: T[]): T[];
>T : T
>x : T[]
>T : T
>T : T
}
interface B {
>B : B
(x: number): number;
>x : number
(x: string): string;
>x : string
(x: Date): void;
>x : Date
>Date : Date
<T>(x: T[]): T[];
>T : T
>x : T[]
>T : T
>T : T
}
interface C {
>C : C
(x: string, ...y: string[]): number;
>x : string
>y : string[]
(x: number, s?: string): number;
>x : number
>s : string
<T>(x: T[]): T[];
>T : T
>x : T[]
>T : T
>T : T
}
var f: A | B | C;
>f : A | B | C
>A : A
>B : B
>C : C
var n = f(42); // number
>n : number
>f(42) : number
>f : A | B | C
>42 : number
var s = f("abc"); // boolean | string | number
>s : boolean | string | number
>f("abc") : boolean | string | number
>f : A | B | C
>"abc" : string
var a = f([true, false]); // boolean[]
>a : boolean[]
>f([true, false]) : boolean[]
>f : A | B | C
>[true, false] : boolean[]
>true : boolean
>false : boolean

36
tests/baselines/reference/unionTypeConstructSignatures.errors.txt
View File

@@ -16,10 +16,9 @@ tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(40,12): erro
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(41,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(42,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(43,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(46,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(47,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(48,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(49,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(47,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(48,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(49,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(55,49): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(56,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(59,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
@@ -27,14 +26,13 @@ tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(60,12): erro
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(61,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(62,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(63,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(66,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(67,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(68,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(69,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(70,12): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(67,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(68,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(69,12): error TS2346: Supplied parameters do not match any signature of call target.
tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(70,12): error TS2346: Supplied parameters do not match any signature of call target.
==== tests/cases/conformance/types/union/unionTypeConstructSignatures.ts (34 errors) ====
==== tests/cases/conformance/types/union/unionTypeConstructSignatures.ts (32 errors) ====
var numOrDate: number | Date;
var strOrBoolean: string | boolean;
var strOrNum: string | number;
@@ -117,17 +115,15 @@ tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(70,12): erro
var unionWithOptionalParameter3: { new (a: string, b?: number): string; } | { new (a: string): number; };
strOrNum = new unionWithOptionalParameter3('hello'); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
strOrNum = new unionWithOptionalParameter3('hello', 10); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = new unionWithOptionalParameter3('hello', "hello"); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = new unionWithOptionalParameter3(); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
var unionWithRestParameter1: { new (a: string, ...b: number[]): string; } | { new (a: string, ...b: number[]): number };
strOrNum = new unionWithRestParameter1('hello');
@@ -159,17 +155,15 @@ tests/cases/conformance/types/union/unionTypeConstructSignatures.ts(70,12): erro
var unionWithRestParameter3: { new (a: string, ...b: number[]): string; } | { new (a: string): number };
strOrNum = new unionWithRestParameter3('hello'); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
strOrNum = new unionWithRestParameter3('hello', 10); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = new unionWithRestParameter3('hello', 10, 11); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = new unionWithRestParameter3('hello', "hello"); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.
strOrNum = new unionWithRestParameter3(); // error no call signature
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
!!! error TS2346: Supplied parameters do not match any signature of call target.