Allow base class expressions to reference class type parameters as long as the type param is not used on the static side of the resulting class

🔎 Search Terms

"Base class expressions cannot reference class type parameters" when stacking dynamic classes (mixins) with type parameters
Allow base class expressions to reference class type parameters as long as the type param is not used on the static side of the resulting class

Most closely related issues, but are IMO a different situation (as I explain below):
https://github.com/microsoft/TypeScript/issues/26154
https://github.com/microsoft/TypeScript/issues/17829 (documented at https://www.typescriptlang.org/docs/handbook/mixins.html#static-property-mixins-17829)

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed all the FAQ entries

⏯ Playground Link

https://www.typescriptlang.org/play?#code/C4TwDgpgBAwg9gOwM7AE4FcDGw6oCrgQA8eAfFALxQCGARiqtdlAhAO5QAUAdL9agHMkALhoIQAbQC6ASkrk8AbgBQyzIhRQAQvzoAbCADFKUEjqTQIAD2AQEAEySwNaLDnyEi1caVKdzEKJ4AXIU5ADeylDRNPRoTMBQmHrUSE46jLQGRAAa5Na2Dump0JEx5VC0-JxWojly4VCoEMDoqAhQVopQAL5RMX3lza3t2rpZECo9KmouUIZwcPpGJmYlUAV2js7Irti4BJBePn4BQSHyUGUxdAwJSSlp84vLufk2W8UWV-0VUABmixqdQaTRabQ6XV6v2hQ3BowWSwmUxmyVSTjwqQA1m8Nh8imNMgZDJxEcsSQB5WgAKwg2BkbwZeSuPSgAHo2VAwKg4BMALZQACWTkQUGAAAthVA9ILWKogA

💻 Code

type ConstructorType<T> = abstract new (...args: any[]) => T;

const BarableF = <TBase extends ConstructorType<any>>(Base: TBase) => {
    abstract class Barable<X> extends Base {
        bar(x: X) { return x; }
    }
    return Barable;
};

const FooableF = <TBase extends ConstructorType<any>>(Base: TBase) => {
    abstract class Fooable<X> extends Base {
        foo(x: X) { return x; }
    }
    return Fooable;
};

abstract class Task<X> extends BarableF(FooableF(Object)<X>)<X> {} // problem is on this line

🙁 Actual behavior

On line class Task<X> extends BarableF(FooableF(Object)<X>)<X> {} // problem is on this line, the inner-most X raises "Base class expressions cannot reference class type parameters", despite the fact that X is only ever used by the base class expression on the instance side of it's return value (as opposed to the static side). This example expands to:

abstract class Fooable<X> extends Object {
    foo(x: X) { return x; }
}

abstract class Barable<X> extends Fooable<X> {
    bar(x: X) { return x; }
}

abstract class Task<X> extends Barable<X> {}

which is perfectly valid code.

🙂 Expected behavior

I would expect for this to be valid code.

Unlike the situations in https://github.com/microsoft/TypeScript/issues/26154 and https://github.com/microsoft/TypeScript/issues/17829 and mentioned in https://www.typescriptlang.org/docs/handbook/mixins.html#static-property-mixins-17829, the type param here is not being used in the static side of resulting class we are extending.

IMO https://github.com/microsoft/TypeScript/pull/17922 was too restrictive of a fix, and since TS seems to error on the side of unsound-ness, I think there's an argument for this change to be reverted until there's a proper fix.

The full correct fix would be to allow type params in the base class expression as long as the result of the base class expression does not reference the type param anywhere on the static side of the class.

A middle-ground fix that would solve my use case in particular would be to allow type params in the base class expression if the expression they are used with is a class-like type (as opposed to a regular function that returns a class). Because TS already checks that class type params aren't used in static members (error 2302), this should be fine. However, that wouldn't solve this case:

function base<T>() {
    class Base {
        foo(t: T): T { return t;}
    }
    return Base;
}

class Gen<T> extends base<T>() {}

where again, the type param is only used on the instance side of the resulting class

Additional information about the issue

No response

Commencez par le Playground lié et la reproduction minimale du mixin dans l’issue, puis comparez les issues connexes #26154 et #17829 ainsi que le PR #17922 référencé. C’est terminé lorsque l’exemple Task passe la vérification des types, tandis que les utilisations du côté statique restent rejetées, y compris le cas d’une classe renvoyant une fonction décrit dans l’issue.