aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--crates/ra_editor/src/diagnostics.rs266
-rw-r--r--crates/ra_editor/src/lib.rs114
2 files changed, 268 insertions, 112 deletions
diff --git a/crates/ra_editor/src/diagnostics.rs b/crates/ra_editor/src/diagnostics.rs
new file mode 100644
index 000000000..d1667fd7c
--- /dev/null
+++ b/crates/ra_editor/src/diagnostics.rs
@@ -0,0 +1,266 @@
1use itertools::Itertools;
2
3use ra_syntax::{
4 ast::{self, AstNode},
5 Location,
6 SourceFileNode,
7 SyntaxKind,
8 TextRange,
9};
10use ra_text_edit::{
11 TextEdit,
12 TextEditBuilder,
13};
14
15use crate::{
16 Diagnostic,
17 LocalEdit,
18 Severity,
19};
20
21pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
22 fn location_to_range(location: Location) -> TextRange {
23 match location {
24 Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
25 Location::Range(range) => range,
26 }
27 }
28
29 let mut errors: Vec<Diagnostic> = file
30 .errors()
31 .into_iter()
32 .map(|err| Diagnostic {
33 range: location_to_range(err.location()),
34 msg: format!("Syntax Error: {}", err),
35 severity: Severity::Error,
36 fix: None,
37 })
38 .collect();
39
40 errors.extend(check_unnecessary_braces_in_use_statement(file));
41 errors.extend(check_struct_shorthand_initialization(file));
42 errors
43}
44
45fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagnostic> {
46 let mut diagnostics = Vec::new();
47 for use_tree_list in file
48 .syntax()
49 .descendants()
50 .filter_map(ast::UseTreeList::cast)
51 {
52 if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
53 let range = use_tree_list.syntax().range();
54 let edit =
55 text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree)
56 .unwrap_or_else(|| {
57 let to_replace = single_use_tree.syntax().text().to_string();
58 let mut edit_builder = TextEditBuilder::new();
59 edit_builder.delete(range);
60 edit_builder.insert(range.start(), to_replace);
61 edit_builder.finish()
62 });
63
64 diagnostics.push(Diagnostic {
65 range,
66 msg: format!("Unnecessary braces in use statement"),
67 severity: Severity::WeakWarning,
68 fix: Some(LocalEdit {
69 label: "Remove unnecessary braces".to_string(),
70 edit,
71 cursor_position: None,
72 }),
73 })
74 }
75 }
76
77 diagnostics
78}
79
80fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
81 single_use_tree: ast::UseTree,
82) -> Option<TextEdit> {
83 let use_tree_list_node = single_use_tree.syntax().parent()?;
84 if single_use_tree
85 .path()?
86 .segment()?
87 .syntax()
88 .first_child()?
89 .kind()
90 == SyntaxKind::SELF_KW
91 {
92 let start = use_tree_list_node.prev_sibling()?.range().start();
93 let end = use_tree_list_node.range().end();
94 let range = TextRange::from_to(start, end);
95 let mut edit_builder = TextEditBuilder::new();
96 edit_builder.delete(range);
97 return Some(edit_builder.finish());
98 }
99 None
100}
101
102fn check_struct_shorthand_initialization(file: &SourceFileNode) -> Vec<Diagnostic> {
103 let mut diagnostics = Vec::new();
104 for struct_lit in file.syntax().descendants().filter_map(ast::StructLit::cast) {
105 if let Some(named_field_list) = struct_lit.named_field_list() {
106 for named_field in named_field_list.fields() {
107 if let (Some(name_ref), Some(expr)) = (named_field.name_ref(), named_field.expr()) {
108 let field_name = name_ref.syntax().text().to_string();
109 let field_expr = expr.syntax().text().to_string();
110 if field_name == field_expr {
111 let mut edit_builder = TextEditBuilder::new();
112 edit_builder.delete(named_field.syntax().range());
113 edit_builder.insert(named_field.syntax().range().start(), field_name);
114 let edit = edit_builder.finish();
115
116 diagnostics.push(Diagnostic {
117 range: named_field.syntax().range(),
118 msg: format!("Shorthand struct initialization"),
119 severity: Severity::WeakWarning,
120 fix: Some(LocalEdit {
121 label: "use struct shorthand initialization".to_string(),
122 edit,
123 cursor_position: None,
124 }),
125 });
126 }
127 }
128 }
129 }
130 }
131 diagnostics
132}
133
134#[cfg(test)]
135mod tests {
136 use crate::test_utils::assert_eq_text;
137
138 use super::*;
139
140 fn check_not_applicable(code: &str, func: fn(file: &SourceFileNode) -> Vec<Diagnostic>) {
141 let file = SourceFileNode::parse(code);
142 let diagnostics = func(&file);
143 assert!(diagnostics.is_empty());
144 }
145
146 fn check_apply(before: &str, after: &str, func: fn(file: &SourceFileNode) -> Vec<Diagnostic>) {
147 let file = SourceFileNode::parse(before);
148 let diagnostic = func(&file)
149 .pop()
150 .unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
151 let fix = diagnostic.fix.unwrap();
152 let actual = fix.edit.apply(&before);
153 assert_eq_text!(after, &actual);
154 }
155
156 #[test]
157 fn test_check_unnecessary_braces_in_use_statement() {
158 check_not_applicable(
159 "
160 use a;
161 use a::{c, d::e};
162 ",
163 check_unnecessary_braces_in_use_statement,
164 );
165 check_apply(
166 "use {b};",
167 "use b;",
168 check_unnecessary_braces_in_use_statement,
169 );
170 check_apply(
171 "use a::{c};",
172 "use a::c;",
173 check_unnecessary_braces_in_use_statement,
174 );
175 check_apply(
176 "use a::{self};",
177 "use a;",
178 check_unnecessary_braces_in_use_statement,
179 );
180 check_apply(
181 "use a::{c, d::{e}};",
182 "use a::{c, d::e};",
183 check_unnecessary_braces_in_use_statement,
184 );
185 }
186
187 #[test]
188 fn test_check_struct_shorthand_initialization() {
189 check_not_applicable(
190 r#"
191 struct A {
192 a: &'static str
193 }
194
195 fn main() {
196 A {
197 a: "hello"
198 }
199 }
200 "#,
201 check_struct_shorthand_initialization,
202 );
203
204 check_apply(
205 r#"
206struct A {
207 a: &'static str
208}
209
210fn main() {
211 let a = "haha";
212 A {
213 a: a
214 }
215}
216 "#,
217 r#"
218struct A {
219 a: &'static str
220}
221
222fn main() {
223 let a = "haha";
224 A {
225 a
226 }
227}
228 "#,
229 check_struct_shorthand_initialization,
230 );
231
232 check_apply(
233 r#"
234struct A {
235 a: &'static str,
236 b: &'static str
237}
238
239fn main() {
240 let a = "haha";
241 let b = "bb";
242 A {
243 a: a,
244 b
245 }
246}
247 "#,
248 r#"
249struct A {
250 a: &'static str,
251 b: &'static str
252}
253
254fn main() {
255 let a = "haha";
256 let b = "bb";
257 A {
258 a,
259 b
260 }
261}
262 "#,
263 check_struct_shorthand_initialization,
264 );
265 }
266}
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index 9043026c1..a65637d52 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -7,6 +7,7 @@ mod symbols;
7#[cfg(test)] 7#[cfg(test)]
8mod test_utils; 8mod test_utils;
9mod typing; 9mod typing;
10mod diagnostics;
10 11
11pub use self::{ 12pub use self::{
12 code_actions::{add_derive, add_impl, flip_comma, introduce_variable, make_pub_crate, LocalEdit}, 13 code_actions::{add_derive, add_impl, flip_comma, introduce_variable, make_pub_crate, LocalEdit},
@@ -16,17 +17,16 @@ pub use self::{
16 line_index_utils::translate_offset_with_edit, 17 line_index_utils::translate_offset_with_edit,
17 symbols::{file_structure, file_symbols, FileSymbol, StructureNode}, 18 symbols::{file_structure, file_symbols, FileSymbol, StructureNode},
18 typing::{join_lines, on_enter, on_eq_typed}, 19 typing::{join_lines, on_enter, on_eq_typed},
20 diagnostics::diagnostics
19}; 21};
20use ra_text_edit::{TextEdit, TextEditBuilder}; 22use ra_text_edit::{TextEdit, TextEditBuilder};
21use ra_syntax::{ 23use ra_syntax::{
22 algo::find_leaf_at_offset, 24 algo::find_leaf_at_offset,
23 ast::{self, AstNode, NameOwner}, 25 ast::{self, AstNode, NameOwner},
24 SourceFileNode, 26 SourceFileNode,
25 Location,
26 SyntaxKind::{self, *}, 27 SyntaxKind::{self, *},
27 SyntaxNodeRef, TextRange, TextUnit, Direction, 28 SyntaxNodeRef, TextRange, TextUnit, Direction,
28}; 29};
29use itertools::Itertools;
30use rustc_hash::FxHashSet; 30use rustc_hash::FxHashSet;
31 31
32#[derive(Debug)] 32#[derive(Debug)]
@@ -129,87 +129,6 @@ pub fn highlight(file: &SourceFileNode) -> Vec<HighlightedRange> {
129 res 129 res
130} 130}
131 131
132pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
133 fn location_to_range(location: Location) -> TextRange {
134 match location {
135 Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
136 Location::Range(range) => range,
137 }
138 }
139
140 let mut errors: Vec<Diagnostic> = file
141 .errors()
142 .into_iter()
143 .map(|err| Diagnostic {
144 range: location_to_range(err.location()),
145 msg: format!("Syntax Error: {}", err),
146 severity: Severity::Error,
147 fix: None,
148 })
149 .collect();
150
151 let warnings = check_unnecessary_braces_in_use_statement(file);
152
153 errors.extend(warnings);
154 errors
155}
156
157fn check_unnecessary_braces_in_use_statement(file: &SourceFileNode) -> Vec<Diagnostic> {
158 let mut diagnostics = Vec::new();
159 for node in file.syntax().descendants() {
160 if let Some(use_tree_list) = ast::UseTreeList::cast(node) {
161 if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
162 let range = use_tree_list.syntax().range();
163 let edit = text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
164 single_use_tree,
165 )
166 .unwrap_or_else(|| {
167 let to_replace = single_use_tree.syntax().text().to_string();
168 let mut edit_builder = TextEditBuilder::new();
169 edit_builder.delete(range);
170 edit_builder.insert(range.start(), to_replace);
171 edit_builder.finish()
172 });
173
174 diagnostics.push(Diagnostic {
175 range: range,
176 msg: format!("Unnecessary braces in use statement"),
177 severity: Severity::WeakWarning,
178 fix: Some(LocalEdit {
179 label: "Remove unnecessary braces".to_string(),
180 edit: edit,
181 cursor_position: None,
182 }),
183 })
184 }
185 }
186 }
187
188 diagnostics
189}
190
191fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
192 single_use_tree: ast::UseTree,
193) -> Option<TextEdit> {
194 let use_tree_list_node = single_use_tree.syntax().parent()?;
195 if single_use_tree
196 .path()?
197 .segment()?
198 .syntax()
199 .first_child()?
200 .kind()
201 == SyntaxKind::SELF_KW
202 {
203 let start = use_tree_list_node.prev_sibling()?.range().start();
204 let end = use_tree_list_node.range().end();
205 let range = TextRange::from_to(start, end);
206 let mut edit_builder = TextEditBuilder::new();
207 edit_builder.delete(range);
208 return Some(edit_builder.finish());
209 }
210 None
211}
212
213pub fn syntax_tree(file: &SourceFileNode) -> String { 132pub fn syntax_tree(file: &SourceFileNode) -> String {
214 ::ra_syntax::utils::dump_tree(file.syntax()) 133 ::ra_syntax::utils::dump_tree(file.syntax())
215} 134}
@@ -310,33 +229,4 @@ fn test_foo() {}
310 do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }"); 229 do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }");
311 } 230 }
312 231
313 #[test]
314 fn test_check_unnecessary_braces_in_use_statement() {
315 fn check_not_applicable(code: &str) {
316 let file = SourceFileNode::parse(code);
317 let diagnostics = check_unnecessary_braces_in_use_statement(&file);
318 assert!(diagnostics.is_empty());
319 }
320
321 fn check_apply(before: &str, after: &str) {
322 let file = SourceFileNode::parse(before);
323 let diagnostic = check_unnecessary_braces_in_use_statement(&file)
324 .pop()
325 .unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
326 let fix = diagnostic.fix.unwrap();
327 let actual = fix.edit.apply(&before);
328 assert_eq_text!(after, &actual);
329 }
330
331 check_not_applicable(
332 "
333 use a;
334 use a::{c, d::e};
335 ",
336 );
337 check_apply("use {b};", "use b;");
338 check_apply("use a::{c};", "use a::c;");
339 check_apply("use a::{self};", "use a;");
340 check_apply("use a::{c, d::{e}};", "use a::{c, d::e};");
341 }
342} 232}