auto-cr-rules 2.0.89 → 2.0.96

package/dist/analysis.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeModule = void 0;
+// 热路径定义：循环体 + 常见数组回调（map/forEach/...）的函数体。
+var HOT_CALLBACK_METHODS = new Set([
+    'map',
+    'forEach',
+    'reduce',
+    'reduceRight',
+    'filter',
+    'some',
+    'every',
+    'find',
+    'findIndex',
+    'flatMap',
+]);
+// 共享 AST 遍历入口：一次遍历同时抽取 imports/loops/callbacks/hotPath/tryStatements。
+// 这样规则只需读取索引即可，避免每条规则重复扫 AST。
+var analyzeModule = function (ast) {
+    var imports = [];
+    var loops = [];
+    var callbacks = [];
+    var tryStatements = [];
+    var hotPath = {
+        callExpressions: [],
+        newExpressions: [],
+        regExpLiterals: [],
+    };
+    var walk = function (node, inHot) {
+        var _a;
+        if (!node || typeof node !== 'object') {
+            return;
+        }
+        var candidate = node;
+        // 先收集与类型无关的索引，避免遗漏。
+        if (candidate.type === 'ImportDeclaration') {
+            var declaration = candidate;
+            imports.push({
+                kind: 'static',
+                value: declaration.source.value,
+                span: declaration.source.span,
+            });
+            // ImportDeclaration 不需要继续深挖（内部结构固定），可以提前返回。
+            return;
+        }
+        if (candidate.type === 'TryStatement') {
+            tryStatements.push(candidate);
+        }
+        // 热路径正则字面量只在热路径内收集，避免无关代码噪声。
+        if (candidate.type === 'RegExpLiteral' && inHot) {
+            hotPath.regExpLiterals.push(candidate);
+        }
+        switch (candidate.type) {
+            case 'ForStatement': {
+                var statement = candidate;
+                loops.push({ type: 'ForStatement', node: statement });
+                // for 循环条件与循环体都视为热路径。
+                walk(statement.init, inHot);
+                walk(statement.test, true);
+                walk(statement.update, true);
+                walk(statement.body, true);
+                return;
+            }
+            case 'WhileStatement': {
+                var statement = candidate;
+                loops.push({ type: 'WhileStatement', node: statement });
+                walk(statement.test, true);
+                walk(statement.body, true);
+                return;
+            }
+            case 'DoWhileStatement': {
+                var statement = candidate;
+                loops.push({ type: 'DoWhileStatement', node: statement });
+                walk(statement.body, true);
+                walk(statement.test, true);
+                return;
+            }
+            case 'ForInStatement':
+            case 'ForOfStatement': {
+                var statement = candidate;
+                loops.push({ type: statement.type, node: statement });
+                walk(statement.left, inHot);
+                walk(statement.right, inHot);
+                walk(statement.body, true);
+                return;
+            }
+            case 'CallExpression': {
+                // 统一在这里处理 import/require、热路径调用点、数组回调。
+                handleCallExpression(candidate, inHot, imports, callbacks, hotPath, walk);
+                return;
+            }
+            case 'NewExpression': {
+                var expression = candidate;
+                // new 表达式可能构造 RegExp，因此也纳入热路径集合。
+                if (inHot) {
+                    hotPath.newExpressions.push(expression);
+                }
+                walk(expression.callee, inHot);
+                (_a = expression.arguments) === null || _a === void 0 ? void 0 : _a.forEach(function (argument) { return walk(argument.expression, inHot); });
+                return;
+            }
+            case 'OptionalChainingExpression': {
+                var expression = candidate;
+                walk(expression.base, inHot);
+                return;
+            }
+            case 'FunctionDeclaration':
+            case 'FunctionExpression':
+            case 'ArrowFunctionExpression': {
+                // 新函数不继承热路径，避免跨函数误标记。
+                walkFunctionBody(candidate, false, walk);
+                return;
+            }
+            default:
+                break;
+        }
+        // 通用遍历：对未知节点递归扫描子节点。
+        var record = candidate;
+        for (var _i = 0, _b = Object.values(record); _i < _b.length; _i++) {
+            var value = _b[_i];
+            if (Array.isArray(value)) {
+                for (var _c = 0, value_1 = value; _c < value_1.length; _c++) {
+                    var item = value_1[_c];
+                    walk(item, inHot);
+                }
+            }
+            else {
+                walk(value, inHot);
+            }
+        }
+    };
+    walk(ast, false);
+    // 对分析结果做 freeze，防止规则侧误修改。
+    return Object.freeze({
+        imports: Object.freeze(imports),
+        loops: Object.freeze(loops),
+        callbacks: Object.freeze(callbacks),
+        tryStatements: Object.freeze(tryStatements),
+        hotPath: Object.freeze({
+            callExpressions: Object.freeze(hotPath.callExpressions),
+            newExpressions: Object.freeze(hotPath.newExpressions),
+            regExpLiterals: Object.freeze(hotPath.regExpLiterals),
+        }),
+    });
+};
+exports.analyzeModule = analyzeModule;
+var handleCallExpression = function (callExpression, inHot, imports, callbacks, hotPath, walk) {
+    if (inHot) {
+        hotPath.callExpressions.push(callExpression);
+    }
+    // 解析 import(...) / require(...)，写入 import 索引。
+    var reference = extractImportReference(callExpression);
+    if (reference) {
+        imports.push(reference);
+    }
+    // 判断是否为数组高阶回调，回调函数体应当视为热路径。
+    var isHotCallback = isHotCallbackMethod(callExpression.callee);
+    walk(callExpression.callee, inHot);
+    if (!callExpression.arguments) {
+        return;
+    }
+    callExpression.arguments.forEach(function (argument, index) {
+        var expression = argument.expression;
+        // 约定数组回调的第一个参数是回调函数体，标记为热路径。
+        if (isHotCallback && index === 0 && isFunctionLike(expression)) {
+            callbacks.push({
+                method: getMemberMethodName(callExpression.callee),
+                callExpression: callExpression,
+                callback: expression,
+            });
+            // 回调函数体在热路径内执行，遍历时显式传入 true。
+            walkFunctionBody(expression, true, walk);
+            return;
+        }
+        walk(expression, inHot);
+    });
+};
+var walkFunctionBody = function (fn, inHot, walk) {
+    // 先遍历参数/装饰器等非 body 字段，保持 inHot=false，避免把定义期表达式算进热路径。
+    // 例如：默认参数表达式不应被当作热路径执行。
+    // TypeScript 对 AST 节点没有索引签名，这里先转为 unknown 再转 Record。
+    var record = fn;
+    for (var _i = 0, _a = Object.entries(record); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        if (key === 'body') {
+            continue;
+        }
+        if (key === 'params' && Array.isArray(value)) {
+            for (var _c = 0, value_2 = value; _c < value_2.length; _c++) {
+                var param = value_2[_c];
+                walk(param, false);
+            }
+            continue;
+        }
+        walk(value, false);
+    }
+    // body 按当前规则标记热路径（回调函数体会传入 true）。
+    walk(fn.body, inHot);
+};
+var isFunctionLike = function (candidate) {
+    return candidate.type === 'FunctionExpression' || candidate.type === 'ArrowFunctionExpression';
+};
+// 判断是否为数组高阶方法（如 arr.map/arr.forEach）。
+var isHotCallbackMethod = function (callee) {
+    if (!callee || typeof callee !== 'object') {
+        return false;
+    }
+    var candidate = callee;
+    if (candidate.type !== 'MemberExpression') {
+        return false;
+    }
+    var member = callee;
+    var property = member.property;
+    if (property.type === 'Identifier') {
+        return HOT_CALLBACK_METHODS.has(property.value);
+    }
+    if (property.type === 'Computed' && property.expression.type === 'StringLiteral') {
+        return HOT_CALLBACK_METHODS.has(property.expression.value);
+    }
+    return false;
+};
+// 提取形如 obj.method(...) 的方法名，用于回调索引。
+var getMemberMethodName = function (expression) {
+    if (!expression || expression.type !== 'MemberExpression') {
+        return null;
+    }
+    var member = expression;
+    var property = member.property;
+    if (property.type === 'Identifier') {
+        return property.value;
+    }
+    if (property.type === 'Computed' && property.expression.type === 'StringLiteral') {
+        return property.expression.value;
+    }
+    return null;
+};
+// 从调用表达式中提取 import/require 的字符串字面量参数。
+var extractImportReference = function (node) {
+    if (!node.arguments.length) {
+        return null;
+    }
+    var firstArgument = node.arguments[0];
+    if (!firstArgument || isSpread(firstArgument)) {
+        return null;
+    }
+    var literal = getStringLiteral(firstArgument);
+    if (!literal) {
+        return null;
+    }
+    if (node.callee.type === 'Import') {
+        return createImportReference('dynamic', literal);
+    }
+    if (isRequireIdentifier(node.callee) || isRequireMember(node.callee)) {
+        return createImportReference('require', literal);
+    }
+    return null;
+};
+var createImportReference = function (kind, literal) { return ({
+    kind: kind,
+    value: literal.value,
+    span: literal.span,
+}); };
+var isSpread = function (argument) { return Boolean(argument.spread); };
+var getStringLiteral = function (argument) {
+    if (argument.expression.type === 'StringLiteral') {
+        return argument.expression;
+    }
+    return null;
+};
+var isRequireIdentifier = function (expression) {
+    return expression.type === 'Identifier' && expression.value === 'require';
+};
+var isRequireMember = function (expression) {
+    return (expression.type === 'MemberExpression' &&
+        expression.object.type === 'Identifier' &&
+        expression.object.value === 'require');
+};

