[experiment] Check for extended empty tuples in isTupleLikeType

src/compiler/checker.ts

@@ -1949,6 +1949,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     const emptyGenericType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray) as ObjectType as GenericType;
     emptyGenericType.instantiations = new Map<string, TypeReference>();
 
+    const emptyReadonlyTupleType = createTupleType(emptyArray, emptyArray, /*readonly*/ true);
+
     const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, emptyArray);
     // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated
     // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.
@@ -22902,7 +22904,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function isTupleLikeType(type: Type): boolean {
-        return isTupleType(type) || !!getPropertyOfType(type, "0" as __String);
+        return isTupleType(type) || !!getPropertyOfType(type, "0" as __String) || isTypeAssignableTo(type, emptyReadonlyTupleType);
     }
 
     function isArrayOrTupleLikeType(type: Type): boolean {

tests/baselines/reference/anyInferenceAnonymousFunctions.types

@@ -19,7 +19,7 @@ paired.reduce(function (a1, a2) {
 >{} : {}
 
 } , []);
->[] : undefined[]
+>[] : []
 
 paired.reduce((b1, b2) => {
 >paired.reduce((b1, b2) => {    return b1.concat({});} , []) : any
@@ -38,7 +38,7 @@ paired.reduce((b1, b2) => {
 >{} : {}
 
 } , []);
->[] : undefined[]
+>[] : []
 
 paired.reduce((b3, b4) => b3.concat({}), []);
 >paired.reduce((b3, b4) => b3.concat({}), []) : any
@@ -53,7 +53,7 @@ paired.reduce((b3, b4) => b3.concat({}), []);
 >b3 : any
 >concat : any
 >{} : {}
->[] : undefined[]
+>[] : []
 
 paired.map((c1) => c1.count);
 >paired.map((c1) => c1.count) : any[]

tests/baselines/reference/assignmentCompatability46.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/assignmentCompatability46.ts(3,4): error TS2345: Argument of type 'number[]' is not assignable to parameter of type 'never'.
+tests/cases/compiler/assignmentCompatability46.ts(3,4): error TS2345: Argument of type '[number, number, number]' is not assignable to parameter of type 'never'.
 tests/cases/compiler/assignmentCompatability46.ts(4,4): error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type 'never'.
 
 
@@ -7,7 +7,7 @@ tests/cases/compiler/assignmentCompatability46.ts(4,4): error TS2345: Argument o
 
     fn([1, 2, 3])
        ~~~~~~~~~
-!!! error TS2345: Argument of type 'number[]' is not assignable to parameter of type 'never'.
+!!! error TS2345: Argument of type '[number, number, number]' is not assignable to parameter of type 'never'.
     fn({ a: 1, b: 2 })
        ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ a: number; b: number; }' is not assignable to parameter of type 'never'.

tests/baselines/reference/assignmentCompatability46.types

@@ -6,7 +6,7 @@ declare function fn(x: never): void;
 fn([1, 2, 3])
 >fn([1, 2, 3]) : void
 >fn : (x: never) => void
->[1, 2, 3] : number[]
+>[1, 2, 3] : [number, number, number]
 >1 : 1
 >2 : 2
 >3 : 3

tests/baselines/reference/assignmentNestedInLiterals.types

@@ -5,9 +5,9 @@ var target, x, y;
 >y : any
 
 target = [x = 1, y = x];
->target = [x = 1, y = x] : number[]
+>target = [x = 1, y = x] : [number, number]
 >target : any
->[x = 1, y = x] : number[]
+>[x = 1, y = x] : [number, number]
 >x = 1 : 1
 >x : any
 >1 : 1

tests/baselines/reference/bigintWithoutLib.types

@@ -125,7 +125,7 @@ bigIntArray = new BigInt64Array([1n, 2n, 3n]);
 >bigIntArray : BigInt64Array
 >new BigInt64Array([1n, 2n, 3n]) : any
 >BigInt64Array : any
->[1n, 2n, 3n] : bigint[]
+>[1n, 2n, 3n] : [bigint, bigint, bigint]
 >1n : 1n
 >2n : 2n
 >3n : 3n
@@ -135,7 +135,7 @@ bigIntArray = new BigInt64Array([1, 2, 3]);
 >bigIntArray : BigInt64Array
 >new BigInt64Array([1, 2, 3]) : any
 >BigInt64Array : any
->[1, 2, 3] : number[]
+>[1, 2, 3] : [number, number, number]
 >1 : 1
 >2 : 2
 >3 : 3
@@ -205,7 +205,7 @@ bigUintArray = new BigUint64Array([1n, 2n, 3n]);
 >bigUintArray : BigUint64Array
 >new BigUint64Array([1n, 2n, 3n]) : any
 >BigUint64Array : any
->[1n, 2n, 3n] : bigint[]
+>[1n, 2n, 3n] : [bigint, bigint, bigint]
 >1n : 1n
 >2n : 2n
 >3n : 3n
@@ -215,7 +215,7 @@ bigUintArray = new BigUint64Array([1, 2, 3]);
 >bigUintArray : BigUint64Array
 >new BigUint64Array([1, 2, 3]) : any
 >BigUint64Array : any
->[1, 2, 3] : number[]
+>[1, 2, 3] : [number, number, number]
 >1 : 1
 >2 : 2
 >3 : 3

tests/baselines/reference/castExpressionParentheses.types

@@ -14,7 +14,7 @@ declare var a;
 (<any>[1,3,]); 
 >(<any>[1,3,]) : any
 ><any>[1,3,] : any
->[1,3,] : number[]
+>[1,3,] : [number, number]
 >1 : 1
 >3 : 3
 

tests/baselines/reference/conditionalTypes1.types

@@ -410,8 +410,8 @@ function zeroOf<T extends number | string | boolean>(value: T) {
 
     return <ZeroOf<T>>(typeof value === "number" ? 0 : typeof value === "string" ? "" : false);
 ><ZeroOf<T>>(typeof value === "number" ? 0 : typeof value === "string" ? "" : false) : ZeroOf<T>
->(typeof value === "number" ? 0 : typeof value === "string" ? "" : false) : false | "" | 0
->typeof value === "number" ? 0 : typeof value === "string" ? "" : false : false | "" | 0
+>(typeof value === "number" ? 0 : typeof value === "string" ? "" : false) : false | 0 | ""
+>typeof value === "number" ? 0 : typeof value === "string" ? "" : false : false | 0 | ""
 >typeof value === "number" : boolean
 >typeof value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >value : T
@@ -476,11 +476,11 @@ function f21<T extends number | string>(x: T, y: ZeroOf<T>) {
 
     let z1: number | string = y;
 >z1 : string | number
->y : "" | 0
+>y : 0 | ""
 
     let z2: 0 | "" = y;
->z2 : "" | 0
->y : "" | 0
+>z2 : 0 | ""
+>y : 0 | ""
 
     x = y;  // Error
 >x = y : ZeroOf<T>

tests/baselines/reference/constructorOverloads2.types

@@ -63,7 +63,7 @@ var f4 = new Foo([f1,f2,f3]);
 >f4 : Foo
 >new Foo([f1,f2,f3]) : Foo
 >Foo : typeof Foo
->[f1,f2,f3] : Foo[]
+>[f1,f2,f3] : [Foo, Foo, Foo]
 >f1 : Foo
 >f2 : Foo
 >f3 : Foo

tests/baselines/reference/constructorOverloads3.types

@@ -56,7 +56,7 @@ var f4 = new Foo([f1,f2,f3]);
 >f4 : Foo
 >new Foo([f1,f2,f3]) : Foo
 >Foo : typeof Foo
->[f1,f2,f3] : Foo[]
+>[f1,f2,f3] : [Foo, Foo, Foo]
 >f1 : Foo
 >f2 : Foo
 >f3 : Foo

tests/baselines/reference/constructorOverloads6.types

@@ -56,7 +56,7 @@ var f4 = new Foo([f1,f2,f3]);
 >f4 : Foo
 >new Foo([f1,f2,f3]) : Foo
 >Foo : typeof Foo
->[f1,f2,f3] : Foo[]
+>[f1,f2,f3] : [Foo, Foo, Foo]
 >f1 : Foo
 >f2 : Foo
 >f3 : Foo

tests/baselines/reference/controlFlowArrayErrors.types

@@ -32,9 +32,9 @@ function f2() {
 >x : any
 
     x = [];
->x = [] : undefined[]
+>x = [] : []
 >x : any
->[] : undefined[]
+>[] : []
 
     let y = x;   // Implicit any[] error
 >y : any[]
@@ -81,16 +81,16 @@ function f4() {
 >x : any
 
     x = [5, "hello"];  // Non-evolving array
->x = [5, "hello"] : (string | number)[]
+>x = [5, "hello"] : [number, string]
 >x : any
->[5, "hello"] : (string | number)[]
+>[5, "hello"] : [number, string]
 >5 : 5
 >"hello" : "hello"
 
     x.push(true);      // Error
 >x.push(true) : number
 >x.push : (...items: (string | number)[]) => number
->x : (string | number)[]
+>x : [number, string]
 >push : (...items: (string | number)[]) => number
 >true : true
 }
@@ -123,9 +123,9 @@ function f6() {
 >cond : () => boolean
 
         x = [];
->x = [] : undefined[]
+>x = [] : []
 >x : any
->[] : undefined[]
+>[] : []
 
         x.push(5);
 >x.push(5) : number
@@ -143,18 +143,18 @@ function f6() {
     }
     else {
         x = [true];  // Non-evolving array
->x = [true] : boolean[]
+>x = [true] : [boolean]
 >x : any
->[true] : boolean[]
+>[true] : [boolean]
 >true : true
     }
     x;           // boolean[] | (string | number)[]
->x : (string | number)[] | boolean[]
+>x : (string | number)[] | [boolean]
 
     x.push(99);  // Error
 >x.push(99) : number
 >x.push : ((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)
->x : (string | number)[] | boolean[]
+>x : (string | number)[] | [boolean]
 >push : ((...items: (string | number)[]) => number) | ((...items: boolean[]) => number)
 >99 : 99
 }

tests/baselines/reference/controlFlowArrays.types

@@ -73,9 +73,9 @@ function f3() {
 >x : any
 
     x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
     x.push(5, "hello");
 >x.push(5, "hello") : number
@@ -130,9 +130,9 @@ function f5() {
 >cond : () => boolean
 
         x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
         x.push(5);
 >x.push(5) : number
@@ -143,9 +143,9 @@ function f5() {
     }
     else {
         x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
         x.push("hello");
 >x.push("hello") : number
@@ -175,9 +175,9 @@ function f6() {
     }
     else {
         x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
         x.push("hello");
 >x.push("hello") : number
@@ -202,9 +202,9 @@ function f7() {
 >cond : () => boolean
 
         x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
         while (cond()) {
 >cond() : boolean
@@ -387,9 +387,9 @@ function f12() {
 >x : any
 
     x = [];
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 
     if (x.length === 0) {  // x.length ok on implicit any[]
 >x.length === 0 : boolean
@@ -513,9 +513,9 @@ function f16() {
 >(x = [], x).push : (...items: any[]) => number
 >(x = [], x) : any[]
 >x = [], x : any[]
->x = [] : never[]
+>x = [] : []
 >x : any
->[] : never[]
+>[] : []
 >x : any[]
 >push : (...items: any[]) => number
 >5 : 5

tests/baselines/reference/declarationEmitDestructuringArrayPattern2.js

@@ -25,7 +25,7 @@ declare var x11: number, y11: string;
 declare var a11: undefined, b11: undefined, c11: undefined;
 declare var a2: number, b2: string, x12: number, c2: boolean;
 declare var x13: number, y13: string;
-declare var a3: (string | number)[], b3: {
+declare var a3: [number, string], b3: {
     x: number;
     y: string;
 };

tests/baselines/reference/declarationEmitDestructuringArrayPattern2.types

@@ -56,10 +56,10 @@ var [x13, y13] = [1, "hello"];
 >"hello" : "hello"
 
 var [a3, b3] = [[x13, y13], { x: x13, y: y13 }];
->a3 : (string | number)[]
+>a3 : [number, string]
 >b3 : { x: number; y: string; }
->[[x13, y13], { x: x13, y: y13 }] : [(string | number)[], { x: number; y: string; }]
->[x13, y13] : (string | number)[]
+>[[x13, y13], { x: x13, y: y13 }] : [[number, string], { x: number; y: string; }]
+>[x13, y13] : [number, string]
 >x13 : number
 >y13 : string
 >{ x: x13, y: y13 } : { x: number; y: string; }

tests/baselines/reference/declarationsAndAssignments.types

@@ -403,10 +403,10 @@ function f13() {
 >"hello" : "hello"
 
     var [a, b] = [[x, y], { x: x, y: y }];
->a : (string | number)[]
+>a : [number, string]
 >b : { x: number; y: string; }
->[[x, y], { x: x, y: y }] : [(string | number)[], { x: number; y: string; }]
->[x, y] : (string | number)[]
+>[[x, y], { x: x, y: y }] : [[number, string], { x: number; y: string; }]
+>[x, y] : [number, string]
 >x : number
 >y : string
 >{ x: x, y: y } : { x: number; y: string; }