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,133 @@
+# 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
+
+### canFillWithFunction
+
+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",
+	{
+		"canFillWithFunction": false
+	}
+]
+```
+
+with `canFillWithFunction: false`, this would fail:
+
+```js
+new Array(3).fill(function () {})
+```

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/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';

rules/no-array-fill-with-reference-type.js

@@ -0,0 +1,184 @@
+import {isFunction} from './ast/index.js';
+
+// @ts-check
+const MESSAGE_ID_ERROR = 'no-array-fill-with-reference-type/error';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Avoid using `{{actual}}` with reference type{{type}}. Use `Array.from({ ... }, () => { ... })` instead to ensure independent instances.',
+};
+
+const debugging = false;
+const log = (...arguments_) => debugging && console.log(...arguments_);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		const isArrayFill = node.callee.type === 'MemberExpression'
+			&& ((node.callee.object.callee?.name === 'Array') || (context.sourceCode.getText(node.callee.object.callee) === 'Array.from'))
+			&& node.callee.property.name === 'fill'
+			&& node.arguments.length > 0;
+
+		log('isArrayFill:', isArrayFill);
+
+		if (!isArrayFill) {
+			return;
+		}
+
+		const fillArgument = node.arguments[0];
+		log('fillArgument:', fillArgument);
+
+		if (!isReferenceType(fillArgument, context)) {
+			return;
+		}
+
+		const actual = context.sourceCode.getText(node.callee.object.callee) === 'Array.from' ? 'Array.from().fill()' : 'Array.fill()';
+		const type = getType(fillArgument);
+
+		return {
+			node: fillArgument,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				actual,
+				type: type ? ` (${type})` : '',
+			},
+		};
+	},
+});
+
+/**
+
+ @param {*} fillArgument
+ @returns {string}
+ */
+function getType(fillArgument) {
+	let type = '';
+
+	switch (fillArgument.type) {
+		case 'ObjectExpression': {
+			type = 'Object';
+			break;
+		}
+
+		case 'ArrayExpression': {
+			type = 'Array';
+			break;
+		}
+
+		case 'NewExpression': {
+			type = `new ${fillArgument.callee.name}()`;
+			break;
+		}
+
+		case 'FunctionExpression':
+		case 'ArrowFunctionExpression': {
+			type = 'Function';
+			break;
+		}
+
+		default: {
+			if (fillArgument.type === 'Literal' && fillArgument.regex) {
+				type = 'RegExp';
+			} else if (fillArgument.type === 'Identifier') {
+				type = `variable (${fillArgument.name})`;
+			}
+		}
+	}
+
+	return type;
+}
+
+/**
+ @param {*} node
+ @param {import('eslint').Rule.RuleContext} context
+ @returns
+ */
+function isReferenceType(node, context) {
+	if (!node) {
+		return false;
+	}
+
+	// For null, number, string, boolean.
+	if (node.type === 'Literal') {
+		// Exclude regular expression literals (e.g., `/pattern/`, which are objects despite being literals).
+		return node.regex !== undefined;
+	}
+
+	// For template literals.
+	if (node.type === 'TemplateLiteral') {
+		return false;
+	}
+
+	// For variable identifiers (recursively check its declaration).
+	if (node.type === 'Identifier') {
+		const {variables} = context.sourceCode.getScope(node);
+		const variable = variables.find(v => v.name === node.name);
+		const definitionNode = variable?.defs[0].node;
+
+		log('variables:', variables);
+		log('variable:', variable);
+		log('variable.defs[0].node:', definitionNode);
+
+		if (!variable || !definitionNode) {
+			return false;
+		}
+
+		// Check `const foo = []; Array(3).fill(foo);`
+		if (definitionNode.type === 'VariableDeclarator') {
+			return isReferenceType(definitionNode.init, context);
+		}
+
+		return isReferenceType(definitionNode, context);
+	}
+
+	// Symbol (such as `Symbol('name')`)
+	if (node.type === 'CallExpression' && node.callee.name === 'Symbol') {
+		const {variables} = context.sourceCode.getScope(node);
+
+		log('variables 2:', variables);
+		if (!variables || variables.length === 0) {
+			// Variable declaration not found; it might be a global variable.
+			return false;
+		}
+	}
+
+	const options = {
+		// Not check for function expressions by default because it is rare to fill an array with a function and add properties to it.
+		canFillWithFunction: true,
+		...context.options[0],
+	};
+
+	if (options.canFillWithFunction && isFunction(node)) {
+		return false;
+	}
+
+	// Other cases: objects, arrays, new expressions, regular expressions, etc.
+	return true;
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			canFillWithFunction: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallows using `Array.fill()` or `Array.from().fill()` with **reference types** to prevent unintended shared references across array elements.',
+			recommended: true,
+		},
+		schema,
+		defaultOptions: [{}],
+		messages,
+	},
+};
+
+export default config;

test/catch-error-name.js

@@ -364,7 +364,7 @@
 			`,
 			errors: [generateError('err', 'error')],
 		}),
 		// TODO: this could fix to `error`
 		invalidTestCase({
 			code: outdent`
 				obj.then(
@@ -496,6 +496,9 @@
 				obj.then(err => {}, error => {});
 				obj.then(err => {}, error => {});
 			`,
+
+			// It's safe due to no mutation to `errors`
+			// eslint-disable-next-line unicorn/no-array-fill-with-reference-type
 			errors: Array.from({length: 4}).fill(generateError('err', 'error')),
 		},
 
@@ -635,7 +638,7 @@
 			`,
 			errors: [generateError('_', 'error')],
 		}),
 		// TODO: this should fix to `error`, not `error_`
 		invalidTestCase({
 			code: outdent`
 				const handleError = error => {