Merge #3710

3710: Inlay hints for method chaining pattern r=matklad a=M-J-Hooper

This PR adds inlay hints on method call chains:
![image](https://user-images.githubusercontent.com/13765376/77472008-8dc2a880-6e13-11ea-9c18-2c2e2b809799.png)

It is not only explicit `MethodCall`s where this can be helpful. The heuristic used here is that whenever any expression is followed by a new line and then a dot, it resembles a call chain and type information can be  #useful.

Changes:
- A new `InlayKind` for chaining.
- New option for disabling this type of hints.
- Tree traversal rules for identifying the chaining hints.
- VSCode decorators in the extension layer (and associated types).

Notes:
- IntelliJ has additional rules and configuration on this topic. Eg. minimum length of chain to start displaying hints and only displaying distinct types in the chain.
- I am checking for chaining on every `ast::Expr` in the tree; Are there performance concerns there?

This is my first contribution (to RA and to Rust in general) so would appreciate any feedback.
The only issue I can find the references this feature is #2741.

Co-authored-by: Matt Hooper <[email protected]>

5 files changed, 39 insertions, 4 deletions

diff --git a/editors/code/package.json b/editors/code/package.json
index 1d113ebb6..37e083220 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -333,6 +333,11 @@
                     "default": true,
                     "description": "Whether to show inlay type hints"
                 },
+                "rust-analyzer.inlayHints.chainingHints": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to show inlay type hints for method chains"
+                },
                 "rust-analyzer.inlayHints.parameterHints": {
                     "type": "boolean",
                     "default": true,
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 82ca749f3..98f2f232f 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -32,6 +32,7 @@ export async function createClient(config: Config, serverPath: string): Promise<
 
             inlayHintsType: config.inlayHints.typeHints,
             inlayHintsParameter: config.inlayHints.parameterHints,
+            inlayHintsChaining: config.inlayHints.chainingHints,
             inlayHintsMaxLength: config.inlayHints.maxLength,
 
             cargoWatchEnable: cargoWatchOpts.enable,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 7668c20b7..637aea27d 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -88,6 +88,7 @@ export class Config {
         return {
             typeHints: this.cfg.get<boolean>("inlayHints.typeHints")!,
             parameterHints: this.cfg.get<boolean>("inlayHints.parameterHints")!,
+            chainingHints: this.cfg.get<boolean>("inlayHints.chainingHints")!,
             maxLength: this.cfg.get<null | number>("inlayHints.maxLength")!,
         };
     }
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 17d0dfa33..542d1f367 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -10,7 +10,11 @@ export function activateInlayHints(ctx: Ctx) {
     const maybeUpdater = {
         updater: null as null | HintsUpdater,
         onConfigChange() {
-            if (!ctx.config.inlayHints.typeHints && !ctx.config.inlayHints.parameterHints) {
+            if (
+                !ctx.config.inlayHints.typeHints &&
+                !ctx.config.inlayHints.parameterHints &&
+                !ctx.config.inlayHints.chainingHints
+            ) {
                 return this.dispose();
             }
             if (!this.updater) this.updater = new HintsUpdater(ctx);
@@ -63,6 +67,22 @@ const paramHints = {
     }
 };
 
+const chainingHints = {
+    decorationType: vscode.window.createTextEditorDecorationType({
+        after: {
+            color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            fontStyle: "normal",
+        }
+    }),
+
+    toDecoration(hint: ra.InlayHint.ChainingHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
+        return {
+            range: conv.asRange(hint.range),
+            renderOptions: { after: { contentText: ` ${hint.label}` } }
+        };
+    }
+};
+
 class HintsUpdater implements Disposable {
     private sourceFiles = new Map<string, RustSourceFile>(); // map Uri -> RustSourceFile
     private readonly disposables: Disposable[] = [];
@@ -95,7 +115,7 @@ class HintsUpdater implements Disposable {
 
     dispose() {
         this.sourceFiles.forEach(file => file.inlaysRequest?.cancel());
-        this.ctx.visibleRustEditors.forEach(editor => this.renderDecorations(editor, { param: [], type: [] }));
+        this.ctx.visibleRustEditors.forEach(editor => this.renderDecorations(editor, { param: [], type: [], chaining: [] }));
         this.disposables.forEach(d => d.dispose());
     }
 
@@ -154,10 +174,11 @@ class HintsUpdater implements Disposable {
     private renderDecorations(editor: RustEditor, decorations: InlaysDecorations) {
         editor.setDecorations(typeHints.decorationType, decorations.type);
         editor.setDecorations(paramHints.decorationType, decorations.param);
+        editor.setDecorations(chainingHints.decorationType, decorations.chaining);
     }
 
     private hintsToDecorations(hints: ra.InlayHint[]): InlaysDecorations {
-        const decorations: InlaysDecorations = { type: [], param: [] };
+        const decorations: InlaysDecorations = { type: [], param: [], chaining: [] };
         const conv = this.ctx.client.protocol2CodeConverter;
 
         for (const hint of hints) {
@@ -170,6 +191,10 @@ class HintsUpdater implements Disposable {
                     decorations.param.push(paramHints.toDecoration(hint, conv));
                     continue;
                 }
+                case ra.InlayHint.Kind.ChainingHint: {
+                    decorations.chaining.push(chainingHints.toDecoration(hint, conv));
+                    continue;
+                }
             }
         }
         return decorations;
@@ -196,6 +221,7 @@ class HintsUpdater implements Disposable {
 interface InlaysDecorations {
     type: vscode.DecorationOptions[];
     param: vscode.DecorationOptions[];
+    chaining: vscode.DecorationOptions[];
 }
 
 interface RustSourceFile {
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
index 9846f7343..400ac3714 100644
--- a/editors/code/src/rust-analyzer-api.ts
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -86,12 +86,13 @@ export interface Runnable {
 }
 export const runnables = request<RunnablesParams, Vec<Runnable>>("runnables");
 
-export type InlayHint = InlayHint.TypeHint | InlayHint.ParamHint;
+export type InlayHint = InlayHint.TypeHint | InlayHint.ParamHint | InlayHint.ChainingHint;
 
 export namespace InlayHint {
     export const enum Kind {
         TypeHint = "TypeHint",
         ParamHint = "ParameterHint",
+        ChainingHint = "ChainingHint",
     }
     interface Common {
         range: lc.Range;
@@ -99,6 +100,7 @@ export namespace InlayHint {
     }
     export type TypeHint = Common & { kind: Kind.TypeHint };
     export type ParamHint = Common & { kind: Kind.ParamHint };
+    export type ChainingHint = Common & { kind: Kind.ChainingHint };
 }
 export interface InlayHintsParams {
     textDocument: lc.TextDocumentIdentifier;