Merge #9675

9675: internal: Move and clean up record completion tests r=Veykril a=Veykril

Now all that's left are the expression related tests which will take some time to go through
bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

Author: bors[bot]

crates/ide_completion/src/completions/record.rs

@@ -47,322 +47,74 @@ pub(crate) fn complete_record(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);
-    }
+    use crate::tests::check_edit;
 
     #[test]
-    fn test_record_literal_field_default() {
-        let test_code = r#"
-//- minicore: default
-struct S { foo: u32, bar: usize }
-
-impl Default for S {
-    fn default() -> Self {
-        S {
-            foo: 0,
-            bar: 0,
-        }
-    }
-}
-
-fn process(f: S) {
-    let other = S {
-        foo: 5,
-        .$0
-    };
-}
-"#;
-        check(
-            test_code,
-            expect![[r#"
-                fd bar usize
-            "#]],
-        );
-
-        check_snippet(
-            test_code,
-            expect![[r#"
-                fd ..Default::default()
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_literal_field_default_completion() {
+    fn default_completion_edit() {
         check_edit(
             "..Default::default()",
             r#"
 //- minicore: default
-struct S { foo: u32, bar: usize }
+struct Struct { foo: u32, bar: usize }
 
-impl Default for S {
-    fn default() -> Self {
-        S {
-            foo: 0,
-            bar: 0,
-        }
-    }
+impl Default for Struct {
+    fn default() -> Self {}
 }
 
-fn process(f: S) {
-    let other = S {
+fn foo() {
+    let other = Struct {
         foo: 5,
         .$0
     };
 }
 "#,
             r#"
-struct S { foo: u32, bar: usize }
+struct Struct { foo: u32, bar: usize }
 
-impl Default for S {
-    fn default() -> Self {
-        S {
-            foo: 0,
-            bar: 0,
-        }
-    }
+impl Default for Struct {
+    fn default() -> Self {}
 }
 
-fn process(f: S) {
-    let other = S {
+fn foo() {
+    let other = Struct {
         foo: 5,
         ..Default::default()
     };
 }
 "#,
         );
-    }
-
-    #[test]
-    fn test_record_literal_field_without_default() {
-        let test_code = r#"
-struct S { foo: u32, bar: usize }
-
-fn process(f: S) {
-    let other = S {
-        foo: 5,
-        .$0
-    };
-}
-"#;
-        check(
-            test_code,
-            expect![[r#"
-                fd bar usize
-            "#]],
-        );
-
-        check_snippet(test_code, expect![[r#""#]]);
-    }
-
-    #[test]
-    fn test_record_pattern_field() {
-        check(
-            r#"
-struct S { foo: u32 }
-
-fn process(f: S) {
-    match f {
-        S { f$0: 92 } => (),
-    }
-}
-"#,
-            expect![[r#"
-                fd foo u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_pattern_enum_variant() {
-        check(
-            r#"
-enum E { S { foo: u32, bar: () } }
-
-fn process(e: E) {
-    match e {
-        E::S { $0 } => (),
-    }
-}
-"#,
-            expect![[r#"
-                fd foo u32
-                fd bar ()
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_pattern_field_in_simple_macro() {
-        check(
-            r"
-macro_rules! m { ($e:expr) => { $e } }
-struct S { foo: u32 }
-
-fn process(f: S) {
-    m!(match f {
-        S { f$0: 92 } => (),
-    })
-}
-",
-            expect![[r#"
-                fd foo u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn only_missing_fields_are_completed_in_destruct_pats() {
-        check(
+        check_edit(
+            "..Default::default()",
             r#"
-struct S {
-    foo1: u32, foo2: u32,
-    bar: u32, baz: u32,
-}
+//- minicore: default
+struct Struct { foo: u32, bar: usize }
 
-fn main() {
-    let s = S {
-        foo1: 1, foo2: 2,
-        bar: 3, baz: 4,
-    };
-    if let S { foo1, foo2: a, $0 } = s {}
+impl Default for Struct {
+    fn default() -> Self {}
 }
-"#,
-            expect![[r#"
-                fd bar u32
-                fd baz u32
-            "#]],
-        );
-    }
 
-    #[test]
-    fn test_record_literal_field() {
-        check(
-            r#"
-struct A { the_field: u32 }
 fn foo() {
-   A { the$0 }
-}
-"#,
-            expect![[r#"
-                fd the_field u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_literal_enum_variant() {
-        check(
-            r#"
-enum E { A { a: u32 } }
-fn foo() {
-    let _ = E::A { $0 }
+    let other = Struct {
+        foo: 5,
+        $0
+    };
 }
 "#,
-            expect![[r#"
-                fd a u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_literal_two_structs() {
-        check(
             r#"
-struct A { a: u32 }
-struct B { b: u32 }
+struct Struct { foo: u32, bar: usize }
 
-fn foo() {
-   let _: A = B { $0 }
+impl Default for Struct {
+    fn default() -> Self {}
 }
-"#,
-            expect![[r#"
-                fd b u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_literal_generic_struct() {
-        check(
-            r#"
-struct A<T> { a: T }
 
 fn foo() {
-   let _: A<u32> = A { $0 }
-}
-"#,
-            expect![[r#"
-                fd a u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn test_record_literal_field_in_simple_macro() {
-        check(
-            r#"
-macro_rules! m { ($e:expr) => { $e } }
-struct A { the_field: u32 }
-fn foo() {
-   m!(A { the$0 })
-}
-"#,
-            expect![[r#"
-                fd the_field u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn only_missing_fields_are_completed() {
-        check(
-            r#"
-struct S {
-    foo1: u32, foo2: u32,
-    bar: u32, baz: u32,
-}
-
-fn main() {
-    let foo1 = 1;
-    let s = S { foo1, foo2: 5, $0 }
-}
-"#,
-            expect![[r#"
-                fd bar u32
-                fd baz u32
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_functional_update() {
-        check(
-            r#"
-struct S { foo1: u32, foo2: u32 }
-
-fn main() {
-    let foo1 = 1;
-    let s = S { foo1, $0 .. loop {} }
+    let other = Struct {
+        foo: 5,
+        ..Default::default()
+    };
 }
 "#,
-            expect![[r#"
-                fd foo2 u32
-            "#]],
         );
     }
 }

crates/ide_completion/src/completions/snippet.rs

@@ -108,10 +108,4 @@ mod tests {
             "#]],
         );
     }
-
-    #[test]
-    fn should_not_complete_snippets_in_path() {
-        check(r#"fn foo(x: i32) { ::foo$0 }"#, expect![[""]]);
-        check(r#"fn foo(x: i32) { ::$0 }"#, expect![[""]]);
-    }
 }