codtracker-js/node_modules/eslint/lib/rules/no-unused-expressions.js

/**
 * @fileoverview Flag expressions in statement position that do not side effect
 * @author Michael Ficarra
 */
'use strict';

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

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

/**
 * Returns `true`.
 * @returns {boolean} `true`.
 */
function alwaysTrue() {
  return true;
}

/**
 * Returns `false`.
 * @returns {boolean} `false`.
 */
function alwaysFalse() {
  return false;
}

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

    docs: {
      description: 'Disallow unused expressions',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/no-unused-expressions',
    },

    schema: [
      {
        type: 'object',
        properties: {
          allowShortCircuit: {
            type: 'boolean',
          },
          allowTernary: {
            type: 'boolean',
          },
          allowTaggedTemplates: {
            type: 'boolean',
          },
          enforceForJSX: {
            type: 'boolean',
          },
        },
        additionalProperties: false,
      },
    ],

    defaultOptions: [
      {
        allowShortCircuit: false,
        allowTernary: false,
        allowTaggedTemplates: false,
        enforceForJSX: false,
      },
    ],

    messages: {
      unusedExpression:
        'Expected an assignment or function call and instead saw an expression.',
    },
  },

  create(context) {
    const [
      { allowShortCircuit, allowTernary, allowTaggedTemplates, enforceForJSX },
    ] = context.options;

    /**
     * Has AST suggesting a directive.
     * @param {ASTNode} node any node
     * @returns {boolean} whether the given node structurally represents a directive
     */
    function looksLikeDirective(node) {
      return (
        node.type === 'ExpressionStatement' &&
        node.expression.type === 'Literal' &&
        typeof node.expression.value === 'string'
      );
    }

    /**
     * Gets the leading sequence of members in a list that pass the predicate.
     * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
     * @param {a[]} list the input list
     * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
     */
    function takeWhile(predicate, list) {
      for (let i = 0; i < list.length; ++i) {
        if (!predicate(list[i])) {
          return list.slice(0, i);
        }
      }
      return list.slice();
    }

    /**
     * Gets leading directives nodes in a Node body.
     * @param {ASTNode} node a Program or BlockStatement node
     * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
     */
    function directives(node) {
      return takeWhile(looksLikeDirective, node.body);
    }

    /**
     * Detect if a Node is a directive.
     * @param {ASTNode} node any node
     * @returns {boolean} whether the given node is considered a directive in its current position
     */
    function isDirective(node) {
      /**
       * https://tc39.es/ecma262/#directive-prologue
       *
       * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
       * Class static blocks do not have directive prologue.
       */
      return (
        astUtils.isTopLevelExpressionStatement(node) &&
        directives(node.parent).includes(node)
      );
    }

    /**
     * The member functions return `true` if the type has no side-effects.
     * Unknown nodes are handled as `false`, then this rule ignores those.
     */
    const Checker = Object.assign(Object.create(null), {
      isDisallowed(node) {
        return (Checker[node.type] || alwaysFalse)(node);
      },

      ArrayExpression: alwaysTrue,
      ArrowFunctionExpression: alwaysTrue,
      BinaryExpression: alwaysTrue,
      ChainExpression(node) {
        return Checker.isDisallowed(node.expression);
      },
      ClassExpression: alwaysTrue,
      ConditionalExpression(node) {
        if (allowTernary) {
          return (
            Checker.isDisallowed(node.consequent) ||
            Checker.isDisallowed(node.alternate)
          );
        }
        return true;
      },
      FunctionExpression: alwaysTrue,
      Identifier: alwaysTrue,
      JSXElement() {
        return enforceForJSX;
      },
      JSXFragment() {
        return enforceForJSX;
      },
      Literal: alwaysTrue,
      LogicalExpression(node) {
        if (allowShortCircuit) {
          return Checker.isDisallowed(node.right);
        }
        return true;
      },
      MemberExpression: alwaysTrue,
      MetaProperty: alwaysTrue,
      ObjectExpression: alwaysTrue,
      SequenceExpression: alwaysTrue,
      TaggedTemplateExpression() {
        return !allowTaggedTemplates;
      },
      TemplateLiteral: alwaysTrue,
      ThisExpression: alwaysTrue,
      UnaryExpression(node) {
        return node.operator !== 'void' && node.operator !== 'delete';
      },
    });

    return {
      ExpressionStatement(node) {
        if (Checker.isDisallowed(node.expression) && !isDirective(node)) {
          context.report({ node, messageId: 'unusedExpression' });
        }
      },
    };
  },
};