7 files changed, 393 insertions, 26 deletions

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 7e7e909dd..2e3d4aba2 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -1,24 +1,18 @@
-import { homedir } from 'os';
 import * as lc from 'vscode-languageclient';
-import { spawnSync } from 'child_process';
 
 import { window, workspace } from 'vscode';
 import { Config } from './config';
+import { ensureLanguageServerBinary } from './installation/language_server';
 
-export function createClient(config: Config): lc.LanguageClient {
+export async function createClient(config: Config): Promise<null | lc.LanguageClient> {
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
     // It might be a good idea to test if the uri points to a file.
     const workspaceFolderPath = workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
 
-    const raLspServerPath = expandPathResolving(config.raLspServerPath);
-    if (spawnSync(raLspServerPath, ["--version"]).status !== 0) {
-        window.showErrorMessage(
-            `Unable to execute '${raLspServerPath} --version'\n\n` +
-            `Perhaps it is not in $PATH?\n\n` +
-            `PATH=${process.env.PATH}\n`
-        );
-    }
+    const raLspServerPath = await ensureLanguageServerBinary(config.langServerSource);
+    if (!raLspServerPath) return null;
+
     const run: lc.Executable = {
         command: raLspServerPath,
         options: { cwd: workspaceFolderPath },
@@ -87,9 +81,3 @@ export function createClient(config: Config): lc.LanguageClient {
     res.registerProposedFeatures();
     return res;
 }
-function expandPathResolving(path: string) {
-    if (path.startsWith('~/')) {
-        return path.replace('~', homedir());
-    }
-    return path;
-}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 524620433..418845436 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -1,4 +1,6 @@
+import * as os from "os";
 import * as vscode from 'vscode';
+import { BinarySource } from "./installation/interfaces";
 
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
 
@@ -16,10 +18,11 @@ export interface CargoFeatures {
 }
 
 export class Config {
+    langServerSource!: null | BinarySource;
+
     highlightingOn = true;
     rainbowHighlightingOn = false;
     enableEnhancedTyping = true;
-    raLspServerPath = RA_LSP_DEBUG || 'ra_lsp_server';
     lruCapacity: null | number = null;
     displayInlayHints = true;
     maxInlayHintLength: null | number = null;
@@ -45,11 +48,89 @@ export class Config {
     private prevCargoWatchOptions: null | CargoWatchOptions = null;
 
     constructor(ctx: vscode.ExtensionContext) {
-        vscode.workspace.onDidChangeConfiguration(_ => this.refresh(), null, ctx.subscriptions);
-        this.refresh();
+        vscode.workspace.onDidChangeConfiguration(_ => this.refresh(ctx), null, ctx.subscriptions);
+        this.refresh(ctx);
+    }
+
+    private static expandPathResolving(path: string) {
+        if (path.startsWith('~/')) {
+            return path.replace('~', os.homedir());
+        }
+        return path;
     }
 
-    private refresh() {
+    /**
+     * Name of the binary artifact for `ra_lsp_server` that is published for
+     * `platform` on GitHub releases. (It is also stored under the same name when
+     * downloaded by the extension).
+     */
+    private static prebuiltLangServerFileName(
+        platform: NodeJS.Platform,
+        arch: string
+    ): null | string {
+        // See possible `arch` values here:
+        // https://nodejs.org/api/process.html#process_process_arch
+
+        switch (platform) {
+
+            case "linux": {
+                switch (arch) {
+                    case "arm":
+                    case "arm64": return null;
+
+                    default: return "ra_lsp_server-linux";
+                }
+            }
+
+            case "darwin": return "ra_lsp_server-mac";
+            case "win32":  return "ra_lsp_server-windows.exe";
+
+            // Users on these platforms yet need to manually build from sources
+            case "aix":
+            case "android":
+            case "freebsd":
+            case "openbsd":
+            case "sunos":
+            case "cygwin":
+            case "netbsd": return null;
+            // The list of platforms is exhaustive (see `NodeJS.Platform` type definition)
+        }
+    }
+
+    private static langServerBinarySource(
+        ctx: vscode.ExtensionContext,
+        config: vscode.WorkspaceConfiguration
+    ): null | BinarySource {
+        const langServerPath = RA_LSP_DEBUG ?? config.get<null | string>("raLspServerPath");
+
+        if (langServerPath) {
+            return {
+                type: BinarySource.Type.ExplicitPath,
+                path: Config.expandPathResolving(langServerPath)
+            };
+        }
+
+        const prebuiltBinaryName = Config.prebuiltLangServerFileName(
+            process.platform, process.arch
+        );
+
+        if (!prebuiltBinaryName) return null;
+
+        return {
+            type: BinarySource.Type.GithubRelease,
+            dir: ctx.globalStoragePath,
+            file: prebuiltBinaryName,
+            repo: {
+                name: "rust-analyzer",
+                owner: "rust-analyzer",
+            }
+        };
+    }
+
+
+    // FIXME: revisit the logic for `if (.has(...)) config.get(...)` set default
+    // values only in one place (i.e. remove default values from non-readonly members declarations)
+    private refresh(ctx: vscode.ExtensionContext) {
         const config = vscode.workspace.getConfiguration('rust-analyzer');
 
         let requireReloadMessage = null;
@@ -82,10 +163,7 @@ export class Config {
             this.prevEnhancedTyping = this.enableEnhancedTyping;
         }
 
-        if (config.has('raLspServerPath')) {
-            this.raLspServerPath =
-                RA_LSP_DEBUG || (config.get('raLspServerPath') as string);
-        }
+        this.langServerSource = Config.langServerBinarySource(ctx, config);
 
         if (config.has('cargo-watch.enable')) {
             this.cargoWatchOptions.enable = config.get<boolean>(
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index aa75943bf..70042a479 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -11,6 +11,9 @@ export class Ctx {
     // deal with it.
     //
     // Ideally, this should be replaced with async getter though.
+    // FIXME: this actually needs syncronization of some kind (check how
+    // vscode deals with `deactivate()` call when extension has some work scheduled
+    // on the event loop to get a better picture of what we can do here)
     client: lc.LanguageClient | null = null;
     private extCtx: vscode.ExtensionContext;
     private onDidRestartHooks: Array<(client: lc.LanguageClient) => void> = [];
@@ -26,7 +29,14 @@ export class Ctx {
             await old.stop();
         }
         this.client = null;
-        const client = createClient(this.config);
+        const client = await createClient(this.config);
+        if (!client) {
+            throw new Error(
+                "Rust Analyzer Language Server is not available. " +
+                "Please, ensure its [proper installation](https://github.com/rust-analyzer/rust-analyzer/tree/master/docs/user#vs-code)."
+            );
+        }
+
         this.pushCleanup(client.start());
         await client.onReady();
 
diff --git a/editors/code/src/installation/download_file.ts b/editors/code/src/installation/download_file.ts
new file mode 100644
index 000000000..f1f9f4a25
--- /dev/null
+++ b/editors/code/src/installation/download_file.ts
@@ -0,0 +1,44 @@
+import fetch from "node-fetch";
+import * as fs from "fs";
+import { strict as assert } from "assert";
+
+/**
+ * Downloads file from `url` and stores it at `destFilePath` with `destFilePermissions`.
+ * `onProgress` callback is called on recieveing each chunk of bytes
+ * to track the progress of downloading, it gets the already read and total
+ * amount of bytes to read as its parameters.
+ */
+export async function downloadFile(
+    url: string,
+    destFilePath: fs.PathLike,
+    destFilePermissions: number,
+    onProgress: (readBytes: number, totalBytes: number) => void
+): Promise<void> {
+    const res = await fetch(url);
+
+    if (!res.ok) {
+        console.log("Error", res.status, "while downloading file from", url);
+        console.dir({ body: await res.text(), headers: res.headers }, { depth: 3 });
+
+        throw new Error(`Got response ${res.status} when trying to download a file`);
+    }
+
+    const totalBytes = Number(res.headers.get('content-length'));
+    assert(!Number.isNaN(totalBytes), "Sanity check of content-length protocol");
+
+    let readBytes = 0;
+
+    console.log("Downloading file of", totalBytes, "bytes size from", url, "to", destFilePath);
+
+    return new Promise<void>((resolve, reject) => res.body
+        .on("data", (chunk: Buffer) => {
+            readBytes += chunk.length;
+            onProgress(readBytes, totalBytes);
+        })
+        .on("error", reject)
+        .pipe(fs
+            .createWriteStream(destFilePath, { mode: destFilePermissions })
+            .on("close", resolve)
+        )
+    );
+}
diff --git a/editors/code/src/installation/fetch_latest_artifact_metadata.ts b/editors/code/src/installation/fetch_latest_artifact_metadata.ts
new file mode 100644
index 000000000..7e3700603
--- /dev/null
+++ b/editors/code/src/installation/fetch_latest_artifact_metadata.ts
@@ -0,0 +1,46 @@
+import fetch from "node-fetch";
+import { GithubRepo, ArtifactMetadata } from "./interfaces";
+
+const GITHUB_API_ENDPOINT_URL = "https://api.github.com";
+
+/**
+ * Fetches the latest release from GitHub `repo` and returns metadata about
+ * `artifactFileName` shipped with this release or `null` if no such artifact was published.
+ */
+export async function fetchLatestArtifactMetadata(
+    repo: GithubRepo, artifactFileName: string
+): Promise<null | ArtifactMetadata> {
+
+    const repoOwner = encodeURIComponent(repo.owner);
+    const repoName  = encodeURIComponent(repo.name);
+
+    const apiEndpointPath = `/repos/${repoOwner}/${repoName}/releases/latest`;
+    const requestUrl = GITHUB_API_ENDPOINT_URL + apiEndpointPath;
+
+    // We skip runtime type checks for simplicity (here we cast from `any` to `GithubRelease`)
+
+    console.log("Issuing request for released artifacts metadata to", requestUrl);
+
+    const response: GithubRelease = await fetch(requestUrl, {
+            headers: { Accept: "application/vnd.github.v3+json" }
+        })
+        .then(res => res.json());
+
+    const artifact = response.assets.find(artifact => artifact.name === artifactFileName);
+
+    if (!artifact) return null;
+
+    return {
+        releaseName: response.name,
+        downloadUrl: artifact.browser_download_url
+    };
+
+    // We omit declaration of tremendous amount of fields that we are not using here
+    interface GithubRelease {
+        name: string;
+        assets: Array<{
+            name: string;
+            browser_download_url: string;
+        }>;
+    }
+}
diff --git a/editors/code/src/installation/interfaces.ts b/editors/code/src/installation/interfaces.ts
new file mode 100644
index 000000000..8039d0b90
--- /dev/null
+++ b/editors/code/src/installation/interfaces.ts
@@ -0,0 +1,55 @@
+export interface GithubRepo {
+    name: string;
+    owner: string;
+}
+
+/**
+ * Metadata about particular artifact retrieved from GitHub releases.
+ */
+export interface ArtifactMetadata {
+    releaseName: string;
+    downloadUrl: string;
+}
+
+/**
+ * Represents the source of a binary artifact which is either specified by the user
+ * explicitly, or bundled by this extension from GitHub releases.
+ */
+export type BinarySource = BinarySource.ExplicitPath | BinarySource.GithubRelease;
+
+export namespace BinarySource {
+    /**
+     * Type tag for `BinarySource` discriminated union.
+     */
+    export const enum Type { ExplicitPath, GithubRelease }
+
+    export interface ExplicitPath {
+        type: Type.ExplicitPath;
+
+        /**
+         * Filesystem path to the binary specified by the user explicitly.
+         */
+        path: string;
+    }
+
+    export interface GithubRelease {
+        type: Type.GithubRelease;
+
+        /**
+         * Repository where the binary is stored.
+         */
+        repo: GithubRepo;
+
+        /**
+         * Directory on the filesystem where the bundled binary is stored.
+         */
+        dir: string;
+
+        /**
+         * Name of the binary file. It is stored under the same name on GitHub releases
+         * and in local `.dir`.
+         */
+        file: string;
+    }
+
+}
diff --git a/editors/code/src/installation/language_server.ts b/editors/code/src/installation/language_server.ts
new file mode 100644
index 000000000..52c5cbe7d
--- /dev/null
+++ b/editors/code/src/installation/language_server.ts
@@ -0,0 +1,146 @@
+import * as vscode from "vscode";
+import * as path from "path";
+import { strict as assert } from "assert";
+import { promises as fs } from "fs";
+import { promises as dns } from "dns";
+import { spawnSync } from "child_process";
+import { throttle } from "throttle-debounce";
+
+import { BinarySource } from "./interfaces";
+import { fetchLatestArtifactMetadata } from "./fetch_latest_artifact_metadata";
+import { downloadFile } from "./download_file";
+
+export async function downloadLatestLanguageServer(
+    {file: artifactFileName, dir: installationDir, repo}: BinarySource.GithubRelease
+) {
+    const { releaseName, downloadUrl } = (await fetchLatestArtifactMetadata(
+        repo, artifactFileName
+    ))!;
+
+    await fs.mkdir(installationDir).catch(err => assert.strictEqual(
+        err?.code,
+        "EEXIST",
+        `Couldn't create directory "${installationDir}" to download `+
+        `language server binary: ${err.message}`
+    ));
+
+    const installationPath = path.join(installationDir, artifactFileName);
+
+    console.time("Downloading ra_lsp_server");
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            cancellable: false, // FIXME: add support for canceling download?
+            title: `Downloading language server (${releaseName})`
+        },
+        async (progress, _cancellationToken) => {
+            let lastPrecentage = 0;
+            const filePermissions = 0o755; // (rwx, r_x, r_x)
+            await downloadFile(downloadUrl, installationPath, filePermissions, throttle(
+                200,
+                /* noTrailing: */ true,
+                (readBytes, totalBytes) => {
+                    const newPercentage = (readBytes / totalBytes) * 100;
+                    progress.report({
+                        message: newPercentage.toFixed(0) + "%",
+                        increment: newPercentage - lastPrecentage
+                    });
+
+                    lastPrecentage = newPercentage;
+                })
+            );
+        }
+    );
+    console.timeEnd("Downloading ra_lsp_server");
+}
+export async function ensureLanguageServerBinary(
+    langServerSource: null | BinarySource
+): Promise<null | string> {
+
+    if (!langServerSource) {
+        vscode.window.showErrorMessage(
+            "Unfortunately we don't ship binaries for your platform yet. " +
+            "You need to manually clone rust-analyzer repository and " +
+            "run `cargo xtask install --server` to build the language server from sources. " +
+            "If you feel that your platform should be supported, please create an issue " +
+            "about that [here](https://github.com/rust-analyzer/rust-analyzer/issues) and we " +
+            "will consider it."
+        );
+        return null;
+    }
+
+    switch (langServerSource.type) {
+        case BinarySource.Type.ExplicitPath: {
+            if (isBinaryAvailable(langServerSource.path)) {
+                return langServerSource.path;
+            }
+
+            vscode.window.showErrorMessage(
+                `Unable to run ${langServerSource.path} binary. ` +
+                `To use the pre-built language server, set "rust-analyzer.raLspServerPath" ` +
+                "value to `null` or remove it from the settings to use it by default."
+            );
+            return null;
+        }
+        case BinarySource.Type.GithubRelease: {
+            const prebuiltBinaryPath = path.join(langServerSource.dir, langServerSource.file);
+
+            if (isBinaryAvailable(prebuiltBinaryPath)) {
+                return prebuiltBinaryPath;
+            }
+
+            const userResponse = await vscode.window.showInformationMessage(
+                "Language server binary for rust-analyzer was not found. " +
+                "Do you want to download it now?",
+                "Download now", "Cancel"
+            );
+            if (userResponse !== "Download now") return null;
+
+            try {
+                await downloadLatestLanguageServer(langServerSource);
+            } catch (err) {
+                vscode.window.showErrorMessage(
+                    `Failed to download language server from ${langServerSource.repo.name} ` +
+                    `GitHub repository: ${err.message}`
+                );
+
+                dns.resolve('example.com').then(
+                    addrs => console.log("DNS resolution for example.com was successful", addrs),
+                    err => {
+                        console.error(
+                            "DNS resolution for example.com failed, " +
+                            "there might be an issue with Internet availability"
+                        );
+                        console.error(err);
+                    }
+                );
+
+                return null;
+            }
+
+            if (!isBinaryAvailable(prebuiltBinaryPath)) assert(false,
+                `Downloaded language server binary is not functional.` +
+                `Downloaded from: ${JSON.stringify(langServerSource)}`
+            );
+
+
+            vscode.window.showInformationMessage(
+                "Rust analyzer language server was successfully installed 🦀"
+            );
+
+            return prebuiltBinaryPath;
+        }
+    }
+
+    function isBinaryAvailable(binaryPath: string) {
+        const res = spawnSync(binaryPath, ["--version"]);
+
+        // ACHTUNG! `res` type declaration is inherently wrong, see
+        // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/42221
+
+        console.log("Checked binary availablity via --version", res);
+        console.log(binaryPath, "--version output:", res.output?.map(String));
+
+        return res.status === 0;
+    }
+}