diff options
author | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-01-08 09:05:55 +0000 |
---|---|---|
committer | bors[bot] <bors[bot]@users.noreply.github.com> | 2019-01-08 09:05:55 +0000 |
commit | 3f4be819125ce4a22edd86721fa56b5caba99c2e (patch) | |
tree | be93895ddc08c911585d9f7bc64623a3741f32c6 /crates/ra_syntax/src/ast/generated.rs | |
parent | 4e444d2bc24d16284401444fd2154f63e0f96070 (diff) | |
parent | 122410d7aa34a32d468a3173858cbc8a2bbc68f5 (diff) |
Merge #449
449: switch to new rowan API r=matklad a=matklad
closes https://github.com/rust-analyzer/rust-analyzer/issues/448
Co-authored-by: Aleksey Kladov <[email protected]>
Diffstat (limited to 'crates/ra_syntax/src/ast/generated.rs')
-rw-r--r-- | crates/ra_syntax/src/ast/generated.rs | 4843 |
1 files changed, 1791 insertions, 3052 deletions
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index 24f72393a..5e96ab142 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs | |||
@@ -9,4648 +9,3387 @@ | |||
9 | 9 | ||
10 | #![cfg_attr(rustfmt, rustfmt_skip)] | 10 | #![cfg_attr(rustfmt, rustfmt_skip)] |
11 | 11 | ||
12 | use std::hash::{Hash, Hasher}; | 12 | use rowan::TransparentNewType; |
13 | 13 | ||
14 | use crate::{ | 14 | use crate::{ |
15 | ast, | 15 | SyntaxNode, SyntaxKind::*, |
16 | SyntaxNode, SyntaxNodeRef, AstNode, | 16 | yellow::{RaTypes, TreePtr}, |
17 | yellow::{TreeRoot, RaTypes, OwnedRoot, RefRoot}, | 17 | ast::{self, AstNode}, |
18 | SyntaxKind::*, | ||
19 | }; | 18 | }; |
20 | 19 | ||
21 | // ArgList | 20 | // ArgList |
22 | #[derive(Debug, Clone, Copy,)] | 21 | #[derive(Debug, PartialEq, Eq, Hash)] |
23 | pub struct ArgListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 22 | #[repr(transparent)] |
24 | pub(crate) syntax: SyntaxNode<R>, | 23 | pub struct ArgList { |
24 | pub(crate) syntax: SyntaxNode, | ||
25 | } | 25 | } |
26 | pub type ArgList<'a> = ArgListNode<RefRoot<'a>>; | 26 | unsafe impl TransparentNewType for ArgList { |
27 | 27 | type Repr = rowan::SyntaxNode<RaTypes>; | |
28 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArgListNode<R1>> for ArgListNode<R2> { | ||
29 | fn eq(&self, other: &ArgListNode<R1>) -> bool { self.syntax == other.syntax } | ||
30 | } | ||
31 | impl<R: TreeRoot<RaTypes>> Eq for ArgListNode<R> {} | ||
32 | impl<R: TreeRoot<RaTypes>> Hash for ArgListNode<R> { | ||
33 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
34 | } | 28 | } |
35 | 29 | ||
36 | impl<'a> AstNode<'a> for ArgList<'a> { | 30 | impl AstNode for ArgList { |
37 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 31 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
38 | match syntax.kind() { | 32 | match syntax.kind() { |
39 | ARG_LIST => Some(ArgList { syntax }), | 33 | ARG_LIST => Some(ArgList::from_repr(syntax.into_repr())), |
40 | _ => None, | 34 | _ => None, |
41 | } | 35 | } |
42 | } | 36 | } |
43 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 37 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
44 | } | 38 | fn to_owned(&self) -> TreePtr<ArgList> { TreePtr::cast(self.syntax.to_owned()) } |
45 | |||
46 | impl<R: TreeRoot<RaTypes>> ArgListNode<R> { | ||
47 | pub fn borrowed(&self) -> ArgList { | ||
48 | ArgListNode { syntax: self.syntax.borrowed() } | ||
49 | } | ||
50 | pub fn owned(&self) -> ArgListNode { | ||
51 | ArgListNode { syntax: self.syntax.owned() } | ||
52 | } | ||
53 | } | 39 | } |
54 | 40 | ||
55 | 41 | ||
56 | impl<'a> ArgList<'a> { | 42 | impl ArgList { |
57 | pub fn args(self) -> impl Iterator<Item = Expr<'a>> + 'a { | 43 | pub fn args(&self) -> impl Iterator<Item = &Expr> { |
58 | super::children(self) | 44 | super::children(self) |
59 | } | 45 | } |
60 | } | 46 | } |
61 | 47 | ||
62 | // ArrayExpr | 48 | // ArrayExpr |
63 | #[derive(Debug, Clone, Copy,)] | 49 | #[derive(Debug, PartialEq, Eq, Hash)] |
64 | pub struct ArrayExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 50 | #[repr(transparent)] |
65 | pub(crate) syntax: SyntaxNode<R>, | 51 | pub struct ArrayExpr { |
52 | pub(crate) syntax: SyntaxNode, | ||
66 | } | 53 | } |
67 | pub type ArrayExpr<'a> = ArrayExprNode<RefRoot<'a>>; | 54 | unsafe impl TransparentNewType for ArrayExpr { |
68 | 55 | type Repr = rowan::SyntaxNode<RaTypes>; | |
69 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayExprNode<R1>> for ArrayExprNode<R2> { | ||
70 | fn eq(&self, other: &ArrayExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
71 | } | ||
72 | impl<R: TreeRoot<RaTypes>> Eq for ArrayExprNode<R> {} | ||
73 | impl<R: TreeRoot<RaTypes>> Hash for ArrayExprNode<R> { | ||
74 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
75 | } | 56 | } |
76 | 57 | ||
77 | impl<'a> AstNode<'a> for ArrayExpr<'a> { | 58 | impl AstNode for ArrayExpr { |
78 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 59 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
79 | match syntax.kind() { | 60 | match syntax.kind() { |
80 | ARRAY_EXPR => Some(ArrayExpr { syntax }), | 61 | ARRAY_EXPR => Some(ArrayExpr::from_repr(syntax.into_repr())), |
81 | _ => None, | 62 | _ => None, |
82 | } | 63 | } |
83 | } | 64 | } |
84 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 65 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
85 | } | 66 | fn to_owned(&self) -> TreePtr<ArrayExpr> { TreePtr::cast(self.syntax.to_owned()) } |
86 | |||
87 | impl<R: TreeRoot<RaTypes>> ArrayExprNode<R> { | ||
88 | pub fn borrowed(&self) -> ArrayExpr { | ||
89 | ArrayExprNode { syntax: self.syntax.borrowed() } | ||
90 | } | ||
91 | pub fn owned(&self) -> ArrayExprNode { | ||
92 | ArrayExprNode { syntax: self.syntax.owned() } | ||
93 | } | ||
94 | } | 67 | } |
95 | 68 | ||
96 | 69 | ||
97 | impl<'a> ArrayExpr<'a> {} | 70 | impl ArrayExpr {} |
98 | 71 | ||
99 | // ArrayType | 72 | // ArrayType |
100 | #[derive(Debug, Clone, Copy,)] | 73 | #[derive(Debug, PartialEq, Eq, Hash)] |
101 | pub struct ArrayTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 74 | #[repr(transparent)] |
102 | pub(crate) syntax: SyntaxNode<R>, | 75 | pub struct ArrayType { |
103 | } | 76 | pub(crate) syntax: SyntaxNode, |
104 | pub type ArrayType<'a> = ArrayTypeNode<RefRoot<'a>>; | ||
105 | |||
106 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayTypeNode<R1>> for ArrayTypeNode<R2> { | ||
107 | fn eq(&self, other: &ArrayTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
108 | } | 77 | } |
109 | impl<R: TreeRoot<RaTypes>> Eq for ArrayTypeNode<R> {} | 78 | unsafe impl TransparentNewType for ArrayType { |
110 | impl<R: TreeRoot<RaTypes>> Hash for ArrayTypeNode<R> { | 79 | type Repr = rowan::SyntaxNode<RaTypes>; |
111 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
112 | } | 80 | } |
113 | 81 | ||
114 | impl<'a> AstNode<'a> for ArrayType<'a> { | 82 | impl AstNode for ArrayType { |
115 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 83 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
116 | match syntax.kind() { | 84 | match syntax.kind() { |
117 | ARRAY_TYPE => Some(ArrayType { syntax }), | 85 | ARRAY_TYPE => Some(ArrayType::from_repr(syntax.into_repr())), |
118 | _ => None, | 86 | _ => None, |
119 | } | 87 | } |
120 | } | 88 | } |
121 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 89 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
90 | fn to_owned(&self) -> TreePtr<ArrayType> { TreePtr::cast(self.syntax.to_owned()) } | ||
122 | } | 91 | } |
123 | 92 | ||
124 | impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> { | ||
125 | pub fn borrowed(&self) -> ArrayType { | ||
126 | ArrayTypeNode { syntax: self.syntax.borrowed() } | ||
127 | } | ||
128 | pub fn owned(&self) -> ArrayTypeNode { | ||
129 | ArrayTypeNode { syntax: self.syntax.owned() } | ||
130 | } | ||
131 | } | ||
132 | 93 | ||
133 | 94 | impl ArrayType { | |
134 | impl<'a> ArrayType<'a> { | 95 | pub fn type_ref(&self) -> Option<&TypeRef> { |
135 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | ||
136 | super::child_opt(self) | 96 | super::child_opt(self) |
137 | } | 97 | } |
138 | 98 | ||
139 | pub fn expr(self) -> Option<Expr<'a>> { | 99 | pub fn expr(&self) -> Option<&Expr> { |
140 | super::child_opt(self) | 100 | super::child_opt(self) |
141 | } | 101 | } |
142 | } | 102 | } |
143 | 103 | ||
144 | // Attr | 104 | // Attr |
145 | #[derive(Debug, Clone, Copy,)] | 105 | #[derive(Debug, PartialEq, Eq, Hash)] |
146 | pub struct AttrNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 106 | #[repr(transparent)] |
147 | pub(crate) syntax: SyntaxNode<R>, | 107 | pub struct Attr { |
148 | } | 108 | pub(crate) syntax: SyntaxNode, |
149 | pub type Attr<'a> = AttrNode<RefRoot<'a>>; | ||
150 | |||
151 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<AttrNode<R1>> for AttrNode<R2> { | ||
152 | fn eq(&self, other: &AttrNode<R1>) -> bool { self.syntax == other.syntax } | ||
153 | } | 109 | } |
154 | impl<R: TreeRoot<RaTypes>> Eq for AttrNode<R> {} | 110 | unsafe impl TransparentNewType for Attr { |
155 | impl<R: TreeRoot<RaTypes>> Hash for AttrNode<R> { | 111 | type Repr = rowan::SyntaxNode<RaTypes>; |
156 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
157 | } | 112 | } |
158 | 113 | ||
159 | impl<'a> AstNode<'a> for Attr<'a> { | 114 | impl AstNode for Attr { |
160 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 115 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
161 | match syntax.kind() { | 116 | match syntax.kind() { |
162 | ATTR => Some(Attr { syntax }), | 117 | ATTR => Some(Attr::from_repr(syntax.into_repr())), |
163 | _ => None, | 118 | _ => None, |
164 | } | 119 | } |
165 | } | 120 | } |
166 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 121 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
167 | } | 122 | fn to_owned(&self) -> TreePtr<Attr> { TreePtr::cast(self.syntax.to_owned()) } |
168 | |||
169 | impl<R: TreeRoot<RaTypes>> AttrNode<R> { | ||
170 | pub fn borrowed(&self) -> Attr { | ||
171 | AttrNode { syntax: self.syntax.borrowed() } | ||
172 | } | ||
173 | pub fn owned(&self) -> AttrNode { | ||
174 | AttrNode { syntax: self.syntax.owned() } | ||
175 | } | ||
176 | } | 123 | } |
177 | 124 | ||
178 | 125 | ||
179 | impl<'a> Attr<'a> { | 126 | impl Attr { |
180 | pub fn value(self) -> Option<TokenTree<'a>> { | 127 | pub fn value(&self) -> Option<&TokenTree> { |
181 | super::child_opt(self) | 128 | super::child_opt(self) |
182 | } | 129 | } |
183 | } | 130 | } |
184 | 131 | ||
185 | // BinExpr | 132 | // BinExpr |
186 | #[derive(Debug, Clone, Copy,)] | 133 | #[derive(Debug, PartialEq, Eq, Hash)] |
187 | pub struct BinExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 134 | #[repr(transparent)] |
188 | pub(crate) syntax: SyntaxNode<R>, | 135 | pub struct BinExpr { |
189 | } | 136 | pub(crate) syntax: SyntaxNode, |
190 | pub type BinExpr<'a> = BinExprNode<RefRoot<'a>>; | ||
191 | |||
192 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BinExprNode<R1>> for BinExprNode<R2> { | ||
193 | fn eq(&self, other: &BinExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
194 | } | 137 | } |
195 | impl<R: TreeRoot<RaTypes>> Eq for BinExprNode<R> {} | 138 | unsafe impl TransparentNewType for BinExpr { |
196 | impl<R: TreeRoot<RaTypes>> Hash for BinExprNode<R> { | 139 | type Repr = rowan::SyntaxNode<RaTypes>; |
197 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
198 | } | 140 | } |
199 | 141 | ||
200 | impl<'a> AstNode<'a> for BinExpr<'a> { | 142 | impl AstNode for BinExpr { |
201 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 143 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
202 | match syntax.kind() { | 144 | match syntax.kind() { |
203 | BIN_EXPR => Some(BinExpr { syntax }), | 145 | BIN_EXPR => Some(BinExpr::from_repr(syntax.into_repr())), |
204 | _ => None, | 146 | _ => None, |
205 | } | 147 | } |
206 | } | 148 | } |
207 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 149 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
208 | } | 150 | fn to_owned(&self) -> TreePtr<BinExpr> { TreePtr::cast(self.syntax.to_owned()) } |
209 | |||
210 | impl<R: TreeRoot<RaTypes>> BinExprNode<R> { | ||
211 | pub fn borrowed(&self) -> BinExpr { | ||
212 | BinExprNode { syntax: self.syntax.borrowed() } | ||
213 | } | ||
214 | pub fn owned(&self) -> BinExprNode { | ||
215 | BinExprNode { syntax: self.syntax.owned() } | ||
216 | } | ||
217 | } | 151 | } |
218 | 152 | ||
219 | 153 | ||
220 | impl<'a> BinExpr<'a> {} | 154 | impl BinExpr {} |
221 | 155 | ||
222 | // BindPat | 156 | // BindPat |
223 | #[derive(Debug, Clone, Copy,)] | 157 | #[derive(Debug, PartialEq, Eq, Hash)] |
224 | pub struct BindPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 158 | #[repr(transparent)] |
225 | pub(crate) syntax: SyntaxNode<R>, | 159 | pub struct BindPat { |
160 | pub(crate) syntax: SyntaxNode, | ||
226 | } | 161 | } |
227 | pub type BindPat<'a> = BindPatNode<RefRoot<'a>>; | 162 | unsafe impl TransparentNewType for BindPat { |
228 | 163 | type Repr = rowan::SyntaxNode<RaTypes>; | |
229 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BindPatNode<R1>> for BindPatNode<R2> { | ||
230 | fn eq(&self, other: &BindPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
231 | } | ||
232 | impl<R: TreeRoot<RaTypes>> Eq for BindPatNode<R> {} | ||
233 | impl<R: TreeRoot<RaTypes>> Hash for BindPatNode<R> { | ||
234 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
235 | } | 164 | } |
236 | 165 | ||
237 | impl<'a> AstNode<'a> for BindPat<'a> { | 166 | impl AstNode for BindPat { |
238 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 167 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
239 | match syntax.kind() { | 168 | match syntax.kind() { |
240 | BIND_PAT => Some(BindPat { syntax }), | 169 | BIND_PAT => Some(BindPat::from_repr(syntax.into_repr())), |
241 | _ => None, | 170 | _ => None, |
242 | } | 171 | } |
243 | } | 172 | } |
244 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 173 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
245 | } | 174 | fn to_owned(&self) -> TreePtr<BindPat> { TreePtr::cast(self.syntax.to_owned()) } |
246 | |||
247 | impl<R: TreeRoot<RaTypes>> BindPatNode<R> { | ||
248 | pub fn borrowed(&self) -> BindPat { | ||
249 | BindPatNode { syntax: self.syntax.borrowed() } | ||
250 | } | ||
251 | pub fn owned(&self) -> BindPatNode { | ||
252 | BindPatNode { syntax: self.syntax.owned() } | ||
253 | } | ||
254 | } | 175 | } |
255 | 176 | ||
256 | 177 | ||
257 | impl<'a> ast::NameOwner<'a> for BindPat<'a> {} | 178 | impl ast::NameOwner for BindPat {} |
258 | impl<'a> BindPat<'a> {} | 179 | impl BindPat {} |
259 | 180 | ||
260 | // Block | 181 | // Block |
261 | #[derive(Debug, Clone, Copy,)] | 182 | #[derive(Debug, PartialEq, Eq, Hash)] |
262 | pub struct BlockNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 183 | #[repr(transparent)] |
263 | pub(crate) syntax: SyntaxNode<R>, | 184 | pub struct Block { |
264 | } | 185 | pub(crate) syntax: SyntaxNode, |
265 | pub type Block<'a> = BlockNode<RefRoot<'a>>; | ||
266 | |||
267 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockNode<R1>> for BlockNode<R2> { | ||
268 | fn eq(&self, other: &BlockNode<R1>) -> bool { self.syntax == other.syntax } | ||
269 | } | 186 | } |
270 | impl<R: TreeRoot<RaTypes>> Eq for BlockNode<R> {} | 187 | unsafe impl TransparentNewType for Block { |
271 | impl<R: TreeRoot<RaTypes>> Hash for BlockNode<R> { | 188 | type Repr = rowan::SyntaxNode<RaTypes>; |
272 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
273 | } | 189 | } |
274 | 190 | ||
275 | impl<'a> AstNode<'a> for Block<'a> { | 191 | impl AstNode for Block { |
276 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 192 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
277 | match syntax.kind() { | 193 | match syntax.kind() { |
278 | BLOCK => Some(Block { syntax }), | 194 | BLOCK => Some(Block::from_repr(syntax.into_repr())), |
279 | _ => None, | 195 | _ => None, |
280 | } | 196 | } |
281 | } | 197 | } |
282 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 198 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
199 | fn to_owned(&self) -> TreePtr<Block> { TreePtr::cast(self.syntax.to_owned()) } | ||
283 | } | 200 | } |
284 | 201 | ||
285 | impl<R: TreeRoot<RaTypes>> BlockNode<R> { | ||
286 | pub fn borrowed(&self) -> Block { | ||
287 | BlockNode { syntax: self.syntax.borrowed() } | ||
288 | } | ||
289 | pub fn owned(&self) -> BlockNode { | ||
290 | BlockNode { syntax: self.syntax.owned() } | ||
291 | } | ||
292 | } | ||
293 | 202 | ||
294 | 203 | impl Block { | |
295 | impl<'a> Block<'a> { | 204 | pub fn statements(&self) -> impl Iterator<Item = &Stmt> { |
296 | pub fn statements(self) -> impl Iterator<Item = Stmt<'a>> + 'a { | ||
297 | super::children(self) | 205 | super::children(self) |
298 | } | 206 | } |
299 | 207 | ||
300 | pub fn expr(self) -> Option<Expr<'a>> { | 208 | pub fn expr(&self) -> Option<&Expr> { |
301 | super::child_opt(self) | 209 | super::child_opt(self) |
302 | } | 210 | } |
303 | } | 211 | } |
304 | 212 | ||
305 | // BlockExpr | 213 | // BlockExpr |
306 | #[derive(Debug, Clone, Copy,)] | 214 | #[derive(Debug, PartialEq, Eq, Hash)] |
307 | pub struct BlockExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 215 | #[repr(transparent)] |
308 | pub(crate) syntax: SyntaxNode<R>, | 216 | pub struct BlockExpr { |
217 | pub(crate) syntax: SyntaxNode, | ||
309 | } | 218 | } |
310 | pub type BlockExpr<'a> = BlockExprNode<RefRoot<'a>>; | 219 | unsafe impl TransparentNewType for BlockExpr { |
311 | 220 | type Repr = rowan::SyntaxNode<RaTypes>; | |
312 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockExprNode<R1>> for BlockExprNode<R2> { | ||
313 | fn eq(&self, other: &BlockExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
314 | } | ||
315 | impl<R: TreeRoot<RaTypes>> Eq for BlockExprNode<R> {} | ||
316 | impl<R: TreeRoot<RaTypes>> Hash for BlockExprNode<R> { | ||
317 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
318 | } | 221 | } |
319 | 222 | ||
320 | impl<'a> AstNode<'a> for BlockExpr<'a> { | 223 | impl AstNode for BlockExpr { |
321 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 224 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
322 | match syntax.kind() { | 225 | match syntax.kind() { |
323 | BLOCK_EXPR => Some(BlockExpr { syntax }), | 226 | BLOCK_EXPR => Some(BlockExpr::from_repr(syntax.into_repr())), |
324 | _ => None, | 227 | _ => None, |
325 | } | 228 | } |
326 | } | 229 | } |
327 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 230 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
328 | } | 231 | fn to_owned(&self) -> TreePtr<BlockExpr> { TreePtr::cast(self.syntax.to_owned()) } |
329 | |||
330 | impl<R: TreeRoot<RaTypes>> BlockExprNode<R> { | ||
331 | pub fn borrowed(&self) -> BlockExpr { | ||
332 | BlockExprNode { syntax: self.syntax.borrowed() } | ||
333 | } | ||
334 | pub fn owned(&self) -> BlockExprNode { | ||
335 | BlockExprNode { syntax: self.syntax.owned() } | ||
336 | } | ||
337 | } | 232 | } |
338 | 233 | ||
339 | 234 | ||
340 | impl<'a> BlockExpr<'a> { | 235 | impl BlockExpr { |
341 | pub fn block(self) -> Option<Block<'a>> { | 236 | pub fn block(&self) -> Option<&Block> { |
342 | super::child_opt(self) | 237 | super::child_opt(self) |
343 | } | 238 | } |
344 | } | 239 | } |
345 | 240 | ||
346 | // BreakExpr | 241 | // BreakExpr |
347 | #[derive(Debug, Clone, Copy,)] | 242 | #[derive(Debug, PartialEq, Eq, Hash)] |
348 | pub struct BreakExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 243 | #[repr(transparent)] |
349 | pub(crate) syntax: SyntaxNode<R>, | 244 | pub struct BreakExpr { |
245 | pub(crate) syntax: SyntaxNode, | ||
350 | } | 246 | } |
351 | pub type BreakExpr<'a> = BreakExprNode<RefRoot<'a>>; | 247 | unsafe impl TransparentNewType for BreakExpr { |
352 | 248 | type Repr = rowan::SyntaxNode<RaTypes>; | |
353 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BreakExprNode<R1>> for BreakExprNode<R2> { | ||
354 | fn eq(&self, other: &BreakExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
355 | } | ||
356 | impl<R: TreeRoot<RaTypes>> Eq for BreakExprNode<R> {} | ||
357 | impl<R: TreeRoot<RaTypes>> Hash for BreakExprNode<R> { | ||
358 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
359 | } | 249 | } |
360 | 250 | ||
361 | impl<'a> AstNode<'a> for BreakExpr<'a> { | 251 | impl AstNode for BreakExpr { |
362 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 252 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
363 | match syntax.kind() { | 253 | match syntax.kind() { |
364 | BREAK_EXPR => Some(BreakExpr { syntax }), | 254 | BREAK_EXPR => Some(BreakExpr::from_repr(syntax.into_repr())), |
365 | _ => None, | 255 | _ => None, |
366 | } | 256 | } |
367 | } | 257 | } |
368 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 258 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
369 | } | 259 | fn to_owned(&self) -> TreePtr<BreakExpr> { TreePtr::cast(self.syntax.to_owned()) } |
370 | |||
371 | impl<R: TreeRoot<RaTypes>> BreakExprNode<R> { | ||
372 | pub fn borrowed(&self) -> BreakExpr { | ||
373 | BreakExprNode { syntax: self.syntax.borrowed() } | ||
374 | } | ||
375 | pub fn owned(&self) -> BreakExprNode { | ||
376 | BreakExprNode { syntax: self.syntax.owned() } | ||
377 | } | ||
378 | } | 260 | } |
379 | 261 | ||
380 | 262 | ||
381 | impl<'a> BreakExpr<'a> { | 263 | impl BreakExpr { |
382 | pub fn expr(self) -> Option<Expr<'a>> { | 264 | pub fn expr(&self) -> Option<&Expr> { |
383 | super::child_opt(self) | 265 | super::child_opt(self) |
384 | } | 266 | } |
385 | } | 267 | } |
386 | 268 | ||
387 | // Byte | 269 | // Byte |
388 | #[derive(Debug, Clone, Copy,)] | 270 | #[derive(Debug, PartialEq, Eq, Hash)] |
389 | pub struct ByteNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 271 | #[repr(transparent)] |
390 | pub(crate) syntax: SyntaxNode<R>, | 272 | pub struct Byte { |
273 | pub(crate) syntax: SyntaxNode, | ||
391 | } | 274 | } |
392 | pub type Byte<'a> = ByteNode<RefRoot<'a>>; | 275 | unsafe impl TransparentNewType for Byte { |
393 | 276 | type Repr = rowan::SyntaxNode<RaTypes>; | |
394 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteNode<R1>> for ByteNode<R2> { | ||
395 | fn eq(&self, other: &ByteNode<R1>) -> bool { self.syntax == other.syntax } | ||
396 | } | ||
397 | impl<R: TreeRoot<RaTypes>> Eq for ByteNode<R> {} | ||
398 | impl<R: TreeRoot<RaTypes>> Hash for ByteNode<R> { | ||
399 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
400 | } | 277 | } |
401 | 278 | ||
402 | impl<'a> AstNode<'a> for Byte<'a> { | 279 | impl AstNode for Byte { |
403 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 280 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
404 | match syntax.kind() { | 281 | match syntax.kind() { |
405 | BYTE => Some(Byte { syntax }), | 282 | BYTE => Some(Byte::from_repr(syntax.into_repr())), |
406 | _ => None, | 283 | _ => None, |
407 | } | 284 | } |
408 | } | 285 | } |
409 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 286 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
410 | } | 287 | fn to_owned(&self) -> TreePtr<Byte> { TreePtr::cast(self.syntax.to_owned()) } |
411 | |||
412 | impl<R: TreeRoot<RaTypes>> ByteNode<R> { | ||
413 | pub fn borrowed(&self) -> Byte { | ||
414 | ByteNode { syntax: self.syntax.borrowed() } | ||
415 | } | ||
416 | pub fn owned(&self) -> ByteNode { | ||
417 | ByteNode { syntax: self.syntax.owned() } | ||
418 | } | ||
419 | } | 288 | } |
420 | 289 | ||
421 | 290 | ||
422 | impl<'a> Byte<'a> {} | 291 | impl Byte {} |
423 | 292 | ||
424 | // ByteString | 293 | // ByteString |
425 | #[derive(Debug, Clone, Copy,)] | 294 | #[derive(Debug, PartialEq, Eq, Hash)] |
426 | pub struct ByteStringNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 295 | #[repr(transparent)] |
427 | pub(crate) syntax: SyntaxNode<R>, | 296 | pub struct ByteString { |
428 | } | 297 | pub(crate) syntax: SyntaxNode, |
429 | pub type ByteString<'a> = ByteStringNode<RefRoot<'a>>; | ||
430 | |||
431 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteStringNode<R1>> for ByteStringNode<R2> { | ||
432 | fn eq(&self, other: &ByteStringNode<R1>) -> bool { self.syntax == other.syntax } | ||
433 | } | 298 | } |
434 | impl<R: TreeRoot<RaTypes>> Eq for ByteStringNode<R> {} | 299 | unsafe impl TransparentNewType for ByteString { |
435 | impl<R: TreeRoot<RaTypes>> Hash for ByteStringNode<R> { | 300 | type Repr = rowan::SyntaxNode<RaTypes>; |
436 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
437 | } | 301 | } |
438 | 302 | ||
439 | impl<'a> AstNode<'a> for ByteString<'a> { | 303 | impl AstNode for ByteString { |
440 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 304 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
441 | match syntax.kind() { | 305 | match syntax.kind() { |
442 | BYTE_STRING => Some(ByteString { syntax }), | 306 | BYTE_STRING => Some(ByteString::from_repr(syntax.into_repr())), |
443 | _ => None, | 307 | _ => None, |
444 | } | 308 | } |
445 | } | 309 | } |
446 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 310 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
447 | } | 311 | fn to_owned(&self) -> TreePtr<ByteString> { TreePtr::cast(self.syntax.to_owned()) } |
448 | |||
449 | impl<R: TreeRoot<RaTypes>> ByteStringNode<R> { | ||
450 | pub fn borrowed(&self) -> ByteString { | ||
451 | ByteStringNode { syntax: self.syntax.borrowed() } | ||
452 | } | ||
453 | pub fn owned(&self) -> ByteStringNode { | ||
454 | ByteStringNode { syntax: self.syntax.owned() } | ||
455 | } | ||
456 | } | 312 | } |
457 | 313 | ||
458 | 314 | ||
459 | impl<'a> ByteString<'a> {} | 315 | impl ByteString {} |
460 | 316 | ||
461 | // CallExpr | 317 | // CallExpr |
462 | #[derive(Debug, Clone, Copy,)] | 318 | #[derive(Debug, PartialEq, Eq, Hash)] |
463 | pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 319 | #[repr(transparent)] |
464 | pub(crate) syntax: SyntaxNode<R>, | 320 | pub struct CallExpr { |
465 | } | 321 | pub(crate) syntax: SyntaxNode, |
466 | pub type CallExpr<'a> = CallExprNode<RefRoot<'a>>; | ||
467 | |||
468 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CallExprNode<R1>> for CallExprNode<R2> { | ||
469 | fn eq(&self, other: &CallExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
470 | } | 322 | } |
471 | impl<R: TreeRoot<RaTypes>> Eq for CallExprNode<R> {} | 323 | unsafe impl TransparentNewType for CallExpr { |
472 | impl<R: TreeRoot<RaTypes>> Hash for CallExprNode<R> { | 324 | type Repr = rowan::SyntaxNode<RaTypes>; |
473 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
474 | } | 325 | } |
475 | 326 | ||
476 | impl<'a> AstNode<'a> for CallExpr<'a> { | 327 | impl AstNode for CallExpr { |
477 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 328 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
478 | match syntax.kind() { | 329 | match syntax.kind() { |
479 | CALL_EXPR => Some(CallExpr { syntax }), | 330 | CALL_EXPR => Some(CallExpr::from_repr(syntax.into_repr())), |
480 | _ => None, | 331 | _ => None, |
481 | } | 332 | } |
482 | } | 333 | } |
483 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 334 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
484 | } | 335 | fn to_owned(&self) -> TreePtr<CallExpr> { TreePtr::cast(self.syntax.to_owned()) } |
485 | |||
486 | impl<R: TreeRoot<RaTypes>> CallExprNode<R> { | ||
487 | pub fn borrowed(&self) -> CallExpr { | ||
488 | CallExprNode { syntax: self.syntax.borrowed() } | ||
489 | } | ||
490 | pub fn owned(&self) -> CallExprNode { | ||
491 | CallExprNode { syntax: self.syntax.owned() } | ||
492 | } | ||
493 | } | 336 | } |
494 | 337 | ||
495 | 338 | ||
496 | impl<'a> ast::ArgListOwner<'a> for CallExpr<'a> {} | 339 | impl ast::ArgListOwner for CallExpr {} |
497 | impl<'a> CallExpr<'a> { | 340 | impl CallExpr { |
498 | pub fn expr(self) -> Option<Expr<'a>> { | 341 | pub fn expr(&self) -> Option<&Expr> { |
499 | super::child_opt(self) | 342 | super::child_opt(self) |
500 | } | 343 | } |
501 | } | 344 | } |
502 | 345 | ||
503 | // CastExpr | 346 | // CastExpr |
504 | #[derive(Debug, Clone, Copy,)] | 347 | #[derive(Debug, PartialEq, Eq, Hash)] |
505 | pub struct CastExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 348 | #[repr(transparent)] |
506 | pub(crate) syntax: SyntaxNode<R>, | 349 | pub struct CastExpr { |
350 | pub(crate) syntax: SyntaxNode, | ||
507 | } | 351 | } |
508 | pub type CastExpr<'a> = CastExprNode<RefRoot<'a>>; | 352 | unsafe impl TransparentNewType for CastExpr { |
509 | 353 | type Repr = rowan::SyntaxNode<RaTypes>; | |
510 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CastExprNode<R1>> for CastExprNode<R2> { | ||
511 | fn eq(&self, other: &CastExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
512 | } | ||
513 | impl<R: TreeRoot<RaTypes>> Eq for CastExprNode<R> {} | ||
514 | impl<R: TreeRoot<RaTypes>> Hash for CastExprNode<R> { | ||
515 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
516 | } | 354 | } |
517 | 355 | ||
518 | impl<'a> AstNode<'a> for CastExpr<'a> { | 356 | impl AstNode for CastExpr { |
519 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 357 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
520 | match syntax.kind() { | 358 | match syntax.kind() { |
521 | CAST_EXPR => Some(CastExpr { syntax }), | 359 | CAST_EXPR => Some(CastExpr::from_repr(syntax.into_repr())), |
522 | _ => None, | 360 | _ => None, |
523 | } | 361 | } |
524 | } | 362 | } |
525 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 363 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
526 | } | 364 | fn to_owned(&self) -> TreePtr<CastExpr> { TreePtr::cast(self.syntax.to_owned()) } |
527 | |||
528 | impl<R: TreeRoot<RaTypes>> CastExprNode<R> { | ||
529 | pub fn borrowed(&self) -> CastExpr { | ||
530 | CastExprNode { syntax: self.syntax.borrowed() } | ||
531 | } | ||
532 | pub fn owned(&self) -> CastExprNode { | ||
533 | CastExprNode { syntax: self.syntax.owned() } | ||
534 | } | ||
535 | } | 365 | } |
536 | 366 | ||
537 | 367 | ||
538 | impl<'a> CastExpr<'a> { | 368 | impl CastExpr { |
539 | pub fn expr(self) -> Option<Expr<'a>> { | 369 | pub fn expr(&self) -> Option<&Expr> { |
540 | super::child_opt(self) | 370 | super::child_opt(self) |
541 | } | 371 | } |
542 | 372 | ||
543 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 373 | pub fn type_ref(&self) -> Option<&TypeRef> { |
544 | super::child_opt(self) | 374 | super::child_opt(self) |
545 | } | 375 | } |
546 | } | 376 | } |
547 | 377 | ||
548 | // Char | 378 | // Char |
549 | #[derive(Debug, Clone, Copy,)] | 379 | #[derive(Debug, PartialEq, Eq, Hash)] |
550 | pub struct CharNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 380 | #[repr(transparent)] |
551 | pub(crate) syntax: SyntaxNode<R>, | 381 | pub struct Char { |
552 | } | 382 | pub(crate) syntax: SyntaxNode, |
553 | pub type Char<'a> = CharNode<RefRoot<'a>>; | ||
554 | |||
555 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CharNode<R1>> for CharNode<R2> { | ||
556 | fn eq(&self, other: &CharNode<R1>) -> bool { self.syntax == other.syntax } | ||
557 | } | 383 | } |
558 | impl<R: TreeRoot<RaTypes>> Eq for CharNode<R> {} | 384 | unsafe impl TransparentNewType for Char { |
559 | impl<R: TreeRoot<RaTypes>> Hash for CharNode<R> { | 385 | type Repr = rowan::SyntaxNode<RaTypes>; |
560 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
561 | } | 386 | } |
562 | 387 | ||
563 | impl<'a> AstNode<'a> for Char<'a> { | 388 | impl AstNode for Char { |
564 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 389 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
565 | match syntax.kind() { | 390 | match syntax.kind() { |
566 | CHAR => Some(Char { syntax }), | 391 | CHAR => Some(Char::from_repr(syntax.into_repr())), |
567 | _ => None, | 392 | _ => None, |
568 | } | 393 | } |
569 | } | 394 | } |
570 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 395 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
396 | fn to_owned(&self) -> TreePtr<Char> { TreePtr::cast(self.syntax.to_owned()) } | ||
571 | } | 397 | } |
572 | 398 | ||
573 | impl<R: TreeRoot<RaTypes>> CharNode<R> { | ||
574 | pub fn borrowed(&self) -> Char { | ||
575 | CharNode { syntax: self.syntax.borrowed() } | ||
576 | } | ||
577 | pub fn owned(&self) -> CharNode { | ||
578 | CharNode { syntax: self.syntax.owned() } | ||
579 | } | ||
580 | } | ||
581 | 399 | ||
582 | 400 | impl Char {} | |
583 | impl<'a> Char<'a> {} | ||
584 | 401 | ||
585 | // Comment | 402 | // Comment |
586 | #[derive(Debug, Clone, Copy,)] | 403 | #[derive(Debug, PartialEq, Eq, Hash)] |
587 | pub struct CommentNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 404 | #[repr(transparent)] |
588 | pub(crate) syntax: SyntaxNode<R>, | 405 | pub struct Comment { |
589 | } | 406 | pub(crate) syntax: SyntaxNode, |
590 | pub type Comment<'a> = CommentNode<RefRoot<'a>>; | ||
591 | |||
592 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CommentNode<R1>> for CommentNode<R2> { | ||
593 | fn eq(&self, other: &CommentNode<R1>) -> bool { self.syntax == other.syntax } | ||
594 | } | 407 | } |
595 | impl<R: TreeRoot<RaTypes>> Eq for CommentNode<R> {} | 408 | unsafe impl TransparentNewType for Comment { |
596 | impl<R: TreeRoot<RaTypes>> Hash for CommentNode<R> { | 409 | type Repr = rowan::SyntaxNode<RaTypes>; |
597 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
598 | } | 410 | } |
599 | 411 | ||
600 | impl<'a> AstNode<'a> for Comment<'a> { | 412 | impl AstNode for Comment { |
601 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 413 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
602 | match syntax.kind() { | 414 | match syntax.kind() { |
603 | COMMENT => Some(Comment { syntax }), | 415 | COMMENT => Some(Comment::from_repr(syntax.into_repr())), |
604 | _ => None, | 416 | _ => None, |
605 | } | 417 | } |
606 | } | 418 | } |
607 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 419 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
608 | } | 420 | fn to_owned(&self) -> TreePtr<Comment> { TreePtr::cast(self.syntax.to_owned()) } |
609 | |||
610 | impl<R: TreeRoot<RaTypes>> CommentNode<R> { | ||
611 | pub fn borrowed(&self) -> Comment { | ||
612 | CommentNode { syntax: self.syntax.borrowed() } | ||
613 | } | ||
614 | pub fn owned(&self) -> CommentNode { | ||
615 | CommentNode { syntax: self.syntax.owned() } | ||
616 | } | ||
617 | } | 421 | } |
618 | 422 | ||
619 | 423 | ||
620 | impl<'a> Comment<'a> {} | 424 | impl Comment {} |
621 | 425 | ||
622 | // Condition | 426 | // Condition |
623 | #[derive(Debug, Clone, Copy,)] | 427 | #[derive(Debug, PartialEq, Eq, Hash)] |
624 | pub struct ConditionNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 428 | #[repr(transparent)] |
625 | pub(crate) syntax: SyntaxNode<R>, | 429 | pub struct Condition { |
430 | pub(crate) syntax: SyntaxNode, | ||
626 | } | 431 | } |
627 | pub type Condition<'a> = ConditionNode<RefRoot<'a>>; | 432 | unsafe impl TransparentNewType for Condition { |
628 | 433 | type Repr = rowan::SyntaxNode<RaTypes>; | |
629 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConditionNode<R1>> for ConditionNode<R2> { | ||
630 | fn eq(&self, other: &ConditionNode<R1>) -> bool { self.syntax == other.syntax } | ||
631 | } | ||
632 | impl<R: TreeRoot<RaTypes>> Eq for ConditionNode<R> {} | ||
633 | impl<R: TreeRoot<RaTypes>> Hash for ConditionNode<R> { | ||
634 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
635 | } | 434 | } |
636 | 435 | ||
637 | impl<'a> AstNode<'a> for Condition<'a> { | 436 | impl AstNode for Condition { |
638 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 437 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
639 | match syntax.kind() { | 438 | match syntax.kind() { |
640 | CONDITION => Some(Condition { syntax }), | 439 | CONDITION => Some(Condition::from_repr(syntax.into_repr())), |
641 | _ => None, | 440 | _ => None, |
642 | } | 441 | } |
643 | } | 442 | } |
644 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 443 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
645 | } | 444 | fn to_owned(&self) -> TreePtr<Condition> { TreePtr::cast(self.syntax.to_owned()) } |
646 | |||
647 | impl<R: TreeRoot<RaTypes>> ConditionNode<R> { | ||
648 | pub fn borrowed(&self) -> Condition { | ||
649 | ConditionNode { syntax: self.syntax.borrowed() } | ||
650 | } | ||
651 | pub fn owned(&self) -> ConditionNode { | ||
652 | ConditionNode { syntax: self.syntax.owned() } | ||
653 | } | ||
654 | } | 445 | } |
655 | 446 | ||
656 | 447 | ||
657 | impl<'a> Condition<'a> { | 448 | impl Condition { |
658 | pub fn pat(self) -> Option<Pat<'a>> { | 449 | pub fn pat(&self) -> Option<&Pat> { |
659 | super::child_opt(self) | 450 | super::child_opt(self) |
660 | } | 451 | } |
661 | 452 | ||
662 | pub fn expr(self) -> Option<Expr<'a>> { | 453 | pub fn expr(&self) -> Option<&Expr> { |
663 | super::child_opt(self) | 454 | super::child_opt(self) |
664 | } | 455 | } |
665 | } | 456 | } |
666 | 457 | ||
667 | // ConstDef | 458 | // ConstDef |
668 | #[derive(Debug, Clone, Copy,)] | 459 | #[derive(Debug, PartialEq, Eq, Hash)] |
669 | pub struct ConstDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 460 | #[repr(transparent)] |
670 | pub(crate) syntax: SyntaxNode<R>, | 461 | pub struct ConstDef { |
462 | pub(crate) syntax: SyntaxNode, | ||
671 | } | 463 | } |
672 | pub type ConstDef<'a> = ConstDefNode<RefRoot<'a>>; | 464 | unsafe impl TransparentNewType for ConstDef { |
673 | 465 | type Repr = rowan::SyntaxNode<RaTypes>; | |
674 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConstDefNode<R1>> for ConstDefNode<R2> { | ||
675 | fn eq(&self, other: &ConstDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
676 | } | ||
677 | impl<R: TreeRoot<RaTypes>> Eq for ConstDefNode<R> {} | ||
678 | impl<R: TreeRoot<RaTypes>> Hash for ConstDefNode<R> { | ||
679 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
680 | } | 466 | } |
681 | 467 | ||
682 | impl<'a> AstNode<'a> for ConstDef<'a> { | 468 | impl AstNode for ConstDef { |
683 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 469 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
684 | match syntax.kind() { | 470 | match syntax.kind() { |
685 | CONST_DEF => Some(ConstDef { syntax }), | 471 | CONST_DEF => Some(ConstDef::from_repr(syntax.into_repr())), |
686 | _ => None, | 472 | _ => None, |
687 | } | 473 | } |
688 | } | 474 | } |
689 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 475 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
690 | } | 476 | fn to_owned(&self) -> TreePtr<ConstDef> { TreePtr::cast(self.syntax.to_owned()) } |
691 | |||
692 | impl<R: TreeRoot<RaTypes>> ConstDefNode<R> { | ||
693 | pub fn borrowed(&self) -> ConstDef { | ||
694 | ConstDefNode { syntax: self.syntax.borrowed() } | ||
695 | } | ||
696 | pub fn owned(&self) -> ConstDefNode { | ||
697 | ConstDefNode { syntax: self.syntax.owned() } | ||
698 | } | ||
699 | } | 477 | } |
700 | 478 | ||
701 | 479 | ||
702 | impl<'a> ast::VisibilityOwner<'a> for ConstDef<'a> {} | 480 | impl ast::VisibilityOwner for ConstDef {} |
703 | impl<'a> ast::NameOwner<'a> for ConstDef<'a> {} | 481 | impl ast::NameOwner for ConstDef {} |
704 | impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {} | 482 | impl ast::TypeParamsOwner for ConstDef {} |
705 | impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {} | 483 | impl ast::AttrsOwner for ConstDef {} |
706 | impl<'a> ast::DocCommentsOwner<'a> for ConstDef<'a> {} | 484 | impl ast::DocCommentsOwner for ConstDef {} |
707 | impl<'a> ConstDef<'a> {} | 485 | impl ConstDef {} |
708 | 486 | ||
709 | // ContinueExpr | 487 | // ContinueExpr |
710 | #[derive(Debug, Clone, Copy,)] | 488 | #[derive(Debug, PartialEq, Eq, Hash)] |
711 | pub struct ContinueExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 489 | #[repr(transparent)] |
712 | pub(crate) syntax: SyntaxNode<R>, | 490 | pub struct ContinueExpr { |
491 | pub(crate) syntax: SyntaxNode, | ||
713 | } | 492 | } |
714 | pub type ContinueExpr<'a> = ContinueExprNode<RefRoot<'a>>; | 493 | unsafe impl TransparentNewType for ContinueExpr { |
715 | 494 | type Repr = rowan::SyntaxNode<RaTypes>; | |
716 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ContinueExprNode<R1>> for ContinueExprNode<R2> { | ||
717 | fn eq(&self, other: &ContinueExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
718 | } | ||
719 | impl<R: TreeRoot<RaTypes>> Eq for ContinueExprNode<R> {} | ||
720 | impl<R: TreeRoot<RaTypes>> Hash for ContinueExprNode<R> { | ||
721 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
722 | } | 495 | } |
723 | 496 | ||
724 | impl<'a> AstNode<'a> for ContinueExpr<'a> { | 497 | impl AstNode for ContinueExpr { |
725 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 498 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
726 | match syntax.kind() { | 499 | match syntax.kind() { |
727 | CONTINUE_EXPR => Some(ContinueExpr { syntax }), | 500 | CONTINUE_EXPR => Some(ContinueExpr::from_repr(syntax.into_repr())), |
728 | _ => None, | 501 | _ => None, |
729 | } | 502 | } |
730 | } | 503 | } |
731 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 504 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
505 | fn to_owned(&self) -> TreePtr<ContinueExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
732 | } | 506 | } |
733 | 507 | ||
734 | impl<R: TreeRoot<RaTypes>> ContinueExprNode<R> { | ||
735 | pub fn borrowed(&self) -> ContinueExpr { | ||
736 | ContinueExprNode { syntax: self.syntax.borrowed() } | ||
737 | } | ||
738 | pub fn owned(&self) -> ContinueExprNode { | ||
739 | ContinueExprNode { syntax: self.syntax.owned() } | ||
740 | } | ||
741 | } | ||
742 | 508 | ||
743 | 509 | impl ContinueExpr {} | |
744 | impl<'a> ContinueExpr<'a> {} | ||
745 | 510 | ||
746 | // DynTraitType | 511 | // DynTraitType |
747 | #[derive(Debug, Clone, Copy,)] | 512 | #[derive(Debug, PartialEq, Eq, Hash)] |
748 | pub struct DynTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 513 | #[repr(transparent)] |
749 | pub(crate) syntax: SyntaxNode<R>, | 514 | pub struct DynTraitType { |
750 | } | 515 | pub(crate) syntax: SyntaxNode, |
751 | pub type DynTraitType<'a> = DynTraitTypeNode<RefRoot<'a>>; | ||
752 | |||
753 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<DynTraitTypeNode<R1>> for DynTraitTypeNode<R2> { | ||
754 | fn eq(&self, other: &DynTraitTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
755 | } | 516 | } |
756 | impl<R: TreeRoot<RaTypes>> Eq for DynTraitTypeNode<R> {} | 517 | unsafe impl TransparentNewType for DynTraitType { |
757 | impl<R: TreeRoot<RaTypes>> Hash for DynTraitTypeNode<R> { | 518 | type Repr = rowan::SyntaxNode<RaTypes>; |
758 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
759 | } | 519 | } |
760 | 520 | ||
761 | impl<'a> AstNode<'a> for DynTraitType<'a> { | 521 | impl AstNode for DynTraitType { |
762 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 522 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
763 | match syntax.kind() { | 523 | match syntax.kind() { |
764 | DYN_TRAIT_TYPE => Some(DynTraitType { syntax }), | 524 | DYN_TRAIT_TYPE => Some(DynTraitType::from_repr(syntax.into_repr())), |
765 | _ => None, | 525 | _ => None, |
766 | } | 526 | } |
767 | } | 527 | } |
768 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 528 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
529 | fn to_owned(&self) -> TreePtr<DynTraitType> { TreePtr::cast(self.syntax.to_owned()) } | ||
769 | } | 530 | } |
770 | 531 | ||
771 | impl<R: TreeRoot<RaTypes>> DynTraitTypeNode<R> { | ||
772 | pub fn borrowed(&self) -> DynTraitType { | ||
773 | DynTraitTypeNode { syntax: self.syntax.borrowed() } | ||
774 | } | ||
775 | pub fn owned(&self) -> DynTraitTypeNode { | ||
776 | DynTraitTypeNode { syntax: self.syntax.owned() } | ||
777 | } | ||
778 | } | ||
779 | 532 | ||
780 | 533 | impl DynTraitType {} | |
781 | impl<'a> DynTraitType<'a> {} | ||
782 | 534 | ||
783 | // EnumDef | 535 | // EnumDef |
784 | #[derive(Debug, Clone, Copy,)] | 536 | #[derive(Debug, PartialEq, Eq, Hash)] |
785 | pub struct EnumDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 537 | #[repr(transparent)] |
786 | pub(crate) syntax: SyntaxNode<R>, | 538 | pub struct EnumDef { |
787 | } | 539 | pub(crate) syntax: SyntaxNode, |
788 | pub type EnumDef<'a> = EnumDefNode<RefRoot<'a>>; | ||
789 | |||
790 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumDefNode<R1>> for EnumDefNode<R2> { | ||
791 | fn eq(&self, other: &EnumDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
792 | } | 540 | } |
793 | impl<R: TreeRoot<RaTypes>> Eq for EnumDefNode<R> {} | 541 | unsafe impl TransparentNewType for EnumDef { |
794 | impl<R: TreeRoot<RaTypes>> Hash for EnumDefNode<R> { | 542 | type Repr = rowan::SyntaxNode<RaTypes>; |
795 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
796 | } | 543 | } |
797 | 544 | ||
798 | impl<'a> AstNode<'a> for EnumDef<'a> { | 545 | impl AstNode for EnumDef { |
799 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 546 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
800 | match syntax.kind() { | 547 | match syntax.kind() { |
801 | ENUM_DEF => Some(EnumDef { syntax }), | 548 | ENUM_DEF => Some(EnumDef::from_repr(syntax.into_repr())), |
802 | _ => None, | 549 | _ => None, |
803 | } | 550 | } |
804 | } | 551 | } |
805 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 552 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
806 | } | 553 | fn to_owned(&self) -> TreePtr<EnumDef> { TreePtr::cast(self.syntax.to_owned()) } |
807 | |||
808 | impl<R: TreeRoot<RaTypes>> EnumDefNode<R> { | ||
809 | pub fn borrowed(&self) -> EnumDef { | ||
810 | EnumDefNode { syntax: self.syntax.borrowed() } | ||
811 | } | ||
812 | pub fn owned(&self) -> EnumDefNode { | ||
813 | EnumDefNode { syntax: self.syntax.owned() } | ||
814 | } | ||
815 | } | 554 | } |
816 | 555 | ||
817 | 556 | ||
818 | impl<'a> ast::VisibilityOwner<'a> for EnumDef<'a> {} | 557 | impl ast::VisibilityOwner for EnumDef {} |
819 | impl<'a> ast::NameOwner<'a> for EnumDef<'a> {} | 558 | impl ast::NameOwner for EnumDef {} |
820 | impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {} | 559 | impl ast::TypeParamsOwner for EnumDef {} |
821 | impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {} | 560 | impl ast::AttrsOwner for EnumDef {} |
822 | impl<'a> ast::DocCommentsOwner<'a> for EnumDef<'a> {} | 561 | impl ast::DocCommentsOwner for EnumDef {} |
823 | impl<'a> EnumDef<'a> { | 562 | impl EnumDef { |
824 | pub fn variant_list(self) -> Option<EnumVariantList<'a>> { | 563 | pub fn variant_list(&self) -> Option<&EnumVariantList> { |
825 | super::child_opt(self) | 564 | super::child_opt(self) |
826 | } | 565 | } |
827 | } | 566 | } |
828 | 567 | ||
829 | // EnumVariant | 568 | // EnumVariant |
830 | #[derive(Debug, Clone, Copy,)] | 569 | #[derive(Debug, PartialEq, Eq, Hash)] |
831 | pub struct EnumVariantNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 570 | #[repr(transparent)] |
832 | pub(crate) syntax: SyntaxNode<R>, | 571 | pub struct EnumVariant { |
572 | pub(crate) syntax: SyntaxNode, | ||
833 | } | 573 | } |
834 | pub type EnumVariant<'a> = EnumVariantNode<RefRoot<'a>>; | 574 | unsafe impl TransparentNewType for EnumVariant { |
835 | 575 | type Repr = rowan::SyntaxNode<RaTypes>; | |
836 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumVariantNode<R1>> for EnumVariantNode<R2> { | ||
837 | fn eq(&self, other: &EnumVariantNode<R1>) -> bool { self.syntax == other.syntax } | ||
838 | } | ||
839 | impl<R: TreeRoot<RaTypes>> Eq for EnumVariantNode<R> {} | ||
840 | impl<R: TreeRoot<RaTypes>> Hash for EnumVariantNode<R> { | ||
841 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
842 | } | 576 | } |
843 | 577 | ||
844 | impl<'a> AstNode<'a> for EnumVariant<'a> { | 578 | impl AstNode for EnumVariant { |
845 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 579 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
846 | match syntax.kind() { | 580 | match syntax.kind() { |
847 | ENUM_VARIANT => Some(EnumVariant { syntax }), | 581 | ENUM_VARIANT => Some(EnumVariant::from_repr(syntax.into_repr())), |
848 | _ => None, | 582 | _ => None, |
849 | } | 583 | } |
850 | } | 584 | } |
851 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 585 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
852 | } | 586 | fn to_owned(&self) -> TreePtr<EnumVariant> { TreePtr::cast(self.syntax.to_owned()) } |
853 | |||
854 | impl<R: TreeRoot<RaTypes>> EnumVariantNode<R> { | ||
855 | pub fn borrowed(&self) -> EnumVariant { | ||
856 | EnumVariantNode { syntax: self.syntax.borrowed() } | ||
857 | } | ||
858 | pub fn owned(&self) -> EnumVariantNode { | ||
859 | EnumVariantNode { syntax: self.syntax.owned() } | ||
860 | } | ||
861 | } | 587 | } |
862 | 588 | ||
863 | 589 | ||
864 | impl<'a> ast::NameOwner<'a> for EnumVariant<'a> {} | 590 | impl ast::NameOwner for EnumVariant {} |
865 | impl<'a> EnumVariant<'a> { | 591 | impl EnumVariant { |
866 | pub fn expr(self) -> Option<Expr<'a>> { | 592 | pub fn expr(&self) -> Option<&Expr> { |
867 | super::child_opt(self) | 593 | super::child_opt(self) |
868 | } | 594 | } |
869 | } | 595 | } |
870 | 596 | ||
871 | // EnumVariantList | 597 | // EnumVariantList |
872 | #[derive(Debug, Clone, Copy,)] | 598 | #[derive(Debug, PartialEq, Eq, Hash)] |
873 | pub struct EnumVariantListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 599 | #[repr(transparent)] |
874 | pub(crate) syntax: SyntaxNode<R>, | 600 | pub struct EnumVariantList { |
875 | } | 601 | pub(crate) syntax: SyntaxNode, |
876 | pub type EnumVariantList<'a> = EnumVariantListNode<RefRoot<'a>>; | ||
877 | |||
878 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumVariantListNode<R1>> for EnumVariantListNode<R2> { | ||
879 | fn eq(&self, other: &EnumVariantListNode<R1>) -> bool { self.syntax == other.syntax } | ||
880 | } | 602 | } |
881 | impl<R: TreeRoot<RaTypes>> Eq for EnumVariantListNode<R> {} | 603 | unsafe impl TransparentNewType for EnumVariantList { |
882 | impl<R: TreeRoot<RaTypes>> Hash for EnumVariantListNode<R> { | 604 | type Repr = rowan::SyntaxNode<RaTypes>; |
883 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
884 | } | 605 | } |
885 | 606 | ||
886 | impl<'a> AstNode<'a> for EnumVariantList<'a> { | 607 | impl AstNode for EnumVariantList { |
887 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 608 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
888 | match syntax.kind() { | 609 | match syntax.kind() { |
889 | ENUM_VARIANT_LIST => Some(EnumVariantList { syntax }), | 610 | ENUM_VARIANT_LIST => Some(EnumVariantList::from_repr(syntax.into_repr())), |
890 | _ => None, | 611 | _ => None, |
891 | } | 612 | } |
892 | } | 613 | } |
893 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 614 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
615 | fn to_owned(&self) -> TreePtr<EnumVariantList> { TreePtr::cast(self.syntax.to_owned()) } | ||
894 | } | 616 | } |
895 | 617 | ||
896 | impl<R: TreeRoot<RaTypes>> EnumVariantListNode<R> { | ||
897 | pub fn borrowed(&self) -> EnumVariantList { | ||
898 | EnumVariantListNode { syntax: self.syntax.borrowed() } | ||
899 | } | ||
900 | pub fn owned(&self) -> EnumVariantListNode { | ||
901 | EnumVariantListNode { syntax: self.syntax.owned() } | ||
902 | } | ||
903 | } | ||
904 | 618 | ||
905 | 619 | impl EnumVariantList { | |
906 | impl<'a> EnumVariantList<'a> { | 620 | pub fn variants(&self) -> impl Iterator<Item = &EnumVariant> { |
907 | pub fn variants(self) -> impl Iterator<Item = EnumVariant<'a>> + 'a { | ||
908 | super::children(self) | 621 | super::children(self) |
909 | } | 622 | } |
910 | } | 623 | } |
911 | 624 | ||
912 | // Expr | 625 | // Expr |
913 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 626 | #[derive(Debug, PartialEq, Eq, Hash)] |
914 | pub enum Expr<'a> { | 627 | #[repr(transparent)] |
915 | TupleExpr(TupleExpr<'a>), | 628 | pub struct Expr { |
916 | ArrayExpr(ArrayExpr<'a>), | 629 | pub(crate) syntax: SyntaxNode, |
917 | ParenExpr(ParenExpr<'a>), | 630 | } |
918 | PathExpr(PathExpr<'a>), | 631 | unsafe impl TransparentNewType for Expr { |
919 | LambdaExpr(LambdaExpr<'a>), | 632 | type Repr = rowan::SyntaxNode<RaTypes>; |
920 | IfExpr(IfExpr<'a>), | ||
921 | LoopExpr(LoopExpr<'a>), | ||
922 | ForExpr(ForExpr<'a>), | ||
923 | WhileExpr(WhileExpr<'a>), | ||
924 | ContinueExpr(ContinueExpr<'a>), | ||
925 | BreakExpr(BreakExpr<'a>), | ||
926 | Label(Label<'a>), | ||
927 | BlockExpr(BlockExpr<'a>), | ||
928 | ReturnExpr(ReturnExpr<'a>), | ||
929 | MatchExpr(MatchExpr<'a>), | ||
930 | StructLit(StructLit<'a>), | ||
931 | CallExpr(CallExpr<'a>), | ||
932 | IndexExpr(IndexExpr<'a>), | ||
933 | MethodCallExpr(MethodCallExpr<'a>), | ||
934 | FieldExpr(FieldExpr<'a>), | ||
935 | TryExpr(TryExpr<'a>), | ||
936 | CastExpr(CastExpr<'a>), | ||
937 | RefExpr(RefExpr<'a>), | ||
938 | PrefixExpr(PrefixExpr<'a>), | ||
939 | RangeExpr(RangeExpr<'a>), | ||
940 | BinExpr(BinExpr<'a>), | ||
941 | Literal(Literal<'a>), | ||
942 | } | ||
943 | |||
944 | impl<'a> AstNode<'a> for Expr<'a> { | ||
945 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | ||
946 | match syntax.kind() { | ||
947 | TUPLE_EXPR => Some(Expr::TupleExpr(TupleExpr { syntax })), | ||
948 | ARRAY_EXPR => Some(Expr::ArrayExpr(ArrayExpr { syntax })), | ||
949 | PAREN_EXPR => Some(Expr::ParenExpr(ParenExpr { syntax })), | ||
950 | PATH_EXPR => Some(Expr::PathExpr(PathExpr { syntax })), | ||
951 | LAMBDA_EXPR => Some(Expr::LambdaExpr(LambdaExpr { syntax })), | ||
952 | IF_EXPR => Some(Expr::IfExpr(IfExpr { syntax })), | ||
953 | LOOP_EXPR => Some(Expr::LoopExpr(LoopExpr { syntax })), | ||
954 | FOR_EXPR => Some(Expr::ForExpr(ForExpr { syntax })), | ||
955 | WHILE_EXPR => Some(Expr::WhileExpr(WhileExpr { syntax })), | ||
956 | CONTINUE_EXPR => Some(Expr::ContinueExpr(ContinueExpr { syntax })), | ||
957 | BREAK_EXPR => Some(Expr::BreakExpr(BreakExpr { syntax })), | ||
958 | LABEL => Some(Expr::Label(Label { syntax })), | ||
959 | BLOCK_EXPR => Some(Expr::BlockExpr(BlockExpr { syntax })), | ||
960 | RETURN_EXPR => Some(Expr::ReturnExpr(ReturnExpr { syntax })), | ||
961 | MATCH_EXPR => Some(Expr::MatchExpr(MatchExpr { syntax })), | ||
962 | STRUCT_LIT => Some(Expr::StructLit(StructLit { syntax })), | ||
963 | CALL_EXPR => Some(Expr::CallExpr(CallExpr { syntax })), | ||
964 | INDEX_EXPR => Some(Expr::IndexExpr(IndexExpr { syntax })), | ||
965 | METHOD_CALL_EXPR => Some(Expr::MethodCallExpr(MethodCallExpr { syntax })), | ||
966 | FIELD_EXPR => Some(Expr::FieldExpr(FieldExpr { syntax })), | ||
967 | TRY_EXPR => Some(Expr::TryExpr(TryExpr { syntax })), | ||
968 | CAST_EXPR => Some(Expr::CastExpr(CastExpr { syntax })), | ||
969 | REF_EXPR => Some(Expr::RefExpr(RefExpr { syntax })), | ||
970 | PREFIX_EXPR => Some(Expr::PrefixExpr(PrefixExpr { syntax })), | ||
971 | RANGE_EXPR => Some(Expr::RangeExpr(RangeExpr { syntax })), | ||
972 | BIN_EXPR => Some(Expr::BinExpr(BinExpr { syntax })), | ||
973 | LITERAL => Some(Expr::Literal(Literal { syntax })), | ||
974 | _ => None, | ||
975 | } | ||
976 | } | ||
977 | fn syntax(self) -> SyntaxNodeRef<'a> { | ||
978 | match self { | ||
979 | Expr::TupleExpr(inner) => inner.syntax(), | ||
980 | Expr::ArrayExpr(inner) => inner.syntax(), | ||
981 | Expr::ParenExpr(inner) => inner.syntax(), | ||
982 | Expr::PathExpr(inner) => inner.syntax(), | ||
983 | Expr::LambdaExpr(inner) => inner.syntax(), | ||
984 | Expr::IfExpr(inner) => inner.syntax(), | ||
985 | Expr::LoopExpr(inner) => inner.syntax(), | ||
986 | Expr::ForExpr(inner) => inner.syntax(), | ||
987 | Expr::WhileExpr(inner) => inner.syntax(), | ||
988 | Expr::ContinueExpr(inner) => inner.syntax(), | ||
989 | Expr::BreakExpr(inner) => inner.syntax(), | ||
990 | Expr::Label(inner) => inner.syntax(), | ||
991 | Expr::BlockExpr(inner) => inner.syntax(), | ||
992 | Expr::ReturnExpr(inner) => inner.syntax(), | ||
993 | Expr::MatchExpr(inner) => inner.syntax(), | ||
994 | Expr::StructLit(inner) => inner.syntax(), | ||
995 | Expr::CallExpr(inner) => inner.syntax(), | ||
996 | Expr::IndexExpr(inner) => inner.syntax(), | ||
997 | Expr::MethodCallExpr(inner) => inner.syntax(), | ||
998 | Expr::FieldExpr(inner) => inner.syntax(), | ||
999 | Expr::TryExpr(inner) => inner.syntax(), | ||
1000 | Expr::CastExpr(inner) => inner.syntax(), | ||
1001 | Expr::RefExpr(inner) => inner.syntax(), | ||
1002 | Expr::PrefixExpr(inner) => inner.syntax(), | ||
1003 | Expr::RangeExpr(inner) => inner.syntax(), | ||
1004 | Expr::BinExpr(inner) => inner.syntax(), | ||
1005 | Expr::Literal(inner) => inner.syntax(), | ||
1006 | } | ||
1007 | } | ||
1008 | } | 633 | } |
1009 | 634 | ||
1010 | impl<'a> Expr<'a> {} | 635 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
636 | pub enum ExprKind<'a> { | ||
637 | TupleExpr(&'a TupleExpr), | ||
638 | ArrayExpr(&'a ArrayExpr), | ||
639 | ParenExpr(&'a ParenExpr), | ||
640 | PathExpr(&'a PathExpr), | ||
641 | LambdaExpr(&'a LambdaExpr), | ||
642 | IfExpr(&'a IfExpr), | ||
643 | LoopExpr(&'a LoopExpr), | ||
644 | ForExpr(&'a ForExpr), | ||
645 | WhileExpr(&'a WhileExpr), | ||
646 | ContinueExpr(&'a ContinueExpr), | ||
647 | BreakExpr(&'a BreakExpr), | ||
648 | Label(&'a Label), | ||
649 | BlockExpr(&'a BlockExpr), | ||
650 | ReturnExpr(&'a ReturnExpr), | ||
651 | MatchExpr(&'a MatchExpr), | ||
652 | StructLit(&'a StructLit), | ||
653 | CallExpr(&'a CallExpr), | ||
654 | IndexExpr(&'a IndexExpr), | ||
655 | MethodCallExpr(&'a MethodCallExpr), | ||
656 | FieldExpr(&'a FieldExpr), | ||
657 | TryExpr(&'a TryExpr), | ||
658 | CastExpr(&'a CastExpr), | ||
659 | RefExpr(&'a RefExpr), | ||
660 | PrefixExpr(&'a PrefixExpr), | ||
661 | RangeExpr(&'a RangeExpr), | ||
662 | BinExpr(&'a BinExpr), | ||
663 | Literal(&'a Literal), | ||
664 | } | ||
665 | |||
666 | impl AstNode for Expr { | ||
667 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { | ||
668 | match syntax.kind() { | ||
669 | | TUPLE_EXPR | ||
670 | | ARRAY_EXPR | ||
671 | | PAREN_EXPR | ||
672 | | PATH_EXPR | ||
673 | | LAMBDA_EXPR | ||
674 | | IF_EXPR | ||
675 | | LOOP_EXPR | ||
676 | | FOR_EXPR | ||
677 | | WHILE_EXPR | ||
678 | | CONTINUE_EXPR | ||
679 | | BREAK_EXPR | ||
680 | | LABEL | ||
681 | | BLOCK_EXPR | ||
682 | | RETURN_EXPR | ||
683 | | MATCH_EXPR | ||
684 | | STRUCT_LIT | ||
685 | | CALL_EXPR | ||
686 | | INDEX_EXPR | ||
687 | | METHOD_CALL_EXPR | ||
688 | | FIELD_EXPR | ||
689 | | TRY_EXPR | ||
690 | | CAST_EXPR | ||
691 | | REF_EXPR | ||
692 | | PREFIX_EXPR | ||
693 | | RANGE_EXPR | ||
694 | | BIN_EXPR | ||
695 | | LITERAL => Some(Expr::from_repr(syntax.into_repr())), | ||
696 | _ => None, | ||
697 | } | ||
698 | } | ||
699 | fn syntax(&self) -> &SyntaxNode { &self.syntax } | ||
700 | fn to_owned(&self) -> TreePtr<Expr> { TreePtr::cast(self.syntax.to_owned()) } | ||
701 | } | ||
702 | |||
703 | impl Expr { | ||
704 | pub fn kind(&self) -> ExprKind { | ||
705 | match self.syntax.kind() { | ||
706 | TUPLE_EXPR => ExprKind::TupleExpr(TupleExpr::cast(&self.syntax).unwrap()), | ||
707 | ARRAY_EXPR => ExprKind::ArrayExpr(ArrayExpr::cast(&self.syntax).unwrap()), | ||
708 | PAREN_EXPR => ExprKind::ParenExpr(ParenExpr::cast(&self.syntax).unwrap()), | ||
709 | PATH_EXPR => ExprKind::PathExpr(PathExpr::cast(&self.syntax).unwrap()), | ||
710 | LAMBDA_EXPR => ExprKind::LambdaExpr(LambdaExpr::cast(&self.syntax).unwrap()), | ||
711 | IF_EXPR => ExprKind::IfExpr(IfExpr::cast(&self.syntax).unwrap()), | ||
712 | LOOP_EXPR => ExprKind::LoopExpr(LoopExpr::cast(&self.syntax).unwrap()), | ||
713 | FOR_EXPR => ExprKind::ForExpr(ForExpr::cast(&self.syntax).unwrap()), | ||
714 | WHILE_EXPR => ExprKind::WhileExpr(WhileExpr::cast(&self.syntax).unwrap()), | ||
715 | CONTINUE_EXPR => ExprKind::ContinueExpr(ContinueExpr::cast(&self.syntax).unwrap()), | ||
716 | BREAK_EXPR => ExprKind::BreakExpr(BreakExpr::cast(&self.syntax).unwrap()), | ||
717 | LABEL => ExprKind::Label(Label::cast(&self.syntax).unwrap()), | ||
718 | BLOCK_EXPR => ExprKind::BlockExpr(BlockExpr::cast(&self.syntax).unwrap()), | ||
719 | RETURN_EXPR => ExprKind::ReturnExpr(ReturnExpr::cast(&self.syntax).unwrap()), | ||
720 | MATCH_EXPR => ExprKind::MatchExpr(MatchExpr::cast(&self.syntax).unwrap()), | ||
721 | STRUCT_LIT => ExprKind::StructLit(StructLit::cast(&self.syntax).unwrap()), | ||
722 | CALL_EXPR => ExprKind::CallExpr(CallExpr::cast(&self.syntax).unwrap()), | ||
723 | INDEX_EXPR => ExprKind::IndexExpr(IndexExpr::cast(&self.syntax).unwrap()), | ||
724 | METHOD_CALL_EXPR => ExprKind::MethodCallExpr(MethodCallExpr::cast(&self.syntax).unwrap()), | ||
725 | FIELD_EXPR => ExprKind::FieldExpr(FieldExpr::cast(&self.syntax).unwrap()), | ||
726 | TRY_EXPR => ExprKind::TryExpr(TryExpr::cast(&self.syntax).unwrap()), | ||
727 | CAST_EXPR => ExprKind::CastExpr(CastExpr::cast(&self.syntax).unwrap()), | ||
728 | REF_EXPR => ExprKind::RefExpr(RefExpr::cast(&self.syntax).unwrap()), | ||
729 | PREFIX_EXPR => ExprKind::PrefixExpr(PrefixExpr::cast(&self.syntax).unwrap()), | ||
730 | RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(&self.syntax).unwrap()), | ||
731 | BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(&self.syntax).unwrap()), | ||
732 | LITERAL => ExprKind::Literal(Literal::cast(&self.syntax).unwrap()), | ||
733 | _ => unreachable!(), | ||
734 | } | ||
735 | } | ||
736 | } | ||
737 | |||
738 | impl Expr {} | ||
1011 | 739 | ||
1012 | // ExprStmt | 740 | // ExprStmt |
1013 | #[derive(Debug, Clone, Copy,)] | 741 | #[derive(Debug, PartialEq, Eq, Hash)] |
1014 | pub struct ExprStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 742 | #[repr(transparent)] |
1015 | pub(crate) syntax: SyntaxNode<R>, | 743 | pub struct ExprStmt { |
744 | pub(crate) syntax: SyntaxNode, | ||
1016 | } | 745 | } |
1017 | pub type ExprStmt<'a> = ExprStmtNode<RefRoot<'a>>; | 746 | unsafe impl TransparentNewType for ExprStmt { |
1018 | 747 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1019 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExprStmtNode<R1>> for ExprStmtNode<R2> { | ||
1020 | fn eq(&self, other: &ExprStmtNode<R1>) -> bool { self.syntax == other.syntax } | ||
1021 | } | ||
1022 | impl<R: TreeRoot<RaTypes>> Eq for ExprStmtNode<R> {} | ||
1023 | impl<R: TreeRoot<RaTypes>> Hash for ExprStmtNode<R> { | ||
1024 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1025 | } | 748 | } |
1026 | 749 | ||
1027 | impl<'a> AstNode<'a> for ExprStmt<'a> { | 750 | impl AstNode for ExprStmt { |
1028 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 751 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1029 | match syntax.kind() { | 752 | match syntax.kind() { |
1030 | EXPR_STMT => Some(ExprStmt { syntax }), | 753 | EXPR_STMT => Some(ExprStmt::from_repr(syntax.into_repr())), |
1031 | _ => None, | 754 | _ => None, |
1032 | } | 755 | } |
1033 | } | 756 | } |
1034 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 757 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1035 | } | 758 | fn to_owned(&self) -> TreePtr<ExprStmt> { TreePtr::cast(self.syntax.to_owned()) } |
1036 | |||
1037 | impl<R: TreeRoot<RaTypes>> ExprStmtNode<R> { | ||
1038 | pub fn borrowed(&self) -> ExprStmt { | ||
1039 | ExprStmtNode { syntax: self.syntax.borrowed() } | ||
1040 | } | ||
1041 | pub fn owned(&self) -> ExprStmtNode { | ||
1042 | ExprStmtNode { syntax: self.syntax.owned() } | ||
1043 | } | ||
1044 | } | 759 | } |
1045 | 760 | ||
1046 | 761 | ||
1047 | impl<'a> ExprStmt<'a> { | 762 | impl ExprStmt { |
1048 | pub fn expr(self) -> Option<Expr<'a>> { | 763 | pub fn expr(&self) -> Option<&Expr> { |
1049 | super::child_opt(self) | 764 | super::child_opt(self) |
1050 | } | 765 | } |
1051 | } | 766 | } |
1052 | 767 | ||
1053 | // ExternCrateItem | 768 | // ExternCrateItem |
1054 | #[derive(Debug, Clone, Copy,)] | 769 | #[derive(Debug, PartialEq, Eq, Hash)] |
1055 | pub struct ExternCrateItemNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 770 | #[repr(transparent)] |
1056 | pub(crate) syntax: SyntaxNode<R>, | 771 | pub struct ExternCrateItem { |
1057 | } | 772 | pub(crate) syntax: SyntaxNode, |
1058 | pub type ExternCrateItem<'a> = ExternCrateItemNode<RefRoot<'a>>; | ||
1059 | |||
1060 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExternCrateItemNode<R1>> for ExternCrateItemNode<R2> { | ||
1061 | fn eq(&self, other: &ExternCrateItemNode<R1>) -> bool { self.syntax == other.syntax } | ||
1062 | } | 773 | } |
1063 | impl<R: TreeRoot<RaTypes>> Eq for ExternCrateItemNode<R> {} | 774 | unsafe impl TransparentNewType for ExternCrateItem { |
1064 | impl<R: TreeRoot<RaTypes>> Hash for ExternCrateItemNode<R> { | 775 | type Repr = rowan::SyntaxNode<RaTypes>; |
1065 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1066 | } | 776 | } |
1067 | 777 | ||
1068 | impl<'a> AstNode<'a> for ExternCrateItem<'a> { | 778 | impl AstNode for ExternCrateItem { |
1069 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 779 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1070 | match syntax.kind() { | 780 | match syntax.kind() { |
1071 | EXTERN_CRATE_ITEM => Some(ExternCrateItem { syntax }), | 781 | EXTERN_CRATE_ITEM => Some(ExternCrateItem::from_repr(syntax.into_repr())), |
1072 | _ => None, | 782 | _ => None, |
1073 | } | 783 | } |
1074 | } | 784 | } |
1075 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 785 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
786 | fn to_owned(&self) -> TreePtr<ExternCrateItem> { TreePtr::cast(self.syntax.to_owned()) } | ||
1076 | } | 787 | } |
1077 | 788 | ||
1078 | impl<R: TreeRoot<RaTypes>> ExternCrateItemNode<R> { | ||
1079 | pub fn borrowed(&self) -> ExternCrateItem { | ||
1080 | ExternCrateItemNode { syntax: self.syntax.borrowed() } | ||
1081 | } | ||
1082 | pub fn owned(&self) -> ExternCrateItemNode { | ||
1083 | ExternCrateItemNode { syntax: self.syntax.owned() } | ||
1084 | } | ||
1085 | } | ||
1086 | 789 | ||
1087 | 790 | impl ExternCrateItem {} | |
1088 | impl<'a> ExternCrateItem<'a> {} | ||
1089 | 791 | ||
1090 | // FieldExpr | 792 | // FieldExpr |
1091 | #[derive(Debug, Clone, Copy,)] | 793 | #[derive(Debug, PartialEq, Eq, Hash)] |
1092 | pub struct FieldExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 794 | #[repr(transparent)] |
1093 | pub(crate) syntax: SyntaxNode<R>, | 795 | pub struct FieldExpr { |
1094 | } | 796 | pub(crate) syntax: SyntaxNode, |
1095 | pub type FieldExpr<'a> = FieldExprNode<RefRoot<'a>>; | ||
1096 | |||
1097 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldExprNode<R1>> for FieldExprNode<R2> { | ||
1098 | fn eq(&self, other: &FieldExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1099 | } | 797 | } |
1100 | impl<R: TreeRoot<RaTypes>> Eq for FieldExprNode<R> {} | 798 | unsafe impl TransparentNewType for FieldExpr { |
1101 | impl<R: TreeRoot<RaTypes>> Hash for FieldExprNode<R> { | 799 | type Repr = rowan::SyntaxNode<RaTypes>; |
1102 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1103 | } | 800 | } |
1104 | 801 | ||
1105 | impl<'a> AstNode<'a> for FieldExpr<'a> { | 802 | impl AstNode for FieldExpr { |
1106 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 803 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1107 | match syntax.kind() { | 804 | match syntax.kind() { |
1108 | FIELD_EXPR => Some(FieldExpr { syntax }), | 805 | FIELD_EXPR => Some(FieldExpr::from_repr(syntax.into_repr())), |
1109 | _ => None, | 806 | _ => None, |
1110 | } | 807 | } |
1111 | } | 808 | } |
1112 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 809 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
810 | fn to_owned(&self) -> TreePtr<FieldExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
1113 | } | 811 | } |
1114 | 812 | ||
1115 | impl<R: TreeRoot<RaTypes>> FieldExprNode<R> { | ||
1116 | pub fn borrowed(&self) -> FieldExpr { | ||
1117 | FieldExprNode { syntax: self.syntax.borrowed() } | ||
1118 | } | ||
1119 | pub fn owned(&self) -> FieldExprNode { | ||
1120 | FieldExprNode { syntax: self.syntax.owned() } | ||
1121 | } | ||
1122 | } | ||
1123 | 813 | ||
1124 | 814 | impl FieldExpr { | |
1125 | impl<'a> FieldExpr<'a> { | 815 | pub fn expr(&self) -> Option<&Expr> { |
1126 | pub fn expr(self) -> Option<Expr<'a>> { | ||
1127 | super::child_opt(self) | 816 | super::child_opt(self) |
1128 | } | 817 | } |
1129 | 818 | ||
1130 | pub fn name_ref(self) -> Option<NameRef<'a>> { | 819 | pub fn name_ref(&self) -> Option<&NameRef> { |
1131 | super::child_opt(self) | 820 | super::child_opt(self) |
1132 | } | 821 | } |
1133 | } | 822 | } |
1134 | 823 | ||
1135 | // FieldPatList | 824 | // FieldPatList |
1136 | #[derive(Debug, Clone, Copy,)] | 825 | #[derive(Debug, PartialEq, Eq, Hash)] |
1137 | pub struct FieldPatListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 826 | #[repr(transparent)] |
1138 | pub(crate) syntax: SyntaxNode<R>, | 827 | pub struct FieldPatList { |
828 | pub(crate) syntax: SyntaxNode, | ||
1139 | } | 829 | } |
1140 | pub type FieldPatList<'a> = FieldPatListNode<RefRoot<'a>>; | 830 | unsafe impl TransparentNewType for FieldPatList { |
1141 | 831 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1142 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FieldPatListNode<R1>> for FieldPatListNode<R2> { | ||
1143 | fn eq(&self, other: &FieldPatListNode<R1>) -> bool { self.syntax == other.syntax } | ||
1144 | } | ||
1145 | impl<R: TreeRoot<RaTypes>> Eq for FieldPatListNode<R> {} | ||
1146 | impl<R: TreeRoot<RaTypes>> Hash for FieldPatListNode<R> { | ||
1147 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1148 | } | 832 | } |
1149 | 833 | ||
1150 | impl<'a> AstNode<'a> for FieldPatList<'a> { | 834 | impl AstNode for FieldPatList { |
1151 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 835 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1152 | match syntax.kind() { | 836 | match syntax.kind() { |
1153 | FIELD_PAT_LIST => Some(FieldPatList { syntax }), | 837 | FIELD_PAT_LIST => Some(FieldPatList::from_repr(syntax.into_repr())), |
1154 | _ => None, | 838 | _ => None, |
1155 | } | 839 | } |
1156 | } | 840 | } |
1157 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 841 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1158 | } | 842 | fn to_owned(&self) -> TreePtr<FieldPatList> { TreePtr::cast(self.syntax.to_owned()) } |
1159 | |||
1160 | impl<R: TreeRoot<RaTypes>> FieldPatListNode<R> { | ||
1161 | pub fn borrowed(&self) -> FieldPatList { | ||
1162 | FieldPatListNode { syntax: self.syntax.borrowed() } | ||
1163 | } | ||
1164 | pub fn owned(&self) -> FieldPatListNode { | ||
1165 | FieldPatListNode { syntax: self.syntax.owned() } | ||
1166 | } | ||
1167 | } | 843 | } |
1168 | 844 | ||
1169 | 845 | ||
1170 | impl<'a> FieldPatList<'a> {} | 846 | impl FieldPatList {} |
1171 | 847 | ||
1172 | // FnDef | 848 | // FnDef |
1173 | #[derive(Debug, Clone, Copy,)] | 849 | #[derive(Debug, PartialEq, Eq, Hash)] |
1174 | pub struct FnDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 850 | #[repr(transparent)] |
1175 | pub(crate) syntax: SyntaxNode<R>, | 851 | pub struct FnDef { |
852 | pub(crate) syntax: SyntaxNode, | ||
1176 | } | 853 | } |
1177 | pub type FnDef<'a> = FnDefNode<RefRoot<'a>>; | 854 | unsafe impl TransparentNewType for FnDef { |
1178 | 855 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1179 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnDefNode<R1>> for FnDefNode<R2> { | ||
1180 | fn eq(&self, other: &FnDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
1181 | } | ||
1182 | impl<R: TreeRoot<RaTypes>> Eq for FnDefNode<R> {} | ||
1183 | impl<R: TreeRoot<RaTypes>> Hash for FnDefNode<R> { | ||
1184 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1185 | } | 856 | } |
1186 | 857 | ||
1187 | impl<'a> AstNode<'a> for FnDef<'a> { | 858 | impl AstNode for FnDef { |
1188 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 859 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1189 | match syntax.kind() { | 860 | match syntax.kind() { |
1190 | FN_DEF => Some(FnDef { syntax }), | 861 | FN_DEF => Some(FnDef::from_repr(syntax.into_repr())), |
1191 | _ => None, | 862 | _ => None, |
1192 | } | 863 | } |
1193 | } | 864 | } |
1194 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 865 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1195 | } | 866 | fn to_owned(&self) -> TreePtr<FnDef> { TreePtr::cast(self.syntax.to_owned()) } |
1196 | |||
1197 | impl<R: TreeRoot<RaTypes>> FnDefNode<R> { | ||
1198 | pub fn borrowed(&self) -> FnDef { | ||
1199 | FnDefNode { syntax: self.syntax.borrowed() } | ||
1200 | } | ||
1201 | pub fn owned(&self) -> FnDefNode { | ||
1202 | FnDefNode { syntax: self.syntax.owned() } | ||
1203 | } | ||
1204 | } | 867 | } |
1205 | 868 | ||
1206 | 869 | ||
1207 | impl<'a> ast::VisibilityOwner<'a> for FnDef<'a> {} | 870 | impl ast::VisibilityOwner for FnDef {} |
1208 | impl<'a> ast::NameOwner<'a> for FnDef<'a> {} | 871 | impl ast::NameOwner for FnDef {} |
1209 | impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {} | 872 | impl ast::TypeParamsOwner for FnDef {} |
1210 | impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {} | 873 | impl ast::AttrsOwner for FnDef {} |
1211 | impl<'a> ast::DocCommentsOwner<'a> for FnDef<'a> {} | 874 | impl ast::DocCommentsOwner for FnDef {} |
1212 | impl<'a> FnDef<'a> { | 875 | impl FnDef { |
1213 | pub fn param_list(self) -> Option<ParamList<'a>> { | 876 | pub fn param_list(&self) -> Option<&ParamList> { |
1214 | super::child_opt(self) | 877 | super::child_opt(self) |
1215 | } | 878 | } |
1216 | 879 | ||
1217 | pub fn body(self) -> Option<Block<'a>> { | 880 | pub fn body(&self) -> Option<&Block> { |
1218 | super::child_opt(self) | 881 | super::child_opt(self) |
1219 | } | 882 | } |
1220 | 883 | ||
1221 | pub fn ret_type(self) -> Option<RetType<'a>> { | 884 | pub fn ret_type(&self) -> Option<&RetType> { |
1222 | super::child_opt(self) | 885 | super::child_opt(self) |
1223 | } | 886 | } |
1224 | } | 887 | } |
1225 | 888 | ||
1226 | // FnPointerType | 889 | // FnPointerType |
1227 | #[derive(Debug, Clone, Copy,)] | 890 | #[derive(Debug, PartialEq, Eq, Hash)] |
1228 | pub struct FnPointerTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 891 | #[repr(transparent)] |
1229 | pub(crate) syntax: SyntaxNode<R>, | 892 | pub struct FnPointerType { |
1230 | } | 893 | pub(crate) syntax: SyntaxNode, |
1231 | pub type FnPointerType<'a> = FnPointerTypeNode<RefRoot<'a>>; | ||
1232 | |||
1233 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<FnPointerTypeNode<R1>> for FnPointerTypeNode<R2> { | ||
1234 | fn eq(&self, other: &FnPointerTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
1235 | } | 894 | } |
1236 | impl<R: TreeRoot<RaTypes>> Eq for FnPointerTypeNode<R> {} | 895 | unsafe impl TransparentNewType for FnPointerType { |
1237 | impl<R: TreeRoot<RaTypes>> Hash for FnPointerTypeNode<R> { | 896 | type Repr = rowan::SyntaxNode<RaTypes>; |
1238 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1239 | } | 897 | } |
1240 | 898 | ||
1241 | impl<'a> AstNode<'a> for FnPointerType<'a> { | 899 | impl AstNode for FnPointerType { |
1242 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 900 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1243 | match syntax.kind() { | 901 | match syntax.kind() { |
1244 | FN_POINTER_TYPE => Some(FnPointerType { syntax }), | 902 | FN_POINTER_TYPE => Some(FnPointerType::from_repr(syntax.into_repr())), |
1245 | _ => None, | 903 | _ => None, |
1246 | } | 904 | } |
1247 | } | 905 | } |
1248 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 906 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
907 | fn to_owned(&self) -> TreePtr<FnPointerType> { TreePtr::cast(self.syntax.to_owned()) } | ||
1249 | } | 908 | } |
1250 | 909 | ||
1251 | impl<R: TreeRoot<RaTypes>> FnPointerTypeNode<R> { | ||
1252 | pub fn borrowed(&self) -> FnPointerType { | ||
1253 | FnPointerTypeNode { syntax: self.syntax.borrowed() } | ||
1254 | } | ||
1255 | pub fn owned(&self) -> FnPointerTypeNode { | ||
1256 | FnPointerTypeNode { syntax: self.syntax.owned() } | ||
1257 | } | ||
1258 | } | ||
1259 | 910 | ||
1260 | 911 | impl FnPointerType { | |
1261 | impl<'a> FnPointerType<'a> { | 912 | pub fn param_list(&self) -> Option<&ParamList> { |
1262 | pub fn param_list(self) -> Option<ParamList<'a>> { | ||
1263 | super::child_opt(self) | 913 | super::child_opt(self) |
1264 | } | 914 | } |
1265 | 915 | ||
1266 | pub fn ret_type(self) -> Option<RetType<'a>> { | 916 | pub fn ret_type(&self) -> Option<&RetType> { |
1267 | super::child_opt(self) | 917 | super::child_opt(self) |
1268 | } | 918 | } |
1269 | } | 919 | } |
1270 | 920 | ||
1271 | // ForExpr | 921 | // ForExpr |
1272 | #[derive(Debug, Clone, Copy,)] | 922 | #[derive(Debug, PartialEq, Eq, Hash)] |
1273 | pub struct ForExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 923 | #[repr(transparent)] |
1274 | pub(crate) syntax: SyntaxNode<R>, | 924 | pub struct ForExpr { |
1275 | } | 925 | pub(crate) syntax: SyntaxNode, |
1276 | pub type ForExpr<'a> = ForExprNode<RefRoot<'a>>; | ||
1277 | |||
1278 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForExprNode<R1>> for ForExprNode<R2> { | ||
1279 | fn eq(&self, other: &ForExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1280 | } | 926 | } |
1281 | impl<R: TreeRoot<RaTypes>> Eq for ForExprNode<R> {} | 927 | unsafe impl TransparentNewType for ForExpr { |
1282 | impl<R: TreeRoot<RaTypes>> Hash for ForExprNode<R> { | 928 | type Repr = rowan::SyntaxNode<RaTypes>; |
1283 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1284 | } | 929 | } |
1285 | 930 | ||
1286 | impl<'a> AstNode<'a> for ForExpr<'a> { | 931 | impl AstNode for ForExpr { |
1287 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 932 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1288 | match syntax.kind() { | 933 | match syntax.kind() { |
1289 | FOR_EXPR => Some(ForExpr { syntax }), | 934 | FOR_EXPR => Some(ForExpr::from_repr(syntax.into_repr())), |
1290 | _ => None, | 935 | _ => None, |
1291 | } | 936 | } |
1292 | } | 937 | } |
1293 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 938 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1294 | } | 939 | fn to_owned(&self) -> TreePtr<ForExpr> { TreePtr::cast(self.syntax.to_owned()) } |
1295 | |||
1296 | impl<R: TreeRoot<RaTypes>> ForExprNode<R> { | ||
1297 | pub fn borrowed(&self) -> ForExpr { | ||
1298 | ForExprNode { syntax: self.syntax.borrowed() } | ||
1299 | } | ||
1300 | pub fn owned(&self) -> ForExprNode { | ||
1301 | ForExprNode { syntax: self.syntax.owned() } | ||
1302 | } | ||
1303 | } | 940 | } |
1304 | 941 | ||
1305 | 942 | ||
1306 | impl<'a> ast::LoopBodyOwner<'a> for ForExpr<'a> {} | 943 | impl ast::LoopBodyOwner for ForExpr {} |
1307 | impl<'a> ForExpr<'a> { | 944 | impl ForExpr { |
1308 | pub fn pat(self) -> Option<Pat<'a>> { | 945 | pub fn pat(&self) -> Option<&Pat> { |
1309 | super::child_opt(self) | 946 | super::child_opt(self) |
1310 | } | 947 | } |
1311 | 948 | ||
1312 | pub fn iterable(self) -> Option<Expr<'a>> { | 949 | pub fn iterable(&self) -> Option<&Expr> { |
1313 | super::child_opt(self) | 950 | super::child_opt(self) |
1314 | } | 951 | } |
1315 | } | 952 | } |
1316 | 953 | ||
1317 | // ForType | 954 | // ForType |
1318 | #[derive(Debug, Clone, Copy,)] | 955 | #[derive(Debug, PartialEq, Eq, Hash)] |
1319 | pub struct ForTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 956 | #[repr(transparent)] |
1320 | pub(crate) syntax: SyntaxNode<R>, | 957 | pub struct ForType { |
1321 | } | 958 | pub(crate) syntax: SyntaxNode, |
1322 | pub type ForType<'a> = ForTypeNode<RefRoot<'a>>; | ||
1323 | |||
1324 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ForTypeNode<R1>> for ForTypeNode<R2> { | ||
1325 | fn eq(&self, other: &ForTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
1326 | } | 959 | } |
1327 | impl<R: TreeRoot<RaTypes>> Eq for ForTypeNode<R> {} | 960 | unsafe impl TransparentNewType for ForType { |
1328 | impl<R: TreeRoot<RaTypes>> Hash for ForTypeNode<R> { | 961 | type Repr = rowan::SyntaxNode<RaTypes>; |
1329 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1330 | } | 962 | } |
1331 | 963 | ||
1332 | impl<'a> AstNode<'a> for ForType<'a> { | 964 | impl AstNode for ForType { |
1333 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 965 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1334 | match syntax.kind() { | 966 | match syntax.kind() { |
1335 | FOR_TYPE => Some(ForType { syntax }), | 967 | FOR_TYPE => Some(ForType::from_repr(syntax.into_repr())), |
1336 | _ => None, | 968 | _ => None, |
1337 | } | 969 | } |
1338 | } | 970 | } |
1339 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 971 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1340 | } | 972 | fn to_owned(&self) -> TreePtr<ForType> { TreePtr::cast(self.syntax.to_owned()) } |
1341 | |||
1342 | impl<R: TreeRoot<RaTypes>> ForTypeNode<R> { | ||
1343 | pub fn borrowed(&self) -> ForType { | ||
1344 | ForTypeNode { syntax: self.syntax.borrowed() } | ||
1345 | } | ||
1346 | pub fn owned(&self) -> ForTypeNode { | ||
1347 | ForTypeNode { syntax: self.syntax.owned() } | ||
1348 | } | ||
1349 | } | 973 | } |
1350 | 974 | ||
1351 | 975 | ||
1352 | impl<'a> ForType<'a> { | 976 | impl ForType { |
1353 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 977 | pub fn type_ref(&self) -> Option<&TypeRef> { |
1354 | super::child_opt(self) | 978 | super::child_opt(self) |
1355 | } | 979 | } |
1356 | } | 980 | } |
1357 | 981 | ||
1358 | // IfExpr | 982 | // IfExpr |
1359 | #[derive(Debug, Clone, Copy,)] | 983 | #[derive(Debug, PartialEq, Eq, Hash)] |
1360 | pub struct IfExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 984 | #[repr(transparent)] |
1361 | pub(crate) syntax: SyntaxNode<R>, | 985 | pub struct IfExpr { |
986 | pub(crate) syntax: SyntaxNode, | ||
1362 | } | 987 | } |
1363 | pub type IfExpr<'a> = IfExprNode<RefRoot<'a>>; | 988 | unsafe impl TransparentNewType for IfExpr { |
1364 | 989 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1365 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IfExprNode<R1>> for IfExprNode<R2> { | ||
1366 | fn eq(&self, other: &IfExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1367 | } | ||
1368 | impl<R: TreeRoot<RaTypes>> Eq for IfExprNode<R> {} | ||
1369 | impl<R: TreeRoot<RaTypes>> Hash for IfExprNode<R> { | ||
1370 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1371 | } | 990 | } |
1372 | 991 | ||
1373 | impl<'a> AstNode<'a> for IfExpr<'a> { | 992 | impl AstNode for IfExpr { |
1374 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 993 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1375 | match syntax.kind() { | 994 | match syntax.kind() { |
1376 | IF_EXPR => Some(IfExpr { syntax }), | 995 | IF_EXPR => Some(IfExpr::from_repr(syntax.into_repr())), |
1377 | _ => None, | 996 | _ => None, |
1378 | } | 997 | } |
1379 | } | 998 | } |
1380 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 999 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1381 | } | 1000 | fn to_owned(&self) -> TreePtr<IfExpr> { TreePtr::cast(self.syntax.to_owned()) } |
1382 | |||
1383 | impl<R: TreeRoot<RaTypes>> IfExprNode<R> { | ||
1384 | pub fn borrowed(&self) -> IfExpr { | ||
1385 | IfExprNode { syntax: self.syntax.borrowed() } | ||
1386 | } | ||
1387 | pub fn owned(&self) -> IfExprNode { | ||
1388 | IfExprNode { syntax: self.syntax.owned() } | ||
1389 | } | ||
1390 | } | 1001 | } |
1391 | 1002 | ||
1392 | 1003 | ||
1393 | impl<'a> IfExpr<'a> { | 1004 | impl IfExpr { |
1394 | pub fn condition(self) -> Option<Condition<'a>> { | 1005 | pub fn condition(&self) -> Option<&Condition> { |
1395 | super::child_opt(self) | 1006 | super::child_opt(self) |
1396 | } | 1007 | } |
1397 | } | 1008 | } |
1398 | 1009 | ||
1399 | // ImplBlock | 1010 | // ImplBlock |
1400 | #[derive(Debug, Clone, Copy,)] | 1011 | #[derive(Debug, PartialEq, Eq, Hash)] |
1401 | pub struct ImplBlockNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1012 | #[repr(transparent)] |
1402 | pub(crate) syntax: SyntaxNode<R>, | 1013 | pub struct ImplBlock { |
1014 | pub(crate) syntax: SyntaxNode, | ||
1403 | } | 1015 | } |
1404 | pub type ImplBlock<'a> = ImplBlockNode<RefRoot<'a>>; | 1016 | unsafe impl TransparentNewType for ImplBlock { |
1405 | 1017 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1406 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplBlockNode<R1>> for ImplBlockNode<R2> { | ||
1407 | fn eq(&self, other: &ImplBlockNode<R1>) -> bool { self.syntax == other.syntax } | ||
1408 | } | ||
1409 | impl<R: TreeRoot<RaTypes>> Eq for ImplBlockNode<R> {} | ||
1410 | impl<R: TreeRoot<RaTypes>> Hash for ImplBlockNode<R> { | ||
1411 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1412 | } | 1018 | } |
1413 | 1019 | ||
1414 | impl<'a> AstNode<'a> for ImplBlock<'a> { | 1020 | impl AstNode for ImplBlock { |
1415 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1021 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1416 | match syntax.kind() { | 1022 | match syntax.kind() { |
1417 | IMPL_BLOCK => Some(ImplBlock { syntax }), | 1023 | IMPL_BLOCK => Some(ImplBlock::from_repr(syntax.into_repr())), |
1418 | _ => None, | 1024 | _ => None, |
1419 | } | 1025 | } |
1420 | } | 1026 | } |
1421 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1027 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1422 | } | 1028 | fn to_owned(&self) -> TreePtr<ImplBlock> { TreePtr::cast(self.syntax.to_owned()) } |
1423 | |||
1424 | impl<R: TreeRoot<RaTypes>> ImplBlockNode<R> { | ||
1425 | pub fn borrowed(&self) -> ImplBlock { | ||
1426 | ImplBlockNode { syntax: self.syntax.borrowed() } | ||
1427 | } | ||
1428 | pub fn owned(&self) -> ImplBlockNode { | ||
1429 | ImplBlockNode { syntax: self.syntax.owned() } | ||
1430 | } | ||
1431 | } | 1029 | } |
1432 | 1030 | ||
1433 | 1031 | ||
1434 | impl<'a> ImplBlock<'a> { | 1032 | impl ImplBlock { |
1435 | pub fn item_list(self) -> Option<ItemList<'a>> { | 1033 | pub fn item_list(&self) -> Option<&ItemList> { |
1436 | super::child_opt(self) | 1034 | super::child_opt(self) |
1437 | } | 1035 | } |
1438 | } | 1036 | } |
1439 | 1037 | ||
1440 | // ImplItem | 1038 | // ImplItem |
1039 | #[derive(Debug, PartialEq, Eq, Hash)] | ||
1040 | #[repr(transparent)] | ||
1041 | pub struct ImplItem { | ||
1042 | pub(crate) syntax: SyntaxNode, | ||
1043 | } | ||
1044 | unsafe impl TransparentNewType for ImplItem { | ||
1045 | type Repr = rowan::SyntaxNode<RaTypes>; | ||
1046 | } | ||
1047 | |||
1441 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 1048 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
1442 | pub enum ImplItem<'a> { | 1049 | pub enum ImplItemKind<'a> { |
1443 | FnDef(FnDef<'a>), | 1050 | FnDef(&'a FnDef), |
1444 | TypeDef(TypeDef<'a>), | 1051 | TypeDef(&'a TypeDef), |
1445 | ConstDef(ConstDef<'a>), | 1052 | ConstDef(&'a ConstDef), |
1446 | } | 1053 | } |
1447 | 1054 | ||
1448 | impl<'a> AstNode<'a> for ImplItem<'a> { | 1055 | impl AstNode for ImplItem { |
1449 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1056 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1450 | match syntax.kind() { | 1057 | match syntax.kind() { |
1451 | FN_DEF => Some(ImplItem::FnDef(FnDef { syntax })), | 1058 | | FN_DEF |
1452 | TYPE_DEF => Some(ImplItem::TypeDef(TypeDef { syntax })), | 1059 | | TYPE_DEF |
1453 | CONST_DEF => Some(ImplItem::ConstDef(ConstDef { syntax })), | 1060 | | CONST_DEF => Some(ImplItem::from_repr(syntax.into_repr())), |
1454 | _ => None, | 1061 | _ => None, |
1455 | } | 1062 | } |
1456 | } | 1063 | } |
1457 | fn syntax(self) -> SyntaxNodeRef<'a> { | 1064 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1458 | match self { | 1065 | fn to_owned(&self) -> TreePtr<ImplItem> { TreePtr::cast(self.syntax.to_owned()) } |
1459 | ImplItem::FnDef(inner) => inner.syntax(), | 1066 | } |
1460 | ImplItem::TypeDef(inner) => inner.syntax(), | 1067 | |
1461 | ImplItem::ConstDef(inner) => inner.syntax(), | 1068 | impl ImplItem { |
1069 | pub fn kind(&self) -> ImplItemKind { | ||
1070 | match self.syntax.kind() { | ||
1071 | FN_DEF => ImplItemKind::FnDef(FnDef::cast(&self.syntax).unwrap()), | ||
1072 | TYPE_DEF => ImplItemKind::TypeDef(TypeDef::cast(&self.syntax).unwrap()), | ||
1073 | CONST_DEF => ImplItemKind::ConstDef(ConstDef::cast(&self.syntax).unwrap()), | ||
1074 | _ => unreachable!(), | ||
1462 | } | 1075 | } |
1463 | } | 1076 | } |
1464 | } | 1077 | } |
1465 | 1078 | ||
1466 | impl<'a> ImplItem<'a> {} | 1079 | impl ImplItem {} |
1467 | 1080 | ||
1468 | // ImplTraitType | 1081 | // ImplTraitType |
1469 | #[derive(Debug, Clone, Copy,)] | 1082 | #[derive(Debug, PartialEq, Eq, Hash)] |
1470 | pub struct ImplTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1083 | #[repr(transparent)] |
1471 | pub(crate) syntax: SyntaxNode<R>, | 1084 | pub struct ImplTraitType { |
1472 | } | 1085 | pub(crate) syntax: SyntaxNode, |
1473 | pub type ImplTraitType<'a> = ImplTraitTypeNode<RefRoot<'a>>; | ||
1474 | |||
1475 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplTraitTypeNode<R1>> for ImplTraitTypeNode<R2> { | ||
1476 | fn eq(&self, other: &ImplTraitTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
1477 | } | 1086 | } |
1478 | impl<R: TreeRoot<RaTypes>> Eq for ImplTraitTypeNode<R> {} | 1087 | unsafe impl TransparentNewType for ImplTraitType { |
1479 | impl<R: TreeRoot<RaTypes>> Hash for ImplTraitTypeNode<R> { | 1088 | type Repr = rowan::SyntaxNode<RaTypes>; |
1480 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1481 | } | 1089 | } |
1482 | 1090 | ||
1483 | impl<'a> AstNode<'a> for ImplTraitType<'a> { | 1091 | impl AstNode for ImplTraitType { |
1484 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1092 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1485 | match syntax.kind() { | 1093 | match syntax.kind() { |
1486 | IMPL_TRAIT_TYPE => Some(ImplTraitType { syntax }), | 1094 | IMPL_TRAIT_TYPE => Some(ImplTraitType::from_repr(syntax.into_repr())), |
1487 | _ => None, | 1095 | _ => None, |
1488 | } | 1096 | } |
1489 | } | 1097 | } |
1490 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1098 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1099 | fn to_owned(&self) -> TreePtr<ImplTraitType> { TreePtr::cast(self.syntax.to_owned()) } | ||
1491 | } | 1100 | } |
1492 | 1101 | ||
1493 | impl<R: TreeRoot<RaTypes>> ImplTraitTypeNode<R> { | ||
1494 | pub fn borrowed(&self) -> ImplTraitType { | ||
1495 | ImplTraitTypeNode { syntax: self.syntax.borrowed() } | ||
1496 | } | ||
1497 | pub fn owned(&self) -> ImplTraitTypeNode { | ||
1498 | ImplTraitTypeNode { syntax: self.syntax.owned() } | ||
1499 | } | ||
1500 | } | ||
1501 | 1102 | ||
1502 | 1103 | impl ImplTraitType {} | |
1503 | impl<'a> ImplTraitType<'a> {} | ||
1504 | 1104 | ||
1505 | // IndexExpr | 1105 | // IndexExpr |
1506 | #[derive(Debug, Clone, Copy,)] | 1106 | #[derive(Debug, PartialEq, Eq, Hash)] |
1507 | pub struct IndexExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1107 | #[repr(transparent)] |
1508 | pub(crate) syntax: SyntaxNode<R>, | 1108 | pub struct IndexExpr { |
1109 | pub(crate) syntax: SyntaxNode, | ||
1509 | } | 1110 | } |
1510 | pub type IndexExpr<'a> = IndexExprNode<RefRoot<'a>>; | 1111 | unsafe impl TransparentNewType for IndexExpr { |
1511 | 1112 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1512 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<IndexExprNode<R1>> for IndexExprNode<R2> { | ||
1513 | fn eq(&self, other: &IndexExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1514 | } | ||
1515 | impl<R: TreeRoot<RaTypes>> Eq for IndexExprNode<R> {} | ||
1516 | impl<R: TreeRoot<RaTypes>> Hash for IndexExprNode<R> { | ||
1517 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1518 | } | 1113 | } |
1519 | 1114 | ||
1520 | impl<'a> AstNode<'a> for IndexExpr<'a> { | 1115 | impl AstNode for IndexExpr { |
1521 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1116 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1522 | match syntax.kind() { | 1117 | match syntax.kind() { |
1523 | INDEX_EXPR => Some(IndexExpr { syntax }), | 1118 | INDEX_EXPR => Some(IndexExpr::from_repr(syntax.into_repr())), |
1524 | _ => None, | 1119 | _ => None, |
1525 | } | 1120 | } |
1526 | } | 1121 | } |
1527 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1122 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1528 | } | 1123 | fn to_owned(&self) -> TreePtr<IndexExpr> { TreePtr::cast(self.syntax.to_owned()) } |
1529 | |||
1530 | impl<R: TreeRoot<RaTypes>> IndexExprNode<R> { | ||
1531 | pub fn borrowed(&self) -> IndexExpr { | ||
1532 | IndexExprNode { syntax: self.syntax.borrowed() } | ||
1533 | } | ||
1534 | pub fn owned(&self) -> IndexExprNode { | ||
1535 | IndexExprNode { syntax: self.syntax.owned() } | ||
1536 | } | ||
1537 | } | 1124 | } |
1538 | 1125 | ||
1539 | 1126 | ||
1540 | impl<'a> IndexExpr<'a> {} | 1127 | impl IndexExpr {} |
1541 | 1128 | ||
1542 | // ItemList | 1129 | // ItemList |
1543 | #[derive(Debug, Clone, Copy,)] | 1130 | #[derive(Debug, PartialEq, Eq, Hash)] |
1544 | pub struct ItemListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1131 | #[repr(transparent)] |
1545 | pub(crate) syntax: SyntaxNode<R>, | 1132 | pub struct ItemList { |
1133 | pub(crate) syntax: SyntaxNode, | ||
1546 | } | 1134 | } |
1547 | pub type ItemList<'a> = ItemListNode<RefRoot<'a>>; | 1135 | unsafe impl TransparentNewType for ItemList { |
1548 | 1136 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1549 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ItemListNode<R1>> for ItemListNode<R2> { | ||
1550 | fn eq(&self, other: &ItemListNode<R1>) -> bool { self.syntax == other.syntax } | ||
1551 | } | ||
1552 | impl<R: TreeRoot<RaTypes>> Eq for ItemListNode<R> {} | ||
1553 | impl<R: TreeRoot<RaTypes>> Hash for ItemListNode<R> { | ||
1554 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1555 | } | 1137 | } |
1556 | 1138 | ||
1557 | impl<'a> AstNode<'a> for ItemList<'a> { | 1139 | impl AstNode for ItemList { |
1558 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1140 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1559 | match syntax.kind() { | 1141 | match syntax.kind() { |
1560 | ITEM_LIST => Some(ItemList { syntax }), | 1142 | ITEM_LIST => Some(ItemList::from_repr(syntax.into_repr())), |
1561 | _ => None, | 1143 | _ => None, |
1562 | } | 1144 | } |
1563 | } | 1145 | } |
1564 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1146 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1565 | } | 1147 | fn to_owned(&self) -> TreePtr<ItemList> { TreePtr::cast(self.syntax.to_owned()) } |
1566 | |||
1567 | impl<R: TreeRoot<RaTypes>> ItemListNode<R> { | ||
1568 | pub fn borrowed(&self) -> ItemList { | ||
1569 | ItemListNode { syntax: self.syntax.borrowed() } | ||
1570 | } | ||
1571 | pub fn owned(&self) -> ItemListNode { | ||
1572 | ItemListNode { syntax: self.syntax.owned() } | ||
1573 | } | ||
1574 | } | 1148 | } |
1575 | 1149 | ||
1576 | 1150 | ||
1577 | impl<'a> ast::FnDefOwner<'a> for ItemList<'a> {} | 1151 | impl ast::FnDefOwner for ItemList {} |
1578 | impl<'a> ast::ModuleItemOwner<'a> for ItemList<'a> {} | 1152 | impl ast::ModuleItemOwner for ItemList {} |
1579 | impl<'a> ItemList<'a> { | 1153 | impl ItemList { |
1580 | pub fn impl_items(self) -> impl Iterator<Item = ImplItem<'a>> + 'a { | 1154 | pub fn impl_items(&self) -> impl Iterator<Item = &ImplItem> { |
1581 | super::children(self) | 1155 | super::children(self) |
1582 | } | 1156 | } |
1583 | } | 1157 | } |
1584 | 1158 | ||
1585 | // Label | 1159 | // Label |
1586 | #[derive(Debug, Clone, Copy,)] | 1160 | #[derive(Debug, PartialEq, Eq, Hash)] |
1587 | pub struct LabelNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1161 | #[repr(transparent)] |
1588 | pub(crate) syntax: SyntaxNode<R>, | 1162 | pub struct Label { |
1163 | pub(crate) syntax: SyntaxNode, | ||
1589 | } | 1164 | } |
1590 | pub type Label<'a> = LabelNode<RefRoot<'a>>; | 1165 | unsafe impl TransparentNewType for Label { |
1591 | 1166 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1592 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LabelNode<R1>> for LabelNode<R2> { | ||
1593 | fn eq(&self, other: &LabelNode<R1>) -> bool { self.syntax == other.syntax } | ||
1594 | } | ||
1595 | impl<R: TreeRoot<RaTypes>> Eq for LabelNode<R> {} | ||
1596 | impl<R: TreeRoot<RaTypes>> Hash for LabelNode<R> { | ||
1597 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1598 | } | 1167 | } |
1599 | 1168 | ||
1600 | impl<'a> AstNode<'a> for Label<'a> { | 1169 | impl AstNode for Label { |
1601 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1170 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1602 | match syntax.kind() { | 1171 | match syntax.kind() { |
1603 | LABEL => Some(Label { syntax }), | 1172 | LABEL => Some(Label::from_repr(syntax.into_repr())), |
1604 | _ => None, | 1173 | _ => None, |
1605 | } | 1174 | } |
1606 | } | 1175 | } |
1607 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1176 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1608 | } | 1177 | fn to_owned(&self) -> TreePtr<Label> { TreePtr::cast(self.syntax.to_owned()) } |
1609 | |||
1610 | impl<R: TreeRoot<RaTypes>> LabelNode<R> { | ||
1611 | pub fn borrowed(&self) -> Label { | ||
1612 | LabelNode { syntax: self.syntax.borrowed() } | ||
1613 | } | ||
1614 | pub fn owned(&self) -> LabelNode { | ||
1615 | LabelNode { syntax: self.syntax.owned() } | ||
1616 | } | ||
1617 | } | 1178 | } |
1618 | 1179 | ||
1619 | 1180 | ||
1620 | impl<'a> Label<'a> {} | 1181 | impl Label {} |
1621 | 1182 | ||
1622 | // LambdaExpr | 1183 | // LambdaExpr |
1623 | #[derive(Debug, Clone, Copy,)] | 1184 | #[derive(Debug, PartialEq, Eq, Hash)] |
1624 | pub struct LambdaExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1185 | #[repr(transparent)] |
1625 | pub(crate) syntax: SyntaxNode<R>, | 1186 | pub struct LambdaExpr { |
1626 | } | 1187 | pub(crate) syntax: SyntaxNode, |
1627 | pub type LambdaExpr<'a> = LambdaExprNode<RefRoot<'a>>; | ||
1628 | |||
1629 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LambdaExprNode<R1>> for LambdaExprNode<R2> { | ||
1630 | fn eq(&self, other: &LambdaExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1631 | } | 1188 | } |
1632 | impl<R: TreeRoot<RaTypes>> Eq for LambdaExprNode<R> {} | 1189 | unsafe impl TransparentNewType for LambdaExpr { |
1633 | impl<R: TreeRoot<RaTypes>> Hash for LambdaExprNode<R> { | 1190 | type Repr = rowan::SyntaxNode<RaTypes>; |
1634 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1635 | } | 1191 | } |
1636 | 1192 | ||
1637 | impl<'a> AstNode<'a> for LambdaExpr<'a> { | 1193 | impl AstNode for LambdaExpr { |
1638 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1194 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1639 | match syntax.kind() { | 1195 | match syntax.kind() { |
1640 | LAMBDA_EXPR => Some(LambdaExpr { syntax }), | 1196 | LAMBDA_EXPR => Some(LambdaExpr::from_repr(syntax.into_repr())), |
1641 | _ => None, | 1197 | _ => None, |
1642 | } | 1198 | } |
1643 | } | 1199 | } |
1644 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1200 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1645 | } | 1201 | fn to_owned(&self) -> TreePtr<LambdaExpr> { TreePtr::cast(self.syntax.to_owned()) } |
1646 | |||
1647 | impl<R: TreeRoot<RaTypes>> LambdaExprNode<R> { | ||
1648 | pub fn borrowed(&self) -> LambdaExpr { | ||
1649 | LambdaExprNode { syntax: self.syntax.borrowed() } | ||
1650 | } | ||
1651 | pub fn owned(&self) -> LambdaExprNode { | ||
1652 | LambdaExprNode { syntax: self.syntax.owned() } | ||
1653 | } | ||
1654 | } | 1202 | } |
1655 | 1203 | ||
1656 | 1204 | ||
1657 | impl<'a> LambdaExpr<'a> { | 1205 | impl LambdaExpr { |
1658 | pub fn param_list(self) -> Option<ParamList<'a>> { | 1206 | pub fn param_list(&self) -> Option<&ParamList> { |
1659 | super::child_opt(self) | 1207 | super::child_opt(self) |
1660 | } | 1208 | } |
1661 | 1209 | ||
1662 | pub fn body(self) -> Option<Expr<'a>> { | 1210 | pub fn body(&self) -> Option<&Expr> { |
1663 | super::child_opt(self) | 1211 | super::child_opt(self) |
1664 | } | 1212 | } |
1665 | } | 1213 | } |
1666 | 1214 | ||
1667 | // LetStmt | 1215 | // LetStmt |
1668 | #[derive(Debug, Clone, Copy,)] | 1216 | #[derive(Debug, PartialEq, Eq, Hash)] |
1669 | pub struct LetStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1217 | #[repr(transparent)] |
1670 | pub(crate) syntax: SyntaxNode<R>, | 1218 | pub struct LetStmt { |
1671 | } | 1219 | pub(crate) syntax: SyntaxNode, |
1672 | pub type LetStmt<'a> = LetStmtNode<RefRoot<'a>>; | ||
1673 | |||
1674 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LetStmtNode<R1>> for LetStmtNode<R2> { | ||
1675 | fn eq(&self, other: &LetStmtNode<R1>) -> bool { self.syntax == other.syntax } | ||
1676 | } | 1220 | } |
1677 | impl<R: TreeRoot<RaTypes>> Eq for LetStmtNode<R> {} | 1221 | unsafe impl TransparentNewType for LetStmt { |
1678 | impl<R: TreeRoot<RaTypes>> Hash for LetStmtNode<R> { | 1222 | type Repr = rowan::SyntaxNode<RaTypes>; |
1679 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1680 | } | 1223 | } |
1681 | 1224 | ||
1682 | impl<'a> AstNode<'a> for LetStmt<'a> { | 1225 | impl AstNode for LetStmt { |
1683 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1226 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1684 | match syntax.kind() { | 1227 | match syntax.kind() { |
1685 | LET_STMT => Some(LetStmt { syntax }), | 1228 | LET_STMT => Some(LetStmt::from_repr(syntax.into_repr())), |
1686 | _ => None, | 1229 | _ => None, |
1687 | } | 1230 | } |
1688 | } | 1231 | } |
1689 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1232 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1690 | } | 1233 | fn to_owned(&self) -> TreePtr<LetStmt> { TreePtr::cast(self.syntax.to_owned()) } |
1691 | |||
1692 | impl<R: TreeRoot<RaTypes>> LetStmtNode<R> { | ||
1693 | pub fn borrowed(&self) -> LetStmt { | ||
1694 | LetStmtNode { syntax: self.syntax.borrowed() } | ||
1695 | } | ||
1696 | pub fn owned(&self) -> LetStmtNode { | ||
1697 | LetStmtNode { syntax: self.syntax.owned() } | ||
1698 | } | ||
1699 | } | 1234 | } |
1700 | 1235 | ||
1701 | 1236 | ||
1702 | impl<'a> LetStmt<'a> { | 1237 | impl LetStmt { |
1703 | pub fn pat(self) -> Option<Pat<'a>> { | 1238 | pub fn pat(&self) -> Option<&Pat> { |
1704 | super::child_opt(self) | 1239 | super::child_opt(self) |
1705 | } | 1240 | } |
1706 | 1241 | ||
1707 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 1242 | pub fn type_ref(&self) -> Option<&TypeRef> { |
1708 | super::child_opt(self) | 1243 | super::child_opt(self) |
1709 | } | 1244 | } |
1710 | 1245 | ||
1711 | pub fn initializer(self) -> Option<Expr<'a>> { | 1246 | pub fn initializer(&self) -> Option<&Expr> { |
1712 | super::child_opt(self) | 1247 | super::child_opt(self) |
1713 | } | 1248 | } |
1714 | } | 1249 | } |
1715 | 1250 | ||
1716 | // Lifetime | 1251 | // Lifetime |
1717 | #[derive(Debug, Clone, Copy,)] | 1252 | #[derive(Debug, PartialEq, Eq, Hash)] |
1718 | pub struct LifetimeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1253 | #[repr(transparent)] |
1719 | pub(crate) syntax: SyntaxNode<R>, | 1254 | pub struct Lifetime { |
1255 | pub(crate) syntax: SyntaxNode, | ||
1720 | } | 1256 | } |
1721 | pub type Lifetime<'a> = LifetimeNode<RefRoot<'a>>; | 1257 | unsafe impl TransparentNewType for Lifetime { |
1722 | 1258 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1723 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeNode<R1>> for LifetimeNode<R2> { | ||
1724 | fn eq(&self, other: &LifetimeNode<R1>) -> bool { self.syntax == other.syntax } | ||
1725 | } | ||
1726 | impl<R: TreeRoot<RaTypes>> Eq for LifetimeNode<R> {} | ||
1727 | impl<R: TreeRoot<RaTypes>> Hash for LifetimeNode<R> { | ||
1728 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1729 | } | 1259 | } |
1730 | 1260 | ||
1731 | impl<'a> AstNode<'a> for Lifetime<'a> { | 1261 | impl AstNode for Lifetime { |
1732 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1262 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1733 | match syntax.kind() { | 1263 | match syntax.kind() { |
1734 | LIFETIME => Some(Lifetime { syntax }), | 1264 | LIFETIME => Some(Lifetime::from_repr(syntax.into_repr())), |
1735 | _ => None, | 1265 | _ => None, |
1736 | } | 1266 | } |
1737 | } | 1267 | } |
1738 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1268 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1739 | } | 1269 | fn to_owned(&self) -> TreePtr<Lifetime> { TreePtr::cast(self.syntax.to_owned()) } |
1740 | |||
1741 | impl<R: TreeRoot<RaTypes>> LifetimeNode<R> { | ||
1742 | pub fn borrowed(&self) -> Lifetime { | ||
1743 | LifetimeNode { syntax: self.syntax.borrowed() } | ||
1744 | } | ||
1745 | pub fn owned(&self) -> LifetimeNode { | ||
1746 | LifetimeNode { syntax: self.syntax.owned() } | ||
1747 | } | ||
1748 | } | 1270 | } |
1749 | 1271 | ||
1750 | 1272 | ||
1751 | impl<'a> Lifetime<'a> {} | 1273 | impl Lifetime {} |
1752 | 1274 | ||
1753 | // LifetimeParam | 1275 | // LifetimeParam |
1754 | #[derive(Debug, Clone, Copy,)] | 1276 | #[derive(Debug, PartialEq, Eq, Hash)] |
1755 | pub struct LifetimeParamNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1277 | #[repr(transparent)] |
1756 | pub(crate) syntax: SyntaxNode<R>, | 1278 | pub struct LifetimeParam { |
1757 | } | 1279 | pub(crate) syntax: SyntaxNode, |
1758 | pub type LifetimeParam<'a> = LifetimeParamNode<RefRoot<'a>>; | ||
1759 | |||
1760 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LifetimeParamNode<R1>> for LifetimeParamNode<R2> { | ||
1761 | fn eq(&self, other: &LifetimeParamNode<R1>) -> bool { self.syntax == other.syntax } | ||
1762 | } | 1280 | } |
1763 | impl<R: TreeRoot<RaTypes>> Eq for LifetimeParamNode<R> {} | 1281 | unsafe impl TransparentNewType for LifetimeParam { |
1764 | impl<R: TreeRoot<RaTypes>> Hash for LifetimeParamNode<R> { | 1282 | type Repr = rowan::SyntaxNode<RaTypes>; |
1765 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1766 | } | 1283 | } |
1767 | 1284 | ||
1768 | impl<'a> AstNode<'a> for LifetimeParam<'a> { | 1285 | impl AstNode for LifetimeParam { |
1769 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1286 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1770 | match syntax.kind() { | 1287 | match syntax.kind() { |
1771 | LIFETIME_PARAM => Some(LifetimeParam { syntax }), | 1288 | LIFETIME_PARAM => Some(LifetimeParam::from_repr(syntax.into_repr())), |
1772 | _ => None, | 1289 | _ => None, |
1773 | } | 1290 | } |
1774 | } | 1291 | } |
1775 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1292 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1293 | fn to_owned(&self) -> TreePtr<LifetimeParam> { TreePtr::cast(self.syntax.to_owned()) } | ||
1776 | } | 1294 | } |
1777 | 1295 | ||
1778 | impl<R: TreeRoot<RaTypes>> LifetimeParamNode<R> { | ||
1779 | pub fn borrowed(&self) -> LifetimeParam { | ||
1780 | LifetimeParamNode { syntax: self.syntax.borrowed() } | ||
1781 | } | ||
1782 | pub fn owned(&self) -> LifetimeParamNode { | ||
1783 | LifetimeParamNode { syntax: self.syntax.owned() } | ||
1784 | } | ||
1785 | } | ||
1786 | 1296 | ||
1787 | 1297 | impl LifetimeParam { | |
1788 | impl<'a> LifetimeParam<'a> { | 1298 | pub fn lifetime(&self) -> Option<&Lifetime> { |
1789 | pub fn lifetime(self) -> Option<Lifetime<'a>> { | ||
1790 | super::child_opt(self) | 1299 | super::child_opt(self) |
1791 | } | 1300 | } |
1792 | } | 1301 | } |
1793 | 1302 | ||
1794 | // Literal | 1303 | // Literal |
1795 | #[derive(Debug, Clone, Copy,)] | 1304 | #[derive(Debug, PartialEq, Eq, Hash)] |
1796 | pub struct LiteralNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1305 | #[repr(transparent)] |
1797 | pub(crate) syntax: SyntaxNode<R>, | 1306 | pub struct Literal { |
1798 | } | 1307 | pub(crate) syntax: SyntaxNode, |
1799 | pub type Literal<'a> = LiteralNode<RefRoot<'a>>; | ||
1800 | |||
1801 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LiteralNode<R1>> for LiteralNode<R2> { | ||
1802 | fn eq(&self, other: &LiteralNode<R1>) -> bool { self.syntax == other.syntax } | ||
1803 | } | 1308 | } |
1804 | impl<R: TreeRoot<RaTypes>> Eq for LiteralNode<R> {} | 1309 | unsafe impl TransparentNewType for Literal { |
1805 | impl<R: TreeRoot<RaTypes>> Hash for LiteralNode<R> { | 1310 | type Repr = rowan::SyntaxNode<RaTypes>; |
1806 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1807 | } | 1311 | } |
1808 | 1312 | ||
1809 | impl<'a> AstNode<'a> for Literal<'a> { | 1313 | impl AstNode for Literal { |
1810 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1314 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1811 | match syntax.kind() { | 1315 | match syntax.kind() { |
1812 | LITERAL => Some(Literal { syntax }), | 1316 | LITERAL => Some(Literal::from_repr(syntax.into_repr())), |
1813 | _ => None, | 1317 | _ => None, |
1814 | } | 1318 | } |
1815 | } | 1319 | } |
1816 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1320 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1817 | } | 1321 | fn to_owned(&self) -> TreePtr<Literal> { TreePtr::cast(self.syntax.to_owned()) } |
1818 | |||
1819 | impl<R: TreeRoot<RaTypes>> LiteralNode<R> { | ||
1820 | pub fn borrowed(&self) -> Literal { | ||
1821 | LiteralNode { syntax: self.syntax.borrowed() } | ||
1822 | } | ||
1823 | pub fn owned(&self) -> LiteralNode { | ||
1824 | LiteralNode { syntax: self.syntax.owned() } | ||
1825 | } | ||
1826 | } | 1322 | } |
1827 | 1323 | ||
1828 | 1324 | ||
1829 | impl<'a> Literal<'a> {} | 1325 | impl Literal {} |
1830 | 1326 | ||
1831 | // LoopExpr | 1327 | // LoopExpr |
1832 | #[derive(Debug, Clone, Copy,)] | 1328 | #[derive(Debug, PartialEq, Eq, Hash)] |
1833 | pub struct LoopExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1329 | #[repr(transparent)] |
1834 | pub(crate) syntax: SyntaxNode<R>, | 1330 | pub struct LoopExpr { |
1331 | pub(crate) syntax: SyntaxNode, | ||
1835 | } | 1332 | } |
1836 | pub type LoopExpr<'a> = LoopExprNode<RefRoot<'a>>; | 1333 | unsafe impl TransparentNewType for LoopExpr { |
1837 | 1334 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1838 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<LoopExprNode<R1>> for LoopExprNode<R2> { | ||
1839 | fn eq(&self, other: &LoopExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
1840 | } | ||
1841 | impl<R: TreeRoot<RaTypes>> Eq for LoopExprNode<R> {} | ||
1842 | impl<R: TreeRoot<RaTypes>> Hash for LoopExprNode<R> { | ||
1843 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1844 | } | 1335 | } |
1845 | 1336 | ||
1846 | impl<'a> AstNode<'a> for LoopExpr<'a> { | 1337 | impl AstNode for LoopExpr { |
1847 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1338 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1848 | match syntax.kind() { | 1339 | match syntax.kind() { |
1849 | LOOP_EXPR => Some(LoopExpr { syntax }), | 1340 | LOOP_EXPR => Some(LoopExpr::from_repr(syntax.into_repr())), |
1850 | _ => None, | 1341 | _ => None, |
1851 | } | 1342 | } |
1852 | } | 1343 | } |
1853 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1344 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1854 | } | 1345 | fn to_owned(&self) -> TreePtr<LoopExpr> { TreePtr::cast(self.syntax.to_owned()) } |
1855 | |||
1856 | impl<R: TreeRoot<RaTypes>> LoopExprNode<R> { | ||
1857 | pub fn borrowed(&self) -> LoopExpr { | ||
1858 | LoopExprNode { syntax: self.syntax.borrowed() } | ||
1859 | } | ||
1860 | pub fn owned(&self) -> LoopExprNode { | ||
1861 | LoopExprNode { syntax: self.syntax.owned() } | ||
1862 | } | ||
1863 | } | 1346 | } |
1864 | 1347 | ||
1865 | 1348 | ||
1866 | impl<'a> ast::LoopBodyOwner<'a> for LoopExpr<'a> {} | 1349 | impl ast::LoopBodyOwner for LoopExpr {} |
1867 | impl<'a> LoopExpr<'a> {} | 1350 | impl LoopExpr {} |
1868 | 1351 | ||
1869 | // MacroCall | 1352 | // MacroCall |
1870 | #[derive(Debug, Clone, Copy,)] | 1353 | #[derive(Debug, PartialEq, Eq, Hash)] |
1871 | pub struct MacroCallNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1354 | #[repr(transparent)] |
1872 | pub(crate) syntax: SyntaxNode<R>, | 1355 | pub struct MacroCall { |
1356 | pub(crate) syntax: SyntaxNode, | ||
1873 | } | 1357 | } |
1874 | pub type MacroCall<'a> = MacroCallNode<RefRoot<'a>>; | 1358 | unsafe impl TransparentNewType for MacroCall { |
1875 | 1359 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1876 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MacroCallNode<R1>> for MacroCallNode<R2> { | ||
1877 | fn eq(&self, other: &MacroCallNode<R1>) -> bool { self.syntax == other.syntax } | ||
1878 | } | ||
1879 | impl<R: TreeRoot<RaTypes>> Eq for MacroCallNode<R> {} | ||
1880 | impl<R: TreeRoot<RaTypes>> Hash for MacroCallNode<R> { | ||
1881 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1882 | } | 1360 | } |
1883 | 1361 | ||
1884 | impl<'a> AstNode<'a> for MacroCall<'a> { | 1362 | impl AstNode for MacroCall { |
1885 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1363 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1886 | match syntax.kind() { | 1364 | match syntax.kind() { |
1887 | MACRO_CALL => Some(MacroCall { syntax }), | 1365 | MACRO_CALL => Some(MacroCall::from_repr(syntax.into_repr())), |
1888 | _ => None, | 1366 | _ => None, |
1889 | } | 1367 | } |
1890 | } | 1368 | } |
1891 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1369 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1892 | } | 1370 | fn to_owned(&self) -> TreePtr<MacroCall> { TreePtr::cast(self.syntax.to_owned()) } |
1893 | |||
1894 | impl<R: TreeRoot<RaTypes>> MacroCallNode<R> { | ||
1895 | pub fn borrowed(&self) -> MacroCall { | ||
1896 | MacroCallNode { syntax: self.syntax.borrowed() } | ||
1897 | } | ||
1898 | pub fn owned(&self) -> MacroCallNode { | ||
1899 | MacroCallNode { syntax: self.syntax.owned() } | ||
1900 | } | ||
1901 | } | 1371 | } |
1902 | 1372 | ||
1903 | 1373 | ||
1904 | impl<'a> MacroCall<'a> { | 1374 | impl MacroCall { |
1905 | pub fn token_tree(self) -> Option<TokenTree<'a>> { | 1375 | pub fn token_tree(&self) -> Option<&TokenTree> { |
1906 | super::child_opt(self) | 1376 | super::child_opt(self) |
1907 | } | 1377 | } |
1908 | 1378 | ||
1909 | pub fn path(self) -> Option<Path<'a>> { | 1379 | pub fn path(&self) -> Option<&Path> { |
1910 | super::child_opt(self) | 1380 | super::child_opt(self) |
1911 | } | 1381 | } |
1912 | } | 1382 | } |
1913 | 1383 | ||
1914 | // MatchArm | 1384 | // MatchArm |
1915 | #[derive(Debug, Clone, Copy,)] | 1385 | #[derive(Debug, PartialEq, Eq, Hash)] |
1916 | pub struct MatchArmNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1386 | #[repr(transparent)] |
1917 | pub(crate) syntax: SyntaxNode<R>, | 1387 | pub struct MatchArm { |
1388 | pub(crate) syntax: SyntaxNode, | ||
1918 | } | 1389 | } |
1919 | pub type MatchArm<'a> = MatchArmNode<RefRoot<'a>>; | 1390 | unsafe impl TransparentNewType for MatchArm { |
1920 | 1391 | type Repr = rowan::SyntaxNode<RaTypes>; | |
1921 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmNode<R1>> for MatchArmNode<R2> { | ||
1922 | fn eq(&self, other: &MatchArmNode<R1>) -> bool { self.syntax == other.syntax } | ||
1923 | } | ||
1924 | impl<R: TreeRoot<RaTypes>> Eq for MatchArmNode<R> {} | ||
1925 | impl<R: TreeRoot<RaTypes>> Hash for MatchArmNode<R> { | ||
1926 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1927 | } | 1392 | } |
1928 | 1393 | ||
1929 | impl<'a> AstNode<'a> for MatchArm<'a> { | 1394 | impl AstNode for MatchArm { |
1930 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1395 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1931 | match syntax.kind() { | 1396 | match syntax.kind() { |
1932 | MATCH_ARM => Some(MatchArm { syntax }), | 1397 | MATCH_ARM => Some(MatchArm::from_repr(syntax.into_repr())), |
1933 | _ => None, | 1398 | _ => None, |
1934 | } | 1399 | } |
1935 | } | 1400 | } |
1936 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1401 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1402 | fn to_owned(&self) -> TreePtr<MatchArm> { TreePtr::cast(self.syntax.to_owned()) } | ||
1937 | } | 1403 | } |
1938 | 1404 | ||
1939 | impl<R: TreeRoot<RaTypes>> MatchArmNode<R> { | ||
1940 | pub fn borrowed(&self) -> MatchArm { | ||
1941 | MatchArmNode { syntax: self.syntax.borrowed() } | ||
1942 | } | ||
1943 | pub fn owned(&self) -> MatchArmNode { | ||
1944 | MatchArmNode { syntax: self.syntax.owned() } | ||
1945 | } | ||
1946 | } | ||
1947 | 1405 | ||
1948 | 1406 | impl MatchArm { | |
1949 | impl<'a> MatchArm<'a> { | 1407 | pub fn pats(&self) -> impl Iterator<Item = &Pat> { |
1950 | pub fn pats(self) -> impl Iterator<Item = Pat<'a>> + 'a { | ||
1951 | super::children(self) | 1408 | super::children(self) |
1952 | } | 1409 | } |
1953 | 1410 | ||
1954 | pub fn guard(self) -> Option<MatchGuard<'a>> { | 1411 | pub fn guard(&self) -> Option<&MatchGuard> { |
1955 | super::child_opt(self) | 1412 | super::child_opt(self) |
1956 | } | 1413 | } |
1957 | 1414 | ||
1958 | pub fn expr(self) -> Option<Expr<'a>> { | 1415 | pub fn expr(&self) -> Option<&Expr> { |
1959 | super::child_opt(self) | 1416 | super::child_opt(self) |
1960 | } | 1417 | } |
1961 | } | 1418 | } |
1962 | 1419 | ||
1963 | // MatchArmList | 1420 | // MatchArmList |
1964 | #[derive(Debug, Clone, Copy,)] | 1421 | #[derive(Debug, PartialEq, Eq, Hash)] |
1965 | pub struct MatchArmListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1422 | #[repr(transparent)] |
1966 | pub(crate) syntax: SyntaxNode<R>, | 1423 | pub struct MatchArmList { |
1967 | } | 1424 | pub(crate) syntax: SyntaxNode, |
1968 | pub type MatchArmList<'a> = MatchArmListNode<RefRoot<'a>>; | ||
1969 | |||
1970 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchArmListNode<R1>> for MatchArmListNode<R2> { | ||
1971 | fn eq(&self, other: &MatchArmListNode<R1>) -> bool { self.syntax == other.syntax } | ||
1972 | } | 1425 | } |
1973 | impl<R: TreeRoot<RaTypes>> Eq for MatchArmListNode<R> {} | 1426 | unsafe impl TransparentNewType for MatchArmList { |
1974 | impl<R: TreeRoot<RaTypes>> Hash for MatchArmListNode<R> { | 1427 | type Repr = rowan::SyntaxNode<RaTypes>; |
1975 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
1976 | } | 1428 | } |
1977 | 1429 | ||
1978 | impl<'a> AstNode<'a> for MatchArmList<'a> { | 1430 | impl AstNode for MatchArmList { |
1979 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1431 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
1980 | match syntax.kind() { | 1432 | match syntax.kind() { |
1981 | MATCH_ARM_LIST => Some(MatchArmList { syntax }), | 1433 | MATCH_ARM_LIST => Some(MatchArmList::from_repr(syntax.into_repr())), |
1982 | _ => None, | 1434 | _ => None, |
1983 | } | 1435 | } |
1984 | } | 1436 | } |
1985 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1437 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1438 | fn to_owned(&self) -> TreePtr<MatchArmList> { TreePtr::cast(self.syntax.to_owned()) } | ||
1986 | } | 1439 | } |
1987 | 1440 | ||
1988 | impl<R: TreeRoot<RaTypes>> MatchArmListNode<R> { | ||
1989 | pub fn borrowed(&self) -> MatchArmList { | ||
1990 | MatchArmListNode { syntax: self.syntax.borrowed() } | ||
1991 | } | ||
1992 | pub fn owned(&self) -> MatchArmListNode { | ||
1993 | MatchArmListNode { syntax: self.syntax.owned() } | ||
1994 | } | ||
1995 | } | ||
1996 | 1441 | ||
1997 | 1442 | impl MatchArmList { | |
1998 | impl<'a> MatchArmList<'a> { | 1443 | pub fn arms(&self) -> impl Iterator<Item = &MatchArm> { |
1999 | pub fn arms(self) -> impl Iterator<Item = MatchArm<'a>> + 'a { | ||
2000 | super::children(self) | 1444 | super::children(self) |
2001 | } | 1445 | } |
2002 | } | 1446 | } |
2003 | 1447 | ||
2004 | // MatchExpr | 1448 | // MatchExpr |
2005 | #[derive(Debug, Clone, Copy,)] | 1449 | #[derive(Debug, PartialEq, Eq, Hash)] |
2006 | pub struct MatchExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1450 | #[repr(transparent)] |
2007 | pub(crate) syntax: SyntaxNode<R>, | 1451 | pub struct MatchExpr { |
2008 | } | 1452 | pub(crate) syntax: SyntaxNode, |
2009 | pub type MatchExpr<'a> = MatchExprNode<RefRoot<'a>>; | ||
2010 | |||
2011 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchExprNode<R1>> for MatchExprNode<R2> { | ||
2012 | fn eq(&self, other: &MatchExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
2013 | } | 1453 | } |
2014 | impl<R: TreeRoot<RaTypes>> Eq for MatchExprNode<R> {} | 1454 | unsafe impl TransparentNewType for MatchExpr { |
2015 | impl<R: TreeRoot<RaTypes>> Hash for MatchExprNode<R> { | 1455 | type Repr = rowan::SyntaxNode<RaTypes>; |
2016 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2017 | } | 1456 | } |
2018 | 1457 | ||
2019 | impl<'a> AstNode<'a> for MatchExpr<'a> { | 1458 | impl AstNode for MatchExpr { |
2020 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1459 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2021 | match syntax.kind() { | 1460 | match syntax.kind() { |
2022 | MATCH_EXPR => Some(MatchExpr { syntax }), | 1461 | MATCH_EXPR => Some(MatchExpr::from_repr(syntax.into_repr())), |
2023 | _ => None, | 1462 | _ => None, |
2024 | } | 1463 | } |
2025 | } | 1464 | } |
2026 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1465 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2027 | } | 1466 | fn to_owned(&self) -> TreePtr<MatchExpr> { TreePtr::cast(self.syntax.to_owned()) } |
2028 | |||
2029 | impl<R: TreeRoot<RaTypes>> MatchExprNode<R> { | ||
2030 | pub fn borrowed(&self) -> MatchExpr { | ||
2031 | MatchExprNode { syntax: self.syntax.borrowed() } | ||
2032 | } | ||
2033 | pub fn owned(&self) -> MatchExprNode { | ||
2034 | MatchExprNode { syntax: self.syntax.owned() } | ||
2035 | } | ||
2036 | } | 1467 | } |
2037 | 1468 | ||
2038 | 1469 | ||
2039 | impl<'a> MatchExpr<'a> { | 1470 | impl MatchExpr { |
2040 | pub fn expr(self) -> Option<Expr<'a>> { | 1471 | pub fn expr(&self) -> Option<&Expr> { |
2041 | super::child_opt(self) | 1472 | super::child_opt(self) |
2042 | } | 1473 | } |
2043 | 1474 | ||
2044 | pub fn match_arm_list(self) -> Option<MatchArmList<'a>> { | 1475 | pub fn match_arm_list(&self) -> Option<&MatchArmList> { |
2045 | super::child_opt(self) | 1476 | super::child_opt(self) |
2046 | } | 1477 | } |
2047 | } | 1478 | } |
2048 | 1479 | ||
2049 | // MatchGuard | 1480 | // MatchGuard |
2050 | #[derive(Debug, Clone, Copy,)] | 1481 | #[derive(Debug, PartialEq, Eq, Hash)] |
2051 | pub struct MatchGuardNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1482 | #[repr(transparent)] |
2052 | pub(crate) syntax: SyntaxNode<R>, | 1483 | pub struct MatchGuard { |
1484 | pub(crate) syntax: SyntaxNode, | ||
2053 | } | 1485 | } |
2054 | pub type MatchGuard<'a> = MatchGuardNode<RefRoot<'a>>; | 1486 | unsafe impl TransparentNewType for MatchGuard { |
2055 | 1487 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2056 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MatchGuardNode<R1>> for MatchGuardNode<R2> { | ||
2057 | fn eq(&self, other: &MatchGuardNode<R1>) -> bool { self.syntax == other.syntax } | ||
2058 | } | ||
2059 | impl<R: TreeRoot<RaTypes>> Eq for MatchGuardNode<R> {} | ||
2060 | impl<R: TreeRoot<RaTypes>> Hash for MatchGuardNode<R> { | ||
2061 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2062 | } | 1488 | } |
2063 | 1489 | ||
2064 | impl<'a> AstNode<'a> for MatchGuard<'a> { | 1490 | impl AstNode for MatchGuard { |
2065 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1491 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2066 | match syntax.kind() { | 1492 | match syntax.kind() { |
2067 | MATCH_GUARD => Some(MatchGuard { syntax }), | 1493 | MATCH_GUARD => Some(MatchGuard::from_repr(syntax.into_repr())), |
2068 | _ => None, | 1494 | _ => None, |
2069 | } | 1495 | } |
2070 | } | 1496 | } |
2071 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1497 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2072 | } | 1498 | fn to_owned(&self) -> TreePtr<MatchGuard> { TreePtr::cast(self.syntax.to_owned()) } |
2073 | |||
2074 | impl<R: TreeRoot<RaTypes>> MatchGuardNode<R> { | ||
2075 | pub fn borrowed(&self) -> MatchGuard { | ||
2076 | MatchGuardNode { syntax: self.syntax.borrowed() } | ||
2077 | } | ||
2078 | pub fn owned(&self) -> MatchGuardNode { | ||
2079 | MatchGuardNode { syntax: self.syntax.owned() } | ||
2080 | } | ||
2081 | } | 1499 | } |
2082 | 1500 | ||
2083 | 1501 | ||
2084 | impl<'a> MatchGuard<'a> {} | 1502 | impl MatchGuard {} |
2085 | 1503 | ||
2086 | // MethodCallExpr | 1504 | // MethodCallExpr |
2087 | #[derive(Debug, Clone, Copy,)] | 1505 | #[derive(Debug, PartialEq, Eq, Hash)] |
2088 | pub struct MethodCallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1506 | #[repr(transparent)] |
2089 | pub(crate) syntax: SyntaxNode<R>, | 1507 | pub struct MethodCallExpr { |
2090 | } | 1508 | pub(crate) syntax: SyntaxNode, |
2091 | pub type MethodCallExpr<'a> = MethodCallExprNode<RefRoot<'a>>; | ||
2092 | |||
2093 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<MethodCallExprNode<R1>> for MethodCallExprNode<R2> { | ||
2094 | fn eq(&self, other: &MethodCallExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
2095 | } | 1509 | } |
2096 | impl<R: TreeRoot<RaTypes>> Eq for MethodCallExprNode<R> {} | 1510 | unsafe impl TransparentNewType for MethodCallExpr { |
2097 | impl<R: TreeRoot<RaTypes>> Hash for MethodCallExprNode<R> { | 1511 | type Repr = rowan::SyntaxNode<RaTypes>; |
2098 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2099 | } | 1512 | } |
2100 | 1513 | ||
2101 | impl<'a> AstNode<'a> for MethodCallExpr<'a> { | 1514 | impl AstNode for MethodCallExpr { |
2102 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1515 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2103 | match syntax.kind() { | 1516 | match syntax.kind() { |
2104 | METHOD_CALL_EXPR => Some(MethodCallExpr { syntax }), | 1517 | METHOD_CALL_EXPR => Some(MethodCallExpr::from_repr(syntax.into_repr())), |
2105 | _ => None, | 1518 | _ => None, |
2106 | } | 1519 | } |
2107 | } | 1520 | } |
2108 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1521 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1522 | fn to_owned(&self) -> TreePtr<MethodCallExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
2109 | } | 1523 | } |
2110 | 1524 | ||
2111 | impl<R: TreeRoot<RaTypes>> MethodCallExprNode<R> { | ||
2112 | pub fn borrowed(&self) -> MethodCallExpr { | ||
2113 | MethodCallExprNode { syntax: self.syntax.borrowed() } | ||
2114 | } | ||
2115 | pub fn owned(&self) -> MethodCallExprNode { | ||
2116 | MethodCallExprNode { syntax: self.syntax.owned() } | ||
2117 | } | ||
2118 | } | ||
2119 | 1525 | ||
2120 | 1526 | impl ast::ArgListOwner for MethodCallExpr {} | |
2121 | impl<'a> ast::ArgListOwner<'a> for MethodCallExpr<'a> {} | 1527 | impl MethodCallExpr { |
2122 | impl<'a> MethodCallExpr<'a> { | 1528 | pub fn expr(&self) -> Option<&Expr> { |
2123 | pub fn expr(self) -> Option<Expr<'a>> { | ||
2124 | super::child_opt(self) | 1529 | super::child_opt(self) |
2125 | } | 1530 | } |
2126 | 1531 | ||
2127 | pub fn name_ref(self) -> Option<NameRef<'a>> { | 1532 | pub fn name_ref(&self) -> Option<&NameRef> { |
2128 | super::child_opt(self) | 1533 | super::child_opt(self) |
2129 | } | 1534 | } |
2130 | } | 1535 | } |
2131 | 1536 | ||
2132 | // Module | 1537 | // Module |
2133 | #[derive(Debug, Clone, Copy,)] | 1538 | #[derive(Debug, PartialEq, Eq, Hash)] |
2134 | pub struct ModuleNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1539 | #[repr(transparent)] |
2135 | pub(crate) syntax: SyntaxNode<R>, | 1540 | pub struct Module { |
2136 | } | 1541 | pub(crate) syntax: SyntaxNode, |
2137 | pub type Module<'a> = ModuleNode<RefRoot<'a>>; | ||
2138 | |||
2139 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ModuleNode<R1>> for ModuleNode<R2> { | ||
2140 | fn eq(&self, other: &ModuleNode<R1>) -> bool { self.syntax == other.syntax } | ||
2141 | } | 1542 | } |
2142 | impl<R: TreeRoot<RaTypes>> Eq for ModuleNode<R> {} | 1543 | unsafe impl TransparentNewType for Module { |
2143 | impl<R: TreeRoot<RaTypes>> Hash for ModuleNode<R> { | 1544 | type Repr = rowan::SyntaxNode<RaTypes>; |
2144 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2145 | } | 1545 | } |
2146 | 1546 | ||
2147 | impl<'a> AstNode<'a> for Module<'a> { | 1547 | impl AstNode for Module { |
2148 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1548 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2149 | match syntax.kind() { | 1549 | match syntax.kind() { |
2150 | MODULE => Some(Module { syntax }), | 1550 | MODULE => Some(Module::from_repr(syntax.into_repr())), |
2151 | _ => None, | 1551 | _ => None, |
2152 | } | 1552 | } |
2153 | } | 1553 | } |
2154 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1554 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1555 | fn to_owned(&self) -> TreePtr<Module> { TreePtr::cast(self.syntax.to_owned()) } | ||
2155 | } | 1556 | } |
2156 | 1557 | ||
2157 | impl<R: TreeRoot<RaTypes>> ModuleNode<R> { | ||
2158 | pub fn borrowed(&self) -> Module { | ||
2159 | ModuleNode { syntax: self.syntax.borrowed() } | ||
2160 | } | ||
2161 | pub fn owned(&self) -> ModuleNode { | ||
2162 | ModuleNode { syntax: self.syntax.owned() } | ||
2163 | } | ||
2164 | } | ||
2165 | 1558 | ||
2166 | 1559 | impl ast::VisibilityOwner for Module {} | |
2167 | impl<'a> ast::VisibilityOwner<'a> for Module<'a> {} | 1560 | impl ast::NameOwner for Module {} |
2168 | impl<'a> ast::NameOwner<'a> for Module<'a> {} | 1561 | impl ast::AttrsOwner for Module {} |
2169 | impl<'a> ast::AttrsOwner<'a> for Module<'a> {} | 1562 | impl ast::DocCommentsOwner for Module {} |
2170 | impl<'a> ast::DocCommentsOwner<'a> for Module<'a> {} | 1563 | impl Module { |
2171 | impl<'a> Module<'a> { | 1564 | pub fn item_list(&self) -> Option<&ItemList> { |
2172 | pub fn item_list(self) -> Option<ItemList<'a>> { | ||
2173 | super::child_opt(self) | 1565 | super::child_opt(self) |
2174 | } | 1566 | } |
2175 | } | 1567 | } |
2176 | 1568 | ||
2177 | // ModuleItem | 1569 | // ModuleItem |
2178 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 1570 | #[derive(Debug, PartialEq, Eq, Hash)] |
2179 | pub enum ModuleItem<'a> { | 1571 | #[repr(transparent)] |
2180 | StructDef(StructDef<'a>), | 1572 | pub struct ModuleItem { |
2181 | EnumDef(EnumDef<'a>), | 1573 | pub(crate) syntax: SyntaxNode, |
2182 | FnDef(FnDef<'a>), | 1574 | } |
2183 | TraitDef(TraitDef<'a>), | 1575 | unsafe impl TransparentNewType for ModuleItem { |
2184 | TypeDef(TypeDef<'a>), | 1576 | type Repr = rowan::SyntaxNode<RaTypes>; |
2185 | ImplBlock(ImplBlock<'a>), | ||
2186 | UseItem(UseItem<'a>), | ||
2187 | ExternCrateItem(ExternCrateItem<'a>), | ||
2188 | ConstDef(ConstDef<'a>), | ||
2189 | StaticDef(StaticDef<'a>), | ||
2190 | Module(Module<'a>), | ||
2191 | } | ||
2192 | |||
2193 | impl<'a> AstNode<'a> for ModuleItem<'a> { | ||
2194 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | ||
2195 | match syntax.kind() { | ||
2196 | STRUCT_DEF => Some(ModuleItem::StructDef(StructDef { syntax })), | ||
2197 | ENUM_DEF => Some(ModuleItem::EnumDef(EnumDef { syntax })), | ||
2198 | FN_DEF => Some(ModuleItem::FnDef(FnDef { syntax })), | ||
2199 | TRAIT_DEF => Some(ModuleItem::TraitDef(TraitDef { syntax })), | ||
2200 | TYPE_DEF => Some(ModuleItem::TypeDef(TypeDef { syntax })), | ||
2201 | IMPL_BLOCK => Some(ModuleItem::ImplBlock(ImplBlock { syntax })), | ||
2202 | USE_ITEM => Some(ModuleItem::UseItem(UseItem { syntax })), | ||
2203 | EXTERN_CRATE_ITEM => Some(ModuleItem::ExternCrateItem(ExternCrateItem { syntax })), | ||
2204 | CONST_DEF => Some(ModuleItem::ConstDef(ConstDef { syntax })), | ||
2205 | STATIC_DEF => Some(ModuleItem::StaticDef(StaticDef { syntax })), | ||
2206 | MODULE => Some(ModuleItem::Module(Module { syntax })), | ||
2207 | _ => None, | ||
2208 | } | ||
2209 | } | ||
2210 | fn syntax(self) -> SyntaxNodeRef<'a> { | ||
2211 | match self { | ||
2212 | ModuleItem::StructDef(inner) => inner.syntax(), | ||
2213 | ModuleItem::EnumDef(inner) => inner.syntax(), | ||
2214 | ModuleItem::FnDef(inner) => inner.syntax(), | ||
2215 | ModuleItem::TraitDef(inner) => inner.syntax(), | ||
2216 | ModuleItem::TypeDef(inner) => inner.syntax(), | ||
2217 | ModuleItem::ImplBlock(inner) => inner.syntax(), | ||
2218 | ModuleItem::UseItem(inner) => inner.syntax(), | ||
2219 | ModuleItem::ExternCrateItem(inner) => inner.syntax(), | ||
2220 | ModuleItem::ConstDef(inner) => inner.syntax(), | ||
2221 | ModuleItem::StaticDef(inner) => inner.syntax(), | ||
2222 | ModuleItem::Module(inner) => inner.syntax(), | ||
2223 | } | ||
2224 | } | ||
2225 | } | 1577 | } |
2226 | 1578 | ||
2227 | impl<'a> ModuleItem<'a> {} | 1579 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
1580 | pub enum ModuleItemKind<'a> { | ||
1581 | StructDef(&'a StructDef), | ||
1582 | EnumDef(&'a EnumDef), | ||
1583 | FnDef(&'a FnDef), | ||
1584 | TraitDef(&'a TraitDef), | ||
1585 | TypeDef(&'a TypeDef), | ||
1586 | ImplBlock(&'a ImplBlock), | ||
1587 | UseItem(&'a UseItem), | ||
1588 | ExternCrateItem(&'a ExternCrateItem), | ||
1589 | ConstDef(&'a ConstDef), | ||
1590 | StaticDef(&'a StaticDef), | ||
1591 | Module(&'a Module), | ||
1592 | } | ||
1593 | |||
1594 | impl AstNode for ModuleItem { | ||
1595 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { | ||
1596 | match syntax.kind() { | ||
1597 | | STRUCT_DEF | ||
1598 | | ENUM_DEF | ||
1599 | | FN_DEF | ||
1600 | | TRAIT_DEF | ||
1601 | | TYPE_DEF | ||
1602 | | IMPL_BLOCK | ||
1603 | | USE_ITEM | ||
1604 | | EXTERN_CRATE_ITEM | ||
1605 | | CONST_DEF | ||
1606 | | STATIC_DEF | ||
1607 | | MODULE => Some(ModuleItem::from_repr(syntax.into_repr())), | ||
1608 | _ => None, | ||
1609 | } | ||
1610 | } | ||
1611 | fn syntax(&self) -> &SyntaxNode { &self.syntax } | ||
1612 | fn to_owned(&self) -> TreePtr<ModuleItem> { TreePtr::cast(self.syntax.to_owned()) } | ||
1613 | } | ||
1614 | |||
1615 | impl ModuleItem { | ||
1616 | pub fn kind(&self) -> ModuleItemKind { | ||
1617 | match self.syntax.kind() { | ||
1618 | STRUCT_DEF => ModuleItemKind::StructDef(StructDef::cast(&self.syntax).unwrap()), | ||
1619 | ENUM_DEF => ModuleItemKind::EnumDef(EnumDef::cast(&self.syntax).unwrap()), | ||
1620 | FN_DEF => ModuleItemKind::FnDef(FnDef::cast(&self.syntax).unwrap()), | ||
1621 | TRAIT_DEF => ModuleItemKind::TraitDef(TraitDef::cast(&self.syntax).unwrap()), | ||
1622 | TYPE_DEF => ModuleItemKind::TypeDef(TypeDef::cast(&self.syntax).unwrap()), | ||
1623 | IMPL_BLOCK => ModuleItemKind::ImplBlock(ImplBlock::cast(&self.syntax).unwrap()), | ||
1624 | USE_ITEM => ModuleItemKind::UseItem(UseItem::cast(&self.syntax).unwrap()), | ||
1625 | EXTERN_CRATE_ITEM => ModuleItemKind::ExternCrateItem(ExternCrateItem::cast(&self.syntax).unwrap()), | ||
1626 | CONST_DEF => ModuleItemKind::ConstDef(ConstDef::cast(&self.syntax).unwrap()), | ||
1627 | STATIC_DEF => ModuleItemKind::StaticDef(StaticDef::cast(&self.syntax).unwrap()), | ||
1628 | MODULE => ModuleItemKind::Module(Module::cast(&self.syntax).unwrap()), | ||
1629 | _ => unreachable!(), | ||
1630 | } | ||
1631 | } | ||
1632 | } | ||
1633 | |||
1634 | impl ModuleItem {} | ||
2228 | 1635 | ||
2229 | // Name | 1636 | // Name |
2230 | #[derive(Debug, Clone, Copy,)] | 1637 | #[derive(Debug, PartialEq, Eq, Hash)] |
2231 | pub struct NameNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1638 | #[repr(transparent)] |
2232 | pub(crate) syntax: SyntaxNode<R>, | 1639 | pub struct Name { |
2233 | } | 1640 | pub(crate) syntax: SyntaxNode, |
2234 | pub type Name<'a> = NameNode<RefRoot<'a>>; | ||
2235 | |||
2236 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameNode<R1>> for NameNode<R2> { | ||
2237 | fn eq(&self, other: &NameNode<R1>) -> bool { self.syntax == other.syntax } | ||
2238 | } | 1641 | } |
2239 | impl<R: TreeRoot<RaTypes>> Eq for NameNode<R> {} | 1642 | unsafe impl TransparentNewType for Name { |
2240 | impl<R: TreeRoot<RaTypes>> Hash for NameNode<R> { | 1643 | type Repr = rowan::SyntaxNode<RaTypes>; |
2241 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2242 | } | 1644 | } |
2243 | 1645 | ||
2244 | impl<'a> AstNode<'a> for Name<'a> { | 1646 | impl AstNode for Name { |
2245 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1647 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2246 | match syntax.kind() { | 1648 | match syntax.kind() { |
2247 | NAME => Some(Name { syntax }), | 1649 | NAME => Some(Name::from_repr(syntax.into_repr())), |
2248 | _ => None, | 1650 | _ => None, |
2249 | } | 1651 | } |
2250 | } | 1652 | } |
2251 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1653 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1654 | fn to_owned(&self) -> TreePtr<Name> { TreePtr::cast(self.syntax.to_owned()) } | ||
2252 | } | 1655 | } |
2253 | 1656 | ||
2254 | impl<R: TreeRoot<RaTypes>> NameNode<R> { | ||
2255 | pub fn borrowed(&self) -> Name { | ||
2256 | NameNode { syntax: self.syntax.borrowed() } | ||
2257 | } | ||
2258 | pub fn owned(&self) -> NameNode { | ||
2259 | NameNode { syntax: self.syntax.owned() } | ||
2260 | } | ||
2261 | } | ||
2262 | 1657 | ||
2263 | 1658 | impl Name {} | |
2264 | impl<'a> Name<'a> {} | ||
2265 | 1659 | ||
2266 | // NameRef | 1660 | // NameRef |
2267 | #[derive(Debug, Clone, Copy,)] | 1661 | #[derive(Debug, PartialEq, Eq, Hash)] |
2268 | pub struct NameRefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1662 | #[repr(transparent)] |
2269 | pub(crate) syntax: SyntaxNode<R>, | 1663 | pub struct NameRef { |
2270 | } | 1664 | pub(crate) syntax: SyntaxNode, |
2271 | pub type NameRef<'a> = NameRefNode<RefRoot<'a>>; | ||
2272 | |||
2273 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NameRefNode<R1>> for NameRefNode<R2> { | ||
2274 | fn eq(&self, other: &NameRefNode<R1>) -> bool { self.syntax == other.syntax } | ||
2275 | } | 1665 | } |
2276 | impl<R: TreeRoot<RaTypes>> Eq for NameRefNode<R> {} | 1666 | unsafe impl TransparentNewType for NameRef { |
2277 | impl<R: TreeRoot<RaTypes>> Hash for NameRefNode<R> { | 1667 | type Repr = rowan::SyntaxNode<RaTypes>; |
2278 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2279 | } | 1668 | } |
2280 | 1669 | ||
2281 | impl<'a> AstNode<'a> for NameRef<'a> { | 1670 | impl AstNode for NameRef { |
2282 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1671 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2283 | match syntax.kind() { | 1672 | match syntax.kind() { |
2284 | NAME_REF => Some(NameRef { syntax }), | 1673 | NAME_REF => Some(NameRef::from_repr(syntax.into_repr())), |
2285 | _ => None, | 1674 | _ => None, |
2286 | } | 1675 | } |
2287 | } | 1676 | } |
2288 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1677 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1678 | fn to_owned(&self) -> TreePtr<NameRef> { TreePtr::cast(self.syntax.to_owned()) } | ||
2289 | } | 1679 | } |
2290 | 1680 | ||
2291 | impl<R: TreeRoot<RaTypes>> NameRefNode<R> { | ||
2292 | pub fn borrowed(&self) -> NameRef { | ||
2293 | NameRefNode { syntax: self.syntax.borrowed() } | ||
2294 | } | ||
2295 | pub fn owned(&self) -> NameRefNode { | ||
2296 | NameRefNode { syntax: self.syntax.owned() } | ||
2297 | } | ||
2298 | } | ||
2299 | 1681 | ||
2300 | 1682 | impl NameRef {} | |
2301 | impl<'a> NameRef<'a> {} | ||
2302 | 1683 | ||
2303 | // NamedField | 1684 | // NamedField |
2304 | #[derive(Debug, Clone, Copy,)] | 1685 | #[derive(Debug, PartialEq, Eq, Hash)] |
2305 | pub struct NamedFieldNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1686 | #[repr(transparent)] |
2306 | pub(crate) syntax: SyntaxNode<R>, | 1687 | pub struct NamedField { |
1688 | pub(crate) syntax: SyntaxNode, | ||
2307 | } | 1689 | } |
2308 | pub type NamedField<'a> = NamedFieldNode<RefRoot<'a>>; | 1690 | unsafe impl TransparentNewType for NamedField { |
2309 | 1691 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2310 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldNode<R1>> for NamedFieldNode<R2> { | ||
2311 | fn eq(&self, other: &NamedFieldNode<R1>) -> bool { self.syntax == other.syntax } | ||
2312 | } | ||
2313 | impl<R: TreeRoot<RaTypes>> Eq for NamedFieldNode<R> {} | ||
2314 | impl<R: TreeRoot<RaTypes>> Hash for NamedFieldNode<R> { | ||
2315 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2316 | } | 1692 | } |
2317 | 1693 | ||
2318 | impl<'a> AstNode<'a> for NamedField<'a> { | 1694 | impl AstNode for NamedField { |
2319 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1695 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2320 | match syntax.kind() { | 1696 | match syntax.kind() { |
2321 | NAMED_FIELD => Some(NamedField { syntax }), | 1697 | NAMED_FIELD => Some(NamedField::from_repr(syntax.into_repr())), |
2322 | _ => None, | 1698 | _ => None, |
2323 | } | 1699 | } |
2324 | } | 1700 | } |
2325 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1701 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2326 | } | 1702 | fn to_owned(&self) -> TreePtr<NamedField> { TreePtr::cast(self.syntax.to_owned()) } |
2327 | |||
2328 | impl<R: TreeRoot<RaTypes>> NamedFieldNode<R> { | ||
2329 | pub fn borrowed(&self) -> NamedField { | ||
2330 | NamedFieldNode { syntax: self.syntax.borrowed() } | ||
2331 | } | ||
2332 | pub fn owned(&self) -> NamedFieldNode { | ||
2333 | NamedFieldNode { syntax: self.syntax.owned() } | ||
2334 | } | ||
2335 | } | 1703 | } |
2336 | 1704 | ||
2337 | 1705 | ||
2338 | impl<'a> NamedField<'a> { | 1706 | impl NamedField { |
2339 | pub fn name_ref(self) -> Option<NameRef<'a>> { | 1707 | pub fn name_ref(&self) -> Option<&NameRef> { |
2340 | super::child_opt(self) | 1708 | super::child_opt(self) |
2341 | } | 1709 | } |
2342 | 1710 | ||
2343 | pub fn expr(self) -> Option<Expr<'a>> { | 1711 | pub fn expr(&self) -> Option<&Expr> { |
2344 | super::child_opt(self) | 1712 | super::child_opt(self) |
2345 | } | 1713 | } |
2346 | } | 1714 | } |
2347 | 1715 | ||
2348 | // NamedFieldDef | 1716 | // NamedFieldDef |
2349 | #[derive(Debug, Clone, Copy,)] | 1717 | #[derive(Debug, PartialEq, Eq, Hash)] |
2350 | pub struct NamedFieldDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1718 | #[repr(transparent)] |
2351 | pub(crate) syntax: SyntaxNode<R>, | 1719 | pub struct NamedFieldDef { |
1720 | pub(crate) syntax: SyntaxNode, | ||
2352 | } | 1721 | } |
2353 | pub type NamedFieldDef<'a> = NamedFieldDefNode<RefRoot<'a>>; | 1722 | unsafe impl TransparentNewType for NamedFieldDef { |
2354 | 1723 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2355 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldDefNode<R1>> for NamedFieldDefNode<R2> { | ||
2356 | fn eq(&self, other: &NamedFieldDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
2357 | } | ||
2358 | impl<R: TreeRoot<RaTypes>> Eq for NamedFieldDefNode<R> {} | ||
2359 | impl<R: TreeRoot<RaTypes>> Hash for NamedFieldDefNode<R> { | ||
2360 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2361 | } | 1724 | } |
2362 | 1725 | ||
2363 | impl<'a> AstNode<'a> for NamedFieldDef<'a> { | 1726 | impl AstNode for NamedFieldDef { |
2364 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1727 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2365 | match syntax.kind() { | 1728 | match syntax.kind() { |
2366 | NAMED_FIELD_DEF => Some(NamedFieldDef { syntax }), | 1729 | NAMED_FIELD_DEF => Some(NamedFieldDef::from_repr(syntax.into_repr())), |
2367 | _ => None, | 1730 | _ => None, |
2368 | } | 1731 | } |
2369 | } | 1732 | } |
2370 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1733 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1734 | fn to_owned(&self) -> TreePtr<NamedFieldDef> { TreePtr::cast(self.syntax.to_owned()) } | ||
2371 | } | 1735 | } |
2372 | 1736 | ||
2373 | impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> { | ||
2374 | pub fn borrowed(&self) -> NamedFieldDef { | ||
2375 | NamedFieldDefNode { syntax: self.syntax.borrowed() } | ||
2376 | } | ||
2377 | pub fn owned(&self) -> NamedFieldDefNode { | ||
2378 | NamedFieldDefNode { syntax: self.syntax.owned() } | ||
2379 | } | ||
2380 | } | ||
2381 | 1737 | ||
2382 | 1738 | impl ast::VisibilityOwner for NamedFieldDef {} | |
2383 | impl<'a> ast::VisibilityOwner<'a> for NamedFieldDef<'a> {} | 1739 | impl ast::NameOwner for NamedFieldDef {} |
2384 | impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {} | 1740 | impl ast::AttrsOwner for NamedFieldDef {} |
2385 | impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {} | 1741 | impl NamedFieldDef { |
2386 | impl<'a> NamedFieldDef<'a> { | 1742 | pub fn type_ref(&self) -> Option<&TypeRef> { |
2387 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | ||
2388 | super::child_opt(self) | 1743 | super::child_opt(self) |
2389 | } | 1744 | } |
2390 | } | 1745 | } |
2391 | 1746 | ||
2392 | // NamedFieldDefList | 1747 | // NamedFieldDefList |
2393 | #[derive(Debug, Clone, Copy,)] | 1748 | #[derive(Debug, PartialEq, Eq, Hash)] |
2394 | pub struct NamedFieldDefListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1749 | #[repr(transparent)] |
2395 | pub(crate) syntax: SyntaxNode<R>, | 1750 | pub struct NamedFieldDefList { |
2396 | } | 1751 | pub(crate) syntax: SyntaxNode, |
2397 | pub type NamedFieldDefList<'a> = NamedFieldDefListNode<RefRoot<'a>>; | ||
2398 | |||
2399 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldDefListNode<R1>> for NamedFieldDefListNode<R2> { | ||
2400 | fn eq(&self, other: &NamedFieldDefListNode<R1>) -> bool { self.syntax == other.syntax } | ||
2401 | } | 1752 | } |
2402 | impl<R: TreeRoot<RaTypes>> Eq for NamedFieldDefListNode<R> {} | 1753 | unsafe impl TransparentNewType for NamedFieldDefList { |
2403 | impl<R: TreeRoot<RaTypes>> Hash for NamedFieldDefListNode<R> { | 1754 | type Repr = rowan::SyntaxNode<RaTypes>; |
2404 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2405 | } | 1755 | } |
2406 | 1756 | ||
2407 | impl<'a> AstNode<'a> for NamedFieldDefList<'a> { | 1757 | impl AstNode for NamedFieldDefList { |
2408 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1758 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2409 | match syntax.kind() { | 1759 | match syntax.kind() { |
2410 | NAMED_FIELD_DEF_LIST => Some(NamedFieldDefList { syntax }), | 1760 | NAMED_FIELD_DEF_LIST => Some(NamedFieldDefList::from_repr(syntax.into_repr())), |
2411 | _ => None, | 1761 | _ => None, |
2412 | } | 1762 | } |
2413 | } | 1763 | } |
2414 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1764 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1765 | fn to_owned(&self) -> TreePtr<NamedFieldDefList> { TreePtr::cast(self.syntax.to_owned()) } | ||
2415 | } | 1766 | } |
2416 | 1767 | ||
2417 | impl<R: TreeRoot<RaTypes>> NamedFieldDefListNode<R> { | ||
2418 | pub fn borrowed(&self) -> NamedFieldDefList { | ||
2419 | NamedFieldDefListNode { syntax: self.syntax.borrowed() } | ||
2420 | } | ||
2421 | pub fn owned(&self) -> NamedFieldDefListNode { | ||
2422 | NamedFieldDefListNode { syntax: self.syntax.owned() } | ||
2423 | } | ||
2424 | } | ||
2425 | 1768 | ||
2426 | 1769 | impl NamedFieldDefList { | |
2427 | impl<'a> NamedFieldDefList<'a> { | 1770 | pub fn fields(&self) -> impl Iterator<Item = &NamedFieldDef> { |
2428 | pub fn fields(self) -> impl Iterator<Item = NamedFieldDef<'a>> + 'a { | ||
2429 | super::children(self) | 1771 | super::children(self) |
2430 | } | 1772 | } |
2431 | } | 1773 | } |
2432 | 1774 | ||
2433 | // NamedFieldList | 1775 | // NamedFieldList |
2434 | #[derive(Debug, Clone, Copy,)] | 1776 | #[derive(Debug, PartialEq, Eq, Hash)] |
2435 | pub struct NamedFieldListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1777 | #[repr(transparent)] |
2436 | pub(crate) syntax: SyntaxNode<R>, | 1778 | pub struct NamedFieldList { |
2437 | } | 1779 | pub(crate) syntax: SyntaxNode, |
2438 | pub type NamedFieldList<'a> = NamedFieldListNode<RefRoot<'a>>; | ||
2439 | |||
2440 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NamedFieldListNode<R1>> for NamedFieldListNode<R2> { | ||
2441 | fn eq(&self, other: &NamedFieldListNode<R1>) -> bool { self.syntax == other.syntax } | ||
2442 | } | 1780 | } |
2443 | impl<R: TreeRoot<RaTypes>> Eq for NamedFieldListNode<R> {} | 1781 | unsafe impl TransparentNewType for NamedFieldList { |
2444 | impl<R: TreeRoot<RaTypes>> Hash for NamedFieldListNode<R> { | 1782 | type Repr = rowan::SyntaxNode<RaTypes>; |
2445 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2446 | } | 1783 | } |
2447 | 1784 | ||
2448 | impl<'a> AstNode<'a> for NamedFieldList<'a> { | 1785 | impl AstNode for NamedFieldList { |
2449 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1786 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2450 | match syntax.kind() { | 1787 | match syntax.kind() { |
2451 | NAMED_FIELD_LIST => Some(NamedFieldList { syntax }), | 1788 | NAMED_FIELD_LIST => Some(NamedFieldList::from_repr(syntax.into_repr())), |
2452 | _ => None, | 1789 | _ => None, |
2453 | } | 1790 | } |
2454 | } | 1791 | } |
2455 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1792 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2456 | } | 1793 | fn to_owned(&self) -> TreePtr<NamedFieldList> { TreePtr::cast(self.syntax.to_owned()) } |
2457 | |||
2458 | impl<R: TreeRoot<RaTypes>> NamedFieldListNode<R> { | ||
2459 | pub fn borrowed(&self) -> NamedFieldList { | ||
2460 | NamedFieldListNode { syntax: self.syntax.borrowed() } | ||
2461 | } | ||
2462 | pub fn owned(&self) -> NamedFieldListNode { | ||
2463 | NamedFieldListNode { syntax: self.syntax.owned() } | ||
2464 | } | ||
2465 | } | 1794 | } |
2466 | 1795 | ||
2467 | 1796 | ||
2468 | impl<'a> NamedFieldList<'a> { | 1797 | impl NamedFieldList { |
2469 | pub fn fields(self) -> impl Iterator<Item = NamedField<'a>> + 'a { | 1798 | pub fn fields(&self) -> impl Iterator<Item = &NamedField> { |
2470 | super::children(self) | 1799 | super::children(self) |
2471 | } | 1800 | } |
2472 | } | 1801 | } |
2473 | 1802 | ||
2474 | // NeverType | 1803 | // NeverType |
2475 | #[derive(Debug, Clone, Copy,)] | 1804 | #[derive(Debug, PartialEq, Eq, Hash)] |
2476 | pub struct NeverTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1805 | #[repr(transparent)] |
2477 | pub(crate) syntax: SyntaxNode<R>, | 1806 | pub struct NeverType { |
2478 | } | 1807 | pub(crate) syntax: SyntaxNode, |
2479 | pub type NeverType<'a> = NeverTypeNode<RefRoot<'a>>; | ||
2480 | |||
2481 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<NeverTypeNode<R1>> for NeverTypeNode<R2> { | ||
2482 | fn eq(&self, other: &NeverTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
2483 | } | 1808 | } |
2484 | impl<R: TreeRoot<RaTypes>> Eq for NeverTypeNode<R> {} | 1809 | unsafe impl TransparentNewType for NeverType { |
2485 | impl<R: TreeRoot<RaTypes>> Hash for NeverTypeNode<R> { | 1810 | type Repr = rowan::SyntaxNode<RaTypes>; |
2486 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2487 | } | 1811 | } |
2488 | 1812 | ||
2489 | impl<'a> AstNode<'a> for NeverType<'a> { | 1813 | impl AstNode for NeverType { |
2490 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1814 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2491 | match syntax.kind() { | 1815 | match syntax.kind() { |
2492 | NEVER_TYPE => Some(NeverType { syntax }), | 1816 | NEVER_TYPE => Some(NeverType::from_repr(syntax.into_repr())), |
2493 | _ => None, | 1817 | _ => None, |
2494 | } | 1818 | } |
2495 | } | 1819 | } |
2496 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1820 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2497 | } | 1821 | fn to_owned(&self) -> TreePtr<NeverType> { TreePtr::cast(self.syntax.to_owned()) } |
2498 | |||
2499 | impl<R: TreeRoot<RaTypes>> NeverTypeNode<R> { | ||
2500 | pub fn borrowed(&self) -> NeverType { | ||
2501 | NeverTypeNode { syntax: self.syntax.borrowed() } | ||
2502 | } | ||
2503 | pub fn owned(&self) -> NeverTypeNode { | ||
2504 | NeverTypeNode { syntax: self.syntax.owned() } | ||
2505 | } | ||
2506 | } | 1822 | } |
2507 | 1823 | ||
2508 | 1824 | ||
2509 | impl<'a> NeverType<'a> {} | 1825 | impl NeverType {} |
2510 | 1826 | ||
2511 | // NominalDef | 1827 | // NominalDef |
1828 | #[derive(Debug, PartialEq, Eq, Hash)] | ||
1829 | #[repr(transparent)] | ||
1830 | pub struct NominalDef { | ||
1831 | pub(crate) syntax: SyntaxNode, | ||
1832 | } | ||
1833 | unsafe impl TransparentNewType for NominalDef { | ||
1834 | type Repr = rowan::SyntaxNode<RaTypes>; | ||
1835 | } | ||
1836 | |||
2512 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 1837 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
2513 | pub enum NominalDef<'a> { | 1838 | pub enum NominalDefKind<'a> { |
2514 | StructDef(StructDef<'a>), | 1839 | StructDef(&'a StructDef), |
2515 | EnumDef(EnumDef<'a>), | 1840 | EnumDef(&'a EnumDef), |
2516 | } | 1841 | } |
2517 | 1842 | ||
2518 | impl<'a> AstNode<'a> for NominalDef<'a> { | 1843 | impl AstNode for NominalDef { |
2519 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1844 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2520 | match syntax.kind() { | 1845 | match syntax.kind() { |
2521 | STRUCT_DEF => Some(NominalDef::StructDef(StructDef { syntax })), | 1846 | | STRUCT_DEF |
2522 | ENUM_DEF => Some(NominalDef::EnumDef(EnumDef { syntax })), | 1847 | | ENUM_DEF => Some(NominalDef::from_repr(syntax.into_repr())), |
2523 | _ => None, | 1848 | _ => None, |
2524 | } | 1849 | } |
2525 | } | 1850 | } |
2526 | fn syntax(self) -> SyntaxNodeRef<'a> { | 1851 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2527 | match self { | 1852 | fn to_owned(&self) -> TreePtr<NominalDef> { TreePtr::cast(self.syntax.to_owned()) } |
2528 | NominalDef::StructDef(inner) => inner.syntax(), | 1853 | } |
2529 | NominalDef::EnumDef(inner) => inner.syntax(), | 1854 | |
1855 | impl NominalDef { | ||
1856 | pub fn kind(&self) -> NominalDefKind { | ||
1857 | match self.syntax.kind() { | ||
1858 | STRUCT_DEF => NominalDefKind::StructDef(StructDef::cast(&self.syntax).unwrap()), | ||
1859 | ENUM_DEF => NominalDefKind::EnumDef(EnumDef::cast(&self.syntax).unwrap()), | ||
1860 | _ => unreachable!(), | ||
2530 | } | 1861 | } |
2531 | } | 1862 | } |
2532 | } | 1863 | } |
2533 | 1864 | ||
2534 | impl<'a> ast::NameOwner<'a> for NominalDef<'a> {} | 1865 | impl ast::NameOwner for NominalDef {} |
2535 | impl<'a> ast::TypeParamsOwner<'a> for NominalDef<'a> {} | 1866 | impl ast::TypeParamsOwner for NominalDef {} |
2536 | impl<'a> ast::AttrsOwner<'a> for NominalDef<'a> {} | 1867 | impl ast::AttrsOwner for NominalDef {} |
2537 | impl<'a> NominalDef<'a> {} | 1868 | impl NominalDef {} |
2538 | 1869 | ||
2539 | // Param | 1870 | // Param |
2540 | #[derive(Debug, Clone, Copy,)] | 1871 | #[derive(Debug, PartialEq, Eq, Hash)] |
2541 | pub struct ParamNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1872 | #[repr(transparent)] |
2542 | pub(crate) syntax: SyntaxNode<R>, | 1873 | pub struct Param { |
2543 | } | 1874 | pub(crate) syntax: SyntaxNode, |
2544 | pub type Param<'a> = ParamNode<RefRoot<'a>>; | ||
2545 | |||
2546 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamNode<R1>> for ParamNode<R2> { | ||
2547 | fn eq(&self, other: &ParamNode<R1>) -> bool { self.syntax == other.syntax } | ||
2548 | } | 1875 | } |
2549 | impl<R: TreeRoot<RaTypes>> Eq for ParamNode<R> {} | 1876 | unsafe impl TransparentNewType for Param { |
2550 | impl<R: TreeRoot<RaTypes>> Hash for ParamNode<R> { | 1877 | type Repr = rowan::SyntaxNode<RaTypes>; |
2551 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2552 | } | 1878 | } |
2553 | 1879 | ||
2554 | impl<'a> AstNode<'a> for Param<'a> { | 1880 | impl AstNode for Param { |
2555 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1881 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2556 | match syntax.kind() { | 1882 | match syntax.kind() { |
2557 | PARAM => Some(Param { syntax }), | 1883 | PARAM => Some(Param::from_repr(syntax.into_repr())), |
2558 | _ => None, | 1884 | _ => None, |
2559 | } | 1885 | } |
2560 | } | 1886 | } |
2561 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1887 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2562 | } | 1888 | fn to_owned(&self) -> TreePtr<Param> { TreePtr::cast(self.syntax.to_owned()) } |
2563 | |||
2564 | impl<R: TreeRoot<RaTypes>> ParamNode<R> { | ||
2565 | pub fn borrowed(&self) -> Param { | ||
2566 | ParamNode { syntax: self.syntax.borrowed() } | ||
2567 | } | ||
2568 | pub fn owned(&self) -> ParamNode { | ||
2569 | ParamNode { syntax: self.syntax.owned() } | ||
2570 | } | ||
2571 | } | 1889 | } |
2572 | 1890 | ||
2573 | 1891 | ||
2574 | impl<'a> Param<'a> { | 1892 | impl Param { |
2575 | pub fn pat(self) -> Option<Pat<'a>> { | 1893 | pub fn pat(&self) -> Option<&Pat> { |
2576 | super::child_opt(self) | 1894 | super::child_opt(self) |
2577 | } | 1895 | } |
2578 | 1896 | ||
2579 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 1897 | pub fn type_ref(&self) -> Option<&TypeRef> { |
2580 | super::child_opt(self) | 1898 | super::child_opt(self) |
2581 | } | 1899 | } |
2582 | } | 1900 | } |
2583 | 1901 | ||
2584 | // ParamList | 1902 | // ParamList |
2585 | #[derive(Debug, Clone, Copy,)] | 1903 | #[derive(Debug, PartialEq, Eq, Hash)] |
2586 | pub struct ParamListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1904 | #[repr(transparent)] |
2587 | pub(crate) syntax: SyntaxNode<R>, | 1905 | pub struct ParamList { |
1906 | pub(crate) syntax: SyntaxNode, | ||
2588 | } | 1907 | } |
2589 | pub type ParamList<'a> = ParamListNode<RefRoot<'a>>; | 1908 | unsafe impl TransparentNewType for ParamList { |
2590 | 1909 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2591 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParamListNode<R1>> for ParamListNode<R2> { | ||
2592 | fn eq(&self, other: &ParamListNode<R1>) -> bool { self.syntax == other.syntax } | ||
2593 | } | ||
2594 | impl<R: TreeRoot<RaTypes>> Eq for ParamListNode<R> {} | ||
2595 | impl<R: TreeRoot<RaTypes>> Hash for ParamListNode<R> { | ||
2596 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2597 | } | 1910 | } |
2598 | 1911 | ||
2599 | impl<'a> AstNode<'a> for ParamList<'a> { | 1912 | impl AstNode for ParamList { |
2600 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1913 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2601 | match syntax.kind() { | 1914 | match syntax.kind() { |
2602 | PARAM_LIST => Some(ParamList { syntax }), | 1915 | PARAM_LIST => Some(ParamList::from_repr(syntax.into_repr())), |
2603 | _ => None, | 1916 | _ => None, |
2604 | } | 1917 | } |
2605 | } | 1918 | } |
2606 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1919 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2607 | } | 1920 | fn to_owned(&self) -> TreePtr<ParamList> { TreePtr::cast(self.syntax.to_owned()) } |
2608 | |||
2609 | impl<R: TreeRoot<RaTypes>> ParamListNode<R> { | ||
2610 | pub fn borrowed(&self) -> ParamList { | ||
2611 | ParamListNode { syntax: self.syntax.borrowed() } | ||
2612 | } | ||
2613 | pub fn owned(&self) -> ParamListNode { | ||
2614 | ParamListNode { syntax: self.syntax.owned() } | ||
2615 | } | ||
2616 | } | 1921 | } |
2617 | 1922 | ||
2618 | 1923 | ||
2619 | impl<'a> ParamList<'a> { | 1924 | impl ParamList { |
2620 | pub fn params(self) -> impl Iterator<Item = Param<'a>> + 'a { | 1925 | pub fn params(&self) -> impl Iterator<Item = &Param> { |
2621 | super::children(self) | 1926 | super::children(self) |
2622 | } | 1927 | } |
2623 | 1928 | ||
2624 | pub fn self_param(self) -> Option<SelfParam<'a>> { | 1929 | pub fn self_param(&self) -> Option<&SelfParam> { |
2625 | super::child_opt(self) | 1930 | super::child_opt(self) |
2626 | } | 1931 | } |
2627 | } | 1932 | } |
2628 | 1933 | ||
2629 | // ParenExpr | 1934 | // ParenExpr |
2630 | #[derive(Debug, Clone, Copy,)] | 1935 | #[derive(Debug, PartialEq, Eq, Hash)] |
2631 | pub struct ParenExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1936 | #[repr(transparent)] |
2632 | pub(crate) syntax: SyntaxNode<R>, | 1937 | pub struct ParenExpr { |
2633 | } | 1938 | pub(crate) syntax: SyntaxNode, |
2634 | pub type ParenExpr<'a> = ParenExprNode<RefRoot<'a>>; | ||
2635 | |||
2636 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParenExprNode<R1>> for ParenExprNode<R2> { | ||
2637 | fn eq(&self, other: &ParenExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
2638 | } | 1939 | } |
2639 | impl<R: TreeRoot<RaTypes>> Eq for ParenExprNode<R> {} | 1940 | unsafe impl TransparentNewType for ParenExpr { |
2640 | impl<R: TreeRoot<RaTypes>> Hash for ParenExprNode<R> { | 1941 | type Repr = rowan::SyntaxNode<RaTypes>; |
2641 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2642 | } | 1942 | } |
2643 | 1943 | ||
2644 | impl<'a> AstNode<'a> for ParenExpr<'a> { | 1944 | impl AstNode for ParenExpr { |
2645 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1945 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2646 | match syntax.kind() { | 1946 | match syntax.kind() { |
2647 | PAREN_EXPR => Some(ParenExpr { syntax }), | 1947 | PAREN_EXPR => Some(ParenExpr::from_repr(syntax.into_repr())), |
2648 | _ => None, | 1948 | _ => None, |
2649 | } | 1949 | } |
2650 | } | 1950 | } |
2651 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1951 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
1952 | fn to_owned(&self) -> TreePtr<ParenExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
2652 | } | 1953 | } |
2653 | 1954 | ||
2654 | impl<R: TreeRoot<RaTypes>> ParenExprNode<R> { | ||
2655 | pub fn borrowed(&self) -> ParenExpr { | ||
2656 | ParenExprNode { syntax: self.syntax.borrowed() } | ||
2657 | } | ||
2658 | pub fn owned(&self) -> ParenExprNode { | ||
2659 | ParenExprNode { syntax: self.syntax.owned() } | ||
2660 | } | ||
2661 | } | ||
2662 | 1955 | ||
2663 | 1956 | impl ParenExpr { | |
2664 | impl<'a> ParenExpr<'a> { | 1957 | pub fn expr(&self) -> Option<&Expr> { |
2665 | pub fn expr(self) -> Option<Expr<'a>> { | ||
2666 | super::child_opt(self) | 1958 | super::child_opt(self) |
2667 | } | 1959 | } |
2668 | } | 1960 | } |
2669 | 1961 | ||
2670 | // ParenType | 1962 | // ParenType |
2671 | #[derive(Debug, Clone, Copy,)] | 1963 | #[derive(Debug, PartialEq, Eq, Hash)] |
2672 | pub struct ParenTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 1964 | #[repr(transparent)] |
2673 | pub(crate) syntax: SyntaxNode<R>, | 1965 | pub struct ParenType { |
1966 | pub(crate) syntax: SyntaxNode, | ||
2674 | } | 1967 | } |
2675 | pub type ParenType<'a> = ParenTypeNode<RefRoot<'a>>; | 1968 | unsafe impl TransparentNewType for ParenType { |
2676 | 1969 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2677 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ParenTypeNode<R1>> for ParenTypeNode<R2> { | ||
2678 | fn eq(&self, other: &ParenTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
2679 | } | ||
2680 | impl<R: TreeRoot<RaTypes>> Eq for ParenTypeNode<R> {} | ||
2681 | impl<R: TreeRoot<RaTypes>> Hash for ParenTypeNode<R> { | ||
2682 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2683 | } | 1970 | } |
2684 | 1971 | ||
2685 | impl<'a> AstNode<'a> for ParenType<'a> { | 1972 | impl AstNode for ParenType { |
2686 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 1973 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2687 | match syntax.kind() { | 1974 | match syntax.kind() { |
2688 | PAREN_TYPE => Some(ParenType { syntax }), | 1975 | PAREN_TYPE => Some(ParenType::from_repr(syntax.into_repr())), |
2689 | _ => None, | 1976 | _ => None, |
2690 | } | 1977 | } |
2691 | } | 1978 | } |
2692 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 1979 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2693 | } | 1980 | fn to_owned(&self) -> TreePtr<ParenType> { TreePtr::cast(self.syntax.to_owned()) } |
2694 | |||
2695 | impl<R: TreeRoot<RaTypes>> ParenTypeNode<R> { | ||
2696 | pub fn borrowed(&self) -> ParenType { | ||
2697 | ParenTypeNode { syntax: self.syntax.borrowed() } | ||
2698 | } | ||
2699 | pub fn owned(&self) -> ParenTypeNode { | ||
2700 | ParenTypeNode { syntax: self.syntax.owned() } | ||
2701 | } | ||
2702 | } | 1981 | } |
2703 | 1982 | ||
2704 | 1983 | ||
2705 | impl<'a> ParenType<'a> { | 1984 | impl ParenType { |
2706 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 1985 | pub fn type_ref(&self) -> Option<&TypeRef> { |
2707 | super::child_opt(self) | 1986 | super::child_opt(self) |
2708 | } | 1987 | } |
2709 | } | 1988 | } |
2710 | 1989 | ||
2711 | // Pat | 1990 | // Pat |
1991 | #[derive(Debug, PartialEq, Eq, Hash)] | ||
1992 | #[repr(transparent)] | ||
1993 | pub struct Pat { | ||
1994 | pub(crate) syntax: SyntaxNode, | ||
1995 | } | ||
1996 | unsafe impl TransparentNewType for Pat { | ||
1997 | type Repr = rowan::SyntaxNode<RaTypes>; | ||
1998 | } | ||
1999 | |||
2712 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 2000 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
2713 | pub enum Pat<'a> { | 2001 | pub enum PatKind<'a> { |
2714 | RefPat(RefPat<'a>), | 2002 | RefPat(&'a RefPat), |
2715 | BindPat(BindPat<'a>), | 2003 | BindPat(&'a BindPat), |
2716 | PlaceholderPat(PlaceholderPat<'a>), | 2004 | PlaceholderPat(&'a PlaceholderPat), |
2717 | PathPat(PathPat<'a>), | 2005 | PathPat(&'a PathPat), |
2718 | StructPat(StructPat<'a>), | 2006 | StructPat(&'a StructPat), |
2719 | FieldPatList(FieldPatList<'a>), | 2007 | FieldPatList(&'a FieldPatList), |
2720 | TupleStructPat(TupleStructPat<'a>), | 2008 | TupleStructPat(&'a TupleStructPat), |
2721 | TuplePat(TuplePat<'a>), | 2009 | TuplePat(&'a TuplePat), |
2722 | SlicePat(SlicePat<'a>), | 2010 | SlicePat(&'a SlicePat), |
2723 | RangePat(RangePat<'a>), | 2011 | RangePat(&'a RangePat), |
2724 | } | 2012 | } |
2725 | 2013 | ||
2726 | impl<'a> AstNode<'a> for Pat<'a> { | 2014 | impl AstNode for Pat { |
2727 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2015 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2728 | match syntax.kind() { | 2016 | match syntax.kind() { |
2729 | REF_PAT => Some(Pat::RefPat(RefPat { syntax })), | 2017 | | REF_PAT |
2730 | BIND_PAT => Some(Pat::BindPat(BindPat { syntax })), | 2018 | | BIND_PAT |
2731 | PLACEHOLDER_PAT => Some(Pat::PlaceholderPat(PlaceholderPat { syntax })), | 2019 | | PLACEHOLDER_PAT |
2732 | PATH_PAT => Some(Pat::PathPat(PathPat { syntax })), | 2020 | | PATH_PAT |
2733 | STRUCT_PAT => Some(Pat::StructPat(StructPat { syntax })), | 2021 | | STRUCT_PAT |
2734 | FIELD_PAT_LIST => Some(Pat::FieldPatList(FieldPatList { syntax })), | 2022 | | FIELD_PAT_LIST |
2735 | TUPLE_STRUCT_PAT => Some(Pat::TupleStructPat(TupleStructPat { syntax })), | 2023 | | TUPLE_STRUCT_PAT |
2736 | TUPLE_PAT => Some(Pat::TuplePat(TuplePat { syntax })), | 2024 | | TUPLE_PAT |
2737 | SLICE_PAT => Some(Pat::SlicePat(SlicePat { syntax })), | 2025 | | SLICE_PAT |
2738 | RANGE_PAT => Some(Pat::RangePat(RangePat { syntax })), | 2026 | | RANGE_PAT => Some(Pat::from_repr(syntax.into_repr())), |
2739 | _ => None, | 2027 | _ => None, |
2740 | } | 2028 | } |
2741 | } | 2029 | } |
2742 | fn syntax(self) -> SyntaxNodeRef<'a> { | 2030 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2743 | match self { | 2031 | fn to_owned(&self) -> TreePtr<Pat> { TreePtr::cast(self.syntax.to_owned()) } |
2744 | Pat::RefPat(inner) => inner.syntax(), | 2032 | } |
2745 | Pat::BindPat(inner) => inner.syntax(), | 2033 | |
2746 | Pat::PlaceholderPat(inner) => inner.syntax(), | 2034 | impl Pat { |
2747 | Pat::PathPat(inner) => inner.syntax(), | 2035 | pub fn kind(&self) -> PatKind { |
2748 | Pat::StructPat(inner) => inner.syntax(), | 2036 | match self.syntax.kind() { |
2749 | Pat::FieldPatList(inner) => inner.syntax(), | 2037 | REF_PAT => PatKind::RefPat(RefPat::cast(&self.syntax).unwrap()), |
2750 | Pat::TupleStructPat(inner) => inner.syntax(), | 2038 | BIND_PAT => PatKind::BindPat(BindPat::cast(&self.syntax).unwrap()), |
2751 | Pat::TuplePat(inner) => inner.syntax(), | 2039 | PLACEHOLDER_PAT => PatKind::PlaceholderPat(PlaceholderPat::cast(&self.syntax).unwrap()), |
2752 | Pat::SlicePat(inner) => inner.syntax(), | 2040 | PATH_PAT => PatKind::PathPat(PathPat::cast(&self.syntax).unwrap()), |
2753 | Pat::RangePat(inner) => inner.syntax(), | 2041 | STRUCT_PAT => PatKind::StructPat(StructPat::cast(&self.syntax).unwrap()), |
2042 | FIELD_PAT_LIST => PatKind::FieldPatList(FieldPatList::cast(&self.syntax).unwrap()), | ||
2043 | TUPLE_STRUCT_PAT => PatKind::TupleStructPat(TupleStructPat::cast(&self.syntax).unwrap()), | ||
2044 | TUPLE_PAT => PatKind::TuplePat(TuplePat::cast(&self.syntax).unwrap()), | ||
2045 | SLICE_PAT => PatKind::SlicePat(SlicePat::cast(&self.syntax).unwrap()), | ||
2046 | RANGE_PAT => PatKind::RangePat(RangePat::cast(&self.syntax).unwrap()), | ||
2047 | _ => unreachable!(), | ||
2754 | } | 2048 | } |
2755 | } | 2049 | } |
2756 | } | 2050 | } |
2757 | 2051 | ||
2758 | impl<'a> Pat<'a> {} | 2052 | impl Pat {} |
2759 | 2053 | ||
2760 | // Path | 2054 | // Path |
2761 | #[derive(Debug, Clone, Copy,)] | 2055 | #[derive(Debug, PartialEq, Eq, Hash)] |
2762 | pub struct PathNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2056 | #[repr(transparent)] |
2763 | pub(crate) syntax: SyntaxNode<R>, | 2057 | pub struct Path { |
2764 | } | 2058 | pub(crate) syntax: SyntaxNode, |
2765 | pub type Path<'a> = PathNode<RefRoot<'a>>; | ||
2766 | |||
2767 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathNode<R1>> for PathNode<R2> { | ||
2768 | fn eq(&self, other: &PathNode<R1>) -> bool { self.syntax == other.syntax } | ||
2769 | } | 2059 | } |
2770 | impl<R: TreeRoot<RaTypes>> Eq for PathNode<R> {} | 2060 | unsafe impl TransparentNewType for Path { |
2771 | impl<R: TreeRoot<RaTypes>> Hash for PathNode<R> { | 2061 | type Repr = rowan::SyntaxNode<RaTypes>; |
2772 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2773 | } | 2062 | } |
2774 | 2063 | ||
2775 | impl<'a> AstNode<'a> for Path<'a> { | 2064 | impl AstNode for Path { |
2776 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2065 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2777 | match syntax.kind() { | 2066 | match syntax.kind() { |
2778 | PATH => Some(Path { syntax }), | 2067 | PATH => Some(Path::from_repr(syntax.into_repr())), |
2779 | _ => None, | 2068 | _ => None, |
2780 | } | 2069 | } |
2781 | } | 2070 | } |
2782 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2071 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2783 | } | 2072 | fn to_owned(&self) -> TreePtr<Path> { TreePtr::cast(self.syntax.to_owned()) } |
2784 | |||
2785 | impl<R: TreeRoot<RaTypes>> PathNode<R> { | ||
2786 | pub fn borrowed(&self) -> Path { | ||
2787 | PathNode { syntax: self.syntax.borrowed() } | ||
2788 | } | ||
2789 | pub fn owned(&self) -> PathNode { | ||
2790 | PathNode { syntax: self.syntax.owned() } | ||
2791 | } | ||
2792 | } | 2073 | } |
2793 | 2074 | ||
2794 | 2075 | ||
2795 | impl<'a> Path<'a> { | 2076 | impl Path { |
2796 | pub fn segment(self) -> Option<PathSegment<'a>> { | 2077 | pub fn segment(&self) -> Option<&PathSegment> { |
2797 | super::child_opt(self) | 2078 | super::child_opt(self) |
2798 | } | 2079 | } |
2799 | 2080 | ||
2800 | pub fn qualifier(self) -> Option<Path<'a>> { | 2081 | pub fn qualifier(&self) -> Option<&Path> { |
2801 | super::child_opt(self) | 2082 | super::child_opt(self) |
2802 | } | 2083 | } |
2803 | } | 2084 | } |
2804 | 2085 | ||
2805 | // PathExpr | 2086 | // PathExpr |
2806 | #[derive(Debug, Clone, Copy,)] | 2087 | #[derive(Debug, PartialEq, Eq, Hash)] |
2807 | pub struct PathExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2088 | #[repr(transparent)] |
2808 | pub(crate) syntax: SyntaxNode<R>, | 2089 | pub struct PathExpr { |
2090 | pub(crate) syntax: SyntaxNode, | ||
2809 | } | 2091 | } |
2810 | pub type PathExpr<'a> = PathExprNode<RefRoot<'a>>; | 2092 | unsafe impl TransparentNewType for PathExpr { |
2811 | 2093 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2812 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathExprNode<R1>> for PathExprNode<R2> { | ||
2813 | fn eq(&self, other: &PathExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
2814 | } | ||
2815 | impl<R: TreeRoot<RaTypes>> Eq for PathExprNode<R> {} | ||
2816 | impl<R: TreeRoot<RaTypes>> Hash for PathExprNode<R> { | ||
2817 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2818 | } | 2094 | } |
2819 | 2095 | ||
2820 | impl<'a> AstNode<'a> for PathExpr<'a> { | 2096 | impl AstNode for PathExpr { |
2821 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2097 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2822 | match syntax.kind() { | 2098 | match syntax.kind() { |
2823 | PATH_EXPR => Some(PathExpr { syntax }), | 2099 | PATH_EXPR => Some(PathExpr::from_repr(syntax.into_repr())), |
2824 | _ => None, | 2100 | _ => None, |
2825 | } | 2101 | } |
2826 | } | 2102 | } |
2827 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2103 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2828 | } | 2104 | fn to_owned(&self) -> TreePtr<PathExpr> { TreePtr::cast(self.syntax.to_owned()) } |
2829 | |||
2830 | impl<R: TreeRoot<RaTypes>> PathExprNode<R> { | ||
2831 | pub fn borrowed(&self) -> PathExpr { | ||
2832 | PathExprNode { syntax: self.syntax.borrowed() } | ||
2833 | } | ||
2834 | pub fn owned(&self) -> PathExprNode { | ||
2835 | PathExprNode { syntax: self.syntax.owned() } | ||
2836 | } | ||
2837 | } | 2105 | } |
2838 | 2106 | ||
2839 | 2107 | ||
2840 | impl<'a> PathExpr<'a> { | 2108 | impl PathExpr { |
2841 | pub fn path(self) -> Option<Path<'a>> { | 2109 | pub fn path(&self) -> Option<&Path> { |
2842 | super::child_opt(self) | 2110 | super::child_opt(self) |
2843 | } | 2111 | } |
2844 | } | 2112 | } |
2845 | 2113 | ||
2846 | // PathPat | 2114 | // PathPat |
2847 | #[derive(Debug, Clone, Copy,)] | 2115 | #[derive(Debug, PartialEq, Eq, Hash)] |
2848 | pub struct PathPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2116 | #[repr(transparent)] |
2849 | pub(crate) syntax: SyntaxNode<R>, | 2117 | pub struct PathPat { |
2118 | pub(crate) syntax: SyntaxNode, | ||
2850 | } | 2119 | } |
2851 | pub type PathPat<'a> = PathPatNode<RefRoot<'a>>; | 2120 | unsafe impl TransparentNewType for PathPat { |
2852 | 2121 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2853 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathPatNode<R1>> for PathPatNode<R2> { | ||
2854 | fn eq(&self, other: &PathPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
2855 | } | ||
2856 | impl<R: TreeRoot<RaTypes>> Eq for PathPatNode<R> {} | ||
2857 | impl<R: TreeRoot<RaTypes>> Hash for PathPatNode<R> { | ||
2858 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2859 | } | 2122 | } |
2860 | 2123 | ||
2861 | impl<'a> AstNode<'a> for PathPat<'a> { | 2124 | impl AstNode for PathPat { |
2862 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2125 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2863 | match syntax.kind() { | 2126 | match syntax.kind() { |
2864 | PATH_PAT => Some(PathPat { syntax }), | 2127 | PATH_PAT => Some(PathPat::from_repr(syntax.into_repr())), |
2865 | _ => None, | 2128 | _ => None, |
2866 | } | 2129 | } |
2867 | } | 2130 | } |
2868 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2131 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2869 | } | 2132 | fn to_owned(&self) -> TreePtr<PathPat> { TreePtr::cast(self.syntax.to_owned()) } |
2870 | |||
2871 | impl<R: TreeRoot<RaTypes>> PathPatNode<R> { | ||
2872 | pub fn borrowed(&self) -> PathPat { | ||
2873 | PathPatNode { syntax: self.syntax.borrowed() } | ||
2874 | } | ||
2875 | pub fn owned(&self) -> PathPatNode { | ||
2876 | PathPatNode { syntax: self.syntax.owned() } | ||
2877 | } | ||
2878 | } | 2133 | } |
2879 | 2134 | ||
2880 | 2135 | ||
2881 | impl<'a> PathPat<'a> {} | 2136 | impl PathPat {} |
2882 | 2137 | ||
2883 | // PathSegment | 2138 | // PathSegment |
2884 | #[derive(Debug, Clone, Copy,)] | 2139 | #[derive(Debug, PartialEq, Eq, Hash)] |
2885 | pub struct PathSegmentNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2140 | #[repr(transparent)] |
2886 | pub(crate) syntax: SyntaxNode<R>, | 2141 | pub struct PathSegment { |
2887 | } | 2142 | pub(crate) syntax: SyntaxNode, |
2888 | pub type PathSegment<'a> = PathSegmentNode<RefRoot<'a>>; | ||
2889 | |||
2890 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathSegmentNode<R1>> for PathSegmentNode<R2> { | ||
2891 | fn eq(&self, other: &PathSegmentNode<R1>) -> bool { self.syntax == other.syntax } | ||
2892 | } | 2143 | } |
2893 | impl<R: TreeRoot<RaTypes>> Eq for PathSegmentNode<R> {} | 2144 | unsafe impl TransparentNewType for PathSegment { |
2894 | impl<R: TreeRoot<RaTypes>> Hash for PathSegmentNode<R> { | 2145 | type Repr = rowan::SyntaxNode<RaTypes>; |
2895 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2896 | } | 2146 | } |
2897 | 2147 | ||
2898 | impl<'a> AstNode<'a> for PathSegment<'a> { | 2148 | impl AstNode for PathSegment { |
2899 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2149 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2900 | match syntax.kind() { | 2150 | match syntax.kind() { |
2901 | PATH_SEGMENT => Some(PathSegment { syntax }), | 2151 | PATH_SEGMENT => Some(PathSegment::from_repr(syntax.into_repr())), |
2902 | _ => None, | 2152 | _ => None, |
2903 | } | 2153 | } |
2904 | } | 2154 | } |
2905 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2155 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2156 | fn to_owned(&self) -> TreePtr<PathSegment> { TreePtr::cast(self.syntax.to_owned()) } | ||
2906 | } | 2157 | } |
2907 | 2158 | ||
2908 | impl<R: TreeRoot<RaTypes>> PathSegmentNode<R> { | ||
2909 | pub fn borrowed(&self) -> PathSegment { | ||
2910 | PathSegmentNode { syntax: self.syntax.borrowed() } | ||
2911 | } | ||
2912 | pub fn owned(&self) -> PathSegmentNode { | ||
2913 | PathSegmentNode { syntax: self.syntax.owned() } | ||
2914 | } | ||
2915 | } | ||
2916 | 2159 | ||
2917 | 2160 | impl PathSegment { | |
2918 | impl<'a> PathSegment<'a> { | 2161 | pub fn name_ref(&self) -> Option<&NameRef> { |
2919 | pub fn name_ref(self) -> Option<NameRef<'a>> { | ||
2920 | super::child_opt(self) | 2162 | super::child_opt(self) |
2921 | } | 2163 | } |
2922 | } | 2164 | } |
2923 | 2165 | ||
2924 | // PathType | 2166 | // PathType |
2925 | #[derive(Debug, Clone, Copy,)] | 2167 | #[derive(Debug, PartialEq, Eq, Hash)] |
2926 | pub struct PathTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2168 | #[repr(transparent)] |
2927 | pub(crate) syntax: SyntaxNode<R>, | 2169 | pub struct PathType { |
2928 | } | 2170 | pub(crate) syntax: SyntaxNode, |
2929 | pub type PathType<'a> = PathTypeNode<RefRoot<'a>>; | ||
2930 | |||
2931 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PathTypeNode<R1>> for PathTypeNode<R2> { | ||
2932 | fn eq(&self, other: &PathTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
2933 | } | 2171 | } |
2934 | impl<R: TreeRoot<RaTypes>> Eq for PathTypeNode<R> {} | 2172 | unsafe impl TransparentNewType for PathType { |
2935 | impl<R: TreeRoot<RaTypes>> Hash for PathTypeNode<R> { | 2173 | type Repr = rowan::SyntaxNode<RaTypes>; |
2936 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2937 | } | 2174 | } |
2938 | 2175 | ||
2939 | impl<'a> AstNode<'a> for PathType<'a> { | 2176 | impl AstNode for PathType { |
2940 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2177 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2941 | match syntax.kind() { | 2178 | match syntax.kind() { |
2942 | PATH_TYPE => Some(PathType { syntax }), | 2179 | PATH_TYPE => Some(PathType::from_repr(syntax.into_repr())), |
2943 | _ => None, | 2180 | _ => None, |
2944 | } | 2181 | } |
2945 | } | 2182 | } |
2946 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2183 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2947 | } | 2184 | fn to_owned(&self) -> TreePtr<PathType> { TreePtr::cast(self.syntax.to_owned()) } |
2948 | |||
2949 | impl<R: TreeRoot<RaTypes>> PathTypeNode<R> { | ||
2950 | pub fn borrowed(&self) -> PathType { | ||
2951 | PathTypeNode { syntax: self.syntax.borrowed() } | ||
2952 | } | ||
2953 | pub fn owned(&self) -> PathTypeNode { | ||
2954 | PathTypeNode { syntax: self.syntax.owned() } | ||
2955 | } | ||
2956 | } | 2185 | } |
2957 | 2186 | ||
2958 | 2187 | ||
2959 | impl<'a> PathType<'a> { | 2188 | impl PathType { |
2960 | pub fn path(self) -> Option<Path<'a>> { | 2189 | pub fn path(&self) -> Option<&Path> { |
2961 | super::child_opt(self) | 2190 | super::child_opt(self) |
2962 | } | 2191 | } |
2963 | } | 2192 | } |
2964 | 2193 | ||
2965 | // PlaceholderPat | 2194 | // PlaceholderPat |
2966 | #[derive(Debug, Clone, Copy,)] | 2195 | #[derive(Debug, PartialEq, Eq, Hash)] |
2967 | pub struct PlaceholderPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2196 | #[repr(transparent)] |
2968 | pub(crate) syntax: SyntaxNode<R>, | 2197 | pub struct PlaceholderPat { |
2198 | pub(crate) syntax: SyntaxNode, | ||
2969 | } | 2199 | } |
2970 | pub type PlaceholderPat<'a> = PlaceholderPatNode<RefRoot<'a>>; | 2200 | unsafe impl TransparentNewType for PlaceholderPat { |
2971 | 2201 | type Repr = rowan::SyntaxNode<RaTypes>; | |
2972 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PlaceholderPatNode<R1>> for PlaceholderPatNode<R2> { | ||
2973 | fn eq(&self, other: &PlaceholderPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
2974 | } | ||
2975 | impl<R: TreeRoot<RaTypes>> Eq for PlaceholderPatNode<R> {} | ||
2976 | impl<R: TreeRoot<RaTypes>> Hash for PlaceholderPatNode<R> { | ||
2977 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
2978 | } | 2202 | } |
2979 | 2203 | ||
2980 | impl<'a> AstNode<'a> for PlaceholderPat<'a> { | 2204 | impl AstNode for PlaceholderPat { |
2981 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2205 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
2982 | match syntax.kind() { | 2206 | match syntax.kind() { |
2983 | PLACEHOLDER_PAT => Some(PlaceholderPat { syntax }), | 2207 | PLACEHOLDER_PAT => Some(PlaceholderPat::from_repr(syntax.into_repr())), |
2984 | _ => None, | 2208 | _ => None, |
2985 | } | 2209 | } |
2986 | } | 2210 | } |
2987 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2211 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2988 | } | 2212 | fn to_owned(&self) -> TreePtr<PlaceholderPat> { TreePtr::cast(self.syntax.to_owned()) } |
2989 | |||
2990 | impl<R: TreeRoot<RaTypes>> PlaceholderPatNode<R> { | ||
2991 | pub fn borrowed(&self) -> PlaceholderPat { | ||
2992 | PlaceholderPatNode { syntax: self.syntax.borrowed() } | ||
2993 | } | ||
2994 | pub fn owned(&self) -> PlaceholderPatNode { | ||
2995 | PlaceholderPatNode { syntax: self.syntax.owned() } | ||
2996 | } | ||
2997 | } | 2213 | } |
2998 | 2214 | ||
2999 | 2215 | ||
3000 | impl<'a> PlaceholderPat<'a> {} | 2216 | impl PlaceholderPat {} |
3001 | 2217 | ||
3002 | // PlaceholderType | 2218 | // PlaceholderType |
3003 | #[derive(Debug, Clone, Copy,)] | 2219 | #[derive(Debug, PartialEq, Eq, Hash)] |
3004 | pub struct PlaceholderTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2220 | #[repr(transparent)] |
3005 | pub(crate) syntax: SyntaxNode<R>, | 2221 | pub struct PlaceholderType { |
2222 | pub(crate) syntax: SyntaxNode, | ||
3006 | } | 2223 | } |
3007 | pub type PlaceholderType<'a> = PlaceholderTypeNode<RefRoot<'a>>; | 2224 | unsafe impl TransparentNewType for PlaceholderType { |
3008 | 2225 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3009 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PlaceholderTypeNode<R1>> for PlaceholderTypeNode<R2> { | ||
3010 | fn eq(&self, other: &PlaceholderTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3011 | } | ||
3012 | impl<R: TreeRoot<RaTypes>> Eq for PlaceholderTypeNode<R> {} | ||
3013 | impl<R: TreeRoot<RaTypes>> Hash for PlaceholderTypeNode<R> { | ||
3014 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3015 | } | 2226 | } |
3016 | 2227 | ||
3017 | impl<'a> AstNode<'a> for PlaceholderType<'a> { | 2228 | impl AstNode for PlaceholderType { |
3018 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2229 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3019 | match syntax.kind() { | 2230 | match syntax.kind() { |
3020 | PLACEHOLDER_TYPE => Some(PlaceholderType { syntax }), | 2231 | PLACEHOLDER_TYPE => Some(PlaceholderType::from_repr(syntax.into_repr())), |
3021 | _ => None, | 2232 | _ => None, |
3022 | } | 2233 | } |
3023 | } | 2234 | } |
3024 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2235 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3025 | } | 2236 | fn to_owned(&self) -> TreePtr<PlaceholderType> { TreePtr::cast(self.syntax.to_owned()) } |
3026 | |||
3027 | impl<R: TreeRoot<RaTypes>> PlaceholderTypeNode<R> { | ||
3028 | pub fn borrowed(&self) -> PlaceholderType { | ||
3029 | PlaceholderTypeNode { syntax: self.syntax.borrowed() } | ||
3030 | } | ||
3031 | pub fn owned(&self) -> PlaceholderTypeNode { | ||
3032 | PlaceholderTypeNode { syntax: self.syntax.owned() } | ||
3033 | } | ||
3034 | } | 2237 | } |
3035 | 2238 | ||
3036 | 2239 | ||
3037 | impl<'a> PlaceholderType<'a> {} | 2240 | impl PlaceholderType {} |
3038 | 2241 | ||
3039 | // PointerType | 2242 | // PointerType |
3040 | #[derive(Debug, Clone, Copy,)] | 2243 | #[derive(Debug, PartialEq, Eq, Hash)] |
3041 | pub struct PointerTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2244 | #[repr(transparent)] |
3042 | pub(crate) syntax: SyntaxNode<R>, | 2245 | pub struct PointerType { |
3043 | } | 2246 | pub(crate) syntax: SyntaxNode, |
3044 | pub type PointerType<'a> = PointerTypeNode<RefRoot<'a>>; | ||
3045 | |||
3046 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PointerTypeNode<R1>> for PointerTypeNode<R2> { | ||
3047 | fn eq(&self, other: &PointerTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3048 | } | 2247 | } |
3049 | impl<R: TreeRoot<RaTypes>> Eq for PointerTypeNode<R> {} | 2248 | unsafe impl TransparentNewType for PointerType { |
3050 | impl<R: TreeRoot<RaTypes>> Hash for PointerTypeNode<R> { | 2249 | type Repr = rowan::SyntaxNode<RaTypes>; |
3051 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3052 | } | 2250 | } |
3053 | 2251 | ||
3054 | impl<'a> AstNode<'a> for PointerType<'a> { | 2252 | impl AstNode for PointerType { |
3055 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2253 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3056 | match syntax.kind() { | 2254 | match syntax.kind() { |
3057 | POINTER_TYPE => Some(PointerType { syntax }), | 2255 | POINTER_TYPE => Some(PointerType::from_repr(syntax.into_repr())), |
3058 | _ => None, | 2256 | _ => None, |
3059 | } | 2257 | } |
3060 | } | 2258 | } |
3061 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2259 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2260 | fn to_owned(&self) -> TreePtr<PointerType> { TreePtr::cast(self.syntax.to_owned()) } | ||
3062 | } | 2261 | } |
3063 | 2262 | ||
3064 | impl<R: TreeRoot<RaTypes>> PointerTypeNode<R> { | ||
3065 | pub fn borrowed(&self) -> PointerType { | ||
3066 | PointerTypeNode { syntax: self.syntax.borrowed() } | ||
3067 | } | ||
3068 | pub fn owned(&self) -> PointerTypeNode { | ||
3069 | PointerTypeNode { syntax: self.syntax.owned() } | ||
3070 | } | ||
3071 | } | ||
3072 | 2263 | ||
3073 | 2264 | impl PointerType { | |
3074 | impl<'a> PointerType<'a> { | 2265 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3075 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | ||
3076 | super::child_opt(self) | 2266 | super::child_opt(self) |
3077 | } | 2267 | } |
3078 | } | 2268 | } |
3079 | 2269 | ||
3080 | // PosField | 2270 | // PosField |
3081 | #[derive(Debug, Clone, Copy,)] | 2271 | #[derive(Debug, PartialEq, Eq, Hash)] |
3082 | pub struct PosFieldNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2272 | #[repr(transparent)] |
3083 | pub(crate) syntax: SyntaxNode<R>, | 2273 | pub struct PosField { |
3084 | } | 2274 | pub(crate) syntax: SyntaxNode, |
3085 | pub type PosField<'a> = PosFieldNode<RefRoot<'a>>; | ||
3086 | |||
3087 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PosFieldNode<R1>> for PosFieldNode<R2> { | ||
3088 | fn eq(&self, other: &PosFieldNode<R1>) -> bool { self.syntax == other.syntax } | ||
3089 | } | 2275 | } |
3090 | impl<R: TreeRoot<RaTypes>> Eq for PosFieldNode<R> {} | 2276 | unsafe impl TransparentNewType for PosField { |
3091 | impl<R: TreeRoot<RaTypes>> Hash for PosFieldNode<R> { | 2277 | type Repr = rowan::SyntaxNode<RaTypes>; |
3092 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3093 | } | 2278 | } |
3094 | 2279 | ||
3095 | impl<'a> AstNode<'a> for PosField<'a> { | 2280 | impl AstNode for PosField { |
3096 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2281 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3097 | match syntax.kind() { | 2282 | match syntax.kind() { |
3098 | POS_FIELD => Some(PosField { syntax }), | 2283 | POS_FIELD => Some(PosField::from_repr(syntax.into_repr())), |
3099 | _ => None, | 2284 | _ => None, |
3100 | } | 2285 | } |
3101 | } | 2286 | } |
3102 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2287 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3103 | } | 2288 | fn to_owned(&self) -> TreePtr<PosField> { TreePtr::cast(self.syntax.to_owned()) } |
3104 | |||
3105 | impl<R: TreeRoot<RaTypes>> PosFieldNode<R> { | ||
3106 | pub fn borrowed(&self) -> PosField { | ||
3107 | PosFieldNode { syntax: self.syntax.borrowed() } | ||
3108 | } | ||
3109 | pub fn owned(&self) -> PosFieldNode { | ||
3110 | PosFieldNode { syntax: self.syntax.owned() } | ||
3111 | } | ||
3112 | } | 2289 | } |
3113 | 2290 | ||
3114 | 2291 | ||
3115 | impl<'a> ast::VisibilityOwner<'a> for PosField<'a> {} | 2292 | impl ast::VisibilityOwner for PosField {} |
3116 | impl<'a> ast::AttrsOwner<'a> for PosField<'a> {} | 2293 | impl ast::AttrsOwner for PosField {} |
3117 | impl<'a> PosField<'a> { | 2294 | impl PosField { |
3118 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 2295 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3119 | super::child_opt(self) | 2296 | super::child_opt(self) |
3120 | } | 2297 | } |
3121 | } | 2298 | } |
3122 | 2299 | ||
3123 | // PosFieldList | 2300 | // PosFieldList |
3124 | #[derive(Debug, Clone, Copy,)] | 2301 | #[derive(Debug, PartialEq, Eq, Hash)] |
3125 | pub struct PosFieldListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2302 | #[repr(transparent)] |
3126 | pub(crate) syntax: SyntaxNode<R>, | 2303 | pub struct PosFieldList { |
3127 | } | 2304 | pub(crate) syntax: SyntaxNode, |
3128 | pub type PosFieldList<'a> = PosFieldListNode<RefRoot<'a>>; | ||
3129 | |||
3130 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PosFieldListNode<R1>> for PosFieldListNode<R2> { | ||
3131 | fn eq(&self, other: &PosFieldListNode<R1>) -> bool { self.syntax == other.syntax } | ||
3132 | } | 2305 | } |
3133 | impl<R: TreeRoot<RaTypes>> Eq for PosFieldListNode<R> {} | 2306 | unsafe impl TransparentNewType for PosFieldList { |
3134 | impl<R: TreeRoot<RaTypes>> Hash for PosFieldListNode<R> { | 2307 | type Repr = rowan::SyntaxNode<RaTypes>; |
3135 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3136 | } | 2308 | } |
3137 | 2309 | ||
3138 | impl<'a> AstNode<'a> for PosFieldList<'a> { | 2310 | impl AstNode for PosFieldList { |
3139 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2311 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3140 | match syntax.kind() { | 2312 | match syntax.kind() { |
3141 | POS_FIELD_LIST => Some(PosFieldList { syntax }), | 2313 | POS_FIELD_LIST => Some(PosFieldList::from_repr(syntax.into_repr())), |
3142 | _ => None, | 2314 | _ => None, |
3143 | } | 2315 | } |
3144 | } | 2316 | } |
3145 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2317 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3146 | } | 2318 | fn to_owned(&self) -> TreePtr<PosFieldList> { TreePtr::cast(self.syntax.to_owned()) } |
3147 | |||
3148 | impl<R: TreeRoot<RaTypes>> PosFieldListNode<R> { | ||
3149 | pub fn borrowed(&self) -> PosFieldList { | ||
3150 | PosFieldListNode { syntax: self.syntax.borrowed() } | ||
3151 | } | ||
3152 | pub fn owned(&self) -> PosFieldListNode { | ||
3153 | PosFieldListNode { syntax: self.syntax.owned() } | ||
3154 | } | ||
3155 | } | 2319 | } |
3156 | 2320 | ||
3157 | 2321 | ||
3158 | impl<'a> PosFieldList<'a> { | 2322 | impl PosFieldList { |
3159 | pub fn fields(self) -> impl Iterator<Item = PosField<'a>> + 'a { | 2323 | pub fn fields(&self) -> impl Iterator<Item = &PosField> { |
3160 | super::children(self) | 2324 | super::children(self) |
3161 | } | 2325 | } |
3162 | } | 2326 | } |
3163 | 2327 | ||
3164 | // PrefixExpr | 2328 | // PrefixExpr |
3165 | #[derive(Debug, Clone, Copy,)] | 2329 | #[derive(Debug, PartialEq, Eq, Hash)] |
3166 | pub struct PrefixExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2330 | #[repr(transparent)] |
3167 | pub(crate) syntax: SyntaxNode<R>, | 2331 | pub struct PrefixExpr { |
2332 | pub(crate) syntax: SyntaxNode, | ||
3168 | } | 2333 | } |
3169 | pub type PrefixExpr<'a> = PrefixExprNode<RefRoot<'a>>; | 2334 | unsafe impl TransparentNewType for PrefixExpr { |
3170 | 2335 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3171 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<PrefixExprNode<R1>> for PrefixExprNode<R2> { | ||
3172 | fn eq(&self, other: &PrefixExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
3173 | } | ||
3174 | impl<R: TreeRoot<RaTypes>> Eq for PrefixExprNode<R> {} | ||
3175 | impl<R: TreeRoot<RaTypes>> Hash for PrefixExprNode<R> { | ||
3176 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3177 | } | 2336 | } |
3178 | 2337 | ||
3179 | impl<'a> AstNode<'a> for PrefixExpr<'a> { | 2338 | impl AstNode for PrefixExpr { |
3180 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2339 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3181 | match syntax.kind() { | 2340 | match syntax.kind() { |
3182 | PREFIX_EXPR => Some(PrefixExpr { syntax }), | 2341 | PREFIX_EXPR => Some(PrefixExpr::from_repr(syntax.into_repr())), |
3183 | _ => None, | 2342 | _ => None, |
3184 | } | 2343 | } |
3185 | } | 2344 | } |
3186 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2345 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3187 | } | 2346 | fn to_owned(&self) -> TreePtr<PrefixExpr> { TreePtr::cast(self.syntax.to_owned()) } |
3188 | |||
3189 | impl<R: TreeRoot<RaTypes>> PrefixExprNode<R> { | ||
3190 | pub fn borrowed(&self) -> PrefixExpr { | ||
3191 | PrefixExprNode { syntax: self.syntax.borrowed() } | ||
3192 | } | ||
3193 | pub fn owned(&self) -> PrefixExprNode { | ||
3194 | PrefixExprNode { syntax: self.syntax.owned() } | ||
3195 | } | ||
3196 | } | 2347 | } |
3197 | 2348 | ||
3198 | 2349 | ||
3199 | impl<'a> PrefixExpr<'a> { | 2350 | impl PrefixExpr { |
3200 | pub fn expr(self) -> Option<Expr<'a>> { | 2351 | pub fn expr(&self) -> Option<&Expr> { |
3201 | super::child_opt(self) | 2352 | super::child_opt(self) |
3202 | } | 2353 | } |
3203 | } | 2354 | } |
3204 | 2355 | ||
3205 | // RangeExpr | 2356 | // RangeExpr |
3206 | #[derive(Debug, Clone, Copy,)] | 2357 | #[derive(Debug, PartialEq, Eq, Hash)] |
3207 | pub struct RangeExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2358 | #[repr(transparent)] |
3208 | pub(crate) syntax: SyntaxNode<R>, | 2359 | pub struct RangeExpr { |
3209 | } | 2360 | pub(crate) syntax: SyntaxNode, |
3210 | pub type RangeExpr<'a> = RangeExprNode<RefRoot<'a>>; | ||
3211 | |||
3212 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<RangeExprNode<R1>> for RangeExprNode<R2> { | ||
3213 | fn eq(&self, other: &RangeExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
3214 | } | 2361 | } |
3215 | impl<R: TreeRoot<RaTypes>> Eq for RangeExprNode<R> {} | 2362 | unsafe impl TransparentNewType for RangeExpr { |
3216 | impl<R: TreeRoot<RaTypes>> Hash for RangeExprNode<R> { | 2363 | type Repr = rowan::SyntaxNode<RaTypes>; |
3217 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3218 | } | 2364 | } |
3219 | 2365 | ||
3220 | impl<'a> AstNode<'a> for RangeExpr<'a> { | 2366 | impl AstNode for RangeExpr { |
3221 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2367 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3222 | match syntax.kind() { | 2368 | match syntax.kind() { |
3223 | RANGE_EXPR => Some(RangeExpr { syntax }), | 2369 | RANGE_EXPR => Some(RangeExpr::from_repr(syntax.into_repr())), |
3224 | _ => None, | 2370 | _ => None, |
3225 | } | 2371 | } |
3226 | } | 2372 | } |
3227 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2373 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2374 | fn to_owned(&self) -> TreePtr<RangeExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
3228 | } | 2375 | } |
3229 | 2376 | ||
3230 | impl<R: TreeRoot<RaTypes>> RangeExprNode<R> { | ||
3231 | pub fn borrowed(&self) -> RangeExpr { | ||
3232 | RangeExprNode { syntax: self.syntax.borrowed() } | ||
3233 | } | ||
3234 | pub fn owned(&self) -> RangeExprNode { | ||
3235 | RangeExprNode { syntax: self.syntax.owned() } | ||
3236 | } | ||
3237 | } | ||
3238 | 2377 | ||
3239 | 2378 | impl RangeExpr {} | |
3240 | impl<'a> RangeExpr<'a> {} | ||
3241 | 2379 | ||
3242 | // RangePat | 2380 | // RangePat |
3243 | #[derive(Debug, Clone, Copy,)] | 2381 | #[derive(Debug, PartialEq, Eq, Hash)] |
3244 | pub struct RangePatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2382 | #[repr(transparent)] |
3245 | pub(crate) syntax: SyntaxNode<R>, | 2383 | pub struct RangePat { |
2384 | pub(crate) syntax: SyntaxNode, | ||
3246 | } | 2385 | } |
3247 | pub type RangePat<'a> = RangePatNode<RefRoot<'a>>; | 2386 | unsafe impl TransparentNewType for RangePat { |
3248 | 2387 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3249 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<RangePatNode<R1>> for RangePatNode<R2> { | ||
3250 | fn eq(&self, other: &RangePatNode<R1>) -> bool { self.syntax == other.syntax } | ||
3251 | } | ||
3252 | impl<R: TreeRoot<RaTypes>> Eq for RangePatNode<R> {} | ||
3253 | impl<R: TreeRoot<RaTypes>> Hash for RangePatNode<R> { | ||
3254 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3255 | } | 2388 | } |
3256 | 2389 | ||
3257 | impl<'a> AstNode<'a> for RangePat<'a> { | 2390 | impl AstNode for RangePat { |
3258 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2391 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3259 | match syntax.kind() { | 2392 | match syntax.kind() { |
3260 | RANGE_PAT => Some(RangePat { syntax }), | 2393 | RANGE_PAT => Some(RangePat::from_repr(syntax.into_repr())), |
3261 | _ => None, | 2394 | _ => None, |
3262 | } | 2395 | } |
3263 | } | 2396 | } |
3264 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2397 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3265 | } | 2398 | fn to_owned(&self) -> TreePtr<RangePat> { TreePtr::cast(self.syntax.to_owned()) } |
3266 | |||
3267 | impl<R: TreeRoot<RaTypes>> RangePatNode<R> { | ||
3268 | pub fn borrowed(&self) -> RangePat { | ||
3269 | RangePatNode { syntax: self.syntax.borrowed() } | ||
3270 | } | ||
3271 | pub fn owned(&self) -> RangePatNode { | ||
3272 | RangePatNode { syntax: self.syntax.owned() } | ||
3273 | } | ||
3274 | } | 2399 | } |
3275 | 2400 | ||
3276 | 2401 | ||
3277 | impl<'a> RangePat<'a> {} | 2402 | impl RangePat {} |
3278 | 2403 | ||
3279 | // RefExpr | 2404 | // RefExpr |
3280 | #[derive(Debug, Clone, Copy,)] | 2405 | #[derive(Debug, PartialEq, Eq, Hash)] |
3281 | pub struct RefExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2406 | #[repr(transparent)] |
3282 | pub(crate) syntax: SyntaxNode<R>, | 2407 | pub struct RefExpr { |
2408 | pub(crate) syntax: SyntaxNode, | ||
3283 | } | 2409 | } |
3284 | pub type RefExpr<'a> = RefExprNode<RefRoot<'a>>; | 2410 | unsafe impl TransparentNewType for RefExpr { |
3285 | 2411 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3286 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<RefExprNode<R1>> for RefExprNode<R2> { | ||
3287 | fn eq(&self, other: &RefExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
3288 | } | ||
3289 | impl<R: TreeRoot<RaTypes>> Eq for RefExprNode<R> {} | ||
3290 | impl<R: TreeRoot<RaTypes>> Hash for RefExprNode<R> { | ||
3291 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3292 | } | 2412 | } |
3293 | 2413 | ||
3294 | impl<'a> AstNode<'a> for RefExpr<'a> { | 2414 | impl AstNode for RefExpr { |
3295 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2415 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3296 | match syntax.kind() { | 2416 | match syntax.kind() { |
3297 | REF_EXPR => Some(RefExpr { syntax }), | 2417 | REF_EXPR => Some(RefExpr::from_repr(syntax.into_repr())), |
3298 | _ => None, | 2418 | _ => None, |
3299 | } | 2419 | } |
3300 | } | 2420 | } |
3301 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2421 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3302 | } | 2422 | fn to_owned(&self) -> TreePtr<RefExpr> { TreePtr::cast(self.syntax.to_owned()) } |
3303 | |||
3304 | impl<R: TreeRoot<RaTypes>> RefExprNode<R> { | ||
3305 | pub fn borrowed(&self) -> RefExpr { | ||
3306 | RefExprNode { syntax: self.syntax.borrowed() } | ||
3307 | } | ||
3308 | pub fn owned(&self) -> RefExprNode { | ||
3309 | RefExprNode { syntax: self.syntax.owned() } | ||
3310 | } | ||
3311 | } | 2423 | } |
3312 | 2424 | ||
3313 | 2425 | ||
3314 | impl<'a> RefExpr<'a> { | 2426 | impl RefExpr { |
3315 | pub fn expr(self) -> Option<Expr<'a>> { | 2427 | pub fn expr(&self) -> Option<&Expr> { |
3316 | super::child_opt(self) | 2428 | super::child_opt(self) |
3317 | } | 2429 | } |
3318 | } | 2430 | } |
3319 | 2431 | ||
3320 | // RefPat | 2432 | // RefPat |
3321 | #[derive(Debug, Clone, Copy,)] | 2433 | #[derive(Debug, PartialEq, Eq, Hash)] |
3322 | pub struct RefPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2434 | #[repr(transparent)] |
3323 | pub(crate) syntax: SyntaxNode<R>, | 2435 | pub struct RefPat { |
2436 | pub(crate) syntax: SyntaxNode, | ||
3324 | } | 2437 | } |
3325 | pub type RefPat<'a> = RefPatNode<RefRoot<'a>>; | 2438 | unsafe impl TransparentNewType for RefPat { |
3326 | 2439 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3327 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<RefPatNode<R1>> for RefPatNode<R2> { | ||
3328 | fn eq(&self, other: &RefPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
3329 | } | ||
3330 | impl<R: TreeRoot<RaTypes>> Eq for RefPatNode<R> {} | ||
3331 | impl<R: TreeRoot<RaTypes>> Hash for RefPatNode<R> { | ||
3332 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3333 | } | 2440 | } |
3334 | 2441 | ||
3335 | impl<'a> AstNode<'a> for RefPat<'a> { | 2442 | impl AstNode for RefPat { |
3336 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2443 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3337 | match syntax.kind() { | 2444 | match syntax.kind() { |
3338 | REF_PAT => Some(RefPat { syntax }), | 2445 | REF_PAT => Some(RefPat::from_repr(syntax.into_repr())), |
3339 | _ => None, | 2446 | _ => None, |
3340 | } | 2447 | } |
3341 | } | 2448 | } |
3342 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2449 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3343 | } | 2450 | fn to_owned(&self) -> TreePtr<RefPat> { TreePtr::cast(self.syntax.to_owned()) } |
3344 | |||
3345 | impl<R: TreeRoot<RaTypes>> RefPatNode<R> { | ||
3346 | pub fn borrowed(&self) -> RefPat { | ||
3347 | RefPatNode { syntax: self.syntax.borrowed() } | ||
3348 | } | ||
3349 | pub fn owned(&self) -> RefPatNode { | ||
3350 | RefPatNode { syntax: self.syntax.owned() } | ||
3351 | } | ||
3352 | } | 2451 | } |
3353 | 2452 | ||
3354 | 2453 | ||
3355 | impl<'a> RefPat<'a> {} | 2454 | impl RefPat {} |
3356 | 2455 | ||
3357 | // ReferenceType | 2456 | // ReferenceType |
3358 | #[derive(Debug, Clone, Copy,)] | 2457 | #[derive(Debug, PartialEq, Eq, Hash)] |
3359 | pub struct ReferenceTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2458 | #[repr(transparent)] |
3360 | pub(crate) syntax: SyntaxNode<R>, | 2459 | pub struct ReferenceType { |
3361 | } | 2460 | pub(crate) syntax: SyntaxNode, |
3362 | pub type ReferenceType<'a> = ReferenceTypeNode<RefRoot<'a>>; | ||
3363 | |||
3364 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ReferenceTypeNode<R1>> for ReferenceTypeNode<R2> { | ||
3365 | fn eq(&self, other: &ReferenceTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3366 | } | 2461 | } |
3367 | impl<R: TreeRoot<RaTypes>> Eq for ReferenceTypeNode<R> {} | 2462 | unsafe impl TransparentNewType for ReferenceType { |
3368 | impl<R: TreeRoot<RaTypes>> Hash for ReferenceTypeNode<R> { | 2463 | type Repr = rowan::SyntaxNode<RaTypes>; |
3369 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3370 | } | 2464 | } |
3371 | 2465 | ||
3372 | impl<'a> AstNode<'a> for ReferenceType<'a> { | 2466 | impl AstNode for ReferenceType { |
3373 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2467 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3374 | match syntax.kind() { | 2468 | match syntax.kind() { |
3375 | REFERENCE_TYPE => Some(ReferenceType { syntax }), | 2469 | REFERENCE_TYPE => Some(ReferenceType::from_repr(syntax.into_repr())), |
3376 | _ => None, | 2470 | _ => None, |
3377 | } | 2471 | } |
3378 | } | 2472 | } |
3379 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2473 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3380 | } | 2474 | fn to_owned(&self) -> TreePtr<ReferenceType> { TreePtr::cast(self.syntax.to_owned()) } |
3381 | |||
3382 | impl<R: TreeRoot<RaTypes>> ReferenceTypeNode<R> { | ||
3383 | pub fn borrowed(&self) -> ReferenceType { | ||
3384 | ReferenceTypeNode { syntax: self.syntax.borrowed() } | ||
3385 | } | ||
3386 | pub fn owned(&self) -> ReferenceTypeNode { | ||
3387 | ReferenceTypeNode { syntax: self.syntax.owned() } | ||
3388 | } | ||
3389 | } | 2475 | } |
3390 | 2476 | ||
3391 | 2477 | ||
3392 | impl<'a> ReferenceType<'a> { | 2478 | impl ReferenceType { |
3393 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 2479 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3394 | super::child_opt(self) | 2480 | super::child_opt(self) |
3395 | } | 2481 | } |
3396 | } | 2482 | } |
3397 | 2483 | ||
3398 | // RetType | 2484 | // RetType |
3399 | #[derive(Debug, Clone, Copy,)] | 2485 | #[derive(Debug, PartialEq, Eq, Hash)] |
3400 | pub struct RetTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2486 | #[repr(transparent)] |
3401 | pub(crate) syntax: SyntaxNode<R>, | 2487 | pub struct RetType { |
3402 | } | 2488 | pub(crate) syntax: SyntaxNode, |
3403 | pub type RetType<'a> = RetTypeNode<RefRoot<'a>>; | ||
3404 | |||
3405 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<RetTypeNode<R1>> for RetTypeNode<R2> { | ||
3406 | fn eq(&self, other: &RetTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3407 | } | 2489 | } |
3408 | impl<R: TreeRoot<RaTypes>> Eq for RetTypeNode<R> {} | 2490 | unsafe impl TransparentNewType for RetType { |
3409 | impl<R: TreeRoot<RaTypes>> Hash for RetTypeNode<R> { | 2491 | type Repr = rowan::SyntaxNode<RaTypes>; |
3410 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3411 | } | 2492 | } |
3412 | 2493 | ||
3413 | impl<'a> AstNode<'a> for RetType<'a> { | 2494 | impl AstNode for RetType { |
3414 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2495 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3415 | match syntax.kind() { | 2496 | match syntax.kind() { |
3416 | RET_TYPE => Some(RetType { syntax }), | 2497 | RET_TYPE => Some(RetType::from_repr(syntax.into_repr())), |
3417 | _ => None, | 2498 | _ => None, |
3418 | } | 2499 | } |
3419 | } | 2500 | } |
3420 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2501 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3421 | } | 2502 | fn to_owned(&self) -> TreePtr<RetType> { TreePtr::cast(self.syntax.to_owned()) } |
3422 | |||
3423 | impl<R: TreeRoot<RaTypes>> RetTypeNode<R> { | ||
3424 | pub fn borrowed(&self) -> RetType { | ||
3425 | RetTypeNode { syntax: self.syntax.borrowed() } | ||
3426 | } | ||
3427 | pub fn owned(&self) -> RetTypeNode { | ||
3428 | RetTypeNode { syntax: self.syntax.owned() } | ||
3429 | } | ||
3430 | } | 2503 | } |
3431 | 2504 | ||
3432 | 2505 | ||
3433 | impl<'a> RetType<'a> { | 2506 | impl RetType { |
3434 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 2507 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3435 | super::child_opt(self) | 2508 | super::child_opt(self) |
3436 | } | 2509 | } |
3437 | } | 2510 | } |
3438 | 2511 | ||
3439 | // ReturnExpr | 2512 | // ReturnExpr |
3440 | #[derive(Debug, Clone, Copy,)] | 2513 | #[derive(Debug, PartialEq, Eq, Hash)] |
3441 | pub struct ReturnExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2514 | #[repr(transparent)] |
3442 | pub(crate) syntax: SyntaxNode<R>, | 2515 | pub struct ReturnExpr { |
2516 | pub(crate) syntax: SyntaxNode, | ||
3443 | } | 2517 | } |
3444 | pub type ReturnExpr<'a> = ReturnExprNode<RefRoot<'a>>; | 2518 | unsafe impl TransparentNewType for ReturnExpr { |
3445 | 2519 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3446 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ReturnExprNode<R1>> for ReturnExprNode<R2> { | ||
3447 | fn eq(&self, other: &ReturnExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
3448 | } | ||
3449 | impl<R: TreeRoot<RaTypes>> Eq for ReturnExprNode<R> {} | ||
3450 | impl<R: TreeRoot<RaTypes>> Hash for ReturnExprNode<R> { | ||
3451 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3452 | } | 2520 | } |
3453 | 2521 | ||
3454 | impl<'a> AstNode<'a> for ReturnExpr<'a> { | 2522 | impl AstNode for ReturnExpr { |
3455 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2523 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3456 | match syntax.kind() { | 2524 | match syntax.kind() { |
3457 | RETURN_EXPR => Some(ReturnExpr { syntax }), | 2525 | RETURN_EXPR => Some(ReturnExpr::from_repr(syntax.into_repr())), |
3458 | _ => None, | 2526 | _ => None, |
3459 | } | 2527 | } |
3460 | } | 2528 | } |
3461 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2529 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3462 | } | 2530 | fn to_owned(&self) -> TreePtr<ReturnExpr> { TreePtr::cast(self.syntax.to_owned()) } |
3463 | |||
3464 | impl<R: TreeRoot<RaTypes>> ReturnExprNode<R> { | ||
3465 | pub fn borrowed(&self) -> ReturnExpr { | ||
3466 | ReturnExprNode { syntax: self.syntax.borrowed() } | ||
3467 | } | ||
3468 | pub fn owned(&self) -> ReturnExprNode { | ||
3469 | ReturnExprNode { syntax: self.syntax.owned() } | ||
3470 | } | ||
3471 | } | 2531 | } |
3472 | 2532 | ||
3473 | 2533 | ||
3474 | impl<'a> ReturnExpr<'a> { | 2534 | impl ReturnExpr { |
3475 | pub fn expr(self) -> Option<Expr<'a>> { | 2535 | pub fn expr(&self) -> Option<&Expr> { |
3476 | super::child_opt(self) | 2536 | super::child_opt(self) |
3477 | } | 2537 | } |
3478 | } | 2538 | } |
3479 | 2539 | ||
3480 | // SelfKw | 2540 | // SelfKw |
3481 | #[derive(Debug, Clone, Copy,)] | 2541 | #[derive(Debug, PartialEq, Eq, Hash)] |
3482 | pub struct SelfKwNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2542 | #[repr(transparent)] |
3483 | pub(crate) syntax: SyntaxNode<R>, | 2543 | pub struct SelfKw { |
3484 | } | 2544 | pub(crate) syntax: SyntaxNode, |
3485 | pub type SelfKw<'a> = SelfKwNode<RefRoot<'a>>; | ||
3486 | |||
3487 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SelfKwNode<R1>> for SelfKwNode<R2> { | ||
3488 | fn eq(&self, other: &SelfKwNode<R1>) -> bool { self.syntax == other.syntax } | ||
3489 | } | 2545 | } |
3490 | impl<R: TreeRoot<RaTypes>> Eq for SelfKwNode<R> {} | 2546 | unsafe impl TransparentNewType for SelfKw { |
3491 | impl<R: TreeRoot<RaTypes>> Hash for SelfKwNode<R> { | 2547 | type Repr = rowan::SyntaxNode<RaTypes>; |
3492 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3493 | } | 2548 | } |
3494 | 2549 | ||
3495 | impl<'a> AstNode<'a> for SelfKw<'a> { | 2550 | impl AstNode for SelfKw { |
3496 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2551 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3497 | match syntax.kind() { | 2552 | match syntax.kind() { |
3498 | SELF_KW => Some(SelfKw { syntax }), | 2553 | SELF_KW => Some(SelfKw::from_repr(syntax.into_repr())), |
3499 | _ => None, | 2554 | _ => None, |
3500 | } | 2555 | } |
3501 | } | 2556 | } |
3502 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2557 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2558 | fn to_owned(&self) -> TreePtr<SelfKw> { TreePtr::cast(self.syntax.to_owned()) } | ||
3503 | } | 2559 | } |
3504 | 2560 | ||
3505 | impl<R: TreeRoot<RaTypes>> SelfKwNode<R> { | ||
3506 | pub fn borrowed(&self) -> SelfKw { | ||
3507 | SelfKwNode { syntax: self.syntax.borrowed() } | ||
3508 | } | ||
3509 | pub fn owned(&self) -> SelfKwNode { | ||
3510 | SelfKwNode { syntax: self.syntax.owned() } | ||
3511 | } | ||
3512 | } | ||
3513 | 2561 | ||
3514 | 2562 | impl SelfKw {} | |
3515 | impl<'a> SelfKw<'a> {} | ||
3516 | 2563 | ||
3517 | // SelfParam | 2564 | // SelfParam |
3518 | #[derive(Debug, Clone, Copy,)] | 2565 | #[derive(Debug, PartialEq, Eq, Hash)] |
3519 | pub struct SelfParamNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2566 | #[repr(transparent)] |
3520 | pub(crate) syntax: SyntaxNode<R>, | 2567 | pub struct SelfParam { |
2568 | pub(crate) syntax: SyntaxNode, | ||
3521 | } | 2569 | } |
3522 | pub type SelfParam<'a> = SelfParamNode<RefRoot<'a>>; | 2570 | unsafe impl TransparentNewType for SelfParam { |
3523 | 2571 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3524 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SelfParamNode<R1>> for SelfParamNode<R2> { | ||
3525 | fn eq(&self, other: &SelfParamNode<R1>) -> bool { self.syntax == other.syntax } | ||
3526 | } | ||
3527 | impl<R: TreeRoot<RaTypes>> Eq for SelfParamNode<R> {} | ||
3528 | impl<R: TreeRoot<RaTypes>> Hash for SelfParamNode<R> { | ||
3529 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3530 | } | 2572 | } |
3531 | 2573 | ||
3532 | impl<'a> AstNode<'a> for SelfParam<'a> { | 2574 | impl AstNode for SelfParam { |
3533 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2575 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3534 | match syntax.kind() { | 2576 | match syntax.kind() { |
3535 | SELF_PARAM => Some(SelfParam { syntax }), | 2577 | SELF_PARAM => Some(SelfParam::from_repr(syntax.into_repr())), |
3536 | _ => None, | 2578 | _ => None, |
3537 | } | 2579 | } |
3538 | } | 2580 | } |
3539 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2581 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3540 | } | 2582 | fn to_owned(&self) -> TreePtr<SelfParam> { TreePtr::cast(self.syntax.to_owned()) } |
3541 | |||
3542 | impl<R: TreeRoot<RaTypes>> SelfParamNode<R> { | ||
3543 | pub fn borrowed(&self) -> SelfParam { | ||
3544 | SelfParamNode { syntax: self.syntax.borrowed() } | ||
3545 | } | ||
3546 | pub fn owned(&self) -> SelfParamNode { | ||
3547 | SelfParamNode { syntax: self.syntax.owned() } | ||
3548 | } | ||
3549 | } | 2583 | } |
3550 | 2584 | ||
3551 | 2585 | ||
3552 | impl<'a> SelfParam<'a> { | 2586 | impl SelfParam { |
3553 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 2587 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3554 | super::child_opt(self) | 2588 | super::child_opt(self) |
3555 | } | 2589 | } |
3556 | 2590 | ||
3557 | pub fn self_kw(self) -> Option<SelfKw<'a>> { | 2591 | pub fn self_kw(&self) -> Option<&SelfKw> { |
3558 | super::child_opt(self) | 2592 | super::child_opt(self) |
3559 | } | 2593 | } |
3560 | } | 2594 | } |
3561 | 2595 | ||
3562 | // SlicePat | 2596 | // SlicePat |
3563 | #[derive(Debug, Clone, Copy,)] | 2597 | #[derive(Debug, PartialEq, Eq, Hash)] |
3564 | pub struct SlicePatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2598 | #[repr(transparent)] |
3565 | pub(crate) syntax: SyntaxNode<R>, | 2599 | pub struct SlicePat { |
2600 | pub(crate) syntax: SyntaxNode, | ||
3566 | } | 2601 | } |
3567 | pub type SlicePat<'a> = SlicePatNode<RefRoot<'a>>; | 2602 | unsafe impl TransparentNewType for SlicePat { |
3568 | 2603 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3569 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SlicePatNode<R1>> for SlicePatNode<R2> { | ||
3570 | fn eq(&self, other: &SlicePatNode<R1>) -> bool { self.syntax == other.syntax } | ||
3571 | } | ||
3572 | impl<R: TreeRoot<RaTypes>> Eq for SlicePatNode<R> {} | ||
3573 | impl<R: TreeRoot<RaTypes>> Hash for SlicePatNode<R> { | ||
3574 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3575 | } | 2604 | } |
3576 | 2605 | ||
3577 | impl<'a> AstNode<'a> for SlicePat<'a> { | 2606 | impl AstNode for SlicePat { |
3578 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2607 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3579 | match syntax.kind() { | 2608 | match syntax.kind() { |
3580 | SLICE_PAT => Some(SlicePat { syntax }), | 2609 | SLICE_PAT => Some(SlicePat::from_repr(syntax.into_repr())), |
3581 | _ => None, | 2610 | _ => None, |
3582 | } | 2611 | } |
3583 | } | 2612 | } |
3584 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2613 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3585 | } | 2614 | fn to_owned(&self) -> TreePtr<SlicePat> { TreePtr::cast(self.syntax.to_owned()) } |
3586 | |||
3587 | impl<R: TreeRoot<RaTypes>> SlicePatNode<R> { | ||
3588 | pub fn borrowed(&self) -> SlicePat { | ||
3589 | SlicePatNode { syntax: self.syntax.borrowed() } | ||
3590 | } | ||
3591 | pub fn owned(&self) -> SlicePatNode { | ||
3592 | SlicePatNode { syntax: self.syntax.owned() } | ||
3593 | } | ||
3594 | } | 2615 | } |
3595 | 2616 | ||
3596 | 2617 | ||
3597 | impl<'a> SlicePat<'a> {} | 2618 | impl SlicePat {} |
3598 | 2619 | ||
3599 | // SliceType | 2620 | // SliceType |
3600 | #[derive(Debug, Clone, Copy,)] | 2621 | #[derive(Debug, PartialEq, Eq, Hash)] |
3601 | pub struct SliceTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2622 | #[repr(transparent)] |
3602 | pub(crate) syntax: SyntaxNode<R>, | 2623 | pub struct SliceType { |
2624 | pub(crate) syntax: SyntaxNode, | ||
3603 | } | 2625 | } |
3604 | pub type SliceType<'a> = SliceTypeNode<RefRoot<'a>>; | 2626 | unsafe impl TransparentNewType for SliceType { |
3605 | 2627 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3606 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SliceTypeNode<R1>> for SliceTypeNode<R2> { | ||
3607 | fn eq(&self, other: &SliceTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3608 | } | ||
3609 | impl<R: TreeRoot<RaTypes>> Eq for SliceTypeNode<R> {} | ||
3610 | impl<R: TreeRoot<RaTypes>> Hash for SliceTypeNode<R> { | ||
3611 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3612 | } | 2628 | } |
3613 | 2629 | ||
3614 | impl<'a> AstNode<'a> for SliceType<'a> { | 2630 | impl AstNode for SliceType { |
3615 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2631 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3616 | match syntax.kind() { | 2632 | match syntax.kind() { |
3617 | SLICE_TYPE => Some(SliceType { syntax }), | 2633 | SLICE_TYPE => Some(SliceType::from_repr(syntax.into_repr())), |
3618 | _ => None, | 2634 | _ => None, |
3619 | } | 2635 | } |
3620 | } | 2636 | } |
3621 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2637 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3622 | } | 2638 | fn to_owned(&self) -> TreePtr<SliceType> { TreePtr::cast(self.syntax.to_owned()) } |
3623 | |||
3624 | impl<R: TreeRoot<RaTypes>> SliceTypeNode<R> { | ||
3625 | pub fn borrowed(&self) -> SliceType { | ||
3626 | SliceTypeNode { syntax: self.syntax.borrowed() } | ||
3627 | } | ||
3628 | pub fn owned(&self) -> SliceTypeNode { | ||
3629 | SliceTypeNode { syntax: self.syntax.owned() } | ||
3630 | } | ||
3631 | } | 2639 | } |
3632 | 2640 | ||
3633 | 2641 | ||
3634 | impl<'a> SliceType<'a> { | 2642 | impl SliceType { |
3635 | pub fn type_ref(self) -> Option<TypeRef<'a>> { | 2643 | pub fn type_ref(&self) -> Option<&TypeRef> { |
3636 | super::child_opt(self) | 2644 | super::child_opt(self) |
3637 | } | 2645 | } |
3638 | } | 2646 | } |
3639 | 2647 | ||
3640 | // SourceFile | 2648 | // SourceFile |
3641 | #[derive(Debug, Clone, Copy,)] | 2649 | #[derive(Debug, PartialEq, Eq, Hash)] |
3642 | pub struct SourceFileNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2650 | #[repr(transparent)] |
3643 | pub(crate) syntax: SyntaxNode<R>, | 2651 | pub struct SourceFile { |
2652 | pub(crate) syntax: SyntaxNode, | ||
3644 | } | 2653 | } |
3645 | pub type SourceFile<'a> = SourceFileNode<RefRoot<'a>>; | 2654 | unsafe impl TransparentNewType for SourceFile { |
3646 | 2655 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3647 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SourceFileNode<R1>> for SourceFileNode<R2> { | ||
3648 | fn eq(&self, other: &SourceFileNode<R1>) -> bool { self.syntax == other.syntax } | ||
3649 | } | ||
3650 | impl<R: TreeRoot<RaTypes>> Eq for SourceFileNode<R> {} | ||
3651 | impl<R: TreeRoot<RaTypes>> Hash for SourceFileNode<R> { | ||
3652 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3653 | } | 2656 | } |
3654 | 2657 | ||
3655 | impl<'a> AstNode<'a> for SourceFile<'a> { | 2658 | impl AstNode for SourceFile { |
3656 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2659 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3657 | match syntax.kind() { | 2660 | match syntax.kind() { |
3658 | SOURCE_FILE => Some(SourceFile { syntax }), | 2661 | SOURCE_FILE => Some(SourceFile::from_repr(syntax.into_repr())), |
3659 | _ => None, | 2662 | _ => None, |
3660 | } | 2663 | } |
3661 | } | 2664 | } |
3662 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2665 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2666 | fn to_owned(&self) -> TreePtr<SourceFile> { TreePtr::cast(self.syntax.to_owned()) } | ||
3663 | } | 2667 | } |
3664 | 2668 | ||
3665 | impl<R: TreeRoot<RaTypes>> SourceFileNode<R> { | ||
3666 | pub fn borrowed(&self) -> SourceFile { | ||
3667 | SourceFileNode { syntax: self.syntax.borrowed() } | ||
3668 | } | ||
3669 | pub fn owned(&self) -> SourceFileNode { | ||
3670 | SourceFileNode { syntax: self.syntax.owned() } | ||
3671 | } | ||
3672 | } | ||
3673 | 2669 | ||
3674 | 2670 | impl ast::ModuleItemOwner for SourceFile {} | |
3675 | impl<'a> ast::ModuleItemOwner<'a> for SourceFile<'a> {} | 2671 | impl ast::FnDefOwner for SourceFile {} |
3676 | impl<'a> ast::FnDefOwner<'a> for SourceFile<'a> {} | 2672 | impl SourceFile { |
3677 | impl<'a> SourceFile<'a> { | 2673 | pub fn modules(&self) -> impl Iterator<Item = &Module> { |
3678 | pub fn modules(self) -> impl Iterator<Item = Module<'a>> + 'a { | ||
3679 | super::children(self) | 2674 | super::children(self) |
3680 | } | 2675 | } |
3681 | } | 2676 | } |
3682 | 2677 | ||
3683 | // StaticDef | 2678 | // StaticDef |
3684 | #[derive(Debug, Clone, Copy,)] | 2679 | #[derive(Debug, PartialEq, Eq, Hash)] |
3685 | pub struct StaticDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2680 | #[repr(transparent)] |
3686 | pub(crate) syntax: SyntaxNode<R>, | 2681 | pub struct StaticDef { |
3687 | } | 2682 | pub(crate) syntax: SyntaxNode, |
3688 | pub type StaticDef<'a> = StaticDefNode<RefRoot<'a>>; | ||
3689 | |||
3690 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<StaticDefNode<R1>> for StaticDefNode<R2> { | ||
3691 | fn eq(&self, other: &StaticDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
3692 | } | 2683 | } |
3693 | impl<R: TreeRoot<RaTypes>> Eq for StaticDefNode<R> {} | 2684 | unsafe impl TransparentNewType for StaticDef { |
3694 | impl<R: TreeRoot<RaTypes>> Hash for StaticDefNode<R> { | 2685 | type Repr = rowan::SyntaxNode<RaTypes>; |
3695 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3696 | } | 2686 | } |
3697 | 2687 | ||
3698 | impl<'a> AstNode<'a> for StaticDef<'a> { | 2688 | impl AstNode for StaticDef { |
3699 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2689 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3700 | match syntax.kind() { | 2690 | match syntax.kind() { |
3701 | STATIC_DEF => Some(StaticDef { syntax }), | 2691 | STATIC_DEF => Some(StaticDef::from_repr(syntax.into_repr())), |
3702 | _ => None, | 2692 | _ => None, |
3703 | } | 2693 | } |
3704 | } | 2694 | } |
3705 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2695 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2696 | fn to_owned(&self) -> TreePtr<StaticDef> { TreePtr::cast(self.syntax.to_owned()) } | ||
3706 | } | 2697 | } |
3707 | 2698 | ||
3708 | impl<R: TreeRoot<RaTypes>> StaticDefNode<R> { | ||
3709 | pub fn borrowed(&self) -> StaticDef { | ||
3710 | StaticDefNode { syntax: self.syntax.borrowed() } | ||
3711 | } | ||
3712 | pub fn owned(&self) -> StaticDefNode { | ||
3713 | StaticDefNode { syntax: self.syntax.owned() } | ||
3714 | } | ||
3715 | } | ||
3716 | 2699 | ||
3717 | 2700 | impl ast::VisibilityOwner for StaticDef {} | |
3718 | impl<'a> ast::VisibilityOwner<'a> for StaticDef<'a> {} | 2701 | impl ast::NameOwner for StaticDef {} |
3719 | impl<'a> ast::NameOwner<'a> for StaticDef<'a> {} | 2702 | impl ast::TypeParamsOwner for StaticDef {} |
3720 | impl<'a> ast::TypeParamsOwner<'a> for StaticDef<'a> {} | 2703 | impl ast::AttrsOwner for StaticDef {} |
3721 | impl<'a> ast::AttrsOwner<'a> for StaticDef<'a> {} | 2704 | impl ast::DocCommentsOwner for StaticDef {} |
3722 | impl<'a> ast::DocCommentsOwner<'a> for StaticDef<'a> {} | 2705 | impl StaticDef {} |
3723 | impl<'a> StaticDef<'a> {} | ||
3724 | 2706 | ||
3725 | // Stmt | 2707 | // Stmt |
2708 | #[derive(Debug, PartialEq, Eq, Hash)] | ||
2709 | #[repr(transparent)] | ||
2710 | pub struct Stmt { | ||
2711 | pub(crate) syntax: SyntaxNode, | ||
2712 | } | ||
2713 | unsafe impl TransparentNewType for Stmt { | ||
2714 | type Repr = rowan::SyntaxNode<RaTypes>; | ||
2715 | } | ||
2716 | |||
3726 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 2717 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
3727 | pub enum Stmt<'a> { | 2718 | pub enum StmtKind<'a> { |
3728 | ExprStmt(ExprStmt<'a>), | 2719 | ExprStmt(&'a ExprStmt), |
3729 | LetStmt(LetStmt<'a>), | 2720 | LetStmt(&'a LetStmt), |
3730 | } | 2721 | } |
3731 | 2722 | ||
3732 | impl<'a> AstNode<'a> for Stmt<'a> { | 2723 | impl AstNode for Stmt { |
3733 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2724 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3734 | match syntax.kind() { | 2725 | match syntax.kind() { |
3735 | EXPR_STMT => Some(Stmt::ExprStmt(ExprStmt { syntax })), | 2726 | | EXPR_STMT |
3736 | LET_STMT => Some(Stmt::LetStmt(LetStmt { syntax })), | 2727 | | LET_STMT => Some(Stmt::from_repr(syntax.into_repr())), |
3737 | _ => None, | 2728 | _ => None, |
3738 | } | 2729 | } |
3739 | } | 2730 | } |
3740 | fn syntax(self) -> SyntaxNodeRef<'a> { | 2731 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3741 | match self { | 2732 | fn to_owned(&self) -> TreePtr<Stmt> { TreePtr::cast(self.syntax.to_owned()) } |
3742 | Stmt::ExprStmt(inner) => inner.syntax(), | 2733 | } |
3743 | Stmt::LetStmt(inner) => inner.syntax(), | 2734 | |
2735 | impl Stmt { | ||
2736 | pub fn kind(&self) -> StmtKind { | ||
2737 | match self.syntax.kind() { | ||
2738 | EXPR_STMT => StmtKind::ExprStmt(ExprStmt::cast(&self.syntax).unwrap()), | ||
2739 | LET_STMT => StmtKind::LetStmt(LetStmt::cast(&self.syntax).unwrap()), | ||
2740 | _ => unreachable!(), | ||
3744 | } | 2741 | } |
3745 | } | 2742 | } |
3746 | } | 2743 | } |
3747 | 2744 | ||
3748 | impl<'a> Stmt<'a> {} | 2745 | impl Stmt {} |
3749 | 2746 | ||
3750 | // String | 2747 | // String |
3751 | #[derive(Debug, Clone, Copy,)] | 2748 | #[derive(Debug, PartialEq, Eq, Hash)] |
3752 | pub struct StringNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2749 | #[repr(transparent)] |
3753 | pub(crate) syntax: SyntaxNode<R>, | 2750 | pub struct String { |
3754 | } | 2751 | pub(crate) syntax: SyntaxNode, |
3755 | pub type String<'a> = StringNode<RefRoot<'a>>; | ||
3756 | |||
3757 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<StringNode<R1>> for StringNode<R2> { | ||
3758 | fn eq(&self, other: &StringNode<R1>) -> bool { self.syntax == other.syntax } | ||
3759 | } | 2752 | } |
3760 | impl<R: TreeRoot<RaTypes>> Eq for StringNode<R> {} | 2753 | unsafe impl TransparentNewType for String { |
3761 | impl<R: TreeRoot<RaTypes>> Hash for StringNode<R> { | 2754 | type Repr = rowan::SyntaxNode<RaTypes>; |
3762 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3763 | } | 2755 | } |
3764 | 2756 | ||
3765 | impl<'a> AstNode<'a> for String<'a> { | 2757 | impl AstNode for String { |
3766 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2758 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3767 | match syntax.kind() { | 2759 | match syntax.kind() { |
3768 | STRING => Some(String { syntax }), | 2760 | STRING => Some(String::from_repr(syntax.into_repr())), |
3769 | _ => None, | 2761 | _ => None, |
3770 | } | 2762 | } |
3771 | } | 2763 | } |
3772 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2764 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3773 | } | 2765 | fn to_owned(&self) -> TreePtr<String> { TreePtr::cast(self.syntax.to_owned()) } |
3774 | |||
3775 | impl<R: TreeRoot<RaTypes>> StringNode<R> { | ||
3776 | pub fn borrowed(&self) -> String { | ||
3777 | StringNode { syntax: self.syntax.borrowed() } | ||
3778 | } | ||
3779 | pub fn owned(&self) -> StringNode { | ||
3780 | StringNode { syntax: self.syntax.owned() } | ||
3781 | } | ||
3782 | } | 2766 | } |
3783 | 2767 | ||
3784 | 2768 | ||
3785 | impl<'a> String<'a> {} | 2769 | impl String {} |
3786 | 2770 | ||
3787 | // StructDef | 2771 | // StructDef |
3788 | #[derive(Debug, Clone, Copy,)] | 2772 | #[derive(Debug, PartialEq, Eq, Hash)] |
3789 | pub struct StructDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2773 | #[repr(transparent)] |
3790 | pub(crate) syntax: SyntaxNode<R>, | 2774 | pub struct StructDef { |
2775 | pub(crate) syntax: SyntaxNode, | ||
3791 | } | 2776 | } |
3792 | pub type StructDef<'a> = StructDefNode<RefRoot<'a>>; | 2777 | unsafe impl TransparentNewType for StructDef { |
3793 | 2778 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3794 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<StructDefNode<R1>> for StructDefNode<R2> { | ||
3795 | fn eq(&self, other: &StructDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
3796 | } | ||
3797 | impl<R: TreeRoot<RaTypes>> Eq for StructDefNode<R> {} | ||
3798 | impl<R: TreeRoot<RaTypes>> Hash for StructDefNode<R> { | ||
3799 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3800 | } | 2779 | } |
3801 | 2780 | ||
3802 | impl<'a> AstNode<'a> for StructDef<'a> { | 2781 | impl AstNode for StructDef { |
3803 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2782 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3804 | match syntax.kind() { | 2783 | match syntax.kind() { |
3805 | STRUCT_DEF => Some(StructDef { syntax }), | 2784 | STRUCT_DEF => Some(StructDef::from_repr(syntax.into_repr())), |
3806 | _ => None, | 2785 | _ => None, |
3807 | } | 2786 | } |
3808 | } | 2787 | } |
3809 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2788 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3810 | } | 2789 | fn to_owned(&self) -> TreePtr<StructDef> { TreePtr::cast(self.syntax.to_owned()) } |
3811 | |||
3812 | impl<R: TreeRoot<RaTypes>> StructDefNode<R> { | ||
3813 | pub fn borrowed(&self) -> StructDef { | ||
3814 | StructDefNode { syntax: self.syntax.borrowed() } | ||
3815 | } | ||
3816 | pub fn owned(&self) -> StructDefNode { | ||
3817 | StructDefNode { syntax: self.syntax.owned() } | ||
3818 | } | ||
3819 | } | 2790 | } |
3820 | 2791 | ||
3821 | 2792 | ||
3822 | impl<'a> ast::VisibilityOwner<'a> for StructDef<'a> {} | 2793 | impl ast::VisibilityOwner for StructDef {} |
3823 | impl<'a> ast::NameOwner<'a> for StructDef<'a> {} | 2794 | impl ast::NameOwner for StructDef {} |
3824 | impl<'a> ast::TypeParamsOwner<'a> for StructDef<'a> {} | 2795 | impl ast::TypeParamsOwner for StructDef {} |
3825 | impl<'a> ast::AttrsOwner<'a> for StructDef<'a> {} | 2796 | impl ast::AttrsOwner for StructDef {} |
3826 | impl<'a> ast::DocCommentsOwner<'a> for StructDef<'a> {} | 2797 | impl ast::DocCommentsOwner for StructDef {} |
3827 | impl<'a> StructDef<'a> {} | 2798 | impl StructDef {} |
3828 | 2799 | ||
3829 | // StructLit | 2800 | // StructLit |
3830 | #[derive(Debug, Clone, Copy,)] | 2801 | #[derive(Debug, PartialEq, Eq, Hash)] |
3831 | pub struct StructLitNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2802 | #[repr(transparent)] |
3832 | pub(crate) syntax: SyntaxNode<R>, | 2803 | pub struct StructLit { |
2804 | pub(crate) syntax: SyntaxNode, | ||
3833 | } | 2805 | } |
3834 | pub type StructLit<'a> = StructLitNode<RefRoot<'a>>; | 2806 | unsafe impl TransparentNewType for StructLit { |
3835 | 2807 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3836 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<StructLitNode<R1>> for StructLitNode<R2> { | ||
3837 | fn eq(&self, other: &StructLitNode<R1>) -> bool { self.syntax == other.syntax } | ||
3838 | } | ||
3839 | impl<R: TreeRoot<RaTypes>> Eq for StructLitNode<R> {} | ||
3840 | impl<R: TreeRoot<RaTypes>> Hash for StructLitNode<R> { | ||
3841 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3842 | } | 2808 | } |
3843 | 2809 | ||
3844 | impl<'a> AstNode<'a> for StructLit<'a> { | 2810 | impl AstNode for StructLit { |
3845 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2811 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3846 | match syntax.kind() { | 2812 | match syntax.kind() { |
3847 | STRUCT_LIT => Some(StructLit { syntax }), | 2813 | STRUCT_LIT => Some(StructLit::from_repr(syntax.into_repr())), |
3848 | _ => None, | 2814 | _ => None, |
3849 | } | 2815 | } |
3850 | } | 2816 | } |
3851 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2817 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3852 | } | 2818 | fn to_owned(&self) -> TreePtr<StructLit> { TreePtr::cast(self.syntax.to_owned()) } |
3853 | |||
3854 | impl<R: TreeRoot<RaTypes>> StructLitNode<R> { | ||
3855 | pub fn borrowed(&self) -> StructLit { | ||
3856 | StructLitNode { syntax: self.syntax.borrowed() } | ||
3857 | } | ||
3858 | pub fn owned(&self) -> StructLitNode { | ||
3859 | StructLitNode { syntax: self.syntax.owned() } | ||
3860 | } | ||
3861 | } | 2819 | } |
3862 | 2820 | ||
3863 | 2821 | ||
3864 | impl<'a> StructLit<'a> { | 2822 | impl StructLit { |
3865 | pub fn path(self) -> Option<Path<'a>> { | 2823 | pub fn path(&self) -> Option<&Path> { |
3866 | super::child_opt(self) | 2824 | super::child_opt(self) |
3867 | } | 2825 | } |
3868 | 2826 | ||
3869 | pub fn named_field_list(self) -> Option<NamedFieldList<'a>> { | 2827 | pub fn named_field_list(&self) -> Option<&NamedFieldList> { |
3870 | super::child_opt(self) | 2828 | super::child_opt(self) |
3871 | } | 2829 | } |
3872 | 2830 | ||
3873 | pub fn spread(self) -> Option<Expr<'a>> { | 2831 | pub fn spread(&self) -> Option<&Expr> { |
3874 | super::child_opt(self) | 2832 | super::child_opt(self) |
3875 | } | 2833 | } |
3876 | } | 2834 | } |
3877 | 2835 | ||
3878 | // StructPat | 2836 | // StructPat |
3879 | #[derive(Debug, Clone, Copy,)] | 2837 | #[derive(Debug, PartialEq, Eq, Hash)] |
3880 | pub struct StructPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2838 | #[repr(transparent)] |
3881 | pub(crate) syntax: SyntaxNode<R>, | 2839 | pub struct StructPat { |
3882 | } | 2840 | pub(crate) syntax: SyntaxNode, |
3883 | pub type StructPat<'a> = StructPatNode<RefRoot<'a>>; | ||
3884 | |||
3885 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<StructPatNode<R1>> for StructPatNode<R2> { | ||
3886 | fn eq(&self, other: &StructPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
3887 | } | 2841 | } |
3888 | impl<R: TreeRoot<RaTypes>> Eq for StructPatNode<R> {} | 2842 | unsafe impl TransparentNewType for StructPat { |
3889 | impl<R: TreeRoot<RaTypes>> Hash for StructPatNode<R> { | 2843 | type Repr = rowan::SyntaxNode<RaTypes>; |
3890 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3891 | } | 2844 | } |
3892 | 2845 | ||
3893 | impl<'a> AstNode<'a> for StructPat<'a> { | 2846 | impl AstNode for StructPat { |
3894 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2847 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3895 | match syntax.kind() { | 2848 | match syntax.kind() { |
3896 | STRUCT_PAT => Some(StructPat { syntax }), | 2849 | STRUCT_PAT => Some(StructPat::from_repr(syntax.into_repr())), |
3897 | _ => None, | 2850 | _ => None, |
3898 | } | 2851 | } |
3899 | } | 2852 | } |
3900 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2853 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2854 | fn to_owned(&self) -> TreePtr<StructPat> { TreePtr::cast(self.syntax.to_owned()) } | ||
3901 | } | 2855 | } |
3902 | 2856 | ||
3903 | impl<R: TreeRoot<RaTypes>> StructPatNode<R> { | ||
3904 | pub fn borrowed(&self) -> StructPat { | ||
3905 | StructPatNode { syntax: self.syntax.borrowed() } | ||
3906 | } | ||
3907 | pub fn owned(&self) -> StructPatNode { | ||
3908 | StructPatNode { syntax: self.syntax.owned() } | ||
3909 | } | ||
3910 | } | ||
3911 | 2857 | ||
3912 | 2858 | impl StructPat {} | |
3913 | impl<'a> StructPat<'a> {} | ||
3914 | 2859 | ||
3915 | // TokenTree | 2860 | // TokenTree |
3916 | #[derive(Debug, Clone, Copy,)] | 2861 | #[derive(Debug, PartialEq, Eq, Hash)] |
3917 | pub struct TokenTreeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2862 | #[repr(transparent)] |
3918 | pub(crate) syntax: SyntaxNode<R>, | 2863 | pub struct TokenTree { |
3919 | } | 2864 | pub(crate) syntax: SyntaxNode, |
3920 | pub type TokenTree<'a> = TokenTreeNode<RefRoot<'a>>; | ||
3921 | |||
3922 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TokenTreeNode<R1>> for TokenTreeNode<R2> { | ||
3923 | fn eq(&self, other: &TokenTreeNode<R1>) -> bool { self.syntax == other.syntax } | ||
3924 | } | 2865 | } |
3925 | impl<R: TreeRoot<RaTypes>> Eq for TokenTreeNode<R> {} | 2866 | unsafe impl TransparentNewType for TokenTree { |
3926 | impl<R: TreeRoot<RaTypes>> Hash for TokenTreeNode<R> { | 2867 | type Repr = rowan::SyntaxNode<RaTypes>; |
3927 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3928 | } | 2868 | } |
3929 | 2869 | ||
3930 | impl<'a> AstNode<'a> for TokenTree<'a> { | 2870 | impl AstNode for TokenTree { |
3931 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2871 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3932 | match syntax.kind() { | 2872 | match syntax.kind() { |
3933 | TOKEN_TREE => Some(TokenTree { syntax }), | 2873 | TOKEN_TREE => Some(TokenTree::from_repr(syntax.into_repr())), |
3934 | _ => None, | 2874 | _ => None, |
3935 | } | 2875 | } |
3936 | } | 2876 | } |
3937 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2877 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3938 | } | 2878 | fn to_owned(&self) -> TreePtr<TokenTree> { TreePtr::cast(self.syntax.to_owned()) } |
3939 | |||
3940 | impl<R: TreeRoot<RaTypes>> TokenTreeNode<R> { | ||
3941 | pub fn borrowed(&self) -> TokenTree { | ||
3942 | TokenTreeNode { syntax: self.syntax.borrowed() } | ||
3943 | } | ||
3944 | pub fn owned(&self) -> TokenTreeNode { | ||
3945 | TokenTreeNode { syntax: self.syntax.owned() } | ||
3946 | } | ||
3947 | } | 2879 | } |
3948 | 2880 | ||
3949 | 2881 | ||
3950 | impl<'a> TokenTree<'a> {} | 2882 | impl TokenTree {} |
3951 | 2883 | ||
3952 | // TraitDef | 2884 | // TraitDef |
3953 | #[derive(Debug, Clone, Copy,)] | 2885 | #[derive(Debug, PartialEq, Eq, Hash)] |
3954 | pub struct TraitDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2886 | #[repr(transparent)] |
3955 | pub(crate) syntax: SyntaxNode<R>, | 2887 | pub struct TraitDef { |
2888 | pub(crate) syntax: SyntaxNode, | ||
3956 | } | 2889 | } |
3957 | pub type TraitDef<'a> = TraitDefNode<RefRoot<'a>>; | 2890 | unsafe impl TransparentNewType for TraitDef { |
3958 | 2891 | type Repr = rowan::SyntaxNode<RaTypes>; | |
3959 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TraitDefNode<R1>> for TraitDefNode<R2> { | ||
3960 | fn eq(&self, other: &TraitDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
3961 | } | ||
3962 | impl<R: TreeRoot<RaTypes>> Eq for TraitDefNode<R> {} | ||
3963 | impl<R: TreeRoot<RaTypes>> Hash for TraitDefNode<R> { | ||
3964 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
3965 | } | 2892 | } |
3966 | 2893 | ||
3967 | impl<'a> AstNode<'a> for TraitDef<'a> { | 2894 | impl AstNode for TraitDef { |
3968 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2895 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
3969 | match syntax.kind() { | 2896 | match syntax.kind() { |
3970 | TRAIT_DEF => Some(TraitDef { syntax }), | 2897 | TRAIT_DEF => Some(TraitDef::from_repr(syntax.into_repr())), |
3971 | _ => None, | 2898 | _ => None, |
3972 | } | 2899 | } |
3973 | } | 2900 | } |
3974 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2901 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3975 | } | 2902 | fn to_owned(&self) -> TreePtr<TraitDef> { TreePtr::cast(self.syntax.to_owned()) } |
3976 | |||
3977 | impl<R: TreeRoot<RaTypes>> TraitDefNode<R> { | ||
3978 | pub fn borrowed(&self) -> TraitDef { | ||
3979 | TraitDefNode { syntax: self.syntax.borrowed() } | ||
3980 | } | ||
3981 | pub fn owned(&self) -> TraitDefNode { | ||
3982 | TraitDefNode { syntax: self.syntax.owned() } | ||
3983 | } | ||
3984 | } | 2903 | } |
3985 | 2904 | ||
3986 | 2905 | ||
3987 | impl<'a> ast::VisibilityOwner<'a> for TraitDef<'a> {} | 2906 | impl ast::VisibilityOwner for TraitDef {} |
3988 | impl<'a> ast::NameOwner<'a> for TraitDef<'a> {} | 2907 | impl ast::NameOwner for TraitDef {} |
3989 | impl<'a> ast::AttrsOwner<'a> for TraitDef<'a> {} | 2908 | impl ast::AttrsOwner for TraitDef {} |
3990 | impl<'a> ast::DocCommentsOwner<'a> for TraitDef<'a> {} | 2909 | impl ast::DocCommentsOwner for TraitDef {} |
3991 | impl<'a> TraitDef<'a> {} | 2910 | impl TraitDef {} |
3992 | 2911 | ||
3993 | // TryExpr | 2912 | // TryExpr |
3994 | #[derive(Debug, Clone, Copy,)] | 2913 | #[derive(Debug, PartialEq, Eq, Hash)] |
3995 | pub struct TryExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2914 | #[repr(transparent)] |
3996 | pub(crate) syntax: SyntaxNode<R>, | 2915 | pub struct TryExpr { |
2916 | pub(crate) syntax: SyntaxNode, | ||
3997 | } | 2917 | } |
3998 | pub type TryExpr<'a> = TryExprNode<RefRoot<'a>>; | 2918 | unsafe impl TransparentNewType for TryExpr { |
3999 | 2919 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4000 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TryExprNode<R1>> for TryExprNode<R2> { | ||
4001 | fn eq(&self, other: &TryExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
4002 | } | ||
4003 | impl<R: TreeRoot<RaTypes>> Eq for TryExprNode<R> {} | ||
4004 | impl<R: TreeRoot<RaTypes>> Hash for TryExprNode<R> { | ||
4005 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4006 | } | 2920 | } |
4007 | 2921 | ||
4008 | impl<'a> AstNode<'a> for TryExpr<'a> { | 2922 | impl AstNode for TryExpr { |
4009 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2923 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4010 | match syntax.kind() { | 2924 | match syntax.kind() { |
4011 | TRY_EXPR => Some(TryExpr { syntax }), | 2925 | TRY_EXPR => Some(TryExpr::from_repr(syntax.into_repr())), |
4012 | _ => None, | 2926 | _ => None, |
4013 | } | 2927 | } |
4014 | } | 2928 | } |
4015 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2929 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
2930 | fn to_owned(&self) -> TreePtr<TryExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
4016 | } | 2931 | } |
4017 | 2932 | ||
4018 | impl<R: TreeRoot<RaTypes>> TryExprNode<R> { | ||
4019 | pub fn borrowed(&self) -> TryExpr { | ||
4020 | TryExprNode { syntax: self.syntax.borrowed() } | ||
4021 | } | ||
4022 | pub fn owned(&self) -> TryExprNode { | ||
4023 | TryExprNode { syntax: self.syntax.owned() } | ||
4024 | } | ||
4025 | } | ||
4026 | 2933 | ||
4027 | 2934 | impl TryExpr { | |
4028 | impl<'a> TryExpr<'a> { | 2935 | pub fn expr(&self) -> Option<&Expr> { |
4029 | pub fn expr(self) -> Option<Expr<'a>> { | ||
4030 | super::child_opt(self) | 2936 | super::child_opt(self) |
4031 | } | 2937 | } |
4032 | } | 2938 | } |
4033 | 2939 | ||
4034 | // TupleExpr | 2940 | // TupleExpr |
4035 | #[derive(Debug, Clone, Copy,)] | 2941 | #[derive(Debug, PartialEq, Eq, Hash)] |
4036 | pub struct TupleExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2942 | #[repr(transparent)] |
4037 | pub(crate) syntax: SyntaxNode<R>, | 2943 | pub struct TupleExpr { |
4038 | } | 2944 | pub(crate) syntax: SyntaxNode, |
4039 | pub type TupleExpr<'a> = TupleExprNode<RefRoot<'a>>; | ||
4040 | |||
4041 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TupleExprNode<R1>> for TupleExprNode<R2> { | ||
4042 | fn eq(&self, other: &TupleExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
4043 | } | 2945 | } |
4044 | impl<R: TreeRoot<RaTypes>> Eq for TupleExprNode<R> {} | 2946 | unsafe impl TransparentNewType for TupleExpr { |
4045 | impl<R: TreeRoot<RaTypes>> Hash for TupleExprNode<R> { | 2947 | type Repr = rowan::SyntaxNode<RaTypes>; |
4046 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4047 | } | 2948 | } |
4048 | 2949 | ||
4049 | impl<'a> AstNode<'a> for TupleExpr<'a> { | 2950 | impl AstNode for TupleExpr { |
4050 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2951 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4051 | match syntax.kind() { | 2952 | match syntax.kind() { |
4052 | TUPLE_EXPR => Some(TupleExpr { syntax }), | 2953 | TUPLE_EXPR => Some(TupleExpr::from_repr(syntax.into_repr())), |
4053 | _ => None, | 2954 | _ => None, |
4054 | } | 2955 | } |
4055 | } | 2956 | } |
4056 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2957 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4057 | } | 2958 | fn to_owned(&self) -> TreePtr<TupleExpr> { TreePtr::cast(self.syntax.to_owned()) } |
4058 | |||
4059 | impl<R: TreeRoot<RaTypes>> TupleExprNode<R> { | ||
4060 | pub fn borrowed(&self) -> TupleExpr { | ||
4061 | TupleExprNode { syntax: self.syntax.borrowed() } | ||
4062 | } | ||
4063 | pub fn owned(&self) -> TupleExprNode { | ||
4064 | TupleExprNode { syntax: self.syntax.owned() } | ||
4065 | } | ||
4066 | } | 2959 | } |
4067 | 2960 | ||
4068 | 2961 | ||
4069 | impl<'a> TupleExpr<'a> {} | 2962 | impl TupleExpr {} |
4070 | 2963 | ||
4071 | // TuplePat | 2964 | // TuplePat |
4072 | #[derive(Debug, Clone, Copy,)] | 2965 | #[derive(Debug, PartialEq, Eq, Hash)] |
4073 | pub struct TuplePatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2966 | #[repr(transparent)] |
4074 | pub(crate) syntax: SyntaxNode<R>, | 2967 | pub struct TuplePat { |
2968 | pub(crate) syntax: SyntaxNode, | ||
4075 | } | 2969 | } |
4076 | pub type TuplePat<'a> = TuplePatNode<RefRoot<'a>>; | 2970 | unsafe impl TransparentNewType for TuplePat { |
4077 | 2971 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4078 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TuplePatNode<R1>> for TuplePatNode<R2> { | ||
4079 | fn eq(&self, other: &TuplePatNode<R1>) -> bool { self.syntax == other.syntax } | ||
4080 | } | ||
4081 | impl<R: TreeRoot<RaTypes>> Eq for TuplePatNode<R> {} | ||
4082 | impl<R: TreeRoot<RaTypes>> Hash for TuplePatNode<R> { | ||
4083 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4084 | } | 2972 | } |
4085 | 2973 | ||
4086 | impl<'a> AstNode<'a> for TuplePat<'a> { | 2974 | impl AstNode for TuplePat { |
4087 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2975 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4088 | match syntax.kind() { | 2976 | match syntax.kind() { |
4089 | TUPLE_PAT => Some(TuplePat { syntax }), | 2977 | TUPLE_PAT => Some(TuplePat::from_repr(syntax.into_repr())), |
4090 | _ => None, | 2978 | _ => None, |
4091 | } | 2979 | } |
4092 | } | 2980 | } |
4093 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 2981 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4094 | } | 2982 | fn to_owned(&self) -> TreePtr<TuplePat> { TreePtr::cast(self.syntax.to_owned()) } |
4095 | |||
4096 | impl<R: TreeRoot<RaTypes>> TuplePatNode<R> { | ||
4097 | pub fn borrowed(&self) -> TuplePat { | ||
4098 | TuplePatNode { syntax: self.syntax.borrowed() } | ||
4099 | } | ||
4100 | pub fn owned(&self) -> TuplePatNode { | ||
4101 | TuplePatNode { syntax: self.syntax.owned() } | ||
4102 | } | ||
4103 | } | 2983 | } |
4104 | 2984 | ||
4105 | 2985 | ||
4106 | impl<'a> TuplePat<'a> {} | 2986 | impl TuplePat {} |
4107 | 2987 | ||
4108 | // TupleStructPat | 2988 | // TupleStructPat |
4109 | #[derive(Debug, Clone, Copy,)] | 2989 | #[derive(Debug, PartialEq, Eq, Hash)] |
4110 | pub struct TupleStructPatNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 2990 | #[repr(transparent)] |
4111 | pub(crate) syntax: SyntaxNode<R>, | 2991 | pub struct TupleStructPat { |
2992 | pub(crate) syntax: SyntaxNode, | ||
4112 | } | 2993 | } |
4113 | pub type TupleStructPat<'a> = TupleStructPatNode<RefRoot<'a>>; | 2994 | unsafe impl TransparentNewType for TupleStructPat { |
4114 | 2995 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4115 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TupleStructPatNode<R1>> for TupleStructPatNode<R2> { | ||
4116 | fn eq(&self, other: &TupleStructPatNode<R1>) -> bool { self.syntax == other.syntax } | ||
4117 | } | ||
4118 | impl<R: TreeRoot<RaTypes>> Eq for TupleStructPatNode<R> {} | ||
4119 | impl<R: TreeRoot<RaTypes>> Hash for TupleStructPatNode<R> { | ||
4120 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4121 | } | 2996 | } |
4122 | 2997 | ||
4123 | impl<'a> AstNode<'a> for TupleStructPat<'a> { | 2998 | impl AstNode for TupleStructPat { |
4124 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 2999 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4125 | match syntax.kind() { | 3000 | match syntax.kind() { |
4126 | TUPLE_STRUCT_PAT => Some(TupleStructPat { syntax }), | 3001 | TUPLE_STRUCT_PAT => Some(TupleStructPat::from_repr(syntax.into_repr())), |
4127 | _ => None, | 3002 | _ => None, |
4128 | } | 3003 | } |
4129 | } | 3004 | } |
4130 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3005 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4131 | } | 3006 | fn to_owned(&self) -> TreePtr<TupleStructPat> { TreePtr::cast(self.syntax.to_owned()) } |
4132 | |||
4133 | impl<R: TreeRoot<RaTypes>> TupleStructPatNode<R> { | ||
4134 | pub fn borrowed(&self) -> TupleStructPat { | ||
4135 | TupleStructPatNode { syntax: self.syntax.borrowed() } | ||
4136 | } | ||
4137 | pub fn owned(&self) -> TupleStructPatNode { | ||
4138 | TupleStructPatNode { syntax: self.syntax.owned() } | ||
4139 | } | ||
4140 | } | 3007 | } |
4141 | 3008 | ||
4142 | 3009 | ||
4143 | impl<'a> TupleStructPat<'a> { | 3010 | impl TupleStructPat { |
4144 | pub fn args(self) -> impl Iterator<Item = Pat<'a>> + 'a { | 3011 | pub fn args(&self) -> impl Iterator<Item = &Pat> { |
4145 | super::children(self) | 3012 | super::children(self) |
4146 | } | 3013 | } |
4147 | 3014 | ||
4148 | pub fn path(self) -> Option<Path<'a>> { | 3015 | pub fn path(&self) -> Option<&Path> { |
4149 | super::child_opt(self) | 3016 | super::child_opt(self) |
4150 | } | 3017 | } |
4151 | } | 3018 | } |
4152 | 3019 | ||
4153 | // TupleType | 3020 | // TupleType |
4154 | #[derive(Debug, Clone, Copy,)] | 3021 | #[derive(Debug, PartialEq, Eq, Hash)] |
4155 | pub struct TupleTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3022 | #[repr(transparent)] |
4156 | pub(crate) syntax: SyntaxNode<R>, | 3023 | pub struct TupleType { |
4157 | } | 3024 | pub(crate) syntax: SyntaxNode, |
4158 | pub type TupleType<'a> = TupleTypeNode<RefRoot<'a>>; | ||
4159 | |||
4160 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TupleTypeNode<R1>> for TupleTypeNode<R2> { | ||
4161 | fn eq(&self, other: &TupleTypeNode<R1>) -> bool { self.syntax == other.syntax } | ||
4162 | } | 3025 | } |
4163 | impl<R: TreeRoot<RaTypes>> Eq for TupleTypeNode<R> {} | 3026 | unsafe impl TransparentNewType for TupleType { |
4164 | impl<R: TreeRoot<RaTypes>> Hash for TupleTypeNode<R> { | 3027 | type Repr = rowan::SyntaxNode<RaTypes>; |
4165 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4166 | } | 3028 | } |
4167 | 3029 | ||
4168 | impl<'a> AstNode<'a> for TupleType<'a> { | 3030 | impl AstNode for TupleType { |
4169 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3031 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4170 | match syntax.kind() { | 3032 | match syntax.kind() { |
4171 | TUPLE_TYPE => Some(TupleType { syntax }), | 3033 | TUPLE_TYPE => Some(TupleType::from_repr(syntax.into_repr())), |
4172 | _ => None, | 3034 | _ => None, |
4173 | } | 3035 | } |
4174 | } | 3036 | } |
4175 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3037 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3038 | fn to_owned(&self) -> TreePtr<TupleType> { TreePtr::cast(self.syntax.to_owned()) } | ||
4176 | } | 3039 | } |
4177 | 3040 | ||
4178 | impl<R: TreeRoot<RaTypes>> TupleTypeNode<R> { | ||
4179 | pub fn borrowed(&self) -> TupleType { | ||
4180 | TupleTypeNode { syntax: self.syntax.borrowed() } | ||
4181 | } | ||
4182 | pub fn owned(&self) -> TupleTypeNode { | ||
4183 | TupleTypeNode { syntax: self.syntax.owned() } | ||
4184 | } | ||
4185 | } | ||
4186 | 3041 | ||
4187 | 3042 | impl TupleType { | |
4188 | impl<'a> TupleType<'a> { | 3043 | pub fn fields(&self) -> impl Iterator<Item = &TypeRef> { |
4189 | pub fn fields(self) -> impl Iterator<Item = TypeRef<'a>> + 'a { | ||
4190 | super::children(self) | 3044 | super::children(self) |
4191 | } | 3045 | } |
4192 | } | 3046 | } |
4193 | 3047 | ||
4194 | // TypeDef | 3048 | // TypeDef |
4195 | #[derive(Debug, Clone, Copy,)] | 3049 | #[derive(Debug, PartialEq, Eq, Hash)] |
4196 | pub struct TypeDefNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3050 | #[repr(transparent)] |
4197 | pub(crate) syntax: SyntaxNode<R>, | 3051 | pub struct TypeDef { |
4198 | } | 3052 | pub(crate) syntax: SyntaxNode, |
4199 | pub type TypeDef<'a> = TypeDefNode<RefRoot<'a>>; | ||
4200 | |||
4201 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TypeDefNode<R1>> for TypeDefNode<R2> { | ||
4202 | fn eq(&self, other: &TypeDefNode<R1>) -> bool { self.syntax == other.syntax } | ||
4203 | } | 3053 | } |
4204 | impl<R: TreeRoot<RaTypes>> Eq for TypeDefNode<R> {} | 3054 | unsafe impl TransparentNewType for TypeDef { |
4205 | impl<R: TreeRoot<RaTypes>> Hash for TypeDefNode<R> { | 3055 | type Repr = rowan::SyntaxNode<RaTypes>; |
4206 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4207 | } | 3056 | } |
4208 | 3057 | ||
4209 | impl<'a> AstNode<'a> for TypeDef<'a> { | 3058 | impl AstNode for TypeDef { |
4210 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3059 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4211 | match syntax.kind() { | 3060 | match syntax.kind() { |
4212 | TYPE_DEF => Some(TypeDef { syntax }), | 3061 | TYPE_DEF => Some(TypeDef::from_repr(syntax.into_repr())), |
4213 | _ => None, | 3062 | _ => None, |
4214 | } | 3063 | } |
4215 | } | 3064 | } |
4216 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3065 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4217 | } | 3066 | fn to_owned(&self) -> TreePtr<TypeDef> { TreePtr::cast(self.syntax.to_owned()) } |
4218 | |||
4219 | impl<R: TreeRoot<RaTypes>> TypeDefNode<R> { | ||
4220 | pub fn borrowed(&self) -> TypeDef { | ||
4221 | TypeDefNode { syntax: self.syntax.borrowed() } | ||
4222 | } | ||
4223 | pub fn owned(&self) -> TypeDefNode { | ||
4224 | TypeDefNode { syntax: self.syntax.owned() } | ||
4225 | } | ||
4226 | } | 3067 | } |
4227 | 3068 | ||
4228 | 3069 | ||
4229 | impl<'a> ast::VisibilityOwner<'a> for TypeDef<'a> {} | 3070 | impl ast::VisibilityOwner for TypeDef {} |
4230 | impl<'a> ast::NameOwner<'a> for TypeDef<'a> {} | 3071 | impl ast::NameOwner for TypeDef {} |
4231 | impl<'a> ast::TypeParamsOwner<'a> for TypeDef<'a> {} | 3072 | impl ast::TypeParamsOwner for TypeDef {} |
4232 | impl<'a> ast::AttrsOwner<'a> for TypeDef<'a> {} | 3073 | impl ast::AttrsOwner for TypeDef {} |
4233 | impl<'a> ast::DocCommentsOwner<'a> for TypeDef<'a> {} | 3074 | impl ast::DocCommentsOwner for TypeDef {} |
4234 | impl<'a> TypeDef<'a> {} | 3075 | impl TypeDef {} |
4235 | 3076 | ||
4236 | // TypeParam | 3077 | // TypeParam |
4237 | #[derive(Debug, Clone, Copy,)] | 3078 | #[derive(Debug, PartialEq, Eq, Hash)] |
4238 | pub struct TypeParamNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3079 | #[repr(transparent)] |
4239 | pub(crate) syntax: SyntaxNode<R>, | 3080 | pub struct TypeParam { |
3081 | pub(crate) syntax: SyntaxNode, | ||
4240 | } | 3082 | } |
4241 | pub type TypeParam<'a> = TypeParamNode<RefRoot<'a>>; | 3083 | unsafe impl TransparentNewType for TypeParam { |
4242 | 3084 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4243 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TypeParamNode<R1>> for TypeParamNode<R2> { | ||
4244 | fn eq(&self, other: &TypeParamNode<R1>) -> bool { self.syntax == other.syntax } | ||
4245 | } | ||
4246 | impl<R: TreeRoot<RaTypes>> Eq for TypeParamNode<R> {} | ||
4247 | impl<R: TreeRoot<RaTypes>> Hash for TypeParamNode<R> { | ||
4248 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4249 | } | 3085 | } |
4250 | 3086 | ||
4251 | impl<'a> AstNode<'a> for TypeParam<'a> { | 3087 | impl AstNode for TypeParam { |
4252 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3088 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4253 | match syntax.kind() { | 3089 | match syntax.kind() { |
4254 | TYPE_PARAM => Some(TypeParam { syntax }), | 3090 | TYPE_PARAM => Some(TypeParam::from_repr(syntax.into_repr())), |
4255 | _ => None, | 3091 | _ => None, |
4256 | } | 3092 | } |
4257 | } | 3093 | } |
4258 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3094 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4259 | } | 3095 | fn to_owned(&self) -> TreePtr<TypeParam> { TreePtr::cast(self.syntax.to_owned()) } |
4260 | |||
4261 | impl<R: TreeRoot<RaTypes>> TypeParamNode<R> { | ||
4262 | pub fn borrowed(&self) -> TypeParam { | ||
4263 | TypeParamNode { syntax: self.syntax.borrowed() } | ||
4264 | } | ||
4265 | pub fn owned(&self) -> TypeParamNode { | ||
4266 | TypeParamNode { syntax: self.syntax.owned() } | ||
4267 | } | ||
4268 | } | 3096 | } |
4269 | 3097 | ||
4270 | 3098 | ||
4271 | impl<'a> ast::NameOwner<'a> for TypeParam<'a> {} | 3099 | impl ast::NameOwner for TypeParam {} |
4272 | impl<'a> TypeParam<'a> {} | 3100 | impl TypeParam {} |
4273 | 3101 | ||
4274 | // TypeParamList | 3102 | // TypeParamList |
4275 | #[derive(Debug, Clone, Copy,)] | 3103 | #[derive(Debug, PartialEq, Eq, Hash)] |
4276 | pub struct TypeParamListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3104 | #[repr(transparent)] |
4277 | pub(crate) syntax: SyntaxNode<R>, | 3105 | pub struct TypeParamList { |
3106 | pub(crate) syntax: SyntaxNode, | ||
4278 | } | 3107 | } |
4279 | pub type TypeParamList<'a> = TypeParamListNode<RefRoot<'a>>; | 3108 | unsafe impl TransparentNewType for TypeParamList { |
4280 | 3109 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4281 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<TypeParamListNode<R1>> for TypeParamListNode<R2> { | ||
4282 | fn eq(&self, other: &TypeParamListNode<R1>) -> bool { self.syntax == other.syntax } | ||
4283 | } | ||
4284 | impl<R: TreeRoot<RaTypes>> Eq for TypeParamListNode<R> {} | ||
4285 | impl<R: TreeRoot<RaTypes>> Hash for TypeParamListNode<R> { | ||
4286 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4287 | } | 3110 | } |
4288 | 3111 | ||
4289 | impl<'a> AstNode<'a> for TypeParamList<'a> { | 3112 | impl AstNode for TypeParamList { |
4290 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3113 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4291 | match syntax.kind() { | 3114 | match syntax.kind() { |
4292 | TYPE_PARAM_LIST => Some(TypeParamList { syntax }), | 3115 | TYPE_PARAM_LIST => Some(TypeParamList::from_repr(syntax.into_repr())), |
4293 | _ => None, | 3116 | _ => None, |
4294 | } | 3117 | } |
4295 | } | 3118 | } |
4296 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3119 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3120 | fn to_owned(&self) -> TreePtr<TypeParamList> { TreePtr::cast(self.syntax.to_owned()) } | ||
4297 | } | 3121 | } |
4298 | 3122 | ||
4299 | impl<R: TreeRoot<RaTypes>> TypeParamListNode<R> { | ||
4300 | pub fn borrowed(&self) -> TypeParamList { | ||
4301 | TypeParamListNode { syntax: self.syntax.borrowed() } | ||
4302 | } | ||
4303 | pub fn owned(&self) -> TypeParamListNode { | ||
4304 | TypeParamListNode { syntax: self.syntax.owned() } | ||
4305 | } | ||
4306 | } | ||
4307 | 3123 | ||
4308 | 3124 | impl TypeParamList { | |
4309 | impl<'a> TypeParamList<'a> { | 3125 | pub fn type_params(&self) -> impl Iterator<Item = &TypeParam> { |
4310 | pub fn type_params(self) -> impl Iterator<Item = TypeParam<'a>> + 'a { | ||
4311 | super::children(self) | 3126 | super::children(self) |
4312 | } | 3127 | } |
4313 | 3128 | ||
4314 | pub fn lifetime_params(self) -> impl Iterator<Item = LifetimeParam<'a>> + 'a { | 3129 | pub fn lifetime_params(&self) -> impl Iterator<Item = &LifetimeParam> { |
4315 | super::children(self) | 3130 | super::children(self) |
4316 | } | 3131 | } |
4317 | } | 3132 | } |
4318 | 3133 | ||
4319 | // TypeRef | 3134 | // TypeRef |
4320 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | 3135 | #[derive(Debug, PartialEq, Eq, Hash)] |
4321 | pub enum TypeRef<'a> { | 3136 | #[repr(transparent)] |
4322 | ParenType(ParenType<'a>), | 3137 | pub struct TypeRef { |
4323 | TupleType(TupleType<'a>), | 3138 | pub(crate) syntax: SyntaxNode, |
4324 | NeverType(NeverType<'a>), | 3139 | } |
4325 | PathType(PathType<'a>), | 3140 | unsafe impl TransparentNewType for TypeRef { |
4326 | PointerType(PointerType<'a>), | 3141 | type Repr = rowan::SyntaxNode<RaTypes>; |
4327 | ArrayType(ArrayType<'a>), | ||
4328 | SliceType(SliceType<'a>), | ||
4329 | ReferenceType(ReferenceType<'a>), | ||
4330 | PlaceholderType(PlaceholderType<'a>), | ||
4331 | FnPointerType(FnPointerType<'a>), | ||
4332 | ForType(ForType<'a>), | ||
4333 | ImplTraitType(ImplTraitType<'a>), | ||
4334 | DynTraitType(DynTraitType<'a>), | ||
4335 | } | ||
4336 | |||
4337 | impl<'a> AstNode<'a> for TypeRef<'a> { | ||
4338 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | ||
4339 | match syntax.kind() { | ||
4340 | PAREN_TYPE => Some(TypeRef::ParenType(ParenType { syntax })), | ||
4341 | TUPLE_TYPE => Some(TypeRef::TupleType(TupleType { syntax })), | ||
4342 | NEVER_TYPE => Some(TypeRef::NeverType(NeverType { syntax })), | ||
4343 | PATH_TYPE => Some(TypeRef::PathType(PathType { syntax })), | ||
4344 | POINTER_TYPE => Some(TypeRef::PointerType(PointerType { syntax })), | ||
4345 | ARRAY_TYPE => Some(TypeRef::ArrayType(ArrayType { syntax })), | ||
4346 | SLICE_TYPE => Some(TypeRef::SliceType(SliceType { syntax })), | ||
4347 | REFERENCE_TYPE => Some(TypeRef::ReferenceType(ReferenceType { syntax })), | ||
4348 | PLACEHOLDER_TYPE => Some(TypeRef::PlaceholderType(PlaceholderType { syntax })), | ||
4349 | FN_POINTER_TYPE => Some(TypeRef::FnPointerType(FnPointerType { syntax })), | ||
4350 | FOR_TYPE => Some(TypeRef::ForType(ForType { syntax })), | ||
4351 | IMPL_TRAIT_TYPE => Some(TypeRef::ImplTraitType(ImplTraitType { syntax })), | ||
4352 | DYN_TRAIT_TYPE => Some(TypeRef::DynTraitType(DynTraitType { syntax })), | ||
4353 | _ => None, | ||
4354 | } | ||
4355 | } | ||
4356 | fn syntax(self) -> SyntaxNodeRef<'a> { | ||
4357 | match self { | ||
4358 | TypeRef::ParenType(inner) => inner.syntax(), | ||
4359 | TypeRef::TupleType(inner) => inner.syntax(), | ||
4360 | TypeRef::NeverType(inner) => inner.syntax(), | ||
4361 | TypeRef::PathType(inner) => inner.syntax(), | ||
4362 | TypeRef::PointerType(inner) => inner.syntax(), | ||
4363 | TypeRef::ArrayType(inner) => inner.syntax(), | ||
4364 | TypeRef::SliceType(inner) => inner.syntax(), | ||
4365 | TypeRef::ReferenceType(inner) => inner.syntax(), | ||
4366 | TypeRef::PlaceholderType(inner) => inner.syntax(), | ||
4367 | TypeRef::FnPointerType(inner) => inner.syntax(), | ||
4368 | TypeRef::ForType(inner) => inner.syntax(), | ||
4369 | TypeRef::ImplTraitType(inner) => inner.syntax(), | ||
4370 | TypeRef::DynTraitType(inner) => inner.syntax(), | ||
4371 | } | ||
4372 | } | ||
4373 | } | 3142 | } |
4374 | 3143 | ||
4375 | impl<'a> TypeRef<'a> {} | 3144 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
3145 | pub enum TypeRefKind<'a> { | ||
3146 | ParenType(&'a ParenType), | ||
3147 | TupleType(&'a TupleType), | ||
3148 | NeverType(&'a NeverType), | ||
3149 | PathType(&'a PathType), | ||
3150 | PointerType(&'a PointerType), | ||
3151 | ArrayType(&'a ArrayType), | ||
3152 | SliceType(&'a SliceType), | ||
3153 | ReferenceType(&'a ReferenceType), | ||
3154 | PlaceholderType(&'a PlaceholderType), | ||
3155 | FnPointerType(&'a FnPointerType), | ||
3156 | ForType(&'a ForType), | ||
3157 | ImplTraitType(&'a ImplTraitType), | ||
3158 | DynTraitType(&'a DynTraitType), | ||
3159 | } | ||
3160 | |||
3161 | impl AstNode for TypeRef { | ||
3162 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { | ||
3163 | match syntax.kind() { | ||
3164 | | PAREN_TYPE | ||
3165 | | TUPLE_TYPE | ||
3166 | | NEVER_TYPE | ||
3167 | | PATH_TYPE | ||
3168 | | POINTER_TYPE | ||
3169 | | ARRAY_TYPE | ||
3170 | | SLICE_TYPE | ||
3171 | | REFERENCE_TYPE | ||
3172 | | PLACEHOLDER_TYPE | ||
3173 | | FN_POINTER_TYPE | ||
3174 | | FOR_TYPE | ||
3175 | | IMPL_TRAIT_TYPE | ||
3176 | | DYN_TRAIT_TYPE => Some(TypeRef::from_repr(syntax.into_repr())), | ||
3177 | _ => None, | ||
3178 | } | ||
3179 | } | ||
3180 | fn syntax(&self) -> &SyntaxNode { &self.syntax } | ||
3181 | fn to_owned(&self) -> TreePtr<TypeRef> { TreePtr::cast(self.syntax.to_owned()) } | ||
3182 | } | ||
3183 | |||
3184 | impl TypeRef { | ||
3185 | pub fn kind(&self) -> TypeRefKind { | ||
3186 | match self.syntax.kind() { | ||
3187 | PAREN_TYPE => TypeRefKind::ParenType(ParenType::cast(&self.syntax).unwrap()), | ||
3188 | TUPLE_TYPE => TypeRefKind::TupleType(TupleType::cast(&self.syntax).unwrap()), | ||
3189 | NEVER_TYPE => TypeRefKind::NeverType(NeverType::cast(&self.syntax).unwrap()), | ||
3190 | PATH_TYPE => TypeRefKind::PathType(PathType::cast(&self.syntax).unwrap()), | ||
3191 | POINTER_TYPE => TypeRefKind::PointerType(PointerType::cast(&self.syntax).unwrap()), | ||
3192 | ARRAY_TYPE => TypeRefKind::ArrayType(ArrayType::cast(&self.syntax).unwrap()), | ||
3193 | SLICE_TYPE => TypeRefKind::SliceType(SliceType::cast(&self.syntax).unwrap()), | ||
3194 | REFERENCE_TYPE => TypeRefKind::ReferenceType(ReferenceType::cast(&self.syntax).unwrap()), | ||
3195 | PLACEHOLDER_TYPE => TypeRefKind::PlaceholderType(PlaceholderType::cast(&self.syntax).unwrap()), | ||
3196 | FN_POINTER_TYPE => TypeRefKind::FnPointerType(FnPointerType::cast(&self.syntax).unwrap()), | ||
3197 | FOR_TYPE => TypeRefKind::ForType(ForType::cast(&self.syntax).unwrap()), | ||
3198 | IMPL_TRAIT_TYPE => TypeRefKind::ImplTraitType(ImplTraitType::cast(&self.syntax).unwrap()), | ||
3199 | DYN_TRAIT_TYPE => TypeRefKind::DynTraitType(DynTraitType::cast(&self.syntax).unwrap()), | ||
3200 | _ => unreachable!(), | ||
3201 | } | ||
3202 | } | ||
3203 | } | ||
3204 | |||
3205 | impl TypeRef {} | ||
4376 | 3206 | ||
4377 | // UseItem | 3207 | // UseItem |
4378 | #[derive(Debug, Clone, Copy,)] | 3208 | #[derive(Debug, PartialEq, Eq, Hash)] |
4379 | pub struct UseItemNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3209 | #[repr(transparent)] |
4380 | pub(crate) syntax: SyntaxNode<R>, | 3210 | pub struct UseItem { |
3211 | pub(crate) syntax: SyntaxNode, | ||
4381 | } | 3212 | } |
4382 | pub type UseItem<'a> = UseItemNode<RefRoot<'a>>; | 3213 | unsafe impl TransparentNewType for UseItem { |
4383 | 3214 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4384 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<UseItemNode<R1>> for UseItemNode<R2> { | ||
4385 | fn eq(&self, other: &UseItemNode<R1>) -> bool { self.syntax == other.syntax } | ||
4386 | } | ||
4387 | impl<R: TreeRoot<RaTypes>> Eq for UseItemNode<R> {} | ||
4388 | impl<R: TreeRoot<RaTypes>> Hash for UseItemNode<R> { | ||
4389 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4390 | } | 3215 | } |
4391 | 3216 | ||
4392 | impl<'a> AstNode<'a> for UseItem<'a> { | 3217 | impl AstNode for UseItem { |
4393 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3218 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4394 | match syntax.kind() { | 3219 | match syntax.kind() { |
4395 | USE_ITEM => Some(UseItem { syntax }), | 3220 | USE_ITEM => Some(UseItem::from_repr(syntax.into_repr())), |
4396 | _ => None, | 3221 | _ => None, |
4397 | } | 3222 | } |
4398 | } | 3223 | } |
4399 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3224 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4400 | } | 3225 | fn to_owned(&self) -> TreePtr<UseItem> { TreePtr::cast(self.syntax.to_owned()) } |
4401 | |||
4402 | impl<R: TreeRoot<RaTypes>> UseItemNode<R> { | ||
4403 | pub fn borrowed(&self) -> UseItem { | ||
4404 | UseItemNode { syntax: self.syntax.borrowed() } | ||
4405 | } | ||
4406 | pub fn owned(&self) -> UseItemNode { | ||
4407 | UseItemNode { syntax: self.syntax.owned() } | ||
4408 | } | ||
4409 | } | 3226 | } |
4410 | 3227 | ||
4411 | 3228 | ||
4412 | impl<'a> UseItem<'a> { | 3229 | impl UseItem { |
4413 | pub fn use_tree(self) -> Option<UseTree<'a>> { | 3230 | pub fn use_tree(&self) -> Option<&UseTree> { |
4414 | super::child_opt(self) | 3231 | super::child_opt(self) |
4415 | } | 3232 | } |
4416 | } | 3233 | } |
4417 | 3234 | ||
4418 | // UseTree | 3235 | // UseTree |
4419 | #[derive(Debug, Clone, Copy,)] | 3236 | #[derive(Debug, PartialEq, Eq, Hash)] |
4420 | pub struct UseTreeNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3237 | #[repr(transparent)] |
4421 | pub(crate) syntax: SyntaxNode<R>, | 3238 | pub struct UseTree { |
3239 | pub(crate) syntax: SyntaxNode, | ||
4422 | } | 3240 | } |
4423 | pub type UseTree<'a> = UseTreeNode<RefRoot<'a>>; | 3241 | unsafe impl TransparentNewType for UseTree { |
4424 | 3242 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4425 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<UseTreeNode<R1>> for UseTreeNode<R2> { | ||
4426 | fn eq(&self, other: &UseTreeNode<R1>) -> bool { self.syntax == other.syntax } | ||
4427 | } | ||
4428 | impl<R: TreeRoot<RaTypes>> Eq for UseTreeNode<R> {} | ||
4429 | impl<R: TreeRoot<RaTypes>> Hash for UseTreeNode<R> { | ||
4430 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4431 | } | 3243 | } |
4432 | 3244 | ||
4433 | impl<'a> AstNode<'a> for UseTree<'a> { | 3245 | impl AstNode for UseTree { |
4434 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3246 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4435 | match syntax.kind() { | 3247 | match syntax.kind() { |
4436 | USE_TREE => Some(UseTree { syntax }), | 3248 | USE_TREE => Some(UseTree::from_repr(syntax.into_repr())), |
4437 | _ => None, | 3249 | _ => None, |
4438 | } | 3250 | } |
4439 | } | 3251 | } |
4440 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3252 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3253 | fn to_owned(&self) -> TreePtr<UseTree> { TreePtr::cast(self.syntax.to_owned()) } | ||
4441 | } | 3254 | } |
4442 | 3255 | ||
4443 | impl<R: TreeRoot<RaTypes>> UseTreeNode<R> { | ||
4444 | pub fn borrowed(&self) -> UseTree { | ||
4445 | UseTreeNode { syntax: self.syntax.borrowed() } | ||
4446 | } | ||
4447 | pub fn owned(&self) -> UseTreeNode { | ||
4448 | UseTreeNode { syntax: self.syntax.owned() } | ||
4449 | } | ||
4450 | } | ||
4451 | 3256 | ||
4452 | 3257 | impl UseTree { | |
4453 | impl<'a> UseTree<'a> { | 3258 | pub fn path(&self) -> Option<&Path> { |
4454 | pub fn path(self) -> Option<Path<'a>> { | ||
4455 | super::child_opt(self) | 3259 | super::child_opt(self) |
4456 | } | 3260 | } |
4457 | 3261 | ||
4458 | pub fn use_tree_list(self) -> Option<UseTreeList<'a>> { | 3262 | pub fn use_tree_list(&self) -> Option<&UseTreeList> { |
4459 | super::child_opt(self) | 3263 | super::child_opt(self) |
4460 | } | 3264 | } |
4461 | } | 3265 | } |
4462 | 3266 | ||
4463 | // UseTreeList | 3267 | // UseTreeList |
4464 | #[derive(Debug, Clone, Copy,)] | 3268 | #[derive(Debug, PartialEq, Eq, Hash)] |
4465 | pub struct UseTreeListNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3269 | #[repr(transparent)] |
4466 | pub(crate) syntax: SyntaxNode<R>, | 3270 | pub struct UseTreeList { |
4467 | } | 3271 | pub(crate) syntax: SyntaxNode, |
4468 | pub type UseTreeList<'a> = UseTreeListNode<RefRoot<'a>>; | ||
4469 | |||
4470 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<UseTreeListNode<R1>> for UseTreeListNode<R2> { | ||
4471 | fn eq(&self, other: &UseTreeListNode<R1>) -> bool { self.syntax == other.syntax } | ||
4472 | } | 3272 | } |
4473 | impl<R: TreeRoot<RaTypes>> Eq for UseTreeListNode<R> {} | 3273 | unsafe impl TransparentNewType for UseTreeList { |
4474 | impl<R: TreeRoot<RaTypes>> Hash for UseTreeListNode<R> { | 3274 | type Repr = rowan::SyntaxNode<RaTypes>; |
4475 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4476 | } | 3275 | } |
4477 | 3276 | ||
4478 | impl<'a> AstNode<'a> for UseTreeList<'a> { | 3277 | impl AstNode for UseTreeList { |
4479 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3278 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4480 | match syntax.kind() { | 3279 | match syntax.kind() { |
4481 | USE_TREE_LIST => Some(UseTreeList { syntax }), | 3280 | USE_TREE_LIST => Some(UseTreeList::from_repr(syntax.into_repr())), |
4482 | _ => None, | 3281 | _ => None, |
4483 | } | 3282 | } |
4484 | } | 3283 | } |
4485 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3284 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4486 | } | 3285 | fn to_owned(&self) -> TreePtr<UseTreeList> { TreePtr::cast(self.syntax.to_owned()) } |
4487 | |||
4488 | impl<R: TreeRoot<RaTypes>> UseTreeListNode<R> { | ||
4489 | pub fn borrowed(&self) -> UseTreeList { | ||
4490 | UseTreeListNode { syntax: self.syntax.borrowed() } | ||
4491 | } | ||
4492 | pub fn owned(&self) -> UseTreeListNode { | ||
4493 | UseTreeListNode { syntax: self.syntax.owned() } | ||
4494 | } | ||
4495 | } | 3286 | } |
4496 | 3287 | ||
4497 | 3288 | ||
4498 | impl<'a> UseTreeList<'a> { | 3289 | impl UseTreeList { |
4499 | pub fn use_trees(self) -> impl Iterator<Item = UseTree<'a>> + 'a { | 3290 | pub fn use_trees(&self) -> impl Iterator<Item = &UseTree> { |
4500 | super::children(self) | 3291 | super::children(self) |
4501 | } | 3292 | } |
4502 | } | 3293 | } |
4503 | 3294 | ||
4504 | // Visibility | 3295 | // Visibility |
4505 | #[derive(Debug, Clone, Copy,)] | 3296 | #[derive(Debug, PartialEq, Eq, Hash)] |
4506 | pub struct VisibilityNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3297 | #[repr(transparent)] |
4507 | pub(crate) syntax: SyntaxNode<R>, | 3298 | pub struct Visibility { |
3299 | pub(crate) syntax: SyntaxNode, | ||
4508 | } | 3300 | } |
4509 | pub type Visibility<'a> = VisibilityNode<RefRoot<'a>>; | 3301 | unsafe impl TransparentNewType for Visibility { |
4510 | 3302 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4511 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<VisibilityNode<R1>> for VisibilityNode<R2> { | ||
4512 | fn eq(&self, other: &VisibilityNode<R1>) -> bool { self.syntax == other.syntax } | ||
4513 | } | ||
4514 | impl<R: TreeRoot<RaTypes>> Eq for VisibilityNode<R> {} | ||
4515 | impl<R: TreeRoot<RaTypes>> Hash for VisibilityNode<R> { | ||
4516 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4517 | } | 3303 | } |
4518 | 3304 | ||
4519 | impl<'a> AstNode<'a> for Visibility<'a> { | 3305 | impl AstNode for Visibility { |
4520 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3306 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4521 | match syntax.kind() { | 3307 | match syntax.kind() { |
4522 | VISIBILITY => Some(Visibility { syntax }), | 3308 | VISIBILITY => Some(Visibility::from_repr(syntax.into_repr())), |
4523 | _ => None, | 3309 | _ => None, |
4524 | } | 3310 | } |
4525 | } | 3311 | } |
4526 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3312 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4527 | } | 3313 | fn to_owned(&self) -> TreePtr<Visibility> { TreePtr::cast(self.syntax.to_owned()) } |
4528 | |||
4529 | impl<R: TreeRoot<RaTypes>> VisibilityNode<R> { | ||
4530 | pub fn borrowed(&self) -> Visibility { | ||
4531 | VisibilityNode { syntax: self.syntax.borrowed() } | ||
4532 | } | ||
4533 | pub fn owned(&self) -> VisibilityNode { | ||
4534 | VisibilityNode { syntax: self.syntax.owned() } | ||
4535 | } | ||
4536 | } | 3314 | } |
4537 | 3315 | ||
4538 | 3316 | ||
4539 | impl<'a> Visibility<'a> {} | 3317 | impl Visibility {} |
4540 | 3318 | ||
4541 | // WhereClause | 3319 | // WhereClause |
4542 | #[derive(Debug, Clone, Copy,)] | 3320 | #[derive(Debug, PartialEq, Eq, Hash)] |
4543 | pub struct WhereClauseNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3321 | #[repr(transparent)] |
4544 | pub(crate) syntax: SyntaxNode<R>, | 3322 | pub struct WhereClause { |
3323 | pub(crate) syntax: SyntaxNode, | ||
4545 | } | 3324 | } |
4546 | pub type WhereClause<'a> = WhereClauseNode<RefRoot<'a>>; | 3325 | unsafe impl TransparentNewType for WhereClause { |
4547 | 3326 | type Repr = rowan::SyntaxNode<RaTypes>; | |
4548 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<WhereClauseNode<R1>> for WhereClauseNode<R2> { | ||
4549 | fn eq(&self, other: &WhereClauseNode<R1>) -> bool { self.syntax == other.syntax } | ||
4550 | } | ||
4551 | impl<R: TreeRoot<RaTypes>> Eq for WhereClauseNode<R> {} | ||
4552 | impl<R: TreeRoot<RaTypes>> Hash for WhereClauseNode<R> { | ||
4553 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4554 | } | 3327 | } |
4555 | 3328 | ||
4556 | impl<'a> AstNode<'a> for WhereClause<'a> { | 3329 | impl AstNode for WhereClause { |
4557 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3330 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4558 | match syntax.kind() { | 3331 | match syntax.kind() { |
4559 | WHERE_CLAUSE => Some(WhereClause { syntax }), | 3332 | WHERE_CLAUSE => Some(WhereClause::from_repr(syntax.into_repr())), |
4560 | _ => None, | 3333 | _ => None, |
4561 | } | 3334 | } |
4562 | } | 3335 | } |
4563 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3336 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4564 | } | 3337 | fn to_owned(&self) -> TreePtr<WhereClause> { TreePtr::cast(self.syntax.to_owned()) } |
4565 | |||
4566 | impl<R: TreeRoot<RaTypes>> WhereClauseNode<R> { | ||
4567 | pub fn borrowed(&self) -> WhereClause { | ||
4568 | WhereClauseNode { syntax: self.syntax.borrowed() } | ||
4569 | } | ||
4570 | pub fn owned(&self) -> WhereClauseNode { | ||
4571 | WhereClauseNode { syntax: self.syntax.owned() } | ||
4572 | } | ||
4573 | } | 3338 | } |
4574 | 3339 | ||
4575 | 3340 | ||
4576 | impl<'a> WhereClause<'a> {} | 3341 | impl WhereClause {} |
4577 | 3342 | ||
4578 | // WhileExpr | 3343 | // WhileExpr |
4579 | #[derive(Debug, Clone, Copy,)] | 3344 | #[derive(Debug, PartialEq, Eq, Hash)] |
4580 | pub struct WhileExprNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3345 | #[repr(transparent)] |
4581 | pub(crate) syntax: SyntaxNode<R>, | 3346 | pub struct WhileExpr { |
4582 | } | 3347 | pub(crate) syntax: SyntaxNode, |
4583 | pub type WhileExpr<'a> = WhileExprNode<RefRoot<'a>>; | ||
4584 | |||
4585 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<WhileExprNode<R1>> for WhileExprNode<R2> { | ||
4586 | fn eq(&self, other: &WhileExprNode<R1>) -> bool { self.syntax == other.syntax } | ||
4587 | } | 3348 | } |
4588 | impl<R: TreeRoot<RaTypes>> Eq for WhileExprNode<R> {} | 3349 | unsafe impl TransparentNewType for WhileExpr { |
4589 | impl<R: TreeRoot<RaTypes>> Hash for WhileExprNode<R> { | 3350 | type Repr = rowan::SyntaxNode<RaTypes>; |
4590 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4591 | } | 3351 | } |
4592 | 3352 | ||
4593 | impl<'a> AstNode<'a> for WhileExpr<'a> { | 3353 | impl AstNode for WhileExpr { |
4594 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3354 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4595 | match syntax.kind() { | 3355 | match syntax.kind() { |
4596 | WHILE_EXPR => Some(WhileExpr { syntax }), | 3356 | WHILE_EXPR => Some(WhileExpr::from_repr(syntax.into_repr())), |
4597 | _ => None, | 3357 | _ => None, |
4598 | } | 3358 | } |
4599 | } | 3359 | } |
4600 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3360 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
3361 | fn to_owned(&self) -> TreePtr<WhileExpr> { TreePtr::cast(self.syntax.to_owned()) } | ||
4601 | } | 3362 | } |
4602 | 3363 | ||
4603 | impl<R: TreeRoot<RaTypes>> WhileExprNode<R> { | ||
4604 | pub fn borrowed(&self) -> WhileExpr { | ||
4605 | WhileExprNode { syntax: self.syntax.borrowed() } | ||
4606 | } | ||
4607 | pub fn owned(&self) -> WhileExprNode { | ||
4608 | WhileExprNode { syntax: self.syntax.owned() } | ||
4609 | } | ||
4610 | } | ||
4611 | 3364 | ||
4612 | 3365 | impl ast::LoopBodyOwner for WhileExpr {} | |
4613 | impl<'a> ast::LoopBodyOwner<'a> for WhileExpr<'a> {} | 3366 | impl WhileExpr { |
4614 | impl<'a> WhileExpr<'a> { | 3367 | pub fn condition(&self) -> Option<&Condition> { |
4615 | pub fn condition(self) -> Option<Condition<'a>> { | ||
4616 | super::child_opt(self) | 3368 | super::child_opt(self) |
4617 | } | 3369 | } |
4618 | } | 3370 | } |
4619 | 3371 | ||
4620 | // Whitespace | 3372 | // Whitespace |
4621 | #[derive(Debug, Clone, Copy,)] | 3373 | #[derive(Debug, PartialEq, Eq, Hash)] |
4622 | pub struct WhitespaceNode<R: TreeRoot<RaTypes> = OwnedRoot> { | 3374 | #[repr(transparent)] |
4623 | pub(crate) syntax: SyntaxNode<R>, | 3375 | pub struct Whitespace { |
4624 | } | 3376 | pub(crate) syntax: SyntaxNode, |
4625 | pub type Whitespace<'a> = WhitespaceNode<RefRoot<'a>>; | ||
4626 | |||
4627 | impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<WhitespaceNode<R1>> for WhitespaceNode<R2> { | ||
4628 | fn eq(&self, other: &WhitespaceNode<R1>) -> bool { self.syntax == other.syntax } | ||
4629 | } | 3377 | } |
4630 | impl<R: TreeRoot<RaTypes>> Eq for WhitespaceNode<R> {} | 3378 | unsafe impl TransparentNewType for Whitespace { |
4631 | impl<R: TreeRoot<RaTypes>> Hash for WhitespaceNode<R> { | 3379 | type Repr = rowan::SyntaxNode<RaTypes>; |
4632 | fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) } | ||
4633 | } | 3380 | } |
4634 | 3381 | ||
4635 | impl<'a> AstNode<'a> for Whitespace<'a> { | 3382 | impl AstNode for Whitespace { |
4636 | fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> { | 3383 | fn cast(syntax: &SyntaxNode) -> Option<&Self> { |
4637 | match syntax.kind() { | 3384 | match syntax.kind() { |
4638 | WHITESPACE => Some(Whitespace { syntax }), | 3385 | WHITESPACE => Some(Whitespace::from_repr(syntax.into_repr())), |
4639 | _ => None, | 3386 | _ => None, |
4640 | } | 3387 | } |
4641 | } | 3388 | } |
4642 | fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax } | 3389 | fn syntax(&self) -> &SyntaxNode { &self.syntax } |
4643 | } | 3390 | fn to_owned(&self) -> TreePtr<Whitespace> { TreePtr::cast(self.syntax.to_owned()) } |
4644 | |||
4645 | impl<R: TreeRoot<RaTypes>> WhitespaceNode<R> { | ||
4646 | pub fn borrowed(&self) -> Whitespace { | ||
4647 | WhitespaceNode { syntax: self.syntax.borrowed() } | ||
4648 | } | ||
4649 | pub fn owned(&self) -> WhitespaceNode { | ||
4650 | WhitespaceNode { syntax: self.syntax.owned() } | ||
4651 | } | ||
4652 | } | 3391 | } |
4653 | 3392 | ||
4654 | 3393 | ||
4655 | impl<'a> Whitespace<'a> {} | 3394 | impl Whitespace {} |
4656 | 3395 | ||