Apply contextual type to empty array literals

Author: RyanCavanaugh

src/compiler/checker.ts

@@ -16933,7 +16933,10 @@ namespace ts {
                 case SyntaxKind.ObjectLiteralExpression:
                     return some((node as ObjectLiteralExpression).properties, isContextSensitive);
                 case SyntaxKind.ArrayLiteralExpression:
-                    return some((node as ArrayLiteralExpression).elements, isContextSensitive);
+                    if ((node as ArrayLiteralExpression).elements.length > 0) {
+                        return some((node as ArrayLiteralExpression).elements, isContextSensitive);
+                    }
+                    return true;
                 case SyntaxKind.ConditionalExpression:
                     return isContextSensitive((node as ConditionalExpression).whenTrue) ||
                         isContextSensitive((node as ConditionalExpression).whenFalse);
@@ -26996,6 +26999,12 @@ namespace ts {
             const elementTypes: Type[] = [];
             const elementFlags: ElementFlags[] = [];
             const contextualType = getApparentTypeOfContextualType(node);
+            if (elementCount === 0 && contextualType && !checkMode) {
+                const elementType = getElementTypeOfArrayType(contextualType);
+                if (elementType) {
+                    return createArrayType(elementType);
+                }
+            }
             const inDestructuringPattern = isAssignmentTarget(node);
             const inConstContext = isConstContext(node);
             let hasOmittedExpression = false;

tests/baselines/reference/arrayAssignmentTest1.types

@@ -81,35 +81,35 @@ var f1 = function () { return new C1();}
 
 var arr_any: any[] = [];
 >arr_any : any[]
->[] : undefined[]
+>[] : any[]
 
 var arr_i1: I1[] = [];
 >arr_i1 : I1[]
->[] : undefined[]
+>[] : I1[]
 
 var arr_c1: C1[] = [];
 >arr_c1 : C1[]
->[] : undefined[]
+>[] : C1[]
 
 var arr_c2: C2[] = [];
 >arr_c2 : C2[]
->[] : undefined[]
+>[] : C2[]
 
 var arr_i1_2: I1[] = [];
 >arr_i1_2 : I1[]
->[] : undefined[]
+>[] : I1[]
 
 var arr_c1_2: C1[] = [];
 >arr_c1_2 : C1[]
->[] : undefined[]
+>[] : C1[]
 
 var arr_c2_2: C2[] = [];
 >arr_c2_2 : C2[]
->[] : undefined[]
+>[] : C2[]
 
 var arr_c3: C3[] = [];
 >arr_c3 : C3[]
->[] : undefined[]
+>[] : C3[]
 
 var i1_error: I1 = []; // should be an error - is
 >i1_error : I1

tests/baselines/reference/arrayAssignmentTest2.types

@@ -81,35 +81,35 @@ var f1 = function () { return new C1();}
 
 var arr_any: any[] = [];
 >arr_any : any[]
->[] : undefined[]
+>[] : any[]
 
 var arr_i1: I1[] = [];
 >arr_i1 : I1[]
->[] : undefined[]
+>[] : I1[]
 
 var arr_c1: C1[] = [];
 >arr_c1 : C1[]
->[] : undefined[]
+>[] : C1[]
 
 var arr_c2: C2[] = [];
 >arr_c2 : C2[]
->[] : undefined[]
+>[] : C2[]
 
 var arr_i1_2: I1[] = [];
 >arr_i1_2 : I1[]
->[] : undefined[]
+>[] : I1[]
 
 var arr_c1_2: C1[] = [];
 >arr_c1_2 : C1[]
->[] : undefined[]
+>[] : C1[]
 
 var arr_c2_2: C2[] = [];
 >arr_c2_2 : C2[]
->[] : undefined[]
+>[] : C2[]
 
 var arr_c3: C3[] = [];
 >arr_c3 : C3[]
->[] : undefined[]
+>[] : C3[]
 
 // "clean up error" occurs at this point
 arr_c3 = arr_c2_2; // should be an error - is

tests/baselines/reference/arrayAssignmentTest4.types

@@ -32,7 +32,7 @@ var o1 = {one : 1};
 
 var arr_any: any[] = [];
 >arr_any : any[]
->[] : undefined[]
+>[] : any[]
 
 arr_any = function () { return null;} // should be an error - is
 >arr_any = function () { return null;} : () => any

tests/baselines/reference/arrayConcat2.types

@@ -1,7 +1,7 @@
 === tests/cases/compiler/arrayConcat2.ts ===
 var a: string[] = [];
 >a : string[]
->[] : undefined[]
+>[] : string[]
 
 a.concat("hello", 'world');
 >a.concat("hello", 'world') : string[]

tests/baselines/reference/arrayFlatMap.types

@@ -1,25 +1,25 @@
 === tests/cases/compiler/arrayFlatMap.ts ===
 const array: number[] = [];
 >array : number[]
->[] : undefined[]
+>[] : number[]
 
 const readonlyArray: ReadonlyArray<number> = [];
 >readonlyArray : readonly number[]
->[] : undefined[]
+>[] : number[]
 
 array.flatMap((): ReadonlyArray<number> => []); // ok
 >array.flatMap((): ReadonlyArray<number> => []) : number[]
 >array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >array : number[]
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
->[] : undefined[]
+>[] : number[]
 
 readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
 >readonlyArray.flatMap((): ReadonlyArray<number> => []) : number[]
 >readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >readonlyArray : readonly number[]
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
->[] : undefined[]
+>[] : number[]
 

tests/baselines/reference/arrayFrom.types

@@ -14,11 +14,11 @@ interface B {
 
 const inputA: A[] = [];
 >inputA : A[]
->[] : undefined[]
+>[] : A[]
 
 const inputB: B[] = [];
 >inputB : B[]
->[] : undefined[]
+>[] : B[]
 
 const inputALike: ArrayLike<A> = { length: 0 };
 >inputALike : ArrayLike<A>

tests/baselines/reference/arrayLiteral.types

@@ -29,7 +29,7 @@ var y = new Array<number>();
 
 var x2: number[] = [];
 >x2 : number[]
->[] : undefined[]
+>[] : number[]
 
 var x2: number[] = new Array(1);
 >x2 : number[]

tests/baselines/reference/arrayLiteralInNonVarArgParameter.types

@@ -7,7 +7,7 @@ function panic(val: string[], ...opt: string[]) { }
 panic([], 'one', 'two');
 >panic([], 'one', 'two') : void
 >panic : (val: string[], ...opt: string[]) => void
->[] : undefined[]
+>[] : string[]
 >'one' : "one"
 >'two' : "two"
 

tests/baselines/reference/badArraySyntax.types

@@ -9,7 +9,7 @@ class Z {
 
 var a1: Z[] = [];
 >a1 : Z[]
->[] : undefined[]
+>[] : Z[]
 
 var a2 = new Z[];
 >a2 : any