Permalink
Cannot retrieve contributors at this time
214 lines (183 sloc)
8.07 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-loss-of-precision.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 numbers that will lose significant figure precision at runtime | |
* @author Jacob Moore | |
*/ | |
"use strict"; | |
//------------------------------------------------------------------------------ | |
// Rule Definition | |
//------------------------------------------------------------------------------ | |
/** @type {import('../shared/types').Rule} */ | |
module.exports = { | |
meta: { | |
type: "problem", | |
docs: { | |
description: "Disallow literal numbers that lose precision", | |
recommended: true, | |
url: "https://eslint.org/docs/latest/rules/no-loss-of-precision" | |
}, | |
schema: [], | |
messages: { | |
noLossOfPrecision: "This number literal will lose precision at runtime." | |
} | |
}, | |
create(context) { | |
/** | |
* Returns whether the node is number literal | |
* @param {Node} node the node literal being evaluated | |
* @returns {boolean} true if the node is a number literal | |
*/ | |
function isNumber(node) { | |
return typeof node.value === "number"; | |
} | |
/** | |
* Gets the source code of the given number literal. Removes `_` numeric separators from the result. | |
* @param {Node} node the number `Literal` node | |
* @returns {string} raw source code of the literal, without numeric separators | |
*/ | |
function getRaw(node) { | |
return node.raw.replace(/_/gu, ""); | |
} | |
/** | |
* Checks whether the number is base ten | |
* @param {ASTNode} node the node being evaluated | |
* @returns {boolean} true if the node is in base ten | |
*/ | |
function isBaseTen(node) { | |
const prefixes = ["0x", "0X", "0b", "0B", "0o", "0O"]; | |
return prefixes.every(prefix => !node.raw.startsWith(prefix)) && | |
!/^0[0-7]+$/u.test(node.raw); | |
} | |
/** | |
* Checks that the user-intended non-base ten number equals the actual number after is has been converted to the Number type | |
* @param {Node} node the node being evaluated | |
* @returns {boolean} true if they do not match | |
*/ | |
function notBaseTenLosesPrecision(node) { | |
const rawString = getRaw(node).toUpperCase(); | |
let base = 0; | |
if (rawString.startsWith("0B")) { | |
base = 2; | |
} else if (rawString.startsWith("0X")) { | |
base = 16; | |
} else { | |
base = 8; | |
} | |
return !rawString.endsWith(node.value.toString(base).toUpperCase()); | |
} | |
/** | |
* Adds a decimal point to the numeric string at index 1 | |
* @param {string} stringNumber the numeric string without any decimal point | |
* @returns {string} the numeric string with a decimal point in the proper place | |
*/ | |
function addDecimalPointToNumber(stringNumber) { | |
return `${stringNumber[0]}.${stringNumber.slice(1)}`; | |
} | |
/** | |
* Returns the number stripped of leading zeros | |
* @param {string} numberAsString the string representation of the number | |
* @returns {string} the stripped string | |
*/ | |
function removeLeadingZeros(numberAsString) { | |
for (let i = 0; i < numberAsString.length; i++) { | |
if (numberAsString[i] !== "0") { | |
return numberAsString.slice(i); | |
} | |
} | |
return numberAsString; | |
} | |
/** | |
* Returns the number stripped of trailing zeros | |
* @param {string} numberAsString the string representation of the number | |
* @returns {string} the stripped string | |
*/ | |
function removeTrailingZeros(numberAsString) { | |
for (let i = numberAsString.length - 1; i >= 0; i--) { | |
if (numberAsString[i] !== "0") { | |
return numberAsString.slice(0, i + 1); | |
} | |
} | |
return numberAsString; | |
} | |
/** | |
* Converts an integer to an object containing the integer's coefficient and order of magnitude | |
* @param {string} stringInteger the string representation of the integer being converted | |
* @returns {Object} the object containing the integer's coefficient and order of magnitude | |
*/ | |
function normalizeInteger(stringInteger) { | |
const significantDigits = removeTrailingZeros(removeLeadingZeros(stringInteger)); | |
return { | |
magnitude: stringInteger.startsWith("0") ? stringInteger.length - 2 : stringInteger.length - 1, | |
coefficient: addDecimalPointToNumber(significantDigits) | |
}; | |
} | |
/** | |
* | |
* Converts a float to an object containing the floats's coefficient and order of magnitude | |
* @param {string} stringFloat the string representation of the float being converted | |
* @returns {Object} the object containing the integer's coefficient and order of magnitude | |
*/ | |
function normalizeFloat(stringFloat) { | |
const trimmedFloat = removeLeadingZeros(stringFloat); | |
if (trimmedFloat.startsWith(".")) { | |
const decimalDigits = trimmedFloat.slice(1); | |
const significantDigits = removeLeadingZeros(decimalDigits); | |
return { | |
magnitude: significantDigits.length - decimalDigits.length - 1, | |
coefficient: addDecimalPointToNumber(significantDigits) | |
}; | |
} | |
return { | |
magnitude: trimmedFloat.indexOf(".") - 1, | |
coefficient: addDecimalPointToNumber(trimmedFloat.replace(".", "")) | |
}; | |
} | |
/** | |
* Converts a base ten number to proper scientific notation | |
* @param {string} stringNumber the string representation of the base ten number to be converted | |
* @returns {string} the number converted to scientific notation | |
*/ | |
function convertNumberToScientificNotation(stringNumber) { | |
const splitNumber = stringNumber.replace("E", "e").split("e"); | |
const originalCoefficient = splitNumber[0]; | |
const normalizedNumber = stringNumber.includes(".") ? normalizeFloat(originalCoefficient) | |
: normalizeInteger(originalCoefficient); | |
const normalizedCoefficient = normalizedNumber.coefficient; | |
const magnitude = splitNumber.length > 1 ? (parseInt(splitNumber[1], 10) + normalizedNumber.magnitude) | |
: normalizedNumber.magnitude; | |
return `${normalizedCoefficient}e${magnitude}`; | |
} | |
/** | |
* Checks that the user-intended base ten number equals the actual number after is has been converted to the Number type | |
* @param {Node} node the node being evaluated | |
* @returns {boolean} true if they do not match | |
*/ | |
function baseTenLosesPrecision(node) { | |
const normalizedRawNumber = convertNumberToScientificNotation(getRaw(node)); | |
const requestedPrecision = normalizedRawNumber.split("e")[0].replace(".", "").length; | |
if (requestedPrecision > 100) { | |
return true; | |
} | |
const storedNumber = node.value.toPrecision(requestedPrecision); | |
const normalizedStoredNumber = convertNumberToScientificNotation(storedNumber); | |
return normalizedRawNumber !== normalizedStoredNumber; | |
} | |
/** | |
* Checks that the user-intended number equals the actual number after is has been converted to the Number type | |
* @param {Node} node the node being evaluated | |
* @returns {boolean} true if they do not match | |
*/ | |
function losesPrecision(node) { | |
return isBaseTen(node) ? baseTenLosesPrecision(node) : notBaseTenLosesPrecision(node); | |
} | |
return { | |
Literal(node) { | |
if (node.value && isNumber(node) && losesPrecision(node)) { | |
context.report({ | |
messageId: "noLossOfPrecision", | |
node | |
}); | |
} | |
} | |
}; | |
} | |
}; |