[mlir-vscode] Add better resolution for server file paths

[rriddle]

Summary

We currently require that server paths are full paths, which is
fairly inconvenient for a myriad of reasons. This commit
attempts to resolve a given server path with the current workspace.

This has a nice additional affect that we can now actually have
default server paths. This means that mlir-lsp-server and
mlir-pdll-lsp-server can be transparently picked up from
build directories (i.e. generally no need for upstream users to
configure the extension).

Fixes #54627

[jpienaar]

mlir/utils/vscode/src/mlirContext.ts

157

Path feels weird here as these seem like tool names instead while the actual path is computed in caller.

188

And this is sufficient to find it in build dir? Any assumptions needed to make that true? (E.g., how it's been configured). Is this globbing expensive? It would seem like a search across all subdirs.

[rriddle]

mlir/utils/vscode/src/mlirContext.ts

188

Yes. This doesn't require any assumptions generally, it just globs for a file with that name in the workspace directory and returns the first one). The glob has never been perceptible to me, and the more refined the path is, the less time conceptually it should take (i.e. providing the full workspace relative path vs just the filename). It's up to the user how refined they want to make the path, e.g. in the case of multiple build directories and such. We could do something more intelligent to pick the most recently built variant or something(if you have multiple build directories and you are currently iterating in one), but this should be fine for now. I also made this a bit better by not recomputing this again in the config watcher.

[jpienaar]

Nice, thanks that SGTM

mlir/utils/vscode/src/configWatcher.ts

 import * as chokidar from 'chokidar';
-import * as path from 'path';
 import * as vscode from 'vscode';
 
 import * as config from './config';
 import {MLIRContext} from './mlirContext';
 
 /**
  *  Prompt the user to see if we should restart the server.
  */
default:
     break;
   }
 }
 
 /**
  *  Activate the watchers that track configuration changes which decide when to
  *  restart the server.
  */
