Extend isEmptyAnonymousObjectType with support for non-generic mapped types

Author: Andarist

src/compiler/checker.ts

@@ -20849,6 +20849,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function isEmptyAnonymousObjectType(type: Type) {
+        if (getObjectFlags(type) & ObjectFlags.Mapped && !isGenericMappedType(type)) {
+            return isEmptyResolvedType(resolveStructuredTypeMembers(type as ObjectType));
+        }
         return !!(getObjectFlags(type) & ObjectFlags.Anonymous && (
             (type as ResolvedType).members && isEmptyResolvedType(type as ResolvedType) ||
             type.symbol && type.symbol.flags & SymbolFlags.TypeLiteral && getMembersOfSymbol(type.symbol).size === 0

tests/baselines/reference/declarationEmitPrivatePromiseLikeInterface.errors.txt

@@ -0,0 +1,52 @@
+//// [tests/cases/compiler/emptyObjectMappedTypeWithNeverKey.ts] ////
+
+=== emptyObjectMappedTypeWithNeverKey.ts ===
+declare const u: unknown;
+>u : Symbol(u, Decl(emptyObjectMappedTypeWithNeverKey.ts, 0, 13))
+
+type A = { [K in never]: any };
+>A : Symbol(A, Decl(emptyObjectMappedTypeWithNeverKey.ts, 0, 25))
+>K : Symbol(K, Decl(emptyObjectMappedTypeWithNeverKey.ts, 2, 12))
+
+const a: null | undefined | A = u;
+>a : Symbol(a, Decl(emptyObjectMappedTypeWithNeverKey.ts, 3, 5))
+>A : Symbol(A, Decl(emptyObjectMappedTypeWithNeverKey.ts, 0, 25))
+>u : Symbol(u, Decl(emptyObjectMappedTypeWithNeverKey.ts, 0, 13))
+
+type Point = { x: number; y: number };
+>Point : Symbol(Point, Decl(emptyObjectMappedTypeWithNeverKey.ts, 3, 34))
+>x : Symbol(x, Decl(emptyObjectMappedTypeWithNeverKey.ts, 5, 14))
+>y : Symbol(y, Decl(emptyObjectMappedTypeWithNeverKey.ts, 5, 25))
+
+declare function foo<T, K extends keyof T>(
+>foo : Symbol(foo, Decl(emptyObjectMappedTypeWithNeverKey.ts, 5, 38))
+>T : Symbol(T, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 21))
+>K : Symbol(K, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 23))
+>T : Symbol(T, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 21))
+
+  obj: T,
+>obj : Symbol(obj, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 43))
+>T : Symbol(T, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 21))
+
+  keys: K[],
+>keys : Symbol(keys, Decl(emptyObjectMappedTypeWithNeverKey.ts, 7, 9))
+>K : Symbol(K, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 23))
+
+  rest: Omit<T, K> | null | undefined,
+>rest : Symbol(rest, Decl(emptyObjectMappedTypeWithNeverKey.ts, 8, 12))
+>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 21))
+>K : Symbol(K, Decl(emptyObjectMappedTypeWithNeverKey.ts, 6, 23))
+
+): void;
+const p: Point = { x: 0, y: 0 };
+>p : Symbol(p, Decl(emptyObjectMappedTypeWithNeverKey.ts, 11, 5))
+>Point : Symbol(Point, Decl(emptyObjectMappedTypeWithNeverKey.ts, 3, 34))
+>x : Symbol(x, Decl(emptyObjectMappedTypeWithNeverKey.ts, 11, 18))
+>y : Symbol(y, Decl(emptyObjectMappedTypeWithNeverKey.ts, 11, 24))
+
+foo(p, ["x", "y"], u);
+>foo : Symbol(foo, Decl(emptyObjectMappedTypeWithNeverKey.ts, 5, 38))
+>p : Symbol(p, Decl(emptyObjectMappedTypeWithNeverKey.ts, 11, 5))
+>u : Symbol(u, Decl(emptyObjectMappedTypeWithNeverKey.ts, 0, 13))
+

tests/baselines/reference/declarationEmitPrivatePromiseLikeInterface.js

@@ -0,0 +1,48 @@
+//// [tests/cases/compiler/emptyObjectMappedTypeWithNeverKey.ts] ////
+
+=== emptyObjectMappedTypeWithNeverKey.ts ===
+declare const u: unknown;
+>u : unknown
+
+type A = { [K in never]: any };
+>A : {}
+
+const a: null | undefined | A = u;
+>a : A | null | undefined
+>u : unknown
+
+type Point = { x: number; y: number };
+>Point : { x: number; y: number; }
+>x : number
+>y : number
+
+declare function foo<T, K extends keyof T>(
+>foo : <T, K extends keyof T>(obj: T, keys: K[], rest: Omit<T, K> | null | undefined) => void
+
+  obj: T,
+>obj : T
+
+  keys: K[],
+>keys : K[]
+
+  rest: Omit<T, K> | null | undefined,
+>rest : Omit<T, K> | null | undefined
+
+): void;
+const p: Point = { x: 0, y: 0 };
+>p : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>0 : 0
+>y : number
+>0 : 0
+
+foo(p, ["x", "y"], u);
+>foo(p, ["x", "y"], u) : void
+>foo : <T, K extends keyof T>(obj: T, keys: K[], rest: Omit<T, K> | null | undefined) => void
+>p : Point
+>["x", "y"] : ("x" | "y")[]
+>"x" : "x"
+>"y" : "y"
+>u : unknown
+

