chore: Simplify extension (#25)

## Summary

### Simplification (`chore: Simplify extension`)
- **`providers.ts`**: Extracted `delegateLocationProvider()` helper
shared by `PHPXDefinitionProvider`, `PHPXTypeDefinitionProvider`, and
`PHPXImplementationProvider` — eliminated ~60 lines of triplicated
boilerplate. Simplified `mapLocationLinkToSource` using a single
`remapUri` variable instead of three mutable lets. Removed dead
`PHPXWorkspaceSymbolProvider` class (exported but never registered in
`extension.ts`).
- **`compiler.ts`**: Moved `stderrOverflow` declaration above its
handler (was declared one line after use). Added `stderrOverflow` to the
`close` handler's overflow branch — previously only `truncated` was
checked, leaving stderr-overflow kills to fall through to `code !== 0`
and attempt `JSON.parse` on a truncated buffer. Removed dead
`compilationErrors` map and `getCompilationError()` method (written but
never read externally). Fixed `err.message || err.stack` order in
`compileAndWrite` catch — stack now used for logging, message for
user-facing error.
- **`diagnostics.ts`**: Removed `shouldForwardDiagnostic()` stub (always
returned `true`) and its no-op `.filter()` call site.
- **`positionMapper.ts`**: Removed `/g` flag from module-level
`PHP_WORD_PATTERN` — `document.getWordRangeAtPosition()` throws if
passed a global regex (this was silently swallowing the error in all
three location providers). Fixed double-`statSync` on cache miss: stat
first, then read.
- **`languageClient.ts`**: Removed redundant `?? undefined` from
optional-chain expression.
- **`extension.ts`**: Deduplicated the three identical vendorWatcher
event handlers into a shared `clearCompilerCache` callback.

### Bug fix (`fix(positionMapper): use fresh regex in getWordAt for
matchAll compatibility`)
- `getWordAt` uses `String.matchAll()` which requires a global regex,
but `PHP_WORD_PATTERN` no longer has `/g`. Fixed by creating a fresh
`new RegExp(PHP_WORD_PATTERN.source, 'g')` at the call site — consistent
with the pattern already used in `getNthOccurrence` and
`findNthOccurrence`.

### Tests (`test(extension): fix false positives and strengthen
assertions`)
- **`extension.test.ts`**: Replaced circular `languageId` test (was
forcibly setting `language: 'phpx'` then asserting `languageId ===
'phpx'`) with a real auto-detection test that opens a temp `.phpx` file
by URI.
- **`grammar.test.ts`**: Removed `runGrammarTests()` — it looped over 12
test cases with `expectedScopes` arrays that were never read; every case
unconditionally incremented `passed`. Actual tokenization is covered by
`pnpm test:grammar` via `vscode-tmgrammar-test`. Strengthened
`validateGrammarStructure` to assert non-empty `patterns` and
`repository`.
- **`range-remap.test.ts`**: Fixed `executeCommand` mocks to capture and
assert the forwarded PHP URI and PHPX→PHP mapped column — the forward
position mapping was previously completely untested. Added end-position
assertions to all four tests (only start was previously checked). Added
`phpxTitleStart !== phpTitleStart` guard to guarantee the fixture
requires non-trivial column remapping.

## Test plan

- [x] TypeScript compilation passes (`pnpm compile` — no errors)
- [x] All 8 integration tests pass (`pnpm test`)
- [x] Grammar tests pass (`pnpm test:grammar`)
- [ ] Go-to-definition, type definition, and find implementation work in
`.phpx` files
- [ ] stderr overflow during compilation produces "Compilation output
exceeded size limit" instead of a JSON parse error
- [ ] No regression in diagnostics forwarding from PHP language server
to `.phpx` files

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: attitude

extension/src/compiler.ts

@@ -14,7 +14,6 @@ export interface CompilationResult {
  */
 export class PHPXCompiler {
 	private outputChannel: vscode.OutputChannel;
-	private compilationErrors: Map<string, string> = new Map();
 	/** Cache: workspace folder fsPath → resolved compiler script path (or null if not found) */
 	private compilerScriptCache: Map<string, string | null> = new Map();
 	/** Cache: workspace folder fsPath → resolved project root */
@@ -178,6 +177,7 @@ export class PHPXCompiler {
 			let stdout = '';
 			let stderr = '';
 			let truncated = false;
+			let stderrOverflow = false;
 
 			proc.stdout!.on('data', (data: Buffer) => {
 				try {
@@ -194,7 +194,7 @@ export class PHPXCompiler {
 					proc.kill();
 				}
 			});
-			let stderrOverflow = false;
+
 			proc.stderr!.on('data', (data: Buffer) => {
 				try {
 					if (stderr.length < maxOutputBytes) {
@@ -218,13 +218,12 @@ export class PHPXCompiler {
 			});
 
 			proc.on('close', (code) => {
-				if (truncated) {
+				if (truncated || stderrOverflow) {
 					resolve({
 						php: '',
 						error: 'Compilation output exceeded size limit',
 					});
 				} else if (code === 0) {
-					this.compilationErrors.delete(documentUri.toString());
 					resolve({ php: stdout });
 				} else {
 					let errorMessage = stderr;
@@ -234,7 +233,6 @@ export class PHPXCompiler {
 					} catch {
 						// stderr is not JSON, use as-is
 					}
-					this.compilationErrors.set(documentUri.toString(), errorMessage);
 					resolve({
 						php: '',
 						error: errorMessage,
@@ -306,20 +304,11 @@ export class PHPXCompiler {
 
 			return { phpUri };
 		} catch (err) {
-			const error =
-				(err instanceof Error
-					? err.message || err.stack || String(err)
-					: String(err)) || 'Unknown compilation error';
-			const errorLog = err instanceof Error ? err.stack || error : error;
+			const message = err instanceof Error ? err.message || String(err) : String(err);
+			const errorLog = err instanceof Error ? err.stack || message : message;
 			this.outputChannel.appendLine(`[PHPX] compileAndWrite error — ${errorLog}`);
-			return { phpUri, error };
+			return { phpUri, error: message || 'Unknown compilation error' };
 		}
 	}
 
-	/**
-	 * Get the last compilation error for a document
-	 */
-	getCompilationError(documentUri: vscode.Uri): string | undefined {
-		return this.compilationErrors.get(documentUri.toString());
-	}
 }

extension/src/diagnostics.ts

@@ -60,9 +60,7 @@ export class PHPXDiagnosticsManager {
 			}
 
 			// Forward diagnostics to the PHPX file with remapped positions
-			const forwarded = phpDiagnostics
-				.filter((d) => this.shouldForwardDiagnostic(d))
-				.map((d) => {
+			const forwarded = phpDiagnostics.map((d) => {
 					const mappedRange = mapRangeToPhpx(uri, phpxUri, d.range);
 					const mapped = new vscode.Diagnostic(
 						mappedRange,
@@ -111,15 +109,6 @@ export class PHPXDiagnosticsManager {
 		}
 	}
 
-	/**
-	 * Filter out diagnostics that are artifacts of the PHPX→PHP compilation.
-	 */
-	private shouldForwardDiagnostic(diagnostic: vscode.Diagnostic): boolean {
-		// Forward all diagnostics for now.
-		// Can be refined later to filter out compilation artifacts.
-		return true;
-	}
-
 	/**
 	 * Show a compiler failure as a diagnostic on the PHPX file.
 	 * This is separate from LSP parse diagnostics — it indicates the

extension/src/extension.ts

@@ -168,9 +168,10 @@ export function activate(context: vscode.ExtensionContext) {
 
 	// Invalidate caches when vendor/composer files change
 	const vendorWatcher = vscode.workspace.createFileSystemWatcher('**/vendor/autoload.php');
-	vendorWatcher.onDidCreate(() => compiler.clearCache());
-	vendorWatcher.onDidChange(() => compiler.clearCache());
-	vendorWatcher.onDidDelete(() => compiler.clearCache());
+	const clearCompilerCache = () => compiler.clearCache();
+	vendorWatcher.onDidCreate(clearCompilerCache);
+	vendorWatcher.onDidChange(clearCompilerCache);
+	vendorWatcher.onDidDelete(clearCompilerCache);
 	context.subscriptions.push(vendorWatcher);
 
 	// Clean up when a PHPX file is closed

extension/src/languageClient.ts

@@ -38,8 +38,7 @@ export function startLanguageClient(
 
 	outputChannel.appendLine(`[PHPX LSP] Using server script: ${serverScript}`);
 
-	const cwd =
-		vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? undefined;
+	const cwd = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
 
 	const serverOptions: ServerOptions = {
 		command: phpPath,

extension/src/positionMapper.ts

@@ -17,7 +17,7 @@ import * as vscode from 'vscode';
  * PHP identifier pattern: variable ($name) or identifier (name).
  * Matches the same tokens the PHP language server would consider "words".
  */
-const PHP_WORD_PATTERN = /\$?[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*/g;
+const PHP_WORD_PATTERN = /\$?[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*/;
 
 /**
  * File content cache with mtime validation.
@@ -85,8 +85,8 @@ function getFileContent(uri: vscode.Uri): string | null {
 
 	// 3. Read from disk and cache
 	try {
-		const content = fs.readFileSync(fsPath, 'utf-8');
 		const stat = fs.statSync(fsPath);
+		const content = fs.readFileSync(fsPath, 'utf-8');
 		fileCache.set(fsPath, { content, mtime: stat.mtimeMs });
 		return content;
 	} catch {
@@ -247,7 +247,7 @@ function getWordAt(
 	line: string,
 	charOffset: number,
 ): { text: string; start: number } | null {
-	const matches = [...line.matchAll(PHP_WORD_PATTERN)];
+	const matches = [...line.matchAll(new RegExp(PHP_WORD_PATTERN.source, 'g'))];
 	for (const match of matches) {
 		const start = match.index!;
 		const end = start + match[0].length;

extension/src/providers.ts

@@ -46,69 +46,73 @@ function mapLocationLinkToSource(
 	phpxUri: vscode.Uri,
 	phpUri: vscode.Uri,
 ): vscode.LocationLink {
-	let targetUri = link.targetUri;
-	let targetRange = link.targetRange;
-	let targetSelectionRange = link.targetSelectionRange;
-
-	if (targetUri.fsPath === phpUri.fsPath) {
-		targetRange = mapRangeToPhpx(phpUri, phpxUri, link.targetRange);
-		targetSelectionRange = link.targetSelectionRange
-			? mapRangeToPhpx(phpUri, phpxUri, link.targetSelectionRange)
-			: undefined;
-		targetUri = phpxUri;
-	} else if (PHPXCompiler.hasPhpxSource(targetUri)) {
-		const sourceUri = PHPXCompiler.getSourceUri(targetUri);
-		targetRange = mapRangeToPhpx(targetUri, sourceUri, link.targetRange);
-		targetSelectionRange = link.targetSelectionRange
-			? mapRangeToPhpx(targetUri, sourceUri, link.targetSelectionRange)
-			: undefined;
-		targetUri = sourceUri;
+	let remapUri: vscode.Uri | undefined;
+	if (link.targetUri.fsPath === phpUri.fsPath) {
+		remapUri = phpxUri;
+	} else if (PHPXCompiler.hasPhpxSource(link.targetUri)) {
+		remapUri = PHPXCompiler.getSourceUri(link.targetUri);
 	}
+
 	return {
 		originSelectionRange: link.originSelectionRange
 			? mapRangeToPhpx(phpUri, phpxUri, link.originSelectionRange)
 			: undefined,
-		targetUri,
-		targetRange,
-		targetSelectionRange,
+		targetUri: remapUri ?? link.targetUri,
+		targetRange: remapUri
+			? mapRangeToPhpx(link.targetUri, remapUri, link.targetRange)
+			: link.targetRange,
+		targetSelectionRange: remapUri && link.targetSelectionRange
+			? mapRangeToPhpx(link.targetUri, remapUri, link.targetSelectionRange)
+			: link.targetSelectionRange,
 	};
 }
 
 // ─── Completion and Hover are handled by the PHPX Language Server (LSP) ─────
 
+/**
+ * Delegate a location-style command to the compiled PHP file and remap results back to PHPX.
+ * Shared by Definition, TypeDefinition, and Implementation providers.
+ */
+async function delegateLocationProvider(
+	document: vscode.TextDocument,
+	position: vscode.Position,
+	command: string,
+): Promise<vscode.Definition | vscode.LocationLink[] | null> {
+	const phpUri = PHPXCompiler.getCompiledUri(document.uri);
+	const phpxUri = document.uri;
+	const mappedPosition = mapPositionToPhp(document, position, phpUri);
+
+	try {
+		const result = await vscode.commands.executeCommand<
+			(vscode.Location | vscode.LocationLink)[]
+		>(command, phpUri, mappedPosition);
+
+		if (!result || result.length === 0) {
+			return null;
+		}
+
+		if ('targetUri' in result[0]) {
+			return (result as vscode.LocationLink[]).map((item) =>
+				mapLocationLinkToSource(item, phpxUri, phpUri),
+			);
+		}
+		return (result as vscode.Location[]).map((item) =>
+			mapLocationToSource(item, phpxUri, phpUri),
+		);
+	} catch {
+		return null;
+	}
+}
+
 // ─── Definition ──────────────────────────────────────────────────────────────
 
 export class PHPXDefinitionProvider implements vscode.DefinitionProvider {
-	async provideDefinition(
+	provideDefinition(
 		document: vscode.TextDocument,
 		position: vscode.Position,
 		_token: vscode.CancellationToken,
 	): Promise<vscode.Definition | vscode.LocationLink[] | null> {
-		const phpUri = PHPXCompiler.getCompiledUri(document.uri);
-		const phpxUri = document.uri;
-		const mappedPosition = mapPositionToPhp(document, position, phpUri);
-
-		try {
-			const result = await vscode.commands.executeCommand<
-				(vscode.Location | vscode.LocationLink)[]
-			>('vscode.executeDefinitionProvider', phpUri, mappedPosition);
-
-			if (!result || result.length === 0) {
-				return null;
-			}
-
-			// Separate into typed arrays to satisfy the union return type
-			if ('targetUri' in result[0]) {
-				return (result as vscode.LocationLink[]).map((item) =>
-					mapLocationLinkToSource(item, phpxUri, phpUri),
-				);
-			}
-			return (result as vscode.Location[]).map((item) =>
-				mapLocationToSource(item, phpxUri, phpUri),
-			);
-		} catch {
-			return null;
-		}
+		return delegateLocationProvider(document, position, 'vscode.executeDefinitionProvider');
 	}
 }
 
@@ -117,35 +121,12 @@ export class PHPXDefinitionProvider implements vscode.DefinitionProvider {
 export class PHPXTypeDefinitionProvider
 	implements vscode.TypeDefinitionProvider
 {
-	async provideTypeDefinition(
+	provideTypeDefinition(
 		document: vscode.TextDocument,
 		position: vscode.Position,
 		_token: vscode.CancellationToken,
 	): Promise<vscode.Definition | vscode.LocationLink[] | null> {
-		const phpUri = PHPXCompiler.getCompiledUri(document.uri);
-		const phpxUri = document.uri;
-		const mappedPosition = mapPositionToPhp(document, position, phpUri);
-
-		try {
-			const result = await vscode.commands.executeCommand<
-				(vscode.Location | vscode.LocationLink)[]
-			>('vscode.executeTypeDefinitionProvider', phpUri, mappedPosition);
-
-			if (!result || result.length === 0) {
-				return null;
-			}
-
-			if ('targetUri' in result[0]) {
-				return (result as vscode.LocationLink[]).map((item) =>
-					mapLocationLinkToSource(item, phpxUri, phpUri),
-				);
-			}
-			return (result as vscode.Location[]).map((item) =>
-				mapLocationToSource(item, phpxUri, phpUri),
-			);
-		} catch {
-			return null;
-		}
+		return delegateLocationProvider(document, position, 'vscode.executeTypeDefinitionProvider');
 	}
 }
 
@@ -257,44 +238,6 @@ export class PHPXDocumentSymbolProvider
 	}
 }
 
-// ─── Workspace Symbols ──────────────────────────────────────────────────────
-
-export class PHPXWorkspaceSymbolProvider
-	implements vscode.WorkspaceSymbolProvider
-{
-	async provideWorkspaceSymbols(
-		query: string,
-		_token: vscode.CancellationToken,
-	): Promise<vscode.SymbolInformation[] | null> {
-		try {
-			const result = await vscode.commands.executeCommand<
-				vscode.SymbolInformation[]
-			>('vscode.executeWorkspaceSymbolProvider', query);
-
-			if (!result) {
-				return null;
-			}
-
-			return result.map((symbol) => {
-				const loc = symbol.location;
-				if (!PHPXCompiler.hasPhpxSource(loc.uri)) {
-					return symbol;
-				}
-				const sourceUri = PHPXCompiler.getSourceUri(loc.uri);
-				const range = mapRangeToPhpx(loc.uri, sourceUri, loc.range);
-				return new vscode.SymbolInformation(
-					symbol.name,
-					symbol.kind,
-					symbol.containerName ?? '',
-					new vscode.Location(sourceUri, range),
-				);
-			});
-		} catch {
-			return null;
-		}
-	}
-}
-
 // ─── Code Actions ────────────────────────────────────────────────────────────
 
 export class PHPXCodeActionProvider implements vscode.CodeActionProvider {
@@ -455,34 +398,11 @@ export class PHPXRenameProvider implements vscode.RenameProvider {
 export class PHPXImplementationProvider
 	implements vscode.ImplementationProvider
 {
-	async provideImplementation(
+	provideImplementation(
 		document: vscode.TextDocument,
 		position: vscode.Position,
 		_token: vscode.CancellationToken,
 	): Promise<vscode.Definition | vscode.LocationLink[] | null> {
-		const phpUri = PHPXCompiler.getCompiledUri(document.uri);
-		const phpxUri = document.uri;
-		const mappedPosition = mapPositionToPhp(document, position, phpUri);
-
-		try {
-			const result = await vscode.commands.executeCommand<
-				(vscode.Location | vscode.LocationLink)[]
-			>('vscode.executeImplementationProvider', phpUri, mappedPosition);
-
-			if (!result || result.length === 0) {
-				return null;
-			}
-
-			if ('targetUri' in result[0]) {
-				return (result as vscode.LocationLink[]).map((item) =>
-					mapLocationLinkToSource(item, phpxUri, phpUri),
-				);
-			}
-			return (result as vscode.Location[]).map((item) =>
-				mapLocationToSource(item, phpxUri, phpUri),
-			);
-		} catch {
-			return null;
-		}
+		return delegateLocationProvider(document, position, 'vscode.executeImplementationProvider');
 	}
 }