@tsslint/config 3.1.0 → 3.1.2

package/lib/plugins/ignore.js

@@ -1,38 +1,181 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
-const ts_api_utils_1 = require("ts-api-utils");
-// `forEachComment` walks every token of the source file; if multiple ignore
-// plugins are configured (one per directive form) we'd walk the same file
-// 3+ times per lint pass. Cache the comment list once per ts.SourceFile so
-// every plugin shares a single sweep. The WeakMap drops entries when the
-// SourceFile is GC'd.
+// Inlined comment-trivia walker. Equivalent to ts-api-utils'
+// `forEachComment` but specialized for our needs (no `kind` / `value`
+// fields, no generator overhead, no per-token closure for the
+// trivia-collector). Algorithm matches upstream:
+//
+//   1. Iterative DFS over `node.getChildren(sourceFile)` — token-only
+//      leaves drive the walk. Realizes the AST tree, but the lint
+//      pipeline does this anyway for type-aware rules so the cost is
+//      amortized across the whole pass.
+//   2. For each token, scan `forEachLeadingCommentRange` (skip shebang
+//      at file start) and `forEachTrailingCommentRange`.
+//   3. JSX needs special care: `JsxText` tokens can't carry leading
+//      trivia, and trailing trivia rules differ for `}` / `>` tokens
+//      based on their JSX-element context.
+//
+// Trivia regions sit BETWEEN tokens — they can't contain string,
+// template, or regex literals (those belong to token text). That's
+// why driving `ts.createScanner` directly without parser context is
+// unsafe (regex / template `${}` interpolation get misclassified) and
+// why the AST-driven walk stays correct.
+//
+// Multiple ignore plugins (one per directive form) share the result via
+// a per-SourceFile WeakMap so the second / third callers in a pass pay
+// one map lookup instead of another scan.
 const sharedFileComments = new WeakMap();
