diff options
81 files changed, 1548 insertions, 1004 deletions
diff --git a/.github/ISSUE_TEMPLATE/blank-issue.md b/.github/ISSUE_TEMPLATE/blank-issue.md new file mode 100644 index 000000000..a08ad07cb --- /dev/null +++ b/.github/ISSUE_TEMPLATE/blank-issue.md | |||
@@ -0,0 +1,10 @@ | |||
1 | --- | ||
2 | name: Blank Issue | ||
3 | about: Create a blank issue. | ||
4 | title: '' | ||
5 | labels: '' | ||
6 | assignees: '' | ||
7 | |||
8 | --- | ||
9 | |||
10 | |||
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 000000000..dddc82f80 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md | |||
@@ -0,0 +1,24 @@ | |||
1 | --- | ||
2 | name: Bug report | ||
3 | about: Create a bug report for rust-analyzer. | ||
4 | title: '' | ||
5 | labels: '' | ||
6 | assignees: '' | ||
7 | |||
8 | --- | ||
9 | |||
10 | <!-- | ||
11 | Troubleshooting guide: https://rust-analyzer.github.io/manual.html#troubleshooting | ||
12 | Forum for questions: https://users.rust-lang.org/c/ide/14 | ||
13 | |||
14 | Before submitting, please make sure that you're not running into one of these known issues: | ||
15 | |||
16 | 1. local imports (`use` statements) don't work: #1165 | ||
17 | 2. local items don't work: #1559 | ||
18 | 3. on-the-fly diagnostics are mostly unimplemented (`cargo check` diagnostics will be shown when saving a file) | ||
19 | 4. some settings are required for procedural macro and build script support (`rust-analyzer.cargo.loadOutDirsFromCheck`, `rust-analyzer.procMacro.enable`): #6448 | ||
20 | 5. some platform-specific imports are not resolved: #6038 | ||
21 | 6. the official `rust-lang.rust` VS Code extension conflicts with `rust-analyzer`: #6463 | ||
22 | |||
23 | Otherwise please try to provide information which will help us to fix the issue faster. Minimal reproducible examples with few dependencies are especially lovely <3. | ||
24 | --> | ||
diff --git a/Cargo.lock b/Cargo.lock index f6b53d188..1a4a63550 100644 --- a/Cargo.lock +++ b/Cargo.lock | |||
@@ -26,9 +26,9 @@ dependencies = [ | |||
26 | 26 | ||
27 | [[package]] | 27 | [[package]] |
28 | name = "anyhow" | 28 | name = "anyhow" |
29 | version = "1.0.33" | 29 | version = "1.0.34" |
30 | source = "registry+https://github.com/rust-lang/crates.io-index" | 30 | source = "registry+https://github.com/rust-lang/crates.io-index" |
31 | checksum = "a1fd36ffbb1fb7c834eac128ea8d0e310c5aeb635548f9d58861e1308d46e71c" | 31 | checksum = "bf8dcb5b4bbaa28653b647d8c77bd4ed40183b48882e130c1f1ffb73de069fd7" |
32 | 32 | ||
33 | [[package]] | 33 | [[package]] |
34 | name = "anymap" | 34 | name = "anymap" |
@@ -269,9 +269,9 @@ dependencies = [ | |||
269 | 269 | ||
270 | [[package]] | 270 | [[package]] |
271 | name = "const_fn" | 271 | name = "const_fn" |
272 | version = "0.4.2" | 272 | version = "0.4.3" |
273 | source = "registry+https://github.com/rust-lang/crates.io-index" | 273 | source = "registry+https://github.com/rust-lang/crates.io-index" |
274 | checksum = "ce90df4c658c62f12d78f7508cf92f9173e5184a539c10bfe54a3107b3ffd0f2" | 274 | checksum = "c478836e029dcef17fb47c89023448c64f781a046e0300e257ad8225ae59afab" |
275 | 275 | ||
276 | [[package]] | 276 | [[package]] |
277 | name = "crc32fast" | 277 | name = "crc32fast" |
@@ -1793,9 +1793,9 @@ dependencies = [ | |||
1793 | 1793 | ||
1794 | [[package]] | 1794 | [[package]] |
1795 | name = "tracing-subscriber" | 1795 | name = "tracing-subscriber" |
1796 | version = "0.2.14" | 1796 | version = "0.2.15" |
1797 | source = "registry+https://github.com/rust-lang/crates.io-index" | 1797 | source = "registry+https://github.com/rust-lang/crates.io-index" |
1798 | checksum = "2810660b9d5b18895d140caba6401765749a6a162e5d0736cfc44ea50db9d79d" | 1798 | checksum = "a1fa8f0c8f4c594e4fc9debc1990deab13238077271ba84dd853d54902ee3401" |
1799 | dependencies = [ | 1799 | dependencies = [ |
1800 | "ansi_term", | 1800 | "ansi_term", |
1801 | "chrono", | 1801 | "chrono", |
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs index a1c0550e4..a17e592b0 100644 --- a/crates/assists/src/assist_context.rs +++ b/crates/assists/src/assist_context.rs | |||
@@ -12,7 +12,7 @@ use ide_db::{ | |||
12 | }; | 12 | }; |
13 | use syntax::{ | 13 | use syntax::{ |
14 | algo::{self, find_node_at_offset, SyntaxRewriter}, | 14 | algo::{self, find_node_at_offset, SyntaxRewriter}, |
15 | AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange, TextSize, | 15 | AstNode, AstToken, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange, TextSize, |
16 | TokenAtOffset, | 16 | TokenAtOffset, |
17 | }; | 17 | }; |
18 | use text_edit::{TextEdit, TextEditBuilder}; | 18 | use text_edit::{TextEdit, TextEditBuilder}; |
@@ -81,9 +81,12 @@ impl<'a> AssistContext<'a> { | |||
81 | pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> { | 81 | pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> { |
82 | self.source_file.syntax().token_at_offset(self.offset()) | 82 | self.source_file.syntax().token_at_offset(self.offset()) |
83 | } | 83 | } |
84 | pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> { | 84 | pub(crate) fn find_token_syntax_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> { |
85 | self.token_at_offset().find(|it| it.kind() == kind) | 85 | self.token_at_offset().find(|it| it.kind() == kind) |
86 | } | 86 | } |
87 | pub(crate) fn find_token_at_offset<T: AstToken>(&self) -> Option<T> { | ||
88 | self.token_at_offset().find_map(T::cast) | ||
89 | } | ||
87 | pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> { | 90 | pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> { |
88 | find_node_at_offset(self.source_file.syntax(), self.offset()) | 91 | find_node_at_offset(self.source_file.syntax(), self.offset()) |
89 | } | 92 | } |
@@ -279,12 +282,6 @@ impl AssistBuilder { | |||
279 | algo::diff(&node, &new).into_text_edit(&mut self.edit); | 282 | algo::diff(&node, &new).into_text_edit(&mut self.edit); |
280 | } | 283 | } |
281 | 284 | ||
282 | // FIXME: kill this API | ||
283 | /// Get access to the raw `TextEditBuilder`. | ||
284 | pub(crate) fn text_edit_builder(&mut self) -> &mut TextEditBuilder { | ||
285 | &mut self.edit | ||
286 | } | ||
287 | |||
288 | fn finish(mut self) -> SourceChange { | 285 | fn finish(mut self) -> SourceChange { |
289 | self.commit(); | 286 | self.commit(); |
290 | SourceChange { | 287 | SourceChange { |
diff --git a/crates/assists/src/handlers/add_custom_impl.rs b/crates/assists/src/handlers/add_custom_impl.rs index 8757fa33f..c13493fd8 100644 --- a/crates/assists/src/handlers/add_custom_impl.rs +++ b/crates/assists/src/handlers/add_custom_impl.rs | |||
@@ -1,13 +1,18 @@ | |||
1 | use ide_db::imports_locator; | ||
1 | use itertools::Itertools; | 2 | use itertools::Itertools; |
2 | use syntax::{ | 3 | use syntax::{ |
3 | ast::{self, AstNode}, | 4 | ast::{self, make, AstNode}, |
4 | Direction, SmolStr, | 5 | Direction, SmolStr, |
5 | SyntaxKind::{IDENT, WHITESPACE}, | 6 | SyntaxKind::{IDENT, WHITESPACE}, |
6 | TextRange, TextSize, | 7 | TextSize, |
7 | }; | 8 | }; |
8 | 9 | ||
9 | use crate::{ | 10 | use crate::{ |
10 | assist_context::{AssistContext, Assists}, | 11 | assist_context::{AssistBuilder, AssistContext, Assists}, |
12 | utils::{ | ||
13 | add_trait_assoc_items_to_impl, filter_assoc_items, mod_path_to_ast, render_snippet, Cursor, | ||
14 | DefaultMethods, | ||
15 | }, | ||
11 | AssistId, AssistKind, | 16 | AssistId, AssistKind, |
12 | }; | 17 | }; |
13 | 18 | ||
@@ -30,72 +35,154 @@ use crate::{ | |||
30 | // ``` | 35 | // ``` |
31 | pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 36 | pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
32 | let attr = ctx.find_node_at_offset::<ast::Attr>()?; | 37 | let attr = ctx.find_node_at_offset::<ast::Attr>()?; |
33 | let input = attr.token_tree()?; | ||
34 | 38 | ||
35 | let attr_name = attr | 39 | let attr_name = attr |
36 | .syntax() | 40 | .syntax() |
37 | .descendants_with_tokens() | 41 | .descendants_with_tokens() |
38 | .filter(|t| t.kind() == IDENT) | 42 | .filter(|t| t.kind() == IDENT) |
39 | .find_map(|i| i.into_token()) | 43 | .find_map(syntax::NodeOrToken::into_token) |
40 | .filter(|t| *t.text() == "derive")? | 44 | .filter(|t| t.text() == "derive")? |
41 | .text() | 45 | .text() |
42 | .clone(); | 46 | .clone(); |
43 | 47 | ||
44 | let trait_token = | 48 | let trait_token = |
45 | ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?; | 49 | ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?; |
50 | let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text()))); | ||
51 | |||
52 | let annotated_name = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?; | ||
53 | let insert_pos = annotated_name.syntax().parent()?.text_range().end(); | ||
54 | |||
55 | let current_module = ctx.sema.scope(annotated_name.syntax()).module()?; | ||
56 | let current_crate = current_module.krate(); | ||
46 | 57 | ||
47 | let annotated = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?; | 58 | let found_traits = imports_locator::find_imports(&ctx.sema, current_crate, trait_token.text()) |
48 | let annotated_name = annotated.syntax().text().to_string(); | 59 | .into_iter() |
49 | let start_offset = annotated.syntax().parent()?.text_range().end(); | 60 | .filter_map(|candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate { |
61 | either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_), | ||
62 | _ => None, | ||
63 | }) | ||
64 | .flat_map(|trait_| { | ||
65 | current_module | ||
66 | .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_)) | ||
67 | .as_ref() | ||
68 | .map(mod_path_to_ast) | ||
69 | .zip(Some(trait_)) | ||
70 | }); | ||
50 | 71 | ||
51 | let label = | 72 | let mut no_traits_found = true; |
52 | format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name); | 73 | for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) { |
74 | add_assist(acc, ctx, &attr, &trait_path, Some(trait_), &annotated_name, insert_pos)?; | ||
75 | } | ||
76 | if no_traits_found { | ||
77 | add_assist(acc, ctx, &attr, &trait_path, None, &annotated_name, insert_pos)?; | ||
78 | } | ||
79 | Some(()) | ||
80 | } | ||
53 | 81 | ||
82 | fn add_assist( | ||
83 | acc: &mut Assists, | ||
84 | ctx: &AssistContext, | ||
85 | attr: &ast::Attr, | ||
86 | trait_path: &ast::Path, | ||
87 | trait_: Option<hir::Trait>, | ||
88 | annotated_name: &ast::Name, | ||
89 | insert_pos: TextSize, | ||
90 | ) -> Option<()> { | ||
54 | let target = attr.syntax().text_range(); | 91 | let target = attr.syntax().text_range(); |
92 | let input = attr.token_tree()?; | ||
93 | let label = format!("Add custom impl `{}` for `{}`", trait_path, annotated_name); | ||
94 | let trait_name = trait_path.segment().and_then(|seg| seg.name_ref())?; | ||
95 | |||
55 | acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| { | 96 | acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| { |
56 | let new_attr_input = input | 97 | let impl_def_with_items = |
57 | .syntax() | 98 | impl_def_from_trait(&ctx.sema, annotated_name, trait_, trait_path); |
58 | .descendants_with_tokens() | 99 | update_attribute(builder, &input, &trait_name, &attr); |
59 | .filter(|t| t.kind() == IDENT) | 100 | match (ctx.config.snippet_cap, impl_def_with_items) { |
60 | .filter_map(|t| t.into_token().map(|t| t.text().clone())) | 101 | (None, _) => builder.insert( |
61 | .filter(|t| t != trait_token.text()) | 102 | insert_pos, |
62 | .collect::<Vec<SmolStr>>(); | 103 | format!("\n\nimpl {} for {} {{\n\n}}", trait_path, annotated_name), |
63 | let has_more_derives = !new_attr_input.is_empty(); | 104 | ), |
64 | 105 | (Some(cap), None) => builder.insert_snippet( | |
65 | if has_more_derives { | 106 | cap, |
66 | let new_attr_input = format!("({})", new_attr_input.iter().format(", ")); | 107 | insert_pos, |
67 | builder.replace(input.syntax().text_range(), new_attr_input); | 108 | format!("\n\nimpl {} for {} {{\n $0\n}}", trait_path, annotated_name), |
68 | } else { | 109 | ), |
69 | let attr_range = attr.syntax().text_range(); | 110 | (Some(cap), Some((impl_def, first_assoc_item))) => { |
70 | builder.delete(attr_range); | 111 | let mut cursor = Cursor::Before(first_assoc_item.syntax()); |
71 | 112 | let placeholder; | |
72 | let line_break_range = attr | 113 | if let ast::AssocItem::Fn(ref func) = first_assoc_item { |
73 | .syntax() | 114 | if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) { |
74 | .next_sibling_or_token() | 115 | if m.syntax().text() == "todo!()" { |
75 | .filter(|t| t.kind() == WHITESPACE) | 116 | placeholder = m; |
76 | .map(|t| t.text_range()) | 117 | cursor = Cursor::Replace(placeholder.syntax()); |
77 | .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0))); | 118 | } |
78 | builder.delete(line_break_range); | 119 | } |
79 | } | 120 | } |
80 | 121 | ||
81 | match ctx.config.snippet_cap { | ||
82 | Some(cap) => { | ||
83 | builder.insert_snippet( | 122 | builder.insert_snippet( |
84 | cap, | 123 | cap, |
85 | start_offset, | 124 | insert_pos, |
86 | format!("\n\nimpl {} for {} {{\n $0\n}}", trait_token, annotated_name), | 125 | format!("\n\n{}", render_snippet(cap, impl_def.syntax(), cursor)), |
87 | ); | 126 | ) |
88 | } | ||
89 | None => { | ||
90 | builder.insert( | ||
91 | start_offset, | ||
92 | format!("\n\nimpl {} for {} {{\n\n}}", trait_token, annotated_name), | ||
93 | ); | ||
94 | } | 127 | } |
95 | } | 128 | }; |
96 | }) | 129 | }) |
97 | } | 130 | } |
98 | 131 | ||
132 | fn impl_def_from_trait( | ||
133 | sema: &hir::Semantics<ide_db::RootDatabase>, | ||
134 | annotated_name: &ast::Name, | ||
135 | trait_: Option<hir::Trait>, | ||
136 | trait_path: &ast::Path, | ||
137 | ) -> Option<(ast::Impl, ast::AssocItem)> { | ||
138 | let trait_ = trait_?; | ||
139 | let target_scope = sema.scope(annotated_name.syntax()); | ||
140 | let trait_items = filter_assoc_items(sema.db, &trait_.items(sema.db), DefaultMethods::No); | ||
141 | if trait_items.is_empty() { | ||
142 | return None; | ||
143 | } | ||
144 | let impl_def = make::impl_trait( | ||
145 | trait_path.clone(), | ||
146 | make::path_unqualified(make::path_segment(make::name_ref(annotated_name.text()))), | ||
147 | ); | ||
148 | let (impl_def, first_assoc_item) = | ||
149 | add_trait_assoc_items_to_impl(sema, trait_items, trait_, impl_def, target_scope); | ||
150 | Some((impl_def, first_assoc_item)) | ||
151 | } | ||
152 | |||
153 | fn update_attribute( | ||
154 | builder: &mut AssistBuilder, | ||
155 | input: &ast::TokenTree, | ||
156 | trait_name: &ast::NameRef, | ||
157 | attr: &ast::Attr, | ||
158 | ) { | ||
159 | let new_attr_input = input | ||
160 | .syntax() | ||
161 | .descendants_with_tokens() | ||
162 | .filter(|t| t.kind() == IDENT) | ||
163 | .filter_map(|t| t.into_token().map(|t| t.text().clone())) | ||
164 | .filter(|t| t != trait_name.text()) | ||
165 | .collect::<Vec<SmolStr>>(); | ||
166 | let has_more_derives = !new_attr_input.is_empty(); | ||
167 | |||
168 | if has_more_derives { | ||
169 | let new_attr_input = format!("({})", new_attr_input.iter().format(", ")); | ||
170 | builder.replace(input.syntax().text_range(), new_attr_input); | ||
171 | } else { | ||
172 | let attr_range = attr.syntax().text_range(); | ||
173 | builder.delete(attr_range); | ||
174 | |||
175 | if let Some(line_break_range) = attr | ||
176 | .syntax() | ||
177 | .next_sibling_or_token() | ||
178 | .filter(|t| t.kind() == WHITESPACE) | ||
179 | .map(|t| t.text_range()) | ||
180 | { | ||
181 | builder.delete(line_break_range); | ||
182 | } | ||
183 | } | ||
184 | } | ||
185 | |||
99 | #[cfg(test)] | 186 | #[cfg(test)] |
100 | mod tests { | 187 | mod tests { |
101 | use crate::tests::{check_assist, check_assist_not_applicable}; | 188 | use crate::tests::{check_assist, check_assist_not_applicable}; |
@@ -103,6 +190,96 @@ mod tests { | |||
103 | use super::*; | 190 | use super::*; |
104 | 191 | ||
105 | #[test] | 192 | #[test] |
193 | fn add_custom_impl_debug() { | ||
194 | check_assist( | ||
195 | add_custom_impl, | ||
196 | " | ||
197 | mod fmt { | ||
198 | pub struct Error; | ||
199 | pub type Result = Result<(), Error>; | ||
200 | pub struct Formatter<'a>; | ||
201 | pub trait Debug { | ||
202 | fn fmt(&self, f: &mut Formatter<'_>) -> Result; | ||
203 | } | ||
204 | } | ||
205 | |||
206 | #[derive(Debu<|>g)] | ||
207 | struct Foo { | ||
208 | bar: String, | ||
209 | } | ||
210 | ", | ||
211 | " | ||
212 | mod fmt { | ||
213 | pub struct Error; | ||
214 | pub type Result = Result<(), Error>; | ||
215 | pub struct Formatter<'a>; | ||
216 | pub trait Debug { | ||
217 | fn fmt(&self, f: &mut Formatter<'_>) -> Result; | ||
218 | } | ||
219 | } | ||
220 | |||
221 | struct Foo { | ||
222 | bar: String, | ||
223 | } | ||
224 | |||
225 | impl fmt::Debug for Foo { | ||
226 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { | ||
227 | ${0:todo!()} | ||
228 | } | ||
229 | } | ||
230 | ", | ||
231 | ) | ||
232 | } | ||
233 | #[test] | ||
234 | fn add_custom_impl_all() { | ||
235 | check_assist( | ||
236 | add_custom_impl, | ||
237 | " | ||
238 | mod foo { | ||
239 | pub trait Bar { | ||
240 | type Qux; | ||
241 | const Baz: usize = 42; | ||
242 | const Fez: usize; | ||
243 | fn foo(); | ||
244 | fn bar() {} | ||
245 | } | ||
246 | } | ||
247 | |||
248 | #[derive(<|>Bar)] | ||
249 | struct Foo { | ||
250 | bar: String, | ||
251 | } | ||
252 | ", | ||
253 | " | ||
254 | mod foo { | ||
255 | pub trait Bar { | ||
256 | type Qux; | ||
257 | const Baz: usize = 42; | ||
258 | const Fez: usize; | ||
259 | fn foo(); | ||
260 | fn bar() {} | ||
261 | } | ||
262 | } | ||
263 | |||
264 | struct Foo { | ||
265 | bar: String, | ||
266 | } | ||
267 | |||
268 | impl foo::Bar for Foo { | ||
269 | $0type Qux; | ||
270 | |||
271 | const Baz: usize = 42; | ||
272 | |||
273 | const Fez: usize; | ||
274 | |||
275 | fn foo() { | ||
276 | todo!() | ||
277 | } | ||
278 | } | ||
279 | ", | ||
280 | ) | ||
281 | } | ||
282 | #[test] | ||
106 | fn add_custom_impl_for_unique_input() { | 283 | fn add_custom_impl_for_unique_input() { |
107 | check_assist( | 284 | check_assist( |
108 | add_custom_impl, | 285 | add_custom_impl, |
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs index b82fb30ad..bbb71e261 100644 --- a/crates/assists/src/handlers/add_missing_impl_members.rs +++ b/crates/assists/src/handlers/add_missing_impl_members.rs | |||
@@ -1,27 +1,14 @@ | |||
1 | use hir::HasSource; | 1 | use ide_db::traits::resolve_target_trait; |
2 | use ide_db::traits::{get_missing_assoc_items, resolve_target_trait}; | 2 | use syntax::ast::{self, AstNode}; |
3 | use syntax::{ | ||
4 | ast::{ | ||
5 | self, | ||
6 | edit::{self, AstNodeEdit, IndentLevel}, | ||
7 | make, AstNode, NameOwner, | ||
8 | }, | ||
9 | SmolStr, | ||
10 | }; | ||
11 | 3 | ||
12 | use crate::{ | 4 | use crate::{ |
13 | assist_context::{AssistContext, Assists}, | 5 | assist_context::{AssistContext, Assists}, |
14 | ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams}, | 6 | utils::add_trait_assoc_items_to_impl, |
15 | utils::{render_snippet, Cursor}, | 7 | utils::DefaultMethods, |
8 | utils::{filter_assoc_items, render_snippet, Cursor}, | ||
16 | AssistId, AssistKind, | 9 | AssistId, AssistKind, |
17 | }; | 10 | }; |
18 | 11 | ||
19 | #[derive(PartialEq)] | ||
20 | enum AddMissingImplMembersMode { | ||
21 | DefaultMethodsOnly, | ||
22 | NoDefaultMethods, | ||
23 | } | ||
24 | |||
25 | // Assist: add_impl_missing_members | 12 | // Assist: add_impl_missing_members |
26 | // | 13 | // |
27 | // Adds scaffold for required impl members. | 14 | // Adds scaffold for required impl members. |
@@ -55,7 +42,7 @@ pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) - | |||
55 | add_missing_impl_members_inner( | 42 | add_missing_impl_members_inner( |
56 | acc, | 43 | acc, |
57 | ctx, | 44 | ctx, |
58 | AddMissingImplMembersMode::NoDefaultMethods, | 45 | DefaultMethods::No, |
59 | "add_impl_missing_members", | 46 | "add_impl_missing_members", |
60 | "Implement missing members", | 47 | "Implement missing members", |
61 | ) | 48 | ) |
@@ -97,7 +84,7 @@ pub(crate) fn add_missing_default_members(acc: &mut Assists, ctx: &AssistContext | |||
97 | add_missing_impl_members_inner( | 84 | add_missing_impl_members_inner( |
98 | acc, | 85 | acc, |
99 | ctx, | 86 | ctx, |
100 | AddMissingImplMembersMode::DefaultMethodsOnly, | 87 | DefaultMethods::Only, |
101 | "add_impl_default_members", | 88 | "add_impl_default_members", |
102 | "Implement default members", | 89 | "Implement default members", |
103 | ) | 90 | ) |
@@ -106,7 +93,7 @@ pub(crate) fn add_missing_default_members(acc: &mut Assists, ctx: &AssistContext | |||
106 | fn add_missing_impl_members_inner( | 93 | fn add_missing_impl_members_inner( |
107 | acc: &mut Assists, | 94 | acc: &mut Assists, |
108 | ctx: &AssistContext, | 95 | ctx: &AssistContext, |
109 | mode: AddMissingImplMembersMode, | 96 | mode: DefaultMethods, |
110 | assist_id: &'static str, | 97 | assist_id: &'static str, |
111 | label: &'static str, | 98 | label: &'static str, |
112 | ) -> Option<()> { | 99 | ) -> Option<()> { |
@@ -114,32 +101,11 @@ fn add_missing_impl_members_inner( | |||
114 | let impl_def = ctx.find_node_at_offset::<ast::Impl>()?; | 101 | let impl_def = ctx.find_node_at_offset::<ast::Impl>()?; |
115 | let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?; | 102 | let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?; |
116 | 103 | ||
117 | let def_name = |item: &ast::AssocItem| -> Option<SmolStr> { | 104 | let missing_items = filter_assoc_items( |
118 | match item { | 105 | ctx.db(), |
119 | ast::AssocItem::Fn(def) => def.name(), | 106 | &ide_db::traits::get_missing_assoc_items(&ctx.sema, &impl_def), |
120 | ast::AssocItem::TypeAlias(def) => def.name(), | 107 | mode, |
121 | ast::AssocItem::Const(def) => def.name(), | 108 | ); |
122 | ast::AssocItem::MacroCall(_) => None, | ||
123 | } | ||
124 | .map(|it| it.text().clone()) | ||
125 | }; | ||
126 | |||
127 | let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def) | ||
128 | .iter() | ||
129 | .map(|i| match i { | ||
130 | hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(ctx.db()).value), | ||
131 | hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(ctx.db()).value), | ||
132 | hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(ctx.db()).value), | ||
133 | }) | ||
134 | .filter(|t| def_name(&t).is_some()) | ||
135 | .filter(|t| match t { | ||
136 | ast::AssocItem::Fn(def) => match mode { | ||
137 | AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(), | ||
138 | AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(), | ||
139 | }, | ||
140 | _ => mode == AddMissingImplMembersMode::NoDefaultMethods, | ||
141 | }) | ||
142 | .collect::<Vec<_>>(); | ||
143 | 109 | ||
144 | if missing_items.is_empty() { | 110 | if missing_items.is_empty() { |
145 | return None; | 111 | return None; |
@@ -147,29 +113,9 @@ fn add_missing_impl_members_inner( | |||
147 | 113 | ||
148 | let target = impl_def.syntax().text_range(); | 114 | let target = impl_def.syntax().text_range(); |
149 | acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| { | 115 | acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| { |
150 | let impl_item_list = impl_def.assoc_item_list().unwrap_or_else(make::assoc_item_list); | ||
151 | |||
152 | let n_existing_items = impl_item_list.assoc_items().count(); | ||
153 | let source_scope = ctx.sema.scope_for_def(trait_); | ||
154 | let target_scope = ctx.sema.scope(impl_def.syntax()); | 116 | let target_scope = ctx.sema.scope(impl_def.syntax()); |
155 | let ast_transform = QualifyPaths::new(&target_scope, &source_scope) | 117 | let (new_impl_def, first_new_item) = |
156 | .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def.clone())); | 118 | add_trait_assoc_items_to_impl(&ctx.sema, missing_items, trait_, impl_def, target_scope); |
157 | |||
158 | let items = missing_items | ||
159 | .into_iter() | ||
160 | .map(|it| ast_transform::apply(&*ast_transform, it)) | ||
161 | .map(|it| match it { | ||
162 | ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)), | ||
163 | ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()), | ||
164 | _ => it, | ||
165 | }) | ||
166 | .map(|it| edit::remove_attrs_and_docs(&it)); | ||
167 | |||
168 | let new_impl_item_list = impl_item_list.append_items(items); | ||
169 | let new_impl_def = impl_def.with_assoc_item_list(new_impl_item_list); | ||
170 | let first_new_item = | ||
171 | new_impl_def.assoc_item_list().unwrap().assoc_items().nth(n_existing_items).unwrap(); | ||
172 | |||
173 | match ctx.config.snippet_cap { | 119 | match ctx.config.snippet_cap { |
174 | None => builder.replace(target, new_impl_def.to_string()), | 120 | None => builder.replace(target, new_impl_def.to_string()), |
175 | Some(cap) => { | 121 | Some(cap) => { |
@@ -193,14 +139,6 @@ fn add_missing_impl_members_inner( | |||
193 | }) | 139 | }) |
194 | } | 140 | } |
195 | 141 | ||
196 | fn add_body(fn_def: ast::Fn) -> ast::Fn { | ||
197 | if fn_def.body().is_some() { | ||
198 | return fn_def; | ||
199 | } | ||
200 | let body = make::block_expr(None, Some(make::expr_todo())).indent(IndentLevel(1)); | ||
201 | fn_def.with_body(body) | ||
202 | } | ||
203 | |||
204 | #[cfg(test)] | 142 | #[cfg(test)] |
205 | mod tests { | 143 | mod tests { |
206 | use crate::tests::{check_assist, check_assist_not_applicable}; | 144 | use crate::tests::{check_assist, check_assist_not_applicable}; |
diff --git a/crates/assists/src/handlers/add_turbo_fish.rs b/crates/assists/src/handlers/add_turbo_fish.rs index e3d84d698..1f486c013 100644 --- a/crates/assists/src/handlers/add_turbo_fish.rs +++ b/crates/assists/src/handlers/add_turbo_fish.rs | |||
@@ -25,7 +25,7 @@ use crate::{ | |||
25 | // } | 25 | // } |
26 | // ``` | 26 | // ``` |
27 | pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 27 | pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
28 | let ident = ctx.find_token_at_offset(SyntaxKind::IDENT).or_else(|| { | 28 | let ident = ctx.find_token_syntax_at_offset(SyntaxKind::IDENT).or_else(|| { |
29 | let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?; | 29 | let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?; |
30 | if arg_list.args().count() > 0 { | 30 | if arg_list.args().count() > 0 { |
31 | return None; | 31 | return None; |
diff --git a/crates/assists/src/handlers/change_return_type_to_result.rs b/crates/assists/src/handlers/change_return_type_to_result.rs index be480943c..76f33a5b6 100644 --- a/crates/assists/src/handlers/change_return_type_to_result.rs +++ b/crates/assists/src/handlers/change_return_type_to_result.rs | |||
@@ -2,7 +2,7 @@ use std::iter; | |||
2 | 2 | ||
3 | use syntax::{ | 3 | use syntax::{ |
4 | ast::{self, make, BlockExpr, Expr, LoopBodyOwner}, | 4 | ast::{self, make, BlockExpr, Expr, LoopBodyOwner}, |
5 | AstNode, SyntaxNode, | 5 | match_ast, AstNode, SyntaxNode, |
6 | }; | 6 | }; |
7 | use test_utils::mark; | 7 | use test_utils::mark; |
8 | 8 | ||
@@ -21,8 +21,18 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
21 | // ``` | 21 | // ``` |
22 | pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 22 | pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
23 | let ret_type = ctx.find_node_at_offset::<ast::RetType>()?; | 23 | let ret_type = ctx.find_node_at_offset::<ast::RetType>()?; |
24 | // FIXME: extend to lambdas as well | 24 | let parent = ret_type.syntax().parent()?; |
25 | let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?; | 25 | let block_expr = match_ast! { |
26 | match parent { | ||
27 | ast::Fn(func) => func.body()?, | ||
28 | ast::ClosureExpr(closure) => match closure.body()? { | ||
29 | Expr::BlockExpr(block) => block, | ||
30 | // closures require a block when a return type is specified | ||
31 | _ => return None, | ||
32 | }, | ||
33 | _ => return None, | ||
34 | } | ||
35 | }; | ||
26 | 36 | ||
27 | let type_ref = &ret_type.ty()?; | 37 | let type_ref = &ret_type.ty()?; |
28 | let ret_type_str = type_ref.syntax().text().to_string(); | 38 | let ret_type_str = type_ref.syntax().text().to_string(); |
@@ -34,16 +44,14 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex | |||
34 | } | 44 | } |
35 | } | 45 | } |
36 | 46 | ||
37 | let block_expr = &fn_def.body()?; | ||
38 | |||
39 | acc.add( | 47 | acc.add( |
40 | AssistId("change_return_type_to_result", AssistKind::RefactorRewrite), | 48 | AssistId("change_return_type_to_result", AssistKind::RefactorRewrite), |
41 | "Wrap return type in Result", | 49 | "Wrap return type in Result", |
42 | type_ref.syntax().text_range(), | 50 | type_ref.syntax().text_range(), |
43 | |builder| { | 51 | |builder| { |
44 | let mut tail_return_expr_collector = TailReturnCollector::new(); | 52 | let mut tail_return_expr_collector = TailReturnCollector::new(); |
45 | tail_return_expr_collector.collect_jump_exprs(block_expr, false); | 53 | tail_return_expr_collector.collect_jump_exprs(&block_expr, false); |
46 | tail_return_expr_collector.collect_tail_exprs(block_expr); | 54 | tail_return_expr_collector.collect_tail_exprs(&block_expr); |
47 | 55 | ||
48 | for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap { | 56 | for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap { |
49 | let ok_wrapped = make::expr_call( | 57 | let ok_wrapped = make::expr_call( |
@@ -285,16 +293,20 @@ mod tests { | |||
285 | } | 293 | } |
286 | 294 | ||
287 | #[test] | 295 | #[test] |
288 | fn change_return_type_to_result_simple_return_type() { | 296 | fn change_return_type_to_result_simple_closure() { |
289 | check_assist( | 297 | check_assist( |
290 | change_return_type_to_result, | 298 | change_return_type_to_result, |
291 | r#"fn foo() -> i32<|> { | 299 | r#"fn foo() { |
292 | let test = "test"; | 300 | || -> i32<|> { |
293 | return 42i32; | 301 | let test = "test"; |
302 | return 42i32; | ||
303 | }; | ||
294 | }"#, | 304 | }"#, |
295 | r#"fn foo() -> Result<i32, ${0:_}> { | 305 | r#"fn foo() { |
296 | let test = "test"; | 306 | || -> Result<i32, ${0:_}> { |
297 | return Ok(42i32); | 307 | let test = "test"; |
308 | return Ok(42i32); | ||
309 | }; | ||
298 | }"#, | 310 | }"#, |
299 | ); | 311 | ); |
300 | } | 312 | } |
@@ -311,6 +323,29 @@ mod tests { | |||
311 | } | 323 | } |
312 | 324 | ||
313 | #[test] | 325 | #[test] |
326 | fn change_return_type_to_result_simple_return_type_bad_cursor_closure() { | ||
327 | check_assist_not_applicable( | ||
328 | change_return_type_to_result, | ||
329 | r#"fn foo() { | ||
330 | || -> i32 { | ||
331 | let test = "test";<|> | ||
332 | return 42i32; | ||
333 | }; | ||
334 | }"#, | ||
335 | ); | ||
336 | } | ||
337 | |||
338 | #[test] | ||
339 | fn change_return_type_to_result_closure_non_block() { | ||
340 | check_assist_not_applicable( | ||
341 | change_return_type_to_result, | ||
342 | r#"fn foo() { | ||
343 | || -> i<|>32 3; | ||
344 | }"#, | ||
345 | ); | ||
346 | } | ||
347 | |||
348 | #[test] | ||
314 | fn change_return_type_to_result_simple_return_type_already_result_std() { | 349 | fn change_return_type_to_result_simple_return_type_already_result_std() { |
315 | check_assist_not_applicable( | 350 | check_assist_not_applicable( |
316 | change_return_type_to_result, | 351 | change_return_type_to_result, |
@@ -334,6 +369,19 @@ mod tests { | |||
334 | } | 369 | } |
335 | 370 | ||
336 | #[test] | 371 | #[test] |
372 | fn change_return_type_to_result_simple_return_type_already_result_closure() { | ||
373 | check_assist_not_applicable( | ||
374 | change_return_type_to_result, | ||
375 | r#"fn foo() { | ||
376 | || -> Result<i32<|>, String> { | ||
377 | let test = "test"; | ||
378 | return 42i32; | ||
379 | }; | ||
380 | }"#, | ||
381 | ); | ||
382 | } | ||
383 | |||
384 | #[test] | ||
337 | fn change_return_type_to_result_simple_with_cursor() { | 385 | fn change_return_type_to_result_simple_with_cursor() { |
338 | check_assist( | 386 | check_assist( |
339 | change_return_type_to_result, | 387 | change_return_type_to_result, |
@@ -364,6 +412,25 @@ mod tests { | |||
364 | } | 412 | } |
365 | 413 | ||
366 | #[test] | 414 | #[test] |
415 | fn change_return_type_to_result_simple_with_tail_closure() { | ||
416 | check_assist( | ||
417 | change_return_type_to_result, | ||
418 | r#"fn foo() { | ||
419 | || -><|> i32 { | ||
420 | let test = "test"; | ||
421 | 42i32 | ||
422 | }; | ||
423 | }"#, | ||
424 | r#"fn foo() { | ||
425 | || -> Result<i32, ${0:_}> { | ||
426 | let test = "test"; | ||
427 | Ok(42i32) | ||
428 | }; | ||
429 | }"#, | ||
430 | ); | ||
431 | } | ||
432 | |||
433 | #[test] | ||
367 | fn change_return_type_to_result_simple_with_tail_only() { | 434 | fn change_return_type_to_result_simple_with_tail_only() { |
368 | check_assist( | 435 | check_assist( |
369 | change_return_type_to_result, | 436 | change_return_type_to_result, |
@@ -375,6 +442,7 @@ mod tests { | |||
375 | }"#, | 442 | }"#, |
376 | ); | 443 | ); |
377 | } | 444 | } |
445 | |||
378 | #[test] | 446 | #[test] |
379 | fn change_return_type_to_result_simple_with_tail_block_like() { | 447 | fn change_return_type_to_result_simple_with_tail_block_like() { |
380 | check_assist( | 448 | check_assist( |
@@ -397,6 +465,31 @@ mod tests { | |||
397 | } | 465 | } |
398 | 466 | ||
399 | #[test] | 467 | #[test] |
468 | fn change_return_type_to_result_simple_without_block_closure() { | ||
469 | check_assist( | ||
470 | change_return_type_to_result, | ||
471 | r#"fn foo() { | ||
472 | || -> i32<|> { | ||
473 | if true { | ||
474 | 42i32 | ||
475 | } else { | ||
476 | 24i32 | ||
477 | } | ||
478 | }; | ||
479 | }"#, | ||
480 | r#"fn foo() { | ||
481 | || -> Result<i32, ${0:_}> { | ||
482 | if true { | ||
483 | Ok(42i32) | ||
484 | } else { | ||
485 | Ok(24i32) | ||
486 | } | ||
487 | }; | ||
488 | }"#, | ||
489 | ); | ||
490 | } | ||
491 | |||
492 | #[test] | ||
400 | fn change_return_type_to_result_simple_with_nested_if() { | 493 | fn change_return_type_to_result_simple_with_nested_if() { |
401 | check_assist( | 494 | check_assist( |
402 | change_return_type_to_result, | 495 | change_return_type_to_result, |
diff --git a/crates/assists/src/handlers/convert_integer_literal.rs b/crates/assists/src/handlers/convert_integer_literal.rs index c8af80701..667115382 100644 --- a/crates/assists/src/handlers/convert_integer_literal.rs +++ b/crates/assists/src/handlers/convert_integer_literal.rs | |||
@@ -1,4 +1,4 @@ | |||
1 | use syntax::{ast, ast::Radix, AstNode}; | 1 | use syntax::{ast, ast::Radix, AstToken}; |
2 | 2 | ||
3 | use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel}; | 3 | use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel}; |
4 | 4 | ||
@@ -15,14 +15,16 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel}; | |||
15 | // ``` | 15 | // ``` |
16 | pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 16 | pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
17 | let literal = ctx.find_node_at_offset::<ast::Literal>()?; | 17 | let literal = ctx.find_node_at_offset::<ast::Literal>()?; |
18 | let (radix, value) = literal.int_value()?; | 18 | let literal = match literal.kind() { |
19 | ast::LiteralKind::IntNumber(it) => it, | ||
20 | _ => return None, | ||
21 | }; | ||
22 | let radix = literal.radix(); | ||
23 | let value = literal.value()?; | ||
24 | let suffix = literal.suffix(); | ||
19 | 25 | ||
20 | let range = literal.syntax().text_range(); | 26 | let range = literal.syntax().text_range(); |
21 | let group_id = GroupLabel("Convert integer base".into()); | 27 | let group_id = GroupLabel("Convert integer base".into()); |
22 | let suffix = match literal.kind() { | ||
23 | ast::LiteralKind::IntNumber { suffix } => suffix, | ||
24 | _ => return None, | ||
25 | }; | ||
26 | 28 | ||
27 | for &target_radix in Radix::ALL { | 29 | for &target_radix in Radix::ALL { |
28 | if target_radix == radix { | 30 | if target_radix == radix { |
@@ -36,16 +38,11 @@ pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) -> | |||
36 | Radix::Hexadecimal => format!("0x{:X}", value), | 38 | Radix::Hexadecimal => format!("0x{:X}", value), |
37 | }; | 39 | }; |
38 | 40 | ||
39 | let label = format!( | 41 | let label = format!("Convert {} to {}{}", literal, converted, suffix.unwrap_or_default()); |
40 | "Convert {} to {}{}", | ||
41 | literal, | ||
42 | converted, | ||
43 | suffix.as_deref().unwrap_or_default() | ||
44 | ); | ||
45 | 42 | ||
46 | // Appends the type suffix back into the new literal if it exists. | 43 | // Appends the type suffix back into the new literal if it exists. |
47 | if let Some(suffix) = &suffix { | 44 | if let Some(suffix) = suffix { |
48 | converted.push_str(&suffix); | 45 | converted.push_str(suffix); |
49 | } | 46 | } |
50 | 47 | ||
51 | acc.add_group( | 48 | acc.add_group( |
@@ -132,34 +129,6 @@ mod tests { | |||
132 | ); | 129 | ); |
133 | } | 130 | } |
134 | 131 | ||
135 | // Decimal numbers under 3 digits have a special case where they return early because we can't fit a | ||
136 | // other base's prefix, so we have a separate test for that. | ||
137 | #[test] | ||
138 | fn convert_small_decimal_integer() { | ||
139 | let before = "const _: i32 = 10<|>;"; | ||
140 | |||
141 | check_assist_by_label( | ||
142 | convert_integer_literal, | ||
143 | before, | ||
144 | "const _: i32 = 0b1010;", | ||
145 | "Convert 10 to 0b1010", | ||
146 | ); | ||
147 | |||
148 | check_assist_by_label( | ||
149 | convert_integer_literal, | ||
150 | before, | ||
151 | "const _: i32 = 0o12;", | ||
152 | "Convert 10 to 0o12", | ||
153 | ); | ||
154 | |||
155 | check_assist_by_label( | ||
156 | convert_integer_literal, | ||
157 | before, | ||
158 | "const _: i32 = 0xA;", | ||
159 | "Convert 10 to 0xA", | ||
160 | ); | ||
161 | } | ||
162 | |||
163 | #[test] | 132 | #[test] |
164 | fn convert_hexadecimal_integer() { | 133 | fn convert_hexadecimal_integer() { |
165 | let before = "const _: i32 = 0xFF<|>;"; | 134 | let before = "const _: i32 = 0xFF<|>;"; |
@@ -239,7 +208,7 @@ mod tests { | |||
239 | } | 208 | } |
240 | 209 | ||
241 | #[test] | 210 | #[test] |
242 | fn convert_decimal_integer_with_underscores() { | 211 | fn convert_integer_with_underscores() { |
243 | let before = "const _: i32 = 1_00_0<|>;"; | 212 | let before = "const _: i32 = 1_00_0<|>;"; |
244 | 213 | ||
245 | check_assist_by_label( | 214 | check_assist_by_label( |
@@ -265,111 +234,7 @@ mod tests { | |||
265 | } | 234 | } |
266 | 235 | ||
267 | #[test] | 236 | #[test] |
268 | fn convert_small_decimal_integer_with_underscores() { | 237 | fn convert_integer_with_suffix() { |
269 | let before = "const _: i32 = 1_0<|>;"; | ||
270 | |||
271 | check_assist_by_label( | ||
272 | convert_integer_literal, | ||
273 | before, | ||
274 | "const _: i32 = 0b1010;", | ||
275 | "Convert 1_0 to 0b1010", | ||
276 | ); | ||
277 | |||
278 | check_assist_by_label( | ||
279 | convert_integer_literal, | ||
280 | before, | ||
281 | "const _: i32 = 0o12;", | ||
282 | "Convert 1_0 to 0o12", | ||
283 | ); | ||
284 | |||
285 | check_assist_by_label( | ||
286 | convert_integer_literal, | ||
287 | before, | ||
288 | "const _: i32 = 0xA;", | ||
289 | "Convert 1_0 to 0xA", | ||
290 | ); | ||
291 | } | ||
292 | |||
293 | #[test] | ||
294 | fn convert_hexadecimal_integer_with_underscores() { | ||
295 | let before = "const _: i32 = 0x_F_F<|>;"; | ||
296 | |||
297 | check_assist_by_label( | ||
298 | convert_integer_literal, | ||
299 | before, | ||
300 | "const _: i32 = 0b11111111;", | ||
301 | "Convert 0x_F_F to 0b11111111", | ||
302 | ); | ||
303 | |||
304 | check_assist_by_label( | ||
305 | convert_integer_literal, | ||
306 | before, | ||
307 | "const _: i32 = 0o377;", | ||
308 | "Convert 0x_F_F to 0o377", | ||
309 | ); | ||
310 | |||
311 | check_assist_by_label( | ||
312 | convert_integer_literal, | ||
313 | before, | ||
314 | "const _: i32 = 255;", | ||
315 | "Convert 0x_F_F to 255", | ||
316 | ); | ||
317 | } | ||
318 | |||
319 | #[test] | ||
320 | fn convert_binary_integer_with_underscores() { | ||
321 | let before = "const _: i32 = 0b1111_1111<|>;"; | ||
322 | |||
323 | check_assist_by_label( | ||
324 | convert_integer_literal, | ||
325 | before, | ||
326 | "const _: i32 = 0o377;", | ||
327 | "Convert 0b1111_1111 to 0o377", | ||
328 | ); | ||
329 | |||
330 | check_assist_by_label( | ||
331 | convert_integer_literal, | ||
332 | before, | ||
333 | "const _: i32 = 255;", | ||
334 | "Convert 0b1111_1111 to 255", | ||
335 | ); | ||
336 | |||
337 | check_assist_by_label( | ||
338 | convert_integer_literal, | ||
339 | before, | ||
340 | "const _: i32 = 0xFF;", | ||
341 | "Convert 0b1111_1111 to 0xFF", | ||
342 | ); | ||
343 | } | ||
344 | |||
345 | #[test] | ||
346 | fn convert_octal_integer_with_underscores() { | ||
347 | let before = "const _: i32 = 0o3_77<|>;"; | ||
348 | |||
349 | check_assist_by_label( | ||
350 | convert_integer_literal, | ||
351 | before, | ||
352 | "const _: i32 = 0b11111111;", | ||
353 | "Convert 0o3_77 to 0b11111111", | ||
354 | ); | ||
355 | |||
356 | check_assist_by_label( | ||
357 | convert_integer_literal, | ||
358 | before, | ||
359 | "const _: i32 = 255;", | ||
360 | "Convert 0o3_77 to 255", | ||
361 | ); | ||
362 | |||
363 | check_assist_by_label( | ||
364 | convert_integer_literal, | ||
365 | before, | ||
366 | "const _: i32 = 0xFF;", | ||
367 | "Convert 0o3_77 to 0xFF", | ||
368 | ); | ||
369 | } | ||
370 | |||
371 | #[test] | ||
372 | fn convert_decimal_integer_with_suffix() { | ||
373 | let before = "const _: i32 = 1000i32<|>;"; | 238 | let before = "const _: i32 = 1000i32<|>;"; |
374 | 239 | ||
375 | check_assist_by_label( | 240 | check_assist_by_label( |
@@ -395,240 +260,6 @@ mod tests { | |||
395 | } | 260 | } |
396 | 261 | ||
397 | #[test] | 262 | #[test] |
398 | fn convert_small_decimal_integer_with_suffix() { | ||
399 | let before = "const _: i32 = 10i32<|>;"; | ||
400 | |||
401 | check_assist_by_label( | ||
402 | convert_integer_literal, | ||
403 | before, | ||
404 | "const _: i32 = 0b1010i32;", | ||
405 | "Convert 10i32 to 0b1010i32", | ||
406 | ); | ||
407 | |||
408 | check_assist_by_label( | ||
409 | convert_integer_literal, | ||
410 | before, | ||
411 | "const _: i32 = 0o12i32;", | ||
412 | "Convert 10i32 to 0o12i32", | ||
413 | ); | ||
414 | |||
415 | check_assist_by_label( | ||
416 | convert_integer_literal, | ||
417 | before, | ||
418 | "const _: i32 = 0xAi32;", | ||
419 | "Convert 10i32 to 0xAi32", | ||
420 | ); | ||
421 | } | ||
422 | |||
423 | #[test] | ||
424 | fn convert_hexadecimal_integer_with_suffix() { | ||
425 | let before = "const _: i32 = 0xFFi32<|>;"; | ||
426 | |||
427 | check_assist_by_label( | ||
428 | convert_integer_literal, | ||
429 | before, | ||
430 | "const _: i32 = 0b11111111i32;", | ||
431 | "Convert 0xFFi32 to 0b11111111i32", | ||
432 | ); | ||
433 | |||
434 | check_assist_by_label( | ||
435 | convert_integer_literal, | ||
436 | before, | ||
437 | "const _: i32 = 0o377i32;", | ||
438 | "Convert 0xFFi32 to 0o377i32", | ||
439 | ); | ||
440 | |||
441 | check_assist_by_label( | ||
442 | convert_integer_literal, | ||
443 | before, | ||
444 | "const _: i32 = 255i32;", | ||
445 | "Convert 0xFFi32 to 255i32", | ||
446 | ); | ||
447 | } | ||
448 | |||
449 | #[test] | ||
450 | fn convert_binary_integer_with_suffix() { | ||
451 | let before = "const _: i32 = 0b11111111i32<|>;"; | ||
452 | |||
453 | check_assist_by_label( | ||
454 | convert_integer_literal, | ||
455 | before, | ||
456 | "const _: i32 = 0o377i32;", | ||
457 | "Convert 0b11111111i32 to 0o377i32", | ||
458 | ); | ||
459 | |||
460 | check_assist_by_label( | ||
461 | convert_integer_literal, | ||
462 | before, | ||
463 | "const _: i32 = 255i32;", | ||
464 | "Convert 0b11111111i32 to 255i32", | ||
465 | ); | ||
466 | |||
467 | check_assist_by_label( | ||
468 | convert_integer_literal, | ||
469 | before, | ||
470 | "const _: i32 = 0xFFi32;", | ||
471 | "Convert 0b11111111i32 to 0xFFi32", | ||
472 | ); | ||
473 | } | ||
474 | |||
475 | #[test] | ||
476 | fn convert_octal_integer_with_suffix() { | ||
477 | let before = "const _: i32 = 0o377i32<|>;"; | ||
478 | |||
479 | check_assist_by_label( | ||
480 | convert_integer_literal, | ||
481 | before, | ||
482 | "const _: i32 = 0b11111111i32;", | ||
483 | "Convert 0o377i32 to 0b11111111i32", | ||
484 | ); | ||
485 | |||
486 | check_assist_by_label( | ||
487 | convert_integer_literal, | ||
488 | before, | ||
489 | "const _: i32 = 255i32;", | ||
490 | "Convert 0o377i32 to 255i32", | ||
491 | ); | ||
492 | |||
493 | check_assist_by_label( | ||
494 | convert_integer_literal, | ||
495 | before, | ||
496 | "const _: i32 = 0xFFi32;", | ||
497 | "Convert 0o377i32 to 0xFFi32", | ||
498 | ); | ||
499 | } | ||
500 | |||
501 | #[test] | ||
502 | fn convert_decimal_integer_with_underscores_and_suffix() { | ||
503 | let before = "const _: i32 = 1_00_0i32<|>;"; | ||
504 | |||
505 | check_assist_by_label( | ||
506 | convert_integer_literal, | ||
507 | before, | ||
508 | "const _: i32 = 0b1111101000i32;", | ||
509 | "Convert 1_00_0i32 to 0b1111101000i32", | ||
510 | ); | ||
511 | |||
512 | check_assist_by_label( | ||
513 | convert_integer_literal, | ||
514 | before, | ||
515 | "const _: i32 = 0o1750i32;", | ||
516 | "Convert 1_00_0i32 to 0o1750i32", | ||
517 | ); | ||
518 | |||
519 | check_assist_by_label( | ||
520 | convert_integer_literal, | ||
521 | before, | ||
522 | "const _: i32 = 0x3E8i32;", | ||
523 | "Convert 1_00_0i32 to 0x3E8i32", | ||
524 | ); | ||
525 | } | ||
526 | |||
527 | #[test] | ||
528 | fn convert_small_decimal_integer_with_underscores_and_suffix() { | ||
529 | let before = "const _: i32 = 1_0i32<|>;"; | ||
530 | |||
531 | check_assist_by_label( | ||
532 | convert_integer_literal, | ||
533 | before, | ||
534 | "const _: i32 = 0b1010i32;", | ||
535 | "Convert 1_0i32 to 0b1010i32", | ||
536 | ); | ||
537 | |||
538 | check_assist_by_label( | ||
539 | convert_integer_literal, | ||
540 | before, | ||
541 | "const _: i32 = 0o12i32;", | ||
542 | "Convert 1_0i32 to 0o12i32", | ||
543 | ); | ||
544 | |||
545 | check_assist_by_label( | ||
546 | convert_integer_literal, | ||
547 | before, | ||
548 | "const _: i32 = 0xAi32;", | ||
549 | "Convert 1_0i32 to 0xAi32", | ||
550 | ); | ||
551 | } | ||
552 | |||
553 | #[test] | ||
554 | fn convert_hexadecimal_integer_with_underscores_and_suffix() { | ||
555 | let before = "const _: i32 = 0x_F_Fi32<|>;"; | ||
556 | |||
557 | check_assist_by_label( | ||
558 | convert_integer_literal, | ||
559 | before, | ||
560 | "const _: i32 = 0b11111111i32;", | ||
561 | "Convert 0x_F_Fi32 to 0b11111111i32", | ||
562 | ); | ||
563 | |||
564 | check_assist_by_label( | ||
565 | convert_integer_literal, | ||
566 | before, | ||
567 | "const _: i32 = 0o377i32;", | ||
568 | "Convert 0x_F_Fi32 to 0o377i32", | ||
569 | ); | ||
570 | |||
571 | check_assist_by_label( | ||
572 | convert_integer_literal, | ||
573 | before, | ||
574 | "const _: i32 = 255i32;", | ||
575 | "Convert 0x_F_Fi32 to 255i32", | ||
576 | ); | ||
577 | } | ||
578 | |||
579 | #[test] | ||
580 | fn convert_binary_integer_with_underscores_and_suffix() { | ||
581 | let before = "const _: i32 = 0b1111_1111i32<|>;"; | ||
582 | |||
583 | check_assist_by_label( | ||
584 | convert_integer_literal, | ||
585 | before, | ||
586 | "const _: i32 = 0o377i32;", | ||
587 | "Convert 0b1111_1111i32 to 0o377i32", | ||
588 | ); | ||
589 | |||
590 | check_assist_by_label( | ||
591 | convert_integer_literal, | ||
592 | before, | ||
593 | "const _: i32 = 255i32;", | ||
594 | "Convert 0b1111_1111i32 to 255i32", | ||
595 | ); | ||
596 | |||
597 | check_assist_by_label( | ||
598 | convert_integer_literal, | ||
599 | before, | ||
600 | "const _: i32 = 0xFFi32;", | ||
601 | "Convert 0b1111_1111i32 to 0xFFi32", | ||
602 | ); | ||
603 | } | ||
604 | |||
605 | #[test] | ||
606 | fn convert_octal_integer_with_underscores_and_suffix() { | ||
607 | let before = "const _: i32 = 0o3_77i32<|>;"; | ||
608 | |||
609 | check_assist_by_label( | ||
610 | convert_integer_literal, | ||
611 | before, | ||
612 | "const _: i32 = 0b11111111i32;", | ||
613 | "Convert 0o3_77i32 to 0b11111111i32", | ||
614 | ); | ||
615 | |||
616 | check_assist_by_label( | ||
617 | convert_integer_literal, | ||
618 | before, | ||
619 | "const _: i32 = 255i32;", | ||
620 | "Convert 0o3_77i32 to 255i32", | ||
621 | ); | ||
622 | |||
623 | check_assist_by_label( | ||
624 | convert_integer_literal, | ||
625 | before, | ||
626 | "const _: i32 = 0xFFi32;", | ||
627 | "Convert 0o3_77i32 to 0xFFi32", | ||
628 | ); | ||
629 | } | ||
630 | |||
631 | #[test] | ||
632 | fn convert_overflowing_literal() { | 263 | fn convert_overflowing_literal() { |
633 | let before = "const _: i32 = | 264 | let before = "const _: i32 = |
634 | 111111111111111111111111111111111111111111111111111111111111111111111111<|>;"; | 265 | 111111111111111111111111111111111111111111111111111111111111111111111111<|>;"; |
diff --git a/crates/assists/src/handlers/expand_glob_import.rs b/crates/assists/src/handlers/expand_glob_import.rs index 316a58d88..f51a9a4ad 100644 --- a/crates/assists/src/handlers/expand_glob_import.rs +++ b/crates/assists/src/handlers/expand_glob_import.rs | |||
@@ -5,13 +5,13 @@ use ide_db::{ | |||
5 | search::SearchScope, | 5 | search::SearchScope, |
6 | }; | 6 | }; |
7 | use syntax::{ | 7 | use syntax::{ |
8 | algo, | 8 | algo::SyntaxRewriter, |
9 | ast::{self, make}, | 9 | ast::{self, make}, |
10 | AstNode, Direction, SyntaxNode, SyntaxToken, T, | 10 | AstNode, Direction, SyntaxNode, SyntaxToken, T, |
11 | }; | 11 | }; |
12 | 12 | ||
13 | use crate::{ | 13 | use crate::{ |
14 | assist_context::{AssistBuilder, AssistContext, Assists}, | 14 | assist_context::{AssistContext, Assists}, |
15 | AssistId, AssistKind, | 15 | AssistId, AssistKind, |
16 | }; | 16 | }; |
17 | 17 | ||
@@ -41,7 +41,7 @@ use crate::{ | |||
41 | // fn qux(bar: Bar, baz: Baz) {} | 41 | // fn qux(bar: Bar, baz: Baz) {} |
42 | // ``` | 42 | // ``` |
43 | pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 43 | pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
44 | let star = ctx.find_token_at_offset(T![*])?; | 44 | let star = ctx.find_token_syntax_at_offset(T![*])?; |
45 | let (parent, mod_path) = find_parent_and_path(&star)?; | 45 | let (parent, mod_path) = find_parent_and_path(&star)?; |
46 | let target_module = match ctx.sema.resolve_path(&mod_path)? { | 46 | let target_module = match ctx.sema.resolve_path(&mod_path)? { |
47 | PathResolution::Def(ModuleDef::Module(it)) => it, | 47 | PathResolution::Def(ModuleDef::Module(it)) => it, |
@@ -61,7 +61,9 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti | |||
61 | "Expand glob import", | 61 | "Expand glob import", |
62 | target.text_range(), | 62 | target.text_range(), |
63 | |builder| { | 63 | |builder| { |
64 | replace_ast(builder, parent, mod_path, names_to_import); | 64 | let mut rewriter = SyntaxRewriter::default(); |
65 | replace_ast(&mut rewriter, parent, mod_path, names_to_import); | ||
66 | builder.rewrite(rewriter); | ||
65 | }, | 67 | }, |
66 | ) | 68 | ) |
67 | } | 69 | } |
@@ -236,7 +238,7 @@ fn find_names_to_import( | |||
236 | } | 238 | } |
237 | 239 | ||
238 | fn replace_ast( | 240 | fn replace_ast( |
239 | builder: &mut AssistBuilder, | 241 | rewriter: &mut SyntaxRewriter, |
240 | parent: Either<ast::UseTree, ast::UseTreeList>, | 242 | parent: Either<ast::UseTree, ast::UseTreeList>, |
241 | path: ast::Path, | 243 | path: ast::Path, |
242 | names_to_import: Vec<Name>, | 244 | names_to_import: Vec<Name>, |
@@ -264,32 +266,21 @@ fn replace_ast( | |||
264 | match use_trees.as_slice() { | 266 | match use_trees.as_slice() { |
265 | [name] => { | 267 | [name] => { |
266 | if let Some(end_path) = name.path() { | 268 | if let Some(end_path) = name.path() { |
267 | let replacement = | 269 | rewriter.replace_ast( |
268 | make::use_tree(make::path_concat(path, end_path), None, None, false); | 270 | &parent.left_or_else(|tl| tl.parent_use_tree()), |
269 | 271 | &make::use_tree(make::path_concat(path, end_path), None, None, false), | |
270 | algo::diff( | 272 | ); |
271 | &parent.either(|n| n.syntax().clone(), |n| n.syntax().clone()), | ||
272 | replacement.syntax(), | ||
273 | ) | ||
274 | .into_text_edit(builder.text_edit_builder()); | ||
275 | } | 273 | } |
276 | } | 274 | } |
277 | names => { | 275 | names => match &parent { |
278 | let replacement = match parent { | 276 | Either::Left(parent) => rewriter.replace_ast( |
279 | Either::Left(_) => { | 277 | parent, |
280 | make::use_tree(path, Some(make::use_tree_list(names.to_owned())), None, false) | 278 | &make::use_tree(path, Some(make::use_tree_list(names.to_owned())), None, false), |
281 | .syntax() | 279 | ), |
282 | .clone() | 280 | Either::Right(parent) => { |
283 | } | 281 | rewriter.replace_ast(parent, &make::use_tree_list(names.to_owned())) |
284 | Either::Right(_) => make::use_tree_list(names.to_owned()).syntax().clone(), | 282 | } |
285 | }; | 283 | }, |
286 | |||
287 | algo::diff( | ||
288 | &parent.either(|n| n.syntax().clone(), |n| n.syntax().clone()), | ||
289 | &replacement, | ||
290 | ) | ||
291 | .into_text_edit(builder.text_edit_builder()); | ||
292 | } | ||
293 | }; | 284 | }; |
294 | } | 285 | } |
295 | 286 | ||
@@ -884,4 +875,33 @@ fn qux(baz: Baz) {} | |||
884 | ", | 875 | ", |
885 | ) | 876 | ) |
886 | } | 877 | } |
878 | |||
879 | #[test] | ||
880 | fn expanding_glob_import_single_nested_glob_only() { | ||
881 | check_assist( | ||
882 | expand_glob_import, | ||
883 | r" | ||
884 | mod foo { | ||
885 | pub struct Bar; | ||
886 | } | ||
887 | |||
888 | use foo::{*<|>}; | ||
889 | |||
890 | struct Baz { | ||
891 | bar: Bar | ||
892 | } | ||
893 | ", | ||
894 | r" | ||
895 | mod foo { | ||
896 | pub struct Bar; | ||
897 | } | ||
898 | |||
899 | use foo::Bar; | ||
900 | |||
901 | struct Baz { | ||
902 | bar: Bar | ||
903 | } | ||
904 | ", | ||
905 | ); | ||
906 | } | ||
887 | } | 907 | } |
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs index dddab255e..14209b771 100644 --- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs +++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs | |||
@@ -1,3 +1,6 @@ | |||
1 | use std::iter; | ||
2 | |||
3 | use either::Either; | ||
1 | use hir::{AsName, EnumVariant, Module, ModuleDef, Name}; | 4 | use hir::{AsName, EnumVariant, Module, ModuleDef, Name}; |
2 | use ide_db::{defs::Definition, search::Reference, RootDatabase}; | 5 | use ide_db::{defs::Definition, search::Reference, RootDatabase}; |
3 | use rustc_hash::{FxHashMap, FxHashSet}; | 6 | use rustc_hash::{FxHashMap, FxHashSet}; |
@@ -31,40 +34,32 @@ pub(crate) fn extract_struct_from_enum_variant( | |||
31 | ctx: &AssistContext, | 34 | ctx: &AssistContext, |
32 | ) -> Option<()> { | 35 | ) -> Option<()> { |
33 | let variant = ctx.find_node_at_offset::<ast::Variant>()?; | 36 | let variant = ctx.find_node_at_offset::<ast::Variant>()?; |
34 | let field_list = match variant.kind() { | 37 | let field_list = extract_field_list_if_applicable(&variant)?; |
35 | ast::StructKind::Tuple(field_list) => field_list, | ||
36 | _ => return None, | ||
37 | }; | ||
38 | |||
39 | // skip 1-tuple variants | ||
40 | if field_list.fields().count() == 1 { | ||
41 | return None; | ||
42 | } | ||
43 | 38 | ||
44 | let variant_name = variant.name()?; | 39 | let variant_name = variant.name()?; |
45 | let variant_hir = ctx.sema.to_def(&variant)?; | 40 | let variant_hir = ctx.sema.to_def(&variant)?; |
46 | if existing_struct_def(ctx.db(), &variant_name, &variant_hir) { | 41 | if existing_definition(ctx.db(), &variant_name, &variant_hir) { |
47 | return None; | 42 | return None; |
48 | } | 43 | } |
44 | |||
49 | let enum_ast = variant.parent_enum(); | 45 | let enum_ast = variant.parent_enum(); |
50 | let visibility = enum_ast.visibility(); | ||
51 | let enum_hir = ctx.sema.to_def(&enum_ast)?; | 46 | let enum_hir = ctx.sema.to_def(&enum_ast)?; |
52 | let variant_hir_name = variant_hir.name(ctx.db()); | ||
53 | let enum_module_def = ModuleDef::from(enum_hir); | ||
54 | let current_module = enum_hir.module(ctx.db()); | ||
55 | let target = variant.syntax().text_range(); | 47 | let target = variant.syntax().text_range(); |
56 | acc.add( | 48 | acc.add( |
57 | AssistId("extract_struct_from_enum_variant", AssistKind::RefactorRewrite), | 49 | AssistId("extract_struct_from_enum_variant", AssistKind::RefactorRewrite), |
58 | "Extract struct from enum variant", | 50 | "Extract struct from enum variant", |
59 | target, | 51 | target, |
60 | |builder| { | 52 | |builder| { |
61 | let definition = Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir)); | 53 | let variant_hir_name = variant_hir.name(ctx.db()); |
62 | let res = definition.usages(&ctx.sema).all(); | 54 | let enum_module_def = ModuleDef::from(enum_hir); |
55 | let usages = | ||
56 | Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir)).usages(&ctx.sema).all(); | ||
63 | 57 | ||
64 | let mut visited_modules_set = FxHashSet::default(); | 58 | let mut visited_modules_set = FxHashSet::default(); |
59 | let current_module = enum_hir.module(ctx.db()); | ||
65 | visited_modules_set.insert(current_module); | 60 | visited_modules_set.insert(current_module); |
66 | let mut rewriters = FxHashMap::default(); | 61 | let mut rewriters = FxHashMap::default(); |
67 | for reference in res { | 62 | for reference in usages { |
68 | let rewriter = rewriters | 63 | let rewriter = rewriters |
69 | .entry(reference.file_range.file_id) | 64 | .entry(reference.file_range.file_id) |
70 | .or_insert_with(SyntaxRewriter::default); | 65 | .or_insert_with(SyntaxRewriter::default); |
@@ -86,26 +81,49 @@ pub(crate) fn extract_struct_from_enum_variant( | |||
86 | builder.rewrite(rewriter); | 81 | builder.rewrite(rewriter); |
87 | } | 82 | } |
88 | builder.edit_file(ctx.frange.file_id); | 83 | builder.edit_file(ctx.frange.file_id); |
89 | update_variant(&mut rewriter, &variant_name, &field_list); | 84 | update_variant(&mut rewriter, &variant); |
90 | extract_struct_def( | 85 | extract_struct_def( |
91 | &mut rewriter, | 86 | &mut rewriter, |
92 | &enum_ast, | 87 | &enum_ast, |
93 | variant_name.clone(), | 88 | variant_name.clone(), |
94 | &field_list, | 89 | &field_list, |
95 | &variant.parent_enum().syntax().clone().into(), | 90 | &variant.parent_enum().syntax().clone().into(), |
96 | visibility, | 91 | enum_ast.visibility(), |
97 | ); | 92 | ); |
98 | builder.rewrite(rewriter); | 93 | builder.rewrite(rewriter); |
99 | }, | 94 | }, |
100 | ) | 95 | ) |
101 | } | 96 | } |
102 | 97 | ||
103 | fn existing_struct_def(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool { | 98 | fn extract_field_list_if_applicable( |
99 | variant: &ast::Variant, | ||
100 | ) -> Option<Either<ast::RecordFieldList, ast::TupleFieldList>> { | ||
101 | match variant.kind() { | ||
102 | ast::StructKind::Record(field_list) if field_list.fields().next().is_some() => { | ||
103 | Some(Either::Left(field_list)) | ||
104 | } | ||
105 | ast::StructKind::Tuple(field_list) if field_list.fields().count() > 1 => { | ||
106 | Some(Either::Right(field_list)) | ||
107 | } | ||
108 | _ => None, | ||
109 | } | ||
110 | } | ||
111 | |||
112 | fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool { | ||
104 | variant | 113 | variant |
105 | .parent_enum(db) | 114 | .parent_enum(db) |
106 | .module(db) | 115 | .module(db) |
107 | .scope(db, None) | 116 | .scope(db, None) |
108 | .into_iter() | 117 | .into_iter() |
118 | .filter(|(_, def)| match def { | ||
119 | // only check type-namespace | ||
120 | hir::ScopeDef::ModuleDef(def) => matches!(def, | ||
121 | ModuleDef::Module(_) | ModuleDef::Adt(_) | | ||
122 | ModuleDef::EnumVariant(_) | ModuleDef::Trait(_) | | ||
123 | ModuleDef::TypeAlias(_) | ModuleDef::BuiltinType(_) | ||
124 | ), | ||
125 | _ => false, | ||
126 | }) | ||
109 | .any(|(name, _)| name == variant_name.as_name()) | 127 | .any(|(name, _)| name == variant_name.as_name()) |
110 | } | 128 | } |
111 | 129 | ||
@@ -133,19 +151,29 @@ fn extract_struct_def( | |||
133 | rewriter: &mut SyntaxRewriter, | 151 | rewriter: &mut SyntaxRewriter, |
134 | enum_: &ast::Enum, | 152 | enum_: &ast::Enum, |
135 | variant_name: ast::Name, | 153 | variant_name: ast::Name, |
136 | variant_list: &ast::TupleFieldList, | 154 | field_list: &Either<ast::RecordFieldList, ast::TupleFieldList>, |
137 | start_offset: &SyntaxElement, | 155 | start_offset: &SyntaxElement, |
138 | visibility: Option<ast::Visibility>, | 156 | visibility: Option<ast::Visibility>, |
139 | ) -> Option<()> { | 157 | ) -> Option<()> { |
140 | let variant_list = make::tuple_field_list( | 158 | let pub_vis = Some(make::visibility_pub()); |
141 | variant_list | 159 | let field_list = match field_list { |
142 | .fields() | 160 | Either::Left(field_list) => { |
143 | .flat_map(|field| Some(make::tuple_field(Some(make::visibility_pub()), field.ty()?))), | 161 | make::record_field_list(field_list.fields().flat_map(|field| { |
144 | ); | 162 | Some(make::record_field(pub_vis.clone(), field.name()?, field.ty()?)) |
163 | })) | ||
164 | .into() | ||
165 | } | ||
166 | Either::Right(field_list) => make::tuple_field_list( | ||
167 | field_list | ||
168 | .fields() | ||
169 | .flat_map(|field| Some(make::tuple_field(pub_vis.clone(), field.ty()?))), | ||
170 | ) | ||
171 | .into(), | ||
172 | }; | ||
145 | 173 | ||
146 | rewriter.insert_before( | 174 | rewriter.insert_before( |
147 | start_offset, | 175 | start_offset, |
148 | make::struct_(visibility, variant_name, None, variant_list.into()).syntax(), | 176 | make::struct_(visibility, variant_name, None, field_list).syntax(), |
149 | ); | 177 | ); |
150 | rewriter.insert_before(start_offset, &make::tokens::blank_line()); | 178 | rewriter.insert_before(start_offset, &make::tokens::blank_line()); |
151 | 179 | ||
@@ -156,15 +184,14 @@ fn extract_struct_def( | |||
156 | Some(()) | 184 | Some(()) |
157 | } | 185 | } |
158 | 186 | ||
159 | fn update_variant( | 187 | fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Option<()> { |
160 | rewriter: &mut SyntaxRewriter, | 188 | let name = variant.name()?; |
161 | variant_name: &ast::Name, | 189 | let tuple_field = make::tuple_field(None, make::ty(name.text())); |
162 | field_list: &ast::TupleFieldList, | 190 | let replacement = make::variant( |
163 | ) -> Option<()> { | 191 | name, |
164 | let (l, r): (SyntaxElement, SyntaxElement) = | 192 | Some(ast::FieldList::TupleFieldList(make::tuple_field_list(iter::once(tuple_field)))), |
165 | (field_list.l_paren_token()?.into(), field_list.r_paren_token()?.into()); | 193 | ); |
166 | let replacement = vec![l, variant_name.syntax().clone().into(), r]; | 194 | rewriter.replace(variant.syntax(), replacement.syntax()); |
167 | rewriter.replace_with_many(field_list.syntax(), replacement); | ||
168 | Some(()) | 195 | Some(()) |
169 | } | 196 | } |
170 | 197 | ||
@@ -211,7 +238,7 @@ mod tests { | |||
211 | use super::*; | 238 | use super::*; |
212 | 239 | ||
213 | #[test] | 240 | #[test] |
214 | fn test_extract_struct_several_fields() { | 241 | fn test_extract_struct_several_fields_tuple() { |
215 | check_assist( | 242 | check_assist( |
216 | extract_struct_from_enum_variant, | 243 | extract_struct_from_enum_variant, |
217 | "enum A { <|>One(u32, u32) }", | 244 | "enum A { <|>One(u32, u32) }", |
@@ -222,6 +249,41 @@ enum A { One(One) }"#, | |||
222 | } | 249 | } |
223 | 250 | ||
224 | #[test] | 251 | #[test] |
252 | fn test_extract_struct_several_fields_named() { | ||
253 | check_assist( | ||
254 | extract_struct_from_enum_variant, | ||
255 | "enum A { <|>One { foo: u32, bar: u32 } }", | ||
256 | r#"struct One{ pub foo: u32, pub bar: u32 } | ||
257 | |||
258 | enum A { One(One) }"#, | ||
259 | ); | ||
260 | } | ||
261 | |||
262 | #[test] | ||
263 | fn test_extract_struct_one_field_named() { | ||
264 | check_assist( | ||
265 | extract_struct_from_enum_variant, | ||
266 | "enum A { <|>One { foo: u32 } }", | ||
267 | r#"struct One{ pub foo: u32 } | ||
268 | |||
269 | enum A { One(One) }"#, | ||
270 | ); | ||
271 | } | ||
272 | |||
273 | #[test] | ||
274 | fn test_extract_enum_variant_name_value_namespace() { | ||
275 | check_assist( | ||
276 | extract_struct_from_enum_variant, | ||
277 | r#"const One: () = (); | ||
278 | enum A { <|>One(u32, u32) }"#, | ||
279 | r#"const One: () = (); | ||
280 | struct One(pub u32, pub u32); | ||
281 | |||
282 | enum A { One(One) }"#, | ||
283 | ); | ||
284 | } | ||
285 | |||
286 | #[test] | ||
225 | fn test_extract_struct_pub_visibility() { | 287 | fn test_extract_struct_pub_visibility() { |
226 | check_assist( | 288 | check_assist( |
227 | extract_struct_from_enum_variant, | 289 | extract_struct_from_enum_variant, |
@@ -298,7 +360,7 @@ fn another_fn() { | |||
298 | fn test_extract_enum_not_applicable_if_struct_exists() { | 360 | fn test_extract_enum_not_applicable_if_struct_exists() { |
299 | check_not_applicable( | 361 | check_not_applicable( |
300 | r#"struct One; | 362 | r#"struct One; |
301 | enum A { <|>One(u8) }"#, | 363 | enum A { <|>One(u8, u32) }"#, |
302 | ); | 364 | ); |
303 | } | 365 | } |
304 | 366 | ||
@@ -306,4 +368,14 @@ fn another_fn() { | |||
306 | fn test_extract_not_applicable_one_field() { | 368 | fn test_extract_not_applicable_one_field() { |
307 | check_not_applicable(r"enum A { <|>One(u32) }"); | 369 | check_not_applicable(r"enum A { <|>One(u32) }"); |
308 | } | 370 | } |
371 | |||
372 | #[test] | ||
373 | fn test_extract_not_applicable_no_field_tuple() { | ||
374 | check_not_applicable(r"enum A { <|>None() }"); | ||
375 | } | ||
376 | |||
377 | #[test] | ||
378 | fn test_extract_not_applicable_no_field_named() { | ||
379 | check_not_applicable(r"enum A { <|>None {} }"); | ||
380 | } | ||
309 | } | 381 | } |
diff --git a/crates/assists/src/handlers/flip_comma.rs b/crates/assists/src/handlers/flip_comma.rs index 5c69db53e..64b4b1a76 100644 --- a/crates/assists/src/handlers/flip_comma.rs +++ b/crates/assists/src/handlers/flip_comma.rs | |||
@@ -18,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
18 | // } | 18 | // } |
19 | // ``` | 19 | // ``` |
20 | pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 20 | pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
21 | let comma = ctx.find_token_at_offset(T![,])?; | 21 | let comma = ctx.find_token_syntax_at_offset(T![,])?; |
22 | let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?; | 22 | let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?; |
23 | let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?; | 23 | let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?; |
24 | 24 | ||
diff --git a/crates/assists/src/handlers/flip_trait_bound.rs b/crates/assists/src/handlers/flip_trait_bound.rs index 347e79b1d..92ee42181 100644 --- a/crates/assists/src/handlers/flip_trait_bound.rs +++ b/crates/assists/src/handlers/flip_trait_bound.rs | |||
@@ -20,7 +20,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
20 | pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 20 | pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
21 | // We want to replicate the behavior of `flip_binexpr` by only suggesting | 21 | // We want to replicate the behavior of `flip_binexpr` by only suggesting |
22 | // the assist when the cursor is on a `+` | 22 | // the assist when the cursor is on a `+` |
23 | let plus = ctx.find_token_at_offset(T![+])?; | 23 | let plus = ctx.find_token_syntax_at_offset(T![+])?; |
24 | 24 | ||
25 | // Make sure we're in a `TypeBoundList` | 25 | // Make sure we're in a `TypeBoundList` |
26 | if ast::TypeBoundList::cast(plus.parent()).is_none() { | 26 | if ast::TypeBoundList::cast(plus.parent()).is_none() { |
diff --git a/crates/assists/src/handlers/infer_function_return_type.rs b/crates/assists/src/handlers/infer_function_return_type.rs new file mode 100644 index 000000000..520d07ae0 --- /dev/null +++ b/crates/assists/src/handlers/infer_function_return_type.rs | |||
@@ -0,0 +1,337 @@ | |||
1 | use hir::HirDisplay; | ||
2 | use syntax::{ast, AstNode, TextRange, TextSize}; | ||
3 | use test_utils::mark; | ||
4 | |||
5 | use crate::{AssistContext, AssistId, AssistKind, Assists}; | ||
6 | |||
7 | // Assist: infer_function_return_type | ||
8 | // | ||
9 | // Adds the return type to a function or closure inferred from its tail expression if it doesn't have a return | ||
10 | // type specified. This assists is useable in a functions or closures tail expression or return type position. | ||
11 | // | ||
12 | // ``` | ||
13 | // fn foo() { 4<|>2i32 } | ||
14 | // ``` | ||
15 | // -> | ||
16 | // ``` | ||
17 | // fn foo() -> i32 { 42i32 } | ||
18 | // ``` | ||
19 | pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | ||
20 | let (tail_expr, builder_edit_pos, wrap_expr) = extract_tail(ctx)?; | ||
21 | let module = ctx.sema.scope(tail_expr.syntax()).module()?; | ||
22 | let ty = ctx.sema.type_of_expr(&tail_expr)?; | ||
23 | if ty.is_unit() { | ||
24 | return None; | ||
25 | } | ||
26 | let ty = ty.display_source_code(ctx.db(), module.into()).ok()?; | ||
27 | |||
28 | acc.add( | ||
29 | AssistId("infer_function_return_type", AssistKind::RefactorRewrite), | ||
30 | "Add this function's return type", | ||
31 | tail_expr.syntax().text_range(), | ||
32 | |builder| { | ||
33 | match builder_edit_pos { | ||
34 | InsertOrReplace::Insert(insert_pos) => { | ||
35 | builder.insert(insert_pos, &format!("-> {} ", ty)) | ||
36 | } | ||
37 | InsertOrReplace::Replace(text_range) => { | ||
38 | builder.replace(text_range, &format!("-> {}", ty)) | ||
39 | } | ||
40 | } | ||
41 | if wrap_expr { | ||
42 | mark::hit!(wrap_closure_non_block_expr); | ||
43 | // `|x| x` becomes `|x| -> T x` which is invalid, so wrap it in a block | ||
44 | builder.replace(tail_expr.syntax().text_range(), &format!("{{{}}}", tail_expr)); | ||
45 | } | ||
46 | }, | ||
47 | ) | ||
48 | } | ||
49 | |||
50 | enum InsertOrReplace { | ||
51 | Insert(TextSize), | ||
52 | Replace(TextRange), | ||
53 | } | ||
54 | |||
55 | /// Check the potentially already specified return type and reject it or turn it into a builder command | ||
56 | /// if allowed. | ||
57 | fn ret_ty_to_action(ret_ty: Option<ast::RetType>, insert_pos: TextSize) -> Option<InsertOrReplace> { | ||
58 | match ret_ty { | ||
59 | Some(ret_ty) => match ret_ty.ty() { | ||
60 | Some(ast::Type::InferType(_)) | None => { | ||
61 | mark::hit!(existing_infer_ret_type); | ||
62 | mark::hit!(existing_infer_ret_type_closure); | ||
63 | Some(InsertOrReplace::Replace(ret_ty.syntax().text_range())) | ||
64 | } | ||
65 | _ => { | ||
66 | mark::hit!(existing_ret_type); | ||
67 | mark::hit!(existing_ret_type_closure); | ||
68 | None | ||
69 | } | ||
70 | }, | ||
71 | None => Some(InsertOrReplace::Insert(insert_pos + TextSize::from(1))), | ||
72 | } | ||
73 | } | ||
74 | |||
75 | fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool)> { | ||
76 | let (tail_expr, return_type_range, action, wrap_expr) = | ||
77 | if let Some(closure) = ctx.find_node_at_offset::<ast::ClosureExpr>() { | ||
78 | let rpipe_pos = closure.param_list()?.syntax().last_token()?.text_range().end(); | ||
79 | let action = ret_ty_to_action(closure.ret_type(), rpipe_pos)?; | ||
80 | |||
81 | let body = closure.body()?; | ||
82 | let body_start = body.syntax().first_token()?.text_range().start(); | ||
83 | let (tail_expr, wrap_expr) = match body { | ||
84 | ast::Expr::BlockExpr(block) => (block.expr()?, false), | ||
85 | body => (body, true), | ||
86 | }; | ||
87 | |||
88 | let ret_range = TextRange::new(rpipe_pos, body_start); | ||
89 | (tail_expr, ret_range, action, wrap_expr) | ||
90 | } else { | ||
91 | let func = ctx.find_node_at_offset::<ast::Fn>()?; | ||
92 | let rparen_pos = func.param_list()?.r_paren_token()?.text_range().end(); | ||
93 | let action = ret_ty_to_action(func.ret_type(), rparen_pos)?; | ||
94 | |||
95 | let body = func.body()?; | ||
96 | let tail_expr = body.expr()?; | ||
97 | |||
98 | let ret_range_end = body.l_curly_token()?.text_range().start(); | ||
99 | let ret_range = TextRange::new(rparen_pos, ret_range_end); | ||
100 | (tail_expr, ret_range, action, false) | ||
101 | }; | ||
102 | let frange = ctx.frange.range; | ||
103 | if return_type_range.contains_range(frange) { | ||
104 | mark::hit!(cursor_in_ret_position); | ||
105 | mark::hit!(cursor_in_ret_position_closure); | ||
106 | } else if tail_expr.syntax().text_range().contains_range(frange) { | ||
107 | mark::hit!(cursor_on_tail); | ||
108 | mark::hit!(cursor_on_tail_closure); | ||
109 | } else { | ||
110 | return None; | ||
111 | } | ||
112 | Some((tail_expr, action, wrap_expr)) | ||
113 | } | ||
114 | |||
115 | #[cfg(test)] | ||
116 | mod tests { | ||
117 | use crate::tests::{check_assist, check_assist_not_applicable}; | ||
118 | |||
119 | use super::*; | ||
120 | |||
121 | #[test] | ||
122 | fn infer_return_type_specified_inferred() { | ||
123 | mark::check!(existing_infer_ret_type); | ||
124 | check_assist( | ||
125 | infer_function_return_type, | ||
126 | r#"fn foo() -> <|>_ { | ||
127 | 45 | ||
128 | }"#, | ||
129 | r#"fn foo() -> i32 { | ||
130 | 45 | ||
131 | }"#, | ||
132 | ); | ||
133 | } | ||
134 | |||
135 | #[test] | ||
136 | fn infer_return_type_specified_inferred_closure() { | ||
137 | mark::check!(existing_infer_ret_type_closure); | ||
138 | check_assist( | ||
139 | infer_function_return_type, | ||
140 | r#"fn foo() { | ||
141 | || -> _ {<|>45}; | ||
142 | }"#, | ||
143 | r#"fn foo() { | ||
144 | || -> i32 {45}; | ||
145 | }"#, | ||
146 | ); | ||
147 | } | ||
148 | |||
149 | #[test] | ||
150 | fn infer_return_type_cursor_at_return_type_pos() { | ||
151 | mark::check!(cursor_in_ret_position); | ||
152 | check_assist( | ||
153 | infer_function_return_type, | ||
154 | r#"fn foo() <|>{ | ||
155 | 45 | ||
156 | }"#, | ||
157 | r#"fn foo() -> i32 { | ||
158 | 45 | ||
159 | }"#, | ||
160 | ); | ||
161 | } | ||
162 | |||
163 | #[test] | ||
164 | fn infer_return_type_cursor_at_return_type_pos_closure() { | ||
165 | mark::check!(cursor_in_ret_position_closure); | ||
166 | check_assist( | ||
167 | infer_function_return_type, | ||
168 | r#"fn foo() { | ||
169 | || <|>45 | ||
170 | }"#, | ||
171 | r#"fn foo() { | ||
172 | || -> i32 {45} | ||
173 | }"#, | ||
174 | ); | ||
175 | } | ||
176 | |||
177 | #[test] | ||
178 | fn infer_return_type() { | ||
179 | mark::check!(cursor_on_tail); | ||
180 | check_assist( | ||
181 | infer_function_return_type, | ||
182 | r#"fn foo() { | ||
183 | 45<|> | ||
184 | }"#, | ||
185 | r#"fn foo() -> i32 { | ||
186 | 45 | ||
187 | }"#, | ||
188 | ); | ||
189 | } | ||
190 | |||
191 | #[test] | ||
192 | fn infer_return_type_nested() { | ||
193 | check_assist( | ||
194 | infer_function_return_type, | ||
195 | r#"fn foo() { | ||
196 | if true { | ||
197 | 3<|> | ||
198 | } else { | ||
199 | 5 | ||
200 | } | ||
201 | }"#, | ||
202 | r#"fn foo() -> i32 { | ||
203 | if true { | ||
204 | 3 | ||
205 | } else { | ||
206 | 5 | ||
207 | } | ||
208 | }"#, | ||
209 | ); | ||
210 | } | ||
211 | |||
212 | #[test] | ||
213 | fn not_applicable_ret_type_specified() { | ||
214 | mark::check!(existing_ret_type); | ||
215 | check_assist_not_applicable( | ||
216 | infer_function_return_type, | ||
217 | r#"fn foo() -> i32 { | ||
218 | ( 45<|> + 32 ) * 123 | ||
219 | }"#, | ||
220 | ); | ||
221 | } | ||
222 | |||
223 | #[test] | ||
224 | fn not_applicable_non_tail_expr() { | ||
225 | check_assist_not_applicable( | ||
226 | infer_function_return_type, | ||
227 | r#"fn foo() { | ||
228 | let x = <|>3; | ||
229 | ( 45 + 32 ) * 123 | ||
230 | }"#, | ||
231 | ); | ||
232 | } | ||
233 | |||
234 | #[test] | ||
235 | fn not_applicable_unit_return_type() { | ||
236 | check_assist_not_applicable( | ||
237 | infer_function_return_type, | ||
238 | r#"fn foo() { | ||
239 | (<|>) | ||
240 | }"#, | ||
241 | ); | ||
242 | } | ||
243 | |||
244 | #[test] | ||
245 | fn infer_return_type_closure_block() { | ||
246 | mark::check!(cursor_on_tail_closure); | ||
247 | check_assist( | ||
248 | infer_function_return_type, | ||
249 | r#"fn foo() { | ||
250 | |x: i32| { | ||
251 | x<|> | ||
252 | }; | ||
253 | }"#, | ||
254 | r#"fn foo() { | ||
255 | |x: i32| -> i32 { | ||
256 | x | ||
257 | }; | ||
258 | }"#, | ||
259 | ); | ||
260 | } | ||
261 | |||
262 | #[test] | ||
263 | fn infer_return_type_closure() { | ||
264 | check_assist( | ||
265 | infer_function_return_type, | ||
266 | r#"fn foo() { | ||
267 | |x: i32| { x<|> }; | ||
268 | }"#, | ||
269 | r#"fn foo() { | ||
270 | |x: i32| -> i32 { x }; | ||
271 | }"#, | ||
272 | ); | ||
273 | } | ||
274 | |||
275 | #[test] | ||
276 | fn infer_return_type_closure_wrap() { | ||
277 | mark::check!(wrap_closure_non_block_expr); | ||
278 | check_assist( | ||
279 | infer_function_return_type, | ||
280 | r#"fn foo() { | ||
281 | |x: i32| x<|>; | ||
282 | }"#, | ||
283 | r#"fn foo() { | ||
284 | |x: i32| -> i32 {x}; | ||
285 | }"#, | ||
286 | ); | ||
287 | } | ||
288 | |||
289 | #[test] | ||
290 | fn infer_return_type_nested_closure() { | ||
291 | check_assist( | ||
292 | infer_function_return_type, | ||
293 | r#"fn foo() { | ||
294 | || { | ||
295 | if true { | ||
296 | 3<|> | ||
297 | } else { | ||
298 | 5 | ||
299 | } | ||
300 | } | ||
301 | }"#, | ||
302 | r#"fn foo() { | ||
303 | || -> i32 { | ||
304 | if true { | ||
305 | 3 | ||
306 | } else { | ||
307 | 5 | ||
308 | } | ||
309 | } | ||
310 | }"#, | ||
311 | ); | ||
312 | } | ||
313 | |||
314 | #[test] | ||
315 | fn not_applicable_ret_type_specified_closure() { | ||
316 | mark::check!(existing_ret_type_closure); | ||
317 | check_assist_not_applicable( | ||
318 | infer_function_return_type, | ||
319 | r#"fn foo() { | ||
320 | || -> i32 { 3<|> } | ||
321 | }"#, | ||
322 | ); | ||
323 | } | ||
324 | |||
325 | #[test] | ||
326 | fn not_applicable_non_tail_expr_closure() { | ||
327 | check_assist_not_applicable( | ||
328 | infer_function_return_type, | ||
329 | r#"fn foo() { | ||
330 | || -> i32 { | ||
331 | let x = 3<|>; | ||
332 | 6 | ||
333 | } | ||
334 | }"#, | ||
335 | ); | ||
336 | } | ||
337 | } | ||
diff --git a/crates/assists/src/handlers/introduce_named_lifetime.rs b/crates/assists/src/handlers/introduce_named_lifetime.rs index 5f623e5f7..4cc8dae65 100644 --- a/crates/assists/src/handlers/introduce_named_lifetime.rs +++ b/crates/assists/src/handlers/introduce_named_lifetime.rs | |||
@@ -36,7 +36,7 @@ static ASSIST_LABEL: &str = "Introduce named lifetime"; | |||
36 | // FIXME: should also add support for the case fun(f: &Foo) -> &<|>Foo | 36 | // FIXME: should also add support for the case fun(f: &Foo) -> &<|>Foo |
37 | pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 37 | pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
38 | let lifetime_token = ctx | 38 | let lifetime_token = ctx |
39 | .find_token_at_offset(SyntaxKind::LIFETIME) | 39 | .find_token_syntax_at_offset(SyntaxKind::LIFETIME) |
40 | .filter(|lifetime| lifetime.text() == "'_")?; | 40 | .filter(|lifetime| lifetime.text() == "'_")?; |
41 | if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::Fn::cast) { | 41 | if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::Fn::cast) { |
42 | generate_fn_def_assist(acc, &fn_def, lifetime_token.text_range()) | 42 | generate_fn_def_assist(acc, &fn_def, lifetime_token.text_range()) |
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs index 461fcf862..ea722b91b 100644 --- a/crates/assists/src/handlers/invert_if.rs +++ b/crates/assists/src/handlers/invert_if.rs | |||
@@ -29,7 +29,7 @@ use crate::{ | |||
29 | // ``` | 29 | // ``` |
30 | 30 | ||
31 | pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 31 | pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
32 | let if_keyword = ctx.find_token_at_offset(T![if])?; | 32 | let if_keyword = ctx.find_token_syntax_at_offset(T![if])?; |
33 | let expr = ast::IfExpr::cast(if_keyword.parent())?; | 33 | let expr = ast::IfExpr::cast(if_keyword.parent())?; |
34 | let if_range = if_keyword.text_range(); | 34 | let if_range = if_keyword.text_range(); |
35 | let cursor_in_range = if_range.contains_range(ctx.frange.range); | 35 | let cursor_in_range = if_range.contains_range(ctx.frange.range); |
diff --git a/crates/assists/src/handlers/raw_string.rs b/crates/assists/src/handlers/raw_string.rs index 9ddd116e0..4c759cc25 100644 --- a/crates/assists/src/handlers/raw_string.rs +++ b/crates/assists/src/handlers/raw_string.rs | |||
@@ -1,11 +1,6 @@ | |||
1 | use std::borrow::Cow; | 1 | use std::borrow::Cow; |
2 | 2 | ||
3 | use syntax::{ | 3 | use syntax::{ast, AstToken, TextRange, TextSize}; |
4 | ast::{self, HasQuotes, HasStringValue}, | ||
5 | AstToken, | ||
6 | SyntaxKind::{RAW_STRING, STRING}, | ||
7 | TextRange, TextSize, | ||
8 | }; | ||
9 | use test_utils::mark; | 4 | use test_utils::mark; |
10 | 5 | ||
11 | use crate::{AssistContext, AssistId, AssistKind, Assists}; | 6 | use crate::{AssistContext, AssistId, AssistKind, Assists}; |
@@ -26,7 +21,10 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
26 | // } | 21 | // } |
27 | // ``` | 22 | // ``` |
28 | pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 23 | pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
29 | let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?; | 24 | let token = ctx.find_token_at_offset::<ast::String>()?; |
25 | if token.is_raw() { | ||
26 | return None; | ||
27 | } | ||
30 | let value = token.value()?; | 28 | let value = token.value()?; |
31 | let target = token.syntax().text_range(); | 29 | let target = token.syntax().text_range(); |
32 | acc.add( | 30 | acc.add( |
@@ -65,7 +63,10 @@ pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option< | |||
65 | // } | 63 | // } |
66 | // ``` | 64 | // ``` |
67 | pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 65 | pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
68 | let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?; | 66 | let token = ctx.find_token_at_offset::<ast::String>()?; |
67 | if !token.is_raw() { | ||
68 | return None; | ||
69 | } | ||
69 | let value = token.value()?; | 70 | let value = token.value()?; |
70 | let target = token.syntax().text_range(); | 71 | let target = token.syntax().text_range(); |
71 | acc.add( | 72 | acc.add( |
@@ -104,11 +105,15 @@ pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Optio | |||
104 | // } | 105 | // } |
105 | // ``` | 106 | // ``` |
106 | pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 107 | pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
107 | let token = ctx.find_token_at_offset(RAW_STRING)?; | 108 | let token = ctx.find_token_at_offset::<ast::String>()?; |
108 | let target = token.text_range(); | 109 | if !token.is_raw() { |
110 | return None; | ||
111 | } | ||
112 | let text_range = token.syntax().text_range(); | ||
113 | let target = text_range; | ||
109 | acc.add(AssistId("add_hash", AssistKind::Refactor), "Add #", target, |edit| { | 114 | acc.add(AssistId("add_hash", AssistKind::Refactor), "Add #", target, |edit| { |
110 | edit.insert(token.text_range().start() + TextSize::of('r'), "#"); | 115 | edit.insert(text_range.start() + TextSize::of('r'), "#"); |
111 | edit.insert(token.text_range().end(), "#"); | 116 | edit.insert(text_range.end(), "#"); |
112 | }) | 117 | }) |
113 | } | 118 | } |
114 | 119 | ||
@@ -128,7 +133,10 @@ pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | |||
128 | // } | 133 | // } |
129 | // ``` | 134 | // ``` |
130 | pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 135 | pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
131 | let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?; | 136 | let token = ctx.find_token_at_offset::<ast::String>()?; |
137 | if !token.is_raw() { | ||
138 | return None; | ||
139 | } | ||
132 | 140 | ||
133 | let text = token.text().as_str(); | 141 | let text = token.text().as_str(); |
134 | if !text.starts_with("r#") && text.ends_with('#') { | 142 | if !text.starts_with("r#") && text.ends_with('#') { |
diff --git a/crates/assists/src/handlers/remove_mut.rs b/crates/assists/src/handlers/remove_mut.rs index 44f41daa9..575b271f7 100644 --- a/crates/assists/src/handlers/remove_mut.rs +++ b/crates/assists/src/handlers/remove_mut.rs | |||
@@ -18,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
18 | // } | 18 | // } |
19 | // ``` | 19 | // ``` |
20 | pub(crate) fn remove_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 20 | pub(crate) fn remove_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
21 | let mut_token = ctx.find_token_at_offset(T![mut])?; | 21 | let mut_token = ctx.find_token_syntax_at_offset(T![mut])?; |
22 | let delete_from = mut_token.text_range().start(); | 22 | let delete_from = mut_token.text_range().start(); |
23 | let delete_to = match mut_token.next_token() { | 23 | let delete_to = match mut_token.next_token() { |
24 | Some(it) if it.kind() == SyntaxKind::WHITESPACE => it.text_range().end(), | 24 | Some(it) if it.kind() == SyntaxKind::WHITESPACE => it.text_range().end(), |
diff --git a/crates/assists/src/handlers/reorder_fields.rs b/crates/assists/src/handlers/reorder_fields.rs index 527f457a7..7c0f0f44e 100644 --- a/crates/assists/src/handlers/reorder_fields.rs +++ b/crates/assists/src/handlers/reorder_fields.rs | |||
@@ -47,9 +47,11 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | |||
47 | "Reorder record fields", | 47 | "Reorder record fields", |
48 | target, | 48 | target, |
49 | |edit| { | 49 | |edit| { |
50 | let mut rewriter = algo::SyntaxRewriter::default(); | ||
50 | for (old, new) in fields.iter().zip(&sorted_fields) { | 51 | for (old, new) in fields.iter().zip(&sorted_fields) { |
51 | algo::diff(old, new).into_text_edit(edit.text_edit_builder()); | 52 | rewriter.replace(old, new); |
52 | } | 53 | } |
54 | edit.rewrite(rewriter); | ||
53 | }, | 55 | }, |
54 | ) | 56 | ) |
55 | } | 57 | } |
diff --git a/crates/assists/src/handlers/replace_let_with_if_let.rs b/crates/assists/src/handlers/replace_let_with_if_let.rs index a5bcbda24..69d3b08d3 100644 --- a/crates/assists/src/handlers/replace_let_with_if_let.rs +++ b/crates/assists/src/handlers/replace_let_with_if_let.rs | |||
@@ -37,7 +37,7 @@ use ide_db::ty_filter::TryEnum; | |||
37 | // fn compute() -> Option<i32> { None } | 37 | // fn compute() -> Option<i32> { None } |
38 | // ``` | 38 | // ``` |
39 | pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 39 | pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
40 | let let_kw = ctx.find_token_at_offset(T![let])?; | 40 | let let_kw = ctx.find_token_syntax_at_offset(T![let])?; |
41 | let let_stmt = let_kw.ancestors().find_map(ast::LetStmt::cast)?; | 41 | let let_stmt = let_kw.ancestors().find_map(ast::LetStmt::cast)?; |
42 | let init = let_stmt.initializer()?; | 42 | let init = let_stmt.initializer()?; |
43 | let original_pat = let_stmt.pat()?; | 43 | let original_pat = let_stmt.pat()?; |
diff --git a/crates/assists/src/handlers/replace_string_with_char.rs b/crates/assists/src/handlers/replace_string_with_char.rs index 4ca87a8ec..b4b898846 100644 --- a/crates/assists/src/handlers/replace_string_with_char.rs +++ b/crates/assists/src/handlers/replace_string_with_char.rs | |||
@@ -1,8 +1,4 @@ | |||
1 | use syntax::{ | 1 | use syntax::{ast, AstToken, SyntaxKind::STRING}; |
2 | ast::{self, HasStringValue}, | ||
3 | AstToken, | ||
4 | SyntaxKind::STRING, | ||
5 | }; | ||
6 | 2 | ||
7 | use crate::{AssistContext, AssistId, AssistKind, Assists}; | 3 | use crate::{AssistContext, AssistId, AssistKind, Assists}; |
8 | 4 | ||
@@ -22,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
22 | // } | 18 | // } |
23 | // ``` | 19 | // ``` |
24 | pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 20 | pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
25 | let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?; | 21 | let token = ctx.find_token_syntax_at_offset(STRING).and_then(ast::String::cast)?; |
26 | let value = token.value()?; | 22 | let value = token.value()?; |
27 | let target = token.syntax().text_range(); | 23 | let target = token.syntax().text_range(); |
28 | 24 | ||
diff --git a/crates/assists/src/handlers/split_import.rs b/crates/assists/src/handlers/split_import.rs index 15e67eaa1..ef1f6b8a1 100644 --- a/crates/assists/src/handlers/split_import.rs +++ b/crates/assists/src/handlers/split_import.rs | |||
@@ -16,7 +16,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists}; | |||
16 | // use std::{collections::HashMap}; | 16 | // use std::{collections::HashMap}; |
17 | // ``` | 17 | // ``` |
18 | pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { | 18 | pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { |
19 | let colon_colon = ctx.find_token_at_offset(T![::])?; | 19 | let colon_colon = ctx.find_token_syntax_at_offset(T![::])?; |
20 | let path = ast::Path::cast(colon_colon.parent())?.qualifier()?; | 20 | let path = ast::Path::cast(colon_colon.parent())?.qualifier()?; |
21 | let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?; | 21 | let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?; |
22 | 22 | ||
diff --git a/crates/assists/src/handlers/unwrap_block.rs b/crates/assists/src/handlers/unwrap_block.rs index 3851aeb3e..36ef871b9 100644 --- a/crates/assists/src/handlers/unwrap_block.rs +++ b/crates/assists/src/handlers/unwrap_block.rs | |||
@@ -29,7 +29,7 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()> | |||
29 | let assist_id = AssistId("unwrap_block", AssistKind::RefactorRewrite); | 29 | let assist_id = AssistId("unwrap_block", AssistKind::RefactorRewrite); |
30 | let assist_label = "Unwrap block"; | 30 | let assist_label = "Unwrap block"; |
31 | 31 | ||
32 | let l_curly_token = ctx.find_token_at_offset(T!['{'])?; | 32 | let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?; |
33 | let mut block = ast::BlockExpr::cast(l_curly_token.parent())?; | 33 | let mut block = ast::BlockExpr::cast(l_curly_token.parent())?; |
34 | let mut parent = block.syntax().parent()?; | 34 | let mut parent = block.syntax().parent()?; |
35 | if ast::MatchArm::can_cast(parent.kind()) { | 35 | if ast::MatchArm::can_cast(parent.kind()) { |
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs index b804e495d..af88b3437 100644 --- a/crates/assists/src/lib.rs +++ b/crates/assists/src/lib.rs | |||
@@ -143,6 +143,7 @@ mod handlers { | |||
143 | mod generate_function; | 143 | mod generate_function; |
144 | mod generate_impl; | 144 | mod generate_impl; |
145 | mod generate_new; | 145 | mod generate_new; |
146 | mod infer_function_return_type; | ||
146 | mod inline_local_variable; | 147 | mod inline_local_variable; |
147 | mod introduce_named_lifetime; | 148 | mod introduce_named_lifetime; |
148 | mod invert_if; | 149 | mod invert_if; |
@@ -190,6 +191,7 @@ mod handlers { | |||
190 | generate_function::generate_function, | 191 | generate_function::generate_function, |
191 | generate_impl::generate_impl, | 192 | generate_impl::generate_impl, |
192 | generate_new::generate_new, | 193 | generate_new::generate_new, |
194 | infer_function_return_type::infer_function_return_type, | ||
193 | inline_local_variable::inline_local_variable, | 195 | inline_local_variable::inline_local_variable, |
194 | introduce_named_lifetime::introduce_named_lifetime, | 196 | introduce_named_lifetime::introduce_named_lifetime, |
195 | invert_if::invert_if, | 197 | invert_if::invert_if, |
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs index acbf5b652..168e1626a 100644 --- a/crates/assists/src/tests/generated.rs +++ b/crates/assists/src/tests/generated.rs | |||
@@ -506,6 +506,19 @@ impl<T: Clone> Ctx<T> { | |||
506 | } | 506 | } |
507 | 507 | ||
508 | #[test] | 508 | #[test] |
509 | fn doctest_infer_function_return_type() { | ||
510 | check_doc_test( | ||
511 | "infer_function_return_type", | ||
512 | r#####" | ||
513 | fn foo() { 4<|>2i32 } | ||
514 | "#####, | ||
515 | r#####" | ||
516 | fn foo() -> i32 { 42i32 } | ||
517 | "#####, | ||
518 | ) | ||
519 | } | ||
520 | |||
521 | #[test] | ||
509 | fn doctest_inline_local_variable() { | 522 | fn doctest_inline_local_variable() { |
510 | check_doc_test( | 523 | check_doc_test( |
511 | "inline_local_variable", | 524 | "inline_local_variable", |
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs index 56f925ee6..7071fe96b 100644 --- a/crates/assists/src/utils.rs +++ b/crates/assists/src/utils.rs | |||
@@ -4,17 +4,22 @@ pub(crate) mod import_assets; | |||
4 | 4 | ||
5 | use std::ops; | 5 | use std::ops; |
6 | 6 | ||
7 | use hir::{Crate, Enum, Module, ScopeDef, Semantics, Trait}; | 7 | use hir::{Crate, Enum, HasSource, Module, ScopeDef, Semantics, Trait}; |
8 | use ide_db::RootDatabase; | 8 | use ide_db::RootDatabase; |
9 | use itertools::Itertools; | 9 | use itertools::Itertools; |
10 | use syntax::{ | 10 | use syntax::{ |
11 | ast::{self, make, ArgListOwner}, | 11 | ast::edit::AstNodeEdit, |
12 | ast::NameOwner, | ||
13 | ast::{self, edit, make, ArgListOwner}, | ||
12 | AstNode, Direction, | 14 | AstNode, Direction, |
13 | SyntaxKind::*, | 15 | SyntaxKind::*, |
14 | SyntaxNode, TextSize, T, | 16 | SyntaxNode, TextSize, T, |
15 | }; | 17 | }; |
16 | 18 | ||
17 | use crate::assist_config::SnippetCap; | 19 | use crate::{ |
20 | assist_config::SnippetCap, | ||
21 | ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams}, | ||
22 | }; | ||
18 | 23 | ||
19 | pub use insert_use::MergeBehaviour; | 24 | pub use insert_use::MergeBehaviour; |
20 | pub(crate) use insert_use::{insert_use, ImportScope}; | 25 | pub(crate) use insert_use::{insert_use, ImportScope}; |
@@ -77,6 +82,87 @@ pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> { | |||
77 | None | 82 | None |
78 | } | 83 | } |
79 | 84 | ||
85 | #[derive(Copy, Clone, PartialEq)] | ||
86 | pub enum DefaultMethods { | ||
87 | Only, | ||
88 | No, | ||
89 | } | ||
90 | |||
91 | pub fn filter_assoc_items( | ||
92 | db: &RootDatabase, | ||
93 | items: &[hir::AssocItem], | ||
94 | default_methods: DefaultMethods, | ||
95 | ) -> Vec<ast::AssocItem> { | ||
96 | fn has_def_name(item: &ast::AssocItem) -> bool { | ||
97 | match item { | ||
98 | ast::AssocItem::Fn(def) => def.name(), | ||
99 | ast::AssocItem::TypeAlias(def) => def.name(), | ||
100 | ast::AssocItem::Const(def) => def.name(), | ||
101 | ast::AssocItem::MacroCall(_) => None, | ||
102 | } | ||
103 | .is_some() | ||
104 | }; | ||
105 | |||
106 | items | ||
107 | .iter() | ||
108 | .map(|i| match i { | ||
109 | hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(db).value), | ||
110 | hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(db).value), | ||
111 | hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(db).value), | ||
112 | }) | ||
113 | .filter(has_def_name) | ||
114 | .filter(|it| match it { | ||
115 | ast::AssocItem::Fn(def) => matches!( | ||
116 | (default_methods, def.body()), | ||
117 | (DefaultMethods::Only, Some(_)) | (DefaultMethods::No, None) | ||
118 | ), | ||
119 | _ => default_methods == DefaultMethods::No, | ||
120 | }) | ||
121 | .collect::<Vec<_>>() | ||
122 | } | ||
123 | |||
124 | pub fn add_trait_assoc_items_to_impl( | ||
125 | sema: &hir::Semantics<ide_db::RootDatabase>, | ||
126 | items: Vec<ast::AssocItem>, | ||
127 | trait_: hir::Trait, | ||
128 | impl_def: ast::Impl, | ||
129 | target_scope: hir::SemanticsScope, | ||
130 | ) -> (ast::Impl, ast::AssocItem) { | ||
131 | let impl_item_list = impl_def.assoc_item_list().unwrap_or_else(make::assoc_item_list); | ||
132 | |||
133 | let n_existing_items = impl_item_list.assoc_items().count(); | ||
134 | let source_scope = sema.scope_for_def(trait_); | ||
135 | let ast_transform = QualifyPaths::new(&target_scope, &source_scope) | ||
136 | .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def.clone())); | ||
137 | |||
138 | let items = items | ||
139 | .into_iter() | ||
140 | .map(|it| ast_transform::apply(&*ast_transform, it)) | ||
141 | .map(|it| match it { | ||
142 | ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)), | ||
143 | ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()), | ||
144 | _ => it, | ||
145 | }) | ||
146 | .map(|it| edit::remove_attrs_and_docs(&it)); | ||
147 | |||
148 | let new_impl_item_list = impl_item_list.append_items(items); | ||
149 | let new_impl_def = impl_def.with_assoc_item_list(new_impl_item_list); | ||
150 | let first_new_item = | ||
151 | new_impl_def.assoc_item_list().unwrap().assoc_items().nth(n_existing_items).unwrap(); | ||
152 | return (new_impl_def, first_new_item); | ||
153 | |||
154 | fn add_body(fn_def: ast::Fn) -> ast::Fn { | ||
155 | match fn_def.body() { | ||
156 | Some(_) => fn_def, | ||
157 | None => { | ||
158 | let body = | ||
159 | make::block_expr(None, Some(make::expr_todo())).indent(edit::IndentLevel(1)); | ||
160 | fn_def.with_body(body) | ||
161 | } | ||
162 | } | ||
163 | } | ||
164 | } | ||
165 | |||
80 | #[derive(Clone, Copy, Debug)] | 166 | #[derive(Clone, Copy, Debug)] |
81 | pub(crate) enum Cursor<'a> { | 167 | pub(crate) enum Cursor<'a> { |
82 | Replace(&'a SyntaxNode), | 168 | Replace(&'a SyntaxNode), |
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs index 348f017bd..7fbda7a6b 100644 --- a/crates/completion/src/completions/postfix.rs +++ b/crates/completion/src/completions/postfix.rs | |||
@@ -184,6 +184,16 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) { | |||
184 | ctx, | 184 | ctx, |
185 | cap, | 185 | cap, |
186 | &dot_receiver, | 186 | &dot_receiver, |
187 | "some", | ||
188 | "Some(expr)", | ||
189 | &format!("Some({})", receiver_text), | ||
190 | ) | ||
191 | .add_to(acc); | ||
192 | |||
193 | postfix_snippet( | ||
194 | ctx, | ||
195 | cap, | ||
196 | &dot_receiver, | ||
187 | "dbg", | 197 | "dbg", |
188 | "dbg!(expr)", | 198 | "dbg!(expr)", |
189 | &format!("dbg!({})", receiver_text), | 199 | &format!("dbg!({})", receiver_text), |
@@ -291,6 +301,7 @@ fn main() { | |||
291 | sn ok Ok(expr) | 301 | sn ok Ok(expr) |
292 | sn ref &expr | 302 | sn ref &expr |
293 | sn refm &mut expr | 303 | sn refm &mut expr |
304 | sn some Some(expr) | ||
294 | sn while while expr {} | 305 | sn while while expr {} |
295 | "#]], | 306 | "#]], |
296 | ); | 307 | ); |
@@ -314,6 +325,7 @@ fn main() { | |||
314 | sn ok Ok(expr) | 325 | sn ok Ok(expr) |
315 | sn ref &expr | 326 | sn ref &expr |
316 | sn refm &mut expr | 327 | sn refm &mut expr |
328 | sn some Some(expr) | ||
317 | "#]], | 329 | "#]], |
318 | ) | 330 | ) |
319 | } | 331 | } |
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs index 1deaa90f2..cd7958746 100644 --- a/crates/hir_def/src/body/lower.rs +++ b/crates/hir_def/src/body/lower.rs | |||
@@ -953,18 +953,19 @@ impl From<ast::BinOp> for BinaryOp { | |||
953 | impl From<ast::LiteralKind> for Literal { | 953 | impl From<ast::LiteralKind> for Literal { |
954 | fn from(ast_lit_kind: ast::LiteralKind) -> Self { | 954 | fn from(ast_lit_kind: ast::LiteralKind) -> Self { |
955 | match ast_lit_kind { | 955 | match ast_lit_kind { |
956 | LiteralKind::IntNumber { suffix } => { | 956 | LiteralKind::IntNumber(lit) => { |
957 | let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it)); | 957 | if let Some(float_suffix) = lit.suffix().and_then(BuiltinFloat::from_suffix) { |
958 | 958 | return Literal::Float(Default::default(), Some(float_suffix)); | |
959 | Literal::Int(Default::default(), known_name) | 959 | } |
960 | let ty = lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it)); | ||
961 | Literal::Int(Default::default(), ty) | ||
960 | } | 962 | } |
961 | LiteralKind::FloatNumber { suffix } => { | 963 | LiteralKind::FloatNumber(lit) => { |
962 | let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it)); | 964 | let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it)); |
963 | 965 | Literal::Float(Default::default(), ty) | |
964 | Literal::Float(Default::default(), known_name) | ||
965 | } | 966 | } |
966 | LiteralKind::ByteString => Literal::ByteString(Default::default()), | 967 | LiteralKind::ByteString(_) => Literal::ByteString(Default::default()), |
967 | LiteralKind::String => Literal::String(Default::default()), | 968 | LiteralKind::String(_) => Literal::String(Default::default()), |
968 | LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)), | 969 | LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)), |
969 | LiteralKind::Bool(val) => Literal::Bool(val), | 970 | LiteralKind::Bool(val) => Literal::Bool(val), |
970 | LiteralKind::Char => Literal::Char(Default::default()), | 971 | LiteralKind::Char => Literal::Char(Default::default()), |
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs index 59b6644c3..386287518 100644 --- a/crates/hir_def/src/nameres/collector.rs +++ b/crates/hir_def/src/nameres/collector.rs | |||
@@ -1116,17 +1116,20 @@ impl ModCollector<'_, '_> { | |||
1116 | &self.item_tree[module.visibility], | 1116 | &self.item_tree[module.visibility], |
1117 | ); | 1117 | ); |
1118 | 1118 | ||
1119 | ModCollector { | 1119 | if let Some(mod_dir) = self.mod_dir.descend_into_definition(&module.name, path_attr) |
1120 | def_collector: &mut *self.def_collector, | 1120 | { |
1121 | macro_depth: self.macro_depth, | 1121 | ModCollector { |
1122 | module_id, | 1122 | def_collector: &mut *self.def_collector, |
1123 | file_id: self.file_id, | 1123 | macro_depth: self.macro_depth, |
1124 | item_tree: self.item_tree, | 1124 | module_id, |
1125 | mod_dir: self.mod_dir.descend_into_definition(&module.name, path_attr), | 1125 | file_id: self.file_id, |
1126 | } | 1126 | item_tree: self.item_tree, |
1127 | .collect(&*items); | 1127 | mod_dir, |
1128 | if is_macro_use { | 1128 | } |
1129 | self.import_all_legacy_macros(module_id); | 1129 | .collect(&*items); |
1130 | if is_macro_use { | ||
1131 | self.import_all_legacy_macros(module_id); | ||
1132 | } | ||
1130 | } | 1133 | } |
1131 | } | 1134 | } |
1132 | // out of line module, resolve, parse and recurse | 1135 | // out of line module, resolve, parse and recurse |
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs index e8389b484..c0c789cae 100644 --- a/crates/hir_def/src/nameres/mod_resolution.rs +++ b/crates/hir_def/src/nameres/mod_resolution.rs | |||
@@ -2,9 +2,12 @@ | |||
2 | use base_db::FileId; | 2 | use base_db::FileId; |
3 | use hir_expand::name::Name; | 3 | use hir_expand::name::Name; |
4 | use syntax::SmolStr; | 4 | use syntax::SmolStr; |
5 | use test_utils::mark; | ||
5 | 6 | ||
6 | use crate::{db::DefDatabase, HirFileId}; | 7 | use crate::{db::DefDatabase, HirFileId}; |
7 | 8 | ||
9 | const MOD_DEPTH_LIMIT: u32 = 32; | ||
10 | |||
8 | #[derive(Clone, Debug)] | 11 | #[derive(Clone, Debug)] |
9 | pub(super) struct ModDir { | 12 | pub(super) struct ModDir { |
10 | /// `` for `mod.rs`, `lib.rs` | 13 | /// `` for `mod.rs`, `lib.rs` |
@@ -14,18 +17,28 @@ pub(super) struct ModDir { | |||
14 | dir_path: DirPath, | 17 | dir_path: DirPath, |
15 | /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/` | 18 | /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/` |
16 | root_non_dir_owner: bool, | 19 | root_non_dir_owner: bool, |
20 | depth: u32, | ||
17 | } | 21 | } |
18 | 22 | ||
19 | impl ModDir { | 23 | impl ModDir { |
20 | pub(super) fn root() -> ModDir { | 24 | pub(super) fn root() -> ModDir { |
21 | ModDir { dir_path: DirPath::empty(), root_non_dir_owner: false } | 25 | ModDir { dir_path: DirPath::empty(), root_non_dir_owner: false, depth: 0 } |
26 | } | ||
27 | fn child(&self, dir_path: DirPath, root_non_dir_owner: bool) -> Option<ModDir> { | ||
28 | let depth = self.depth + 1; | ||
29 | if depth > MOD_DEPTH_LIMIT { | ||
30 | log::error!("MOD_DEPTH_LIMIT exceeded"); | ||
31 | mark::hit!(circular_mods); | ||
32 | return None; | ||
33 | } | ||
34 | Some(ModDir { dir_path, root_non_dir_owner, depth }) | ||
22 | } | 35 | } |
23 | 36 | ||
24 | pub(super) fn descend_into_definition( | 37 | pub(super) fn descend_into_definition( |
25 | &self, | 38 | &self, |
26 | name: &Name, | 39 | name: &Name, |
27 | attr_path: Option<&SmolStr>, | 40 | attr_path: Option<&SmolStr>, |
28 | ) -> ModDir { | 41 | ) -> Option<ModDir> { |
29 | let path = match attr_path.map(|it| it.as_str()) { | 42 | let path = match attr_path.map(|it| it.as_str()) { |
30 | None => { | 43 | None => { |
31 | let mut path = self.dir_path.clone(); | 44 | let mut path = self.dir_path.clone(); |
@@ -40,7 +53,7 @@ impl ModDir { | |||
40 | DirPath::new(path) | 53 | DirPath::new(path) |
41 | } | 54 | } |
42 | }; | 55 | }; |
43 | ModDir { dir_path: path, root_non_dir_owner: false } | 56 | self.child(path, false) |
44 | } | 57 | } |
45 | 58 | ||
46 | pub(super) fn resolve_declaration( | 59 | pub(super) fn resolve_declaration( |
@@ -72,7 +85,9 @@ impl ModDir { | |||
72 | } else { | 85 | } else { |
73 | (DirPath::new(format!("{}/", name)), true) | 86 | (DirPath::new(format!("{}/", name)), true) |
74 | }; | 87 | }; |
75 | return Ok((file_id, is_mod_rs, ModDir { dir_path, root_non_dir_owner })); | 88 | if let Some(mod_dir) = self.child(dir_path, root_non_dir_owner) { |
89 | return Ok((file_id, is_mod_rs, mod_dir)); | ||
90 | } | ||
76 | } | 91 | } |
77 | } | 92 | } |
78 | Err(candidate_files.remove(0)) | 93 | Err(candidate_files.remove(0)) |
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs index 9c19bf572..a4d1fb8f3 100644 --- a/crates/hir_def/src/nameres/tests.rs +++ b/crates/hir_def/src/nameres/tests.rs | |||
@@ -20,9 +20,8 @@ fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> { | |||
20 | } | 20 | } |
21 | 21 | ||
22 | fn check(ra_fixture: &str, expect: Expect) { | 22 | fn check(ra_fixture: &str, expect: Expect) { |
23 | let db = TestDB::with_files(ra_fixture); | 23 | let def_map = compute_crate_def_map(ra_fixture); |
24 | let krate = db.crate_graph().iter().next().unwrap(); | 24 | let actual = def_map.dump(); |
25 | let actual = db.crate_def_map(krate).dump(); | ||
26 | expect.assert_eq(&actual); | 25 | expect.assert_eq(&actual); |
27 | } | 26 | } |
28 | 27 | ||
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs index ec9d589a3..ba295fd9e 100644 --- a/crates/hir_def/src/nameres/tests/mod_resolution.rs +++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs | |||
@@ -771,3 +771,30 @@ struct X; | |||
771 | "#]], | 771 | "#]], |
772 | ); | 772 | ); |
773 | } | 773 | } |
774 | |||
775 | #[test] | ||
776 | fn circular_mods() { | ||
777 | mark::check!(circular_mods); | ||
778 | compute_crate_def_map( | ||
779 | r#" | ||
780 | //- /lib.rs | ||
781 | mod foo; | ||
782 | //- /foo.rs | ||
783 | #[path = "./foo.rs"] | ||
784 | mod foo; | ||
785 | "#, | ||
786 | ); | ||
787 | |||
788 | compute_crate_def_map( | ||
789 | r#" | ||
790 | //- /lib.rs | ||
791 | mod foo; | ||
792 | //- /foo.rs | ||
793 | #[path = "./bar.rs"] | ||
794 | mod bar; | ||
795 | //- /bar.rs | ||
796 | #[path = "./foo.rs"] | ||
797 | mod foo; | ||
798 | "#, | ||
799 | ); | ||
800 | } | ||
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs index 86918b626..aebbfc4df 100644 --- a/crates/hir_expand/src/builtin_macro.rs +++ b/crates/hir_expand/src/builtin_macro.rs | |||
@@ -8,7 +8,7 @@ use base_db::FileId; | |||
8 | use either::Either; | 8 | use either::Either; |
9 | use mbe::parse_to_token_tree; | 9 | use mbe::parse_to_token_tree; |
10 | use parser::FragmentKind; | 10 | use parser::FragmentKind; |
11 | use syntax::ast::{self, AstToken, HasStringValue}; | 11 | use syntax::ast::{self, AstToken}; |
12 | 12 | ||
13 | macro_rules! register_builtin { | 13 | macro_rules! register_builtin { |
14 | ( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),* ) => { | 14 | ( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),* ) => { |
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs index 02e17ba43..d275dd75b 100644 --- a/crates/ide/src/diagnostics/fixes.rs +++ b/crates/ide/src/diagnostics/fixes.rs | |||
@@ -157,7 +157,8 @@ fn missing_record_expr_field_fix( | |||
157 | return None; | 157 | return None; |
158 | } | 158 | } |
159 | let new_field = make::record_field( | 159 | let new_field = make::record_field( |
160 | record_expr_field.field_name()?, | 160 | None, |
161 | make::name(record_expr_field.field_name()?.text()), | ||
161 | make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?), | 162 | make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?), |
162 | ); | 163 | ); |
163 | 164 | ||
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs index 3ee0af8ad..0971f7701 100644 --- a/crates/ide/src/extend_selection.rs +++ b/crates/ide/src/extend_selection.rs | |||
@@ -35,7 +35,7 @@ fn try_extend_selection( | |||
35 | ) -> Option<TextRange> { | 35 | ) -> Option<TextRange> { |
36 | let range = frange.range; | 36 | let range = frange.range; |
37 | 37 | ||
38 | let string_kinds = [COMMENT, STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING]; | 38 | let string_kinds = [COMMENT, STRING, BYTE_STRING]; |
39 | let list_kinds = [ | 39 | let list_kinds = [ |
40 | RECORD_PAT_FIELD_LIST, | 40 | RECORD_PAT_FIELD_LIST, |
41 | MATCH_ARM_LIST, | 41 | MATCH_ARM_LIST, |
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs index efcc8ecfe..05bafe9c8 100644 --- a/crates/ide/src/syntax_highlighting.rs +++ b/crates/ide/src/syntax_highlighting.rs | |||
@@ -179,10 +179,12 @@ pub(crate) fn highlight( | |||
179 | element.clone() | 179 | element.clone() |
180 | }; | 180 | }; |
181 | 181 | ||
182 | if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) { | 182 | if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) { |
183 | let expanded = element_to_highlight.as_token().unwrap().clone(); | 183 | if token.is_raw() { |
184 | if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() { | 184 | let expanded = element_to_highlight.as_token().unwrap().clone(); |
185 | continue; | 185 | if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() { |
186 | continue; | ||
187 | } | ||
186 | } | 188 | } |
187 | } | 189 | } |
188 | 190 | ||
@@ -214,10 +216,6 @@ pub(crate) fn highlight( | |||
214 | } | 216 | } |
215 | stack.pop_and_inject(None); | 217 | stack.pop_and_inject(None); |
216 | } | 218 | } |
217 | } else if let Some(string) = | ||
218 | element_to_highlight.as_token().cloned().and_then(ast::RawString::cast) | ||
219 | { | ||
220 | format_string_highlighter.highlight_format_string(&mut stack, &string, range); | ||
221 | } | 219 | } |
222 | } | 220 | } |
223 | } | 221 | } |
@@ -532,7 +530,7 @@ fn highlight_element( | |||
532 | None => h.into(), | 530 | None => h.into(), |
533 | } | 531 | } |
534 | } | 532 | } |
535 | STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(), | 533 | STRING | BYTE_STRING => HighlightTag::StringLiteral.into(), |
536 | ATTR => HighlightTag::Attribute.into(), | 534 | ATTR => HighlightTag::Attribute.into(), |
537 | INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(), | 535 | INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(), |
538 | BYTE => HighlightTag::ByteLiteral.into(), | 536 | BYTE => HighlightTag::ByteLiteral.into(), |
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs index 71bde24f0..42f27df5d 100644 --- a/crates/ide/src/syntax_highlighting/format.rs +++ b/crates/ide/src/syntax_highlighting/format.rs | |||
@@ -29,9 +29,7 @@ impl FormatStringHighlighter { | |||
29 | .children_with_tokens() | 29 | .children_with_tokens() |
30 | .filter(|t| t.kind() != SyntaxKind::WHITESPACE) | 30 | .filter(|t| t.kind() != SyntaxKind::WHITESPACE) |
31 | .nth(1) | 31 | .nth(1) |
32 | .filter(|e| { | 32 | .filter(|e| ast::String::can_cast(e.kind())) |
33 | ast::String::can_cast(e.kind()) || ast::RawString::can_cast(e.kind()) | ||
34 | }) | ||
35 | } | 33 | } |
36 | _ => {} | 34 | _ => {} |
37 | } | 35 | } |
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs index 59a74bc02..e97d1be1a 100644 --- a/crates/ide/src/syntax_highlighting/injection.rs +++ b/crates/ide/src/syntax_highlighting/injection.rs | |||
@@ -2,7 +2,6 @@ | |||
2 | 2 | ||
3 | use std::{collections::BTreeMap, convert::TryFrom}; | 3 | use std::{collections::BTreeMap, convert::TryFrom}; |
4 | 4 | ||
5 | use ast::{HasQuotes, HasStringValue}; | ||
6 | use hir::Semantics; | 5 | use hir::Semantics; |
7 | use ide_db::call_info::ActiveParameter; | 6 | use ide_db::call_info::ActiveParameter; |
8 | use itertools::Itertools; | 7 | use itertools::Itertools; |
@@ -15,7 +14,7 @@ use super::HighlightedRangeStack; | |||
15 | pub(super) fn highlight_injection( | 14 | pub(super) fn highlight_injection( |
16 | acc: &mut HighlightedRangeStack, | 15 | acc: &mut HighlightedRangeStack, |
17 | sema: &Semantics<RootDatabase>, | 16 | sema: &Semantics<RootDatabase>, |
18 | literal: ast::RawString, | 17 | literal: ast::String, |
19 | expanded: SyntaxToken, | 18 | expanded: SyntaxToken, |
20 | ) -> Option<()> { | 19 | ) -> Option<()> { |
21 | let active_parameter = ActiveParameter::at_token(&sema, expanded)?; | 20 | let active_parameter = ActiveParameter::at_token(&sema, expanded)?; |
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs index 7941610d6..6dd05c05d 100644 --- a/crates/ide/src/syntax_tree.rs +++ b/crates/ide/src/syntax_tree.rs | |||
@@ -1,9 +1,7 @@ | |||
1 | use ide_db::base_db::{FileId, SourceDatabase}; | 1 | use ide_db::base_db::{FileId, SourceDatabase}; |
2 | use ide_db::RootDatabase; | 2 | use ide_db::RootDatabase; |
3 | use syntax::{ | 3 | use syntax::{ |
4 | algo, AstNode, NodeOrToken, SourceFile, | 4 | algo, AstNode, NodeOrToken, SourceFile, SyntaxKind::STRING, SyntaxToken, TextRange, TextSize, |
5 | SyntaxKind::{RAW_STRING, STRING}, | ||
6 | SyntaxToken, TextRange, TextSize, | ||
7 | }; | 5 | }; |
8 | 6 | ||
9 | // Feature: Show Syntax Tree | 7 | // Feature: Show Syntax Tree |
@@ -46,7 +44,7 @@ fn syntax_tree_for_string(token: &SyntaxToken, text_range: TextRange) -> Option< | |||
46 | // we'll attempt parsing it as rust syntax | 44 | // we'll attempt parsing it as rust syntax |
47 | // to provide the syntax tree of the contents of the string | 45 | // to provide the syntax tree of the contents of the string |
48 | match token.kind() { | 46 | match token.kind() { |
49 | STRING | RAW_STRING => syntax_tree_for_token(token, text_range), | 47 | STRING => syntax_tree_for_token(token, text_range), |
50 | _ => None, | 48 | _ => None, |
51 | } | 49 | } |
52 | } | 50 | } |
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs index 4ab206a83..116b991a8 100644 --- a/crates/parser/src/grammar.rs +++ b/crates/parser/src/grammar.rs | |||
@@ -236,10 +236,7 @@ fn abi(p: &mut Parser) { | |||
236 | assert!(p.at(T![extern])); | 236 | assert!(p.at(T![extern])); |
237 | let abi = p.start(); | 237 | let abi = p.start(); |
238 | p.bump(T![extern]); | 238 | p.bump(T![extern]); |
239 | match p.current() { | 239 | p.eat(STRING); |
240 | STRING | RAW_STRING => p.bump_any(), | ||
241 | _ => (), | ||
242 | } | ||
243 | abi.complete(p, ABI); | 240 | abi.complete(p, ABI); |
244 | } | 241 | } |
245 | 242 | ||
diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs index 66a92a4e1..31f42f161 100644 --- a/crates/parser/src/grammar/expressions/atom.rs +++ b/crates/parser/src/grammar/expressions/atom.rs | |||
@@ -15,18 +15,8 @@ use super::*; | |||
15 | // let _ = b"e"; | 15 | // let _ = b"e"; |
16 | // let _ = br"f"; | 16 | // let _ = br"f"; |
17 | // } | 17 | // } |
18 | pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[ | 18 | pub(crate) const LITERAL_FIRST: TokenSet = |
19 | TRUE_KW, | 19 | TokenSet::new(&[TRUE_KW, FALSE_KW, INT_NUMBER, FLOAT_NUMBER, BYTE, CHAR, STRING, BYTE_STRING]); |
20 | FALSE_KW, | ||
21 | INT_NUMBER, | ||
22 | FLOAT_NUMBER, | ||
23 | BYTE, | ||
24 | CHAR, | ||
25 | STRING, | ||
26 | RAW_STRING, | ||
27 | BYTE_STRING, | ||
28 | RAW_BYTE_STRING, | ||
29 | ]); | ||
30 | 20 | ||
31 | pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> { | 21 | pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> { |
32 | if !p.at_ts(LITERAL_FIRST) { | 22 | if !p.at_ts(LITERAL_FIRST) { |
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs index 22810e6fb..780bc470a 100644 --- a/crates/parser/src/grammar/items.rs +++ b/crates/parser/src/grammar/items.rs | |||
@@ -239,9 +239,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> { | |||
239 | T![static] => consts::static_(p, m), | 239 | T![static] => consts::static_(p, m), |
240 | // test extern_block | 240 | // test extern_block |
241 | // extern {} | 241 | // extern {} |
242 | T![extern] | 242 | T![extern] if la == T!['{'] || (la == STRING && p.nth(2) == T!['{']) => { |
243 | if la == T!['{'] || ((la == STRING || la == RAW_STRING) && p.nth(2) == T!['{']) => | ||
244 | { | ||
245 | abi(p); | 243 | abi(p); |
246 | extern_item_list(p); | 244 | extern_item_list(p); |
247 | m.complete(p, EXTERN_BLOCK); | 245 | m.complete(p, EXTERN_BLOCK); |
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs index 935bd2c5e..8bc6688f3 100644 --- a/crates/parser/src/syntax_kind/generated.rs +++ b/crates/parser/src/syntax_kind/generated.rs | |||
@@ -111,9 +111,7 @@ pub enum SyntaxKind { | |||
111 | CHAR, | 111 | CHAR, |
112 | BYTE, | 112 | BYTE, |
113 | STRING, | 113 | STRING, |
114 | RAW_STRING, | ||
115 | BYTE_STRING, | 114 | BYTE_STRING, |
116 | RAW_BYTE_STRING, | ||
117 | ERROR, | 115 | ERROR, |
118 | IDENT, | 116 | IDENT, |
119 | WHITESPACE, | 117 | WHITESPACE, |
@@ -277,8 +275,7 @@ impl SyntaxKind { | |||
277 | } | 275 | } |
278 | pub fn is_literal(self) -> bool { | 276 | pub fn is_literal(self) -> bool { |
279 | match self { | 277 | match self { |
280 | INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE | STRING | RAW_STRING | BYTE_STRING | 278 | INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE | STRING | BYTE_STRING => true, |
281 | | RAW_BYTE_STRING => true, | ||
282 | _ => false, | 279 | _ => false, |
283 | } | 280 | } |
284 | } | 281 | } |
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs index 3fe494729..b0e8863f6 100644 --- a/crates/project_model/src/sysroot.rs +++ b/crates/project_model/src/sysroot.rs | |||
@@ -114,8 +114,12 @@ fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> { | |||
114 | if let Ok(path) = env::var("RUST_SRC_PATH") { | 114 | if let Ok(path) = env::var("RUST_SRC_PATH") { |
115 | let path = AbsPathBuf::try_from(path.as_str()) | 115 | let path = AbsPathBuf::try_from(path.as_str()) |
116 | .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?; | 116 | .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?; |
117 | log::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display()); | 117 | let core = path.join("core"); |
118 | return Ok(path); | 118 | if core.exists() { |
119 | log::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display()); | ||
120 | return Ok(path); | ||
121 | } | ||
122 | log::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core); | ||
119 | } | 123 | } |
120 | 124 | ||
121 | let sysroot_path = { | 125 | let sysroot_path = { |
diff --git a/crates/syntax/src/ast.rs b/crates/syntax/src/ast.rs index a16ac6a7c..8a0e3d27b 100644 --- a/crates/syntax/src/ast.rs +++ b/crates/syntax/src/ast.rs | |||
@@ -16,7 +16,7 @@ use crate::{ | |||
16 | }; | 16 | }; |
17 | 17 | ||
18 | pub use self::{ | 18 | pub use self::{ |
19 | expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, Radix, RangeOp}, | 19 | expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp}, |
20 | generated::{nodes::*, tokens::*}, | 20 | generated::{nodes::*, tokens::*}, |
21 | node_ext::{ | 21 | node_ext::{ |
22 | AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents, | 22 | AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents, |
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs index 3aff01e83..9253c97d0 100644 --- a/crates/syntax/src/ast/expr_ext.rs +++ b/crates/syntax/src/ast/expr_ext.rs | |||
@@ -2,7 +2,7 @@ | |||
2 | 2 | ||
3 | use crate::{ | 3 | use crate::{ |
4 | ast::{self, support, AstChildren, AstNode}, | 4 | ast::{self, support, AstChildren, AstNode}, |
5 | SmolStr, | 5 | AstToken, |
6 | SyntaxKind::*, | 6 | SyntaxKind::*, |
7 | SyntaxToken, T, | 7 | SyntaxToken, T, |
8 | }; | 8 | }; |
@@ -298,12 +298,12 @@ impl ast::ArrayExpr { | |||
298 | 298 | ||
299 | #[derive(Clone, Debug, PartialEq, Eq, Hash)] | 299 | #[derive(Clone, Debug, PartialEq, Eq, Hash)] |
300 | pub enum LiteralKind { | 300 | pub enum LiteralKind { |
301 | String, | 301 | String(ast::String), |
302 | ByteString, | 302 | ByteString(ast::ByteString), |
303 | IntNumber(ast::IntNumber), | ||
304 | FloatNumber(ast::FloatNumber), | ||
303 | Char, | 305 | Char, |
304 | Byte, | 306 | Byte, |
305 | IntNumber { suffix: Option<SmolStr> }, | ||
306 | FloatNumber { suffix: Option<SmolStr> }, | ||
307 | Bool(bool), | 307 | Bool(bool), |
308 | } | 308 | } |
309 | 309 | ||
@@ -315,114 +315,30 @@ impl ast::Literal { | |||
315 | .and_then(|e| e.into_token()) | 315 | .and_then(|e| e.into_token()) |
316 | .unwrap() | 316 | .unwrap() |
317 | } | 317 | } |
318 | |||
319 | fn find_suffix(text: &str, possible_suffixes: &[&str]) -> Option<SmolStr> { | ||
320 | possible_suffixes | ||
321 | .iter() | ||
322 | .find(|&suffix| text.ends_with(suffix)) | ||
323 | .map(|&suffix| SmolStr::new(suffix)) | ||
324 | } | ||
325 | |||
326 | pub fn kind(&self) -> LiteralKind { | 318 | pub fn kind(&self) -> LiteralKind { |
327 | const INT_SUFFIXES: [&str; 12] = [ | ||
328 | "u64", "u32", "u16", "u8", "usize", "isize", "i64", "i32", "i16", "i8", "u128", "i128", | ||
329 | ]; | ||
330 | const FLOAT_SUFFIXES: [&str; 2] = ["f32", "f64"]; | ||
331 | |||
332 | let token = self.token(); | 319 | let token = self.token(); |
333 | 320 | ||
321 | if let Some(t) = ast::IntNumber::cast(token.clone()) { | ||
322 | return LiteralKind::IntNumber(t); | ||
323 | } | ||
324 | if let Some(t) = ast::FloatNumber::cast(token.clone()) { | ||
325 | return LiteralKind::FloatNumber(t); | ||
326 | } | ||
327 | if let Some(t) = ast::String::cast(token.clone()) { | ||
328 | return LiteralKind::String(t); | ||
329 | } | ||
330 | if let Some(t) = ast::ByteString::cast(token.clone()) { | ||
331 | return LiteralKind::ByteString(t); | ||
332 | } | ||
333 | |||
334 | match token.kind() { | 334 | match token.kind() { |
335 | INT_NUMBER => { | ||
336 | // FYI: there was a bug here previously, thus the if statement below is necessary. | ||
337 | // The lexer treats e.g. `1f64` as an integer literal. See | ||
338 | // https://github.com/rust-analyzer/rust-analyzer/issues/1592 | ||
339 | // and the comments on the linked PR. | ||
340 | |||
341 | let text = token.text(); | ||
342 | if let suffix @ Some(_) = Self::find_suffix(&text, &FLOAT_SUFFIXES) { | ||
343 | LiteralKind::FloatNumber { suffix } | ||
344 | } else { | ||
345 | LiteralKind::IntNumber { suffix: Self::find_suffix(&text, &INT_SUFFIXES) } | ||
346 | } | ||
347 | } | ||
348 | FLOAT_NUMBER => { | ||
349 | let text = token.text(); | ||
350 | LiteralKind::FloatNumber { suffix: Self::find_suffix(&text, &FLOAT_SUFFIXES) } | ||
351 | } | ||
352 | STRING | RAW_STRING => LiteralKind::String, | ||
353 | T![true] => LiteralKind::Bool(true), | 335 | T![true] => LiteralKind::Bool(true), |
354 | T![false] => LiteralKind::Bool(false), | 336 | T![false] => LiteralKind::Bool(false), |
355 | BYTE_STRING | RAW_BYTE_STRING => LiteralKind::ByteString, | ||
356 | CHAR => LiteralKind::Char, | 337 | CHAR => LiteralKind::Char, |
357 | BYTE => LiteralKind::Byte, | 338 | BYTE => LiteralKind::Byte, |
358 | _ => unreachable!(), | 339 | _ => unreachable!(), |
359 | } | 340 | } |
360 | } | 341 | } |
361 | |||
362 | // FIXME: should probably introduce string token type? | ||
363 | // https://github.com/rust-analyzer/rust-analyzer/issues/6308 | ||
364 | pub fn int_value(&self) -> Option<(Radix, u128)> { | ||
365 | let suffix = match self.kind() { | ||
366 | LiteralKind::IntNumber { suffix } => suffix, | ||
367 | _ => return None, | ||
368 | }; | ||
369 | |||
370 | let token = self.token(); | ||
371 | let mut text = token.text().as_str(); | ||
372 | text = &text[..text.len() - suffix.map_or(0, |it| it.len())]; | ||
373 | |||
374 | let buf; | ||
375 | if text.contains("_") { | ||
376 | buf = text.replace('_', ""); | ||
377 | text = buf.as_str(); | ||
378 | }; | ||
379 | |||
380 | let radix = Radix::identify(text)?; | ||
381 | let digits = &text[radix.prefix_len()..]; | ||
382 | let value = u128::from_str_radix(digits, radix as u32).ok()?; | ||
383 | Some((radix, value)) | ||
384 | } | ||
385 | } | ||
386 | |||
387 | #[derive(Debug, PartialEq, Eq, Copy, Clone)] | ||
388 | pub enum Radix { | ||
389 | Binary = 2, | ||
390 | Octal = 8, | ||
391 | Decimal = 10, | ||
392 | Hexadecimal = 16, | ||
393 | } | ||
394 | |||
395 | impl Radix { | ||
396 | pub const ALL: &'static [Radix] = | ||
397 | &[Radix::Binary, Radix::Octal, Radix::Decimal, Radix::Hexadecimal]; | ||
398 | |||
399 | fn identify(literal_text: &str) -> Option<Self> { | ||
400 | // We cannot express a literal in anything other than decimal in under 3 characters, so we return here if possible. | ||
401 | if literal_text.len() < 3 && literal_text.chars().all(|c| c.is_digit(10)) { | ||
402 | return Some(Self::Decimal); | ||
403 | } | ||
404 | |||
405 | let res = match &literal_text[..2] { | ||
406 | "0b" => Radix::Binary, | ||
407 | "0o" => Radix::Octal, | ||
408 | "0x" => Radix::Hexadecimal, | ||
409 | _ => Radix::Decimal, | ||
410 | }; | ||
411 | |||
412 | // Checks that all characters after the base prefix are all valid digits for that base. | ||
413 | if literal_text[res.prefix_len()..].chars().all(|c| c.is_digit(res as u32)) { | ||
414 | Some(res) | ||
415 | } else { | ||
416 | None | ||
417 | } | ||
418 | } | ||
419 | |||
420 | const fn prefix_len(&self) -> usize { | ||
421 | match self { | ||
422 | Self::Decimal => 0, | ||
423 | _ => 2, | ||
424 | } | ||
425 | } | ||
426 | } | 342 | } |
427 | 343 | ||
428 | #[derive(Debug, Clone, PartialEq, Eq)] | 344 | #[derive(Debug, Clone, PartialEq, Eq)] |
diff --git a/crates/syntax/src/ast/generated/tokens.rs b/crates/syntax/src/ast/generated/tokens.rs index abadd0b61..728b72cd7 100644 --- a/crates/syntax/src/ast/generated/tokens.rs +++ b/crates/syntax/src/ast/generated/tokens.rs | |||
@@ -70,16 +70,58 @@ impl AstToken for String { | |||
70 | } | 70 | } |
71 | 71 | ||
72 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | 72 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
73 | pub struct RawString { | 73 | pub struct ByteString { |
74 | pub(crate) syntax: SyntaxToken, | 74 | pub(crate) syntax: SyntaxToken, |
75 | } | 75 | } |
76 | impl std::fmt::Display for RawString { | 76 | impl std::fmt::Display for ByteString { |
77 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { | 77 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
78 | std::fmt::Display::fmt(&self.syntax, f) | 78 | std::fmt::Display::fmt(&self.syntax, f) |
79 | } | 79 | } |
80 | } | 80 | } |
81 | impl AstToken for RawString { | 81 | impl AstToken for ByteString { |
82 | fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_STRING } | 82 | fn can_cast(kind: SyntaxKind) -> bool { kind == BYTE_STRING } |
83 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
84 | if Self::can_cast(syntax.kind()) { | ||
85 | Some(Self { syntax }) | ||
86 | } else { | ||
87 | None | ||
88 | } | ||
89 | } | ||
90 | fn syntax(&self) -> &SyntaxToken { &self.syntax } | ||
91 | } | ||
92 | |||
93 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
94 | pub struct IntNumber { | ||
95 | pub(crate) syntax: SyntaxToken, | ||
96 | } | ||
97 | impl std::fmt::Display for IntNumber { | ||
98 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { | ||
99 | std::fmt::Display::fmt(&self.syntax, f) | ||
100 | } | ||
101 | } | ||
102 | impl AstToken for IntNumber { | ||
103 | fn can_cast(kind: SyntaxKind) -> bool { kind == INT_NUMBER } | ||
104 | fn cast(syntax: SyntaxToken) -> Option<Self> { | ||
105 | if Self::can_cast(syntax.kind()) { | ||
106 | Some(Self { syntax }) | ||
107 | } else { | ||
108 | None | ||
109 | } | ||
110 | } | ||
111 | fn syntax(&self) -> &SyntaxToken { &self.syntax } | ||
112 | } | ||
113 | |||
114 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | ||
115 | pub struct FloatNumber { | ||
116 | pub(crate) syntax: SyntaxToken, | ||
117 | } | ||
118 | impl std::fmt::Display for FloatNumber { | ||
119 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { | ||
120 | std::fmt::Display::fmt(&self.syntax, f) | ||
121 | } | ||
122 | } | ||
123 | impl AstToken for FloatNumber { | ||
124 | fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER } | ||
83 | fn cast(syntax: SyntaxToken) -> Option<Self> { | 125 | fn cast(syntax: SyntaxToken) -> Option<Self> { |
84 | if Self::can_cast(syntax.kind()) { | 126 | if Self::can_cast(syntax.kind()) { |
85 | Some(Self { syntax }) | 127 | Some(Self { syntax }) |
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs index 2cf436e7a..876659a2b 100644 --- a/crates/syntax/src/ast/make.rs +++ b/crates/syntax/src/ast/make.rs | |||
@@ -25,6 +25,10 @@ pub fn assoc_item_list() -> ast::AssocItemList { | |||
25 | ast_from_text("impl C for D {};") | 25 | ast_from_text("impl C for D {};") |
26 | } | 26 | } |
27 | 27 | ||
28 | pub fn impl_trait(trait_: ast::Path, ty: ast::Path) -> ast::Impl { | ||
29 | ast_from_text(&format!("impl {} for {} {{}}", trait_, ty)) | ||
30 | } | ||
31 | |||
28 | pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment { | 32 | pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment { |
29 | ast_from_text(&format!("use {};", name_ref)) | 33 | ast_from_text(&format!("use {};", name_ref)) |
30 | } | 34 | } |
@@ -110,8 +114,16 @@ pub fn record_expr_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::Re | |||
110 | } | 114 | } |
111 | } | 115 | } |
112 | 116 | ||
113 | pub fn record_field(name: ast::NameRef, ty: ast::Type) -> ast::RecordField { | 117 | pub fn record_field( |
114 | ast_from_text(&format!("struct S {{ {}: {}, }}", name, ty)) | 118 | visibility: Option<ast::Visibility>, |
119 | name: ast::Name, | ||
120 | ty: ast::Type, | ||
121 | ) -> ast::RecordField { | ||
122 | let visibility = match visibility { | ||
123 | None => String::new(), | ||
124 | Some(it) => format!("{} ", it), | ||
125 | }; | ||
126 | ast_from_text(&format!("struct S {{ {}{}: {}, }}", visibility, name, ty)) | ||
115 | } | 127 | } |
116 | 128 | ||
117 | pub fn block_expr( | 129 | pub fn block_expr( |
@@ -360,6 +372,13 @@ pub fn tuple_field_list(fields: impl IntoIterator<Item = ast::TupleField>) -> as | |||
360 | ast_from_text(&format!("struct f({});", fields)) | 372 | ast_from_text(&format!("struct f({});", fields)) |
361 | } | 373 | } |
362 | 374 | ||
375 | pub fn record_field_list( | ||
376 | fields: impl IntoIterator<Item = ast::RecordField>, | ||
377 | ) -> ast::RecordFieldList { | ||
378 | let fields = fields.into_iter().join(", "); | ||
379 | ast_from_text(&format!("struct f {{ {} }}", fields)) | ||
380 | } | ||
381 | |||
363 | pub fn tuple_field(visibility: Option<ast::Visibility>, ty: ast::Type) -> ast::TupleField { | 382 | pub fn tuple_field(visibility: Option<ast::Visibility>, ty: ast::Type) -> ast::TupleField { |
364 | let visibility = match visibility { | 383 | let visibility = match visibility { |
365 | None => String::new(), | 384 | None => String::new(), |
@@ -368,6 +387,14 @@ pub fn tuple_field(visibility: Option<ast::Visibility>, ty: ast::Type) -> ast::T | |||
368 | ast_from_text(&format!("struct f({}{});", visibility, ty)) | 387 | ast_from_text(&format!("struct f({}{});", visibility, ty)) |
369 | } | 388 | } |
370 | 389 | ||
390 | pub fn variant(name: ast::Name, field_list: Option<ast::FieldList>) -> ast::Variant { | ||
391 | let field_list = match field_list { | ||
392 | None => String::new(), | ||
393 | Some(it) => format!("{}", it), | ||
394 | }; | ||
395 | ast_from_text(&format!("enum f {{ {}{} }}", name, field_list)) | ||
396 | } | ||
397 | |||
371 | pub fn fn_( | 398 | pub fn fn_( |
372 | visibility: Option<ast::Visibility>, | 399 | visibility: Option<ast::Visibility>, |
373 | fn_name: ast::Name, | 400 | fn_name: ast::Name, |
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs index c5cd1c504..ce35ac01a 100644 --- a/crates/syntax/src/ast/node_ext.rs +++ b/crates/syntax/src/ast/node_ext.rs | |||
@@ -7,7 +7,7 @@ use itertools::Itertools; | |||
7 | use parser::SyntaxKind; | 7 | use parser::SyntaxKind; |
8 | 8 | ||
9 | use crate::{ | 9 | use crate::{ |
10 | ast::{self, support, token_ext::HasStringValue, AstNode, AstToken, NameOwner, SyntaxNode}, | 10 | ast::{self, support, AstNode, AstToken, NameOwner, SyntaxNode}, |
11 | SmolStr, SyntaxElement, SyntaxToken, T, | 11 | SmolStr, SyntaxElement, SyntaxToken, T, |
12 | }; | 12 | }; |
13 | 13 | ||
@@ -55,13 +55,7 @@ impl ast::Attr { | |||
55 | let key = self.simple_name()?; | 55 | let key = self.simple_name()?; |
56 | let value_token = lit.syntax().first_token()?; | 56 | let value_token = lit.syntax().first_token()?; |
57 | 57 | ||
58 | let value: SmolStr = if let Some(s) = ast::String::cast(value_token.clone()) { | 58 | let value: SmolStr = ast::String::cast(value_token.clone())?.value()?.into(); |
59 | s.value()?.into() | ||
60 | } else if let Some(s) = ast::RawString::cast(value_token) { | ||
61 | s.value()?.into() | ||
62 | } else { | ||
63 | return None; | ||
64 | }; | ||
65 | 59 | ||
66 | Some((key, value)) | 60 | Some((key, value)) |
67 | } | 61 | } |
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs index c5ef92733..e4e512f2e 100644 --- a/crates/syntax/src/ast/token_ext.rs +++ b/crates/syntax/src/ast/token_ext.rs | |||
@@ -8,11 +8,11 @@ use std::{ | |||
8 | use rustc_lexer::unescape::{unescape_literal, Mode}; | 8 | use rustc_lexer::unescape::{unescape_literal, Mode}; |
9 | 9 | ||
10 | use crate::{ | 10 | use crate::{ |
11 | ast::{AstToken, Comment, RawString, String, Whitespace}, | 11 | ast::{self, AstToken}, |
12 | TextRange, TextSize, | 12 | TextRange, TextSize, |
13 | }; | 13 | }; |
14 | 14 | ||
15 | impl Comment { | 15 | impl ast::Comment { |
16 | pub fn kind(&self) -> CommentKind { | 16 | pub fn kind(&self) -> CommentKind { |
17 | kind_by_prefix(self.text()) | 17 | kind_by_prefix(self.text()) |
18 | } | 18 | } |
@@ -80,7 +80,7 @@ fn kind_by_prefix(text: &str) -> CommentKind { | |||
80 | panic!("bad comment text: {:?}", text) | 80 | panic!("bad comment text: {:?}", text) |
81 | } | 81 | } |
82 | 82 | ||
83 | impl Whitespace { | 83 | impl ast::Whitespace { |
84 | pub fn spans_multiple_lines(&self) -> bool { | 84 | pub fn spans_multiple_lines(&self) -> bool { |
85 | let text = self.text(); | 85 | let text = self.text(); |
86 | text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n')) | 86 | text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n')) |
@@ -114,43 +114,28 @@ impl QuoteOffsets { | |||
114 | } | 114 | } |
115 | } | 115 | } |
116 | 116 | ||
117 | pub trait HasQuotes: AstToken { | 117 | impl ast::String { |
118 | fn quote_offsets(&self) -> Option<QuoteOffsets> { | 118 | pub fn is_raw(&self) -> bool { |
119 | let text = self.text().as_str(); | 119 | self.text().starts_with('r') |
120 | let offsets = QuoteOffsets::new(text)?; | ||
121 | let o = self.syntax().text_range().start(); | ||
122 | let offsets = QuoteOffsets { | ||
123 | quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o), | ||
124 | contents: offsets.contents + o, | ||
125 | }; | ||
126 | Some(offsets) | ||
127 | } | ||
128 | fn open_quote_text_range(&self) -> Option<TextRange> { | ||
129 | self.quote_offsets().map(|it| it.quotes.0) | ||
130 | } | 120 | } |
131 | 121 | pub fn map_range_up(&self, range: TextRange) -> Option<TextRange> { | |
132 | fn close_quote_text_range(&self) -> Option<TextRange> { | 122 | let contents_range = self.text_range_between_quotes()?; |
133 | self.quote_offsets().map(|it| it.quotes.1) | 123 | assert!(TextRange::up_to(contents_range.len()).contains_range(range)); |
124 | Some(range + contents_range.start()) | ||
134 | } | 125 | } |
135 | 126 | ||
136 | fn text_range_between_quotes(&self) -> Option<TextRange> { | 127 | pub fn value(&self) -> Option<Cow<'_, str>> { |
137 | self.quote_offsets().map(|it| it.contents) | 128 | if self.is_raw() { |
138 | } | 129 | let text = self.text().as_str(); |
139 | } | 130 | let text = |
140 | 131 | &text[self.text_range_between_quotes()? - self.syntax().text_range().start()]; | |
141 | impl HasQuotes for String {} | 132 | return Some(Cow::Borrowed(text)); |
142 | impl HasQuotes for RawString {} | 133 | } |
143 | |||
144 | pub trait HasStringValue: HasQuotes { | ||
145 | fn value(&self) -> Option<Cow<'_, str>>; | ||
146 | } | ||
147 | 134 | ||
148 | impl HasStringValue for String { | ||
149 | fn value(&self) -> Option<Cow<'_, str>> { | ||
150 | let text = self.text().as_str(); | 135 | let text = self.text().as_str(); |
151 | let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()]; | 136 | let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()]; |
152 | 137 | ||
153 | let mut buf = std::string::String::with_capacity(text.len()); | 138 | let mut buf = String::with_capacity(text.len()); |
154 | let mut has_error = false; | 139 | let mut has_error = false; |
155 | unescape_literal(text, Mode::Str, &mut |_, unescaped_char| match unescaped_char { | 140 | unescape_literal(text, Mode::Str, &mut |_, unescaped_char| match unescaped_char { |
156 | Ok(c) => buf.push(c), | 141 | Ok(c) => buf.push(c), |
@@ -164,21 +149,31 @@ impl HasStringValue for String { | |||
164 | let res = if buf == text { Cow::Borrowed(text) } else { Cow::Owned(buf) }; | 149 | let res = if buf == text { Cow::Borrowed(text) } else { Cow::Owned(buf) }; |
165 | Some(res) | 150 | Some(res) |
166 | } | 151 | } |
167 | } | ||
168 | 152 | ||
169 | impl HasStringValue for RawString { | 153 | pub fn quote_offsets(&self) -> Option<QuoteOffsets> { |
170 | fn value(&self) -> Option<Cow<'_, str>> { | ||
171 | let text = self.text().as_str(); | 154 | let text = self.text().as_str(); |
172 | let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()]; | 155 | let offsets = QuoteOffsets::new(text)?; |
173 | Some(Cow::Borrowed(text)) | 156 | let o = self.syntax().text_range().start(); |
157 | let offsets = QuoteOffsets { | ||
158 | quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o), | ||
159 | contents: offsets.contents + o, | ||
160 | }; | ||
161 | Some(offsets) | ||
162 | } | ||
163 | pub fn text_range_between_quotes(&self) -> Option<TextRange> { | ||
164 | self.quote_offsets().map(|it| it.contents) | ||
165 | } | ||
166 | pub fn open_quote_text_range(&self) -> Option<TextRange> { | ||
167 | self.quote_offsets().map(|it| it.quotes.0) | ||
168 | } | ||
169 | pub fn close_quote_text_range(&self) -> Option<TextRange> { | ||
170 | self.quote_offsets().map(|it| it.quotes.1) | ||
174 | } | 171 | } |
175 | } | 172 | } |
176 | 173 | ||
177 | impl RawString { | 174 | impl ast::ByteString { |
178 | pub fn map_range_up(&self, range: TextRange) -> Option<TextRange> { | 175 | pub fn is_raw(&self) -> bool { |
179 | let contents_range = self.text_range_between_quotes()?; | 176 | self.text().starts_with("br") |
180 | assert!(TextRange::up_to(contents_range.len()).contains_range(range)); | ||
181 | Some(range + contents_range.start()) | ||
182 | } | 177 | } |
183 | } | 178 | } |
184 | 179 | ||
@@ -500,7 +495,7 @@ pub trait HasFormatSpecifier: AstToken { | |||
500 | } | 495 | } |
501 | } | 496 | } |
502 | 497 | ||
503 | impl HasFormatSpecifier for String { | 498 | impl HasFormatSpecifier for ast::String { |
504 | fn char_ranges( | 499 | fn char_ranges( |
505 | &self, | 500 | &self, |
506 | ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> { | 501 | ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> { |
@@ -521,18 +516,86 @@ impl HasFormatSpecifier for String { | |||
521 | } | 516 | } |
522 | } | 517 | } |
523 | 518 | ||
524 | impl HasFormatSpecifier for RawString { | 519 | impl ast::IntNumber { |
525 | fn char_ranges( | 520 | const SUFFIXES: &'static [&'static str] = &[ |
526 | &self, | 521 | "u8", "u16", "u32", "u64", "u128", "usize", // Unsigned. |
527 | ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> { | 522 | "i8", "i16", "i32", "i64", "i128", "isize", // Signed. |
528 | let text = self.text().as_str(); | 523 | ]; |
529 | let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()]; | 524 | |
530 | let offset = self.text_range_between_quotes()?.start() - self.syntax().text_range().start(); | 525 | pub fn radix(&self) -> Radix { |
526 | match self.text().get(..2).unwrap_or_default() { | ||
527 | "0b" => Radix::Binary, | ||
528 | "0o" => Radix::Octal, | ||
529 | "0x" => Radix::Hexadecimal, | ||
530 | _ => Radix::Decimal, | ||
531 | } | ||
532 | } | ||
531 | 533 | ||
532 | let mut res = Vec::with_capacity(text.len()); | 534 | pub fn value(&self) -> Option<u128> { |
533 | for (idx, c) in text.char_indices() { | 535 | let token = self.syntax(); |
534 | res.push((TextRange::at(idx.try_into().unwrap(), TextSize::of(c)) + offset, Ok(c))); | 536 | |
537 | let mut text = token.text().as_str(); | ||
538 | if let Some(suffix) = self.suffix() { | ||
539 | text = &text[..text.len() - suffix.len()] | ||
540 | } | ||
541 | |||
542 | let radix = self.radix(); | ||
543 | text = &text[radix.prefix_len()..]; | ||
544 | |||
545 | let buf; | ||
546 | if text.contains("_") { | ||
547 | buf = text.replace('_', ""); | ||
548 | text = buf.as_str(); | ||
549 | }; | ||
550 | |||
551 | let value = u128::from_str_radix(text, radix as u32).ok()?; | ||
552 | Some(value) | ||
553 | } | ||
554 | |||
555 | pub fn suffix(&self) -> Option<&str> { | ||
556 | let text = self.text(); | ||
557 | // FIXME: don't check a fixed set of suffixes, `1_0_1_l_o_l` is valid | ||
558 | // syntax, suffix is `l_o_l`. | ||
559 | ast::IntNumber::SUFFIXES.iter().chain(ast::FloatNumber::SUFFIXES.iter()).find_map( | ||
560 | |suffix| { | ||
561 | if text.ends_with(suffix) { | ||
562 | return Some(&text[text.len() - suffix.len()..]); | ||
563 | } | ||
564 | None | ||
565 | }, | ||
566 | ) | ||
567 | } | ||
568 | } | ||
569 | |||
570 | impl ast::FloatNumber { | ||
571 | const SUFFIXES: &'static [&'static str] = &["f32", "f64"]; | ||
572 | pub fn suffix(&self) -> Option<&str> { | ||
573 | let text = self.text(); | ||
574 | ast::FloatNumber::SUFFIXES.iter().find_map(|suffix| { | ||
575 | if text.ends_with(suffix) { | ||
576 | return Some(&text[text.len() - suffix.len()..]); | ||
577 | } | ||
578 | None | ||
579 | }) | ||
580 | } | ||
581 | } | ||
582 | |||
583 | #[derive(Debug, PartialEq, Eq, Copy, Clone)] | ||
584 | pub enum Radix { | ||
585 | Binary = 2, | ||
586 | Octal = 8, | ||
587 | Decimal = 10, | ||
588 | Hexadecimal = 16, | ||
589 | } | ||
590 | |||
591 | impl Radix { | ||
592 | pub const ALL: &'static [Radix] = | ||
593 | &[Radix::Binary, Radix::Octal, Radix::Decimal, Radix::Hexadecimal]; | ||
594 | |||
595 | const fn prefix_len(&self) -> usize { | ||
596 | match self { | ||
597 | Self::Decimal => 0, | ||
598 | _ => 2, | ||
535 | } | 599 | } |
536 | Some(res) | ||
537 | } | 600 | } |
538 | } | 601 | } |
diff --git a/crates/syntax/src/parsing/lexer.rs b/crates/syntax/src/parsing/lexer.rs index 7e38c32cc..8afd7e53b 100644 --- a/crates/syntax/src/parsing/lexer.rs +++ b/crates/syntax/src/parsing/lexer.rs | |||
@@ -3,7 +3,7 @@ | |||
3 | 3 | ||
4 | use std::convert::TryInto; | 4 | use std::convert::TryInto; |
5 | 5 | ||
6 | use rustc_lexer::{LiteralKind as LK, RawStrError}; | 6 | use rustc_lexer::RawStrError; |
7 | 7 | ||
8 | use crate::{ | 8 | use crate::{ |
9 | SyntaxError, | 9 | SyntaxError, |
@@ -185,63 +185,77 @@ fn rustc_token_kind_to_syntax_kind( | |||
185 | return (syntax_kind, None); | 185 | return (syntax_kind, None); |
186 | 186 | ||
187 | fn match_literal_kind(kind: &rustc_lexer::LiteralKind) -> (SyntaxKind, Option<&'static str>) { | 187 | fn match_literal_kind(kind: &rustc_lexer::LiteralKind) -> (SyntaxKind, Option<&'static str>) { |
188 | #[rustfmt::skip] | 188 | let mut err = ""; |
189 | let syntax_kind = match *kind { | 189 | let syntax_kind = match *kind { |
190 | LK::Int { empty_int: false, .. } => INT_NUMBER, | 190 | rustc_lexer::LiteralKind::Int { empty_int, base: _ } => { |
191 | LK::Int { empty_int: true, .. } => { | 191 | if empty_int { |
192 | return (INT_NUMBER, Some("Missing digits after the integer base prefix")) | 192 | err = "Missing digits after the integer base prefix"; |
193 | } | ||
194 | INT_NUMBER | ||
193 | } | 195 | } |
194 | 196 | rustc_lexer::LiteralKind::Float { empty_exponent, base: _ } => { | |
195 | LK::Float { empty_exponent: false, .. } => FLOAT_NUMBER, | 197 | if empty_exponent { |
196 | LK::Float { empty_exponent: true, .. } => { | 198 | err = "Missing digits after the exponent symbol"; |
197 | return (FLOAT_NUMBER, Some("Missing digits after the exponent symbol")) | 199 | } |
200 | FLOAT_NUMBER | ||
198 | } | 201 | } |
199 | 202 | rustc_lexer::LiteralKind::Char { terminated } => { | |
200 | LK::Char { terminated: true } => CHAR, | 203 | if !terminated { |
201 | LK::Char { terminated: false } => { | 204 | err = "Missing trailing `'` symbol to terminate the character literal"; |
202 | return (CHAR, Some("Missing trailing `'` symbol to terminate the character literal")) | 205 | } |
206 | CHAR | ||
203 | } | 207 | } |
204 | 208 | rustc_lexer::LiteralKind::Byte { terminated } => { | |
205 | LK::Byte { terminated: true } => BYTE, | 209 | if !terminated { |
206 | LK::Byte { terminated: false } => { | 210 | err = "Missing trailing `'` symbol to terminate the byte literal"; |
207 | return (BYTE, Some("Missing trailing `'` symbol to terminate the byte literal")) | 211 | } |
212 | BYTE | ||
208 | } | 213 | } |
209 | 214 | rustc_lexer::LiteralKind::Str { terminated } => { | |
210 | LK::Str { terminated: true } => STRING, | 215 | if !terminated { |
211 | LK::Str { terminated: false } => { | 216 | err = "Missing trailing `\"` symbol to terminate the string literal"; |
212 | return (STRING, Some("Missing trailing `\"` symbol to terminate the string literal")) | 217 | } |
218 | STRING | ||
213 | } | 219 | } |
214 | 220 | rustc_lexer::LiteralKind::ByteStr { terminated } => { | |
215 | 221 | if !terminated { | |
216 | LK::ByteStr { terminated: true } => BYTE_STRING, | 222 | err = "Missing trailing `\"` symbol to terminate the byte string literal"; |
217 | LK::ByteStr { terminated: false } => { | 223 | } |
218 | return (BYTE_STRING, Some("Missing trailing `\"` symbol to terminate the byte string literal")) | 224 | BYTE_STRING |
225 | } | ||
226 | rustc_lexer::LiteralKind::RawStr { err: raw_str_err, .. } => { | ||
227 | if let Some(raw_str_err) = raw_str_err { | ||
228 | err = match raw_str_err { | ||
229 | RawStrError::InvalidStarter { .. } => "Missing `\"` symbol after `#` symbols to begin the raw string literal", | ||
230 | RawStrError::NoTerminator { expected, found, .. } => if expected == found { | ||
231 | "Missing trailing `\"` to terminate the raw string literal" | ||
232 | } else { | ||
233 | "Missing trailing `\"` with `#` symbols to terminate the raw string literal" | ||
234 | }, | ||
235 | RawStrError::TooManyDelimiters { .. } => "Too many `#` symbols: raw strings may be delimited by up to 65535 `#` symbols", | ||
236 | }; | ||
237 | }; | ||
238 | STRING | ||
239 | } | ||
240 | rustc_lexer::LiteralKind::RawByteStr { err: raw_str_err, .. } => { | ||
241 | if let Some(raw_str_err) = raw_str_err { | ||
242 | err = match raw_str_err { | ||
243 | RawStrError::InvalidStarter { .. } => "Missing `\"` symbol after `#` symbols to begin the raw byte string literal", | ||
244 | RawStrError::NoTerminator { expected, found, .. } => if expected == found { | ||
245 | "Missing trailing `\"` to terminate the raw byte string literal" | ||
246 | } else { | ||
247 | "Missing trailing `\"` with `#` symbols to terminate the raw byte string literal" | ||
248 | }, | ||
249 | RawStrError::TooManyDelimiters { .. } => "Too many `#` symbols: raw byte strings may be delimited by up to 65535 `#` symbols", | ||
250 | }; | ||
251 | }; | ||
252 | |||
253 | BYTE_STRING | ||
219 | } | 254 | } |
220 | |||
221 | LK::RawStr { err, .. } => match err { | ||
222 | None => RAW_STRING, | ||
223 | Some(RawStrError::InvalidStarter { .. }) => return (RAW_STRING, Some("Missing `\"` symbol after `#` symbols to begin the raw string literal")), | ||
224 | Some(RawStrError::NoTerminator { expected, found, .. }) => if expected == found { | ||
225 | return (RAW_STRING, Some("Missing trailing `\"` to terminate the raw string literal")) | ||
226 | } else { | ||
227 | return (RAW_STRING, Some("Missing trailing `\"` with `#` symbols to terminate the raw string literal")) | ||
228 | |||
229 | }, | ||
230 | Some(RawStrError::TooManyDelimiters { .. }) => return (RAW_STRING, Some("Too many `#` symbols: raw strings may be delimited by up to 65535 `#` symbols")), | ||
231 | }, | ||
232 | LK::RawByteStr { err, .. } => match err { | ||
233 | None => RAW_BYTE_STRING, | ||
234 | Some(RawStrError::InvalidStarter { .. }) => return (RAW_BYTE_STRING, Some("Missing `\"` symbol after `#` symbols to begin the raw byte string literal")), | ||
235 | Some(RawStrError::NoTerminator { expected, found, .. }) => if expected == found { | ||
236 | return (RAW_BYTE_STRING, Some("Missing trailing `\"` to terminate the raw byte string literal")) | ||
237 | } else { | ||
238 | return (RAW_BYTE_STRING, Some("Missing trailing `\"` with `#` symbols to terminate the raw byte string literal")) | ||
239 | |||
240 | }, | ||
241 | Some(RawStrError::TooManyDelimiters { .. }) => return (RAW_BYTE_STRING, Some("Too many `#` symbols: raw byte strings may be delimited by up to 65535 `#` symbols")), | ||
242 | }, | ||
243 | }; | 255 | }; |
244 | 256 | ||
245 | (syntax_kind, None) | 257 | let err = if err.is_empty() { None } else { Some(err) }; |
258 | |||
259 | (syntax_kind, err) | ||
246 | } | 260 | } |
247 | } | 261 | } |
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs index 4149f856a..190f5f67a 100644 --- a/crates/syntax/src/parsing/reparsing.rs +++ b/crates/syntax/src/parsing/reparsing.rs | |||
@@ -44,7 +44,7 @@ fn reparse_token<'node>( | |||
44 | let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone(); | 44 | let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone(); |
45 | let prev_token_kind = prev_token.kind(); | 45 | let prev_token_kind = prev_token.kind(); |
46 | match prev_token_kind { | 46 | match prev_token_kind { |
47 | WHITESPACE | COMMENT | IDENT | STRING | RAW_STRING => { | 47 | WHITESPACE | COMMENT | IDENT | STRING => { |
48 | if prev_token_kind == WHITESPACE || prev_token_kind == COMMENT { | 48 | if prev_token_kind == WHITESPACE || prev_token_kind == COMMENT { |
49 | // removing a new line may extends previous token | 49 | // removing a new line may extends previous token |
50 | let deleted_range = edit.delete - prev_token.text_range().start(); | 50 | let deleted_range = edit.delete - prev_token.text_range().start(); |
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs index 0f9a5e8ae..6f45149bf 100644 --- a/crates/syntax/src/validation.rs +++ b/crates/syntax/src/validation.rs | |||
@@ -4,7 +4,7 @@ mod block; | |||
4 | 4 | ||
5 | use crate::{ | 5 | use crate::{ |
6 | algo, ast, match_ast, AstNode, SyntaxError, | 6 | algo, ast, match_ast, AstNode, SyntaxError, |
7 | SyntaxKind::{BYTE, BYTE_STRING, CHAR, CONST, FN, INT_NUMBER, STRING, TYPE_ALIAS}, | 7 | SyntaxKind::{CONST, FN, INT_NUMBER, TYPE_ALIAS}, |
8 | SyntaxNode, SyntaxToken, TextSize, T, | 8 | SyntaxNode, SyntaxToken, TextSize, T, |
9 | }; | 9 | }; |
10 | use rowan::Direction; | 10 | use rowan::Direction; |
@@ -121,36 +121,42 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) { | |||
121 | acc.push(SyntaxError::new_at_offset(rustc_unescape_error_to_string(err), off)); | 121 | acc.push(SyntaxError::new_at_offset(rustc_unescape_error_to_string(err), off)); |
122 | }; | 122 | }; |
123 | 123 | ||
124 | match token.kind() { | 124 | match literal.kind() { |
125 | BYTE => { | 125 | ast::LiteralKind::String(s) => { |
126 | if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape_byte) { | 126 | if !s.is_raw() { |
127 | push_err(2, e); | 127 | if let Some(without_quotes) = unquote(text, 1, '"') { |
128 | unescape_literal(without_quotes, Mode::Str, &mut |range, char| { | ||
129 | if let Err(err) = char { | ||
130 | push_err(1, (range.start, err)); | ||
131 | } | ||
132 | }) | ||
133 | } | ||
128 | } | 134 | } |
129 | } | 135 | } |
130 | CHAR => { | 136 | ast::LiteralKind::ByteString(s) => { |
131 | if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape_char) { | 137 | if !s.is_raw() { |
132 | push_err(1, e); | 138 | if let Some(without_quotes) = unquote(text, 2, '"') { |
139 | unescape_byte_literal(without_quotes, Mode::ByteStr, &mut |range, char| { | ||
140 | if let Err(err) = char { | ||
141 | push_err(2, (range.start, err)); | ||
142 | } | ||
143 | }) | ||
144 | } | ||
133 | } | 145 | } |
134 | } | 146 | } |
135 | BYTE_STRING => { | 147 | ast::LiteralKind::Char => { |
136 | if let Some(without_quotes) = unquote(text, 2, '"') { | 148 | if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape_char) { |
137 | unescape_byte_literal(without_quotes, Mode::ByteStr, &mut |range, char| { | 149 | push_err(1, e); |
138 | if let Err(err) = char { | ||
139 | push_err(2, (range.start, err)); | ||
140 | } | ||
141 | }) | ||
142 | } | 150 | } |
143 | } | 151 | } |
144 | STRING => { | 152 | ast::LiteralKind::Byte => { |
145 | if let Some(without_quotes) = unquote(text, 1, '"') { | 153 | if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape_byte) { |
146 | unescape_literal(without_quotes, Mode::Str, &mut |range, char| { | 154 | push_err(2, e); |
147 | if let Err(err) = char { | ||
148 | push_err(1, (range.start, err)); | ||
149 | } | ||
150 | }) | ||
151 | } | 155 | } |
152 | } | 156 | } |
153 | _ => (), | 157 | ast::LiteralKind::IntNumber(_) |
158 | | ast::LiteralKind::FloatNumber(_) | ||
159 | | ast::LiteralKind::Bool(_) => {} | ||
154 | } | 160 | } |
155 | } | 161 | } |
156 | 162 | ||
diff --git a/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt index 6fd59ccc0..54e707b73 100644 --- a/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt +++ b/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 4 "r##\"" | 1 | STRING 4 "r##\"" |
2 | > error0..4 token("r##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..4 token("r##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt b/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt index 8d9ca0e8f..1f9889775 100644 --- a/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt +++ b/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 8 "r##\"🦀" | 1 | STRING 8 "r##\"🦀" |
2 | > error0..8 token("r##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..8 token("r##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt b/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt index a906380c7..93f6f72ae 100644 --- a/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt +++ b/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 8 "r##\"\\x7f" | 1 | STRING 8 "r##\"\\x7f" |
2 | > error0..8 token("r##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..8 token("r##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt b/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt index 5667c6149..1d2ebc60f 100644 --- a/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt +++ b/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 12 "r##\"\\u{20AA}" | 1 | STRING 12 "r##\"\\u{20AA}" |
2 | > error0..12 token("r##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..12 token("r##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt b/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt index 141c8268e..c567ab7e2 100644 --- a/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt +++ b/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 5 "r##\" " | 1 | STRING 5 "r##\" " |
2 | > error0..5 token("r##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..5 token("r##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt b/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt index f61d4cc91..343b20323 100644 --- a/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt +++ b/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 5 "r##\"\\" | 1 | STRING 5 "r##\"\\" |
2 | > error0..5 token("r##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..5 token("r##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt b/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt index 12e2c0fc0..041a42737 100644 --- a/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt +++ b/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 6 "r##\"\\n" | 1 | STRING 6 "r##\"\\n" |
2 | > error0..6 token("r##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) | 2 | > error0..6 token("r##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt index fe12cb5fc..efaa1cafd 100644 --- a/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt +++ b/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 5 "br##\"" | 1 | BYTE_STRING 5 "br##\"" |
2 | > error0..5 token("br##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..5 token("br##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt b/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt index 5be2a7861..b6c938f94 100644 --- a/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt +++ b/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 9 "br##\"🦀" | 1 | BYTE_STRING 9 "br##\"🦀" |
2 | > error0..9 token("br##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..9 token("br##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt b/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt index 6cbe08d07..f82efe49a 100644 --- a/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt +++ b/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 9 "br##\"\\x7f" | 1 | BYTE_STRING 9 "br##\"\\x7f" |
2 | > error0..9 token("br##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..9 token("br##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt b/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt index f56a4f984..4e4a57696 100644 --- a/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt +++ b/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 13 "br##\"\\u{20AA}" | 1 | BYTE_STRING 13 "br##\"\\u{20AA}" |
2 | > error0..13 token("br##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..13 token("br##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt b/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt index 3d32ce34e..0018c8623 100644 --- a/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt +++ b/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 6 "br##\" " | 1 | BYTE_STRING 6 "br##\" " |
2 | > error0..6 token("br##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..6 token("br##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt b/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt index 320fea177..c3ba4ae82 100644 --- a/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt +++ b/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 6 "br##\"\\" | 1 | BYTE_STRING 6 "br##\"\\" |
2 | > error0..6 token("br##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..6 token("br##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt b/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt index b3a56380c..7bda72276 100644 --- a/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt +++ b/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 7 "br##\"\\n" | 1 | BYTE_STRING 7 "br##\"\\n" |
2 | > error0..7 token("br##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) | 2 | > error0..7 token("br##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt index 5af1e2d97..ce92d2ff7 100644 --- a/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt +++ b/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 3 "r##" | 1 | STRING 3 "r##" |
2 | > error0..3 token("r##") msg(Missing `"` symbol after `#` symbols to begin the raw string literal) | 2 | > error0..3 token("r##") msg(Missing `"` symbol after `#` symbols to begin the raw string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt index aec7afd92..a75d9030c 100644 --- a/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt +++ b/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_BYTE_STRING 4 "br##" | 1 | BYTE_STRING 4 "br##" |
2 | > error0..4 token("br##") msg(Missing `"` symbol after `#` symbols to begin the raw byte string literal) | 2 | > error0..4 token("br##") msg(Missing `"` symbol after `#` symbols to begin the raw byte string literal) |
diff --git a/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt b/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt index e22fe5374..516e0b78e 100644 --- a/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt +++ b/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt | |||
@@ -1,4 +1,4 @@ | |||
1 | RAW_STRING 4 "r## " | 1 | STRING 4 "r## " |
2 | IDENT 1 "I" | 2 | IDENT 1 "I" |
3 | WHITESPACE 1 " " | 3 | WHITESPACE 1 " " |
4 | IDENT 4 "lack" | 4 | IDENT 4 "lack" |
diff --git a/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt b/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt index d74ea4c27..2f8a6f5f2 100644 --- a/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt +++ b/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt | |||
@@ -1,4 +1,4 @@ | |||
1 | RAW_BYTE_STRING 5 "br## " | 1 | BYTE_STRING 5 "br## " |
2 | IDENT 1 "I" | 2 | IDENT 1 "I" |
3 | WHITESPACE 1 " " | 3 | WHITESPACE 1 " " |
4 | IDENT 4 "lack" | 4 | IDENT 4 "lack" |
diff --git a/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt b/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt index bc03b51a8..e61ad99be 100644 --- a/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt +++ b/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt | |||
@@ -4,13 +4,13 @@ BYTE 4 "b\'x\'" | |||
4 | WHITESPACE 1 " " | 4 | WHITESPACE 1 " " |
5 | BYTE_STRING 6 "b\"foo\"" | 5 | BYTE_STRING 6 "b\"foo\"" |
6 | WHITESPACE 1 " " | 6 | WHITESPACE 1 " " |
7 | RAW_BYTE_STRING 4 "br\"\"" | 7 | BYTE_STRING 4 "br\"\"" |
8 | WHITESPACE 1 "\n" | 8 | WHITESPACE 1 "\n" |
9 | BYTE 6 "b\'\'suf" | 9 | BYTE 6 "b\'\'suf" |
10 | WHITESPACE 1 " " | 10 | WHITESPACE 1 " " |
11 | BYTE_STRING 5 "b\"\"ix" | 11 | BYTE_STRING 5 "b\"\"ix" |
12 | WHITESPACE 1 " " | 12 | WHITESPACE 1 " " |
13 | RAW_BYTE_STRING 6 "br\"\"br" | 13 | BYTE_STRING 6 "br\"\"br" |
14 | WHITESPACE 1 "\n" | 14 | WHITESPACE 1 "\n" |
15 | BYTE 5 "b\'\\n\'" | 15 | BYTE 5 "b\'\\n\'" |
16 | WHITESPACE 1 " " | 16 | WHITESPACE 1 " " |
diff --git a/crates/syntax/test_data/lexer/ok/0009_strings.txt b/crates/syntax/test_data/lexer/ok/0009_strings.txt index 4cb4d711d..988a8877b 100644 --- a/crates/syntax/test_data/lexer/ok/0009_strings.txt +++ b/crates/syntax/test_data/lexer/ok/0009_strings.txt | |||
@@ -1,6 +1,6 @@ | |||
1 | STRING 7 "\"hello\"" | 1 | STRING 7 "\"hello\"" |
2 | WHITESPACE 1 " " | 2 | WHITESPACE 1 " " |
3 | RAW_STRING 8 "r\"world\"" | 3 | STRING 8 "r\"world\"" |
4 | WHITESPACE 1 " " | 4 | WHITESPACE 1 " " |
5 | STRING 17 "\"\\n\\\"\\\\no escape\"" | 5 | STRING 17 "\"\\n\\\"\\\\no escape\"" |
6 | WHITESPACE 1 " " | 6 | WHITESPACE 1 " " |
diff --git a/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt b/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt index 9cf0957d1..db0d5ffd1 100644 --- a/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt +++ b/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt | |||
@@ -1,2 +1,2 @@ | |||
1 | RAW_STRING 36 "r###\"this is a r##\"raw\"## string\"###" | 1 | STRING 36 "r###\"this is a r##\"raw\"## string\"###" |
2 | WHITESPACE 1 "\n" | 2 | WHITESPACE 1 "\n" |
diff --git a/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast b/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast index 9a87b5b93..ae838105d 100644 --- a/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast +++ b/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast | |||
@@ -104,7 +104,7 @@ [email protected] | |||
104 | [email protected] "=" | 104 | [email protected] "=" |
105 | [email protected] " " | 105 | [email protected] " " |
106 | [email protected] | 106 | [email protected] |
107 | RAW_[email protected] "r\"d\"" | 107 | [email protected] "r\"d\"" |
108 | [email protected] ";" | 108 | [email protected] ";" |
109 | [email protected] "\n " | 109 | [email protected] "\n " |
110 | [email protected] | 110 | [email protected] |
@@ -128,7 +128,7 @@ [email protected] | |||
128 | [email protected] "=" | 128 | [email protected] "=" |
129 | [email protected] " " | 129 | [email protected] " " |
130 | [email protected] | 130 | [email protected] |
131 | RAW_[email protected] "br\"f\"" | 131 | [email protected] "br\"f\"" |
132 | [email protected] ";" | 132 | [email protected] ";" |
133 | [email protected] "\n" | 133 | [email protected] "\n" |
134 | [email protected] "}" | 134 | [email protected] "}" |
diff --git a/docs/dev/style.md b/docs/dev/style.md index 8d57fc049..1a952197f 100644 --- a/docs/dev/style.md +++ b/docs/dev/style.md | |||
@@ -89,6 +89,32 @@ There are many benefits to this: | |||
89 | It also makes sense to format snippets more compactly (for example, by placing enum definitions like `enum E { Foo, Bar }` on a single line), | 89 | It also makes sense to format snippets more compactly (for example, by placing enum definitions like `enum E { Foo, Bar }` on a single line), |
90 | as long as they are still readable. | 90 | as long as they are still readable. |
91 | 91 | ||
92 | When using multiline fixtures, use unindented raw string literals: | ||
93 | |||
94 | ```rust | ||
95 | #[test] | ||
96 | fn inline_field_shorthand() { | ||
97 | check_assist( | ||
98 | inline_local_variable, | ||
99 | r" | ||
100 | struct S { foo: i32} | ||
101 | fn main() { | ||
102 | let <|>foo = 92; | ||
103 | S { foo } | ||
104 | } | ||
105 | ", | ||
106 | r" | ||
107 | struct S { foo: i32} | ||
108 | fn main() { | ||
109 | S { foo: 92 } | ||
110 | } | ||
111 | ", | ||
112 | ); | ||
113 | } | ||
114 | ``` | ||
115 | |||
116 | That way, you can use your editor's "number of selected characters" feature to correlate offsets with test's source code. | ||
117 | |||
92 | ## Preconditions | 118 | ## Preconditions |
93 | 119 | ||
94 | Express function preconditions in types and force the caller to provide them (rather than checking in callee): | 120 | Express function preconditions in types and force the caller to provide them (rather than checking in callee): |
diff --git a/editors/code/rust.tmGrammar.json b/editors/code/rust.tmGrammar.json index 77595aa00..b3a10795e 100644 --- a/editors/code/rust.tmGrammar.json +++ b/editors/code/rust.tmGrammar.json | |||
@@ -50,7 +50,7 @@ | |||
50 | { | 50 | { |
51 | "comment": "macro type metavariables", | 51 | "comment": "macro type metavariables", |
52 | "name": "meta.macro.metavariable.type.rust", | 52 | "name": "meta.macro.metavariable.type.rust", |
53 | "match": "(\\$)((crate)|([A-Z][A-Za-z0-9_]*))((:)(block|expr|ident|item|lifetime|literal|meta|pat|path|stmt|tt|ty|vis))?", | 53 | "match": "(\\$)((crate)|([A-Z][A-Za-z0-9_]*))((:)(block|expr|ident|item|lifetime|literal|meta|path?|stmt|tt|ty|vis))?", |
54 | "captures": { | 54 | "captures": { |
55 | "1": { | 55 | "1": { |
56 | "name": "keyword.operator.macro.dollar.rust" | 56 | "name": "keyword.operator.macro.dollar.rust" |
@@ -77,7 +77,7 @@ | |||
77 | { | 77 | { |
78 | "comment": "macro metavariables", | 78 | "comment": "macro metavariables", |
79 | "name": "meta.macro.metavariable.rust", | 79 | "name": "meta.macro.metavariable.rust", |
80 | "match": "(\\$)([a-z][A-Za-z0-9_]*)((:)(block|expr|ident|item|lifetime|literal|meta|pat|path|stmt|tt|ty|vis))?", | 80 | "match": "(\\$)([a-z][A-Za-z0-9_]*)((:)(block|expr|ident|item|lifetime|literal|meta|path?|stmt|tt|ty|vis))?", |
81 | "captures": { | 81 | "captures": { |
82 | "1": { | 82 | "1": { |
83 | "name": "keyword.operator.macro.dollar.rust" | 83 | "name": "keyword.operator.macro.dollar.rust" |
@@ -167,7 +167,7 @@ | |||
167 | "match": "(mod)\\s+((?:r#(?!crate|[Ss]elf|super))?[a-z][A-Za-z0-9_]*)", | 167 | "match": "(mod)\\s+((?:r#(?!crate|[Ss]elf|super))?[a-z][A-Za-z0-9_]*)", |
168 | "captures": { | 168 | "captures": { |
169 | "1": { | 169 | "1": { |
170 | "name": "keyword.control.rust" | 170 | "name": "storage.type.rust" |
171 | }, | 171 | }, |
172 | "2": { | 172 | "2": { |
173 | "name": "entity.name.module.rust" | 173 | "name": "entity.name.module.rust" |
@@ -180,7 +180,7 @@ | |||
180 | "begin": "\\b(extern)\\s+(crate)", | 180 | "begin": "\\b(extern)\\s+(crate)", |
181 | "beginCaptures": { | 181 | "beginCaptures": { |
182 | "1": { | 182 | "1": { |
183 | "name": "keyword.control.rust" | 183 | "name": "storage.type.rust" |
184 | }, | 184 | }, |
185 | "2": { | 185 | "2": { |
186 | "name": "keyword.other.crate.rust" | 186 | "name": "keyword.other.crate.rust" |
@@ -213,7 +213,7 @@ | |||
213 | "begin": "\\b(use)\\s", | 213 | "begin": "\\b(use)\\s", |
214 | "beginCaptures": { | 214 | "beginCaptures": { |
215 | "1": { | 215 | "1": { |
216 | "name": "keyword.control.rust" | 216 | "name": "keyword.other.rust" |
217 | } | 217 | } |
218 | }, | 218 | }, |
219 | "end": ";", | 219 | "end": ";", |
@@ -342,7 +342,7 @@ | |||
342 | "match": "\\b(const)\\s+([A-Z][A-Za-z0-9_]*)\\b", | 342 | "match": "\\b(const)\\s+([A-Z][A-Za-z0-9_]*)\\b", |
343 | "captures": { | 343 | "captures": { |
344 | "1": { | 344 | "1": { |
345 | "name": "keyword.control.rust" | 345 | "name": "storage.type.rust" |
346 | }, | 346 | }, |
347 | "2": { | 347 | "2": { |
348 | "name": "constant.other.caps.rust" | 348 | "name": "constant.other.caps.rust" |
@@ -450,7 +450,7 @@ | |||
450 | "begin": "\\b(fn)\\s+((?:r#(?!crate|[Ss]elf|super))?[A-Za-z0-9_]+)((\\()|(<))", | 450 | "begin": "\\b(fn)\\s+((?:r#(?!crate|[Ss]elf|super))?[A-Za-z0-9_]+)((\\()|(<))", |
451 | "beginCaptures": { | 451 | "beginCaptures": { |
452 | "1": { | 452 | "1": { |
453 | "name": "keyword.control.fn.rust" | 453 | "name": "keyword.other.fn.rust" |
454 | }, | 454 | }, |
455 | "2": { | 455 | "2": { |
456 | "name": "entity.name.function.rust" | 456 | "name": "entity.name.function.rust" |
@@ -643,7 +643,7 @@ | |||
643 | { | 643 | { |
644 | "comment": "control flow keywords", | 644 | "comment": "control flow keywords", |
645 | "name": "keyword.control.rust", | 645 | "name": "keyword.control.rust", |
646 | "match": "\\b(async|await|break|continue|do|else|for|if|loop|match|move|return|try|where|while|yield)\\b" | 646 | "match": "\\b(await|break|continue|do|else|for|if|loop|match|return|try|while|yield)\\b" |
647 | }, | 647 | }, |
648 | { | 648 | { |
649 | "comment": "storage keywords", | 649 | "comment": "storage keywords", |
@@ -658,7 +658,7 @@ | |||
658 | { | 658 | { |
659 | "comment": "other keywords", | 659 | "comment": "other keywords", |
660 | "name": "keyword.other.rust", | 660 | "name": "keyword.other.rust", |
661 | "match": "\\b(as|become|box|dyn|final|impl|in|override|priv|pub|ref|typeof|union|unsafe|unsized|use|virtual)\\b" | 661 | "match": "\\b(as|async|become|box|dyn|move|final|impl|in|override|priv|pub|ref|typeof|union|unsafe|unsized|use|virtual|where)\\b" |
662 | }, | 662 | }, |
663 | { | 663 | { |
664 | "comment": "fn", | 664 | "comment": "fn", |
@@ -676,11 +676,6 @@ | |||
676 | "match": "\\bmut\\b" | 676 | "match": "\\bmut\\b" |
677 | }, | 677 | }, |
678 | { | 678 | { |
679 | "comment": "math operators", | ||
680 | "name": "keyword.operator.math.rust", | ||
681 | "match": "(([+%]|(\\*(?!\\w)))(?!=))|(-(?!>))|(/(?!/))" | ||
682 | }, | ||
683 | { | ||
684 | "comment": "logical operators", | 679 | "comment": "logical operators", |
685 | "name": "keyword.operator.logical.rust", | 680 | "name": "keyword.operator.logical.rust", |
686 | "match": "(\\^|\\||\\|\\||&&|<<|>>|!)(?!=)" | 681 | "match": "(\\^|\\||\\|\\||&&|<<|>>|!)(?!=)" |
@@ -693,7 +688,7 @@ | |||
693 | { | 688 | { |
694 | "comment": "assignment operators", | 689 | "comment": "assignment operators", |
695 | "name": "keyword.operator.assignment.rust", | 690 | "name": "keyword.operator.assignment.rust", |
696 | "match": "(-=|\\*=|/=|%=|\\^=|&=|\\|=|<<=|>>=)" | 691 | "match": "(\\+=|-=|\\*=|/=|%=|\\^=|&=|\\|=|<<=|>>=)" |
697 | }, | 692 | }, |
698 | { | 693 | { |
699 | "comment": "single equal", | 694 | "comment": "single equal", |
@@ -706,6 +701,11 @@ | |||
706 | "match": "(=(=)?(?!>)|!=|<=|(?<!=)>=)" | 701 | "match": "(=(=)?(?!>)|!=|<=|(?<!=)>=)" |
707 | }, | 702 | }, |
708 | { | 703 | { |
704 | "comment": "math operators", | ||
705 | "name": "keyword.operator.math.rust", | ||
706 | "match": "(([+%]|(\\*(?!\\w)))(?!=))|(-(?!>))|(/(?!/))" | ||
707 | }, | ||
708 | { | ||
709 | "comment": "less than, greater than (special case)", | 709 | "comment": "less than, greater than (special case)", |
710 | "match": "(?:\\b|(?:(\\))|(\\])|(\\})))[ \\t]+([<>])[ \\t]+(?:\\b|(?:(\\()|(\\[)|(\\{)))", | 710 | "match": "(?:\\b|(?:(\\))|(\\])|(\\})))[ \\t]+([<>])[ \\t]+(?:\\b|(?:(\\()|(\\[)|(\\{)))", |
711 | "captures": { | 711 | "captures": { |
@@ -1127,7 +1127,7 @@ | |||
1127 | { | 1127 | { |
1128 | "comment": "variables", | 1128 | "comment": "variables", |
1129 | "name": "variable.other.rust", | 1129 | "name": "variable.other.rust", |
1130 | "match": "\\b(?<!\\.)(?:r#(?!(crate|[Ss]elf|super)))?[a-z0-9_]+\\b" | 1130 | "match": "\\b(?<!(?<!\\.)\\.)(?:r#(?!(crate|[Ss]elf|super)))?[a-z0-9_]+\\b" |
1131 | } | 1131 | } |
1132 | ] | 1132 | ] |
1133 | } | 1133 | } |
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts index 1ba2352ee..d032b45b7 100644 --- a/editors/code/src/client.ts +++ b/editors/code/src/client.ts | |||
@@ -2,6 +2,7 @@ import * as lc from 'vscode-languageclient/node'; | |||
2 | import * as vscode from 'vscode'; | 2 | import * as vscode from 'vscode'; |
3 | import * as ra from '../src/lsp_ext'; | 3 | import * as ra from '../src/lsp_ext'; |
4 | import * as Is from 'vscode-languageclient/lib/common/utils/is'; | 4 | import * as Is from 'vscode-languageclient/lib/common/utils/is'; |
5 | import { DocumentSemanticsTokensSignature, DocumentSemanticsTokensEditsSignature, DocumentRangeSemanticTokensSignature } from 'vscode-languageclient/lib/common/semanticTokens'; | ||
5 | import { assert } from './util'; | 6 | import { assert } from './util'; |
6 | 7 | ||
7 | function renderCommand(cmd: ra.CommandLink) { | 8 | function renderCommand(cmd: ra.CommandLink) { |
@@ -18,6 +19,13 @@ function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownStri | |||
18 | return result; | 19 | return result; |
19 | } | 20 | } |
20 | 21 | ||
22 | // Workaround for https://github.com/microsoft/vscode-languageserver-node/issues/576 | ||
23 | async function semanticHighlightingWorkaround<R, F extends (...args: any[]) => vscode.ProviderResult<R>>(next: F, ...args: Parameters<F>): Promise<R> { | ||
24 | const res = await next(...args); | ||
25 | if (res == null) throw new Error('busy'); | ||
26 | return res; | ||
27 | } | ||
28 | |||
21 | export function createClient(serverPath: string, cwd: string): lc.LanguageClient { | 29 | export function createClient(serverPath: string, cwd: string): lc.LanguageClient { |
22 | // '.' Is the fallback if no folder is open | 30 | // '.' Is the fallback if no folder is open |
23 | // TODO?: Workspace folders support Uri's (eg: file://test.txt). | 31 | // TODO?: Workspace folders support Uri's (eg: file://test.txt). |
@@ -41,6 +49,15 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient | |||
41 | diagnosticCollectionName: "rustc", | 49 | diagnosticCollectionName: "rustc", |
42 | traceOutputChannel, | 50 | traceOutputChannel, |
43 | middleware: { | 51 | middleware: { |
52 | provideDocumentSemanticTokens(document: vscode.TextDocument, token: vscode.CancellationToken, next: DocumentSemanticsTokensSignature): vscode.ProviderResult<vscode.SemanticTokens> { | ||
53 | return semanticHighlightingWorkaround(next, document, token); | ||
54 | }, | ||
55 | provideDocumentSemanticTokensEdits(document: vscode.TextDocument, previousResultId: string, token: vscode.CancellationToken, next: DocumentSemanticsTokensEditsSignature): vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens> { | ||
56 | return semanticHighlightingWorkaround(next, document, previousResultId, token); | ||
57 | }, | ||
58 | provideDocumentRangeSemanticTokens(document: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken, next: DocumentRangeSemanticTokensSignature): vscode.ProviderResult<vscode.SemanticTokens> { | ||
59 | return semanticHighlightingWorkaround(next, document, range, token); | ||
60 | }, | ||
44 | async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, _next: lc.ProvideHoverSignature) { | 61 | async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, _next: lc.ProvideHoverSignature) { |
45 | return client.sendRequest(lc.HoverRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then( | 62 | return client.sendRequest(lc.HoverRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then( |
46 | (result) => { | 63 | (result) => { |
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index adc191254..8ceaaf60e 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs | |||
@@ -71,16 +71,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
71 | "trait", "true", "try", "type", "unsafe", "use", "where", "while", | 71 | "trait", "true", "try", "type", "unsafe", "use", "where", "while", |
72 | ], | 72 | ], |
73 | contextual_keywords: &["auto", "default", "existential", "union", "raw"], | 73 | contextual_keywords: &["auto", "default", "existential", "union", "raw"], |
74 | literals: &[ | 74 | literals: &["INT_NUMBER", "FLOAT_NUMBER", "CHAR", "BYTE", "STRING", "BYTE_STRING"], |
75 | "INT_NUMBER", | ||
76 | "FLOAT_NUMBER", | ||
77 | "CHAR", | ||
78 | "BYTE", | ||
79 | "STRING", | ||
80 | "RAW_STRING", | ||
81 | "BYTE_STRING", | ||
82 | "RAW_BYTE_STRING", | ||
83 | ], | ||
84 | tokens: &[ | 75 | tokens: &[ |
85 | "ERROR", | 76 | "ERROR", |
86 | "IDENT", | 77 | "IDENT", |
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs index 02f4095ce..44460effa 100644 --- a/xtask/src/codegen/gen_syntax.rs +++ b/xtask/src/codegen/gen_syntax.rs | |||
@@ -504,7 +504,11 @@ impl Field { | |||
504 | 504 | ||
505 | fn lower(grammar: &Grammar) -> AstSrc { | 505 | fn lower(grammar: &Grammar) -> AstSrc { |
506 | let mut res = AstSrc::default(); | 506 | let mut res = AstSrc::default(); |
507 | res.tokens = vec!["Whitespace".into(), "Comment".into(), "String".into(), "RawString".into()]; | 507 | |
508 | res.tokens = "Whitespace Comment String ByteString IntNumber FloatNumber" | ||
509 | .split_ascii_whitespace() | ||
510 | .map(|it| it.to_string()) | ||
511 | .collect::<Vec<_>>(); | ||
508 | 512 | ||
509 | let nodes = grammar.iter().collect::<Vec<_>>(); | 513 | let nodes = grammar.iter().collect::<Vec<_>>(); |
510 | 514 | ||
diff --git a/xtask/tests/tidy.rs b/xtask/tests/tidy.rs index 9de60c76c..4c7db8405 100644 --- a/xtask/tests/tidy.rs +++ b/xtask/tests/tidy.rs | |||
@@ -215,6 +215,7 @@ fn check_todo(path: &Path, text: &str) { | |||
215 | "tests/cli.rs", | 215 | "tests/cli.rs", |
216 | // Some of our assists generate `todo!()`. | 216 | // Some of our assists generate `todo!()`. |
217 | "tests/generated.rs", | 217 | "tests/generated.rs", |
218 | "handlers/add_custom_impl.rs", | ||
218 | "handlers/add_missing_impl_members.rs", | 219 | "handlers/add_missing_impl_members.rs", |
219 | "handlers/add_turbo_fish.rs", | 220 | "handlers/add_turbo_fish.rs", |
220 | "handlers/generate_function.rs", | 221 | "handlers/generate_function.rs", |