typeof generic class returns any for all type arguments about typescript

[Andarist]

Here the source signature (<H extends Host2>(host: H): Page<H>) gets instantiated in context of the target signature ((...args: any[]): IPage<Host1>). That gets us a new source: (host: any): Page<any>. So the problem is that the any from the argument list in your target becomes an inference source for H on the source side and gets picked as the inferred type. This corrupts the comparison of those 2 signatures.

An interesting thing about this is that this code path uses different logic for inference from a signature than inferFromSignature. The latter uses the same inference priority for parameters and return types but collects covariant and contravariant candidates separately (and a covariant candidate is often preferred). This case uses different priorities (InferencePriority.ReturnType is weaker than InferencePriority.None) and collects everything as covariant candidates.

[martaver]

To paraphrase @Andarist, my understanding of why H is inferred as any is because:

• H exists in two places, as a parameter and as a return type.
• H corresponds to any in the parameter in the inference context of (...args: any[]) => IPage<Host1>.
• H could also be Host1, but typeof Host2Page is invariant, and (IIUC) TS prefers the parameter type anyway, so any is inferred over Host1.

From this perspective, I think TS is acting as intended, and the problem is actually the misuse of (...args: any[]) which has colloquially come to mean "I don't care about the parameters", instead of what it actually means which is "Must accept any and all parameters".

The solution we found was to use a constructor type as the inference context that allows parameters and return types to be contravariant and covariant respectively, e.g.

type PageCtor<T extends IHost, TIn extends T = T, TOut extends T = T> = new (host: TIn) => IPage<TOut>

This allows TIn and TOut to be inferred independently of each other, which is usually why (...args: any[]) is used - to prevent the args from getting in the way of the return type.

Here it is in action: https://tsplay.dev/WGbO9m

I'm going to suggest that this issue is closed as 'working as intended', however @Andarist might have an opinion about whether everything is as it should be.

It's probably worth considering whether there could be a better way to express a constructor type that keeps its variance.

[fatcerberus]

(...args: any[]) which has colloquially come to mean "I don't care about the parameters", instead of what it actually means which is "Must accept any and all parameters".

Yep, contravariance strikes again. Just like how (x: Animal) => void doesn't mean "the parameter is some kind of animal" but rather "must accept any kind of animal"

[typescript-bot]

This issue has been marked as "Working as Intended" and has seen no recent activity. It has been automatically closed for house-keeping purposes.