use crate::RootDatabase; use base_db::{fixture::ChangeFixture, FilePosition}; use expect_test::{expect, Expect}; use test_utils::{mark, RangeOrOffset}; /// Creates analysis from a multi-file fixture, returns positions marked with <|>. pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) { let change_fixture = ChangeFixture::parse(ra_fixture); let mut database = RootDatabase::default(); database.apply_change(change_fixture.change); let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker (<|>)"); let offset = match range_or_offset { RangeOrOffset::Range(_) => panic!(), RangeOrOffset::Offset(it) => it, }; (database, FilePosition { file_id, offset }) } fn check(ra_fixture: &str, expect: Expect) { let (db, position) = position(ra_fixture); let call_info = crate::call_info::call_info(&db, position); let actual = match call_info { Some(call_info) => { let docs = match &call_info.doc { None => "".to_string(), Some(docs) => format!("{}\n------\n", docs.as_str()), }; let params = call_info .parameter_labels() .enumerate() .map(|(i, param)| { if Some(i) == call_info.active_parameter { format!("<{}>", param) } else { param.to_string() } }) .collect::>() .join(", "); format!("{}{}\n({})\n", docs, call_info.signature, params) } None => String::new(), }; expect.assert_eq(&actual); } #[test] fn test_fn_signature_two_args() { check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo(<|>3, ); } "#, expect![[r#" fn foo(x: u32, y: u32) -> u32 (, y: u32) "#]], ); check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo(3<|>, ); } "#, expect![[r#" fn foo(x: u32, y: u32) -> u32 (, y: u32) "#]], ); check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo(3,<|> ); } "#, expect![[r#" fn foo(x: u32, y: u32) -> u32 (x: u32, ) "#]], ); check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo(3, <|>); } "#, expect![[r#" fn foo(x: u32, y: u32) -> u32 (x: u32, ) "#]], ); } #[test] fn test_fn_signature_two_args_empty() { check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo(<|>); } "#, expect![[r#" fn foo(x: u32, y: u32) -> u32 (, y: u32) "#]], ); } #[test] fn test_fn_signature_two_args_first_generics() { check( r#" fn foo(x: T, y: U) -> u32 where T: Copy + Display, U: Debug { x + y } fn bar() { foo(<|>3, ); } "#, expect![[r#" fn foo(x: i32, y: {unknown}) -> u32 (, y: {unknown}) "#]], ); } #[test] fn test_fn_signature_no_params() { check( r#" fn foo() -> T where T: Copy + Display {} fn bar() { foo(<|>); } "#, expect![[r#" fn foo() -> {unknown} () "#]], ); } #[test] fn test_fn_signature_for_impl() { check( r#" struct F; impl F { pub fn new() { } } fn bar() { let _ : F = F::new(<|>); } "#, expect![[r#" fn new() () "#]], ); } #[test] fn test_fn_signature_for_method_self() { check( r#" struct S; impl S { pub fn do_it(&self) {} } fn bar() { let s: S = S; s.do_it(<|>); } "#, expect![[r#" fn do_it(&self) () "#]], ); } #[test] fn test_fn_signature_for_method_with_arg() { check( r#" struct S; impl S { fn foo(&self, x: i32) {} } fn main() { S.foo(<|>); } "#, expect![[r#" fn foo(&self, x: i32) () "#]], ); } #[test] fn test_fn_signature_for_method_with_arg_as_assoc_fn() { check( r#" struct S; impl S { fn foo(&self, x: i32) {} } fn main() { S::foo(<|>); } "#, expect![[r#" fn foo(self: &S, x: i32) (, x: i32) "#]], ); } #[test] fn test_fn_signature_with_docs_simple() { check( r#" /// test // non-doc-comment fn foo(j: u32) -> u32 { j } fn bar() { let _ = foo(<|>); } "#, expect![[r#" test ------ fn foo(j: u32) -> u32 () "#]], ); } #[test] fn test_fn_signature_with_docs() { check( r#" /// Adds one to the number given. /// /// # Examples /// /// ``` /// let five = 5; /// /// assert_eq!(6, my_crate::add_one(5)); /// ``` pub fn add_one(x: i32) -> i32 { x + 1 } pub fn do() { add_one(<|> }"#, expect![[r##" Adds one to the number given. # Examples ``` let five = 5; assert_eq!(6, my_crate::add_one(5)); ``` ------ fn add_one(x: i32) -> i32 () "##]], ); } #[test] fn test_fn_signature_with_docs_impl() { check( r#" struct addr; impl addr { /// Adds one to the number given. /// /// # Examples /// /// ``` /// let five = 5; /// /// assert_eq!(6, my_crate::add_one(5)); /// ``` pub fn add_one(x: i32) -> i32 { x + 1 } } pub fn do_it() { addr {}; addr::add_one(<|>); } "#, expect![[r##" Adds one to the number given. # Examples ``` let five = 5; assert_eq!(6, my_crate::add_one(5)); ``` ------ fn add_one(x: i32) -> i32 () "##]], ); } #[test] fn test_fn_signature_with_docs_from_actix() { check( r#" struct WriteHandler; impl WriteHandler { /// Method is called when writer emits error. /// /// If this method returns `ErrorAction::Continue` writer processing /// continues otherwise stream processing stops. fn error(&mut self, err: E, ctx: &mut Self::Context) -> Running { Running::Stop } /// Method is called when writer finishes. /// /// By default this method stops actor's `Context`. fn finished(&mut self, ctx: &mut Self::Context) { ctx.stop() } } pub fn foo(mut r: WriteHandler<()>) { r.finished(<|>); } "#, expect![[r#" Method is called when writer finishes. By default this method stops actor's `Context`. ------ fn finished(&mut self, ctx: &mut {unknown}) () "#]], ); } #[test] fn call_info_bad_offset() { mark::check!(call_info_bad_offset); check( r#" fn foo(x: u32, y: u32) -> u32 {x + y} fn bar() { foo <|> (3, ); } "#, expect![[""]], ); } #[test] fn test_nested_method_in_lambda() { check( r#" struct Foo; impl Foo { fn bar(&self, _: u32) { } } fn bar(_: u32) { } fn main() { let foo = Foo; std::thread::spawn(move || foo.bar(<|>)); } "#, expect![[r#" fn bar(&self, _: u32) (<_: u32>) "#]], ); } #[test] fn works_for_tuple_structs() { check( r#" /// A cool tuple struct struct S(u32, i32); fn main() { let s = S(0, <|>); } "#, expect![[r#" A cool tuple struct ------ struct S(u32, i32) (u32, ) "#]], ); } #[test] fn generic_struct() { check( r#" struct S(T); fn main() { let s = S(<|>); } "#, expect![[r#" struct S({unknown}) (<{unknown}>) "#]], ); } #[test] fn works_for_enum_variants() { check( r#" enum E { /// A Variant A(i32), /// Another B, /// And C C { a: i32, b: i32 } } fn main() { let a = E::A(<|>); } "#, expect![[r#" A Variant ------ enum E::A(i32) () "#]], ); } #[test] fn cant_call_struct_record() { check( r#" struct S { x: u32, y: i32 } fn main() { let s = S(<|>); } "#, expect![[""]], ); } #[test] fn cant_call_enum_record() { check( r#" enum E { /// A Variant A(i32), /// Another B, /// And C C { a: i32, b: i32 } } fn main() { let a = E::C(<|>); } "#, expect![[""]], ); } #[test] fn fn_signature_for_call_in_macro() { check( r#" macro_rules! id { ($($tt:tt)*) => { $($tt)* } } fn foo() { } id! { fn bar() { foo(<|>); } } "#, expect![[r#" fn foo() () "#]], ); } #[test] fn call_info_for_lambdas() { check( r#" struct S; fn foo(s: S) -> i32 { 92 } fn main() { (|s| foo(s))(<|>) } "#, expect![[r#" (S) -> i32 () "#]], ) } #[test] fn call_info_for_fn_ptr() { check( r#" fn main(f: fn(i32, f64) -> char) { f(0, <|>) } "#, expect![[r#" (i32, f64) -> char (i32, ) "#]], ) }