tests/baselines/reference/emptyObjectMappedTypeWithNeverKey.symbols

@@ -198,7 +198,7 @@ function canPickStepContinue<T extends QuickPickStep>(
 >_step : T
 
   _state: PartialStepState,
->_state : PartialStepState<unknown>
+>_state : { counter: number; confirm?: boolean | undefined; startingStep?: number | undefined; }
 
   _selection: StepItemType<T> | Directive
 >_selection : Directive | StepItemType<T>
@@ -220,7 +220,7 @@ function createPickStep<T extends QuickPickItem>(
 }
 
 function* showStep<
->showStep : <State extends Partial<unknown> & { counter: number; confirm?: boolean | undefined; startingStep?: number | undefined; } & { repo: any; }, Context extends { repos: any[]; title: string; status: any; }>(state: State, _context: Context) => StepResultGenerator<QuickPickItem>
+>showStep : <State extends { counter: number; confirm?: boolean | undefined; startingStep?: number | undefined; } & { repo: any; }, Context extends { repos: any[]; title: string; status: any; }>(state: State, _context: Context) => StepResultGenerator<QuickPickItem>
 
   State extends PartialStepState & { repo: any },
 >repo : any
@@ -258,7 +258,7 @@ function* showStep<
   return canPickStepContinue(step, state, selection)
 >canPickStepContinue(step, state, selection)    ? selection[0]    : StepResult.Break : QuickPickItem | unique symbol
 >canPickStepContinue(step, state, selection) : boolean
->canPickStepContinue : <T extends QuickPickStep<QuickPickItem>>(_step: T, _state: PartialStepState<unknown>, _selection: Directive | StepItemType<T>) => _selection is StepItemType<T>
+>canPickStepContinue : <T extends QuickPickStep<QuickPickItem>>(_step: T, _state: { counter: number; confirm?: boolean | undefined; startingStep?: number | undefined; }, _selection: Directive | StepItemType<T>) => _selection is StepItemType<T>
 >step : QuickPickStep<QuickPickItem>
 >state : State
 >selection : Directive | QuickPickItem[]

tests/baselines/reference/emptyObjectMappedTypeWithNeverKey.types

@@ -2,7 +2,7 @@ intersectionWithIndexSignatures.ts(17,1): error TS2322: Type '{ x: A; } & { y: B
   Property 'y' is incompatible with index signature.
     Property 'a' is missing in type 'B' but required in type 'A'.
 intersectionWithIndexSignatures.ts(27,10): error TS2339: Property 'b' does not exist on type '{ a: string; }'.
-intersectionWithIndexSignatures.ts(29,7): error TS2322: Type 's' is not assignable to type '{ [key: string]: { a: string; b: string; }; }'.
+intersectionWithIndexSignatures.ts(29,7): error TS2322: Type 'Pick<{ [key: string]: { a: string; }; }, string | number>' is not assignable to type '{ [key: string]: { a: string; b: string; }; }'.
   'string' index signatures are incompatible.
     Property 'b' is missing in type '{ a: string; }' but required in type '{ a: string; b: string; }'.
 intersectionWithIndexSignatures.ts(35,1): error TS2322: Type '{ a: string; } & { b: number; }' is not assignable to type '{ [key: string]: string; }'.
@@ -48,7 +48,7 @@ intersectionWithIndexSignatures.ts(35,1): error TS2322: Type '{ a: string; } & {
 
     const d: { [key: string]: {a: string, b: string} } = q;  // Error
           ~
-!!! error TS2322: Type 's' is not assignable to type '{ [key: string]: { a: string; b: string; }; }'.
+!!! error TS2322: Type 'Pick<{ [key: string]: { a: string; }; }, string | number>' is not assignable to type '{ [key: string]: { a: string; b: string; }; }'.
 !!! error TS2322:   'string' index signatures are incompatible.
 !!! error TS2322:     Property 'b' is missing in type '{ a: string; }' but required in type '{ a: string; b: string; }'.
 !!! related TS2728 intersectionWithIndexSignatures.ts:29:39: 'b' is declared here.

tests/baselines/reference/generatorYieldContextualType.types

@@ -67,19 +67,19 @@ type constr<Source, Tgt> = { [K in keyof Source]: string } & Pick<Tgt, Exclude<k
 >constr : constr<Source, Tgt>
 
 type s = constr<{}, { [key: string]: { a: string } }>;
->s : {} & Pick<{ [key: string]: { a: string; }; }, string | number>
+>s : Pick<{ [key: string]: { a: string; }; }, string | number>
 >key : string
 >a : string
 
 declare const q: s;
->q : s
+>q : Pick<{ [key: string]: { a: string; }; }, string | number>
 
 q["asd"].a.substr(1);
 >q["asd"].a.substr(1) : string
 >q["asd"].a.substr : (from: number, length?: number | undefined) => string
 >q["asd"].a : string
 >q["asd"] : { a: string; }
->q : s
+>q : Pick<{ [key: string]: { a: string; }; }, string | number>
 >"asd" : "asd"
 >a : string
 >substr : (from: number, length?: number | undefined) => string
@@ -88,7 +88,7 @@ q["asd"].a.substr(1);
 q["asd"].b;  // Error
 >q["asd"].b : any
 >q["asd"] : { a: string; }
->q : s
+>q : Pick<{ [key: string]: { a: string; }; }, string | number>
 >"asd" : "asd"
 >b : any
 
@@ -97,7 +97,7 @@ const d: { [key: string]: {a: string, b: string} } = q;  // Error
 >key : string
 >a : string
 >b : string
->q : s
+>q : Pick<{ [key: string]: { a: string; }; }, string | number>
 
 // Repro from #32484
 

tests/baselines/reference/intersectionWithIndexSignatures.errors.txt

@@ -0,0 +1,96 @@
+intersectionsAndEmptyObjects.ts(81,6): error TS2456: Type alias 'Foo2' circularly references itself.
+
+
+==== intersectionsAndEmptyObjects.ts (1 errors) ====
+    // Empty object type literals are removed from intersections types
+    // that contain other object types
+    
+    type A = { a: number };
+    type B = { b: string };
+    type C = {};
+    
+    let x01: A & B;
+    let x02: A & C;
+    let x03: B & C;
+    let x04: A & B & C;
+    let x05: string & C;
+    let x06: C & string;
+    let x07: C;
+    let x08: C & {};
+    let x09: {} & A & {} & B & {} & C & {};
+    
+    interface D {}
+    interface E {}
+    
+    let x10: A & D;
+    let x11: C & D;
+    let x12: A & B & C & D;
+    let x13: D & E;
+    let x14: A & B & C & D & E;
+    
+    // Repro from #20225
+    
+    type Dictionary = { [name: string]: string };
+    
+    const intersectDictionaries = <F1 extends Dictionary, F2 extends Dictionary>(
+      d1: F1,
+      d2: F2,
+    ): F1 & F2 => Object.assign({}, d1, d2);
+    
+    const testDictionary = <T extends Dictionary>(_value: T) => { };
+    
+    const d1 = {};
+    testDictionary(d1);
+    const d2 = intersectDictionaries(d1, d1);
+    testDictionary(d2);
+    
+    const d3 = {
+      s: '',
+    };
+    testDictionary(d3);
+    const d4 = intersectDictionaries(d1, d3);
+    testDictionary(d4);
+    const d5 = intersectDictionaries(d3, d1);
+    testDictionary(d5);
+    const d6 = intersectDictionaries(d3, d3);
+    testDictionary(d6);
+    
+    // Repro from #27044
+    
+    type choices<IChoiceList extends {
+        [key: string]: boolean;
+    }> = IChoiceList & {
+        shoes:boolean;
+        food:boolean;
+    };
+    
+    type IMyChoiceList = {
+        car: true
+    };
+    
+    type IUnknownChoiceList = {};
+    
+    var defaultChoices: choices<{}>;
+    var defaultChoicesAndEmpty: choices<{} & {}>;
+    
+    var myChoices: choices<IMyChoiceList>;
+    var myChoicesAndEmpty: choices<IMyChoiceList & {}>;
+    
+    var unknownChoices: choices<IUnknownChoiceList>;
+    var unknownChoicesAndEmpty: choices<IUnknownChoiceList & {}>;
+    
+    // Repro from #38672
+    
+    type Foo1 = { x: string } & { [x: number]: Foo1 };
+    type Foo2 = { x: string } & { [K in number]: Foo2 };
+         ~~~~
+!!! error TS2456: Type alias 'Foo2' circularly references itself.
+    
+    // Repro from #40239
+    
+    declare function mock<M>(_: Promise<M>): {} & M;
+    mock(import('./ex'))
+    
+==== ex.d.ts (0 errors) ====
+    export {}
+    

tests/baselines/reference/intersectionWithIndexSignatures.types

@@ -216,7 +216,7 @@ type Foo1 = { x: string } & { [x: number]: Foo1 };
 >x : number
 
 type Foo2 = { x: string } & { [K in number]: Foo2 };
->Foo2 : { x: string; } & { [x: number]: Foo2; }
+>Foo2 : any
 >x : string
 
 // Repro from #40239