eslint prefer-object-has-own

• If `Object.hasOwn` is shadowed by a local variable in scope, the rewrite will refer to that variable instead of the global built-in, changing behavior.
• If the original code relied on `Object.prototype.hasOwnProperty.call` being a specific function object (e.g., for equality checks or `typeof`), replacing it with `Object.hasOwn` may break such checks.
• If the `obj` or `prop` expressions have side effects, the rewrite preserves their evaluation order only if the autotool keeps the same argument order—which it does—but any tool that reorders arguments would introduce a hazard; however, the rule’s fix does not reorder, so this is not a hazard of the fix itself.
• If `Object` is rebound (e.g., `let Object = null;`), then `Object.hasOwn` will throw or behave incorrectly, whereas the original `Object.prototype.hasOwnProperty.call` might still work if `Object.prototype` is unaffected—but this is a preexisting issue, not introduced by the fix.
• If the code is in a context where `Object.hasOwn` is not supported (e.g., older engines), the rewrite will cause a runtime error, while the original code would have worked—this is a versioning hazard, but the rule should only be used where ES2022+ is supported.
• If the call is part of a larger expression and the autofix removes parentheses implicitly relied on for grouping, it could change precedence—but the fix replaces a full CallExpression with another, preserving expression structure, so this is unlikely.
• If the original code had trailing comments on the same line after the semicolon, some autofix implementations might incorrectly discard them if they replace the whole statement without preserving trailing comments.
• If the original code used a computed property access like `obj[expr]` and the autofix does not preserve the exact spacing or formatting, it could affect readability but not behavior—this is not a behavioral hazard.
• If the `obj` expression is `undefined` or `null`, both `Object.prototype.hasOwnProperty.call` and `Object.hasOwn` throw the same TypeError, so no behavioral change occurs.
• If the original code was written as `(Object.prototype.hasOwnProperty).call(obj, prop)` and the rule somehow misfires, but the rule does not flag this form, so it’s not relevant.
• If the codebase uses a polyfill for `Object.hasOwn` that behaves differently from the native version (e.g., treats `-0` and `0` differently), then the rewrite might change behavior relative to expectations—but this depends on the polyfill, not the fix itself.

--- orig.js	2026-10-22 14:28:30.490417742 -0400
+++ fixed.js	2026-10-22 14:28:34.966379683 -0400
@@ -1,5 +1,5 @@
 let a = 0, b = 0;
 function next() { return ++a; }
 function val() { return ++b; }
-console.log(Object.prototype.hasOwnProperty.call({ [val()]: 'x' }, next()) ? 'yes' : 'no');
+console.log(Object.hasOwn({ [val()]: 'x' }, next()) ? 'yes' : 'no');
 console.log(`a=${a} b=${b}`);

yes
a=1 b=1

--- orig.js	2026-10-22 14:28:30.491417733 -0400
+++ fixed.js	2026-10-22 14:28:33.180394650 -0400
@@ -1,6 +1,6 @@
 "use strict";
 try {
-  console.log(Object.prototype.hasOwnProperty.call(null, 'x'));
+  console.log(Object.hasOwn(null, 'x'));
 } catch (e) {
   console.log(e.name);
 }

TypeError
TypeError

