Static method on abstract class with generic this parameter causes "excessively deep" error when called on concrete class

🔎 Search Terms

• abstract class
• static method
• this parameter
• excessively deep
• concrete class
• generic

🕗 Version & Regression Information

This is broken in 5.6, 5.7, and nightly at least.

⏯ Playground Link

https://www.typescriptlang.org/play/?target=99&ts=5.8.0-dev.20250117&ssl=6&ssc=12&pln=6&pc=15#code/IYIwzgLgTsDGEAJYBthjAgguacIGFV0AeAEQD4EBvAKAXoQHMBTRAE2AmAAoBKALgSlqdBmKisArlAB21AL4I0CSTIDWMgPYB3OctKj68moYSROAS1gIAHgE8AXsQAqCZjYjMZbDBDsAHZk0AMywcGHhCNDBiYBk7cnJuUzEIAAsLMEFnABoUhg4ubLcPLx8EP0CQsMgIgiIYixlg5ighSgB+IQRBGWYAN1bTXgUaYxoUaIR8TRlYCU8o9BLPbwxsWrwlmNqmxkpaMZMZuYXmbYA6ewduAEYAJgBmXiA

💻 Code

abstract class AbstractClass<D> {
    get data(): D {
        return {} as unknown as D
    }

    static xyz<T extends typeof AbstractClass<any>>(
        this: T,
        data: T extends typeof AbstractClass<infer D> ? D : never
    ) {}
}

class ConcreteClass extends AbstractClass<string> {

}

ConcreteClass.xyz(123)

🙁 Actual behavior

The ConcreteClass.xyz results in Type instantiation is excessively deep and possibly infinite. and as a result infers D as never.

🙂 Expected behavior

This to work fine. A similar case, but where InstanceType<T> extends AbstractClass<infer D> ? D : never works fine: https://www.typescriptlang.org/play/?target=99&ts=5.8.0-dev.20250117#code/IYIwzgLgTsDGEAJYBthjAgguacIGFV0AeAEQD4EBvAKAXoQHMBTRAE2AmAAoBKALgSlqdBmKisArlAB21AL4I0CSTIDWMgPYB3OctKj68moYSROAS1gIAHgE8AXsQAqCZjYjMZbDBDsAHZk0AMywcGHhCNDBiYBk7cnJuUzEIAAsLMEFnABoUhg4uQQBJGXMZWGZnAOYXSndPbwxsSAiCIhiLGWDmKCFKAH4hBEEZZgA3XtNeBRpjGhRohHxNColPKPQ3Dy8fMNa8TZjWrsZKWjmTFbXWZiOAOnsHbgBGACYAZl4gA

Additional information about the issue

No response

Start by running the provided TypeScript Playground reproduction and compare it with the working InstanceType variant. Trace how the compiler handles the static this parameter and conditional type inference; done means ConcreteClass.xyz no longer reports an excessively deep instantiation error and infers the intended type.