Content mappers

Herebyfile.mjs

@@ -346,7 +346,11 @@ const enumDefs = [
     { name: "ModuleDetectionKind", goPrefix: "ModuleDetectionKind", goFile: "internal/core/compileroptions.go", outDir: "_packages/native-preview/src/enums" },
     { name: "NewLineKind", goPrefix: "NewLineKind", goFile: "internal/core/compileroptions.go", outDir: "_packages/native-preview/src/enums" },
     { name: "JsxEmit", goPrefix: "JsxEmit", goFile: "internal/core/compileroptions.go", outDir: "_packages/native-preview/src/enums" },
+    { name: "ScriptKind", goPrefix: "ScriptKind", goFile: "internal/core/scriptkind.go", outDir: "_packages/native-preview/src/enums" },
     { name: "TokenFlags", goPrefix: "TokenFlags", goFile: "internal/ast/tokenflags.go", outDir: "_packages/native-preview/src/enums" },
+    { name: "SpanMapKind", goPrefix: "Kind", goFile: "internal/spanmap/spanmap.go", outDir: "_packages/native-preview/src/enums" },
+    { name: "SpanMapFidelity", goPrefix: "Fidelity", goFile: "internal/spanmap/spanmap.go", outDir: "_packages/native-preview/src/enums" },
+    { name: "SpanMapPurpose", goPrefix: "Purpose", goFile: "internal/spanmap/spanmap.go", outDir: "_packages/native-preview/src/enums" },
     { name: "NodeBuilderFlags", goPrefix: "Flags", goFile: "internal/nodebuilder/types.go", outDir: "_packages/native-preview/src/enums" },
     { name: "CompletionItemKind", goPrefix: "CompletionItemKind", goFile: "internal/lsp/lsproto/lsp_generated.go", outDir: "_packages/native-preview/src/enums" },
     // String enum: Go stores internal names with a "\xFE" sentinel prefix, but the escaped

_extension/package.json

@@ -254,6 +254,10 @@
                 "title": "%native-preview.codeLens.showLocations.title%",
                 "enablement": "false"
             },