--- orig.js	2026-10-22 14:28:30.492417725 -0400
+++ fixed.js	2026-10-22 14:28:35.010379316 -0400
@@ -1,7 +1,7 @@
 async function* gen() {
   let obj = {};
   obj[await Promise.resolve('key')] = 1;
-  if (Object.prototype.hasOwnProperty.call(obj, await Promise.resolve('key'))) {
+  if (Object.hasOwn(obj, await Promise.resolve('key'))) {
     yield 1;
   }
 }

1

--- orig.js	2026-10-22 14:28:30.493417716 -0400
+++ fixed.js	2026-10-22 14:28:34.948379833 -0400
@@ -1,5 +1,5 @@
 let obj = { a: 1 };
 let result = typeof Object.hasOwn === 'function'
   ? Object.hasOwn(obj, 'a')
-  : Object.prototype.hasOwnProperty.call(obj, 'a');
+  : Object.hasOwn(obj, 'a');
 console.log(result); // prints true only if polyfilled or modern

true

--- orig.js	2026-10-22 14:28:30.493417716 -0400
+++ fixed.js	2026-10-22 14:28:33.760389761 -0400
@@ -1,6 +1,6 @@
 outer: {
   let obj = { x: 1 };
-  if (Object.prototype.hasOwnProperty.call(obj, 'x')) {
+  if (Object.hasOwn(obj, 'x')) {
     console.log('found');
     break outer;
   }

found
done

--- orig.js	2026-10-22 14:28:30.494417707 -0400
+++ fixed.js	2026-10-22 14:28:35.028379168 -0400
@@ -2,7 +2,7 @@
 let re = /a/g;
 re.lastIndex = 0;
 obj[re.exec('ba')] = true; // sets obj['a'] = true
-if (Object.prototype.hasOwnProperty.call(obj, re.exec('ba')[0])) {
+if (Object.hasOwn(obj, re.exec('ba')[0])) {
   console.log('has');
 } else {
   console.log('missing');

--- orig.js	2026-10-22 14:28:34.845380691 -0400
+++ fixed.js	2026-10-22 14:28:36.894363861 -0400
@@ -1,4 +1,4 @@
 let obj = { prop: 42 };
-let has = Object.prototype.hasOwnProperty.call(obj, 'prop'); // keep this comment
+let has = Object.hasOwn(obj, 'prop'); // keep this comment
 console.log(has); // should print true
 // Expected output: true then comment about keeping

true

--- orig.js	2026-10-22 14:28:34.880380400 -0400
+++ fixed.js	2026-10-22 14:28:38.593350204 -0400
@@ -2,7 +2,7 @@
   static staticField;
   static {
     let tmp = { prop: 1 };
-    C.staticField = Object.prototype.hasOwnProperty.call(tmp, 'prop') ? 'yes' : 'no';
+    C.staticField = Object.hasOwn(tmp, 'prop') ? 'yes' : 'no';
   }
   instanceField = Object.hasOwn(C.prototype, 'instanceField') ? 1 : 0;
 }

yes
0

--- orig.js	2026-10-22 14:28:44.968301252 -0400
+++ fixed.js	2026-10-22 14:28:49.334269846 -0400
@@ -1,7 +1,7 @@
 let o = {a: 1}; let x;
 function getObj() { return x; }
 console.log(getObj()?.a ?? 'missing');
-if (Object.prototype.hasOwnProperty.call(getObj(), 'a')) {
+if (Object.hasOwn(getObj(), 'a')) {
   console.log('has own');
 } else {
   console.log('does not have own');

missing

--- orig.js	2026-10-22 14:28:44.969301245 -0400
+++ fixed.js	2026-10-22 14:28:49.266270321 -0400
@@ -1,6 +1,6 @@
 'use strict';
 try {
-  Object.prototype.hasOwnProperty.call(null, 'x');
+  Object.hasOwn(null, 'x');
 } catch (e) {
   console.log(e.name + ': ' + e.message);
 }

TypeError: Cannot convert undefined or null to object
TypeError: Cannot convert undefined or null to object

--- orig.js	2026-10-22 14:28:44.970301237 -0400
+++ fixed.js	2026-10-22 14:28:48.139278270 -0400
@@ -1,5 +1,5 @@
 let o = {a: 1};
-let result = !Object.prototype.hasOwnProperty.call(o, 'a') && 0;
+let result = !Object.hasOwn(o, 'a') && 0;
 console.log('Result:', result);
 result = !Object.hasOwn(o, 'a') && 0;
 console.log('Result after fix:', result);

Result: false
Result after fix: false

--- orig.js	2026-10-22 14:28:44.970301237 -0400
+++ fixed.js	2026-10-22 14:28:49.287270174 -0400
@@ -2,12 +2,12 @@
   let o = {x: 1};
   switch (o.x) {
     case 1:
-      function inner() { return Object.prototype.hasOwnProperty.call(o, 'x'); }
+      function inner() { return Object.hasOwn(o, 'x'); }
       console.log(inner());
       break;
   }
   label: {
-    if (Object.prototype.hasOwnProperty.call(o, 'x')) {
+    if (Object.hasOwn(o, 'x')) {
       break label;
     }
     console.log('should not reach');

true

--- orig.js	2026-10-22 14:28:44.970301237 -0400
+++ fixed.js	2026-10-22 14:28:49.312269999 -0400
@@ -1,11 +1,11 @@
 for (var i = 0; i < 2; i++) {
   var o = {a: i};
-  if (Object.prototype.hasOwnProperty.call(o, 'a')) {
+  if (Object.hasOwn(o, 'a')) {
     console.log('loop', i, 'has a');
   }
 }
 console.log('o after loop:', typeof o);
-if (Object.prototype.hasOwnProperty.call(o, 'a')) {
+if (Object.hasOwn(o, 'a')) {
   console.log('o has a');
 } else {
   console.log('o does not have a');

loop 0 has a
loop 1 has a
o after loop: object
o has a

--- orig.js	2026-10-22 14:28:44.971301230 -0400
+++ fixed.js	2026-10-22 14:28:47.051286053 -0400
@@ -2,8 +2,8 @@
 if (typeof Object.hasOwn !== 'function') {
   console.log('Object.hasOwn not available, simulating old engine');
   // We still call the original to show it works
-  console.log(Object.prototype.hasOwnProperty.call(o, 'a'));
+  console.log(Object.hasOwn(o, 'a'));
 } else {
-  console.log(Object.prototype.hasOwnProperty.call(o, 'a'));
+  console.log(Object.hasOwn(o, 'a'));
   console.log(Object.hasOwn(o, 'a'));
 }

true
true

--- orig.js	2026-10-22 14:28:49.221270635 -0400
+++ fixed.js	2026-10-22 14:28:51.297256273 -0400
@@ -1,5 +1,5 @@
 let o = {a: 1};
-if (Object.prototype.hasOwnProperty.call(o, 'a')) { // check if a exists
+if (Object.hasOwn(o, 'a')) { // check if a exists
   console.log('yes');
 } // end if
 console.log('done');

yes
done

--- orig.js	2026-10-22 14:28:49.738267023 -0400
+++ fixed.js	2026-10-22 14:28:52.357249087 -0400
@@ -6,7 +6,7 @@
   configurable: true
 });
 console.log('Before check, val =', val);
-if (Object.prototype.hasOwnProperty.call(obj, 'prop')) {
+if (Object.hasOwn(obj, 'prop')) {
   console.log('Has own prop');
 }
 console.log('After check, val =', val);

Before check, val = 42
Has own prop
After check, val = 42