[typespec-vscode] Allow lsp disable running emitters

.chronus/changes/allow-lsp-disable-running-emitters-2025-5-11-2-18-42.md

@@ -0,0 +1,9 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+  - typespec-vscode
+---
+
+Allow LSP to configure which emitters to include for live checks

packages/compiler/src/server/client-config-provider.ts

@@ -0,0 +1,69 @@
+import { Connection } from "vscode-languageserver/node.js";
+import { ServerHost } from "./types.js";
+
+interface LSPConfig {
+  emit?: string[];
+}
+
+interface Config {
+  lsp?: LSPConfig;
+}
+
+/**
+ * TypeSpec client-side configuration provider
+ * Inspired by VS Code's WorkspaceConfiguration API for extensibility
+ */
+export interface ClientConfigProvider {
+  /**
+   * Initialize client configuration with connection and host
+   * @param connection Language server connection
+   * @param host Server host instance
+   */
+  initialize(connection: Connection, host: ServerHost): Promise<void>;
+
+  config?: Config;
+}
+
+export function createClientConfigProvider(): ClientConfigProvider {
+  let config: Config | undefined;
+
+  async function initialize(connection: Connection, host: ServerHost): Promise<void> {
+    try {
+      const configs = await connection.workspace.getConfiguration("typespec");
+      host.log({ level: "debug", message: "VSCode settings loaded", detail: configs });
+
+      // Transform the raw configuration to match our Config interface
+      config = {
+        lsp: {
+          emit: configs?.lsp?.emit,
+        },
+      };
+
+      connection.onDidChangeConfiguration(async (params) => {
+        if (params.settings) {
+          const newConfigs = params.settings?.typespec;
+          config = {
+            lsp: {
+              emit: newConfigs?.lsp?.emit,
+            },
+          };
+        }
+
+        host.log({ level: "debug", message: "Configuration changed", detail: params.settings });
+      });
+    } catch (error) {
+      host.log({
+        level: "error",
+        message: "An error occurred while loading the VSCode settings",
+        detail: error,
+      });
+    }
+  }
+
+  return {
+    initialize,
+    get config() {
+      return config;
+    },
+  };
+}

packages/compiler/src/server/compile-service.ts

@@ -25,6 +25,7 @@ import { doIO, loadFile } from "../utils/io.js";
 import { resolveTspMain } from "../utils/misc.js";
 import { getLocationInYamlScript } from "../yaml/diagnostics.js";
 import { parseYaml } from "../yaml/parser.js";
+import { ClientConfigProvider } from "./client-config-provider.js";
 import { serverOptions } from "./constants.js";
 import { FileService } from "./file-service.js";
 import { FileSystemCache } from "./file-system-cache.js";
