Literal type not inferred correctly when using generics #10685

Activity

1. mhegazy commented on Sep 2, 2016

   

   Mohamed Hegazy (mhegazy)

   on Sep 2, 2016

   Contributor

   More actions

   The main problem is that literal types are not inferred unless there is a contextual type. and for generic types, return types are not an inference position. so the A[] in const x: A[] = Array.from(['a']) does not impact how T is inferred for Array.from call. and thus "a" is always inferred as string.

   The rational here is that literal types were added later on, and inferring them always by default would be a breaking change to code written before TS 1.8. e.g.:

   let x = `a`;
   x = `b` // Error x is `a`.

   Now #10676 is trying to address that by inferring literals more often. but it will not address all cases, such as the one above. you can see the description Anders Hejlsberg (@ahejlsberg) provides in the PR:

   During type argument inference, literal types are widened to their base primitive type unless the target type parameter has a constraint that includes primitive or literal types.

   The rational here is that a literal type is not super useful by itself, if the target of the inference is not one itself. e.g. new Array('a'), most likely you do not want an array of a's, but rather a string array with one initial value.

   so to an extent this issue is really a design limitation. if we infer literal types all the time, this breaks existing code in a huge way.

   A better work around for this scenario is to explicitly specify the generic type argument for Array.from, e.g:

   const y = Array.from<A>(['a']);
2. Mohamed Hegazy (mhegazy)

   added

   Design LimitationConstraints of the existing architecture prevent this from being fixedConstraints of the existing architecture prevent this from being fixed

   on Sep 2, 2016
3. Mohamed Hegazy (mhegazy)

   closed this as completedon Sep 20, 2016
4. microsoft

   locked and limited conversation to collaborators on Jun 19, 2018