Content mappers

Herebyfile.mjs

@@ -352,7 +352,12 @@ 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: "DiagnosticDirectivePolicy", goPrefix: "MappedDiagnosticDirectivePolicy", goFile: "internal/ast/ast.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: "SpanMapFeature", goPrefix: "Feature", 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" },
     { name: "EmitOnly", goPrefix: "Emit", goFile: "internal/compiler/emitter.go", outDir: "_packages/native-preview/src/enums", excludeMembers: ["OnlyBuilderSignature"] },
@@ -370,7 +375,7 @@ function parseGoConstBlock(block, def) {
     const prefix = def.goPrefix;
     const members = [];
     let iotaCounter = 0;
-    let hasIota = false;
+    let iotaExpression;
 
     for (const rawLine of block.split("\n")) {
         const line = rawLine.replace(/\/\/.*$/, "").trim();
@@ -379,7 +384,7 @@ function parseGoConstBlock(block, def) {
         // Match: PrefixName Type = value  or  PrefixName = value
         const fullMatch = line.match(new RegExp(`^(${prefix}\\w+)\\s+(?:\\S+\\s*)?=\\s*(.+)$`));
         // Match bare iota continuation: just PrefixName
-        const bareMatch = !fullMatch && hasIota
+        const bareMatch = !fullMatch && iotaExpression !== undefined
             ? line.match(new RegExp(`^(${prefix}\\w+)$`))
             : null;
 
@@ -393,12 +398,12 @@ function parseGoConstBlock(block, def) {
         if (def.stringEnum) {
             tsValue = parseGoStringValue(goValue, def.valueReplacements ?? {});
         }
-        else if (goValue === "iota") {
-            tsValue = String(iotaCounter);
-            hasIota = true;
+        else if (goValue.includes("iota")) {
+            iotaExpression = goValue;
+            tsValue = goValue.replace(/\biota\b/g, String(iotaCounter));
         }
-        else if (hasIota && goValue === "") {
-            tsValue = String(iotaCounter);
+        else if (iotaExpression !== undefined && goValue === "") {
+            tsValue = iotaExpression.replace(/\biota\b/g, String(iotaCounter));
         }
         else {
             // Replace Go bitwise NOT (^) with TypeScript (~)

_extension/package.json

@@ -86,6 +86,15 @@
                             "experimental"
                         ]
                     },
+                    "js/ts.contentMappers.enabled": {
+                        "type": "boolean",
+                        "default": true,
+                        "description": "%native-preview.contentMappers.enabled.description%",
+                        "scope": "window",
+                        "tags": [
+                            "experimental"
+                        ]
+                    },
                     "js/ts.server.goMemLimit": {
                         "type": "string",
                         "description": "%native-preview.goMemLimit.description%",

_extension/package.nls.json

@@ -6,6 +6,7 @@
     "native-preview.tsserver.tsdk.description": "Path to the @typescript/native-preview package or tsgo binary directory. If not specified, the extension will look for it in the default location.",
     "native-preview.additionalTsdkLocations.description": "Additional paths to tsgo binary directories or @typescript/native-preview packages that should appear in the version selector.",
     "native-preview.showDebugInfo.description": "Show debug information (PID, executable path) in the server menu.",
+    "native-preview.contentMappers.enabled.description": "Enable external content mappers that transform otherwise unsupported file types for TypeScript language features. Content mappers can be configured in tsconfig.json/jsconfig.json files or provided by VS Code extensions.",
     "native-preview.goMemLimit.description": "Set GOMEMLIMIT for the language server (e.g., '2048MiB', '4GiB'). See https://pkg.go.dev/runtime#hdr-Environment_Variables for more information.",
     "native-preview.goMemLimit.error": "Must be a valid memory limit (e.g., '2048MiB', '4GiB').",
     "native-preview.customConfigFileName.deprecation": "This setting has moved to js/ts.customConfigFileName.",

_extension/src/client.ts

@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 
+import { CancellationToken } from "vscode-languageclient";
 import {
     ClientCapabilities,
     CloseAction,
@@ -23,12 +24,14 @@ import {
     configurationMiddleware,
     sendNotificationMiddleware,
 } from "./configurationMiddleware";
+import type { SerializedContentMapperContribution } from "./contentMapperContributions";
 import { registerMultiDocumentHighlightFeature } from "./languageFeatures/documentHighlight";
 import { registerHoverFeature } from "./languageFeatures/hover";
 import { registerOnAutoInsertFeature } from "./languageFeatures/onAutoInsert";
 import { registerSourceDefinitionFeature } from "./languageFeatures/sourceDefinition";
 import * as tr from "./telemetryReporting";
 import {
+    contentMappersEnabled,
     ExeInfo,
     getExe,
     jsTsLanguageModes,
@@ -38,6 +41,24 @@ import {
 import { getLanguageForUri } from "./util";
 import { workspaceSymbolSendRequestMiddleware } from "./workspaceSymbolMiddleware";
 
+// 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 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>;
@@ -52,6 +73,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;
 
@@ -85,6 +114,7 @@ export class Client implements vscode.Disposable {
                 codeLensShowLocationsCommandName,
                 enableTelemetry: true,
                 logVerbosity: this.outputChannel.logLevel,
+                runExternalCode: contentMappersEnabled(),
             },
             errorHandler: this.errorHandler,
             middleware: {
@@ -100,6 +130,18 @@ export class Client implements vscode.Disposable {
                 sendNotification: sendNotificationMiddleware,
                 sendRequest: workspaceSymbolSendRequestMiddleware,
                 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: {
@@ -135,10 +177,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;
@@ -197,9 +245,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.runExternalCode = contentMappersEnabled();
         this.clientOptions.initializationOptions.trackFlakyDiagnostics = effectiveflakesFlag !== "never" ? (effectiveflakesFlag === "panic" ? 2 : 1) : 0;
 
         this.client = new NativePreviewLanguageClient(
@@ -265,11 +313,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> {
@@ -278,6 +392,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();
@@ -290,6 +408,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();
@@ -399,6 +521,16 @@ export class Client implements vscode.Disposable {
             textDocument: { uri },
         }, token);
     }
+
+    async setContentMapperContributions(contributions: readonly SerializedContentMapperContribution[], openDocuments: readonly vscode.Uri[]): Promise<void> {
+        if (!this.client || !this.isInitialized) {
+            return;
+        }
+        await this.client.sendRequest("custom/setContentMapperContributions", {
+            contributions: contentMappersEnabled() ? contributions : [],
+            openDocuments: openDocuments.map(uri => ({ uri: uri.toString() })),
+        });
+    }
 }
 
 // Returns true when running on a VS Code Insiders build.