Regression: Argument of type 'awaited T' is not assignable to parameter of type 'T' #37534

Activity

1. Ryan Cavanaugh (RyanCavanaugh)

   added

   DiscussionIssues which may not have code impactIssues which may not have code impact

   on Mar 23, 2020
2. RyanCavanaugh commented on Mar 23, 2020

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Mar 23, 2020

   Member

   More actions

   This is a correct error. You could have written code like this:

   declare const arr: Array<() => Promise<Promise<string>>>;
   
   async function fn() {
     // x: Array<Promise<string>>
     const x = await runSequentially(arr);
     // Crashes
     x[0].then(() => { });
   }

   There are some workaround available (adding a constraint to T for example) but we're also considering adding a flag to allow the assignment to proceed even though it's unsound. Interested to hear your feedback and from others who encounter this error.
3. falsandtru commented on Mar 23, 2020

   

   falsandtru (falsandtru)

   on Mar 23, 2020

   Contributor

   More actions

   strictAwaitedTypes was implemented but removed after in #35998. Ron Buckton (@rbuckton) Why?
4. RyanCavanaugh commented on Mar 23, 2020

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Mar 23, 2020

   Member

   More actions

   We don't want to add the flag unless we really need it. Assessing what kind of breaks people encounter in real codebases is how we're figuring that out.
5. Pajn commented on Mar 23, 2020

   

   Emma (Pajn)

   on Mar 23, 2020

   Author

   More actions

   Is there any real world example that this is unsound in? Because a Promise<Promise<string>> string can't be constructed.

   Personally, I consider that Typescript allows Promise<Promise<string>> to be written a bug (that hopefully can be fixed soon #29317)
6. falsandtru commented on Mar 23, 2020

   

   falsandtru (falsandtru)

   on Mar 23, 2020

   Contributor

   More actions

   #37501

   Conclusion: ship it without a flag in the beta, re-evaluate for the RC if the breaks are that bad.

   Hm...

   awaited operator is effective to find a bug but correcting for awaited operator was very bored.

   falsandtru/spica@c569afd

   #37511
7. RyanCavanaugh commented on Mar 23, 2020

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Mar 23, 2020

   Member

   More actions

   Is there any real world example that this is unsound in?

   Sure, any higher-order type operation involving Promise<T> is potentially a problem. Note that the actual type Promise<Promise<T>> never appears in this example:

   // Previously-allowed but unsound definition
   async function myAwaitWrong<T>(arg: Promise<T>): Promise<T[]> {
     // Proposed: That this be valid without a type assertion
     return [await arg] as any;
   }
   
   // Correct definition of an awaiting function
   async function myAwaitRight<T>(arg: Promise<T>): Promise<(awaited T)[]> {
     return [await arg];
   }
   
   // Toggle these to observe different behavior
   const myAwait = myAwaitRight;
   // const myAwait = myAwaitWrong;
   
   
   class MyThing<T> {
     value!: T;
     // Returns Promise<T>
     async getValue() {
       return this.value;
     }
     // Returns Promise<T[]>
     async doSomething() {
       return myAwait(this.getValue());
     }
   }
   
   async function f() {
     const p = new MyThing<Promise<string>>();
     // Under myAwaitWrong - m: Incorrectly Promise<string>[]
     // Under myAwaitRight - m: Correctly string[]
     const m = await p.doSomething();
   }

   Because a Promise<Promise<string>> can't be constructed.

   People keep saying this and I continually question what it means for this to be the case; it's like saying f(x) => abs(abs(x)) isn't a thing because abs is idempotent on itself. It's valid and you can do it. Higher-order constructions exist and you can't just say "abs(abs(x)) should be illegal" because it implies any higher-order type construction should be banned unless it somehow proves that it can never operate in a way that produces this result.
8. jeiea commented on Mar 25, 2020

   

   jeiea

   on Mar 25, 2020

   Last edited by jeiea

   More actions

   May I ask a question? Can I make the following type check?

   async function* flatten<T>(generator: AsyncGenerator<T[]>): AsyncGenerator<T> {
     for await (const array of generator) {
       for (const value of array) {
         yield (value as unknown) as T;
         //    ^^^^^^^^^^^^^^^^^^^^^^^
         // Type 'awaited T' is not assignable to type 'T'.
         //  'T' could be instantiated with an arbitrary type which could be unrelated to 'awaited T'.ts(2322)
       }
     }
   }
   

   I'm using typescript 3.9.0-dev.20200324.
9. falsandtru commented on Mar 25, 2020

   

   falsandtru (falsandtru)

   on Mar 25, 2020

   Contributor

   More actions

   You have to change the return type to AsyncGenerator<awaited T>.
10. jeiea commented on Mar 25, 2020

    

    jeiea

    on Mar 25, 2020

    Last edited by jeiea

    More actions

    falsandtru (@falsandtru) It causes Parsing error: '>' expected.
11. Ron Buckton (rbuckton)

    closed this as completedin #37610on Mar 26, 2020