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

   1 /**
   2  * @fileoverview Flag expressions in statement position that do not side effect
   3  * @author Michael Ficarra
   4  */
   5 "use strict";
   6
   7 //------------------------------------------------------------------------------
   8 // Rule Definition
   9 //------------------------------------------------------------------------------
  10
  11 /**
  12  * Returns `true`.
  13  * @returns {boolean} `true`.
  14  */
  15 function alwaysTrue() {
  16     return true;
  17 }
  18
  19 /**
  20  * Returns `false`.
  21  * @returns {boolean} `false`.
  22  */
  23 function alwaysFalse() {
  24     return false;
  25 }
  26
  27 /** @type {import('../shared/types').Rule} */
  28 module.exports = {
  29     meta: {
  30         type: "suggestion",
  31
  32         docs: {
  33             description: "Disallow unused expressions",
  34             recommended: false,
  35             url: "https://eslint.org/docs/latest/rules/no-unused-expressions"
  36         },
  37
  38         schema: [
  39             {
  40                 type: "object",
  41                 properties: {
  42                     allowShortCircuit: {
  43                         type: "boolean",
  44                         default: false
  45                     },
  46                     allowTernary: {
  47                         type: "boolean",
  48                         default: false
  49                     },
  50                     allowTaggedTemplates: {
  51                         type: "boolean",
  52                         default: false
  53                     },
  54                     enforceForJSX: {
  55                         type: "boolean",
  56                         default: false
  57                     }
  58                 },
  59                 additionalProperties: false
  60             }
  61         ],
  62
  63         messages: {
  64             unusedExpression: "Expected an assignment or function call and instead saw an expression."
  65         }
  66     },
  67
  68     create(context) {
  69         const config = context.options[0] || {},
  70             allowShortCircuit = config.allowShortCircuit || false,
  71             allowTernary = config.allowTernary || false,
  72             allowTaggedTemplates = config.allowTaggedTemplates || false,
  73             enforceForJSX = config.enforceForJSX || false;
  74
  75         /**
  76          * Has AST suggesting a directive.
  77          * @param {ASTNode} node any node
  78          * @returns {boolean} whether the given node structurally represents a directive
  79          */
  80         function looksLikeDirective(node) {
  81             return node.type === "ExpressionStatement" &&
  82                 node.expression.type === "Literal" && typeof node.expression.value === "string";
  83         }
  84
  85         /**
  86          * Gets the leading sequence of members in a list that pass the predicate.
  87          * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
  88          * @param {a[]} list the input list
  89          * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
  90          */
  91         function takeWhile(predicate, list) {
  92             for (let i = 0; i < list.length; ++i) {
  93                 if (!predicate(list[i])) {
  94                     return list.slice(0, i);
  95                 }
  96             }
  97             return list.slice();
  98         }
  99
 100         /**
 101          * Gets leading directives nodes in a Node body.
 102          * @param {ASTNode} node a Program or BlockStatement node
 103          * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
 104          */
 105         function directives(node) {
 106             return takeWhile(looksLikeDirective, node.body);
 107         }
 108
 109         /**
 110          * Detect if a Node is a directive.
 111          * @param {ASTNode} node any node
 112          * @returns {boolean} whether the given node is considered a directive in its current position
 113          */
 114         function isDirective(node) {
 115             const parent = node.parent,
 116                 grandparent = parent.parent;
 117
 118             /**
 119              * https://tc39.es/ecma262/#directive-prologue
 120              *
 121              * Only `FunctionBody`, `ScriptBody` and `ModuleBody` can have directive prologue.
 122              * Class static blocks do not have directive prologue.
 123              */
 124             return (parent.type === "Program" || parent.type === "BlockStatement" &&
 125                     (/Function/u.test(grandparent.type))) &&
 126                     directives(parent).includes(node);
 127         }
 128
 129         /**
 130          * The member functions return `true` if the type has no side-effects.
 131          * Unknown nodes are handled as `false`, then this rule ignores those.
 132          */
 133         const Checker = Object.assign(Object.create(null), {
 134             isDisallowed(node) {
 135                 return (Checker[node.type] || alwaysFalse)(node);
 136             },
 137
 138             ArrayExpression: alwaysTrue,
 139             ArrowFunctionExpression: alwaysTrue,
 140             BinaryExpression: alwaysTrue,
 141             ChainExpression(node) {
 142                 return Checker.isDisallowed(node.expression);
 143             },
 144             ClassExpression: alwaysTrue,
 145             ConditionalExpression(node) {
 146                 if (allowTernary) {
 147                     return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
 148                 }
 149                 return true;
 150             },
 151             FunctionExpression: alwaysTrue,
 152             Identifier: alwaysTrue,
 153             JSXElement() {
 154                 return enforceForJSX;
 155             },
 156             JSXFragment() {
 157                 return enforceForJSX;
 158             },
 159             Literal: alwaysTrue,
 160             LogicalExpression(node) {
 161                 if (allowShortCircuit) {
 162                     return Checker.isDisallowed(node.right);
 163                 }
 164                 return true;
 165             },
 166             MemberExpression: alwaysTrue,
 167             MetaProperty: alwaysTrue,
 168             ObjectExpression: alwaysTrue,
 169             SequenceExpression: alwaysTrue,
 170             TaggedTemplateExpression() {
 171                 return !allowTaggedTemplates;
 172             },
 173             TemplateLiteral: alwaysTrue,
 174             ThisExpression: alwaysTrue,
 175             UnaryExpression(node) {
 176                 return node.operator !== "void" && node.operator !== "delete";
 177             }
 178         });
 179
 180         return {
 181             ExpressionStatement(node) {
 182                 if (Checker.isDisallowed(node.expression) && !isDirective(node)) {
 183                     context.report({ node, messageId: "unusedExpression" });
 184                 }
 185             }
 186         };
 187     }
 188 };