+            {
+                "command": "typescript.native-preview.discoverContentMappers",
+                "title": "%native-preview.discoverContentMappers.title%"
+            },
             {
                 "command": "typescript.native-preview.dev.runGC",
                 "title": "%native-preview.dev.runGC.title%",
@@ -293,6 +297,10 @@
         ],
         "menus": {
             "commandPalette": [
+                {
+                    "command": "typescript.native-preview.discoverContentMappers",
+                    "when": "false"
+                },
                 {
                     "command": "typescript.native-preview.restart",
                     "when": "typescript.native-preview.serverRunning"

_extension/package.nls.json

@@ -25,6 +25,7 @@
     "native-preview.sortImports.title": "Sort Imports",
     "native-preview.removeUnusedImports.title": "Remove Unused Imports",
     "native-preview.codeLens.showLocations.title": "Show References of CodeLens",
+    "native-preview.discoverContentMappers.title": "Discover TypeScript Content Mappers",
     "native-preview.dev.runGC.title": "TypeScript: Run Garbage Collection",
     "native-preview.dev.saveHeapProfile.title": "TypeScript: Save Heap Profile",
     "native-preview.dev.saveAllocProfile.title": "TypeScript: Save Allocation Profile",

_extension/src/client.ts

@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 
+import { CancellationToken } from "vscode-languageclient";
 import {
     ClientCapabilities,
     CloseAction,
@@ -37,6 +38,24 @@ import {
 } from "./util";
 import { getLanguageForUri } from "./util";
 
+// Registration IDs the server uses for content mapper capabilities all share this prefix (see
+// RegisterContentMapperExtensions in internal/lsp/server.go). The extension watches for these dynamic
+// registrations to learn which foreign file extensions are content-mapped.
+const contentMapperRegistrationPrefix = "content-mapper-";
+
+// ContentMapperRegisterOptions is the subset of a dynamic registration's options that our server sends
+// for content mapper capabilities: a document selector of simple glob-pattern filters (see
+// RegisterContentMapperExtensions in internal/lsp/server.go).
+interface ContentMapperRegisterOptions {
+    documentSelector?: ReadonlyArray<{ pattern: string; }>;
+}
+
+// extractPatternFilters reuses the server's glob-pattern filters so the extension's custom providers match
+// the same content-mapped files.
+function extractPatternFilters(registerOptions: ContentMapperRegisterOptions | undefined): vscode.DocumentFilter[] {
+    return (registerOptions?.documentSelector ?? []).map(({ pattern }) => ({ pattern }));
+}
+
 export class Client implements vscode.Disposable {
     private outputChannel: vscode.LogOutputChannel;
     private initializedEventEmitter: vscode.EventEmitter<void>;
@@ -51,6 +70,14 @@ export class Client implements vscode.Disposable {
     private disposables: vscode.Disposable[] = [];
     isInitialized = false;
 
+    // Document filters for content-mapped file extensions, keyed by the server's registration ID. These
+    // augment the static jsTs document selector so the extension's custom language-feature providers
+    // (hover, multi-document highlight, on-auto-insert) also cover content-mapped files.
+    private contentMapperFiltersById = new Map<string, vscode.DocumentFilter[]>();
+    // Disposables for the custom providers registered against the current (selector-scoped) document set.
+    // Re-registered whenever the set of content-mapped extensions changes.
+    private selectorScopedFeatures: vscode.Disposable[] = [];
+
     private exe: ExeInfo | undefined;
     private errorHandler: ReportingErrorHandler;
 
@@ -84,6 +111,8 @@ export class Client implements vscode.Disposable {
                 codeLensShowLocationsCommandName,
                 enableTelemetry: true,
                 logVerbosity: this.outputChannel.logLevel,
+                // Content mappers run external plugin processes, so they are only enabled in a trusted workspace.
+                loadExternalPlugins: vscode.workspace.isTrusted,
             },
             errorHandler: this.errorHandler,
             middleware: {
@@ -98,6 +127,18 @@ export class Client implements vscode.Disposable {
                 },
                 sendNotification: sendNotificationMiddleware,
                 provideHover: () => undefined,
+                handleRegisterCapability: async (params, next) => {
+                    await next(params, CancellationToken.None);
+                    if (this.trackContentMapperRegistrations(params.registrations)) {
+                        this.registerSelectorScopedFeatures();
+                    }
+                },
+                handleUnregisterCapability: async (params, next) => {
+                    await next(params, CancellationToken.None);
+                    if (this.trackContentMapperUnregistrations(params.unregisterations)) {
+                        this.registerSelectorScopedFeatures();
+                    }
+                },
             },
             diagnosticCollectionName: "typescript-push",
             diagnosticPullOptions: {
@@ -133,10 +174,16 @@ export class Client implements vscode.Disposable {
                             }
 
                             if (selector.pattern !== undefined) {
-                                // VS Code's glob matcher is not available via the API;
-                                // see: https://github.com/microsoft/vscode/issues/237304
-                                // But, we're only called on selectors passed above, so just ignore this for now.
-                                throw new Error("Not implemented");
+                                // VS Code's full glob matcher is not available via the API
+                                // (microsoft/vscode#237304), but content mapper registrations only ever
+                                // use simple "**/*<ext>" patterns, so match those by suffix. Any other
+                                // pattern falls through to the next selector.
+                                const glob = typeof selector.pattern === "string" ? selector.pattern : selector.pattern.pattern;
+                                const globPrefix = "**/*";
+                                if (glob.startsWith(globPrefix) && resource.path.endsWith(glob.slice(globPrefix.length))) {
+                                    return true;
+                                }
+                                continue;
                             }
 
                             return true;
@@ -190,9 +237,9 @@ export class Client implements vscode.Disposable {
             },
         };
 
-        // Refresh the initial log verbosity in case the output channel's log
-        // level changed between construction and start.
+        // Refresh options in case they changed between construction and start.
         this.clientOptions.initializationOptions.logVerbosity = this.outputChannel.logLevel;
+        this.clientOptions.initializationOptions.loadExternalPlugins = vscode.workspace.isTrusted;
 
         this.client = new NativePreviewLanguageClient(
             "js/ts",
@@ -257,11 +304,77 @@ export class Client implements vscode.Disposable {
         this.disposables.push(
             logLevelListener,
             serverTelemetryListener,
-            registerMultiDocumentHighlightFeature(this.documentSelector, this.client),
             registerSourceDefinitionFeature(this.client),
-            registerHoverFeature(this.documentSelector, this.client),
             registerOnAutoInsertFeature(this.documentSelector, this.client),
         );
+        // Register the selector-scoped custom providers (hover, multi-document highlight). These start
+        // scoped to the static jsTs selector and expand as content-mapped extensions register.
+        this.registerSelectorScopedFeatures();
+    }
+
+    // trackContentMapperRegistrations records the content-mapped document filters carried by the server's
+    // dynamic capability registrations. Returns whether the known set of content-mapper filters changed.
+    private trackContentMapperRegistrations(registrations: ReadonlyArray<{ id: string; registerOptions?: ContentMapperRegisterOptions; }>): boolean {
+        let changed = false;
+        for (const registration of registrations) {
+            if (!registration.id.startsWith(contentMapperRegistrationPrefix)) {
+                continue;
+            }
+            const filters = extractPatternFilters(registration.registerOptions);
+            if (filters.length > 0) {
+                this.contentMapperFiltersById.set(registration.id, filters);
+                changed = true;
+            }
+            else if (this.contentMapperFiltersById.delete(registration.id)) {
+                changed = true;
+            }
+        }
+        return changed;
+    }
+
+    // trackContentMapperUnregistrations forgets the filters for any content-mapper registration the server
+    // has removed. Returns whether the known set of content-mapper filters changed.
+    private trackContentMapperUnregistrations(unregistrations: ReadonlyArray<{ id: string; }>): boolean {
+        let changed = false;
+        for (const unregistration of unregistrations) {
+            if (this.contentMapperFiltersById.delete(unregistration.id)) {
+                changed = true;
+            }
+        }
+        return changed;
+    }
+
+    // selectorScopedDocumentSelector is the static jsTs selector plus every active content-mapper filter,
+    // deduplicated. The custom providers are registered against it so they also cover content-mapped files.
+    private selectorScopedDocumentSelector(): vscode.DocumentSelector {
+        const seen = new Set<string>();
+        const filters: vscode.DocumentFilter[] = [];
+        for (const list of this.contentMapperFiltersById.values()) {
+            for (const filter of list) {
+                const key = typeof filter.pattern === "string" ? filter.pattern : JSON.stringify(filter.pattern);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    filters.push(filter);
+                }
+            }
+        }
+        return [...this.documentSelector, ...filters];
+    }
+
+    // registerSelectorScopedFeatures (re)registers the custom language-feature providers whose scope must
+    // track the set of content-mapped extensions. Existing registrations are disposed first.
+    private registerSelectorScopedFeatures(): void {
+        for (const disposable of this.selectorScopedFeatures.splice(0)) {
+            disposable.dispose();
+        }
+        if (!this.client || this.isStopping || this.isDisposed) {
+            return;
+        }
+        const selector = this.selectorScopedDocumentSelector();
+        this.selectorScopedFeatures.push(
+            registerMultiDocumentHighlightFeature(selector, this.client),
+            registerHoverFeature(selector, this.client),
+        );
     }
 
     async stop(): Promise<void> {
@@ -270,6 +383,10 @@ export class Client implements vscode.Disposable {
         }
         this.isStopping = true;
         this.isInitialized = false;
+        for (const disposable of this.selectorScopedFeatures.splice(0)) {
+            disposable.dispose();
+        }
+        this.contentMapperFiltersById.clear();
         const disposables = this.disposables.splice(0);
         await Promise.all(disposables.map(d => d.dispose()));
         await this.client?.stop();
@@ -282,6 +399,10 @@ export class Client implements vscode.Disposable {
         this.isDisposed = true;
         this.isStopping = true;
         this.isInitialized = false;
+        for (const disposable of this.selectorScopedFeatures.splice(0)) {
+            disposable.dispose();
+        }
+        this.contentMapperFiltersById.clear();
         const disposables = this.disposables.splice(0);
         await Promise.all(disposables.map(d => d.dispose()));
         await this.client?.dispose();
@@ -391,6 +512,23 @@ export class Client implements vscode.Disposable {
             textDocument: { uri },
         }, token);
     }
+
+    async discoverContentMappers(uris: readonly vscode.Uri[], extensions: readonly string[]): Promise<readonly string[]> {
+        if (!this.client || !this.isInitialized || !vscode.workspace.isTrusted) {
+            return [];
+        }
+        try {
+            const result = await this.client.sendRequest<{ extensions: string[]; }>("custom/discoverContentMappers", {
+                textDocuments: uris.map(uri => ({ uri: uri.toString() })),
+                extensions: [...extensions],
+            });
+            return result.extensions;
+        }
+        catch (error) {
+            this.outputChannel.warn(`Content mapper discovery failed: ${String(error)}`);
+            return [];
+        }
+    }
 }
 
 // Returns true when running on a VS Code Insiders build.

_extension/src/commands.ts

@@ -26,6 +26,36 @@ export function registerEnablementCommands(context: vscode.ExtensionContext, tel
     }));
 }
 
+export const discoverContentMappersCommandName = "typescript.native-preview.discoverContentMappers";
+
+export interface DiscoverContentMappersCommandArgs {
+    readonly uris: readonly vscode.Uri[];
+    readonly extensions: readonly string[];
+}
+
+export function registerDiscoverContentMappersCommand(
+    context: vscode.ExtensionContext,
+    discover: (uris: readonly vscode.Uri[], extensions: readonly string[]) => Promise<readonly string[]>,
+): void {
+    context.subscriptions.push(vscode.commands.registerCommand(discoverContentMappersCommandName, async (args: unknown): Promise<readonly string[]> => {
+        if (!isDiscoverContentMappersCommandArgs(args)) {
+            return [];
+        }
+        return discover(args.uris, args.extensions);
+    }));
+}
+
+function isDiscoverContentMappersCommandArgs(value: unknown): value is DiscoverContentMappersCommandArgs {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const args = value as Partial<DiscoverContentMappersCommandArgs>;
+    return Array.isArray(args.uris)
+        && args.uris.every(uri => uri instanceof vscode.Uri)
+        && Array.isArray(args.extensions)
+        && args.extensions.every(extension => typeof extension === "string");
+}
+
 /**
  * Updates the TypeScript 7 setting and reloads extension host.
  * Handles both `js/ts.experimental.useTsgo` and `typescript.experimental.useTsgo`.

_extension/src/extension.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 
 import {
+    registerDiscoverContentMappersCommand,
     registerEnablementCommands,
     updateUseTsgoSetting,
 } from "./commands";
@@ -51,6 +52,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<Extens
     const sessionManager = new SessionManager(context, output, languageServerInitializedEventEmitter, telemetryReporter);
     context.subscriptions.push(sessionManager);
     registerEnablementCommands(context, telemetryReporter, () => sessionManager.stop());
+    registerDiscoverContentMappersCommand(context, (uris, extensions) => sessionManager.discoverContentMappers(uris, extensions));
 
     let pluginWarningShown = false;
     const onDidChangeExtensions = vscode.extensions.onDidChange(() => {

_extension/src/session.ts

@@ -42,6 +42,10 @@ export class SessionManager implements vscode.Disposable {
         this.outputChannel = outputChannel;
         this.telemetryReporter = telemetryReporter;
         this.initializedEventEmitter = initializedEventEmitter;
+
+        // Workspace trust gates content mappers (external plugin processes), which are passed to the
+        // server as an initialization option. Restart when trust is granted so they become active.
+        this.disposables.push(vscode.workspace.onDidGrantWorkspaceTrust(() => this.restart(context)));
     }
 
     start(context: vscode.ExtensionContext): Promise<void> {
@@ -72,6 +76,10 @@ export class SessionManager implements vscode.Disposable {
         return result.pipe;
     }
 
+    async discoverContentMappers(uris: readonly vscode.Uri[], extensions: readonly string[]): Promise<readonly string[]> {
+        return this.currentSession?.client.discoverContentMappers(uris, extensions) ?? [];
+    }
+
     async dispose(): Promise<void> {
         await this.currentSession?.dispose();
         await Promise.all(this.disposables.map(d => d.dispose()));

_packages/native-preview/src/api/async/client.ts

@@ -17,6 +17,7 @@ import {
     type ClientOptions,
     type ClientSocketOptions,
     type ClientSpawnOptions,
+    getAPIProcessArgs,
     isSpawnOptions,
     resolveExePath,
 } from "../options.ts";
@@ -65,16 +66,7 @@ export class Client {
         const { spawn } = await import("node:child_process");
 
         return new Promise((resolve, reject) => {
-            const args = [
-                "--api",
-                "--async",
-                "--cwd",
-                options.cwd ?? process.cwd(),
-            ];
-
-            if (options.collectTiming) {
-                args.push("--timing");
-            }
+            const args = getAPIProcessArgs(options, true);
 
             // Enable virtual FS callbacks for each provided FS function
             const enabledCallbacks: string[] = [];

_packages/native-preview/src/api/node/encoder.ts

@@ -139,7 +139,7 @@ function recordExtendedData(node: Node, strs: StringTable, extendedData: number[
         const referencedFilesOffset = encodeFileReferences(sf.referencedFiles, structuredWriter);
         const typeRefDirectivesOffset = encodeFileReferences(sf.typeReferenceDirectives, structuredWriter);
         const libRefDirectivesOffset = encodeFileReferences(sf.libReferenceDirectives, structuredWriter);
-        extendedData.push(textIndex, fileNameIndex, pathIndex, sf.languageVariant, sf.scriptKind, referencedFilesOffset, typeRefDirectivesOffset, libRefDirectivesOffset, NO_STRUCTURED_DATA, NO_STRUCTURED_DATA, NO_STRUCTURED_DATA, 0);
+        extendedData.push(textIndex, fileNameIndex, pathIndex, sf.languageVariant, sf.scriptKind, referencedFilesOffset, typeRefDirectivesOffset, libRefDirectivesOffset, NO_STRUCTURED_DATA, NO_STRUCTURED_DATA, NO_STRUCTURED_DATA, 0, textIndex, NO_STRUCTURED_DATA);
     }
     else if (
         node.kind === SyntaxKind.TemplateHead ||