Unexpected literal union type widening in generic type inference #32596

Activity

1. ulrichb commented on Jul 28, 2019

   

   ulrichb

   on Jul 28, 2019

   Author

   More actions

   For reference this is my original code (simplified version of my real scenario):

   function extended_example() {
   
       type SomeUnion = "A" | "B" | "C";
   
       interface SomeInterface<T extends SomeUnion> { prop: T }
   
       const a: SomeInterface<"A"> = { prop: "A" }
       const b: SomeInterface<"B"> = { prop: "B" }
   
       function fun<T extends SomeUnion>(x: T, y: SomeInterface<T>) { }
   
       fun("A", a); // no error
   
       fun("A", b); // !!! no error because widening to "A" | "B"
       fun("B", a); // !!! no error because widening to "A" | "B"
   }

   ... here I can pass a wrong SomeInterface<T> next to T which is (again pretty unexpected and) not very type safe :/
2. AnyhowStep commented on Jul 28, 2019

   

   AnyhowStep

   on Jul 28, 2019

   Last edited by AnyhowStep

   Contributor

   More actions

   Somewhat unrelated. But what do you think of the following?

   const interfaceB: SomeInterface<"B"> = { prop: "B" }
   function fun<T extends SomeUnion>(x: T, y: SomeInterface<T>) { }
   
   declare const aOrB : "A"|"B";
   //Could possibly be "A", interfaceB
   fun(aOrB, interfaceB);
3. ulrichb commented on Jul 29, 2019

   

   ulrichb

   on Jul 29, 2019

   Author

   More actions

   AnyhowStep

   Interesting. I thinks here it's okay that no error happens because there is no "out of bounds" type widening involved like my ("A" literal typed argument widened to "A" | "B" in my example).

   Also it is symmetric with non-literals ...

   type SomeUnion = string | number | boolean;
   function fun<T extends SomeUnion>(x: T, y: T) { }
   declare const strOrNum: string | number;
   fun(strOrNum, 42); // no error as expected

   But this brings me to the following example which should error again (it's generalization of the original example):

   type SomeUnion = "A" | "B" | "C";
   interface SomeInterface<T extends SomeUnion> { prop: T }
   function fun<T extends SomeUnion>(x: T, y: SomeInterface<T>) { }
   
   declare const aOrB : "A" | "B";
   const interfaceC: SomeInterface<"C"> = { prop: "C" }
   fun(aOrB, interfaceC); // !!! no error

   which again is asymmetric with non-literals:

   type SomeUnion = string | number | boolean;
   function fun<T extends SomeUnion>(x: T, y: T) { }
   declare const strOrNum: string | number;
   fun(strOrNum, true); // error as expected
4. AnyhowStep commented on Jul 29, 2019

   

   AnyhowStep

   on Jul 29, 2019

   Last edited by AnyhowStep

   Contributor

   More actions

   I'm not on my computer but what happens when you try this,

   function fun (...args : ["A", Some<"A">]|["B", Some<"B">])

   ---

   If the above works as you expected, how about,

   type Blah<T> = T extends any ? [T, Some<T>] : never
   
   function fun (...args : Blah<SomeUnion>)
   
   function fun2<ArgsT extends Blah<SomeUnion>> (...args : ArgsT)
5. Ryan Cavanaugh (RyanCavanaugh)

   added

   Working as IntendedThe behavior described is the intended behavior; this is not a bugThe behavior described is the intended behavior; this is not a bug

   on Jul 29, 2019
6. RyanCavanaugh commented on Jul 29, 2019

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Jul 29, 2019

   Last edited by RyanCavanaugh

   Member

   More actions

   It's assumed that a union of two literal types from the same primitive family are an OK inference, but not from two different families.

   Any inference that matches the constraint and is a supertype of all candidates is legal and your function implementation should be assuming that this is possible - in the worst case, a caller of your function could write

   fun<"A" | "B">("A", "B");

   See also #14829

   You could write this instead:

   function extended_example() {
   
       type SomeUnion = "A" | "B" | "C";
   
       interface SomeInterface<T extends SomeUnion> { prop: T }
   
       const a: SomeInterface<"A"> = { prop: "A" }
       const b: SomeInterface<"B"> = { prop: "B" }
   
       function fun<T extends SomeInterface<SomeUnion>>(x: T extends SomeInterface<infer U> ? U : never, y: T) { }
   
       fun("A", a); // no error
   
       fun("A", b); // errors
       fun("B", a); // errors
   }
7. ulrichb commented on Jul 29, 2019

   

   ulrichb

   on Jul 29, 2019

   Author

   More actions

   Okay. Thanks for info and sharing the workaround with the conditional type.

   ... and +1 for NoInfer<T> :)
8. ulrichb

   closed this as completedon Jul 29, 2019
9. microsoft

   locked as resolved and limited conversation to collaborators on Oct 21, 2025