@atlisp/lint 0.1.17 → 0.1.19

package/README.md

@@ -92,7 +92,6 @@ npx @atlisp/lint --format-check
 | `constant_condition` | warn | 风格 | if/while/cond 中常量条件 |
 | `redundant_progn` | warn | 风格 | 分支中多余 progn |
 | `empty_branch` | warn | 风格 | if/cond 中空分支 |
-| `redundant_cond` | warn | 风格 | 单子句 cond 或末尾 T 子句 |
 | `redundant_if` | warn | 风格 | if/when 中冗余 progn |
 | `redundant_let` | warn | 风格 | 无绑定 let 建议改用 progn |
 | `redundant_quotes` | warn | 风格 | 冗余双引号 ''x |
@@ -232,12 +231,12 @@ npx @atlisp/lint --format-check
   },
   "preset": "recommended",
   "line_length": {
-    "max": 100,
+    "max": 200,
     "tab_width": 2
   },
   "function_complexity": {
-    "max_lines": 60,
-    "max_nesting": 6
+    "max_lines": 300,
+    "max_nesting": 30
   },
   "cl_syntax": {
     "keywords": ["&key"]

package/atlisp-lint.default.json

@@ -31,7 +31,6 @@
     "unused_let_binding": "warn",
     "recursive_call": "warn",
     "variable_shadow": "warn",
-    "redundant_cond": "warn",
     "unused_local_fun": "warn",
     "multiple_setq": "warn",
     "redundant_quotes": "warn",
@@ -80,15 +79,23 @@
     "loop_optimization": "off",
     "type_check": "off",
     "redundant_if": "warn",
-    "undeclared_setq": "warn"
+    "undeclared_setq": "warn",
+    "unused_catch_result": "warn",
+    "string_concat_loop": "warn",
+    "if_without_else": "warn",
+    "redundant_list": "warn",
+    "entget_in_loop": "warn",
+    "promise_handler": "warn",
+    "module_cycle": "warn",
+    "arg_count_project": "warn"
   },
   "line_length": {
-    "max": 100,
+    "max": 200,
     "tab_width": 2
   },
   "function_complexity": {
-    "max_lines": 60,
-    "max_nesting": 15
+    "max_lines": 300,
+    "max_nesting": 30
   },
   "cl_syntax": {
     "keywords": ["&key"]

package/dist/checks/bare-names.js

@@ -18,6 +18,8 @@ function checkBareFunctionNames(content, file, allowlist, namespacePattern) {
             continue; // local: defun foo/bar
         if (name.startsWith('cb-'))
             continue; // DCL callback
+        if (name === '*error*')
+            continue;
         if (!nsRegex.test(name) && !name.includes(':')) {
             issues.push({
                 file,

package/dist/checks/constant-condition.js

@@ -41,6 +41,9 @@ function checkConstantConditionAst(ast, file) {
                 continue;
             const condTest = clause.children[0];
             if (condTest.type === 'symbol' && condTest.name && CONSTANTS.has(condTest.name)) {
+                // Skip last clause with T — that's the standard else/default pattern
+                if (condTest.name === 'T' && i === condNode.children.length - 1)
+                    continue;
                 issues.push({
                     file,
                     line: condTest.pos.line,

package/dist/checks/empty-catch.js

@@ -2,33 +2,78 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkEmptyCatch = checkEmptyCatch;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkEmptyCatch(content, file) {
     const issues = [];
-    const lines = content.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        // Detect (vl-catch-all-apply ...) not inside (vl-catch-all-error-p ...) check
-        if (stripped.includes('vl-catch-all-apply')) {
-            // Check subsequent lines for error-p check
-            let hasErrorCheck = false;
-            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
-                if ((0, utils_1.stripLine)(lines[j]).includes('vl-catch-all-error-p')) {
-                    hasErrorCheck = true;
-                    break;
-                }
-            }
-            if (!hasErrorCheck) {
-                issues.push({
-                    file,
-                    line: i + 1,
-                    severity: 'warn',
-                    rule: 'empty_catch',
-                    message: (0, locale_1.t)('empty_catch'),
-                });
-            }
+    const ast = (0, parser_1.parseAst)(content);
+    const catchNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'vl-catch-all-apply'));
+    for (const node of catchNodes) {
+        if (isInQuote(node))
+            continue;
+        if (isWrappedByCatchError(node))
+            continue;
+        if (isSetqStored(node)) {
+            const varName = getSetqVarName(node);
+            if (varName && hasErrorCheckInSiblings(node, varName))
+                continue;
         }
+        issues.push({
+            file,
+            line: node.pos.line,
+            severity: 'warn',
+            rule: 'empty_catch',
+            message: (0, locale_1.t)('empty_catch'),
+        });
     }
     return issues;
 }
+function isInQuote(node) {
+    let p = node.parent;
+    while (p) {
+        if ((0, parser_1.astIsList)(p, 'quote'))
+            return true;
+        p = p.parent;
+    }
+    return false;
+}
+function isWrappedByCatchError(node) {
+    const parent = node.parent;
+    return !!(parent && (0, parser_1.astIsList)(parent, 'vl-catch-all-error-p'));
+}
+function isSetqStored(node) {
+    const parent = node.parent;
+    if (!parent || !(0, parser_1.astIsList)(parent, 'setq'))
+        return false;
+    if (!parent.children || parent.children.length < 3)
+        return false;
+    const idx = parent.children.indexOf(node);
+    return idx >= 2 && idx % 2 === 0;
+}
+function getSetqVarName(node) {
+    const parent = node.parent;
+    if (!parent || !parent.children)
+        return null;
+    const idx = parent.children.indexOf(node);
+    const varNode = parent.children[idx - 1];
+    if (varNode && varNode.type === 'symbol' && varNode.name) {
+        return varNode.name;
+    }
+    return null;
+}
+function hasErrorCheckInSiblings(node, varName) {
+    const parent = node.parent;
+    if (!parent || !parent.children)
+        return false;
+    const idx = parent.children.indexOf(node);
+    for (let i = idx + 1; i < parent.children.length; i++) {
+        const sibling = parent.children[i];
+        if ((0, parser_1.astIsList)(sibling, 'vl-catch-all-error-p')) {
+            if (sibling.children && sibling.children.length >= 2 &&
+                (0, parser_1.astIsSymbol)(sibling.children[1], varName)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 //# sourceMappingURL=empty-catch.js.map

package/dist/checks/entget-in-loop.d.ts

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

package/dist/checks/entget-in-loop.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEntgetInLoop = checkEntgetInLoop;
+const locale_1 = require("../locale");
+function isInsideLoop(ast, targetNode) {
+    let node = targetNode.parent;
+    while (node) {
+        if (node.type === 'list' && node.children && node.children.length > 0 &&
+            node.children[0].type === 'symbol') {
+            const name = node.children[0].name;
+            if (name === 'while' || name === 'repeat' || name === 'foreach') {
+                return true;
+            }
+        }
+        node = node.parent;
+    }
+    return false;
+}
+function checkEntgetInLoop(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const re = /\((while|repeat|foreach)\s/;
+    for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i])) {
+            let depth = 0;
+            let inLoop = false;
+            let entgetCount = 0;
+            for (let j = i; j < Math.min(i + 50, lines.length); j++) {
+                for (let k = 0; k < lines[j].length; k++) {
+                    if (lines[j][k] === '(') {
+                        depth++;
+                        if (!inLoop)
+                            inLoop = true;
+                    }
+                    else if (lines[j][k] === ')')
+                        depth--;
+                }
+                if (lines[j].includes('entget'))
+                    entgetCount++;
+                if (depth === 0 && inLoop)
+                    break;
+            }
+            if (entgetCount > 0) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'entget_in_loop',
+                    message: (0, locale_1.t)('entget_in_loop'),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=entget-in-loop.js.map

package/dist/checks/if-without-else.d.ts

@@ -0,0 +1,4 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkIfWithoutElse(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=if-without-else.d.ts.map

package/dist/checks/if-without-else.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfWithoutElse = checkIfWithoutElse;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkIfWithoutElse(ast, file) {
+    const issues = [];
+    const ifNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'if'));
+    for (const node of ifNodes) {
+        if (!node.children || node.children.length < 3)
+            continue;
+        if (node.children.length === 3) {
+            const parent = node.parent;
+            if (parent && parent.type === 'list' && parent.children && parent.children.length > 0 &&
+                parent.children[0].type === 'symbol') {
+                const parentName = parent.children[0].name;
+                if (parentName === 'cond' || parentName === 'if')
+                    continue;
+            }
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'if_without_else',
+                message: (0, locale_1.t)('if_without_else'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=if-without-else.js.map

package/dist/checks/long-function-call.js

@@ -39,7 +39,7 @@ function checkLongFunctionCall(content, file, maxArgs) {
         }
         if (inArg)
             argCount++;
-        if (argCount > maxArgs && !m[1].startsWith('(') && !m[1].startsWith('"') && m[1] !== 'if') {
+        if (argCount > maxArgs && !m[1].startsWith('(') && !m[1].startsWith('"') && m[1] !== 'if' && m[1] !== 'quote') {
             issues.push({
                 file,
                 line: i + 1,

package/dist/checks/promise-handler.d.ts

@@ -0,0 +1,4 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkPromiseHandler(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=promise-handler.d.ts.map

package/dist/checks/promise-handler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPromiseHandler = checkPromiseHandler;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkPromiseHandler(ast, file) {
+    const issues = [];
+    const vlaxNodes = (0, parser_1.astFindAll)(ast, (n) => !!(n.type === 'list' && n.children && n.children.length > 0 &&
+        n.children[0].type === 'symbol' && typeof n.children[0].name === 'string' &&
+        (n.children[0].name.startsWith('vlax-invoke') || n.children[0].name.startsWith('vlax-invoke-method'))));
+    for (const node of vlaxNodes) {
+        if (isInQuote(node))
+            continue;
+        const parent = node.parent;
+        if (parent && parent.type === 'list' && parent.children && parent.children.length > 0 &&
+            parent.children[0].type === 'symbol' && parent.children[0].name === 'vl-catch-all-apply') {
+            continue;
+        }
+        let hasCallback = false;
+        if (node.children) {
+            for (const child of node.children) {
+                if (child.type === 'list' && child.children && child.children.length > 0 &&
+                    child.children[0].type === 'symbol' &&
+                    (child.children[0].name === 'lambda' || child.children[0].name === 'function')) {
+                    hasCallback = true;
+                    break;
+                }
+            }
+        }
+        if (!hasCallback) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'promise_handler',
+                message: (0, locale_1.t)('promise_handler'),
+            });
+        }
+    }
+    return issues;
+}
+function isInQuote(node) {
+    let p = node.parent;
+    while (p) {
+        if (p.type === 'list' && p.children && p.children.length > 0 &&
+            p.children[0].type === 'symbol' && p.children[0].name === 'quote') {
+            return true;
+        }
+        p = p.parent;
+    }
+    return false;
+}
+//# sourceMappingURL=promise-handler.js.map

package/dist/checks/redundant-list.d.ts

@@ -0,0 +1,4 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantList(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-list.d.ts.map

package/dist/checks/redundant-list.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantList = checkRedundantList;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantList(ast, file) {
+    const issues = [];
+    const listNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'list'));
+    for (const node of listNodes) {
+        if (!node.children || node.children.length === 1) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'redundant_list',
+                message: (0, locale_1.t)('redundant_list'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-list.js.map

package/dist/checks/string-concat-loop.d.ts

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

package/dist/checks/string-concat-loop.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStringConcatInLoop = checkStringConcatInLoop;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function hasStrcatInBody(body) {
+    for (const node of body) {
+        for (const n of (0, parser_1.astWalk)(node)) {
+            if (n.type === 'list' && n.children && n.children.length > 0 &&
+                n.children[0].type === 'symbol' && n.children[0].name === 'strcat') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isLoopForm(name) {
+    return name === 'while' || name === 'repeat' || name === 'foreach';
+}
+function checkStringConcatInLoop(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const re = /\((while|repeat|foreach)\s/g;
+    for (let i = 0; i < lines.length; i++) {
+        let match;
+        while ((match = re.exec(lines[i])) !== null) {
+            const name = match[1];
+            let depth = 0;
+            let started = false;
+            let startLine = i;
+            let foundStrcat = false;
+            for (let j = i; j < lines.length; j++) {
+                for (let k = 0; k < lines[j].length; k++) {
+                    const ch = lines[j][k];
+                    if (ch === '(')
+                        depth++;
+                    else if (ch === ')')
+                        depth--;
+                }
+                if (!started && depth > 0)
+                    started = true;
+                if (depth === 0 && started)
+                    break;
+            }
+            const loopBody = lines.slice(i, i + 20).join('\n');
+            if (loopBody.includes('strcat') || loopBody.includes('strcat ')) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'string_concat_loop',
+                    message: (0, locale_1.t)('string_concat_loop', name),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=string-concat-loop.js.map

package/dist/checks/undeclared-setq.js

@@ -58,6 +58,8 @@ function checkUndeclaredSetq(content, file) {
                 continue;
             if (v.name === 'T' || v.name === 'nil')
                 continue;
+            if (v.name.includes('::'))
+                continue;
             if (isEarmuffed(v.name))
                 continue;
             if (declared.has(v.name))

package/dist/checks/unused-catch-result.d.ts

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

package/dist/checks/unused-catch-result.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnusedCatchResult = checkUnusedCatchResult;
+const locale_1 = require("../locale");
+function checkUnusedCatchResult(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const catchRe = /\(vl-catch-all-apply\s+'[^)]+\)/g;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let match;
+        while ((match = catchRe.exec(line)) !== null) {
+            const col = match.index;
+            const after = line.slice(col + match[0].length).trim();
+            if (!after.startsWith(')')) {
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'unused_catch_result',
+                    message: (0, locale_1.t)('unused_catch_result'),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=unused-catch-result.js.map

package/dist/config.js

@@ -74,7 +74,6 @@ const DEFAULT_CONFIG = {
         unused_let_binding: 'warn',
         recursive_call: 'warn',
         variable_shadow: 'warn',
-        redundant_cond: 'warn',
         unused_local_fun: 'warn',
         multiple_setq: 'warn',
         redundant_quotes: 'warn',
@@ -123,14 +122,22 @@ const DEFAULT_CONFIG = {
         type_check: 'off',
         format_indent: 'off',
         redundant_if: 'warn',
+        unused_catch_result: 'warn',
+        string_concat_loop: 'warn',
+        if_without_else: 'warn',
+        redundant_list: 'warn',
+        entget_in_loop: 'warn',
+        promise_handler: 'warn',
+        module_cycle: 'warn',
+        arg_count_project: 'warn',
     },
     line_length: {
-        max: 100,
+        max: 200,
         tab_width: 2,
     },
     function_complexity: {
-        max_lines: 60,
-        max_nesting: 15,
+        max_lines: 300,
+        max_nesting: 30,
     },
     cl_syntax: {
         keywords: ['&key'],

package/dist/formatters-html.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from './types';
+export declare function formatHtml(issues: Issue[], errorCount: number, warningCount: number): string;
+//# sourceMappingURL=formatters-html.d.ts.map

package/dist/formatters-html.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHtml = formatHtml;
+function formatHtml(issues, errorCount, warningCount) {
+    const summaryColor = errorCount > 0 ? '#dc3545' : warningCount > 0 ? '#ffc107' : '#198754';
+    const ruleGroups = new Map();
+    for (const iss of issues) {
+        const list = ruleGroups.get(iss.rule) || [];
+        list.push(iss);
+        ruleGroups.set(iss.rule, list);
+    }
+    const sortedRules = Array.from(ruleGroups.entries()).sort(([a], [b]) => a.localeCompare(b));
+    let rows = '';
+    for (const iss of issues) {
+        const tag = iss.severity === 'error'
+            ? '<span class="badge bg-danger">ERROR</span>'
+            : '<span class="badge bg-warning text-dark">WARN</span>';
+        rows += `<tr><td>${tag}</td><td>${iss.rule}</td><td>${iss.file}</td><td>${iss.line || '-'}</td><td>${escHtml(iss.message)}</td></tr>\n`;
+    }
+    let summaryHtml = '';
+    if (errorCount > 0) {
+        summaryHtml += `<span class="text-danger fw-bold">${errorCount} error(s)</span> `;
+    }
+    if (warningCount > 0) {
+        summaryHtml += `<span class="text-warning fw-bold">${warningCount} warning(s)</span> `;
+    }
+    if (errorCount === 0 && warningCount === 0) {
+        summaryHtml = '<span class="text-success fw-bold">All files OK</span>';
+    }
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>@atlisp/lint Report</title>
+<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+<style>
+  body { padding: 20px; background: #f8f9fa; }
+  .summary-card { background: white; border-radius: 8px; padding: 20px; margin-bottom: 20px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+  .summary-count { font-size: 2em; font-weight: bold; margin-right: 20px; }
+  table { font-size: 0.9em; }
+  .badge { font-size: 0.75em; }
+  footer { margin-top: 30px; color: #6c757d; font-size: 0.85em; text-align: center; }
+</style>
+</head>
+<body>
+<div class="container">
+  <h1 class="mb-4">@atlisp/lint Report</h1>
+
+  <div class="summary-card">
+    <h5 class="card-title" style="color:${summaryColor}">Summary</h5>
+    <p>${summaryHtml}</p>
+    <p class="text-muted">${issues.length} total issues across ${ruleGroups.size} rules</p>
+  </div>
+
+  ${sortedRules.map(([rule, ruleIssues]) => `
+  <div class="summary-card">
+    <h5 class="card-title">${escHtml(rule)} <span class="badge bg-secondary">${ruleIssues.length}</span></h5>
+    <ul class="list-group list-group-flush">
+    ${ruleIssues.map(iss => `
+      <li class="list-group-item d-flex justify-content-between align-items-start">
+        <div>
+          <span class="fw-bold">${escHtml(iss.file)}:${iss.line || '-'}</span>
+          <br><span class="text-muted">${escHtml(iss.message)}</span>
+        </div>
+        ${iss.severity === 'error' ? '<span class="badge bg-danger rounded-pill">ERROR</span>' : '<span class="badge bg-warning text-dark rounded-pill">WARN</span>'}
+      </li>
+    `).join('')}
+    </ul>
+  </div>
+  `).join('')}
+
+  <div class="summary-card">
+    <h5>All Issues</h5>
+    <div class="table-responsive">
+      <table class="table table-striped table-hover">
+        <thead><tr><th>Severity</th><th>Rule</th><th>File</th><th>Line</th><th>Message</th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>
+    </div>
+  </div>
+
+  <footer>Generated by @atlisp/lint on ${new Date().toISOString()}</footer>
+</div>
+</body>
+</html>`;
+}
+function escHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+//# sourceMappingURL=formatters-html.js.map

package/dist/formatters-sarif.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from './types';
+export declare function formatSarif(issues: Issue[], errorCount: number, warningCount: number): string;
+//# sourceMappingURL=formatters-sarif.d.ts.map