codtracker-js/node_modules/eslint/lib/rules/func-names.js

/**
 * @fileoverview Rule to warn when a function expression does not have a name.
 * @author Kyle T. Nunery
 */

'use strict';

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

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

/**
 * Checks whether or not a given variable is a function name.
 * @param {eslint-scope.Variable} variable A variable to check.
 * @returns {boolean} `true` if the variable is a function name.
 */
function isFunctionName(variable) {
  return variable && variable.defs[0].type === 'FunctionName';
}

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

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

    defaultOptions: ['always', {}],

    docs: {
      description: 'Require or disallow named `function` expressions',
      recommended: false,
      url: 'https://eslint.org/docs/latest/rules/func-names',
    },

    schema: {
      definitions: {
        value: {
          enum: ['always', 'as-needed', 'never'],
        },
      },
      items: [
        {
          $ref: '#/definitions/value',
        },
        {
          type: 'object',
          properties: {
            generators: {
              $ref: '#/definitions/value',
            },
          },
          additionalProperties: false,
        },
      ],
    },

    messages: {
      unnamed: 'Unexpected unnamed {{name}}.',
      named: 'Unexpected named {{name}}.',
    },
  },

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

    /**
     * Returns the config option for the given node.
     * @param {ASTNode} node A node to get the config for.
     * @returns {string} The config option.
     */
    function getConfigForNode(node) {
      if (node.generator && context.options[1].generators) {
        return context.options[1].generators;
      }

      return context.options[0];
    }

    /**
     * Determines whether the current FunctionExpression node is a get, set, or
     * shorthand method in an object literal or a class.
     * @param {ASTNode} node A node to check.
     * @returns {boolean} True if the node is a get, set, or shorthand method.
     */
    function isObjectOrClassMethod(node) {
      const parent = node.parent;

      return (
        parent.type === 'MethodDefinition' ||
        (parent.type === 'Property' &&
          (parent.method || parent.kind === 'get' || parent.kind === 'set'))
      );
    }

    /**
     * Determines whether the current FunctionExpression node has a name that would be
     * inferred from context in a conforming ES6 environment.
     * @param {ASTNode} node A node to check.
     * @returns {boolean} True if the node would have a name assigned automatically.
     */
    function hasInferredName(node) {
      const parent = node.parent;

      return (
        isObjectOrClassMethod(node) ||
        (parent.type === 'VariableDeclarator' &&
          parent.id.type === 'Identifier' &&
          parent.init === node) ||
        (parent.type === 'Property' && parent.value === node) ||
        (parent.type === 'PropertyDefinition' && parent.value === node) ||
        (parent.type === 'AssignmentExpression' &&
          parent.left.type === 'Identifier' &&
          parent.right === node) ||
        (parent.type === 'AssignmentPattern' &&
          parent.left.type === 'Identifier' &&
          parent.right === node)
      );
    }

    /**
     * Reports that an unnamed function should be named
     * @param {ASTNode} node The node to report in the event of an error.
     * @returns {void}
     */
    function reportUnexpectedUnnamedFunction(node) {
      context.report({
        node,
        messageId: 'unnamed',
        loc: astUtils.getFunctionHeadLoc(node, sourceCode),
        data: { name: astUtils.getFunctionNameWithKind(node) },
      });
    }

    /**
     * Reports that a named function should be unnamed
     * @param {ASTNode} node The node to report in the event of an error.
     * @returns {void}
     */
    function reportUnexpectedNamedFunction(node) {
      context.report({
        node,
        messageId: 'named',
        loc: astUtils.getFunctionHeadLoc(node, sourceCode),
        data: { name: astUtils.getFunctionNameWithKind(node) },
      });
    }

    /**
     * The listener for function nodes.
     * @param {ASTNode} node function node
     * @returns {void}
     */
    function handleFunction(node) {
      // Skip recursive functions.
      const nameVar = sourceCode.getDeclaredVariables(node)[0];

      if (isFunctionName(nameVar) && nameVar.references.length > 0) {
        return;
      }

      const hasName = Boolean(node.id && node.id.name);
      const config = getConfigForNode(node);

      if (config === 'never') {
        if (hasName && node.type !== 'FunctionDeclaration') {
          reportUnexpectedNamedFunction(node);
        }
      } else if (config === 'as-needed') {
        if (!hasName && !hasInferredName(node)) {
          reportUnexpectedUnnamedFunction(node);
        }
      } else {
        if (!hasName && !isObjectOrClassMethod(node)) {
          reportUnexpectedUnnamedFunction(node);
        }
      }
    }

    return {
      'FunctionExpression:exit': handleFunction,
      'ExportDefaultDeclaration > FunctionDeclaration': handleFunction,
    };
  },
};