@atlisp/lint 0.2.12 → 0.2.13

package/dist/visitor-runner.d.ts

@@ -1,4 +1,32 @@
 import { Issue, LintConfig } from './types';
 import { AstNode } from '@atlisp/parser';
+export interface CollectState {
+    openCount: number;
+    closeCount: number;
+    setqDefs: Map<string, {
+        line: number;
+        file: string;
+    }>;
+    symbolRefs: Map<string, number>;
+    condKeys: Map<number, Set<string>>;
+    defunScopes: Array<{
+        name: string;
+        params: string[];
+        body: AstNode[];
+        line: number;
+        file: string;
+    }>;
+    letScopes: Array<{
+        bindings: string[];
+        body: AstNode[];
+        line: number;
+    }>;
+    dangerousCalls: Array<{
+        name: string;
+        node: AstNode;
+    }>;
+    ssgetCount: number;
+    sssetCount: number;
+}
 export declare function runChecksWithVisitor(ast: AstNode, file: string, config: LintConfig, disableMap: Map<string, Set<number>>): Issue[];
 //# sourceMappingURL=visitor-runner.d.ts.map

package/dist/visitor-runner.js

@@ -4,6 +4,7 @@ exports.runChecksWithVisitor = runChecksWithVisitor;
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
 const parser_1 = require("@atlisp/parser");
+const index_1 = require("./visitors/index");
 function runChecksWithVisitor(ast, file, config, disableMap) {
     const issues = [];
     const checks = config.checks;
@@ -17,6 +18,8 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
         defunScopes: [],
         letScopes: [],
         dangerousCalls: [],
+        ssgetCount: 0,
+        sssetCount: 0,
     };
     function addIssue(rule, line, message) {
         const severity = checks[rule];
@@ -435,6 +438,8 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
             dangerNames.add('startapp');
         if (dc.vl_registry_write !== 'off')
             dangerNames.add('vl-registry-write');
+        if (dc.eval !== 'off')
+            dangerNames.add('eval');
         if (dangerNames.size > 0) {
             visitor.on('*', node => {
                 if (node.type === 'list' &&
@@ -695,6 +700,106 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
             }
         });
     }
+    // command_s — recommend (command-s ...) over (command ...)
+    if (checks['command_s'] !== 'off') {
+        visitor.on('command', node => {
+            if (node.children && node.children.length >= 2) {
+                const subCmd = node.children[1];
+                if (subCmd.type === 'string' && typeof subCmd.value === 'string' && subCmd.value === 'shell')
+                    return;
+                addIssue('command_s', node.pos.line, (0, locale_1.t)('command_s'));
+            }
+        });
+    }
+    // zerop_usage — (= x 0) → (zerop x)
+    if (checks['zerop_usage'] !== 'off') {
+        const checkZero = (node) => {
+            if (node.children && node.children.length === 3) {
+                const a = node.children[1];
+                const b = node.children[2];
+                const extract = (n) => n.type === 'symbol' ? n.name || '' : n.type === 'number' ? String(n.value ?? '') : '';
+                if (a.type === 'number' && a.value === 0 && b.type === 'symbol') {
+                    addIssue('zerop_usage', node.pos.line, (0, locale_1.t)('zerop_usage', extract(b)));
+                }
+                else if (b.type === 'number' && b.value === 0 && a.type === 'symbol') {
+                    addIssue('zerop_usage', node.pos.line, (0, locale_1.t)('zerop_usage', extract(a)));
+                }
+            }
+        };
+        visitor.on('=', checkZero);
+        visitor.on('equal', checkZero);
+    }
+    // progn_in_body — redundant progn in while/repeat/foreach
+    if (checks['progn_in_body'] !== 'off') {
+        const checkPrognInBody = (node, formName, bodyStartIdx) => {
+            if (node.children && node.children.length > bodyStartIdx) {
+                const firstBody = node.children[bodyStartIdx];
+                if (firstBody.type === 'list' &&
+                    firstBody.children &&
+                    firstBody.children.length > 0 &&
+                    firstBody.children[0].type === 'symbol' &&
+                    firstBody.children[0].name === 'progn') {
+                    addIssue('progn_in_body', firstBody.pos.line, (0, locale_1.t)('progn_in_body', formName));
+                }
+            }
+        };
+        visitor.on('while', node => checkPrognInBody(node, 'while', 2));
+        visitor.on('repeat', node => checkPrognInBody(node, 'repeat', 2));
+        visitor.on('foreach', node => checkPrognInBody(node, 'foreach', 3));
+    }
+    // if_progn_both — both branches of if use progn
+    if (checks['if_progn_both'] !== 'off') {
+        visitor.on('if', node => {
+            if (node.children && node.children.length === 4) {
+                const thenBranch = node.children[2];
+                const elseBranch = node.children[3];
+                const isProgn = (n) => n.type === 'list' &&
+                    n.children !== undefined &&
+                    n.children.length > 0 &&
+                    n.children[0].type === 'symbol' &&
+                    n.children[0].name === 'progn';
+                if (isProgn(thenBranch) && isProgn(elseBranch)) {
+                    addIssue('if_progn_both', node.pos.line, (0, locale_1.t)('if_progn_both'));
+                }
+            }
+        });
+    }
+    // redundant_cond — single-clause cond
+    if (checks['redundant_cond'] !== 'off') {
+        visitor.on('cond', node => {
+            if (node.children && node.children.length === 2) {
+                const clause = node.children[1];
+                if (clause.type === 'list' && clause.children && clause.children.length === 2) {
+                    const test = clause.children[0];
+                    if (test.type === 'symbol' && test.name === 't')
+                        return;
+                    addIssue('redundant_cond', node.pos.line, (0, locale_1.t)('redundant_cond'));
+                }
+            }
+        });
+    }
+    // empty_branch_cond — cond clause with no body
+    if (checks['empty_branch_cond'] !== 'off') {
+        visitor.on('cond', node => {
+            if (!node.children)
+                return;
+            for (let i = 1; i < node.children.length; i++) {
+                const clause = node.children[i];
+                if (clause.type === 'list' && (!clause.children || clause.children.length < 2)) {
+                    addIssue('empty_branch_cond', clause.pos.line, (0, locale_1.t)('empty_branch_cond'));
+                }
+            }
+        });
+    }
+    // selection_set_leak (data collection)
+    if (checks['selection_set_leak'] !== 'off') {
+        visitor.on('ssget', () => {
+            state.ssgetCount++;
+        });
+        visitor.on('ssset', () => {
+            state.sssetCount++;
+        });
+    }
     // promise_handler
     if (checks['promise_handler'] !== 'off') {
         visitor.on('*', node => {
@@ -732,6 +837,7 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
             }
         });
     }
