use hir::{Adt, HirDisplay, Semantics, Type}; use ra_ide_db::RootDatabase; use ra_prof::profile; use ra_syntax::{ ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner}, match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange, }; use crate::{FileId, FunctionSignature}; use stdx::to_lower_snake_case; #[derive(Clone, Debug, PartialEq, Eq)] pub struct InlayHintsConfig { pub type_hints: bool, pub parameter_hints: bool, pub chaining_hints: bool, pub max_length: Option, } impl Default for InlayHintsConfig { fn default() -> Self { 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)] pub struct InlayHint { pub range: TextRange, pub kind: InlayKind, pub label: SmolStr, } // Feature: Inlay Hints // // rust-analyzer shows additional information inline with the source code. // Editors usually render this using read-only virtual text snippets interspersed with code. // // rust-analyzer shows hits for // // * types of local variables // * names of function arguments // * types of chained expressions // // **Note:** VS Code does not have native support for inlay hints https://github.com/microsoft/vscode/issues/16221[yet] and the hints are implemented using decorations. // This approach has limitations, the caret movement and bracket highlighting near the edges of the hint may be weird: // https://github.com/rust-analyzer/rust-analyzer/issues/1623[1], https://github.com/rust-analyzer/rust-analyzer/issues/3453[2]. // // |=== // | Editor | Action Name // // | VS Code | **Rust Analyzer: Toggle inlay hints* // |=== pub(crate) fn inlay_hints( db: &RootDatabase, file_id: FileId, config: &InlayHintsConfig, ) -> Vec { let _p = profile("inlay_hints"); let sema = Semantics::new(db); let file = sema.parse(file_id); 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, config, expr); } match_ast! { match node { ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); }, ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); }, ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, config, it); }, _ => (), } } } res } fn get_chaining_hints( acc: &mut Vec, sema: &Semantics, config: &InlayHintsConfig, expr: ast::Expr, ) -> Option<()> { if !config.chaining_hints { return None; } if matches!(expr, ast::Expr::RecordLit(_)) { 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 ty = sema.type_of_expr(&expr)?; if ty.is_unknown() { return None; } if matches!(expr, ast::Expr::PathExpr(_)) { if let Some(Adt::Struct(st)) = ty.as_adt() { if st.fields(sema.db).is_empty() { return None; } } } let label = ty.display_truncated(sema.db, config.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, sema: &Semantics, config: &InlayHintsConfig, expr: ast::Expr, ) -> Option<()> { if !config.parameter_hints { return None; } let args = match &expr { ast::Expr::CallExpr(expr) => expr.arg_list()?.args(), ast::Expr::MethodCallExpr(expr) => expr.arg_list()?.args(), _ => return None, }; let fn_signature = get_fn_signature(sema, &expr)?; let n_params_to_skip = if fn_signature.has_self_param && matches!(&expr, ast::Expr::MethodCallExpr(_)) { 1 } else { 0 }; let hints = fn_signature .parameter_names .iter() .skip(n_params_to_skip) .zip(args) .filter(|(param, arg)| should_show_param_name_hint(sema, &fn_signature, param, &arg)) .map(|(param_name, arg)| InlayHint { range: arg.syntax().text_range(), kind: InlayKind::ParameterHint, label: param_name.into(), }); acc.extend(hints); Some(()) } fn get_bind_pat_hints( acc: &mut Vec, sema: &Semantics, config: &InlayHintsConfig, pat: ast::BindPat, ) -> Option<()> { if !config.type_hints { return None; } let ty = sema.type_of_pat(&pat.clone().into())?; if should_not_display_type_hint(sema.db, &pat, &ty) { return None; } acc.push(InlayHint { range: pat.syntax().text_range(), kind: InlayKind::TypeHint, label: ty.display_truncated(sema.db, config.max_length).to_string().into(), }); Some(()) } fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool { if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() { let pat_text = bind_pat.to_string(); enum_data .variants(db) .into_iter() .map(|variant| variant.name(db).to_string()) .any(|enum_name| enum_name == pat_text) } else { false } } fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool { if pat_ty.is_unknown() { 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.to_string() { return true; } } for node in bind_pat.syntax().ancestors() { match_ast! { match node { ast::LetStmt(it) => { return it.ascribed_type().is_some() }, ast::Param(it) => { return it.ascribed_type().is_some() }, ast::MatchArm(_it) => { return pat_is_enum_variant(db, bind_pat, pat_ty); }, ast::IfExpr(it) => { return it.condition().and_then(|condition| condition.pat()).is_some() && pat_is_enum_variant(db, bind_pat, pat_ty); }, ast::WhileExpr(it) => { return it.condition().and_then(|condition| condition.pat()).is_some() && pat_is_enum_variant(db, bind_pat, pat_ty); }, _ => (), } } } false } fn should_show_param_name_hint( sema: &Semantics, fn_signature: &FunctionSignature, param_name: &str, argument: &ast::Expr, ) -> bool { let param_name = param_name.trim_start_matches('_'); if param_name.is_empty() || Some(param_name) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_')) || is_argument_similar_to_param_name(sema, argument, param_name) { return false; } let parameters_len = if fn_signature.has_self_param { fn_signature.parameters.len() - 1 } else { fn_signature.parameters.len() }; // avoid displaying hints for common functions like map, filter, etc. // or other obvious words used in std parameters_len != 1 || !is_obvious_param(param_name) } fn is_argument_similar_to_param_name( sema: &Semantics, argument: &ast::Expr, param_name: &str, ) -> bool { if is_enum_name_similar_to_param_name(sema, argument, param_name) { return true; } match get_string_representation(argument) { None => false, Some(repr) => { let argument_string = repr.trim_start_matches('_'); argument_string.starts_with(param_name) || argument_string.ends_with(param_name) } } } fn is_enum_name_similar_to_param_name( sema: &Semantics, argument: &ast::Expr, param_name: &str, ) -> bool { match sema.type_of_expr(argument).and_then(|t| t.as_adt()) { Some(Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name, _ => false, } } fn get_string_representation(expr: &ast::Expr) -> Option { match expr { ast::Expr::MethodCallExpr(method_call_expr) => { Some(method_call_expr.name_ref()?.to_string()) } ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?), _ => Some(expr.to_string()), } } fn is_obvious_param(param_name: &str) -> bool { let is_obvious_param_name = match param_name { "predicate" | "value" | "pat" | "rhs" | "other" => true, _ => false, }; param_name.len() == 1 || is_obvious_param_name } fn get_fn_signature(sema: &Semantics, expr: &ast::Expr) -> Option { match expr { ast::Expr::CallExpr(expr) => { // FIXME: Type::as_callable is broken for closures let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?; match callable_def { hir::CallableDef::FunctionId(it) => { Some(FunctionSignature::from_hir(sema.db, it.into())) } hir::CallableDef::StructId(it) => { FunctionSignature::from_struct(sema.db, it.into()) } hir::CallableDef::EnumVariantId(it) => { FunctionSignature::from_enum_variant(sema.db, it.into()) } } } ast::Expr::MethodCallExpr(expr) => { let fn_def = sema.resolve_method_call(&expr)?; Some(FunctionSignature::from_hir(sema.db, fn_def)) } _ => None, } } #[cfg(test)] mod tests { use crate::inlay_hints::InlayHintsConfig; use insta::assert_debug_snapshot; use crate::mock_analysis::single_file; #[test] fn param_hints_only() { let (analysis, file_id) = single_file( r#" fn foo(a: i32, b: i32) -> i32 { a + b } fn main() { let _x = foo(4, 4); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###" [ InlayHint { range: 69..70, kind: ParameterHint, label: "a", }, InlayHint { range: 72..73, kind: ParameterHint, label: "b", }, ] "###); } #[test] fn hints_disabled() { let (analysis, file_id) = single_file( r#" fn foo(a: i32, b: i32) -> i32 { a + b } fn main() { let _x = foo(4, 4); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###); } #[test] fn type_hints_only() { let (analysis, file_id) = single_file( r#" fn foo(a: i32, b: i32) -> i32 { a + b } fn main() { let _x = foo(4, 4); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###" [ InlayHint { range: 60..62, kind: TypeHint, label: "i32", }, ] "###); } #[test] fn default_generic_types_should_not_be_displayed() { let (analysis, file_id) = single_file( r#" struct Test { k: K, t: T, } fn main() { let zz = Test { t: 23u8, k: 33 }; let zz_ref = &zz; }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 68..70, kind: TypeHint, label: "Test", }, InlayHint { range: 106..112, kind: TypeHint, label: "&Test", }, ] "### ); } #[test] fn let_statement() { let (analysis, file_id) = single_file( r#" #[derive(PartialEq)] enum CustomOption { None, Some(T), } #[derive(PartialEq)] struct Test { a: CustomOption, b: u8, } fn main() { struct InnerStruct {} let test = 54; let test: i32 = 33; let mut test = 33; let _ = 22; let test = "test"; let test = InnerStruct {}; let test = vec![222]; let test: Vec<_> = (0..3).collect(); let test = (0..3).collect::>(); let test = (0..3).collect::>(); let mut test = Vec::new(); test.push(333); let test = (42, 'a'); let (a, (b, c, (d, e), f)) = (2, (3, 4, (6.6, 7.7), 5)); let &x = &92; }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 192..196, kind: TypeHint, label: "i32", }, InlayHint { range: 235..243, kind: TypeHint, label: "i32", }, InlayHint { range: 274..278, kind: TypeHint, label: "&str", }, InlayHint { range: 538..542, kind: TypeHint, label: "(i32, char)", }, InlayHint { range: 565..566, kind: TypeHint, label: "i32", }, InlayHint { range: 569..570, kind: TypeHint, label: "i32", }, InlayHint { range: 572..573, kind: TypeHint, label: "i32", }, InlayHint { range: 576..577, kind: TypeHint, label: "f64", }, InlayHint { range: 579..580, kind: TypeHint, label: "f64", }, InlayHint { range: 583..584, kind: TypeHint, label: "i32", }, InlayHint { range: 626..627, kind: TypeHint, label: "i32", }, ] "### ); } #[test] fn closure_parameters() { let (analysis, file_id) = single_file( r#" fn main() { let mut start = 0; (0..2).for_each(|increment| { start += increment; }); let multiply = |a, b, c, d| a * b * c * d; let _: i32 = multiply(1, 2, 3, 4); let multiply_ref = &multiply; let return_42 = || 42; }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 20..29, kind: TypeHint, label: "i32", }, InlayHint { range: 56..65, kind: TypeHint, label: "i32", }, InlayHint { range: 114..122, kind: TypeHint, label: "|…| -> i32", }, InlayHint { range: 126..127, kind: TypeHint, label: "i32", }, InlayHint { range: 129..130, kind: TypeHint, label: "i32", }, InlayHint { range: 132..133, kind: TypeHint, label: "i32", }, InlayHint { range: 135..136, kind: TypeHint, label: "i32", }, InlayHint { range: 200..212, kind: TypeHint, label: "&|…| -> i32", }, InlayHint { range: 235..244, kind: TypeHint, label: "|| -> i32", }, ] "### ); } #[test] fn for_expression() { let (analysis, file_id) = single_file( r#" fn main() { let mut start = 0; for increment in 0..2 { start += increment; } }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 20..29, kind: TypeHint, label: "i32", }, InlayHint { range: 43..52, kind: TypeHint, label: "i32", }, ] "### ); } #[test] fn if_expr() { let (analysis, file_id) = single_file( r#" #[derive(PartialEq)] enum CustomOption { None, Some(T), } #[derive(PartialEq)] struct Test { a: CustomOption, b: u8, } use CustomOption::*; fn main() { let test = Some(Test { a: Some(3), b: 1 }); if let None = &test {}; if let test = &test {}; if let Some(test) = &test {}; if let Some(Test { a, b }) = &test {}; if let Some(Test { a: x, b: y }) = &test {}; if let Some(Test { a: Some(x), b: y }) = &test {}; if let Some(Test { a: None, b: y }) = &test {}; if let Some(Test { b: y, .. }) = &test {}; if test == None {} }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 187..191, kind: TypeHint, label: "CustomOption", }, InlayHint { range: 266..270, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 299..303, kind: TypeHint, label: "&Test", }, InlayHint { range: 340..341, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 343..344, kind: TypeHint, label: "&u8", }, InlayHint { range: 386..387, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 392..393, kind: TypeHint, label: "&u8", }, InlayHint { range: 440..441, kind: TypeHint, label: "&u32", }, InlayHint { range: 447..448, kind: TypeHint, label: "&u8", }, InlayHint { range: 499..500, kind: TypeHint, label: "&u8", }, InlayHint { range: 542..543, kind: TypeHint, label: "&u8", }, ] "### ); } #[test] fn while_expr() { let (analysis, file_id) = single_file( r#" #[derive(PartialEq)] enum CustomOption { None, Some(T), } #[derive(PartialEq)] struct Test { a: CustomOption, b: u8, } use CustomOption::*; fn main() { let test = Some(Test { a: Some(3), b: 1 }); while let None = &test {}; while let test = &test {}; while let Some(test) = &test {}; while let Some(Test { a, b }) = &test {}; while let Some(Test { a: x, b: y }) = &test {}; while let Some(Test { a: Some(x), b: y }) = &test {}; while let Some(Test { a: None, b: y }) = &test {}; while let Some(Test { b: y, .. }) = &test {}; while test == None {} }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 187..191, kind: TypeHint, label: "CustomOption", }, InlayHint { range: 272..276, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 308..312, kind: TypeHint, label: "&Test", }, InlayHint { range: 352..353, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 355..356, kind: TypeHint, label: "&u8", }, InlayHint { range: 401..402, kind: TypeHint, label: "&CustomOption", }, InlayHint { range: 407..408, kind: TypeHint, label: "&u8", }, InlayHint { range: 458..459, kind: TypeHint, label: "&u32", }, InlayHint { range: 465..466, kind: TypeHint, label: "&u8", }, InlayHint { range: 520..521, kind: TypeHint, label: "&u8", }, InlayHint { range: 566..567, kind: TypeHint, label: "&u8", }, ] "### ); } #[test] fn match_arm_list() { let (analysis, file_id) = single_file( r#" #[derive(PartialEq)] enum CustomOption { None, Some(T), } #[derive(PartialEq)] struct Test { a: CustomOption, b: u8, } use CustomOption::*; fn main() { match Some(Test { a: Some(3), b: 1 }) { None => (), test => (), Some(test) => (), Some(Test { a, b }) => (), Some(Test { a: x, b: y }) => (), Some(Test { a: Some(x), b: y }) => (), Some(Test { a: None, b: y }) => (), Some(Test { b: y, .. }) => (), _ => {} } }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 251..255, kind: TypeHint, label: "CustomOption", }, InlayHint { range: 276..280, kind: TypeHint, label: "Test", }, InlayHint { range: 309..310, kind: TypeHint, label: "CustomOption", }, InlayHint { range: 312..313, kind: TypeHint, label: "u8", }, InlayHint { range: 347..348, kind: TypeHint, label: "CustomOption", }, InlayHint { range: 353..354, kind: TypeHint, label: "u8", }, InlayHint { range: 393..394, kind: TypeHint, label: "u32", }, InlayHint { range: 400..401, kind: TypeHint, label: "u8", }, InlayHint { range: 444..445, kind: TypeHint, label: "u8", }, InlayHint { range: 479..480, kind: TypeHint, label: "u8", }, ] "### ); } #[test] fn hint_truncation() { let (analysis, file_id) = single_file( r#" struct Smol(T); struct VeryLongOuterName(T); fn main() { let a = Smol(0u32); let b = VeryLongOuterName(0usize); let c = Smol(Smol(0u32)) }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###" [ InlayHint { range: 73..74, kind: TypeHint, label: "Smol", }, InlayHint { range: 97..98, kind: TypeHint, label: "VeryLongOuterName<…>", }, InlayHint { range: 136..137, kind: TypeHint, label: "Smol>", }, ] "### ); } #[test] fn function_call_parameter_hint() { let (analysis, file_id) = single_file( r#" enum CustomOption { None, Some(T), } use CustomOption::*; struct FileId {} struct SmolStr {} impl From<&str> for SmolStr { fn from(_: &str) -> Self { unimplemented!() } } 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: CustomOption, full_range: TextRange, kind: SyntaxKind, docs: CustomOption, description: CustomOption, ) -> 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); let t: Test = Test {}; t.method(123); Test::method(&t, 3456); Test::from_syntax( FileId {}, "impl".into(), None, TextRange {}, SyntaxKind {}, None, None, ); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###" [ InlayHint { range: 797..808, kind: TypeHint, label: "i32", }, InlayHint { range: 841..842, kind: ParameterHint, label: "foo", }, InlayHint { range: 844..845, kind: ParameterHint, label: "bar", }, InlayHint { range: 847..854, kind: ParameterHint, label: "msg", }, InlayHint { range: 859..870, kind: ParameterHint, label: "last", }, InlayHint { range: 913..916, kind: ParameterHint, label: "param", }, InlayHint { range: 936..938, kind: ParameterHint, label: "&self", }, InlayHint { range: 940..944, kind: ParameterHint, label: "param", }, InlayHint { range: 979..988, kind: ParameterHint, label: "file_id", }, InlayHint { range: 998..1011, kind: ParameterHint, label: "name", }, InlayHint { range: 1021..1025, kind: ParameterHint, label: "focus_range", }, InlayHint { range: 1035..1047, kind: ParameterHint, label: "full_range", }, InlayHint { range: 1057..1070, kind: ParameterHint, label: "kind", }, InlayHint { range: 1080..1084, kind: ParameterHint, label: "docs", }, InlayHint { range: 1094..1098, kind: ParameterHint, label: "description", }, ] "### ); } #[test] fn omitted_parameters_hints_heuristics() { let (analysis, file_id) = single_file( r#" fn map(f: i32) {} fn filter(predicate: i32) {} struct TestVarContainer { test_var: i32, } impl TestVarContainer { fn test_var(&self) -> i32 { self.test_var } } struct Test {} impl Test { fn map(self, f: i32) -> Self { self } fn filter(self, predicate: i32) -> Self { self } fn field(self, value: i32) -> Self { self } fn no_hints_expected(&self, _: i32, test_var: i32) {} fn frob(&self, frob: bool) {} } 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 twiddle(twiddle: bool) {} fn doo(_doo: bool) {} enum CompletionKind { Keyword, } 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 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); twiddle(true); doo(true); let mut param_begin: Param = Param {}; different_order(¶m_begin); different_order(&mut param_begin); let param: bool = true; has_underscore(param); enum_matches_param_name(CompletionKind::Keyword); let a: f64 = 7.0; let b: f64 = 4.0; let _: f64 = a.div_euclid(b); let _: f64 = a.abs_sub(b); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###" [] "### ); } #[test] fn unit_structs_have_no_type_hints() { let (analysis, file_id) = single_file( r#" enum CustomResult { Ok(T), Err(E), } use CustomResult::*; struct SyntheticSyntax; fn main() { match Ok(()) { Ok(_) => (), Err(SyntheticSyntax) => (), } }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###" [] "### ); } #[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, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###" [ InlayHint { range: 147..172, kind: ChainingHint, label: "B", }, InlayHint { range: 147..154, 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, &InlayHintsConfig{ 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); struct D; impl D { fn foo(&self) -> i32 { 42 } } fn main() { let x = A { b: B { c: C(true) } } .b .c .0; let x = D .foo(); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###" [ InlayHint { range: 143..190, kind: ChainingHint, label: "C", }, InlayHint { range: 143..179, kind: ChainingHint, label: "B", }, ] "###); } #[test] fn generic_chaining_hints() { let (analysis, file_id) = single_file( r#" struct A(T); struct B(T); struct C(T); struct X(T, R); impl A { fn new(t: T) -> Self { A(t) } fn into_b(self) -> B { B(self.0) } } impl B { fn into_c(self) -> C { C(self.0) } } fn main() { let c = A::new(X(42, true)) .into_b() .into_c(); }"#, ); assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###" [ InlayHint { range: 246..283, kind: ChainingHint, label: "B>", }, InlayHint { range: 246..265, kind: ChainingHint, label: "A>", }, ] "###); } }