Missing constraint error in instantiation expression for a nested class

[Andarist]

🔎 Search Terms

instantiation expression caching class expression declaration type arguments type parameter

🕗 Version & Regression Information

• This changed in PR: Cache instantiation expression types early enough to prevent reentrancy during printback #59931 , cc @weswigham

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.0-dev.20250701#code/MYGwhgzhAECCA8AVaBeaA7ArgWwEYFMAnAPmgG8AoaaANzBE3wEIAuaRAbiumAAsBLEABNW0AJLoIAFzDpg+RAE8ADvnhSV+APYAzOADoAQvASJi5jtAD0V6FIEwIvLZmHQihLYQrdpYKfzA0IaoPOBQwUjuAB5S+OhCMLChsKSU1NTKYITxUqKc3AC+XIUUQA

💻 Code

class A<T = number> {
  value!: T;
  child!: InstanceType<typeof A.B<A<T>>>; // this should error

  static B = class B<T extends A = A> {
    parent!: T;
  };
}

🙁 Actual behavior

It doesn't error

🙂 Expected behavior

it should error with:

Type 'A<T>' does not satisfy the constraint 'A<number>'.
  Type 'T' is not assignable to type 'number'.(2344)

like it did in 5.6: TS playground

Additional information about the issue

The problem here is that the situation is a little bit circular and variances worker gets hits in reentrant manner. The nested call returns emptyArray that is a signal for structuredTypeRelatedToWorker to return Ternary.Unknown.

So checkTypeArguments called by getInstantiatedSignatures doesn't report an error. In the old version of the code, this would be re-called after the variance worker would completely exit and the error would be raised.

I see 2 ways to solve this:

• ignore the introduced caching based inVarianceComputation to avoid spoiling this
• defer checkTypeArguments in getInstantiatedSignatures (well, call it with /*reportErrors*/ false and defer anoher call with /*reportErrors*/ true)

[LukeAbby]

Tinkering with this a little bit I found you don't need to use a nested class or static expression at all! Just using an instantiation expression is enough:

class B<T extends A = A> {
  parent!: T;
};

type C<T extends A = A> = T;

class A<U = number> {
  value!: U;
  child1!: typeof B<A<U>>; // No error but should
  child2!: B<A<U>>; // Consistently errors
  child3!: C<A<U>>; // Consistently errors
}

[MYRA31JAIS]

Hopefully it helps

class A<T extends number = number> { // T must extend number
  value!: T;
  child!: InstanceType<typeof A.B>; // Use B directly without type parameters

  static B = class B<U extends A = A<number>> { // U must extend A<number>
    parent!: U; // Ensure U extends A<number>
  };
}

// Example usage
const instance = new A<number>(); // This will work correctly
const childInstance = new A.B(); // This will also work correctly
childInstance.parent = instance; // This should be valid