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 <matthewjhooper94@gmail.com>

Author: bors[bot]

crates/ra_ide/src/inlay_hints.rs

@@ -5,7 +5,7 @@ use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, SmolStr, TextRange,
+    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange,
 };
 
 use crate::{FileId, FunctionSignature};
@@ -14,19 +14,21 @@ use crate::{FileId, FunctionSignature};
 pub struct InlayHintsOptions {
     pub type_hints: bool,
     pub parameter_hints: bool,
+    pub chaining_hints: bool,
     pub max_length: Option<usize>,
 }
 
 impl Default for InlayHintsOptions {
     fn default() -> Self {
-        Self { type_hints: true, parameter_hints: true, max_length: None }
+        Self { type_hints: true, parameter_hints: true, chaining_hints: true, max_length: None }
     }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum InlayKind {
     TypeHint,
     ParameterHint,
+    ChainingHint,
 }
 
 #[derive(Debug)]
@@ -47,6 +49,10 @@ pub(crate) fn inlay_hints(
 
     let mut res = Vec::new();
     for node in file.syntax().descendants() {
+        if let Some(expr) = ast::Expr::cast(node.clone()) {
+            get_chaining_hints(&mut res, &sema, options, expr);
+        }
+
         match_ast! {
             match node {
                 ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
@@ -59,6 +65,46 @@ pub(crate) fn inlay_hints(
     res
 }
 
+fn get_chaining_hints(
+    acc: &mut Vec<InlayHint>,
+    sema: &Semantics<RootDatabase>,
+    options: &InlayHintsOptions,
+    expr: ast::Expr,
+) -> Option<()> {
+    if !options.chaining_hints {
+        return None;
+    }
+
+    let ty = sema.type_of_expr(&expr)?;
+    if ty.is_unknown() {
+        return None;
+    }
+
+    let mut tokens = expr
+        .syntax()
+        .siblings_with_tokens(Direction::Next)
+        .filter_map(NodeOrToken::into_token)
+        .filter(|t| match t.kind() {
+            SyntaxKind::WHITESPACE if !t.text().contains('\n') => false,
+            SyntaxKind::COMMENT => false,
+            _ => true,
+        });
+
+    // Chaining can be defined as an expression whose next sibling tokens are newline and dot
+    // Ignoring extra whitespace and comments
+    let next = tokens.next()?.kind();
+    let next_next = tokens.next()?.kind();
+    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
+        let label = ty.display_truncated(sema.db, options.max_length).to_string();
+        acc.push(InlayHint {
+            range: expr.syntax().text_range(),
+            kind: InlayKind::ChainingHint,
+            label: label.into(),
+        });
+    }
+    Some(())
+}
+
 fn get_param_name_hints(
     acc: &mut Vec<InlayHint>,
     sema: &Semantics<RootDatabase>,
@@ -238,7 +284,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
         [
             InlayHint {
                 range: [106; 107),
@@ -262,7 +308,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
     }
 
     #[test]
@@ -274,7 +320,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
         [
             InlayHint {
                 range: [97; 99),
@@ -1052,4 +1098,124 @@ fn main() {
         "###
         );
     }
+
+    #[test]
+    fn chaining_hints_ignore_comments() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A(B);
+            impl A { fn into_b(self) -> B { self.0 } }
+            struct B(C);
+            impl B { fn into_c(self) -> C { self.0 } }
+            struct C;
+
+            fn main() {
+                let c = A(B(C))
+                    .into_b() // This is a comment
+                    .into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [232; 269),
+                kind: ChainingHint,
+                label: "B",
+            },
+            InlayHint {
+                range: [232; 239),
+                kind: ChainingHint,
+                label: "A",
+            },
+        ]"###);
+    }
+
+    #[test]
+    fn chaining_hints_without_newlines() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A(B);
+            impl A { fn into_b(self) -> B { self.0 } }
+            struct B(C);
+            impl B { fn into_c(self) -> C { self.0 } }
+            struct C;
+
+            fn main() {
+                let c = A(B(C)).into_b().into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
+    }
+
+    #[test]
+    fn struct_access_chaining_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A { pub b: B }
+            struct B { pub c: C }
+            struct C(pub bool);
+
+            fn main() {
+                let x = A { b: B { c: C(true) } }
+                    .b
+                    .c
+                    .0;
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [150; 221),
+                kind: ChainingHint,
+                label: "C",
+            },
+            InlayHint {
+                range: [150; 198),
+                kind: ChainingHint,
+                label: "B",
+            },
+            InlayHint {
+                range: [150; 175),
+                kind: ChainingHint,
+                label: "A",
+            },
+        ]"###);
+    }
+
+    #[test]
+    fn generic_chaining_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A<T>(T);
+            struct B<T>(T);
+            struct C<T>(T);
+            struct X<T,R>(T, R);
+
+            impl<T> A<T> {
+                fn new(t: T) -> Self { A(t) }
+                fn into_b(self) -> B<T> { B(self.0) }
+            }
+            impl<T> B<T> {
+                fn into_c(self) -> C<T> { C(self.0) }
+            }
+            fn main() {
+                let c = A::new(X(42, true))
+                    .into_b()
+                    .into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [403; 452),
+                kind: ChainingHint,
+                label: "B<X<i32, bool>>",
+            },
+            InlayHint {
+                range: [403; 422),
+                kind: ChainingHint,
+                label: "A<X<i32, bool>>",
+            },
+        ]"###);
+    }
 }

