1 files changed, 0 insertions, 241 deletions
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
deleted file mode 100644
index e4e764f58..000000000
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-//! FIXME: write short doc here
-use crate::completion::{CompletionContext, Completions};
-use ra_syntax::SmolStr;
-/// Complete fields in fields literals.
-pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
-    let (ty, variant) = match ctx.record_lit_syntax.as_ref().and_then(|it| {
-        Some((ctx.sema.type_of_expr(&it.clone().into())?, ctx.sema.resolve_record_literal(it)?))
-    }) {
-        Some(it) => it,
-        _ => return,
-    };
-    let already_present_names: Vec<SmolStr> = ctx
-        .record_lit_syntax
-        .as_ref()
-        .and_then(|record_literal| record_literal.record_field_list())
-        .map(|field_list| field_list.fields())
-        .map(|fields| {
-            fields
-                .into_iter()
-                .filter_map(|field| field.name_ref())
-                .map(|name_ref| name_ref.text().clone())
-                .collect()
-        })
-        .unwrap_or_default();
-    for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
-        if !already_present_names.contains(&SmolStr::from(field.name(ctx.db).to_string())) {
-            acc.add_field(ctx, field, &field_ty);
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
-    }
-    #[test]
-    fn test_record_literal_deprecated_field() {
-        let completions = complete(
-            r"
-            struct A {
-                #[deprecated]
-                the_field: u32,
-            }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [142; 145),
-                delete: [142; 145),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                deprecated: true,
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_field() {
-        let completions = complete(
-            r"
-            struct A { the_field: u32 }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [83; 86),
-                delete: [83; 86),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_enum_variant() {
-        let completions = complete(
-            r"
-            enum E {
-                A { a: u32 }
-            }
-            fn foo() {
-                let _ = E::A { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: [119; 119),
-                delete: [119; 119),
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_two_structs() {
-        let completions = complete(
-            r"
-            struct A { a: u32 }
-            struct B { b: u32 }
-            fn foo() {
-               let _: A = B { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "b",
-                source_range: [119; 119),
-                delete: [119; 119),
-                insert: "b",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_generic_struct() {
-        let completions = complete(
-            r"
-            struct A<T> { a: T }
-            fn foo() {
-               let _: A<u32> = A { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: [93; 93),
-                delete: [93; 93),
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_field_in_simple_macro() {
-        let completions = complete(
-            r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct A { the_field: u32 }
-            fn foo() {
-               m!(A { the<|> })
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [137; 140),
-                delete: [137; 140),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn only_missing_fields_are_completed() {
-        let completions = complete(
-            r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    foo2: 5,
-                    <|>
-                }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: [302; 302),
-                delete: [302; 302),
-                insert: "bar",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "baz",
-                source_range: [302; 302),
-                delete: [302; 302),
-                insert: "baz",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-}

diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs deleted file mode 100644 index e4e764f58..000000000 --- a/crates/ra_ide/src/completion/complete_record_literal.rs +++ /dev/null
@@ -1,241 +0,0 @@
1	//! FIXME: write short doc here
2
3	use crate::completion::{CompletionContext, Completions};
4	use ra_syntax::SmolStr;
5
6	/// Complete fields in fields literals.
7	pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
8	let (ty, variant) = match ctx.record_lit_syntax.as_ref().and_then(\|it\| {
9	Some((ctx.sema.type_of_expr(&it.clone().into())?, ctx.sema.resolve_record_literal(it)?))
10	}) {
11	Some(it) => it,
12	_ => return,
13	};
14
15	let already_present_names: Vec<SmolStr> = ctx
16	.record_lit_syntax
17	.as_ref()
18	.and_then(\|record_literal\| record_literal.record_field_list())
19	.map(\|field_list\| field_list.fields())
20	.map(\|fields\| {
21	fields
22	.into_iter()
23	.filter_map(\|field\| field.name_ref())
24	.map(\|name_ref\| name_ref.text().clone())
25	.collect()
26	})
27	.unwrap_or_default();
28
29	for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
30	if !already_present_names.contains(&SmolStr::from(field.name(ctx.db).to_string())) {
31	acc.add_field(ctx, field, &field_ty);
32	}
33	}
34	}
35
36	#[cfg(test)]
37	mod tests {
38	use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
39	use insta::assert_debug_snapshot;
40
41	fn complete(code: &str) -> Vec<CompletionItem> {
42	do_completion(code, CompletionKind::Reference)
43	}
44
45	#[test]
46	fn test_record_literal_deprecated_field() {
47	let completions = complete(
48	r"
49	struct A {
50	#[deprecated]
51	the_field: u32,
52	}
53	fn foo() {
54	A { the<\|> }
55	}
56	",
57	);
58	assert_debug_snapshot!(completions, @r###"
59	[
60	CompletionItem {
61	label: "the_field",
62	source_range: [142; 145),
63	delete: [142; 145),
64	insert: "the_field",
65	kind: Field,
66	detail: "u32",
67	deprecated: true,
68	},
69	]
70	"###);
71	}
72
73	#[test]
74	fn test_record_literal_field() {
75	let completions = complete(
76	r"
77	struct A { the_field: u32 }
78	fn foo() {
79	A { the<\|> }
80	}
81	",
82	);
83	assert_debug_snapshot!(completions, @r###"
84	[
85	CompletionItem {
86	label: "the_field",
87	source_range: [83; 86),
88	delete: [83; 86),
89	insert: "the_field",
90	kind: Field,
91	detail: "u32",
92	},
93	]
94	"###);
95	}
96
97	#[test]
98	fn test_record_literal_enum_variant() {
99	let completions = complete(
100	r"
101	enum E {
102	A { a: u32 }
103	}
104	fn foo() {
105	let _ = E::A { <\|> }
106	}
107	",
108	);
109	assert_debug_snapshot!(completions, @r###"
110	[
111	CompletionItem {
112	label: "a",
113	source_range: [119; 119),
114	delete: [119; 119),
115	insert: "a",
116	kind: Field,
117	detail: "u32",
118	},
119	]
120	"###);
121	}
122
123	#[test]
124	fn test_record_literal_two_structs() {
125	let completions = complete(
126	r"
127	struct A { a: u32 }
128	struct B { b: u32 }
129
130	fn foo() {
131	let _: A = B { <\|> }
132	}
133	",
134	);
135	assert_debug_snapshot!(completions, @r###"
136	[
137	CompletionItem {
138	label: "b",
139	source_range: [119; 119),
140	delete: [119; 119),
141	insert: "b",
142	kind: Field,
143	detail: "u32",
144	},
145	]
146	"###);
147	}
148
149	#[test]
150	fn test_record_literal_generic_struct() {
151	let completions = complete(
152	r"
153	struct A<T> { a: T }
154
155	fn foo() {
156	let _: A<u32> = A { <\|> }
157	}
158	",
159	);
160	assert_debug_snapshot!(completions, @r###"
161	[
162	CompletionItem {
163	label: "a",
164	source_range: [93; 93),
165	delete: [93; 93),
166	insert: "a",
167	kind: Field,
168	detail: "u32",
169	},
170	]
171	"###);
172	}
173
174	#[test]
175	fn test_record_literal_field_in_simple_macro() {
176	let completions = complete(
177	r"
178	macro_rules! m { ($e:expr) => { $e } }
179	struct A { the_field: u32 }
180	fn foo() {
181	m!(A { the<\|> })
182	}
183	",
184	);
185	assert_debug_snapshot!(completions, @r###"
186	[
187	CompletionItem {
188	label: "the_field",
189	source_range: [137; 140),
190	delete: [137; 140),
191	insert: "the_field",
192	kind: Field,
193	detail: "u32",
194	},
195	]
196	"###);
197	}
198
199	#[test]
200	fn only_missing_fields_are_completed() {
201	let completions = complete(
202	r"
203	struct S {
204	foo1: u32,
205	foo2: u32,
206	bar: u32,
207	baz: u32,
208	}
209
210	fn main() {
211	let foo1 = 1;
212	let s = S {
213	foo1,
214	foo2: 5,
215	<\|>
216	}
217	}
218	",
219	);
220	assert_debug_snapshot!(completions, @r###"
221	[
222	CompletionItem {
223	label: "bar",
224	source_range: [302; 302),
225	delete: [302; 302),
226	insert: "bar",
227	kind: Field,
228	detail: "u32",
229	},
230	CompletionItem {
231	label: "baz",
232	source_range: [302; 302),
233	delete: [302; 302),
234	insert: "baz",
235	kind: Field,
236	detail: "u32",
237	},
238	]
239	"###);
240	}
241	}