Merge #1652

1652: Improve type hints behavior r=matklad a=SomeoneToIgnore This PR fixed the following type hints issues: * Restructures the `InlayKind` enum contents based on the discussion here: https://github.com/rust-analyzer/rust-analyzer/pull/1606#issuecomment-515968055 * Races described in #1639 * Caches the latest decorations received for each file to show them the next time the file is opened (instead of a new server request) Co-authored-by: Kirill Bulatov <mail4score@gmail.com>
2019-08-06 16:50:49 +00:00 · 2019-08-06 16:50:49 +00:00 · 7e12422fa2
commit 7e12422fa2
parent 811492aa54 c5598d9ade
5 changed files with 100 additions and 114 deletions
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@ -9,14 +9,9 @@
    SmolStr, SyntaxKind, SyntaxNode, TextRange,
 };

-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
-    LetBindingType,
-    ClosureParameterType,
-    ForExpressionBindingType,
-    IfExpressionType,
-    WhileLetExpressionType,
-    MatchArmType,
+    TypeHint,
 }

 #[derive(Debug)]
@ -46,7 +41,7 @@ fn get_inlay_hints(
            }
            let pat = let_statement.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, let_statement.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::LetBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
        })
        .visit(|closure_parameter: LambdaExpr| {
            let analyzer = SourceAnalyzer::new(db, file_id, closure_parameter.syntax(), None);
@ -55,15 +50,7 @@ fn get_inlay_hints(
                    .params()
                    .filter(|closure_param| closure_param.ascribed_type().is_none())
                    .filter_map(|closure_param| closure_param.pat())
-                    .map(|root_pat| {
-                        get_pat_hints(
-                            db,
-                            &analyzer,
-                            root_pat,
-                            InlayKind::ClosureParameterType,
-                            false,
-                        )
-                    })
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, false))
                    .flatten()
                    .collect()
            })
@ -71,17 +58,17 @@ fn get_inlay_hints(
        .visit(|for_expression: ForExpr| {
            let pat = for_expression.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, for_expression.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::ForExpressionBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
        })
        .visit(|if_expr: IfExpr| {
            let pat = if_expr.condition()?.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, if_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::IfExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
        })
        .visit(|while_expr: WhileExpr| {
            let pat = while_expr.condition()?.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, while_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::WhileLetExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
        })
        .visit(|match_arm_list: MatchArmList| {
            let analyzer = SourceAnalyzer::new(db, file_id, match_arm_list.syntax(), None);
@ -90,9 +77,7 @@ fn get_inlay_hints(
                    .arms()
                    .map(|match_arm| match_arm.pats())
                    .flatten()
-                    .map(|root_pat| {
-                        get_pat_hints(db, &analyzer, root_pat, InlayKind::MatchArmType, true)
-                    })
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, true))
                    .flatten()
                    .collect(),
            )
@ -100,11 +85,10 @@ fn get_inlay_hints(
        .accept(&node)?
 }

-fn get_pat_hints(
+fn get_pat_type_hints(
    db: &RootDatabase,
    analyzer: &SourceAnalyzer,
    root_pat: Pat,
-    kind: InlayKind,
    skip_root_pat_hint: bool,
 ) -> Vec<InlayHint> {
    let original_pat = &root_pat.clone();
@ -118,7 +102,7 @@ fn get_pat_hints(
        })
        .map(|(range, pat_type)| InlayHint {
            range,
-            kind: kind.clone(),
+            kind: InlayKind::TypeHint,
            label: pat_type.display(db).to_string().into(),
        })
        .collect()
@ -232,52 +216,52 @@ struct InnerStruct {}
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [193; 197),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [236; 244),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [275; 279),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "&str",
    },
    InlayHint {
        range: [539; 543),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "(i32, char)",
    },
    InlayHint {
        range: [566; 567),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [570; 571),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [573; 574),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [584; 585),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [577; 578),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "f64",
    },
    InlayHint {
        range: [580; 581),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "f64",
    },
 ]"#
@ -299,12 +283,12 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [57; 66),
-        kind: ClosureParameterType,
+        kind: TypeHint,
        label: "i32",
    },
 ]"#
