Fix restart for server.

antaalt · antaalt · commit 0e50297cebaf · 2025-08-29T19:48:27.000+02:00
diff --git a/README.md b/README.md
@@ -136,6 +136,14 @@ This extension contributes the following settings:
 *   `shader-validator.glsl.targetClient`: Specify the OpenGL or Vulkan version for GLSL
 *   `shader-validator.glsl.spirvVersion`: Specify the SPIRV version to target for GLSL
 
+
+## Commands
+
+*   `shader-validator.restartServer`: Restart the server if you have any issue
+*   `shader-validator.addCurrentFileVariant`: Add a variant to the current file.
+*   `shader-validator.dumpDependency`: Print dependency tree in logs. mostly for debug.
+*   `shader-validator.dumpAst`: Print internal ast in logs. mostly for debug.
+
 ## Platform support
 
 This extension is supported on every platform, but some limitations are to be expected on some:
diff --git a/package.json b/package.json
@@ -120,6 +120,11 @@
             "type": "boolean",
             "default": false
           },
+          "shader-validator.updateSymbolsOnVariantUpdate": {
+            "description": "Automatically update the symbols on variant update. Will trigger a save on the file.",
+            "type": "boolean",
+            "default": false
+          },
           "shader-validator.severity": {
             "type": "string",
             "description": "Minimum linting severity. Set it lower to display some hints aswell. Might not be supported by all languages.",
@@ -290,6 +295,12 @@
       }
     ],
     "commands": [
+      {
+        "command": "shader-validator.restartServer",
+        "title": "Restart server",
+        "category": "Shader validator",
+        "icon": "$(check)"
+      },
       {
         "command": "shader-validator.validateFile",
         "title": "Validate file",
diff --git a/src/extension.ts b/src/extension.ts
@@ -2,7 +2,7 @@
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
 
-import { createLanguageClient, getServerPlatform, ServerPlatform } from './validator';
+import { createLanguageClient, getServerPlatform, ServerPlatform, ShaderLanguageClient } from './validator';
 import { dumpAstRequest, dumpDependencyRequest } from './request';
 import { ShaderVariantTreeDataProvider } from './shaderVariant';
 import { DidChangeConfigurationNotification, LanguageClient } from 'vscode-languageclient';
@@ -35,73 +35,70 @@ export async function activate(context: vscode.ExtensionContext)
                 },
             );
         } else {
-            vscode.window.showErrorMessage("Extension shader-validator failed to install dependencies. It will not launch the validation server.");
+            vscode.window.showErrorMessage("Extension shader-validator failed to install dependencies. It will not launch the shader language server.");
             return; // Extension failed to launch.
         }
     }
 
     // Create language client
