@atlisp/lint 0.1.12 → 0.1.15

package/dist/checks/global-naming.js

@@ -2,60 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkGlobalNaming = checkGlobalNaming;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
-function checkGlobalNaming(content, file) {
-    const issues = [];
-    const lines = content.split('\n');
-    let depth = 0;
-    let inDefun = false;
-    let defunLocals = new Set();
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        // Track depth
-        for (const ch of stripped) {
-            if (ch === '(')
-                depth++;
-            else if (ch === ')')
-                depth--;
-        }
-        // Detect defun start and extract local variables
-        if (!inDefun) {
-            const defunMatch = stripped.match(/\(defun\s+\S+\s+\(([^)]*\/\s+[^)]*)\)/);
-            if (defunMatch) {
-                inDefun = true;
-                const all = defunMatch[1];
-                const slashIdx = all.indexOf('/');
-                defunLocals = new Set(all
-                    .slice(slashIdx + 1)
-                    .split(/\s+/)
-                    .filter(Boolean));
-            }
-        }
-        if (depth <= 0) {
-            inDefun = false;
-            defunLocals = new Set();
-        }
-        // setq at depth 0 or 1 (top-level or directly inside progn) is global
-        if (depth <= 1) {
-            const m = stripped.match(/\(setq\s+(\S+)/);
-            if (m) {
-                const v = m[1];
-                if (v !== 'T' &&
-                    v !== 'nil' &&
-                    !v.startsWith('*') &&
-                    !v.endsWith('*') &&
-                    !v.includes('/') &&
-                    !defunLocals.has(v)) {
-                    issues.push({
-                        file,
-                        line: i + 1,
-                        severity: 'warn',
-                        rule: 'global_naming',
-                        message: (0, locale_1.t)('global_naming', v),
-                    });
+const parser_1 = require("@atlisp/parser");
+function isInsideLocalScope(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'list' && cur.children && cur.children.length > 0) {
+            const head = cur.children[0];
+            if (head.type === 'symbol' && head.name) {
+                if (['defun', 'lambda', 'let', 'let*'].includes(head.name)) {
+                    return true;
                 }
             }
         }
+        cur = cur.parent;
+    }
+    return false;
+}
+function checkGlobalNaming(content, file) {
+    const issues = [];
+    const ast = (0, parser_1.parseAst)(content);
+    const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
+    for (const form of setqForms) {
+        if (!form.children || form.children.length < 2)
+            continue;
+        // Skip setq inside defun/lambda/let — those are local
+        if (isInsideLocalScope(form))
+            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('*') && v.name.endsWith('*'))
+                continue;
+            issues.push({
+                file,
+                line: v.pos.line,
+                severity: 'warn',
+                rule: 'global_naming',
+                message: (0, locale_1.t)('global_naming', v.name),
+            });
+        }
     }
     return issues;
 }

package/dist/checks/unused-variable.js

@@ -24,8 +24,8 @@ function checkUnusedVariableAst(ast, file) {
                 continue;
             if (v.name.startsWith('/'))
                 continue;
-            // Skip earmuffed globals (*var*) — typically cross-file
-            if (v.name.startsWith('*') && v.name.endsWith('*') && v.name.length > 2)
+            // Skip earmuffed globals (*var*) and namespaced earmuffed (ns:*var*) — typically cross-file
+            if (isEarmuffed(v.name))
                 continue;
             if (!setqVars.has(v.name)) {
                 setqVars.set(v.name, v.pos.line);
@@ -69,6 +69,11 @@ function checkUnusedVariableAst(ast, file) {
     }
     return issues;
 }
+/** Check if a variable name is earmuffed (*var*), optionally with a namespace prefix (ns:*var*) */
+function isEarmuffed(name) {
+    const localName = name.includes(':') ? name.slice(name.lastIndexOf(':') + 1) : name;
+    return localName.startsWith('*') && localName.endsWith('*') && localName.length > 2;
+}
 function isInsideLetBinding(node, varName) {
     let cur = node.parent;
     while (cur) {

package/dist/index.js

@@ -151,24 +151,29 @@ function* walkFiles(dir, rootDir, regex) {
         catch {
             continue;
         }
+        const rel = path.relative(rootDir, fullPath).replace(/\\/g, '/');
+        if (rel.startsWith('..'))
+            continue;
         if (stat.isDirectory()) {
             yield* walkFiles(fullPath, rootDir, regex);
         }
         else if (stat.isFile()) {
-            const rel = path.relative(rootDir, fullPath).replace(/\\/g, '/');
             if (regex.test(rel))
                 yield fullPath;
         }
     }
 }
+// Placeholder regex (dynamically constructed to avoid no-control-regex)
+const GLOB_PLACEHOLDER = '\x00GLOB\x00';
+const GLOB_RE = new RegExp(GLOB_PLACEHOLDER, 'g');
 function globFiles(pattern, rootDir) {
     const regexStr = pattern
         .replace(/\./g, '\\.')
-        .replace(/\*\*\//g, '\x00GLOB\x00')
+        .replace(/\*\*\//g, GLOB_PLACEHOLDER)
         .replace(/\*\*/g, '.*')
         .replace(/\*/g, '[^/]*')
         .replace(/\?/g, '.')
-        .replace(/\x00GLOB\x00/g, '(.*/)?');
+        .replace(GLOB_RE, '(.*/)?');
     const regex = new RegExp(`^${regexStr}$`);
     return Array.from(walkFiles(rootDir, rootDir, regex));
 }
@@ -198,9 +203,10 @@ function collectFiles(rootDir, opts, config) {
     const excludePatterns = config.source.exclude.map(e => {
         const str = e
             .replace(/\./g, '\\.')
-            .replace(/\*\*/g, '\x00STAR\x00')
+            .replace(/\*\*\//g, GLOB_PLACEHOLDER)
+            .replace(/\*\*/g, '.*')
             .replace(/\*/g, '[^/]*')
-            .replace(/\x00STAR\x00/g, '.*');
+            .replace(GLOB_RE, '(.*/)?');
         return new RegExp(`^${str}$`);
     });
     return Array.from(files)

package/package.json

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