[typespec-vscode] Allow lsp disable running emitters

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

@@ -0,0 +1,140 @@
+import { Connection, DidChangeConfigurationNotification } from "vscode-languageserver/node.js";
+import { ServerHost } from "./types.js";
+
+/**
+ * Represents configuration value with additional metadata
+ */
+export interface ConfigurationValue<T = any> {
+  /** The configuration value */
+  value: T;
+  /** The scope where this value was defined (global, workspace, etc.) */
+  scope?: "default" | "global" | "workspace" | "workspaceFolder";
+  /** Language specific configuration if applicable */
+  languageId?: string;
+}
+
+/**
+ * TypeSpec client-side configuration provider
+ * Inspired by VS Code's WorkspaceConfiguration API for extensibility
+ */
+export interface ClientConfigProvider {
+  /**
+   * Get a configuration value by section key
+   * @param section The configuration section (e.g., "lsp.emit", "formatting.enabled")
+   * @param defaultValue Default value if not found
+   * @returns The configuration value or default
+   */
+  get<T>(section: string): T | undefined;
+  get<T>(section: string, defaultValue: T): T;
+
+  /**
+   * Check if a configuration section exists
+   * @param section The configuration section
+   * @returns True if the section exists
+   */
+  has(section: string): boolean;
+
+  /**
+   * Get detailed information about a configuration value
+   * @param section The configuration section
+   * @returns Detailed configuration information
+   */
+  inspect<T>(section: string): ConfigurationValue<T> | undefined;
+
+  /**
+   * Update the entire configuration
+   * @param configs The new configuration object
+   */
+  update(configs: Record<string, any>): void;
+
+  /**
+   * Initialize client configuration with connection and host
+   * @param connection Language server connection
+   * @param host Server host instance
+   */
+  initialize(connection: Connection, host: ServerHost): Promise<void>;
+}
+
+export function createClientConfigProvider(): ClientConfigProvider {
+  let configuration: Record<string, any> = {};
+
+  function get<T>(section: string): T | undefined;
+  function get<T>(section: string, defaultValue: T): T;
+  function get<T>(section: string, defaultValue?: T): T | undefined {
+    const keys = section.split(".");
+    let current: any = configuration;
+
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return defaultValue;
+      }
+    }
+
+    return current !== undefined ? current : defaultValue;
+  }
+
+  function has(section: string): boolean {
+    const keys = section.split(".");
+    let current: any = configuration;
+
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return false;
+      }
+    }
+
+    return current !== undefined;
+  }
+
+  function inspect<T>(section: string): ConfigurationValue<T> | undefined {
+    if (!has(section)) {
+      return undefined;
+    }
+
+    const value = get<T>(section);
+    return {
+      value: value as T, // Safe cast since we know it exists from has() check
+      scope: "workspace", // Default scope, could be enhanced to track actual scope
+    };
+  }
+
+  function update(configs: Record<string, any>): void {
+    configuration = { ...configs };
+  }
+
+  async function initialize(connection: Connection, host: ServerHost): Promise<void> {
+    try {
+      await connection.client.register(DidChangeConfigurationNotification.type, undefined);
+      const configs = await connection.workspace.getConfiguration("typespec");
+      host.log({ level: "debug", message: "VSCode settings loaded", detail: configs });
+
+      update(configs);
+
+      connection.onDidChangeConfiguration(async (params) => {
+        if (params.settings && params.settings.typespec) {
+          update(params.settings.typespec);
+        }
+
+        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 {
+    get,
+    has,
+    inspect,
+    update,
+    initialize,
+  };
+}

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,13 @@ export function createCompileService({
       ...(additionalOptions ?? {}),
     };
 
+    if (additionalOptions?.emit === undefined || additionalOptions?.emit.length === 0) {
+      const configEmits = clientConfigsProvider?.get<string[]>("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";
 
@@ -26,12 +27,12 @@ let profileSession: inspector.Session | undefined;
 
 process.on("unhandledRejection", fatalError);
 try {
-  main();
+  await main();
 } catch (e) {
   fatalError(e);
 }
 
-function main() {
+async function main() {
   // Redirect all console stdout output to stderr since LSP pipe uses stdout
   // and writing to stdout for anything other than LSP protocol will break
   // things badly.
@@ -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: {},