feat: add new rule no-array-fill-with-reference-type without fix solution

docs/new-rule.md

@@ -2,6 +2,7 @@
 
 ## Prerequisite
 
+- Use npm to install.
 - Ensure ESLint doesn't already have the [rule built-in](https://eslint.org/docs/rules/).
 - [Read the ESLint docs on creating a new rule.](https://eslint.org/docs/developer-guide/working-with-rules)
 - Look at the commit for how previous rules were added as inspiration. For example, the [`no-unused-properties` rule](https://github.com/sindresorhus/eslint-plugin-unicorn/commit/0179443f24326fb01342a0bf799f7ac66e0e2c23).
@@ -17,7 +18,7 @@ Use the [`astexplorer` site](https://astexplorer.net) with the `espree` parser a
 - Open “rules/{RULE_ID}.js” and implement the rule logic.
 - Add the correct [`meta.type`](https://eslint.org/docs/developer-guide/working-with-rules#rule-basics) to the rule.
 - Open “docs/rules/{RULE_ID}.js” and write some documentation.
-- Double check `configs/recommended.js` and `readme.md`, make sure the new rule is correctly added.
+- Double check `readme.md`, make sure the new rule is correctly added.
 - Run `npm test` to ensure the tests pass.
 - Run `npm run integration` to run the rules against real projects to ensure your rule does not fail on real-world code.
 - Open a pull request with a title in exactly the format `` Add `rule-name` rule ``, for example, `` Add `no-unused-properties` rule ``.

docs/rules/no-array-fill-with-reference-type.md

@@ -0,0 +1,161 @@
+# Disallows using `Array.fill()` or `Array.from().fill()` with **reference types** to prevent unintended shared references across array elements
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/sindresorhus/eslint-plugin-unicorn#recommended-config).
+
+<!-- end auto-generated rule header -->
+<!-- Do not manually modify this header. Run: `npm run fix:eslint-docs` -->
+
+Disallows using `Array.fill()` or `Array.from().fill()` with **reference types** (objects, arrays, functions, Maps, Sets, RegExp literals, etc.) to prevent unintended shared references across array elements. Encourages `Array.from()` or explicit iteration for creating independent instances.
+
+**Reason**:
+`Array(len).fill(value)` fills all elements with the **same reference** if `value` is non-primitive (e.g., `fill([])`), leading to bugs when one element’s mutations affect others.
+
+**Key Features**:
+
+- Catches **all reference types**: Objects, Arrays, Functions, `new` expressions, RegExp literals, and variables referencing them.
+- **Clear error messages**: Identifies the reference type (e.g., `Object`, `RegExp`, `variable (name)`).
+
+**Note**: Primitive types (`number`, `string`, `boolean`, `null`, `undefined`, `symbol`, `bigint`) are always allowed.
+
+## Examples
+
+```js
+// ❌ Object
+new Array(3).fill({});
+Array(3).fill({});
+Array.from({ length: 3 }).fill({});
+
+// ✅
+Array.from({ length: 3 }, () => ({}));
+```
+
+```js
+// ❌ Array
+new Array(3).fill([]);
+Array(3).fill([]);
+Array.from({ length: 3 }).fill([]);
+
+// ✅
+Array.from({ length: 3 }, () => []);
+```
+
+```js
+// ❌ Map
+new Array(3).fill(new Map());
+Array(3).fill(new Map());
+Array.from({ length: 3 }).fill(new Map());
+
+// ✅
+Array.from({ length: 3 }, () => new Map());
+```
+
+```js
+// ❌ Date
+new Array(3).fill(new Date());
+Array(3).fill(new Date());
+Array.from({ length: 3 }).fill(new Date());
+
+// ✅
+Array.from({ length: 3 }, () => new Date());
+```
+
+```js
+// ❌ Class
+class BarClass {};
+new Array(3).fill(new BarClass());
+Array(3).fill(new BarClass());
+Array.from({ length: 3 }).fill(new BarClass());
+
+// ✅
+Array.from({ length: 3 }, () => new BarClass());
+```
+
+```js
+// ❌ Function
+new Array(3).fill(function () {})
+Array(3).fill(function () {})
+Array.from({ length: 3 }).fill(function () {});
+
+// ✅
+Array.from({ length: 3 }, () => function () {});
+```
+
+```js
+// ❌ RegExp literal
+new Array(3).fill(/pattern/);
+Array(3).fill(/pattern/);
+Array.from({ length: 3 }).fill(/pattern/);
+
+// ✅
+Array.from({ length: 3 }, () => /pattern/);
+```
+
+```js
+const box = []
+
+// ❌ Shared reference
+new Array(3).fill(box);
+Array(3).fill(box);
+Array.from({ length: 3 }).fill(box);
+
+// ✅
+Array.from({ length: 3 }, () => []);
+```
+
+## Options
+
+### allowFunctions
+
+Type: `boolean`\
+Default: `true`
+
+Should check function when filling an array?
+
+This would pass by default:
+
+```js
+new Array(3).fill(function () {})
+```
+
+```js
+"unicorn/catch-error-name": [
+	"error",
+	{
+		"allowFunctions": false
+	}
+]
+```
+
+with `allowFunctions: false`, this would fail:
+
+```js
+new Array(3).fill(function () {})
+```
+
+### allowRegularExpressions
+
+Type: `boolean`\
+Default: `true`
+
+Should check function when filling an array?
+
+This would pass by default:
+
+```js
+new Array(3).fill(/pattern/)
+```
+
+```js
+"unicorn/catch-error-name": [
+	"error",
+	{
+		"allowRegularExpressions": false
+	}
+]
+```
+
+with `allowRegularExpressions: false`, this would fail:
+
+```js
+new Array(3).fill(/pattern/)
+```

package.json

@@ -95,6 +95,7 @@
 		"eslint-remote-tester-repositories": "^2.0.1",
 		"espree": "^10.4.0",
 		"listr2": "^8.3.3",
+		"lodash-es": "^4.17.21",
 		"markdownlint-cli": "^0.45.0",
 		"memoize": "^10.1.0",
 		"nano-spawn": "^1.0.2",

readme.md

@@ -77,6 +77,7 @@ export default [
 | [no-accessor-recursion](docs/rules/no-accessor-recursion.md)                                     | Disallow recursive access to `this` within getters and setters.                                                                                                                                                   | ✅  |    |    |
 | [no-anonymous-default-export](docs/rules/no-anonymous-default-export.md)                         | Disallow anonymous functions and classes as the default export.                                                                                                                                                   | ✅  |    | 💡 |
 | [no-array-callback-reference](docs/rules/no-array-callback-reference.md)                         | Prevent passing a function reference directly to iterator methods.                                                                                                                                                | ✅  |    | 💡 |
+| [no-array-fill-with-reference-type](docs/rules/no-array-fill-with-reference-type.md)             | Disallows using `Array.fill()` or `Array.from().fill()` with **reference types** to prevent unintended shared references across array elements.                                                                   | ✅  |    |    |
 | [no-array-for-each](docs/rules/no-array-for-each.md)                                             | Prefer `for…of` over the `forEach` method.                                                                                                                                                                        | ✅  | 🔧 | 💡 |
 | [no-array-method-this-argument](docs/rules/no-array-method-this-argument.md)                     | Disallow using the `this` argument in array methods.                                                                                                                                                              | ✅  | 🔧 | 💡 |
 | [no-array-reduce](docs/rules/no-array-reduce.md)                                                 | Disallow `Array#reduce()` and `Array#reduceRight()`.                                                                                                                                                              | ✅  |    |    |

rules/ast/is-member-expression.d.ts

@@ -0,0 +1,16 @@
+import type { Node, MemberExpression } from "estree";
+
+export default function isMemberExpression(
+	node: Node,
+	options?:
+		| {
+				property?: string;
+				properties?: string[];
+				object?: string;
+				objects?: string[];
+				optional?: boolean;
+				computed?: boolean;
+		  }
+		| string
+		| string[]
+): node is MemberExpression;

rules/ast/is-member-expression.js

@@ -1,5 +1,7 @@
+// @ts-check
 /* eslint-disable complexity */
 /**
+@param {ESTreeNode} node
 @param {
 	{
 		property?: string,
@@ -10,7 +12,7 @@
 		computed?: boolean
 	} | string | string[]
 } [options]
-@returns {string}
+@returns {boolean}
 */
 export default function isMemberExpression(node, options) {
 	if (node?.type !== 'MemberExpression') {
@@ -96,3 +98,5 @@ export default function isMemberExpression(node, options) {
 
 	return true;
 }
+
+/** @typedef {import('estree').Node} ESTreeNode */

rules/index.js

@@ -21,6 +21,7 @@ export {default as 'no-abusive-eslint-disable'} from './no-abusive-eslint-disabl
 export {default as 'no-accessor-recursion'} from './no-accessor-recursion.js';
 export {default as 'no-anonymous-default-export'} from './no-anonymous-default-export.js';
 export {default as 'no-array-callback-reference'} from './no-array-callback-reference.js';
+export {default as 'no-array-fill-with-reference-type'} from './no-array-fill-with-reference-type.js';
 export {default as 'no-array-for-each'} from './no-array-for-each.js';
 export {default as 'no-array-method-this-argument'} from './no-array-method-this-argument.js';
 export {default as 'no-array-reduce'} from './no-array-reduce.js';