From 532aaba234eb26e672e62847afb8f208237b4af9 Mon Sep 17 00:00:00 2001 From: funkill2 Date: Tue, 2 Jul 2019 00:51:18 +0300 Subject: inline snapshots --- crates/ra_ide_api/src/completion/complete_path.rs | 523 +++++++++++++++------- 1 file changed, 366 insertions(+), 157 deletions(-) (limited to 'crates/ra_ide_api/src/completion/complete_path.rs') diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs index b42b7c458..a41cab359 100644 --- a/crates/ra_ide_api/src/completion/complete_path.rs +++ b/crates/ra_ide_api/src/completion/complete_path.rs @@ -74,10 +74,11 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) { mod tests { use test_utils::covers; - use crate::completion::{CompletionKind, check_completion, do_completion}; + use crate::completion::{CompletionKind, do_completion, CompletionItem}; + use insta::assert_debug_snapshot_matches; - fn check_reference_completion(code: &str, expected_completions: &str) { - check_completion(code, expected_completions, CompletionKind::Reference); + fn do_reference_completion(code: &str) -> Vec { + do_completion(code, CompletionKind::Reference) } #[test] @@ -115,227 +116,435 @@ mod tests { #[test] fn completes_mod_with_docs() { - check_reference_completion( - "mod_with_docs", - r" - use self::my<|>; - - /// Some simple - /// docs describing `mod my`. - mod my { - struct Bar; - } - ", + assert_debug_snapshot_matches!( + do_reference_completion( + r" + use self::my<|>; + + /// Some simple + /// docs describing `mod my`. + mod my { + struct Bar; + } + " + ), + @r###"[ + CompletionItem { + label: "my", + source_range: [27; 29), + delete: [27; 29), + insert: "my", + kind: Module, + documentation: Documentation( + "Some simple\ndocs describing `mod my`.", + ), + }, +]"### ); } #[test] fn completes_use_item_starting_with_self() { - check_reference_completion( - "use_item_starting_with_self", - r" - use self::m::<|>; + assert_debug_snapshot_matches!( + do_reference_completion( + r" + use self::m::<|>; - mod m { - struct Bar; - } - ", + mod m { + struct Bar; + } + " + ), + @r###"[ + CompletionItem { + label: "Bar", + source_range: [30; 30), + delete: [30; 30), + insert: "Bar", + kind: Struct, + }, +]"### ); } #[test] fn completes_use_item_starting_with_crate() { - check_reference_completion( - "use_item_starting_with_crate", - " - //- /lib.rs - mod foo; - struct Spam; - //- /foo.rs - use crate::Sp<|> - ", + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + mod foo; + struct Spam; + //- /foo.rs + use crate::Sp<|> + " + ), + @r###"[ + CompletionItem { + label: "Spam", + source_range: [11; 13), + delete: [11; 13), + insert: "Spam", + kind: Struct, + }, + CompletionItem { + label: "foo", + source_range: [11; 13), + delete: [11; 13), + insert: "foo", + kind: Module, + }, +]"### ); } #[test] fn completes_nested_use_tree() { - check_reference_completion( - "nested_use_tree", - " - //- /lib.rs - mod foo; - struct Spam; - //- /foo.rs - use crate::{Sp<|>}; - ", + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + mod foo; + struct Spam; + //- /foo.rs + use crate::{Sp<|>}; + " + ), + @r###"[ + CompletionItem { + label: "Spam", + source_range: [12; 14), + delete: [12; 14), + insert: "Spam", + kind: Struct, + }, + CompletionItem { + label: "foo", + source_range: [12; 14), + delete: [12; 14), + insert: "foo", + kind: Module, + }, +]"### ); } #[test] fn completes_deeply_nested_use_tree() { - check_reference_completion( - "deeply_nested_use_tree", - " - //- /lib.rs - mod foo; - pub mod bar { - pub mod baz { - pub struct Spam; + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + mod foo; + pub mod bar { + pub mod baz { + pub struct Spam; + } } - } - //- /foo.rs - use crate::{bar::{baz::Sp<|>}}; - ", + //- /foo.rs + use crate::{bar::{baz::Sp<|>}}; + " + ), + @r###"[ + CompletionItem { + label: "Spam", + source_range: [23; 25), + delete: [23; 25), + insert: "Spam", + kind: Struct, + }, +]"### ); } #[test] fn completes_enum_variant() { - check_reference_completion( - "enum_variant", - " - //- /lib.rs - /// An enum - enum E { - /// Foo Variant - Foo, - /// Bar Variant with i32 - Bar(i32) - } - fn foo() { let _ = E::<|> } - ", + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// An enum + enum E { + /// Foo Variant + Foo, + /// Bar Variant with i32 + Bar(i32) + } + fn foo() { let _ = E::<|> } + " + ), + @r###"[ + CompletionItem { + label: "Bar", + source_range: [116; 116), + delete: [116; 116), + insert: "Bar", + kind: EnumVariant, + detail: "(i32)", + documentation: Documentation( + "Bar Variant with i32", + ), + }, + CompletionItem { + label: "Foo", + source_range: [116; 116), + delete: [116; 116), + insert: "Foo", + kind: EnumVariant, + detail: "()", + documentation: Documentation( + "Foo Variant", + ), + }, +]"### ); } #[test] fn completes_enum_variant_with_details() { - check_reference_completion( - "enum_variant_with_details", - " - //- /lib.rs - struct S { field: u32 } - /// An enum - enum E { - /// Foo Variant (empty) - Foo, - /// Bar Variant with i32 and u32 - Bar(i32, u32), - /// - S(S), - } - fn foo() { let _ = E::<|> } - ", + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + struct S { field: u32 } + /// An enum + enum E { + /// Foo Variant (empty) + Foo, + /// Bar Variant with i32 and u32 + Bar(i32, u32), + /// + S(S), + } + fn foo() { let _ = E::<|> } + " + ), + @r###"[ + CompletionItem { + label: "Bar", + source_range: [180; 180), + delete: [180; 180), + insert: "Bar", + kind: EnumVariant, + detail: "(i32, u32)", + documentation: Documentation( + "Bar Variant with i32 and u32", + ), + }, + CompletionItem { + label: "Foo", + source_range: [180; 180), + delete: [180; 180), + insert: "Foo", + kind: EnumVariant, + detail: "()", + documentation: Documentation( + "Foo Variant (empty)", + ), + }, + CompletionItem { + label: "S", + source_range: [180; 180), + delete: [180; 180), + insert: "S", + kind: EnumVariant, + detail: "(S)", + documentation: Documentation( + "", + ), + }, +]"### ); } #[test] fn completes_struct_associated_method() { - check_reference_completion( - "struct_associated_method", - " - //- /lib.rs - /// A Struct - struct S; - - impl S { - /// An associated method - fn m() { } - } + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// A Struct + struct S; + + impl S { + /// An associated method + fn m() { } + } - fn foo() { let _ = S::<|> } - ", + fn foo() { let _ = S::<|> } + " + ), + @r###"[ + CompletionItem { + label: "m", + source_range: [100; 100), + delete: [100; 100), + insert: "m()$0", + kind: Function, + detail: "fn m()", + documentation: Documentation( + "An associated method", + ), + }, +]"### ); } #[test] fn completes_struct_associated_const() { - check_reference_completion( - "struct_associated_const", - " - //- /lib.rs - /// A Struct - struct S; - - impl S { - /// An associated const - const C: i32 = 42; - } + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// A Struct + struct S; + + impl S { + /// An associated const + const C: i32 = 42; + } - fn foo() { let _ = S::<|> } - ", + fn foo() { let _ = S::<|> } + " + ), + @r###"[ + CompletionItem { + label: "C", + source_range: [107; 107), + delete: [107; 107), + insert: "C", + kind: Const, + detail: "const C: i32 = 42;", + documentation: Documentation( + "An associated const", + ), + }, +]"### ); } #[test] fn completes_struct_associated_type() { - check_reference_completion( - "struct_associated_type", - " - //- /lib.rs - /// A Struct - struct S; - - impl S { - /// An associated type - type T = i32; - } + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// A Struct + struct S; + + impl S { + /// An associated type + type T = i32; + } - fn foo() { let _ = S::<|> } - ", + fn foo() { let _ = S::<|> } + " + ), + @r###"[ + CompletionItem { + label: "T", + source_range: [101; 101), + delete: [101; 101), + insert: "T", + kind: TypeAlias, + detail: "type T = i32;", + documentation: Documentation( + "An associated type", + ), + }, +]"### ); } #[test] fn completes_enum_associated_method() { - check_reference_completion( - "enum_associated_method", - " - //- /lib.rs - /// An enum - enum S {}; - - impl S { - /// An associated method - fn m() { } - } + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// An enum + enum S {}; + + impl S { + /// An associated method + fn m() { } + } - fn foo() { let _ = S::<|> } - ", + fn foo() { let _ = S::<|> } + " + ), + @r###"[ + CompletionItem { + label: "m", + source_range: [100; 100), + delete: [100; 100), + insert: "m()$0", + kind: Function, + detail: "fn m()", + documentation: Documentation( + "An associated method", + ), + }, +]"### ); } #[test] fn completes_union_associated_method() { - check_reference_completion( - "union_associated_method", - " - //- /lib.rs - /// A union - union U {}; - - impl U { - /// An associated method - fn m() { } - } + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /lib.rs + /// A union + union U {}; + + impl U { + /// An associated method + fn m() { } + } - fn foo() { let _ = U::<|> } - ", + fn foo() { let _ = U::<|> } + " + ), + @r###"[ + CompletionItem { + label: "m", + source_range: [101; 101), + delete: [101; 101), + insert: "m()$0", + kind: Function, + detail: "fn m()", + documentation: Documentation( + "An associated method", + ), + }, +]"### ); } #[test] fn completes_use_paths_across_crates() { - check_reference_completion( - "completes_use_paths_across_crates", - " - //- /main.rs - use foo::<|>; - - //- /foo/lib.rs - pub mod bar { - pub struct S; - } - ", + assert_debug_snapshot_matches!( + do_reference_completion( + " + //- /main.rs + use foo::<|>; + + //- /foo/lib.rs + pub mod bar { + pub struct S; + } + " + ), + @r###"[ + CompletionItem { + label: "bar", + source_range: [9; 9), + delete: [9; 9), + insert: "bar", + kind: Module, + }, +]"### ); } } -- cgit v1.2.3