Permalink
243 lines (216 sloc)
9.26 KB
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
codeql-action/node_modules/eslint/lib/rules/no-magic-numbers.js
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* @fileoverview Rule to flag statements that use magic numbers (adapted from https://github.com/danielstjules/buddy.js) | |
* @author Vincent Lemeunier | |
*/ | |
"use strict"; | |
const astUtils = require("./utils/ast-utils"); | |
// Maximum array length by the ECMAScript Specification. | |
const MAX_ARRAY_LENGTH = 2 ** 32 - 1; | |
//------------------------------------------------------------------------------ | |
// Rule Definition | |
//------------------------------------------------------------------------------ | |
/** | |
* Convert the value to bigint if it's a string. Otherwise return the value as-is. | |
* @param {bigint|number|string} x The value to normalize. | |
* @returns {bigint|number} The normalized value. | |
*/ | |
function normalizeIgnoreValue(x) { | |
if (typeof x === "string") { | |
return BigInt(x.slice(0, -1)); | |
} | |
return x; | |
} | |
/** @type {import('../shared/types').Rule} */ | |
module.exports = { | |
meta: { | |
type: "suggestion", | |
docs: { | |
description: "Disallow magic numbers", | |
recommended: false, | |
url: "https://eslint.org/docs/latest/rules/no-magic-numbers" | |
}, | |
schema: [{ | |
type: "object", | |
properties: { | |
detectObjects: { | |
type: "boolean", | |
default: false | |
}, | |
enforceConst: { | |
type: "boolean", | |
default: false | |
}, | |
ignore: { | |
type: "array", | |
items: { | |
anyOf: [ | |
{ type: "number" }, | |
{ type: "string", pattern: "^[+-]?(?:0|[1-9][0-9]*)n$" } | |
] | |
}, | |
uniqueItems: true | |
}, | |
ignoreArrayIndexes: { | |
type: "boolean", | |
default: false | |
}, | |
ignoreDefaultValues: { | |
type: "boolean", | |
default: false | |
}, | |
ignoreClassFieldInitialValues: { | |
type: "boolean", | |
default: false | |
} | |
}, | |
additionalProperties: false | |
}], | |
messages: { | |
useConst: "Number constants declarations must use 'const'.", | |
noMagic: "No magic number: {{raw}}." | |
} | |
}, | |
create(context) { | |
const config = context.options[0] || {}, | |
detectObjects = !!config.detectObjects, | |
enforceConst = !!config.enforceConst, | |
ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)), | |
ignoreArrayIndexes = !!config.ignoreArrayIndexes, | |
ignoreDefaultValues = !!config.ignoreDefaultValues, | |
ignoreClassFieldInitialValues = !!config.ignoreClassFieldInitialValues; | |
const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"]; | |
/** | |
* Returns whether the rule is configured to ignore the given value | |
* @param {bigint|number} value The value to check | |
* @returns {boolean} true if the value is ignored | |
*/ | |
function isIgnoredValue(value) { | |
return ignore.has(value); | |
} | |
/** | |
* Returns whether the number is a default value assignment. | |
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node | |
* @returns {boolean} true if the number is a default value | |
*/ | |
function isDefaultValue(fullNumberNode) { | |
const parent = fullNumberNode.parent; | |
return parent.type === "AssignmentPattern" && parent.right === fullNumberNode; | |
} | |
/** | |
* Returns whether the number is the initial value of a class field. | |
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node | |
* @returns {boolean} true if the number is the initial value of a class field. | |
*/ | |
function isClassFieldInitialValue(fullNumberNode) { | |
const parent = fullNumberNode.parent; | |
return parent.type === "PropertyDefinition" && parent.value === fullNumberNode; | |
} | |
/** | |
* Returns whether the given node is used as a radix within parseInt() or Number.parseInt() | |
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node | |
* @returns {boolean} true if the node is radix | |
*/ | |
function isParseIntRadix(fullNumberNode) { | |
const parent = fullNumberNode.parent; | |
return parent.type === "CallExpression" && fullNumberNode === parent.arguments[1] && | |
( | |
astUtils.isSpecificId(parent.callee, "parseInt") || | |
astUtils.isSpecificMemberAccess(parent.callee, "Number", "parseInt") | |
); | |
} | |
/** | |
* Returns whether the given node is a direct child of a JSX node. | |
* In particular, it aims to detect numbers used as prop values in JSX tags. | |
* Example: <input maxLength={10} /> | |
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node | |
* @returns {boolean} true if the node is a JSX number | |
*/ | |
function isJSXNumber(fullNumberNode) { | |
return fullNumberNode.parent.type.indexOf("JSX") === 0; | |
} | |
/** | |
* Returns whether the given node is used as an array index. | |
* Value must coerce to a valid array index name: "0", "1", "2" ... "4294967294". | |
* | |
* All other values, like "-1", "2.5", or "4294967295", are just "normal" object properties, | |
* which can be created and accessed on an array in addition to the array index properties, | |
* but they don't affect array's length and are not considered by methods such as .map(), .forEach() etc. | |
* | |
* The maximum array length by the specification is 2 ** 32 - 1 = 4294967295, | |
* thus the maximum valid index is 2 ** 32 - 2 = 4294967294. | |
* | |
* All notations are allowed, as long as the value coerces to one of "0", "1", "2" ... "4294967294". | |
* | |
* Valid examples: | |
* a[0], a[1], a[1.2e1], a[0xAB], a[0n], a[1n] | |
* a[-0] (same as a[0] because -0 coerces to "0") | |
* a[-0n] (-0n evaluates to 0n) | |
* | |
* Invalid examples: | |
* a[-1], a[-0xAB], a[-1n], a[2.5], a[1.23e1], a[12e-1] | |
* a[4294967295] (above the max index, it's an access to a regular property a["4294967295"]) | |
* a[999999999999999999999] (even if it wasn't above the max index, it would be a["1e+21"]) | |
* a[1e310] (same as a["Infinity"]) | |
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node | |
* @param {bigint|number} value Value expressed by the fullNumberNode | |
* @returns {boolean} true if the node is a valid array index | |
*/ | |
function isArrayIndex(fullNumberNode, value) { | |
const parent = fullNumberNode.parent; | |
return parent.type === "MemberExpression" && parent.property === fullNumberNode && | |
(Number.isInteger(value) || typeof value === "bigint") && | |
value >= 0 && value < MAX_ARRAY_LENGTH; | |
} | |
return { | |
Literal(node) { | |
if (!astUtils.isNumericLiteral(node)) { | |
return; | |
} | |
let fullNumberNode; | |
let value; | |
let raw; | |
// Treat unary minus as a part of the number | |
if (node.parent.type === "UnaryExpression" && node.parent.operator === "-") { | |
fullNumberNode = node.parent; | |
value = -node.value; | |
raw = `-${node.raw}`; | |
} else { | |
fullNumberNode = node; | |
value = node.value; | |
raw = node.raw; | |
} | |
const parent = fullNumberNode.parent; | |
// Always allow radix arguments and JSX props | |
if ( | |
isIgnoredValue(value) || | |
(ignoreDefaultValues && isDefaultValue(fullNumberNode)) || | |
(ignoreClassFieldInitialValues && isClassFieldInitialValue(fullNumberNode)) || | |
isParseIntRadix(fullNumberNode) || | |
isJSXNumber(fullNumberNode) || | |
(ignoreArrayIndexes && isArrayIndex(fullNumberNode, value)) | |
) { | |
return; | |
} | |
if (parent.type === "VariableDeclarator") { | |
if (enforceConst && parent.parent.kind !== "const") { | |
context.report({ | |
node: fullNumberNode, | |
messageId: "useConst" | |
}); | |
} | |
} else if ( | |
!okTypes.includes(parent.type) || | |
(parent.type === "AssignmentExpression" && parent.left.type === "Identifier") | |
) { | |
context.report({ | |
node: fullNumberNode, | |
messageId: "noMagic", | |
data: { | |
raw | |
} | |
}); | |
} | |
} | |
}; | |
} | |
}; |