@atlisp/lint 0.2.16 → 0.2.18

package/dist/visitors/shared.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.higherOrderFuncs = void 0;
+exports.isInQuote = isInQuote;
+exports.isLiteral = isLiteral;
+exports.astEqual = astEqual;
+exports.getCondKey = getCondKey;
+exports.hasConditionalForm = hasConditionalForm;
+exports.hasSelfCall = hasSelfCall;
+exports.defunParams = defunParams;
+exports.defunLocals = defunLocals;
+exports.collectSymbolRefs = collectSymbolRefs;
+const parser_1 = require("@atlisp/parser");
+function isInQuote(node, checkFunction = true) {
+    for (const p of (0, parser_1.astAncestors)(node)) {
+        if ((0, parser_1.astIsList)(p, 'quote') || (checkFunction && (0, parser_1.astIsList)(p, 'function'))) {
+            return true;
+        }
+    }
+    return false;
+}
+function isLiteral(node) {
+    if ((0, parser_1.astIsSymbol)(node, 'T') || (0, parser_1.astIsSymbol)(node, 't') || (0, parser_1.astIsSymbol)(node, 'nil'))
+        return true;
+    if ((0, parser_1.astIsNumber)(node))
+        return true;
+    return false;
+}
+function astEqual(a, b) {
+    if ((0, parser_1.astIsSymbol)(a) && (0, parser_1.astIsSymbol)(b))
+        return a.name === b.name;
+    if ((0, parser_1.astIsString)(a) && (0, parser_1.astIsString)(b))
+        return a.value === b.value;
+    if ((0, parser_1.astIsNumber)(a) && (0, parser_1.astIsNumber)(b))
+        return a.value === b.value;
+    if ((0, parser_1.astIsList)(a) && (0, parser_1.astIsList)(b)) {
+        if (a.children.length !== b.children.length)
+            return false;
+        for (let i = 0; i < a.children.length; i++) {
+            if (!astEqual(a.children[i], b.children[i]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function getCondKey(node) {
+    if ((0, parser_1.astIsSymbol)(node) || (0, parser_1.astIsKeyword)(node))
+        return node.name || '';
+    if ((0, parser_1.astIsString)(node) || (0, parser_1.astIsNumber)(node))
+        return String(node.value);
+    if ((0, parser_1.astIsList)(node)) {
+        return '(' + node.children.map(c => getCondKey(c)).join(' ') + ')';
+    }
+    return '';
+}
+function hasConditionalForm(body) {
+    for (const form of body) {
+        if ((0, parser_1.astIsList)(form) && form.children.length > 0 && (0, parser_1.astIsSymbol)(form.children[0])) {
+            const name = form.children[0].name;
+            if (name === 'if' || name === 'cond' || name === 'when' || name === 'unless') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function hasSelfCall(body, fnName) {
+    for (const form of body) {
+        if ((0, parser_1.astIsList)(form, fnName)) {
+            return true;
+        }
+    }
+    return false;
+}
+function defunParams(defunNode) {
+    const children = (0, parser_1.astChildren)(defunNode);
+    if (children.length < 3)
+        return [];
+    const paramList = children[2];
+    const params = [];
+    for (const child of (0, parser_1.astChildren)(paramList)) {
+        if ((0, parser_1.astIsSymbol)(child) && child.name !== '/') {
+            params.push(child.name);
+        }
+    }
+    return params;
+}
+function defunLocals(defunNode) {
+    const children = (0, parser_1.astChildren)(defunNode);
+    if (children.length < 3)
+        return [];
+    const paramList = children[2];
+    const locals = [];
+    let afterSlash = false;
+    for (const child of (0, parser_1.astChildren)(paramList)) {
+        if (!(0, parser_1.astIsSymbol)(child))
+            continue;
+        if (child.name === '/') {
+            afterSlash = true;
+            continue;
+        }
+        if (afterSlash && child.name) {
+            locals.push(child.name);
+        }
+    }
+    return locals;
+}
+function collectSymbolRefs(node, result) {
+    if ((0, parser_1.astIsSymbol)(node) && node.name) {
+        result.add(node.name);
+    }
+    for (const c of (0, parser_1.astChildren)(node)) {
+        collectSymbolRefs(c, result);
+    }
+}
+exports.higherOrderFuncs = new Set([
+    'mapcar',
+    'apply',
+    'lambda',
+    'vl-sort',
+    'vl-sort-i',
+    'vl-remove-if',
+    'vl-remove-if-not',
+    'vl-member-if',
+    'vl-some',
+    'vl-every',
+]);
+//# sourceMappingURL=shared.js.map

package/dist/visitors/types.d.ts

@@ -1,13 +1,8 @@
-import { AstNode, AstVisitor } from '@atlisp/parser';
-import { CollectState } from '../visitor-runner';
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from './shared';
 export type AddIssueFn = (rule: string, line: number, message: string) => void;
 export interface VisitorModule {
     name: string;
     register: (visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn) => void;
 }
-export declare function isInQuote(node: AstNode): boolean;
-export declare function isLiteral(node: AstNode): boolean;
-export declare function astEqual(a: AstNode, b: AstNode): boolean;
-export declare function getCondKey(node: AstNode): string;
-export declare function hasConditionalForm(body: AstNode[]): boolean;
 //# sourceMappingURL=types.d.ts.map

package/dist/visitors/types.js

@@ -1,72 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInQuote = isInQuote;
-exports.isLiteral = isLiteral;
-exports.astEqual = astEqual;
-exports.getCondKey = getCondKey;
-exports.hasConditionalForm = hasConditionalForm;
-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' || p.children[0].name === 'function')) {
-            return true;
-        }
-        p = p.parent;
-    }
-    return false;
-}
-function isLiteral(node) {
-    if (node.type === 'symbol' && (node.name === 'T' || node.name === 't' || node.name === 'nil'))
-        return true;
-    if (node.type === 'number')
-        return true;
-    return false;
-}
-function astEqual(a, b) {
-    if (a.type !== b.type)
-        return false;
-    if (a.type === 'symbol')
-        return a.name === b.name;
-    if (a.type === 'string')
-        return a.value === b.value;
-    if (a.type === 'number')
-        return a.value === b.value;
-    if (a.type === 'list') {
-        const ac = a.children || [];
-        const bc = b.children || [];
-        if (ac.length !== bc.length)
-            return false;
-        for (let i = 0; i < ac.length; i++) {
-            if (!astEqual(ac[i], bc[i]))
-                return false;
-        }
-        return true;
-    }
-    return false;
-}
-function getCondKey(node) {
-    if (node.type === 'symbol' || node.type === 'keyword')
-        return node.name || '';
-    if (node.type === 'string' || node.type === 'number')
-        return String(node.value);
-    if (node.type === 'list' && node.children) {
-        return '(' + node.children.map(c => getCondKey(c)).join(' ') + ')';
-    }
-    return '';
-}
-function hasConditionalForm(body) {
-    for (const form of body) {
-        if (form.type === 'list' && form.children && form.children.length > 0 && form.children[0].type === 'symbol') {
-            const name = form.children[0].name;
-            if (name === 'if' || name === 'cond' || name === 'when' || name === 'unless') {
-                return true;
-            }
-        }
-    }
-    return false;
-}
 //# sourceMappingURL=types.js.map

package/dist/watch.js

@@ -39,11 +39,31 @@ const path = __importStar(require("path"));
 const runner_1 = require("./runner");
 const formatters_1 = require("./formatters");
 const locale_1 = require("./locale");
+let previousIssues = [];
+let debounceTimer;
+let pendingFiles = new Set();
+function scheduleLint(files, rootDir, format, config, changedFile) {
+    pendingFiles.add(changedFile);
+    if (debounceTimer)
+        clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+        const toLint = Array.from(pendingFiles);
+        pendingFiles.clear();
+        debounceTimer = undefined;
+        // Only lint the changed files, merge with previous results
+        const newIssues = (0, runner_1.lintFiles)(toLint, config, rootDir);
+        const changedSet = new Set(toLint.map(f => path.relative(rootDir, f)));
+        const merged = previousIssues.filter(i => !changedSet.has(i.file)).concat(newIssues);
+        previousIssues = merged;
+        displayResults(merged, rootDir, format, files.length);
+    }, 200);
+}
 function watchFiles(files, options) {
     const { rootDir, format, config } = options;
     (0, locale_1.setLocale)(config.locale || 'zh');
     // Initial lint
-    runLint(files, rootDir, format, config);
+    previousIssues = (0, runner_1.lintFiles)(files, config, rootDir);
+    displayResults(previousIssues, rootDir, format, files.length);
     // Watch all files for changes
     const watchers = [];
     const watchedDirs = new Set();
@@ -52,15 +72,12 @@ function watchFiles(files, options) {
         if (!watchedDirs.has(dir)) {
             watchedDirs.add(dir);
             try {
-                const watcher = fs.watch(dir, (eventType, filename) => {
+                const watcher = fs.watch(dir, (_eventType, filename) => {
                     if (!filename)
                         return;
                     const fullPath = path.join(dir, filename);
                     if (files.includes(fullPath)) {
-                        // Debounce: wait a bit for the file to finish writing
-                        setTimeout(() => {
-                            runLint(files, rootDir, format, config);
-                        }, 200);
+                        scheduleLint(files, rootDir, format, config, fullPath);
                     }
                 });
                 watchers.push(watcher);
@@ -84,10 +101,8 @@ function watchFiles(files, options) {
         process.exit(0);
     });
 }
-function runLint(files, rootDir, format, config) {
-    // Clear console
+function displayResults(issues, rootDir, format, totalFiles) {
     process.stdout.write('\x1Bc');
-    const issues = (0, runner_1.lintFiles)(files, config, rootDir);
     const fileContents = new Map();
     for (const iss of issues) {
         if (!fileContents.has(iss.file)) {
@@ -106,8 +121,14 @@ function runLint(files, rootDir, format, config) {
     else {
         console.log((0, formatters_1.formatDefault)(issues, fileContents));
     }
-    const errorCount = issues.filter(i => i.severity === 'error').length;
-    const warningCount = issues.filter(i => i.severity === 'warn').length;
-    console.log(`\n[${new Date().toLocaleTimeString()}] ${(0, locale_1.t)('index.watch_status', files.length, errorCount, warningCount)}`);
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const iss of issues) {
+        if (iss.severity === 'error')
+            errorCount++;
+        else if (iss.severity === 'warn')
+            warningCount++;
+    }
+    console.log(`\n[${new Date().toLocaleTimeString()}] ${(0, locale_1.t)('index.watch_status', totalFiles, errorCount, warningCount)}`);
 }
 //# sourceMappingURL=watch.js.map

package/dist/worker.js

@@ -18,7 +18,7 @@ if (worker_threads_1.parentPort && worker_threads_1.workerData) {
     const input = worker_threads_1.workerData;
     (0, locale_1.setLocale)(input.config.locale || 'zh');
     try {
-        const content = (0, fs_1.readFileSync)(input.filepath, 'utf-8');
+        const content = input.content ?? (0, fs_1.readFileSync)(input.filepath, 'utf-8');
         const issues = (0, runner_1.runChecks)(content, input.relPath, input.config);
         sendMessage({ filepath: input.filepath, issues });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",
@@ -54,6 +54,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@atlisp/parser": "^0.1.8"
+    "@atlisp/parser": "^0.1.9"
   }
 }