crates/rust-analyzer/src/config.rs

@@ -34,6 +34,8 @@ pub struct ServerConfig {
     pub inlay_hints_type: bool,
     #[serde(deserialize_with = "nullable_bool_true")]
     pub inlay_hints_parameter: bool,
+    #[serde(deserialize_with = "nullable_bool_true")]
+    pub inlay_hints_chaining: bool,
     pub inlay_hints_max_length: Option<usize>,
 
     pub cargo_watch_enable: bool,
@@ -66,6 +68,7 @@ impl Default for ServerConfig {
             lru_capacity: None,
             inlay_hints_type: true,
             inlay_hints_parameter: true,
+            inlay_hints_chaining: true,
             inlay_hints_max_length: None,
             cargo_watch_enable: true,
             cargo_watch_args: Vec::new(),

crates/rust-analyzer/src/conv.rs

@@ -332,6 +332,7 @@ impl ConvWith<&LineIndex> for InlayHint {
             kind: match self.kind {
                 InlayKind::ParameterHint => req::InlayKind::ParameterHint,
                 InlayKind::TypeHint => req::InlayKind::TypeHint,
+                InlayKind::ChainingHint => req::InlayKind::ChainingHint,
             },
         }
     }

crates/rust-analyzer/src/main_loop.rs

@@ -183,6 +183,7 @@ pub fn main_loop(
                 inlay_hints: InlayHintsOptions {
                     type_hints: config.inlay_hints_type,
                     parameter_hints: config.inlay_hints_parameter,
+                    chaining_hints: config.inlay_hints_chaining,
                     max_length: config.inlay_hints_max_length,
                 },
                 cargo_watch: CheckOptions {

crates/rust-analyzer/src/req.rs

@@ -200,6 +200,7 @@ pub struct InlayHintsParams {
 pub enum InlayKind {
     TypeHint,
     ParameterHint,
+    ChainingHint,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

docs/user/features.md

@@ -185,13 +185,15 @@ These contain extended information on the hovered language item.
 Two types of inlay hints are displayed currently:
 
 * type hints, displaying the minimal information on the type of the expression (if the information is available)
+* method chaining hints, type information for multi-line method chains
 * parameter name hints, displaying the names of the parameters in the corresponding methods
 
 #### VS Code
 
 In VS Code, the following settings can be used to configure the inlay hints:
 
 * `rust-analyzer.inlayHints.typeHints` - enable hints for inferred types.
+* `rust-analyzer.inlayHints.chainingHints` - enable hints for inferred types on method chains.
 * `rust-analyzer.inlayHints.parameterHints` - enable hints for function parameters.
 * `rust-analyzer.inlayHints.maxLength` — shortens the hints if their length exceeds the value specified. If no value is specified (`null`), no shortening is applied.
 

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,

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,

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")!,
         };
     }