-    const possiblyNullClient = await createLanguageClient(context);
-    if (possiblyNullClient === null) {
+    const server = new ShaderLanguageClient;
+    context.subscriptions.push(server);
+    const isInitialized = await server.start(context);
+    if (!isInitialized) {
         console.error("Failed to launch shader-validator language server.");
         return;
     }
-    let client = possiblyNullClient;
     let supportedLangId = ["hlsl", "glsl", "wgsl"];
 
     // Create sidebar
-    sidebar = new ShaderVariantTreeDataProvider(context, client);
-
-    // Subscribe for dispose
-    context.subscriptions.push(vscode.Disposable.from(client));
+    sidebar = new ShaderVariantTreeDataProvider(context, server);
 
     // Subscribe commands
     context.subscriptions.push(vscode.commands.registerCommand("shader-validator.validateFile", (uri: vscode.Uri) => {
         //client.sendRequest()
         vscode.window.showInformationMessage("Cannot validate file manually for now");
     }));
+    context.subscriptions.push(vscode.commands.registerCommand("shader-validator.restartServer", (uri: vscode.Uri) => {
+        server.restart(context);
+    }));
     context.subscriptions.push(vscode.commands.registerCommand("shader-validator.dumpAst", () => {
         let activeTextEditor = vscode.window.activeTextEditor;
         if (activeTextEditor && activeTextEditor.document.uri.scheme === 'file' && supportedLangId.includes(activeTextEditor.document.languageId)) {            
-            client.sendRequest(dumpAstRequest, {
-                uri: client.code2ProtocolConverter.asUri(activeTextEditor.document.uri)
+            server.sendRequest(dumpAstRequest, {
+                uri: server.uriAsString(activeTextEditor.document.uri)
             }).then((value: string | null) => {
                 console.info(value);
-                client.outputChannel.appendLine(value || "No AST to dump");
+                server.log(value || "No AST to dump");
             }, (reason: any) => {
-                client.outputChannel.appendLine("Failed to get ast: " + reason);
+                server.log("Failed to get ast: " + reason);
             });
         } else {
-            client.outputChannel.appendLine("No active file for dumping ast");
+            server.log("No active file for dumping ast");
         }
     }));
     context.subscriptions.push(vscode.commands.registerCommand("shader-validator.dumpDependency", () => {
         let activeTextEditor = vscode.window.activeTextEditor;
         if (activeTextEditor && activeTextEditor.document.uri.scheme === 'file' && supportedLangId.includes(activeTextEditor.document.languageId)) {            
-            client.sendRequest(dumpDependencyRequest, {
-                uri: client.code2ProtocolConverter.asUri(activeTextEditor.document.uri)
+            server.sendRequest(dumpDependencyRequest, {
+                uri: server.uriAsString(activeTextEditor.document.uri)
             }).then((value: string | null) => {
                 console.info(value);
-                client.outputChannel.appendLine(value || "No deps tree to dump");
+                server.log(value || "No deps tree to dump");
             }, (reason: any) => {
-                client.outputChannel.appendLine("Failed to get deps tree: " + reason);
+                server.log("Failed to get deps tree: " + reason);
             });
         } else {
-            client.outputChannel.appendLine("No active file for dumping deps tree");
+            server.log("No active file for dumping deps tree");
         }
     }));
     context.subscriptions.push(
         vscode.workspace.onDidChangeConfiguration(async (event : vscode.ConfigurationChangeEvent) => {
             if (event.affectsConfiguration("shader-validator")) {
                 if (event.affectsConfiguration("shader-validator.trace.server") || 
                     event.affectsConfiguration("shader-validator.serverPath")) {
-                    let newClient = await createLanguageClient(context);
-                    if (newClient !== null) {
-                        client.dispose();
-                        client = newClient;
-                    }
+                    server.restart(context);
                 } else {
-                    await client.sendNotification(DidChangeConfigurationNotification.type, {
+                    await server.sendNotification(DidChangeConfigurationNotification.type, {
                         settings: "",
                     });
                 }
diff --git a/src/shaderVariant.ts b/src/shaderVariant.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { CancellationToken, DocumentSymbol, DocumentSymbolRequest, DocumentUri, LanguageClient, ProtocolNotificationType, ProtocolRequestType, Range, SymbolInformation, SymbolKind, TextDocumentIdentifier, TextDocumentItem, TextDocumentRegistrationOptions } from 'vscode-languageclient/node';
-import { resolveVSCodeVariables } from './validator';
+import { resolveVSCodeVariables, ShaderLanguageClient } from './validator';
 
 interface ShaderVariantSerialized {
     url: DocumentUri,
@@ -121,7 +121,7 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
     // using vscode.Uri as key does not match well with Memento state storage...
     private files: Map<string, ShaderVariantFile>;
     private tree: vscode.TreeView<ShaderVariantNode>;
-    private client: LanguageClient;
+    private server: ShaderLanguageClient;
     private decorator: vscode.TextEditorDecorationType;
     private workspaceState: vscode.Memento;
     private shaderEntryPointList: Map<string, ShaderEntryPoint[]>;
@@ -143,12 +143,12 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
         this.workspaceState.update(shaderVariantTreeKey, array);
     }
 
-    constructor(context: vscode.ExtensionContext, client: LanguageClient) {
+    constructor(context: vscode.ExtensionContext, server: ShaderLanguageClient) {
         this.workspaceState = context.workspaceState;
         this.files = new Map;
         this.load();
         this.shaderEntryPointList = new Map;
-        this.client = client;
+        this.server = server;
         this.tree = vscode.window.createTreeView<ShaderVariantNode>("shader-validator-variants", {
             treeDataProvider: this
             // TODO: drag and drop for better ux.
@@ -252,6 +252,10 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
             this.save();
         }));
         context.subscriptions.push(vscode.commands.registerCommand("shader-validator.gotoShaderEntryPoint", (uri: vscode.Uri, entryPointName: string) => {
+            // sometimes, its goes in random place in file... 
+            // TODO: Should use regex & read diag region instead.
+            let diagnostic = vscode.languages.getDiagnostics().find(([diagUri, diags]) => diagUri === uri);
+            
             this.goToShaderEntryPoint(uri, entryPointName, true);
         }));
         // Prepare entry point symbol cache
@@ -268,6 +272,35 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
         context.subscriptions.push(vscode.workspace.onDidCloseTextDocument(document => {
             this.shaderEntryPointList.delete(document.uri.path);
         }));
+        context.subscriptions.push(vscode.workspace.onDidRenameFiles(document => {
+            for (const fileObj of document.files) {
+                const { oldUri, newUri } = fileObj;
+                // To update the key in a Map, you need to remove the old key and add the new one.
+                const oldPath = oldUri.path;
+                const newPath = newUri.path;
+                const file = this.files.get(oldPath);
+                if (file) {
+                    // Update the uri inside the file object
+                    file.uri = newUri;
+                    // Remove the old key and set the new key
+                    this.files.delete(oldPath);
+                    this.files.set(newPath, file);
+                }
+                // Also update entry point and async maps
+                const entryPoints = this.shaderEntryPointList.get(oldPath);
+                if (entryPoints) {
+                    this.shaderEntryPointList.delete(oldPath);
+                    this.shaderEntryPointList.set(newPath, entryPoints);
+                }
+                const asyncEntryPoint = this.asyncGoToShaderEntryPoint.get(oldUri);
+                if (asyncEntryPoint) {
+                    this.asyncGoToShaderEntryPoint.delete(oldUri);
+                    this.asyncGoToShaderEntryPoint.set(newUri, asyncEntryPoint);
+                }
+                this.shaderEntryPointList;
+                this.asyncGoToShaderEntryPoint;
+            }
+        }));
         this.updateDependencies();
     }
     private getActiveVariant() : ShaderVariant | null {
@@ -390,17 +423,17 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
             // Open document to get language ID.
             // This does not open the document in the editor, only internally.
             vscode.workspace.openTextDocument(fileActiveVariant.uri).then(doc => {
-                this.client.sendNotification(didChangeShaderVariantNotification, {
+                this.server.sendNotification(didChangeShaderVariantNotification, {
                     // Need this check again here because its async
                     shaderVariant: fileActiveVariant ? shaderVariantToSerialized(
-                        this.client.code2ProtocolConverter.asUri(fileActiveVariant.uri), 
+                        this.server.uriAsString(fileActiveVariant.uri), 
                         capitalizeFirstLetter(doc.languageId), // Server expect it with capitalized first letter.
                         fileActiveVariant
                     ) : null,
                 });
             });
         } else {
-            this.client.sendNotification(didChangeShaderVariantNotification, {
+            this.server.sendNotification(didChangeShaderVariantNotification, {
                 shaderVariant: null,
             });
         }
@@ -421,24 +454,29 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
         // Dirty hack to trigger document symbol update
         // Ideally, it should retrigger dependencies aswell.
         // See https://github.com/microsoft/vscode/issues/108722 (Old one https://github.com/microsoft/vscode/issues/71454)
-        let visibleEditor = vscode.window.visibleTextEditors.find(e => e.document.uri.path === uri.path);
-        if (visibleEditor) {
-            let editor = visibleEditor;
-            editor.edit(editBuilder => {
-                for (let iLine = 0; iLine < editor.document.lineCount; iLine++) {
-                    // Find first non-empty line to avoid crashing on empty line with negative position.
-                    let line = editor.document.lineAt(iLine);
-                    if (line.text.length > 0) {
-                        const text = line.text;
-                        const c = line.range.end.character;
-                        // Remove last character of first line and add it back.
-                        editBuilder.delete(new vscode.Range(iLine, c-1, iLine, c));
-                        editBuilder.insert(new vscode.Position(iLine, c), text[c-1]);
-                        break;
+
+        // Only trigger it if requested by user as it may be a bit invasive.
+        let updateSymbolsOnVariantUpdate = vscode.workspace.getConfiguration("shader-validator").get<boolean>("updateSymbolsOnVariantUpdate");
+        if (updateSymbolsOnVariantUpdate) {
+            let visibleEditor = vscode.window.visibleTextEditors.find(e => e.document.uri.path === uri.path);
+            if (visibleEditor) {
+                let editor = visibleEditor;
+                editor.edit(editBuilder => {
+                    for (let iLine = 0; iLine < editor.document.lineCount; iLine++) {
+                        // Find first non-empty line to avoid crashing on empty line with negative position.
+                        let line = editor.document.lineAt(iLine);
+                        if (line.text.length > 0) {
+                            const text = line.text;
+                            const c = line.range.end.character;
+                            // Remove last character of first line and add it back.
+                            editBuilder.delete(new vscode.Range(iLine, c-1, iLine, c));
+                            editBuilder.insert(new vscode.Position(iLine, c), text[c-1]);
+                            break;
+                        }
                     }
-                }
-                // All empty lines means no symbols !
-            });
+                    // All empty lines means no symbols !
+                });
+            }
         }
     }
     private updateDependency(file: ShaderVariantFile) {
@@ -568,6 +606,24 @@ export class ShaderVariantTreeDataProvider implements vscode.TreeDataProvider<Sh
         if (uri.scheme !== 'file') {
             return;
         }
+        // If adding active variant, remove all currently active ones.
+        if (variant) {
+            if (variant.isActive) {
+                for (let [url, file] of this.files) {
+                    let needRefresh = false;
+                    for (let otherVariant of file.variants) {
+                        if (otherVariant.isActive) {
+                            needRefresh = true;
+                            otherVariant.isActive = false;
+                        }
+                    }
+                    if (needRefresh) {
+                        // Refresh file & all its childs
+                        this.refresh(file, file);
+                    }
+                }
+            }
+        }
         let file = this.files.get(uri.path);
         if (!file) {
             let newFile : ShaderVariantFile = {
diff --git a/src/validator.ts b/src/validator.ts
