Blame view

node_modules/eslint/lib/rules/no-unsafe-negation.js 2.64 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
  /**
   * @fileoverview Rule to disallow negating the left operand of relational operators
   * @author Toru Nagashima
   */
  
  "use strict";
  
  //------------------------------------------------------------------------------
  // Requirements
  //------------------------------------------------------------------------------
  
  const astUtils = require("../ast-utils");
  
  //------------------------------------------------------------------------------
  // Helpers
  //------------------------------------------------------------------------------
  
  /**
   * Checks whether the given operator is a relational operator or not.
   *
   * @param {string} op - The operator type to check.
   * @returns {boolean} `true` if the operator is a relational operator.
   */
  function isRelationalOperator(op) {
      return op === "in" || op === "instanceof";
  }
  
  /**
   * Checks whether the given node is a logical negation expression or not.
   *
   * @param {ASTNode} node - The node to check.
   * @returns {boolean} `true` if the node is a logical negation expression.
   */
  function isNegation(node) {
      return node.type === "UnaryExpression" && node.operator === "!";
  }
  
  //------------------------------------------------------------------------------
  // Rule Definition
  //------------------------------------------------------------------------------
  
  module.exports = {
      meta: {
          docs: {
              description: "disallow negating the left operand of relational operators",
              category: "Possible Errors",
              recommended: true,
              url: "https://eslint.org/docs/rules/no-unsafe-negation"
          },
          schema: [],
          fixable: "code"
      },
  
      create(context) {
          const sourceCode = context.getSourceCode();
  
          return {
              BinaryExpression(node) {
                  if (isRelationalOperator(node.operator) &&
                      isNegation(node.left) &&
                      !astUtils.isParenthesised(sourceCode, node.left)
                  ) {
                      context.report({
                          node,
                          loc: node.left.loc,
                          message: "Unexpected negating the left operand of '{{operator}}' operator.",
                          data: node,
  
                          fix(fixer) {
                              const negationToken = sourceCode.getFirstToken(node.left);
                              const fixRange = [negationToken.range[1], node.range[1]];
                              const text = sourceCode.text.slice(fixRange[0], fixRange[1]);
  
                              return fixer.replaceTextRange(fixRange, `(${text})`);
                          }
                      });
                  }
              }
          };
      }
  };