package/dist/messages.js

@@ -13,6 +13,10 @@ var ruleTranslations = {
             var chain = _a.chain;
             return "\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ".concat(chain);
         },
+        unresolvedImport: function (_a) {
+            var value = _a.value;
+            return "\u65E0\u6CD5\u89E3\u6790\u5BFC\u5165 \"".concat(value, "\"\uFF0C\u8BF7\u68C0\u67E5 tsconfig paths/baseUrl/rootDirs \u6216 package.json exports\u3002");
+        },
         noCatastrophicRegex: function (_a) {
             var pattern = _a.pattern;
             return "\u70ED\u8DEF\u5F84\u6B63\u5219\u5305\u542B\u5D4C\u5957\u7684\u65E0\u9650\u91CF\u8BCD\uFF0C\u53EF\u80FD\u5F15\u53D1\u707E\u96BE\u6027\u56DE\u6EAF: ".concat(pattern);
@@ -33,6 +37,10 @@ var ruleTranslations = {
             var chain = _a.chain;
             return "Circular dependency detected: ".concat(chain);
         },
+        unresolvedImport: function (_a) {
+            var value = _a.value;
+            return "Unable to resolve import \"".concat(value, "\". Check tsconfig paths/baseUrl/rootDirs or package.json exports.");
+        },
         noCatastrophicRegex: function (_a) {
             var pattern = _a.pattern;
             return "Regex in a hot path contains nested unbounded quantifiers and may trigger catastrophic backtracking: ".concat(pattern);

package/dist/rules/noCatastrophicRegex.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noCatastrophicRegex = void 0;
 var types_1 = require("../types");
-var hotPath_1 = require("./utils/hotPath");
 // 检测热路径中可能引发灾难性回溯的嵌套无限量词正则。
 // 只处理字面量或静态字符串/模板字符串构造的 RegExp，忽略动态拼接。
 exports.noCatastrophicRegex = (0, types_1.defineRule)('no-catastrophic-regex', { tag: 'performance', severity: types_1.RuleSeverity.Optimizing }, function (_a) {
-    var ast = _a.ast, helpers = _a.helpers, language = _a.language, messages = _a.messages;
+    var analysis = _a.analysis, helpers = _a.helpers, language = _a.language, messages = _a.messages;
     var suggestions = language === 'zh'
         ? [
             { text: '避免嵌套无限量词，给量词增加上限或使用更具体的匹配。' },
@@ -16,42 +15,45 @@ exports.noCatastrophicRegex = (0, types_1.defineRule)('no-catastrophic-regex', {
             { text: 'Avoid nested unbounded quantifiers by adding bounds or more specific tokens.' },
             { text: 'Split the regex into multiple passes or pre-filter before matching.' },
         ];
-    (0, hotPath_1.walkHotPath)(ast, function (node, inHot) {
-        if (!inHot || !node || typeof node !== 'object') {
-            return;
+    // hotPath 索引已由共享遍历生成，这里直接遍历相关节点。
+    for (var _i = 0, _b = analysis.hotPath.regExpLiterals; _i < _b.length; _i++) {
+        var literal = _b[_i];
+        if (!hasNestedUnboundedQuantifier(literal.pattern)) {
+            continue;
         }
-        var candidate = node;
-        // 直接的 /.../ 字面量。
-        if (candidate.type === 'RegExpLiteral') {
-            var literal = candidate;
-            if (!hasNestedUnboundedQuantifier(literal.pattern)) {
-                return;
-            }
-            helpers.reportViolation({
-                description: messages.noCatastrophicRegex({ pattern: literal.pattern }),
-                code: literal.pattern,
-                suggestions: suggestions,
-                span: literal.span,
-            }, literal.span);
-            return;
+        helpers.reportViolation({
+            description: messages.noCatastrophicRegex({ pattern: literal.pattern }),
+            code: literal.pattern,
+            suggestions: suggestions,
+            span: literal.span,
+        }, literal.span);
+    }
+    for (var _c = 0, _d = analysis.hotPath.callExpressions; _c < _d.length; _c++) {
+        var callExpression = _d[_c];
+        var info = extractRegExpPattern(callExpression);
+        if (!info || !hasNestedUnboundedQuantifier(info.pattern)) {
+            continue;
         }
-        // RegExp('...') 或 new RegExp('...') 的静态模式。
-        if (candidate.type === 'CallExpression' || candidate.type === 'NewExpression') {
-            var info = extractRegExpPattern(candidate);
-            if (!info) {
-                return;
-            }
-            if (!hasNestedUnboundedQuantifier(info.pattern)) {
-                return;
-            }
-            helpers.reportViolation({
-                description: messages.noCatastrophicRegex({ pattern: info.pattern }),
-                code: info.pattern,
-                suggestions: suggestions,
-                span: info.span,
-            }, info.span);
+        helpers.reportViolation({
+            description: messages.noCatastrophicRegex({ pattern: info.pattern }),
+            code: info.pattern,
+            suggestions: suggestions,
+            span: info.span,
+        }, info.span);
+    }
+    for (var _e = 0, _f = analysis.hotPath.newExpressions; _e < _f.length; _e++) {
+        var newExpression = _f[_e];
+        var info = extractRegExpPattern(newExpression);
+        if (!info || !hasNestedUnboundedQuantifier(info.pattern)) {
+            continue;
         }
-    });
+        helpers.reportViolation({
+            description: messages.noCatastrophicRegex({ pattern: info.pattern }),
+            code: info.pattern,
+            suggestions: suggestions,
+            span: info.span,
+        }, info.span);
+    }
 });
 // 提取静态 RegExp 字符串，动态表达式直接跳过。
 var extractRegExpPattern = function (expression) {