@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/object-shorthand.js

@@ -1,652 +0,0 @@
-/**
- * @fileoverview Rule to enforce concise object methods and properties.
- * @author Jamund Ferguson
- */
-
-"use strict";
-
-const OPTIONS = {
-	always: "always",
-	never: "never",
-	methods: "methods",
-	properties: "properties",
-	consistent: "consistent",
-	consistentAsNeeded: "consistent-as-needed",
-};
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-const astUtils = require("./utils/ast-utils");
-
-//--------------------------------------------------------------------------
-// Helpers
-//--------------------------------------------------------------------------
-const CTOR_PREFIX_REGEX = /[^_$0-9]/u;
-const JSDOC_COMMENT_REGEX = /^\s*\*/u;
-
-/**
- * Determines if the first character of the name is a capital letter.
- * @param {string} name The name of the node to evaluate.
- * @returns {boolean} True if the first character of the property name is a capital letter, false if not.
- * @private
- */
-function isConstructor(name) {
-	const match = CTOR_PREFIX_REGEX.exec(name);
-
-	// Not a constructor if name has no characters apart from '_', '$' and digits e.g. '_', '$$', '_8'
-	if (!match) {
-		return false;
-	}
-
-	const firstChar = name.charAt(match.index);
-
-	return firstChar === firstChar.toUpperCase();
-}
-
-/**
- * Determines if the property can have a shorthand form.
- * @param {ASTNode} property Property AST node
- * @returns {boolean} True if the property can have a shorthand form
- * @private
- */
-function canHaveShorthand(property) {
-	return (
-		property.kind !== "set" &&
-		property.kind !== "get" &&
-		property.type !== "SpreadElement" &&
-		property.type !== "SpreadProperty" &&
-		property.type !== "ExperimentalSpreadProperty"
-	);
-}
-
-/**
- * Checks whether a node is a string literal.
- * @param {ASTNode} node Any AST node.
- * @returns {boolean} `true` if it is a string literal.
- */
-function isStringLiteral(node) {
-	return node.type === "Literal" && typeof node.value === "string";
-}
-
-/**
- * Determines if the property is a shorthand or not.
- * @param {ASTNode} property Property AST node
- * @returns {boolean} True if the property is considered shorthand, false if not.
- * @private
- */
-function isShorthand(property) {
-	// property.method is true when `{a(){}}`.
-	return property.shorthand || property.method;
-}
-
-/**
- * Determines if the property's key and method or value are named equally.
- * @param {ASTNode} property Property AST node
- * @returns {boolean} True if the key and value are named equally, false if not.
- * @private
- */
-function isRedundant(property) {
-	const value = property.value;
-
-	if (value.type === "FunctionExpression") {
-		return !value.id; // Only anonymous should be shorthand method.
-	}
-	if (value.type === "Identifier") {
-		return astUtils.getStaticPropertyName(property) === value.name;
-	}
-
-	return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Require or disallow method and property shorthand syntax for object literals",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/object-shorthand",
-		},
-
-		fixable: "code",
-
-		schema: {
-			anyOf: [
-				{
-					type: "array",
-					items: [
-						{
-							enum: [
-								"always",
-								"methods",
-								"properties",
-								"never",
-								"consistent",
-								"consistent-as-needed",
-							],
-						},
-					],
-					minItems: 0,
-					maxItems: 1,
-				},
-				{
-					type: "array",
-					items: [
-						{
-							enum: ["always", "methods", "properties"],
-						},
-						{
-							type: "object",
-							properties: {
-								avoidQuotes: {
-									type: "boolean",
-								},
-							},
-							additionalProperties: false,
-						},
-					],
-					minItems: 0,
-					maxItems: 2,
-				},
-				{
-					type: "array",
-					items: [
-						{
-							enum: ["always", "methods"],
-						},
-						{
-							type: "object",
-							properties: {
-								ignoreConstructors: {
-									type: "boolean",
-								},
-								methodsIgnorePattern: {
-									type: "string",
-								},
-								avoidQuotes: {
-									type: "boolean",
-								},
-								avoidExplicitReturnArrows: {
-									type: "boolean",
-								},
-							},
-							additionalProperties: false,
-						},
-					],
-					minItems: 0,
-					maxItems: 2,
-				},
-			],
-		},
-
-		messages: {
-			expectedAllPropertiesShorthanded:
-				"Expected shorthand for all properties.",
-			expectedLiteralMethodLongform:
-				"Expected longform method syntax for string literal keys.",
-			expectedPropertyShorthand: "Expected property shorthand.",
-			expectedPropertyLongform: "Expected longform property syntax.",
-			expectedMethodShorthand: "Expected method shorthand.",
-			expectedMethodLongform: "Expected longform method syntax.",
-			unexpectedMix:
-				"Unexpected mix of shorthand and non-shorthand properties.",
-		},
-	},
-
-	create(context) {
-		const APPLY = context.options[0] || OPTIONS.always;
-		const APPLY_TO_METHODS =
-			APPLY === OPTIONS.methods || APPLY === OPTIONS.always;
-		const APPLY_TO_PROPS =
-			APPLY === OPTIONS.properties || APPLY === OPTIONS.always;
-		const APPLY_NEVER = APPLY === OPTIONS.never;
-		const APPLY_CONSISTENT = APPLY === OPTIONS.consistent;
-		const APPLY_CONSISTENT_AS_NEEDED = APPLY === OPTIONS.consistentAsNeeded;
-
-		const PARAMS = context.options[1] || {};
-		const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors;
-		const METHODS_IGNORE_PATTERN = PARAMS.methodsIgnorePattern
-			? new RegExp(PARAMS.methodsIgnorePattern, "u")
-			: null;
-		const AVOID_QUOTES = PARAMS.avoidQuotes;
-		const AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows;
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Ensures that an object's properties are consistently shorthand, or not shorthand at all.
-		 * @param {ASTNode} node Property AST node
-		 * @param {boolean} checkRedundancy Whether to check longform redundancy
-		 * @returns {void}
-		 */
-		function checkConsistency(node, checkRedundancy) {
-			// We are excluding getters/setters and spread properties as they are considered neither longform nor shorthand.
-			const properties = node.properties.filter(canHaveShorthand);
-
-			// Do we still have properties left after filtering the getters and setters?
-			if (properties.length > 0) {
-				const shorthandProperties = properties.filter(isShorthand);
-
-				/*
-				 * If we do not have an equal number of longform properties as
-				 * shorthand properties, we are using the annotations inconsistently
-				 */
-				if (shorthandProperties.length !== properties.length) {
-					// We have at least 1 shorthand property
-					if (shorthandProperties.length > 0) {
-						context.report({ node, messageId: "unexpectedMix" });
-					} else if (checkRedundancy) {
-						/*
-						 * If all properties of the object contain a method or value with a name matching it's key,
-						 * all the keys are redundant.
-						 */
-						const canAlwaysUseShorthand =
-							properties.every(isRedundant);
-
-						if (canAlwaysUseShorthand) {
-							context.report({
-								node,
-								messageId: "expectedAllPropertiesShorthanded",
-							});
-						}
-					}
-				}
-			}
-		}
-
-		/**
-		 * Fixes a FunctionExpression node by making it into a shorthand property.
-		 * @param {SourceCodeFixer} fixer The fixer object
-		 * @param {ASTNode} node A `Property` node that has a `FunctionExpression` or `ArrowFunctionExpression` as its value
-		 * @returns {Object} A fix for this node
-		 */
-		function makeFunctionShorthand(fixer, node) {
-			const firstKeyToken = node.computed
-				? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken)
-				: sourceCode.getFirstToken(node.key);
-			const lastKeyToken = node.computed
-				? sourceCode.getFirstTokenBetween(
-						node.key,
-						node.value,
-						astUtils.isClosingBracketToken,
-					)
-				: sourceCode.getLastToken(node.key);
-			const keyText = sourceCode.text.slice(
-				firstKeyToken.range[0],
-				lastKeyToken.range[1],
-			);
-			let keyPrefix = "";
-
-			// key: /* */ () => {}
-			if (sourceCode.commentsExistBetween(lastKeyToken, node.value)) {
-				return null;
-			}
-
-			if (node.value.async) {
-				keyPrefix += "async ";
-			}
-			if (node.value.generator) {
-				keyPrefix += "*";
-			}
-
-			const fixRange = [firstKeyToken.range[0], node.range[1]];
-			const methodPrefix = keyPrefix + keyText;
-
-			if (node.value.type === "FunctionExpression") {
-				const functionToken = sourceCode
-					.getTokens(node.value)
-					.find(
-						token =>
-							token.type === "Keyword" &&
-							token.value === "function",
-					);
-				const tokenBeforeParams = node.value.generator
-					? sourceCode.getTokenAfter(functionToken)
-					: functionToken;
-
-				return fixer.replaceTextRange(
-					fixRange,
-					methodPrefix +
-						sourceCode.text.slice(
-							tokenBeforeParams.range[1],
-							node.value.range[1],
-						),
-				);
-			}
-
-			const arrowToken = sourceCode.getTokenBefore(
-				node.value.body,
-				astUtils.isArrowToken,
-			);
-			const fnBody = sourceCode.text.slice(
-				arrowToken.range[1],
-				node.value.range[1],
-			);
-
-			// First token should not be `async`
-			const firstValueToken = sourceCode.getFirstToken(node.value, {
-				skip: node.value.async ? 1 : 0,
-			});
-
-			const sliceStart = firstValueToken.range[0];
-			const sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1];
-			const shouldAddParens =
-				node.value.params.length === 1 &&
-				node.value.params[0].range[0] === sliceStart;
-
-			const oldParamText = sourceCode.text.slice(sliceStart, sliceEnd);
-			const newParamText = shouldAddParens
-				? `(${oldParamText})`
-				: oldParamText;
-
-			return fixer.replaceTextRange(
-				fixRange,
-				methodPrefix + newParamText + fnBody,
-			);
-		}
-
-		/**
-		 * Fixes a FunctionExpression node by making it into a longform property.
-		 * @param {SourceCodeFixer} fixer The fixer object
-		 * @param {ASTNode} node A `Property` node that has a `FunctionExpression` as its value
-		 * @returns {Object} A fix for this node
-		 */
-		function makeFunctionLongform(fixer, node) {
-			const firstKeyToken = node.computed
-				? sourceCode.getTokens(node).find(token => token.value === "[")
-				: sourceCode.getFirstToken(node.key);
-			const lastKeyToken = node.computed
-				? sourceCode
-						.getTokensBetween(node.key, node.value)
-						.find(token => token.value === "]")
-				: sourceCode.getLastToken(node.key);
-			const keyText = sourceCode.text.slice(
-				firstKeyToken.range[0],
-				lastKeyToken.range[1],
-			);
-			let functionHeader = "function";
-
-			if (node.value.async) {
-				functionHeader = `async ${functionHeader}`;
-			}
-			if (node.value.generator) {
-				functionHeader = `${functionHeader}*`;
-			}
-
-			return fixer.replaceTextRange(
-				[node.range[0], lastKeyToken.range[1]],
-				`${keyText}: ${functionHeader}`,
-			);
-		}
-
-		/*
-		 * To determine whether a given arrow function has a lexical identifier (`this`, `arguments`, `super`, or `new.target`),
-		 * create a stack of functions that define these identifiers (i.e. all functions except arrow functions) as the AST is
-		 * traversed. Whenever a new function is encountered, create a new entry on the stack (corresponding to a different lexical
-		 * scope of `this`), and whenever a function is exited, pop that entry off the stack. When an arrow function is entered,
-		 * keep a reference to it on the current stack entry, and remove that reference when the arrow function is exited.
-		 * When a lexical identifier is encountered, mark all the arrow functions on the current stack entry by adding them
-		 * to an `arrowsWithLexicalIdentifiers` set. Any arrow function in that set will not be reported by this rule,
-		 * because converting it into a method would change the value of one of the lexical identifiers.
-		 */
-		const lexicalScopeStack = [];
-		const arrowsWithLexicalIdentifiers = new WeakSet();
-		const argumentsIdentifiers = new WeakSet();
-
-		/**
-		 * Enters a function. This creates a new lexical identifier scope, so a new Set of arrow functions is pushed onto the stack.
-		 * Also, this marks all `arguments` identifiers so that they can be detected later.
-		 * @param {ASTNode} node The node representing the function.
-		 * @returns {void}
-		 */
-		function enterFunction(node) {
-			lexicalScopeStack.unshift(new Set());
-			sourceCode
-				.getScope(node)
-				.variables.filter(variable => variable.name === "arguments")
-				.forEach(variable => {
-					variable.references
-						.map(ref => ref.identifier)
-						.forEach(identifier =>
-							argumentsIdentifiers.add(identifier),
-						);
-				});
-		}
-
-		/**
-		 * Exits a function. This pops the current set of arrow functions off the lexical scope stack.
-		 * @returns {void}
-		 */
-		function exitFunction() {
-			lexicalScopeStack.shift();
-		}
-
-		/**
-		 * Marks the current function as having a lexical keyword. This implies that all arrow functions
-		 * in the current lexical scope contain a reference to this lexical keyword.
-		 * @returns {void}
-		 */
-		function reportLexicalIdentifier() {
-			lexicalScopeStack[0].forEach(arrowFunction =>
-				arrowsWithLexicalIdentifiers.add(arrowFunction),
-			);
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program: enterFunction,
-			FunctionDeclaration: enterFunction,
-			FunctionExpression: enterFunction,
-			"Program:exit": exitFunction,
-			"FunctionDeclaration:exit": exitFunction,
-			"FunctionExpression:exit": exitFunction,
-
-			ArrowFunctionExpression(node) {
-				lexicalScopeStack[0].add(node);
-			},
-			"ArrowFunctionExpression:exit"(node) {
-				lexicalScopeStack[0].delete(node);
-			},
-
-			ThisExpression: reportLexicalIdentifier,
-			Super: reportLexicalIdentifier,
-			MetaProperty(node) {
-				if (
-					node.meta.name === "new" &&
-					node.property.name === "target"
-				) {
-					reportLexicalIdentifier();
-				}
-			},
-			Identifier(node) {
-				if (argumentsIdentifiers.has(node)) {
-					reportLexicalIdentifier();
-				}
-			},
-
-			ObjectExpression(node) {
-				if (APPLY_CONSISTENT) {
-					checkConsistency(node, false);
-				} else if (APPLY_CONSISTENT_AS_NEEDED) {
-					checkConsistency(node, true);
-				}
-			},
-
-			"Property:exit"(node) {
-				const isConciseProperty = node.method || node.shorthand;
-
-				// Ignore destructuring assignment
-				if (node.parent.type === "ObjectPattern") {
-					return;
-				}
-
-				// getters and setters are ignored
-				if (node.kind === "get" || node.kind === "set") {
-					return;
-				}
-
-				// only computed methods can fail the following checks
-				if (
-					node.computed &&
-					node.value.type !== "FunctionExpression" &&
-					node.value.type !== "ArrowFunctionExpression"
-				) {
-					return;
-				}
-
-				//--------------------------------------------------------------
-				// Checks for property/method shorthand.
-				if (isConciseProperty) {
-					if (
-						node.method &&
-						(APPLY_NEVER ||
-							(AVOID_QUOTES && isStringLiteral(node.key)))
-					) {
-						const messageId = APPLY_NEVER
-							? "expectedMethodLongform"
-							: "expectedLiteralMethodLongform";
-
-						// { x() {} } should be written as { x: function() {} }
-						context.report({
-							node,
-							messageId,
-							fix: fixer => makeFunctionLongform(fixer, node),
-						});
-					} else if (APPLY_NEVER) {
-						// { x } should be written as { x: x }
-						context.report({
-							node,
-							messageId: "expectedPropertyLongform",
-							fix: fixer =>
-								fixer.insertTextAfter(
-									node.key,
-									`: ${node.key.name}`,
-								),
-						});
-					}
-				} else if (
-					APPLY_TO_METHODS &&
-					!node.value.id &&
-					(node.value.type === "FunctionExpression" ||
-						node.value.type === "ArrowFunctionExpression")
-				) {
-					if (
-						IGNORE_CONSTRUCTORS &&
-						node.key.type === "Identifier" &&
-						isConstructor(node.key.name)
-					) {
-						return;
-					}
-
-					if (METHODS_IGNORE_PATTERN) {
-						const propertyName =
-							astUtils.getStaticPropertyName(node);
-
-						if (
-							propertyName !== null &&
-							METHODS_IGNORE_PATTERN.test(propertyName)
-						) {
-							return;
-						}
-					}
-
-					if (AVOID_QUOTES && isStringLiteral(node.key)) {
-						return;
-					}
-
-					// {[x]: function(){}} should be written as {[x]() {}}
-					if (
-						node.value.type === "FunctionExpression" ||
-						(node.value.type === "ArrowFunctionExpression" &&
-							node.value.body.type === "BlockStatement" &&
-							AVOID_EXPLICIT_RETURN_ARROWS &&
-							!arrowsWithLexicalIdentifiers.has(node.value))
-					) {
-						context.report({
-							node,
-							messageId: "expectedMethodShorthand",
-							fix: fixer => makeFunctionShorthand(fixer, node),
-						});
-					}
-				} else if (
-					node.value.type === "Identifier" &&
-					node.key.name === node.value.name &&
-					APPLY_TO_PROPS
-				) {
-					// Skip if there are JSDoc comments inside the property (e.g., JSDoc type annotations)
-					const comments = sourceCode.getCommentsInside(node);
-					if (
-						comments.some(
-							comment =>
-								comment.type === "Block" &&
-								JSDOC_COMMENT_REGEX.test(comment.value) &&
-								comment.value.includes("@type"),
-						)
-					) {
-						return;
-					}
-
-					// {x: x} should be written as {x}
-					context.report({
-						node,
-						messageId: "expectedPropertyShorthand",
-						fix(fixer) {
-							// x: /* */ x
-							// x: (/* */ x)
-							if (sourceCode.getCommentsInside(node).length > 0) {
-								return null;
-							}
-
-							return fixer.replaceText(node, node.value.name);
-						},
-					});
-				} else if (
-					node.value.type === "Identifier" &&
-					node.key.type === "Literal" &&
-					node.key.value === node.value.name &&
-					APPLY_TO_PROPS
-				) {
-					if (AVOID_QUOTES) {
-						return;
-					}
-
-					const comments = sourceCode.getCommentsInside(node);
-					if (
-						comments.some(
-							comment =>
-								comment.type === "Block" &&
-								comment.value.startsWith("*") &&
-								comment.value.includes("@type"),
-						)
-					) {
-						return;
-					}
-
-					// {"x": x} should be written as {x}
-					context.report({
-						node,
-						messageId: "expectedPropertyShorthand",
-						fix(fixer) {
-							// "x": /* */ x
-							// "x": (/* */ x)
-							if (sourceCode.getCommentsInside(node).length > 0) {
-								return null;
-							}
-
-							return fixer.replaceText(node, node.value.name);
-						},
-					});
-				}
-			},
-		};
-	},
-};