ReturnType break the original funtion return type if function is method of a class

[linonetwo]

Bug Report

🔎 Search Terms

ReturnType method
ReturnType extends keyof

🕗 Version & Regression Information

"typescript": "4.1.3",

⏯ Playground Link

Playground Link

💻 Code

// I think infer ReturnValue break the actual return type of each P

type AsyncifyProxy5<OriginalProxy> = {
  [P in keyof OriginalProxy]: OriginalProxy[P] extends (...arguments_: any) => infer ReturnValue
    ? (...arguments_: Parameters<OriginalProxy[P]>) => Promise<ReturnValue>
    : unknown;
};

/**
 * Bug is here:
 */


/**
const ggg: Promise<string | boolean | {
    a: 3;
    b: 4;
}>

But it should be just {
    a: 3;
    b: 4;
}
*/
const ggg = ({} as AsyncifyProxy5<IContextService>).get('environmentVersions');

🙁 Actual behavior

ReturnType gives Union of all ReturnType<OriginalProxy[P]>

🙂 Expected behavior

I hope it can give me the exact ReturnType for each method, so I can get async version of all class method.

[RyanCavanaugh]

Please provide a repro that is both short and self-contained. We cannot investigate repros this large.

[linonetwo]

Sure, sorry that the previous repro contains some code from npm package type-fest.

I update the link, think this one is short enough:

https://www.typescriptlang.org/play?jsx=1&ts=4.1.3#code/PTAEElQFwCwSwHYGtSIGYFMBOoBKGoBXLBANQEMAbQjUAIyw3JVlvIGMirRGiToAngAdaAezSgm7GKAAKAKHlRhtAIIBnAQnZw0A2VlEAPAQFYAPAHkscAOaIqB4wIB8oALygA3vNCgA2rKoCKBIGALioNZ2DpROJgC6AFxRNvYIjoYmgQmSRlAYCAAm6qAAFAB0VeRYtoQAtoVQ6gD6KeQIAgCUHm7o2HgExGRUNL5+oAD85VUVNXWNCM1tcjXkjQVY6lZpsfECOS497m5O9XDqGOb4fCPUGC7jfimEyAiiAO4IANzyAL6-eTAABUwN8wNAACFCLZUKUYNgMElwcBFOxRAh1FBQLZcR5yl4-qByKUNFodHp9hZwABhDEFfIAZWwADc4OwHl0KrYCGUAOSFNmGBCLKCkbDqOAY9R8rqAxQgsGgCGQjCUT7ExiCESgNCiHC0+kYJms9kYFHyY1CfXYxCbNAcWjgWTkWClHx+XAAUVUNIAKi1ZKo-QAJFJYmwIWy-Py0ywAOUDwbDoAjiGj-yBoPBoFULPIcEo5DolFo+fupWLokI2KwrwQ6ckCCFGNFFqtNuC9sdEDpmKgHWa3nGFwAIhgWWrREJRSk6KJRKWOjHQEIi1A9Vh6uGoJGM35BXBhaLxVspZiUl5iSkAMwAGnoKQALKAAZnLUZrVhbUtsA6Ob2Rr5HkBTFKUzqujA6gPoa-aDu6fwKtmyqgAAsh05A8qA6JwUsoDljQoCUHAYSgAABmOE5TjOTRkcSxSgPUHQCJIlCXA+6iiKAESENhHShO8HzEvONbCdWtb1o2h7Hk0wSMQWIQdEUPCFEUiI4EIhgcuopRMJKlACBU7afp2dp-j2sEMlAzJYGyAEejiBDmAA0iBqmlGEEQSJZxpQC4ZSeSkzldCkPn5P4zkJL8fxAA

[RyanCavanaugh]

Shortened

type Promisify<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : never;
type PromiseProxify<OriginalProxy> = {
  [P in keyof OriginalProxy]: Promisify<OriginalProxy[P]>;
};

interface IConstants {
  isDevelopment: boolean;
  platform: string;
  environmentVersions: { a: 3, b: 4 };
}
interface IContextService {
  get<K extends keyof IConstants>(key: K): IConstants[K];
}

declare const m: PromiseProxify<IContextService>;
const ggg = m.get("platform");

The type expression (...args: A) => Promise<R> : never isn't generic, so get isn't generic either. There are a few cases where we're able to synthetically make a function generic, but this definitely isn't one of them and it's not clear how to make that work in general.

[linonetwo]

Okay, should I keep this issue open? Will you reconsider this usage in the future?

I think I will manually as unknown as { a: 3, b: 4 } for now.

[RyanCavanaugh]

I think this is pretty unlikely to change unless we collect new use cases around generic synthesis, or redo inference completely (oh no).

[saltman424]

For posterity, this is essentially a duplicate of #39594 and I have posted a use case and some proposals over there