@atlisp/lint 0.1.2 → 0.1.4

package/README.md

@@ -37,6 +37,9 @@ npx @atlisp/lint --fix
 --init               在当前目录生成 atlisp-lint.json
 --install-hook       安装 git pre-commit hook
 --fix                自动修复尾部空格、UTF-8 BOM 等问题
+--cache              启用文件哈希缓存，跳过未变更的文件
+--clear-cache        清除缓存目录
+--parallel           开启多线程并行检查（使用 Worker Threads）
 --hook-args <args>   自定义 pre-commit hook 参数（配合 --install-hook）
 ```
 

package/atlisp-lint.default.json

@@ -21,15 +21,34 @@
     "parameter_naming": "warn",
     "unused_variable": "warn",
     "missing_doc": "warn",
-    "error_handling": "warn",
-    "global_naming": "warn",
-    "extra_parens": "warn",
-    "arg_count": "warn",
-    "strcat_usage": "warn",
-    "cond_simplify": "warn",
     "trailing_whitespace": "warn",
     "module_registration": "off",
-    "namespace_header": "off"
+    "namespace_header": "off",
+    "unused_parameter": "warn",
+    "constant_condition": "warn",
+    "redundant_progn": "warn",
+    "empty_branch": "warn",
+    "unused_let_binding": "warn",
+    "recursive_call": "warn",
+    "variable_shadow": "warn",
+    "redundant_cond": "warn",
+    "unused_local_fun": "warn",
+    "multiple_setq": "warn",
+    "redundant_quotes": "warn",
+    "trailing_paren": "warn",
+    "empty_comment": "warn",
+    "redundant_setq": "warn",
+    "redundant_nil_else": "warn",
+    "single_arg_and_or": "warn",
+    "redundant_let": "warn",
+    "self_compare": "warn",
+    "misplaced_else": "warn",
+    "quote_vs_function": "warn",
+    "commented_code": "warn",
+    "double_not": "warn",
+    "dangling_defun": "warn",
+    "missing_export": "warn",
+    "unused_package_dep": "warn"
   },
   "line_length": {
     "max": 100,

package/dist/checks/bare-names.js

@@ -18,7 +18,10 @@ function checkBareFunctionNames(content, file, allowlist, namespacePattern) {
             continue; // local: defun foo/bar
         if (!nsRegex.test(name) && !name.includes(':')) {
             issues.push({
-                file, line: lineno, severity: 'warn', rule: 'bare_function_names',
+                file,
+                line: lineno,
+                severity: 'warn',
+                rule: 'bare_function_names',
                 message: (0, locale_1.t)('bare_function_names', name),
             });
         }

package/dist/checks/cl-syntax.js

@@ -13,7 +13,10 @@ function checkClSyntax(content, file, keywords) {
             const idx = s.indexOf(kw);
             if (idx >= 0 && (idx === 0 || !/[a-zA-Z]/.test(s[idx - 1]))) {
                 issues.push({
-                    file, line: lineno, severity: 'warn', rule: 'cl_syntax',
+                    file,
+                    line: lineno,
+                    severity: 'warn',
+                    rule: 'cl_syntax',
                     message: (0, locale_1.t)('cl_syntax', kw),
                 });
             }

package/dist/checks/commented-code.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkCommentedCode(content: string, file: string): Issue[];
+//# sourceMappingURL=commented-code.d.ts.map

package/dist/checks/commented-code.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommentedCode = checkCommentedCode;
+const locale_1 = require("../locale");
+const CODE_PATTERNS = [
+    /^\s*\(defun\s/i,
+    /^\s*\(setq\s/i,
+    /^\s*\(if\s/i,
+    /^\s*\(cond\s/i,
+    /^\s*\(while\s/i,
+    /^\s*\(foreach\s/i,
+    /^\s*\(let\s/i,
+    /^\s*\(lambda\s/i,
+    /^\s*\(repeat\s/i,
+    /^\s*\(progn\s/i,
+    /^\s*\(princ?\s/i,
+    /^\s*\(command\s/i,
+    /^\s*\(defun-q\s/i,
+    /^\s*\(vl-\S/,
+    /^\s*\(vla-\S/,
+];
+function checkCommentedCode(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(/^\s*;+([^;].*)$/);
+        if (!match)
+            continue;
+        const afterSemicolon = match[1];
+        for (const pat of CODE_PATTERNS) {
+            if (pat.test(afterSemicolon)) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'commented_code',
+                    message: (0, locale_1.t)('commented_code'),
+                });
+                break;
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=commented-code.js.map

package/dist/checks/constant-condition.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkConstantCondition(content: string, file: string): Issue[];
+export declare function checkConstantConditionAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=constant-condition.d.ts.map

package/dist/checks/constant-condition.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConstantCondition = checkConstantCondition;
+exports.checkConstantConditionAst = checkConstantConditionAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const CONDITION_FORMS = new Set(['if', 'while']);
+const CONSTANTS = new Set(['T', 'nil']);
+function checkConstantCondition(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkConstantConditionAst(ast, file);
+}
+function checkConstantConditionAst(ast, file) {
+    const issues = [];
+    // Check if / while with constant condition
+    for (const form of CONDITION_FORMS) {
+        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        for (const node of nodes) {
+            if (!node.children || node.children.length < 2)
+                continue;
+            const cond = node.children[1];
+            if (cond.type === 'symbol' && cond.name && CONSTANTS.has(cond.name)) {
+                issues.push({
+                    file,
+                    line: cond.pos.line,
+                    severity: 'warn',
+                    rule: 'constant_condition',
+                    message: (0, locale_1.t)('constant_condition', cond.name, `(${form} ...)`),
+                });
+            }
+        }
+    }
+    // Check (cond (T ...))
+    const condNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'cond'));
+    for (const condNode of condNodes) {
+        if (!condNode.children)
+            continue;
+        for (let i = 1; i < condNode.children.length; i++) {
+            const clause = condNode.children[i];
+            if (clause.type !== 'list' || !clause.children || clause.children.length === 0)
+                continue;
+            const condTest = clause.children[0];
+            if (condTest.type === 'symbol' && condTest.name && CONSTANTS.has(condTest.name)) {
+                issues.push({
+                    file,
+                    line: condTest.pos.line,
+                    severity: 'warn',
+                    rule: 'constant_condition',
+                    message: (0, locale_1.t)('constant_condition', condTest.name, '(cond ...)'),
+                });
+            }
+        }
+    }
+    // Check (or T ...) — first arg is T, always short-circuits to T
+    const orNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'or'));
+    for (const node of orNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const first = node.children[1];
+        if (first.type === 'symbol' && first.name === 'T') {
+            issues.push({
+                file,
+                line: first.pos.line,
+                severity: 'warn',
+                rule: 'constant_condition',
+                message: (0, locale_1.t)('constant_condition', 'T', '(or ...)'),
+            });
+        }
+    }
+    // Check (and nil ...) — first arg is nil, always short-circuits to nil
+    const andNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'and'));
+    for (const node of andNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const first = node.children[1];
+        if (first.type === 'symbol' && first.name === 'nil') {
+            issues.push({
+                file,
+                line: first.pos.line,
+                severity: 'warn',
+                rule: 'constant_condition',
+                message: (0, locale_1.t)('constant_condition', 'nil', '(and ...)'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=constant-condition.js.map

package/dist/checks/dangerous-calls.d.ts

@@ -1,3 +1,5 @@
 import { Issue, DangerousCallsConfig } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkDangerousCalls(content: string, file: string, config: DangerousCallsConfig): Issue[];
+export declare function checkDangerousCallsAst(ast: AstNode, file: string, config: DangerousCallsConfig): Issue[];
 //# sourceMappingURL=dangerous-calls.d.ts.map

package/dist/checks/dangerous-calls.js

@@ -1,41 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDangerousCalls = checkDangerousCalls;
-const utils_1 = require("../utils");
+exports.checkDangerousCallsAst = checkDangerousCallsAst;
 const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
 const PATTERNS = [
-    { rule: 'quit', check: l => /\bquit\b/.test(l), key: 'quit', useStripped: true },
-    { rule: 'exit', check: l => /\bexit\b/.test(l), key: 'exit', useStripped: true },
-    { rule: 'command_shell', check: l => /\(command\s+"shell"\s/.test(l), key: 'command_shell' },
-    { rule: 'startapp', check: l => /\bstartapp\b/.test(l), key: 'startapp' },
-    { rule: 'vl_registry_write', check: l => /\bvl-registry-write\b/.test(l), key: 'vl_registry_write' },
+    { rule: 'quit', key: 'quit', messageKey: 'dangerous.quit', functionCall: true },
+    { rule: 'exit', key: 'exit', messageKey: 'dangerous.exit', functionCall: true },
+    { rule: 'startapp', key: 'startapp', messageKey: 'dangerous.startapp', functionCall: true },
+    {
+        rule: 'vl_registry_write',
+        key: 'vl_registry_write',
+        messageKey: 'dangerous.vl_registry_write',
+        functionCall: true,
+    },
+    { rule: 'command_shell', key: 'command_shell', messageKey: 'dangerous.command_shell', commandShell: true },
 ];
-const MESSAGE_KEYS = {
-    quit: 'dangerous.quit',
-    exit: 'dangerous.exit',
-    command_shell: 'dangerous.command_shell',
-    startapp: 'dangerous.startapp',
-    vl_registry_write: 'dangerous.vl_registry_write',
-};
+function isInQuote(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'list' &&
+            cur.children &&
+            cur.children.length > 0 &&
+            cur.children[0].type === 'symbol' &&
+            cur.children[0].name === 'quote') {
+            return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
+function isFunctionCall(list, name) {
+    if (list.type !== 'list' || !list.children || list.children.length === 0)
+        return false;
+    return list.children[0].type === 'symbol' && list.children[0].name === name;
+}
 function checkDangerousCalls(content, file, config) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkDangerousCallsAst(ast, file, config);
+}
+function checkDangerousCallsAst(ast, file, config) {
     const issues = [];
-    const lines = content.split('\n');
-    for (let lineno = 1; lineno <= lines.length; lineno++) {
-        const line = lines[lineno - 1];
-        // Two versions: without strings (for bare word checks) and with strings (for quoted arg checks)
-        const strippedCode = (0, utils_1.stripLine)(line).trim(); // strings removed
-        const strippedRaw = (0, utils_1.stripLineRaw)(line).trim(); // strings preserved
-        for (const p of PATTERNS) {
-            const configuredSeverity = config[p.key];
-            if (configuredSeverity === 'off')
-                continue;
-            const testStr = p.useStripped ? strippedCode : strippedRaw;
-            if (!testStr)
-                continue;
-            if (p.check(testStr)) {
+    for (const pattern of PATTERNS) {
+        const severity = config[pattern.key];
+        if (severity === 'off')
+            continue;
+        if (pattern.commandShell) {
+            // Find (command "shell" ...) calls
+            const commandCalls = (0, parser_1.astFindAll)(ast, (n) => isFunctionCall(n, 'command'));
+            for (const call of commandCalls) {
+                if (isInQuote(call))
+                    continue;
+                if (!call.children || call.children.length < 2)
+                    continue;
+                const firstArg = call.children[1];
+                if (firstArg.type === 'string' && firstArg.value === 'shell') {
+                    issues.push({
+                        file,
+                        line: call.pos.line,
+                        severity,
+                        rule: pattern.rule,
+                        message: (0, locale_1.t)(pattern.messageKey),
+                    });
+                }
+            }
+        }
+        else if (pattern.functionCall) {
+            // Find actual function calls
+            const calls = (0, parser_1.astFindAll)(ast, (n) => isFunctionCall(n, pattern.rule));
+            for (const call of calls) {
+                if (isInQuote(call))
+                    continue;
                 issues.push({
-                    file, line: lineno, severity: configuredSeverity, rule: p.rule,
-                    message: (0, locale_1.t)(MESSAGE_KEYS[p.rule]),
+                    file,
+                    line: call.pos.line,
+                    severity,
+                    rule: pattern.rule,
+                    message: (0, locale_1.t)(pattern.messageKey),
                 });
             }
         }

package/dist/checks/dangling-defun.d.ts

@@ -0,0 +1,6 @@
+import { Issue } from '../types';
+export declare function checkDanglingDefun(file: string, allDefuns: Map<string, {
+    file: string;
+    line: number;
+}[]>): Issue[];
+//# sourceMappingURL=dangling-defun.d.ts.map

package/dist/checks/dangling-defun.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDanglingDefun = checkDanglingDefun;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const fs = __importStar(require("fs"));
+function checkDanglingDefun(file, allDefuns) {
+    const issues = [];
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const localDefuns = [];
+    const defunNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
+    for (const node of defunNodes) {
+        if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            localDefuns.push(node.children[1].name);
+        }
+    }
+    const calledSymbols = new Set();
+    const allCalls = (0, parser_1.astFindAll)(ast, (n) => {
+        if (n.type !== 'list' || !n.children || n.children.length === 0)
+            return false;
+        return (0, parser_1.astIsSymbol)(n.children[0]);
+    });
+    for (const call of allCalls) {
+        const name = call.children[0].name;
+        if (name !== 'defun' && name !== 'defun-q' && !name.startsWith('c:') && !name.includes(':')) {
+            calledSymbols.add(name);
+        }
+    }
+    for (const defunName of localDefuns) {
+        let isCalled = calledSymbols.has(defunName);
+        if (!isCalled) {
+            for (const [, defs] of allDefuns) {
+                if (defs.some((d) => d.file !== file)) {
+                    isCalled = true;
+                    break;
+                }
+            }
+        }
+        if (!isCalled) {
+            issues.push({
+                file,
+                line: defunNodes.find((n) => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === defunName).pos.line,
+                severity: 'warn',
+                rule: 'dangling_defun',
+                message: (0, locale_1.t)('dangling_defun', defunName),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=dangling-defun.js.map

package/dist/checks/double-not.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkDoubleNot(content: string, file: string): Issue[];
+export declare function checkDoubleNotAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=double-not.d.ts.map

package/dist/checks/double-not.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDoubleNot = checkDoubleNot;
+exports.checkDoubleNotAst = checkDoubleNotAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkDoubleNot(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkDoubleNotAst(ast, file);
+}
+function checkDoubleNotAst(ast, file) {
+    const issues = [];
+    const notNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'not'));
+    for (const node of notNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const arg = node.children[1];
+        if (!(0, parser_1.astIsList)(arg, 'not'))
+            continue;
+        issues.push({
+            file,
+            line: node.pos.line,
+            severity: 'warn',
+            rule: 'double_not',
+            message: (0, locale_1.t)('double_not'),
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=double-not.js.map

package/dist/checks/empty-branch.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkEmptyBranch(content: string, file: string): Issue[];
+export declare function checkEmptyBranchAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=empty-branch.d.ts.map

package/dist/checks/empty-branch.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmptyBranch = checkEmptyBranch;
+exports.checkEmptyBranchAst = checkEmptyBranchAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+// AutoLISP only has `if` for conditional branching; `while` with no body is valid (no-op loop)
+const BRANCH_FORMS = new Set(['if']);
+function checkEmptyBranch(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkEmptyBranchAst(ast, file);
+}
+function checkEmptyBranchAst(ast, file) {
+    const issues = [];
+    for (const form of BRANCH_FORMS) {
+        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        for (const node of nodes) {
+            if (!node.children)
+                continue;
+            // (if cond) — no then or else, only 2 items (form + cond)
+            if (node.children.length < 3) {
+                issues.push({
+                    file,
+                    line: node.pos.line,
+                    severity: 'warn',
+                    rule: 'empty_branch',
+                    message: (0, locale_1.t)('empty_branch', `(${form} ...)`),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=empty-branch.js.map

package/dist/checks/empty-comments.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkEmptyComments(content: string, file: string): Issue[];
+//# sourceMappingURL=empty-comments.d.ts.map

package/dist/checks/empty-comments.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmptyComments = checkEmptyComments;
+const locale_1 = require("../locale");
+function checkEmptyComments(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Check: line is a comment with only whitespace after the ;
+        if (line.startsWith(';')) {
+            const afterSemicolon = line.slice(1);
+            if (afterSemicolon.trim() === '') {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'empty_comment',
+                    message: (0, locale_1.t)('empty_comment'),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=empty-comments.js.map

package/dist/checks/encoding.js

@@ -6,9 +6,12 @@ function checkEncoding(content, file) {
     const issues = [];
     const raw = Buffer.from(content, 'utf-8');
     // BOM detection
-    if (raw.length >= 3 && raw[0] === 0xEF && raw[1] === 0xBB && raw[2] === 0xBF) {
+    if (raw.length >= 3 && raw[0] === 0xef && raw[1] === 0xbb && raw[2] === 0xbf) {
         issues.push({
-            file, line: 1, severity: 'warn', rule: 'encoding',
+            file,
+            line: 1,
+            severity: 'warn',
+            rule: 'encoding',
             message: (0, locale_1.t)('encoding.bom'),
         });
     }
@@ -17,14 +20,20 @@ function checkEncoding(content, file) {
         const roundtrip = Buffer.from(content, 'utf-8').toString('utf-8');
         if (roundtrip !== content) {
             issues.push({
-                file, line: 1, severity: 'error', rule: 'encoding',
+                file,
+                line: 1,
+                severity: 'error',
+                rule: 'encoding',
                 message: (0, locale_1.t)('encoding.non_utf8_cad'),
             });
         }
     }
     catch {
         issues.push({
-            file, line: 1, severity: 'error', rule: 'encoding',
+            file,
+            line: 1,
+            severity: 'error',
+            rule: 'encoding',
             message: (0, locale_1.t)('encoding.non_utf8'),
         });
     }

package/dist/checks/function-complexity.d.ts

@@ -1,3 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkFunctionComplexity(content: string, file: string, maxLines: number, maxNesting: number): Issue[];
+export declare function checkFunctionComplexityAst(ast: AstNode, file: string, maxLines: number, maxNesting: number): Issue[];
 //# sourceMappingURL=function-complexity.d.ts.map