Runtime Validation With Variables Fails

[GEMISIS]

Bug Report

🔎 Search Terms

typescript validation variable boolean failure

🕗 Version & Regression Information

Version 4.6.2 and below all seem to exhibit the same issue. Also confirmed most recent nightly build as of this filing exhibits the same issue.

This is the behavior in every version I tried, and I reviewed the FAQ for entries about TypeScript type validation

⏯ Playground Link

Playground link with relevant code

💻 Code

  interface test {
      val1: string | undefined;
  }

  function test1(input: string) {
      console.log(input);
  }
  function test2(input: test) {
      const canWork = input.val1 !== undefined;
      // Fails
      if (canWork) {
          test1(input.val1);
      }
      // Succeeds
      if (input.val1 !== undefined) {
          test1(input.val1);
      }
  }

🙁 Actual behavior

Receive the following error for type validation:

Argument of type 'string | undefined' is not assignable to parameter of type 'string'.
  Type 'undefined' is not assignable to type 'string'.(2345)

🙂 Expected behavior

Type validation from the boolean expression should work.

[MartinJohns]

This is working as intended. See #44730.

Narrowing through indirect references occurs only when the conditional expression or discriminant property access is declared in a const variable declaration with no type annotation, and the reference being narrowed is a const variable, a readonly property, or a parameter for which there are no assignments in the function body.

[GEMISIS]

@MartinJohns Got it, that's super strange and not what I would have expected, as it seems similar to the f6 function in #44730, but I guess the compiler doesn't know which type to choose still/can't pick one?

[fatcerberus]

Look closer: f6 in #44730 is explicitly an example of a function where narrowing doesn’t work.

Some examples where narrowing does not occur (but it would had the indirectly referenced conditions been written in-line)

[GEMISIS]

@fatcerberus I meant closer in terms of removing the obj reassignment in-function. IE: If it was like this:

function f6(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
    const isFoo = obj.kind === 'foo';
    if (isFoo) {
        obj.foo;  // Error, no narrowing because 'obj' is assigned in function body
    }
}

It seems that because obj has two distinct definitions, this is why it works? So in my example, if test was defined as:

interface test {
    val1: string;
} | {
    val1: undefined;
}

Then everything works fine, which is weird to me was my point.

[fatcerberus]

Ah, that's a bit tricky, but I suspect that works because obj.kind === 'foo' is treated as a type guard applying to obj itself (because it's a discriminated union), rather than only obj.kind. Thus it meets the criteria of directly narrowing a parameter which is not reassigned. In your example you're trying to narrow a single property of an object (input.val1), not input as a whole, which fails because val1 is not declared readonly.

[MartinJohns]

That'd be my best guess as well.

[RyanCavanaugh]

We're quite a bit stricter about when to apply indirect narrowing as opposed to indirect narrowing. If you mark it as readonly val1: string | undefined then it succeeds as expected.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.