WIP

Author: RyanCavanaugh

src/compiler/checker.ts

@@ -18675,7 +18675,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             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);
@@ -29121,6 +29124,27 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         if (forceTuple || inConstContext || contextualType && someType(contextualType, isTupleLikeType)) {
             return createArrayLiteralType(createTupleType(elementTypes, elementFlags, /*readonly*/ inConstContext));
         }
+        if (elementCount === 0 && contextualType && !checkMode) {
+            // For an empty array literal, produce the type (T1 & T2 & T3...)[] where Tn is the element type
+            // of each array-like union constituent of the contextual type
+            const contextualElementTypes: Type[] = [];
+            forEachType(contextualType, type => {
+                if (isArrayLikeType(type)) {
+                    // Note that if we're here, it's not a tuple contextual type, so the
+                    // numeric index signature must be present and sufficient
+                    const elementType = getIndexTypeOfType(type, numberType);
+                    if (elementType) {
+                        contextualElementTypes.push(elementType);
+                    }
+                }
+            });
+            // It's possible that zero contextual types are arraylike
+            if (contextualElementTypes.length > 1) {
+                return createArrayType(getIntersectionType(contextualElementTypes));
+            } else if (contextualElementTypes.length === 1) {
+                return createArrayType(contextualElementTypes);
+            }
+        }
         return createArrayLiteralType(createArrayType(elementTypes.length ?
             getUnionType(sameMap(elementTypes, (t, i) => elementFlags[i] & ElementFlags.Variadic ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t), UnionReduction.Subtype) :
             strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));

tests/baselines/reference/APISample_jsdoc.errors.txt

@@ -0,0 +1,127 @@
+tests/cases/compiler/APISample_jsdoc.ts(102,11): error TS2719: Type '(import("typescript").JSDocTag | undefined)[]' is not assignable to type '(import("typescript").JSDocTag | undefined)[]'. Two different types with this name exist, but they are unrelated.
+  Type 'import("typescript").JSDocTag | undefined' is not assignable to type 'import("typescript").JSDocTag | undefined'. Two different types with this name exist, but they are unrelated.
+
+
+==== tests/cases/compiler/node_modules/typescript/package.json (0 errors) ====
+    {
+        "name": "typescript",
+        "types": "/.ts/typescript.d.ts"
+    }
+    
+==== tests/cases/compiler/APISample_jsdoc.ts (1 errors) ====
+    /*
+     * Note: This test is a public API sample. The original sources can be found
+     *       at: https://github.com/YousefED/typescript-json-schema
+     *           https://github.com/vega/ts-json-schema-generator
+     *       Please log a "breaking change" issue for any API breaking change affecting this issue
+     */
+    
+    declare var console: any;
+    
+    import * as ts from "typescript";
+    
+    // excerpted from https://github.com/YousefED/typescript-json-schema
+    // (converted from a method and modified; for example, `this: any` to compensate, among other changes)
+    function parseCommentsIntoDefinition(this: any,
+                                         symbol: ts.Symbol,
+                                         definition: {description?: string, [s: string]: string | undefined},
+                                         otherAnnotations: { [s: string]: true}): void {
+        if (!symbol) {
+            return;
+        }
+    
+        // the comments for a symbol
+        let comments = symbol.getDocumentationComment(undefined);
+    
+        if (comments.length) {
+            definition.description = comments.map(comment => comment.kind === "lineBreak" ? comment.text : comment.text.trim().replace(/\r\n/g, "\n")).join("");
+        }
+    
+        // jsdocs are separate from comments
+        const jsdocs = symbol.getJsDocTags(this.checker);
+        jsdocs.forEach(doc => {
+            // if we have @TJS-... annotations, we have to parse them
+            const { name, text } = doc;
+            if (this.userValidationKeywords[name]) {
+                definition[name] = this.parseValue(text);
+            } else {
+                // special annotations
+                otherAnnotations[doc.name] = true;
+            }
+        });
+    }
+    
+    
+    // excerpted from https://github.com/vega/ts-json-schema-generator
+    export interface Annotations {
+        [name: string]: any;
+    }
+    function getAnnotations(this: any, node: ts.Node): Annotations | undefined {
+        const symbol: ts.Symbol = (node as any).symbol;
+        if (!symbol) {
+            return undefined;
+        }
+    
+        const jsDocTags: ts.JSDocTagInfo[] = symbol.getJsDocTags(this.checker);
+        if (!jsDocTags || !jsDocTags.length) {
+            return undefined;
+        }
+    
+        const annotations: Annotations = jsDocTags.reduce((result: Annotations, jsDocTag: ts.JSDocTagInfo) => {
+            const value = this.parseJsDocTag(jsDocTag);
+            if (value !== undefined) {
+                result[jsDocTag.name] = value;
+            }
+    
+            return result;
+        }, {});
+        return Object.keys(annotations).length ? annotations : undefined;
+    }
+    
+    // these examples are artificial and mostly nonsensical
+    function parseSpecificTags(node: ts.Node) {
+        if (node.kind === ts.SyntaxKind.Parameter) {
+            return ts.getJSDocParameterTags(node as ts.ParameterDeclaration);
+        }
+        if (node.kind === ts.SyntaxKind.FunctionDeclaration) {
+            const func = node as ts.FunctionDeclaration;
+            if (ts.hasJSDocParameterTags(func)) {
+                const flat: ts.JSDocTag[] = [];
+                for (const tags of func.parameters.map(ts.getJSDocParameterTags)) {
+                    if (tags) flat.push(...tags);
+                }
+                return flat;
+            }
+        }
+    }
+    
+    function getReturnTypeFromJSDoc(node: ts.Node) {
+        if (node.kind === ts.SyntaxKind.FunctionDeclaration) {
+            return ts.getJSDocReturnType(node);
+        }
+        let type = ts.getJSDocType(node);
+        if (type && type.kind === ts.SyntaxKind.FunctionType) {
+            return (type as ts.FunctionTypeNode).type;
+        }
+    }
+    
+    function getAllTags(node: ts.Node) {
+        ts.getJSDocTags(node);
+    }
+    
+    function getSomeOtherTags(node: ts.Node) {
+        const tags: (ts.JSDocTag | undefined)[] = [];
+              ~~~~
+!!! error TS2719: Type '(import("typescript").JSDocTag | undefined)[]' is not assignable to type '(import("typescript").JSDocTag | undefined)[]'. Two different types with this name exist, but they are unrelated.
+!!! error TS2719:   Type 'import("typescript").JSDocTag | undefined' is not assignable to type 'import("typescript").JSDocTag | undefined'. Two different types with this name exist, but they are unrelated.
+        tags.push(ts.getJSDocAugmentsTag(node));
+        tags.push(ts.getJSDocClassTag(node));
+        tags.push(ts.getJSDocReturnTag(node));
+        const type = ts.getJSDocTypeTag(node);
+        if (type) {
+            tags.push(type);
+        }
+        tags.push(ts.getJSDocTemplateTag(node));
+        return tags;
+    }
+    

