2 files changed, 520 insertions, 541 deletions

diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 04598cd06..455a27e48 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -28,6 +28,7 @@ use crate::{
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct HoverConfig {
     pub implementations: bool,
+    pub references: bool,
     pub run: bool,
     pub debug: bool,
     pub goto_type_def: bool,
@@ -38,6 +39,7 @@ pub struct HoverConfig {
 impl HoverConfig {
     pub const NO_ACTIONS: Self = Self {
         implementations: false,
+        references: false,
         run: false,
         debug: false,
         goto_type_def: false,
@@ -46,7 +48,7 @@ impl HoverConfig {
     };
 
     pub fn any(&self) -> bool {
-        self.implementations || self.runnable() || self.goto_type_def
+        self.implementations || self.references || self.runnable() || self.goto_type_def
     }
 
     pub fn none(&self) -> bool {
@@ -62,6 +64,7 @@ impl HoverConfig {
 pub enum HoverAction {
     Runnable(Runnable),
     Implementation(FilePosition),
+    Reference(FilePosition),
     GoToType(Vec<HoverGotoTypeData>),
 }
 
@@ -148,6 +151,10 @@ pub(crate) fn hover(
                 res.actions.push(action);
             }
 
+            if let Some(action) = show_fn_references_action(db, definition) {
+                res.actions.push(action);
+            }
+
             if let Some(action) = runnable_action(&sema, definition, position.file_id) {
                 res.actions.push(action);
             }
@@ -211,6 +218,18 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
     adt.try_to_nav(db).map(to_action)
 }
 
+fn show_fn_references_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+    match def {
+        Definition::ModuleDef(ModuleDef::Function(it)) => it.try_to_nav(db).map(|nav_target| {
+            HoverAction::Reference(FilePosition {
+                file_id: nav_target.file_id,
+                offset: nav_target.focus_or_full_range().start(),
+            })
+        }),
+        _ => None,
+    }
+}
+
 fn runnable_action(
     sema: &Semantics<RootDatabase>,
     def: Definition,
@@ -2377,6 +2396,14 @@ fn foo_$0test() {}
 "#,
             expect![[r#"
                 [
+                    Reference(
+                        FilePosition {
+                            file_id: FileId(
+                                0,
+                            ),
+                            offset: 11,
+                        },
+                    ),
                     Runnable(
                         Runnable {
                             nav: NavigationTarget {
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index d6dfa0183..821c61403 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -299,9 +299,8 @@ fn should_not_display_type_hint(
                     // Type of expr should be iterable.
                     return it.in_token().is_none() ||
                         it.iterable()
-                            .and_then(|iterable_expr|sema.type_of_expr(&iterable_expr))
-                            .map(|iterable_ty| iterable_ty.is_unknown() || iterable_ty.is_unit())
-                            .unwrap_or(true)
+                            .and_then(|iterable_expr| sema.type_of_expr(&iterable_expr))
+                            .map_or(true, |iterable_ty| iterable_ty.is_unknown() || iterable_ty.is_unit())
                 },
                 _ => (),
             }
@@ -316,11 +315,12 @@ fn should_hide_param_name_hint(
     param_name: &str,
     argument: &ast::Expr,
 ) -> bool {
+    // These are to be tested in the `parameter_hint_heuristics` test
     // hide when:
     // - the parameter name is a suffix of the function's name
     // - the argument is an enum whose name is equal to the parameter
-    // - exact argument<->parameter match(ignoring leading underscore) or argument is a prefix/suffix
-    //   of parameter with _ splitting it off
+    // - exact argument<->parameter match(ignoring leading underscore) or parameter is a prefix/suffix
+    //   of argument with _ splitting it off
     // - param starts with `ra_fixture`
     // - param is a well known name in an unary function
 
@@ -342,23 +342,22 @@ fn should_hide_param_name_hint(
 }
 
 fn is_argument_similar_to_param_name(argument: &ast::Expr, param_name: &str) -> bool {
-    match get_string_representation(argument) {
-        None => false,
-        Some(argument) => {
-            let mut res = false;
-            if let Some(first) = argument.bytes().skip_while(|&c| c == b'_').position(|c| c == b'_')
-            {
-                res |= param_name == argument[..first].trim_start_matches('_');
-            }
-            if let Some(last) =
-                argument.bytes().rev().skip_while(|&c| c == b'_').position(|c| c == b'_')
-            {
-                res |= param_name == argument[last..].trim_end_matches('_');
-            }
-            res |= argument == param_name;
-            res
-        }
+    // check whether param_name and argument are the same or
+    // whether param_name is a prefix/suffix of argument(split at `_`)
+    let argument = match get_string_representation(argument) {
+        Some(argument) => argument,
+        None => return false,
+    };
+
+    let param_name = param_name.trim_start_matches('_');
+    let argument = argument.trim_start_matches('_');
+    if argument.strip_prefix(param_name).map_or(false, |s| s.starts_with('_')) {
+        return true;
     }
+    if argument.strip_suffix(param_name).map_or(false, |s| s.ends_with('_')) {
+        return true;
+    }
+    argument == param_name
 }
 
 /// Hide the parameter name of an unary function if it is a `_` - prefixed suffix of the function's name, or equal.
@@ -397,7 +396,7 @@ fn get_string_representation(expr: &ast::Expr) -> Option<String> {
         ast::Expr::MethodCallExpr(method_call_expr) => {
             let name_ref = method_call_expr.name_ref()?;
             match name_ref.text().as_str() {
-                "clone" => method_call_expr.receiver().map(|rec| rec.to_string()),
+                "clone" | "as_ref" => method_call_expr.receiver().map(|rec| rec.to_string()),
                 name_ref => Some(name_ref.to_owned()),
             }
         }
@@ -451,6 +450,42 @@ mod tests {
         check_with_config(TEST_CONFIG, ra_fixture);
     }
 
+    fn check_params(ra_fixture: &str) {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: true,
+                type_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
+            ra_fixture,
+        );
+    }
+
+    fn check_types(ra_fixture: &str) {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: true,
+                chaining_hints: false,
+                max_length: None,
+            },
+            ra_fixture,
+        );
+    }
+
+    fn check_chains(ra_fixture: &str) {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            ra_fixture,
+        );
+    }
+
     fn check_with_config(config: InlayHintsConfig, ra_fixture: &str) {
         let ra_fixture =
             format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
@@ -471,17 +506,30 @@ mod tests {
     }
 
     #[test]
-    fn param_hints_only() {
+    fn hints_disabled() {
         check_with_config(
             InlayHintsConfig {
-                parameter_hints: true,
                 type_hints: false,
+                parameter_hints: false,
                 chaining_hints: false,
                 max_length: None,
             },
             r#"
 fn foo(a: i32, b: i32) -> i32 { a + b }
 fn main() {
+    let _x = foo(4, 4);
+}"#,
+        );
+    }
+
+    // Parameter hint tests
+
+    #[test]
+    fn param_hints_only() {
+        check_params(
+            r#"
+fn foo(a: i32, b: i32) -> i32 { a + b }
+fn main() {
     let _x = foo(
         4,
       //^ a
@@ -494,13 +542,7 @@ fn main() {
 
     #[test]
     fn param_name_similar_to_fn_name_still_hints() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+        check_params(
             r#"
 fn max(x: i32, y: i32) -> i32 { x + y }
 fn main() {
@@ -516,13 +558,7 @@ fn main() {
 
     #[test]
     fn param_name_similar_to_fn_name() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+        check_params(
             r#"
 fn param_with_underscore(with_underscore: i32) -> i32 { with_underscore }
 fn main() {
@@ -531,17 +567,20 @@ fn main() {
     );
 }"#,
         );
+        check_params(
+            r#"
+fn param_with_underscore(underscore: i32) -> i32 { underscore }
+fn main() {
+    let _x = param_with_underscore(
+        4,
+    );
+}"#,
+        );
     }
 
     #[test]
     fn param_name_same_as_fn_name() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+        check_params(
             r#"
 fn foo(foo: i32) -> i32 { foo }
 fn main() {
@@ -554,52 +593,206 @@ fn main() {
 
     #[test]
     fn never_hide_param_when_multiple_params() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+        check_params(
             r#"
-fn foo(bar: i32, baz: i32) -> i32 { bar + baz }
+fn foo(foo: i32, bar: i32) -> i32 { bar + baz }
 fn main() {
     let _x = foo(
         4,
-      //^ bar
+      //^ foo
         8,
-      //^ baz
+      //^ bar
     );
 }"#,
         );
     }
 
     #[test]
-    fn hints_disabled() {
-        check_with_config(
-            InlayHintsConfig {
-                type_hints: false,
-                parameter_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+    fn param_hints_look_through_as_ref_and_clone() {
+        check_params(
             r#"
-fn foo(a: i32, b: i32) -> i32 { a + b }
+fn foo(bar: i32, baz: f32) {}
+
 fn main() {
-    let _x = foo(4, 4);
+    let bar = 3;
+    let baz = &"baz";
+    let fez = 1.0;
+    foo(bar.clone(), bar.clone());
+                   //^^^^^^^^^^^ baz
+    foo(bar.as_ref(), bar.as_ref());
+                    //^^^^^^^^^^^^ baz
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn self_param_hints() {
+        check_params(
+            r#"
+struct Foo;
+
+impl Foo {
+    fn foo(self: Self) {}
+    fn bar(self: &Self) {}
+}
+
+fn main() {
+    Foo::foo(Foo);
+           //^^^ self
+    Foo::bar(&Foo);
+           //^^^^ self
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn param_name_hints_show_for_literals() {
+        check_params(
+            r#"pub fn test(a: i32, b: i32) -> [i32; 2] { [a, b] }
+fn main() {
+    test(
+        0xa_b,
+      //^^^^^ a
+        0xa_b,
+      //^^^^^ b
+    );
+}"#,
+        )
+    }
+
+    #[test]
+    fn function_call_parameter_hint() {
+        check_params(
+            r#"
+enum Option<T> { None, Some(T) }
+use Option::*;
+
+struct FileId {}
+struct SmolStr {}
+
+struct TextRange {}
+struct SyntaxKind {}
+struct NavigationTarget {}
+
+struct Test {}
+
+impl Test {
+    fn method(&self, mut param: i32) -> i32 { param * 2 }
+
+    fn from_syntax(
+        file_id: FileId,
+        name: SmolStr,
+        focus_range: Option<TextRange>,
+        full_range: TextRange,
+        kind: SyntaxKind,
+        docs: Option<String>,
+    ) -> NavigationTarget {
+        NavigationTarget {}
+    }
+}
+
+fn test_func(mut foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
+    foo + bar
+}
+
+fn main() {
+    let not_literal = 1;
+    let _: i32 = test_func(1,    2,      "hello", 3,  not_literal);
+                         //^ foo ^ bar   ^^^^^^^ msg  ^^^^^^^^^^^ last
+    let t: Test = Test {};
+    t.method(123);
+           //^^^ param
+    Test::method(&t,      3456);
+               //^^ self  ^^^^ param
+    Test::from_syntax(
+        FileId {},
+      //^^^^^^^^^ file_id
+        "impl".into(),
+      //^^^^^^^^^^^^^ name
+        None,
+      //^^^^ focus_range
+        TextRange {},
+      //^^^^^^^^^^^^ full_range
+        SyntaxKind {},
+      //^^^^^^^^^^^^^ kind
+        None,
+      //^^^^ docs
+    );
+}"#,
+        );
+    }
+
+    #[test]
+    fn parameter_hint_heuristics() {
+        check_params(
+            r#"
+fn check(ra_fixture_thing: &str) {}
+
+fn map(f: i32) {}
+fn filter(predicate: i32) {}
+
+fn strip_suffix(suffix: &str) {}
+fn stripsuffix(suffix: &str) {}
+fn same(same: u32) {}
+fn same2(_same2: u32) {}
+
+fn enum_matches_param_name(completion_kind: CompletionKind) {}
+
+fn foo(param: u32) {}
+fn bar(param_eter: u32) {}
+
+enum CompletionKind {
+    Keyword,
+}
+
+fn non_ident_pat((a, b): (u32, u32)) {}
+
+fn main() {
+    check("");
+
+    map(0);
+    filter(0);
+
+    strip_suffix("");
+    stripsuffix("");
+              //^^ suffix
+    same(0);
+    same2(0);
+
+    enum_matches_param_name(CompletionKind::Keyword);
+
+    let param = 0;
+    foo(param);
+    let param_end = 0;
+    foo(param_end);
+    let start_param = 0;
+    foo(start_param);
+    let param2 = 0;
+    foo(param2);
+      //^^^^^^ param
+
+    let param_eter = 0;
+    bar(param_eter);
+    let param_eter_end = 0;
+    bar(param_eter_end);
+    let start_param_eter = 0;
+    bar(start_param_eter);
+    let param_eter2 = 0;
+    bar(param_eter2);
+      //^^^^^^^^^^^ param_eter
+
+    non_ident_pat((0, 0));
 }"#,
         );
     }
 
+    // Type-Hint tests
+
     #[test]
     fn type_hints_only() {
-        check_with_config(
-            InlayHintsConfig {
-                type_hints: true,
-                parameter_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
+        check_types(
             r#"
 fn foo(a: i32, b: i32) -> i32 { a + b }
 fn main() {
@@ -627,8 +820,115 @@ fn main() {
     }
 
     #[test]
+    fn shorten_iterators_in_associated_params() {
+        check_types(
+            r#"
+use core::iter;
+
+pub struct SomeIter<T> {}
+
+impl<T> SomeIter<T> {
+    pub fn new() -> Self { SomeIter {} }
+    pub fn push(&mut self, t: T) {}
+}
+
+impl<T> Iterator for SomeIter<T> {
+    type Item = T;
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
+}
+
+fn main() {
+    let mut some_iter = SomeIter::new();
+      //^^^^^^^^^^^^^ SomeIter<Take<Repeat<i32>>>
+      some_iter.push(iter::repeat(2).take(2));
+    let iter_of_iters = some_iter.take(2);
+      //^^^^^^^^^^^^^ impl Iterator<Item = impl Iterator<Item = i32>>
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn infer_call_method_return_associated_types_with_generic() {
+        check_types(
+            r#"
+            pub trait Default {
+                fn default() -> Self;
+            }
+            pub trait Foo {
+                type Bar: Default;
+            }
+
+            pub fn quux<T: Foo>() -> T::Bar {
+                let y = Default::default();
+                  //^ <T as Foo>::Bar
+
+                y
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn fn_hints() {
+        check_types(
+            r#"
+trait Sized {}
+
+fn foo() -> impl Fn() { loop {} }
+fn foo1() -> impl Fn(f64) { loop {} }
+fn foo2() -> impl Fn(f64, f64) { loop {} }
+fn foo3() -> impl Fn(f64, f64) -> u32 { loop {} }
+fn foo4() -> &'static dyn Fn(f64, f64) -> u32 { loop {} }
+fn foo5() -> &'static dyn Fn(&'static dyn Fn(f64, f64) -> u32, f64) -> u32 { loop {} }
+fn foo6() -> impl Fn(f64, f64) -> u32 + Sized { loop {} }
+fn foo7() -> *const (impl Fn(f64, f64) -> u32 + Sized) { loop {} }
+
+fn main() {
+    let foo = foo();
+     // ^^^ impl Fn()
+    let foo = foo1();
+     // ^^^ impl Fn(f64)
+    let foo = foo2();
+     // ^^^ impl Fn(f64, f64)
+    let foo = foo3();
+     // ^^^ impl Fn(f64, f64) -> u32
+    let foo = foo4();
+     // ^^^ &dyn Fn(f64, f64) -> u32
+    let foo = foo5();
+     // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
+    let foo = foo6();
+     // ^^^ impl Fn(f64, f64) -> u32 + Sized
+    let foo = foo7();
+     // ^^^ *const (impl Fn(f64, f64) -> u32 + Sized)
+}
+"#,
+        )
+    }
+
+    #[test]
+    fn unit_structs_have_no_type_hints() {
+        check_types(
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
+
+struct SyntheticSyntax;
+
+fn main() {
+    match Ok(()) {
+        Ok(_) => (),
+        Err(SyntheticSyntax) => (),
+    }
+}"#,
+        );
+    }
+
+    #[test]
     fn let_statement() {
-        check(
+        check_types(
             r#"
 #[derive(PartialEq)]
 enum Option<T> { None, Some(T) }
@@ -663,34 +963,8 @@ fn main() {
     }
 
     #[test]
-    fn closure_parameters() {
-        check(
-            r#"
-fn main() {
-    let mut start = 0;
-      //^^^^^^^^^ i32
-    (0..2).for_each(|increment| { start += increment; });
-                   //^^^^^^^^^ i32
-
-    let multiply =
-      //^^^^^^^^ |…| -> i32
-      | a,     b| a * b
-      //^ i32  ^ i32
-    ;
-
-    let _: i32 = multiply(1, 2);
-    let multiply_ref = &multiply;
-      //^^^^^^^^^^^^ &|…| -> i32
-
-    let return_42 = || 42;
-      //^^^^^^^^^ || -> i32
-}"#,
-        );
-    }
-
-    #[test]
     fn if_expr() {
-        check(
+        check_types(
             r#"
 enum Option<T> { None, Some(T) }
 use Option::*;
@@ -722,7 +996,7 @@ fn main() {
 
     #[test]
     fn while_expr() {
-        check(
+        check_types(
             r#"
 enum Option<T> { None, Some(T) }
 use Option::*;
@@ -740,7 +1014,7 @@ fn main() {
 
     #[test]
     fn match_arm_list() {
-        check(
+        check_types(
             r#"
 enum Option<T> { None, Some(T) }
 use Option::*;
@@ -761,203 +1035,175 @@ fn main() {
     }
 
     #[test]
-    fn hint_truncation() {
-        check_with_config(
-            InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
+    fn incomplete_for_no_hint() {
+        check_types(
             r#"
-struct Smol<T>(T);
-
-struct VeryLongOuterName<T>(T);
-
 fn main() {
-    let a = Smol(0u32);
-      //^ Smol<u32>
-    let b = VeryLongOuterName(0usize);
-      //^ VeryLongOuterName<…>
-    let c = Smol(Smol(0u32))
-      //^ Smol<Smol<…>>
+    let data = &[1i32, 2, 3];
+      //^^^^ &[i32; 3]
+    for i
 }"#,
         );
-    }
-
-    #[test]
-    fn function_call_parameter_hint() {
         check(
             r#"
-enum Option<T> { None, Some(T) }
-use Option::*;
-
-struct FileId {}
-struct SmolStr {}
-
-struct TextRange {}
-struct SyntaxKind {}
-struct NavigationTarget {}
-
-struct Test {}
-
-impl Test {
-    fn method(&self, mut param: i32) -> i32 { param * 2 }
+pub struct Vec<T> {}
 
-    fn from_syntax(
-        file_id: FileId,
-        name: SmolStr,
-        focus_range: Option<TextRange>,
-        full_range: TextRange,
-        kind: SyntaxKind,
-        docs: Option<String>,
-    ) -> NavigationTarget {
-        NavigationTarget {}
-    }
+impl<T> Vec<T> {
+    pub fn new() -> Self { Vec {} }
+    pub fn push(&mut self, t: T) {}
 }
 
-fn test_func(mut foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
-    foo + bar
+impl<T> IntoIterator for Vec<T> {
+    type Item=T;
 }
 
 fn main() {
-    let not_literal = 1;
-      //^^^^^^^^^^^ i32
-    let _: i32 = test_func(1,    2,      "hello", 3,  not_literal);
-                         //^ foo ^ bar   ^^^^^^^ msg  ^^^^^^^^^^^ last
-    let t: Test = Test {};
-    t.method(123);
-           //^^^ param
-    Test::method(&t,      3456);
-               //^^ self  ^^^^ param
-    Test::from_syntax(
-        FileId {},
-      //^^^^^^^^^ file_id
-        "impl".into(),
-      //^^^^^^^^^^^^^ name
-        None,
-      //^^^^ focus_range
-        TextRange {},
-      //^^^^^^^^^^^^ full_range
-        SyntaxKind {},
-      //^^^^^^^^^^^^^ kind
-        None,
-      //^^^^ docs
-    );
-}"#,
+    let mut data = Vec::new();
+      //^^^^^^^^ Vec<&str>
+    data.push("foo");
+    for i in
+
+    println!("Unit expr");
+}
+"#,
         );
     }
 
     #[test]
-    fn omitted_parameters_hints_heuristics() {
-        check_with_config(
-            InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
+    fn complete_for_hint() {
+        check_types(
             r#"
-fn map(f: i32) {}
-fn filter(predicate: i32) {}
+pub struct Vec<T> {}
 
-struct TestVarContainer {
-    test_var: i32,
+impl<T> Vec<T> {
+    pub fn new() -> Self { Vec {} }
+    pub fn push(&mut self, t: T) {}
 }
 
-impl TestVarContainer {
-    fn test_var(&self) -> i32 {
-        self.test_var
-    }
+impl<T> IntoIterator for Vec<T> {
+    type Item=T;
 }
 
-struct Test {}
-
-impl Test {
-    fn map(self, f: i32) -> Self {
-        self
-    }
-
-    fn filter(self, predicate: i32) -> Self {
-        self
+fn main() {
+    let mut data = Vec::new();
+      //^^^^^^^^ Vec<&str>
+    data.push("foo");
+    for i in data {
+      //^ &str
+      let z = i;
+        //^ &str
     }
-
-    fn field(self, value: i32) -> Self {
-        self
+}
+"#,
+        );
     }
 
-    fn no_hints_expected(&self, _: i32, test_var: i32) {}
+    #[test]
+    fn multi_dyn_trait_bounds() {
+        check_types(
+            r#"
+pub struct Vec<T> {}
 
-    fn frob(&self, frob: bool) {}
+impl<T> Vec<T> {
+    pub fn new() -> Self { Vec {} }
 }
 
-struct Param {}
-
-fn different_order(param: &Param) {}
-fn different_order_mut(param: &mut Param) {}
-fn has_underscore(_param: bool) {}
-fn enum_matches_param_name(completion_kind: CompletionKind) {}
-fn param_destructuring_omitted_1((a, b): (u32, u32)) {}
-fn param_destructuring_omitted_2(TestVarContainer { test_var: _ }: TestVarContainer) {}
-
-fn twiddle(twiddle: bool) {}
-fn doo(_doo: bool) {}
+pub struct Box<T> {}
 
-enum CompletionKind {
-    Keyword,
-}
+trait Display {}
+trait Sync {}
 
 fn main() {
-    let container: TestVarContainer = TestVarContainer { test_var: 42 };
-    let test: Test = Test {};
-
-    map(22);
-    filter(33);
-
-    let test_processed: Test = test.map(1).filter(2).field(3);
+    let _v = Vec::<Box<&(dyn Display + Sync)>>::new();
+      //^^ Vec<Box<&(dyn Display + Sync)>>
+    let _v = Vec::<Box<*const (dyn Display + Sync)>>::new();
+      //^^ Vec<Box<*const (dyn Display + Sync)>>
+    let _v = Vec::<Box<dyn Display + Sync>>::new();
+      //^^ Vec<Box<dyn Display + Sync>>
+}
+"#,
+        );
+    }
 
-    let test_var: i32 = 55;
-    test_processed.no_hints_expected(22, test_var);
-    test_processed.no_hints_expected(33, container.test_var);
-    test_processed.no_hints_expected(44, container.test_var());
-    test_processed.frob(false);
+    #[test]
+    fn shorten_iterator_hints() {
+        check_types(
+            r#"
+use core::iter;
 
-    twiddle(true);
-    doo(true);
+struct MyIter;
 
-    const TWIDDLE_UPPERCASE: bool = true;
-    twiddle(TWIDDLE_UPPERCASE);
+impl Iterator for MyIter {
+    type Item = ();
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
+}
 
-    let mut param_begin: Param = Param {};
-    different_order(&param_begin);
-    different_order(&mut param_begin);
+fn main() {
+    let _x = MyIter;
+      //^^ MyIter
+    let _x = iter::repeat(0);
+      //^^ impl Iterator<Item = i32>
+    fn generic<T: Clone>(t: T) {
+        let _x = iter::repeat(t);
+          //^^ impl Iterator<Item = T>
+        let _chained = iter::repeat(t).take(10);
+          //^^^^^^^^ impl Iterator<Item = T>
+    }
+}
+"#,
+        );
+    }
 
-    let param: bool = true;
-    has_underscore(param);
+    #[test]
+    fn closures() {
+        check(
+            r#"
+fn main() {
+    let mut start = 0;
+      //^^^^^^^^^ i32
+    (0..2).for_each(|increment| { start += increment; });
+                   //^^^^^^^^^ i32
 
-    enum_matches_param_name(CompletionKind::Keyword);
+    let multiply =
+      //^^^^^^^^ |…| -> i32
+      | a,     b| a * b
+      //^ i32  ^ i32
+    ;
 
-    let a: f64 = 7.0;
-    let b: f64 = 4.0;
-    let _: f64 = a.div_euclid(b);
-    let _: f64 = a.abs_sub(b);
+    let _: i32 = multiply(1, 2);
+    let multiply_ref = &multiply;
+      //^^^^^^^^^^^^ &|…| -> i32
 
-    let range: (u32, u32) = (3, 5);
-    param_destructuring_omitted_1(range);
-    param_destructuring_omitted_2(container);
+    let return_42 = || 42;
+      //^^^^^^^^^ || -> i32
 }"#,
         );
     }
 
     #[test]
-    fn unit_structs_have_no_type_hints() {
+    fn hint_truncation() {
         check_with_config(
             InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
             r#"
-enum Result<T, E> { Ok(T), Err(E) }
-use Result::*;
+struct Smol<T>(T);
 
-struct SyntheticSyntax;
+struct VeryLongOuterName<T>(T);
 
 fn main() {
-    match Ok(()) {
-        Ok(_) => (),
-        Err(SyntheticSyntax) => (),
-    }
+    let a = Smol(0u32);
+      //^ Smol<u32>
+    let b = VeryLongOuterName(0usize);
+      //^ VeryLongOuterName<…>
+    let c = Smol(Smol(0u32))
+      //^ Smol<Smol<…>>
 }"#,
         );
     }
 
+    // Chaining hint tests
+
     #[test]
     fn chaining_hints_ignore_comments() {
         check_expect(
@@ -1000,13 +1246,7 @@ fn main() {
 
     #[test]
     fn chaining_hints_without_newlines() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: false,
-                chaining_hints: true,
-                max_length: None,
-            },
+        check_chains(
             r#"
 struct A(B);
 impl A { fn into_b(self) -> B { self.0 } }
@@ -1110,140 +1350,6 @@ fn main() {
     }
 
     #[test]
-    fn incomplete_for_no_hint() {
-        check(
-            r#"
-fn main() {
-    let data = &[1i32, 2, 3];
-      //^^^^ &[i32; 3]
-    for i
-}"#,
-        );
-        check(
-            r#"
-pub struct Vec<T> {}
-
-impl<T> Vec<T> {
-    pub fn new() -> Self { Vec {} }
-    pub fn push(&mut self, t: T) {}
-}
-
-impl<T> IntoIterator for Vec<T> {
-    type Item=T;
-}
-
-fn main() {
-    let mut data = Vec::new();
-      //^^^^^^^^ Vec<&str>
-    data.push("foo");
-    for i in
-
-    println!("Unit expr");
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn complete_for_hint() {
-        check(
-            r#"
-pub struct Vec<T> {}
-
-impl<T> Vec<T> {
-    pub fn new() -> Self { Vec {} }
-    pub fn push(&mut self, t: T) {}
-}
-
-impl<T> IntoIterator for Vec<T> {
-    type Item=T;
-}
-
-fn main() {
-    let mut data = Vec::new();
-      //^^^^^^^^ Vec<&str>
-    data.push("foo");
-    for i in data {
-      //^ &str
-      let z = i;
-        //^ &str
-    }
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn multi_dyn_trait_bounds() {
-        check_with_config(
-            InlayHintsConfig {
-                type_hints: true,
-                parameter_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
-            r#"
-pub struct Vec<T> {}
-
-impl<T> Vec<T> {
-    pub fn new() -> Self { Vec {} }
-}
-
-pub struct Box<T> {}
-
-trait Display {}
-trait Sync {}
-
-fn main() {
-    let _v = Vec::<Box<&(dyn Display + Sync)>>::new();
-      //^^ Vec<Box<&(dyn Display + Sync)>>
-    let _v = Vec::<Box<*const (dyn Display + Sync)>>::new();
-      //^^ Vec<Box<*const (dyn Display + Sync)>>
-    let _v = Vec::<Box<dyn Display + Sync>>::new();
-      //^^ Vec<Box<dyn Display + Sync>>
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn shorten_iterator_hints() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: true,
-                chaining_hints: false,
-                max_length: None,
-            },
-            r#"
-use core::iter;
-
-struct MyIter;
-
-impl Iterator for MyIter {
-    type Item = ();
-    fn next(&mut self) -> Option<Self::Item> {
-        None
-    }
-}
-
-fn main() {
-    let _x = MyIter;
-      //^^ MyIter
-    let _x = iter::repeat(0);
-      //^^ impl Iterator<Item = i32>
-    fn generic<T: Clone>(t: T) {
-        let _x = iter::repeat(t);
-          //^^ impl Iterator<Item = T>
-        let _chained = iter::repeat(t).take(10);
-          //^^^^^^^^ impl Iterator<Item = T>
-    }
-}
-"#,
-        );
-    }
-
-    #[test]
     fn shorten_iterator_chaining_hints() {
         check_expect(
             InlayHintsConfig {
@@ -1298,158 +1404,4 @@ fn main() {
             "#]],
         );
     }
-
-    #[test]
-    fn shorten_iterators_in_associated_params() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: false,
-                type_hints: true,
-                chaining_hints: false,
-                max_length: None,
-            },
-            r#"
-use core::iter;
-
-pub struct SomeIter<T> {}
-
-impl<T> SomeIter<T> {
-    pub fn new() -> Self { SomeIter {} }
-    pub fn push(&mut self, t: T) {}
-}
-
-impl<T> Iterator for SomeIter<T> {
-    type Item = T;
-    fn next(&mut self) -> Option<Self::Item> {
-        None
-    }
-}
-
-fn main() {
-    let mut some_iter = SomeIter::new();
-      //^^^^^^^^^^^^^ SomeIter<Take<Repeat<i32>>>
-      some_iter.push(iter::repeat(2).take(2));
-    let iter_of_iters = some_iter.take(2);
-      //^^^^^^^^^^^^^ impl Iterator<Item = impl Iterator<Item = i32>>
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn hide_param_hints_for_clones() {
-        check_with_config(
-            InlayHintsConfig {
-                parameter_hints: true,
-                type_hints: false,
-                chaining_hints: false,
-                max_length: None,
-            },
-            r#"
-fn foo(bar: i32, baz: String, qux: f32) {}
-
-fn main() {
-    let bar = 3;
-    let baz = &"baz";
-    let fez = 1.0;
-    foo(bar.clone(), baz.clone(), fez.clone());
-                                //^^^^^^^^^^^ qux
-}
-"#,
-        );
-    }
-
-    #[test]
-    fn infer_call_method_return_associated_types_with_generic() {
-        check(
-            r#"
-            pub trait Default {
-                fn default() -> Self;
-            }
-            pub trait Foo {
-                type Bar: Default;
-            }
-
-            pub fn quux<T: Foo>() -> T::Bar {
-                let y = Default::default();
-                  //^ <T as Foo>::Bar
-
-                y
-            }
-            "#,
-        );
-    }
-
-    #[test]
-    fn self_param_hints() {
-        check(
-            r#"
-struct Foo;
-
-impl Foo {
-    fn foo(self: Self) {}
-    fn bar(self: &Self) {}
-}
-
-fn main() {
-    Foo::foo(Foo);
-           //^^^ self
-    Foo::bar(&Foo);
-           //^^^^ self
-}
-"#,
-        )
-    }
-
-    #[test]
-    fn fn_hints() {
-        check(
-            r#"
-trait Sized {}
-
-fn foo() -> impl Fn() { loop {} }
-fn foo1() -> impl Fn(f64) { loop {} }
-fn foo2() -> impl Fn(f64, f64) { loop {} }
-fn foo3() -> impl Fn(f64, f64) -> u32 { loop {} }
-fn foo4() -> &'static dyn Fn(f64, f64) -> u32 { loop {} }
-fn foo5() -> &'static dyn Fn(&'static dyn Fn(f64, f64) -> u32, f64) -> u32 { loop {} }
-fn foo6() -> impl Fn(f64, f64) -> u32 + Sized { loop {} }
-fn foo7() -> *const (impl Fn(f64, f64) -> u32 + Sized) { loop {} }
-
-fn main() {
-    let foo = foo();
-     // ^^^ impl Fn()
-    let foo = foo1();
-     // ^^^ impl Fn(f64)
-    let foo = foo2();
-     // ^^^ impl Fn(f64, f64)
-    let foo = foo3();
-     // ^^^ impl Fn(f64, f64) -> u32
-    let foo = foo4();
-     // ^^^ &dyn Fn(f64, f64) -> u32
-    let foo = foo5();
-     // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
-    let foo = foo6();
-     // ^^^ impl Fn(f64, f64) -> u32 + Sized
-    let foo = foo7();
-     // ^^^ *const (impl Fn(f64, f64) -> u32 + Sized)
-}
-"#,
-        )
-    }
-
-    #[test]
-    fn param_name_hints_show_for_literals() {
-        check(
-            r#"pub fn test(a: i32, b: i32) -> [i32; 2] { [a, b] }
-fn main() {
-    test(
-        0x0fab272b,
-      //^^^^^^^^^^ a
-        0x0fab272b
-      //^^^^^^^^^^ b
-    );
-}"#,
-        )
-    }
 }