diff options
-rw-r--r-- | crates/ra_ide_api/src/diagnostics.rs | 351 | ||||
-rw-r--r-- | crates/ra_ide_api_light/src/diagnostics.rs | 246 | ||||
-rw-r--r-- | crates/ra_ide_api_light/src/lib.rs | 2 |
3 files changed, 298 insertions, 301 deletions
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs index 53d95fb4c..069092528 100644 --- a/crates/ra_ide_api/src/diagnostics.rs +++ b/crates/ra_ide_api/src/diagnostics.rs | |||
@@ -1,65 +1,310 @@ | |||
1 | use itertools::Itertools; | ||
1 | use hir::{Problem, source_binder}; | 2 | use hir::{Problem, source_binder}; |
2 | use ra_ide_api_light::Severity; | 3 | use ra_ide_api_light::Severity; |
3 | use ra_db::SourceDatabase; | 4 | use ra_db::SourceDatabase; |
5 | use ra_syntax::{ | ||
6 | Location, SourceFile, SyntaxKind, TextRange, SyntaxNode, | ||
7 | ast::{self, AstNode}, | ||
4 | 8 | ||
5 | use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, db::RootDatabase}; | 9 | }; |
10 | use ra_text_edit::{TextEdit, TextEditBuilder}; | ||
11 | |||
12 | use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit, db::RootDatabase}; | ||
6 | 13 | ||
7 | pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic> { | 14 | pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic> { |
8 | let syntax = db.parse(file_id); | 15 | let source_file = db.parse(file_id); |
9 | 16 | let mut res = Vec::new(); | |
10 | let mut res = ra_ide_api_light::diagnostics(&syntax) | 17 | |
11 | .into_iter() | 18 | syntax_errors(&mut res, &source_file); |
12 | .map(|d| Diagnostic { | 19 | |
13 | range: d.range, | 20 | for node in source_file.syntax().descendants() { |
14 | message: d.msg, | 21 | check_unnecessary_braces_in_use_statement(&mut res, file_id, node); |
15 | severity: d.severity, | 22 | check_struct_shorthand_initialization(&mut res, file_id, node); |
16 | fix: d.fix.map(|fix| SourceChange::from_local_edit(file_id, fix)), | 23 | } |
17 | }) | 24 | |
18 | .collect::<Vec<_>>(); | ||
19 | if let Some(m) = source_binder::module_from_file_id(db, file_id) { | 25 | if let Some(m) = source_binder::module_from_file_id(db, file_id) { |
20 | for (name_node, problem) in m.problems(db) { | 26 | check_module(&mut res, db, file_id, m); |
21 | let source_root = db.file_source_root(file_id); | 27 | }; |
22 | let diag = match problem { | 28 | res |
23 | Problem::UnresolvedModule { candidate } => { | 29 | } |
24 | let create_file = | 30 | |
25 | FileSystemEdit::CreateFile { source_root, path: candidate.clone() }; | 31 | fn syntax_errors(acc: &mut Vec<Diagnostic>, source_file: &SourceFile) { |
26 | let fix = SourceChange { | 32 | fn location_to_range(location: Location) -> TextRange { |
27 | label: "create module".to_string(), | 33 | match location { |
28 | source_file_edits: Vec::new(), | 34 | Location::Offset(offset) => TextRange::offset_len(offset, 1.into()), |
29 | file_system_edits: vec![create_file], | 35 | Location::Range(range) => range, |
36 | } | ||
37 | } | ||
38 | |||
39 | acc.extend(source_file.errors().into_iter().map(|err| Diagnostic { | ||
40 | range: location_to_range(err.location()), | ||
41 | message: format!("Syntax Error: {}", err), | ||
42 | severity: Severity::Error, | ||
43 | fix: None, | ||
44 | })); | ||
45 | } | ||
46 | |||
47 | fn check_unnecessary_braces_in_use_statement( | ||
48 | acc: &mut Vec<Diagnostic>, | ||
49 | file_id: FileId, | ||
50 | node: &SyntaxNode, | ||
51 | ) -> Option<()> { | ||
52 | let use_tree_list = ast::UseTreeList::cast(node)?; | ||
53 | if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() { | ||
54 | let range = use_tree_list.syntax().range(); | ||
55 | let edit = | ||
56 | text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree) | ||
57 | .unwrap_or_else(|| { | ||
58 | let to_replace = single_use_tree.syntax().text().to_string(); | ||
59 | let mut edit_builder = TextEditBuilder::default(); | ||
60 | edit_builder.delete(range); | ||
61 | edit_builder.insert(range.start(), to_replace); | ||
62 | edit_builder.finish() | ||
63 | }); | ||
64 | |||
65 | acc.push(Diagnostic { | ||
66 | range, | ||
67 | message: format!("Unnecessary braces in use statement"), | ||
68 | severity: Severity::WeakWarning, | ||
69 | fix: Some(SourceChange { | ||
70 | label: "Remove unnecessary braces".to_string(), | ||
71 | source_file_edits: vec![SourceFileEdit { file_id, edit }], | ||
72 | file_system_edits: Vec::new(), | ||
73 | cursor_position: None, | ||
74 | }), | ||
75 | }); | ||
76 | } | ||
77 | |||
78 | Some(()) | ||
79 | } | ||
80 | |||
81 | fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement( | ||
82 | single_use_tree: &ast::UseTree, | ||
83 | ) -> Option<TextEdit> { | ||
84 | let use_tree_list_node = single_use_tree.syntax().parent()?; | ||
85 | if single_use_tree.path()?.segment()?.syntax().first_child()?.kind() == SyntaxKind::SELF_KW { | ||
86 | let start = use_tree_list_node.prev_sibling()?.range().start(); | ||
87 | let end = use_tree_list_node.range().end(); | ||
88 | let range = TextRange::from_to(start, end); | ||
89 | let mut edit_builder = TextEditBuilder::default(); | ||
90 | edit_builder.delete(range); | ||
91 | return Some(edit_builder.finish()); | ||
92 | } | ||
93 | None | ||
94 | } | ||
95 | |||
96 | fn check_struct_shorthand_initialization( | ||
97 | acc: &mut Vec<Diagnostic>, | ||
98 | file_id: FileId, | ||
99 | node: &SyntaxNode, | ||
100 | ) -> Option<()> { | ||
101 | let struct_lit = ast::StructLit::cast(node)?; | ||
102 | let named_field_list = struct_lit.named_field_list()?; | ||
103 | for named_field in named_field_list.fields() { | ||
104 | if let (Some(name_ref), Some(expr)) = (named_field.name_ref(), named_field.expr()) { | ||
105 | let field_name = name_ref.syntax().text().to_string(); | ||
106 | let field_expr = expr.syntax().text().to_string(); | ||
107 | if field_name == field_expr { | ||
108 | let mut edit_builder = TextEditBuilder::default(); | ||
109 | edit_builder.delete(named_field.syntax().range()); | ||
110 | edit_builder.insert(named_field.syntax().range().start(), field_name); | ||
111 | let edit = edit_builder.finish(); | ||
112 | |||
113 | acc.push(Diagnostic { | ||
114 | range: named_field.syntax().range(), | ||
115 | message: format!("Shorthand struct initialization"), | ||
116 | severity: Severity::WeakWarning, | ||
117 | fix: Some(SourceChange { | ||
118 | label: "use struct shorthand initialization".to_string(), | ||
119 | source_file_edits: vec![SourceFileEdit { file_id, edit }], | ||
120 | file_system_edits: Vec::new(), | ||
30 | cursor_position: None, | 121 | cursor_position: None, |
31 | }; | 122 | }), |
32 | Diagnostic { | 123 | }); |
33 | range: name_node.range(), | 124 | } |
34 | message: "unresolved module".to_string(), | 125 | } |
35 | severity: Severity::Error, | 126 | } |
36 | fix: Some(fix), | 127 | Some(()) |
37 | } | 128 | } |
129 | |||
130 | fn check_module( | ||
131 | acc: &mut Vec<Diagnostic>, | ||
132 | db: &RootDatabase, | ||
133 | file_id: FileId, | ||
134 | module: hir::Module, | ||
135 | ) { | ||
136 | let source_root = db.file_source_root(file_id); | ||
137 | for (name_node, problem) in module.problems(db) { | ||
138 | let diag = match problem { | ||
139 | Problem::UnresolvedModule { candidate } => { | ||
140 | let create_file = | ||
141 | FileSystemEdit::CreateFile { source_root, path: candidate.clone() }; | ||
142 | let fix = SourceChange { | ||
143 | label: "create module".to_string(), | ||
144 | source_file_edits: Vec::new(), | ||
145 | file_system_edits: vec![create_file], | ||
146 | cursor_position: None, | ||
147 | }; | ||
148 | Diagnostic { | ||
149 | range: name_node.range(), | ||
150 | message: "unresolved module".to_string(), | ||
151 | severity: Severity::Error, | ||
152 | fix: Some(fix), | ||
38 | } | 153 | } |
39 | Problem::NotDirOwner { move_to, candidate } => { | 154 | } |
40 | let move_file = FileSystemEdit::MoveFile { | 155 | Problem::NotDirOwner { move_to, candidate } => { |
41 | src: file_id, | 156 | let move_file = FileSystemEdit::MoveFile { |
42 | dst_source_root: source_root, | 157 | src: file_id, |
43 | dst_path: move_to.clone(), | 158 | dst_source_root: source_root, |
44 | }; | 159 | dst_path: move_to.clone(), |
45 | let create_file = | 160 | }; |
46 | FileSystemEdit::CreateFile { source_root, path: move_to.join(candidate) }; | 161 | let create_file = |
47 | let fix = SourceChange { | 162 | FileSystemEdit::CreateFile { source_root, path: move_to.join(candidate) }; |
48 | label: "move file and create module".to_string(), | 163 | let fix = SourceChange { |
49 | source_file_edits: Vec::new(), | 164 | label: "move file and create module".to_string(), |
50 | file_system_edits: vec![move_file, create_file], | 165 | source_file_edits: Vec::new(), |
51 | cursor_position: None, | 166 | file_system_edits: vec![move_file, create_file], |
52 | }; | 167 | cursor_position: None, |
53 | Diagnostic { | 168 | }; |
54 | range: name_node.range(), | 169 | Diagnostic { |
55 | message: "can't declare module at this location".to_string(), | 170 | range: name_node.range(), |
56 | severity: Severity::Error, | 171 | message: "can't declare module at this location".to_string(), |
57 | fix: Some(fix), | 172 | severity: Severity::Error, |
58 | } | 173 | fix: Some(fix), |
59 | } | 174 | } |
60 | }; | 175 | } |
61 | res.push(diag) | 176 | }; |
177 | acc.push(diag) | ||
178 | } | ||
179 | } | ||
180 | |||
181 | #[cfg(test)] | ||
182 | mod tests { | ||
183 | use test_utils::assert_eq_text; | ||
184 | |||
185 | use super::*; | ||
186 | |||
187 | type DiagnosticChecker = fn(&mut Vec<Diagnostic>, FileId, &SyntaxNode) -> Option<()>; | ||
188 | |||
189 | fn check_not_applicable(code: &str, func: DiagnosticChecker) { | ||
190 | let file = SourceFile::parse(code); | ||
191 | let mut diagnostics = Vec::new(); | ||
192 | for node in file.syntax().descendants() { | ||
193 | func(&mut diagnostics, FileId(0), node); | ||
62 | } | 194 | } |
63 | }; | 195 | assert!(diagnostics.is_empty()); |
64 | res | 196 | } |
197 | |||
198 | fn check_apply(before: &str, after: &str, func: DiagnosticChecker) { | ||
199 | let file = SourceFile::parse(before); | ||
200 | let mut diagnostics = Vec::new(); | ||
201 | for node in file.syntax().descendants() { | ||
202 | func(&mut diagnostics, FileId(0), node); | ||
203 | } | ||
204 | let diagnostic = | ||
205 | diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before)); | ||
206 | let mut fix = diagnostic.fix.unwrap(); | ||
207 | let edit = fix.source_file_edits.pop().unwrap().edit; | ||
208 | let actual = edit.apply(&before); | ||
209 | assert_eq_text!(after, &actual); | ||
210 | } | ||
211 | |||
212 | #[test] | ||
213 | fn test_check_unnecessary_braces_in_use_statement() { | ||
214 | check_not_applicable( | ||
215 | " | ||
216 | use a; | ||
217 | use a::{c, d::e}; | ||
218 | ", | ||
219 | check_unnecessary_braces_in_use_statement, | ||
220 | ); | ||
221 | check_apply("use {b};", "use b;", check_unnecessary_braces_in_use_statement); | ||
222 | check_apply("use a::{c};", "use a::c;", check_unnecessary_braces_in_use_statement); | ||
223 | check_apply("use a::{self};", "use a;", check_unnecessary_braces_in_use_statement); | ||
224 | check_apply( | ||
225 | "use a::{c, d::{e}};", | ||
226 | "use a::{c, d::e};", | ||
227 | check_unnecessary_braces_in_use_statement, | ||
228 | ); | ||
229 | } | ||
230 | |||
231 | #[test] | ||
232 | fn test_check_struct_shorthand_initialization() { | ||
233 | check_not_applicable( | ||
234 | r#" | ||
235 | struct A { | ||
236 | a: &'static str | ||
237 | } | ||
238 | |||
239 | fn main() { | ||
240 | A { | ||
241 | a: "hello" | ||
242 | } | ||
243 | } | ||
244 | "#, | ||
245 | check_struct_shorthand_initialization, | ||
246 | ); | ||
247 | |||
248 | check_apply( | ||
249 | r#" | ||
250 | struct A { | ||
251 | a: &'static str | ||
252 | } | ||
253 | |||
254 | fn main() { | ||
255 | let a = "haha"; | ||
256 | A { | ||
257 | a: a | ||
258 | } | ||
259 | } | ||
260 | "#, | ||
261 | r#" | ||
262 | struct A { | ||
263 | a: &'static str | ||
264 | } | ||
265 | |||
266 | fn main() { | ||
267 | let a = "haha"; | ||
268 | A { | ||
269 | a | ||
270 | } | ||
271 | } | ||
272 | "#, | ||
273 | check_struct_shorthand_initialization, | ||
274 | ); | ||
275 | |||
276 | check_apply( | ||
277 | r#" | ||
278 | struct A { | ||
279 | a: &'static str, | ||
280 | b: &'static str | ||
281 | } | ||
282 | |||
283 | fn main() { | ||
284 | let a = "haha"; | ||
285 | let b = "bb"; | ||
286 | A { | ||
287 | a: a, | ||
288 | b | ||
289 | } | ||
290 | } | ||
291 | "#, | ||
292 | r#" | ||
293 | struct A { | ||
294 | a: &'static str, | ||
295 | b: &'static str | ||
296 | } | ||
297 | |||
298 | fn main() { | ||
299 | let a = "haha"; | ||
300 | let b = "bb"; | ||
301 | A { | ||
302 | a, | ||
303 | b | ||
304 | } | ||
305 | } | ||
306 | "#, | ||
307 | check_struct_shorthand_initialization, | ||
308 | ); | ||
309 | } | ||
65 | } | 310 | } |
diff --git a/crates/ra_ide_api_light/src/diagnostics.rs b/crates/ra_ide_api_light/src/diagnostics.rs deleted file mode 100644 index 7c383ca2a..000000000 --- a/crates/ra_ide_api_light/src/diagnostics.rs +++ /dev/null | |||
@@ -1,246 +0,0 @@ | |||
1 | use itertools::Itertools; | ||
2 | |||
3 | use ra_syntax::{ | ||
4 | Location, SourceFile, SyntaxKind, TextRange, SyntaxNode, | ||
5 | ast::{self, AstNode}, | ||
6 | |||
7 | }; | ||
8 | use ra_text_edit::{TextEdit, TextEditBuilder}; | ||
9 | |||
10 | use crate::{Diagnostic, LocalEdit, Severity}; | ||
11 | |||
12 | pub fn diagnostics(file: &SourceFile) -> Vec<Diagnostic> { | ||
13 | fn location_to_range(location: Location) -> TextRange { | ||
14 | match location { | ||
15 | Location::Offset(offset) => TextRange::offset_len(offset, 1.into()), | ||
16 | Location::Range(range) => range, | ||
17 | } | ||
18 | } | ||
19 | |||
20 | let mut errors: Vec<Diagnostic> = file | ||
21 | .errors() | ||
22 | .into_iter() | ||
23 | .map(|err| Diagnostic { | ||
24 | range: location_to_range(err.location()), | ||
25 | msg: format!("Syntax Error: {}", err), | ||
26 | severity: Severity::Error, | ||
27 | fix: None, | ||
28 | }) | ||
29 | .collect(); | ||
30 | |||
31 | for node in file.syntax().descendants() { | ||
32 | check_unnecessary_braces_in_use_statement(&mut errors, node); | ||
33 | check_struct_shorthand_initialization(&mut errors, node); | ||
34 | } | ||
35 | |||
36 | errors | ||
37 | } | ||
38 | |||
39 | fn check_unnecessary_braces_in_use_statement( | ||
40 | acc: &mut Vec<Diagnostic>, | ||
41 | node: &SyntaxNode, | ||
42 | ) -> Option<()> { | ||
43 | let use_tree_list = ast::UseTreeList::cast(node)?; | ||
44 | if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() { | ||
45 | let range = use_tree_list.syntax().range(); | ||
46 | let edit = | ||
47 | text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree) | ||
48 | .unwrap_or_else(|| { | ||
49 | let to_replace = single_use_tree.syntax().text().to_string(); | ||
50 | let mut edit_builder = TextEditBuilder::default(); | ||
51 | edit_builder.delete(range); | ||
52 | edit_builder.insert(range.start(), to_replace); | ||
53 | edit_builder.finish() | ||
54 | }); | ||
55 | |||
56 | acc.push(Diagnostic { | ||
57 | range, | ||
58 | msg: format!("Unnecessary braces in use statement"), | ||
59 | severity: Severity::WeakWarning, | ||
60 | fix: Some(LocalEdit { | ||
61 | label: "Remove unnecessary braces".to_string(), | ||
62 | edit, | ||
63 | cursor_position: None, | ||
64 | }), | ||
65 | }); | ||
66 | } | ||
67 | |||
68 | Some(()) | ||
69 | } | ||
70 | |||
71 | fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement( | ||
72 | single_use_tree: &ast::UseTree, | ||
73 | ) -> Option<TextEdit> { | ||
74 | let use_tree_list_node = single_use_tree.syntax().parent()?; | ||
75 | if single_use_tree.path()?.segment()?.syntax().first_child()?.kind() == SyntaxKind::SELF_KW { | ||
76 | let start = use_tree_list_node.prev_sibling()?.range().start(); | ||
77 | let end = use_tree_list_node.range().end(); | ||
78 | let range = TextRange::from_to(start, end); | ||
79 | let mut edit_builder = TextEditBuilder::default(); | ||
80 | edit_builder.delete(range); | ||
81 | return Some(edit_builder.finish()); | ||
82 | } | ||
83 | None | ||
84 | } | ||
85 | |||
86 | fn check_struct_shorthand_initialization( | ||
87 | acc: &mut Vec<Diagnostic>, | ||
88 | node: &SyntaxNode, | ||
89 | ) -> Option<()> { | ||
90 | let struct_lit = ast::StructLit::cast(node)?; | ||
91 | let named_field_list = struct_lit.named_field_list()?; | ||
92 | for named_field in named_field_list.fields() { | ||
93 | if let (Some(name_ref), Some(expr)) = (named_field.name_ref(), named_field.expr()) { | ||
94 | let field_name = name_ref.syntax().text().to_string(); | ||
95 | let field_expr = expr.syntax().text().to_string(); | ||
96 | if field_name == field_expr { | ||
97 | let mut edit_builder = TextEditBuilder::default(); | ||
98 | edit_builder.delete(named_field.syntax().range()); | ||
99 | edit_builder.insert(named_field.syntax().range().start(), field_name); | ||
100 | let edit = edit_builder.finish(); | ||
101 | |||
102 | acc.push(Diagnostic { | ||
103 | range: named_field.syntax().range(), | ||
104 | msg: format!("Shorthand struct initialization"), | ||
105 | severity: Severity::WeakWarning, | ||
106 | fix: Some(LocalEdit { | ||
107 | label: "use struct shorthand initialization".to_string(), | ||
108 | edit, | ||
109 | cursor_position: None, | ||
110 | }), | ||
111 | }); | ||
112 | } | ||
113 | } | ||
114 | } | ||
115 | Some(()) | ||
116 | } | ||
117 | |||
118 | #[cfg(test)] | ||
119 | mod tests { | ||
120 | use crate::test_utils::assert_eq_text; | ||
121 | |||
122 | use super::*; | ||
123 | |||
124 | type DiagnosticChecker = fn(&mut Vec<Diagnostic>, &SyntaxNode) -> Option<()>; | ||
125 | |||
126 | fn check_not_applicable(code: &str, func: DiagnosticChecker) { | ||
127 | let file = SourceFile::parse(code); | ||
128 | let mut diagnostics = Vec::new(); | ||
129 | for node in file.syntax().descendants() { | ||
130 | func(&mut diagnostics, node); | ||
131 | } | ||
132 | assert!(diagnostics.is_empty()); | ||
133 | } | ||
134 | |||
135 | fn check_apply(before: &str, after: &str, func: DiagnosticChecker) { | ||
136 | let file = SourceFile::parse(before); | ||
137 | let mut diagnostics = Vec::new(); | ||
138 | for node in file.syntax().descendants() { | ||
139 | func(&mut diagnostics, node); | ||
140 | } | ||
141 | let diagnostic = | ||
142 | diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before)); | ||
143 | let fix = diagnostic.fix.unwrap(); | ||
144 | let actual = fix.edit.apply(&before); | ||
145 | assert_eq_text!(after, &actual); | ||
146 | } | ||
147 | |||
148 | #[test] | ||
149 | fn test_check_unnecessary_braces_in_use_statement() { | ||
150 | check_not_applicable( | ||
151 | " | ||
152 | use a; | ||
153 | use a::{c, d::e}; | ||
154 | ", | ||
155 | check_unnecessary_braces_in_use_statement, | ||
156 | ); | ||
157 | check_apply("use {b};", "use b;", check_unnecessary_braces_in_use_statement); | ||
158 | check_apply("use a::{c};", "use a::c;", check_unnecessary_braces_in_use_statement); | ||
159 | check_apply("use a::{self};", "use a;", check_unnecessary_braces_in_use_statement); | ||
160 | check_apply( | ||
161 | "use a::{c, d::{e}};", | ||
162 | "use a::{c, d::e};", | ||
163 | check_unnecessary_braces_in_use_statement, | ||
164 | ); | ||
165 | } | ||
166 | |||
167 | #[test] | ||
168 | fn test_check_struct_shorthand_initialization() { | ||
169 | check_not_applicable( | ||
170 | r#" | ||
171 | struct A { | ||
172 | a: &'static str | ||
173 | } | ||
174 | |||
175 | fn main() { | ||
176 | A { | ||
177 | a: "hello" | ||
178 | } | ||
179 | } | ||
180 | "#, | ||
181 | check_struct_shorthand_initialization, | ||
182 | ); | ||
183 | |||
184 | check_apply( | ||
185 | r#" | ||
186 | struct A { | ||
187 | a: &'static str | ||
188 | } | ||
189 | |||
190 | fn main() { | ||
191 | let a = "haha"; | ||
192 | A { | ||
193 | a: a | ||
194 | } | ||
195 | } | ||
196 | "#, | ||
197 | r#" | ||
198 | struct A { | ||
199 | a: &'static str | ||
200 | } | ||
201 | |||
202 | fn main() { | ||
203 | let a = "haha"; | ||
204 | A { | ||
205 | a | ||
206 | } | ||
207 | } | ||
208 | "#, | ||
209 | check_struct_shorthand_initialization, | ||
210 | ); | ||
211 | |||
212 | check_apply( | ||
213 | r#" | ||
214 | struct A { | ||
215 | a: &'static str, | ||
216 | b: &'static str | ||
217 | } | ||
218 | |||
219 | fn main() { | ||
220 | let a = "haha"; | ||
221 | let b = "bb"; | ||
222 | A { | ||
223 | a: a, | ||
224 | b | ||
225 | } | ||
226 | } | ||
227 | "#, | ||
228 | r#" | ||
229 | struct A { | ||
230 | a: &'static str, | ||
231 | b: &'static str | ||
232 | } | ||
233 | |||
234 | fn main() { | ||
235 | let a = "haha"; | ||
236 | let b = "bb"; | ||
237 | A { | ||
238 | a, | ||
239 | b | ||
240 | } | ||
241 | } | ||
242 | "#, | ||
243 | check_struct_shorthand_initialization, | ||
244 | ); | ||
245 | } | ||
246 | } | ||
diff --git a/crates/ra_ide_api_light/src/lib.rs b/crates/ra_ide_api_light/src/lib.rs index ca13eb018..47b30255b 100644 --- a/crates/ra_ide_api_light/src/lib.rs +++ b/crates/ra_ide_api_light/src/lib.rs | |||
@@ -11,7 +11,6 @@ mod structure; | |||
11 | mod test_utils; | 11 | mod test_utils; |
12 | mod join_lines; | 12 | mod join_lines; |
13 | mod typing; | 13 | mod typing; |
14 | mod diagnostics; | ||
15 | 14 | ||
16 | use rustc_hash::FxHashSet; | 15 | use rustc_hash::FxHashSet; |
17 | use ra_text_edit::TextEditBuilder; | 16 | use ra_text_edit::TextEditBuilder; |
@@ -27,7 +26,6 @@ pub use crate::{ | |||
27 | line_index::{LineCol, LineIndex}, | 26 | line_index::{LineCol, LineIndex}, |
28 | line_index_utils::translate_offset_with_edit, | 27 | line_index_utils::translate_offset_with_edit, |
29 | structure::{file_structure, StructureNode}, | 28 | structure::{file_structure, StructureNode}, |
30 | diagnostics::diagnostics, | ||
31 | join_lines::join_lines, | 29 | join_lines::join_lines, |
32 | typing::{on_enter, on_dot_typed, on_eq_typed}, | 30 | typing::{on_enter, on_dot_typed, on_eq_typed}, |
33 | }; | 31 | }; |