@ -326,12 +310,12 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [44; 53),
-        kind: ForExpressionBindingType,
+        kind: TypeHint,
        label: "i32",
    },
 ]"#
@ -364,7 +348,7 @@ fn main() {
    if let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
    if let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
    if let CustomOption::Some(Test { b: y, .. }) = &test {};
-    
+
    if test == CustomOption::None {}
 }"#,
        );
@ -372,27 +356,27 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [166; 170),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "CustomOption<Test>",
    },
    InlayHint {
        range: [334; 338),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&Test",
    },
    InlayHint {
        range: [389; 390),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&CustomOption<u32>",
    },
    InlayHint {
        range: [392; 393),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&u8",
    },
    InlayHint {
        range: [531; 532),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&u32",
    },
 ]"#
@ -425,7 +409,7 @@ fn main() {
    while let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
    while let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
    while let CustomOption::Some(Test { b: y, .. }) = &test {};
-    
+
    while test == CustomOption::None {}
 }"#,
        );
@ -433,7 +417,7 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [166; 170),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "CustomOption<Test>",
    },
 ]"#
@ -445,7 +429,7 @@ fn match_arm_list() {
        let (analysis, file_id) = single_file(
            r#"
 #[derive(PartialEq)]
-enum CustomOption<T> { 
+enum CustomOption<T> {
    None,
    Some(T),
 }
@ -473,23 +457,23 @@ fn main() {

        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
-        range: [312; 316),
-        kind: MatchArmType,
+        range: [311; 315),
+        kind: TypeHint,
        label: "Test",
    },
    InlayHint {
-        range: [359; 360),
-        kind: MatchArmType,
+        range: [358; 359),
+        kind: TypeHint,
        label: "CustomOption<u32>",
    },
    InlayHint {
-        range: [362; 363),
-        kind: MatchArmType,
+        range: [361; 362),
+        kind: TypeHint,
        label: "u8",
    },
    InlayHint {
-        range: [485; 486),
-        kind: MatchArmType,
+        range: [484; 485),
+        kind: TypeHint,
        label: "u32",
    },
 ]"#
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@ -885,14 +885,7 @@ pub fn handle_inlay_hints(
            label: api_type.label.to_string(),
            range: api_type.range.conv_with(&line_index),
            kind: match api_type.kind {
-                ra_ide_api::InlayKind::LetBindingType => InlayKind::LetBindingType,
-                ra_ide_api::InlayKind::ClosureParameterType => InlayKind::ClosureParameterType,
-                ra_ide_api::InlayKind::ForExpressionBindingType => {
-                    InlayKind::ForExpressionBindingType
-                }
-                ra_ide_api::InlayKind::IfExpressionType => InlayKind::IfExpressionType,
-                ra_ide_api::InlayKind::WhileLetExpressionType => InlayKind::WhileLetExpressionType,
-                ra_ide_api::InlayKind::MatchArmType => InlayKind::MatchArmType,
+                ra_ide_api::InlayKind::TypeHint => InlayKind::TypeHint,
            },
        })
        .collect())
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@ -213,12 +213,7 @@ pub struct InlayHintsParams {

 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub enum InlayKind {
-    LetBindingType,
-    ClosureParameterType,
-    ForExpressionBindingType,
-    IfExpressionType,
-    WhileLetExpressionType,
-    MatchArmType,
+    TypeHint,
 }

 #[derive(Debug, Deserialize, Serialize)]
--- a/editors/code/src/commands/inlay_hints.ts
+++ b/editors/code/src/commands/inlay_hints.ts
@ -22,53 +22,56 @@ const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
 export class HintsUpdater {
    private displayHints = true;

-    public async loadHints(
-        editor: vscode.TextEditor | undefined
-    ): Promise<void> {
-        if (
-            this.displayHints &&
-            editor !== undefined &&
-            this.isRustDocument(editor.document)
-        ) {
-            await this.updateDecorationsFromServer(
-                editor.document.uri.toString(),
-                editor
+    public async toggleHintsDisplay(displayHints: boolean): Promise<void> {
+        if (this.displayHints !== displayHints) {
+            this.displayHints = displayHints;
+            return this.refreshVisibleEditorsHints(
+                displayHints ? undefined : []
            );
        }
    }

-    public async toggleHintsDisplay(displayHints: boolean): Promise<void> {
-        if (this.displayHints !== displayHints) {
-            this.displayHints = displayHints;
-
-            if (displayHints) {
-                return this.updateHints();
-            } else {
-                const editor = vscode.window.activeTextEditor;
-                if (editor != null) {
-                    return editor.setDecorations(typeHintDecorationType, []);
-                }
-            }
-        }
-    }
-
-    public async updateHints(cause?: TextDocumentChangeEvent): Promise<void> {
+    public async refreshHintsForVisibleEditors(
+        cause?: TextDocumentChangeEvent
+    ): Promise<void> {
        if (!this.displayHints) {
            return;
        }
-        const editor = vscode.window.activeTextEditor;
-        if (editor == null) {
+        if (
+            cause !== undefined &&
+            (cause.contentChanges.length === 0 ||
+                !this.isRustDocument(cause.document))
+        ) {
            return;
        }
-        const document = cause == null ? editor.document : cause.document;
-        if (!this.isRustDocument(document)) {
-            return;
+        return this.refreshVisibleEditorsHints();
+    }
+
+    private async refreshVisibleEditorsHints(
+        newDecorations?: vscode.DecorationOptions[]
+    ) {
+        const promises: Array<Promise<void>> = [];
+
+        for (const rustEditor of vscode.window.visibleTextEditors.filter(
+            editor => this.isRustDocument(editor.document)
+        )) {
+            if (newDecorations !== undefined) {
+                promises.push(
+                    Promise.resolve(
+                        rustEditor.setDecorations(
+                            typeHintDecorationType,
+                            newDecorations
+                        )
+                    )
+                );
+            } else {
+                promises.push(this.updateDecorationsFromServer(rustEditor));
+            }
        }

-        return await this.updateDecorationsFromServer(
-            document.uri.toString(),
-            editor
-        );
+        for (const promise of promises) {
+            await promise;
+        }
    }

    private isRustDocument(document: vscode.TextDocument): boolean {
@ -76,11 +79,10 @@ export class HintsUpdater {
    }

    private async updateDecorationsFromServer(
-        documentUri: string,
        editor: TextEditor
    ): Promise<void> {
-        const newHints = await this.queryHints(documentUri);
-        if (newHints != null) {
+        const newHints = await this.queryHints(editor.document.uri.toString());
+        if (newHints !== null) {
            const newDecorations = newHints.map(hint => ({
                range: hint.range,
                renderOptions: { after: { contentText: `: ${hint.label}` } }
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@ -151,15 +151,27 @@ export function activate(context: vscode.ExtensionContext) {

    if (Server.config.displayInlayHints) {
        const hintsUpdater = new HintsUpdater();
-        hintsUpdater.loadHints(vscode.window.activeTextEditor).then(() => {
+        hintsUpdater.refreshHintsForVisibleEditors().then(() => {
+            // vscode may ignore top level hintsUpdater.refreshHintsForVisibleEditors()
+            // so update the hints once when the focus changes to guarantee their presence
+            let editorChangeDisposable: vscode.Disposable | null = null;
+            editorChangeDisposable = vscode.window.onDidChangeActiveTextEditor(
+                _ => {
+                    if (editorChangeDisposable !== null) {
+                        editorChangeDisposable.dispose();
+                    }
+                    return hintsUpdater.refreshHintsForVisibleEditors();
+                }
+            );
+
            disposeOnDeactivation(
-                vscode.window.onDidChangeActiveTextEditor(editor =>
-                    hintsUpdater.loadHints(editor)
+                vscode.window.onDidChangeVisibleTextEditors(_ =>
+                    hintsUpdater.refreshHintsForVisibleEditors()
                )
            );
            disposeOnDeactivation(
                vscode.workspace.onDidChangeTextDocument(e =>
-                    hintsUpdater.updateHints(e)
+                    hintsUpdater.refreshHintsForVisibleEditors(e)
                )
            );
            disposeOnDeactivation(