Remove useWsl related logic

Author: Xanewok

CHANGELOG.md

@@ -1,5 +1,8 @@
 ### Unreleased
 
+* Remove deprecated `rust-client.useWsl` setting (use the official
+[Remote - WSL](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl) extension instead)
+
 ### 0.7.4 - 2020-04-27
 
 * Add a Start/Stop the RLS command

package.json

@@ -169,11 +169,6 @@
                     "description": "Path to rustup executable. Ignored if rustup is disabled.",
                     "scope": "machine"
                 },
-                "rust-client.useWSL": {
-                    "type": "boolean",
-                    "default": false,
-                    "description": "When set to true, RLS is started within Windows Subsystem for Linux."
-                },
                 "rust-client.rlsPath": {
                     "type": [
                         "string",

src/configuration.ts

@@ -1,4 +1,4 @@
-import { window, workspace, WorkspaceConfiguration } from 'vscode';
+import { workspace, WorkspaceConfiguration } from 'vscode';
 import { RevealOutputChannelOn } from 'vscode-languageclient';
 
 import { getActiveChannel, RustupConfig } from './rustup';
@@ -26,14 +26,6 @@ export class RLSConfiguration {
   private constructor(configuration: WorkspaceConfiguration, wsPath: string) {
     this.configuration = configuration;
     this.wsPath = wsPath;
-
-    if (this.configuration.get<boolean>('rust-client.useWSL')) {
-      window.showWarningMessage(
-        'Option `rust-client.useWsl` is enabled for this workspace, which is DEPRECATED.\
-        For a complete and first-class WSL support try Remote - WSL extension \
-        extension (https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl)',
-      );
-    }
   }
 
   public static loadFromWorkspace(wsPath: string): RLSConfiguration {
@@ -79,10 +71,6 @@ export class RLSConfiguration {
     return this.configuration.get('rust-client.rustupPath', 'rustup');
   }
 
-  public get useWSL(): boolean {
-    return this.configuration.get<boolean>('rust-client.useWSL', false);
-  }
-
   public get logToFile(): boolean {
     return this.configuration.get<boolean>('rust-client.logToFile', false);
   }
@@ -130,7 +118,6 @@ export class RLSConfiguration {
     return {
       channel: ignoreChannel ? '' : this.channel,
       path: this.rustupPath,
-      useWSL: this.useWSL,
     };
   }
 }

src/extension.ts

@@ -1,6 +1,7 @@
 import * as child_process from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as util from 'util';
 import {
   commands,
   ConfigurationTarget,
@@ -27,10 +28,10 @@ import { SignatureHelpProvider } from './providers/signatureHelpProvider';
 import { checkForRls, ensureToolchain, rustupUpdate } from './rustup';
 import { startSpinner, stopSpinner } from './spinner';
 import { activateTaskProvider, Execution, runRlsCommand } from './tasks';
-import { withWsl } from './utils/child_process';
 import { Observable } from './utils/observable';
 import { nearestParentWorkspace } from './utils/workspace';
-import { uriWindowsToWsl, uriWslToWindows } from './utils/wslpath';
+
+const exec = util.promisify(child_process.exec);
 
 /**
  * Parameter type to `window/progress` request as issued by the RLS.
@@ -233,23 +234,6 @@ class ClientWorkspace {
       workspaceFolder: this.folder,
     };
 
-    // Changes paths between Windows and Windows Subsystem for Linux
-    if (this.config.useWSL) {
-      clientOptions.uriConverters = {
-        code2Protocol: (uri: Uri) => {
-          const res = Uri.file(uriWindowsToWsl(uri.fsPath)).toString();
-          console.log(`code2Protocol for path ${uri.fsPath} -> ${res}`);
-          return res;
-        },
-        protocol2Code: (wslUri: string) => {
-          const urlDecodedPath = Uri.parse(wslUri).path;
-          const winPath = Uri.file(uriWslToWindows(urlDecodedPath));
-          console.log(`protocol2Code for path ${wslUri} -> ${winPath.fsPath}`);
-          return winPath;
-        },
-      };
-    }
-
     // Create the language client and start the client.
     this.lc = new LanguageClient(
       'rust-client',
@@ -330,12 +314,10 @@ class ClientWorkspace {
   }
 
   private async getSysroot(env: typeof process.env): Promise<string> {
-    const wslWrapper = withWsl(this.config.useWSL);
-
     const rustcPrintSysroot = () =>
       this.config.rustupDisabled
-        ? wslWrapper.exec('rustc --print sysroot', { env })
-        : wslWrapper.exec(
+        ? exec('rustc --print sysroot', { env })
+        : exec(
             `${this.config.rustupPath} run ${this.config.channel} rustc --print sysroot`,
             { env },
           );
@@ -424,7 +406,7 @@ class ClientWorkspace {
       }
 
       const env = await makeRlsEnv();
-      childProcess = withWsl(config.useWSL).spawn(
+      childProcess = child_process.spawn(
         config.path,
         ['run', config.channel, rlsPath],
         { env, cwd, shell: true },

src/rustup.ts

@@ -2,11 +2,14 @@
  * @file This module handles running the RLS via rustup, including checking that
  * rustup is installed and installing any required components/toolchains.
  */
+import * as child_process from 'child_process';
+import * as util from 'util';
 import { window } from 'vscode';
 
 import { startSpinner, stopSpinner } from './spinner';
 import { runTaskCommand } from './tasks';
-import { withWsl } from './utils/child_process';
+
+const exec = util.promisify(child_process.exec);
 
 const REQUIRED_COMPONENTS = ['rust-analysis', 'rust-src', 'rls'];
 
@@ -17,16 +20,13 @@ function isInstalledRegex(componentName: string): RegExp {
 export interface RustupConfig {
   channel: string;
   path: string;
-  useWSL: boolean;
 }
 
 export async function rustupUpdate(config: RustupConfig) {
   startSpinner('Updating…');
 
   try {
-    const { stdout } = await withWsl(config.useWSL).exec(
-      `${config.path} update`,
-    );
+    const { stdout } = await exec(`${config.path} update`);
 
     // This test is imperfect because if the user has multiple toolchains installed, they
     // might have one updated and one unchanged. But I don't want to go too far down the
@@ -83,20 +83,12 @@ export async function checkForRls(config: RustupConfig) {
 
 async function hasToolchain(config: RustupConfig): Promise<boolean> {
   try {
-    const { stdout } = await withWsl(config.useWSL).exec(
-      `${config.path} toolchain list`,
-    );
+    const { stdout } = await exec(`${config.path} toolchain list`);
     return stdout.includes(config.channel);
   } catch (e) {
     console.log(e);
-    const rustupFoundButNotInWSLMode =
-      config.useWSL && (await hasRustup({ useWSL: false, ...config }));
-
     window.showErrorMessage(
-      rustupFoundButNotInWSLMode
-        ? `Rustup is installed but can't be found under WSL. Ensure that
-        invoking \`wsl rustup\` works correctly.`
-        : 'Rustup not available. Install from https://www.rustup.rs/',
+      'Rustup not available. Install from https://www.rustup.rs/',
     );
     throw e;
   }
@@ -105,11 +97,8 @@ async function hasToolchain(config: RustupConfig): Promise<boolean> {
 async function tryToInstallToolchain(config: RustupConfig) {
   startSpinner('Installing toolchain…');
   try {
-    const { command, args } = withWsl(config.useWSL).modifyArgs(config.path, [
-      'toolchain',
-      'install',
-      config.channel,
-    ]);
+    const command = config.path;
+    const args = ['toolchain', 'install', config.channel];
     await runTaskCommand({ command, args }, 'Installing toolchain…');
     if (!(await hasToolchain(config))) {
       throw new Error();
@@ -128,14 +117,14 @@ async function tryToInstallToolchain(config: RustupConfig) {
  * valid listed component name.
  */
 async function listComponents(config: RustupConfig): Promise<string[]> {
-  return withWsl(config.useWSL)
-    .exec(`${config.path} component list --toolchain ${config.channel}`)
-    .then(({ stdout }) =>
-      stdout
-        .toString()
-        .replace('\r', '')
-        .split('\n'),
-    );
+  return exec(
+    `${config.path} component list --toolchain ${config.channel}`,
+  ).then(({ stdout }) =>
+    stdout
+      .toString()
+      .replace('\r', '')
+      .split('\n'),
+  );
 }
 
 async function hasRlsComponents(config: RustupConfig): Promise<boolean> {
@@ -158,13 +147,14 @@ async function installRlsComponents(config: RustupConfig) {
 
   for (const component of REQUIRED_COMPONENTS) {
     try {
-      const { command, args } = withWsl(config.useWSL).modifyArgs(config.path, [
+      const command = config.path;
+      const args = [
         'component',
         'add',
         component,
         '--toolchain',
         config.channel,
-      ]);
+      ];
       await runTaskCommand({ command, args }, `Installing \`${component}\``);
 
       const isInstalled = isInstalledRegex(component);
@@ -226,7 +216,7 @@ export function parseActiveToolchain(rustupOutput: string): string {
 export async function getVersion(config: RustupConfig): Promise<string> {
   const versionRegex = /rustup ([0-9]+\.[0-9]+\.[0-9]+)/;
 
-  const output = await withWsl(config.useWSL).exec(`${config.path} --version`);
+  const output = await exec(`${config.path} --version`);
   const versionMatch = output.stdout.toString().match(versionRegex);
   if (versionMatch && versionMatch.length >= 2) {
     return versionMatch[1];
@@ -256,8 +246,10 @@ export function getActiveChannel(wsPath: string, config: RustupConfig): string {
   let activeChannel;
   try {
     // `rustup show active-toolchain` is available since rustup 1.12.0
-    activeChannel = withWsl(config.useWSL)
-      .execSync(`${config.path} show active-toolchain`, { cwd: wsPath })
+    activeChannel = child_process
+      .execSync(`${config.path} show active-toolchain`, {
+        cwd: wsPath,
+      })
       .toString()
       .trim();
     // Since rustup 1.17.0 if the active toolchain is the default, we're told
@@ -267,8 +259,10 @@ export function getActiveChannel(wsPath: string, config: RustupConfig): string {
     activeChannel = activeChannel.replace(/ \(.*\)$/, '');
   } catch (e) {
     // Possibly an old rustup version, so try rustup show
-    const showOutput = withWsl(config.useWSL)
-      .execSync(`${config.path} show`, { cwd: wsPath })
+    const showOutput = child_process
+      .execSync(`${config.path} show`, {
+        cwd: wsPath,
+      })
       .toString();
     activeChannel = parseActiveToolchain(showOutput);
   }