strictNullChecks false positives in case clause

[ajafff]

TypeScript Version: 2.9.0-dev.20180512

Search Terms:

Code

// @strictNullChecks: true

function test1(param?: {prop: string}) {
  switch (param && param.prop) {
    case 'foo':
      return param.prop; // error: 'param' is possibly undefined
  }
}

function test2(param: {prop?: string}) {
  switch (param && param.prop) {
    case 'foo':
      return param.prop.charAt(0); // error: 'param.prop' is possibly undefined
  }
}

Expected behavior:

Compiles without error.

Actual behavior:

strictNullChecks errors as described in the comments above.

Playground Link: https://agentcooper.github.io/typescript-play/?noImplicitReturns=false#code/GYVwdgxgLglg9mABFApgZygRgBQAcCGATvgLYD8AXIgN66Fy5UaExgDmAvgJQ0BQiiNAHcYUCAAtEeIqUQAyOYgLESAOjoMe1fgMQR8aFIgDkwOHGMUduxIRRQQhJMtLr6uANyIA9N8QpCekIqYxcSY0QYNCU4NDQYACMAGwBPRHAAExRgVhQMnQ5eQt5QSFgEZHQoACZpFSpad0pBKBZ2bj4BYVEJKTD5RTC3TU7dfUMTMwsrGwE7ByclGTUNXFUJIgBBKGwABi4vX39AuGCTIdWIqJi4xNT0sCycsDyCoqA

Related Issues:
#23818

[DanielRosenwasser]

Wow I've never seen anyone do that with a switch/case. I don't know how easy it is to add this to our narrowing logic, but I'll mark it as a bug.

[weswigham]

A survey of our own codebase says that we have seen this pattern before (we just don't use a discriminated union for node and strict null checks yet, so we haven't noticed). 😄

[weswigham]

This isn't unique to switch-case - this also doesn't work:

function test1(param?: { prop: string }) {
    if ((param && param.prop) === "foo") {
        return param.prop;
    }
}

which is equivalent to the switch-case above.

And, similarly/simplified a bit:

function test1(param?: { prop: string | number }): "no" | { prop: string | number } {
    if ((param && "foo") === "foo") {
        return param; // error
    }
    return "no";
}

The root cause looks like it's because when we start diving into (param && "foo") === "foo" to narrow, our logic to locate references to narrow is a little... narrow (we need to derive that param is at least truthy in the true branch of that block).

[defenestrant]

I think I've just come across this same issue. The strict-null check doesn't work when the check is contained in an other function.

type NullOrString = string | null

const testForNull = (param : NullOrString) => param != null
const doStringStuff = (param : String) => { /* ... */ }

const doSomething = (param: NullOrString) =>
{
    if(param != null)
        doStringStuff(param)
}

const doSamething = (param: NullOrString) =>
{
    if(testForNull(param))
        doStringStuff(param)
}

The doSamething-function will give this error:

[ts]
Argument of type 'NullOrString' is not assignable to parameter of type 'String'.
  Type 'null' is not assignable to type 'String'.
(parameter) param: NullOrString

[RyanCavanaugh]

@defenestrant see #10734 or similar issues