diff options
| -rw-r--r-- | crates/ra_ide/src/completion/complete_dot.rs | 984 | ||||
| -rw-r--r-- | crates/ra_ide/src/completion/complete_keyword.rs | 35 | ||||
| -rw-r--r-- | crates/ra_ide/src/completion/complete_qualified_path.rs | 39 | ||||
| -rw-r--r-- | crates/ra_ide/src/completion/presentation.rs | 69 |
4 files changed, 407 insertions, 720 deletions
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs index 520652a3738..667a8b94993 100644 --- a/crates/ra_ide/src/completion/complete_dot.rs +++ b/crates/ra_ide/src/completion/complete_dot.rs @@ -2,16 +2,11 @@ use hir::{HasVisibility, Type}; use rustc_hash::FxHashSet; +use test_utils::mark; -use crate::{ - completion::{ - completion_context::CompletionContext, - completion_item::{CompletionKind, Completions}, - }, - CompletionItem, -}; +use crate::completion::{completion_context::CompletionContext, completion_item::Completions}; -/// Complete dot accesses, i.e. fields or methods (and .await syntax). +/// Complete dot accesses, i.e. fields or methods. pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) { let dot_receiver = match &ctx.dot_receiver { Some(expr) => expr, @@ -23,18 +18,12 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) { _ => return, }; - if !ctx.is_call { + if ctx.is_call { + mark::hit!(test_no_struct_field_completion_for_method_call); + } else { complete_fields(acc, ctx, &receiver_ty); } complete_methods(acc, ctx, &receiver_ty); - - // Suggest .await syntax for types that implement Future trait - if receiver_ty.impls_future(ctx.db) { - CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await") - .detail("expr.await") - .insert_text("await") - .add_to(acc); - } } fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) { @@ -72,801 +61,356 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T #[cfg(test)] mod tests { - use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind}; - use insta::assert_debug_snapshot; + use expect::{expect, Expect}; + use test_utils::mark; + + use crate::completion::{test_utils::completion_list, CompletionKind}; - fn do_ref_completion(code: &str) -> Vec<CompletionItem> { - do_completion(code, CompletionKind::Reference) + fn check(ra_fixture: &str, expect: Expect) { + let actual = completion_list(ra_fixture, CompletionKind::Reference); + expect.assert_eq(&actual); } #[test] - fn test_struct_field_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A { the_field: u32 } - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 45..45, - delete: 45..45, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### + fn test_struct_field_and_method_completion() { + check( + r#" +struct S { foo: u32 } +impl S { + fn bar(&self) {} +} +fn foo(s: S) { s.<|> } +"#, + expect![[r#" + me bar() fn bar(&self) + fd foo u32 + "#]], ); } #[test] fn test_struct_field_completion_self() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A { - /// This is the_field - the_field: (u32,) - } - impl A { - fn foo(self) { - self.<|> - } - } - ", - ), - @r###" - [ - CompletionItem { - label: "foo()", - source_range: 102..102, - delete: 102..102, - insert: "foo()$0", - kind: Method, - lookup: "foo", - detail: "fn foo(self)", - }, - CompletionItem { - label: "the_field", - source_range: 102..102, - delete: 102..102, - insert: "the_field", - kind: Field, - detail: "(u32,)", - documentation: Documentation( - "This is the_field", - ), - }, - ] - "### - ); + check( + r#" +struct S { the_field: (u32,) } +impl S { + fn foo(self) { self.<|> } +} +"#, + expect![[r#" + me foo() fn foo(self) + fd the_field (u32,) + "#]], + ) } #[test] fn test_struct_field_completion_autoderef() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A { the_field: (u32, i32) } - impl A { - fn foo(&self) { - self.<|> - } - } - ", - ), - @r###" - [ - CompletionItem { - label: "foo()", - source_range: 77..77, - delete: 77..77, - insert: "foo()$0", - kind: Method, - lookup: "foo", - detail: "fn foo(&self)", - }, - CompletionItem { - label: "the_field", - source_range: 77..77, - delete: 77..77, - insert: "the_field", - kind: Field, - detail: "(u32, i32)", - }, - ] - "### - ); + check( + r#" +struct A { the_field: (u32, i32) } +impl A { + fn foo(&self) { self.<|> } +} +"#, + expect![[r#" + me foo() fn foo(&self) + fd the_field (u32, i32) + "#]], + ) } #[test] fn test_no_struct_field_completion_for_method_call() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A { the_field: u32 } - fn foo(a: A) { - a.<|>() - } - ", - ), - @"[]" + mark::check!(test_no_struct_field_completion_for_method_call); + check( + r#" +struct A { the_field: u32 } +fn foo(a: A) { a.<|>() } +"#, + expect![[""]], ); } #[test] - fn test_struct_field_visibility_private() { - assert_debug_snapshot!( - do_ref_completion( - r" - mod inner { - struct A { - private_field: u32, - pub pub_field: u32, - pub(crate) crate_field: u32, - pub(super) super_field: u32, - } - } - fn foo(a: inner::A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "crate_field", - source_range: 192..192, - delete: 192..192, - insert: "crate_field", - kind: Field, - detail: "u32", - }, - CompletionItem { - label: "pub_field", - source_range: 192..192, - delete: 192..192, - insert: "pub_field", - kind: Field, - detail: "u32", - }, - CompletionItem { - label: "super_field", - source_range: 192..192, - delete: 192..192, - insert: "super_field", - kind: Field, - detail: "u32", - }, - ] - "### - ); + fn test_visibility_filtering() { + check( + r#" +mod inner { + pub struct A { + private_field: u32, + pub pub_field: u32, + pub(crate) crate_field: u32, + pub(super) super_field: u32, } - - #[test] - fn test_union_field_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - union Un { - field: u8, - other: u16, - } - - fn foo(u: Un) { - u.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "field", - source_range: 67..67, - delete: 67..67, - insert: "field", - kind: Field, - detail: "u8", - }, - CompletionItem { - label: "other", - source_range: 67..67, - delete: 67..67, - insert: "other", - kind: Field, - detail: "u16", - }, - ] - "### +} +fn foo(a: inner::A) { a.<|> } +"#, + expect![[r#" + fd crate_field u32 + fd pub_field u32 + fd super_field u32 + "#]], ); - } - #[test] - fn test_method_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - impl A { - fn the_method(&self) {} - } - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 71..71, - delete: 71..71, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### + check( + r#" +struct A {} +mod m { + impl super::A { + fn private_method(&self) {} + pub(super) fn the_method(&self) {} + } +} +fn foo(a: A) { a.<|> } +"#, + expect![[r#" + me the_method() pub(super) fn the_method(&self) + "#]], ); } #[test] - fn test_method_completion_only_fitting_impls() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A<T> {} - impl A<u32> { - fn the_method(&self) {} - } - impl A<i32> { - fn the_other_method(&self) {} - } - fn foo(a: A<u32>) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 134..134, - delete: 134..134, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### + fn test_union_field_completion() { + check( + r#" +union U { field: u8, other: u16 } +fn foo(u: U) { u.<|> } +"#, + expect![[r#" + fd field u8 + fd other u16 + "#]], ); } #[test] - fn test_method_completion_private() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - mod m { - impl super::A { - fn private_method(&self) {} - pub(super) fn the_method(&self) {} - } - } - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 147..147, - delete: 147..147, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "pub(super) fn the_method(&self)", - }, - ] - "### - ); + fn test_method_completion_only_fitting_impls() { + check( + r#" +struct A<T> {} +impl A<u32> { + fn the_method(&self) {} +} +impl A<i32> { + fn the_other_method(&self) {} +} +fn foo(a: A<u32>) { a.<|> } +"#, + expect![[r#" + me the_method() fn the_method(&self) + "#]], + ) } #[test] fn test_trait_method_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - trait Trait { fn the_method(&self); } - impl Trait for A {} - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 90..90, - delete: 90..90, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### + check( + r#" +struct A {} +trait Trait { fn the_method(&self); } +impl Trait for A {} +fn foo(a: A) { a.<|> } +"#, + expect![[r#" + me the_method() fn the_method(&self) + "#]], ); } #[test] fn test_trait_method_completion_deduplicated() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - trait Trait { fn the_method(&self); } - impl<T> Trait for T {} - fn foo(a: &A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 94..94, - delete: 94..94, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### + check( + r" +struct A {} +trait Trait { fn the_method(&self); } +impl<T> Trait for T {} +fn foo(a: &A) { a.<|> } +", + expect![[r#" + me the_method() fn the_method(&self) + "#]], ); } #[test] fn completes_trait_method_from_other_module() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - mod m { - pub trait Trait { fn the_method(&self); } - } - use m::Trait; - impl Trait for A {} - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 122..122, - delete: 122..122, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### - ); - } - - #[test] - fn test_no_non_self_method() { - assert_debug_snapshot!( - do_ref_completion( + check( r" - struct A {} - impl A { - fn the_method() {} - } - fn foo(a: A) { - a.<|> - } - ", - ), - @"[]" +struct A {} +mod m { + pub trait Trait { fn the_method(&self); } +} +use m::Trait; +impl Trait for A {} +fn foo(a: A) { a.<|> } +", + expect![[r#" + me the_method() fn the_method(&self) + "#]], ); } #[test] - fn test_method_attr_filtering() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A {} - impl A { - #[inline] - fn the_method(&self) { - let x = 1; - let y = 2; - } - } - fn foo(a: A) { - a.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 128..128, - delete: 128..128, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "fn the_method(&self)", - }, - ] - "### + fn test_no_non_self_method() { + check( + r#" +struct A {} +impl A { + fn the_method() {} +} +fn foo(a: A) { + a.<|> +} +"#, + expect![[""]], ); } #[test] fn test_tuple_field_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - fn foo() { - let b = (0, 3.14); - b.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "0", - source_range: 38..38, - delete: 38..38, - insert: "0", - kind: Field, - detail: "i32", - }, - CompletionItem { - label: "1", - source_range: 38..38, - delete: 38..38, - insert: "1", - kind: Field, - detail: "f64", - }, - ] - "### - ); + check( + r#" +fn foo() { + let b = (0, 3.14); + b.<|> +} +"#, + expect![[r#" + fd 0 i32 + fd 1 f64 + "#]], + ) } #[test] fn test_tuple_field_inference() { - assert_debug_snapshot!( - do_ref_completion( - r" - pub struct S; - impl S { - pub fn blah(&self) {} - } + check( + r#" +pub struct S; +impl S { pub fn blah(&self) {} } - struct T(S); +struct T(S); - impl T { - fn foo(&self) { - // FIXME: This doesn't work without the trailing `a` as `0.` is a float - self.0.a<|> - } - } - ", - ), - @r###" - [ - CompletionItem { - label: "blah()", - source_range: 190..191, - delete: 190..191, - insert: "blah()$0", - kind: Method, - lookup: "blah", - detail: "pub fn blah(&self)", - }, - ] - "### - ); +impl T { + fn foo(&self) { + // FIXME: This doesn't work without the trailing `a` as `0.` is a float + self.0.a<|> } - - #[test] - fn test_completion_works_in_consts() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct A { the_field: u32 } - const X: u32 = { - A { the_field: 92 }.<|> - }; - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 69..69, - delete: 69..69, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### +} +"#, + expect![[r#" + me blah() pub fn blah(&self) + "#]], ); } #[test] - fn test_completion_await_impls_future() { - assert_debug_snapshot!( - do_completion( - r###" - //- /main.rs - use std::future::*; - struct A {} - impl Future for A {} - fn foo(a: A) { - a.<|> - } - - //- /std/lib.rs - pub mod future { - #[lang = "future_trait"] - pub trait Future {} - } - "###, CompletionKind::Keyword), - @r###" - [ - CompletionItem { - label: "await", - source_range: 74..74, - delete: 74..74, - insert: "await", - detail: "expr.await", - }, - ] - "### - ) - } - - #[test] - fn test_super_super_completion() { - assert_debug_snapshot!( - do_ref_completion( - r" - mod a { - const A: usize = 0; - - mod b { - const B: usize = 0; - - mod c { - use super::super::<|> - } - } - } - ", - ), - @r###" - [ - CompletionItem { - label: "A", - source_range: 120..120, - delete: 120..120, - insert: "A", - kind: Const, - }, - CompletionItem { - label: "b", - source_range: 120..120, - delete: 120..120, - insert: "b", - kind: Module, - }, - ] - "### + fn test_completion_works_in_consts() { + check( + r#" +struct A { the_field: u32 } +const X: u32 = { + A { the_field: 92 }.<|> +}; +"#, + expect![[r#" + fd the_field u32 + "#]], ); } #[test] fn works_in_simple_macro_1() { - assert_debug_snapshot!( - do_ref_completion( - r" - macro_rules! m { ($e:expr) => { $e } } - struct A { the_field: u32 } - fn foo(a: A) { - m!(a.x<|>) - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 91..92, - delete: 91..92, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### - ); - } - - #[test] - fn works_in_simple_macro_recursive() { - assert_debug_snapshot!( - do_ref_completion( - r" - macro_rules! m { ($e:expr) => { $e } } - struct A { the_field: u32 } - fn foo(a: A) { - m!(a.x<|>) - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 91..92, - delete: 91..92, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### + check( + r#" +macro_rules! m { ($e:expr) => { $e } } +struct A { the_field: u32 } +fn foo(a: A) { + m!(a.x<|>) +} +"#, + expect![[r#" + fd the_field u32 + "#]], ); } #[test] fn works_in_simple_macro_2() { // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery - assert_debug_snapshot!( - do_ref_completion( - r" - macro_rules! m { ($e:expr) => { $e } } - struct A { the_field: u32 } - fn foo(a: A) { - m!(a.<|>) - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 91..91, - delete: 91..91, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### + check( + r#" +macro_rules! m { ($e:expr) => { $e } } +struct A { the_field: u32 } +fn foo(a: A) { + m!(a.<|>) +} +"#, + expect![[r#" + fd the_field u32 + "#]], ); } #[test] fn works_in_simple_macro_recursive_1() { - assert_debug_snapshot!( - do_ref_completion( - r" - macro_rules! m { ($e:expr) => { $e } } - struct A { the_field: u32 } - fn foo(a: A) { - m!(m!(m!(a.x<|>))) - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 97..98, - delete: 97..98, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### + check( + r#" +macro_rules! m { ($e:expr) => { $e } } +struct A { the_field: u32 } +fn foo(a: A) { + m!(m!(m!(a.x<|>))) +} +"#, + expect![[r#" + fd the_field u32 + "#]], ); } #[test] fn macro_expansion_resilient() { - assert_debug_snapshot!( - do_ref_completion( - r" - macro_rules! dbg { - () => {}; - ($val:expr) => { - match $val { tmp => { tmp } } - }; - // Trailing comma with single argument is ignored - ($val:expr,) => { $crate::dbg!($val) }; - ($($val:expr),+ $(,)?) => { - ($($crate::dbg!($val)),+,) - }; - } - struct A { the_field: u32 } - fn foo(a: A) { - dbg!(a.<|>) - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_field", - source_range: 327..327, - delete: 327..327, - insert: "the_field", - kind: Field, - detail: "u32", - }, - ] - "### + check( + r#" +macro_rules! dbg { + () => {}; + ($val:expr) => { + match $val { tmp => { tmp } } + }; + // Trailing comma with single argument is ignored + ($val:expr,) => { $crate::dbg!($val) }; + ($($val:expr),+ $(,)?) => { + ($($crate::dbg!($val)),+,) + }; +} +struct A { the_field: u32 } +fn foo(a: A) { + dbg!(a.<|>) +} +"#, + expect![[r#" + fd the_field u32 + "#]], ); } #[test] - fn test_method_completion_3547() { - assert_debug_snapshot!( - do_ref_completion( - r" - struct HashSet<T> {} - impl<T> HashSet<T> { - pub fn the_method(&self) {} - } - fn foo() { - let s: HashSet<_>; - s.<|> - } - ", - ), - @r###" - [ - CompletionItem { - label: "the_method()", - source_range: 116..116, - delete: 116..116, - insert: "the_method()$0", - kind: Method, - lookup: "the_method", - detail: "pub fn the_method(&self)", - }, - ] - "### + fn test_method_completion_issue_3547() { + check( + r#" +struct HashSet<T> {} +impl<T> HashSet<T> { + pub fn the_method(&self) {} +} +fn foo() { + let s: HashSet<_>; + s.<|> +} +"#, + expect![[r#" + me the_method() pub fn the_method(&self) + "#]], ); } } diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs index 086b917ce89..340d57a49c6 100644 --- a/crates/ra_ide/src/completion/complete_keyword.rs +++ b/crates/ra_ide/src/completion/complete_keyword.rs @@ -35,6 +35,19 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC } _ => {} } + + // Suggest .await syntax for types that implement Future trait + if let Some(receiver) = &ctx.dot_receiver { + if let Some(ty) = ctx.sema.type_of_expr(receiver) { + if ty.impls_future(ctx.db) { + CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await") + .kind(CompletionItemKind::Keyword) + .detail("expr.await") + .insert_text("await") + .add_to(acc); + } + }; + } } pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) { @@ -490,4 +503,26 @@ Some multi-line comment<|> expect![[""]], ); } + + #[test] + fn test_completion_await_impls_future() { + check( + r#" +//- /main.rs +use std::future::*; +struct A {} +impl Future for A {} +fn foo(a: A) { a.<|> } + +//- /std/lib.rs +pub mod future { + #[lang = "future_trait"] + pub trait Future {} +} +"#, + expect![[r#" + kw await expr.await + "#]], + ) + } } diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs index f133ce3cece..a16866cd2d4 100644 --- a/crates/ra_ide/src/completion/complete_qualified_path.rs +++ b/crates/ra_ide/src/completion/complete_qualified_path.rs @@ -1206,6 +1206,45 @@ mod tests { } #[test] + fn test_super_super_completion() { + assert_debug_snapshot!( + do_reference_completion( + r" + mod a { + const A: usize = 0; + + mod b { + const B: usize = 0; + + mod c { + use super::super::<|> + } + } + } + ", + ), + @r###" + [ + CompletionItem { + label: "A", + source_range: 120..120, + delete: 120..120, + insert: "A", + kind: Const, + }, + CompletionItem { + label: "b", + source_range: 120..120, + delete: 120..120, + insert: "b", + kind: Module, + }, + ] + "### + ); + } + + #[test] fn completes_reexported_items_under_correct_name() { assert_debug_snapshot!( do_reference_completion( diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs index bd48156b026..dc391c46bc1 100644 --- a/crates/ra_ide/src/completion/presentation.rs +++ b/crates/ra_ide/src/completion/presentation.rs @@ -644,6 +644,75 @@ fn foo() { A { the<|> } } } #[test] + fn renders_docs() { + check( + r#" +struct S { + /// Field docs + foo: +} +impl S { + /// Method docs + fn bar(self) { self.<|> } +}"#, + expect![[r#" + [ + CompletionItem { + label: "bar()", + source_range: 94..94, + delete: 94..94, + insert: "bar()$0", + kind: Method, + lookup: "bar", + detail: "fn bar(self)", + documentation: Documentation( + "Method docs", + ), + }, + CompletionItem { + label: "foo", + source_range: 94..94, + delete: 94..94, + insert: "foo", + kind: Field, + detail: "{unknown}", + documentation: Documentation( + "Field docs", + ), + }, + ] + "#]], + ) + } + + #[test] + fn dont_render_attrs() { + check( + r#" +struct S; +impl S { + #[inline] + fn the_method(&self) { } +} +fn foo(s: S) { s.<|> } +"#, + expect![[r#" + [ + CompletionItem { + label: "the_method()", + source_range: 81..81, + delete: 81..81, + insert: "the_method()$0", + kind: Method, + lookup: "the_method", + detail: "fn the_method(&self)", + }, + ] + "#]], + ) + } + + #[test] fn inserts_parens_for_function_calls() { mark::check!(inserts_parens_for_function_calls); check_edit( |