-function getFileComments(file) {
+function getFileComments(ts, file) {
     let comments = sharedFileComments.get(file);
     if (!comments) {
         comments = [];
-        (0, ts_api_utils_1.forEachComment)(file, (fullText, { pos, end }) => {
-            const start = pos + 2; // strip leading `//` or `/*`
-            comments.push({
+        const fullText = file.text;
+        const SK = ts.SyntaxKind;
+        const notJsx = file.languageVariant !== ts.LanguageVariant.JSX;
+        // Iterative DFS: token leaves trigger trivia scans. Single shared
+        // callback object instead of allocating a closure per
+        // forEachLeading/Trailing call.
+        //
+        // CRITICAL: TS's `forEachLeading/TrailingCommentRange` stops
+        // iterating as soon as the callback returns a truthy value
+        // (matches the documented `forEachX` contract — return non-
+        // undefined to short-circuit). The callback body MUST NOT
+        // implicit-return `array.push(...)` (returns length → truthy →
+        // only the first comment per token gets collected).
+        const collected = comments;
+        const onComment = (pos, end) => {
+            const start = pos + 2; // strip `//` or `/*`
+            collected.push({
                 pos: start,
                 end,
                 text: fullText.substring(start, end),
             });
-        });
+            // no return → undefined → continue iteration
+        };
+        // `getChildren` array per visit creates the most allocation
+        // pressure; we still need it because `forEachChild` skips token
+        // kinds. Iterative stack avoids the recursive overhead.
+        let stack = [file];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (ts.isTokenKind(node.kind)) {
+                if (node.pos === node.end) {
+                    continue;
+                }
+                if (node.kind !== SK.JsxText) {
+                    // Skip the shebang at file position 0; otherwise
+                    // `forEachLeadingCommentRange` would re-emit it as a
+                    // line comment.
+                    const scanFrom = node.pos === 0
+                        ? (ts.getShebang(fullText) ?? '').length
+                        : node.pos;
+                    ts.forEachLeadingCommentRange(fullText, scanFrom, onComment);
+                }
+                if (notJsx || canHaveTrailingTrivia(ts, node)) {
+                    ts.forEachTrailingCommentRange(fullText, node.end, onComment);
+                }
+                continue;
+            }
+            const children = node.getChildren(file);
+            // Push in reverse so DFS order matches source order.
+            for (let i = children.length - 1; i >= 0; --i) {
+                stack.push(children[i]);
+            }
+        }
         sharedFileComments.set(file, comments);
     }
     return comments;
 }
+function canHaveTrailingTrivia(ts, token) {
+    const SK = ts.SyntaxKind;
+    switch (token.kind) {
+        case SK.CloseBraceToken:
+            // `}` of a JsxExpression inside a JSX element: no trailing
+            // trivia (the next character is JsxText, not a comment).
+            return token.parent.kind !== SK.JsxExpression
+                || !isJsxElementOrFragment(ts, token.parent.parent);
+        case SK.GreaterThanToken:
+            switch (token.parent.kind) {
+                case SK.JsxClosingElement:
+                case SK.JsxClosingFragment:
+                    return !isJsxElementOrFragment(ts, token.parent.parent.parent);
+                case SK.JsxOpeningElement:
+                    // Type-args list keeps trailing trivia; the `>` that
+                    // closes the opening tag itself does not (next is
+                    // JsxText).
+                    return token.end !== token.parent.end;
+                case SK.JsxOpeningFragment:
+                    return false;
+                case SK.JsxSelfClosingElement:
+                    return token.end !== token.parent.end
+                        || !isJsxElementOrFragment(ts, token.parent.parent);
+            }
+    }
+    return true;
+}
+function isJsxElementOrFragment(ts, node) {
+    const SK = ts.SyntaxKind;
+    return node.kind === SK.JsxElement || node.kind === SK.JsxFragment;
+}
 function create(cmdOption, reportsUnusedComments) {
     const mode = typeof cmdOption === 'string' ? 'singleLine' : 'multiLine';
     const [cmd, endCmd] = Array.isArray(cmdOption) ? cmdOption : [cmdOption, undefined];
     const cmdText = cmd.replace(/\?/g, '');
-    const withRuleId = '[ \\t]*\\b(?<ruleId>\\w\\S*)?';
+    // Rule IDs in the wild: bare (`no-shadow`), plugin-prefixed
+    // (`regexp/no-foo`), or scoped (`@typescript-eslint/no-foo`,
+    // `@scope/plugin/rule`). The previous `\w\S*` required a word char
+    // first — `@` failed, so every scoped disable comment fell into the
+    // `comments.get(undefined)` "disable all" bucket. Stacking multiple
+    // scoped disables then collapsed them into duplicates, only the first
+    // got marked used by an incoming error, the rest were reported as
+    // unused-comment FPs (real Astro repro: stacked `@typescript-eslint/...`
+    // block disables on `extendables.ts`).
+    //
+    // Match: leading scope segment `@xxx/`, then a name segment that
+    // starts with letter/underscore (skip `--` description delimiter),
+    // allowing `\w / . -` thereafter.
+    const ruleIdPattern = '(?:@[\\w-]+\\/)?[A-Za-z_][\\w/.-]*';
+    // Capture EVERYTHING after the command word as `tail`. The previous
+    // `(?<ruleId>...)?([ \\t]+[^\\r\\n]*)?` form captured a single rule
+    // id and let the trailing-text group eat the rest — but `,` is not
+    // in `[ \\t]+`, so for `eslint-disable rule1, rule2` the optional
+    // ruleId group backtracked to nothing, the trailing-text group then
+    // consumed `rule1, rule2 */`, and the result was treated as a bare
+    // `eslint-disable` (= disable ALL). Now we capture the whole tail
+    // and split it ourselves below to extract the rule list.
+    //
+    // `cmd` MUST be followed by whitespace, `*/`, or end of comment —
+    // not by another word/`-` char. Otherwise `eslint-disable` would
+    // also match `eslint-disable-line ...` (treating `-line ...` as a
+    // malformed rule list and falling back to disable-all). The
+    // `(?:\\s+(?<tail>...))?` form requires whitespace if anything
+    // follows.
     const header = '^\\s*';
-    const ending = '([ \\t]+[^\\r\\n]*)?$';
-    const reg = new RegExp(`${header}${cmd}${withRuleId}${ending}`);
-    const endReg = endCmd ? new RegExp(`${header}${endCmd}${withRuleId}${ending}`) : undefined;
+    const tail = '(?:\\s+(?<tail>[^]*?))?(?:\\*\\/)?\\s*$';
+    const reg = new RegExp(`${header}${cmd}${tail}`);
+    const endReg = endCmd ? new RegExp(`${header}${endCmd}${tail}`) : undefined;
+    // `tail` parsing: split by `--` (description marker), keep left side,
+    // split by `,`, trim each, drop blanks, validate against ruleIdPattern.
+    // Empty result = disable-all (matches ESLint semantics).
+    const ruleIdRegExp = new RegExp(`^${ruleIdPattern}$`);
+    function parseRuleList(rawTail) {
+        if (!rawTail)
+            return undefined; // bare command — disable all
+        const beforeDescription = rawTail.split(/\s--\s/)[0];
+        const parts = beforeDescription.split(',').map(s => s.trim()).filter(Boolean);
+        if (parts.length === 0)
+            return undefined; // disable all
+        const valid = parts.filter(p => ruleIdRegExp.test(p));
+        // If any part is malformed (e.g. trailing `*/` snuck in), be
+        // conservative and treat the whole comment as disable-all rather
+        // than silently dropping rules. ESLint surfaces an error here;
+        // for our purposes mirroring the legacy "disable all on parse
+        // failure" preserves behaviour for malformed comments.
+        if (valid.length !== parts.length)
+            return undefined;
+        return valid;
+    }
     const completeReg1 = /^\s*\/\/(\s*)([\S]*)?$/;
     const completeReg2 = new RegExp(`//\\s*${cmd}(\\S*)?$`);
     return ({ typescript: ts, languageService }) => {
@@ -135,15 +278,18 @@ function create(cmdOption, reportsUnusedComments) {
                     return results;
                 }
                 const comments = new Map();
-                for (const c of getFileComments(file)) {
+                for (const c of getFileComments(ts, file)) {
                     const startComment = c.text.match(reg);
                     if (startComment?.index !== undefined) {
                         const index = startComment.index + c.pos;
-                        const ruleId = startComment.groups?.ruleId;
-                        if (!comments.has(ruleId)) {
-                            comments.set(ruleId, []);
-                        }
-                        const disabledLines = comments.get(ruleId);
+                        const ruleList = parseRuleList(startComment.groups?.tail);
+                        // `undefined` = bare command (disable all). Else
+                        // register one entry PER rule so comma-separated
+                        // disables don't collapse into the disable-all
+                        // bucket (the bug: `eslint-disable a, b` used
+                        // to silently disable everything because the old
+                        // regex backtracked to ruleId=undefined).
+                        const ruleKeys = ruleList ?? [undefined];
                         const line = file.getLineAndCharacterOfPosition(index).line;
                         let startLine = line;
                         if (mode === 'singleLine') {
@@ -152,23 +298,34 @@ function create(cmdOption, reportsUnusedComments) {
                                 startLine = line + 1; // If the comment is at the start of the line, the error is in the next line
                             }
                         }
-                        disabledLines.push({
-                            commentRange: [
-                                index - 2,
-                                index + startComment[0].length,
-                            ],
-                            startLine,
-                        });
+                        const commentRange = [
+                            index - 2,
+                            index + startComment[0].length,
+                        ];
+                        for (const ruleId of ruleKeys) {
+                            if (!comments.has(ruleId)) {
+                                comments.set(ruleId, []);
+                            }
+                            // Per-rule state object: a paired `eslint-enable
+                            // rule1` mutates `.endLine` on the matching
+                            // rule's last entry. Sharing one state across
+                            // `[rule1, rule2]` would cause the enable to
+                            // also close rule2's window.
+                            comments.get(ruleId).push({ commentRange, startLine });
+                        }
                     }
                     else if (endReg) {
                         const endComment = c.text.match(endReg);
                         if (endComment?.index !== undefined) {
                             const index = endComment.index + c.pos;
                             const prevLine = file.getLineAndCharacterOfPosition(index).line;
-                            const ruleId = endComment.groups?.ruleId;
-                            const disabledLines = comments.get(ruleId);
-                            if (disabledLines) {
-                                disabledLines[disabledLines.length - 1].endLine = prevLine;
+                            const endRuleList = parseRuleList(endComment.groups?.tail);
+                            const endRuleKeys = endRuleList ?? [undefined];
+                            for (const ruleId of endRuleKeys) {
+                                const disabledLines = comments.get(ruleId);
+                                if (disabledLines) {
+                                    disabledLines[disabledLines.length - 1].endLine = prevLine;
+                                }
                             }
                         }
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/config",
-	"version": "3.1.0",
+	"version": "3.1.2",
 	"license": "MIT",
 	"engines": {
 		"node": ">=22.6.0"
@@ -18,12 +18,11 @@
 		"directory": "packages/config"
 	},
 	"dependencies": {
-		"@tsslint/types": "3.1.0",
-		"minimatch": "^10.0.1",
-		"ts-api-utils": "^2.0.0"
+		"@tsslint/types": "3.1.2",
+		"minimatch": "^10.0.1"
 	},
 	"devDependencies": {
-		"@tsslint/compat-eslint": "3.1.0",
+		"@tsslint/compat-eslint": "3.1.2",
 		"tslint": "^6.1.3"
 	},
 	"peerDependencies": {
@@ -38,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "3c3cf1ef52e0379d5c5f48050c1a98c2627c5d52"
+	"gitHead": "e6fb08d18e9f4feb2b0191199cecce4bdf3c4a29"
 }