reintroduce multi project setup

* enable multiple projects with multiple rls running
* change the URI key back to string for workspaces (as it's unreliable)
* add selectors such that only the correct rls is used for a given project
* take great care to ensure the old setup works normally
* add a configuration and turn it off by default.

Author: jannickj

package.json

@@ -219,6 +219,11 @@
                     "default": true,
                     "description": "If one root workspace folder is nested in another root folder, look for the Rust config in the outermost root."
                 },
+                "rust-client.enableMultiProjectSetup": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "Allow multiple projects in the same folder, along with remove the constraint that the cargo.toml must be located at the root. (Experimental: might not work for certain setups)"
+                },
                 "rust.sysroot": {
                     "type": [
                         "string",

src/configuration.ts

@@ -118,6 +118,10 @@ export class RLSConfiguration {
     return this.configuration.get<string>('rust-client.rlsPath');
   }
 
+  public get multiProjectEnabled(): boolean {
+    return this.configuration.get<boolean>('rust-client.enableMultiProjectSetup', false);
+  }
+
   // Added ignoreChannel for readChannel function. Otherwise we end in an infinite loop.
   public rustupConfig(ignoreChannel: boolean = false): RustupConfig {
     return {

src/extension.ts

@@ -69,23 +69,37 @@ function didOpenTextDocument(
   if (!folder) {
     return;
   }
+
   if (
+    workspace
+      .getConfiguration()
+      .get<boolean>('rust-client.enableMultiProjectSetup', false)
+  ) {
+    folder = nearestCargoTomlWorkspace(folder, document.uri.fsPath);
+  } else if (
     workspace
       .getConfiguration()
       .get<boolean>('rust-client.nestedMultiRootConfigInOutermost', true)
   ) {
     folder = getOuterMostWorkspaceFolder(folder);
   }
-  // folder = getCargoTomlWorkspace(folder, document.uri.fsPath);
+
   if (!folder) {
     stopSpinner(`RLS: Cargo.toml missing`);
     return;
   }
 
-  if (!workspaces.has(folder.uri)) {
+  const folderPath = folder.uri.toString();
+
+  if (!workspaces.has(folderPath)) {
+
     const workspace = new ClientWorkspace(folder);
-    workspaces.set(folder.uri, workspace);
+    activeWorkspace = workspace;
+    workspaces.set(folderPath, workspace);
     workspace.start(context);
+  } else {
+    const ws = workspaces.get(folderPath);
+    activeWorkspace = typeof ws === "undefined" ? null : ws;
   }
 }
 
@@ -110,37 +124,41 @@ function sortedWorkspaceFolders(): string[] {
   return _sortedWorkspaceFolders || [];
 }
 
-// function getCargoTomlWorkspace(cur_workspace: WorkspaceFolder, file_path: string): WorkspaceFolder {
-//     if (!cur_workspace) {
-//         return cur_workspace;
-//     }
-
-//     const workspace_root = path.parse(cur_workspace.uri.fsPath).dir;
-//     const root_manifest = path.join(workspace_root, 'Cargo.toml');
-//     if (fs.existsSync(root_manifest)) {
-//         return cur_workspace;
-//     }
-
-//     let current = file_path;
-
-//     while (true) {
-//         const old = current;
-//         current = path.dirname(current);
-//         if (old == current) {
-//             break;
-//         }
-//         if (workspace_root == path.parse(current).dir) {
-//             break;
-//         }
-
-//         const cargo_path = path.join(current, 'Cargo.toml');
-//         if (fs.existsSync(cargo_path)) {
-//             return { ...cur_workspace, uri: Uri.parse(current) };
-//         }
-//     }
-
-//     return cur_workspace;
-// }
+function nearestCargoTomlWorkspace(
+  curWorkspace: WorkspaceFolder,
+  filePath: string,
+): WorkspaceFolder {
+  if (!curWorkspace) {
+    return curWorkspace;
+  }
+
+  const workspaceRoot = path.parse(curWorkspace.uri.fsPath).dir;
+  const rootManifest = path.join(workspaceRoot, 'Cargo.toml');
+  if (fs.existsSync(rootManifest)) {
+    return curWorkspace;
+  }
+
+  let current = filePath;
+
+  while (true) {
+    const old = current;
+    current = path.dirname(current);
+    if (old === current) {
+      break;
+    }
+    if (workspaceRoot === path.parse(current).dir) {
+      break;
+    }
+
+    const cargoPath = path.join(current, 'Cargo.toml');
+    const uri = Uri.file(current);
+    if (fs.existsSync(cargoPath)) {
+      return { ...curWorkspace, uri };
+    }
+  }
+
+  return curWorkspace;
+}
 
 function getOuterMostWorkspaceFolder(folder: WorkspaceFolder): WorkspaceFolder {
   const sorted = sortedWorkspaceFolders();
@@ -166,13 +184,13 @@ function didChangeWorkspaceFolders(
   // if not, and it is a Rust project (i.e., has a Cargo.toml), then create a new client.
   for (let folder of e.added) {
     folder = getOuterMostWorkspaceFolder(folder);
-    if (workspaces.has(folder.uri)) {
+    if (workspaces.has(folder.uri.toString())) {
       continue;
     }
     for (const f of fs.readdirSync(folder.uri.fsPath)) {
       if (f === 'Cargo.toml') {
         const workspace = new ClientWorkspace(folder);
-        workspaces.set(folder.uri, workspace);
+        workspaces.set(folder.uri.toString(), workspace);
         workspace.start(context);
         break;
       }
@@ -181,15 +199,18 @@ function didChangeWorkspaceFolders(
 
   // If a workspace is removed which is a Rust workspace, kill the client.
   for (const folder of e.removed) {
-    const ws = workspaces.get(folder.uri);
+    const ws = workspaces.get(folder.uri.toString());
     if (ws) {
-      workspaces.delete(folder.uri);
+      workspaces.delete(folder.uri.toString());
       ws.stop();
     }
   }
 }
 
-const workspaces: Map<Uri, ClientWorkspace> = new Map();
+// Don't use URI as it's unreliable the same path might not become the same URI.
+const workspaces: Map<string, ClientWorkspace> = new Map();
+let activeWorkspace: ClientWorkspace | null;
+let commandsUnregistered: boolean = true;
 
 // We run one RLS and one corresponding language client per workspace folder
 // (VSCode workspace, not Cargo workspace). This class contains all the per-client
@@ -209,21 +230,28 @@ class ClientWorkspace {
   }
 
   public async start(context: ExtensionContext) {
-    warnOnMissingCargoToml();
+    if (!this.config.multiProjectEnabled) {
+      warnOnMissingCargoToml();
+    }
+
 
     startSpinner('RLS', 'Starting');
 
     const serverOptions: ServerOptions = async () => {
       await this.autoUpdate();
       return this.makeRlsProcess();
     };
+
+    const pattern = this.config.multiProjectEnabled ? `${this.folder.uri.path}/**` : undefined;
+    const collectionName = this.config.multiProjectEnabled ? `rust ${this.folder.uri.toString()}` : 'rust';
     const clientOptions: LanguageClientOptions = {
       // Register the server for Rust files
+
       documentSelector: [
-        { language: 'rust', scheme: 'file' },
-        { language: 'rust', scheme: 'untitled' },
+        { language: 'rust', scheme: 'file', pattern },
+        { language: 'rust', scheme: 'untitled', pattern },
       ],
-      diagnosticCollectionName: 'rust',
+      diagnosticCollectionName: collectionName,
       synchronize: { configurationSection: 'rust' },
       // Controls when to focus the channel rather than when to reveal it in the drop-down list
       revealOutputChannelOn: this.config.revealOutputChannelOn,
@@ -259,13 +287,15 @@ class ClientWorkspace {
       clientOptions,
     );
 
+    const selector = this.config.multiProjectEnabled ? { language: 'rust', scheme: 'file', pattern } : { language: 'rust' };
+
     this.setupProgressCounter();
-    this.registerCommands(context);
+    this.registerCommands(context, this.config.multiProjectEnabled);
     this.disposables.push(activateTaskProvider(this.folder));
     this.disposables.push(this.lc.start());
     this.disposables.push(
       languages.registerSignatureHelpProvider(
-        { language: 'rust' },
+        selector,
         new SignatureHelpProvider(this.lc),
         '(',
         ',',
@@ -279,30 +309,41 @@ class ClientWorkspace {
     }
 
     this.disposables.forEach(d => d.dispose());
+    commandsUnregistered = true;
   }
 
-  private registerCommands(context: ExtensionContext) {
+  private registerCommands(context: ExtensionContext, multiProjectEnabled: boolean) {
     if (!this.lc) {
       return;
     }
+    if (multiProjectEnabled && !commandsUnregistered) {
+      return;
+    }
 
+    commandsUnregistered = false;
     const rustupUpdateDisposable = commands.registerCommand(
       'rls.update',
       () => {
-        return rustupUpdate(this.config.rustupConfig());
+        const ws = multiProjectEnabled && activeWorkspace ? activeWorkspace : this;
+        return rustupUpdate(ws.config.rustupConfig());
       },
     );
     this.disposables.push(rustupUpdateDisposable);
 
     const restartServer = commands.registerCommand('rls.restart', async () => {
-      await this.stop();
-      return this.start(context);
+      const ws = multiProjectEnabled && activeWorkspace ? activeWorkspace : this;
+      await ws.stop();
+      return ws.start(context);
+
     });
     this.disposables.push(restartServer);
 
     this.disposables.push(
-      commands.registerCommand('rls.run', (cmd: Execution) =>
-        runRlsCommand(this.folder, cmd),
+      commands.registerCommand('rls.run', (cmd: Execution) => {
+        const ws = multiProjectEnabled && activeWorkspace ? activeWorkspace : this;
+        runRlsCommand(ws.folder, cmd)
+      },
+
       ),
     );
   }