Support for `Object.hasOwn` (`lib.d.ts` and narrowing)

[DanielRosenwasser]

Object.hasOwn(obj, key) has just moved to stage 3.

https://github.com/tc39/proposal-accessible-object-hasownproperty

[RyanCavanaugh]

Discussed a bit with @jamiebuilds offline. Some key scenarios and questions to resolve:

declare const ra: Record<string, any>;
if (Object.hasOwn(ra, "foo")) {
  ra.foo; // should be 'any'
}

declare const ru: Record<string, unknown>;
if (Object.hasOwn(ra, "foo")) {
  ra.foo; // should be 'unknown'
}

declare const abcd: { a: string, b: string } | { c: string, d: string };
if (Object.hasOwn(abcd, "a")) {
  abcd.b; // should be OK
}
// Should this be OK?
// Could argue either way
Object.hasOwn(abcd, "efg")

// TODO: Add more use cases + desired behavior

[DanielRosenwasser]

Should there be a separate issue for hasOwn guards? Should it continue here? Doesn't #43947 already hande hasOwnProperty specially?

[DanielRosenwasser]

declare const abcd: { a: string, b: string } | { c: string, d: string };
if (Object.hasOwn(abcd, "a")) {
  abcd.b; // should be OK
}

I don't like it, but we already did it for in.

I think one concern I have is making sure that the else branch doesn't narrow out anything that does have that property. Specifically this:

declare const abcd: { a: string, b: string } | { c: string, d: string };
if ("a" in abcd) {
    abcd.b; // okay
}
else {
    abcd.c // okay
    abcd.d // okay
}

in currently does a negated narrowing because of the prototype walk, but hasOwn won't. In theory, it would be more correct to keep the type of abcd as { a: string, b: string } | { c: string, d: string } in the else branch. But maybe that's too pedantic.

[pubmikeb]

Object.hasOwn has reached stage 4 and is finally in GA of V8/Chromium-based browsers/Node.js.
It's a time to update lib.es5.d.ts.

[pubmikeb]

Any update?
Both, Node.js v.16.11+ and V8 v.95+ support Object.hasOwn out-of-box.

P.S. On 17th October Node.js 17.0 will be released.

[nicolas377]

Since there doesn't seem to be much progress here, could I help with this in any way?

[r-cyr]

This feature is, AFAIK, now Stage 4 and scheduled to be part of this June release of ES2022. It would be wonderful if it could do narrowing, because I wouldn't be surprised if it will eventually replace most usages of Object#hasOwnProperty(hasOwn is safer) and the in operator(hasOwn doesn't have to go through the prototype chain).