Typeguard with ""|undefined not working

[AnyhowStep]

TypeScript Version: 3.3.0, and the version on TS playground (3.4.1 as of this writing)

Search Terms: typeguard, empty string literal, undefined, union

Code

//--strictNullChecks
type Falsy<T> = (
 | Extract<0, T>
 | Extract<
 (
 | false
 | null
 | undefined
 //Actually, only 0|NaN
 //But TS does not support NaN literal
 | number
 | ""
 | 0n
 | HTMLAllCollection
 ),
 T
 >
);
declare const emptyStrOrUndefined: Falsy<string | undefined>;
declare function isFalsy<T>(
 mixed: T
): mixed is Falsy<T>;

declare const s: string | undefined;
/*
 Hovering over this isFalsy() call gives me,
 function isFalsy<string | undefined>(mixed: string | undefined): mixed is "" | undefined

 This is as expected
*/
if (isFalsy(s)) {
 //Expected: s should be ""|undefined now
 //Actual: s is undefined
 if (s == undefined) {
 //Should be undefined now
 console.log(s);
 } else {
 //Expected: Should be "" now
 //Actual: s is `never`
 //Property 'length' does not exist on type 'never'.
 console.log(s.length);
 }
}

declare function isEmptyStrOrUndefined(mixed: any): mixed is "" | undefined;
if (isEmptyStrOrUndefined(s)) {
 //Expected: s should be ""|undefined now
 //Actual: s is undefined
 if (s == undefined) {
 //Should be undefined now
 console.log(s);
 } else {
 //Expected: Should be "" now
 //Actual: s is `never`
 //Property 'length' does not exist on type 'never'.
 console.log(s.length);
 }
}

Expected behavior:

s should be ""|undefined where marked.

Also, unrelated, but this is where I would have liked a NaN literal in TS =/

Actual behavior:

s is undefined

Playground Link: Here

Related Issues: Not that I could find

[jack-williams]

This looks like a bug to me. The current behaviour when the source type is a union (here string | undefined) is that the source is filtered against the candidate type (here "" | undefined) removing all types not related to the candidate. The type string is not related to "" | undefined and is therefore filtered out, returning undefined (which is related to "" | undefined).

When the source type is not a union then the code intersects the source with the candidate (string & ("" | undefined)), producing the right narrowing.

I think getNarrowedType should probably map over unions first, applying narrowing to each constituent, abit like narrowTypeByTypeof.

[RyanCavanaugh]

Andrew Branch (@andrewbranch) fyi I didn't look fully into this, but generally assume Jack Williams (@jack-williams) is right 😉

[andrewbranch]

Ryan Cavanaugh (@RyanCavanaugh) given the discussion in #31206, what should we bump the milestone to?

[andrewbranch]

Cross-posting from PR #31206 for visibility:

We discussed this in a design meeting and decided there’s not currently a solution that’s worth the disruption it will bring. A hypothetical future where we can stop treating “branded primitives” as they exist today (e.g. string & { __kind: 'path' }) as possible value-containing types will help somewhat, and we also discussed this as an indicator that people often think about their object types as being closed, when in fact the type system doesn’t represent this at all (aside from excess property checking on fresh object literals).

I may look into doing the correct thing when all constituents of both the original type and the predicate type are primitives, since intersections of those are more intuitive and fall out when empty. On the other hand, I’m not sure if we want that kind of logical branching—maybe it’s better just to keep it in its current slightly wrong but consistent state. At any rate, this PR is out of scope for that kind of change.

[AnyhowStep]

I need a sad face react =(

Thank you for the update, and the attempt!