eslint-plugin-etc/dist/rules/no-assign-mutated-array.js

More general-purpose ESLint rules

"use strict";
const eslint_etc_1 = require("eslint-etc");
const utils_1 = require("../utils");
const mutatorRegExp = /^(fill|reverse|sort)$/;
const creatorRegExp = /^(concat|entries|filter|keys|map|slice|splice|values)$/;
const rule = (0, utils_1.ruleCreator)({
    defaultOptions: [],
    meta: {
        docs: {
            description: "Forbids the assignment of returned, mutated arrays.",
            recommended: false,
        },
        fixable: undefined,
        hasSuggestions: false,
        messages: {
            forbidden: "Assignment of mutated arrays is forbidden.",
        },
        schema: [],
        type: "problem",
    },
    name: "no-assign-mutated-array",
    create: (context) => {
        const { couldBeType } = (0, eslint_etc_1.getTypeServices)(context);
        return {
            [`CallExpression > MemberExpression[property.name=${mutatorRegExp.toString()}]`]: (memberExpression) => {
                const callExpression = (0, eslint_etc_1.getParent)(memberExpression);
                const parent = (0, eslint_etc_1.getParent)(callExpression);
                if (parent && !(0, eslint_etc_1.isExpressionStatement)(parent)) {
                    if (couldBeType(memberExpression.object, "Array") &&
                        mutatesReferencedArray(callExpression)) {
                        context.report({
                            messageId: "forbidden",
                            node: memberExpression.property,
                        });
                    }
                }
            },
        };
        function isNewArray(node) {
            if ((0, eslint_etc_1.isArrayExpression)(node)) {
                return true;
            }
            if ((0, eslint_etc_1.isNewExpression)(node)) {
                return true;
            }
            if ((0, eslint_etc_1.isCallExpression)(node)) {
                const { callee } = node;
                if ((0, eslint_etc_1.isIdentifier)(callee) && callee.name === "Array") {
                    return true;
                }
                if ((0, eslint_etc_1.isMemberExpression)(callee) &&
                    (0, eslint_etc_1.isIdentifier)(callee.object) &&
                    callee.object.name === "Array") {
                    return true;
                }
            }
            return false;
        }
        function mutatesReferencedArray(callExpression) {
            if ((0, eslint_etc_1.isMemberExpression)(callExpression.callee)) {
                const memberExpression = callExpression.callee;
                const { object, property } = memberExpression;
                if ((0, eslint_etc_1.isIdentifier)(property) && creatorRegExp.test(property.name)) {
                    return false;
                }
                if (isNewArray(object)) {
                    return false;
                }
                if ((0, eslint_etc_1.isCallExpression)(object)) {
                    return mutatesReferencedArray(object);
                }
            }
            return true;
        }
    },
});
module.exports = rule;