@@ -78,6 +79,7 @@ export interface CompileServiceOptions {
   readonly serverHost: ServerHost;
   readonly compilerHost: CompilerHost;
   readonly log: (log: ServerLog) => void;
+  readonly clientConfigsProvider?: ClientConfigProvider;
 }
 
 export function createCompileService({
@@ -86,6 +88,7 @@ export function createCompileService({
   fileService,
   fileSystemCache,
   log,
+  clientConfigsProvider,
 }: CompileServiceOptions): CompileService {
   const oldPrograms = new Map<string, Program>();
   const eventListeners = new Map<string, (...args: unknown[]) => void>();
@@ -140,6 +143,15 @@ export function createCompileService({
       ...(additionalOptions ?? {}),
     };
 
+    // If emit is set in additionalOptions, use this setting first
+    // otherwise, obtain the `typespec.lsp.emit` configuration from clientConfigsProvider
+    if (additionalOptions?.emit === undefined) {
+      const configEmits = clientConfigsProvider?.config?.lsp?.emit;
+      if (configEmits) {
+        options.emit = configEmits;
+      }
+    }
+
     // add linter rule for unused using if user didn't configure it explicitly
     const unusedUsingRule = `${builtInLinterLibraryName}/${builtInLinterRule_UnusedUsing}`;
     if (

packages/compiler/src/server/server.ts

@@ -15,6 +15,7 @@ import {
 } from "vscode-languageserver/node.js";
 import { NodeHost } from "../core/node-host.js";
 import { typespecVersion } from "../manifest.js";
+import { createClientConfigProvider } from "./client-config-provider.js";
 import { createServer } from "./serverlib.js";
 import { CustomRequestName, Server, ServerHost, ServerLog } from "./types.js";
 
@@ -86,7 +87,8 @@ function main() {
     },
   };
 
-  const s = createServer(host);
+  const clientConfigProvider = createClientConfigProvider();
+  const s = createServer(host, clientConfigProvider);
   server = s;
   s.log({ level: `info`, message: `TypeSpec language server v${typespecVersion}` });
   s.log({ level: `info`, message: `Module: ${fileURLToPath(import.meta.url)}` });
@@ -106,10 +108,13 @@ function main() {
     return await s.initialize(params);
   });
 
-  connection.onInitialized((params) => {
+  connection.onInitialized(async (params) => {
     if (clientHasWorkspaceFolderCapability) {
       connection.workspace.onDidChangeWorkspaceFolders(s.workspaceFoldersChanged);
     }
+
+    // Initialize client configurations
+    await clientConfigProvider.initialize(connection, host);
     s.initialized(params);
   });
 

packages/compiler/src/server/serverlib.ts

@@ -98,6 +98,7 @@ import { resolveModule, ResolveModuleHost } from "../module-resolver/module-reso
 import { listAllFilesInDir } from "../utils/fs-utils.js";
 import { getNormalizedRealPath, resolveTspMain } from "../utils/misc.js";
 import { getSemanticTokens } from "./classify.js";
+import { ClientConfigProvider } from "./client-config-provider.js";
 import { createCompileService } from "./compile-service.js";
 import { resolveCompletion } from "./completion.js";
 import { Commands } from "./constants.js";
@@ -130,7 +131,10 @@ import {
   ServerWorkspaceFolder,
 } from "./types.js";
 
-export function createServer(host: ServerHost): Server {
+export function createServer(
+  host: ServerHost,
+  clientConfigsProvider?: ClientConfigProvider,
+): Server {
   const fileService = createFileService({ serverHost: host });
 
   // Cache all file I/O. Only open documents are sent over the LSP pipe. When
@@ -158,6 +162,7 @@ export function createServer(host: ServerHost): Server {
     compilerHost,
     serverHost: host,
     log,
+    clientConfigsProvider,
   });
   const currentDiagnosticIndex = new Map<number, Diagnostic>();
   let diagnosticIdCounter = 0;

packages/compiler/src/testing/test-server-host.ts

@@ -4,6 +4,7 @@ import { Diagnostic, FileChangeType } from "vscode-languageserver/node.js";
 import { parse, visitChildren } from "../core/parser.js";
 import { resolvePath } from "../core/path-utils.js";
 import { IdentifierNode, SyntaxKind } from "../core/types.js";
+import { createClientConfigProvider } from "../server/client-config-provider.js";
 import { Server, ServerHost, createServer } from "../server/index.js";
 import { createStringMap } from "../utils/misc.js";
 import { StandardTestLibrary, TestHostOptions, createTestFileSystem } from "./test-host.js";
@@ -108,7 +109,8 @@ export async function createTestServerHost(options?: TestHostOptions & { workspa
 
   const workspaceDir = options?.workspaceDir ?? "./";
   const rootUri = serverHost.getURL(workspaceDir);
-  const server = createServer(serverHost);
+  const clientConfigProvider = createClientConfigProvider();
+  const server = createServer(serverHost, clientConfigProvider);
   await server.initialize({
     rootUri: options?.caseInsensitiveFileSystem ? rootUri.toUpperCase() : rootUri,
     capabilities: {},

packages/compiler/test/server/vscode-settings.test.ts

@@ -0,0 +1,89 @@
+import { strictEqual } from "assert";
+import { beforeEach, describe, it, vi } from "vitest";
+import {
+  ClientConfigProvider,
+  createClientConfigProvider,
+} from "../../src/server/client-config-provider.js";
+
+let configProvider: ClientConfigProvider;
+
+beforeEach(() => {
+  // Create a new client config provider before each test
+  configProvider = createClientConfigProvider();
+});
+
+describe("configuration API", () => {
+  it("should return undefined when configuration is not initialized", () => {
+    const config = configProvider.config;
+    strictEqual(config, undefined);
+  });
+  it("should handle accessing config properties safely", () => {
+    const config = configProvider.config;
+    strictEqual(config?.lsp?.emit, undefined);
+  });
+});
+
+describe("initialization and VS Code integration", () => {
+  let mockHost: any;
+
+  beforeEach(() => {
+    mockHost = {
+      log: vi.fn(),
+    } as any;
+  });
+
+  it("should handle initialization with mock connection and host", async () => {
+    // Create mock connection and host
+    const mockConnection = {
+      workspace: {
+        getConfiguration: vi.fn().mockResolvedValue({
+          lsp: { emit: ["openapi3"] },
+          formatting: { enabled: true },
+        }),
+      },
+      onDidChangeConfiguration: vi.fn(),
+    } as any;
+
+    await configProvider.initialize(mockConnection, mockHost);
+
+    const config = configProvider.config;
+    strictEqual(config?.lsp?.emit?.[0], "openapi3");
+  });
+
+  it("should completely replace configuration on change notifications", async () => {
+    let onDidChangeHandler: any;
+
+    const mockConnection = {
+      workspace: {
+        getConfiguration: vi.fn().mockResolvedValue({
+          lsp: { emit: ["openapi3"] },
+          formatting: { enabled: true },
+        }),
+      },
+      onDidChangeConfiguration: vi.fn().mockImplementation((handler) => {
+        onDidChangeHandler = handler;
+      }),
+    } as any;
+
+    await configProvider.initialize(mockConnection, mockHost);
+
+    // Verify initial configuration
+    const initialConfig = configProvider.config;
+    strictEqual(initialConfig?.lsp?.emit?.[0], "openapi3");
+
+    // Simulate a configuration change that only includes some settings
+    const changeParams = {
+      settings: {
+        typespec: {
+          lsp: { emit: ["swagger"] },
+        },
+      },
+    };
+
+    await onDidChangeHandler(changeParams);
+
+    // Verify configuration was updated
+    const updatedConfig = configProvider.config;
+    strictEqual(updatedConfig?.lsp?.emit?.[0], "swagger");
+  });
+});

packages/typespec-vscode/package.json

@@ -98,6 +98,15 @@
               "additionalProperties": false
             }
           },
+          "typespec.lsp.emit": {
+            "type": "array",
+            "default": null,
+            "description": "List of emitters that should be included in compilation in typespec LSP server when supporting LSP related functionalities. And only supports emitter running in dry mode.\n\nExample:\n\"typespec.lsp.emit\": [\n  \"@typespec/openapi3\"\n]",
+            "scope": "machine-overridable",
+            "items": {
+              "type": "string"
+            }
+          },
           "typespec.trace.server": {
             "scope": "window",
             "type": "string",