-export function activate(mlirContext: MLIRContext) {
+export async function activate(mlirContext: MLIRContext,
+                               serverPathsToWatch: string[]) {
   // When a configuration change happens, check to see if we should restart the
   // server.
   mlirContext.subscriptions.push(vscode.workspace.onDidChangeConfiguration(event => {
     const settings: string[] = [ 'server_path', 'pdll_server_path' ];
     for (const setting of settings) {
       const expandedSetting = `mlir.${setting}`;
       if (event.affectsConfiguration(expandedSetting)) {
         promptRestart(
             'onSettingsChanged',
             `setting '${
                 expandedSetting}' has changed. Do you want to reload the server?`);
         break;
       }
     }
   }));
 
   // Track the server file in case it changes. We use `fs` here because the
   // server may not be in a workspace directory.
-  const settings: string[] = [ 'server_path', 'pdll_server_path' ];
-  for (const setting of settings) {
-    const serverPath = config.get<string>(setting);
-
+  for (const serverPath of serverPathsToWatch) {
     // Check that the path actually exists.
     if (serverPath === '') {
       continue;
     }
 
     const fileWatcherConfig = {
       disableGlobbing : true,
       followSymlinks : true,

mlir/utils/vscode/src/mlirContext.ts

 import * as fs from 'fs';
+import * as path from 'path';
 import * as vscode from 'vscode';
 import * as vscodelc from 'vscode-languageclient';
 
 import * as config from './config';
 import * as configWatcher from './configWatcher';
 
 /**
  *  This class manages all of the MLIR extension state,
  *  including the language client.
  */
 export class MLIRContext implements vscode.Disposable {
   subscriptions: vscode.Disposable[] = [];
   client!: vscodelc.LanguageClient;
   pdllClient!: vscodelc.LanguageClient;
 
   /**
    *  Activate the MLIR context, and start the language clients.
    */
   async activate(outputChannel: vscode.OutputChannel,
                  warnOnEmptyServerPath: boolean) {
     // Create the language clients for mlir and pdll.
-    this.pdllClient = this.startLanguageClient(
+    let mlirServerPath: string, pdllServerPath: string;
+    [this.client, mlirServerPath] = await this.startLanguageClient(
+        outputChannel, warnOnEmptyServerPath, 'server_path', 'mlir');
+    [this.pdllClient, pdllServerPath] = await this.startLanguageClient(
         outputChannel, warnOnEmptyServerPath, 'pdll_server_path', 'pdll');
-    this.client = this.startLanguageClient(outputChannel, warnOnEmptyServerPath,
-                                           'server_path', 'mlir');
 
     // Watch for configuration changes.
-    configWatcher.activate(this);
+    const serverPathsToWatch = [ mlirServerPath, pdllServerPath ];
+    await configWatcher.activate(this, serverPathsToWatch);
   }
 
   /**
-   *  Start a new language client for the given language.
+   *  Start a new language client for the given language. Returns an array
+   *  containing the opened server, or null if the server could not be started,
+   *  and the resolved server path.
    */
-  startLanguageClient(outputChannel: vscode.OutputChannel,
-                      warnOnEmptyServerPath: boolean, serverSettingName: string,
-                      languageName: string): vscodelc.LanguageClient {
+  async startLanguageClient(outputChannel: vscode.OutputChannel,
+                            warnOnEmptyServerPath: boolean,
+                            serverSettingName: string, languageName: string):
+      Promise<[ vscodelc.LanguageClient, string ]> {
     const clientTitle = languageName.toUpperCase() + ' Language Client';
 
     // Get the path of the lsp-server that is used to provide language
     // functionality.
-    const serverPath = config.get<string>(serverSettingName);
+    var serverPath = await this.resolveServerPath(serverSettingName);
 
     // If we aren't emitting warnings on an empty server path, and the server
     // path is empty, bail.
     if (!warnOnEmptyServerPath && serverPath === '') {
-      return null;
+      return [ null, serverPath ];
     }
 
     // Check that the file actually exists.
     if (serverPath === '' || !fs.existsSync(serverPath)) {
       vscode.window
           .showErrorMessage(
               `${clientTitle}: Unable to resolve path for '${
                   serverSettingName}', please ensure the path is correct`,
               "Open Setting")
           .then((value) => {
             if (value === "Open Setting") {
               vscode.commands.executeCommand(
                   'workbench.action.openWorkspaceSettings',
                   {openToSide : false, query : `mlir.${serverSettingName}`});
             }
           });
-      return null;
+      return [ null, serverPath ];
     }
 
     // Configure the server options.
     const serverOptions: vscodelc.ServerOptions = {
       run : {
         command : serverPath,
         transport : vscodelc.TransportKind.stdio,
         args : []
const clientOptions: vscodelc.LanguageClientOptions = {
       },
       outputChannel : outputChannel,
     };
 
     // Create the language client and start the client.
     let languageClient = new vscodelc.LanguageClient(
         languageName + '-lsp', clientTitle, serverOptions, clientOptions);
     this.subscriptions.push(languageClient.start());
-    return languageClient;
+    return [ languageClient, serverPath ];
+  }
+
+  /**
+   * Given a server setting, return the default server path.
+   */
+  static getDefaultServerFilename(serverSettingName: string): string {
+    if (serverSettingName === 'pdll_server_path') {
+      return 'mlir-pdll-lsp-server';
+    }
+    if (serverSettingName === 'server_path') {
+      return 'mlir-lsp-server';
+    }
+    return '';
+  }
+
+  /**
+   * Try to resolve the path for the given server setting.
+   */
+  async resolveServerPath(serverSettingName: string): Promise<string> {
+    let configServerPath = config.get<string>(serverSettingName);
+    let serverPath = configServerPath;
+
+    // If the path is already fully resolved, there is nothing to do.
+    if (path.isAbsolute(serverPath)) {
+      return serverPath;
+    }
+
+    // If a path hasn't been set, try to use the default path.
+    if (serverPath === '') {
+      serverPath = MLIRContext.getDefaultServerFilename(serverSettingName);
+      if (serverPath === '') {
+        return serverPath;
+      }
+      // Fallthrough to try resolving the default path.
+    }
+
+    // Try to resolve the path relative to the workspace.
+    const foundUris: vscode.Uri[] =
+        await vscode.workspace.findFiles('**/' + serverPath, null, 1);
+    if (foundUris.length === 0) {
+      // If we couldn't resolve it, just return the current configuration path
+      // anyways. The file might not exist yet.
+      return configServerPath;
+    }
+    // Otherwise, return the resolved path.
+    return foundUris[0].fsPath;
   }
 
   dispose() {
     this.subscriptions.forEach((d) => { d.dispose(); });
     this.subscriptions = [];
   }
 }