7 files changed, 246 insertions, 143 deletions

diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 69098a630..cf0cbdbd0 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -119,6 +119,12 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
         return true;
     }
 
+    if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+            return true;
+        }
+    }
+
     for node in bind_pat.syntax().ancestors() {
         match_ast! {
             match node {
@@ -943,4 +949,30 @@ fn main() {
         "###
         );
     }
+
+    #[test]
+    fn unit_structs_have_no_type_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+enum CustomResult<T, E> {
+    Ok(T),
+    Err(E),
+}
+use CustomResult::*;
+
+struct SyntheticSyntax;
+
+fn main() {
+    match Ok(()) {
+        Ok(_) => (),
+        Err(SyntheticSyntax) => (),
+    }
+}"#,
+        );
+
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, Some(8)).unwrap(), @r###"
+        []
+        "###
+        );
+    }
 }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 580ad1f2c..5480b9e4d 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -631,6 +631,9 @@ fn on_notification(
         }
         Err(not) => not,
     };
+    if not.method.starts_with("$/") {
+        return Ok(());
+    }
     log::error!("unhandled notification: {:?}", not);
     Ok(())
 }
diff --git a/editors/code/package.json b/editors/code/package.json
index 225739328..fd44d2bd5 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -191,7 +191,7 @@
                     "properties": {
                         "lsp.diagnostics": {
                             "type": "boolean",
-                            "description": "Whether to show diagnostics from `cargo check`"
+                            "markdownDescription": "Whether to show diagnostics from `cargo check`"
                         },
                         "completion.insertion.add-call-parenthesis": {
                             "type": "boolean",
@@ -203,7 +203,7 @@
                         },
                         "completion.enable-postfix": {
                             "type": "boolean",
-                            "description": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
+                            "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
                         },
                         "call-info.full": {
                             "type": "boolean",
@@ -211,11 +211,11 @@
                         },
                         "notifications.workspace-loaded": {
                             "type": "boolean",
-                            "description": "Whether to show `workspace loaded` message"
+                            "markdownDescription": "Whether to show `workspace loaded` message"
                         },
                         "notifications.cargo-toml-not-found": {
                             "type": "boolean",
-                            "description": "Whether to show `can't find Cargo.toml` error message"
+                            "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
                         }
                     }
                 },
