An error occurred while loading the file. Please try again.
no-unused-expressions.js 6.10 KiB
/**
 * @fileoverview Flag expressions in statement position that do not side effect
 * @author Michael Ficarra
 */
"use strict";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/**
 * Returns `true`.
 * @returns {boolean} `true`.
function alwaysTrue() {
    return true;
/**
 * Returns `false`.
 * @returns {boolean} `false`.
function alwaysFalse() {
    return false;
module.exports = {
    meta: {
        type: "suggestion",
        docs: {
            description: "disallow unused expressions",
            category: "Best Practices",
            recommended: false,
            url: "https://eslint.org/docs/rules/no-unused-expressions"
        schema: [
                type: "object",
                properties: {
                    allowShortCircuit: {
                        type: "boolean",
                        default: false
                    allowTernary: {
                        type: "boolean",
                        default: false
                    allowTaggedTemplates: {
                        type: "boolean",
                        default: false
                    enforceForJSX: {
                        type: "boolean",
                        default: false
                additionalProperties: false
        messages: {
            unusedExpression: "Expected an assignment or function call and instead saw an expression."
    create(context) {
        const config = context.options[0] || {},
            allowShortCircuit = config.allowShortCircuit || false,
allowTernary = config.allowTernary || false, allowTaggedTemplates = config.allowTaggedTemplates || false, enforceForJSX = config.enforceForJSX || false; // eslint-disable-next-line jsdoc/require-description /** * @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"; } // eslint-disable-next-line jsdoc/require-description /** * @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(); } // eslint-disable-next-line jsdoc/require-description /** * @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); } // eslint-disable-next-line jsdoc/require-description /** * @param {ASTNode} node any node * @param {ASTNode[]} ancestors the given node's ancestors * @returns {boolean} whether the given node is considered a directive in its current position */ function isDirective(node, ancestors) { const parent = ancestors[ancestors.length - 1], grandparent = ancestors[ancestors.length - 2]; return (parent.type === "Program" || parent.type === "BlockStatement" && (/Function/u.test(grandparent.type))) && directives(parent).indexOf(node) >= 0; } /** * 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.getAncestors())) { context.report({ node, messageId: "unusedExpression" }); } } }; } };