`silentNeverType` leak in contextual parameter types coming from anonymous non-aliased object type instantiations

[Andarist]

🔎 Search Terms

silent never type return type inference alias propagating anonymous object

🕗 Version & Regression Information

• This is the behavior in every version I tried

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=6.0.0-dev.20250827#code/JYOwLgpgTgZghgYwgAgAoB4AqA+ZBvAKGWTAAsIQAuZACgHsQYBXAGxmBZYgBNqaA3OCyYRqmAJTIAvLiYgA1iDoB3EJJnI5ilSADcBAL4ECoSLEQpUAYQYBnMFCYIwdKPiLIQEZcizYaEAAeEAhMLlB8UBC2dCz8orSCwgkS0rj8dMDc6umZ2dQYOPpGBNwhLHBRyIJuqAU2IPaOzq76peWVKMwgzsAMyDB0dACMfjSBfDlo6HjIZfCsYGLIBtjiYm0IdmDIUbaLw9IDQ8M0NFOExFFgTFAgnt5oZ3ux8RceV9GvEPrExAD0-2QAD0APweAziYpQ4xgACeAAcUAB1YBkAAiEAWLDAfiOs3mcEWywMbTKCAqVW6vX6gzoACYxhNaFMMKiMViiTi-GsNsYto0dntFvSjnT6Wd3p8bncHj5UM8vnEIFK-i9lb8-oCQeDiJDoWSOlS5DT7nSAMxMyZpaYAbUwAF1echMJttrtootzWKhubJTbLh6ZfcvPLFTFlarPhH4pqAUCwRCYfrjOTKV0TWA+mahgAWK0sm0YAmc4n4ZAIqB0BEklbO13893CnG5n10XP+jSB663EOPBU0dVvAMfD0xn6j7WJvXJmHtCmdAaZ7PHOgAVgL5yLMzmpZx1HtDrr6xdbsFY8Wa7ba87uG7EGDcqeg6Vw67o6HE7+yCnupWs90IA

💻 Code

interface P<T> {
 then: (onfulfilled: (value: T) => unknown) => unknown;
}

interface PConstructor {
 new <T>(executor: (resolve: (value: T) => void) => void): P<T>;
}

declare var P: PConstructor;

declare function foo1<T>(x: () => P<{ default: T }>): T;

const result1 = foo1(() => {
 return new P((resolve) => {
 resolve;
 });
});

type WithDefault<T> = { default: T };

declare function foo2<T>(x: () => P<WithDefault<T>>): T;

const result2 = foo2(() => {
 return new P((resolve) => {
 resolve;
 });
});

declare function foo3<T>(x: () => P<[T]>): T;

const result3 = foo3(() => {
 return new P((resolve) => {
 resolve;
 });
});

declare function foo4<T>(x: () => P<{ default: { prop: T } }>): T;

const result4 = foo4(() => {
 return new P((resolve) => {
 resolve;
 });
});

declare function foo5<T>(x: () => P<{ default: [T] }>): T;

const result5 = foo5(() => {
 return new P((resolve) => {
 resolve;
 });
});

🙁 Actual behavior

Only foo2 and foo3 have errors and we can see that their inner resolves reference never

🙂 Expected behavior

All of those should consistently error and resolve should be typed as (value: unknown) => void. Specifically, foo1 and foo2 are the almost the same signatures but foo2 is using a type alias in its declaration which changes the inference behavior. This is strong indication of the bug here

Additional information about the issue

No response

[bvanjoi]

another case:

declare const bbbbbb: <CCC, DDD>(
 opA: () => CCC, 
 opB: (thing: CCC) => DDD, 
) => DDD
declare const eeee: () => { data: number };
declare function ffff<GGGG>(): (thing: GGGG) => GGGG;
declare function hhhh<E>(factory: () => { data: E }): void;
hhhh(() => bbbbbb(
 eeee, // ERROR: Type 'number' is not assignable to type 'never'
 ffff(),
));

However, it works correctly if a type alias is used.

+ type AAAAAAA<V> = { data: V };

declare const bbbbbb: <CCC, DDD>(
 opA: () => CCC, 
 opB: (thing: CCC) => DDD, 
) => DDD
declare const eeee: () => { data: number };
declare function ffff<GGGG>(): (thing: GGGG) => GGGG;
- declare function hhhh<E>(factory: () => { data: E }): void;
+ declare function hhhh<E>(factory: () => AAAAAAA<E>): void;
hhhh(() => bbbbbb(
 eeee,
 ffff(),
));