fix: resolve all biome lint warnings with recommended rules

- Enable biome recommended rules with zero rule-level exceptions
- Fix noNonNullAssertion (44 places) with guard clauses and fallbacks
- Convert forEach to for...of loops (useIterableCallbackReturn)
- Convert static-only classes to plain objects (noStaticOnlyClass)
- Fix noAccumulatingSpread with push-based loops
- Extract VS Code placeholder strings to placeholders.ts (noTemplateCurlyInString)
- Fix noAssignInExpressions, noExplicitAny, and other minor warnings
- Add __mocks__ override for mock-specific lint exceptions

Author: recca0120

__mocks__/vscode.ts

@@ -1,10 +1,19 @@
-import { vi } from 'vitest';
+import { readFile } from 'node:fs/promises';
 import { glob } from 'glob';
 import { minimatch } from 'minimatch';
-import { readFile } from 'node:fs/promises';
-import {
-    CancellationToken, DocumentFilter, MarkdownString, TestController, TestCoverageCount, TestItem, TestItemCollection,
-    TestRunRequest as BaseTestRunRequest, TestTag, TextDocument, WorkspaceFolder,
+import { vi } from 'vitest';
+import type {
+    TestRunRequest as BaseTestRunRequest,
+    CancellationToken,
+    DocumentFilter,
+    MarkdownString,
+    TestController,
+    TestCoverageCount,
+    TestItem,
+    TestItemCollection,
+    TestTag,
+    TextDocument,
+    WorkspaceFolder,
 } from 'vscode';
 import { URI } from 'vscode-uri';
 
@@ -83,7 +92,9 @@ class FakeTestItemCollection implements Iterable<[id: string, testItem: TestItem
 
     replace(items: readonly TestItem[]) {
         this.items.clear();
-        items.forEach((item) => this.add(item));
+        for (const item of items) {
+            this.add(item);
+        }
     }
 
     forEach(
@@ -111,16 +122,18 @@ const createTestItem = vi
 
 const createRunProfile = vi
     .fn()
-    .mockImplementation((
-        label: string,
-        kind: TestRunProfileKind,
-        runHandler: (
-            request: BaseTestRunRequest,
-            token: CancellationToken,
-        ) => Thenable<void> | void,
-        isDefault?: boolean,
-        tag?: TestTag,
-    ) => ({ label, kind, isDefault, tag, runHandler }));
+    .mockImplementation(
+        (
+            label: string,
+            kind: TestRunProfileKind,
+            runHandler: (
+                request: BaseTestRunRequest,
+                token: CancellationToken,
+            ) => Thenable<void> | void,
+            isDefault?: boolean,
+            tag?: TestTag,
+        ) => ({ label, kind, isDefault, tag, runHandler }),
+    );
 
 const createTestRun = vi
     .fn()
@@ -175,25 +188,37 @@ class Disposable {
 }
 
 class FakeLocation {
-    constructor(public uri: URI, public range: any) {}
+    constructor(
+        public uri: URI,
+        public range: any,
+    ) {}
 }
 const Location = FakeLocation;
 
 class FakeRange {
-    constructor(public start: any, public end: any) {}
+    constructor(
+        public start: any,
+        public end: any,
+    ) {}
 }
 const Range = FakeRange;
 
 class Position {
-    constructor(public line: number, public character: number) {}
+    constructor(
+        public line: number,
+        public character: number,
+    ) {}
 
     translate(lineDelta?: number, characterDelta?: number) {
         return new Position(this.line + (lineDelta ?? 0), characterDelta ?? this.character);
     }
 }
 
 class FakeDocumentLink {
-    constructor(public range: any, public target?: URI) {}
+    constructor(
+        public range: any,
+        public target?: URI,
+    ) {}
 }
 const DocumentLink = FakeDocumentLink;
 
@@ -210,7 +235,9 @@ class FakeCancellationTokenSource {
 
     cancel() {
         this.token.isCancellationRequested = true;
-        this.listeners.forEach((fn) => fn());
+        for (const fn of this.listeners) {
+            fn();
+        }
     }
 
     dispose() {}
@@ -223,7 +250,7 @@ export class Configuration {
     constructor(items: Map<string, unknown> | { [p: string]: string } | undefined = undefined) {
         if (items instanceof Map) {
             this.items = items;
-        } else if (!!items) {
+        } else if (items) {
             for (const x in items) {
                 this.items.set(x, items[x]);
             }
@@ -261,25 +288,33 @@ const workspace = {
             uri.toString().includes(folder.uri.toString()),
         );
     },
-    findFiles: Object.assign(vi.fn().mockImplementation(async (pattern, exclude: any | undefined) => {
-        workspace.findFiles._concurrentCount++;
-        workspace.findFiles._maxConcurrent = Math.max(
-            workspace.findFiles._maxConcurrent,
-            workspace.findFiles._concurrentCount,
-        );
-        try {
-            const splitPattern = (pattern: string) => {
-                return pattern.replace(/^{|}$/g, '').split(',').map((v) => v.trim());
-            };
-            return (await glob(splitPattern(pattern.pattern), {
-                absolute: true,
-                ignore: exclude ? splitPattern(exclude.pattern) : undefined,
-                cwd: pattern.uri.fsPath,
-            })).map((file) => URI.file(file.replace(/^\w:/, (matched) => matched.toLowerCase())));
-        } finally {
-            workspace.findFiles._concurrentCount--;
-        }
-    }), { _concurrentCount: 0, _maxConcurrent: 0 }),
+    findFiles: Object.assign(
+        vi.fn().mockImplementation(async (pattern, exclude: any | undefined) => {
+            workspace.findFiles._concurrentCount++;
+            workspace.findFiles._maxConcurrent = Math.max(
+                workspace.findFiles._maxConcurrent,
+                workspace.findFiles._concurrentCount,
+            );
+            try {
+                const splitPattern = (pattern: string) => {
+                    return pattern
+                        .replace(/^{|}$/g, '')
+                        .split(',')
+                        .map((v) => v.trim());
+                };
+                return (
+                    await glob(splitPattern(pattern.pattern), {
+                        absolute: true,
+                        ignore: exclude ? splitPattern(exclude.pattern) : undefined,
+                        cwd: pattern.uri.fsPath,
+                    })
+                ).map((file) => URI.file(file.replace(/^\w:/, (matched) => matched.toLowerCase())));
+            } finally {
+                workspace.findFiles._concurrentCount--;
+            }
+        }),
+        { _concurrentCount: 0, _maxConcurrent: 0 },
+    ),
     createFileSystemWatcher: vi.fn().mockImplementation(() => {
         return {
             onDidCreate: vi.fn(),
@@ -342,13 +377,15 @@ const window = {
     showQuickPick: vi.fn(),
 };
 
-const commands = (function () {
+const commands = (() => {
     const commands = new Map<string, (...rest: any[]) => void>();
     return {
-        registerCommand: vi.fn().mockImplementation((command: string, callback: (...rest: any[]) => void) => {
-            commands.set(command, callback);
-            return new Disposable();
-        }),
+        registerCommand: vi
+            .fn()
+            .mockImplementation((command: string, callback: (...rest: any[]) => void) => {
+                commands.set(command, callback);
+                return new Disposable();
+            }),
         executeCommand: async (command: string, ...rest: any[]) => {
             return commands.get(command)!(...rest);
         },
@@ -364,7 +401,9 @@ class FakeEventEmitter<T = void> {
     };
 
     fire(data: T) {
-        this.listeners.forEach((fn) => fn(data));
+        for (const fn of this.listeners) {
+            fn(data);
+        }
     }
 
     dispose() {
@@ -381,15 +420,24 @@ const extensions = {
 };
 
 class FileCoverage {
-    constructor(public uri: URI, public statementCoverage: TestCoverageCount) {}
+    constructor(
+        public uri: URI,
+        public statementCoverage: TestCoverageCount,
+    ) {}
 }
 
 class TestCoverageCount {
-    constructor(public covered: number, public total: number) {}
+    constructor(
+        public covered: number,
+        public total: number,
+    ) {}
 }
 
 class StatementCoverage {
-    constructor(public executed: number | boolean, public location: any) {}
+    constructor(
+        public executed: number | boolean,
+        public location: any,
+    ) {}
 }
 
 const debug = {

biome.json

@@ -1,64 +1,34 @@
 {
     "$schema": "https://biomejs.dev/schemas/2.3.15/schema.json",
-    "vcs": {
-        "enabled": true,
-        "clientKind": "git",
-        "useIgnoreFile": true
-    },
+    "vcs": { "enabled": true, "clientKind": "git", "useIgnoreFile": true },
     "files": {
         "includes": ["**", "!**/out", "!**/dist", "!**/coverage", "!**/.vscode-test", "!**/*.d.ts"]
     },
-    "formatter": {
-        "indentStyle": "space",
-        "indentWidth": 4,
-        "lineWidth": 100
-    },
+    "formatter": { "indentStyle": "space", "indentWidth": 4, "lineWidth": 100 },
     "javascript": {
-        "parser": {
-            "unsafeParameterDecoratorsEnabled": true
-        },
-        "formatter": {
-            "quoteStyle": "single",
-            "trailingCommas": "all"
-        }
+        "parser": { "unsafeParameterDecoratorsEnabled": true },
+        "formatter": { "quoteStyle": "single", "trailingCommas": "all" }
     },
     "linter": {
         "rules": {
-            "style": {
-                "noNonNullAssertion": "warn"
-            },
-            "complexity": {
-                "noStaticOnlyClass": "warn",
-                "noBannedTypes": "warn"
-            },
-            "performance": {
-                "noAccumulatingSpread": "warn"
-            },
-            "suspicious": {
-                "noDoubleEquals": "warn",
-                "noExplicitAny": "error",
-                "noNonNullAssertedOptionalChain": "warn",
-                "useIterableCallbackReturn": "warn",
-                "noDuplicateTestHooks": "warn",
-                "noAssignInExpressions": "warn",
-                "noImplicitAnyLet": "warn",
-                "noExportsInTest": "warn",
-                "noTemplateCurlyInString": "warn"
-            },
-            "correctness": {
-                "noUnusedVariables": "warn",
-                "noUnusedImports": "warn",
-                "noUnsafeOptionalChaining": "warn"
-            }
+            "recommended": true
         }
     },
     "overrides": [
         {
-            "includes": ["**/*.test.ts"],
+            "includes": ["**/*.test.ts", "**/test/**"],
             "linter": {
                 "rules": {
                     "suspicious": { "noConsole": "off", "noExportsInTest": "off" },
-                    "correctness": { "noUnusedFunctionParameters": "off" },
+                    "correctness": { "noUnusedFunctionParameters": "off" }
+                }
+            }
+        },
+        {
+            "includes": ["**/__mocks__/**"],
+            "linter": {
+                "rules": {
+                    "suspicious": { "noExplicitAny": "off", "noRedeclare": "off" },
                     "style": { "noNonNullAssertion": "off" }
                 }
             }

src/Commands/PHPUnitLinkProvider.test.ts

@@ -1,6 +1,12 @@
 import { relative } from 'node:path';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { type CancellationToken, type DocumentLink, Position, Range, type TextDocument as VscodeTextDocument } from 'vscode';
+import {
+    type CancellationToken,
+    type DocumentLink,
+    Position,
+    Range,
+    type TextDocument as VscodeTextDocument,
+} from 'vscode';
 import { PHPUnitXML } from '../PHPUnit';
 import { phpUnitProject } from '../PHPUnit/__tests__/utils';
 import { PHPUnitLinkProvider } from './PHPUnitLinkProvider';
@@ -67,7 +73,7 @@ MockeryExceptionInvalidCountException: Method test(<Any Arguments>) from Mockery
                 document as unknown as VscodeTextDocument,
                 {} as unknown as CancellationToken,
             ) as DocumentLink[]
-        ).map((link) => [normalizePath(link.target!.fsPath), link.target!.fragment]);
+        ).map((link) => [normalizePath(link.target?.fsPath), link.target?.fragment]);
 
         expect(links).toEqual([
             ['vendor/mockery/mockery/library/Mockery/CountValidator/Exact.php', 'L32'],
@@ -125,7 +131,7 @@ at src/Calculator.php:7
                 document as unknown as VscodeTextDocument,
                 {} as unknown as CancellationToken,
             ) as DocumentLink[]
-        ).map((link) => [normalizePath(link.target!.fsPath), link.target!.fragment]);
+        ).map((link) => [normalizePath(link.target?.fsPath), link.target?.fragment]);
 
         expect(links).toEqual([
             ['src/Calculator.php', 'L7'],

src/Commands/PHPUnitLinkProvider.ts

@@ -8,7 +8,7 @@ import {
     type TextDocument,
 } from 'vscode';
 import { URI } from 'vscode-uri';
-import { PHPUnitXML } from '../PHPUnit';
+import type { PHPUnitXML } from '../PHPUnit';
 
 export class PHPUnitLinkProvider implements DocumentLinkProvider {
     private regex = /((?:[A-Z]:)?(?:\.{0,2}[\\/])?[^\s:]+\.php):(\d+)(?::(\d+))?/gi;
@@ -26,7 +26,11 @@ export class PHPUnitLinkProvider implements DocumentLinkProvider {
             const line = document.lineAt(lineIndex);
             let match: RegExpExecArray | null;
 
-            while ((match = this.regex.exec(line.text)) !== null) {
+            while (true) {
+                match = this.regex.exec(line.text);
+                if (match === null) {
+                    break;
+                }
                 const [fullMatch, filePath, lineStr] = match;
                 const lineNumber = parseInt(lineStr, 10);