codtracker-js/node_modules/eslint/lib/rules/prefer-object-spread.js

/**
 * @fileoverview Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead
 * @author Sharmila Jesupaul
 */

'use strict';

const { CALL, ReferenceTracker } = require('@eslint-community/eslint-utils');
const {
  isCommaToken,
  isOpeningParenToken,
  isClosingParenToken,
  isParenthesised,
} = require('./utils/ast-utils');

const ANY_SPACE = /\s/u;

/**
 * Helper that checks if the Object.assign call has array spread
 * @param {ASTNode} node The node that the rule warns on
 * @returns {boolean} - Returns true if the Object.assign call has array spread
 */
function hasArraySpread(node) {
  return node.arguments.some((arg) => arg.type === 'SpreadElement');
}

/**
 * Determines whether the given node is an accessor property (getter/setter).
 * @param {ASTNode} node Node to check.
 * @returns {boolean} `true` if the node is a getter or a setter.
 */
function isAccessorProperty(node) {
  return (
    node.type === 'Property' && (node.kind === 'get' || node.kind === 'set')
  );
}

/**
 * Determines whether the given object expression node has accessor properties (getters/setters).
 * @param {ASTNode} node `ObjectExpression` node to check.
 * @returns {boolean} `true` if the node has at least one getter/setter.
 */
function hasAccessors(node) {
  return node.properties.some(isAccessorProperty);
}

/**
 * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
 * @param {ASTNode} node `CallExpression` node to check.
 * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
 */
function hasArgumentsWithAccessors(node) {
  return node.arguments
    .filter((arg) => arg.type === 'ObjectExpression')
    .some(hasAccessors);
}

/**
 * Helper that checks if the node needs parentheses to be valid JS.
 * The default is to wrap the node in parentheses to avoid parsing errors.
 * @param {ASTNode} node The node that the rule warns on
 * @param {Object} sourceCode in context sourcecode object
 * @returns {boolean} - Returns true if the node needs parentheses
 */
function needsParens(node, sourceCode) {
  const parent = node.parent;

  switch (parent.type) {
    case 'VariableDeclarator':
    case 'ArrayExpression':
    case 'ReturnStatement':
    case 'CallExpression':
    case 'Property':
      return false;
    case 'AssignmentExpression':
      return parent.left === node && !isParenthesised(sourceCode, node);
    default:
      return !isParenthesised(sourceCode, node);
  }
}

/**
 * Determines if an argument needs parentheses. The default is to not add parens.
 * @param {ASTNode} node The node to be checked.
 * @param {Object} sourceCode in context sourcecode object
 * @returns {boolean} True if the node needs parentheses
 */
function argNeedsParens(node, sourceCode) {
  switch (node.type) {
    case 'AssignmentExpression':
    case 'ArrowFunctionExpression':
    case 'ConditionalExpression':
      return !isParenthesised(sourceCode, node);
    default:
      return false;
  }
}

/**
 * Get the parenthesis tokens of a given ObjectExpression node.
 * This includes the braces of the object literal and enclosing parentheses.
 * @param {ASTNode} node The node to get.
 * @param {Token} leftArgumentListParen The opening paren token of the argument list.
 * @param {SourceCode} sourceCode The source code object to get tokens.
 * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
 */
function getParenTokens(node, leftArgumentListParen, sourceCode) {
  const parens = [
    sourceCode.getFirstToken(node),
    sourceCode.getLastToken(node),
  ];
  let leftNext = sourceCode.getTokenBefore(node);
  let rightNext = sourceCode.getTokenAfter(node);

  // Note: don't include the parens of the argument list.
  while (
    leftNext &&
    rightNext &&
    leftNext.range[0] > leftArgumentListParen.range[0] &&
    isOpeningParenToken(leftNext) &&
    isClosingParenToken(rightNext)
  ) {
    parens.push(leftNext, rightNext);
    leftNext = sourceCode.getTokenBefore(leftNext);
    rightNext = sourceCode.getTokenAfter(rightNext);
  }

  return parens.sort((a, b) => a.range[0] - b.range[0]);
}

/**
 * Get the range of a given token and around whitespaces.
 * @param {Token} token The token to get range.
 * @param {SourceCode} sourceCode The source code object to get tokens.
 * @returns {number} The end of the range of the token and around whitespaces.
 */
