codtracker-js/node_modules/eslint/lib/rules/semi-style.js

/**
 * @fileoverview Rule to enforce location of semicolons.
 * @author Toru Nagashima
 * @deprecated in ESLint v8.53.0
 */

'use strict';

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

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

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

const SELECTOR = [
  'BreakStatement',
  'ContinueStatement',
  'DebuggerStatement',
  'DoWhileStatement',
  'ExportAllDeclaration',
  'ExportDefaultDeclaration',
  'ExportNamedDeclaration',
  'ExpressionStatement',
  'ImportDeclaration',
  'ReturnStatement',
  'ThrowStatement',
  'VariableDeclaration',
  'PropertyDefinition',
].join(',');

/**
 * Get the child node list of a given node.
 * This returns `BlockStatement#body`, `StaticBlock#body`, `Program#body`,
 * `ClassBody#body`, or `SwitchCase#consequent`.
 * This is used to check whether a node is the first/last child.
 * @param {Node} node A node to get child node list.
 * @returns {Node[]|null} The child node list.
 */
function getChildren(node) {
  const t = node.type;

  if (
    t === 'BlockStatement' ||
    t === 'StaticBlock' ||
    t === 'Program' ||
    t === 'ClassBody'
  ) {
    return node.body;
  }
  if (t === 'SwitchCase') {
    return node.consequent;
  }
  return null;
}

/**
 * Check whether a given node is the last statement in the parent block.
 * @param {Node} node A node to check.
 * @returns {boolean} `true` if the node is the last statement in the parent block.
 */
function isLastChild(node) {
  const t = node.parent.type;

  if (
    t === 'IfStatement' &&
    node.parent.consequent === node &&
    node.parent.alternate
  ) {
    // before `else` keyword.
    return true;
  }
  if (t === 'DoWhileStatement') {
    // before `while` keyword.
    return true;
  }
  const nodeList = getChildren(node.parent);

  return nodeList !== null && nodeList.at(-1) === node; // before `}` or etc.
}

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
  meta: {
    deprecated: {
      message: 'Formatting rules are being moved out of ESLint core.',
      url: 'https://eslint.org/blog/2023/10/deprecating-formatting-rules/',
      deprecatedSince: '8.53.0',
      availableUntil: '10.0.0',
      replacedBy: [
        {
          message:
            'ESLint Stylistic now maintains deprecated stylistic core rules.',
          url: 'https://eslint.style/guide/migration',
          plugin: {
            name: '@stylistic/eslint-plugin-js',
            url: 'https://eslint.style/packages/js',
          },
          rule: {
            name: 'semi-style',
            url: 'https://eslint.style/rules/js/semi-style',
          },
        },
      ],
    },
    type: 'layout',

    docs: {
      description: 'Enforce location of semicolons',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/semi-style',
    },

    schema: [{ enum: ['last', 'first'] }],
    fixable: 'whitespace',

    messages: {
      expectedSemiColon: 'Expected this semicolon to be at {{pos}}.',
    },
  },

  create(context) {
    const sourceCode = context.sourceCode;
    const option = context.options[0] || 'last';

    /**
     * Check the given semicolon token.
     * @param {Token} semiToken The semicolon token to check.
     * @param {"first"|"last"} expected The expected location to check.
     * @returns {void}
     */
    function check(semiToken, expected) {
      const prevToken = sourceCode.getTokenBefore(semiToken);
      const nextToken = sourceCode.getTokenAfter(semiToken);
      const prevIsSameLine =
        !prevToken || astUtils.isTokenOnSameLine(prevToken, semiToken);
      const nextIsSameLine =
        !nextToken || astUtils.isTokenOnSameLine(semiToken, nextToken);

      if (
        (expected === 'last' && !prevIsSameLine) ||
        (expected === 'first' && !nextIsSameLine)
      ) {
        context.report({
          loc: semiToken.loc,
          messageId: 'expectedSemiColon',
          data: {
            pos:
              expected === 'last' ?
                'the end of the previous line'
              : 'the beginning of the next line',
          },
          fix(fixer) {
            if (
              prevToken &&
              nextToken &&
              sourceCode.commentsExistBetween(prevToken, nextToken)
            ) {
              return null;
            }

            const start = prevToken ? prevToken.range[1] : semiToken.range[0];
            const end = nextToken ? nextToken.range[0] : semiToken.range[1];
            const text = expected === 'last' ? ';\n' : '\n;';

            return fixer.replaceTextRange([start, end], text);
          },
        });
      }
    }

    return {
      [SELECTOR](node) {
        if (option === 'first' && isLastChild(node)) {
          return;
        }

        const lastToken = sourceCode.getLastToken(node);

        if (astUtils.isSemicolonToken(lastToken)) {
          check(lastToken, option);
        }
      },

      ForStatement(node) {
        const firstSemi =
          node.init &&
          sourceCode.getTokenAfter(node.init, astUtils.isSemicolonToken);
        const secondSemi =
          node.test &&
          sourceCode.getTokenAfter(node.test, astUtils.isSemicolonToken);

        if (firstSemi) {
          check(firstSemi, 'last');
        }
        if (secondSemi) {
          check(secondSemi, 'last');
        }
      },
    };
  },
};