Generic types are not inferred for abstract classes if not explicitly used

[Xriuk]

Bug Report

⏯ Playground Link

Playground link with relevant code

💻 Code

abstract class MyAbstractGeneric<TValue1, TValue2 extends string, TValue3> {}

class MyConcreteGeneric<TValue1, TValue3> extends MyAbstractGeneric<TValue1, 'test', TValue3> {}

function myGenericFunction<TValue1, TValue2 extends string, TValue3>(abstractVar: MyAbstractGeneric<TValue1, TValue2, TValue3>) {}

let myConcreteVar = new MyConcreteGeneric<string, number>();
// Inferred as <unknown, string, unknown>
myGenericFunction(myConcreteVar);

let myAbstractVar = new MyConcreteGeneric<string, number>() as MyAbstractGeneric<string, any, number>;
// Inferred as <string, any, number>
myGenericFunction(myAbstractVar);

If I declare a member of a generic type inside the abstract class everything works (for the declared members)

abstract class MyAbstractGeneric<TValue1, TValue2 extends string, TValue3> {
  myVar?:TValue1;
}

class MyConcreteGeneric<TValue1, TValue3> extends MyAbstractGeneric<TValue1, 'test', TValue3> {}

function myGenericFunction<TValue1, TValue2 extends string, TValue3>(abstractVar: MyAbstractGeneric<TValue1, TValue2, TValue3>) {}

let myConcreteVar = new MyConcreteGeneric<string, number>();
// Inferred as <string, string, unknown>
myGenericFunction(myConcreteVar);

let myAbstractVar = new MyConcreteGeneric<string, number>() as MyAbstractGeneric<string, any, number>;
// Inferred as <string, any, number>
myGenericFunction(myAbstractVar);

But then some complex type using any of the generic types is not considered apparently

import { Get } from 'type-fest';

abstract class MyAbstractGeneric<TValue1, TValue2 extends string, TValue3> {
  myVar?:Get<TValue1, TValue2>;
}

class MyConcreteGeneric<TValue1, TValue3> extends MyAbstractGeneric<TValue1, 'test', TValue3> {}

function myGenericFunction<TValue1, TValue2 extends string, TValue3>(abstractVar: MyAbstractGeneric<TValue1, TValue2, TValue3>) {}

let myConcreteVar = new MyConcreteGeneric<string, number>();
// Inferred as <unknown, string, unknown>
myGenericFunction(myConcreteVar);

let myAbstractVar = new MyConcreteGeneric<string, number>() as MyAbstractGeneric<string, any, number>;
// Inferred as <string, any, number>
myGenericFunction(myAbstractVar);

🙁 Actual behavior

The function called on a child of a generic abstract has the wrong type inferred if no concrete members of the type(s) are declared in the abstract class.

🙂 Expected behavior

The generic types should be inferred regardless of their use inside the class

[fatcerberus]

I’d say this is working as intended. Because of structural typing, if you don’t use a type parameter in the definition of a type, then as far as TypeScript is concerned it effectively doesn’t exist for the purposes of type checking and inference.

[MartinJohns]

Relevant: https://github.com/microsoft/TypeScript/wiki/FAQ#why-is-astring-assignable-to-anumber-for-interface-at--

In general, you should never have type parameters which are unused. The type will have unexpected compatibility (as shown here) and will also fail to have proper generic type inference in function calls.

[fatcerberus]

There’s also this entry explaining this exact behavior:
https://github.com/microsoft/TypeScript/wiki/FAQ#why-doesnt-type-inference-work-on-this-interface-interface-foot--

[Xriuk]

I’d say this is working as intended. Because of structural typing, if you don’t use a type parameter in the definition of a type, then as far as TypeScript is concerned it effectively doesn’t exist for the purposes of type checking and inference.

The problem is that the type parameter usage is not considered, this is a valid type which is not picked by Typescript:
Get<TValue1, TValue2> which is a complex type using the generic class' parameters

[fatcerberus]

Get<TValue1, TValue2> which is a complex type using the generic class' parameters

It doesn't matter - if at any point in a chain of generic type instantiations there is a class which doesn't use its type parameter, then TS won't be able to infer it, because inference has to work backwards from the final type. It doesn't matter that at some point you wrote Foo<number> if the number isn't witnessed in the type you ultimately end up with - it's like having a function f(x) = 0 and then asking, based on the result of calling the function, what value was originally passed for x. (the answer being that it doesn't matter because a 0 is a 0 - which equally applies here)

This is explained in the FAQ entry I linked above.

[typescript-bot]

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

[mp3por]

Sooo - how to fix this ? Please provide the proper implementation of the submitted code for reference to me and future people. For me the DOCS are not really clear what I must do since the "fix" from the docs does not compile.

[RyanCavanaugh]

@mp3por there's nothing to "fix" here. Structural inference in a structural type system is the expected and intentional behavior. See also https://github.com/microsoft/TypeScript/wiki/FAQ#structural-vs-instantiation-based-inference