aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_flycheck/Cargo.toml4
-rw-r--r--crates/ra_flycheck/src/conv.rs341
-rw-r--r--crates/ra_flycheck/src/conv/test.rs1072
-rw-r--r--crates/ra_flycheck/src/lib.rs90
-rw-r--r--crates/rust-analyzer/Cargo.toml2
-rw-r--r--crates/rust-analyzer/src/diagnostics.rs1
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_clippy_pass_by_ref.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_handles_macro_location.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_macro_compiler_error.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_incompatible_type_for_trait.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_mismatched_type.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_wrong_number_of_parameters.snap (renamed from crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap)2
-rw-r--r--crates/rust-analyzer/src/diagnostics/to_proto.rs1408
-rw-r--r--crates/rust-analyzer/src/main_loop.rs67
-rw-r--r--crates/rust-analyzer/src/world.rs6
17 files changed, 1503 insertions, 1504 deletions
diff --git a/crates/ra_flycheck/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index eac502da5..1aa39bade 100644
--- a/crates/ra_flycheck/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -9,12 +9,8 @@ doctest = false
9 9
10[dependencies] 10[dependencies]
11crossbeam-channel = "0.4.0" 11crossbeam-channel = "0.4.0"
12lsp-types = { version = "0.74.0", features = ["proposed"] }
13log = "0.4.8" 12log = "0.4.8"
14cargo_metadata = "0.10.0" 13cargo_metadata = "0.10.0"
15serde_json = "1.0.48" 14serde_json = "1.0.48"
16jod-thread = "0.1.1" 15jod-thread = "0.1.1"
17ra_toolchain = { path = "../ra_toolchain" } 16ra_toolchain = { path = "../ra_toolchain" }
18
19[dev-dependencies]
20insta = "0.16.0"
diff --git a/crates/ra_flycheck/src/conv.rs b/crates/ra_flycheck/src/conv.rs
deleted file mode 100644
index 817543deb..000000000
--- a/crates/ra_flycheck/src/conv.rs
+++ /dev/null
@@ -1,341 +0,0 @@
1//! This module provides the functionality needed to convert diagnostics from
2//! `cargo check` json format to the LSP diagnostic format.
3use cargo_metadata::diagnostic::{
4 Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
5 DiagnosticSpanMacroExpansion,
6};
7use lsp_types::{
8 CodeAction, Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag,
9 Location, NumberOrString, Position, Range, TextEdit, Url, WorkspaceEdit,
10};
11use std::{
12 collections::HashMap,
13 fmt::Write,
14 path::{Component, Path, PathBuf, Prefix},
15 str::FromStr,
16};
17
18#[cfg(test)]
19mod test;
20
21/// Converts a Rust level string to a LSP severity
22fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
23 match val {
24 DiagnosticLevel::Ice => Some(DiagnosticSeverity::Error),
25 DiagnosticLevel::Error => Some(DiagnosticSeverity::Error),
26 DiagnosticLevel::Warning => Some(DiagnosticSeverity::Warning),
27 DiagnosticLevel::Note => Some(DiagnosticSeverity::Information),
28 DiagnosticLevel::Help => Some(DiagnosticSeverity::Hint),
29 DiagnosticLevel::Unknown => None,
30 }
31}
32
33/// Check whether a file name is from macro invocation
34fn is_from_macro(file_name: &str) -> bool {
35 file_name.starts_with('<') && file_name.ends_with('>')
36}
37
38/// Converts a Rust macro span to a LSP location recursively
39fn map_macro_span_to_location(
40 span_macro: &DiagnosticSpanMacroExpansion,
41 workspace_root: &PathBuf,
42) -> Option<Location> {
43 if !is_from_macro(&span_macro.span.file_name) {
44 return Some(map_span_to_location(&span_macro.span, workspace_root));
45 }
46
47 if let Some(expansion) = &span_macro.span.expansion {
48 return map_macro_span_to_location(&expansion, workspace_root);
49 }
50
51 None
52}
53
54/// Converts a Rust span to a LSP location, resolving macro expansion site if neccesary
55fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
56 if span.expansion.is_some() {
57 let expansion = span.expansion.as_ref().unwrap();
58 if let Some(macro_range) = map_macro_span_to_location(&expansion, workspace_root) {
59 return macro_range;
60 }
61 }
62
63 map_span_to_location_naive(span, workspace_root)
64}
65
66/// Converts a Rust span to a LSP location
67fn map_span_to_location_naive(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
68 let mut file_name = workspace_root.clone();
69 file_name.push(&span.file_name);
70 let uri = url_from_path_with_drive_lowercasing(file_name).unwrap();
71
72 let range = Range::new(
73 Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
74 Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
75 );
76
77 Location { uri, range }
78}
79
80/// Converts a secondary Rust span to a LSP related information
81///
82/// If the span is unlabelled this will return `None`.
83fn map_secondary_span_to_related(
84 span: &DiagnosticSpan,
85 workspace_root: &PathBuf,
86) -> Option<DiagnosticRelatedInformation> {
87 if let Some(label) = &span.label {
88 let location = map_span_to_location(span, workspace_root);
89 Some(DiagnosticRelatedInformation { location, message: label.clone() })
90 } else {
91 // Nothing to label this with
92 None
93 }
94}
95
96/// Determines if diagnostic is related to unused code
97fn is_unused_or_unnecessary(rd: &RustDiagnostic) -> bool {
98 if let Some(code) = &rd.code {
99 match code.code.as_str() {
100 "dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"
101 | "unused_imports" | "unused_macros" | "unused_variables" => true,
102 _ => false,
103 }
104 } else {
105 false
106 }
107}
108
109/// Determines if diagnostic is related to deprecated code
110fn is_deprecated(rd: &RustDiagnostic) -> bool {
111 if let Some(code) = &rd.code {
112 match code.code.as_str() {
113 "deprecated" => true,
114 _ => false,
115 }
116 } else {
117 false
118 }
119}
120
121enum MappedRustChildDiagnostic {
122 Related(DiagnosticRelatedInformation),
123 SuggestedFix(CodeAction),
124 MessageLine(String),
125}
126
127fn map_rust_child_diagnostic(
128 rd: &RustDiagnostic,
129 workspace_root: &PathBuf,
130) -> MappedRustChildDiagnostic {
131 let spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
132 if spans.is_empty() {
133 // `rustc` uses these spanless children as a way to print multi-line
134 // messages
135 return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
136 }
137
138 let mut edit_map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
139 for &span in &spans {
140 match (&span.suggestion_applicability, &span.suggested_replacement) {
141 (Some(Applicability::MachineApplicable), Some(suggested_replacement)) => {
142 let location = map_span_to_location(span, workspace_root);
143 let edit = TextEdit::new(location.range, suggested_replacement.clone());
144 edit_map.entry(location.uri).or_default().push(edit);
145 }
146 _ => {}
147 }
148 }
149
150 if !edit_map.is_empty() {
151 MappedRustChildDiagnostic::SuggestedFix(CodeAction {
152 title: rd.message.clone(),
153 kind: Some("quickfix".to_string()),
154 diagnostics: None,
155 edit: Some(WorkspaceEdit::new(edit_map)),
156 command: None,
157 is_preferred: None,
158 })
159 } else {
160 MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
161 location: map_span_to_location(spans[0], workspace_root),
162 message: rd.message.clone(),
163 })
164 }
165}
166
167#[derive(Debug)]
168pub(crate) struct MappedRustDiagnostic {
169 pub location: Location,
170 pub diagnostic: Diagnostic,
171 pub fixes: Vec<CodeAction>,
172}
173
174/// Converts a Rust root diagnostic to LSP form
175///
176/// This flattens the Rust diagnostic by:
177///
178/// 1. Creating a LSP diagnostic with the root message and primary span.
179/// 2. Adding any labelled secondary spans to `relatedInformation`
180/// 3. Categorising child diagnostics as either `SuggestedFix`es,
181/// `relatedInformation` or additional message lines.
182///
183/// If the diagnostic has no primary span this will return `None`
184pub(crate) fn map_rust_diagnostic_to_lsp(
185 rd: &RustDiagnostic,
186 workspace_root: &PathBuf,
187) -> Vec<MappedRustDiagnostic> {
188 let primary_spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
189 if primary_spans.is_empty() {
190 return vec![];
191 }
192
193 let severity = map_level_to_severity(rd.level);
194
195 let mut source = String::from("rustc");
196 let mut code = rd.code.as_ref().map(|c| c.code.clone());
197 if let Some(code_val) = &code {
198 // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
199 let scoped_code: Vec<&str> = code_val.split("::").collect();
200 if scoped_code.len() == 2 {
201 source = String::from(scoped_code[0]);
202 code = Some(String::from(scoped_code[1]));
203 }
204 }
205
206 let mut needs_primary_span_label = true;
207 let mut related_information = vec![];
208 let mut tags = vec![];
209
210 for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
211 let related = map_secondary_span_to_related(secondary_span, workspace_root);
212 if let Some(related) = related {
213 related_information.push(related);
214 }
215 }
216
217 let mut fixes = vec![];
218 let mut message = rd.message.clone();
219 for child in &rd.children {
220 let child = map_rust_child_diagnostic(&child, workspace_root);
221 match child {
222 MappedRustChildDiagnostic::Related(related) => related_information.push(related),
223 MappedRustChildDiagnostic::SuggestedFix(code_action) => fixes.push(code_action),
224 MappedRustChildDiagnostic::MessageLine(message_line) => {
225 write!(&mut message, "\n{}", message_line).unwrap();
226
227 // These secondary messages usually duplicate the content of the
228 // primary span label.
229 needs_primary_span_label = false;
230 }
231 }
232 }
233
234 if is_unused_or_unnecessary(rd) {
235 tags.push(DiagnosticTag::Unnecessary);
236 }
237
238 if is_deprecated(rd) {
239 tags.push(DiagnosticTag::Deprecated);
240 }
241
242 primary_spans
243 .iter()
244 .map(|primary_span| {
245 let location = map_span_to_location(&primary_span, workspace_root);
246
247 let mut message = message.clone();
248 if needs_primary_span_label {
249 if let Some(primary_span_label) = &primary_span.label {
250 write!(&mut message, "\n{}", primary_span_label).unwrap();
251 }
252 }
253
254 // If error occurs from macro expansion, add related info pointing to
255 // where the error originated
256 if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
257 let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
258 related_information.push(DiagnosticRelatedInformation {
259 location: def_loc,
260 message: "Error originated from macro here".to_string(),
261 });
262 }
263
264 let diagnostic = Diagnostic {
265 range: location.range,
266 severity,
267 code: code.clone().map(NumberOrString::String),
268 source: Some(source.clone()),
269 message,
270 related_information: if !related_information.is_empty() {
271 Some(related_information.clone())
272 } else {
273 None
274 },
275 tags: if !tags.is_empty() { Some(tags.clone()) } else { None },
276 };
277
278 MappedRustDiagnostic { location, diagnostic, fixes: fixes.clone() }
279 })
280 .collect()
281}
282
283/// Returns a `Url` object from a given path, will lowercase drive letters if present.
284/// This will only happen when processing windows paths.
285///
286/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
287pub fn url_from_path_with_drive_lowercasing(
288 path: impl AsRef<Path>,
289) -> Result<Url, Box<dyn std::error::Error + Send + Sync>> {
290 let component_has_windows_drive = path.as_ref().components().any(|comp| {
291 if let Component::Prefix(c) = comp {
292 match c.kind() {
293 Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
294 _ => return false,
295 }
296 }
297 false
298 });
299
300 // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
301 if component_has_windows_drive {
302 let url_original = Url::from_file_path(&path)
303 .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
304
305 let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
306
307 // There is a drive partition, but we never found a colon.
308 // This should not happen, but in this case we just pass it through.
309 if drive_partition.len() == 1 {
310 return Ok(url_original);
311 }
312
313 let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
314 let url = Url::from_str(&joined).expect("This came from a valid `Url`");
315
316 Ok(url)
317 } else {
318 Ok(Url::from_file_path(&path)
319 .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
320 }
321}
322
323// `Url` is not able to parse windows paths on unix machines.
324#[cfg(target_os = "windows")]
325#[cfg(test)]
326mod path_conversion_windows_tests {
327 use super::url_from_path_with_drive_lowercasing;
328 #[test]
329 fn test_lowercase_drive_letter_with_drive() {
330 let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
331
332 assert_eq!(url.to_string(), "file:///c:/Test");
333 }
334
335 #[test]
336 fn test_drive_without_colon_passthrough() {
337 let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
338
339 assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
340 }
341}
diff --git a/crates/ra_flycheck/src/conv/test.rs b/crates/ra_flycheck/src/conv/test.rs
deleted file mode 100644
index 4e81455ca..000000000
--- a/crates/ra_flycheck/src/conv/test.rs
+++ /dev/null
@@ -1,1072 +0,0 @@
1//! This module contains the large and verbose snapshot tests for the
2//! conversions between `cargo check` json and LSP diagnostics.
3#[cfg(not(windows))]
4use crate::*;
5
6#[cfg(not(windows))]
7fn parse_diagnostic(val: &str) -> cargo_metadata::diagnostic::Diagnostic {
8 serde_json::from_str::<cargo_metadata::diagnostic::Diagnostic>(val).unwrap()
9}
10
11#[test]
12#[cfg(not(windows))]
13fn snap_rustc_incompatible_type_for_trait() {
14 let diag = parse_diagnostic(
15 r##"{
16 "message": "method `next` has an incompatible type for trait",
17 "code": {
18 "code": "E0053",
19 "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n fn foo(x: u16);\n fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n // error, expected u16, found i16\n fn foo(x: i16) { }\n\n // error, types differ in mutability\n fn bar(&mut self) { }\n}\n```\n"
20 },
21 "level": "error",
22 "spans": [
23 {
24 "file_name": "compiler/ty/list_iter.rs",
25 "byte_start": 1307,
26 "byte_end": 1350,
27 "line_start": 52,
28 "line_end": 52,
29 "column_start": 5,
30 "column_end": 48,
31 "is_primary": true,
32 "text": [
33 {
34 "text": " fn next(&self) -> Option<&'list ty::Ref<M>> {",
35 "highlight_start": 5,
36 "highlight_end": 48
37 }
38 ],
39 "label": "types differ in mutability",
40 "suggested_replacement": null,
41 "suggestion_applicability": null,
42 "expansion": null
43 }
44 ],
45 "children": [
46 {
47 "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
48 "code": null,
49 "level": "note",
50 "spans": [],
51 "children": [],
52 "rendered": null
53 }
54 ],
55 "rendered": "error[E0053]: method `next` has an incompatible type for trait\n --> compiler/ty/list_iter.rs:52:5\n |\n52 | fn next(&self) -> Option<&'list ty::Ref<M>> {\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n |\n = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
56 }
57 "##,
58 );
59
60 let workspace_root = PathBuf::from("/test/");
61 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
62 insta::assert_debug_snapshot!(diag);
63}
64
65#[test]
66#[cfg(not(windows))]
67fn snap_rustc_unused_variable() {
68 let diag = parse_diagnostic(
69 r##"{
70"message": "unused variable: `foo`",
71"code": {
72 "code": "unused_variables",
73 "explanation": null
74},
75"level": "warning",
76"spans": [
77 {
78 "file_name": "driver/subcommand/repl.rs",
79 "byte_start": 9228,
80 "byte_end": 9231,
81 "line_start": 291,
82 "line_end": 291,
83 "column_start": 9,
84 "column_end": 12,
85 "is_primary": true,
86 "text": [
87 {
88 "text": " let foo = 42;",
89 "highlight_start": 9,
90 "highlight_end": 12
91 }
92 ],
93 "label": null,
94 "suggested_replacement": null,
95 "suggestion_applicability": null,
96 "expansion": null
97 }
98],
99"children": [
100 {
101 "message": "#[warn(unused_variables)] on by default",
102 "code": null,
103 "level": "note",
104 "spans": [],
105 "children": [],
106 "rendered": null
107 },
108 {
109 "message": "consider prefixing with an underscore",
110 "code": null,
111 "level": "help",
112 "spans": [
113 {
114 "file_name": "driver/subcommand/repl.rs",
115 "byte_start": 9228,
116 "byte_end": 9231,
117 "line_start": 291,
118 "line_end": 291,
119 "column_start": 9,
120 "column_end": 12,
121 "is_primary": true,
122 "text": [
123 {
124 "text": " let foo = 42;",
125 "highlight_start": 9,
126 "highlight_end": 12
127 }
128 ],
129 "label": null,
130 "suggested_replacement": "_foo",
131 "suggestion_applicability": "MachineApplicable",
132 "expansion": null
133 }
134 ],
135 "children": [],
136 "rendered": null
137 }
138],
139"rendered": "warning: unused variable: `foo`\n --> driver/subcommand/repl.rs:291:9\n |\n291 | let foo = 42;\n | ^^^ help: consider prefixing with an underscore: `_foo`\n |\n = note: #[warn(unused_variables)] on by default\n\n"
140}"##,
141 );
142
143 let workspace_root = PathBuf::from("/test/");
144 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
145 insta::assert_debug_snapshot!(diag);
146}
147
148#[test]
149#[cfg(not(windows))]
150fn snap_rustc_wrong_number_of_parameters() {
151 let diag = parse_diagnostic(
152 r##"{
153"message": "this function takes 2 parameters but 3 parameters were supplied",
154"code": {
155 "code": "E0061",
156 "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
157},
158"level": "error",
159"spans": [
160 {
161 "file_name": "compiler/ty/select.rs",
162 "byte_start": 8787,
163 "byte_end": 9241,
164 "line_start": 219,
165 "line_end": 231,
166 "column_start": 5,
167 "column_end": 6,
168 "is_primary": false,
169 "text": [
170 {
171 "text": " pub fn add_evidence(",
172 "highlight_start": 5,
173 "highlight_end": 25
174 },
175 {
176 "text": " &mut self,",
177 "highlight_start": 1,
178 "highlight_end": 19
179 },
180 {
181 "text": " target_poly: &ty::Ref<ty::Poly>,",
182 "highlight_start": 1,
183 "highlight_end": 41
184 },
185 {
186 "text": " evidence_poly: &ty::Ref<ty::Poly>,",
187 "highlight_start": 1,
188 "highlight_end": 43
189 },
190 {
191 "text": " ) {",
192 "highlight_start": 1,
193 "highlight_end": 8
194 },
195 {
196 "text": " match target_poly {",
197 "highlight_start": 1,
198 "highlight_end": 28
199 },
200 {
201 "text": " ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
202 "highlight_start": 1,
203 "highlight_end": 81
204 },
205 {
206 "text": " ty::Ref::Fixed(target_ty) => {",
207 "highlight_start": 1,
208 "highlight_end": 43
209 },
210 {
211 "text": " let evidence_ty = evidence_poly.resolve_to_ty();",
212 "highlight_start": 1,
213 "highlight_end": 65
214 },
215 {
216 "text": " self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
217 "highlight_start": 1,
218 "highlight_end": 76
219 },
220 {
221 "text": " }",
222 "highlight_start": 1,
223 "highlight_end": 14
224 },
225 {
226 "text": " }",
227 "highlight_start": 1,
228 "highlight_end": 10
229 },
230 {
231 "text": " }",
232 "highlight_start": 1,
233 "highlight_end": 6
234 }
235 ],
236 "label": "defined here",
237 "suggested_replacement": null,
238 "suggestion_applicability": null,
239 "expansion": null
240 },
241 {
242 "file_name": "compiler/ty/select.rs",
243 "byte_start": 4045,
244 "byte_end": 4057,
245 "line_start": 104,
246 "line_end": 104,
247 "column_start": 18,
248 "column_end": 30,
249 "is_primary": true,
250 "text": [
251 {
252 "text": " self.add_evidence(target_fixed, evidence_fixed, false);",
253 "highlight_start": 18,
254 "highlight_end": 30
255 }
256 ],
257 "label": "expected 2 parameters",
258 "suggested_replacement": null,
259 "suggestion_applicability": null,
260 "expansion": null
261 }
262],
263"children": [],
264"rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n --> compiler/ty/select.rs:104:18\n |\n104 | self.add_evidence(target_fixed, evidence_fixed, false);\n | ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | / pub fn add_evidence(\n220 | | &mut self,\n221 | | target_poly: &ty::Ref<ty::Poly>,\n222 | | evidence_poly: &ty::Ref<ty::Poly>,\n... |\n230 | | }\n231 | | }\n | |_____- defined here\n\n"
265}"##,
266 );
267
268 let workspace_root = PathBuf::from("/test/");
269 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
270 insta::assert_debug_snapshot!(diag);
271}
272
273#[test]
274#[cfg(not(windows))]
275fn snap_clippy_pass_by_ref() {
276 let diag = parse_diagnostic(
277 r##"{
278"message": "this argument is passed by reference, but would be more efficient if passed by value",
279"code": {
280 "code": "clippy::trivially_copy_pass_by_ref",
281 "explanation": null
282},
283"level": "warning",
284"spans": [
285 {
286 "file_name": "compiler/mir/tagset.rs",
287 "byte_start": 941,
288 "byte_end": 946,
289 "line_start": 42,
290 "line_end": 42,
291 "column_start": 24,
292 "column_end": 29,
293 "is_primary": true,
294 "text": [
295 {
296 "text": " pub fn is_disjoint(&self, other: Self) -> bool {",
297 "highlight_start": 24,
298 "highlight_end": 29
299 }
300 ],
301 "label": null,
302 "suggested_replacement": null,
303 "suggestion_applicability": null,
304 "expansion": null
305 }
306],
307"children": [
308 {
309 "message": "lint level defined here",
310 "code": null,
311 "level": "note",
312 "spans": [
313 {
314 "file_name": "compiler/lib.rs",
315 "byte_start": 8,
316 "byte_end": 19,
317 "line_start": 1,
318 "line_end": 1,
319 "column_start": 9,
320 "column_end": 20,
321 "is_primary": true,
322 "text": [
323 {
324 "text": "#![warn(clippy::all)]",
325 "highlight_start": 9,
326 "highlight_end": 20
327 }
328 ],
329 "label": null,
330 "suggested_replacement": null,
331 "suggestion_applicability": null,
332 "expansion": null
333 }
334 ],
335 "children": [],
336 "rendered": null
337 },
338 {
339 "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
340 "code": null,
341 "level": "note",
342 "spans": [],
343 "children": [],
344 "rendered": null
345 },
346 {
347 "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
348 "code": null,
349 "level": "help",
350 "spans": [],
351 "children": [],
352 "rendered": null
353 },
354 {
355 "message": "consider passing by value instead",
356 "code": null,
357 "level": "help",
358 "spans": [
359 {
360 "file_name": "compiler/mir/tagset.rs",
361 "byte_start": 941,
362 "byte_end": 946,
363 "line_start": 42,
364 "line_end": 42,
365 "column_start": 24,
366 "column_end": 29,
367 "is_primary": true,
368 "text": [
369 {
370 "text": " pub fn is_disjoint(&self, other: Self) -> bool {",
371 "highlight_start": 24,
372 "highlight_end": 29
373 }
374 ],
375 "label": null,
376 "suggested_replacement": "self",
377 "suggestion_applicability": "Unspecified",
378 "expansion": null
379 }
380 ],
381 "children": [],
382 "rendered": null
383 }
384],
385"rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n --> compiler/mir/tagset.rs:42:24\n |\n42 | pub fn is_disjoint(&self, other: Self) -> bool {\n | ^^^^^ help: consider passing by value instead: `self`\n |\nnote: lint level defined here\n --> compiler/lib.rs:1:9\n |\n1 | #![warn(clippy::all)]\n | ^^^^^^^^^^^\n = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
386}"##,
387 );
388
389 let workspace_root = PathBuf::from("/test/");
390 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
391 insta::assert_debug_snapshot!(diag);
392}
393
394#[test]
395#[cfg(not(windows))]
396fn snap_rustc_mismatched_type() {
397 let diag = parse_diagnostic(
398 r##"{
399"message": "mismatched types",
400"code": {
401 "code": "E0308",
402 "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n// ~~~ ~~~~~~~~~~~~~~~~~~~~\n// | |\n// | initializing expression;\n// | compiler infers type `&str`\n// |\n// type `i32` assigned to variable `x`\n```\n"
403},
404"level": "error",
405"spans": [
406 {
407 "file_name": "runtime/compiler_support.rs",
408 "byte_start": 1589,
409 "byte_end": 1594,
410 "line_start": 48,
411 "line_end": 48,
412 "column_start": 65,
413 "column_end": 70,
414 "is_primary": true,
415 "text": [
416 {
417 "text": " let layout = alloc::Layout::from_size_align_unchecked(size, align);",
418 "highlight_start": 65,
419 "highlight_end": 70
420 }
421 ],
422 "label": "expected usize, found u32",
423 "suggested_replacement": null,
424 "suggestion_applicability": null,
425 "expansion": null
426 }
427],
428"children": [],
429"rendered": "error[E0308]: mismatched types\n --> runtime/compiler_support.rs:48:65\n |\n48 | let layout = alloc::Layout::from_size_align_unchecked(size, align);\n | ^^^^^ expected usize, found u32\n\n"
430}"##,
431 );
432
433 let workspace_root = PathBuf::from("/test/");
434 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
435 insta::assert_debug_snapshot!(diag);
436}
437
438#[test]
439#[cfg(not(windows))]
440fn snap_handles_macro_location() {
441 let diag = parse_diagnostic(
442 r##"{
443"rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n |\n2 | assert_eq!(1, \"love\");\n | ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n |\n = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
444"children": [
445 {
446 "children": [],
447 "code": null,
448 "level": "help",
449 "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
450 "rendered": null,
451 "spans": []
452 }
453],
454"code": {
455 "code": "E0277",
456 "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n foo.bar();\n}\n\nfn main() {\n // we now call the method with the i32 type, which doesn't implement\n // the Foo trait\n some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n foo.bar(); // we can now use this method since i32 implements the\n // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n fn bar(&self) {}\n}\n\nfn main() {\n some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n // implemented for the type `T`\n}\n\nfn main() {\n // We now call the method with the i32 type,\n // which *does* implement the Debug trait.\n some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n println!(\"{:?}\", foo);\n}\n\nfn main() {\n // Calling the method is still fine, as i32 implements Debug.\n some_func(5i32);\n\n // This would fail to compile now:\n // struct WithoutDebug;\n // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
457},
458"level": "error",
459"message": "can't compare `{integer}` with `&str`",
460"spans": [
461 {
462 "byte_end": 155,
463 "byte_start": 153,
464 "column_end": 33,
465 "column_start": 31,
466 "expansion": {
467 "def_site_span": {
468 "byte_end": 940,
469 "byte_start": 0,
470 "column_end": 6,
471 "column_start": 1,
472 "expansion": null,
473 "file_name": "<::core::macros::assert_eq macros>",
474 "is_primary": false,
475 "label": null,
476 "line_end": 36,
477 "line_start": 1,
478 "suggested_replacement": null,
479 "suggestion_applicability": null,
480 "text": [
481 {
482 "highlight_end": 35,
483 "highlight_start": 1,
484 "text": "($ left : expr, $ right : expr) =>"
485 },
486 {
487 "highlight_end": 3,
488 "highlight_start": 1,
489 "text": "({"
490 },
491 {
492 "highlight_end": 33,
493 "highlight_start": 1,
494 "text": " match (& $ left, & $ right)"
495 },
496 {
497 "highlight_end": 7,
498 "highlight_start": 1,
499 "text": " {"
500 },
501 {
502 "highlight_end": 34,
503 "highlight_start": 1,
504 "text": " (left_val, right_val) =>"
505 },
506 {
507 "highlight_end": 11,
508 "highlight_start": 1,
509 "text": " {"
510 },
511 {
512 "highlight_end": 46,
513 "highlight_start": 1,
514 "text": " if ! (* left_val == * right_val)"
515 },
516 {
517 "highlight_end": 15,
518 "highlight_start": 1,
519 "text": " {"
520 },
521 {
522 "highlight_end": 25,
523 "highlight_start": 1,
524 "text": " panic !"
525 },
526 {
527 "highlight_end": 57,
528 "highlight_start": 1,
529 "text": " (r#\"assertion failed: `(left == right)`"
530 },
531 {
532 "highlight_end": 16,
533 "highlight_start": 1,
534 "text": " left: `{:?}`,"
535 },
536 {
537 "highlight_end": 18,
538 "highlight_start": 1,
539 "text": " right: `{:?}`\"#,"
540 },
541 {
542 "highlight_end": 47,
543 "highlight_start": 1,
544 "text": " & * left_val, & * right_val)"
545 },
546 {
547 "highlight_end": 15,
548 "highlight_start": 1,
549 "text": " }"
550 },
551 {
552 "highlight_end": 11,
553 "highlight_start": 1,
554 "text": " }"
555 },
556 {
557 "highlight_end": 7,
558 "highlight_start": 1,
559 "text": " }"
560 },
561 {
562 "highlight_end": 42,
563 "highlight_start": 1,
564 "text": " }) ; ($ left : expr, $ right : expr,) =>"
565 },
566 {
567 "highlight_end": 49,
568 "highlight_start": 1,
569 "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
570 },
571 {
572 "highlight_end": 53,
573 "highlight_start": 1,
574 "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
575 },
576 {
577 "highlight_end": 3,
578 "highlight_start": 1,
579 "text": "({"
580 },
581 {
582 "highlight_end": 37,
583 "highlight_start": 1,
584 "text": " match (& ($ left), & ($ right))"
585 },
586 {
587 "highlight_end": 7,
588 "highlight_start": 1,
589 "text": " {"
590 },
591 {
592 "highlight_end": 34,
593 "highlight_start": 1,
594 "text": " (left_val, right_val) =>"
595 },
596 {
597 "highlight_end": 11,
598 "highlight_start": 1,
599 "text": " {"
600 },
601 {
602 "highlight_end": 46,
603 "highlight_start": 1,
604 "text": " if ! (* left_val == * right_val)"
605 },
606 {
607 "highlight_end": 15,
608 "highlight_start": 1,
609 "text": " {"
610 },
611 {
612 "highlight_end": 25,
613 "highlight_start": 1,
614 "text": " panic !"
615 },
616 {
617 "highlight_end": 57,
618 "highlight_start": 1,
619 "text": " (r#\"assertion failed: `(left == right)`"
620 },
621 {
622 "highlight_end": 16,
623 "highlight_start": 1,
624 "text": " left: `{:?}`,"
625 },
626 {
627 "highlight_end": 22,
628 "highlight_start": 1,
629 "text": " right: `{:?}`: {}\"#,"
630 },
631 {
632 "highlight_end": 72,
633 "highlight_start": 1,
634 "text": " & * left_val, & * right_val, $ crate :: format_args !"
635 },
636 {
637 "highlight_end": 33,
638 "highlight_start": 1,
639 "text": " ($ ($ arg) +))"
640 },
641 {
642 "highlight_end": 15,
643 "highlight_start": 1,
644 "text": " }"
645 },
646 {
647 "highlight_end": 11,
648 "highlight_start": 1,
649 "text": " }"
650 },
651 {
652 "highlight_end": 7,
653 "highlight_start": 1,
654 "text": " }"
655 },
656 {
657 "highlight_end": 6,
658 "highlight_start": 1,
659 "text": " }) ;"
660 }
661 ]
662 },
663 "macro_decl_name": "assert_eq!",
664 "span": {
665 "byte_end": 38,
666 "byte_start": 16,
667 "column_end": 27,
668 "column_start": 5,
669 "expansion": null,
670 "file_name": "src/main.rs",
671 "is_primary": false,
672 "label": null,
673 "line_end": 2,
674 "line_start": 2,
675 "suggested_replacement": null,
676 "suggestion_applicability": null,
677 "text": [
678 {
679 "highlight_end": 27,
680 "highlight_start": 5,
681 "text": " assert_eq!(1, \"love\");"
682 }
683 ]
684 }
685 },
686 "file_name": "<::core::macros::assert_eq macros>",
687 "is_primary": true,
688 "label": "no implementation for `{integer} == &str`",
689 "line_end": 7,
690 "line_start": 7,
691 "suggested_replacement": null,
692 "suggestion_applicability": null,
693 "text": [
694 {
695 "highlight_end": 33,
696 "highlight_start": 31,
697 "text": " if ! (* left_val == * right_val)"
698 }
699 ]
700 }
701]
702}"##,
703 );
704
705 let workspace_root = PathBuf::from("/test/");
706 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
707 insta::assert_debug_snapshot!(diag);
708}
709
710#[test]
711#[cfg(not(windows))]
712fn snap_macro_compiler_error() {
713 let diag = parse_diagnostic(
714 r##"{
715 "rendered": "error: Please register your known path in the path module\n --> crates/ra_hir_def/src/path.rs:265:9\n |\n265 | compile_error!(\"Please register your known path in the path module\")\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n | \n ::: crates/ra_hir_def/src/data.rs:80:16\n |\n80 | let path = path![std::future::Future];\n | -------------------------- in this macro invocation\n\n",
716 "children": [],
717 "code": null,
718 "level": "error",
719 "message": "Please register your known path in the path module",
720 "spans": [
721 {
722 "byte_end": 8285,
723 "byte_start": 8217,
724 "column_end": 77,
725 "column_start": 9,
726 "expansion": {
727 "def_site_span": {
728 "byte_end": 8294,
729 "byte_start": 7858,
730 "column_end": 2,
731 "column_start": 1,
732 "expansion": null,
733 "file_name": "crates/ra_hir_def/src/path.rs",
734 "is_primary": false,
735 "label": null,
736 "line_end": 267,
737 "line_start": 254,
738 "suggested_replacement": null,
739 "suggestion_applicability": null,
740 "text": [
741 {
742 "highlight_end": 28,
743 "highlight_start": 1,
744 "text": "macro_rules! __known_path {"
745 },
746 {
747 "highlight_end": 37,
748 "highlight_start": 1,
749 "text": " (std::iter::IntoIterator) => {};"
750 },
751 {
752 "highlight_end": 33,
753 "highlight_start": 1,
754 "text": " (std::result::Result) => {};"
755 },
756 {
757 "highlight_end": 29,
758 "highlight_start": 1,
759 "text": " (std::ops::Range) => {};"
760 },
761 {
762 "highlight_end": 33,
763 "highlight_start": 1,
764 "text": " (std::ops::RangeFrom) => {};"
765 },
766 {
767 "highlight_end": 33,
768 "highlight_start": 1,
769 "text": " (std::ops::RangeFull) => {};"
770 },
771 {
772 "highlight_end": 31,
773 "highlight_start": 1,
774 "text": " (std::ops::RangeTo) => {};"
775 },
776 {
777 "highlight_end": 40,
778 "highlight_start": 1,
779 "text": " (std::ops::RangeToInclusive) => {};"
780 },
781 {
782 "highlight_end": 38,
783 "highlight_start": 1,
784 "text": " (std::ops::RangeInclusive) => {};"
785 },
786 {
787 "highlight_end": 27,
788 "highlight_start": 1,
789 "text": " (std::ops::Try) => {};"
790 },
791 {
792 "highlight_end": 22,
793 "highlight_start": 1,
794 "text": " ($path:path) => {"
795 },
796 {
797 "highlight_end": 77,
798 "highlight_start": 1,
799 "text": " compile_error!(\"Please register your known path in the path module\")"
800 },
801 {
802 "highlight_end": 7,
803 "highlight_start": 1,
804 "text": " };"
805 },
806 {
807 "highlight_end": 2,
808 "highlight_start": 1,
809 "text": "}"
810 }
811 ]
812 },
813 "macro_decl_name": "$crate::__known_path!",
814 "span": {
815 "byte_end": 8427,
816 "byte_start": 8385,
817 "column_end": 51,
818 "column_start": 9,
819 "expansion": {
820 "def_site_span": {
821 "byte_end": 8611,
822 "byte_start": 8312,
823 "column_end": 2,
824 "column_start": 1,
825 "expansion": null,
826 "file_name": "crates/ra_hir_def/src/path.rs",
827 "is_primary": false,
828 "label": null,
829 "line_end": 277,
830 "line_start": 270,
831 "suggested_replacement": null,
832 "suggestion_applicability": null,
833 "text": [
834 {
835 "highlight_end": 22,
836 "highlight_start": 1,
837 "text": "macro_rules! __path {"
838 },
839 {
840 "highlight_end": 43,
841 "highlight_start": 1,
842 "text": " ($start:ident $(:: $seg:ident)*) => ({"
843 },
844 {
845 "highlight_end": 51,
846 "highlight_start": 1,
847 "text": " $crate::__known_path!($start $(:: $seg)*);"
848 },
849 {
850 "highlight_end": 87,
851 "highlight_start": 1,
852 "text": " $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec!["
853 },
854 {
855 "highlight_end": 76,
856 "highlight_start": 1,
857 "text": " $crate::path::__name![$start], $($crate::path::__name![$seg],)*"
858 },
859 {
860 "highlight_end": 11,
861 "highlight_start": 1,
862 "text": " ])"
863 },
864 {
865 "highlight_end": 8,
866 "highlight_start": 1,
867 "text": " });"
868 },
869 {
870 "highlight_end": 2,
871 "highlight_start": 1,
872 "text": "}"
873 }
874 ]
875 },
876 "macro_decl_name": "path!",
877 "span": {
878 "byte_end": 2966,
879 "byte_start": 2940,
880 "column_end": 42,
881 "column_start": 16,
882 "expansion": null,
883 "file_name": "crates/ra_hir_def/src/data.rs",
884 "is_primary": false,
885 "label": null,
886 "line_end": 80,
887 "line_start": 80,
888 "suggested_replacement": null,
889 "suggestion_applicability": null,
890 "text": [
891 {
892 "highlight_end": 42,
893 "highlight_start": 16,
894 "text": " let path = path![std::future::Future];"
895 }
896 ]
897 }
898 },
899 "file_name": "crates/ra_hir_def/src/path.rs",
900 "is_primary": false,
901 "label": null,
902 "line_end": 272,
903 "line_start": 272,
904 "suggested_replacement": null,
905 "suggestion_applicability": null,
906 "text": [
907 {
908 "highlight_end": 51,
909 "highlight_start": 9,
910 "text": " $crate::__known_path!($start $(:: $seg)*);"
911 }
912 ]
913 }
914 },
915 "file_name": "crates/ra_hir_def/src/path.rs",
916 "is_primary": true,
917 "label": null,
918 "line_end": 265,
919 "line_start": 265,
920 "suggested_replacement": null,
921 "suggestion_applicability": null,
922 "text": [
923 {
924 "highlight_end": 77,
925 "highlight_start": 9,
926 "text": " compile_error!(\"Please register your known path in the path module\")"
927 }
928 ]
929 }
930 ]
931}
932 "##,
933 );
934
935 let workspace_root = PathBuf::from("/test/");
936 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
937 insta::assert_debug_snapshot!(diag);
938}
939
940#[test]
941#[cfg(not(windows))]
942fn snap_multi_line_fix() {
943 let diag = parse_diagnostic(
944 r##"{
945 "rendered": "warning: returning the result of a let binding from a block\n --> src/main.rs:4:5\n |\n3 | let a = (0..10).collect();\n | -------------------------- unnecessary let binding\n4 | a\n | ^\n |\n = note: `#[warn(clippy::let_and_return)]` on by default\n = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return\nhelp: return the expression directly\n |\n3 | \n4 | (0..10).collect()\n |\n\n",
946 "children": [
947 {
948 "children": [],
949 "code": null,
950 "level": "note",
951 "message": "`#[warn(clippy::let_and_return)]` on by default",
952 "rendered": null,
953 "spans": []
954 },
955 {
956 "children": [],
957 "code": null,
958 "level": "help",
959 "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",
960 "rendered": null,
961 "spans": []
962 },
963 {
964 "children": [],
965 "code": null,
966 "level": "help",
967 "message": "return the expression directly",
968 "rendered": null,
969 "spans": [
970 {
971 "byte_end": 55,
972 "byte_start": 29,
973 "column_end": 31,
974 "column_start": 5,
975 "expansion": null,
976 "file_name": "src/main.rs",
977 "is_primary": true,
978 "label": null,
979 "line_end": 3,
980 "line_start": 3,
981 "suggested_replacement": "",
982 "suggestion_applicability": "MachineApplicable",
983 "text": [
984 {
985 "highlight_end": 31,
986 "highlight_start": 5,
987 "text": " let a = (0..10).collect();"
988 }
989 ]
990 },
991 {
992 "byte_end": 61,
993 "byte_start": 60,
994 "column_end": 6,
995 "column_start": 5,
996 "expansion": null,
997 "file_name": "src/main.rs",
998 "is_primary": true,
999 "label": null,
1000 "line_end": 4,
1001 "line_start": 4,
1002 "suggested_replacement": "(0..10).collect()",
1003 "suggestion_applicability": "MachineApplicable",
1004 "text": [
1005 {
1006 "highlight_end": 6,
1007 "highlight_start": 5,
1008 "text": " a"
1009 }
1010 ]
1011 }
1012 ]
1013 }
1014 ],
1015 "code": {
1016 "code": "clippy::let_and_return",
1017 "explanation": null
1018 },
1019 "level": "warning",
1020 "message": "returning the result of a let binding from a block",
1021 "spans": [
1022 {
1023 "byte_end": 55,
1024 "byte_start": 29,
1025 "column_end": 31,
1026 "column_start": 5,
1027 "expansion": null,
1028 "file_name": "src/main.rs",
1029 "is_primary": false,
1030 "label": "unnecessary let binding",
1031 "line_end": 3,
1032 "line_start": 3,
1033 "suggested_replacement": null,
1034 "suggestion_applicability": null,
1035 "text": [
1036 {
1037 "highlight_end": 31,
1038 "highlight_start": 5,
1039 "text": " let a = (0..10).collect();"
1040 }
1041 ]
1042 },
1043 {
1044 "byte_end": 61,
1045 "byte_start": 60,
1046 "column_end": 6,
1047 "column_start": 5,
1048 "expansion": null,
1049 "file_name": "src/main.rs",
1050 "is_primary": true,
1051 "label": null,
1052 "line_end": 4,
1053 "line_start": 4,
1054 "suggested_replacement": null,
1055 "suggestion_applicability": null,
1056 "text": [
1057 {
1058 "highlight_end": 6,
1059 "highlight_start": 5,
1060 "text": " a"
1061 }
1062 ]
1063 }
1064 ]
1065 }
1066 "##,
1067 );
1068
1069 let workspace_root = PathBuf::from("/test/");
1070 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
1071 insta::assert_debug_snapshot!(diag);
1072}
diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index d5efb6ab3..178485c9e 100644
--- a/crates/ra_flycheck/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -1,10 +1,9 @@
1//! cargo_check provides the functionality needed to run `cargo check` or 1//! cargo_check provides the functionality needed to run `cargo check` or
2//! another compatible command (f.x. clippy) in a background thread and provide 2//! another compatible command (f.x. clippy) in a background thread and provide
3//! LSP diagnostics based on the output of the command. 3//! LSP diagnostics based on the output of the command.
4mod conv;
5 4
6use std::{ 5use std::{
7 io::{self, BufRead, BufReader}, 6 io::{self, BufReader},
8 path::PathBuf, 7 path::PathBuf,
9 process::{Command, Stdio}, 8 process::{Command, Stdio},
10 time::Instant, 9 time::Instant,
@@ -12,14 +11,6 @@ use std::{
12 11
13use cargo_metadata::Message; 12use cargo_metadata::Message;
14use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender}; 13use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
15use lsp_types::{
16 CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
17 WorkDoneProgressEnd, WorkDoneProgressReport,
18};
19
20use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
21
22pub use crate::conv::url_from_path_with_drive_lowercasing;
23 14
24#[derive(Clone, Debug, PartialEq, Eq)] 15#[derive(Clone, Debug, PartialEq, Eq)]
25pub enum FlycheckConfig { 16pub enum FlycheckConfig {
@@ -61,10 +52,17 @@ pub enum CheckTask {
61 ClearDiagnostics, 52 ClearDiagnostics,
62 53
63 /// Request adding a diagnostic with fixes included to a file 54 /// Request adding a diagnostic with fixes included to a file
64 AddDiagnostic { url: Url, diagnostic: Diagnostic, fixes: Vec<CodeActionOrCommand> }, 55 AddDiagnostic { workspace_root: PathBuf, diagnostic: cargo_metadata::diagnostic::Diagnostic },
65 56
66 /// Request check progress notification to client 57 /// Request check progress notification to client
67 Status(WorkDoneProgress), 58 Status(Status),
59}
60
61#[derive(Debug)]
62pub enum Status {
63 Being,
64 Progress(String),
65 End,
68} 66}
69 67
70pub enum CheckCommand { 68pub enum CheckCommand {
@@ -131,9 +129,7 @@ impl FlycheckThread {
131 129
132 fn clean_previous_results(&self, task_send: &Sender<CheckTask>) { 130 fn clean_previous_results(&self, task_send: &Sender<CheckTask>) {
133 task_send.send(CheckTask::ClearDiagnostics).unwrap(); 131 task_send.send(CheckTask::ClearDiagnostics).unwrap();
134 task_send 132 task_send.send(CheckTask::Status(Status::End)).unwrap();
135 .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd { message: None })))
136 .unwrap();
137 } 133 }
138 134
139 fn should_recheck(&mut self) -> bool { 135 fn should_recheck(&mut self) -> bool {
@@ -155,52 +151,24 @@ impl FlycheckThread {
155 fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) { 151 fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
156 match msg { 152 match msg {
157 CheckEvent::Begin => { 153 CheckEvent::Begin => {
158 task_send 154 task_send.send(CheckTask::Status(Status::Being)).unwrap();
159 .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
160 title: "Running `cargo check`".to_string(),
161 cancellable: Some(false),
162 message: None,
163 percentage: None,
164 })))
165 .unwrap();
166 } 155 }
167 156
168 CheckEvent::End => { 157 CheckEvent::End => {
169 task_send 158 task_send.send(CheckTask::Status(Status::End)).unwrap();
170 .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
171 message: None,
172 })))
173 .unwrap();
174 } 159 }
175 160
176 CheckEvent::Msg(Message::CompilerArtifact(msg)) => { 161 CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
177 task_send 162 task_send.send(CheckTask::Status(Status::Progress(msg.target.name))).unwrap();
178 .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
179 cancellable: Some(false),
180 message: Some(msg.target.name),
181 percentage: None,
182 })))
183 .unwrap();
184 } 163 }
185 164
186 CheckEvent::Msg(Message::CompilerMessage(msg)) => { 165 CheckEvent::Msg(Message::CompilerMessage(msg)) => {
187 let map_result = map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root); 166 task_send
188 if map_result.is_empty() { 167 .send(CheckTask::AddDiagnostic {
189 return; 168 workspace_root: self.workspace_root.clone(),
190 } 169 diagnostic: msg.message,
191 170 })
192 for MappedRustDiagnostic { location, diagnostic, fixes } in map_result { 171 .unwrap();
193 let fixes = fixes
194 .into_iter()
195 .map(|fix| {
196 CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
197 })
198 .collect();
199
200 task_send
201 .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
202 .unwrap();
203 }
204 } 172 }
205 173
206 CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {} 174 CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
@@ -271,11 +239,11 @@ impl FlycheckThread {
271 } 239 }
272} 240}
273 241
274#[derive(Debug)] 242// #[derive(Debug)]
275pub struct DiagnosticWithFixes { 243// pub struct DiagnosticWithFixes {
276 diagnostic: Diagnostic, 244// diagnostic: Diagnostic,
277 fixes: Vec<CodeAction>, 245// fixes: Vec<CodeAction>,
278} 246// }
279 247
280enum CheckEvent { 248enum CheckEvent {
281 Begin, 249 Begin,
@@ -300,15 +268,11 @@ fn run_cargo(
300 // erroneus output. 268 // erroneus output.
301 let stdout = BufReader::new(child.stdout.take().unwrap()); 269 let stdout = BufReader::new(child.stdout.take().unwrap());
302 let mut read_at_least_one_message = false; 270 let mut read_at_least_one_message = false;
303 271 for message in cargo_metadata::Message::parse_stream(stdout) {
304 for line in stdout.lines() {
305 let line = line?;
306
307 let message = serde_json::from_str::<cargo_metadata::Message>(&line);
308 let message = match message { 272 let message = match message {
309 Ok(message) => message, 273 Ok(message) => message,
310 Err(err) => { 274 Err(err) => {
311 log::error!("Invalid json from cargo check, ignoring ({}): {:?} ", err, line); 275 log::error!("Invalid json from cargo check, ignoring ({})", err);
312 continue; 276 continue;
313 } 277 }
314 }; 278 };
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 8c94f430a..21e705597 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -29,6 +29,7 @@ rustc-hash = "1.1.0"
29serde = { version = "1.0.106", features = ["derive"] } 29serde = { version = "1.0.106", features = ["derive"] }
30serde_json = "1.0.48" 30serde_json = "1.0.48"
31threadpool = "1.7.1" 31threadpool = "1.7.1"
32cargo_metadata = "0.10.0"
32 33
33stdx = { path = "../stdx" } 34stdx = { path = "../stdx" }
34 35
@@ -53,6 +54,7 @@ winapi = "0.3.8"
53 54
54[dev-dependencies] 55[dev-dependencies]
55tempfile = "3.1.0" 56tempfile = "3.1.0"
57insta = "0.16.0"
56test_utils = { path = "../test_utils" } 58test_utils = { path = "../test_utils" }
57 59
58[features] 60[features]
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index e7924f0a3..4bdd45a7d 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -1,4 +1,5 @@
1//! Book keeping for keeping diagnostics easily in sync with the client. 1//! Book keeping for keeping diagnostics easily in sync with the client.
2pub(crate) mod to_proto;
2 3
3use std::{collections::HashMap, sync::Arc}; 4use std::{collections::HashMap, sync::Arc};
4 5
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_clippy_pass_by_ref.snap
index 4c9db0385..d7f9ec049 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_clippy_pass_by_ref.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_handles_macro_location.snap
index 7cde4d867..a59faf254 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_handles_macro_location.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_macro_compiler_error.snap
index 1cc37e087..3c78e7f36 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_macro_compiler_error.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
index 615ed8378..076b3cf27 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_incompatible_type_for_trait.snap
index 0df0fce18..46d0c56d2 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_incompatible_type_for_trait.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_mismatched_type.snap
index 28ebcb3b3..4182929ba 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_mismatched_type.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
index 5e0873281..69138c15b 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_wrong_number_of_parameters.snap
index e500d3cd6..f6ab05004 100644
--- a/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_wrong_number_of_parameters.snap
@@ -1,5 +1,5 @@
1--- 1---
2source: crates/ra_flycheck/src/conv/test.rs 2source: crates/rust-analyzer/src/diagnostics/to_proto.rs
3expression: diag 3expression: diag
4--- 4---
5[ 5[
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
new file mode 100644
index 000000000..0c8108591
--- /dev/null
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -0,0 +1,1408 @@
1//! This module provides the functionality needed to convert diagnostics from
2//! `cargo check` json format to the LSP diagnostic format.
3use cargo_metadata::diagnostic::{
4 Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
5 DiagnosticSpanMacroExpansion,
6};
7use lsp_types::{
8 CodeAction, Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag,
9 Location, NumberOrString, Position, Range, TextEdit, Url, WorkspaceEdit,
10};
11use std::{
12 collections::HashMap,
13 fmt::Write,
14 path::{Component, Path, PathBuf, Prefix},
15 str::FromStr,
16};
17
18/// Converts a Rust level string to a LSP severity
19fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
20 match val {
21 DiagnosticLevel::Ice => Some(DiagnosticSeverity::Error),
22 DiagnosticLevel::Error => Some(DiagnosticSeverity::Error),
23 DiagnosticLevel::Warning => Some(DiagnosticSeverity::Warning),
24 DiagnosticLevel::Note => Some(DiagnosticSeverity::Information),
25 DiagnosticLevel::Help => Some(DiagnosticSeverity::Hint),
26 DiagnosticLevel::Unknown => None,
27 }
28}
29
30/// Check whether a file name is from macro invocation
31fn is_from_macro(file_name: &str) -> bool {
32 file_name.starts_with('<') && file_name.ends_with('>')
33}
34
35/// Converts a Rust macro span to a LSP location recursively
36fn map_macro_span_to_location(
37 span_macro: &DiagnosticSpanMacroExpansion,
38 workspace_root: &PathBuf,
39) -> Option<Location> {
40 if !is_from_macro(&span_macro.span.file_name) {
41 return Some(map_span_to_location(&span_macro.span, workspace_root));
42 }
43
44 if let Some(expansion) = &span_macro.span.expansion {
45 return map_macro_span_to_location(&expansion, workspace_root);
46 }
47
48 None
49}
50
51/// Converts a Rust span to a LSP location, resolving macro expansion site if neccesary
52fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
53 if span.expansion.is_some() {
54 let expansion = span.expansion.as_ref().unwrap();
55 if let Some(macro_range) = map_macro_span_to_location(&expansion, workspace_root) {
56 return macro_range;
57 }
58 }
59
60 map_span_to_location_naive(span, workspace_root)
61}
62
63/// Converts a Rust span to a LSP location
64fn map_span_to_location_naive(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
65 let mut file_name = workspace_root.clone();
66 file_name.push(&span.file_name);
67 let uri = url_from_path_with_drive_lowercasing(file_name).unwrap();
68
69 let range = Range::new(
70 Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
71 Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
72 );
73
74 Location { uri, range }
75}
76
77/// Converts a secondary Rust span to a LSP related information
78///
79/// If the span is unlabelled this will return `None`.
80fn map_secondary_span_to_related(
81 span: &DiagnosticSpan,
82 workspace_root: &PathBuf,
83) -> Option<DiagnosticRelatedInformation> {
84 if let Some(label) = &span.label {
85 let location = map_span_to_location(span, workspace_root);
86 Some(DiagnosticRelatedInformation { location, message: label.clone() })
87 } else {
88 // Nothing to label this with
89 None
90 }
91}
92
93/// Determines if diagnostic is related to unused code
94fn is_unused_or_unnecessary(rd: &RustDiagnostic) -> bool {
95 if let Some(code) = &rd.code {
96 match code.code.as_str() {
97 "dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"
98 | "unused_imports" | "unused_macros" | "unused_variables" => true,
99 _ => false,
100 }
101 } else {
102 false
103 }
104}
105
106/// Determines if diagnostic is related to deprecated code
107fn is_deprecated(rd: &RustDiagnostic) -> bool {
108 if let Some(code) = &rd.code {
109 match code.code.as_str() {
110 "deprecated" => true,
111 _ => false,
112 }
113 } else {
114 false
115 }
116}
117
118enum MappedRustChildDiagnostic {
119 Related(DiagnosticRelatedInformation),
120 SuggestedFix(CodeAction),
121 MessageLine(String),
122}
123
124fn map_rust_child_diagnostic(
125 rd: &RustDiagnostic,
126 workspace_root: &PathBuf,
127) -> MappedRustChildDiagnostic {
128 let spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
129 if spans.is_empty() {
130 // `rustc` uses these spanless children as a way to print multi-line
131 // messages
132 return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
133 }
134
135 let mut edit_map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
136 for &span in &spans {
137 match (&span.suggestion_applicability, &span.suggested_replacement) {
138 (Some(Applicability::MachineApplicable), Some(suggested_replacement)) => {
139 let location = map_span_to_location(span, workspace_root);
140 let edit = TextEdit::new(location.range, suggested_replacement.clone());
141 edit_map.entry(location.uri).or_default().push(edit);
142 }
143 _ => {}
144 }
145 }
146
147 if !edit_map.is_empty() {
148 MappedRustChildDiagnostic::SuggestedFix(CodeAction {
149 title: rd.message.clone(),
150 kind: Some("quickfix".to_string()),
151 diagnostics: None,
152 edit: Some(WorkspaceEdit::new(edit_map)),
153 command: None,
154 is_preferred: None,
155 })
156 } else {
157 MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
158 location: map_span_to_location(spans[0], workspace_root),
159 message: rd.message.clone(),
160 })
161 }
162}
163
164#[derive(Debug)]
165pub(crate) struct MappedRustDiagnostic {
166 pub location: Location,
167 pub diagnostic: Diagnostic,
168 pub fixes: Vec<CodeAction>,
169}
170
171/// Converts a Rust root diagnostic to LSP form
172///
173/// This flattens the Rust diagnostic by:
174///
175/// 1. Creating a LSP diagnostic with the root message and primary span.
176/// 2. Adding any labelled secondary spans to `relatedInformation`
177/// 3. Categorising child diagnostics as either `SuggestedFix`es,
178/// `relatedInformation` or additional message lines.
179///
180/// If the diagnostic has no primary span this will return `None`
181pub(crate) fn map_rust_diagnostic_to_lsp(
182 rd: &RustDiagnostic,
183 workspace_root: &PathBuf,
184) -> Vec<MappedRustDiagnostic> {
185 let primary_spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
186 if primary_spans.is_empty() {
187 return vec![];
188 }
189
190 let severity = map_level_to_severity(rd.level);
191
192 let mut source = String::from("rustc");
193 let mut code = rd.code.as_ref().map(|c| c.code.clone());
194 if let Some(code_val) = &code {
195 // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
196 let scoped_code: Vec<&str> = code_val.split("::").collect();
197 if scoped_code.len() == 2 {
198 source = String::from(scoped_code[0]);
199 code = Some(String::from(scoped_code[1]));
200 }
201 }
202
203 let mut needs_primary_span_label = true;
204 let mut related_information = vec![];
205 let mut tags = vec![];
206
207 for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
208 let related = map_secondary_span_to_related(secondary_span, workspace_root);
209 if let Some(related) = related {
210 related_information.push(related);
211 }
212 }
213
214 let mut fixes = vec![];
215 let mut message = rd.message.clone();
216 for child in &rd.children {
217 let child = map_rust_child_diagnostic(&child, workspace_root);
218 match child {
219 MappedRustChildDiagnostic::Related(related) => related_information.push(related),
220 MappedRustChildDiagnostic::SuggestedFix(code_action) => fixes.push(code_action),
221 MappedRustChildDiagnostic::MessageLine(message_line) => {
222 write!(&mut message, "\n{}", message_line).unwrap();
223
224 // These secondary messages usually duplicate the content of the
225 // primary span label.
226 needs_primary_span_label = false;
227 }
228 }
229 }
230
231 if is_unused_or_unnecessary(rd) {
232 tags.push(DiagnosticTag::Unnecessary);
233 }
234
235 if is_deprecated(rd) {
236 tags.push(DiagnosticTag::Deprecated);
237 }
238
239 primary_spans
240 .iter()
241 .map(|primary_span| {
242 let location = map_span_to_location(&primary_span, workspace_root);
243
244 let mut message = message.clone();
245 if needs_primary_span_label {
246 if let Some(primary_span_label) = &primary_span.label {
247 write!(&mut message, "\n{}", primary_span_label).unwrap();
248 }
249 }
250
251 // If error occurs from macro expansion, add related info pointing to
252 // where the error originated
253 if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
254 let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
255 related_information.push(DiagnosticRelatedInformation {
256 location: def_loc,
257 message: "Error originated from macro here".to_string(),
258 });
259 }
260
261 let diagnostic = Diagnostic {
262 range: location.range,
263 severity,
264 code: code.clone().map(NumberOrString::String),
265 source: Some(source.clone()),
266 message,
267 related_information: if !related_information.is_empty() {
268 Some(related_information.clone())
269 } else {
270 None
271 },
272 tags: if !tags.is_empty() { Some(tags.clone()) } else { None },
273 };
274
275 MappedRustDiagnostic { location, diagnostic, fixes: fixes.clone() }
276 })
277 .collect()
278}
279
280/// Returns a `Url` object from a given path, will lowercase drive letters if present.
281/// This will only happen when processing windows paths.
282///
283/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
284pub fn url_from_path_with_drive_lowercasing(
285 path: impl AsRef<Path>,
286) -> Result<Url, Box<dyn std::error::Error + Send + Sync>> {
287 let component_has_windows_drive = path.as_ref().components().any(|comp| {
288 if let Component::Prefix(c) = comp {
289 match c.kind() {
290 Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
291 _ => return false,
292 }
293 }
294 false
295 });
296
297 // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
298 if component_has_windows_drive {
299 let url_original = Url::from_file_path(&path)
300 .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
301
302 let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
303
304 // There is a drive partition, but we never found a colon.
305 // This should not happen, but in this case we just pass it through.
306 if drive_partition.len() == 1 {
307 return Ok(url_original);
308 }
309
310 let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
311 let url = Url::from_str(&joined).expect("This came from a valid `Url`");
312
313 Ok(url)
314 } else {
315 Ok(Url::from_file_path(&path)
316 .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
317 }
318}
319
320#[cfg(test)]
321mod tests {
322 use super::*;
323
324 // `Url` is not able to parse windows paths on unix machines.
325 #[test]
326 #[cfg(target_os = "windows")]
327 fn test_lowercase_drive_letter_with_drive() {
328 let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
329
330 assert_eq!(url.to_string(), "file:///c:/Test");
331 }
332
333 #[test]
334 #[cfg(target_os = "windows")]
335 fn test_drive_without_colon_passthrough() {
336 let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
337
338 assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
339 }
340
341 #[cfg(not(windows))]
342 fn parse_diagnostic(val: &str) -> cargo_metadata::diagnostic::Diagnostic {
343 serde_json::from_str::<cargo_metadata::diagnostic::Diagnostic>(val).unwrap()
344 }
345
346 #[test]
347 #[cfg(not(windows))]
348 fn snap_rustc_incompatible_type_for_trait() {
349 let diag = parse_diagnostic(
350 r##"{
351 "message": "method `next` has an incompatible type for trait",
352 "code": {
353 "code": "E0053",
354 "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n fn foo(x: u16);\n fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n // error, expected u16, found i16\n fn foo(x: i16) { }\n\n // error, types differ in mutability\n fn bar(&mut self) { }\n}\n```\n"
355 },
356 "level": "error",
357 "spans": [
358 {
359 "file_name": "compiler/ty/list_iter.rs",
360 "byte_start": 1307,
361 "byte_end": 1350,
362 "line_start": 52,
363 "line_end": 52,
364 "column_start": 5,
365 "column_end": 48,
366 "is_primary": true,
367 "text": [
368 {
369 "text": " fn next(&self) -> Option<&'list ty::Ref<M>> {",
370 "highlight_start": 5,
371 "highlight_end": 48
372 }
373 ],
374 "label": "types differ in mutability",
375 "suggested_replacement": null,
376 "suggestion_applicability": null,
377 "expansion": null
378 }
379 ],
380 "children": [
381 {
382 "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
383 "code": null,
384 "level": "note",
385 "spans": [],
386 "children": [],
387 "rendered": null
388 }
389 ],
390 "rendered": "error[E0053]: method `next` has an incompatible type for trait\n --> compiler/ty/list_iter.rs:52:5\n |\n52 | fn next(&self) -> Option<&'list ty::Ref<M>> {\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n |\n = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
391 }
392 "##,
393 );
394
395 let workspace_root = PathBuf::from("/test/");
396 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
397 insta::assert_debug_snapshot!(diag);
398 }
399
400 #[test]
401 #[cfg(not(windows))]
402 fn snap_rustc_unused_variable() {
403 let diag = parse_diagnostic(
404 r##"{
405 "message": "unused variable: `foo`",
406 "code": {
407 "code": "unused_variables",
408 "explanation": null
409 },
410 "level": "warning",
411 "spans": [
412 {
413 "file_name": "driver/subcommand/repl.rs",
414 "byte_start": 9228,
415 "byte_end": 9231,
416 "line_start": 291,
417 "line_end": 291,
418 "column_start": 9,
419 "column_end": 12,
420 "is_primary": true,
421 "text": [
422 {
423 "text": " let foo = 42;",
424 "highlight_start": 9,
425 "highlight_end": 12
426 }
427 ],
428 "label": null,
429 "suggested_replacement": null,
430 "suggestion_applicability": null,
431 "expansion": null
432 }
433 ],
434 "children": [
435 {
436 "message": "#[warn(unused_variables)] on by default",
437 "code": null,
438 "level": "note",
439 "spans": [],
440 "children": [],
441 "rendered": null
442 },
443 {
444 "message": "consider prefixing with an underscore",
445 "code": null,
446 "level": "help",
447 "spans": [
448 {
449 "file_name": "driver/subcommand/repl.rs",
450 "byte_start": 9228,
451 "byte_end": 9231,
452 "line_start": 291,
453 "line_end": 291,
454 "column_start": 9,
455 "column_end": 12,
456 "is_primary": true,
457 "text": [
458 {
459 "text": " let foo = 42;",
460 "highlight_start": 9,
461 "highlight_end": 12
462 }
463 ],
464 "label": null,
465 "suggested_replacement": "_foo",
466 "suggestion_applicability": "MachineApplicable",
467 "expansion": null
468 }
469 ],
470 "children": [],
471 "rendered": null
472 }
473 ],
474 "rendered": "warning: unused variable: `foo`\n --> driver/subcommand/repl.rs:291:9\n |\n291 | let foo = 42;\n | ^^^ help: consider prefixing with an underscore: `_foo`\n |\n = note: #[warn(unused_variables)] on by default\n\n"
475 }"##,
476 );
477
478 let workspace_root = PathBuf::from("/test/");
479 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
480 insta::assert_debug_snapshot!(diag);
481 }
482
483 #[test]
484 #[cfg(not(windows))]
485 fn snap_rustc_wrong_number_of_parameters() {
486 let diag = parse_diagnostic(
487 r##"{
488 "message": "this function takes 2 parameters but 3 parameters were supplied",
489 "code": {
490 "code": "E0061",
491 "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
492 },
493 "level": "error",
494 "spans": [
495 {
496 "file_name": "compiler/ty/select.rs",
497 "byte_start": 8787,
498 "byte_end": 9241,
499 "line_start": 219,
500 "line_end": 231,
501 "column_start": 5,
502 "column_end": 6,
503 "is_primary": false,
504 "text": [
505 {
506 "text": " pub fn add_evidence(",
507 "highlight_start": 5,
508 "highlight_end": 25
509 },
510 {
511 "text": " &mut self,",
512 "highlight_start": 1,
513 "highlight_end": 19
514 },
515 {
516 "text": " target_poly: &ty::Ref<ty::Poly>,",
517 "highlight_start": 1,
518 "highlight_end": 41
519 },
520 {
521 "text": " evidence_poly: &ty::Ref<ty::Poly>,",
522 "highlight_start": 1,
523 "highlight_end": 43
524 },
525 {
526 "text": " ) {",
527 "highlight_start": 1,
528 "highlight_end": 8
529 },
530 {
531 "text": " match target_poly {",
532 "highlight_start": 1,
533 "highlight_end": 28
534 },
535 {
536 "text": " ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
537 "highlight_start": 1,
538 "highlight_end": 81
539 },
540 {
541 "text": " ty::Ref::Fixed(target_ty) => {",
542 "highlight_start": 1,
543 "highlight_end": 43
544 },
545 {
546 "text": " let evidence_ty = evidence_poly.resolve_to_ty();",
547 "highlight_start": 1,
548 "highlight_end": 65
549 },
550 {
551 "text": " self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
552 "highlight_start": 1,
553 "highlight_end": 76
554 },
555 {
556 "text": " }",
557 "highlight_start": 1,
558 "highlight_end": 14
559 },
560 {
561 "text": " }",
562 "highlight_start": 1,
563 "highlight_end": 10
564 },
565 {
566 "text": " }",
567 "highlight_start": 1,
568 "highlight_end": 6
569 }
570 ],
571 "label": "defined here",
572 "suggested_replacement": null,
573 "suggestion_applicability": null,
574 "expansion": null
575 },
576 {
577 "file_name": "compiler/ty/select.rs",
578 "byte_start": 4045,
579 "byte_end": 4057,
580 "line_start": 104,
581 "line_end": 104,
582 "column_start": 18,
583 "column_end": 30,
584 "is_primary": true,
585 "text": [
586 {
587 "text": " self.add_evidence(target_fixed, evidence_fixed, false);",
588 "highlight_start": 18,
589 "highlight_end": 30
590 }
591 ],
592 "label": "expected 2 parameters",
593 "suggested_replacement": null,
594 "suggestion_applicability": null,
595 "expansion": null
596 }
597 ],
598 "children": [],
599 "rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n --> compiler/ty/select.rs:104:18\n |\n104 | self.add_evidence(target_fixed, evidence_fixed, false);\n | ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | / pub fn add_evidence(\n220 | | &mut self,\n221 | | target_poly: &ty::Ref<ty::Poly>,\n222 | | evidence_poly: &ty::Ref<ty::Poly>,\n... |\n230 | | }\n231 | | }\n | |_____- defined here\n\n"
600 }"##,
601 );
602
603 let workspace_root = PathBuf::from("/test/");
604 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
605 insta::assert_debug_snapshot!(diag);
606 }
607
608 #[test]
609 #[cfg(not(windows))]
610 fn snap_clippy_pass_by_ref() {
611 let diag = parse_diagnostic(
612 r##"{
613 "message": "this argument is passed by reference, but would be more efficient if passed by value",
614 "code": {
615 "code": "clippy::trivially_copy_pass_by_ref",
616 "explanation": null
617 },
618 "level": "warning",
619 "spans": [
620 {
621 "file_name": "compiler/mir/tagset.rs",
622 "byte_start": 941,
623 "byte_end": 946,
624 "line_start": 42,
625 "line_end": 42,
626 "column_start": 24,
627 "column_end": 29,
628 "is_primary": true,
629 "text": [
630 {
631 "text": " pub fn is_disjoint(&self, other: Self) -> bool {",
632 "highlight_start": 24,
633 "highlight_end": 29
634 }
635 ],
636 "label": null,
637 "suggested_replacement": null,
638 "suggestion_applicability": null,
639 "expansion": null
640 }
641 ],
642 "children": [
643 {
644 "message": "lint level defined here",
645 "code": null,
646 "level": "note",
647 "spans": [
648 {
649 "file_name": "compiler/lib.rs",
650 "byte_start": 8,
651 "byte_end": 19,
652 "line_start": 1,
653 "line_end": 1,
654 "column_start": 9,
655 "column_end": 20,
656 "is_primary": true,
657 "text": [
658 {
659 "text": "#![warn(clippy::all)]",
660 "highlight_start": 9,
661 "highlight_end": 20
662 }
663 ],
664 "label": null,
665 "suggested_replacement": null,
666 "suggestion_applicability": null,
667 "expansion": null
668 }
669 ],
670 "children": [],
671 "rendered": null
672 },
673 {
674 "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
675 "code": null,
676 "level": "note",
677 "spans": [],
678 "children": [],
679 "rendered": null
680 },
681 {
682 "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
683 "code": null,
684 "level": "help",
685 "spans": [],
686 "children": [],
687 "rendered": null
688 },
689 {
690 "message": "consider passing by value instead",
691 "code": null,
692 "level": "help",
693 "spans": [
694 {
695 "file_name": "compiler/mir/tagset.rs",
696 "byte_start": 941,
697 "byte_end": 946,
698 "line_start": 42,
699 "line_end": 42,
700 "column_start": 24,
701 "column_end": 29,
702 "is_primary": true,
703 "text": [
704 {
705 "text": " pub fn is_disjoint(&self, other: Self) -> bool {",
706 "highlight_start": 24,
707 "highlight_end": 29
708 }
709 ],
710 "label": null,
711 "suggested_replacement": "self",
712 "suggestion_applicability": "Unspecified",
713 "expansion": null
714 }
715 ],
716 "children": [],
717 "rendered": null
718 }
719 ],
720 "rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n --> compiler/mir/tagset.rs:42:24\n |\n42 | pub fn is_disjoint(&self, other: Self) -> bool {\n | ^^^^^ help: consider passing by value instead: `self`\n |\nnote: lint level defined here\n --> compiler/lib.rs:1:9\n |\n1 | #![warn(clippy::all)]\n | ^^^^^^^^^^^\n = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
721 }"##,
722 );
723
724 let workspace_root = PathBuf::from("/test/");
725 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
726 insta::assert_debug_snapshot!(diag);
727 }
728
729 #[test]
730 #[cfg(not(windows))]
731 fn snap_rustc_mismatched_type() {
732 let diag = parse_diagnostic(
733 r##"{
734 "message": "mismatched types",
735 "code": {
736 "code": "E0308",
737 "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n// ~~~ ~~~~~~~~~~~~~~~~~~~~\n// | |\n// | initializing expression;\n// | compiler infers type `&str`\n// |\n// type `i32` assigned to variable `x`\n```\n"
738 },
739 "level": "error",
740 "spans": [
741 {
742 "file_name": "runtime/compiler_support.rs",
743 "byte_start": 1589,
744 "byte_end": 1594,
745 "line_start": 48,
746 "line_end": 48,
747 "column_start": 65,
748 "column_end": 70,
749 "is_primary": true,
750 "text": [
751 {
752 "text": " let layout = alloc::Layout::from_size_align_unchecked(size, align);",
753 "highlight_start": 65,
754 "highlight_end": 70
755 }
756 ],
757 "label": "expected usize, found u32",
758 "suggested_replacement": null,
759 "suggestion_applicability": null,
760 "expansion": null
761 }
762 ],
763 "children": [],
764 "rendered": "error[E0308]: mismatched types\n --> runtime/compiler_support.rs:48:65\n |\n48 | let layout = alloc::Layout::from_size_align_unchecked(size, align);\n | ^^^^^ expected usize, found u32\n\n"
765 }"##,
766 );
767
768 let workspace_root = PathBuf::from("/test/");
769 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
770 insta::assert_debug_snapshot!(diag);
771 }
772
773 #[test]
774 #[cfg(not(windows))]
775 fn snap_handles_macro_location() {
776 let diag = parse_diagnostic(
777 r##"{
778 "rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n |\n2 | assert_eq!(1, \"love\");\n | ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n |\n = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
779 "children": [
780 {
781 "children": [],
782 "code": null,
783 "level": "help",
784 "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
785 "rendered": null,
786 "spans": []
787 }
788 ],
789 "code": {
790 "code": "E0277",
791 "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n foo.bar();\n}\n\nfn main() {\n // we now call the method with the i32 type, which doesn't implement\n // the Foo trait\n some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n foo.bar(); // we can now use this method since i32 implements the\n // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n fn bar(&self) {}\n}\n\nfn main() {\n some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n // implemented for the type `T`\n}\n\nfn main() {\n // We now call the method with the i32 type,\n // which *does* implement the Debug trait.\n some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n println!(\"{:?}\", foo);\n}\n\nfn main() {\n // Calling the method is still fine, as i32 implements Debug.\n some_func(5i32);\n\n // This would fail to compile now:\n // struct WithoutDebug;\n // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
792 },
793 "level": "error",
794 "message": "can't compare `{integer}` with `&str`",
795 "spans": [
796 {
797 "byte_end": 155,
798 "byte_start": 153,
799 "column_end": 33,
800 "column_start": 31,
801 "expansion": {
802 "def_site_span": {
803 "byte_end": 940,
804 "byte_start": 0,
805 "column_end": 6,
806 "column_start": 1,
807 "expansion": null,
808 "file_name": "<::core::macros::assert_eq macros>",
809 "is_primary": false,
810 "label": null,
811 "line_end": 36,
812 "line_start": 1,
813 "suggested_replacement": null,
814 "suggestion_applicability": null,
815 "text": [
816 {
817 "highlight_end": 35,
818 "highlight_start": 1,
819 "text": "($ left : expr, $ right : expr) =>"
820 },
821 {
822 "highlight_end": 3,
823 "highlight_start": 1,
824 "text": "({"
825 },
826 {
827 "highlight_end": 33,
828 "highlight_start": 1,
829 "text": " match (& $ left, & $ right)"
830 },
831 {
832 "highlight_end": 7,
833 "highlight_start": 1,
834 "text": " {"
835 },
836 {
837 "highlight_end": 34,
838 "highlight_start": 1,
839 "text": " (left_val, right_val) =>"
840 },
841 {
842 "highlight_end": 11,
843 "highlight_start": 1,
844 "text": " {"
845 },
846 {
847 "highlight_end": 46,
848 "highlight_start": 1,
849 "text": " if ! (* left_val == * right_val)"
850 },
851 {
852 "highlight_end": 15,
853 "highlight_start": 1,
854 "text": " {"
855 },
856 {
857 "highlight_end": 25,
858 "highlight_start": 1,
859 "text": " panic !"
860 },
861 {
862 "highlight_end": 57,
863 "highlight_start": 1,
864 "text": " (r#\"assertion failed: `(left == right)`"
865 },
866 {
867 "highlight_end": 16,
868 "highlight_start": 1,
869 "text": " left: `{:?}`,"
870 },
871 {
872 "highlight_end": 18,
873 "highlight_start": 1,
874 "text": " right: `{:?}`\"#,"
875 },
876 {
877 "highlight_end": 47,
878 "highlight_start": 1,
879 "text": " & * left_val, & * right_val)"
880 },
881 {
882 "highlight_end": 15,
883 "highlight_start": 1,
884 "text": " }"
885 },
886 {
887 "highlight_end": 11,
888 "highlight_start": 1,
889 "text": " }"
890 },
891 {
892 "highlight_end": 7,
893 "highlight_start": 1,
894 "text": " }"
895 },
896 {
897 "highlight_end": 42,
898 "highlight_start": 1,
899 "text": " }) ; ($ left : expr, $ right : expr,) =>"
900 },
901 {
902 "highlight_end": 49,
903 "highlight_start": 1,
904 "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
905 },
906 {
907 "highlight_end": 53,
908 "highlight_start": 1,
909 "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
910 },
911 {
912 "highlight_end": 3,
913 "highlight_start": 1,
914 "text": "({"
915 },
916 {
917 "highlight_end": 37,
918 "highlight_start": 1,
919 "text": " match (& ($ left), & ($ right))"
920 },
921 {
922 "highlight_end": 7,
923 "highlight_start": 1,
924 "text": " {"
925 },
926 {
927 "highlight_end": 34,
928 "highlight_start": 1,
929 "text": " (left_val, right_val) =>"
930 },
931 {
932 "highlight_end": 11,
933 "highlight_start": 1,
934 "text": " {"
935 },
936 {
937 "highlight_end": 46,
938 "highlight_start": 1,
939 "text": " if ! (* left_val == * right_val)"
940 },
941 {
942 "highlight_end": 15,
943 "highlight_start": 1,
944 "text": " {"
945 },
946 {
947 "highlight_end": 25,
948 "highlight_start": 1,
949 "text": " panic !"
950 },
951 {
952 "highlight_end": 57,
953 "highlight_start": 1,
954 "text": " (r#\"assertion failed: `(left == right)`"
955 },
956 {
957 "highlight_end": 16,
958 "highlight_start": 1,
959 "text": " left: `{:?}`,"
960 },
961 {
962 "highlight_end": 22,
963 "highlight_start": 1,
964 "text": " right: `{:?}`: {}\"#,"
965 },
966 {
967 "highlight_end": 72,
968 "highlight_start": 1,
969 "text": " & * left_val, & * right_val, $ crate :: format_args !"
970 },
971 {
972 "highlight_end": 33,
973 "highlight_start": 1,
974 "text": " ($ ($ arg) +))"
975 },
976 {
977 "highlight_end": 15,
978 "highlight_start": 1,
979 "text": " }"
980 },
981 {
982 "highlight_end": 11,
983 "highlight_start": 1,
984 "text": " }"
985 },
986 {
987 "highlight_end": 7,
988 "highlight_start": 1,
989 "text": " }"
990 },
991 {
992 "highlight_end": 6,
993 "highlight_start": 1,
994 "text": " }) ;"
995 }
996 ]
997 },
998 "macro_decl_name": "assert_eq!",
999 "span": {
1000 "byte_end": 38,
1001 "byte_start": 16,
1002 "column_end": 27,
1003 "column_start": 5,
1004 "expansion": null,
1005 "file_name": "src/main.rs",
1006 "is_primary": false,
1007 "label": null,
1008 "line_end": 2,
1009 "line_start": 2,
1010 "suggested_replacement": null,
1011 "suggestion_applicability": null,
1012 "text": [
1013 {
1014 "highlight_end": 27,
1015 "highlight_start": 5,
1016 "text": " assert_eq!(1, \"love\");"
1017 }
1018 ]
1019 }
1020 },
1021 "file_name": "<::core::macros::assert_eq macros>",
1022 "is_primary": true,
1023 "label": "no implementation for `{integer} == &str`",
1024 "line_end": 7,
1025 "line_start": 7,
1026 "suggested_replacement": null,
1027 "suggestion_applicability": null,
1028 "text": [
1029 {
1030 "highlight_end": 33,
1031 "highlight_start": 31,
1032 "text": " if ! (* left_val == * right_val)"
1033 }
1034 ]
1035 }
1036 ]
1037 }"##,
1038 );
1039
1040 let workspace_root = PathBuf::from("/test/");
1041 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
1042 insta::assert_debug_snapshot!(diag);
1043 }
1044
1045 #[test]
1046 #[cfg(not(windows))]
1047 fn snap_macro_compiler_error() {
1048 let diag = parse_diagnostic(
1049 r##"{
1050 "rendered": "error: Please register your known path in the path module\n --> crates/ra_hir_def/src/path.rs:265:9\n |\n265 | compile_error!(\"Please register your known path in the path module\")\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n | \n ::: crates/ra_hir_def/src/data.rs:80:16\n |\n80 | let path = path![std::future::Future];\n | -------------------------- in this macro invocation\n\n",
1051 "children": [],
1052 "code": null,
1053 "level": "error",
1054 "message": "Please register your known path in the path module",
1055 "spans": [
1056 {
1057 "byte_end": 8285,
1058 "byte_start": 8217,
1059 "column_end": 77,
1060 "column_start": 9,
1061 "expansion": {
1062 "def_site_span": {
1063 "byte_end": 8294,
1064 "byte_start": 7858,
1065 "column_end": 2,
1066 "column_start": 1,
1067 "expansion": null,
1068 "file_name": "crates/ra_hir_def/src/path.rs",
1069 "is_primary": false,
1070 "label": null,
1071 "line_end": 267,
1072 "line_start": 254,
1073 "suggested_replacement": null,
1074 "suggestion_applicability": null,
1075 "text": [
1076 {
1077 "highlight_end": 28,
1078 "highlight_start": 1,
1079 "text": "macro_rules! __known_path {"
1080 },
1081 {
1082 "highlight_end": 37,
1083 "highlight_start": 1,
1084 "text": " (std::iter::IntoIterator) => {};"
1085 },
1086 {
1087 "highlight_end": 33,
1088 "highlight_start": 1,
1089 "text": " (std::result::Result) => {};"
1090 },
1091 {
1092 "highlight_end": 29,
1093 "highlight_start": 1,
1094 "text": " (std::ops::Range) => {};"
1095 },
1096 {
1097 "highlight_end": 33,
1098 "highlight_start": 1,
1099 "text": " (std::ops::RangeFrom) => {};"
1100 },
1101 {
1102 "highlight_end": 33,
1103 "highlight_start": 1,
1104 "text": " (std::ops::RangeFull) => {};"
1105 },
1106 {
1107 "highlight_end": 31,
1108 "highlight_start": 1,
1109 "text": " (std::ops::RangeTo) => {};"
1110 },
1111 {
1112 "highlight_end": 40,
1113 "highlight_start": 1,
1114 "text": " (std::ops::RangeToInclusive) => {};"
1115 },
1116 {
1117 "highlight_end": 38,
1118 "highlight_start": 1,
1119 "text": " (std::ops::RangeInclusive) => {};"
1120 },
1121 {
1122 "highlight_end": 27,
1123 "highlight_start": 1,
1124 "text": " (std::ops::Try) => {};"
1125 },
1126 {
1127 "highlight_end": 22,
1128 "highlight_start": 1,
1129 "text": " ($path:path) => {"
1130 },
1131 {
1132 "highlight_end": 77,
1133 "highlight_start": 1,
1134 "text": " compile_error!(\"Please register your known path in the path module\")"
1135 },
1136 {
1137 "highlight_end": 7,
1138 "highlight_start": 1,
1139 "text": " };"
1140 },
1141 {
1142 "highlight_end": 2,
1143 "highlight_start": 1,
1144 "text": "}"
1145 }
1146 ]
1147 },
1148 "macro_decl_name": "$crate::__known_path!",
1149 "span": {
1150 "byte_end": 8427,
1151 "byte_start": 8385,
1152 "column_end": 51,
1153 "column_start": 9,
1154 "expansion": {
1155 "def_site_span": {
1156 "byte_end": 8611,
1157 "byte_start": 8312,
1158 "column_end": 2,
1159 "column_start": 1,
1160 "expansion": null,
1161 "file_name": "crates/ra_hir_def/src/path.rs",
1162 "is_primary": false,
1163 "label": null,
1164 "line_end": 277,
1165 "line_start": 270,
1166 "suggested_replacement": null,
1167 "suggestion_applicability": null,
1168 "text": [
1169 {
1170 "highlight_end": 22,
1171 "highlight_start": 1,
1172 "text": "macro_rules! __path {"
1173 },
1174 {
1175 "highlight_end": 43,
1176 "highlight_start": 1,
1177 "text": " ($start:ident $(:: $seg:ident)*) => ({"
1178 },
1179 {
1180 "highlight_end": 51,
1181 "highlight_start": 1,
1182 "text": " $crate::__known_path!($start $(:: $seg)*);"
1183 },
1184 {
1185 "highlight_end": 87,
1186 "highlight_start": 1,
1187 "text": " $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec!["
1188 },
1189 {
1190 "highlight_end": 76,
1191 "highlight_start": 1,
1192 "text": " $crate::path::__name![$start], $($crate::path::__name![$seg],)*"
1193 },
1194 {
1195 "highlight_end": 11,
1196 "highlight_start": 1,
1197 "text": " ])"
1198 },
1199 {
1200 "highlight_end": 8,
1201 "highlight_start": 1,
1202 "text": " });"
1203 },
1204 {
1205 "highlight_end": 2,
1206 "highlight_start": 1,
1207 "text": "}"
1208 }
1209 ]
1210 },
1211 "macro_decl_name": "path!",
1212 "span": {
1213 "byte_end": 2966,
1214 "byte_start": 2940,
1215 "column_end": 42,
1216 "column_start": 16,
1217 "expansion": null,
1218 "file_name": "crates/ra_hir_def/src/data.rs",
1219 "is_primary": false,
1220 "label": null,
1221 "line_end": 80,
1222 "line_start": 80,
1223 "suggested_replacement": null,
1224 "suggestion_applicability": null,
1225 "text": [
1226 {
1227 "highlight_end": 42,
1228 "highlight_start": 16,
1229 "text": " let path = path![std::future::Future];"
1230 }
1231 ]
1232 }
1233 },
1234 "file_name": "crates/ra_hir_def/src/path.rs",
1235 "is_primary": false,
1236 "label": null,
1237 "line_end": 272,
1238 "line_start": 272,
1239 "suggested_replacement": null,
1240 "suggestion_applicability": null,
1241 "text": [
1242 {
1243 "highlight_end": 51,
1244 "highlight_start": 9,
1245 "text": " $crate::__known_path!($start $(:: $seg)*);"
1246 }
1247 ]
1248 }
1249 },
1250 "file_name": "crates/ra_hir_def/src/path.rs",
1251 "is_primary": true,
1252 "label": null,
1253 "line_end": 265,
1254 "line_start": 265,
1255 "suggested_replacement": null,
1256 "suggestion_applicability": null,
1257 "text": [
1258 {
1259 "highlight_end": 77,
1260 "highlight_start": 9,
1261 "text": " compile_error!(\"Please register your known path in the path module\")"
1262 }
1263 ]
1264 }
1265 ]
1266 }
1267 "##,
1268 );
1269
1270 let workspace_root = PathBuf::from("/test/");
1271 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
1272 insta::assert_debug_snapshot!(diag);
1273 }
1274
1275 #[test]
1276 #[cfg(not(windows))]
1277 fn snap_multi_line_fix() {
1278 let diag = parse_diagnostic(
1279 r##"{
1280 "rendered": "warning: returning the result of a let binding from a block\n --> src/main.rs:4:5\n |\n3 | let a = (0..10).collect();\n | -------------------------- unnecessary let binding\n4 | a\n | ^\n |\n = note: `#[warn(clippy::let_and_return)]` on by default\n = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return\nhelp: return the expression directly\n |\n3 | \n4 | (0..10).collect()\n |\n\n",
1281 "children": [
1282 {
1283 "children": [],
1284 "code": null,
1285 "level": "note",
1286 "message": "`#[warn(clippy::let_and_return)]` on by default",
1287 "rendered": null,
1288 "spans": []
1289 },
1290 {
1291 "children": [],
1292 "code": null,
1293 "level": "help",
1294 "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",
1295 "rendered": null,
1296 "spans": []
1297 },
1298 {
1299 "children": [],
1300 "code": null,
1301 "level": "help",
1302 "message": "return the expression directly",
1303 "rendered": null,
1304 "spans": [
1305 {
1306 "byte_end": 55,
1307 "byte_start": 29,
1308 "column_end": 31,
1309 "column_start": 5,
1310 "expansion": null,
1311 "file_name": "src/main.rs",
1312 "is_primary": true,
1313 "label": null,
1314 "line_end": 3,
1315 "line_start": 3,
1316 "suggested_replacement": "",
1317 "suggestion_applicability": "MachineApplicable",
1318 "text": [
1319 {
1320 "highlight_end": 31,
1321 "highlight_start": 5,
1322 "text": " let a = (0..10).collect();"
1323 }
1324 ]
1325 },
1326 {
1327 "byte_end": 61,
1328 "byte_start": 60,
1329 "column_end": 6,
1330 "column_start": 5,
1331 "expansion": null,
1332 "file_name": "src/main.rs",
1333 "is_primary": true,
1334 "label": null,
1335 "line_end": 4,
1336 "line_start": 4,
1337 "suggested_replacement": "(0..10).collect()",
1338 "suggestion_applicability": "MachineApplicable",
1339 "text": [
1340 {
1341 "highlight_end": 6,
1342 "highlight_start": 5,
1343 "text": " a"
1344 }
1345 ]
1346 }
1347 ]
1348 }
1349 ],
1350 "code": {
1351 "code": "clippy::let_and_return",
1352 "explanation": null
1353 },
1354 "level": "warning",
1355 "message": "returning the result of a let binding from a block",
1356 "spans": [
1357 {
1358 "byte_end": 55,
1359 "byte_start": 29,
1360 "column_end": 31,
1361 "column_start": 5,
1362 "expansion": null,
1363 "file_name": "src/main.rs",
1364 "is_primary": false,
1365 "label": "unnecessary let binding",
1366 "line_end": 3,
1367 "line_start": 3,
1368 "suggested_replacement": null,
1369 "suggestion_applicability": null,
1370 "text": [
1371 {
1372 "highlight_end": 31,
1373 "highlight_start": 5,
1374 "text": " let a = (0..10).collect();"
1375 }
1376 ]
1377 },
1378 {
1379 "byte_end": 61,
1380 "byte_start": 60,
1381 "column_end": 6,
1382 "column_start": 5,
1383 "expansion": null,
1384 "file_name": "src/main.rs",
1385 "is_primary": true,
1386 "label": null,
1387 "line_end": 4,
1388 "line_start": 4,
1389 "suggested_replacement": null,
1390 "suggestion_applicability": null,
1391 "text": [
1392 {
1393 "highlight_end": 6,
1394 "highlight_start": 5,
1395 "text": " a"
1396 }
1397 ]
1398 }
1399 ]
1400 }
1401 "##,
1402 );
1403
1404 let workspace_root = PathBuf::from("/test/");
1405 let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
1406 insta::assert_debug_snapshot!(diag);
1407 }
1408}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 13d305b97..15e5bb354 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -25,7 +25,7 @@ use lsp_types::{
25 WorkDoneProgressBegin, WorkDoneProgressCreateParams, WorkDoneProgressEnd, 25 WorkDoneProgressBegin, WorkDoneProgressCreateParams, WorkDoneProgressEnd,
26 WorkDoneProgressReport, 26 WorkDoneProgressReport,
27}; 27};
28use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckTask}; 28use ra_flycheck::{CheckTask, Status};
29use ra_ide::{Canceled, FileId, LibraryData, LineIndex, SourceRootId}; 29use ra_ide::{Canceled, FileId, LibraryData, LineIndex, SourceRootId};
30use ra_prof::profile; 30use ra_prof::profile;
31use ra_project_model::{PackageRoot, ProjectWorkspace}; 31use ra_project_model::{PackageRoot, ProjectWorkspace};
@@ -37,7 +37,7 @@ use threadpool::ThreadPool;
37 37
38use crate::{ 38use crate::{
39 config::{Config, FilesWatcher}, 39 config::{Config, FilesWatcher},
40 diagnostics::DiagnosticTask, 40 diagnostics::{to_proto::url_from_path_with_drive_lowercasing, DiagnosticTask},
41 from_proto, lsp_ext, 41 from_proto, lsp_ext,
42 main_loop::{ 42 main_loop::{
43 pending_requests::{PendingRequest, PendingRequests}, 43 pending_requests::{PendingRequest, PendingRequests},
@@ -736,22 +736,61 @@ fn on_check_task(
736 task_sender.send(Task::Diagnostic(DiagnosticTask::ClearCheck))?; 736 task_sender.send(Task::Diagnostic(DiagnosticTask::ClearCheck))?;
737 } 737 }
738 738
739 CheckTask::AddDiagnostic { url, diagnostic, fixes } => { 739 CheckTask::AddDiagnostic { workspace_root, diagnostic } => {
740 let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?; 740 let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
741 let file_id = match world_state.vfs.read().path2file(&path) { 741 &diagnostic,
742 Some(file) => FileId(file.0), 742 &workspace_root,
743 None => { 743 );
744 log::error!("File with cargo diagnostic not found in VFS: {}", path.display()); 744 for diag in diagnostics {
745 return Ok(()); 745 let path = diag
746 } 746 .location
747 }; 747 .uri
748 .to_file_path()
749 .map_err(|()| format!("invalid uri: {}", diag.location.uri))?;
750 let file_id = match world_state.vfs.read().path2file(&path) {
751 Some(file) => FileId(file.0),
752 None => {
753 log::error!(
754 "File with cargo diagnostic not found in VFS: {}",
755 path.display()
756 );
757 return Ok(());
758 }
759 };
748 760
749 task_sender 761 task_sender.send(Task::Diagnostic(DiagnosticTask::AddCheck(
750 .send(Task::Diagnostic(DiagnosticTask::AddCheck(file_id, diagnostic, fixes)))?; 762 file_id,
763 diag.diagnostic,
764 diag.fixes.into_iter().map(|it| it.into()).collect(),
765 )))?;
766 }
751 } 767 }
752 768
753 CheckTask::Status(progress) => { 769 CheckTask::Status(status) => {
754 if world_state.config.client_caps.work_done_progress { 770 if world_state.config.client_caps.work_done_progress {
771 let progress = match status {
772 Status::Being => {
773 lsp_types::WorkDoneProgress::Begin(lsp_types::WorkDoneProgressBegin {
774 title: "Running `cargo check`".to_string(),
775 cancellable: Some(false),
776 message: None,
777 percentage: None,
778 })
779 }
780 Status::Progress(target) => {
781 lsp_types::WorkDoneProgress::Report(lsp_types::WorkDoneProgressReport {
782 cancellable: Some(false),
783 message: Some(target),
784 percentage: None,
785 })
786 }
787 Status::End => {
788 lsp_types::WorkDoneProgress::End(lsp_types::WorkDoneProgressEnd {
789 message: None,
790 })
791 }
792 };
793
755 let params = lsp_types::ProgressParams { 794 let params = lsp_types::ProgressParams {
756 token: lsp_types::ProgressToken::String( 795 token: lsp_types::ProgressToken::String(
757 "rustAnalyzer/cargoWatcher".to_string(), 796 "rustAnalyzer/cargoWatcher".to_string(),
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 6333c15b2..367272925 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -11,7 +11,7 @@ use std::{
11use crossbeam_channel::{unbounded, Receiver}; 11use crossbeam_channel::{unbounded, Receiver};
12use lsp_types::Url; 12use lsp_types::Url;
13use parking_lot::RwLock; 13use parking_lot::RwLock;
14use ra_flycheck::{url_from_path_with_drive_lowercasing, Flycheck, FlycheckConfig}; 14use ra_flycheck::{Flycheck, FlycheckConfig};
15use ra_ide::{ 15use ra_ide::{
16 Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId, 16 Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
17}; 17};
@@ -22,7 +22,9 @@ use stdx::format_to;
22 22
23use crate::{ 23use crate::{
24 config::Config, 24 config::Config,
25 diagnostics::{CheckFixes, DiagnosticCollection}, 25 diagnostics::{
26 to_proto::url_from_path_with_drive_lowercasing, CheckFixes, DiagnosticCollection,
27 },
26 main_loop::pending_requests::{CompletedRequest, LatestRequests}, 28 main_loop::pending_requests::{CompletedRequest, LatestRequests},
27 vfs_glob::{Glob, RustPackageFilterBuilder}, 29 vfs_glob::{Glob, RustPackageFilterBuilder},
28 LspError, Result, 30 LspError, Result,
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-17 22:37:30 +0000