poe-code 4.0.57 → 4.0.59

package/packages/safejs/dist/lint/rules/AS012.js

@@ -1,384 +0,0 @@
-import { parseModule } from "../../parse/parser.js";
-const SORT_MESSAGE = "Array#sort only supports comparators that are arrows returning a number.";
-const NUMBER_RETURNING_BINARY_OPERATORS = new Set([
-    "%",
-    "*",
-    "**",
-    "-",
-    "/",
-    "<<",
-    ">>",
-    ">>>",
-    "&",
-    "^",
-    "|"
-]);
-export function AS012(source, options = {}) {
-    return new AS012Scanner(options.filename ?? "<input>").scan(source);
-}
-class AS012Scanner {
-    filename;
-    diagnostics = [];
-    constructor(filename) {
-        this.filename = filename;
-    }
-    scan(source) {
-        this.visitModule(parseModule(source, this.filename));
-        return this.diagnostics;
-    }
-    visitModule(node) {
-        for (const statement of node.body) {
-            this.visitStatement(statement);
-        }
-    }
-    visitStatement(node) {
-        switch (node.type) {
-            case "BlockStatement":
-                for (const statement of node.body) {
-                    this.visitStatement(statement);
-                }
-                return;
-            case "ExpressionStatement":
-                this.visitExpression(node.expression);
-                return;
-            case "IfStatement":
-                this.visitIfStatement(node);
-                return;
-            case "ForStatement":
-                this.visitForStatement(node);
-                return;
-            case "ForInStatement":
-            case "ForOfStatement":
-                this.visitForOfStatement(node);
-                return;
-            case "WhileStatement":
-            case "DoWhileStatement":
-                this.visitWhileStatement(node);
-                return;
-            case "TryStatement":
-                this.visitTryStatement(node);
-                return;
-            case "VariableDeclaration":
-                this.visitVariableDeclaration(node);
-                return;
-            case "ReturnStatement":
-                this.visitReturnStatement(node);
-                return;
-            case "ThrowStatement":
-                this.visitThrowStatement(node);
-                return;
-            case "ExportNamedDeclaration":
-                this.visitVariableDeclaration(node.declaration);
-                return;
-            case "ExportDefaultDeclaration":
-                this.visitExpression(node.declaration);
-                return;
-            case "ImportDeclaration":
-            case "BreakStatement":
-            case "ContinueStatement":
-                return;
-        }
-    }
-    visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== undefined) {
-            this.visitStatement(node.alternate);
-        }
-    }
-    visitForStatement(node) {
-        if (node.init !== undefined) {
-            if (node.init.type === "VariableDeclaration") {
-                this.visitVariableDeclaration(node.init);
-            }
-            else {
-                this.visitExpression(node.init);
-            }
-        }
-        if (node.test !== undefined) {
-            this.visitExpression(node.test);
-        }
-        if (node.update !== undefined) {
-            this.visitExpression(node.update);
-        }
-        this.visitStatement(node.body);
-    }
-    visitForOfStatement(node) {
-        if (node.left.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.left);
-        }
-        else {
-            this.visitPattern(node.left);
-        }
-        this.visitExpression(node.right);
-        this.visitStatement(node.body);
-    }
-    visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-    }
-    visitTryStatement(node) {
-        this.visitStatement(node.block);
-        if (node.handler !== undefined) {
-            this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== undefined) {
-            this.visitStatement(node.finalizer);
-        }
-    }
-    visitCatchClause(node) {
-        if (node.param !== undefined) {
-            this.visitPattern(node.param);
-        }
-        this.visitStatement(node.body);
-    }
-    visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-            this.visitVariableDeclarator(declarator);
-        }
-    }
-    visitVariableDeclarator(node) {
-        this.visitPattern(node.id);
-        if (node.init !== undefined) {
-            this.visitExpression(node.init);
-        }
-    }
-    visitReturnStatement(node) {
-        if (node.argument !== undefined) {
-            this.visitExpression(node.argument);
-        }
-    }
-    visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-    }
-    visitExpression(node) {
-        switch (node.type) {
-            case "ArrowFunctionExpression":
-                this.visitArrowFunction(node);
-                return;
-            case "AwaitExpression":
-                this.visitExpression(node.argument);
-                return;
-            case "ArrayExpression":
-                this.visitArrayExpression(node);
-                return;
-            case "ObjectExpression":
-                this.visitObjectExpression(node);
-                return;
-            case "UnaryExpression":
-                this.visitUnaryExpression(node);
-                return;
-            case "BinaryExpression":
-            case "LogicalExpression":
-                this.visitBinaryLikeExpression(node);
-                return;
-            case "ConditionalExpression":
-                this.visitConditionalExpression(node);
-                return;
-            case "MemberExpression":
-                this.visitMemberExpression(node);
-                return;
-            case "AssignmentExpression":
-                this.visitAssignmentExpression(node);
-                return;
-            case "CallExpression":
-                this.visitCallExpression(node);
-                return;
-            case "TemplateLiteral":
-                this.visitTemplateLiteral(node);
-                return;
-            case "Identifier":
-            case "BooleanLiteral":
-            case "NullLiteral":
-            case "NumericLiteral":
-            case "RegexLiteral":
-            case "StringLiteral":
-            case "UndefinedLiteral":
-                return;
-        }
-    }
-    visitArrowFunction(node) {
-        for (const parameter of node.params) {
-            this.visitPattern(parameter);
-        }
-        if (node.body.type === "BlockStatement") {
-            for (const statement of node.body.body) {
-                this.visitStatement(statement);
-            }
-            return;
-        }
-        this.visitExpression(node.body);
-    }
-    visitArrayExpression(node) {
-        for (const element of node.elements) {
-            if (element.type === "SpreadElement") {
-                this.visitExpression(element.argument);
-                continue;
-            }
-            this.visitExpression(element);
-        }
-    }
-    visitObjectExpression(node) {
-        for (const property of node.properties) {
-            if (property.type === "SpreadElement") {
-                this.visitExpression(property.argument);
-                continue;
-            }
-            this.visitProperty(property);
-        }
-    }
-    visitProperty(node) {
-        if (node.computed) {
-            this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-    }
-    visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-    }
-    visitBinaryLikeExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-    }
-    visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-    }
-    visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-            this.visitExpression(node.property);
-        }
-    }
-    visitAssignmentExpression(node) {
-        this.visitPattern(node.left);
-        this.visitExpression(node.right);
-    }
-    visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        this.reportUnsupportedMethodArgs(node);
-        for (const argument of node.arguments) {
-            this.visitCallArgument(argument);
-        }
-    }
-    visitCallArgument(node) {
-        if (node.type === "SpreadElement") {
-            this.visitExpression(node.argument);
-            return;
-        }
-        this.visitExpression(node);
-    }
-    visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-            this.visitExpression(expression);
-        }
-    }
-    visitPattern(node) {
-        switch (node.type) {
-            case "Identifier":
-            case "MetaProperty":
-                return;
-            case "MemberExpression":
-                this.visitMemberExpression(node);
-                return;
-            case "ArrayPattern":
-                for (const element of node.elements) {
-                    if (element === null) {
-                        continue;
-                    }
-                    this.visitPattern(element);
-                }
-                return;
-            case "ObjectPattern":
-                for (const property of node.properties) {
-                    if (property.type === "RestElement") {
-                        this.visitPattern(property);
-                        continue;
-                    }
-                    if (property.computed) {
-                        this.visitExpression(property.key);
-                    }
-                    this.visitPattern(property.value);
-                }
-                return;
-            case "AssignmentPattern":
-                this.visitPattern(node.left);
-                this.visitExpression(node.right);
-                return;
-            case "RestElement":
-                this.visitPattern(node.argument);
-                return;
-        }
-    }
-    reportUnsupportedMethodArgs(node) {
-        const methodName = getMemberPropertyName(node.callee);
-        if (methodName === undefined) {
-            return;
-        }
-        if (methodName !== "sort") {
-            return;
-        }
-        const comparator = node.arguments[0];
-        if (comparator === undefined || comparator.type === "SpreadElement") {
-            return;
-        }
-        if (!isSupportedSortComparator(comparator)) {
-            this.report(comparator.span, SORT_MESSAGE);
-        }
-    }
-    report(span, message) {
-        this.diagnostics.push({
-            code: "AS012",
-            severity: "error",
-            message,
-            filename: this.filename,
-            line: span.start.line,
-            column: span.start.column,
-            span
-        });
-    }
-}
-function getMemberPropertyName(node) {
-    if (node.type !== "MemberExpression") {
-        return undefined;
-    }
-    if (!node.computed && node.property.type === "Identifier") {
-        return node.property.name;
-    }
-    if (node.computed && node.property.type === "StringLiteral") {
-        return node.property.value;
-    }
-    return undefined;
-}
-function isSupportedSortComparator(node) {
-    return node.type === "ArrowFunctionExpression" && !node.async && isNumberReturningArrow(node);
-}
-function isNumberReturningArrow(node) {
-    if (node.body.type === "BlockStatement") {
-        return false;
-    }
-    return isClearlyNumberExpression(node.body);
-}
-function isClearlyNumberExpression(node) {
-    switch (node.type) {
-        case "NumericLiteral":
-            return true;
-        case "RegexLiteral":
-            return false;
-        case "UnaryExpression":
-            return ((node.operator === "+" || node.operator === "-" || node.operator === "~") &&
-                isClearlyNumberExpression(node.argument));
-        case "BinaryExpression":
-            return NUMBER_RETURNING_BINARY_OPERATORS.has(node.operator);
-        case "ConditionalExpression":
-            return (isClearlyNumberExpression(node.consequent) && isClearlyNumberExpression(node.alternate));
-        case "CallExpression":
-            return isLocaleCompareCall(node);
-        default:
-            return false;
-    }
-}
-function isLocaleCompareCall(node) {
-    return getMemberPropertyName(node.callee) === "localeCompare";
-}