@atlisp/lint 0.1.2 → 0.1.4

package/dist/checks/unused-package-dep.js

@@ -0,0 +1,93 @@
+"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.checkUnusedPackageDep = checkUnusedPackageDep;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const fs = __importStar(require("fs"));
+function checkUnusedPackageDep(file) {
+    const issues = [];
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const inPackageNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'in-package'));
+    if (inPackageNodes.length === 0)
+        return issues;
+    const allPackages = new Set();
+    for (const node of inPackageNodes) {
+        if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            allPackages.add(node.children[1].name);
+        }
+    }
+    const usedSymbols = new Set();
+    const allLists = (0, parser_1.astFindAll)(ast, (n) => n.type === 'list');
+    for (const node of allLists) {
+        if (!node.children || node.children.length === 0)
+            continue;
+        const car = node.children[0];
+        if (car.type === 'symbol' && car.name) {
+            const parts = car.name.split(':');
+            if (parts.length === 2 && parts[0] && parts[1]) {
+                usedSymbols.add(parts[0]);
+            }
+        }
+        for (let i = 1; i < node.children.length; i++) {
+            const child = node.children[i];
+            if (child.type === 'symbol' && child.name) {
+                const parts = child.name.split(':');
+                if (parts.length === 2 && parts[0] && parts[1]) {
+                    usedSymbols.add(parts[0]);
+                }
+            }
+        }
+    }
+    const mainPackage = inPackageNodes.length > 0 && inPackageNodes[0].children && inPackageNodes[0].children[1]
+        ? inPackageNodes[0].children[1].name || ''
+        : '';
+    allPackages.delete(mainPackage);
+    for (const pkg of allPackages) {
+        if (!usedSymbols.has(pkg)) {
+            const node = inPackageNodes.find((n) => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === pkg);
+            issues.push({
+                file,
+                line: node ? node.pos.line : 1,
+                severity: 'warn',
+                rule: 'unused_package_dep',
+                message: (0, locale_1.t)('unused_package_dep', pkg),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=unused-package-dep.js.map

package/dist/checks/unused-param.d.ts

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

package/dist/checks/unused-param.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnusedParameter = checkUnusedParameter;
+exports.checkUnusedParameterAst = checkUnusedParameterAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkUnusedParameter(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkUnusedParameterAst(ast, file);
+}
+function checkUnusedParameterAst(ast, file) {
+    const issues = [];
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        const funcName = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '<unknown>';
+        if (funcName.startsWith('c:') || funcName.startsWith('C:'))
+            continue;
+        const paramList = defun.children[2];
+        if (paramList.type !== 'list' || !paramList.children)
+            continue;
+        // Collect params before / (AutoLISP: (defun foo (a b / x y) ...) — a,b are params, x,y are locals)
+        const params = [];
+        for (const p of paramList.children) {
+            if (p.type === 'symbol' && p.name === '/')
+                break;
+            if (p.type !== 'symbol' || !p.name)
+                continue;
+            if (p.name === 'T' || p.name === 'nil')
+                continue;
+            params.push(p);
+        }
+        if (params.length === 0)
+            continue;
+        // Collect all symbol references in the body (excluding param list)
+        const used = new Set();
+        for (let i = 3; i < defun.children.length; i++) {
+            collectSymbolRefs(defun.children[i], used);
+        }
+        for (const p of params) {
+            if (!used.has(p.name)) {
+                issues.push({
+                    file,
+                    line: p.pos.line,
+                    severity: 'warn',
+                    rule: 'unused_parameter',
+                    message: (0, locale_1.t)('unused_parameter', p.name, funcName),
+                });
+            }
+        }
+    }
+    return issues;
+}
+function collectSymbolRefs(node, refs) {
+    for (const n of (0, parser_1.astWalk)(node)) {
+        if (n.type === 'symbol' && n.name) {
+            refs.add(n.name);
+        }
+    }
+}
+//# sourceMappingURL=unused-param.js.map

package/dist/checks/unused-variable.d.ts

@@ -1,3 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkUnusedVariable(content: string, file: string): Issue[];
+export declare function checkUnusedVariableAst(ast: AstNode, file: string): Issue[];
 //# sourceMappingURL=unused-variable.d.ts.map

package/dist/checks/unused-variable.js

@@ -1,50 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkUnusedVariable = checkUnusedVariable;
+exports.checkUnusedVariableAst = checkUnusedVariableAst;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkUnusedVariable(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkUnusedVariableAst(ast, file);
+}
+function checkUnusedVariableAst(ast, file) {
     const issues = [];
-    const lines = content.split('\n');
+    // Find all setq forms, collect variable definitions
+    const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
     const setqVars = new Map();
-    const usedVars = new Set();
-    let inStr = false;
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        // Find (setq var val)
-        const setqMatch = stripped.match(/\(setq\s+(\S+)/);
-        if (setqMatch) {
-            const v = setqMatch[1];
-            if (!setqVars.has(v) && v !== 'T' && v !== 'nil') {
-                setqVars.set(v, i + 1);
+    for (const form of setqForms) {
+        if (!form.children)
+            continue;
+        for (let i = 1; i < form.children.length; i += 2) {
+            const v = form.children[i];
+            if (v.type !== 'symbol' || !v.name)
+                continue;
+            if (v.name === 'T' || v.name === 'nil')
+                continue;
+            if (v.name.startsWith('/'))
+                continue;
+            if (!setqVars.has(v.name)) {
+                setqVars.set(v.name, v.pos.line);
             }
         }
-        // Find variable references (word boundaries)
-        const strippedNoStr = lines[i].replace(/{[^}]*}/g, '');
-        for (let j = 0; j < strippedNoStr.length; j++) {
-            if (strippedNoStr[j] === '"')
-                inStr = !inStr;
-        }
-        if (!inStr) {
-            for (const [v] of setqVars) {
-                if (v.length > 0) {
-                    const re = new RegExp('\\b' + v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
-                    // Don't count the setq line itself
-                    if (re.test(stripped) && !stripped.match(new RegExp('\\(setq\\s+' + v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b'))) {
-                        usedVars.add(v);
-                    }
-                }
-            }
+    }
+    if (setqVars.size === 0)
+        return issues;
+    // Set of defined var nodes (to exclude from usage)
+    const defNodes = new Set();
+    for (const form of setqForms) {
+        if (!form.children)
+            continue;
+        for (let i = 1; i < form.children.length; i += 2) {
+            defNodes.add(form.children[i]);
         }
     }
+    // Walk entire AST, collect used variable references
+    // Skip references inside a (let ((x ...)) ...) when checking outer x
+    const usedVars = new Set();
+    for (const node of (0, parser_1.astWalk)(ast)) {
+        if (node.type !== 'symbol' || !node.name)
+            continue;
+        if (defNodes.has(node))
+            continue;
+        // Skip if this reference is inside a let that binds the same name
+        if (isInsideLetBinding(node, node.name))
+            continue;
+        usedVars.add(node.name);
+    }
     for (const [v, line] of setqVars) {
-        if (!usedVars.has(v) && !v.startsWith('/')) {
+        if (!usedVars.has(v)) {
             issues.push({
-                file, line, severity: 'warn', rule: 'unused_variable',
+                file,
+                line,
+                severity: 'warn',
+                rule: 'unused_variable',
                 message: (0, locale_1.t)('unused_variable', v),
             });
         }
     }
     return issues;
 }
+function isInsideLetBinding(node, varName) {
+    let cur = node.parent;
+    while (cur) {
+        if ((0, parser_1.astIsList)(cur, 'let') && cur.children && cur.children.length >= 2) {
+            const bindings = cur.children[1];
+            if (bindings.type === 'list' && bindings.children) {
+                for (const b of bindings.children) {
+                    if (b.type === 'list' &&
+                        b.children &&
+                        b.children.length > 0 &&
+                        b.children[0].type === 'symbol' &&
+                        b.children[0].name === varName) {
+                        return true;
+                    }
+                }
+            }
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
 //# sourceMappingURL=unused-variable.js.map

package/dist/checks/variable-shadow.d.ts

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

package/dist/checks/variable-shadow.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkVariableShadow = checkVariableShadow;
+exports.checkVariableShadowAst = checkVariableShadowAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkVariableShadow(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkVariableShadowAst(ast, file);
+}
+function checkVariableShadowAst(ast, file) {
+    const issues = [];
+    const letNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'let'));
+    for (const node of letNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const bindingList = node.children[1];
+        if (bindingList.type !== 'list' || !bindingList.children)
+            continue;
+        // Collect let-bound variable names
+        const letVars = new Set();
+        for (const binding of bindingList.children) {
+            if (binding.type !== 'list' || !binding.children || binding.children.length === 0)
+                continue;
+            const varNode = binding.children[0];
+            if (varNode.type !== 'symbol' || !varNode.name)
+                continue;
+            letVars.add(varNode.name);
+        }
+        if (letVars.size === 0)
+            continue;
+        // Walk the body for (setq var ...) where var is a let-bound name
+        for (let i = 2; i < node.children.length; i++) {
+            collectSetqTargets(node.children[i], letVars, issues, file);
+        }
+    }
+    return issues;
+}
+function collectSetqTargets(node, letVars, issues, file) {
+    if (node.type !== 'list' || !node.children)
+        return;
+    const car = node.children[0];
+    if (car.type === 'symbol' && car.name === 'setq') {
+        for (let i = 1; i < node.children.length; i += 2) {
+            const target = node.children[i];
+            if (target.type === 'symbol' && target.name && letVars.has(target.name)) {
+                issues.push({
+                    file,
+                    line: target.pos.line,
+                    severity: 'warn',
+                    rule: 'variable_shadow',
+                    message: (0, locale_1.t)('variable_shadow', target.name),
+                });
+            }
+        }
+    }
+    // Recurse into sublists (but don't enter nested let forms — they create new scope)
+    if (car.type === 'symbol' && car.name === 'let')
+        return;
+    for (const child of node.children) {
+        if (child.type === 'list') {
+            collectSetqTargets(child, letVars, issues, file);
+        }
+    }
+}
+//# sourceMappingURL=variable-shadow.js.map

package/dist/checks/vlax.js

@@ -8,10 +8,15 @@ function checkVlaxWithoutLoading(content, file) {
         return [];
     for (const { lineno, stripped } of (0, utils_1.codeLines)(content)) {
         if (/vlax-/i.test(stripped)) {
-            return [{
-                    file, line: lineno, severity: 'warn', rule: 'vlax_without_loading',
+            return [
+                {
+                    file,
+                    line: lineno,
+                    severity: 'warn',
+                    rule: 'vlax_without_loading',
                     message: (0, locale_1.t)('vlax_without_loading'),
-                }];
+                },
+            ];
         }
     }
     return [];

package/dist/config.d.ts

@@ -1,6 +1,5 @@
-import { LintConfig, Severity } from './types';
+import { LintConfig } from './types';
 export declare function loadConfig(configPath?: string): LintConfig;
-export declare function getCheckSeverity(config: LintConfig, checkName: string): Severity;
 export declare function findOverrides(filepath: string): Partial<LintConfig> | null;
 export declare function mergeOverrides(base: LintConfig, overrides: Partial<LintConfig>): LintConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfig = loadConfig;
-exports.getCheckSeverity = getCheckSeverity;
 exports.findOverrides = findOverrides;
 exports.mergeOverrides = mergeOverrides;
 const fs = __importStar(require("fs"));
@@ -63,12 +62,6 @@ const DEFAULT_CONFIG = {
         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',
         module_registration: 'off',
         namespace_header: 'off',
     },
@@ -140,12 +133,6 @@ function deepMerge(target, source) {
         }
     }
 }
-function getCheckSeverity(config, checkName) {
-    const sev = config.checks[checkName];
-    if (sev === 'error' || sev === 'warn')
-        return sev;
-    return 'off';
-}
 function findOverrides(filepath) {
     const dir = path.dirname(filepath);
     const configPath = path.join(dir, '.atlisp-lint.json');

package/dist/disable.js

@@ -10,7 +10,10 @@ function parseDisableComments(content, fileLine) {
         const m = line.match(/;\s*atlisp-lint:\s*disable=(.+)/i);
         if (!m)
             continue;
-        const rules = m[1].split(',').map(r => r.trim()).filter(Boolean);
+        const rules = m[1]
+            .split(',')
+            .map((r) => r.trim())
+            .filter(Boolean);
         let targetLine = i + 1;
         if (fileLine !== undefined)
             targetLine = fileLine;

package/dist/formatters.d.ts

@@ -1,5 +1,4 @@
 import { Issue } from './types';
 export declare function formatDefault(issues: Issue[], fileContents?: Map<string, string>): string;
-export declare function formatJson(issues: Issue[]): string;
-export declare function formatHtml(issues: Issue[], totalErrors: number, totalWarnings: number): string;
+export declare function formatJson(issues: Issue[], errorCount?: number, warningCount?: number): string;
 //# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDefault = formatDefault;
 exports.formatJson = formatJson;
-exports.formatHtml = formatHtml;
 const locale_1 = require("./locale");
 const colors = {
     red: '\x1b[31m',
@@ -26,9 +25,7 @@ function formatDefault(issues, fileContents) {
         const tagColor = iss.severity === 'error' ? colors.red : colors.yellow;
         const tag = iss.severity === 'error' ? (0, locale_1.t)('summary.tag_fail') : (0, locale_1.t)('summary.tag_warn');
         const loc = iss.line > 0 ? `${(0, locale_1.t)('summary.line')} ${iss.line}` : '';
-        const prefix = useColor
-            ? `${tagColor}${tag}${colors.reset}`
-            : tag;
+        const prefix = useColor ? `${tagColor}${tag}${colors.reset}` : tag;
         lines.push(`${prefix}: ${iss.file} — ${loc}${loc ? ': ' : ''}${iss.message}`.trim());
         if (iss.line > 0 && fileContents) {
             const content = fileContents.get(iss.file);
@@ -48,7 +45,7 @@ function formatDefault(issues, fileContents) {
     }
     if (lines.length > 0)
         lines.push('');
-    const summaryColor = errors > 0 ? colors.red : (warnings > 0 ? colors.yellow : colors.cyan);
+    const summaryColor = errors > 0 ? colors.red : warnings > 0 ? colors.yellow : colors.cyan;
     if (useColor) {
         lines.push(`${colors.cyan}${(0, locale_1.t)('summary.header')}${colors.reset}`);
         if (errors === 0 && warnings === 0) {
@@ -71,61 +68,11 @@ function formatDefault(issues, fileContents) {
     }
     return lines.join('\n');
 }
-function formatJson(issues) {
-    return JSON.stringify({ issues }, null, 2);
-}
-function formatHtml(issues, totalErrors, totalWarnings) {
-    const rows = issues.map(iss => {
-        const sevClass = iss.severity === 'error' ? 'error' : 'warn';
-        const loc = iss.line > 0 ? `Line ${iss.line}` : '';
-        return `<tr class="${sevClass}">
-      <td><span class="badge badge-${sevClass}">${sevClass === 'error' ? 'FAIL' : 'WARN'}</span></td>
-      <td>${iss.file}</td>
-      <td>${loc}</td>
-      <td>${iss.rule}</td>
-      <td>${iss.message}</td>
-    </tr>`;
-    }).join('\n');
-    return `<!DOCTYPE html>
-<html lang="zh">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>@atlisp/lint Report</title>
-<style>
-body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 20px; background: #f5f5f5; }
-h1 { color: #333; }
-.summary { display: flex; gap: 20px; margin: 20px 0; }
-.stat { background: #fff; padding: 15px 25px; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
-.stat-errors { border-left: 4px solid #e74c3c; }
-.stat-warnings { border-left: 4px solid #f39c12; }
-.stat-ok { border-left: 4px solid #27ae60; }
-.stat-value { font-size: 28px; font-weight: bold; }
-.stat-label { color: #666; font-size: 12px; text-transform: uppercase; }
-table { width: 100%; border-collapse: collapse; background: #fff; border-radius: 8px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
-th { background: #333; color: #fff; padding: 12px; text-align: left; }
-td { padding: 10px 12px; border-bottom: 1px solid #eee; }
-tr.error td { background: #fef0ef; }
-tr.warn td { background: #fef9e7; }
-.badge { padding: 2px 8px; border-radius: 4px; font-size: 12px; font-weight: bold; color: #fff; }
-.badge-error { background: #e74c3c; }
-.badge-warn { background: #f39c12; }
-.footer { margin-top: 20px; color: #999; font-size: 12px; text-align: center; }
-</style>
-</head>
-<body>
-<h1>@atlisp/lint Report</h1>
-<div class="summary">
-  <div class="stat stat-errors"><div class="stat-value">${totalErrors}</div><div class="stat-label">Errors</div></div>
-  <div class="stat stat-warnings"><div class="stat-value">${totalWarnings}</div><div class="stat-label">Warnings</div></div>
-  <div class="stat stat-ok"><div class="stat-value">${issues.length}</div><div class="stat-label">Total Issues</div></div>
-</div>
-<table>
-<thead><tr><th>Severity</th><th>File</th><th>Line</th><th>Rule</th><th>Message</th></tr></thead>
-<tbody>${rows.length ? rows : '<tr><td colspan="5" style="text-align:center;color:#999;">No issues found</td></tr>'}</tbody>
-</table>
-<div class="footer">Generated by @atlisp/lint</div>
-</body>
-</html>`;
+function formatJson(issues, errorCount, warningCount) {
+    return JSON.stringify({
+        issues,
+        error_count: errorCount ?? issues.filter((i) => i.severity === 'error').length,
+        warning_count: warningCount ?? issues.filter((i) => i.severity === 'warn').length,
+    }, null, 2);
 }
 //# sourceMappingURL=formatters.js.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export declare function main(): void;
+export declare function main(): Promise<void>;
 //# sourceMappingURL=index.d.ts.map