function getStartWithSpaces(token, sourceCode) {
  const text = sourceCode.text;
  let start = token.range[0];

  // If the previous token is a line comment then skip this step to avoid commenting this token out.
  {
    const prevToken = sourceCode.getTokenBefore(token, {
      includeComments: true,
    });

    if (prevToken && prevToken.type === 'Line') {
      return start;
    }
  }

  // Detect spaces before the token.
  while (ANY_SPACE.test(text[start - 1] || '')) {
    start -= 1;
  }

  return start;
}

/**
 * Get the range of a given token and around whitespaces.
 * @param {Token} token The token to get range.
 * @param {SourceCode} sourceCode The source code object to get tokens.
 * @returns {number} The start of the range of the token and around whitespaces.
 */
function getEndWithSpaces(token, sourceCode) {
  const text = sourceCode.text;
  let end = token.range[1];

  // Detect spaces after the token.
  while (ANY_SPACE.test(text[end] || '')) {
    end += 1;
  }

  return end;
}

/**
 * Autofixes the Object.assign call to use an object spread instead.
 * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
 * @param {string} sourceCode sourceCode of the Object.assign call
 * @returns {Function} autofixer - replaces the Object.assign with a spread object.
 */
function defineFixer(node, sourceCode) {
  return function* (fixer) {
    const leftParen = sourceCode.getTokenAfter(
      node.callee,
      isOpeningParenToken
    );
    const rightParen = sourceCode.getLastToken(node);

    // Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren.
    yield fixer.removeRange([node.range[0], leftParen.range[0]]);

    // Replace the parens of argument list to braces.
    if (needsParens(node, sourceCode)) {
      yield fixer.replaceText(leftParen, '({');
      yield fixer.replaceText(rightParen, '})');
    } else {
      yield fixer.replaceText(leftParen, '{');
      yield fixer.replaceText(rightParen, '}');
    }

    // Process arguments.
    for (const argNode of node.arguments) {
      const innerParens = getParenTokens(argNode, leftParen, sourceCode);
      const left = innerParens.shift();
      const right = innerParens.pop();

      if (argNode.type === 'ObjectExpression') {
        const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
        const maybeArgumentComma = sourceCode.getTokenAfter(right);

        /*
         * Make bare this object literal.
         * And remove spaces inside of the braces for better formatting.
         */
        for (const innerParen of innerParens) {
          yield fixer.remove(innerParen);
        }
        const leftRange = [left.range[0], getEndWithSpaces(left, sourceCode)];
        const rightRange = [
          Math.max(getStartWithSpaces(right, sourceCode), leftRange[1]), // Ensure ranges don't overlap
          right.range[1],
        ];

        yield fixer.removeRange(leftRange);
        yield fixer.removeRange(rightRange);

        // Remove the comma of this argument if it's duplication.
        if (
          (argNode.properties.length === 0 ||
            isCommaToken(maybeTrailingComma)) &&
          isCommaToken(maybeArgumentComma)
        ) {
          yield fixer.remove(maybeArgumentComma);
        }
      } else {
        // Make spread.
        if (argNeedsParens(argNode, sourceCode)) {
          yield fixer.insertTextBefore(left, '...(');
          yield fixer.insertTextAfter(right, ')');
        } else {
          yield fixer.insertTextBefore(left, '...');
        }
      }
    }
  };
}

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

    docs: {
      description:
        'Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead',
      recommended: false,
      frozen: true,
      url: 'https://eslint.org/docs/latest/rules/prefer-object-spread',
    },

    schema: [],
    fixable: 'code',

    messages: {
      useSpreadMessage:
        'Use an object spread instead of `Object.assign` eg: `{ ...foo }`.',
      useLiteralMessage:
        'Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`.',
    },
  },

  create(context) {
    const sourceCode = context.sourceCode;

    return {
      Program(node) {
        const scope = sourceCode.getScope(node);
        const tracker = new ReferenceTracker(scope);
        const trackMap = {
          Object: {
            assign: { [CALL]: true },
          },
        };

        // Iterate all calls of `Object.assign` (only of the global variable `Object`).
        for (const { node: refNode } of tracker.iterateGlobalReferences(
          trackMap
        )) {
          if (
            refNode.arguments.length >= 1 &&
            refNode.arguments[0].type === 'ObjectExpression' &&
            !hasArraySpread(refNode) &&
            !(
              refNode.arguments.length > 1 && hasArgumentsWithAccessors(refNode)
            )
          ) {
            const messageId =
              refNode.arguments.length === 1 ?
                'useLiteralMessage'
              : 'useSpreadMessage';
            const fix = defineFixer(refNode, sourceCode);

            context.report({ node: refNode, messageId, fix });
          }
        }
      },
    };
  },
};