@atlisp/lint 0.1.4 → 0.1.6

package/dist/index.js

@@ -44,6 +44,7 @@ const sbcl_1 = require("./sbcl");
 const formatters_1 = require("./formatters");
 const locale_1 = require("./locale");
 const cache_1 = require("./cache");
+const watch_1 = require("./watch");
 function parseArgs() {
     const argv = process.argv.slice(2);
     const opts = {
@@ -59,6 +60,7 @@ function parseArgs() {
         clearCache: false,
         parallel: false,
         project: false,
+        watch: false,
     };
     for (let i = 0; i < argv.length; i++) {
         switch (argv[i]) {
@@ -101,6 +103,9 @@ function parseArgs() {
             case '--project':
                 opts.project = true;
                 break;
+            case '--watch':
+                opts.watch = true;
+                break;
             default:
                 break;
         }
@@ -168,12 +173,12 @@ function collectFiles(rootDir, opts, config) {
             }
         }
     }
-    const excludePatterns = config.source.exclude.map((e) => {
+    const excludePatterns = config.source.exclude.map(e => {
         const str = e.replace(/\./g, '\\.').replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
         return new RegExp(`^${str}$`);
     });
     return Array.from(files)
-        .filter((f) => {
+        .filter(f => {
         const rel = path.relative(rootDir, f).replace(/\\/g, '/');
         for (const re of excludePatterns) {
             if (re.test(rel))
@@ -190,10 +195,10 @@ function collectStagedFiles(rootDir) {
     });
     return output
         .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.endsWith('.lsp'))
-        .map((l) => path.resolve(rootDir, l))
-        .filter((f) => fs.existsSync(f));
+        .map(l => l.trim())
+        .filter(l => l.endsWith('.lsp'))
+        .map(l => path.resolve(rootDir, l))
+        .filter(f => fs.existsSync(f));
 }
 function initConfig(rootDir) {
     const defaultPath = path.join(__dirname, '..', 'atlisp-lint.default.json');
@@ -249,6 +254,11 @@ async function main() {
             console.log((0, locale_1.t)('index.no_files'));
             return;
         }
+        // --watch mode
+        if (opts.watch) {
+            (0, watch_1.watchFiles)(files, { rootDir, format: opts.format, config });
+            return;
+        }
         // --fix mode: auto-fix before linting
         if (opts.fix) {
             for (const f of files) {
@@ -260,10 +270,20 @@ async function main() {
             if (!opts.staged)
                 return;
         }
-        // Filter cached files
+        // Filter cached files (pre-read content to avoid double I/O)
+        const contentCache = new Map();
         const filesToLint = opts.cache
-            ? files.filter((f) => {
-                const cached = (0, cache_1.isCached)(f, rootDir);
+            ? files.filter(f => {
+                let content;
+                try {
+                    content = fs.readFileSync(f, 'utf-8');
+                }
+                catch {
+                    /* ignore */
+                }
+                if (content !== undefined)
+                    contentCache.set(f, content);
+                const cached = (0, cache_1.isCached)(f, rootDir, content);
                 if (cached) {
                     console.log(`${(0, locale_1.t)('summary.tag_warn')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.cached')}`);
                 }
@@ -283,10 +303,30 @@ async function main() {
             const projectIssues = (0, project_1.lintProject)(filesToLint, config, rootDir);
             issues.push(...projectIssues);
         }
-        // Mark as cached
+        // Apply rule-based fixes (after lint, when --fix is set)
+        if (opts.fix) {
+            for (const f of filesToLint) {
+                const relPath = path.relative(rootDir, f);
+                const fileIssues = issues.filter(i => i.file === relPath);
+                if (fileIssues.length > 0) {
+                    try {
+                        const content = fs.readFileSync(f, 'utf-8');
+                        const fixed = (0, runner_1.applyFixes)(fileIssues, content, relPath);
+                        if (fixed !== content) {
+                            fs.writeFileSync(f, fixed, 'utf-8');
+                            console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        // Mark as cached (reuse pre-read content if available)
         if (opts.cache) {
             for (const f of filesToLint) {
-                (0, cache_1.markCached)(f, rootDir);
+                (0, cache_1.markCached)(f, rootDir, contentCache.get(f));
             }
         }
         // Phase 2: SBCL syntax validation
@@ -319,8 +359,8 @@ async function main() {
             }
         }
         // Format & output
-        const errorCount = issues.filter((i) => i.severity === 'error').length;
-        const warningCount = issues.filter((i) => i.severity === 'warn').length;
+        const errorCount = issues.filter(i => i.severity === 'error').length;
+        const warningCount = issues.filter(i => i.severity === 'warn').length;
         if (opts.format === 'json') {
             console.log((0, formatters_1.formatJson)(issues, errorCount, warningCount));
         }

package/dist/lib/lint-sbcl.lisp

@@ -0,0 +1,161 @@
+;; @lisp SBCL Lint — syntax validation via SBCL
+;; Usage: sbcl --script lint-sbcl.lisp <src-dir> <stub-packages.json> <walk-exclude-json> <defmacro-allow-files-json> <locale>
+
+(require :uiop)
+
+(defparameter *errors* 0)
+(defparameter *warnings* 0)
+(defparameter *checked* 0)
+(defparameter *locale* "zh")
+
+;; ── i18n ──────────────────────────────────────────────────────────────
+(defun i18n (key)
+  (cdr (assoc key
+    (if (string= *locale* "zh")
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))))))
+
+;; ── Stub packages from external file ──────────────────────────────────
+(defun load-stub-packages (file-path)
+  (flet ((ensure-pkg (name &optional use-list)
+           (unless (find-package name)
+             (make-package name :use (or use-list '())))))
+    (with-open-file (s file-path :direction :input)
+      (let ((packages (read s)))
+        (dolist (pkg packages)
+          (ensure-pkg (first pkg) (second pkg)))))))
+
+;; ── File walking ──────────────────────────────────────────────────────
+(defun source-files (dir)
+  (sort
+    (remove-if-not
+      (lambda (p)
+        (let ((n (pathname-type p)))
+          (and n (string-equal n "lsp"))))
+      (uiop:directory-files dir))
+    'string< :key #'namestring))
+
+(defun walk-tree (dir exclude-dirs)
+  (let ((result (source-files dir)))
+    (dolist (sub (uiop:subdirectories dir))
+      (let ((name (car (last (pathname-directory sub)))))
+        (unless (find name exclude-dirs :test 'string=)
+          (setf result (append result (walk-tree sub exclude-dirs))))))
+    result))
+
+;; ── Per-file check ────────────────────────────────────────────────────
+(defun check-file (path src-dir defmacro-allow-files)
+  (incf *checked*)
+  (let* ((rel (enough-namestring path src-dir))
+         (fullname (format nil "~a.~a" (pathname-name path) (pathname-type path))))
+    (format t "  ~a ... " rel)
+    (force-output)
+    ;; Syntax check via READ
+    (handler-case
+        (with-open-file (s path :direction :input)
+          (loop for form = (read s nil :eof)
+                until (eq form :eof)))
+      (error (e)
+        (let ((msg (princ-to-string e)))
+          (cond
+            ((search "not found" msg)
+             (format t "~%  [NOTE] ~a: ~a~%" rel (i18n :not-found))
+             (incf *warnings*))
+            (t
+             (format t "~a~%  [ERROR] ~a: ~a~%" (i18n :fail) rel (i18n :syntax-error))
+             (incf *errors*)
+             (return-from check-file))))))
+    ;; Trailing whitespace
+    (with-open-file (s path :direction :input)
+      (loop for line = (read-line s nil nil)
+            for lineno from 1
+            while line
+            when (and (> (length line) 0)
+                      (find (char line (1- (length line))) '(#\Space #\Tab)))
+              do (progn
+                   (format t "~%  [WARN] ~a line ~d: ~a~%" rel lineno (i18n :trailing-ws))
+                   (incf *warnings*))))
+    ;; CL-ism checks: raw content scan
+    (with-open-file (s path :direction :input)
+      (let ((content (make-string (file-length s))))
+        (file-position s 0)
+        (read-sequence content s)
+        (when (search "#(" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :vec-syntax))
+          (incf *warnings*))
+        (when (search "#\\" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :char-syntax))
+          (incf *warnings*))
+        (when (search "#." content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :eval-syntax))
+          (incf *warnings*))
+        (when (and (search "defmacro" content)
+                   (not (some (lambda (s) (search s fullname)) defmacro-allow-files)))
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :defmacro))
+          (incf *warnings*))))
+    (format t "~a~%" (i18n :ok))))
+
+;; ── Main ──────────────────────────────────────────────────────────────
+(defun main ()
+  (let* ((args (uiop:command-line-arguments))
+         (src-dir (first args))
+         (stub-file (second args))
+         (walk-exclude (if (third args)
+                          (read-from-string (third args))
+                          '(".vscode" "test" "experiment" "tools" ".git")))
+         (defmacro-allow (if (fourth args)
+                            (read-from-string (fourth args))
+                            '("compat-cl")))
+         (locale (fifth args)))
+    (when locale (setf *locale* locale))
+    (load-stub-packages stub-file)
+
+    (format t "~%==================================================~%")
+    (format t "~a~%" (i18n :header))
+    (format t "~a: ~a~%" (i18n :source) (namestring (pathname src-dir)))
+    (format t "==================================================~%~%")
+    (setf *errors* 0 *warnings* 0 *checked* 0)
+
+    (let ((files (walk-tree src-dir walk-exclude)))
+      (format t "~a~%~%" (format nil (i18n :found) (length files)))
+      (dolist (f files)
+        (check-file f src-dir defmacro-allow)))
+
+    (format t "~%==================================================~%")
+    (format t "~a: ~d~%" (i18n :scanned) *checked*)
+    (format t "~a: ~d~%" (i18n :errors) *errors*)
+    (format t "~a: ~d~%" (i18n :warnings) *warnings*)
+    (format t "==================================================~%~%")
+    (if (> *errors* 0)
+        (uiop:quit 1)
+        (uiop:quit 0))))
+
+(main)

package/dist/locale.js

@@ -52,6 +52,15 @@ const messages = {
         quote_vs_function: 'Quoted lambda passed to {0} — use (function (lambda ...)) instead for compiled code',
         commented_code: 'Commented-out code detected — remove or uncomment if needed',
         double_not: 'Double (not (not ...)) — simplifies to single not',
+        error_handling: "Functions using command but missing *error*: '{0}'",
+        global_naming: "Global variable '{0}' should use *...* naming convention",
+        extra_parens: 'Suspicious excessive closing parenthesis: {0} extra )',
+        setq_single_arg: "Variable '{0}' is setq'd with no value — likely a typo",
+        assoc_without_cdr: 'assoc result is not used — wrap with cdr to extract the value',
+        identical_branches: 'if has identical then and else branches — possible copy-paste error',
+        while_constant: "while with constant condition '{0}' — loop may never execute or never terminate",
+        cond_duplicate: 'cond has duplicate conditions — second clause is unreachable',
+        duplicate_defun: "Function '{0}' is defined multiple times",
         dangling_defun: "Function '{0}' is defined but never called",
         missing_export: "Function '{0}' is not registered in @::*modules*",
         unused_package_dep: "Imported package '{0}' is never referenced",
@@ -74,6 +83,9 @@ const messages = {
         'index.cached': 'Cached, skipping',
         'index.all_cached': 'All files are cached, nothing to lint',
         'index.cache_cleared': 'Cache cleared',
+        'index.watching': 'Watching',
+        'index.watch_hint': 'Press Ctrl+C to stop',
+        'index.watch_status': '{0} files checked: {1} error(s), {2} warning(s)',
     },
     zh: {
         'parens.mismatch': "括号不匹配：{0} 个 '(' vs {1} 个 ')'（{2}）",
@@ -123,6 +135,15 @@ const messages = {
         quote_vs_function: '在 {0} 中使用引用 lambda —— 建议改用 (function (lambda ...)) 以支持编译优化',
         commented_code: '检测到被注释掉的代码 —— 请删除或取消注释',
         double_not: '双重 (not (not ...)) —— 可以简化为单个 not',
+        error_handling: "使用 command 但缺少 *error* 的函数: '{0}'",
+        global_naming: "全局变量 '{0}' 应使用 *...* 命名约定",
+        extra_parens: '可疑的过多闭合括号：多余 {0} 个 )',
+        setq_single_arg: "变量 '{0}' 被 setq 但未赋值——可能是笔误",
+        assoc_without_cdr: 'assoc 的结果未被使用——应使用 cdr 获取值',
+        identical_branches: 'if 的 then 和 else 分支完全相同——可能是复制粘贴错误',
+        while_constant: "while 使用了常量条件 '{0}'——循环可能永不执行或永不终止",
+        cond_duplicate: 'cond 中存在重复条件——第二个子句不可达',
+        duplicate_defun: "函数 '{0}' 被多次定义",
         dangling_defun: "函数 '{0}' 定义了但从未被调用",
         missing_export: "函数 '{0}' 未注册到 @::*modules*",
         unused_package_dep: "导入的包 '{0}' 从未被引用",
@@ -145,6 +166,9 @@ const messages = {
         'index.cached': '已缓存，跳过',
         'index.all_cached': '所有文件均已缓存，无需检查',
         'index.cache_cleared': '缓存已清除',
+        'index.watching': '监听中',
+        'index.watch_hint': '按 Ctrl+C 停止',
+        'index.watch_status': '已检查 {0} 个文件: {1} 个错误, {2} 个警告',
     },
 };
 let currentLocale = 'zh';

package/dist/presets.d.ts

@@ -0,0 +1,4 @@
+import { LintConfig } from './types';
+export type PresetName = 'recommended' | 'strict' | 'relaxed';
+export declare const PRESETS: Record<PresetName, Partial<LintConfig>>;
+//# sourceMappingURL=presets.d.ts.map

package/dist/presets.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESETS = void 0;
+exports.PRESETS = {
+    recommended: {
+        checks: {
+            parens: 'error',
+            encoding: 'error',
+            cl_syntax: 'warn',
+            quit_exit: 'error',
+            command_shell: 'error',
+            startapp: 'warn',
+            vl_registry_write: 'warn',
+            token_in_url: 'warn',
+            open_without_close: 'warn',
+            line_length: 'warn',
+            function_complexity: 'warn',
+            parameter_naming: 'warn',
+            unused_variable: 'warn',
+            missing_doc: 'warn',
+            trailing_whitespace: 'warn',
+            unused_parameter: 'warn',
+            constant_condition: 'warn',
+            redundant_progn: 'warn',
+            empty_branch: 'warn',
+            unused_let_binding: 'warn',
+            recursive_call: 'warn',
+            variable_shadow: 'warn',
+            redundant_cond: 'warn',
+            unused_local_fun: 'warn',
+            multiple_setq: 'warn',
+            redundant_quotes: 'warn',
+            trailing_paren: 'warn',
+            empty_comment: 'warn',
+            redundant_setq: 'warn',
+            redundant_nil_else: 'warn',
+            single_arg_and_or: 'warn',
+            redundant_let: 'warn',
+            self_compare: 'warn',
+            misplaced_else: 'warn',
+            quote_vs_function: 'warn',
+            commented_code: 'warn',
+            double_not: 'warn',
+            setq_single_arg: 'warn',
+            assoc_without_cdr: 'warn',
+            identical_branches: 'warn',
+            while_constant: 'warn',
+            cond_duplicate: 'warn',
+            error_handling: 'warn',
+            global_naming: 'warn',
+            extra_parens: 'warn',
+            arg_count: 'warn',
+            strcat_usage: 'warn',
+            cond_simplify: 'warn',
+            quote_style: 'warn',
+            eq_usage: 'warn',
+            lambda_syntax: 'warn',
+            comment_style: 'warn',
+            empty_catch: 'warn',
+            nth_usage: 'warn',
+            append_single: 'warn',
+            setq_multiple: 'warn',
+            mixed_indent: 'warn',
+            long_function_call: 'warn',
+            no_return: 'warn',
+            shadow_builtin: 'warn',
+            dynamic_doc: 'warn',
+            redundant_if: 'warn',
+        },
+    },
+    strict: {
+        checks: {
+            parens: 'error',
+            encoding: 'error',
+            cl_syntax: 'error',
+            quit_exit: 'error',
+            command_shell: 'error',
+            startapp: 'error',
+            vl_registry_write: 'error',
+            vlax_without_loading: 'error',
+            token_in_url: 'error',
+            open_without_close: 'error',
+            bare_function_names: 'error',
+            line_length: 'error',
+            function_complexity: 'error',
+            parameter_naming: 'error',
+            unused_variable: 'error',
+            missing_doc: 'error',
+            trailing_whitespace: 'error',
+            unused_parameter: 'error',
+            constant_condition: 'error',
+            redundant_progn: 'error',
+            empty_branch: 'error',
+            unused_let_binding: 'error',
+            recursive_call: 'error',
+            variable_shadow: 'error',
+            redundant_cond: 'error',
+            unused_local_fun: 'error',
+            multiple_setq: 'warn',
+            redundant_quotes: 'error',
+            trailing_paren: 'error',
+            empty_comment: 'error',
+            redundant_setq: 'error',
+            redundant_nil_else: 'error',
+            single_arg_and_or: 'error',
+            redundant_let: 'error',
+            self_compare: 'error',
+            misplaced_else: 'error',
+            quote_vs_function: 'error',
+            commented_code: 'error',
+            double_not: 'error',
+            setq_single_arg: 'error',
+            assoc_without_cdr: 'error',
+            identical_branches: 'error',
+            while_constant: 'error',
+            cond_duplicate: 'error',
+            duplicate_defun: 'error',
+            dangling_defun: 'error',
+            missing_export: 'error',
+            unused_package_dep: 'error',
+            error_handling: 'error',
+            global_naming: 'error',
+            extra_parens: 'error',
+            arg_count: 'error',
+            strcat_usage: 'error',
+            cond_simplify: 'error',
+            quote_style: 'error',
+            eq_usage: 'error',
+            lambda_syntax: 'error',
+            comment_style: 'error',
+            empty_catch: 'error',
+            nth_usage: 'error',
+            append_single: 'error',
+            setq_multiple: 'error',
+            function_order: 'warn',
+            magic_number: 'warn',
+            mixed_indent: 'error',
+            long_function_call: 'error',
+            no_return: 'error',
+            shadow_builtin: 'error',
+            dynamic_doc: 'error',
+            loop_optimization: 'warn',
+            type_check: 'warn',
+            redundant_if: 'error',
+            module_registration: 'error',
+            namespace_header: 'error',
+        },
+    },
+    relaxed: {
+        checks: {
+            parens: 'error',
+            encoding: 'error',
+            quit_exit: 'error',
+            command_shell: 'error',
+        },
+    },
+};
+//# sourceMappingURL=presets.js.map

package/dist/project.js

@@ -40,12 +40,13 @@ const parser_1 = require("@atlisp/parser");
 const dangling_defun_1 = require("./checks/dangling-defun");
 const missing_export_1 = require("./checks/missing-export");
 const unused_package_dep_1 = require("./checks/unused-package-dep");
+const duplicate_defun_1 = require("./checks/duplicate-defun");
 const locale_1 = require("./locale");
 function collectDefuns(file) {
     const content = fs.readFileSync(file, 'utf-8');
     const ast = (0, parser_1.parseAst)(content);
     const results = [];
-    const defunNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
+    const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
         if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
             results.push({ name: node.children[1].name, line: node.pos.line });
@@ -53,10 +54,27 @@ function collectDefuns(file) {
     }
     return results;
 }
+function collectReferences(file, _filepath) {
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const results = [];
+    const allCalls = (0, parser_1.astFindAll)(ast, n => {
+        if (n.type !== 'list' || !n.children || n.children.length === 0)
+            return false;
+        return (0, parser_1.astIsSymbol)(n.children[0]);
+    });
+    for (const call of allCalls) {
+        const name = call.children[0].name;
+        if (name !== 'defun' && name !== 'defun-q' && !name.startsWith('c:') && !name.includes(':')) {
+            results.push({ name, line: call.pos.line });
+        }
+    }
+    return results;
+}
 function lintProject(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
-    const defuns = { defuns: new Map() };
+    const symbols = { defuns: new Map(), references: new Map() };
     const fileContents = new Map();
     for (const filepath of files) {
         try {
@@ -70,9 +88,15 @@ function lintProject(files, config, rootDir) {
     for (const [filepath] of fileContents) {
         const defunList = collectDefuns(filepath);
         for (const d of defunList) {
-            const list = defuns.defuns.get(d.name) || [];
+            const list = symbols.defuns.get(d.name) || [];
             list.push({ file: filepath, line: d.line });
-            defuns.defuns.set(d.name, list);
+            symbols.defuns.set(d.name, list);
+        }
+        const refList = collectReferences(filepath, filepath);
+        for (const r of refList) {
+            const list = symbols.references.get(r.name) || [];
+            list.push({ file: filepath, line: r.line });
+            symbols.references.set(r.name, list);
         }
     }
     for (const [filepath] of fileContents) {
@@ -80,7 +104,7 @@ function lintProject(files, config, rootDir) {
         const override = findProjectOverride(filepath);
         const checks = override?.checks || config.checks;
         if (checks['dangling_defun'] !== 'off') {
-            const danglingIssues = (0, dangling_defun_1.checkDanglingDefun)(filepath, defuns.defuns);
+            const danglingIssues = (0, dangling_defun_1.checkDanglingDefun)(filepath, symbols.defuns, symbols.references);
             for (const iss of danglingIssues) {
                 iss.file = relPath;
                 allIssues.push(iss);
@@ -89,7 +113,7 @@ function lintProject(files, config, rootDir) {
         if (checks['missing_export'] !== 'off') {
             const pkgDir = findPackageDir(filepath);
             if (pkgDir) {
-                const missingIssues = (0, missing_export_1.checkMissingExport)(filepath, pkgDir, defuns.defuns);
+                const missingIssues = (0, missing_export_1.checkMissingExport)(filepath, pkgDir, symbols.defuns);
                 for (const iss of missingIssues) {
                     iss.file = relPath;
                     allIssues.push(iss);
@@ -103,6 +127,13 @@ function lintProject(files, config, rootDir) {
                 allIssues.push(iss);
             }
         }
+        if (checks['duplicate_defun'] !== 'off') {
+            const dupIssues = (0, duplicate_defun_1.checkDuplicateDefun)(filepath, symbols.defuns);
+            for (const iss of dupIssues) {
+                iss.file = relPath;
+                allIssues.push(iss);
+            }
+        }
     }
     return allIssues;
 }

package/dist/rules.d.ts

@@ -0,0 +1,9 @@
+export interface RuleDoc {
+    name: string;
+    defaultSeverity: string;
+    description: string;
+    category: string;
+}
+export declare const RULES: RuleDoc[];
+export declare function generateRulesMarkdown(): string;
+//# sourceMappingURL=rules.d.ts.map