wrong type infer in 3.6.0-dev.20190725 #32572

Activity

1. jcalz commented on Jul 26, 2019

   

   Joe Calzaretta (jcalz)

   on Jul 26, 2019

   Last edited by jcalz

   Contributor

   More actions

   Ideally bug reports will have a completely self-contained example that you don't need external libraries to reproduce. Like maybe this:

   interface Prom<T> {
     mapSeries<Q>(
       this: Prom<T & Iterable<Q>>,
       iterator: (item: Q) => any
     ): any;
   }
   
   declare const p: Prom<string[]>;
   
   p.mapSeries(async function (s) {
     console.log(s.toUpperCase()); // error, s is unknown 3.6.0-dev.20190725
   });

   Playground (but there's no error in v3.5.1)

   Something about this and not being able to infer Q from the type T & Iterable<Q> in this scenario. (Workaround: replace Q with or constrain Q to (T extends Iterable<infer I> ? I : never))

   Not sure if this is really a bug or what. Seems like it might be a breaking change for Bluebird, though.

   Caused by #32386/#32460? (🃏wild guess❓)
2. ahejlsberg commented on Jul 26, 2019

   

   Anders Hejlsberg (ahejlsberg)

   on Jul 26, 2019

   Member

   More actions

   This is caused by #32460. Consider the following simplified example:

   declare function foo1<T>(obj: string[] & Iterable<T>): T;
   declare function foo2<T>(obj: string[] & T): T;
   
   declare let sa: string[];
   declare let sx: string[] & { extra: number };
   
   let x1 = foo1(sa);
   let y1 = foo1(sx);
   
   let x2 = foo2(sa);
   let y2 = foo2(sx);

   With 3.5.x we produced the following results:

   let x1 = foo1(sa);  // string
   let y1 = foo1(sx);  // unknown
   
   let x2 = foo2(sa);  // string[]
   let y2 = foo2(sx);  // { extra: number }

   It's pretty clear that x1 and y2 are inconsistent, and unknown would be a better inference for x2.

   With 3.6.0-dev.20190725 we produce:

   let x1 = foo1(sa);  // unknown
   let y1 = foo1(sx);  // unknown
   
   let x2 = foo2(sa);  // unknown
   let y2 = foo2(sx);  // { extra: number }

   This has the better inference for x2 and it makes x1 and y1 consistent, but unknown is really not a good inference here. I think the desired outcome is:

   let x1 = foo1(sa);  // string
   let y1 = foo1(sx);  // string
   
   let x2 = foo2(sa);  // unknown
   let y2 = foo2(sx);  // { extra: number }

   I have updated #32558 to implement this and I'm currently checking for effects on the DT tests.

   👍React with 👍2Reacted by Joe Calzaretta and Ryan Cavanaugh
3. Anders Hejlsberg (ahejlsberg)

   self-assigned this

   on Jul 26, 2019
4. Anders Hejlsberg (ahejlsberg)

   added

   BugA bug in TypeScriptA bug in TypeScript

   on Jul 26, 2019
5. Anders Hejlsberg (ahejlsberg)

   added this to the TypeScript 3.6.1 milestone on Jul 26, 2019
6. Anders Hejlsberg (ahejlsberg)

   added

   Fix AvailableA PR has been opened for this issueA PR has been opened for this issue

   on Jul 26, 2019
7. Anders Hejlsberg (ahejlsberg)

   closed this as completedin #32558on Jul 29, 2019
8. microsoft

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