codtracker-js/node_modules/eslint/lib/rules/no-loss-of-precision.js

/**
 * @fileoverview Rule to flag numbers that will lose significant figure precision at runtime
 * @author Jacob Moore
 */

'use strict';

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

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    type: 'problem',
    dialects: ['typescript', 'javascript'],
    language: 'javascript',

    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;

      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,
          });
        }
      },
    };
  },
};