@@ -251,24 +251,24 @@
                 "rust-analyzer.cargo-watch.enable": {
                     "type": "boolean",
                     "default": true,
-                    "description": "Run `cargo check` for diagnostics on save"
+                    "markdownDescription": "Run `cargo check` for diagnostics on save"
                 },
                 "rust-analyzer.cargo-watch.arguments": {
                     "type": "array",
                     "items": {
                         "type": "string"
                     },
-                    "description": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
+                    "markdownDescription": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
                     "default": []
                 },
                 "rust-analyzer.cargo-watch.command": {
                     "type": "string",
-                    "description": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
+                    "markdownDescription": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
                     "default": "check"
                 },
                 "rust-analyzer.cargo-watch.allTargets": {
                     "type": "boolean",
-                    "description": "Check all targets and tests (will be passed as `--all-targets`)",
+                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)",
                     "default": true
                 },
                 "rust-analyzer.trace.server": {
@@ -320,7 +320,7 @@
                 "rust-analyzer.cargoFeatures.noDefaultFeatures": {
                     "type": "boolean",
                     "default": false,
-                    "description": "Do not activate the `default` feature"
+                    "markdownDescription": "Do not activate the `default` feature"
                 },
                 "rust-analyzer.cargoFeatures.allFeatures": {
                     "type": "boolean",
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index b4e983a0c..25ef38aed 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,7 +3,7 @@ import * as lc from 'vscode-languageclient';
 
 import { Config } from './config';
 import { createClient } from './client';
-import { isRustDocument } from './util';
+import { isRustEditor, RustEditor } from './util';
 
 export class Ctx {
     private constructor(
@@ -22,17 +22,15 @@ export class Ctx {
         return res;
     }
 
-    get activeRustEditor(): vscode.TextEditor | undefined {
+    get activeRustEditor(): RustEditor | undefined {
         const editor = vscode.window.activeTextEditor;
-        return editor && isRustDocument(editor.document)
+        return editor && isRustEditor(editor)
             ? editor
             : undefined;
     }
 
-    get visibleRustEditors(): vscode.TextEditor[] {
-        return vscode.window.visibleTextEditors.filter(
-            editor => isRustDocument(editor.document),
-        );
+    get visibleRustEditors(): RustEditor[] {
+        return vscode.window.visibleTextEditors.filter(isRustEditor);
     }
 
     registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 08d3a64a7..e1a82e03e 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -1,156 +1,214 @@
+import * as lc from "vscode-languageclient";
 import * as vscode from 'vscode';
 import * as ra from './rust-analyzer-api';
 
-import { Ctx } from './ctx';
-import { log, sendRequestWithRetry, isRustDocument } from './util';
+import { Ctx, Disposable } from './ctx';
+import { sendRequestWithRetry, isRustDocument, RustDocument, RustEditor } from './util';
 
-export function activateInlayHints(ctx: Ctx) {
-    const hintsUpdater = new HintsUpdater(ctx);
-    vscode.window.onDidChangeVisibleTextEditors(
-        async _ => hintsUpdater.refresh(),
-        null,
-        ctx.subscriptions
-    );
 
-    vscode.workspace.onDidChangeTextDocument(
-        async event => {
-            if (event.contentChanges.length === 0) return;
-            if (!isRustDocument(event.document)) return;
-            await hintsUpdater.refresh();
+export function activateInlayHints(ctx: Ctx) {
+    const maybeUpdater = {
+        updater: null as null | HintsUpdater,
+        onConfigChange() {
+            if (!ctx.config.displayInlayHints) {
+                return this.dispose();
+            }
+            if (!this.updater) this.updater = new HintsUpdater(ctx);
         },
-        null,
-        ctx.subscriptions
-    );
+        dispose() {
+            this.updater?.dispose();
+            this.updater = null;
+        }
+    };
+
+    ctx.pushCleanup(maybeUpdater);
 
     vscode.workspace.onDidChangeConfiguration(
-        async _ => hintsUpdater.setEnabled(ctx.config.displayInlayHints),
-        null,
-        ctx.subscriptions
+        maybeUpdater.onConfigChange, maybeUpdater, ctx.subscriptions
     );
 
-    ctx.pushCleanup({
-        dispose() {
-            hintsUpdater.clear();
+    maybeUpdater.onConfigChange();
+}
+
+
+const typeHints = {
+    decorationType: vscode.window.createTextEditorDecorationType({
+        after: {
+            color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            fontStyle: "normal",
         }
-    });
+    }),
 
-    // XXX: we don't await this, thus Promise rejections won't be handled, but
-    // this should never throw in fact...
-    void hintsUpdater.setEnabled(ctx.config.displayInlayHints);
-}
+    toDecoration(hint: ra.InlayHint.TypeHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
+        return {
+            range: conv.asRange(hint.range),
+            renderOptions: { after: { contentText: `: ${hint.label}` } }
+        };
+    }
+};
+
+const paramHints = {
+    decorationType: vscode.window.createTextEditorDecorationType({
+        before: {
+            color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            fontStyle: "normal",
+        }
+    }),
 
-const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
-    after: {
-        color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
-        fontStyle: "normal",
-    },
-});
-
-const parameterHintDecorationType = vscode.window.createTextEditorDecorationType({
-    before: {
-        color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
-        fontStyle: "normal",
-    },
-});
-
-class HintsUpdater {
-    private pending = new Map<string, vscode.CancellationTokenSource>();
-    private ctx: Ctx;
-    private enabled: boolean;
-
-    constructor(ctx: Ctx) {
-        this.ctx = ctx;
-        this.enabled = false;
+    toDecoration(hint: ra.InlayHint.ParamHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
+        return {
+            range: conv.asRange(hint.range),
+            renderOptions: { before: { contentText: `${hint.label}: ` } }
+        };
     }
+};
 
-    async setEnabled(enabled: boolean): Promise<void> {
-        log.debug({ enabled, prev: this.enabled });
+class HintsUpdater implements Disposable {
+    private sourceFiles = new Map<string, RustSourceFile>(); // map Uri -> RustSourceFile
+    private readonly disposables: Disposable[] = [];
 
-        if (this.enabled === enabled) return;
-        this.enabled = enabled;
+    constructor(private readonly ctx: Ctx) {
+        vscode.window.onDidChangeVisibleTextEditors(
+            this.onDidChangeVisibleTextEditors,
+            this,
+            this.disposables
+        );
 
-        if (this.enabled) {
-            return await this.refresh();
-        } else {
-            return this.clear();
-        }
+        vscode.workspace.onDidChangeTextDocument(
+            this.onDidChangeTextDocument,
+            this,
+            this.disposables
+        );
+
+        // Set up initial cache shape
+        ctx.visibleRustEditors.forEach(editor => this.sourceFiles.set(
+            editor.document.uri.toString(),
+            {
+                document: editor.document,
+                inlaysRequest: null,
+                cachedDecorations: null
+            }
+        ));
+
+        this.syncCacheAndRenderHints();
     }
 
-    clear() {
-        this.ctx.visibleRustEditors.forEach(it => {
-            this.setTypeDecorations(it, []);
-            this.setParameterDecorations(it, []);
-        });
+    dispose() {
+        this.sourceFiles.forEach(file => file.inlaysRequest?.cancel());
+        this.ctx.visibleRustEditors.forEach(editor => this.renderDecorations(editor, { param: [], type: [] }));
+        this.disposables.forEach(d => d.dispose());
+    }
+
+    onDidChangeTextDocument({ contentChanges, document }: vscode.TextDocumentChangeEvent) {
+        if (contentChanges.length === 0 || !isRustDocument(document)) return;
+        this.syncCacheAndRenderHints();
     }
 
-    async refresh() {
-        if (!this.enabled) return;
-        await Promise.all(this.ctx.visibleRustEditors.map(it => this.refreshEditor(it)));
+    private syncCacheAndRenderHints() {
+        // FIXME: make inlayHints request pass an array of files?
+        this.sourceFiles.forEach((file, uri) => this.fetchHints(file).then(hints => {
+            if (!hints) return;
+
+            file.cachedDecorations = this.hintsToDecorations(hints);
+
+            for (const editor of this.ctx.visibleRustEditors) {
+                if (editor.document.uri.toString() === uri) {
+                    this.renderDecorations(editor, file.cachedDecorations);
+                }
+            }
+        }));
     }
 
-    private async refreshEditor(editor: vscode.TextEditor): Promise<void> {
-        const newHints = await this.queryHints(editor.document.uri.toString());
-        if (newHints == null) return;
-
-        const newTypeDecorations = newHints
-            .filter(hint => hint.kind === ra.InlayKind.TypeHint)
-            .map(hint => ({
-                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
-                renderOptions: {
-                    after: {
-                        contentText: `: ${hint.label}`,
-                    },
-                },
-            }));
-        this.setTypeDecorations(editor, newTypeDecorations);
-
-        const newParameterDecorations = newHints
-            .filter(hint => hint.kind === ra.InlayKind.ParameterHint)
-            .map(hint => ({
-                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
-                renderOptions: {
-                    before: {
-                        contentText: `${hint.label}: `,
-                    },
-                },
-            }));
-        this.setParameterDecorations(editor, newParameterDecorations);
+    onDidChangeVisibleTextEditors() {
+        const newSourceFiles = new Map<string, RustSourceFile>();
+
+        // Rerendering all, even up-to-date editors for simplicity
+        this.ctx.visibleRustEditors.forEach(async editor => {
+            const uri = editor.document.uri.toString();
+            const file = this.sourceFiles.get(uri) ?? {
+                document: editor.document,
+                inlaysRequest: null,
+                cachedDecorations: null
+            };
+            newSourceFiles.set(uri, file);
+
+            // No text documents changed, so we may try to use the cache
+            if (!file.cachedDecorations) {
+                file.inlaysRequest?.cancel();
+
+                const hints = await this.fetchHints(file);
+                if (!hints) return;
+
+                file.cachedDecorations = this.hintsToDecorations(hints);
+            }
+
+            this.renderDecorations(editor, file.cachedDecorations);
+        });
+
+        // Cancel requests for no longer visible (disposed) source files
+        this.sourceFiles.forEach((file, uri) => {
+            if (!newSourceFiles.has(uri)) file.inlaysRequest?.cancel();
+        });
+
+        this.sourceFiles = newSourceFiles;
     }
 
-    private setTypeDecorations(
-        editor: vscode.TextEditor,
-        decorations: vscode.DecorationOptions[],
-    ) {
-        editor.setDecorations(
-            typeHintDecorationType,
-            this.enabled ? decorations : [],
-        );
+    private renderDecorations(editor: RustEditor, decorations: InlaysDecorations) {
+        editor.setDecorations(typeHints.decorationType, decorations.type);
+        editor.setDecorations(paramHints.decorationType, decorations.param);
     }
 
-    private setParameterDecorations(
-        editor: vscode.TextEditor,
-        decorations: vscode.DecorationOptions[],
-    ) {
-        editor.setDecorations(
-            parameterHintDecorationType,
-            this.enabled ? decorations : [],
-        );
+    private hintsToDecorations(hints: ra.InlayHint[]): InlaysDecorations {
+        const decorations: InlaysDecorations = { type: [], param: [] };
+        const conv = this.ctx.client.protocol2CodeConverter;
+
+        for (const hint of hints) {
+            switch (hint.kind) {
+                case ra.InlayHint.Kind.TypeHint: {
+                    decorations.type.push(typeHints.toDecoration(hint, conv));
+                    continue;
+                }
+                case ra.InlayHint.Kind.ParamHint: {
+                    decorations.param.push(paramHints.toDecoration(hint, conv));
+                    continue;
+                }
+            }
+        }
+        return decorations;
     }
 
-    private async queryHints(documentUri: string): Promise<ra.InlayHint[] | null> {
-        this.pending.get(documentUri)?.cancel();
+    private async fetchHints(file: RustSourceFile): Promise<null | ra.InlayHint[]> {
+        file.inlaysRequest?.cancel();
 
         const tokenSource = new vscode.CancellationTokenSource();
-        this.pending.set(documentUri, tokenSource);
+        file.inlaysRequest = tokenSource;
 
-        const request = { textDocument: { uri: documentUri } };
+        const request = { textDocument: { uri: file.document.uri.toString() } };
 
         return sendRequestWithRetry(this.ctx.client, ra.inlayHints, request, tokenSource.token)
             .catch(_ => null)
             .finally(() => {
-                if (!tokenSource.token.isCancellationRequested) {
-                    this.pending.delete(documentUri);
+                if (file.inlaysRequest === tokenSource) {
+                    file.inlaysRequest = null;
                 }
             });
     }
 }
+
+interface InlaysDecorations {
+    type: vscode.DecorationOptions[];
+    param: vscode.DecorationOptions[];
+}
+
+interface RustSourceFile {
+    /*
+    * Source of the token to cancel in-flight inlay hints request if any.
+    */
+    inlaysRequest: null | vscode.CancellationTokenSource;
+    /**
+    * Last applied decorations.
+    */
+    cachedDecorations: null | InlaysDecorations;
+
+    document: RustDocument;
+}
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
index c5a010e94..bd6e3ada0 100644
--- a/editors/code/src/rust-analyzer-api.ts
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -86,14 +86,20 @@ export interface Runnable {
 export const runnables = request<RunnablesParams, Vec<Runnable>>("runnables");
 
 
-export const enum InlayKind {
-    TypeHint = "TypeHint",
-    ParameterHint = "ParameterHint",
-}
-export interface InlayHint {
-    range: lc.Range;
-    kind: InlayKind;
-    label: string;
+
+export type InlayHint = InlayHint.TypeHint | InlayHint.ParamHint;
+
+export namespace InlayHint {
+    export const enum Kind {
+        TypeHint = "TypeHint",
+        ParamHint = "ParameterHint",
+    }
+    interface Common {
+        range: lc.Range;
+        label: string;
+    }
+    export type TypeHint = Common & { kind: Kind.TypeHint };
+    export type ParamHint = Common & { kind: Kind.ParamHint };
 }
 export interface InlayHintsParams {
     textDocument: lc.TextDocumentIdentifier;
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 7c95769bb..95a5f1227 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -1,7 +1,6 @@
 import * as lc from "vscode-languageclient";
 import * as vscode from "vscode";
 import { strict as nativeAssert } from "assert";
-import { TextDocument } from "vscode";
 
 export function assert(condition: boolean, explanation: string): asserts condition {
     try {
@@ -67,9 +66,16 @@ function sleep(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-export function isRustDocument(document: TextDocument) {
+export type RustDocument = vscode.TextDocument & { languageId: "rust" };
+export type RustEditor = vscode.TextEditor & { document: RustDocument; id: string };
+
+export function isRustDocument(document: vscode.TextDocument): document is RustDocument {
     return document.languageId === 'rust'
         // SCM diff views have the same URI as the on-disk document but not the same content
         && document.uri.scheme !== 'git'
         && document.uri.scheme !== 'svn';
-}
\ No newline at end of file
+}
+
+export function isRustEditor(editor: vscode.TextEditor): editor is RustEditor {
+    return isRustDocument(editor.document);
+}