From f835279b3ae41644e9568187b4468cd9d9e84eca Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Mon, 21 Jun 2021 13:48:25 +0200 Subject: Move out completion pattern tests --- crates/ide_completion/src/completions/keyword.rs | 22 -- crates/ide_completion/src/completions/pattern.rs | 395 --------------------- .../src/completions/unqualified_path.rs | 50 --- crates/ide_completion/src/tests.rs | 1 + crates/ide_completion/src/tests/pattern.rs | 348 ++++++++++++++++++ 5 files changed, 349 insertions(+), 467 deletions(-) create mode 100644 crates/ide_completion/src/tests/pattern.rs (limited to 'crates') diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs index 07541c79c..e40ec6280 100644 --- a/crates/ide_completion/src/completions/keyword.rs +++ b/crates/ide_completion/src/completions/keyword.rs @@ -372,28 +372,6 @@ fn quux() -> i32 { ); } - #[test] - fn test_mut_in_ref_and_in_fn_parameters_list() { - check( - r"fn my_fn(&$0) {}", - expect![[r#" - kw mut - "#]], - ); - check( - r"fn my_fn($0) {}", - expect![[r#" - kw mut - "#]], - ); - check( - r"fn my_fn() { let &$0 }", - expect![[r#" - kw mut - "#]], - ); - } - #[test] fn no_keyword_completion_in_comments() { cov_mark::check!(no_keyword_completion_in_comments); diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs index efe3c957a..bd13a62d7 100644 --- a/crates/ide_completion/src/completions/pattern.rs +++ b/crates/ide_completion/src/completions/pattern.rs @@ -55,398 +55,3 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) { } }); } - -#[cfg(test)] -mod tests { - use expect_test::{expect, Expect}; - - use crate::{ - tests::{check_edit, filtered_completion_list}, - CompletionKind, - }; - - fn check(ra_fixture: &str, expect: Expect) { - let actual = filtered_completion_list(ra_fixture, CompletionKind::Reference); - expect.assert_eq(&actual) - } - - fn check_snippet(ra_fixture: &str, expect: Expect) { - let actual = filtered_completion_list(ra_fixture, CompletionKind::Snippet); - expect.assert_eq(&actual) - } - - #[test] - fn completes_enum_variants_and_modules() { - check( - r#" -enum E { X } -use self::E::X; -const Z: E = E::X; -mod m {} - -static FOO: E = E::X; -struct Bar { f: u32 } - -fn foo() { - match E::X { a$0 } -} -"#, - expect![[r#" - en E - ct Z - st Bar - ev X - md m - "#]], - ); - } - - #[test] - fn does_not_complete_non_fn_macros() { - check( - r#" -macro_rules! m { ($e:expr) => { $e } } -enum E { X } - -#[rustc_builtin_macro] -macro Clone {} - -fn foo() { - match E::X { $0 } -} -"#, - expect![[r#" - ev E::X () - en E - ma m!(…) macro_rules! m - "#]], - ); - } - - #[test] - fn completes_in_simple_macro_call() { - check( - r#" -macro_rules! m { ($e:expr) => { $e } } -enum E { X } - -fn foo() { - m!(match E::X { a$0 }) -} -"#, - expect![[r#" - ev E::X () - en E - ma m!(…) macro_rules! m - "#]], - ); - } - - #[test] - fn completes_in_irrefutable_let() { - check( - r#" -enum E { X } -use self::E::X; -const Z: E = E::X; -mod m {} - -static FOO: E = E::X; -struct Bar { f: u32 } - -fn foo() { - let a$0 -} -"#, - expect![[r#" - st Bar - "#]], - ); - } - - #[test] - fn completes_in_param() { - check( - r#" -enum E { X } - -static FOO: E = E::X; -struct Bar { f: u32 } - -fn foo(a$0) { -} -"#, - expect![[r#" - st Bar - "#]], - ); - } - - #[test] - fn completes_pat_in_let() { - check_snippet( - r#" -struct Bar { f: u32 } - -fn foo() { - let a$0 -} -"#, - expect![[r#" - bn Bar Bar { f$1 }$0 - "#]], - ); - } - - #[test] - fn completes_param_pattern() { - check_snippet( - r#" -struct Foo { bar: String, baz: String } -struct Bar(String, String); -struct Baz; -fn outer(a$0) {} -"#, - expect![[r#" - bn Foo Foo { bar$1, baz$2 }: Foo$0 - bn Bar Bar($1, $2): Bar$0 - "#]], - ) - } - - #[test] - fn completes_let_pattern() { - check_snippet( - r#" -struct Foo { bar: String, baz: String } -struct Bar(String, String); -struct Baz; -fn outer() { - let a$0 -} -"#, - expect![[r#" - bn Foo Foo { bar$1, baz$2 }$0 - bn Bar Bar($1, $2)$0 - "#]], - ) - } - - #[test] - fn completes_refutable_pattern() { - check_snippet( - r#" -struct Foo { bar: i32, baz: i32 } -struct Bar(String, String); -struct Baz; -fn outer() { - match () { - a$0 - } -} -"#, - expect![[r#" - bn Foo Foo { bar$1, baz$2 }$0 - bn Bar Bar($1, $2)$0 - "#]], - ) - } - - #[test] - fn omits_private_fields_pat() { - check_snippet( - r#" -mod foo { - pub struct Foo { pub bar: i32, baz: i32 } - pub struct Bar(pub String, String); - pub struct Invisible(String, String); -} -use foo::*; - -fn outer() { - match () { - a$0 - } -} -"#, - expect![[r#" - bn Foo Foo { bar$1, .. }$0 - bn Bar Bar($1, ..)$0 - "#]], - ) - } - - #[test] - fn only_shows_ident_completion() { - check_edit( - "Foo", - r#" -struct Foo(i32); -fn main() { - match Foo(92) { - a$0(92) => (), - } -} -"#, - r#" -struct Foo(i32); -fn main() { - match Foo(92) { - Foo(92) => (), - } -} -"#, - ); - } - - #[test] - fn completes_self_pats() { - check_snippet( - r#" -struct Foo(i32); -impl Foo { - fn foo() { - match () { - a$0 - } - } -} - "#, - expect![[r#" - bn Self Self($1)$0 - bn Foo Foo($1)$0 - "#]], - ) - } - - #[test] - fn completes_qualified_variant() { - check_snippet( - r#" -enum Foo { - Bar { baz: i32 } -} -impl Foo { - fn foo() { - match {Foo::Bar { baz: 0 }} { - B$0 - } - } -} - "#, - expect![[r#" - bn Self::Bar Self::Bar { baz$1 }$0 - bn Foo::Bar Foo::Bar { baz$1 }$0 - "#]], - ) - } - - #[test] - fn completes_enum_variant_matcharm() { - check( - r#" -enum Foo { Bar, Baz, Quux } - -fn main() { - let foo = Foo::Quux; - match foo { Qu$0 } -} -"#, - expect![[r#" - ev Foo::Bar () - ev Foo::Baz () - ev Foo::Quux () - en Foo - "#]], - ) - } - - #[test] - fn completes_enum_variant_matcharm_ref() { - check( - r#" -enum Foo { Bar, Baz, Quux } - -fn main() { - let foo = Foo::Quux; - match &foo { Qu$0 } -} -"#, - expect![[r#" - ev Foo::Bar () - ev Foo::Baz () - ev Foo::Quux () - en Foo - "#]], - ) - } - - #[test] - fn completes_enum_variant_iflet() { - check( - r#" -enum Foo { Bar, Baz, Quux } - -fn main() { - let foo = Foo::Quux; - if let Qu$0 = foo { } -} -"#, - expect![[r#" - ev Foo::Bar () - ev Foo::Baz () - ev Foo::Quux () - en Foo - "#]], - ) - } - - #[test] - fn completes_enum_variant_impl() { - check( - r#" -enum Foo { Bar, Baz, Quux } -impl Foo { - fn foo() { match Foo::Bar { Q$0 } } -} -"#, - expect![[r#" - ev Self::Bar () - ev Self::Baz () - ev Self::Quux () - ev Foo::Bar () - ev Foo::Baz () - ev Foo::Quux () - sp Self - en Foo - "#]], - ) - } - - #[test] - fn completes_in_record_field_pat() { - check_snippet( - r#" -struct Foo { bar: Bar } -struct Bar(u32); -fn outer(Foo { bar: $0 }: Foo) {} -"#, - expect![[r#" - bn Foo Foo { bar$1 }$0 - bn Bar Bar($1)$0 - "#]], - ) - } - - #[test] - fn skips_in_record_field_pat_name() { - check_snippet( - r#" -struct Foo { bar: Bar } -struct Bar(u32); -fn outer(Foo { bar$0 }: Foo) {} -"#, - expect![[r#""#]], - ) - } -} diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs index 81c4fb305..819fa3a43 100644 --- a/crates/ide_completion/src/completions/unqualified_path.rs +++ b/crates/ide_completion/src/completions/unqualified_path.rs @@ -134,56 +134,6 @@ fn foo() { ); } - #[test] - fn bind_pat_and_path_ignore_at() { - check( - r#" -enum Enum { A, B } -fn quux(x: Option) { - match x { - None => (), - Some(en$0 @ Enum::A) => (), - } -} -"#, - expect![[r#""#]], - ); - } - - #[test] - fn bind_pat_and_path_ignore_ref() { - check( - r#" -enum Enum { A, B } -fn quux(x: Option) { - match x { - None => (), - Some(ref en$0) => (), - } -} -"#, - expect![[r#""#]], - ); - } - - #[test] - fn bind_pat_and_path() { - check( - r#" -enum Enum { A, B } -fn quux(x: Option) { - match x { - None => (), - Some(En$0) => (), - } -} -"#, - expect![[r#" - en Enum - "#]], - ); - } - #[test] fn completes_bindings_from_let() { check( diff --git a/crates/ide_completion/src/tests.rs b/crates/ide_completion/src/tests.rs index 211c89c40..7af8c903b 100644 --- a/crates/ide_completion/src/tests.rs +++ b/crates/ide_completion/src/tests.rs @@ -7,6 +7,7 @@ mod item_list; mod use_tree; mod items; +mod pattern; use hir::{PrefixKind, Semantics}; use ide_db::{ diff --git a/crates/ide_completion/src/tests/pattern.rs b/crates/ide_completion/src/tests/pattern.rs new file mode 100644 index 000000000..1ad5ccd97 --- /dev/null +++ b/crates/ide_completion/src/tests/pattern.rs @@ -0,0 +1,348 @@ +//! Completions tests for pattern position. +use expect_test::{expect, Expect}; + +use crate::tests::completion_list; + +fn check(ra_fixture: &str, expect: Expect) { + let actual = completion_list(ra_fixture); + expect.assert_eq(&actual) +} + +fn check_with(ra_fixture: &str, expect: Expect) { + let base = r#" +enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV } +use self::Enum::TupleV; +mod module {} + +static STATIC: Unit = Unit; +const CONST: Unit = Unit; +struct Record { field: u32 } +struct Tuple(u32); +struct Unit +macro_rules! makro {} +"#; + let actual = completion_list(&format!("{}\n{}", base, ra_fixture)); + expect.assert_eq(&actual) +} + +#[test] +fn ident_rebind_pat() { + check( + r#" +fn quux() { + let en$0 @ x +} +"#, + expect![[r#" + kw mut + "#]], + ); +} + +#[test] +fn ident_ref_pat() { + check( + r#" +fn quux() { + let ref en$0 +} +"#, + expect![[r#" + kw mut + "#]], + ); + check( + r#" +fn quux() { + let ref en$0 @ x +} +"#, + expect![[r#" + kw mut + "#]], + ); +} + +#[test] +fn ident_ref_mut_pat() { + // FIXME mut is already here, don't complete it again + check( + r#" +fn quux() { + let ref mut en$0 +} +"#, + expect![[r#" + kw mut + "#]], + ); + check( + r#" +fn quux() { + let ref mut en$0 @ x +} +"#, + expect![[r#" + kw mut + "#]], + ); +} + +#[test] +fn ref_pat() { + check( + r#" +fn quux() { + let &en$0 +} +"#, + expect![[r#" + kw mut + "#]], + ); + // FIXME mut is already here, don't complete it again + check( + r#" +fn quux() { + let &mut en$0 +} +"#, + expect![[r#" + kw mut + "#]], + ); +} + +#[test] +fn refutable() { + check_with( + r#" +fn foo() { + if let a$0 +} +"#, + expect![[r#" + kw mut + bn Record Record { field$1 }$0 + st Record + en Enum + bn Tuple Tuple($1)$0 + st Tuple + md module + bn TupleV TupleV($1)$0 + ev TupleV + st Unit + ct CONST + ma makro!(…) macro_rules! makro + "#]], + ); +} + +#[test] +fn irrefutable() { + check_with( + r#" +fn foo() { + let a$0 +} +"#, + expect![[r#" + kw mut + bn Record Record { field$1 }$0 + st Record + bn Tuple Tuple($1)$0 + st Tuple + st Unit + ma makro!(…) macro_rules! makro + "#]], + ); +} + +#[test] +fn in_param() { + check_with( + r#" +fn foo(a$0) { +} +"#, + expect![[r#" + kw mut + bn Record Record { field$1 }: Record$0 + st Record + bn Tuple Tuple($1): Tuple$0 + st Tuple + st Unit + ma makro!(…) macro_rules! makro + "#]], + ); +} + +#[test] +fn only_fn_like_macros() { + check( + r#" +macro_rules! m { ($e:expr) => { $e } } + +#[rustc_builtin_macro] +macro Clone {} + +fn foo() { + let x$0 +} +"#, + expect![[r#" + kw mut + ma m!(…) macro_rules! m + "#]], + ); +} + +#[test] +fn in_simple_macro_call() { + check( + r#" +macro_rules! m { ($e:expr) => { $e } } +enum E { X } + +fn foo() { + m!(match E::X { a$0 }) +} +"#, + expect![[r#" + kw mut + ev E::X () + en E + ma m!(…) macro_rules! m + "#]], + ); +} + +#[test] +fn omits_private_fields_pat() { + check( + r#" +mod foo { + pub struct Record { pub field: i32, _field: i32 } + pub struct Tuple(pub u32, u32); + pub struct Invisible(u32, u32); +} +use foo::*; + +fn outer() { + if let a$0 +} +"#, + expect![[r#" + kw mut + bn Record Record { field$1, .. }$0 + st Record + bn Tuple Tuple($1, ..)$0 + st Tuple + st Invisible + md foo + "#]], + ) +} + +// #[test] +// fn only_shows_ident_completion() { +// check_edit( +// "Foo", +// r#" +// struct Foo(i32); +// fn main() { +// match Foo(92) { +// a$0(92) => (), +// } +// } +// "#, +// r#" +// struct Foo(i32); +// fn main() { +// match Foo(92) { +// Foo(92) => (), +// } +// } +// "#, +// ); +// } + +#[test] +fn completes_self_pats() { + check( + r#" +struct Foo(i32); +impl Foo { + fn foo() { + match Foo(0) { + a$0 + } + } +} + "#, + expect![[r#" + kw mut + bn Self Self($1)$0 + sp Self + bn Foo Foo($1)$0 + st Foo + "#]], + ) +} + +#[test] +fn completes_qualified_variant() { + check( + r#" +enum Foo { + Bar { baz: i32 } +} +impl Foo { + fn foo() { + match {Foo::Bar { baz: 0 }} { + B$0 + } + } +} + "#, + expect![[r#" + kw mut + bn Self::Bar Self::Bar { baz$1 }$0 + ev Self::Bar { baz: i32 } + bn Foo::Bar Foo::Bar { baz$1 }$0 + ev Foo::Bar { baz: i32 } + sp Self + en Foo + "#]], + ) +} + +#[test] +fn completes_in_record_field_pat() { + check( + r#" +struct Foo { bar: Bar } +struct Bar(u32); +fn outer(Foo { bar: $0 }: Foo) {} +"#, + expect![[r#" + kw mut + bn Foo Foo { bar$1 }$0 + st Foo + bn Bar Bar($1)$0 + st Bar + "#]], + ) +} + +#[test] +fn skips_in_record_field_pat_name() { + check( + r#" +struct Foo { bar: Bar } +struct Bar(u32); +fn outer(Foo { bar$0 }: Foo) {} +"#, + expect![[r#""#]], + ) +} -- cgit v1.2.3