+    (0, index_1.registerAll)(visitor, state, checks, addIssue);
     visitor.run(ast);
     // ===== POST-PROCESSING =====
     // open_without_close
@@ -754,12 +860,20 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
                         ? 'dangerous.startapp'
                         : call.name === 'vl-registry-write'
                             ? 'dangerous.vl_registry_write'
-                            : '';
+                            : call.name === 'eval'
+                                ? 'dangerous.eval'
+                                : '';
             if (msgKey) {
                 addIssue(call.name === 'vl-registry-write' ? 'vl_registry_write' : call.name, call.node.pos.line, (0, locale_1.t)(msgKey));
             }
         }
     }
+    // selection_set_leak
+    if (checks['selection_set_leak'] !== 'off') {
+        if (state.ssgetCount > state.sssetCount) {
+            addIssue('selection_set_leak', 1, (0, locale_1.t)('selection_set_leak', String(state.ssgetCount), String(state.sssetCount)));
+        }
+    }
     // unused_variable
     if (checks['unused_variable'] !== 'off') {
         for (const [name, def] of state.setqDefs) {

package/dist/visitors/equal-nil.d.ts

@@ -0,0 +1,8 @@
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+import { AddIssueFn } from './types';
+export declare const equalNilModule: {
+    name: string;
+    register(visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn): void;
+};
+//# sourceMappingURL=equal-nil.d.ts.map

package/dist/visitors/equal-nil.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalNilModule = void 0;
+const types_1 = require("./types");
+exports.equalNilModule = {
+    name: 'equal_nil',
+    register(visitor, state, checks, addIssue) {
+        if (checks['equal_nil'] === 'off')
+            return;
+        const checkEqualNil = (node) => {
+            if (!node.children || node.children.length < 3)
+                return;
+            if ((0, types_1.isInQuote)(node))
+                return;
+            const a = node.children[1];
+            const b = node.children[2];
+            const isNilSym = (n) => n.type === 'symbol' && (n.name === 'nil' || n.name === 'NIL');
+            const varName = a.type === 'symbol' && isNilSym(b) ? a.name || '' : b.type === 'symbol' && isNilSym(a) ? b.name || '' : '';
+            if (varName) {
+                addIssue('equal_nil', node.pos.line, `(equal ${varName} nil) — use (null ${varName}) or (not ${varName})`);
+            }
+        };
+        visitor.on('equal', checkEqualNil);
+    },
+};
+//# sourceMappingURL=equal-nil.js.map

package/dist/visitors/index.d.ts

@@ -0,0 +1,5 @@
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+import { AddIssueFn } from './types';
+export declare function registerAll(visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/visitors/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAll = registerAll;
+const progn_in_cond_1 = require("./progn-in-cond");
+const redundant_car_cdr_1 = require("./redundant-car-cdr");
+const equal_nil_1 = require("./equal-nil");
+const redundant_and_or_1 = require("./redundant-and-or");
+const modules = [progn_in_cond_1.prognInCondModule, redundant_car_cdr_1.redundantCarCdrModule, equal_nil_1.equalNilModule, redundant_and_or_1.redundantAndOrModule];
+function registerAll(visitor, state, checks, addIssue) {
+    for (const mod of modules) {
+        mod.register(visitor, state, checks, addIssue);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/visitors/progn-in-cond.d.ts

@@ -0,0 +1,8 @@
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+import { AddIssueFn } from './types';
+export declare const prognInCondModule: {
+    name: string;
+    register(visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn): void;
+};
+//# sourceMappingURL=progn-in-cond.d.ts.map

package/dist/visitors/progn-in-cond.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prognInCondModule = void 0;
+const types_1 = require("./types");
+exports.prognInCondModule = {
+    name: 'progn_in_cond',
+    register(visitor, state, checks, addIssue) {
+        if (checks['progn_in_cond'] === 'off')
+            return;
+        visitor.on('cond', (node) => {
+            if (!node.children)
+                return;
+            for (let i = 1; i < node.children.length; i++) {
+                const clause = node.children[i];
+                if (clause.type !== 'list' || !clause.children || clause.children.length < 2)
+                    continue;
+                for (let j = 1; j < clause.children.length; j++) {
+                    const form = clause.children[j];
+                    if (form.type === 'list' &&
+                        form.children &&
+                        form.children.length > 0 &&
+                        form.children[0].type === 'symbol' &&
+                        form.children[0].name === 'progn') {
+                        if ((0, types_1.isInQuote)(form))
+                            continue;
+                        addIssue('progn_in_cond', form.pos.line, 'cond clause with progn — cond already allows multiple forms');
+                    }
+                }
+            }
+        });
+    },
+};
+//# sourceMappingURL=progn-in-cond.js.map

package/dist/visitors/redundant-and-or.d.ts

@@ -0,0 +1,8 @@
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+import { AddIssueFn } from './types';
+export declare const redundantAndOrModule: {
+    name: string;
+    register(visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn): void;
+};
+//# sourceMappingURL=redundant-and-or.d.ts.map

package/dist/visitors/redundant-and-or.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redundantAndOrModule = void 0;
+const types_1 = require("./types");
+exports.redundantAndOrModule = {
+    name: 'redundant_and_or',
+    register(visitor, state, checks, addIssue) {
+        if (checks['redundant_and_or'] === 'off')
+            return;
+        visitor.on('*', (node) => {
+            if (node.type !== 'list' || !node.children || node.children.length !== 1)
+                return;
+            const fn = node.children[0];
+            if (fn.type !== 'symbol')
+                return;
+            if ((0, types_1.isInQuote)(node))
+                return;
+            if (fn.name === 'and') {
+                addIssue('redundant_and_or', node.pos.line, '(and) always returns T — may be leftover code');
+            }
+            else if (fn.name === 'or') {
+                addIssue('redundant_and_or', node.pos.line, '(or) always returns nil — may be leftover code');
+            }
+        });
+    },
+};
+//# sourceMappingURL=redundant-and-or.js.map

package/dist/visitors/redundant-car-cdr.d.ts

@@ -0,0 +1,8 @@
+import { AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+import { AddIssueFn } from './types';
+export declare const redundantCarCdrModule: {
+    name: string;
+    register(visitor: AstVisitor, state: CollectState, checks: Record<string, string>, addIssue: AddIssueFn): void;
+};
+//# sourceMappingURL=redundant-car-cdr.d.ts.map

package/dist/visitors/redundant-car-cdr.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redundantCarCdrModule = void 0;
+const types_1 = require("./types");
+const CAR_CDR_MAP = {
+    car: { car: 'caar', cdr: 'cadr' },
+    cdr: { car: 'cdar', cdr: 'cddr' },
+};
+exports.redundantCarCdrModule = {
+    name: 'redundant_car_cdr',
+    register(visitor, state, checks, addIssue) {
+        if (checks['redundant_car_cdr'] === 'off')
+            return;
+        visitor.on('*', (node) => {
+            if (node.type !== 'list' || !node.children || node.children.length !== 2)
+                return;
+            const outer = node.children[0];
+            if (outer.type !== 'symbol' || !outer.name)
+                return;
+            const inner = node.children[1];
+            if (inner.type !== 'list' || !inner.children || inner.children.length !== 2)
+                return;
+            const innerFn = inner.children[0];
+            if (innerFn.type !== 'symbol' || !innerFn.name)
+                return;
+            const replacement = CAR_CDR_MAP[outer.name]?.[innerFn.name];
+            if (!replacement)
+                return;
+            if ((0, types_1.isInQuote)(node))
+                return;
+            addIssue('redundant_car_cdr', node.pos.line, `(${outer.name} (${innerFn.name} x)) → (${replacement} x)`);
+        });
+    },
+};
+//# sourceMappingURL=redundant-car-cdr.js.map

package/dist/visitors/types.d.ts

@@ -0,0 +1,13 @@
+import { AstNode, AstVisitor } from '@atlisp/parser';
+import { CollectState } from '../visitor-runner';
+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

@@ -0,0 +1,72 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",