eslint-plugin-sonarjs/cjs/S6442/rule.js

SonarJS rules for ESLint

"use strict";
/*
 * SonarQube JavaScript Plugin
 * Copyright (C) 2011-2025 SonarSource SA
 * mailto:info AT sonarsource DOT com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the Sonar Source-Available License for more details.
 *
 * You should have received a copy of the Sonar Source-Available License
 * along with this program; if not, see https://sonarsource.com/license/ssal/
 */
// https://sonarsource.github.io/rspec/#/rspec/S6442/javascript
Object.defineProperty(exports, "__esModule", { value: true });
exports.rule = void 0;
const index_js_1 = require("../helpers/index.js");
const meta_js_1 = require("./meta.js");
const REACT_MODULE = 'react';
const REACT_PATTERN = /^[^a-z]/;
const HOOK_FUNCTION = 'useState';
exports.rule = {
    meta: (0, index_js_1.generateMeta)(meta_js_1.meta, {
        messages: {
            noHookSetterInBody: 'Remove this state setter call, perhaps move it to an event handler or JSX attribute',
        },
    }),
    create(context) {
        function isHookCall(node) {
            return ((0, index_js_1.getFullyQualifiedName)(context, node) === `${REACT_MODULE}.${HOOK_FUNCTION}` &&
                node.arguments.length === 1);
        }
        function getReactComponentScope(node) {
            const scope = context.sourceCode.getScope(node);
            const isReact = (0, index_js_1.isFunctionNode)(scope.block) && matchesReactComponentName(scope.block, 1);
            return isReact ? scope : null;
        }
        function isInsideFunctionScope(scope, node) {
            function searchUpperFunctionScope(current) {
                if (current === null) {
                    return null;
                }
                else if (current.type === 'function') {
                    return current;
                }
                else {
                    return searchUpperFunctionScope(current.upper);
                }
            }
            return (scope !== null && searchUpperFunctionScope(context.sourceCode.getScope(node)) === scope);
        }
        function isInsideConditional(node) {
            return ((0, index_js_1.findFirstMatchingLocalAncestor)(node, n => n.type === 'IfStatement') !==
                undefined);
        }
        let reactComponentScope; // Scope.Scope of the React component render function.
        const setters = []; // Setter variables returned by the React useState() function.
        return {
            ':function'(node) {
                reactComponentScope ??= getReactComponentScope(node); // Store the top-most React component scope.
            },
            ':function:exit'(node) {
                if (context.sourceCode.getScope(node) === reactComponentScope) {
                    // Clean variables when leaving the React component scope.
                    reactComponentScope = null;
                    setters.length = 0;
                }
            },
            // Selector matching declarations like: const [count, setCount] = useState(0);
            ['VariableDeclarator[init.type="CallExpression"]' +
                ':has(ArrayPattern[elements.length=2][elements.0.type="Identifier"][elements.1.type="Identifier"])'](node) {
                if (!isInsideFunctionScope(reactComponentScope, node)) {
                    return;
                }
                const hookDeclarator = node;
                if (isHookCall(hookDeclarator.init)) {
                    const variable = (0, index_js_1.getVariableFromName)(context, hookDeclarator.id.elements[1].name, node);
                    if (variable != null) {
                        setters.push(variable);
                    }
                }
            },
            // Selector matching function calls like: setCount(1)
            'CallExpression[callee.type="Identifier"][arguments.length=1]'(node) {
                if (!isInsideFunctionScope(reactComponentScope, node) ||
                    setters.length === 0 ||
                    isInsideConditional(node)) {
                    return;
                }
                const maybeSetterCall = node;
                const calleeVariable = (0, index_js_1.getVariableFromName)(context, maybeSetterCall.callee.name, node);
                if (setters.some(variable => variable === calleeVariable)) {
                    context.report({
                        messageId: 'noHookSetterInBody',
                        node: node.callee,
                    });
                }
            },
        };
    },
};
function hasParent(node) {
    return node.parent != null;
}
function matchesReactComponentName(node, max = 0) {
    if (node == null) {
        return false;
    }
    else if ((0, index_js_1.isIdentifier)(node)) {
        return REACT_PATTERN.test(node.name);
    }
    else if (node.type === 'FunctionDeclaration') {
        return matchesReactComponentName(node.id);
    }
    else if (node.type === 'VariableDeclarator') {
        return matchesReactComponentName(node.id);
    }
    else if (node.type === 'AssignmentExpression') {
        return matchesReactComponentName(node.left);
    }
    else if (node.type === 'MemberExpression') {
        return matchesReactComponentName(node.property);
    }
    else if (hasParent(node) && max > 0) {
        return matchesReactComponentName(node.parent, max - 1);
    }
    else {
        return false;
    }
}