tests/baselines/reference/accessorsOverrideProperty9.types

@@ -20,7 +20,7 @@ class ApiItem {
 >members : readonly ApiItem[]
 
     return [];
->[] : never[]
+>[] : ApiItem[]
   }
 }
 
@@ -63,7 +63,7 @@ function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(
 >members : readonly ApiItem[]
 
       return [];
->[] : never[]
+>[] : ApiItem[]
     }
   }
 
@@ -83,7 +83,7 @@ export class ApiEnum extends ApiItemContainerMixin(ApiItem) {
 >members : readonly ApiEnumMember[]
 
     return [];
->[] : never[]
+>[] : ApiEnumMember[]
   }
 }
 

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/arrayContextualTyping.errors.txt

@@ -0,0 +1,48 @@
+tests/cases/compiler/arrayContextualTyping.ts(9,9): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+  Type 'string' is not assignable to type 'number'.
+tests/cases/compiler/arrayContextualTyping.ts(14,11): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
+  Type 'number' is not assignable to type 'string'.
+
+
+==== tests/cases/compiler/arrayContextualTyping.ts (2 errors) ====
+    // Setup
+    declare class MyCustomArray extends Array<number> {
+        isCustom: true;
+    }
+    
+    // MVP: An empty array contextually typed by an array type gets that array's type
+    const m1 = [] satisfies number[];
+    m1.push(0); // Should be OK
+    m1.push(""); // Should error
+            ~~
+!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
+    
+    // Works in object fields?
+    const m2 = { a: [] satisfies string[] };
+    m2.a.push(""); // Should be OK
+    m2.a.push(0); // Should error
+              ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'.
+!!! error TS2345:   Type 'number' is not assignable to type 'string'.
+    
+    // If the contextual type is a union, keep the array-supertyping parts of the union
+    const m3 = [] satisfies number[] | ArrayLike<string>;
+    const m3t: number[] | string[] = m3;
+    
+    // Keep only the array parts
+    const m4 = [] satisfies MyCustomArray | string[];
+    const m4t: string[] = m4;
+    
+    // Should OK
+    const m5: string[] | number[] = [] satisfies string[] | number[];
+    // Should OK
+    type Obj = { a: string[] } | { a: number[] };
+    const m6: Obj = { a: [] } satisfies Obj;
+    
+    // Should all OK
+    type DiscrObj = { a: string[], kind: "strings" } | { a: number[], kind: "numbers" };
+    const m7: DiscrObj = { a: [], kind: "numbers"};
+    const m8: DiscrObj = { a: [], kind: "numbers"} satisfies DiscrObj;
+    const m9: DiscrObj = { a: [], kind: "strings"} satisfies DiscrObj;
+