diff options
Diffstat (limited to 'crates/ra_syntax/src/ast.rs')
-rw-r--r-- | crates/ra_syntax/src/ast.rs | 275 |
1 files changed, 26 insertions, 249 deletions
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index ffd115cef..beef2c6e2 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs | |||
@@ -1,17 +1,24 @@ | |||
1 | //! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s | 1 | //! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s |
2 | mod generated; | 2 | mod generated; |
3 | mod traits; | ||
4 | mod tokens; | ||
3 | 5 | ||
4 | use std::marker::PhantomData; | 6 | use std::marker::PhantomData; |
5 | 7 | ||
6 | use itertools::Itertools; | 8 | use itertools::Itertools; |
7 | 9 | ||
8 | pub use self::generated::*; | ||
9 | use crate::{ | 10 | use crate::{ |
10 | syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement, SyntaxElementChildren}, | 11 | syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement}, |
11 | SmolStr, | 12 | SmolStr, |
12 | SyntaxKind::*, | 13 | SyntaxKind::*, |
13 | }; | 14 | }; |
14 | 15 | ||
16 | pub use self::{ | ||
17 | generated::*, | ||
18 | traits::*, | ||
19 | tokens::*, | ||
20 | }; | ||
21 | |||
15 | /// The main trait to go from untyped `SyntaxNode` to a typed ast. The | 22 | /// The main trait to go from untyped `SyntaxNode` to a typed ast. The |
16 | /// conversion itself has zero runtime cost: ast and syntax nodes have exactly | 23 | /// conversion itself has zero runtime cost: ast and syntax nodes have exactly |
17 | /// the same representation: a pointer to the tree root and a pointer to the | 24 | /// the same representation: a pointer to the tree root and a pointer to the |
@@ -25,134 +32,32 @@ pub trait AstNode: | |||
25 | fn syntax(&self) -> &SyntaxNode; | 32 | fn syntax(&self) -> &SyntaxNode; |
26 | } | 33 | } |
27 | 34 | ||
28 | pub trait TypeAscriptionOwner: AstNode { | ||
29 | fn ascribed_type(&self) -> Option<&TypeRef> { | ||
30 | child_opt(self) | ||
31 | } | ||
32 | } | ||
33 | |||
34 | pub trait NameOwner: AstNode { | ||
35 | fn name(&self) -> Option<&Name> { | ||
36 | child_opt(self) | ||
37 | } | ||
38 | } | ||
39 | |||
40 | pub trait VisibilityOwner: AstNode { | ||
41 | fn visibility(&self) -> Option<&Visibility> { | ||
42 | child_opt(self) | ||
43 | } | ||
44 | } | ||
45 | |||
46 | pub trait LoopBodyOwner: AstNode { | ||
47 | fn loop_body(&self) -> Option<&Block> { | ||
48 | child_opt(self) | ||
49 | } | ||
50 | } | ||
51 | |||
52 | pub trait ArgListOwner: AstNode { | ||
53 | fn arg_list(&self) -> Option<&ArgList> { | ||
54 | child_opt(self) | ||
55 | } | ||
56 | } | ||
57 | |||
58 | pub trait FnDefOwner: AstNode { | ||
59 | fn functions(&self) -> AstChildren<FnDef> { | ||
60 | children(self) | ||
61 | } | ||
62 | } | ||
63 | |||
64 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | ||
65 | pub enum ItemOrMacro<'a> { | ||
66 | Item(&'a ModuleItem), | ||
67 | Macro(&'a MacroCall), | ||
68 | } | ||
69 | |||
70 | pub trait ModuleItemOwner: AstNode { | ||
71 | fn items(&self) -> AstChildren<ModuleItem> { | ||
72 | children(self) | ||
73 | } | ||
74 | fn items_with_macros(&self) -> ItemOrMacroIter { | ||
75 | ItemOrMacroIter(self.syntax().children()) | ||
76 | } | ||
77 | } | ||
78 | |||
79 | #[derive(Debug)] | 35 | #[derive(Debug)] |
80 | pub struct ItemOrMacroIter<'a>(SyntaxNodeChildren<'a>); | 36 | pub struct AstChildren<'a, N> { |
81 | 37 | inner: SyntaxNodeChildren<'a>, | |
82 | impl<'a> Iterator for ItemOrMacroIter<'a> { | 38 | ph: PhantomData<N>, |
83 | type Item = ItemOrMacro<'a>; | ||
84 | fn next(&mut self) -> Option<ItemOrMacro<'a>> { | ||
85 | loop { | ||
86 | let n = self.0.next()?; | ||
87 | if let Some(item) = ModuleItem::cast(n) { | ||
88 | return Some(ItemOrMacro::Item(item)); | ||
89 | } | ||
90 | if let Some(call) = MacroCall::cast(n) { | ||
91 | return Some(ItemOrMacro::Macro(call)); | ||
92 | } | ||
93 | } | ||
94 | } | ||
95 | } | ||
96 | |||
97 | pub trait TypeParamsOwner: AstNode { | ||
98 | fn type_param_list(&self) -> Option<&TypeParamList> { | ||
99 | child_opt(self) | ||
100 | } | ||
101 | |||
102 | fn where_clause(&self) -> Option<&WhereClause> { | ||
103 | child_opt(self) | ||
104 | } | ||
105 | } | 39 | } |
106 | 40 | ||
107 | pub trait TypeBoundsOwner: AstNode { | 41 | impl<'a, N> AstChildren<'a, N> { |
108 | fn type_bound_list(&self) -> Option<&TypeBoundList> { | 42 | fn new(parent: &'a SyntaxNode) -> Self { |
109 | child_opt(self) | 43 | AstChildren { inner: parent.children(), ph: PhantomData } |
110 | } | 44 | } |
111 | } | 45 | } |
112 | 46 | ||
113 | pub trait AttrsOwner: AstNode { | 47 | impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> { |
114 | fn attrs(&self) -> AstChildren<Attr> { | 48 | type Item = &'a N; |
115 | children(self) | 49 | fn next(&mut self) -> Option<&'a N> { |
116 | } | 50 | self.inner.by_ref().find_map(N::cast) |
117 | fn has_atom_attr(&self, atom: &str) -> bool { | ||
118 | self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom) | ||
119 | } | 51 | } |
120 | } | 52 | } |
121 | 53 | ||
122 | pub trait DocCommentsOwner: AstNode { | 54 | pub trait AstToken<'a> { |
123 | fn doc_comments(&self) -> CommentIter { | 55 | fn cast(token: SyntaxToken<'a>) -> Option<Self> |
124 | CommentIter { iter: self.syntax().children_with_tokens() } | 56 | where |
125 | } | 57 | Self: Sized; |
126 | 58 | fn syntax(&self) -> SyntaxToken<'a>; | |
127 | /// Returns the textual content of a doc comment block as a single string. | 59 | fn text(&self) -> &'a SmolStr { |
128 | /// That is, strips leading `///` (+ optional 1 character of whitespace) | 60 | self.syntax().text() |
129 | /// and joins lines. | ||
130 | fn doc_comment_text(&self) -> Option<std::string::String> { | ||
131 | let docs = self | ||
132 | .doc_comments() | ||
133 | .filter(|comment| comment.is_doc_comment()) | ||
134 | .map(|comment| { | ||
135 | let prefix_len = comment.prefix().len(); | ||
136 | |||
137 | let line = comment.text().as_str(); | ||
138 | |||
139 | // Determine if the prefix or prefix + 1 char is stripped | ||
140 | let pos = | ||
141 | if line.chars().nth(prefix_len).map(|c| c.is_whitespace()).unwrap_or(false) { | ||
142 | prefix_len + 1 | ||
143 | } else { | ||
144 | prefix_len | ||
145 | }; | ||
146 | |||
147 | line[pos..].to_owned() | ||
148 | }) | ||
149 | .join("\n"); | ||
150 | |||
151 | if docs.is_empty() { | ||
152 | None | ||
153 | } else { | ||
154 | Some(docs) | ||
155 | } | ||
156 | } | 61 | } |
157 | } | 62 | } |
158 | 63 | ||
@@ -203,111 +108,6 @@ impl Attr { | |||
203 | } | 108 | } |
204 | } | 109 | } |
205 | 110 | ||
206 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | ||
207 | pub struct Comment<'a>(SyntaxToken<'a>); | ||
208 | |||
209 | impl<'a> Comment<'a> { | ||
210 | pub fn cast(token: SyntaxToken<'a>) -> Option<Self> { | ||
211 | if token.kind() == COMMENT { | ||
212 | Some(Comment(token)) | ||
213 | } else { | ||
214 | None | ||
215 | } | ||
216 | } | ||
217 | |||
218 | pub fn syntax(&self) -> SyntaxToken<'a> { | ||
219 | self.0 | ||
220 | } | ||
221 | |||
222 | pub fn text(&self) -> &'a SmolStr { | ||
223 | self.0.text() | ||
224 | } | ||
225 | |||
226 | pub fn flavor(&self) -> CommentFlavor { | ||
227 | let text = self.text(); | ||
228 | if text.starts_with("///") { | ||
229 | CommentFlavor::Doc | ||
230 | } else if text.starts_with("//!") { | ||
231 | CommentFlavor::ModuleDoc | ||
232 | } else if text.starts_with("//") { | ||
233 | CommentFlavor::Line | ||
234 | } else { | ||
235 | CommentFlavor::Multiline | ||
236 | } | ||
237 | } | ||
238 | |||
239 | pub fn is_doc_comment(&self) -> bool { | ||
240 | self.flavor().is_doc_comment() | ||
241 | } | ||
242 | |||
243 | pub fn prefix(&self) -> &'static str { | ||
244 | self.flavor().prefix() | ||
245 | } | ||
246 | } | ||
247 | |||
248 | pub struct CommentIter<'a> { | ||
249 | iter: SyntaxElementChildren<'a>, | ||
250 | } | ||
251 | |||
252 | impl<'a> Iterator for CommentIter<'a> { | ||
253 | type Item = Comment<'a>; | ||
254 | fn next(&mut self) -> Option<Comment<'a>> { | ||
255 | self.iter.by_ref().find_map(|el| el.as_token().and_then(Comment::cast)) | ||
256 | } | ||
257 | } | ||
258 | |||
259 | #[derive(Debug, PartialEq, Eq)] | ||
260 | pub enum CommentFlavor { | ||
261 | Line, | ||
262 | Doc, | ||
263 | ModuleDoc, | ||
264 | Multiline, | ||
265 | } | ||
266 | |||
267 | impl CommentFlavor { | ||
268 | pub fn prefix(&self) -> &'static str { | ||
269 | use self::CommentFlavor::*; | ||
270 | match *self { | ||
271 | Line => "//", | ||
272 | Doc => "///", | ||
273 | ModuleDoc => "//!", | ||
274 | Multiline => "/*", | ||
275 | } | ||
276 | } | ||
277 | |||
278 | pub fn is_doc_comment(&self) -> bool { | ||
279 | match self { | ||
280 | CommentFlavor::Doc | CommentFlavor::ModuleDoc => true, | ||
281 | _ => false, | ||
282 | } | ||
283 | } | ||
284 | } | ||
285 | |||
286 | pub struct Whitespace<'a>(SyntaxToken<'a>); | ||
287 | |||
288 | impl<'a> Whitespace<'a> { | ||
289 | pub fn cast(token: SyntaxToken<'a>) -> Option<Self> { | ||
290 | if token.kind() == WHITESPACE { | ||
291 | Some(Whitespace(token)) | ||
292 | } else { | ||
293 | None | ||
294 | } | ||
295 | } | ||
296 | |||
297 | pub fn syntax(&self) -> SyntaxToken<'a> { | ||
298 | self.0 | ||
299 | } | ||
300 | |||
301 | pub fn text(&self) -> &'a SmolStr { | ||
302 | self.0.text() | ||
303 | } | ||
304 | |||
305 | pub fn spans_multiple_lines(&self) -> bool { | ||
306 | let text = self.text(); | ||
307 | text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n')) | ||
308 | } | ||
309 | } | ||
310 | |||
311 | impl Name { | 111 | impl Name { |
312 | pub fn text(&self) -> &SmolStr { | 112 | pub fn text(&self) -> &SmolStr { |
313 | let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); | 113 | let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap(); |
@@ -468,29 +268,6 @@ fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> { | |||
468 | AstChildren::new(parent.syntax()) | 268 | AstChildren::new(parent.syntax()) |
469 | } | 269 | } |
470 | 270 | ||
471 | #[derive(Debug)] | ||
472 | pub struct AstChildren<'a, N> { | ||
473 | inner: SyntaxNodeChildren<'a>, | ||
474 | ph: PhantomData<N>, | ||
475 | } | ||
476 | |||
477 | impl<'a, N> AstChildren<'a, N> { | ||
478 | fn new(parent: &'a SyntaxNode) -> Self { | ||
479 | AstChildren { inner: parent.children(), ph: PhantomData } | ||
480 | } | ||
481 | } | ||
482 | |||
483 | impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> { | ||
484 | type Item = &'a N; | ||
485 | fn next(&mut self) -> Option<&'a N> { | ||
486 | loop { | ||
487 | if let Some(n) = N::cast(self.inner.next()?) { | ||
488 | return Some(n); | ||
489 | } | ||
490 | } | ||
491 | } | ||
492 | } | ||
493 | |||
494 | #[derive(Debug, Clone, PartialEq, Eq)] | 271 | #[derive(Debug, Clone, PartialEq, Eq)] |
495 | pub enum StructFlavor<'a> { | 272 | pub enum StructFlavor<'a> { |
496 | Tuple(&'a PosFieldDefList), | 273 | Tuple(&'a PosFieldDefList), |