feat: add prefer-object-has-own rule

docs/rules/prefer-object-has-own.md

@@ -0,0 +1,55 @@
+# Prefer `Object.hasOwn()` over `Object.prototype.hasOwnProperty.call()` (prefer-object-has-own)
+
+`Object.hasOwn()` is more accessible than `Object.prototype.hasOwnProperty.call()`.
+
+It is recommended over `Object#hasOwnProperty()` because it works for objects created using `Object.create(null)` and with objects that have overridden the inherited `hasOwnProperty()` method.
+
+```js
+const foo = {
+  hasOwnProperty: function() {
+    return false;
+  },
+  bar: 'Hello World'
+};
+
+console.log(Object.hasOwn(foo, 'bar')); // true - re-implementation of hasOwnProperty() does not affect Object
+
+const bar = Object.create(null);
+bar.prop = 'exists';
+
+console.log(Object.hasOwn(bar, 'prop')); // true - works irrespective of how the object is created.
+```
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```js
+/*eslint prefer-object-has-own: "error"*/
+
+Object.prototype.hasOwnProperty.call(obj, "a");
+
+Object.hasOwnProperty.call(obj, "a");
+
+({}).hasOwnProperty.call(obj, "a");
+
+const hasProperty = Object.prototype.hasOwnProperty.call(object, property);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+/*eslint prefer-object-has-own: "error"*/
+
+Object.hasOwn(obj, "a");
+
+const hasProperty = Object.hasOwn(object, property);
+```
+
+## When Not To Use It
+
+This rule should not be used unless ES2022 is supported in your codebase.
+
+## Further Reading
+
+* [Object.hasOwn()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)

lib/rules/index.js

@@ -255,6 +255,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "prefer-exponentiation-operator": () => require("./prefer-exponentiation-operator"),
     "prefer-named-capture-group": () => require("./prefer-named-capture-group"),
     "prefer-numeric-literals": () => require("./prefer-numeric-literals"),
+    "prefer-object-has-own": () => require("./prefer-object-has-own"),
     "prefer-object-spread": () => require("./prefer-object-spread"),
     "prefer-promise-reject-errors": () => require("./prefer-promise-reject-errors"),
     "prefer-reflect": () => require("./prefer-reflect"),

lib/rules/prefer-object-has-own.js

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call()
+ * @author Nitin Kumar
+ * @author Gautam Arora
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+/**
+ * Checks to see if a property name 'Object' or an empty 'ObjectExpression' ({}) exists in the subtree.
+ * @param {ASTnode} node to evalutate.
+ * @returns {boolean} `true` if object property exists, `false` otherwise.
+ */
+function hasLeftHandObject(node) {
+    if (!node.object) {
+        return false;
+    }
+
+    /*
+     * ({}).hasOwnProperty.call(obj, prop) - `true`
+     * ({ foo }.hasOwnProperty.call(obj, prop)) - `false`, object literal should be empty
+     */
+    if (node.object.type === "ObjectExpression" && node.object.properties.length === 0) {
+        return true;
+    }
+
+    const objectPropertyName = astUtils.getStaticPropertyName(node.object);
+    const objectNodeToCheck = objectPropertyName === "prototype" ? node.object.object : node.object;
+
+    if (objectNodeToCheck.name === "Object") {
+        return true;
+    }
+
+    return false;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description:
+                "disallow use of `Object.prototype.hasOwnProperty.call())` and prefer use of `Object.hasOwn()`",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-object-has-own"
+        },
+        schema: [],
+        messages: {
+            useHasOwn: "Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'."
+        },
+        fixable: "code"
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!(node.callee.type === "MemberExpression" && node.callee.object.type === "MemberExpression")) {
+                    return;
+                }
+
+                const calleePropertyName = astUtils.getStaticPropertyName(node.callee);
+                const objectPropertyName = astUtils.getStaticPropertyName(node.callee.object);
+                const isObject = node.callee.object && hasLeftHandObject(node.callee.object);
+
+                // check `Object` scope
+                const scope = context.getScope();
+                const variable = astUtils.getVariableByName(scope, "Object");
+
+                if (
+                    calleePropertyName === "call" &&
+                    objectPropertyName === "hasOwnProperty" &&
+                    isObject &&
+                    variable && variable.scope.type === "global"
+                ) {
+                    context.report({
+                        node,
+                        messageId: "useHasOwn",
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+
+                            if (sourceCode.getCommentsInside(node.callee).length > 0) {
+                                return null;
+                            }
+
+                            return fixer.replaceText(node.callee, "Object.hasOwn");
+                        }
+                    });
+                }
+            }
+        };
+    }
+};