Why `map.has()` doesn't act as a type guard

I faced the following problem: In my application I have a Map in which a set of lambda functions are paired with some Roles. Each lambda takes a secondParameter and returns a settings object.

enum Role {
    ROLE_1 = "role"
}
const settingsRole1 = {}
const defaultSettings = {}
const secondParameter = ""

const map = new Map<Role, (secondParameter: string) => any>([
    [Role.ROLE_1, (secondParameter: string) => settingsRole1]
]);
const settings = map.get(Role.ROLE_1)(secondParameter) ?? defaultSettings;

I received this error while trying to calling the function returning from the map: TS2722: Cannot invoke an object which is possibly 'undefined'.
I tried to guard it as shown below, but it doesn't seem to work...

const settings = map.has(Role.ROLE_1) ? map.get(Role.ROLE_1)(secondParameter) : defaultSettings;

As answered here, it seems that using the optional chaining operator works, so the following snippet implements a working guard

const settings = map.get(Role.ROLE_1)?.(secondParameter) ?? defaultSettings;

Why does the guard build using the optional chaining operator work, while the one built with if map.has() does not?

The has() method on Map doesn't act as a type guard method on the Map instance. So calling map.has(x) has no narrowing effect on map, and therefore cannot affect subsequent calls to map.get(x).

There is an open feature request at microsoft/TypeScript#13086 to support this, but it hasn't been implemented because, at least for a mutable, non-ReadonlyMap (see https://stackoverflow.com/q/50046573/2887218 ), the fact that map.has(x) is true now doesn't mean it will be true forever. As mentioned by the TS team dev lead in this comment: "This much, much, much, much more tricky than it looks because you also have to define how long the has check should last."

Any change to accomodate this would need to act correctly in both map.get() lines below:

const map = new Map([[1, { a: 1 }], [3, { a: 2 }]]);
if (map.has(2)) {
    map.get(2).a; // should be okay
    map.delete(2);
    map.get(2).a; // should not be okay
}

Right now it errors on both of them, which is annoying, but safe.

You could merge in your own type guard for has() if you want, maybe like this:

interface NarrowableMap<K, V> extends Map<K, V> {
    has<P extends K>(k: P): this is { get(p: P): V } & this;
}

but then it would fail to error on both of them, which is convenient, but unsafe, especially on that second line.

const map = new Map([[1, { a: 1 }], [3, { a: 2 }]]) as
    NarrowableMap<number, { a: number }>;

if (map.has(2)) {
    map.get(2).a; // no error, that's good
    map.delete(2);
    map.get(2).a; // no error, that's bad
}

The language currently doesn't have a way to mark methods as resetting control flow narrowing. This happens automatically on property reassignment and the delete keyword, but map operations don't trigger this.

So that's why it doesn't work.

The easiest refactoring is to give up on has-then-get and switch to get-then-validate. So you can do it like this:

const v = map.get(2);
if (v !== undefined) { v.a }

Or you could use optional chaining to make it more concise:

const w = v?.a
const x = map.get(2)?.a

Playground link to code