5 files changed, 49 insertions, 48 deletions

diff --git a/editors/code/package.json b/editors/code/package.json
index 9565c6edb..1fac700be 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -313,7 +313,7 @@
                 },
                 "rust-analyzer.updates.askBeforeDownload": {
                     "type": "boolean",
-                    "default": true,
+                    "default": false,
                     "description": "Whether to ask for permission before downloading any files from the Internet."
                 },
                 "rust-analyzer.server.path": {
@@ -389,7 +389,7 @@
                     "default": {},
                     "markdownDescription": "Optional settings passed to the debug engine. Example: `{ \"lldb\": { \"terminal\":\"external\"} }`"
                 },
-                "$generated-start": false,
+                "$generated-start": {},
                 "rust-analyzer.assist.importGranularity": {
                     "markdownDescription": "How imports should be grouped into use statements.",
                     "default": "crate",
@@ -841,7 +841,7 @@
                         "Search for all symbols kinds"
                     ]
                 },
-                "$generated-end": false
+                "$generated-end": {}
             }
         },
         "problemPatterns": [
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 1f1fe59a4..2277eeb7e 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -31,10 +31,10 @@ export class Config {
         enableProposedApi: boolean | undefined;
     } = vscode.extensions.getExtension(this.extensionId)!.packageJSON;
 
-    readonly globalStoragePath: string;
+    readonly globalStorageUri: vscode.Uri;
 
     constructor(ctx: vscode.ExtensionContext) {
-        this.globalStoragePath = ctx.globalStorageUri.fsPath;
+        this.globalStorageUri = ctx.globalStorageUri;
         vscode.workspace.onDidChangeConfiguration(this.onDidChangeConfiguration, this, ctx.subscriptions);
         this.refreshLogging();
     }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 74ee28d24..15f2151ad 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -1,7 +1,5 @@
 import * as vscode from 'vscode';
-import * as path from "path";
 import * as os from "os";
-import { promises as fs, PathLike } from "fs";
 
 import * as commands from './commands';
 import { activateInlayHints } from './inlay_hints';
@@ -160,7 +158,7 @@ export async function deactivate() {
 }
 
 async function bootstrap(config: Config, state: PersistentState): Promise<string> {
-    await fs.mkdir(config.globalStoragePath, { recursive: true });
+    await vscode.workspace.fs.createDirectory(config.globalStorageUri).then();
 
     if (!config.currentExtensionIsNightly) {
         await state.updateNightlyReleaseId(undefined);
@@ -222,7 +220,7 @@ async function bootstrapExtension(config: Config, state: PersistentState): Promi
     const artifact = latestNightlyRelease.assets.find(artifact => artifact.name === "rust-analyzer.vsix");
     assert(!!artifact, `Bad release: ${JSON.stringify(latestNightlyRelease)}`);
 
-    const dest = path.join(config.globalStoragePath, "rust-analyzer.vsix");
+    const dest = vscode.Uri.joinPath(config.globalStorageUri, "rust-analyzer.vsix");
 
     await downloadWithRetryDialog(state, async () => {
         await download({
@@ -233,8 +231,8 @@ async function bootstrapExtension(config: Config, state: PersistentState): Promi
         });
     });
 
-    await vscode.commands.executeCommand("workbench.extensions.installExtension", vscode.Uri.file(dest));
-    await fs.unlink(dest);
+    await vscode.commands.executeCommand("workbench.extensions.installExtension", dest);
+    await vscode.workspace.fs.delete(dest);
 
     await state.updateNightlyReleaseId(latestNightlyRelease.id);
     await state.updateLastCheck(now);
@@ -259,7 +257,7 @@ async function bootstrapServer(config: Config, state: PersistentState): Promise<
     return path;
 }
 
-async function patchelf(dest: PathLike): Promise<void> {
+async function patchelf(dest: vscode.Uri): Promise<void> {
     await vscode.window.withProgress(
         {
             location: vscode.ProgressLocation.Notification,
@@ -279,11 +277,11 @@ async function patchelf(dest: PathLike): Promise<void> {
                     '';
                 }
             `;
-            const origFile = dest + "-orig";
-            await fs.rename(dest, origFile);
+            const origFile = vscode.Uri.file(dest.fsPath + "-orig");
+            await vscode.workspace.fs.rename(dest, origFile);
             progress.report({ message: "Patching executable", increment: 20 });
             await new Promise((resolve, reject) => {
-                const handle = exec(`nix-build -E - --argstr srcStr '${origFile}' -o '${dest}'`,
+                const handle = exec(`nix-build -E - --argstr srcStr '${origFile.fsPath}' -o '${dest.fsPath}'`,
                     (err, stdout, stderr) => {
                         if (err != null) {
                             reject(Error(stderr));
@@ -294,7 +292,7 @@ async function patchelf(dest: PathLike): Promise<void> {
                 handle.stdin?.write(expression);
                 handle.stdin?.end();
             });
-            await fs.unlink(origFile);
+            await vscode.workspace.fs.delete(origFile);
         }
     );
 }
@@ -334,20 +332,20 @@ async function getServer(config: Config, state: PersistentState): Promise<string
         platform = "x86_64-unknown-linux-musl";
     }
     const ext = platform.indexOf("-windows-") !== -1 ? ".exe" : "";
-    const dest = path.join(config.globalStoragePath, `rust-analyzer-${platform}${ext}`);
-    const exists = await fs.stat(dest).then(() => true, () => false);
+    const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer-${platform}${ext}`);
+    const exists = await vscode.workspace.fs.stat(dest).then(() => true, () => false);
     if (!exists) {
         await state.updateServerVersion(undefined);
     }
 
-    if (state.serverVersion === config.package.version) return dest;
+    if (state.serverVersion === config.package.version) return dest.fsPath;
 
     if (config.askBeforeDownload) {
         const userResponse = await vscode.window.showInformationMessage(
             `Language server version ${config.package.version} for rust-analyzer is not installed.`,
             "Download now"
         );
-        if (userResponse !== "Download now") return dest;
+        if (userResponse !== "Download now") return dest.fsPath;
     }
 
     const releaseTag = config.package.releaseTag;
@@ -374,7 +372,7 @@ async function getServer(config: Config, state: PersistentState): Promise<string
     }
 
     await state.updateServerVersion(config.package.version);
-    return dest;
+    return dest.fsPath;
 }
 
 function serverPath(config: Config): string | null {
@@ -383,9 +381,9 @@ function serverPath(config: Config): string | null {
 
 async function isNixOs(): Promise<boolean> {
     try {
-        const contents = await fs.readFile("/etc/os-release");
+        const contents = (await vscode.workspace.fs.readFile(vscode.Uri.file("/etc/os-release"))).toString();
         return contents.indexOf("ID=nixos") !== -1;
-    } catch (e) {
+    } catch {
         return false;
     }
 }
diff --git a/editors/code/src/net.ts b/editors/code/src/net.ts
index 07ebc615c..722dab756 100644
--- a/editors/code/src/net.ts
+++ b/editors/code/src/net.ts
@@ -73,14 +73,14 @@ export interface GithubRelease {
     assets: Array<{
         name: string;
         // eslint-disable-next-line camelcase
-        browser_download_url: string;
+        browser_download_url: vscode.Uri;
     }>;
 }
 
 interface DownloadOpts {
     progressTitle: string;
-    url: string;
-    dest: string;
+    url: vscode.Uri;
+    dest: vscode.Uri;
     mode?: number;
     gunzip?: boolean;
     httpProxy?: string;
@@ -90,9 +90,9 @@ export async function download(opts: DownloadOpts) {
     // Put artifact into a temporary file (in the same dir for simplicity)
     // to prevent partially downloaded files when user kills vscode
     // This also avoids overwriting running executables
-    const dest = path.parse(opts.dest);
     const randomHex = crypto.randomBytes(5).toString("hex");
-    const tempFile = path.join(dest.dir, `${dest.name}${randomHex}`);
+    const rawDest = path.parse(opts.dest.fsPath);
+    const tempFilePath = vscode.Uri.joinPath(vscode.Uri.file(rawDest.dir), `${rawDest.name}${randomHex}`);
 
     await vscode.window.withProgress(
         {
@@ -102,7 +102,7 @@ export async function download(opts: DownloadOpts) {
         },
         async (progress, _cancellationToken) => {
             let lastPercentage = 0;
-            await downloadFile(opts.url, tempFile, opts.mode, !!opts.gunzip, opts.httpProxy, (readBytes, totalBytes) => {
+            await downloadFile(opts.url, tempFilePath, opts.mode, !!opts.gunzip, opts.httpProxy, (readBytes, totalBytes) => {
                 const newPercentage = Math.round((readBytes / totalBytes) * 100);
                 if (newPercentage !== lastPercentage) {
                     progress.report({
@@ -116,28 +116,30 @@ export async function download(opts: DownloadOpts) {
         }
     );
 
-    await fs.promises.rename(tempFile, opts.dest);
+    await vscode.workspace.fs.rename(tempFilePath, opts.dest, { overwrite: true });
 }
 
 async function downloadFile(
-    url: string,
-    destFilePath: fs.PathLike,
+    url: vscode.Uri,
+    destFilePath: vscode.Uri,
     mode: number | undefined,
     gunzip: boolean,
     httpProxy: string | null | undefined,
     onProgress: (readBytes: number, totalBytes: number) => void
 ): Promise<void> {
+    const urlString = url.toString();
+
     const res = await (() => {
         if (httpProxy) {
-            log.debug(`Downloading ${url} via proxy: ${httpProxy}`);
-            return fetch(url, { agent: new HttpsProxyAgent(httpProxy) });
+            log.debug(`Downloading ${urlString} via proxy: ${httpProxy}`);
+            return fetch(urlString, { agent: new HttpsProxyAgent(httpProxy) });
         }
 
-        return fetch(url);
+        return fetch(urlString);
     })();
 
     if (!res.ok) {
-        log.error("Error", res.status, "while downloading file from", url);
+        log.error("Error", res.status, "while downloading file from", urlString);
         log.error({ body: await res.text(), headers: res.headers });
 
         throw new Error(`Got response ${res.status} when trying to download a file.`);
@@ -146,7 +148,7 @@ async function downloadFile(
     const totalBytes = Number(res.headers.get('content-length'));
     assert(!Number.isNaN(totalBytes), "Sanity check of content-length protocol");
 
-    log.debug("Downloading file of", totalBytes, "bytes size from", url, "to", destFilePath);
+    log.debug("Downloading file of", totalBytes, "bytes size from", urlString, "to", destFilePath.fsPath);
 
     let readBytes = 0;
     res.body.on("data", (chunk: Buffer) => {
@@ -154,7 +156,7 @@ async function downloadFile(
         onProgress(readBytes, totalBytes);
     });
 
-    const destFileStream = fs.createWriteStream(destFilePath, { mode });
+    const destFileStream = fs.createWriteStream(destFilePath.fsPath, { mode });
     const srcStream = gunzip ? res.body.pipe(zlib.createGunzip()) : res.body;
 
     await pipeline(srcStream, destFileStream);
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index 68826c478..355dd76fe 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -1,9 +1,8 @@
 import * as cp from 'child_process';
 import * as os from 'os';
 import * as path from 'path';
-import * as fs from 'fs';
 import * as readline from 'readline';
-import { OutputChannel } from 'vscode';
+import * as vscode from 'vscode';
 import { execute, log, memoize } from './util';
 
 interface CompilationArtifact {
@@ -19,7 +18,7 @@ export interface ArtifactSpec {
 }
 
 export class Cargo {
-    constructor(readonly rootFolder: string, readonly output: OutputChannel) { }
+    constructor(readonly rootFolder: string, readonly output: vscode.OutputChannel) { }
 
     // Made public for testing purposes
     static artifactSpec(args: readonly string[]): ArtifactSpec {
@@ -158,9 +157,9 @@ export const getPathForExecutable = memoize(
         try {
             // hmm, `os.homedir()` seems to be infallible
             // it is not mentioned in docs and cannot be infered by the type signature...
-            const standardPath = path.join(os.homedir(), ".cargo", "bin", executableName);
+            const standardPath = vscode.Uri.joinPath(vscode.Uri.file(os.homedir()), ".cargo", "bin", executableName);
 
-            if (isFile(standardPath)) return standardPath;
+            if (isFileAtUri(standardPath)) return standardPath.fsPath;
         } catch (err) {
             log.error("Failed to read the fs info", err);
         }
@@ -178,14 +177,16 @@ function lookupInPath(exec: string): boolean {
             : [candidate];
     });
 
-    return candidates.some(isFile);
+    return candidates.some(isFileAtPath);
 }
 
-function isFile(suspectPath: string): boolean {
-    // It is not mentionned in docs, but `statSync()` throws an error when
-    // the path doesn't exist
+async function isFileAtPath(path: string): Promise<boolean> {
+    return isFileAtUri(vscode.Uri.file(path));
+}
+
+async function isFileAtUri(uri: vscode.Uri): Promise<boolean> {
     try {
-        return fs.statSync(suspectPath).isFile();
+        return ((await vscode.workspace.fs.stat(uri)).type & vscode.FileType.File) !== 0;
     } catch {
         return false;
     }