Add Object.create(null) exemption to no-null rule and tests

Agent-Logs-Url: https://github.com/microsoft/rushstack/sessions/88c04cb4-f442-4fe2-8991-6a20aa3c6f9b

Co-authored-by: dmichon-msft <26827560+dmichon-msft@users.noreply.github.com>

Author: Copilot

eslint/eslint-plugin/src/no-null.ts

@@ -2,6 +2,7 @@
 // See LICENSE in the project root for license information.
 
 import type { TSESTree, TSESLint } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
 type MessageIds = 'error-usage-of-null';
 type Options = [];
@@ -27,15 +28,29 @@ const noNullRule: TSESLint.RuleModule<MessageIds, Options> = {
         // Is it a "null" literal?
         if (node.value === null) {
           // Does the "null" appear in a comparison such as "if (x === null)"?
-          let isComparison: boolean = false;
-          if (node.parent && node.parent.type === 'BinaryExpression') {
+          if (node.parent && node.parent.type === AST_NODE_TYPES.BinaryExpression) {
             const operator: string = node.parent.operator;
-            isComparison = operator === '!==' || operator === '===' || operator === '!=' || operator === '==';
+            if (operator === '!==' || operator === '===' || operator === '!=' || operator === '==') {
+              return;
+            }
           }
 
-          if (!isComparison) {
-            context.report({ node, messageId: 'error-usage-of-null' });
+          // Is this "Object.create(null)"?  This is the correct pattern for creating
+          // a dictionary object that does not inherit members from the Object prototype.
+          if (
+            node.parent &&
+            node.parent.type === AST_NODE_TYPES.CallExpression &&
+            node.parent.arguments[0] === node &&
+            node.parent.callee.type === AST_NODE_TYPES.MemberExpression &&
+            node.parent.callee.object.type === AST_NODE_TYPES.Identifier &&
+            node.parent.callee.object.name === 'Object' &&
+            node.parent.callee.property.type === AST_NODE_TYPES.Identifier &&
+            node.parent.callee.property.name === 'create'
+          ) {
+            return;
           }
+
+          context.report({ node, messageId: 'error-usage-of-null' });
         }
       }
     };

eslint/eslint-plugin/src/test/no-null.test.ts

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+import type { RuleTester } from '@typescript-eslint/rule-tester';
+
+import { getRuleTesterWithoutProject } from './ruleTester';
+import { noNullRule } from '../no-null';
+
+const ruleTester: RuleTester = getRuleTesterWithoutProject();
+
+ruleTester.run('no-null', noNullRule, {
+  invalid: [
+    {
+      // Assigning null to a variable
+      code: 'let x = null;',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Passing null as a function argument (not Object.create)
+      code: 'foo(null);',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Returning null
+      code: 'function f() { return null; }',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Using null in a ternary
+      code: 'let x = true ? null : undefined;',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Using null as a second argument to Object.create
+      code: 'Object.create(proto, null);',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Using null on a different method of Object
+      code: 'Object.assign(null);',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Using null with a different object's create method
+      code: 'NotObject.create(null);',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    },
+    {
+      // Computed property access: Object["create"](null) is NOT exempted
+      code: 'Object["create"](null);',
+      errors: [{ messageId: 'error-usage-of-null' }]
+    }
+  ],
+  valid: [
+    {
+      // Comparison with === is allowed
+      code: 'if (x === null) {}'
+    },
+    {
+      // Comparison with !== is allowed
+      code: 'if (x !== null) {}'
+    },
+    {
+      // Comparison with == is allowed
+      code: 'if (x == null) {}'
+    },
+    {
+      // Comparison with != is allowed
+      code: 'if (x != null) {}'
+    },
+    {
+      // Object.create(null) is allowed for creating prototype-less dictionary objects
+      code: 'const dict = Object.create(null);'
+    },
+    {
+      // Object.create(null) with type annotation
+      code: 'const dict: Record<string, number> = Object.create(null);'
+    },
+    {
+      // Object.create(null) inside a function
+      code: 'function createDict() { return Object.create(null); }'
+    }
+  ]
+});