codtracker-js/node_modules/eslint/lib/rules/no-useless-computed-key.js

/**
 * @fileoverview Rule to disallow unnecessary computed property keys in object literals
 * @author Burak Yigit Kaya
 */
"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require("./utils/ast-utils");

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

/**
 * Determines whether the computed key syntax is unnecessarily used for the given node.
 * In particular, it determines whether removing the square brackets and using the content between them
 * directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior.
 * Valid non-computed keys are only: identifiers, number literals and string literals.
 * Only literals can preserve the same behavior, with a few exceptions for specific node types:
 * Property
 *   - { ["__proto__"]: foo } defines a property named "__proto__"
 *     { "__proto__": foo } defines object's prototype
 * PropertyDefinition
 *   - class C { ["constructor"]; } defines an instance field named "constructor"
 *     class C { "constructor"; } produces a parsing error
 *   - class C { static ["constructor"]; } defines a static field named "constructor"
 *     class C { static "constructor"; } produces a parsing error
 *   - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script)
 *     class C { static "prototype"; } produces a parsing error (breaks the whole script)
 * MethodDefinition
 *   - class C { ["constructor"]() {} } defines a prototype method named "constructor"
 *     class C { "constructor"() {} } defines the constructor
 *   - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script)
 *     class C { static "prototype"() {} } produces a parsing error (breaks the whole script)
 * @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`.
 * @throws {Error} (Unreachable.)
 * @returns {void} `true` if the node has useless computed key.
 */
function hasUselessComputedKey(node) {
	if (!node.computed) {
		return false;
	}

	const { key } = node;

	if (key.type !== "Literal") {
		return false;
	}

	const { value } = key;

	if (typeof value !== "number" && typeof value !== "string") {
		return false;
	}

	switch (node.type) {
		case "Property":
			if (node.parent.type === "ObjectExpression") {
				return value !== "__proto__";
			}
			return true;

		case "PropertyDefinition":
			if (node.static) {
				return value !== "constructor" && value !== "prototype";
			}

			return value !== "constructor";

		case "MethodDefinition":
			if (node.static) {
				return value !== "prototype";
			}

			return value !== "constructor";

		/* c8 ignore next */
		default:
			throw new Error(`Unexpected node type: ${node.type}`);
	}
}

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
	meta: {
		type: "suggestion",

		defaultOptions: [
			{
				enforceForClassMembers: true,
			},
		],

		docs: {
			description:
				"Disallow unnecessary computed property keys in objects and classes",
			recommended: false,
			frozen: true,
			url: "https://eslint.org/docs/latest/rules/no-useless-computed-key",
		},

		schema: [
			{
				type: "object",
				properties: {
					enforceForClassMembers: {
						type: "boolean",
					},
				},
				additionalProperties: false,
			},
		],
		fixable: "code",

		messages: {
			unnecessarilyComputedProperty:
				"Unnecessarily computed property [{{property}}] found.",
		},
	},
	create(context) {
		const sourceCode = context.sourceCode;
		const [{ enforceForClassMembers }] = context.options;

		/**
		 * Reports a given node if it violated this rule.
		 * @param {ASTNode} node The node to check.
		 * @returns {void}
		 */
		function check(node) {
			if (hasUselessComputedKey(node)) {
				const { key } = node;

				context.report({
					node,
					messageId: "unnecessarilyComputedProperty",
					data: { property: sourceCode.getText(key) },
					fix(fixer) {
						const leftSquareBracket = sourceCode.getTokenBefore(
							key,
							astUtils.isOpeningBracketToken,
						);
						const rightSquareBracket = sourceCode.getTokenAfter(
							key,
							astUtils.isClosingBracketToken,
						);

						// If there are comments between the brackets and the property name, don't do a fix.
						if (
							sourceCode.commentsExistBetween(
								leftSquareBracket,
								rightSquareBracket,
							)
						) {
							return null;
						}

						const tokenBeforeLeftBracket =
							sourceCode.getTokenBefore(leftSquareBracket);

						// Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
						const needsSpaceBeforeKey =
							tokenBeforeLeftBracket.range[1] ===
								leftSquareBracket.range[0] &&
							!astUtils.canTokensBeAdjacent(
								tokenBeforeLeftBracket,
								sourceCode.getFirstToken(key),
							);

						const replacementKey =
							(needsSpaceBeforeKey ? " " : "") + key.raw;

						return fixer.replaceTextRange(
							[
								leftSquareBracket.range[0],
								rightSquareBracket.range[1],
							],
							replacementKey,
						);
					},
				});
			}
		}

		/**
		 * A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`.
		 * @returns {void}
		 * @private
		 */
		function noop() {}

		return {
			Property: check,
			MethodDefinition: enforceForClassMembers ? check : noop,
			PropertyDefinition: enforceForClassMembers ? check : noop,
		};
	},
};