Instantiation expressions should filter overloads by type parameter constraints #63126

Activity

1. snarbles2 commented on Feb 11, 2026

   

   snarbles2

   on Feb 11, 2026

   More actions

   I see the appeal, but I'd be worried about creating an unintended situation where members are silently disappearing. One could also take the position that if an argument is permissible, then it shouldn't be a constraint.

   declare const f: {
       <T>(x: T): T;
       new<T>(x: T): T extends object ? T : never;
       // Or if yo don't like `never`, substitute preferred error sentinel
   };
2. AFatNiBBa commented on Feb 11, 2026

   

   Sean Alunni (AFatNiBBa)

   on Feb 11, 2026

   Author

   More actions

   I get what you're saying, but the two signatures are separate, so each has its own constraint.
   Example:

   const f: {
       <T>(x: T): T;
       new<T extends object>(x: T): T;
   } = function FuncName<T>(x: T) { return x; } as any;
   
   const a = f(1);
   //    ^? const a: 1
   // Runtime value: 1
   
   const b = f(2);
   //    ^? const b: 2
   // Runtime value: 2
   
   const c = f({ a: 1 });
   //    ^? const c: { a: number; }
   // Runtime value: { a: 1 }
   
   const d = new f(1);
   // Error: Argument of type 'number' is not assignable to parameter of type 'object'
   // Runtime value: FuncName { }
   
   const e = new f({ a: 1 });
   //    ^? const e: { a: number; }
   // Runtime value: { a: 1 }

   As you can see in d, when a constructor returns a value which neither an object nor a function, it gets ignored and an actual instance of the constructor is made at runtime.
   As you can see in a and b, this only happens when using the function as a constructor, so I would like to express this fact in the type of f
3. AFatNiBBa commented on Feb 11, 2026

   

   Sean Alunni (AFatNiBBa)

   on Feb 11, 2026

   Last edited by AFatNiBBa

   Author

   More actions

   Also notice that your workaround doesn't work if the function is not called directly

   declare const original: {
       <T>(x: T): T;
       new<T extends object>(x: T): T;
   };
   
   declare const workaround: {
       <T>(x: T): T;
       new<T>(x: T): T extends object ? T : never;
   };
   
   declare const noCtor: {
       <T>(x: T): T;
       // Let's pretend there's no constructor signature because the type parameter constraint was unmet
   };
   
   const list = [ [1, 2], [3] ];
   
   const a = list.flatMap(original);
   //    ^? const a: unknown[]
   
   const b = list.flatMap(workaround);
   //    ^? const b: unknown[]
   
   const c = list.flatMap(noCtor);
   //    ^? const c: number[]

   Even if, probably, noCtor should have worked anyway, since Array.flatMap() doesn't accept constructors: There's no reason for it to get confused
4. jcalz commented on Feb 12, 2026

   

   Joe Calzaretta (jcalz)

   on Feb 12, 2026

   Contributor

   More actions

   This issue is specifically about instantiation expressions as implemented in #47607. The behavior is apparently as intended, according to #47607 (comment), so this is more like a missing feature than a bug.

   Duplicate of #51694.
5. AFatNiBBa commented on Feb 13, 2026

   

   Sean Alunni (AFatNiBBa)

   on Feb 13, 2026

   Last edited by AFatNiBBa

   Author

   More actions

   I think it is a bug, the documentation states that what I'm asking for should work
   
   To my understanding, it is because it just checks for the number of type arguments, but that's not the expected thing to happen

   👍React with 👍1Reacted by Ryan Cavanaugh
6. RyanCavanaugh commented on Feb 13, 2026

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Feb 13, 2026

   Member

   More actions

   I think the docs mean compatible by arity only. I'm not sure why it works this way, though
7. Ryan Cavanaugh (RyanCavanaugh)

   added

   Needs InvestigationThis issue needs a team member to investigate its status.This issue needs a team member to investigate its status.

   on Feb 13, 2026
8. Ryan Cavanaugh (RyanCavanaugh)

   assigned

   Anders Hejlsberg (ahejlsberg)

   on Feb 13, 2026
9. Ryan Cavanaugh (RyanCavanaugh)

   changed the title [-]Overloads should be filtered by unmet constraints of type parameters[/-] [+]Instantiation expressions should filter overloads by type parameter constraints[/+] on Feb 13, 2026