@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-immediate-mutation.js

@@ -1,778 +0,0 @@
-import {
-	hasSideEffect,
-	isCommaToken,
-	isSemicolonToken,
-	findVariable,
-} from '@eslint-community/eslint-utils';
-import {
-	isMethodCall,
-	isMemberExpression,
-	isNewExpression,
-} from './ast/index.js';
-import {
-	removeExpressionStatement,
-	removeArgument,
-} from './fix/index.js';
-import {
-	getNextNode,
-	getCallExpressionArgumentsText,
-	getParenthesizedText,
-	getVariableIdentifiers,
-	getNewExpressionTokens,
-	isNewExpressionWithParentheses,
-} from './utils/index.js';
-
-/**
-@import {TSESTree as ESTree} from '@typescript-eslint/types';
-@import * as ESLint from 'eslint';
-*/
-
-const MESSAGE_ID_ERROR = 'error';
-const MESSAGE_ID_SUGGESTION_ARRAY = 'suggestion/array';
-const MESSAGE_ID_SUGGESTION_OBJECT = 'suggestion/object';
-const MESSAGE_ID_SUGGESTION_OBJECT_ASSIGN = 'suggestion/object-assign';
-const MESSAGE_ID_SUGGESTION_SET = 'suggestion/set';
-const MESSAGE_ID_SUGGESTION_MAP = 'suggestion/map';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Immediate mutation on {{objectType}} is not allowed.',
-	[MESSAGE_ID_SUGGESTION_ARRAY]: '{{operation}} the elements to the {{assignType}}.',
-	[MESSAGE_ID_SUGGESTION_OBJECT]: 'Move this property to the {{assignType}}.',
-	[MESSAGE_ID_SUGGESTION_OBJECT_ASSIGN]: '{{description}} the {{assignType}}.',
-	[MESSAGE_ID_SUGGESTION_SET]: 'Move the element to the {{assignType}}.',
-	[MESSAGE_ID_SUGGESTION_MAP]: 'Move the entry to the {{assignType}}.',
-};
-
-const hasVariableInNodes = (variable, nodes, context) => {
-	const {sourceCode} = context;
-	const identifiers = getVariableIdentifiers(variable);
-	return nodes.some(node => {
-		const range = sourceCode.getRange(node);
-		return identifiers.some(identifier => {
-			const [start, end] = sourceCode.getRange(identifier);
-			return start >= range[0] && end <= range[1];
-		});
-	});
-};
-
-function isCallExpressionWithOptionalArrayExpression(newExpression, names) {
-	if (!isNewExpression(
-		newExpression,
-		{names, maximumArguments: 1},
-	)) {
-		return false;
-	}
-
-	// `new Set();` and `new Set([]);`
-	const [iterable] = newExpression.arguments;
-	return (!iterable || iterable.type === 'ArrayExpression');
-}
-
-function * removeExpressionStatementAfterAssign(expressionStatement, context, fixer) {
-	const tokenBefore = context.sourceCode.getTokenBefore(expressionStatement);
-	const shouldPreserveSemiColon = !isSemicolonToken(tokenBefore);
-	yield removeExpressionStatement(expressionStatement, context, fixer, shouldPreserveSemiColon);
-}
-
-function appendListTextToArrayExpressionOrObjectExpression(
-	context,
-	fixer,
-	arrayOrObjectExpression,
-	listText,
-) {
-	const {sourceCode} = context;
-	const [
-		penultimateToken,
-		closingBracketToken,
-	] = sourceCode.getLastTokens(arrayOrObjectExpression, 2);
-	const list = arrayOrObjectExpression.type === 'ArrayExpression'
-		? arrayOrObjectExpression.elements
-		: arrayOrObjectExpression.properties;
-	const shouldInsertComma = list.length > 0 && !isCommaToken(penultimateToken);
-
-	return fixer.insertTextBefore(
-		closingBracketToken,
-		`${shouldInsertComma ? ',' : ''} ${listText}`,
-	);
-}
-
-function * appendElementsTextToSetConstructor({
-	context,
-	fixer,
-	newExpression,
-	elementsText,
-	nextExpressionStatement,
-}) {
-	if (isNewExpressionWithParentheses(newExpression, context)) {
-		const [setInitialValue] = newExpression.arguments;
-		if (setInitialValue) {
-			yield appendListTextToArrayExpressionOrObjectExpression(context, fixer, setInitialValue, elementsText);
-		} else {
-			const {
-				openingParenthesisToken,
-			} = getNewExpressionTokens(newExpression, context);
-			yield fixer.insertTextAfter(openingParenthesisToken, `[${elementsText}]`);
-		}
-	} else {
-		/*
-		The new expression doesn't have parentheses
-		```
-		const set = (( new (( Set )) ));
-		set.add(1);
-		```
-		*/
-		yield fixer.insertTextAfter(newExpression, `([${elementsText}])`);
-	}
-
-	yield * removeExpressionStatementAfterAssign(nextExpressionStatement, context, fixer);
-}
-
-function getObjectExpressionPropertiesText(objectExpression, context) {
-	const {sourceCode} = context;
-	const openingBraceToken = sourceCode.getFirstToken(objectExpression);
-	const [penultimateToken, closingBraceToken] = sourceCode.getLastTokens(objectExpression, 2);
-	const [, start] = sourceCode.getRange(openingBraceToken);
-	const [end] = sourceCode.getRange(isCommaToken(penultimateToken) ? penultimateToken : closingBraceToken);
-	return sourceCode.text.slice(start, end);
-}
-
-/**
-@typedef {ESTree.VariableDeclarator['init'] | ESTree.AssignmentExpression['right']} ValueNode
-@typedef {(information: ViolationCaseInformation, arguments: any)} GetFix
-@typedef {Parameters<ESLint.Rule.RuleContext['report']>[0]} Problem
-@typedef {(information: ViolationCaseInformation) => ESTree.Node} GetProblematicNode
-@typedef {{
-	context: ESLint.Rule.RuleContext,
-	variable: ESLint.Scope.Variable,
-	variableNode: ESTree.Identifier,
-	valueNode: ValueNode,
-	statement: ESTree.VariableDeclaration | ESTree.ExpressionStatement,
-	nextExpressionStatement: ESTree.ExpressionStatement,
-	assignType: 'assignment' | 'declaration',
-	getFix: GetFix,
-}} ViolationCaseInformation
-@typedef {{
-	testValue: (value: ValueNode) => boolean,
-	getProblematicNode: GetProblematicNode,
-	getProblem: (node: ReturnType<GetProblematicNode>, information: ViolationCaseInformation) => Problem,
-	getFix: GetFix,
-}} ViolationCase
-*/
-
-// `Array`
-/** @type {ViolationCase} */
-const arrayMutationSettings = {
-	testValue: value => value?.type === 'ArrayExpression',
-	getProblematicNode({
-		context,
-		variable,
-		nextExpressionStatement,
-	}) {
-		const callExpression = nextExpressionStatement.expression;
-
-		if (!(
-			isMethodCall(callExpression, {
-				object: variable.name,
-				methods: ['push', 'unshift'],
-				optionalMember: false,
-				optionalCall: false,
-			})
-			&& callExpression.arguments.length > 0
-		)) {
-			return;
-		}
-
-		if (hasVariableInNodes(variable, callExpression.arguments, context)) {
-			return;
-		}
-
-		return callExpression;
-	},
-	getProblem(callExpression, information) {
-		const {
-			context,
-			assignType,
-			getFix,
-		} = information;
-		const {sourceCode} = context;
-		const memberExpression = callExpression.callee;
-		const method = memberExpression.property;
-		const problem = {
-			node: memberExpression,
-			messageId: MESSAGE_ID_ERROR,
-			data: {objectType: 'array'},
-		};
-
-		const isPrepend = method.name === 'unshift';
-		const fix = getFix(information, {
-			callExpression,
-			isPrepend,
-		});
-
-		if (callExpression.arguments.some(element => hasSideEffect(element, sourceCode))) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION_ARRAY,
-					fix,
-					data: {operation: isPrepend ? 'Prepend' : 'Append', assignType},
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-	getFix: (
-		{
-			context,
-			valueNode: arrayExpression,
-			nextExpressionStatement,
-		},
-		{
-			callExpression,
-			isPrepend,
-		},
-	) => function * (fixer) {
-		const text = getCallExpressionArgumentsText(context, callExpression, /* includeTrailingComma */ false);
-
-		yield (
-			isPrepend
-				? fixer.insertTextAfter(
-					context.sourceCode.getFirstToken(arrayExpression),
-					`${text}, `,
-				)
-				: appendListTextToArrayExpressionOrObjectExpression(context, fixer, arrayExpression, text)
-		);
-
-		yield * removeExpressionStatementAfterAssign(
-			nextExpressionStatement,
-			context,
-			fixer,
-		);
-	},
-};
-
-// `Object` + `AssignmentExpression`
-/** @type {ViolationCase} */
-const objectWithAssignmentExpressionSettings = {
-	testValue: value => value?.type === 'ObjectExpression',
-	getProblematicNode({
-		context,
-		variable,
-		nextExpressionStatement,
-	}) {
-		const assignmentExpression = nextExpressionStatement.expression;
-		if (!(
-			assignmentExpression.type === 'AssignmentExpression'
-			&& assignmentExpression.operator === '='
-			&& isMemberExpression(assignmentExpression.left, {object: variable.name, optional: false})
-		)) {
-			return;
-		}
-
-		const value = assignmentExpression.right;
-		const memberExpression = assignmentExpression.left;
-		const {property} = memberExpression;
-
-		if (
-			hasVariableInNodes(
-				variable,
-				memberExpression.computed ? [property, value] : [value],
-				context,
-			)
-		) {
-			return;
-		}
-
-		return assignmentExpression;
-	},
-	getProblem(assignmentExpression, information) {
-		const {
-			context,
-			assignType,
-			getFix,
-		} = information;
-		const {sourceCode} = context;
-		const {
-			left: memberExpression,
-			right: value,
-		} = assignmentExpression;
-
-		const {property} = memberExpression;
-		const operatorToken = sourceCode.getTokenAfter(memberExpression, token => token.type === 'Punctuator' && token.value === assignmentExpression.operator);
-
-		const problem = {
-			node: assignmentExpression,
-			loc: {
-				start: sourceCode.getLoc(assignmentExpression).start,
-				end: sourceCode.getLoc(operatorToken).end,
-			},
-			messageId: MESSAGE_ID_ERROR,
-			data: {objectType: 'object'},
-		};
-		const fix = getFix(information, {
-			assignmentExpression,
-			memberExpression,
-			property,
-			value,
-		});
-
-		if (
-			(memberExpression.computed && hasSideEffect(property, sourceCode))
-			|| hasSideEffect(value, sourceCode)
-		) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION_OBJECT,
-					data: {assignType},
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-	getFix: (
-		{
-			context,
-			valueNode: objectExpression,
-			nextExpressionStatement,
-		},
-		{
-			memberExpression,
-			property,
-			value,
-		},
-	) => function * (fixer) {
-		let propertyText = getParenthesizedText(property, context);
-		if (memberExpression.computed) {
-			propertyText = `[${propertyText}]`;
-		}
-
-		const valueText = getParenthesizedText(value, context);
-
-		const text = `${propertyText}: ${valueText},`;
-		const [
-			penultimateToken,
-			closingBraceToken,
-		] = context.sourceCode.getLastTokens(objectExpression, 2);
-		const shouldInsertComma = objectExpression.properties.length > 0 && !isCommaToken(penultimateToken);
-
-		yield fixer.insertTextBefore(
-			closingBraceToken,
-			`${shouldInsertComma ? ',' : ''} ${text}`,
-		);
-
-		yield * removeExpressionStatementAfterAssign(
-			nextExpressionStatement,
-			context,
-			fixer,
-		);
-	},
-};
-
-// `Object` + `Object.assign()`
-/** @type {ViolationCase} */
-const objectWithObjectAssignSettings = {
-	testValue: value => value?.type === 'ObjectExpression',
-	getProblematicNode({
-		context,
-		variable,
-		nextExpressionStatement,
-	}) {
-		const callExpression = nextExpressionStatement.expression;
-
-		if (!isMethodCall(callExpression, {
-			object: 'Object',
-			method: 'assign',
-			minimumArguments: 2,
-			optionalMember: false,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		const [object, firstValue] = callExpression.arguments;
-
-		if (
-			!(object.type === 'Identifier' && object.name === variable.name)
-			|| firstValue.type === 'SpreadElement'
-			|| hasVariableInNodes(variable, [firstValue], context)
-		) {
-			return;
-		}
-
-		return callExpression;
-	},
-	getProblem(callExpression, information) {
-		const {
-			context,
-			assignType,
-			getFix,
-		} = information;
-		const {sourceCode} = context;
-		const [, firstValue] = callExpression.arguments;
-
-		const problem = {
-			node: callExpression.callee,
-			messageId: MESSAGE_ID_ERROR,
-			data: {objectType: 'object'},
-		};
-		const fix = getFix(information, {
-			callExpression,
-			firstValue,
-		});
-
-		if (hasSideEffect(firstValue, sourceCode)) {
-			const description = firstValue.type === 'ObjectExpression'
-				? 'Move properties to'
-				: 'Spread properties in';
-
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION_OBJECT_ASSIGN,
-					data: {description, assignType},
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-	getFix: (
-		{
-			context,
-			valueNode: objectExpression,
-			nextExpressionStatement,
-		},
-		{
-			callExpression,
-			firstValue,
-		},
-	) => function * (fixer) {
-		let text;
-		if (firstValue.type === 'ObjectExpression') {
-			if (firstValue.properties.length > 0) {
-				text = getObjectExpressionPropertiesText(firstValue, context);
-			}
-		} else {
-			text = `...${getParenthesizedText(firstValue, context)}`;
-		}
-
-		if (text) {
-			yield appendListTextToArrayExpressionOrObjectExpression(context, fixer, objectExpression, text);
-		}
-
-		if (callExpression.arguments.length !== 2) {
-			yield removeArgument(fixer, firstValue, context);
-
-			return;
-		}
-
-		yield * removeExpressionStatementAfterAssign(
-			nextExpressionStatement,
-			context,
-			fixer,
-		);
-	},
-};
-
-// `Set` and `WeakSet`
-/** @type {ViolationCase} */
-const setMutationSettings = {
-	testValue: value => isCallExpressionWithOptionalArrayExpression(value, ['Set', 'WeakSet']),
-	getProblematicNode({
-		context,
-		variable,
-		nextExpressionStatement,
-	}) {
-		let callExpression = nextExpressionStatement.expression;
-		if (callExpression.type === 'ChainExpression') {
-			callExpression = callExpression.expression;
-		}
-
-		if (!isMethodCall(callExpression, {
-			object: variable.name,
-			method: 'add',
-			argumentsLength: 1,
-			optionalMember: false,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		if (hasVariableInNodes(variable, callExpression.arguments, context)) {
-			return;
-		}
-
-		return callExpression;
-	},
-	getProblem(callExpression, information) {
-		const {
-			context,
-			assignType,
-			valueNode: newExpression,
-			getFix,
-		} = information;
-		const {sourceCode} = context;
-		const memberExpression = callExpression.callee;
-		const problem = {
-			node: memberExpression,
-			messageId: MESSAGE_ID_ERROR,
-			data: {objectType: `\`${newExpression.callee.name}\``},
-		};
-
-		const fix = getFix(information, {
-			callExpression,
-			newExpression,
-		});
-
-		if (callExpression.arguments.some(element => hasSideEffect(element, sourceCode))) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION_SET,
-					data: {assignType},
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-	getFix: (
-		{
-			context,
-			nextExpressionStatement,
-		},
-		{
-			callExpression,
-			newExpression,
-		},
-	) => fixer => {
-		const elementsText = getCallExpressionArgumentsText(
-			context,
-			callExpression,
-			/* IncludeTrailingComma */ false,
-		);
-		return appendElementsTextToSetConstructor({
-			context,
-			fixer,
-			newExpression,
-			elementsText,
-			nextExpressionStatement,
-		});
-	},
-};
-
-// `Map` and `WeakMap`
-/** @type {ViolationCase} */
-const mapMutationSettings = {
-	testValue: value => isCallExpressionWithOptionalArrayExpression(value, ['Map', 'WeakMap']),
-	getProblematicNode({
-		context,
-		variable,
-		nextExpressionStatement,
-	}) {
-		const callExpression = nextExpressionStatement.expression;
-
-		if (!isMethodCall(callExpression, {
-			object: variable.name,
-			method: 'set',
-			argumentsLength: 2,
-			optionalCall: false,
-		})) {
-			return;
-		}
-
-		if (hasVariableInNodes(variable, callExpression.arguments, context)) {
-			return;
-		}
-
-		return callExpression;
-	},
-	getProblem(callExpression, information) {
-		const {
-			context,
-			assignType,
-			valueNode: newExpression,
-			getFix,
-		} = information;
-		const {sourceCode} = context;
-		const memberExpression = callExpression.callee;
-		const problem = {
-			node: memberExpression,
-			messageId: MESSAGE_ID_ERROR,
-			data: {objectType: `\`${newExpression.callee.name}\``},
-		};
-
-		const fix = getFix(information, {
-			callExpression,
-			newExpression,
-		});
-
-		if (callExpression.arguments.some(element => hasSideEffect(element, sourceCode))) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION_MAP,
-					data: {assignType},
-					fix,
-				},
-			];
-		} else {
-			problem.fix = fix;
-		}
-
-		return problem;
-	},
-	getFix: (
-		{
-			context,
-			nextExpressionStatement,
-		},
-		{
-			callExpression,
-			newExpression,
-		},
-	) => fixer => {
-		const argumentsText = getCallExpressionArgumentsText(
-			context,
-			callExpression,
-			/* IncludeTrailingComma */ false,
-		);
-		const entryText = `[${argumentsText}]`;
-		return appendElementsTextToSetConstructor({
-			context,
-			fixer,
-			newExpression,
-			elementsText: entryText,
-			nextExpressionStatement,
-		});
-	},
-};
-
-const cases = [
-	arrayMutationSettings,
-	objectWithAssignmentExpressionSettings,
-	objectWithObjectAssignSettings,
-	setMutationSettings,
-	mapMutationSettings,
-];
-
-function isLastDeclarator(variableDeclarator) {
-	const variableDeclaration = variableDeclarator.parent;
-	return (
-		variableDeclaration.type === 'VariableDeclaration'
-		&& variableDeclaration.declarations.at(-1) === variableDeclarator
-	);
-}
-
-const getVariable = (node, context) => {
-	if (node.type === 'VariableDeclarator') {
-		return context.sourceCode.getDeclaredVariables(node)
-			.find(variable => variable.defs.length === 1 && variable.defs[0].name === node.id);
-	}
-
-	return findVariable(context.sourceCode.getScope(node), node.left.name);
-};
-
-function getCaseProblem(
-	context,
-	assignNode,
-	{
-		testValue,
-		getProblematicNode,
-		getProblem,
-		getFix,
-	},
-) {
-	const isAssignment = assignNode.type === 'AssignmentExpression';
-	const [variableNode, valueNode] = (isAssignment ? ['left', 'right'] : ['id', 'init'])
-		.map(property => assignNode[property]);
-
-	// eslint-disable-next-line no-warning-comments
-	// TODO[@fisker]: `AssignmentExpression` should not limit to `Identifier`
-	if (!(variableNode.type === 'Identifier' && testValue(valueNode))) {
-		return;
-	}
-
-	const statement = assignNode.parent;
-
-	if (!(
-		// eslint-disable-next-line no-warning-comments
-		// TODO[@fisker]: `AssignmentExpression` should support `a = b = c` too
-		(
-			isAssignment
-			&& assignNode.operator === '='
-			&& statement.type === 'ExpressionStatement'
-			&& statement.expression === assignNode)
-		|| (!isAssignment && isLastDeclarator(assignNode))
-	)) {
-		return;
-	}
-
-	const nextExpressionStatement = getNextNode(statement, context);
-	if (nextExpressionStatement?.type !== 'ExpressionStatement') {
-		return;
-	}
-
-	const variable = getVariable(assignNode, context);
-	/* c8 ignore next */
-	if (!variable) {
-		return;
-	}
-
-	const information = {
-		context,
-		variable,
-		variableNode,
-		valueNode,
-		statement,
-		nextExpressionStatement,
-		assignType: isAssignment ? 'assignment' : 'declaration',
-		getFix,
-	};
-
-	const problematicNode = getProblematicNode(information);
-
-	if (!problematicNode) {
-		return;
-	}
-
-	return getProblem(problematicNode, information);
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	for (const caseSettings of cases) {
-		context.on(
-			[
-				'VariableDeclarator',
-				'AssignmentExpression',
-			],
-			assignNode => getCaseProblem(context, assignNode, caseSettings),
-		);
-	}
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow immediate mutation after variable assignment.',
-			recommended: true,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;