Type narrowing for awaited values

[samdenty]

Search Terms

promise, type narrowing, await

Suggestion

The type narrowing that occurs inside if statements, should work with awaited values

Though generally speaking a type is used for values that are already

Examples

type A = {
  kind: 'a'
  a: string
}

type B = {
  kind: 'b'
  b: string
}

let data: A | B

async function valueTest() {
  if ((await data.kind) === 'a') {
    // 'data' hasn't been narrowed to type 'A'
    data.a // Error
  }

  // Works fine without await
  if (data.kind === 'a') {
    data.a // Okay
  }
}

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[MartinJohns]

This is due to #9998.

[DanielRosenwasser]

I think it's more that there's a limited set of syntactic constructs we can analyze because it would be inefficient otherwise. I guess the thing I want to know is whether there's a reason to write code like that.

[jeremymeng]

I guess this is the same issue that for-await-of doesn't narrow types?

/// <reference lib="esnext.asynciterable"/>

interface MyIterator<T> {
  next(): Promise<
    | {
        done: false;
        value: T;
      }
    | {
        done: true;
        value: undefined;
      }
  >;
  [Symbol.asyncIterator](): MyIterator<T>;
}
interface Item { name: string }

async function m(iter: MyIterator<Item>) {
  for await (const it of iter) {
    console.log(it.name);           // Error here complaining about 'it': Object is possibly 'undefined'.ts(2532)

  }
}

[jeremymeng]

hmm, actually it is not related to await. iterator has the same error

interface MyIterator<T> {
    next():
      | {
          done: false;
          value: T;
        }
      | {
          done: true;
          value: undefined;
        }
    ;
    [Symbol.iterator](): MyIterator<T>;
}

interface Item { name: string }

function m(iter: MyIterator<Item>) {
    for (const it of iter) {
        console.log(it.name);           // Error here complaining about 'it': Object is possibly 'undefined'.ts(2532)

    }
}