1#![allow(clippy::match_single_binding)]
3#![allow(clippy::too_many_arguments)]
4#![allow(dead_code)]
5#![allow(unused_variables)]
6use std::ops::Deref;
7use std::sync::Arc;
8
9use cairo_lang_filesystem::span::TextWidth;
10use cairo_lang_utils::{Intern, LookupIntern, extract_matches};
11use smol_str::SmolStr;
12
13use super::element_list::ElementList;
14use super::green::GreenNodeDetails;
15use super::kind::SyntaxKind;
16use super::{
17 GreenId, GreenNode, SyntaxGroup, SyntaxNode, SyntaxStablePtr, SyntaxStablePtrId, Terminal,
18 Token, TypedStablePtr, TypedSyntaxNode,
19};
20#[path = "ast_ext.rs"]
21mod ast_ext;
22#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23pub struct Trivia(ElementList<Trivium, 1>);
24impl Deref for Trivia {
25 type Target = ElementList<Trivium, 1>;
26 fn deref(&self) -> &Self::Target {
27 &self.0
28 }
29}
30impl Trivia {
31 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<TriviumGreen>) -> TriviaGreen {
32 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
33 TriviaGreen(
34 Arc::new(GreenNode {
35 kind: SyntaxKind::Trivia,
36 details: GreenNodeDetails::Node {
37 children: children.iter().map(|x| x.0).collect(),
38 width,
39 },
40 })
41 .intern(db),
42 )
43 }
44}
45#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
46pub struct TriviaPtr(pub SyntaxStablePtrId);
47impl TypedStablePtr for TriviaPtr {
48 type SyntaxNode = Trivia;
49 fn untyped(&self) -> SyntaxStablePtrId {
50 self.0
51 }
52 fn lookup(&self, db: &dyn SyntaxGroup) -> Trivia {
53 Trivia::from_syntax_node(db, self.0.lookup(db))
54 }
55}
56impl From<TriviaPtr> for SyntaxStablePtrId {
57 fn from(ptr: TriviaPtr) -> Self {
58 ptr.untyped()
59 }
60}
61#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
62pub struct TriviaGreen(pub GreenId);
63impl TypedSyntaxNode for Trivia {
64 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Trivia);
65 type StablePtr = TriviaPtr;
66 type Green = TriviaGreen;
67 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
68 TriviaGreen(
69 Arc::new(GreenNode {
70 kind: SyntaxKind::Trivia,
71 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
72 })
73 .intern(db),
74 )
75 }
76 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
77 Self(ElementList::new(node))
78 }
79 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
80 if node.kind(db) == SyntaxKind::Trivia { Some(Self(ElementList::new(node))) } else { None }
81 }
82 fn as_syntax_node(&self) -> SyntaxNode {
83 self.node.clone()
84 }
85 fn stable_ptr(&self) -> Self::StablePtr {
86 TriviaPtr(self.node.0.stable_ptr)
87 }
88}
89impl From<&Trivia> for SyntaxStablePtrId {
90 fn from(node: &Trivia) -> Self {
91 node.stable_ptr().untyped()
92 }
93}
94#[derive(Clone, Debug, Eq, Hash, PartialEq)]
95pub enum Trivium {
96 SingleLineComment(TokenSingleLineComment),
97 SingleLineDocComment(TokenSingleLineDocComment),
98 SingleLineInnerComment(TokenSingleLineInnerComment),
99 Whitespace(TokenWhitespace),
100 Newline(TokenNewline),
101 Skipped(TokenSkipped),
102 SkippedNode(TriviumSkippedNode),
103}
104#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
105pub struct TriviumPtr(pub SyntaxStablePtrId);
106impl TypedStablePtr for TriviumPtr {
107 type SyntaxNode = Trivium;
108 fn untyped(&self) -> SyntaxStablePtrId {
109 self.0
110 }
111 fn lookup(&self, db: &dyn SyntaxGroup) -> Trivium {
112 Trivium::from_syntax_node(db, self.0.lookup(db))
113 }
114}
115impl From<TriviumPtr> for SyntaxStablePtrId {
116 fn from(ptr: TriviumPtr) -> Self {
117 ptr.untyped()
118 }
119}
120impl From<TokenSingleLineCommentPtr> for TriviumPtr {
121 fn from(value: TokenSingleLineCommentPtr) -> Self {
122 Self(value.0)
123 }
124}
125impl From<TokenSingleLineDocCommentPtr> for TriviumPtr {
126 fn from(value: TokenSingleLineDocCommentPtr) -> Self {
127 Self(value.0)
128 }
129}
130impl From<TokenSingleLineInnerCommentPtr> for TriviumPtr {
131 fn from(value: TokenSingleLineInnerCommentPtr) -> Self {
132 Self(value.0)
133 }
134}
135impl From<TokenWhitespacePtr> for TriviumPtr {
136 fn from(value: TokenWhitespacePtr) -> Self {
137 Self(value.0)
138 }
139}
140impl From<TokenNewlinePtr> for TriviumPtr {
141 fn from(value: TokenNewlinePtr) -> Self {
142 Self(value.0)
143 }
144}
145impl From<TokenSkippedPtr> for TriviumPtr {
146 fn from(value: TokenSkippedPtr) -> Self {
147 Self(value.0)
148 }
149}
150impl From<TriviumSkippedNodePtr> for TriviumPtr {
151 fn from(value: TriviumSkippedNodePtr) -> Self {
152 Self(value.0)
153 }
154}
155impl From<TokenSingleLineCommentGreen> for TriviumGreen {
156 fn from(value: TokenSingleLineCommentGreen) -> Self {
157 Self(value.0)
158 }
159}
160impl From<TokenSingleLineDocCommentGreen> for TriviumGreen {
161 fn from(value: TokenSingleLineDocCommentGreen) -> Self {
162 Self(value.0)
163 }
164}
165impl From<TokenSingleLineInnerCommentGreen> for TriviumGreen {
166 fn from(value: TokenSingleLineInnerCommentGreen) -> Self {
167 Self(value.0)
168 }
169}
170impl From<TokenWhitespaceGreen> for TriviumGreen {
171 fn from(value: TokenWhitespaceGreen) -> Self {
172 Self(value.0)
173 }
174}
175impl From<TokenNewlineGreen> for TriviumGreen {
176 fn from(value: TokenNewlineGreen) -> Self {
177 Self(value.0)
178 }
179}
180impl From<TokenSkippedGreen> for TriviumGreen {
181 fn from(value: TokenSkippedGreen) -> Self {
182 Self(value.0)
183 }
184}
185impl From<TriviumSkippedNodeGreen> for TriviumGreen {
186 fn from(value: TriviumSkippedNodeGreen) -> Self {
187 Self(value.0)
188 }
189}
190#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
191pub struct TriviumGreen(pub GreenId);
192impl TypedSyntaxNode for Trivium {
193 const OPTIONAL_KIND: Option<SyntaxKind> = None;
194 type StablePtr = TriviumPtr;
195 type Green = TriviumGreen;
196 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
197 panic!("No missing variant.");
198 }
199 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
200 let kind = node.kind(db);
201 match kind {
202 SyntaxKind::TokenSingleLineComment => {
203 Trivium::SingleLineComment(TokenSingleLineComment::from_syntax_node(db, node))
204 }
205 SyntaxKind::TokenSingleLineDocComment => {
206 Trivium::SingleLineDocComment(TokenSingleLineDocComment::from_syntax_node(db, node))
207 }
208 SyntaxKind::TokenSingleLineInnerComment => Trivium::SingleLineInnerComment(
209 TokenSingleLineInnerComment::from_syntax_node(db, node),
210 ),
211 SyntaxKind::TokenWhitespace => {
212 Trivium::Whitespace(TokenWhitespace::from_syntax_node(db, node))
213 }
214 SyntaxKind::TokenNewline => Trivium::Newline(TokenNewline::from_syntax_node(db, node)),
215 SyntaxKind::TokenSkipped => Trivium::Skipped(TokenSkipped::from_syntax_node(db, node)),
216 SyntaxKind::TriviumSkippedNode => {
217 Trivium::SkippedNode(TriviumSkippedNode::from_syntax_node(db, node))
218 }
219 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Trivium"),
220 }
221 }
222 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
223 let kind = node.kind(db);
224 match kind {
225 SyntaxKind::TokenSingleLineComment => {
226 Some(Trivium::SingleLineComment(TokenSingleLineComment::from_syntax_node(db, node)))
227 }
228 SyntaxKind::TokenSingleLineDocComment => Some(Trivium::SingleLineDocComment(
229 TokenSingleLineDocComment::from_syntax_node(db, node),
230 )),
231 SyntaxKind::TokenSingleLineInnerComment => Some(Trivium::SingleLineInnerComment(
232 TokenSingleLineInnerComment::from_syntax_node(db, node),
233 )),
234 SyntaxKind::TokenWhitespace => {
235 Some(Trivium::Whitespace(TokenWhitespace::from_syntax_node(db, node)))
236 }
237 SyntaxKind::TokenNewline => {
238 Some(Trivium::Newline(TokenNewline::from_syntax_node(db, node)))
239 }
240 SyntaxKind::TokenSkipped => {
241 Some(Trivium::Skipped(TokenSkipped::from_syntax_node(db, node)))
242 }
243 SyntaxKind::TriviumSkippedNode => {
244 Some(Trivium::SkippedNode(TriviumSkippedNode::from_syntax_node(db, node)))
245 }
246 _ => None,
247 }
248 }
249 fn as_syntax_node(&self) -> SyntaxNode {
250 match self {
251 Trivium::SingleLineComment(x) => x.as_syntax_node(),
252 Trivium::SingleLineDocComment(x) => x.as_syntax_node(),
253 Trivium::SingleLineInnerComment(x) => x.as_syntax_node(),
254 Trivium::Whitespace(x) => x.as_syntax_node(),
255 Trivium::Newline(x) => x.as_syntax_node(),
256 Trivium::Skipped(x) => x.as_syntax_node(),
257 Trivium::SkippedNode(x) => x.as_syntax_node(),
258 }
259 }
260 fn stable_ptr(&self) -> Self::StablePtr {
261 TriviumPtr(self.as_syntax_node().0.stable_ptr)
262 }
263}
264impl From<&Trivium> for SyntaxStablePtrId {
265 fn from(node: &Trivium) -> Self {
266 node.stable_ptr().untyped()
267 }
268}
269impl Trivium {
270 pub fn is_variant(kind: SyntaxKind) -> bool {
272 matches!(
273 kind,
274 SyntaxKind::TokenSingleLineComment
275 | SyntaxKind::TokenSingleLineDocComment
276 | SyntaxKind::TokenSingleLineInnerComment
277 | SyntaxKind::TokenWhitespace
278 | SyntaxKind::TokenNewline
279 | SyntaxKind::TokenSkipped
280 | SyntaxKind::TriviumSkippedNode
281 )
282 }
283}
284#[derive(Clone, Debug, Eq, Hash, PartialEq)]
285pub enum Expr {
286 Path(ExprPath),
287 Literal(TerminalLiteralNumber),
288 ShortString(TerminalShortString),
289 String(TerminalString),
290 False(TerminalFalse),
291 True(TerminalTrue),
292 Parenthesized(ExprParenthesized),
293 Unary(ExprUnary),
294 Binary(ExprBinary),
295 Tuple(ExprListParenthesized),
296 FunctionCall(ExprFunctionCall),
297 StructCtorCall(ExprStructCtorCall),
298 Block(ExprBlock),
299 Match(ExprMatch),
300 If(ExprIf),
301 Loop(ExprLoop),
302 While(ExprWhile),
303 For(ExprFor),
304 Closure(ExprClosure),
305 ErrorPropagate(ExprErrorPropagate),
306 FieldInitShorthand(ExprFieldInitShorthand),
307 Indexed(ExprIndexed),
308 InlineMacro(ExprInlineMacro),
309 FixedSizeArray(ExprFixedSizeArray),
310 Missing(ExprMissing),
311}
312#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
313pub struct ExprPtr(pub SyntaxStablePtrId);
314impl TypedStablePtr for ExprPtr {
315 type SyntaxNode = Expr;
316 fn untyped(&self) -> SyntaxStablePtrId {
317 self.0
318 }
319 fn lookup(&self, db: &dyn SyntaxGroup) -> Expr {
320 Expr::from_syntax_node(db, self.0.lookup(db))
321 }
322}
323impl From<ExprPtr> for SyntaxStablePtrId {
324 fn from(ptr: ExprPtr) -> Self {
325 ptr.untyped()
326 }
327}
328impl From<ExprPathPtr> for ExprPtr {
329 fn from(value: ExprPathPtr) -> Self {
330 Self(value.0)
331 }
332}
333impl From<TerminalLiteralNumberPtr> for ExprPtr {
334 fn from(value: TerminalLiteralNumberPtr) -> Self {
335 Self(value.0)
336 }
337}
338impl From<TerminalShortStringPtr> for ExprPtr {
339 fn from(value: TerminalShortStringPtr) -> Self {
340 Self(value.0)
341 }
342}
343impl From<TerminalStringPtr> for ExprPtr {
344 fn from(value: TerminalStringPtr) -> Self {
345 Self(value.0)
346 }
347}
348impl From<TerminalFalsePtr> for ExprPtr {
349 fn from(value: TerminalFalsePtr) -> Self {
350 Self(value.0)
351 }
352}
353impl From<TerminalTruePtr> for ExprPtr {
354 fn from(value: TerminalTruePtr) -> Self {
355 Self(value.0)
356 }
357}
358impl From<ExprParenthesizedPtr> for ExprPtr {
359 fn from(value: ExprParenthesizedPtr) -> Self {
360 Self(value.0)
361 }
362}
363impl From<ExprUnaryPtr> for ExprPtr {
364 fn from(value: ExprUnaryPtr) -> Self {
365 Self(value.0)
366 }
367}
368impl From<ExprBinaryPtr> for ExprPtr {
369 fn from(value: ExprBinaryPtr) -> Self {
370 Self(value.0)
371 }
372}
373impl From<ExprListParenthesizedPtr> for ExprPtr {
374 fn from(value: ExprListParenthesizedPtr) -> Self {
375 Self(value.0)
376 }
377}
378impl From<ExprFunctionCallPtr> for ExprPtr {
379 fn from(value: ExprFunctionCallPtr) -> Self {
380 Self(value.0)
381 }
382}
383impl From<ExprStructCtorCallPtr> for ExprPtr {
384 fn from(value: ExprStructCtorCallPtr) -> Self {
385 Self(value.0)
386 }
387}
388impl From<ExprBlockPtr> for ExprPtr {
389 fn from(value: ExprBlockPtr) -> Self {
390 Self(value.0)
391 }
392}
393impl From<ExprMatchPtr> for ExprPtr {
394 fn from(value: ExprMatchPtr) -> Self {
395 Self(value.0)
396 }
397}
398impl From<ExprIfPtr> for ExprPtr {
399 fn from(value: ExprIfPtr) -> Self {
400 Self(value.0)
401 }
402}
403impl From<ExprLoopPtr> for ExprPtr {
404 fn from(value: ExprLoopPtr) -> Self {
405 Self(value.0)
406 }
407}
408impl From<ExprWhilePtr> for ExprPtr {
409 fn from(value: ExprWhilePtr) -> Self {
410 Self(value.0)
411 }
412}
413impl From<ExprForPtr> for ExprPtr {
414 fn from(value: ExprForPtr) -> Self {
415 Self(value.0)
416 }
417}
418impl From<ExprClosurePtr> for ExprPtr {
419 fn from(value: ExprClosurePtr) -> Self {
420 Self(value.0)
421 }
422}
423impl From<ExprErrorPropagatePtr> for ExprPtr {
424 fn from(value: ExprErrorPropagatePtr) -> Self {
425 Self(value.0)
426 }
427}
428impl From<ExprFieldInitShorthandPtr> for ExprPtr {
429 fn from(value: ExprFieldInitShorthandPtr) -> Self {
430 Self(value.0)
431 }
432}
433impl From<ExprIndexedPtr> for ExprPtr {
434 fn from(value: ExprIndexedPtr) -> Self {
435 Self(value.0)
436 }
437}
438impl From<ExprInlineMacroPtr> for ExprPtr {
439 fn from(value: ExprInlineMacroPtr) -> Self {
440 Self(value.0)
441 }
442}
443impl From<ExprFixedSizeArrayPtr> for ExprPtr {
444 fn from(value: ExprFixedSizeArrayPtr) -> Self {
445 Self(value.0)
446 }
447}
448impl From<ExprMissingPtr> for ExprPtr {
449 fn from(value: ExprMissingPtr) -> Self {
450 Self(value.0)
451 }
452}
453impl From<ExprPathGreen> for ExprGreen {
454 fn from(value: ExprPathGreen) -> Self {
455 Self(value.0)
456 }
457}
458impl From<TerminalLiteralNumberGreen> for ExprGreen {
459 fn from(value: TerminalLiteralNumberGreen) -> Self {
460 Self(value.0)
461 }
462}
463impl From<TerminalShortStringGreen> for ExprGreen {
464 fn from(value: TerminalShortStringGreen) -> Self {
465 Self(value.0)
466 }
467}
468impl From<TerminalStringGreen> for ExprGreen {
469 fn from(value: TerminalStringGreen) -> Self {
470 Self(value.0)
471 }
472}
473impl From<TerminalFalseGreen> for ExprGreen {
474 fn from(value: TerminalFalseGreen) -> Self {
475 Self(value.0)
476 }
477}
478impl From<TerminalTrueGreen> for ExprGreen {
479 fn from(value: TerminalTrueGreen) -> Self {
480 Self(value.0)
481 }
482}
483impl From<ExprParenthesizedGreen> for ExprGreen {
484 fn from(value: ExprParenthesizedGreen) -> Self {
485 Self(value.0)
486 }
487}
488impl From<ExprUnaryGreen> for ExprGreen {
489 fn from(value: ExprUnaryGreen) -> Self {
490 Self(value.0)
491 }
492}
493impl From<ExprBinaryGreen> for ExprGreen {
494 fn from(value: ExprBinaryGreen) -> Self {
495 Self(value.0)
496 }
497}
498impl From<ExprListParenthesizedGreen> for ExprGreen {
499 fn from(value: ExprListParenthesizedGreen) -> Self {
500 Self(value.0)
501 }
502}
503impl From<ExprFunctionCallGreen> for ExprGreen {
504 fn from(value: ExprFunctionCallGreen) -> Self {
505 Self(value.0)
506 }
507}
508impl From<ExprStructCtorCallGreen> for ExprGreen {
509 fn from(value: ExprStructCtorCallGreen) -> Self {
510 Self(value.0)
511 }
512}
513impl From<ExprBlockGreen> for ExprGreen {
514 fn from(value: ExprBlockGreen) -> Self {
515 Self(value.0)
516 }
517}
518impl From<ExprMatchGreen> for ExprGreen {
519 fn from(value: ExprMatchGreen) -> Self {
520 Self(value.0)
521 }
522}
523impl From<ExprIfGreen> for ExprGreen {
524 fn from(value: ExprIfGreen) -> Self {
525 Self(value.0)
526 }
527}
528impl From<ExprLoopGreen> for ExprGreen {
529 fn from(value: ExprLoopGreen) -> Self {
530 Self(value.0)
531 }
532}
533impl From<ExprWhileGreen> for ExprGreen {
534 fn from(value: ExprWhileGreen) -> Self {
535 Self(value.0)
536 }
537}
538impl From<ExprForGreen> for ExprGreen {
539 fn from(value: ExprForGreen) -> Self {
540 Self(value.0)
541 }
542}
543impl From<ExprClosureGreen> for ExprGreen {
544 fn from(value: ExprClosureGreen) -> Self {
545 Self(value.0)
546 }
547}
548impl From<ExprErrorPropagateGreen> for ExprGreen {
549 fn from(value: ExprErrorPropagateGreen) -> Self {
550 Self(value.0)
551 }
552}
553impl From<ExprFieldInitShorthandGreen> for ExprGreen {
554 fn from(value: ExprFieldInitShorthandGreen) -> Self {
555 Self(value.0)
556 }
557}
558impl From<ExprIndexedGreen> for ExprGreen {
559 fn from(value: ExprIndexedGreen) -> Self {
560 Self(value.0)
561 }
562}
563impl From<ExprInlineMacroGreen> for ExprGreen {
564 fn from(value: ExprInlineMacroGreen) -> Self {
565 Self(value.0)
566 }
567}
568impl From<ExprFixedSizeArrayGreen> for ExprGreen {
569 fn from(value: ExprFixedSizeArrayGreen) -> Self {
570 Self(value.0)
571 }
572}
573impl From<ExprMissingGreen> for ExprGreen {
574 fn from(value: ExprMissingGreen) -> Self {
575 Self(value.0)
576 }
577}
578#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
579pub struct ExprGreen(pub GreenId);
580impl TypedSyntaxNode for Expr {
581 const OPTIONAL_KIND: Option<SyntaxKind> = None;
582 type StablePtr = ExprPtr;
583 type Green = ExprGreen;
584 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
585 ExprGreen(ExprMissing::missing(db).0)
586 }
587 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
588 let kind = node.kind(db);
589 match kind {
590 SyntaxKind::ExprPath => Expr::Path(ExprPath::from_syntax_node(db, node)),
591 SyntaxKind::TerminalLiteralNumber => {
592 Expr::Literal(TerminalLiteralNumber::from_syntax_node(db, node))
593 }
594 SyntaxKind::TerminalShortString => {
595 Expr::ShortString(TerminalShortString::from_syntax_node(db, node))
596 }
597 SyntaxKind::TerminalString => Expr::String(TerminalString::from_syntax_node(db, node)),
598 SyntaxKind::TerminalFalse => Expr::False(TerminalFalse::from_syntax_node(db, node)),
599 SyntaxKind::TerminalTrue => Expr::True(TerminalTrue::from_syntax_node(db, node)),
600 SyntaxKind::ExprParenthesized => {
601 Expr::Parenthesized(ExprParenthesized::from_syntax_node(db, node))
602 }
603 SyntaxKind::ExprUnary => Expr::Unary(ExprUnary::from_syntax_node(db, node)),
604 SyntaxKind::ExprBinary => Expr::Binary(ExprBinary::from_syntax_node(db, node)),
605 SyntaxKind::ExprListParenthesized => {
606 Expr::Tuple(ExprListParenthesized::from_syntax_node(db, node))
607 }
608 SyntaxKind::ExprFunctionCall => {
609 Expr::FunctionCall(ExprFunctionCall::from_syntax_node(db, node))
610 }
611 SyntaxKind::ExprStructCtorCall => {
612 Expr::StructCtorCall(ExprStructCtorCall::from_syntax_node(db, node))
613 }
614 SyntaxKind::ExprBlock => Expr::Block(ExprBlock::from_syntax_node(db, node)),
615 SyntaxKind::ExprMatch => Expr::Match(ExprMatch::from_syntax_node(db, node)),
616 SyntaxKind::ExprIf => Expr::If(ExprIf::from_syntax_node(db, node)),
617 SyntaxKind::ExprLoop => Expr::Loop(ExprLoop::from_syntax_node(db, node)),
618 SyntaxKind::ExprWhile => Expr::While(ExprWhile::from_syntax_node(db, node)),
619 SyntaxKind::ExprFor => Expr::For(ExprFor::from_syntax_node(db, node)),
620 SyntaxKind::ExprClosure => Expr::Closure(ExprClosure::from_syntax_node(db, node)),
621 SyntaxKind::ExprErrorPropagate => {
622 Expr::ErrorPropagate(ExprErrorPropagate::from_syntax_node(db, node))
623 }
624 SyntaxKind::ExprFieldInitShorthand => {
625 Expr::FieldInitShorthand(ExprFieldInitShorthand::from_syntax_node(db, node))
626 }
627 SyntaxKind::ExprIndexed => Expr::Indexed(ExprIndexed::from_syntax_node(db, node)),
628 SyntaxKind::ExprInlineMacro => {
629 Expr::InlineMacro(ExprInlineMacro::from_syntax_node(db, node))
630 }
631 SyntaxKind::ExprFixedSizeArray => {
632 Expr::FixedSizeArray(ExprFixedSizeArray::from_syntax_node(db, node))
633 }
634 SyntaxKind::ExprMissing => Expr::Missing(ExprMissing::from_syntax_node(db, node)),
635 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Expr"),
636 }
637 }
638 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
639 let kind = node.kind(db);
640 match kind {
641 SyntaxKind::ExprPath => Some(Expr::Path(ExprPath::from_syntax_node(db, node))),
642 SyntaxKind::TerminalLiteralNumber => {
643 Some(Expr::Literal(TerminalLiteralNumber::from_syntax_node(db, node)))
644 }
645 SyntaxKind::TerminalShortString => {
646 Some(Expr::ShortString(TerminalShortString::from_syntax_node(db, node)))
647 }
648 SyntaxKind::TerminalString => {
649 Some(Expr::String(TerminalString::from_syntax_node(db, node)))
650 }
651 SyntaxKind::TerminalFalse => {
652 Some(Expr::False(TerminalFalse::from_syntax_node(db, node)))
653 }
654 SyntaxKind::TerminalTrue => Some(Expr::True(TerminalTrue::from_syntax_node(db, node))),
655 SyntaxKind::ExprParenthesized => {
656 Some(Expr::Parenthesized(ExprParenthesized::from_syntax_node(db, node)))
657 }
658 SyntaxKind::ExprUnary => Some(Expr::Unary(ExprUnary::from_syntax_node(db, node))),
659 SyntaxKind::ExprBinary => Some(Expr::Binary(ExprBinary::from_syntax_node(db, node))),
660 SyntaxKind::ExprListParenthesized => {
661 Some(Expr::Tuple(ExprListParenthesized::from_syntax_node(db, node)))
662 }
663 SyntaxKind::ExprFunctionCall => {
664 Some(Expr::FunctionCall(ExprFunctionCall::from_syntax_node(db, node)))
665 }
666 SyntaxKind::ExprStructCtorCall => {
667 Some(Expr::StructCtorCall(ExprStructCtorCall::from_syntax_node(db, node)))
668 }
669 SyntaxKind::ExprBlock => Some(Expr::Block(ExprBlock::from_syntax_node(db, node))),
670 SyntaxKind::ExprMatch => Some(Expr::Match(ExprMatch::from_syntax_node(db, node))),
671 SyntaxKind::ExprIf => Some(Expr::If(ExprIf::from_syntax_node(db, node))),
672 SyntaxKind::ExprLoop => Some(Expr::Loop(ExprLoop::from_syntax_node(db, node))),
673 SyntaxKind::ExprWhile => Some(Expr::While(ExprWhile::from_syntax_node(db, node))),
674 SyntaxKind::ExprFor => Some(Expr::For(ExprFor::from_syntax_node(db, node))),
675 SyntaxKind::ExprClosure => Some(Expr::Closure(ExprClosure::from_syntax_node(db, node))),
676 SyntaxKind::ExprErrorPropagate => {
677 Some(Expr::ErrorPropagate(ExprErrorPropagate::from_syntax_node(db, node)))
678 }
679 SyntaxKind::ExprFieldInitShorthand => {
680 Some(Expr::FieldInitShorthand(ExprFieldInitShorthand::from_syntax_node(db, node)))
681 }
682 SyntaxKind::ExprIndexed => Some(Expr::Indexed(ExprIndexed::from_syntax_node(db, node))),
683 SyntaxKind::ExprInlineMacro => {
684 Some(Expr::InlineMacro(ExprInlineMacro::from_syntax_node(db, node)))
685 }
686 SyntaxKind::ExprFixedSizeArray => {
687 Some(Expr::FixedSizeArray(ExprFixedSizeArray::from_syntax_node(db, node)))
688 }
689 SyntaxKind::ExprMissing => Some(Expr::Missing(ExprMissing::from_syntax_node(db, node))),
690 _ => None,
691 }
692 }
693 fn as_syntax_node(&self) -> SyntaxNode {
694 match self {
695 Expr::Path(x) => x.as_syntax_node(),
696 Expr::Literal(x) => x.as_syntax_node(),
697 Expr::ShortString(x) => x.as_syntax_node(),
698 Expr::String(x) => x.as_syntax_node(),
699 Expr::False(x) => x.as_syntax_node(),
700 Expr::True(x) => x.as_syntax_node(),
701 Expr::Parenthesized(x) => x.as_syntax_node(),
702 Expr::Unary(x) => x.as_syntax_node(),
703 Expr::Binary(x) => x.as_syntax_node(),
704 Expr::Tuple(x) => x.as_syntax_node(),
705 Expr::FunctionCall(x) => x.as_syntax_node(),
706 Expr::StructCtorCall(x) => x.as_syntax_node(),
707 Expr::Block(x) => x.as_syntax_node(),
708 Expr::Match(x) => x.as_syntax_node(),
709 Expr::If(x) => x.as_syntax_node(),
710 Expr::Loop(x) => x.as_syntax_node(),
711 Expr::While(x) => x.as_syntax_node(),
712 Expr::For(x) => x.as_syntax_node(),
713 Expr::Closure(x) => x.as_syntax_node(),
714 Expr::ErrorPropagate(x) => x.as_syntax_node(),
715 Expr::FieldInitShorthand(x) => x.as_syntax_node(),
716 Expr::Indexed(x) => x.as_syntax_node(),
717 Expr::InlineMacro(x) => x.as_syntax_node(),
718 Expr::FixedSizeArray(x) => x.as_syntax_node(),
719 Expr::Missing(x) => x.as_syntax_node(),
720 }
721 }
722 fn stable_ptr(&self) -> Self::StablePtr {
723 ExprPtr(self.as_syntax_node().0.stable_ptr)
724 }
725}
726impl From<&Expr> for SyntaxStablePtrId {
727 fn from(node: &Expr) -> Self {
728 node.stable_ptr().untyped()
729 }
730}
731impl Expr {
732 pub fn is_variant(kind: SyntaxKind) -> bool {
734 matches!(
735 kind,
736 SyntaxKind::ExprPath
737 | SyntaxKind::TerminalLiteralNumber
738 | SyntaxKind::TerminalShortString
739 | SyntaxKind::TerminalString
740 | SyntaxKind::TerminalFalse
741 | SyntaxKind::TerminalTrue
742 | SyntaxKind::ExprParenthesized
743 | SyntaxKind::ExprUnary
744 | SyntaxKind::ExprBinary
745 | SyntaxKind::ExprListParenthesized
746 | SyntaxKind::ExprFunctionCall
747 | SyntaxKind::ExprStructCtorCall
748 | SyntaxKind::ExprBlock
749 | SyntaxKind::ExprMatch
750 | SyntaxKind::ExprIf
751 | SyntaxKind::ExprLoop
752 | SyntaxKind::ExprWhile
753 | SyntaxKind::ExprFor
754 | SyntaxKind::ExprClosure
755 | SyntaxKind::ExprErrorPropagate
756 | SyntaxKind::ExprFieldInitShorthand
757 | SyntaxKind::ExprIndexed
758 | SyntaxKind::ExprInlineMacro
759 | SyntaxKind::ExprFixedSizeArray
760 | SyntaxKind::ExprMissing
761 )
762 }
763}
764#[derive(Clone, Debug, Eq, Hash, PartialEq)]
765pub struct ExprList(ElementList<Expr, 2>);
766impl Deref for ExprList {
767 type Target = ElementList<Expr, 2>;
768 fn deref(&self) -> &Self::Target {
769 &self.0
770 }
771}
772impl ExprList {
773 pub fn new_green(
774 db: &dyn SyntaxGroup,
775 children: Vec<ExprListElementOrSeparatorGreen>,
776 ) -> ExprListGreen {
777 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
778 ExprListGreen(
779 Arc::new(GreenNode {
780 kind: SyntaxKind::ExprList,
781 details: GreenNodeDetails::Node {
782 children: children.iter().map(|x| x.id()).collect(),
783 width,
784 },
785 })
786 .intern(db),
787 )
788 }
789}
790#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
791pub struct ExprListPtr(pub SyntaxStablePtrId);
792impl TypedStablePtr for ExprListPtr {
793 type SyntaxNode = ExprList;
794 fn untyped(&self) -> SyntaxStablePtrId {
795 self.0
796 }
797 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprList {
798 ExprList::from_syntax_node(db, self.0.lookup(db))
799 }
800}
801impl From<ExprListPtr> for SyntaxStablePtrId {
802 fn from(ptr: ExprListPtr) -> Self {
803 ptr.untyped()
804 }
805}
806#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
807pub enum ExprListElementOrSeparatorGreen {
808 Separator(TerminalCommaGreen),
809 Element(ExprGreen),
810}
811impl From<TerminalCommaGreen> for ExprListElementOrSeparatorGreen {
812 fn from(value: TerminalCommaGreen) -> Self {
813 ExprListElementOrSeparatorGreen::Separator(value)
814 }
815}
816impl From<ExprGreen> for ExprListElementOrSeparatorGreen {
817 fn from(value: ExprGreen) -> Self {
818 ExprListElementOrSeparatorGreen::Element(value)
819 }
820}
821impl ExprListElementOrSeparatorGreen {
822 fn id(&self) -> GreenId {
823 match self {
824 ExprListElementOrSeparatorGreen::Separator(green) => green.0,
825 ExprListElementOrSeparatorGreen::Element(green) => green.0,
826 }
827 }
828}
829#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
830pub struct ExprListGreen(pub GreenId);
831impl TypedSyntaxNode for ExprList {
832 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprList);
833 type StablePtr = ExprListPtr;
834 type Green = ExprListGreen;
835 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
836 ExprListGreen(
837 Arc::new(GreenNode {
838 kind: SyntaxKind::ExprList,
839 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
840 })
841 .intern(db),
842 )
843 }
844 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
845 Self(ElementList::new(node))
846 }
847 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
848 if node.kind(db) == SyntaxKind::ExprList {
849 Some(Self(ElementList::new(node)))
850 } else {
851 None
852 }
853 }
854 fn as_syntax_node(&self) -> SyntaxNode {
855 self.node.clone()
856 }
857 fn stable_ptr(&self) -> Self::StablePtr {
858 ExprListPtr(self.node.0.stable_ptr)
859 }
860}
861impl From<&ExprList> for SyntaxStablePtrId {
862 fn from(node: &ExprList) -> Self {
863 node.stable_ptr().untyped()
864 }
865}
866#[derive(Clone, Debug, Eq, Hash, PartialEq)]
867pub struct Arg {
868 node: SyntaxNode,
869 children: Arc<[SyntaxNode]>,
870}
871impl Arg {
872 pub const INDEX_MODIFIERS: usize = 0;
873 pub const INDEX_ARG_CLAUSE: usize = 1;
874 pub fn new_green(
875 db: &dyn SyntaxGroup,
876 modifiers: ModifierListGreen,
877 arg_clause: ArgClauseGreen,
878 ) -> ArgGreen {
879 let children: Vec<GreenId> = vec![modifiers.0, arg_clause.0];
880 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
881 ArgGreen(
882 Arc::new(GreenNode {
883 kind: SyntaxKind::Arg,
884 details: GreenNodeDetails::Node { children, width },
885 })
886 .intern(db),
887 )
888 }
889}
890impl Arg {
891 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
892 ModifierList::from_syntax_node(db, self.children[0].clone())
893 }
894 pub fn arg_clause(&self, db: &dyn SyntaxGroup) -> ArgClause {
895 ArgClause::from_syntax_node(db, self.children[1].clone())
896 }
897}
898#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
899pub struct ArgPtr(pub SyntaxStablePtrId);
900impl ArgPtr {}
901impl TypedStablePtr for ArgPtr {
902 type SyntaxNode = Arg;
903 fn untyped(&self) -> SyntaxStablePtrId {
904 self.0
905 }
906 fn lookup(&self, db: &dyn SyntaxGroup) -> Arg {
907 Arg::from_syntax_node(db, self.0.lookup(db))
908 }
909}
910impl From<ArgPtr> for SyntaxStablePtrId {
911 fn from(ptr: ArgPtr) -> Self {
912 ptr.untyped()
913 }
914}
915#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
916pub struct ArgGreen(pub GreenId);
917impl TypedSyntaxNode for Arg {
918 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Arg);
919 type StablePtr = ArgPtr;
920 type Green = ArgGreen;
921 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
922 ArgGreen(
923 Arc::new(GreenNode {
924 kind: SyntaxKind::Arg,
925 details: GreenNodeDetails::Node {
926 children: vec![ModifierList::missing(db).0, ArgClause::missing(db).0],
927 width: TextWidth::default(),
928 },
929 })
930 .intern(db),
931 )
932 }
933 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
934 let kind = node.kind(db);
935 assert_eq!(
936 kind,
937 SyntaxKind::Arg,
938 "Unexpected SyntaxKind {:?}. Expected {:?}.",
939 kind,
940 SyntaxKind::Arg
941 );
942 let children = db.get_children(node.clone());
943 Self { node, children }
944 }
945 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
946 let kind = node.kind(db);
947 if kind == SyntaxKind::Arg { Some(Self::from_syntax_node(db, node)) } else { None }
948 }
949 fn as_syntax_node(&self) -> SyntaxNode {
950 self.node.clone()
951 }
952 fn stable_ptr(&self) -> Self::StablePtr {
953 ArgPtr(self.node.0.stable_ptr)
954 }
955}
956impl From<&Arg> for SyntaxStablePtrId {
957 fn from(node: &Arg) -> Self {
958 node.stable_ptr().untyped()
959 }
960}
961#[derive(Clone, Debug, Eq, Hash, PartialEq)]
962pub enum ArgClause {
963 Unnamed(ArgClauseUnnamed),
964 Named(ArgClauseNamed),
965 FieldInitShorthand(ArgClauseFieldInitShorthand),
966}
967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
968pub struct ArgClausePtr(pub SyntaxStablePtrId);
969impl TypedStablePtr for ArgClausePtr {
970 type SyntaxNode = ArgClause;
971 fn untyped(&self) -> SyntaxStablePtrId {
972 self.0
973 }
974 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClause {
975 ArgClause::from_syntax_node(db, self.0.lookup(db))
976 }
977}
978impl From<ArgClausePtr> for SyntaxStablePtrId {
979 fn from(ptr: ArgClausePtr) -> Self {
980 ptr.untyped()
981 }
982}
983impl From<ArgClauseUnnamedPtr> for ArgClausePtr {
984 fn from(value: ArgClauseUnnamedPtr) -> Self {
985 Self(value.0)
986 }
987}
988impl From<ArgClauseNamedPtr> for ArgClausePtr {
989 fn from(value: ArgClauseNamedPtr) -> Self {
990 Self(value.0)
991 }
992}
993impl From<ArgClauseFieldInitShorthandPtr> for ArgClausePtr {
994 fn from(value: ArgClauseFieldInitShorthandPtr) -> Self {
995 Self(value.0)
996 }
997}
998impl From<ArgClauseUnnamedGreen> for ArgClauseGreen {
999 fn from(value: ArgClauseUnnamedGreen) -> Self {
1000 Self(value.0)
1001 }
1002}
1003impl From<ArgClauseNamedGreen> for ArgClauseGreen {
1004 fn from(value: ArgClauseNamedGreen) -> Self {
1005 Self(value.0)
1006 }
1007}
1008impl From<ArgClauseFieldInitShorthandGreen> for ArgClauseGreen {
1009 fn from(value: ArgClauseFieldInitShorthandGreen) -> Self {
1010 Self(value.0)
1011 }
1012}
1013#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1014pub struct ArgClauseGreen(pub GreenId);
1015impl TypedSyntaxNode for ArgClause {
1016 const OPTIONAL_KIND: Option<SyntaxKind> = None;
1017 type StablePtr = ArgClausePtr;
1018 type Green = ArgClauseGreen;
1019 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1020 panic!("No missing variant.");
1021 }
1022 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1023 let kind = node.kind(db);
1024 match kind {
1025 SyntaxKind::ArgClauseUnnamed => {
1026 ArgClause::Unnamed(ArgClauseUnnamed::from_syntax_node(db, node))
1027 }
1028 SyntaxKind::ArgClauseNamed => {
1029 ArgClause::Named(ArgClauseNamed::from_syntax_node(db, node))
1030 }
1031 SyntaxKind::ArgClauseFieldInitShorthand => ArgClause::FieldInitShorthand(
1032 ArgClauseFieldInitShorthand::from_syntax_node(db, node),
1033 ),
1034 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ArgClause"),
1035 }
1036 }
1037 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1038 let kind = node.kind(db);
1039 match kind {
1040 SyntaxKind::ArgClauseUnnamed => {
1041 Some(ArgClause::Unnamed(ArgClauseUnnamed::from_syntax_node(db, node)))
1042 }
1043 SyntaxKind::ArgClauseNamed => {
1044 Some(ArgClause::Named(ArgClauseNamed::from_syntax_node(db, node)))
1045 }
1046 SyntaxKind::ArgClauseFieldInitShorthand => Some(ArgClause::FieldInitShorthand(
1047 ArgClauseFieldInitShorthand::from_syntax_node(db, node),
1048 )),
1049 _ => None,
1050 }
1051 }
1052 fn as_syntax_node(&self) -> SyntaxNode {
1053 match self {
1054 ArgClause::Unnamed(x) => x.as_syntax_node(),
1055 ArgClause::Named(x) => x.as_syntax_node(),
1056 ArgClause::FieldInitShorthand(x) => x.as_syntax_node(),
1057 }
1058 }
1059 fn stable_ptr(&self) -> Self::StablePtr {
1060 ArgClausePtr(self.as_syntax_node().0.stable_ptr)
1061 }
1062}
1063impl From<&ArgClause> for SyntaxStablePtrId {
1064 fn from(node: &ArgClause) -> Self {
1065 node.stable_ptr().untyped()
1066 }
1067}
1068impl ArgClause {
1069 pub fn is_variant(kind: SyntaxKind) -> bool {
1071 matches!(
1072 kind,
1073 SyntaxKind::ArgClauseUnnamed
1074 | SyntaxKind::ArgClauseNamed
1075 | SyntaxKind::ArgClauseFieldInitShorthand
1076 )
1077 }
1078}
1079#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1080pub struct ArgClauseNamed {
1081 node: SyntaxNode,
1082 children: Arc<[SyntaxNode]>,
1083}
1084impl ArgClauseNamed {
1085 pub const INDEX_NAME: usize = 0;
1086 pub const INDEX_COLON: usize = 1;
1087 pub const INDEX_VALUE: usize = 2;
1088 pub fn new_green(
1089 db: &dyn SyntaxGroup,
1090 name: TerminalIdentifierGreen,
1091 colon: TerminalColonGreen,
1092 value: ExprGreen,
1093 ) -> ArgClauseNamedGreen {
1094 let children: Vec<GreenId> = vec![name.0, colon.0, value.0];
1095 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1096 ArgClauseNamedGreen(
1097 Arc::new(GreenNode {
1098 kind: SyntaxKind::ArgClauseNamed,
1099 details: GreenNodeDetails::Node { children, width },
1100 })
1101 .intern(db),
1102 )
1103 }
1104}
1105impl ArgClauseNamed {
1106 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1107 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1108 }
1109 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
1110 TerminalColon::from_syntax_node(db, self.children[1].clone())
1111 }
1112 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
1113 Expr::from_syntax_node(db, self.children[2].clone())
1114 }
1115}
1116#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1117pub struct ArgClauseNamedPtr(pub SyntaxStablePtrId);
1118impl ArgClauseNamedPtr {}
1119impl TypedStablePtr for ArgClauseNamedPtr {
1120 type SyntaxNode = ArgClauseNamed;
1121 fn untyped(&self) -> SyntaxStablePtrId {
1122 self.0
1123 }
1124 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseNamed {
1125 ArgClauseNamed::from_syntax_node(db, self.0.lookup(db))
1126 }
1127}
1128impl From<ArgClauseNamedPtr> for SyntaxStablePtrId {
1129 fn from(ptr: ArgClauseNamedPtr) -> Self {
1130 ptr.untyped()
1131 }
1132}
1133#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1134pub struct ArgClauseNamedGreen(pub GreenId);
1135impl TypedSyntaxNode for ArgClauseNamed {
1136 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseNamed);
1137 type StablePtr = ArgClauseNamedPtr;
1138 type Green = ArgClauseNamedGreen;
1139 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1140 ArgClauseNamedGreen(
1141 Arc::new(GreenNode {
1142 kind: SyntaxKind::ArgClauseNamed,
1143 details: GreenNodeDetails::Node {
1144 children: vec![
1145 TerminalIdentifier::missing(db).0,
1146 TerminalColon::missing(db).0,
1147 Expr::missing(db).0,
1148 ],
1149 width: TextWidth::default(),
1150 },
1151 })
1152 .intern(db),
1153 )
1154 }
1155 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1156 let kind = node.kind(db);
1157 assert_eq!(
1158 kind,
1159 SyntaxKind::ArgClauseNamed,
1160 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1161 kind,
1162 SyntaxKind::ArgClauseNamed
1163 );
1164 let children = db.get_children(node.clone());
1165 Self { node, children }
1166 }
1167 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1168 let kind = node.kind(db);
1169 if kind == SyntaxKind::ArgClauseNamed {
1170 Some(Self::from_syntax_node(db, node))
1171 } else {
1172 None
1173 }
1174 }
1175 fn as_syntax_node(&self) -> SyntaxNode {
1176 self.node.clone()
1177 }
1178 fn stable_ptr(&self) -> Self::StablePtr {
1179 ArgClauseNamedPtr(self.node.0.stable_ptr)
1180 }
1181}
1182impl From<&ArgClauseNamed> for SyntaxStablePtrId {
1183 fn from(node: &ArgClauseNamed) -> Self {
1184 node.stable_ptr().untyped()
1185 }
1186}
1187#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1188pub struct ArgClauseUnnamed {
1189 node: SyntaxNode,
1190 children: Arc<[SyntaxNode]>,
1191}
1192impl ArgClauseUnnamed {
1193 pub const INDEX_VALUE: usize = 0;
1194 pub fn new_green(db: &dyn SyntaxGroup, value: ExprGreen) -> ArgClauseUnnamedGreen {
1195 let children: Vec<GreenId> = vec![value.0];
1196 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1197 ArgClauseUnnamedGreen(
1198 Arc::new(GreenNode {
1199 kind: SyntaxKind::ArgClauseUnnamed,
1200 details: GreenNodeDetails::Node { children, width },
1201 })
1202 .intern(db),
1203 )
1204 }
1205}
1206impl ArgClauseUnnamed {
1207 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
1208 Expr::from_syntax_node(db, self.children[0].clone())
1209 }
1210}
1211#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1212pub struct ArgClauseUnnamedPtr(pub SyntaxStablePtrId);
1213impl ArgClauseUnnamedPtr {}
1214impl TypedStablePtr for ArgClauseUnnamedPtr {
1215 type SyntaxNode = ArgClauseUnnamed;
1216 fn untyped(&self) -> SyntaxStablePtrId {
1217 self.0
1218 }
1219 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseUnnamed {
1220 ArgClauseUnnamed::from_syntax_node(db, self.0.lookup(db))
1221 }
1222}
1223impl From<ArgClauseUnnamedPtr> for SyntaxStablePtrId {
1224 fn from(ptr: ArgClauseUnnamedPtr) -> Self {
1225 ptr.untyped()
1226 }
1227}
1228#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1229pub struct ArgClauseUnnamedGreen(pub GreenId);
1230impl TypedSyntaxNode for ArgClauseUnnamed {
1231 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseUnnamed);
1232 type StablePtr = ArgClauseUnnamedPtr;
1233 type Green = ArgClauseUnnamedGreen;
1234 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1235 ArgClauseUnnamedGreen(
1236 Arc::new(GreenNode {
1237 kind: SyntaxKind::ArgClauseUnnamed,
1238 details: GreenNodeDetails::Node {
1239 children: vec![Expr::missing(db).0],
1240 width: TextWidth::default(),
1241 },
1242 })
1243 .intern(db),
1244 )
1245 }
1246 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1247 let kind = node.kind(db);
1248 assert_eq!(
1249 kind,
1250 SyntaxKind::ArgClauseUnnamed,
1251 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1252 kind,
1253 SyntaxKind::ArgClauseUnnamed
1254 );
1255 let children = db.get_children(node.clone());
1256 Self { node, children }
1257 }
1258 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1259 let kind = node.kind(db);
1260 if kind == SyntaxKind::ArgClauseUnnamed {
1261 Some(Self::from_syntax_node(db, node))
1262 } else {
1263 None
1264 }
1265 }
1266 fn as_syntax_node(&self) -> SyntaxNode {
1267 self.node.clone()
1268 }
1269 fn stable_ptr(&self) -> Self::StablePtr {
1270 ArgClauseUnnamedPtr(self.node.0.stable_ptr)
1271 }
1272}
1273impl From<&ArgClauseUnnamed> for SyntaxStablePtrId {
1274 fn from(node: &ArgClauseUnnamed) -> Self {
1275 node.stable_ptr().untyped()
1276 }
1277}
1278#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1279pub struct ArgClauseFieldInitShorthand {
1280 node: SyntaxNode,
1281 children: Arc<[SyntaxNode]>,
1282}
1283impl ArgClauseFieldInitShorthand {
1284 pub const INDEX_COLON: usize = 0;
1285 pub const INDEX_NAME: usize = 1;
1286 pub fn new_green(
1287 db: &dyn SyntaxGroup,
1288 colon: TerminalColonGreen,
1289 name: ExprFieldInitShorthandGreen,
1290 ) -> ArgClauseFieldInitShorthandGreen {
1291 let children: Vec<GreenId> = vec![colon.0, name.0];
1292 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1293 ArgClauseFieldInitShorthandGreen(
1294 Arc::new(GreenNode {
1295 kind: SyntaxKind::ArgClauseFieldInitShorthand,
1296 details: GreenNodeDetails::Node { children, width },
1297 })
1298 .intern(db),
1299 )
1300 }
1301}
1302impl ArgClauseFieldInitShorthand {
1303 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
1304 TerminalColon::from_syntax_node(db, self.children[0].clone())
1305 }
1306 pub fn name(&self, db: &dyn SyntaxGroup) -> ExprFieldInitShorthand {
1307 ExprFieldInitShorthand::from_syntax_node(db, self.children[1].clone())
1308 }
1309}
1310#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1311pub struct ArgClauseFieldInitShorthandPtr(pub SyntaxStablePtrId);
1312impl ArgClauseFieldInitShorthandPtr {}
1313impl TypedStablePtr for ArgClauseFieldInitShorthandPtr {
1314 type SyntaxNode = ArgClauseFieldInitShorthand;
1315 fn untyped(&self) -> SyntaxStablePtrId {
1316 self.0
1317 }
1318 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseFieldInitShorthand {
1319 ArgClauseFieldInitShorthand::from_syntax_node(db, self.0.lookup(db))
1320 }
1321}
1322impl From<ArgClauseFieldInitShorthandPtr> for SyntaxStablePtrId {
1323 fn from(ptr: ArgClauseFieldInitShorthandPtr) -> Self {
1324 ptr.untyped()
1325 }
1326}
1327#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1328pub struct ArgClauseFieldInitShorthandGreen(pub GreenId);
1329impl TypedSyntaxNode for ArgClauseFieldInitShorthand {
1330 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseFieldInitShorthand);
1331 type StablePtr = ArgClauseFieldInitShorthandPtr;
1332 type Green = ArgClauseFieldInitShorthandGreen;
1333 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1334 ArgClauseFieldInitShorthandGreen(
1335 Arc::new(GreenNode {
1336 kind: SyntaxKind::ArgClauseFieldInitShorthand,
1337 details: GreenNodeDetails::Node {
1338 children: vec![
1339 TerminalColon::missing(db).0,
1340 ExprFieldInitShorthand::missing(db).0,
1341 ],
1342 width: TextWidth::default(),
1343 },
1344 })
1345 .intern(db),
1346 )
1347 }
1348 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1349 let kind = node.kind(db);
1350 assert_eq!(
1351 kind,
1352 SyntaxKind::ArgClauseFieldInitShorthand,
1353 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1354 kind,
1355 SyntaxKind::ArgClauseFieldInitShorthand
1356 );
1357 let children = db.get_children(node.clone());
1358 Self { node, children }
1359 }
1360 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1361 let kind = node.kind(db);
1362 if kind == SyntaxKind::ArgClauseFieldInitShorthand {
1363 Some(Self::from_syntax_node(db, node))
1364 } else {
1365 None
1366 }
1367 }
1368 fn as_syntax_node(&self) -> SyntaxNode {
1369 self.node.clone()
1370 }
1371 fn stable_ptr(&self) -> Self::StablePtr {
1372 ArgClauseFieldInitShorthandPtr(self.node.0.stable_ptr)
1373 }
1374}
1375impl From<&ArgClauseFieldInitShorthand> for SyntaxStablePtrId {
1376 fn from(node: &ArgClauseFieldInitShorthand) -> Self {
1377 node.stable_ptr().untyped()
1378 }
1379}
1380#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1381pub struct ExprFieldInitShorthand {
1382 node: SyntaxNode,
1383 children: Arc<[SyntaxNode]>,
1384}
1385impl ExprFieldInitShorthand {
1386 pub const INDEX_NAME: usize = 0;
1387 pub fn new_green(
1388 db: &dyn SyntaxGroup,
1389 name: TerminalIdentifierGreen,
1390 ) -> ExprFieldInitShorthandGreen {
1391 let children: Vec<GreenId> = vec![name.0];
1392 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1393 ExprFieldInitShorthandGreen(
1394 Arc::new(GreenNode {
1395 kind: SyntaxKind::ExprFieldInitShorthand,
1396 details: GreenNodeDetails::Node { children, width },
1397 })
1398 .intern(db),
1399 )
1400 }
1401}
1402impl ExprFieldInitShorthand {
1403 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1404 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1405 }
1406}
1407#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1408pub struct ExprFieldInitShorthandPtr(pub SyntaxStablePtrId);
1409impl ExprFieldInitShorthandPtr {}
1410impl TypedStablePtr for ExprFieldInitShorthandPtr {
1411 type SyntaxNode = ExprFieldInitShorthand;
1412 fn untyped(&self) -> SyntaxStablePtrId {
1413 self.0
1414 }
1415 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFieldInitShorthand {
1416 ExprFieldInitShorthand::from_syntax_node(db, self.0.lookup(db))
1417 }
1418}
1419impl From<ExprFieldInitShorthandPtr> for SyntaxStablePtrId {
1420 fn from(ptr: ExprFieldInitShorthandPtr) -> Self {
1421 ptr.untyped()
1422 }
1423}
1424#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1425pub struct ExprFieldInitShorthandGreen(pub GreenId);
1426impl TypedSyntaxNode for ExprFieldInitShorthand {
1427 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFieldInitShorthand);
1428 type StablePtr = ExprFieldInitShorthandPtr;
1429 type Green = ExprFieldInitShorthandGreen;
1430 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1431 ExprFieldInitShorthandGreen(
1432 Arc::new(GreenNode {
1433 kind: SyntaxKind::ExprFieldInitShorthand,
1434 details: GreenNodeDetails::Node {
1435 children: vec![TerminalIdentifier::missing(db).0],
1436 width: TextWidth::default(),
1437 },
1438 })
1439 .intern(db),
1440 )
1441 }
1442 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1443 let kind = node.kind(db);
1444 assert_eq!(
1445 kind,
1446 SyntaxKind::ExprFieldInitShorthand,
1447 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1448 kind,
1449 SyntaxKind::ExprFieldInitShorthand
1450 );
1451 let children = db.get_children(node.clone());
1452 Self { node, children }
1453 }
1454 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1455 let kind = node.kind(db);
1456 if kind == SyntaxKind::ExprFieldInitShorthand {
1457 Some(Self::from_syntax_node(db, node))
1458 } else {
1459 None
1460 }
1461 }
1462 fn as_syntax_node(&self) -> SyntaxNode {
1463 self.node.clone()
1464 }
1465 fn stable_ptr(&self) -> Self::StablePtr {
1466 ExprFieldInitShorthandPtr(self.node.0.stable_ptr)
1467 }
1468}
1469impl From<&ExprFieldInitShorthand> for SyntaxStablePtrId {
1470 fn from(node: &ExprFieldInitShorthand) -> Self {
1471 node.stable_ptr().untyped()
1472 }
1473}
1474#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1475pub struct ArgList(ElementList<Arg, 2>);
1476impl Deref for ArgList {
1477 type Target = ElementList<Arg, 2>;
1478 fn deref(&self) -> &Self::Target {
1479 &self.0
1480 }
1481}
1482impl ArgList {
1483 pub fn new_green(
1484 db: &dyn SyntaxGroup,
1485 children: Vec<ArgListElementOrSeparatorGreen>,
1486 ) -> ArgListGreen {
1487 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
1488 ArgListGreen(
1489 Arc::new(GreenNode {
1490 kind: SyntaxKind::ArgList,
1491 details: GreenNodeDetails::Node {
1492 children: children.iter().map(|x| x.id()).collect(),
1493 width,
1494 },
1495 })
1496 .intern(db),
1497 )
1498 }
1499}
1500#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1501pub struct ArgListPtr(pub SyntaxStablePtrId);
1502impl TypedStablePtr for ArgListPtr {
1503 type SyntaxNode = ArgList;
1504 fn untyped(&self) -> SyntaxStablePtrId {
1505 self.0
1506 }
1507 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgList {
1508 ArgList::from_syntax_node(db, self.0.lookup(db))
1509 }
1510}
1511impl From<ArgListPtr> for SyntaxStablePtrId {
1512 fn from(ptr: ArgListPtr) -> Self {
1513 ptr.untyped()
1514 }
1515}
1516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1517pub enum ArgListElementOrSeparatorGreen {
1518 Separator(TerminalCommaGreen),
1519 Element(ArgGreen),
1520}
1521impl From<TerminalCommaGreen> for ArgListElementOrSeparatorGreen {
1522 fn from(value: TerminalCommaGreen) -> Self {
1523 ArgListElementOrSeparatorGreen::Separator(value)
1524 }
1525}
1526impl From<ArgGreen> for ArgListElementOrSeparatorGreen {
1527 fn from(value: ArgGreen) -> Self {
1528 ArgListElementOrSeparatorGreen::Element(value)
1529 }
1530}
1531impl ArgListElementOrSeparatorGreen {
1532 fn id(&self) -> GreenId {
1533 match self {
1534 ArgListElementOrSeparatorGreen::Separator(green) => green.0,
1535 ArgListElementOrSeparatorGreen::Element(green) => green.0,
1536 }
1537 }
1538}
1539#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1540pub struct ArgListGreen(pub GreenId);
1541impl TypedSyntaxNode for ArgList {
1542 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgList);
1543 type StablePtr = ArgListPtr;
1544 type Green = ArgListGreen;
1545 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1546 ArgListGreen(
1547 Arc::new(GreenNode {
1548 kind: SyntaxKind::ArgList,
1549 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1550 })
1551 .intern(db),
1552 )
1553 }
1554 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1555 Self(ElementList::new(node))
1556 }
1557 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1558 if node.kind(db) == SyntaxKind::ArgList { Some(Self(ElementList::new(node))) } else { None }
1559 }
1560 fn as_syntax_node(&self) -> SyntaxNode {
1561 self.node.clone()
1562 }
1563 fn stable_ptr(&self) -> Self::StablePtr {
1564 ArgListPtr(self.node.0.stable_ptr)
1565 }
1566}
1567impl From<&ArgList> for SyntaxStablePtrId {
1568 fn from(node: &ArgList) -> Self {
1569 node.stable_ptr().untyped()
1570 }
1571}
1572#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1573pub struct ExprMissing {
1574 node: SyntaxNode,
1575 children: Arc<[SyntaxNode]>,
1576}
1577impl ExprMissing {
1578 pub fn new_green(db: &dyn SyntaxGroup) -> ExprMissingGreen {
1579 let children: Vec<GreenId> = vec![];
1580 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1581 ExprMissingGreen(
1582 Arc::new(GreenNode {
1583 kind: SyntaxKind::ExprMissing,
1584 details: GreenNodeDetails::Node { children, width },
1585 })
1586 .intern(db),
1587 )
1588 }
1589}
1590impl ExprMissing {}
1591#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1592pub struct ExprMissingPtr(pub SyntaxStablePtrId);
1593impl ExprMissingPtr {}
1594impl TypedStablePtr for ExprMissingPtr {
1595 type SyntaxNode = ExprMissing;
1596 fn untyped(&self) -> SyntaxStablePtrId {
1597 self.0
1598 }
1599 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprMissing {
1600 ExprMissing::from_syntax_node(db, self.0.lookup(db))
1601 }
1602}
1603impl From<ExprMissingPtr> for SyntaxStablePtrId {
1604 fn from(ptr: ExprMissingPtr) -> Self {
1605 ptr.untyped()
1606 }
1607}
1608#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1609pub struct ExprMissingGreen(pub GreenId);
1610impl TypedSyntaxNode for ExprMissing {
1611 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprMissing);
1612 type StablePtr = ExprMissingPtr;
1613 type Green = ExprMissingGreen;
1614 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1615 ExprMissingGreen(
1616 Arc::new(GreenNode {
1617 kind: SyntaxKind::ExprMissing,
1618 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1619 })
1620 .intern(db),
1621 )
1622 }
1623 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1624 let kind = node.kind(db);
1625 assert_eq!(
1626 kind,
1627 SyntaxKind::ExprMissing,
1628 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1629 kind,
1630 SyntaxKind::ExprMissing
1631 );
1632 let children = db.get_children(node.clone());
1633 Self { node, children }
1634 }
1635 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1636 let kind = node.kind(db);
1637 if kind == SyntaxKind::ExprMissing { Some(Self::from_syntax_node(db, node)) } else { None }
1638 }
1639 fn as_syntax_node(&self) -> SyntaxNode {
1640 self.node.clone()
1641 }
1642 fn stable_ptr(&self) -> Self::StablePtr {
1643 ExprMissingPtr(self.node.0.stable_ptr)
1644 }
1645}
1646impl From<&ExprMissing> for SyntaxStablePtrId {
1647 fn from(node: &ExprMissing) -> Self {
1648 node.stable_ptr().untyped()
1649 }
1650}
1651#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1652pub enum PathSegment {
1653 WithGenericArgs(PathSegmentWithGenericArgs),
1654 Simple(PathSegmentSimple),
1655}
1656#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1657pub struct PathSegmentPtr(pub SyntaxStablePtrId);
1658impl TypedStablePtr for PathSegmentPtr {
1659 type SyntaxNode = PathSegment;
1660 fn untyped(&self) -> SyntaxStablePtrId {
1661 self.0
1662 }
1663 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegment {
1664 PathSegment::from_syntax_node(db, self.0.lookup(db))
1665 }
1666}
1667impl From<PathSegmentPtr> for SyntaxStablePtrId {
1668 fn from(ptr: PathSegmentPtr) -> Self {
1669 ptr.untyped()
1670 }
1671}
1672impl From<PathSegmentWithGenericArgsPtr> for PathSegmentPtr {
1673 fn from(value: PathSegmentWithGenericArgsPtr) -> Self {
1674 Self(value.0)
1675 }
1676}
1677impl From<PathSegmentSimplePtr> for PathSegmentPtr {
1678 fn from(value: PathSegmentSimplePtr) -> Self {
1679 Self(value.0)
1680 }
1681}
1682impl From<PathSegmentWithGenericArgsGreen> for PathSegmentGreen {
1683 fn from(value: PathSegmentWithGenericArgsGreen) -> Self {
1684 Self(value.0)
1685 }
1686}
1687impl From<PathSegmentSimpleGreen> for PathSegmentGreen {
1688 fn from(value: PathSegmentSimpleGreen) -> Self {
1689 Self(value.0)
1690 }
1691}
1692#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1693pub struct PathSegmentGreen(pub GreenId);
1694impl TypedSyntaxNode for PathSegment {
1695 const OPTIONAL_KIND: Option<SyntaxKind> = None;
1696 type StablePtr = PathSegmentPtr;
1697 type Green = PathSegmentGreen;
1698 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1699 PathSegmentGreen(PathSegmentSimple::missing(db).0)
1700 }
1701 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1702 let kind = node.kind(db);
1703 match kind {
1704 SyntaxKind::PathSegmentWithGenericArgs => {
1705 PathSegment::WithGenericArgs(PathSegmentWithGenericArgs::from_syntax_node(db, node))
1706 }
1707 SyntaxKind::PathSegmentSimple => {
1708 PathSegment::Simple(PathSegmentSimple::from_syntax_node(db, node))
1709 }
1710 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "PathSegment"),
1711 }
1712 }
1713 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1714 let kind = node.kind(db);
1715 match kind {
1716 SyntaxKind::PathSegmentWithGenericArgs => Some(PathSegment::WithGenericArgs(
1717 PathSegmentWithGenericArgs::from_syntax_node(db, node),
1718 )),
1719 SyntaxKind::PathSegmentSimple => {
1720 Some(PathSegment::Simple(PathSegmentSimple::from_syntax_node(db, node)))
1721 }
1722 _ => None,
1723 }
1724 }
1725 fn as_syntax_node(&self) -> SyntaxNode {
1726 match self {
1727 PathSegment::WithGenericArgs(x) => x.as_syntax_node(),
1728 PathSegment::Simple(x) => x.as_syntax_node(),
1729 }
1730 }
1731 fn stable_ptr(&self) -> Self::StablePtr {
1732 PathSegmentPtr(self.as_syntax_node().0.stable_ptr)
1733 }
1734}
1735impl From<&PathSegment> for SyntaxStablePtrId {
1736 fn from(node: &PathSegment) -> Self {
1737 node.stable_ptr().untyped()
1738 }
1739}
1740impl PathSegment {
1741 pub fn is_variant(kind: SyntaxKind) -> bool {
1743 matches!(kind, SyntaxKind::PathSegmentWithGenericArgs | SyntaxKind::PathSegmentSimple)
1744 }
1745}
1746#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1747pub struct PathSegmentSimple {
1748 node: SyntaxNode,
1749 children: Arc<[SyntaxNode]>,
1750}
1751impl PathSegmentSimple {
1752 pub const INDEX_IDENT: usize = 0;
1753 pub fn new_green(
1754 db: &dyn SyntaxGroup,
1755 ident: TerminalIdentifierGreen,
1756 ) -> PathSegmentSimpleGreen {
1757 let children: Vec<GreenId> = vec![ident.0];
1758 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1759 PathSegmentSimpleGreen(
1760 Arc::new(GreenNode {
1761 kind: SyntaxKind::PathSegmentSimple,
1762 details: GreenNodeDetails::Node { children, width },
1763 })
1764 .intern(db),
1765 )
1766 }
1767}
1768impl PathSegmentSimple {
1769 pub fn ident(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1770 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1771 }
1772}
1773#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1774pub struct PathSegmentSimplePtr(pub SyntaxStablePtrId);
1775impl PathSegmentSimplePtr {}
1776impl TypedStablePtr for PathSegmentSimplePtr {
1777 type SyntaxNode = PathSegmentSimple;
1778 fn untyped(&self) -> SyntaxStablePtrId {
1779 self.0
1780 }
1781 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegmentSimple {
1782 PathSegmentSimple::from_syntax_node(db, self.0.lookup(db))
1783 }
1784}
1785impl From<PathSegmentSimplePtr> for SyntaxStablePtrId {
1786 fn from(ptr: PathSegmentSimplePtr) -> Self {
1787 ptr.untyped()
1788 }
1789}
1790#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1791pub struct PathSegmentSimpleGreen(pub GreenId);
1792impl TypedSyntaxNode for PathSegmentSimple {
1793 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PathSegmentSimple);
1794 type StablePtr = PathSegmentSimplePtr;
1795 type Green = PathSegmentSimpleGreen;
1796 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1797 PathSegmentSimpleGreen(
1798 Arc::new(GreenNode {
1799 kind: SyntaxKind::PathSegmentSimple,
1800 details: GreenNodeDetails::Node {
1801 children: vec![TerminalIdentifier::missing(db).0],
1802 width: TextWidth::default(),
1803 },
1804 })
1805 .intern(db),
1806 )
1807 }
1808 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1809 let kind = node.kind(db);
1810 assert_eq!(
1811 kind,
1812 SyntaxKind::PathSegmentSimple,
1813 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1814 kind,
1815 SyntaxKind::PathSegmentSimple
1816 );
1817 let children = db.get_children(node.clone());
1818 Self { node, children }
1819 }
1820 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1821 let kind = node.kind(db);
1822 if kind == SyntaxKind::PathSegmentSimple {
1823 Some(Self::from_syntax_node(db, node))
1824 } else {
1825 None
1826 }
1827 }
1828 fn as_syntax_node(&self) -> SyntaxNode {
1829 self.node.clone()
1830 }
1831 fn stable_ptr(&self) -> Self::StablePtr {
1832 PathSegmentSimplePtr(self.node.0.stable_ptr)
1833 }
1834}
1835impl From<&PathSegmentSimple> for SyntaxStablePtrId {
1836 fn from(node: &PathSegmentSimple) -> Self {
1837 node.stable_ptr().untyped()
1838 }
1839}
1840#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1841pub enum OptionTerminalColonColon {
1842 Empty(OptionTerminalColonColonEmpty),
1843 TerminalColonColon(TerminalColonColon),
1844}
1845#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1846pub struct OptionTerminalColonColonPtr(pub SyntaxStablePtrId);
1847impl TypedStablePtr for OptionTerminalColonColonPtr {
1848 type SyntaxNode = OptionTerminalColonColon;
1849 fn untyped(&self) -> SyntaxStablePtrId {
1850 self.0
1851 }
1852 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColon {
1853 OptionTerminalColonColon::from_syntax_node(db, self.0.lookup(db))
1854 }
1855}
1856impl From<OptionTerminalColonColonPtr> for SyntaxStablePtrId {
1857 fn from(ptr: OptionTerminalColonColonPtr) -> Self {
1858 ptr.untyped()
1859 }
1860}
1861impl From<OptionTerminalColonColonEmptyPtr> for OptionTerminalColonColonPtr {
1862 fn from(value: OptionTerminalColonColonEmptyPtr) -> Self {
1863 Self(value.0)
1864 }
1865}
1866impl From<TerminalColonColonPtr> for OptionTerminalColonColonPtr {
1867 fn from(value: TerminalColonColonPtr) -> Self {
1868 Self(value.0)
1869 }
1870}
1871impl From<OptionTerminalColonColonEmptyGreen> for OptionTerminalColonColonGreen {
1872 fn from(value: OptionTerminalColonColonEmptyGreen) -> Self {
1873 Self(value.0)
1874 }
1875}
1876impl From<TerminalColonColonGreen> for OptionTerminalColonColonGreen {
1877 fn from(value: TerminalColonColonGreen) -> Self {
1878 Self(value.0)
1879 }
1880}
1881#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1882pub struct OptionTerminalColonColonGreen(pub GreenId);
1883impl TypedSyntaxNode for OptionTerminalColonColon {
1884 const OPTIONAL_KIND: Option<SyntaxKind> = None;
1885 type StablePtr = OptionTerminalColonColonPtr;
1886 type Green = OptionTerminalColonColonGreen;
1887 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1888 panic!("No missing variant.");
1889 }
1890 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1891 let kind = node.kind(db);
1892 match kind {
1893 SyntaxKind::OptionTerminalColonColonEmpty => OptionTerminalColonColon::Empty(
1894 OptionTerminalColonColonEmpty::from_syntax_node(db, node),
1895 ),
1896 SyntaxKind::TerminalColonColon => OptionTerminalColonColon::TerminalColonColon(
1897 TerminalColonColon::from_syntax_node(db, node),
1898 ),
1899 _ => panic!(
1900 "Unexpected syntax kind {:?} when constructing {}.",
1901 kind, "OptionTerminalColonColon"
1902 ),
1903 }
1904 }
1905 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
1906 let kind = node.kind(db);
1907 match kind {
1908 SyntaxKind::OptionTerminalColonColonEmpty => Some(OptionTerminalColonColon::Empty(
1909 OptionTerminalColonColonEmpty::from_syntax_node(db, node),
1910 )),
1911 SyntaxKind::TerminalColonColon => Some(OptionTerminalColonColon::TerminalColonColon(
1912 TerminalColonColon::from_syntax_node(db, node),
1913 )),
1914 _ => None,
1915 }
1916 }
1917 fn as_syntax_node(&self) -> SyntaxNode {
1918 match self {
1919 OptionTerminalColonColon::Empty(x) => x.as_syntax_node(),
1920 OptionTerminalColonColon::TerminalColonColon(x) => x.as_syntax_node(),
1921 }
1922 }
1923 fn stable_ptr(&self) -> Self::StablePtr {
1924 OptionTerminalColonColonPtr(self.as_syntax_node().0.stable_ptr)
1925 }
1926}
1927impl From<&OptionTerminalColonColon> for SyntaxStablePtrId {
1928 fn from(node: &OptionTerminalColonColon) -> Self {
1929 node.stable_ptr().untyped()
1930 }
1931}
1932impl OptionTerminalColonColon {
1933 pub fn is_variant(kind: SyntaxKind) -> bool {
1935 matches!(kind, SyntaxKind::OptionTerminalColonColonEmpty | SyntaxKind::TerminalColonColon)
1936 }
1937}
1938#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1939pub struct OptionTerminalColonColonEmpty {
1940 node: SyntaxNode,
1941 children: Arc<[SyntaxNode]>,
1942}
1943impl OptionTerminalColonColonEmpty {
1944 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalColonColonEmptyGreen {
1945 let children: Vec<GreenId> = vec![];
1946 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1947 OptionTerminalColonColonEmptyGreen(
1948 Arc::new(GreenNode {
1949 kind: SyntaxKind::OptionTerminalColonColonEmpty,
1950 details: GreenNodeDetails::Node { children, width },
1951 })
1952 .intern(db),
1953 )
1954 }
1955}
1956impl OptionTerminalColonColonEmpty {}
1957#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1958pub struct OptionTerminalColonColonEmptyPtr(pub SyntaxStablePtrId);
1959impl OptionTerminalColonColonEmptyPtr {}
1960impl TypedStablePtr for OptionTerminalColonColonEmptyPtr {
1961 type SyntaxNode = OptionTerminalColonColonEmpty;
1962 fn untyped(&self) -> SyntaxStablePtrId {
1963 self.0
1964 }
1965 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColonEmpty {
1966 OptionTerminalColonColonEmpty::from_syntax_node(db, self.0.lookup(db))
1967 }
1968}
1969impl From<OptionTerminalColonColonEmptyPtr> for SyntaxStablePtrId {
1970 fn from(ptr: OptionTerminalColonColonEmptyPtr) -> Self {
1971 ptr.untyped()
1972 }
1973}
1974#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1975pub struct OptionTerminalColonColonEmptyGreen(pub GreenId);
1976impl TypedSyntaxNode for OptionTerminalColonColonEmpty {
1977 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalColonColonEmpty);
1978 type StablePtr = OptionTerminalColonColonEmptyPtr;
1979 type Green = OptionTerminalColonColonEmptyGreen;
1980 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1981 OptionTerminalColonColonEmptyGreen(
1982 Arc::new(GreenNode {
1983 kind: SyntaxKind::OptionTerminalColonColonEmpty,
1984 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1985 })
1986 .intern(db),
1987 )
1988 }
1989 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1990 let kind = node.kind(db);
1991 assert_eq!(
1992 kind,
1993 SyntaxKind::OptionTerminalColonColonEmpty,
1994 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1995 kind,
1996 SyntaxKind::OptionTerminalColonColonEmpty
1997 );
1998 let children = db.get_children(node.clone());
1999 Self { node, children }
2000 }
2001 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2002 let kind = node.kind(db);
2003 if kind == SyntaxKind::OptionTerminalColonColonEmpty {
2004 Some(Self::from_syntax_node(db, node))
2005 } else {
2006 None
2007 }
2008 }
2009 fn as_syntax_node(&self) -> SyntaxNode {
2010 self.node.clone()
2011 }
2012 fn stable_ptr(&self) -> Self::StablePtr {
2013 OptionTerminalColonColonEmptyPtr(self.node.0.stable_ptr)
2014 }
2015}
2016impl From<&OptionTerminalColonColonEmpty> for SyntaxStablePtrId {
2017 fn from(node: &OptionTerminalColonColonEmpty) -> Self {
2018 node.stable_ptr().untyped()
2019 }
2020}
2021#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2022pub struct PathSegmentWithGenericArgs {
2023 node: SyntaxNode,
2024 children: Arc<[SyntaxNode]>,
2025}
2026impl PathSegmentWithGenericArgs {
2027 pub const INDEX_IDENT: usize = 0;
2028 pub const INDEX_SEPARATOR: usize = 1;
2029 pub const INDEX_GENERIC_ARGS: usize = 2;
2030 pub fn new_green(
2031 db: &dyn SyntaxGroup,
2032 ident: TerminalIdentifierGreen,
2033 separator: OptionTerminalColonColonGreen,
2034 generic_args: GenericArgsGreen,
2035 ) -> PathSegmentWithGenericArgsGreen {
2036 let children: Vec<GreenId> = vec![ident.0, separator.0, generic_args.0];
2037 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2038 PathSegmentWithGenericArgsGreen(
2039 Arc::new(GreenNode {
2040 kind: SyntaxKind::PathSegmentWithGenericArgs,
2041 details: GreenNodeDetails::Node { children, width },
2042 })
2043 .intern(db),
2044 )
2045 }
2046}
2047impl PathSegmentWithGenericArgs {
2048 pub fn ident(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
2049 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
2050 }
2051 pub fn separator(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColon {
2052 OptionTerminalColonColon::from_syntax_node(db, self.children[1].clone())
2053 }
2054 pub fn generic_args(&self, db: &dyn SyntaxGroup) -> GenericArgs {
2055 GenericArgs::from_syntax_node(db, self.children[2].clone())
2056 }
2057}
2058#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2059pub struct PathSegmentWithGenericArgsPtr(pub SyntaxStablePtrId);
2060impl PathSegmentWithGenericArgsPtr {}
2061impl TypedStablePtr for PathSegmentWithGenericArgsPtr {
2062 type SyntaxNode = PathSegmentWithGenericArgs;
2063 fn untyped(&self) -> SyntaxStablePtrId {
2064 self.0
2065 }
2066 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegmentWithGenericArgs {
2067 PathSegmentWithGenericArgs::from_syntax_node(db, self.0.lookup(db))
2068 }
2069}
2070impl From<PathSegmentWithGenericArgsPtr> for SyntaxStablePtrId {
2071 fn from(ptr: PathSegmentWithGenericArgsPtr) -> Self {
2072 ptr.untyped()
2073 }
2074}
2075#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2076pub struct PathSegmentWithGenericArgsGreen(pub GreenId);
2077impl TypedSyntaxNode for PathSegmentWithGenericArgs {
2078 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PathSegmentWithGenericArgs);
2079 type StablePtr = PathSegmentWithGenericArgsPtr;
2080 type Green = PathSegmentWithGenericArgsGreen;
2081 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2082 PathSegmentWithGenericArgsGreen(
2083 Arc::new(GreenNode {
2084 kind: SyntaxKind::PathSegmentWithGenericArgs,
2085 details: GreenNodeDetails::Node {
2086 children: vec![
2087 TerminalIdentifier::missing(db).0,
2088 OptionTerminalColonColon::missing(db).0,
2089 GenericArgs::missing(db).0,
2090 ],
2091 width: TextWidth::default(),
2092 },
2093 })
2094 .intern(db),
2095 )
2096 }
2097 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2098 let kind = node.kind(db);
2099 assert_eq!(
2100 kind,
2101 SyntaxKind::PathSegmentWithGenericArgs,
2102 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2103 kind,
2104 SyntaxKind::PathSegmentWithGenericArgs
2105 );
2106 let children = db.get_children(node.clone());
2107 Self { node, children }
2108 }
2109 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2110 let kind = node.kind(db);
2111 if kind == SyntaxKind::PathSegmentWithGenericArgs {
2112 Some(Self::from_syntax_node(db, node))
2113 } else {
2114 None
2115 }
2116 }
2117 fn as_syntax_node(&self) -> SyntaxNode {
2118 self.node.clone()
2119 }
2120 fn stable_ptr(&self) -> Self::StablePtr {
2121 PathSegmentWithGenericArgsPtr(self.node.0.stable_ptr)
2122 }
2123}
2124impl From<&PathSegmentWithGenericArgs> for SyntaxStablePtrId {
2125 fn from(node: &PathSegmentWithGenericArgs) -> Self {
2126 node.stable_ptr().untyped()
2127 }
2128}
2129#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2130pub struct ExprPath(ElementList<PathSegment, 2>);
2131impl Deref for ExprPath {
2132 type Target = ElementList<PathSegment, 2>;
2133 fn deref(&self) -> &Self::Target {
2134 &self.0
2135 }
2136}
2137impl ExprPath {
2138 pub fn new_green(
2139 db: &dyn SyntaxGroup,
2140 children: Vec<ExprPathElementOrSeparatorGreen>,
2141 ) -> ExprPathGreen {
2142 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
2143 ExprPathGreen(
2144 Arc::new(GreenNode {
2145 kind: SyntaxKind::ExprPath,
2146 details: GreenNodeDetails::Node {
2147 children: children.iter().map(|x| x.id()).collect(),
2148 width,
2149 },
2150 })
2151 .intern(db),
2152 )
2153 }
2154}
2155#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2156pub struct ExprPathPtr(pub SyntaxStablePtrId);
2157impl TypedStablePtr for ExprPathPtr {
2158 type SyntaxNode = ExprPath;
2159 fn untyped(&self) -> SyntaxStablePtrId {
2160 self.0
2161 }
2162 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprPath {
2163 ExprPath::from_syntax_node(db, self.0.lookup(db))
2164 }
2165}
2166impl From<ExprPathPtr> for SyntaxStablePtrId {
2167 fn from(ptr: ExprPathPtr) -> Self {
2168 ptr.untyped()
2169 }
2170}
2171#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2172pub enum ExprPathElementOrSeparatorGreen {
2173 Separator(TerminalColonColonGreen),
2174 Element(PathSegmentGreen),
2175}
2176impl From<TerminalColonColonGreen> for ExprPathElementOrSeparatorGreen {
2177 fn from(value: TerminalColonColonGreen) -> Self {
2178 ExprPathElementOrSeparatorGreen::Separator(value)
2179 }
2180}
2181impl From<PathSegmentGreen> for ExprPathElementOrSeparatorGreen {
2182 fn from(value: PathSegmentGreen) -> Self {
2183 ExprPathElementOrSeparatorGreen::Element(value)
2184 }
2185}
2186impl ExprPathElementOrSeparatorGreen {
2187 fn id(&self) -> GreenId {
2188 match self {
2189 ExprPathElementOrSeparatorGreen::Separator(green) => green.0,
2190 ExprPathElementOrSeparatorGreen::Element(green) => green.0,
2191 }
2192 }
2193}
2194#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2195pub struct ExprPathGreen(pub GreenId);
2196impl TypedSyntaxNode for ExprPath {
2197 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprPath);
2198 type StablePtr = ExprPathPtr;
2199 type Green = ExprPathGreen;
2200 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2201 ExprPathGreen(
2202 Arc::new(GreenNode {
2203 kind: SyntaxKind::ExprPath,
2204 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
2205 })
2206 .intern(db),
2207 )
2208 }
2209 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2210 Self(ElementList::new(node))
2211 }
2212 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2213 if node.kind(db) == SyntaxKind::ExprPath {
2214 Some(Self(ElementList::new(node)))
2215 } else {
2216 None
2217 }
2218 }
2219 fn as_syntax_node(&self) -> SyntaxNode {
2220 self.node.clone()
2221 }
2222 fn stable_ptr(&self) -> Self::StablePtr {
2223 ExprPathPtr(self.node.0.stable_ptr)
2224 }
2225}
2226impl From<&ExprPath> for SyntaxStablePtrId {
2227 fn from(node: &ExprPath) -> Self {
2228 node.stable_ptr().untyped()
2229 }
2230}
2231#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2232pub struct ExprParenthesized {
2233 node: SyntaxNode,
2234 children: Arc<[SyntaxNode]>,
2235}
2236impl ExprParenthesized {
2237 pub const INDEX_LPAREN: usize = 0;
2238 pub const INDEX_EXPR: usize = 1;
2239 pub const INDEX_RPAREN: usize = 2;
2240 pub fn new_green(
2241 db: &dyn SyntaxGroup,
2242 lparen: TerminalLParenGreen,
2243 expr: ExprGreen,
2244 rparen: TerminalRParenGreen,
2245 ) -> ExprParenthesizedGreen {
2246 let children: Vec<GreenId> = vec![lparen.0, expr.0, rparen.0];
2247 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2248 ExprParenthesizedGreen(
2249 Arc::new(GreenNode {
2250 kind: SyntaxKind::ExprParenthesized,
2251 details: GreenNodeDetails::Node { children, width },
2252 })
2253 .intern(db),
2254 )
2255 }
2256}
2257impl ExprParenthesized {
2258 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
2259 TerminalLParen::from_syntax_node(db, self.children[0].clone())
2260 }
2261 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
2262 Expr::from_syntax_node(db, self.children[1].clone())
2263 }
2264 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
2265 TerminalRParen::from_syntax_node(db, self.children[2].clone())
2266 }
2267}
2268#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2269pub struct ExprParenthesizedPtr(pub SyntaxStablePtrId);
2270impl ExprParenthesizedPtr {}
2271impl TypedStablePtr for ExprParenthesizedPtr {
2272 type SyntaxNode = ExprParenthesized;
2273 fn untyped(&self) -> SyntaxStablePtrId {
2274 self.0
2275 }
2276 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprParenthesized {
2277 ExprParenthesized::from_syntax_node(db, self.0.lookup(db))
2278 }
2279}
2280impl From<ExprParenthesizedPtr> for SyntaxStablePtrId {
2281 fn from(ptr: ExprParenthesizedPtr) -> Self {
2282 ptr.untyped()
2283 }
2284}
2285#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2286pub struct ExprParenthesizedGreen(pub GreenId);
2287impl TypedSyntaxNode for ExprParenthesized {
2288 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprParenthesized);
2289 type StablePtr = ExprParenthesizedPtr;
2290 type Green = ExprParenthesizedGreen;
2291 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2292 ExprParenthesizedGreen(
2293 Arc::new(GreenNode {
2294 kind: SyntaxKind::ExprParenthesized,
2295 details: GreenNodeDetails::Node {
2296 children: vec![
2297 TerminalLParen::missing(db).0,
2298 Expr::missing(db).0,
2299 TerminalRParen::missing(db).0,
2300 ],
2301 width: TextWidth::default(),
2302 },
2303 })
2304 .intern(db),
2305 )
2306 }
2307 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2308 let kind = node.kind(db);
2309 assert_eq!(
2310 kind,
2311 SyntaxKind::ExprParenthesized,
2312 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2313 kind,
2314 SyntaxKind::ExprParenthesized
2315 );
2316 let children = db.get_children(node.clone());
2317 Self { node, children }
2318 }
2319 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2320 let kind = node.kind(db);
2321 if kind == SyntaxKind::ExprParenthesized {
2322 Some(Self::from_syntax_node(db, node))
2323 } else {
2324 None
2325 }
2326 }
2327 fn as_syntax_node(&self) -> SyntaxNode {
2328 self.node.clone()
2329 }
2330 fn stable_ptr(&self) -> Self::StablePtr {
2331 ExprParenthesizedPtr(self.node.0.stable_ptr)
2332 }
2333}
2334impl From<&ExprParenthesized> for SyntaxStablePtrId {
2335 fn from(node: &ExprParenthesized) -> Self {
2336 node.stable_ptr().untyped()
2337 }
2338}
2339#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2340pub struct ExprUnary {
2341 node: SyntaxNode,
2342 children: Arc<[SyntaxNode]>,
2343}
2344impl ExprUnary {
2345 pub const INDEX_OP: usize = 0;
2346 pub const INDEX_EXPR: usize = 1;
2347 pub fn new_green(
2348 db: &dyn SyntaxGroup,
2349 op: UnaryOperatorGreen,
2350 expr: ExprGreen,
2351 ) -> ExprUnaryGreen {
2352 let children: Vec<GreenId> = vec![op.0, expr.0];
2353 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2354 ExprUnaryGreen(
2355 Arc::new(GreenNode {
2356 kind: SyntaxKind::ExprUnary,
2357 details: GreenNodeDetails::Node { children, width },
2358 })
2359 .intern(db),
2360 )
2361 }
2362}
2363impl ExprUnary {
2364 pub fn op(&self, db: &dyn SyntaxGroup) -> UnaryOperator {
2365 UnaryOperator::from_syntax_node(db, self.children[0].clone())
2366 }
2367 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
2368 Expr::from_syntax_node(db, self.children[1].clone())
2369 }
2370}
2371#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2372pub struct ExprUnaryPtr(pub SyntaxStablePtrId);
2373impl ExprUnaryPtr {}
2374impl TypedStablePtr for ExprUnaryPtr {
2375 type SyntaxNode = ExprUnary;
2376 fn untyped(&self) -> SyntaxStablePtrId {
2377 self.0
2378 }
2379 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprUnary {
2380 ExprUnary::from_syntax_node(db, self.0.lookup(db))
2381 }
2382}
2383impl From<ExprUnaryPtr> for SyntaxStablePtrId {
2384 fn from(ptr: ExprUnaryPtr) -> Self {
2385 ptr.untyped()
2386 }
2387}
2388#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2389pub struct ExprUnaryGreen(pub GreenId);
2390impl TypedSyntaxNode for ExprUnary {
2391 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprUnary);
2392 type StablePtr = ExprUnaryPtr;
2393 type Green = ExprUnaryGreen;
2394 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2395 ExprUnaryGreen(
2396 Arc::new(GreenNode {
2397 kind: SyntaxKind::ExprUnary,
2398 details: GreenNodeDetails::Node {
2399 children: vec![UnaryOperator::missing(db).0, Expr::missing(db).0],
2400 width: TextWidth::default(),
2401 },
2402 })
2403 .intern(db),
2404 )
2405 }
2406 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2407 let kind = node.kind(db);
2408 assert_eq!(
2409 kind,
2410 SyntaxKind::ExprUnary,
2411 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2412 kind,
2413 SyntaxKind::ExprUnary
2414 );
2415 let children = db.get_children(node.clone());
2416 Self { node, children }
2417 }
2418 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2419 let kind = node.kind(db);
2420 if kind == SyntaxKind::ExprUnary { Some(Self::from_syntax_node(db, node)) } else { None }
2421 }
2422 fn as_syntax_node(&self) -> SyntaxNode {
2423 self.node.clone()
2424 }
2425 fn stable_ptr(&self) -> Self::StablePtr {
2426 ExprUnaryPtr(self.node.0.stable_ptr)
2427 }
2428}
2429impl From<&ExprUnary> for SyntaxStablePtrId {
2430 fn from(node: &ExprUnary) -> Self {
2431 node.stable_ptr().untyped()
2432 }
2433}
2434#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2435pub enum UnaryOperator {
2436 Not(TerminalNot),
2437 BitNot(TerminalBitNot),
2438 Minus(TerminalMinus),
2439 At(TerminalAt),
2440 Desnap(TerminalMul),
2441}
2442#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2443pub struct UnaryOperatorPtr(pub SyntaxStablePtrId);
2444impl TypedStablePtr for UnaryOperatorPtr {
2445 type SyntaxNode = UnaryOperator;
2446 fn untyped(&self) -> SyntaxStablePtrId {
2447 self.0
2448 }
2449 fn lookup(&self, db: &dyn SyntaxGroup) -> UnaryOperator {
2450 UnaryOperator::from_syntax_node(db, self.0.lookup(db))
2451 }
2452}
2453impl From<UnaryOperatorPtr> for SyntaxStablePtrId {
2454 fn from(ptr: UnaryOperatorPtr) -> Self {
2455 ptr.untyped()
2456 }
2457}
2458impl From<TerminalNotPtr> for UnaryOperatorPtr {
2459 fn from(value: TerminalNotPtr) -> Self {
2460 Self(value.0)
2461 }
2462}
2463impl From<TerminalBitNotPtr> for UnaryOperatorPtr {
2464 fn from(value: TerminalBitNotPtr) -> Self {
2465 Self(value.0)
2466 }
2467}
2468impl From<TerminalMinusPtr> for UnaryOperatorPtr {
2469 fn from(value: TerminalMinusPtr) -> Self {
2470 Self(value.0)
2471 }
2472}
2473impl From<TerminalAtPtr> for UnaryOperatorPtr {
2474 fn from(value: TerminalAtPtr) -> Self {
2475 Self(value.0)
2476 }
2477}
2478impl From<TerminalMulPtr> for UnaryOperatorPtr {
2479 fn from(value: TerminalMulPtr) -> Self {
2480 Self(value.0)
2481 }
2482}
2483impl From<TerminalNotGreen> for UnaryOperatorGreen {
2484 fn from(value: TerminalNotGreen) -> Self {
2485 Self(value.0)
2486 }
2487}
2488impl From<TerminalBitNotGreen> for UnaryOperatorGreen {
2489 fn from(value: TerminalBitNotGreen) -> Self {
2490 Self(value.0)
2491 }
2492}
2493impl From<TerminalMinusGreen> for UnaryOperatorGreen {
2494 fn from(value: TerminalMinusGreen) -> Self {
2495 Self(value.0)
2496 }
2497}
2498impl From<TerminalAtGreen> for UnaryOperatorGreen {
2499 fn from(value: TerminalAtGreen) -> Self {
2500 Self(value.0)
2501 }
2502}
2503impl From<TerminalMulGreen> for UnaryOperatorGreen {
2504 fn from(value: TerminalMulGreen) -> Self {
2505 Self(value.0)
2506 }
2507}
2508#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2509pub struct UnaryOperatorGreen(pub GreenId);
2510impl TypedSyntaxNode for UnaryOperator {
2511 const OPTIONAL_KIND: Option<SyntaxKind> = None;
2512 type StablePtr = UnaryOperatorPtr;
2513 type Green = UnaryOperatorGreen;
2514 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2515 panic!("No missing variant.");
2516 }
2517 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2518 let kind = node.kind(db);
2519 match kind {
2520 SyntaxKind::TerminalNot => UnaryOperator::Not(TerminalNot::from_syntax_node(db, node)),
2521 SyntaxKind::TerminalBitNot => {
2522 UnaryOperator::BitNot(TerminalBitNot::from_syntax_node(db, node))
2523 }
2524 SyntaxKind::TerminalMinus => {
2525 UnaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))
2526 }
2527 SyntaxKind::TerminalAt => UnaryOperator::At(TerminalAt::from_syntax_node(db, node)),
2528 SyntaxKind::TerminalMul => {
2529 UnaryOperator::Desnap(TerminalMul::from_syntax_node(db, node))
2530 }
2531 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UnaryOperator"),
2532 }
2533 }
2534 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2535 let kind = node.kind(db);
2536 match kind {
2537 SyntaxKind::TerminalNot => {
2538 Some(UnaryOperator::Not(TerminalNot::from_syntax_node(db, node)))
2539 }
2540 SyntaxKind::TerminalBitNot => {
2541 Some(UnaryOperator::BitNot(TerminalBitNot::from_syntax_node(db, node)))
2542 }
2543 SyntaxKind::TerminalMinus => {
2544 Some(UnaryOperator::Minus(TerminalMinus::from_syntax_node(db, node)))
2545 }
2546 SyntaxKind::TerminalAt => {
2547 Some(UnaryOperator::At(TerminalAt::from_syntax_node(db, node)))
2548 }
2549 SyntaxKind::TerminalMul => {
2550 Some(UnaryOperator::Desnap(TerminalMul::from_syntax_node(db, node)))
2551 }
2552 _ => None,
2553 }
2554 }
2555 fn as_syntax_node(&self) -> SyntaxNode {
2556 match self {
2557 UnaryOperator::Not(x) => x.as_syntax_node(),
2558 UnaryOperator::BitNot(x) => x.as_syntax_node(),
2559 UnaryOperator::Minus(x) => x.as_syntax_node(),
2560 UnaryOperator::At(x) => x.as_syntax_node(),
2561 UnaryOperator::Desnap(x) => x.as_syntax_node(),
2562 }
2563 }
2564 fn stable_ptr(&self) -> Self::StablePtr {
2565 UnaryOperatorPtr(self.as_syntax_node().0.stable_ptr)
2566 }
2567}
2568impl From<&UnaryOperator> for SyntaxStablePtrId {
2569 fn from(node: &UnaryOperator) -> Self {
2570 node.stable_ptr().untyped()
2571 }
2572}
2573impl UnaryOperator {
2574 pub fn is_variant(kind: SyntaxKind) -> bool {
2576 matches!(
2577 kind,
2578 SyntaxKind::TerminalNot
2579 | SyntaxKind::TerminalBitNot
2580 | SyntaxKind::TerminalMinus
2581 | SyntaxKind::TerminalAt
2582 | SyntaxKind::TerminalMul
2583 )
2584 }
2585}
2586#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2587pub struct ExprBinary {
2588 node: SyntaxNode,
2589 children: Arc<[SyntaxNode]>,
2590}
2591impl ExprBinary {
2592 pub const INDEX_LHS: usize = 0;
2593 pub const INDEX_OP: usize = 1;
2594 pub const INDEX_RHS: usize = 2;
2595 pub fn new_green(
2596 db: &dyn SyntaxGroup,
2597 lhs: ExprGreen,
2598 op: BinaryOperatorGreen,
2599 rhs: ExprGreen,
2600 ) -> ExprBinaryGreen {
2601 let children: Vec<GreenId> = vec![lhs.0, op.0, rhs.0];
2602 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2603 ExprBinaryGreen(
2604 Arc::new(GreenNode {
2605 kind: SyntaxKind::ExprBinary,
2606 details: GreenNodeDetails::Node { children, width },
2607 })
2608 .intern(db),
2609 )
2610 }
2611}
2612impl ExprBinary {
2613 pub fn lhs(&self, db: &dyn SyntaxGroup) -> Expr {
2614 Expr::from_syntax_node(db, self.children[0].clone())
2615 }
2616 pub fn op(&self, db: &dyn SyntaxGroup) -> BinaryOperator {
2617 BinaryOperator::from_syntax_node(db, self.children[1].clone())
2618 }
2619 pub fn rhs(&self, db: &dyn SyntaxGroup) -> Expr {
2620 Expr::from_syntax_node(db, self.children[2].clone())
2621 }
2622}
2623#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2624pub struct ExprBinaryPtr(pub SyntaxStablePtrId);
2625impl ExprBinaryPtr {}
2626impl TypedStablePtr for ExprBinaryPtr {
2627 type SyntaxNode = ExprBinary;
2628 fn untyped(&self) -> SyntaxStablePtrId {
2629 self.0
2630 }
2631 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprBinary {
2632 ExprBinary::from_syntax_node(db, self.0.lookup(db))
2633 }
2634}
2635impl From<ExprBinaryPtr> for SyntaxStablePtrId {
2636 fn from(ptr: ExprBinaryPtr) -> Self {
2637 ptr.untyped()
2638 }
2639}
2640#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2641pub struct ExprBinaryGreen(pub GreenId);
2642impl TypedSyntaxNode for ExprBinary {
2643 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprBinary);
2644 type StablePtr = ExprBinaryPtr;
2645 type Green = ExprBinaryGreen;
2646 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2647 ExprBinaryGreen(
2648 Arc::new(GreenNode {
2649 kind: SyntaxKind::ExprBinary,
2650 details: GreenNodeDetails::Node {
2651 children: vec![
2652 Expr::missing(db).0,
2653 BinaryOperator::missing(db).0,
2654 Expr::missing(db).0,
2655 ],
2656 width: TextWidth::default(),
2657 },
2658 })
2659 .intern(db),
2660 )
2661 }
2662 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2663 let kind = node.kind(db);
2664 assert_eq!(
2665 kind,
2666 SyntaxKind::ExprBinary,
2667 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2668 kind,
2669 SyntaxKind::ExprBinary
2670 );
2671 let children = db.get_children(node.clone());
2672 Self { node, children }
2673 }
2674 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
2675 let kind = node.kind(db);
2676 if kind == SyntaxKind::ExprBinary { Some(Self::from_syntax_node(db, node)) } else { None }
2677 }
2678 fn as_syntax_node(&self) -> SyntaxNode {
2679 self.node.clone()
2680 }
2681 fn stable_ptr(&self) -> Self::StablePtr {
2682 ExprBinaryPtr(self.node.0.stable_ptr)
2683 }
2684}
2685impl From<&ExprBinary> for SyntaxStablePtrId {
2686 fn from(node: &ExprBinary) -> Self {
2687 node.stable_ptr().untyped()
2688 }
2689}
2690#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2691pub enum BinaryOperator {
2692 Dot(TerminalDot),
2693 Not(TerminalNot),
2694 Mul(TerminalMul),
2695 MulEq(TerminalMulEq),
2696 Div(TerminalDiv),
2697 DivEq(TerminalDivEq),
2698 Mod(TerminalMod),
2699 ModEq(TerminalModEq),
2700 Plus(TerminalPlus),
2701 PlusEq(TerminalPlusEq),
2702 Minus(TerminalMinus),
2703 MinusEq(TerminalMinusEq),
2704 EqEq(TerminalEqEq),
2705 Neq(TerminalNeq),
2706 Eq(TerminalEq),
2707 And(TerminalAnd),
2708 AndAnd(TerminalAndAnd),
2709 Or(TerminalOr),
2710 OrOr(TerminalOrOr),
2711 Xor(TerminalXor),
2712 LE(TerminalLE),
2713 GE(TerminalGE),
2714 LT(TerminalLT),
2715 GT(TerminalGT),
2716 DotDot(TerminalDotDot),
2717}
2718#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2719pub struct BinaryOperatorPtr(pub SyntaxStablePtrId);
2720impl TypedStablePtr for BinaryOperatorPtr {
2721 type SyntaxNode = BinaryOperator;
2722 fn untyped(&self) -> SyntaxStablePtrId {
2723 self.0
2724 }
2725 fn lookup(&self, db: &dyn SyntaxGroup) -> BinaryOperator {
2726 BinaryOperator::from_syntax_node(db, self.0.lookup(db))
2727 }
2728}
2729impl From<BinaryOperatorPtr> for SyntaxStablePtrId {
2730 fn from(ptr: BinaryOperatorPtr) -> Self {
2731 ptr.untyped()
2732 }
2733}
2734impl From<TerminalDotPtr> for BinaryOperatorPtr {
2735 fn from(value: TerminalDotPtr) -> Self {
2736 Self(value.0)
2737 }
2738}
2739impl From<TerminalNotPtr> for BinaryOperatorPtr {
2740 fn from(value: TerminalNotPtr) -> Self {
2741 Self(value.0)
2742 }
2743}
2744impl From<TerminalMulPtr> for BinaryOperatorPtr {
2745 fn from(value: TerminalMulPtr) -> Self {
2746 Self(value.0)
2747 }
2748}
2749impl From<TerminalMulEqPtr> for BinaryOperatorPtr {
2750 fn from(value: TerminalMulEqPtr) -> Self {
2751 Self(value.0)
2752 }
2753}
2754impl From<TerminalDivPtr> for BinaryOperatorPtr {
2755 fn from(value: TerminalDivPtr) -> Self {
2756 Self(value.0)
2757 }
2758}
2759impl From<TerminalDivEqPtr> for BinaryOperatorPtr {
2760 fn from(value: TerminalDivEqPtr) -> Self {
2761 Self(value.0)
2762 }
2763}
2764impl From<TerminalModPtr> for BinaryOperatorPtr {
2765 fn from(value: TerminalModPtr) -> Self {
2766 Self(value.0)
2767 }
2768}
2769impl From<TerminalModEqPtr> for BinaryOperatorPtr {
2770 fn from(value: TerminalModEqPtr) -> Self {
2771 Self(value.0)
2772 }
2773}
2774impl From<TerminalPlusPtr> for BinaryOperatorPtr {
2775 fn from(value: TerminalPlusPtr) -> Self {
2776 Self(value.0)
2777 }
2778}
2779impl From<TerminalPlusEqPtr> for BinaryOperatorPtr {
2780 fn from(value: TerminalPlusEqPtr) -> Self {
2781 Self(value.0)
2782 }
2783}
2784impl From<TerminalMinusPtr> for BinaryOperatorPtr {
2785 fn from(value: TerminalMinusPtr) -> Self {
2786 Self(value.0)
2787 }
2788}
2789impl From<TerminalMinusEqPtr> for BinaryOperatorPtr {
2790 fn from(value: TerminalMinusEqPtr) -> Self {
2791 Self(value.0)
2792 }
2793}
2794impl From<TerminalEqEqPtr> for BinaryOperatorPtr {
2795 fn from(value: TerminalEqEqPtr) -> Self {
2796 Self(value.0)
2797 }
2798}
2799impl From<TerminalNeqPtr> for BinaryOperatorPtr {
2800 fn from(value: TerminalNeqPtr) -> Self {
2801 Self(value.0)
2802 }
2803}
2804impl From<TerminalEqPtr> for BinaryOperatorPtr {
2805 fn from(value: TerminalEqPtr) -> Self {
2806 Self(value.0)
2807 }
2808}
2809impl From<TerminalAndPtr> for BinaryOperatorPtr {
2810 fn from(value: TerminalAndPtr) -> Self {
2811 Self(value.0)
2812 }
2813}
2814impl From<TerminalAndAndPtr> for BinaryOperatorPtr {
2815 fn from(value: TerminalAndAndPtr) -> Self {
2816 Self(value.0)
2817 }
2818}
2819impl From<TerminalOrPtr> for BinaryOperatorPtr {
2820 fn from(value: TerminalOrPtr) -> Self {
2821 Self(value.0)
2822 }
2823}
2824impl From<TerminalOrOrPtr> for BinaryOperatorPtr {
2825 fn from(value: TerminalOrOrPtr) -> Self {
2826 Self(value.0)
2827 }
2828}
2829impl From<TerminalXorPtr> for BinaryOperatorPtr {
2830 fn from(value: TerminalXorPtr) -> Self {
2831 Self(value.0)
2832 }
2833}
2834impl From<TerminalLEPtr> for BinaryOperatorPtr {
2835 fn from(value: TerminalLEPtr) -> Self {
2836 Self(value.0)
2837 }
2838}
2839impl From<TerminalGEPtr> for BinaryOperatorPtr {
2840 fn from(value: TerminalGEPtr) -> Self {
2841 Self(value.0)
2842 }
2843}
2844impl From<TerminalLTPtr> for BinaryOperatorPtr {
2845 fn from(value: TerminalLTPtr) -> Self {
2846 Self(value.0)
2847 }
2848}
2849impl From<TerminalGTPtr> for BinaryOperatorPtr {
2850 fn from(value: TerminalGTPtr) -> Self {
2851 Self(value.0)
2852 }
2853}
2854impl From<TerminalDotDotPtr> for BinaryOperatorPtr {
2855 fn from(value: TerminalDotDotPtr) -> Self {
2856 Self(value.0)
2857 }
2858}
2859impl From<TerminalDotGreen> for BinaryOperatorGreen {
2860 fn from(value: TerminalDotGreen) -> Self {
2861 Self(value.0)
2862 }
2863}
2864impl From<TerminalNotGreen> for BinaryOperatorGreen {
2865 fn from(value: TerminalNotGreen) -> Self {
2866 Self(value.0)
2867 }
2868}
2869impl From<TerminalMulGreen> for BinaryOperatorGreen {
2870 fn from(value: TerminalMulGreen) -> Self {
2871 Self(value.0)
2872 }
2873}
2874impl From<TerminalMulEqGreen> for BinaryOperatorGreen {
2875 fn from(value: TerminalMulEqGreen) -> Self {
2876 Self(value.0)
2877 }
2878}
2879impl From<TerminalDivGreen> for BinaryOperatorGreen {
2880 fn from(value: TerminalDivGreen) -> Self {
2881 Self(value.0)
2882 }
2883}
2884impl From<TerminalDivEqGreen> for BinaryOperatorGreen {
2885 fn from(value: TerminalDivEqGreen) -> Self {
2886 Self(value.0)
2887 }
2888}
2889impl From<TerminalModGreen> for BinaryOperatorGreen {
2890 fn from(value: TerminalModGreen) -> Self {
2891 Self(value.0)
2892 }
2893}
2894impl From<TerminalModEqGreen> for BinaryOperatorGreen {
2895 fn from(value: TerminalModEqGreen) -> Self {
2896 Self(value.0)
2897 }
2898}
2899impl From<TerminalPlusGreen> for BinaryOperatorGreen {
2900 fn from(value: TerminalPlusGreen) -> Self {
2901 Self(value.0)
2902 }
2903}
2904impl From<TerminalPlusEqGreen> for BinaryOperatorGreen {
2905 fn from(value: TerminalPlusEqGreen) -> Self {
2906 Self(value.0)
2907 }
2908}
2909impl From<TerminalMinusGreen> for BinaryOperatorGreen {
2910 fn from(value: TerminalMinusGreen) -> Self {
2911 Self(value.0)
2912 }
2913}
2914impl From<TerminalMinusEqGreen> for BinaryOperatorGreen {
2915 fn from(value: TerminalMinusEqGreen) -> Self {
2916 Self(value.0)
2917 }
2918}
2919impl From<TerminalEqEqGreen> for BinaryOperatorGreen {
2920 fn from(value: TerminalEqEqGreen) -> Self {
2921 Self(value.0)
2922 }
2923}
2924impl From<TerminalNeqGreen> for BinaryOperatorGreen {
2925 fn from(value: TerminalNeqGreen) -> Self {
2926 Self(value.0)
2927 }
2928}
2929impl From<TerminalEqGreen> for BinaryOperatorGreen {
2930 fn from(value: TerminalEqGreen) -> Self {
2931 Self(value.0)
2932 }
2933}
2934impl From<TerminalAndGreen> for BinaryOperatorGreen {
2935 fn from(value: TerminalAndGreen) -> Self {
2936 Self(value.0)
2937 }
2938}
2939impl From<TerminalAndAndGreen> for BinaryOperatorGreen {
2940 fn from(value: TerminalAndAndGreen) -> Self {
2941 Self(value.0)
2942 }
2943}
2944impl From<TerminalOrGreen> for BinaryOperatorGreen {
2945 fn from(value: TerminalOrGreen) -> Self {
2946 Self(value.0)
2947 }
2948}
2949impl From<TerminalOrOrGreen> for BinaryOperatorGreen {
2950 fn from(value: TerminalOrOrGreen) -> Self {
2951 Self(value.0)
2952 }
2953}
2954impl From<TerminalXorGreen> for BinaryOperatorGreen {
2955 fn from(value: TerminalXorGreen) -> Self {
2956 Self(value.0)
2957 }
2958}
2959impl From<TerminalLEGreen> for BinaryOperatorGreen {
2960 fn from(value: TerminalLEGreen) -> Self {
2961 Self(value.0)
2962 }
2963}
2964impl From<TerminalGEGreen> for BinaryOperatorGreen {
2965 fn from(value: TerminalGEGreen) -> Self {
2966 Self(value.0)
2967 }
2968}
2969impl From<TerminalLTGreen> for BinaryOperatorGreen {
2970 fn from(value: TerminalLTGreen) -> Self {
2971 Self(value.0)
2972 }
2973}
2974impl From<TerminalGTGreen> for BinaryOperatorGreen {
2975 fn from(value: TerminalGTGreen) -> Self {
2976 Self(value.0)
2977 }
2978}
2979impl From<TerminalDotDotGreen> for BinaryOperatorGreen {
2980 fn from(value: TerminalDotDotGreen) -> Self {
2981 Self(value.0)
2982 }
2983}
2984#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2985pub struct BinaryOperatorGreen(pub GreenId);
2986impl TypedSyntaxNode for BinaryOperator {
2987 const OPTIONAL_KIND: Option<SyntaxKind> = None;
2988 type StablePtr = BinaryOperatorPtr;
2989 type Green = BinaryOperatorGreen;
2990 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2991 panic!("No missing variant.");
2992 }
2993 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2994 let kind = node.kind(db);
2995 match kind {
2996 SyntaxKind::TerminalDot => BinaryOperator::Dot(TerminalDot::from_syntax_node(db, node)),
2997 SyntaxKind::TerminalNot => BinaryOperator::Not(TerminalNot::from_syntax_node(db, node)),
2998 SyntaxKind::TerminalMul => BinaryOperator::Mul(TerminalMul::from_syntax_node(db, node)),
2999 SyntaxKind::TerminalMulEq => {
3000 BinaryOperator::MulEq(TerminalMulEq::from_syntax_node(db, node))
3001 }
3002 SyntaxKind::TerminalDiv => BinaryOperator::Div(TerminalDiv::from_syntax_node(db, node)),
3003 SyntaxKind::TerminalDivEq => {
3004 BinaryOperator::DivEq(TerminalDivEq::from_syntax_node(db, node))
3005 }
3006 SyntaxKind::TerminalMod => BinaryOperator::Mod(TerminalMod::from_syntax_node(db, node)),
3007 SyntaxKind::TerminalModEq => {
3008 BinaryOperator::ModEq(TerminalModEq::from_syntax_node(db, node))
3009 }
3010 SyntaxKind::TerminalPlus => {
3011 BinaryOperator::Plus(TerminalPlus::from_syntax_node(db, node))
3012 }
3013 SyntaxKind::TerminalPlusEq => {
3014 BinaryOperator::PlusEq(TerminalPlusEq::from_syntax_node(db, node))
3015 }
3016 SyntaxKind::TerminalMinus => {
3017 BinaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))
3018 }
3019 SyntaxKind::TerminalMinusEq => {
3020 BinaryOperator::MinusEq(TerminalMinusEq::from_syntax_node(db, node))
3021 }
3022 SyntaxKind::TerminalEqEq => {
3023 BinaryOperator::EqEq(TerminalEqEq::from_syntax_node(db, node))
3024 }
3025 SyntaxKind::TerminalNeq => BinaryOperator::Neq(TerminalNeq::from_syntax_node(db, node)),
3026 SyntaxKind::TerminalEq => BinaryOperator::Eq(TerminalEq::from_syntax_node(db, node)),
3027 SyntaxKind::TerminalAnd => BinaryOperator::And(TerminalAnd::from_syntax_node(db, node)),
3028 SyntaxKind::TerminalAndAnd => {
3029 BinaryOperator::AndAnd(TerminalAndAnd::from_syntax_node(db, node))
3030 }
3031 SyntaxKind::TerminalOr => BinaryOperator::Or(TerminalOr::from_syntax_node(db, node)),
3032 SyntaxKind::TerminalOrOr => {
3033 BinaryOperator::OrOr(TerminalOrOr::from_syntax_node(db, node))
3034 }
3035 SyntaxKind::TerminalXor => BinaryOperator::Xor(TerminalXor::from_syntax_node(db, node)),
3036 SyntaxKind::TerminalLE => BinaryOperator::LE(TerminalLE::from_syntax_node(db, node)),
3037 SyntaxKind::TerminalGE => BinaryOperator::GE(TerminalGE::from_syntax_node(db, node)),
3038 SyntaxKind::TerminalLT => BinaryOperator::LT(TerminalLT::from_syntax_node(db, node)),
3039 SyntaxKind::TerminalGT => BinaryOperator::GT(TerminalGT::from_syntax_node(db, node)),
3040 SyntaxKind::TerminalDotDot => {
3041 BinaryOperator::DotDot(TerminalDotDot::from_syntax_node(db, node))
3042 }
3043 _ => {
3044 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "BinaryOperator")
3045 }
3046 }
3047 }
3048 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3049 let kind = node.kind(db);
3050 match kind {
3051 SyntaxKind::TerminalDot => {
3052 Some(BinaryOperator::Dot(TerminalDot::from_syntax_node(db, node)))
3053 }
3054 SyntaxKind::TerminalNot => {
3055 Some(BinaryOperator::Not(TerminalNot::from_syntax_node(db, node)))
3056 }
3057 SyntaxKind::TerminalMul => {
3058 Some(BinaryOperator::Mul(TerminalMul::from_syntax_node(db, node)))
3059 }
3060 SyntaxKind::TerminalMulEq => {
3061 Some(BinaryOperator::MulEq(TerminalMulEq::from_syntax_node(db, node)))
3062 }
3063 SyntaxKind::TerminalDiv => {
3064 Some(BinaryOperator::Div(TerminalDiv::from_syntax_node(db, node)))
3065 }
3066 SyntaxKind::TerminalDivEq => {
3067 Some(BinaryOperator::DivEq(TerminalDivEq::from_syntax_node(db, node)))
3068 }
3069 SyntaxKind::TerminalMod => {
3070 Some(BinaryOperator::Mod(TerminalMod::from_syntax_node(db, node)))
3071 }
3072 SyntaxKind::TerminalModEq => {
3073 Some(BinaryOperator::ModEq(TerminalModEq::from_syntax_node(db, node)))
3074 }
3075 SyntaxKind::TerminalPlus => {
3076 Some(BinaryOperator::Plus(TerminalPlus::from_syntax_node(db, node)))
3077 }
3078 SyntaxKind::TerminalPlusEq => {
3079 Some(BinaryOperator::PlusEq(TerminalPlusEq::from_syntax_node(db, node)))
3080 }
3081 SyntaxKind::TerminalMinus => {
3082 Some(BinaryOperator::Minus(TerminalMinus::from_syntax_node(db, node)))
3083 }
3084 SyntaxKind::TerminalMinusEq => {
3085 Some(BinaryOperator::MinusEq(TerminalMinusEq::from_syntax_node(db, node)))
3086 }
3087 SyntaxKind::TerminalEqEq => {
3088 Some(BinaryOperator::EqEq(TerminalEqEq::from_syntax_node(db, node)))
3089 }
3090 SyntaxKind::TerminalNeq => {
3091 Some(BinaryOperator::Neq(TerminalNeq::from_syntax_node(db, node)))
3092 }
3093 SyntaxKind::TerminalEq => {
3094 Some(BinaryOperator::Eq(TerminalEq::from_syntax_node(db, node)))
3095 }
3096 SyntaxKind::TerminalAnd => {
3097 Some(BinaryOperator::And(TerminalAnd::from_syntax_node(db, node)))
3098 }
3099 SyntaxKind::TerminalAndAnd => {
3100 Some(BinaryOperator::AndAnd(TerminalAndAnd::from_syntax_node(db, node)))
3101 }
3102 SyntaxKind::TerminalOr => {
3103 Some(BinaryOperator::Or(TerminalOr::from_syntax_node(db, node)))
3104 }
3105 SyntaxKind::TerminalOrOr => {
3106 Some(BinaryOperator::OrOr(TerminalOrOr::from_syntax_node(db, node)))
3107 }
3108 SyntaxKind::TerminalXor => {
3109 Some(BinaryOperator::Xor(TerminalXor::from_syntax_node(db, node)))
3110 }
3111 SyntaxKind::TerminalLE => {
3112 Some(BinaryOperator::LE(TerminalLE::from_syntax_node(db, node)))
3113 }
3114 SyntaxKind::TerminalGE => {
3115 Some(BinaryOperator::GE(TerminalGE::from_syntax_node(db, node)))
3116 }
3117 SyntaxKind::TerminalLT => {
3118 Some(BinaryOperator::LT(TerminalLT::from_syntax_node(db, node)))
3119 }
3120 SyntaxKind::TerminalGT => {
3121 Some(BinaryOperator::GT(TerminalGT::from_syntax_node(db, node)))
3122 }
3123 SyntaxKind::TerminalDotDot => {
3124 Some(BinaryOperator::DotDot(TerminalDotDot::from_syntax_node(db, node)))
3125 }
3126 _ => None,
3127 }
3128 }
3129 fn as_syntax_node(&self) -> SyntaxNode {
3130 match self {
3131 BinaryOperator::Dot(x) => x.as_syntax_node(),
3132 BinaryOperator::Not(x) => x.as_syntax_node(),
3133 BinaryOperator::Mul(x) => x.as_syntax_node(),
3134 BinaryOperator::MulEq(x) => x.as_syntax_node(),
3135 BinaryOperator::Div(x) => x.as_syntax_node(),
3136 BinaryOperator::DivEq(x) => x.as_syntax_node(),
3137 BinaryOperator::Mod(x) => x.as_syntax_node(),
3138 BinaryOperator::ModEq(x) => x.as_syntax_node(),
3139 BinaryOperator::Plus(x) => x.as_syntax_node(),
3140 BinaryOperator::PlusEq(x) => x.as_syntax_node(),
3141 BinaryOperator::Minus(x) => x.as_syntax_node(),
3142 BinaryOperator::MinusEq(x) => x.as_syntax_node(),
3143 BinaryOperator::EqEq(x) => x.as_syntax_node(),
3144 BinaryOperator::Neq(x) => x.as_syntax_node(),
3145 BinaryOperator::Eq(x) => x.as_syntax_node(),
3146 BinaryOperator::And(x) => x.as_syntax_node(),
3147 BinaryOperator::AndAnd(x) => x.as_syntax_node(),
3148 BinaryOperator::Or(x) => x.as_syntax_node(),
3149 BinaryOperator::OrOr(x) => x.as_syntax_node(),
3150 BinaryOperator::Xor(x) => x.as_syntax_node(),
3151 BinaryOperator::LE(x) => x.as_syntax_node(),
3152 BinaryOperator::GE(x) => x.as_syntax_node(),
3153 BinaryOperator::LT(x) => x.as_syntax_node(),
3154 BinaryOperator::GT(x) => x.as_syntax_node(),
3155 BinaryOperator::DotDot(x) => x.as_syntax_node(),
3156 }
3157 }
3158 fn stable_ptr(&self) -> Self::StablePtr {
3159 BinaryOperatorPtr(self.as_syntax_node().0.stable_ptr)
3160 }
3161}
3162impl From<&BinaryOperator> for SyntaxStablePtrId {
3163 fn from(node: &BinaryOperator) -> Self {
3164 node.stable_ptr().untyped()
3165 }
3166}
3167impl BinaryOperator {
3168 pub fn is_variant(kind: SyntaxKind) -> bool {
3170 matches!(
3171 kind,
3172 SyntaxKind::TerminalDot
3173 | SyntaxKind::TerminalNot
3174 | SyntaxKind::TerminalMul
3175 | SyntaxKind::TerminalMulEq
3176 | SyntaxKind::TerminalDiv
3177 | SyntaxKind::TerminalDivEq
3178 | SyntaxKind::TerminalMod
3179 | SyntaxKind::TerminalModEq
3180 | SyntaxKind::TerminalPlus
3181 | SyntaxKind::TerminalPlusEq
3182 | SyntaxKind::TerminalMinus
3183 | SyntaxKind::TerminalMinusEq
3184 | SyntaxKind::TerminalEqEq
3185 | SyntaxKind::TerminalNeq
3186 | SyntaxKind::TerminalEq
3187 | SyntaxKind::TerminalAnd
3188 | SyntaxKind::TerminalAndAnd
3189 | SyntaxKind::TerminalOr
3190 | SyntaxKind::TerminalOrOr
3191 | SyntaxKind::TerminalXor
3192 | SyntaxKind::TerminalLE
3193 | SyntaxKind::TerminalGE
3194 | SyntaxKind::TerminalLT
3195 | SyntaxKind::TerminalGT
3196 | SyntaxKind::TerminalDotDot
3197 )
3198 }
3199}
3200#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3201pub struct ExprListParenthesized {
3202 node: SyntaxNode,
3203 children: Arc<[SyntaxNode]>,
3204}
3205impl ExprListParenthesized {
3206 pub const INDEX_LPAREN: usize = 0;
3207 pub const INDEX_EXPRESSIONS: usize = 1;
3208 pub const INDEX_RPAREN: usize = 2;
3209 pub fn new_green(
3210 db: &dyn SyntaxGroup,
3211 lparen: TerminalLParenGreen,
3212 expressions: ExprListGreen,
3213 rparen: TerminalRParenGreen,
3214 ) -> ExprListParenthesizedGreen {
3215 let children: Vec<GreenId> = vec![lparen.0, expressions.0, rparen.0];
3216 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3217 ExprListParenthesizedGreen(
3218 Arc::new(GreenNode {
3219 kind: SyntaxKind::ExprListParenthesized,
3220 details: GreenNodeDetails::Node { children, width },
3221 })
3222 .intern(db),
3223 )
3224 }
3225}
3226impl ExprListParenthesized {
3227 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
3228 TerminalLParen::from_syntax_node(db, self.children[0].clone())
3229 }
3230 pub fn expressions(&self, db: &dyn SyntaxGroup) -> ExprList {
3231 ExprList::from_syntax_node(db, self.children[1].clone())
3232 }
3233 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
3234 TerminalRParen::from_syntax_node(db, self.children[2].clone())
3235 }
3236}
3237#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3238pub struct ExprListParenthesizedPtr(pub SyntaxStablePtrId);
3239impl ExprListParenthesizedPtr {}
3240impl TypedStablePtr for ExprListParenthesizedPtr {
3241 type SyntaxNode = ExprListParenthesized;
3242 fn untyped(&self) -> SyntaxStablePtrId {
3243 self.0
3244 }
3245 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprListParenthesized {
3246 ExprListParenthesized::from_syntax_node(db, self.0.lookup(db))
3247 }
3248}
3249impl From<ExprListParenthesizedPtr> for SyntaxStablePtrId {
3250 fn from(ptr: ExprListParenthesizedPtr) -> Self {
3251 ptr.untyped()
3252 }
3253}
3254#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3255pub struct ExprListParenthesizedGreen(pub GreenId);
3256impl TypedSyntaxNode for ExprListParenthesized {
3257 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprListParenthesized);
3258 type StablePtr = ExprListParenthesizedPtr;
3259 type Green = ExprListParenthesizedGreen;
3260 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3261 ExprListParenthesizedGreen(
3262 Arc::new(GreenNode {
3263 kind: SyntaxKind::ExprListParenthesized,
3264 details: GreenNodeDetails::Node {
3265 children: vec![
3266 TerminalLParen::missing(db).0,
3267 ExprList::missing(db).0,
3268 TerminalRParen::missing(db).0,
3269 ],
3270 width: TextWidth::default(),
3271 },
3272 })
3273 .intern(db),
3274 )
3275 }
3276 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3277 let kind = node.kind(db);
3278 assert_eq!(
3279 kind,
3280 SyntaxKind::ExprListParenthesized,
3281 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3282 kind,
3283 SyntaxKind::ExprListParenthesized
3284 );
3285 let children = db.get_children(node.clone());
3286 Self { node, children }
3287 }
3288 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3289 let kind = node.kind(db);
3290 if kind == SyntaxKind::ExprListParenthesized {
3291 Some(Self::from_syntax_node(db, node))
3292 } else {
3293 None
3294 }
3295 }
3296 fn as_syntax_node(&self) -> SyntaxNode {
3297 self.node.clone()
3298 }
3299 fn stable_ptr(&self) -> Self::StablePtr {
3300 ExprListParenthesizedPtr(self.node.0.stable_ptr)
3301 }
3302}
3303impl From<&ExprListParenthesized> for SyntaxStablePtrId {
3304 fn from(node: &ExprListParenthesized) -> Self {
3305 node.stable_ptr().untyped()
3306 }
3307}
3308#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3309pub struct ExprFunctionCall {
3310 node: SyntaxNode,
3311 children: Arc<[SyntaxNode]>,
3312}
3313impl ExprFunctionCall {
3314 pub const INDEX_PATH: usize = 0;
3315 pub const INDEX_ARGUMENTS: usize = 1;
3316 pub fn new_green(
3317 db: &dyn SyntaxGroup,
3318 path: ExprPathGreen,
3319 arguments: ArgListParenthesizedGreen,
3320 ) -> ExprFunctionCallGreen {
3321 let children: Vec<GreenId> = vec![path.0, arguments.0];
3322 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3323 ExprFunctionCallGreen(
3324 Arc::new(GreenNode {
3325 kind: SyntaxKind::ExprFunctionCall,
3326 details: GreenNodeDetails::Node { children, width },
3327 })
3328 .intern(db),
3329 )
3330 }
3331}
3332impl ExprFunctionCall {
3333 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
3334 ExprPath::from_syntax_node(db, self.children[0].clone())
3335 }
3336 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgListParenthesized {
3337 ArgListParenthesized::from_syntax_node(db, self.children[1].clone())
3338 }
3339}
3340#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3341pub struct ExprFunctionCallPtr(pub SyntaxStablePtrId);
3342impl ExprFunctionCallPtr {}
3343impl TypedStablePtr for ExprFunctionCallPtr {
3344 type SyntaxNode = ExprFunctionCall;
3345 fn untyped(&self) -> SyntaxStablePtrId {
3346 self.0
3347 }
3348 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFunctionCall {
3349 ExprFunctionCall::from_syntax_node(db, self.0.lookup(db))
3350 }
3351}
3352impl From<ExprFunctionCallPtr> for SyntaxStablePtrId {
3353 fn from(ptr: ExprFunctionCallPtr) -> Self {
3354 ptr.untyped()
3355 }
3356}
3357#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3358pub struct ExprFunctionCallGreen(pub GreenId);
3359impl TypedSyntaxNode for ExprFunctionCall {
3360 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFunctionCall);
3361 type StablePtr = ExprFunctionCallPtr;
3362 type Green = ExprFunctionCallGreen;
3363 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3364 ExprFunctionCallGreen(
3365 Arc::new(GreenNode {
3366 kind: SyntaxKind::ExprFunctionCall,
3367 details: GreenNodeDetails::Node {
3368 children: vec![ExprPath::missing(db).0, ArgListParenthesized::missing(db).0],
3369 width: TextWidth::default(),
3370 },
3371 })
3372 .intern(db),
3373 )
3374 }
3375 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3376 let kind = node.kind(db);
3377 assert_eq!(
3378 kind,
3379 SyntaxKind::ExprFunctionCall,
3380 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3381 kind,
3382 SyntaxKind::ExprFunctionCall
3383 );
3384 let children = db.get_children(node.clone());
3385 Self { node, children }
3386 }
3387 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3388 let kind = node.kind(db);
3389 if kind == SyntaxKind::ExprFunctionCall {
3390 Some(Self::from_syntax_node(db, node))
3391 } else {
3392 None
3393 }
3394 }
3395 fn as_syntax_node(&self) -> SyntaxNode {
3396 self.node.clone()
3397 }
3398 fn stable_ptr(&self) -> Self::StablePtr {
3399 ExprFunctionCallPtr(self.node.0.stable_ptr)
3400 }
3401}
3402impl From<&ExprFunctionCall> for SyntaxStablePtrId {
3403 fn from(node: &ExprFunctionCall) -> Self {
3404 node.stable_ptr().untyped()
3405 }
3406}
3407#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3408pub struct ArgListParenthesized {
3409 node: SyntaxNode,
3410 children: Arc<[SyntaxNode]>,
3411}
3412impl ArgListParenthesized {
3413 pub const INDEX_LPAREN: usize = 0;
3414 pub const INDEX_ARGUMENTS: usize = 1;
3415 pub const INDEX_RPAREN: usize = 2;
3416 pub fn new_green(
3417 db: &dyn SyntaxGroup,
3418 lparen: TerminalLParenGreen,
3419 arguments: ArgListGreen,
3420 rparen: TerminalRParenGreen,
3421 ) -> ArgListParenthesizedGreen {
3422 let children: Vec<GreenId> = vec![lparen.0, arguments.0, rparen.0];
3423 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3424 ArgListParenthesizedGreen(
3425 Arc::new(GreenNode {
3426 kind: SyntaxKind::ArgListParenthesized,
3427 details: GreenNodeDetails::Node { children, width },
3428 })
3429 .intern(db),
3430 )
3431 }
3432}
3433impl ArgListParenthesized {
3434 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
3435 TerminalLParen::from_syntax_node(db, self.children[0].clone())
3436 }
3437 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
3438 ArgList::from_syntax_node(db, self.children[1].clone())
3439 }
3440 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
3441 TerminalRParen::from_syntax_node(db, self.children[2].clone())
3442 }
3443}
3444#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3445pub struct ArgListParenthesizedPtr(pub SyntaxStablePtrId);
3446impl ArgListParenthesizedPtr {}
3447impl TypedStablePtr for ArgListParenthesizedPtr {
3448 type SyntaxNode = ArgListParenthesized;
3449 fn untyped(&self) -> SyntaxStablePtrId {
3450 self.0
3451 }
3452 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListParenthesized {
3453 ArgListParenthesized::from_syntax_node(db, self.0.lookup(db))
3454 }
3455}
3456impl From<ArgListParenthesizedPtr> for SyntaxStablePtrId {
3457 fn from(ptr: ArgListParenthesizedPtr) -> Self {
3458 ptr.untyped()
3459 }
3460}
3461#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3462pub struct ArgListParenthesizedGreen(pub GreenId);
3463impl TypedSyntaxNode for ArgListParenthesized {
3464 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListParenthesized);
3465 type StablePtr = ArgListParenthesizedPtr;
3466 type Green = ArgListParenthesizedGreen;
3467 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3468 ArgListParenthesizedGreen(
3469 Arc::new(GreenNode {
3470 kind: SyntaxKind::ArgListParenthesized,
3471 details: GreenNodeDetails::Node {
3472 children: vec![
3473 TerminalLParen::missing(db).0,
3474 ArgList::missing(db).0,
3475 TerminalRParen::missing(db).0,
3476 ],
3477 width: TextWidth::default(),
3478 },
3479 })
3480 .intern(db),
3481 )
3482 }
3483 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3484 let kind = node.kind(db);
3485 assert_eq!(
3486 kind,
3487 SyntaxKind::ArgListParenthesized,
3488 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3489 kind,
3490 SyntaxKind::ArgListParenthesized
3491 );
3492 let children = db.get_children(node.clone());
3493 Self { node, children }
3494 }
3495 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3496 let kind = node.kind(db);
3497 if kind == SyntaxKind::ArgListParenthesized {
3498 Some(Self::from_syntax_node(db, node))
3499 } else {
3500 None
3501 }
3502 }
3503 fn as_syntax_node(&self) -> SyntaxNode {
3504 self.node.clone()
3505 }
3506 fn stable_ptr(&self) -> Self::StablePtr {
3507 ArgListParenthesizedPtr(self.node.0.stable_ptr)
3508 }
3509}
3510impl From<&ArgListParenthesized> for SyntaxStablePtrId {
3511 fn from(node: &ArgListParenthesized) -> Self {
3512 node.stable_ptr().untyped()
3513 }
3514}
3515#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3516pub enum OptionArgListParenthesized {
3517 Empty(OptionArgListParenthesizedEmpty),
3518 ArgListParenthesized(ArgListParenthesized),
3519}
3520#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3521pub struct OptionArgListParenthesizedPtr(pub SyntaxStablePtrId);
3522impl TypedStablePtr for OptionArgListParenthesizedPtr {
3523 type SyntaxNode = OptionArgListParenthesized;
3524 fn untyped(&self) -> SyntaxStablePtrId {
3525 self.0
3526 }
3527 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesized {
3528 OptionArgListParenthesized::from_syntax_node(db, self.0.lookup(db))
3529 }
3530}
3531impl From<OptionArgListParenthesizedPtr> for SyntaxStablePtrId {
3532 fn from(ptr: OptionArgListParenthesizedPtr) -> Self {
3533 ptr.untyped()
3534 }
3535}
3536impl From<OptionArgListParenthesizedEmptyPtr> for OptionArgListParenthesizedPtr {
3537 fn from(value: OptionArgListParenthesizedEmptyPtr) -> Self {
3538 Self(value.0)
3539 }
3540}
3541impl From<ArgListParenthesizedPtr> for OptionArgListParenthesizedPtr {
3542 fn from(value: ArgListParenthesizedPtr) -> Self {
3543 Self(value.0)
3544 }
3545}
3546impl From<OptionArgListParenthesizedEmptyGreen> for OptionArgListParenthesizedGreen {
3547 fn from(value: OptionArgListParenthesizedEmptyGreen) -> Self {
3548 Self(value.0)
3549 }
3550}
3551impl From<ArgListParenthesizedGreen> for OptionArgListParenthesizedGreen {
3552 fn from(value: ArgListParenthesizedGreen) -> Self {
3553 Self(value.0)
3554 }
3555}
3556#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3557pub struct OptionArgListParenthesizedGreen(pub GreenId);
3558impl TypedSyntaxNode for OptionArgListParenthesized {
3559 const OPTIONAL_KIND: Option<SyntaxKind> = None;
3560 type StablePtr = OptionArgListParenthesizedPtr;
3561 type Green = OptionArgListParenthesizedGreen;
3562 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3563 panic!("No missing variant.");
3564 }
3565 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3566 let kind = node.kind(db);
3567 match kind {
3568 SyntaxKind::OptionArgListParenthesizedEmpty => OptionArgListParenthesized::Empty(
3569 OptionArgListParenthesizedEmpty::from_syntax_node(db, node),
3570 ),
3571 SyntaxKind::ArgListParenthesized => OptionArgListParenthesized::ArgListParenthesized(
3572 ArgListParenthesized::from_syntax_node(db, node),
3573 ),
3574 _ => panic!(
3575 "Unexpected syntax kind {:?} when constructing {}.",
3576 kind, "OptionArgListParenthesized"
3577 ),
3578 }
3579 }
3580 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3581 let kind = node.kind(db);
3582 match kind {
3583 SyntaxKind::OptionArgListParenthesizedEmpty => Some(OptionArgListParenthesized::Empty(
3584 OptionArgListParenthesizedEmpty::from_syntax_node(db, node),
3585 )),
3586 SyntaxKind::ArgListParenthesized => {
3587 Some(OptionArgListParenthesized::ArgListParenthesized(
3588 ArgListParenthesized::from_syntax_node(db, node),
3589 ))
3590 }
3591 _ => None,
3592 }
3593 }
3594 fn as_syntax_node(&self) -> SyntaxNode {
3595 match self {
3596 OptionArgListParenthesized::Empty(x) => x.as_syntax_node(),
3597 OptionArgListParenthesized::ArgListParenthesized(x) => x.as_syntax_node(),
3598 }
3599 }
3600 fn stable_ptr(&self) -> Self::StablePtr {
3601 OptionArgListParenthesizedPtr(self.as_syntax_node().0.stable_ptr)
3602 }
3603}
3604impl From<&OptionArgListParenthesized> for SyntaxStablePtrId {
3605 fn from(node: &OptionArgListParenthesized) -> Self {
3606 node.stable_ptr().untyped()
3607 }
3608}
3609impl OptionArgListParenthesized {
3610 pub fn is_variant(kind: SyntaxKind) -> bool {
3612 matches!(
3613 kind,
3614 SyntaxKind::OptionArgListParenthesizedEmpty | SyntaxKind::ArgListParenthesized
3615 )
3616 }
3617}
3618#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3619pub struct OptionArgListParenthesizedEmpty {
3620 node: SyntaxNode,
3621 children: Arc<[SyntaxNode]>,
3622}
3623impl OptionArgListParenthesizedEmpty {
3624 pub fn new_green(db: &dyn SyntaxGroup) -> OptionArgListParenthesizedEmptyGreen {
3625 let children: Vec<GreenId> = vec![];
3626 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3627 OptionArgListParenthesizedEmptyGreen(
3628 Arc::new(GreenNode {
3629 kind: SyntaxKind::OptionArgListParenthesizedEmpty,
3630 details: GreenNodeDetails::Node { children, width },
3631 })
3632 .intern(db),
3633 )
3634 }
3635}
3636impl OptionArgListParenthesizedEmpty {}
3637#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3638pub struct OptionArgListParenthesizedEmptyPtr(pub SyntaxStablePtrId);
3639impl OptionArgListParenthesizedEmptyPtr {}
3640impl TypedStablePtr for OptionArgListParenthesizedEmptyPtr {
3641 type SyntaxNode = OptionArgListParenthesizedEmpty;
3642 fn untyped(&self) -> SyntaxStablePtrId {
3643 self.0
3644 }
3645 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesizedEmpty {
3646 OptionArgListParenthesizedEmpty::from_syntax_node(db, self.0.lookup(db))
3647 }
3648}
3649impl From<OptionArgListParenthesizedEmptyPtr> for SyntaxStablePtrId {
3650 fn from(ptr: OptionArgListParenthesizedEmptyPtr) -> Self {
3651 ptr.untyped()
3652 }
3653}
3654#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3655pub struct OptionArgListParenthesizedEmptyGreen(pub GreenId);
3656impl TypedSyntaxNode for OptionArgListParenthesizedEmpty {
3657 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionArgListParenthesizedEmpty);
3658 type StablePtr = OptionArgListParenthesizedEmptyPtr;
3659 type Green = OptionArgListParenthesizedEmptyGreen;
3660 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3661 OptionArgListParenthesizedEmptyGreen(
3662 Arc::new(GreenNode {
3663 kind: SyntaxKind::OptionArgListParenthesizedEmpty,
3664 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
3665 })
3666 .intern(db),
3667 )
3668 }
3669 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3670 let kind = node.kind(db);
3671 assert_eq!(
3672 kind,
3673 SyntaxKind::OptionArgListParenthesizedEmpty,
3674 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3675 kind,
3676 SyntaxKind::OptionArgListParenthesizedEmpty
3677 );
3678 let children = db.get_children(node.clone());
3679 Self { node, children }
3680 }
3681 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3682 let kind = node.kind(db);
3683 if kind == SyntaxKind::OptionArgListParenthesizedEmpty {
3684 Some(Self::from_syntax_node(db, node))
3685 } else {
3686 None
3687 }
3688 }
3689 fn as_syntax_node(&self) -> SyntaxNode {
3690 self.node.clone()
3691 }
3692 fn stable_ptr(&self) -> Self::StablePtr {
3693 OptionArgListParenthesizedEmptyPtr(self.node.0.stable_ptr)
3694 }
3695}
3696impl From<&OptionArgListParenthesizedEmpty> for SyntaxStablePtrId {
3697 fn from(node: &OptionArgListParenthesizedEmpty) -> Self {
3698 node.stable_ptr().untyped()
3699 }
3700}
3701#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3702pub struct ExprStructCtorCall {
3703 node: SyntaxNode,
3704 children: Arc<[SyntaxNode]>,
3705}
3706impl ExprStructCtorCall {
3707 pub const INDEX_PATH: usize = 0;
3708 pub const INDEX_ARGUMENTS: usize = 1;
3709 pub fn new_green(
3710 db: &dyn SyntaxGroup,
3711 path: ExprPathGreen,
3712 arguments: StructArgListBracedGreen,
3713 ) -> ExprStructCtorCallGreen {
3714 let children: Vec<GreenId> = vec![path.0, arguments.0];
3715 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3716 ExprStructCtorCallGreen(
3717 Arc::new(GreenNode {
3718 kind: SyntaxKind::ExprStructCtorCall,
3719 details: GreenNodeDetails::Node { children, width },
3720 })
3721 .intern(db),
3722 )
3723 }
3724}
3725impl ExprStructCtorCall {
3726 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
3727 ExprPath::from_syntax_node(db, self.children[0].clone())
3728 }
3729 pub fn arguments(&self, db: &dyn SyntaxGroup) -> StructArgListBraced {
3730 StructArgListBraced::from_syntax_node(db, self.children[1].clone())
3731 }
3732}
3733#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3734pub struct ExprStructCtorCallPtr(pub SyntaxStablePtrId);
3735impl ExprStructCtorCallPtr {}
3736impl TypedStablePtr for ExprStructCtorCallPtr {
3737 type SyntaxNode = ExprStructCtorCall;
3738 fn untyped(&self) -> SyntaxStablePtrId {
3739 self.0
3740 }
3741 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprStructCtorCall {
3742 ExprStructCtorCall::from_syntax_node(db, self.0.lookup(db))
3743 }
3744}
3745impl From<ExprStructCtorCallPtr> for SyntaxStablePtrId {
3746 fn from(ptr: ExprStructCtorCallPtr) -> Self {
3747 ptr.untyped()
3748 }
3749}
3750#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3751pub struct ExprStructCtorCallGreen(pub GreenId);
3752impl TypedSyntaxNode for ExprStructCtorCall {
3753 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprStructCtorCall);
3754 type StablePtr = ExprStructCtorCallPtr;
3755 type Green = ExprStructCtorCallGreen;
3756 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3757 ExprStructCtorCallGreen(
3758 Arc::new(GreenNode {
3759 kind: SyntaxKind::ExprStructCtorCall,
3760 details: GreenNodeDetails::Node {
3761 children: vec![ExprPath::missing(db).0, StructArgListBraced::missing(db).0],
3762 width: TextWidth::default(),
3763 },
3764 })
3765 .intern(db),
3766 )
3767 }
3768 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3769 let kind = node.kind(db);
3770 assert_eq!(
3771 kind,
3772 SyntaxKind::ExprStructCtorCall,
3773 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3774 kind,
3775 SyntaxKind::ExprStructCtorCall
3776 );
3777 let children = db.get_children(node.clone());
3778 Self { node, children }
3779 }
3780 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3781 let kind = node.kind(db);
3782 if kind == SyntaxKind::ExprStructCtorCall {
3783 Some(Self::from_syntax_node(db, node))
3784 } else {
3785 None
3786 }
3787 }
3788 fn as_syntax_node(&self) -> SyntaxNode {
3789 self.node.clone()
3790 }
3791 fn stable_ptr(&self) -> Self::StablePtr {
3792 ExprStructCtorCallPtr(self.node.0.stable_ptr)
3793 }
3794}
3795impl From<&ExprStructCtorCall> for SyntaxStablePtrId {
3796 fn from(node: &ExprStructCtorCall) -> Self {
3797 node.stable_ptr().untyped()
3798 }
3799}
3800#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3801pub struct StructArgListBraced {
3802 node: SyntaxNode,
3803 children: Arc<[SyntaxNode]>,
3804}
3805impl StructArgListBraced {
3806 pub const INDEX_LBRACE: usize = 0;
3807 pub const INDEX_ARGUMENTS: usize = 1;
3808 pub const INDEX_RBRACE: usize = 2;
3809 pub fn new_green(
3810 db: &dyn SyntaxGroup,
3811 lbrace: TerminalLBraceGreen,
3812 arguments: StructArgListGreen,
3813 rbrace: TerminalRBraceGreen,
3814 ) -> StructArgListBracedGreen {
3815 let children: Vec<GreenId> = vec![lbrace.0, arguments.0, rbrace.0];
3816 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3817 StructArgListBracedGreen(
3818 Arc::new(GreenNode {
3819 kind: SyntaxKind::StructArgListBraced,
3820 details: GreenNodeDetails::Node { children, width },
3821 })
3822 .intern(db),
3823 )
3824 }
3825}
3826impl StructArgListBraced {
3827 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
3828 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
3829 }
3830 pub fn arguments(&self, db: &dyn SyntaxGroup) -> StructArgList {
3831 StructArgList::from_syntax_node(db, self.children[1].clone())
3832 }
3833 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
3834 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
3835 }
3836}
3837#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3838pub struct StructArgListBracedPtr(pub SyntaxStablePtrId);
3839impl StructArgListBracedPtr {}
3840impl TypedStablePtr for StructArgListBracedPtr {
3841 type SyntaxNode = StructArgListBraced;
3842 fn untyped(&self) -> SyntaxStablePtrId {
3843 self.0
3844 }
3845 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgListBraced {
3846 StructArgListBraced::from_syntax_node(db, self.0.lookup(db))
3847 }
3848}
3849impl From<StructArgListBracedPtr> for SyntaxStablePtrId {
3850 fn from(ptr: StructArgListBracedPtr) -> Self {
3851 ptr.untyped()
3852 }
3853}
3854#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3855pub struct StructArgListBracedGreen(pub GreenId);
3856impl TypedSyntaxNode for StructArgListBraced {
3857 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgListBraced);
3858 type StablePtr = StructArgListBracedPtr;
3859 type Green = StructArgListBracedGreen;
3860 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3861 StructArgListBracedGreen(
3862 Arc::new(GreenNode {
3863 kind: SyntaxKind::StructArgListBraced,
3864 details: GreenNodeDetails::Node {
3865 children: vec![
3866 TerminalLBrace::missing(db).0,
3867 StructArgList::missing(db).0,
3868 TerminalRBrace::missing(db).0,
3869 ],
3870 width: TextWidth::default(),
3871 },
3872 })
3873 .intern(db),
3874 )
3875 }
3876 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3877 let kind = node.kind(db);
3878 assert_eq!(
3879 kind,
3880 SyntaxKind::StructArgListBraced,
3881 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3882 kind,
3883 SyntaxKind::StructArgListBraced
3884 );
3885 let children = db.get_children(node.clone());
3886 Self { node, children }
3887 }
3888 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3889 let kind = node.kind(db);
3890 if kind == SyntaxKind::StructArgListBraced {
3891 Some(Self::from_syntax_node(db, node))
3892 } else {
3893 None
3894 }
3895 }
3896 fn as_syntax_node(&self) -> SyntaxNode {
3897 self.node.clone()
3898 }
3899 fn stable_ptr(&self) -> Self::StablePtr {
3900 StructArgListBracedPtr(self.node.0.stable_ptr)
3901 }
3902}
3903impl From<&StructArgListBraced> for SyntaxStablePtrId {
3904 fn from(node: &StructArgListBraced) -> Self {
3905 node.stable_ptr().untyped()
3906 }
3907}
3908#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3909pub struct ExprBlock {
3910 node: SyntaxNode,
3911 children: Arc<[SyntaxNode]>,
3912}
3913impl ExprBlock {
3914 pub const INDEX_LBRACE: usize = 0;
3915 pub const INDEX_STATEMENTS: usize = 1;
3916 pub const INDEX_RBRACE: usize = 2;
3917 pub fn new_green(
3918 db: &dyn SyntaxGroup,
3919 lbrace: TerminalLBraceGreen,
3920 statements: StatementListGreen,
3921 rbrace: TerminalRBraceGreen,
3922 ) -> ExprBlockGreen {
3923 let children: Vec<GreenId> = vec![lbrace.0, statements.0, rbrace.0];
3924 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3925 ExprBlockGreen(
3926 Arc::new(GreenNode {
3927 kind: SyntaxKind::ExprBlock,
3928 details: GreenNodeDetails::Node { children, width },
3929 })
3930 .intern(db),
3931 )
3932 }
3933}
3934impl ExprBlock {
3935 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
3936 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
3937 }
3938 pub fn statements(&self, db: &dyn SyntaxGroup) -> StatementList {
3939 StatementList::from_syntax_node(db, self.children[1].clone())
3940 }
3941 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
3942 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
3943 }
3944}
3945#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3946pub struct ExprBlockPtr(pub SyntaxStablePtrId);
3947impl ExprBlockPtr {}
3948impl TypedStablePtr for ExprBlockPtr {
3949 type SyntaxNode = ExprBlock;
3950 fn untyped(&self) -> SyntaxStablePtrId {
3951 self.0
3952 }
3953 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprBlock {
3954 ExprBlock::from_syntax_node(db, self.0.lookup(db))
3955 }
3956}
3957impl From<ExprBlockPtr> for SyntaxStablePtrId {
3958 fn from(ptr: ExprBlockPtr) -> Self {
3959 ptr.untyped()
3960 }
3961}
3962#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3963pub struct ExprBlockGreen(pub GreenId);
3964impl TypedSyntaxNode for ExprBlock {
3965 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprBlock);
3966 type StablePtr = ExprBlockPtr;
3967 type Green = ExprBlockGreen;
3968 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3969 ExprBlockGreen(
3970 Arc::new(GreenNode {
3971 kind: SyntaxKind::ExprBlock,
3972 details: GreenNodeDetails::Node {
3973 children: vec![
3974 TerminalLBrace::missing(db).0,
3975 StatementList::missing(db).0,
3976 TerminalRBrace::missing(db).0,
3977 ],
3978 width: TextWidth::default(),
3979 },
3980 })
3981 .intern(db),
3982 )
3983 }
3984 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3985 let kind = node.kind(db);
3986 assert_eq!(
3987 kind,
3988 SyntaxKind::ExprBlock,
3989 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3990 kind,
3991 SyntaxKind::ExprBlock
3992 );
3993 let children = db.get_children(node.clone());
3994 Self { node, children }
3995 }
3996 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
3997 let kind = node.kind(db);
3998 if kind == SyntaxKind::ExprBlock { Some(Self::from_syntax_node(db, node)) } else { None }
3999 }
4000 fn as_syntax_node(&self) -> SyntaxNode {
4001 self.node.clone()
4002 }
4003 fn stable_ptr(&self) -> Self::StablePtr {
4004 ExprBlockPtr(self.node.0.stable_ptr)
4005 }
4006}
4007impl From<&ExprBlock> for SyntaxStablePtrId {
4008 fn from(node: &ExprBlock) -> Self {
4009 node.stable_ptr().untyped()
4010 }
4011}
4012#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4013pub struct ExprMatch {
4014 node: SyntaxNode,
4015 children: Arc<[SyntaxNode]>,
4016}
4017impl ExprMatch {
4018 pub const INDEX_MATCH_KW: usize = 0;
4019 pub const INDEX_EXPR: usize = 1;
4020 pub const INDEX_LBRACE: usize = 2;
4021 pub const INDEX_ARMS: usize = 3;
4022 pub const INDEX_RBRACE: usize = 4;
4023 pub fn new_green(
4024 db: &dyn SyntaxGroup,
4025 match_kw: TerminalMatchGreen,
4026 expr: ExprGreen,
4027 lbrace: TerminalLBraceGreen,
4028 arms: MatchArmsGreen,
4029 rbrace: TerminalRBraceGreen,
4030 ) -> ExprMatchGreen {
4031 let children: Vec<GreenId> = vec![match_kw.0, expr.0, lbrace.0, arms.0, rbrace.0];
4032 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4033 ExprMatchGreen(
4034 Arc::new(GreenNode {
4035 kind: SyntaxKind::ExprMatch,
4036 details: GreenNodeDetails::Node { children, width },
4037 })
4038 .intern(db),
4039 )
4040 }
4041}
4042impl ExprMatch {
4043 pub fn match_kw(&self, db: &dyn SyntaxGroup) -> TerminalMatch {
4044 TerminalMatch::from_syntax_node(db, self.children[0].clone())
4045 }
4046 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4047 Expr::from_syntax_node(db, self.children[1].clone())
4048 }
4049 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
4050 TerminalLBrace::from_syntax_node(db, self.children[2].clone())
4051 }
4052 pub fn arms(&self, db: &dyn SyntaxGroup) -> MatchArms {
4053 MatchArms::from_syntax_node(db, self.children[3].clone())
4054 }
4055 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
4056 TerminalRBrace::from_syntax_node(db, self.children[4].clone())
4057 }
4058}
4059#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4060pub struct ExprMatchPtr(pub SyntaxStablePtrId);
4061impl ExprMatchPtr {}
4062impl TypedStablePtr for ExprMatchPtr {
4063 type SyntaxNode = ExprMatch;
4064 fn untyped(&self) -> SyntaxStablePtrId {
4065 self.0
4066 }
4067 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprMatch {
4068 ExprMatch::from_syntax_node(db, self.0.lookup(db))
4069 }
4070}
4071impl From<ExprMatchPtr> for SyntaxStablePtrId {
4072 fn from(ptr: ExprMatchPtr) -> Self {
4073 ptr.untyped()
4074 }
4075}
4076#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4077pub struct ExprMatchGreen(pub GreenId);
4078impl TypedSyntaxNode for ExprMatch {
4079 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprMatch);
4080 type StablePtr = ExprMatchPtr;
4081 type Green = ExprMatchGreen;
4082 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4083 ExprMatchGreen(
4084 Arc::new(GreenNode {
4085 kind: SyntaxKind::ExprMatch,
4086 details: GreenNodeDetails::Node {
4087 children: vec![
4088 TerminalMatch::missing(db).0,
4089 Expr::missing(db).0,
4090 TerminalLBrace::missing(db).0,
4091 MatchArms::missing(db).0,
4092 TerminalRBrace::missing(db).0,
4093 ],
4094 width: TextWidth::default(),
4095 },
4096 })
4097 .intern(db),
4098 )
4099 }
4100 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4101 let kind = node.kind(db);
4102 assert_eq!(
4103 kind,
4104 SyntaxKind::ExprMatch,
4105 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4106 kind,
4107 SyntaxKind::ExprMatch
4108 );
4109 let children = db.get_children(node.clone());
4110 Self { node, children }
4111 }
4112 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4113 let kind = node.kind(db);
4114 if kind == SyntaxKind::ExprMatch { Some(Self::from_syntax_node(db, node)) } else { None }
4115 }
4116 fn as_syntax_node(&self) -> SyntaxNode {
4117 self.node.clone()
4118 }
4119 fn stable_ptr(&self) -> Self::StablePtr {
4120 ExprMatchPtr(self.node.0.stable_ptr)
4121 }
4122}
4123impl From<&ExprMatch> for SyntaxStablePtrId {
4124 fn from(node: &ExprMatch) -> Self {
4125 node.stable_ptr().untyped()
4126 }
4127}
4128#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4129pub struct MatchArms(ElementList<MatchArm, 2>);
4130impl Deref for MatchArms {
4131 type Target = ElementList<MatchArm, 2>;
4132 fn deref(&self) -> &Self::Target {
4133 &self.0
4134 }
4135}
4136impl MatchArms {
4137 pub fn new_green(
4138 db: &dyn SyntaxGroup,
4139 children: Vec<MatchArmsElementOrSeparatorGreen>,
4140 ) -> MatchArmsGreen {
4141 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
4142 MatchArmsGreen(
4143 Arc::new(GreenNode {
4144 kind: SyntaxKind::MatchArms,
4145 details: GreenNodeDetails::Node {
4146 children: children.iter().map(|x| x.id()).collect(),
4147 width,
4148 },
4149 })
4150 .intern(db),
4151 )
4152 }
4153}
4154#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4155pub struct MatchArmsPtr(pub SyntaxStablePtrId);
4156impl TypedStablePtr for MatchArmsPtr {
4157 type SyntaxNode = MatchArms;
4158 fn untyped(&self) -> SyntaxStablePtrId {
4159 self.0
4160 }
4161 fn lookup(&self, db: &dyn SyntaxGroup) -> MatchArms {
4162 MatchArms::from_syntax_node(db, self.0.lookup(db))
4163 }
4164}
4165impl From<MatchArmsPtr> for SyntaxStablePtrId {
4166 fn from(ptr: MatchArmsPtr) -> Self {
4167 ptr.untyped()
4168 }
4169}
4170#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4171pub enum MatchArmsElementOrSeparatorGreen {
4172 Separator(TerminalCommaGreen),
4173 Element(MatchArmGreen),
4174}
4175impl From<TerminalCommaGreen> for MatchArmsElementOrSeparatorGreen {
4176 fn from(value: TerminalCommaGreen) -> Self {
4177 MatchArmsElementOrSeparatorGreen::Separator(value)
4178 }
4179}
4180impl From<MatchArmGreen> for MatchArmsElementOrSeparatorGreen {
4181 fn from(value: MatchArmGreen) -> Self {
4182 MatchArmsElementOrSeparatorGreen::Element(value)
4183 }
4184}
4185impl MatchArmsElementOrSeparatorGreen {
4186 fn id(&self) -> GreenId {
4187 match self {
4188 MatchArmsElementOrSeparatorGreen::Separator(green) => green.0,
4189 MatchArmsElementOrSeparatorGreen::Element(green) => green.0,
4190 }
4191 }
4192}
4193#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4194pub struct MatchArmsGreen(pub GreenId);
4195impl TypedSyntaxNode for MatchArms {
4196 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MatchArms);
4197 type StablePtr = MatchArmsPtr;
4198 type Green = MatchArmsGreen;
4199 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4200 MatchArmsGreen(
4201 Arc::new(GreenNode {
4202 kind: SyntaxKind::MatchArms,
4203 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
4204 })
4205 .intern(db),
4206 )
4207 }
4208 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4209 Self(ElementList::new(node))
4210 }
4211 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4212 if node.kind(db) == SyntaxKind::MatchArms {
4213 Some(Self(ElementList::new(node)))
4214 } else {
4215 None
4216 }
4217 }
4218 fn as_syntax_node(&self) -> SyntaxNode {
4219 self.node.clone()
4220 }
4221 fn stable_ptr(&self) -> Self::StablePtr {
4222 MatchArmsPtr(self.node.0.stable_ptr)
4223 }
4224}
4225impl From<&MatchArms> for SyntaxStablePtrId {
4226 fn from(node: &MatchArms) -> Self {
4227 node.stable_ptr().untyped()
4228 }
4229}
4230#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4231pub struct MatchArm {
4232 node: SyntaxNode,
4233 children: Arc<[SyntaxNode]>,
4234}
4235impl MatchArm {
4236 pub const INDEX_PATTERNS: usize = 0;
4237 pub const INDEX_ARROW: usize = 1;
4238 pub const INDEX_EXPRESSION: usize = 2;
4239 pub fn new_green(
4240 db: &dyn SyntaxGroup,
4241 patterns: PatternListOrGreen,
4242 arrow: TerminalMatchArrowGreen,
4243 expression: ExprGreen,
4244 ) -> MatchArmGreen {
4245 let children: Vec<GreenId> = vec![patterns.0, arrow.0, expression.0];
4246 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4247 MatchArmGreen(
4248 Arc::new(GreenNode {
4249 kind: SyntaxKind::MatchArm,
4250 details: GreenNodeDetails::Node { children, width },
4251 })
4252 .intern(db),
4253 )
4254 }
4255}
4256impl MatchArm {
4257 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternListOr {
4258 PatternListOr::from_syntax_node(db, self.children[0].clone())
4259 }
4260 pub fn arrow(&self, db: &dyn SyntaxGroup) -> TerminalMatchArrow {
4261 TerminalMatchArrow::from_syntax_node(db, self.children[1].clone())
4262 }
4263 pub fn expression(&self, db: &dyn SyntaxGroup) -> Expr {
4264 Expr::from_syntax_node(db, self.children[2].clone())
4265 }
4266}
4267#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4268pub struct MatchArmPtr(pub SyntaxStablePtrId);
4269impl MatchArmPtr {}
4270impl TypedStablePtr for MatchArmPtr {
4271 type SyntaxNode = MatchArm;
4272 fn untyped(&self) -> SyntaxStablePtrId {
4273 self.0
4274 }
4275 fn lookup(&self, db: &dyn SyntaxGroup) -> MatchArm {
4276 MatchArm::from_syntax_node(db, self.0.lookup(db))
4277 }
4278}
4279impl From<MatchArmPtr> for SyntaxStablePtrId {
4280 fn from(ptr: MatchArmPtr) -> Self {
4281 ptr.untyped()
4282 }
4283}
4284#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4285pub struct MatchArmGreen(pub GreenId);
4286impl TypedSyntaxNode for MatchArm {
4287 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MatchArm);
4288 type StablePtr = MatchArmPtr;
4289 type Green = MatchArmGreen;
4290 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4291 MatchArmGreen(
4292 Arc::new(GreenNode {
4293 kind: SyntaxKind::MatchArm,
4294 details: GreenNodeDetails::Node {
4295 children: vec![
4296 PatternListOr::missing(db).0,
4297 TerminalMatchArrow::missing(db).0,
4298 Expr::missing(db).0,
4299 ],
4300 width: TextWidth::default(),
4301 },
4302 })
4303 .intern(db),
4304 )
4305 }
4306 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4307 let kind = node.kind(db);
4308 assert_eq!(
4309 kind,
4310 SyntaxKind::MatchArm,
4311 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4312 kind,
4313 SyntaxKind::MatchArm
4314 );
4315 let children = db.get_children(node.clone());
4316 Self { node, children }
4317 }
4318 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4319 let kind = node.kind(db);
4320 if kind == SyntaxKind::MatchArm { Some(Self::from_syntax_node(db, node)) } else { None }
4321 }
4322 fn as_syntax_node(&self) -> SyntaxNode {
4323 self.node.clone()
4324 }
4325 fn stable_ptr(&self) -> Self::StablePtr {
4326 MatchArmPtr(self.node.0.stable_ptr)
4327 }
4328}
4329impl From<&MatchArm> for SyntaxStablePtrId {
4330 fn from(node: &MatchArm) -> Self {
4331 node.stable_ptr().untyped()
4332 }
4333}
4334#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4335pub struct ExprIf {
4336 node: SyntaxNode,
4337 children: Arc<[SyntaxNode]>,
4338}
4339impl ExprIf {
4340 pub const INDEX_IF_KW: usize = 0;
4341 pub const INDEX_CONDITION: usize = 1;
4342 pub const INDEX_IF_BLOCK: usize = 2;
4343 pub const INDEX_ELSE_CLAUSE: usize = 3;
4344 pub fn new_green(
4345 db: &dyn SyntaxGroup,
4346 if_kw: TerminalIfGreen,
4347 condition: ConditionGreen,
4348 if_block: ExprBlockGreen,
4349 else_clause: OptionElseClauseGreen,
4350 ) -> ExprIfGreen {
4351 let children: Vec<GreenId> = vec![if_kw.0, condition.0, if_block.0, else_clause.0];
4352 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4353 ExprIfGreen(
4354 Arc::new(GreenNode {
4355 kind: SyntaxKind::ExprIf,
4356 details: GreenNodeDetails::Node { children, width },
4357 })
4358 .intern(db),
4359 )
4360 }
4361}
4362impl ExprIf {
4363 pub fn if_kw(&self, db: &dyn SyntaxGroup) -> TerminalIf {
4364 TerminalIf::from_syntax_node(db, self.children[0].clone())
4365 }
4366 pub fn condition(&self, db: &dyn SyntaxGroup) -> Condition {
4367 Condition::from_syntax_node(db, self.children[1].clone())
4368 }
4369 pub fn if_block(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4370 ExprBlock::from_syntax_node(db, self.children[2].clone())
4371 }
4372 pub fn else_clause(&self, db: &dyn SyntaxGroup) -> OptionElseClause {
4373 OptionElseClause::from_syntax_node(db, self.children[3].clone())
4374 }
4375}
4376#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4377pub struct ExprIfPtr(pub SyntaxStablePtrId);
4378impl ExprIfPtr {}
4379impl TypedStablePtr for ExprIfPtr {
4380 type SyntaxNode = ExprIf;
4381 fn untyped(&self) -> SyntaxStablePtrId {
4382 self.0
4383 }
4384 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprIf {
4385 ExprIf::from_syntax_node(db, self.0.lookup(db))
4386 }
4387}
4388impl From<ExprIfPtr> for SyntaxStablePtrId {
4389 fn from(ptr: ExprIfPtr) -> Self {
4390 ptr.untyped()
4391 }
4392}
4393#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4394pub struct ExprIfGreen(pub GreenId);
4395impl TypedSyntaxNode for ExprIf {
4396 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprIf);
4397 type StablePtr = ExprIfPtr;
4398 type Green = ExprIfGreen;
4399 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4400 ExprIfGreen(
4401 Arc::new(GreenNode {
4402 kind: SyntaxKind::ExprIf,
4403 details: GreenNodeDetails::Node {
4404 children: vec![
4405 TerminalIf::missing(db).0,
4406 Condition::missing(db).0,
4407 ExprBlock::missing(db).0,
4408 OptionElseClause::missing(db).0,
4409 ],
4410 width: TextWidth::default(),
4411 },
4412 })
4413 .intern(db),
4414 )
4415 }
4416 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4417 let kind = node.kind(db);
4418 assert_eq!(
4419 kind,
4420 SyntaxKind::ExprIf,
4421 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4422 kind,
4423 SyntaxKind::ExprIf
4424 );
4425 let children = db.get_children(node.clone());
4426 Self { node, children }
4427 }
4428 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4429 let kind = node.kind(db);
4430 if kind == SyntaxKind::ExprIf { Some(Self::from_syntax_node(db, node)) } else { None }
4431 }
4432 fn as_syntax_node(&self) -> SyntaxNode {
4433 self.node.clone()
4434 }
4435 fn stable_ptr(&self) -> Self::StablePtr {
4436 ExprIfPtr(self.node.0.stable_ptr)
4437 }
4438}
4439impl From<&ExprIf> for SyntaxStablePtrId {
4440 fn from(node: &ExprIf) -> Self {
4441 node.stable_ptr().untyped()
4442 }
4443}
4444#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4445pub enum Condition {
4446 Let(ConditionLet),
4447 Expr(ConditionExpr),
4448}
4449#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4450pub struct ConditionPtr(pub SyntaxStablePtrId);
4451impl TypedStablePtr for ConditionPtr {
4452 type SyntaxNode = Condition;
4453 fn untyped(&self) -> SyntaxStablePtrId {
4454 self.0
4455 }
4456 fn lookup(&self, db: &dyn SyntaxGroup) -> Condition {
4457 Condition::from_syntax_node(db, self.0.lookup(db))
4458 }
4459}
4460impl From<ConditionPtr> for SyntaxStablePtrId {
4461 fn from(ptr: ConditionPtr) -> Self {
4462 ptr.untyped()
4463 }
4464}
4465impl From<ConditionLetPtr> for ConditionPtr {
4466 fn from(value: ConditionLetPtr) -> Self {
4467 Self(value.0)
4468 }
4469}
4470impl From<ConditionExprPtr> for ConditionPtr {
4471 fn from(value: ConditionExprPtr) -> Self {
4472 Self(value.0)
4473 }
4474}
4475impl From<ConditionLetGreen> for ConditionGreen {
4476 fn from(value: ConditionLetGreen) -> Self {
4477 Self(value.0)
4478 }
4479}
4480impl From<ConditionExprGreen> for ConditionGreen {
4481 fn from(value: ConditionExprGreen) -> Self {
4482 Self(value.0)
4483 }
4484}
4485#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4486pub struct ConditionGreen(pub GreenId);
4487impl TypedSyntaxNode for Condition {
4488 const OPTIONAL_KIND: Option<SyntaxKind> = None;
4489 type StablePtr = ConditionPtr;
4490 type Green = ConditionGreen;
4491 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4492 panic!("No missing variant.");
4493 }
4494 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4495 let kind = node.kind(db);
4496 match kind {
4497 SyntaxKind::ConditionLet => Condition::Let(ConditionLet::from_syntax_node(db, node)),
4498 SyntaxKind::ConditionExpr => Condition::Expr(ConditionExpr::from_syntax_node(db, node)),
4499 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Condition"),
4500 }
4501 }
4502 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4503 let kind = node.kind(db);
4504 match kind {
4505 SyntaxKind::ConditionLet => {
4506 Some(Condition::Let(ConditionLet::from_syntax_node(db, node)))
4507 }
4508 SyntaxKind::ConditionExpr => {
4509 Some(Condition::Expr(ConditionExpr::from_syntax_node(db, node)))
4510 }
4511 _ => None,
4512 }
4513 }
4514 fn as_syntax_node(&self) -> SyntaxNode {
4515 match self {
4516 Condition::Let(x) => x.as_syntax_node(),
4517 Condition::Expr(x) => x.as_syntax_node(),
4518 }
4519 }
4520 fn stable_ptr(&self) -> Self::StablePtr {
4521 ConditionPtr(self.as_syntax_node().0.stable_ptr)
4522 }
4523}
4524impl From<&Condition> for SyntaxStablePtrId {
4525 fn from(node: &Condition) -> Self {
4526 node.stable_ptr().untyped()
4527 }
4528}
4529impl Condition {
4530 pub fn is_variant(kind: SyntaxKind) -> bool {
4532 matches!(kind, SyntaxKind::ConditionLet | SyntaxKind::ConditionExpr)
4533 }
4534}
4535#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4536pub struct ConditionLet {
4537 node: SyntaxNode,
4538 children: Arc<[SyntaxNode]>,
4539}
4540impl ConditionLet {
4541 pub const INDEX_LET_KW: usize = 0;
4542 pub const INDEX_PATTERNS: usize = 1;
4543 pub const INDEX_EQ: usize = 2;
4544 pub const INDEX_EXPR: usize = 3;
4545 pub fn new_green(
4546 db: &dyn SyntaxGroup,
4547 let_kw: TerminalLetGreen,
4548 patterns: PatternListOrGreen,
4549 eq: TerminalEqGreen,
4550 expr: ExprGreen,
4551 ) -> ConditionLetGreen {
4552 let children: Vec<GreenId> = vec![let_kw.0, patterns.0, eq.0, expr.0];
4553 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4554 ConditionLetGreen(
4555 Arc::new(GreenNode {
4556 kind: SyntaxKind::ConditionLet,
4557 details: GreenNodeDetails::Node { children, width },
4558 })
4559 .intern(db),
4560 )
4561 }
4562}
4563impl ConditionLet {
4564 pub fn let_kw(&self, db: &dyn SyntaxGroup) -> TerminalLet {
4565 TerminalLet::from_syntax_node(db, self.children[0].clone())
4566 }
4567 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternListOr {
4568 PatternListOr::from_syntax_node(db, self.children[1].clone())
4569 }
4570 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
4571 TerminalEq::from_syntax_node(db, self.children[2].clone())
4572 }
4573 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4574 Expr::from_syntax_node(db, self.children[3].clone())
4575 }
4576}
4577#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4578pub struct ConditionLetPtr(pub SyntaxStablePtrId);
4579impl ConditionLetPtr {}
4580impl TypedStablePtr for ConditionLetPtr {
4581 type SyntaxNode = ConditionLet;
4582 fn untyped(&self) -> SyntaxStablePtrId {
4583 self.0
4584 }
4585 fn lookup(&self, db: &dyn SyntaxGroup) -> ConditionLet {
4586 ConditionLet::from_syntax_node(db, self.0.lookup(db))
4587 }
4588}
4589impl From<ConditionLetPtr> for SyntaxStablePtrId {
4590 fn from(ptr: ConditionLetPtr) -> Self {
4591 ptr.untyped()
4592 }
4593}
4594#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4595pub struct ConditionLetGreen(pub GreenId);
4596impl TypedSyntaxNode for ConditionLet {
4597 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ConditionLet);
4598 type StablePtr = ConditionLetPtr;
4599 type Green = ConditionLetGreen;
4600 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4601 ConditionLetGreen(
4602 Arc::new(GreenNode {
4603 kind: SyntaxKind::ConditionLet,
4604 details: GreenNodeDetails::Node {
4605 children: vec![
4606 TerminalLet::missing(db).0,
4607 PatternListOr::missing(db).0,
4608 TerminalEq::missing(db).0,
4609 Expr::missing(db).0,
4610 ],
4611 width: TextWidth::default(),
4612 },
4613 })
4614 .intern(db),
4615 )
4616 }
4617 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4618 let kind = node.kind(db);
4619 assert_eq!(
4620 kind,
4621 SyntaxKind::ConditionLet,
4622 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4623 kind,
4624 SyntaxKind::ConditionLet
4625 );
4626 let children = db.get_children(node.clone());
4627 Self { node, children }
4628 }
4629 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4630 let kind = node.kind(db);
4631 if kind == SyntaxKind::ConditionLet { Some(Self::from_syntax_node(db, node)) } else { None }
4632 }
4633 fn as_syntax_node(&self) -> SyntaxNode {
4634 self.node.clone()
4635 }
4636 fn stable_ptr(&self) -> Self::StablePtr {
4637 ConditionLetPtr(self.node.0.stable_ptr)
4638 }
4639}
4640impl From<&ConditionLet> for SyntaxStablePtrId {
4641 fn from(node: &ConditionLet) -> Self {
4642 node.stable_ptr().untyped()
4643 }
4644}
4645#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4646pub struct ConditionExpr {
4647 node: SyntaxNode,
4648 children: Arc<[SyntaxNode]>,
4649}
4650impl ConditionExpr {
4651 pub const INDEX_EXPR: usize = 0;
4652 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> ConditionExprGreen {
4653 let children: Vec<GreenId> = vec![expr.0];
4654 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4655 ConditionExprGreen(
4656 Arc::new(GreenNode {
4657 kind: SyntaxKind::ConditionExpr,
4658 details: GreenNodeDetails::Node { children, width },
4659 })
4660 .intern(db),
4661 )
4662 }
4663}
4664impl ConditionExpr {
4665 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4666 Expr::from_syntax_node(db, self.children[0].clone())
4667 }
4668}
4669#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4670pub struct ConditionExprPtr(pub SyntaxStablePtrId);
4671impl ConditionExprPtr {}
4672impl TypedStablePtr for ConditionExprPtr {
4673 type SyntaxNode = ConditionExpr;
4674 fn untyped(&self) -> SyntaxStablePtrId {
4675 self.0
4676 }
4677 fn lookup(&self, db: &dyn SyntaxGroup) -> ConditionExpr {
4678 ConditionExpr::from_syntax_node(db, self.0.lookup(db))
4679 }
4680}
4681impl From<ConditionExprPtr> for SyntaxStablePtrId {
4682 fn from(ptr: ConditionExprPtr) -> Self {
4683 ptr.untyped()
4684 }
4685}
4686#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4687pub struct ConditionExprGreen(pub GreenId);
4688impl TypedSyntaxNode for ConditionExpr {
4689 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ConditionExpr);
4690 type StablePtr = ConditionExprPtr;
4691 type Green = ConditionExprGreen;
4692 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4693 ConditionExprGreen(
4694 Arc::new(GreenNode {
4695 kind: SyntaxKind::ConditionExpr,
4696 details: GreenNodeDetails::Node {
4697 children: vec![Expr::missing(db).0],
4698 width: TextWidth::default(),
4699 },
4700 })
4701 .intern(db),
4702 )
4703 }
4704 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4705 let kind = node.kind(db);
4706 assert_eq!(
4707 kind,
4708 SyntaxKind::ConditionExpr,
4709 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4710 kind,
4711 SyntaxKind::ConditionExpr
4712 );
4713 let children = db.get_children(node.clone());
4714 Self { node, children }
4715 }
4716 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4717 let kind = node.kind(db);
4718 if kind == SyntaxKind::ConditionExpr {
4719 Some(Self::from_syntax_node(db, node))
4720 } else {
4721 None
4722 }
4723 }
4724 fn as_syntax_node(&self) -> SyntaxNode {
4725 self.node.clone()
4726 }
4727 fn stable_ptr(&self) -> Self::StablePtr {
4728 ConditionExprPtr(self.node.0.stable_ptr)
4729 }
4730}
4731impl From<&ConditionExpr> for SyntaxStablePtrId {
4732 fn from(node: &ConditionExpr) -> Self {
4733 node.stable_ptr().untyped()
4734 }
4735}
4736#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4737pub enum BlockOrIf {
4738 Block(ExprBlock),
4739 If(ExprIf),
4740}
4741#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4742pub struct BlockOrIfPtr(pub SyntaxStablePtrId);
4743impl TypedStablePtr for BlockOrIfPtr {
4744 type SyntaxNode = BlockOrIf;
4745 fn untyped(&self) -> SyntaxStablePtrId {
4746 self.0
4747 }
4748 fn lookup(&self, db: &dyn SyntaxGroup) -> BlockOrIf {
4749 BlockOrIf::from_syntax_node(db, self.0.lookup(db))
4750 }
4751}
4752impl From<BlockOrIfPtr> for SyntaxStablePtrId {
4753 fn from(ptr: BlockOrIfPtr) -> Self {
4754 ptr.untyped()
4755 }
4756}
4757impl From<ExprBlockPtr> for BlockOrIfPtr {
4758 fn from(value: ExprBlockPtr) -> Self {
4759 Self(value.0)
4760 }
4761}
4762impl From<ExprIfPtr> for BlockOrIfPtr {
4763 fn from(value: ExprIfPtr) -> Self {
4764 Self(value.0)
4765 }
4766}
4767impl From<ExprBlockGreen> for BlockOrIfGreen {
4768 fn from(value: ExprBlockGreen) -> Self {
4769 Self(value.0)
4770 }
4771}
4772impl From<ExprIfGreen> for BlockOrIfGreen {
4773 fn from(value: ExprIfGreen) -> Self {
4774 Self(value.0)
4775 }
4776}
4777#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4778pub struct BlockOrIfGreen(pub GreenId);
4779impl TypedSyntaxNode for BlockOrIf {
4780 const OPTIONAL_KIND: Option<SyntaxKind> = None;
4781 type StablePtr = BlockOrIfPtr;
4782 type Green = BlockOrIfGreen;
4783 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4784 panic!("No missing variant.");
4785 }
4786 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4787 let kind = node.kind(db);
4788 match kind {
4789 SyntaxKind::ExprBlock => BlockOrIf::Block(ExprBlock::from_syntax_node(db, node)),
4790 SyntaxKind::ExprIf => BlockOrIf::If(ExprIf::from_syntax_node(db, node)),
4791 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "BlockOrIf"),
4792 }
4793 }
4794 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4795 let kind = node.kind(db);
4796 match kind {
4797 SyntaxKind::ExprBlock => Some(BlockOrIf::Block(ExprBlock::from_syntax_node(db, node))),
4798 SyntaxKind::ExprIf => Some(BlockOrIf::If(ExprIf::from_syntax_node(db, node))),
4799 _ => None,
4800 }
4801 }
4802 fn as_syntax_node(&self) -> SyntaxNode {
4803 match self {
4804 BlockOrIf::Block(x) => x.as_syntax_node(),
4805 BlockOrIf::If(x) => x.as_syntax_node(),
4806 }
4807 }
4808 fn stable_ptr(&self) -> Self::StablePtr {
4809 BlockOrIfPtr(self.as_syntax_node().0.stable_ptr)
4810 }
4811}
4812impl From<&BlockOrIf> for SyntaxStablePtrId {
4813 fn from(node: &BlockOrIf) -> Self {
4814 node.stable_ptr().untyped()
4815 }
4816}
4817impl BlockOrIf {
4818 pub fn is_variant(kind: SyntaxKind) -> bool {
4820 matches!(kind, SyntaxKind::ExprBlock | SyntaxKind::ExprIf)
4821 }
4822}
4823#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4824pub struct ExprLoop {
4825 node: SyntaxNode,
4826 children: Arc<[SyntaxNode]>,
4827}
4828impl ExprLoop {
4829 pub const INDEX_LOOP_KW: usize = 0;
4830 pub const INDEX_BODY: usize = 1;
4831 pub fn new_green(
4832 db: &dyn SyntaxGroup,
4833 loop_kw: TerminalLoopGreen,
4834 body: ExprBlockGreen,
4835 ) -> ExprLoopGreen {
4836 let children: Vec<GreenId> = vec![loop_kw.0, body.0];
4837 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4838 ExprLoopGreen(
4839 Arc::new(GreenNode {
4840 kind: SyntaxKind::ExprLoop,
4841 details: GreenNodeDetails::Node { children, width },
4842 })
4843 .intern(db),
4844 )
4845 }
4846}
4847impl ExprLoop {
4848 pub fn loop_kw(&self, db: &dyn SyntaxGroup) -> TerminalLoop {
4849 TerminalLoop::from_syntax_node(db, self.children[0].clone())
4850 }
4851 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4852 ExprBlock::from_syntax_node(db, self.children[1].clone())
4853 }
4854}
4855#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4856pub struct ExprLoopPtr(pub SyntaxStablePtrId);
4857impl ExprLoopPtr {}
4858impl TypedStablePtr for ExprLoopPtr {
4859 type SyntaxNode = ExprLoop;
4860 fn untyped(&self) -> SyntaxStablePtrId {
4861 self.0
4862 }
4863 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprLoop {
4864 ExprLoop::from_syntax_node(db, self.0.lookup(db))
4865 }
4866}
4867impl From<ExprLoopPtr> for SyntaxStablePtrId {
4868 fn from(ptr: ExprLoopPtr) -> Self {
4869 ptr.untyped()
4870 }
4871}
4872#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4873pub struct ExprLoopGreen(pub GreenId);
4874impl TypedSyntaxNode for ExprLoop {
4875 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprLoop);
4876 type StablePtr = ExprLoopPtr;
4877 type Green = ExprLoopGreen;
4878 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4879 ExprLoopGreen(
4880 Arc::new(GreenNode {
4881 kind: SyntaxKind::ExprLoop,
4882 details: GreenNodeDetails::Node {
4883 children: vec![TerminalLoop::missing(db).0, ExprBlock::missing(db).0],
4884 width: TextWidth::default(),
4885 },
4886 })
4887 .intern(db),
4888 )
4889 }
4890 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4891 let kind = node.kind(db);
4892 assert_eq!(
4893 kind,
4894 SyntaxKind::ExprLoop,
4895 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4896 kind,
4897 SyntaxKind::ExprLoop
4898 );
4899 let children = db.get_children(node.clone());
4900 Self { node, children }
4901 }
4902 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
4903 let kind = node.kind(db);
4904 if kind == SyntaxKind::ExprLoop { Some(Self::from_syntax_node(db, node)) } else { None }
4905 }
4906 fn as_syntax_node(&self) -> SyntaxNode {
4907 self.node.clone()
4908 }
4909 fn stable_ptr(&self) -> Self::StablePtr {
4910 ExprLoopPtr(self.node.0.stable_ptr)
4911 }
4912}
4913impl From<&ExprLoop> for SyntaxStablePtrId {
4914 fn from(node: &ExprLoop) -> Self {
4915 node.stable_ptr().untyped()
4916 }
4917}
4918#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4919pub struct ExprWhile {
4920 node: SyntaxNode,
4921 children: Arc<[SyntaxNode]>,
4922}
4923impl ExprWhile {
4924 pub const INDEX_WHILE_KW: usize = 0;
4925 pub const INDEX_CONDITION: usize = 1;
4926 pub const INDEX_BODY: usize = 2;
4927 pub fn new_green(
4928 db: &dyn SyntaxGroup,
4929 while_kw: TerminalWhileGreen,
4930 condition: ConditionGreen,
4931 body: ExprBlockGreen,
4932 ) -> ExprWhileGreen {
4933 let children: Vec<GreenId> = vec![while_kw.0, condition.0, body.0];
4934 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4935 ExprWhileGreen(
4936 Arc::new(GreenNode {
4937 kind: SyntaxKind::ExprWhile,
4938 details: GreenNodeDetails::Node { children, width },
4939 })
4940 .intern(db),
4941 )
4942 }
4943}
4944impl ExprWhile {
4945 pub fn while_kw(&self, db: &dyn SyntaxGroup) -> TerminalWhile {
4946 TerminalWhile::from_syntax_node(db, self.children[0].clone())
4947 }
4948 pub fn condition(&self, db: &dyn SyntaxGroup) -> Condition {
4949 Condition::from_syntax_node(db, self.children[1].clone())
4950 }
4951 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4952 ExprBlock::from_syntax_node(db, self.children[2].clone())
4953 }
4954}
4955#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4956pub struct ExprWhilePtr(pub SyntaxStablePtrId);
4957impl ExprWhilePtr {}
4958impl TypedStablePtr for ExprWhilePtr {
4959 type SyntaxNode = ExprWhile;
4960 fn untyped(&self) -> SyntaxStablePtrId {
4961 self.0
4962 }
4963 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprWhile {
4964 ExprWhile::from_syntax_node(db, self.0.lookup(db))
4965 }
4966}
4967impl From<ExprWhilePtr> for SyntaxStablePtrId {
4968 fn from(ptr: ExprWhilePtr) -> Self {
4969 ptr.untyped()
4970 }
4971}
4972#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4973pub struct ExprWhileGreen(pub GreenId);
4974impl TypedSyntaxNode for ExprWhile {
4975 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprWhile);
4976 type StablePtr = ExprWhilePtr;
4977 type Green = ExprWhileGreen;
4978 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4979 ExprWhileGreen(
4980 Arc::new(GreenNode {
4981 kind: SyntaxKind::ExprWhile,
4982 details: GreenNodeDetails::Node {
4983 children: vec![
4984 TerminalWhile::missing(db).0,
4985 Condition::missing(db).0,
4986 ExprBlock::missing(db).0,
4987 ],
4988 width: TextWidth::default(),
4989 },
4990 })
4991 .intern(db),
4992 )
4993 }
4994 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4995 let kind = node.kind(db);
4996 assert_eq!(
4997 kind,
4998 SyntaxKind::ExprWhile,
4999 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5000 kind,
5001 SyntaxKind::ExprWhile
5002 );
5003 let children = db.get_children(node.clone());
5004 Self { node, children }
5005 }
5006 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5007 let kind = node.kind(db);
5008 if kind == SyntaxKind::ExprWhile { Some(Self::from_syntax_node(db, node)) } else { None }
5009 }
5010 fn as_syntax_node(&self) -> SyntaxNode {
5011 self.node.clone()
5012 }
5013 fn stable_ptr(&self) -> Self::StablePtr {
5014 ExprWhilePtr(self.node.0.stable_ptr)
5015 }
5016}
5017impl From<&ExprWhile> for SyntaxStablePtrId {
5018 fn from(node: &ExprWhile) -> Self {
5019 node.stable_ptr().untyped()
5020 }
5021}
5022#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5023pub struct ExprFor {
5024 node: SyntaxNode,
5025 children: Arc<[SyntaxNode]>,
5026}
5027impl ExprFor {
5028 pub const INDEX_FOR_KW: usize = 0;
5029 pub const INDEX_PATTERN: usize = 1;
5030 pub const INDEX_IDENTIFIER: usize = 2;
5031 pub const INDEX_EXPR: usize = 3;
5032 pub const INDEX_BODY: usize = 4;
5033 pub fn new_green(
5034 db: &dyn SyntaxGroup,
5035 for_kw: TerminalForGreen,
5036 pattern: PatternGreen,
5037 identifier: TerminalIdentifierGreen,
5038 expr: ExprGreen,
5039 body: ExprBlockGreen,
5040 ) -> ExprForGreen {
5041 let children: Vec<GreenId> = vec![for_kw.0, pattern.0, identifier.0, expr.0, body.0];
5042 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5043 ExprForGreen(
5044 Arc::new(GreenNode {
5045 kind: SyntaxKind::ExprFor,
5046 details: GreenNodeDetails::Node { children, width },
5047 })
5048 .intern(db),
5049 )
5050 }
5051}
5052impl ExprFor {
5053 pub fn for_kw(&self, db: &dyn SyntaxGroup) -> TerminalFor {
5054 TerminalFor::from_syntax_node(db, self.children[0].clone())
5055 }
5056 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
5057 Pattern::from_syntax_node(db, self.children[1].clone())
5058 }
5059 pub fn identifier(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
5060 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
5061 }
5062 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5063 Expr::from_syntax_node(db, self.children[3].clone())
5064 }
5065 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
5066 ExprBlock::from_syntax_node(db, self.children[4].clone())
5067 }
5068}
5069#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5070pub struct ExprForPtr(pub SyntaxStablePtrId);
5071impl ExprForPtr {
5072 pub fn pattern_green(self, db: &dyn SyntaxGroup) -> PatternGreen {
5073 let ptr = self.0.lookup_intern(db);
5074 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
5075 PatternGreen(key_fields[0])
5076 } else {
5077 panic!("Unexpected key field query on root.");
5078 }
5079 }
5080 pub fn identifier_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
5081 let ptr = self.0.lookup_intern(db);
5082 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
5083 TerminalIdentifierGreen(key_fields[1])
5084 } else {
5085 panic!("Unexpected key field query on root.");
5086 }
5087 }
5088}
5089impl TypedStablePtr for ExprForPtr {
5090 type SyntaxNode = ExprFor;
5091 fn untyped(&self) -> SyntaxStablePtrId {
5092 self.0
5093 }
5094 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFor {
5095 ExprFor::from_syntax_node(db, self.0.lookup(db))
5096 }
5097}
5098impl From<ExprForPtr> for SyntaxStablePtrId {
5099 fn from(ptr: ExprForPtr) -> Self {
5100 ptr.untyped()
5101 }
5102}
5103#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5104pub struct ExprForGreen(pub GreenId);
5105impl TypedSyntaxNode for ExprFor {
5106 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFor);
5107 type StablePtr = ExprForPtr;
5108 type Green = ExprForGreen;
5109 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5110 ExprForGreen(
5111 Arc::new(GreenNode {
5112 kind: SyntaxKind::ExprFor,
5113 details: GreenNodeDetails::Node {
5114 children: vec![
5115 TerminalFor::missing(db).0,
5116 Pattern::missing(db).0,
5117 TerminalIdentifier::missing(db).0,
5118 Expr::missing(db).0,
5119 ExprBlock::missing(db).0,
5120 ],
5121 width: TextWidth::default(),
5122 },
5123 })
5124 .intern(db),
5125 )
5126 }
5127 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5128 let kind = node.kind(db);
5129 assert_eq!(
5130 kind,
5131 SyntaxKind::ExprFor,
5132 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5133 kind,
5134 SyntaxKind::ExprFor
5135 );
5136 let children = db.get_children(node.clone());
5137 Self { node, children }
5138 }
5139 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5140 let kind = node.kind(db);
5141 if kind == SyntaxKind::ExprFor { Some(Self::from_syntax_node(db, node)) } else { None }
5142 }
5143 fn as_syntax_node(&self) -> SyntaxNode {
5144 self.node.clone()
5145 }
5146 fn stable_ptr(&self) -> Self::StablePtr {
5147 ExprForPtr(self.node.0.stable_ptr)
5148 }
5149}
5150impl From<&ExprFor> for SyntaxStablePtrId {
5151 fn from(node: &ExprFor) -> Self {
5152 node.stable_ptr().untyped()
5153 }
5154}
5155#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5156pub struct ElseClause {
5157 node: SyntaxNode,
5158 children: Arc<[SyntaxNode]>,
5159}
5160impl ElseClause {
5161 pub const INDEX_ELSE_KW: usize = 0;
5162 pub const INDEX_ELSE_BLOCK_OR_IF: usize = 1;
5163 pub fn new_green(
5164 db: &dyn SyntaxGroup,
5165 else_kw: TerminalElseGreen,
5166 else_block_or_if: BlockOrIfGreen,
5167 ) -> ElseClauseGreen {
5168 let children: Vec<GreenId> = vec![else_kw.0, else_block_or_if.0];
5169 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5170 ElseClauseGreen(
5171 Arc::new(GreenNode {
5172 kind: SyntaxKind::ElseClause,
5173 details: GreenNodeDetails::Node { children, width },
5174 })
5175 .intern(db),
5176 )
5177 }
5178}
5179impl ElseClause {
5180 pub fn else_kw(&self, db: &dyn SyntaxGroup) -> TerminalElse {
5181 TerminalElse::from_syntax_node(db, self.children[0].clone())
5182 }
5183 pub fn else_block_or_if(&self, db: &dyn SyntaxGroup) -> BlockOrIf {
5184 BlockOrIf::from_syntax_node(db, self.children[1].clone())
5185 }
5186}
5187#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5188pub struct ElseClausePtr(pub SyntaxStablePtrId);
5189impl ElseClausePtr {}
5190impl TypedStablePtr for ElseClausePtr {
5191 type SyntaxNode = ElseClause;
5192 fn untyped(&self) -> SyntaxStablePtrId {
5193 self.0
5194 }
5195 fn lookup(&self, db: &dyn SyntaxGroup) -> ElseClause {
5196 ElseClause::from_syntax_node(db, self.0.lookup(db))
5197 }
5198}
5199impl From<ElseClausePtr> for SyntaxStablePtrId {
5200 fn from(ptr: ElseClausePtr) -> Self {
5201 ptr.untyped()
5202 }
5203}
5204#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5205pub struct ElseClauseGreen(pub GreenId);
5206impl TypedSyntaxNode for ElseClause {
5207 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ElseClause);
5208 type StablePtr = ElseClausePtr;
5209 type Green = ElseClauseGreen;
5210 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5211 ElseClauseGreen(
5212 Arc::new(GreenNode {
5213 kind: SyntaxKind::ElseClause,
5214 details: GreenNodeDetails::Node {
5215 children: vec![TerminalElse::missing(db).0, BlockOrIf::missing(db).0],
5216 width: TextWidth::default(),
5217 },
5218 })
5219 .intern(db),
5220 )
5221 }
5222 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5223 let kind = node.kind(db);
5224 assert_eq!(
5225 kind,
5226 SyntaxKind::ElseClause,
5227 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5228 kind,
5229 SyntaxKind::ElseClause
5230 );
5231 let children = db.get_children(node.clone());
5232 Self { node, children }
5233 }
5234 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5235 let kind = node.kind(db);
5236 if kind == SyntaxKind::ElseClause { Some(Self::from_syntax_node(db, node)) } else { None }
5237 }
5238 fn as_syntax_node(&self) -> SyntaxNode {
5239 self.node.clone()
5240 }
5241 fn stable_ptr(&self) -> Self::StablePtr {
5242 ElseClausePtr(self.node.0.stable_ptr)
5243 }
5244}
5245impl From<&ElseClause> for SyntaxStablePtrId {
5246 fn from(node: &ElseClause) -> Self {
5247 node.stable_ptr().untyped()
5248 }
5249}
5250#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5251pub enum OptionElseClause {
5252 Empty(OptionElseClauseEmpty),
5253 ElseClause(ElseClause),
5254}
5255#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5256pub struct OptionElseClausePtr(pub SyntaxStablePtrId);
5257impl TypedStablePtr for OptionElseClausePtr {
5258 type SyntaxNode = OptionElseClause;
5259 fn untyped(&self) -> SyntaxStablePtrId {
5260 self.0
5261 }
5262 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionElseClause {
5263 OptionElseClause::from_syntax_node(db, self.0.lookup(db))
5264 }
5265}
5266impl From<OptionElseClausePtr> for SyntaxStablePtrId {
5267 fn from(ptr: OptionElseClausePtr) -> Self {
5268 ptr.untyped()
5269 }
5270}
5271impl From<OptionElseClauseEmptyPtr> for OptionElseClausePtr {
5272 fn from(value: OptionElseClauseEmptyPtr) -> Self {
5273 Self(value.0)
5274 }
5275}
5276impl From<ElseClausePtr> for OptionElseClausePtr {
5277 fn from(value: ElseClausePtr) -> Self {
5278 Self(value.0)
5279 }
5280}
5281impl From<OptionElseClauseEmptyGreen> for OptionElseClauseGreen {
5282 fn from(value: OptionElseClauseEmptyGreen) -> Self {
5283 Self(value.0)
5284 }
5285}
5286impl From<ElseClauseGreen> for OptionElseClauseGreen {
5287 fn from(value: ElseClauseGreen) -> Self {
5288 Self(value.0)
5289 }
5290}
5291#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5292pub struct OptionElseClauseGreen(pub GreenId);
5293impl TypedSyntaxNode for OptionElseClause {
5294 const OPTIONAL_KIND: Option<SyntaxKind> = None;
5295 type StablePtr = OptionElseClausePtr;
5296 type Green = OptionElseClauseGreen;
5297 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5298 panic!("No missing variant.");
5299 }
5300 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5301 let kind = node.kind(db);
5302 match kind {
5303 SyntaxKind::OptionElseClauseEmpty => {
5304 OptionElseClause::Empty(OptionElseClauseEmpty::from_syntax_node(db, node))
5305 }
5306 SyntaxKind::ElseClause => {
5307 OptionElseClause::ElseClause(ElseClause::from_syntax_node(db, node))
5308 }
5309 _ => panic!(
5310 "Unexpected syntax kind {:?} when constructing {}.",
5311 kind, "OptionElseClause"
5312 ),
5313 }
5314 }
5315 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5316 let kind = node.kind(db);
5317 match kind {
5318 SyntaxKind::OptionElseClauseEmpty => {
5319 Some(OptionElseClause::Empty(OptionElseClauseEmpty::from_syntax_node(db, node)))
5320 }
5321 SyntaxKind::ElseClause => {
5322 Some(OptionElseClause::ElseClause(ElseClause::from_syntax_node(db, node)))
5323 }
5324 _ => None,
5325 }
5326 }
5327 fn as_syntax_node(&self) -> SyntaxNode {
5328 match self {
5329 OptionElseClause::Empty(x) => x.as_syntax_node(),
5330 OptionElseClause::ElseClause(x) => x.as_syntax_node(),
5331 }
5332 }
5333 fn stable_ptr(&self) -> Self::StablePtr {
5334 OptionElseClausePtr(self.as_syntax_node().0.stable_ptr)
5335 }
5336}
5337impl From<&OptionElseClause> for SyntaxStablePtrId {
5338 fn from(node: &OptionElseClause) -> Self {
5339 node.stable_ptr().untyped()
5340 }
5341}
5342impl OptionElseClause {
5343 pub fn is_variant(kind: SyntaxKind) -> bool {
5345 matches!(kind, SyntaxKind::OptionElseClauseEmpty | SyntaxKind::ElseClause)
5346 }
5347}
5348#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5349pub struct OptionElseClauseEmpty {
5350 node: SyntaxNode,
5351 children: Arc<[SyntaxNode]>,
5352}
5353impl OptionElseClauseEmpty {
5354 pub fn new_green(db: &dyn SyntaxGroup) -> OptionElseClauseEmptyGreen {
5355 let children: Vec<GreenId> = vec![];
5356 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5357 OptionElseClauseEmptyGreen(
5358 Arc::new(GreenNode {
5359 kind: SyntaxKind::OptionElseClauseEmpty,
5360 details: GreenNodeDetails::Node { children, width },
5361 })
5362 .intern(db),
5363 )
5364 }
5365}
5366impl OptionElseClauseEmpty {}
5367#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5368pub struct OptionElseClauseEmptyPtr(pub SyntaxStablePtrId);
5369impl OptionElseClauseEmptyPtr {}
5370impl TypedStablePtr for OptionElseClauseEmptyPtr {
5371 type SyntaxNode = OptionElseClauseEmpty;
5372 fn untyped(&self) -> SyntaxStablePtrId {
5373 self.0
5374 }
5375 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionElseClauseEmpty {
5376 OptionElseClauseEmpty::from_syntax_node(db, self.0.lookup(db))
5377 }
5378}
5379impl From<OptionElseClauseEmptyPtr> for SyntaxStablePtrId {
5380 fn from(ptr: OptionElseClauseEmptyPtr) -> Self {
5381 ptr.untyped()
5382 }
5383}
5384#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5385pub struct OptionElseClauseEmptyGreen(pub GreenId);
5386impl TypedSyntaxNode for OptionElseClauseEmpty {
5387 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionElseClauseEmpty);
5388 type StablePtr = OptionElseClauseEmptyPtr;
5389 type Green = OptionElseClauseEmptyGreen;
5390 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5391 OptionElseClauseEmptyGreen(
5392 Arc::new(GreenNode {
5393 kind: SyntaxKind::OptionElseClauseEmpty,
5394 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
5395 })
5396 .intern(db),
5397 )
5398 }
5399 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5400 let kind = node.kind(db);
5401 assert_eq!(
5402 kind,
5403 SyntaxKind::OptionElseClauseEmpty,
5404 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5405 kind,
5406 SyntaxKind::OptionElseClauseEmpty
5407 );
5408 let children = db.get_children(node.clone());
5409 Self { node, children }
5410 }
5411 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5412 let kind = node.kind(db);
5413 if kind == SyntaxKind::OptionElseClauseEmpty {
5414 Some(Self::from_syntax_node(db, node))
5415 } else {
5416 None
5417 }
5418 }
5419 fn as_syntax_node(&self) -> SyntaxNode {
5420 self.node.clone()
5421 }
5422 fn stable_ptr(&self) -> Self::StablePtr {
5423 OptionElseClauseEmptyPtr(self.node.0.stable_ptr)
5424 }
5425}
5426impl From<&OptionElseClauseEmpty> for SyntaxStablePtrId {
5427 fn from(node: &OptionElseClauseEmpty) -> Self {
5428 node.stable_ptr().untyped()
5429 }
5430}
5431#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5432pub struct ExprErrorPropagate {
5433 node: SyntaxNode,
5434 children: Arc<[SyntaxNode]>,
5435}
5436impl ExprErrorPropagate {
5437 pub const INDEX_EXPR: usize = 0;
5438 pub const INDEX_OP: usize = 1;
5439 pub fn new_green(
5440 db: &dyn SyntaxGroup,
5441 expr: ExprGreen,
5442 op: TerminalQuestionMarkGreen,
5443 ) -> ExprErrorPropagateGreen {
5444 let children: Vec<GreenId> = vec![expr.0, op.0];
5445 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5446 ExprErrorPropagateGreen(
5447 Arc::new(GreenNode {
5448 kind: SyntaxKind::ExprErrorPropagate,
5449 details: GreenNodeDetails::Node { children, width },
5450 })
5451 .intern(db),
5452 )
5453 }
5454}
5455impl ExprErrorPropagate {
5456 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5457 Expr::from_syntax_node(db, self.children[0].clone())
5458 }
5459 pub fn op(&self, db: &dyn SyntaxGroup) -> TerminalQuestionMark {
5460 TerminalQuestionMark::from_syntax_node(db, self.children[1].clone())
5461 }
5462}
5463#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5464pub struct ExprErrorPropagatePtr(pub SyntaxStablePtrId);
5465impl ExprErrorPropagatePtr {}
5466impl TypedStablePtr for ExprErrorPropagatePtr {
5467 type SyntaxNode = ExprErrorPropagate;
5468 fn untyped(&self) -> SyntaxStablePtrId {
5469 self.0
5470 }
5471 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprErrorPropagate {
5472 ExprErrorPropagate::from_syntax_node(db, self.0.lookup(db))
5473 }
5474}
5475impl From<ExprErrorPropagatePtr> for SyntaxStablePtrId {
5476 fn from(ptr: ExprErrorPropagatePtr) -> Self {
5477 ptr.untyped()
5478 }
5479}
5480#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5481pub struct ExprErrorPropagateGreen(pub GreenId);
5482impl TypedSyntaxNode for ExprErrorPropagate {
5483 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprErrorPropagate);
5484 type StablePtr = ExprErrorPropagatePtr;
5485 type Green = ExprErrorPropagateGreen;
5486 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5487 ExprErrorPropagateGreen(
5488 Arc::new(GreenNode {
5489 kind: SyntaxKind::ExprErrorPropagate,
5490 details: GreenNodeDetails::Node {
5491 children: vec![Expr::missing(db).0, TerminalQuestionMark::missing(db).0],
5492 width: TextWidth::default(),
5493 },
5494 })
5495 .intern(db),
5496 )
5497 }
5498 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5499 let kind = node.kind(db);
5500 assert_eq!(
5501 kind,
5502 SyntaxKind::ExprErrorPropagate,
5503 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5504 kind,
5505 SyntaxKind::ExprErrorPropagate
5506 );
5507 let children = db.get_children(node.clone());
5508 Self { node, children }
5509 }
5510 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5511 let kind = node.kind(db);
5512 if kind == SyntaxKind::ExprErrorPropagate {
5513 Some(Self::from_syntax_node(db, node))
5514 } else {
5515 None
5516 }
5517 }
5518 fn as_syntax_node(&self) -> SyntaxNode {
5519 self.node.clone()
5520 }
5521 fn stable_ptr(&self) -> Self::StablePtr {
5522 ExprErrorPropagatePtr(self.node.0.stable_ptr)
5523 }
5524}
5525impl From<&ExprErrorPropagate> for SyntaxStablePtrId {
5526 fn from(node: &ExprErrorPropagate) -> Self {
5527 node.stable_ptr().untyped()
5528 }
5529}
5530#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5531pub struct ExprIndexed {
5532 node: SyntaxNode,
5533 children: Arc<[SyntaxNode]>,
5534}
5535impl ExprIndexed {
5536 pub const INDEX_EXPR: usize = 0;
5537 pub const INDEX_LBRACK: usize = 1;
5538 pub const INDEX_INDEX_EXPR: usize = 2;
5539 pub const INDEX_RBRACK: usize = 3;
5540 pub fn new_green(
5541 db: &dyn SyntaxGroup,
5542 expr: ExprGreen,
5543 lbrack: TerminalLBrackGreen,
5544 index_expr: ExprGreen,
5545 rbrack: TerminalRBrackGreen,
5546 ) -> ExprIndexedGreen {
5547 let children: Vec<GreenId> = vec![expr.0, lbrack.0, index_expr.0, rbrack.0];
5548 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5549 ExprIndexedGreen(
5550 Arc::new(GreenNode {
5551 kind: SyntaxKind::ExprIndexed,
5552 details: GreenNodeDetails::Node { children, width },
5553 })
5554 .intern(db),
5555 )
5556 }
5557}
5558impl ExprIndexed {
5559 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5560 Expr::from_syntax_node(db, self.children[0].clone())
5561 }
5562 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
5563 TerminalLBrack::from_syntax_node(db, self.children[1].clone())
5564 }
5565 pub fn index_expr(&self, db: &dyn SyntaxGroup) -> Expr {
5566 Expr::from_syntax_node(db, self.children[2].clone())
5567 }
5568 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
5569 TerminalRBrack::from_syntax_node(db, self.children[3].clone())
5570 }
5571}
5572#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5573pub struct ExprIndexedPtr(pub SyntaxStablePtrId);
5574impl ExprIndexedPtr {}
5575impl TypedStablePtr for ExprIndexedPtr {
5576 type SyntaxNode = ExprIndexed;
5577 fn untyped(&self) -> SyntaxStablePtrId {
5578 self.0
5579 }
5580 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprIndexed {
5581 ExprIndexed::from_syntax_node(db, self.0.lookup(db))
5582 }
5583}
5584impl From<ExprIndexedPtr> for SyntaxStablePtrId {
5585 fn from(ptr: ExprIndexedPtr) -> Self {
5586 ptr.untyped()
5587 }
5588}
5589#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5590pub struct ExprIndexedGreen(pub GreenId);
5591impl TypedSyntaxNode for ExprIndexed {
5592 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprIndexed);
5593 type StablePtr = ExprIndexedPtr;
5594 type Green = ExprIndexedGreen;
5595 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5596 ExprIndexedGreen(
5597 Arc::new(GreenNode {
5598 kind: SyntaxKind::ExprIndexed,
5599 details: GreenNodeDetails::Node {
5600 children: vec![
5601 Expr::missing(db).0,
5602 TerminalLBrack::missing(db).0,
5603 Expr::missing(db).0,
5604 TerminalRBrack::missing(db).0,
5605 ],
5606 width: TextWidth::default(),
5607 },
5608 })
5609 .intern(db),
5610 )
5611 }
5612 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5613 let kind = node.kind(db);
5614 assert_eq!(
5615 kind,
5616 SyntaxKind::ExprIndexed,
5617 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5618 kind,
5619 SyntaxKind::ExprIndexed
5620 );
5621 let children = db.get_children(node.clone());
5622 Self { node, children }
5623 }
5624 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5625 let kind = node.kind(db);
5626 if kind == SyntaxKind::ExprIndexed { Some(Self::from_syntax_node(db, node)) } else { None }
5627 }
5628 fn as_syntax_node(&self) -> SyntaxNode {
5629 self.node.clone()
5630 }
5631 fn stable_ptr(&self) -> Self::StablePtr {
5632 ExprIndexedPtr(self.node.0.stable_ptr)
5633 }
5634}
5635impl From<&ExprIndexed> for SyntaxStablePtrId {
5636 fn from(node: &ExprIndexed) -> Self {
5637 node.stable_ptr().untyped()
5638 }
5639}
5640#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5641pub struct ExprInlineMacro {
5642 node: SyntaxNode,
5643 children: Arc<[SyntaxNode]>,
5644}
5645impl ExprInlineMacro {
5646 pub const INDEX_PATH: usize = 0;
5647 pub const INDEX_BANG: usize = 1;
5648 pub const INDEX_ARGUMENTS: usize = 2;
5649 pub fn new_green(
5650 db: &dyn SyntaxGroup,
5651 path: ExprPathGreen,
5652 bang: TerminalNotGreen,
5653 arguments: WrappedArgListGreen,
5654 ) -> ExprInlineMacroGreen {
5655 let children: Vec<GreenId> = vec![path.0, bang.0, arguments.0];
5656 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5657 ExprInlineMacroGreen(
5658 Arc::new(GreenNode {
5659 kind: SyntaxKind::ExprInlineMacro,
5660 details: GreenNodeDetails::Node { children, width },
5661 })
5662 .intern(db),
5663 )
5664 }
5665}
5666impl ExprInlineMacro {
5667 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
5668 ExprPath::from_syntax_node(db, self.children[0].clone())
5669 }
5670 pub fn bang(&self, db: &dyn SyntaxGroup) -> TerminalNot {
5671 TerminalNot::from_syntax_node(db, self.children[1].clone())
5672 }
5673 pub fn arguments(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
5674 WrappedArgList::from_syntax_node(db, self.children[2].clone())
5675 }
5676}
5677#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5678pub struct ExprInlineMacroPtr(pub SyntaxStablePtrId);
5679impl ExprInlineMacroPtr {}
5680impl TypedStablePtr for ExprInlineMacroPtr {
5681 type SyntaxNode = ExprInlineMacro;
5682 fn untyped(&self) -> SyntaxStablePtrId {
5683 self.0
5684 }
5685 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprInlineMacro {
5686 ExprInlineMacro::from_syntax_node(db, self.0.lookup(db))
5687 }
5688}
5689impl From<ExprInlineMacroPtr> for SyntaxStablePtrId {
5690 fn from(ptr: ExprInlineMacroPtr) -> Self {
5691 ptr.untyped()
5692 }
5693}
5694#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5695pub struct ExprInlineMacroGreen(pub GreenId);
5696impl TypedSyntaxNode for ExprInlineMacro {
5697 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprInlineMacro);
5698 type StablePtr = ExprInlineMacroPtr;
5699 type Green = ExprInlineMacroGreen;
5700 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5701 ExprInlineMacroGreen(
5702 Arc::new(GreenNode {
5703 kind: SyntaxKind::ExprInlineMacro,
5704 details: GreenNodeDetails::Node {
5705 children: vec![
5706 ExprPath::missing(db).0,
5707 TerminalNot::missing(db).0,
5708 WrappedArgList::missing(db).0,
5709 ],
5710 width: TextWidth::default(),
5711 },
5712 })
5713 .intern(db),
5714 )
5715 }
5716 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5717 let kind = node.kind(db);
5718 assert_eq!(
5719 kind,
5720 SyntaxKind::ExprInlineMacro,
5721 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5722 kind,
5723 SyntaxKind::ExprInlineMacro
5724 );
5725 let children = db.get_children(node.clone());
5726 Self { node, children }
5727 }
5728 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5729 let kind = node.kind(db);
5730 if kind == SyntaxKind::ExprInlineMacro {
5731 Some(Self::from_syntax_node(db, node))
5732 } else {
5733 None
5734 }
5735 }
5736 fn as_syntax_node(&self) -> SyntaxNode {
5737 self.node.clone()
5738 }
5739 fn stable_ptr(&self) -> Self::StablePtr {
5740 ExprInlineMacroPtr(self.node.0.stable_ptr)
5741 }
5742}
5743impl From<&ExprInlineMacro> for SyntaxStablePtrId {
5744 fn from(node: &ExprInlineMacro) -> Self {
5745 node.stable_ptr().untyped()
5746 }
5747}
5748#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5749pub struct ExprFixedSizeArray {
5750 node: SyntaxNode,
5751 children: Arc<[SyntaxNode]>,
5752}
5753impl ExprFixedSizeArray {
5754 pub const INDEX_LBRACK: usize = 0;
5755 pub const INDEX_EXPRS: usize = 1;
5756 pub const INDEX_SIZE: usize = 2;
5757 pub const INDEX_RBRACK: usize = 3;
5758 pub fn new_green(
5759 db: &dyn SyntaxGroup,
5760 lbrack: TerminalLBrackGreen,
5761 exprs: ExprListGreen,
5762 size: OptionFixedSizeArraySizeGreen,
5763 rbrack: TerminalRBrackGreen,
5764 ) -> ExprFixedSizeArrayGreen {
5765 let children: Vec<GreenId> = vec![lbrack.0, exprs.0, size.0, rbrack.0];
5766 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5767 ExprFixedSizeArrayGreen(
5768 Arc::new(GreenNode {
5769 kind: SyntaxKind::ExprFixedSizeArray,
5770 details: GreenNodeDetails::Node { children, width },
5771 })
5772 .intern(db),
5773 )
5774 }
5775}
5776impl ExprFixedSizeArray {
5777 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
5778 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
5779 }
5780 pub fn exprs(&self, db: &dyn SyntaxGroup) -> ExprList {
5781 ExprList::from_syntax_node(db, self.children[1].clone())
5782 }
5783 pub fn size(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySize {
5784 OptionFixedSizeArraySize::from_syntax_node(db, self.children[2].clone())
5785 }
5786 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
5787 TerminalRBrack::from_syntax_node(db, self.children[3].clone())
5788 }
5789}
5790#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5791pub struct ExprFixedSizeArrayPtr(pub SyntaxStablePtrId);
5792impl ExprFixedSizeArrayPtr {}
5793impl TypedStablePtr for ExprFixedSizeArrayPtr {
5794 type SyntaxNode = ExprFixedSizeArray;
5795 fn untyped(&self) -> SyntaxStablePtrId {
5796 self.0
5797 }
5798 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFixedSizeArray {
5799 ExprFixedSizeArray::from_syntax_node(db, self.0.lookup(db))
5800 }
5801}
5802impl From<ExprFixedSizeArrayPtr> for SyntaxStablePtrId {
5803 fn from(ptr: ExprFixedSizeArrayPtr) -> Self {
5804 ptr.untyped()
5805 }
5806}
5807#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5808pub struct ExprFixedSizeArrayGreen(pub GreenId);
5809impl TypedSyntaxNode for ExprFixedSizeArray {
5810 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFixedSizeArray);
5811 type StablePtr = ExprFixedSizeArrayPtr;
5812 type Green = ExprFixedSizeArrayGreen;
5813 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5814 ExprFixedSizeArrayGreen(
5815 Arc::new(GreenNode {
5816 kind: SyntaxKind::ExprFixedSizeArray,
5817 details: GreenNodeDetails::Node {
5818 children: vec![
5819 TerminalLBrack::missing(db).0,
5820 ExprList::missing(db).0,
5821 OptionFixedSizeArraySize::missing(db).0,
5822 TerminalRBrack::missing(db).0,
5823 ],
5824 width: TextWidth::default(),
5825 },
5826 })
5827 .intern(db),
5828 )
5829 }
5830 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5831 let kind = node.kind(db);
5832 assert_eq!(
5833 kind,
5834 SyntaxKind::ExprFixedSizeArray,
5835 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5836 kind,
5837 SyntaxKind::ExprFixedSizeArray
5838 );
5839 let children = db.get_children(node.clone());
5840 Self { node, children }
5841 }
5842 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5843 let kind = node.kind(db);
5844 if kind == SyntaxKind::ExprFixedSizeArray {
5845 Some(Self::from_syntax_node(db, node))
5846 } else {
5847 None
5848 }
5849 }
5850 fn as_syntax_node(&self) -> SyntaxNode {
5851 self.node.clone()
5852 }
5853 fn stable_ptr(&self) -> Self::StablePtr {
5854 ExprFixedSizeArrayPtr(self.node.0.stable_ptr)
5855 }
5856}
5857impl From<&ExprFixedSizeArray> for SyntaxStablePtrId {
5858 fn from(node: &ExprFixedSizeArray) -> Self {
5859 node.stable_ptr().untyped()
5860 }
5861}
5862#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5863pub struct FixedSizeArraySize {
5864 node: SyntaxNode,
5865 children: Arc<[SyntaxNode]>,
5866}
5867impl FixedSizeArraySize {
5868 pub const INDEX_SEMICOLON: usize = 0;
5869 pub const INDEX_SIZE: usize = 1;
5870 pub fn new_green(
5871 db: &dyn SyntaxGroup,
5872 semicolon: TerminalSemicolonGreen,
5873 size: ExprGreen,
5874 ) -> FixedSizeArraySizeGreen {
5875 let children: Vec<GreenId> = vec![semicolon.0, size.0];
5876 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5877 FixedSizeArraySizeGreen(
5878 Arc::new(GreenNode {
5879 kind: SyntaxKind::FixedSizeArraySize,
5880 details: GreenNodeDetails::Node { children, width },
5881 })
5882 .intern(db),
5883 )
5884 }
5885}
5886impl FixedSizeArraySize {
5887 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
5888 TerminalSemicolon::from_syntax_node(db, self.children[0].clone())
5889 }
5890 pub fn size(&self, db: &dyn SyntaxGroup) -> Expr {
5891 Expr::from_syntax_node(db, self.children[1].clone())
5892 }
5893}
5894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5895pub struct FixedSizeArraySizePtr(pub SyntaxStablePtrId);
5896impl FixedSizeArraySizePtr {}
5897impl TypedStablePtr for FixedSizeArraySizePtr {
5898 type SyntaxNode = FixedSizeArraySize;
5899 fn untyped(&self) -> SyntaxStablePtrId {
5900 self.0
5901 }
5902 fn lookup(&self, db: &dyn SyntaxGroup) -> FixedSizeArraySize {
5903 FixedSizeArraySize::from_syntax_node(db, self.0.lookup(db))
5904 }
5905}
5906impl From<FixedSizeArraySizePtr> for SyntaxStablePtrId {
5907 fn from(ptr: FixedSizeArraySizePtr) -> Self {
5908 ptr.untyped()
5909 }
5910}
5911#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5912pub struct FixedSizeArraySizeGreen(pub GreenId);
5913impl TypedSyntaxNode for FixedSizeArraySize {
5914 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FixedSizeArraySize);
5915 type StablePtr = FixedSizeArraySizePtr;
5916 type Green = FixedSizeArraySizeGreen;
5917 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5918 FixedSizeArraySizeGreen(
5919 Arc::new(GreenNode {
5920 kind: SyntaxKind::FixedSizeArraySize,
5921 details: GreenNodeDetails::Node {
5922 children: vec![TerminalSemicolon::missing(db).0, Expr::missing(db).0],
5923 width: TextWidth::default(),
5924 },
5925 })
5926 .intern(db),
5927 )
5928 }
5929 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5930 let kind = node.kind(db);
5931 assert_eq!(
5932 kind,
5933 SyntaxKind::FixedSizeArraySize,
5934 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5935 kind,
5936 SyntaxKind::FixedSizeArraySize
5937 );
5938 let children = db.get_children(node.clone());
5939 Self { node, children }
5940 }
5941 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
5942 let kind = node.kind(db);
5943 if kind == SyntaxKind::FixedSizeArraySize {
5944 Some(Self::from_syntax_node(db, node))
5945 } else {
5946 None
5947 }
5948 }
5949 fn as_syntax_node(&self) -> SyntaxNode {
5950 self.node.clone()
5951 }
5952 fn stable_ptr(&self) -> Self::StablePtr {
5953 FixedSizeArraySizePtr(self.node.0.stable_ptr)
5954 }
5955}
5956impl From<&FixedSizeArraySize> for SyntaxStablePtrId {
5957 fn from(node: &FixedSizeArraySize) -> Self {
5958 node.stable_ptr().untyped()
5959 }
5960}
5961#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5962pub enum OptionFixedSizeArraySize {
5963 Empty(OptionFixedSizeArraySizeEmpty),
5964 FixedSizeArraySize(FixedSizeArraySize),
5965}
5966#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5967pub struct OptionFixedSizeArraySizePtr(pub SyntaxStablePtrId);
5968impl TypedStablePtr for OptionFixedSizeArraySizePtr {
5969 type SyntaxNode = OptionFixedSizeArraySize;
5970 fn untyped(&self) -> SyntaxStablePtrId {
5971 self.0
5972 }
5973 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySize {
5974 OptionFixedSizeArraySize::from_syntax_node(db, self.0.lookup(db))
5975 }
5976}
5977impl From<OptionFixedSizeArraySizePtr> for SyntaxStablePtrId {
5978 fn from(ptr: OptionFixedSizeArraySizePtr) -> Self {
5979 ptr.untyped()
5980 }
5981}
5982impl From<OptionFixedSizeArraySizeEmptyPtr> for OptionFixedSizeArraySizePtr {
5983 fn from(value: OptionFixedSizeArraySizeEmptyPtr) -> Self {
5984 Self(value.0)
5985 }
5986}
5987impl From<FixedSizeArraySizePtr> for OptionFixedSizeArraySizePtr {
5988 fn from(value: FixedSizeArraySizePtr) -> Self {
5989 Self(value.0)
5990 }
5991}
5992impl From<OptionFixedSizeArraySizeEmptyGreen> for OptionFixedSizeArraySizeGreen {
5993 fn from(value: OptionFixedSizeArraySizeEmptyGreen) -> Self {
5994 Self(value.0)
5995 }
5996}
5997impl From<FixedSizeArraySizeGreen> for OptionFixedSizeArraySizeGreen {
5998 fn from(value: FixedSizeArraySizeGreen) -> Self {
5999 Self(value.0)
6000 }
6001}
6002#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6003pub struct OptionFixedSizeArraySizeGreen(pub GreenId);
6004impl TypedSyntaxNode for OptionFixedSizeArraySize {
6005 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6006 type StablePtr = OptionFixedSizeArraySizePtr;
6007 type Green = OptionFixedSizeArraySizeGreen;
6008 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6009 panic!("No missing variant.");
6010 }
6011 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6012 let kind = node.kind(db);
6013 match kind {
6014 SyntaxKind::OptionFixedSizeArraySizeEmpty => OptionFixedSizeArraySize::Empty(
6015 OptionFixedSizeArraySizeEmpty::from_syntax_node(db, node),
6016 ),
6017 SyntaxKind::FixedSizeArraySize => OptionFixedSizeArraySize::FixedSizeArraySize(
6018 FixedSizeArraySize::from_syntax_node(db, node),
6019 ),
6020 _ => panic!(
6021 "Unexpected syntax kind {:?} when constructing {}.",
6022 kind, "OptionFixedSizeArraySize"
6023 ),
6024 }
6025 }
6026 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6027 let kind = node.kind(db);
6028 match kind {
6029 SyntaxKind::OptionFixedSizeArraySizeEmpty => Some(OptionFixedSizeArraySize::Empty(
6030 OptionFixedSizeArraySizeEmpty::from_syntax_node(db, node),
6031 )),
6032 SyntaxKind::FixedSizeArraySize => Some(OptionFixedSizeArraySize::FixedSizeArraySize(
6033 FixedSizeArraySize::from_syntax_node(db, node),
6034 )),
6035 _ => None,
6036 }
6037 }
6038 fn as_syntax_node(&self) -> SyntaxNode {
6039 match self {
6040 OptionFixedSizeArraySize::Empty(x) => x.as_syntax_node(),
6041 OptionFixedSizeArraySize::FixedSizeArraySize(x) => x.as_syntax_node(),
6042 }
6043 }
6044 fn stable_ptr(&self) -> Self::StablePtr {
6045 OptionFixedSizeArraySizePtr(self.as_syntax_node().0.stable_ptr)
6046 }
6047}
6048impl From<&OptionFixedSizeArraySize> for SyntaxStablePtrId {
6049 fn from(node: &OptionFixedSizeArraySize) -> Self {
6050 node.stable_ptr().untyped()
6051 }
6052}
6053impl OptionFixedSizeArraySize {
6054 pub fn is_variant(kind: SyntaxKind) -> bool {
6056 matches!(kind, SyntaxKind::OptionFixedSizeArraySizeEmpty | SyntaxKind::FixedSizeArraySize)
6057 }
6058}
6059#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6060pub struct OptionFixedSizeArraySizeEmpty {
6061 node: SyntaxNode,
6062 children: Arc<[SyntaxNode]>,
6063}
6064impl OptionFixedSizeArraySizeEmpty {
6065 pub fn new_green(db: &dyn SyntaxGroup) -> OptionFixedSizeArraySizeEmptyGreen {
6066 let children: Vec<GreenId> = vec![];
6067 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6068 OptionFixedSizeArraySizeEmptyGreen(
6069 Arc::new(GreenNode {
6070 kind: SyntaxKind::OptionFixedSizeArraySizeEmpty,
6071 details: GreenNodeDetails::Node { children, width },
6072 })
6073 .intern(db),
6074 )
6075 }
6076}
6077impl OptionFixedSizeArraySizeEmpty {}
6078#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6079pub struct OptionFixedSizeArraySizeEmptyPtr(pub SyntaxStablePtrId);
6080impl OptionFixedSizeArraySizeEmptyPtr {}
6081impl TypedStablePtr for OptionFixedSizeArraySizeEmptyPtr {
6082 type SyntaxNode = OptionFixedSizeArraySizeEmpty;
6083 fn untyped(&self) -> SyntaxStablePtrId {
6084 self.0
6085 }
6086 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySizeEmpty {
6087 OptionFixedSizeArraySizeEmpty::from_syntax_node(db, self.0.lookup(db))
6088 }
6089}
6090impl From<OptionFixedSizeArraySizeEmptyPtr> for SyntaxStablePtrId {
6091 fn from(ptr: OptionFixedSizeArraySizeEmptyPtr) -> Self {
6092 ptr.untyped()
6093 }
6094}
6095#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6096pub struct OptionFixedSizeArraySizeEmptyGreen(pub GreenId);
6097impl TypedSyntaxNode for OptionFixedSizeArraySizeEmpty {
6098 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionFixedSizeArraySizeEmpty);
6099 type StablePtr = OptionFixedSizeArraySizeEmptyPtr;
6100 type Green = OptionFixedSizeArraySizeEmptyGreen;
6101 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6102 OptionFixedSizeArraySizeEmptyGreen(
6103 Arc::new(GreenNode {
6104 kind: SyntaxKind::OptionFixedSizeArraySizeEmpty,
6105 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
6106 })
6107 .intern(db),
6108 )
6109 }
6110 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6111 let kind = node.kind(db);
6112 assert_eq!(
6113 kind,
6114 SyntaxKind::OptionFixedSizeArraySizeEmpty,
6115 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6116 kind,
6117 SyntaxKind::OptionFixedSizeArraySizeEmpty
6118 );
6119 let children = db.get_children(node.clone());
6120 Self { node, children }
6121 }
6122 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6123 let kind = node.kind(db);
6124 if kind == SyntaxKind::OptionFixedSizeArraySizeEmpty {
6125 Some(Self::from_syntax_node(db, node))
6126 } else {
6127 None
6128 }
6129 }
6130 fn as_syntax_node(&self) -> SyntaxNode {
6131 self.node.clone()
6132 }
6133 fn stable_ptr(&self) -> Self::StablePtr {
6134 OptionFixedSizeArraySizeEmptyPtr(self.node.0.stable_ptr)
6135 }
6136}
6137impl From<&OptionFixedSizeArraySizeEmpty> for SyntaxStablePtrId {
6138 fn from(node: &OptionFixedSizeArraySizeEmpty) -> Self {
6139 node.stable_ptr().untyped()
6140 }
6141}
6142#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6143pub struct ExprClosure {
6144 node: SyntaxNode,
6145 children: Arc<[SyntaxNode]>,
6146}
6147impl ExprClosure {
6148 pub const INDEX_WRAPPER: usize = 0;
6149 pub const INDEX_RET_TY: usize = 1;
6150 pub const INDEX_OPTIONAL_NO_PANIC: usize = 2;
6151 pub const INDEX_EXPR: usize = 3;
6152 pub fn new_green(
6153 db: &dyn SyntaxGroup,
6154 wrapper: ClosureParamWrapperGreen,
6155 ret_ty: OptionReturnTypeClauseGreen,
6156 optional_no_panic: OptionTerminalNoPanicGreen,
6157 expr: ExprGreen,
6158 ) -> ExprClosureGreen {
6159 let children: Vec<GreenId> = vec![wrapper.0, ret_ty.0, optional_no_panic.0, expr.0];
6160 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6161 ExprClosureGreen(
6162 Arc::new(GreenNode {
6163 kind: SyntaxKind::ExprClosure,
6164 details: GreenNodeDetails::Node { children, width },
6165 })
6166 .intern(db),
6167 )
6168 }
6169}
6170impl ExprClosure {
6171 pub fn wrapper(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapper {
6172 ClosureParamWrapper::from_syntax_node(db, self.children[0].clone())
6173 }
6174 pub fn ret_ty(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
6175 OptionReturnTypeClause::from_syntax_node(db, self.children[1].clone())
6176 }
6177 pub fn optional_no_panic(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
6178 OptionTerminalNoPanic::from_syntax_node(db, self.children[2].clone())
6179 }
6180 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
6181 Expr::from_syntax_node(db, self.children[3].clone())
6182 }
6183}
6184#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6185pub struct ExprClosurePtr(pub SyntaxStablePtrId);
6186impl ExprClosurePtr {}
6187impl TypedStablePtr for ExprClosurePtr {
6188 type SyntaxNode = ExprClosure;
6189 fn untyped(&self) -> SyntaxStablePtrId {
6190 self.0
6191 }
6192 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprClosure {
6193 ExprClosure::from_syntax_node(db, self.0.lookup(db))
6194 }
6195}
6196impl From<ExprClosurePtr> for SyntaxStablePtrId {
6197 fn from(ptr: ExprClosurePtr) -> Self {
6198 ptr.untyped()
6199 }
6200}
6201#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6202pub struct ExprClosureGreen(pub GreenId);
6203impl TypedSyntaxNode for ExprClosure {
6204 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprClosure);
6205 type StablePtr = ExprClosurePtr;
6206 type Green = ExprClosureGreen;
6207 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6208 ExprClosureGreen(
6209 Arc::new(GreenNode {
6210 kind: SyntaxKind::ExprClosure,
6211 details: GreenNodeDetails::Node {
6212 children: vec![
6213 ClosureParamWrapper::missing(db).0,
6214 OptionReturnTypeClause::missing(db).0,
6215 OptionTerminalNoPanic::missing(db).0,
6216 Expr::missing(db).0,
6217 ],
6218 width: TextWidth::default(),
6219 },
6220 })
6221 .intern(db),
6222 )
6223 }
6224 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6225 let kind = node.kind(db);
6226 assert_eq!(
6227 kind,
6228 SyntaxKind::ExprClosure,
6229 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6230 kind,
6231 SyntaxKind::ExprClosure
6232 );
6233 let children = db.get_children(node.clone());
6234 Self { node, children }
6235 }
6236 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6237 let kind = node.kind(db);
6238 if kind == SyntaxKind::ExprClosure { Some(Self::from_syntax_node(db, node)) } else { None }
6239 }
6240 fn as_syntax_node(&self) -> SyntaxNode {
6241 self.node.clone()
6242 }
6243 fn stable_ptr(&self) -> Self::StablePtr {
6244 ExprClosurePtr(self.node.0.stable_ptr)
6245 }
6246}
6247impl From<&ExprClosure> for SyntaxStablePtrId {
6248 fn from(node: &ExprClosure) -> Self {
6249 node.stable_ptr().untyped()
6250 }
6251}
6252#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6253pub enum ClosureParamWrapper {
6254 Nullary(TerminalOrOr),
6255 NAry(ClosureParamWrapperNAry),
6256}
6257#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6258pub struct ClosureParamWrapperPtr(pub SyntaxStablePtrId);
6259impl TypedStablePtr for ClosureParamWrapperPtr {
6260 type SyntaxNode = ClosureParamWrapper;
6261 fn untyped(&self) -> SyntaxStablePtrId {
6262 self.0
6263 }
6264 fn lookup(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapper {
6265 ClosureParamWrapper::from_syntax_node(db, self.0.lookup(db))
6266 }
6267}
6268impl From<ClosureParamWrapperPtr> for SyntaxStablePtrId {
6269 fn from(ptr: ClosureParamWrapperPtr) -> Self {
6270 ptr.untyped()
6271 }
6272}
6273impl From<TerminalOrOrPtr> for ClosureParamWrapperPtr {
6274 fn from(value: TerminalOrOrPtr) -> Self {
6275 Self(value.0)
6276 }
6277}
6278impl From<ClosureParamWrapperNAryPtr> for ClosureParamWrapperPtr {
6279 fn from(value: ClosureParamWrapperNAryPtr) -> Self {
6280 Self(value.0)
6281 }
6282}
6283impl From<TerminalOrOrGreen> for ClosureParamWrapperGreen {
6284 fn from(value: TerminalOrOrGreen) -> Self {
6285 Self(value.0)
6286 }
6287}
6288impl From<ClosureParamWrapperNAryGreen> for ClosureParamWrapperGreen {
6289 fn from(value: ClosureParamWrapperNAryGreen) -> Self {
6290 Self(value.0)
6291 }
6292}
6293#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6294pub struct ClosureParamWrapperGreen(pub GreenId);
6295impl TypedSyntaxNode for ClosureParamWrapper {
6296 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6297 type StablePtr = ClosureParamWrapperPtr;
6298 type Green = ClosureParamWrapperGreen;
6299 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6300 panic!("No missing variant.");
6301 }
6302 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6303 let kind = node.kind(db);
6304 match kind {
6305 SyntaxKind::TerminalOrOr => {
6306 ClosureParamWrapper::Nullary(TerminalOrOr::from_syntax_node(db, node))
6307 }
6308 SyntaxKind::ClosureParamWrapperNAry => {
6309 ClosureParamWrapper::NAry(ClosureParamWrapperNAry::from_syntax_node(db, node))
6310 }
6311 _ => panic!(
6312 "Unexpected syntax kind {:?} when constructing {}.",
6313 kind, "ClosureParamWrapper"
6314 ),
6315 }
6316 }
6317 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6318 let kind = node.kind(db);
6319 match kind {
6320 SyntaxKind::TerminalOrOr => {
6321 Some(ClosureParamWrapper::Nullary(TerminalOrOr::from_syntax_node(db, node)))
6322 }
6323 SyntaxKind::ClosureParamWrapperNAry => {
6324 Some(ClosureParamWrapper::NAry(ClosureParamWrapperNAry::from_syntax_node(db, node)))
6325 }
6326 _ => None,
6327 }
6328 }
6329 fn as_syntax_node(&self) -> SyntaxNode {
6330 match self {
6331 ClosureParamWrapper::Nullary(x) => x.as_syntax_node(),
6332 ClosureParamWrapper::NAry(x) => x.as_syntax_node(),
6333 }
6334 }
6335 fn stable_ptr(&self) -> Self::StablePtr {
6336 ClosureParamWrapperPtr(self.as_syntax_node().0.stable_ptr)
6337 }
6338}
6339impl From<&ClosureParamWrapper> for SyntaxStablePtrId {
6340 fn from(node: &ClosureParamWrapper) -> Self {
6341 node.stable_ptr().untyped()
6342 }
6343}
6344impl ClosureParamWrapper {
6345 pub fn is_variant(kind: SyntaxKind) -> bool {
6347 matches!(kind, SyntaxKind::TerminalOrOr | SyntaxKind::ClosureParamWrapperNAry)
6348 }
6349}
6350#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6351pub struct ClosureParamWrapperNAry {
6352 node: SyntaxNode,
6353 children: Arc<[SyntaxNode]>,
6354}
6355impl ClosureParamWrapperNAry {
6356 pub const INDEX_LEFTOR: usize = 0;
6357 pub const INDEX_PARAMS: usize = 1;
6358 pub const INDEX_RIGHTOR: usize = 2;
6359 pub fn new_green(
6360 db: &dyn SyntaxGroup,
6361 leftor: TerminalOrGreen,
6362 params: ParamListGreen,
6363 rightor: TerminalOrGreen,
6364 ) -> ClosureParamWrapperNAryGreen {
6365 let children: Vec<GreenId> = vec![leftor.0, params.0, rightor.0];
6366 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6367 ClosureParamWrapperNAryGreen(
6368 Arc::new(GreenNode {
6369 kind: SyntaxKind::ClosureParamWrapperNAry,
6370 details: GreenNodeDetails::Node { children, width },
6371 })
6372 .intern(db),
6373 )
6374 }
6375}
6376impl ClosureParamWrapperNAry {
6377 pub fn leftor(&self, db: &dyn SyntaxGroup) -> TerminalOr {
6378 TerminalOr::from_syntax_node(db, self.children[0].clone())
6379 }
6380 pub fn params(&self, db: &dyn SyntaxGroup) -> ParamList {
6381 ParamList::from_syntax_node(db, self.children[1].clone())
6382 }
6383 pub fn rightor(&self, db: &dyn SyntaxGroup) -> TerminalOr {
6384 TerminalOr::from_syntax_node(db, self.children[2].clone())
6385 }
6386}
6387#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6388pub struct ClosureParamWrapperNAryPtr(pub SyntaxStablePtrId);
6389impl ClosureParamWrapperNAryPtr {}
6390impl TypedStablePtr for ClosureParamWrapperNAryPtr {
6391 type SyntaxNode = ClosureParamWrapperNAry;
6392 fn untyped(&self) -> SyntaxStablePtrId {
6393 self.0
6394 }
6395 fn lookup(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapperNAry {
6396 ClosureParamWrapperNAry::from_syntax_node(db, self.0.lookup(db))
6397 }
6398}
6399impl From<ClosureParamWrapperNAryPtr> for SyntaxStablePtrId {
6400 fn from(ptr: ClosureParamWrapperNAryPtr) -> Self {
6401 ptr.untyped()
6402 }
6403}
6404#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6405pub struct ClosureParamWrapperNAryGreen(pub GreenId);
6406impl TypedSyntaxNode for ClosureParamWrapperNAry {
6407 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ClosureParamWrapperNAry);
6408 type StablePtr = ClosureParamWrapperNAryPtr;
6409 type Green = ClosureParamWrapperNAryGreen;
6410 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6411 ClosureParamWrapperNAryGreen(
6412 Arc::new(GreenNode {
6413 kind: SyntaxKind::ClosureParamWrapperNAry,
6414 details: GreenNodeDetails::Node {
6415 children: vec![
6416 TerminalOr::missing(db).0,
6417 ParamList::missing(db).0,
6418 TerminalOr::missing(db).0,
6419 ],
6420 width: TextWidth::default(),
6421 },
6422 })
6423 .intern(db),
6424 )
6425 }
6426 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6427 let kind = node.kind(db);
6428 assert_eq!(
6429 kind,
6430 SyntaxKind::ClosureParamWrapperNAry,
6431 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6432 kind,
6433 SyntaxKind::ClosureParamWrapperNAry
6434 );
6435 let children = db.get_children(node.clone());
6436 Self { node, children }
6437 }
6438 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6439 let kind = node.kind(db);
6440 if kind == SyntaxKind::ClosureParamWrapperNAry {
6441 Some(Self::from_syntax_node(db, node))
6442 } else {
6443 None
6444 }
6445 }
6446 fn as_syntax_node(&self) -> SyntaxNode {
6447 self.node.clone()
6448 }
6449 fn stable_ptr(&self) -> Self::StablePtr {
6450 ClosureParamWrapperNAryPtr(self.node.0.stable_ptr)
6451 }
6452}
6453impl From<&ClosureParamWrapperNAry> for SyntaxStablePtrId {
6454 fn from(node: &ClosureParamWrapperNAry) -> Self {
6455 node.stable_ptr().untyped()
6456 }
6457}
6458#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6459pub struct StructArgExpr {
6460 node: SyntaxNode,
6461 children: Arc<[SyntaxNode]>,
6462}
6463impl StructArgExpr {
6464 pub const INDEX_COLON: usize = 0;
6465 pub const INDEX_EXPR: usize = 1;
6466 pub fn new_green(
6467 db: &dyn SyntaxGroup,
6468 colon: TerminalColonGreen,
6469 expr: ExprGreen,
6470 ) -> StructArgExprGreen {
6471 let children: Vec<GreenId> = vec![colon.0, expr.0];
6472 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6473 StructArgExprGreen(
6474 Arc::new(GreenNode {
6475 kind: SyntaxKind::StructArgExpr,
6476 details: GreenNodeDetails::Node { children, width },
6477 })
6478 .intern(db),
6479 )
6480 }
6481}
6482impl StructArgExpr {
6483 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
6484 TerminalColon::from_syntax_node(db, self.children[0].clone())
6485 }
6486 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
6487 Expr::from_syntax_node(db, self.children[1].clone())
6488 }
6489}
6490#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6491pub struct StructArgExprPtr(pub SyntaxStablePtrId);
6492impl StructArgExprPtr {}
6493impl TypedStablePtr for StructArgExprPtr {
6494 type SyntaxNode = StructArgExpr;
6495 fn untyped(&self) -> SyntaxStablePtrId {
6496 self.0
6497 }
6498 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgExpr {
6499 StructArgExpr::from_syntax_node(db, self.0.lookup(db))
6500 }
6501}
6502impl From<StructArgExprPtr> for SyntaxStablePtrId {
6503 fn from(ptr: StructArgExprPtr) -> Self {
6504 ptr.untyped()
6505 }
6506}
6507#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6508pub struct StructArgExprGreen(pub GreenId);
6509impl TypedSyntaxNode for StructArgExpr {
6510 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgExpr);
6511 type StablePtr = StructArgExprPtr;
6512 type Green = StructArgExprGreen;
6513 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6514 StructArgExprGreen(
6515 Arc::new(GreenNode {
6516 kind: SyntaxKind::StructArgExpr,
6517 details: GreenNodeDetails::Node {
6518 children: vec![TerminalColon::missing(db).0, Expr::missing(db).0],
6519 width: TextWidth::default(),
6520 },
6521 })
6522 .intern(db),
6523 )
6524 }
6525 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6526 let kind = node.kind(db);
6527 assert_eq!(
6528 kind,
6529 SyntaxKind::StructArgExpr,
6530 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6531 kind,
6532 SyntaxKind::StructArgExpr
6533 );
6534 let children = db.get_children(node.clone());
6535 Self { node, children }
6536 }
6537 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6538 let kind = node.kind(db);
6539 if kind == SyntaxKind::StructArgExpr {
6540 Some(Self::from_syntax_node(db, node))
6541 } else {
6542 None
6543 }
6544 }
6545 fn as_syntax_node(&self) -> SyntaxNode {
6546 self.node.clone()
6547 }
6548 fn stable_ptr(&self) -> Self::StablePtr {
6549 StructArgExprPtr(self.node.0.stable_ptr)
6550 }
6551}
6552impl From<&StructArgExpr> for SyntaxStablePtrId {
6553 fn from(node: &StructArgExpr) -> Self {
6554 node.stable_ptr().untyped()
6555 }
6556}
6557#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6558pub enum OptionStructArgExpr {
6559 Empty(OptionStructArgExprEmpty),
6560 StructArgExpr(StructArgExpr),
6561}
6562#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6563pub struct OptionStructArgExprPtr(pub SyntaxStablePtrId);
6564impl TypedStablePtr for OptionStructArgExprPtr {
6565 type SyntaxNode = OptionStructArgExpr;
6566 fn untyped(&self) -> SyntaxStablePtrId {
6567 self.0
6568 }
6569 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionStructArgExpr {
6570 OptionStructArgExpr::from_syntax_node(db, self.0.lookup(db))
6571 }
6572}
6573impl From<OptionStructArgExprPtr> for SyntaxStablePtrId {
6574 fn from(ptr: OptionStructArgExprPtr) -> Self {
6575 ptr.untyped()
6576 }
6577}
6578impl From<OptionStructArgExprEmptyPtr> for OptionStructArgExprPtr {
6579 fn from(value: OptionStructArgExprEmptyPtr) -> Self {
6580 Self(value.0)
6581 }
6582}
6583impl From<StructArgExprPtr> for OptionStructArgExprPtr {
6584 fn from(value: StructArgExprPtr) -> Self {
6585 Self(value.0)
6586 }
6587}
6588impl From<OptionStructArgExprEmptyGreen> for OptionStructArgExprGreen {
6589 fn from(value: OptionStructArgExprEmptyGreen) -> Self {
6590 Self(value.0)
6591 }
6592}
6593impl From<StructArgExprGreen> for OptionStructArgExprGreen {
6594 fn from(value: StructArgExprGreen) -> Self {
6595 Self(value.0)
6596 }
6597}
6598#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6599pub struct OptionStructArgExprGreen(pub GreenId);
6600impl TypedSyntaxNode for OptionStructArgExpr {
6601 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6602 type StablePtr = OptionStructArgExprPtr;
6603 type Green = OptionStructArgExprGreen;
6604 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6605 panic!("No missing variant.");
6606 }
6607 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6608 let kind = node.kind(db);
6609 match kind {
6610 SyntaxKind::OptionStructArgExprEmpty => {
6611 OptionStructArgExpr::Empty(OptionStructArgExprEmpty::from_syntax_node(db, node))
6612 }
6613 SyntaxKind::StructArgExpr => {
6614 OptionStructArgExpr::StructArgExpr(StructArgExpr::from_syntax_node(db, node))
6615 }
6616 _ => panic!(
6617 "Unexpected syntax kind {:?} when constructing {}.",
6618 kind, "OptionStructArgExpr"
6619 ),
6620 }
6621 }
6622 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6623 let kind = node.kind(db);
6624 match kind {
6625 SyntaxKind::OptionStructArgExprEmpty => Some(OptionStructArgExpr::Empty(
6626 OptionStructArgExprEmpty::from_syntax_node(db, node),
6627 )),
6628 SyntaxKind::StructArgExpr => {
6629 Some(OptionStructArgExpr::StructArgExpr(StructArgExpr::from_syntax_node(db, node)))
6630 }
6631 _ => None,
6632 }
6633 }
6634 fn as_syntax_node(&self) -> SyntaxNode {
6635 match self {
6636 OptionStructArgExpr::Empty(x) => x.as_syntax_node(),
6637 OptionStructArgExpr::StructArgExpr(x) => x.as_syntax_node(),
6638 }
6639 }
6640 fn stable_ptr(&self) -> Self::StablePtr {
6641 OptionStructArgExprPtr(self.as_syntax_node().0.stable_ptr)
6642 }
6643}
6644impl From<&OptionStructArgExpr> for SyntaxStablePtrId {
6645 fn from(node: &OptionStructArgExpr) -> Self {
6646 node.stable_ptr().untyped()
6647 }
6648}
6649impl OptionStructArgExpr {
6650 pub fn is_variant(kind: SyntaxKind) -> bool {
6652 matches!(kind, SyntaxKind::OptionStructArgExprEmpty | SyntaxKind::StructArgExpr)
6653 }
6654}
6655#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6656pub struct OptionStructArgExprEmpty {
6657 node: SyntaxNode,
6658 children: Arc<[SyntaxNode]>,
6659}
6660impl OptionStructArgExprEmpty {
6661 pub fn new_green(db: &dyn SyntaxGroup) -> OptionStructArgExprEmptyGreen {
6662 let children: Vec<GreenId> = vec![];
6663 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6664 OptionStructArgExprEmptyGreen(
6665 Arc::new(GreenNode {
6666 kind: SyntaxKind::OptionStructArgExprEmpty,
6667 details: GreenNodeDetails::Node { children, width },
6668 })
6669 .intern(db),
6670 )
6671 }
6672}
6673impl OptionStructArgExprEmpty {}
6674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6675pub struct OptionStructArgExprEmptyPtr(pub SyntaxStablePtrId);
6676impl OptionStructArgExprEmptyPtr {}
6677impl TypedStablePtr for OptionStructArgExprEmptyPtr {
6678 type SyntaxNode = OptionStructArgExprEmpty;
6679 fn untyped(&self) -> SyntaxStablePtrId {
6680 self.0
6681 }
6682 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionStructArgExprEmpty {
6683 OptionStructArgExprEmpty::from_syntax_node(db, self.0.lookup(db))
6684 }
6685}
6686impl From<OptionStructArgExprEmptyPtr> for SyntaxStablePtrId {
6687 fn from(ptr: OptionStructArgExprEmptyPtr) -> Self {
6688 ptr.untyped()
6689 }
6690}
6691#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6692pub struct OptionStructArgExprEmptyGreen(pub GreenId);
6693impl TypedSyntaxNode for OptionStructArgExprEmpty {
6694 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionStructArgExprEmpty);
6695 type StablePtr = OptionStructArgExprEmptyPtr;
6696 type Green = OptionStructArgExprEmptyGreen;
6697 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6698 OptionStructArgExprEmptyGreen(
6699 Arc::new(GreenNode {
6700 kind: SyntaxKind::OptionStructArgExprEmpty,
6701 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
6702 })
6703 .intern(db),
6704 )
6705 }
6706 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6707 let kind = node.kind(db);
6708 assert_eq!(
6709 kind,
6710 SyntaxKind::OptionStructArgExprEmpty,
6711 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6712 kind,
6713 SyntaxKind::OptionStructArgExprEmpty
6714 );
6715 let children = db.get_children(node.clone());
6716 Self { node, children }
6717 }
6718 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6719 let kind = node.kind(db);
6720 if kind == SyntaxKind::OptionStructArgExprEmpty {
6721 Some(Self::from_syntax_node(db, node))
6722 } else {
6723 None
6724 }
6725 }
6726 fn as_syntax_node(&self) -> SyntaxNode {
6727 self.node.clone()
6728 }
6729 fn stable_ptr(&self) -> Self::StablePtr {
6730 OptionStructArgExprEmptyPtr(self.node.0.stable_ptr)
6731 }
6732}
6733impl From<&OptionStructArgExprEmpty> for SyntaxStablePtrId {
6734 fn from(node: &OptionStructArgExprEmpty) -> Self {
6735 node.stable_ptr().untyped()
6736 }
6737}
6738#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6739pub struct StructArgSingle {
6740 node: SyntaxNode,
6741 children: Arc<[SyntaxNode]>,
6742}
6743impl StructArgSingle {
6744 pub const INDEX_IDENTIFIER: usize = 0;
6745 pub const INDEX_ARG_EXPR: usize = 1;
6746 pub fn new_green(
6747 db: &dyn SyntaxGroup,
6748 identifier: TerminalIdentifierGreen,
6749 arg_expr: OptionStructArgExprGreen,
6750 ) -> StructArgSingleGreen {
6751 let children: Vec<GreenId> = vec![identifier.0, arg_expr.0];
6752 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6753 StructArgSingleGreen(
6754 Arc::new(GreenNode {
6755 kind: SyntaxKind::StructArgSingle,
6756 details: GreenNodeDetails::Node { children, width },
6757 })
6758 .intern(db),
6759 )
6760 }
6761}
6762impl StructArgSingle {
6763 pub fn identifier(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
6764 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
6765 }
6766 pub fn arg_expr(&self, db: &dyn SyntaxGroup) -> OptionStructArgExpr {
6767 OptionStructArgExpr::from_syntax_node(db, self.children[1].clone())
6768 }
6769}
6770#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6771pub struct StructArgSinglePtr(pub SyntaxStablePtrId);
6772impl StructArgSinglePtr {
6773 pub fn identifier_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
6774 let ptr = self.0.lookup_intern(db);
6775 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
6776 TerminalIdentifierGreen(key_fields[0])
6777 } else {
6778 panic!("Unexpected key field query on root.");
6779 }
6780 }
6781}
6782impl TypedStablePtr for StructArgSinglePtr {
6783 type SyntaxNode = StructArgSingle;
6784 fn untyped(&self) -> SyntaxStablePtrId {
6785 self.0
6786 }
6787 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgSingle {
6788 StructArgSingle::from_syntax_node(db, self.0.lookup(db))
6789 }
6790}
6791impl From<StructArgSinglePtr> for SyntaxStablePtrId {
6792 fn from(ptr: StructArgSinglePtr) -> Self {
6793 ptr.untyped()
6794 }
6795}
6796#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6797pub struct StructArgSingleGreen(pub GreenId);
6798impl TypedSyntaxNode for StructArgSingle {
6799 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgSingle);
6800 type StablePtr = StructArgSinglePtr;
6801 type Green = StructArgSingleGreen;
6802 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6803 StructArgSingleGreen(
6804 Arc::new(GreenNode {
6805 kind: SyntaxKind::StructArgSingle,
6806 details: GreenNodeDetails::Node {
6807 children: vec![
6808 TerminalIdentifier::missing(db).0,
6809 OptionStructArgExpr::missing(db).0,
6810 ],
6811 width: TextWidth::default(),
6812 },
6813 })
6814 .intern(db),
6815 )
6816 }
6817 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6818 let kind = node.kind(db);
6819 assert_eq!(
6820 kind,
6821 SyntaxKind::StructArgSingle,
6822 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6823 kind,
6824 SyntaxKind::StructArgSingle
6825 );
6826 let children = db.get_children(node.clone());
6827 Self { node, children }
6828 }
6829 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6830 let kind = node.kind(db);
6831 if kind == SyntaxKind::StructArgSingle {
6832 Some(Self::from_syntax_node(db, node))
6833 } else {
6834 None
6835 }
6836 }
6837 fn as_syntax_node(&self) -> SyntaxNode {
6838 self.node.clone()
6839 }
6840 fn stable_ptr(&self) -> Self::StablePtr {
6841 StructArgSinglePtr(self.node.0.stable_ptr)
6842 }
6843}
6844impl From<&StructArgSingle> for SyntaxStablePtrId {
6845 fn from(node: &StructArgSingle) -> Self {
6846 node.stable_ptr().untyped()
6847 }
6848}
6849#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6850pub struct StructArgTail {
6851 node: SyntaxNode,
6852 children: Arc<[SyntaxNode]>,
6853}
6854impl StructArgTail {
6855 pub const INDEX_DOTDOT: usize = 0;
6856 pub const INDEX_EXPRESSION: usize = 1;
6857 pub fn new_green(
6858 db: &dyn SyntaxGroup,
6859 dotdot: TerminalDotDotGreen,
6860 expression: ExprGreen,
6861 ) -> StructArgTailGreen {
6862 let children: Vec<GreenId> = vec![dotdot.0, expression.0];
6863 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6864 StructArgTailGreen(
6865 Arc::new(GreenNode {
6866 kind: SyntaxKind::StructArgTail,
6867 details: GreenNodeDetails::Node { children, width },
6868 })
6869 .intern(db),
6870 )
6871 }
6872}
6873impl StructArgTail {
6874 pub fn dotdot(&self, db: &dyn SyntaxGroup) -> TerminalDotDot {
6875 TerminalDotDot::from_syntax_node(db, self.children[0].clone())
6876 }
6877 pub fn expression(&self, db: &dyn SyntaxGroup) -> Expr {
6878 Expr::from_syntax_node(db, self.children[1].clone())
6879 }
6880}
6881#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6882pub struct StructArgTailPtr(pub SyntaxStablePtrId);
6883impl StructArgTailPtr {}
6884impl TypedStablePtr for StructArgTailPtr {
6885 type SyntaxNode = StructArgTail;
6886 fn untyped(&self) -> SyntaxStablePtrId {
6887 self.0
6888 }
6889 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgTail {
6890 StructArgTail::from_syntax_node(db, self.0.lookup(db))
6891 }
6892}
6893impl From<StructArgTailPtr> for SyntaxStablePtrId {
6894 fn from(ptr: StructArgTailPtr) -> Self {
6895 ptr.untyped()
6896 }
6897}
6898#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6899pub struct StructArgTailGreen(pub GreenId);
6900impl TypedSyntaxNode for StructArgTail {
6901 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgTail);
6902 type StablePtr = StructArgTailPtr;
6903 type Green = StructArgTailGreen;
6904 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6905 StructArgTailGreen(
6906 Arc::new(GreenNode {
6907 kind: SyntaxKind::StructArgTail,
6908 details: GreenNodeDetails::Node {
6909 children: vec![TerminalDotDot::missing(db).0, Expr::missing(db).0],
6910 width: TextWidth::default(),
6911 },
6912 })
6913 .intern(db),
6914 )
6915 }
6916 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6917 let kind = node.kind(db);
6918 assert_eq!(
6919 kind,
6920 SyntaxKind::StructArgTail,
6921 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6922 kind,
6923 SyntaxKind::StructArgTail
6924 );
6925 let children = db.get_children(node.clone());
6926 Self { node, children }
6927 }
6928 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
6929 let kind = node.kind(db);
6930 if kind == SyntaxKind::StructArgTail {
6931 Some(Self::from_syntax_node(db, node))
6932 } else {
6933 None
6934 }
6935 }
6936 fn as_syntax_node(&self) -> SyntaxNode {
6937 self.node.clone()
6938 }
6939 fn stable_ptr(&self) -> Self::StablePtr {
6940 StructArgTailPtr(self.node.0.stable_ptr)
6941 }
6942}
6943impl From<&StructArgTail> for SyntaxStablePtrId {
6944 fn from(node: &StructArgTail) -> Self {
6945 node.stable_ptr().untyped()
6946 }
6947}
6948#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6949pub enum StructArg {
6950 StructArgSingle(StructArgSingle),
6951 StructArgTail(StructArgTail),
6952}
6953#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6954pub struct StructArgPtr(pub SyntaxStablePtrId);
6955impl TypedStablePtr for StructArgPtr {
6956 type SyntaxNode = StructArg;
6957 fn untyped(&self) -> SyntaxStablePtrId {
6958 self.0
6959 }
6960 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArg {
6961 StructArg::from_syntax_node(db, self.0.lookup(db))
6962 }
6963}
6964impl From<StructArgPtr> for SyntaxStablePtrId {
6965 fn from(ptr: StructArgPtr) -> Self {
6966 ptr.untyped()
6967 }
6968}
6969impl From<StructArgSinglePtr> for StructArgPtr {
6970 fn from(value: StructArgSinglePtr) -> Self {
6971 Self(value.0)
6972 }
6973}
6974impl From<StructArgTailPtr> for StructArgPtr {
6975 fn from(value: StructArgTailPtr) -> Self {
6976 Self(value.0)
6977 }
6978}
6979impl From<StructArgSingleGreen> for StructArgGreen {
6980 fn from(value: StructArgSingleGreen) -> Self {
6981 Self(value.0)
6982 }
6983}
6984impl From<StructArgTailGreen> for StructArgGreen {
6985 fn from(value: StructArgTailGreen) -> Self {
6986 Self(value.0)
6987 }
6988}
6989#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6990pub struct StructArgGreen(pub GreenId);
6991impl TypedSyntaxNode for StructArg {
6992 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6993 type StablePtr = StructArgPtr;
6994 type Green = StructArgGreen;
6995 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6996 panic!("No missing variant.");
6997 }
6998 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6999 let kind = node.kind(db);
7000 match kind {
7001 SyntaxKind::StructArgSingle => {
7002 StructArg::StructArgSingle(StructArgSingle::from_syntax_node(db, node))
7003 }
7004 SyntaxKind::StructArgTail => {
7005 StructArg::StructArgTail(StructArgTail::from_syntax_node(db, node))
7006 }
7007 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "StructArg"),
7008 }
7009 }
7010 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7011 let kind = node.kind(db);
7012 match kind {
7013 SyntaxKind::StructArgSingle => {
7014 Some(StructArg::StructArgSingle(StructArgSingle::from_syntax_node(db, node)))
7015 }
7016 SyntaxKind::StructArgTail => {
7017 Some(StructArg::StructArgTail(StructArgTail::from_syntax_node(db, node)))
7018 }
7019 _ => None,
7020 }
7021 }
7022 fn as_syntax_node(&self) -> SyntaxNode {
7023 match self {
7024 StructArg::StructArgSingle(x) => x.as_syntax_node(),
7025 StructArg::StructArgTail(x) => x.as_syntax_node(),
7026 }
7027 }
7028 fn stable_ptr(&self) -> Self::StablePtr {
7029 StructArgPtr(self.as_syntax_node().0.stable_ptr)
7030 }
7031}
7032impl From<&StructArg> for SyntaxStablePtrId {
7033 fn from(node: &StructArg) -> Self {
7034 node.stable_ptr().untyped()
7035 }
7036}
7037impl StructArg {
7038 pub fn is_variant(kind: SyntaxKind) -> bool {
7040 matches!(kind, SyntaxKind::StructArgSingle | SyntaxKind::StructArgTail)
7041 }
7042}
7043#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7044pub struct StructArgList(ElementList<StructArg, 2>);
7045impl Deref for StructArgList {
7046 type Target = ElementList<StructArg, 2>;
7047 fn deref(&self) -> &Self::Target {
7048 &self.0
7049 }
7050}
7051impl StructArgList {
7052 pub fn new_green(
7053 db: &dyn SyntaxGroup,
7054 children: Vec<StructArgListElementOrSeparatorGreen>,
7055 ) -> StructArgListGreen {
7056 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
7057 StructArgListGreen(
7058 Arc::new(GreenNode {
7059 kind: SyntaxKind::StructArgList,
7060 details: GreenNodeDetails::Node {
7061 children: children.iter().map(|x| x.id()).collect(),
7062 width,
7063 },
7064 })
7065 .intern(db),
7066 )
7067 }
7068}
7069#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7070pub struct StructArgListPtr(pub SyntaxStablePtrId);
7071impl TypedStablePtr for StructArgListPtr {
7072 type SyntaxNode = StructArgList;
7073 fn untyped(&self) -> SyntaxStablePtrId {
7074 self.0
7075 }
7076 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgList {
7077 StructArgList::from_syntax_node(db, self.0.lookup(db))
7078 }
7079}
7080impl From<StructArgListPtr> for SyntaxStablePtrId {
7081 fn from(ptr: StructArgListPtr) -> Self {
7082 ptr.untyped()
7083 }
7084}
7085#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7086pub enum StructArgListElementOrSeparatorGreen {
7087 Separator(TerminalCommaGreen),
7088 Element(StructArgGreen),
7089}
7090impl From<TerminalCommaGreen> for StructArgListElementOrSeparatorGreen {
7091 fn from(value: TerminalCommaGreen) -> Self {
7092 StructArgListElementOrSeparatorGreen::Separator(value)
7093 }
7094}
7095impl From<StructArgGreen> for StructArgListElementOrSeparatorGreen {
7096 fn from(value: StructArgGreen) -> Self {
7097 StructArgListElementOrSeparatorGreen::Element(value)
7098 }
7099}
7100impl StructArgListElementOrSeparatorGreen {
7101 fn id(&self) -> GreenId {
7102 match self {
7103 StructArgListElementOrSeparatorGreen::Separator(green) => green.0,
7104 StructArgListElementOrSeparatorGreen::Element(green) => green.0,
7105 }
7106 }
7107}
7108#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7109pub struct StructArgListGreen(pub GreenId);
7110impl TypedSyntaxNode for StructArgList {
7111 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgList);
7112 type StablePtr = StructArgListPtr;
7113 type Green = StructArgListGreen;
7114 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7115 StructArgListGreen(
7116 Arc::new(GreenNode {
7117 kind: SyntaxKind::StructArgList,
7118 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
7119 })
7120 .intern(db),
7121 )
7122 }
7123 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7124 Self(ElementList::new(node))
7125 }
7126 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7127 if node.kind(db) == SyntaxKind::StructArgList {
7128 Some(Self(ElementList::new(node)))
7129 } else {
7130 None
7131 }
7132 }
7133 fn as_syntax_node(&self) -> SyntaxNode {
7134 self.node.clone()
7135 }
7136 fn stable_ptr(&self) -> Self::StablePtr {
7137 StructArgListPtr(self.node.0.stable_ptr)
7138 }
7139}
7140impl From<&StructArgList> for SyntaxStablePtrId {
7141 fn from(node: &StructArgList) -> Self {
7142 node.stable_ptr().untyped()
7143 }
7144}
7145#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7146pub struct ArgListBraced {
7147 node: SyntaxNode,
7148 children: Arc<[SyntaxNode]>,
7149}
7150impl ArgListBraced {
7151 pub const INDEX_LBRACE: usize = 0;
7152 pub const INDEX_ARGUMENTS: usize = 1;
7153 pub const INDEX_RBRACE: usize = 2;
7154 pub fn new_green(
7155 db: &dyn SyntaxGroup,
7156 lbrace: TerminalLBraceGreen,
7157 arguments: ArgListGreen,
7158 rbrace: TerminalRBraceGreen,
7159 ) -> ArgListBracedGreen {
7160 let children: Vec<GreenId> = vec![lbrace.0, arguments.0, rbrace.0];
7161 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7162 ArgListBracedGreen(
7163 Arc::new(GreenNode {
7164 kind: SyntaxKind::ArgListBraced,
7165 details: GreenNodeDetails::Node { children, width },
7166 })
7167 .intern(db),
7168 )
7169 }
7170}
7171impl ArgListBraced {
7172 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
7173 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
7174 }
7175 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
7176 ArgList::from_syntax_node(db, self.children[1].clone())
7177 }
7178 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
7179 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
7180 }
7181}
7182#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7183pub struct ArgListBracedPtr(pub SyntaxStablePtrId);
7184impl ArgListBracedPtr {}
7185impl TypedStablePtr for ArgListBracedPtr {
7186 type SyntaxNode = ArgListBraced;
7187 fn untyped(&self) -> SyntaxStablePtrId {
7188 self.0
7189 }
7190 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListBraced {
7191 ArgListBraced::from_syntax_node(db, self.0.lookup(db))
7192 }
7193}
7194impl From<ArgListBracedPtr> for SyntaxStablePtrId {
7195 fn from(ptr: ArgListBracedPtr) -> Self {
7196 ptr.untyped()
7197 }
7198}
7199#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7200pub struct ArgListBracedGreen(pub GreenId);
7201impl TypedSyntaxNode for ArgListBraced {
7202 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListBraced);
7203 type StablePtr = ArgListBracedPtr;
7204 type Green = ArgListBracedGreen;
7205 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7206 ArgListBracedGreen(
7207 Arc::new(GreenNode {
7208 kind: SyntaxKind::ArgListBraced,
7209 details: GreenNodeDetails::Node {
7210 children: vec![
7211 TerminalLBrace::missing(db).0,
7212 ArgList::missing(db).0,
7213 TerminalRBrace::missing(db).0,
7214 ],
7215 width: TextWidth::default(),
7216 },
7217 })
7218 .intern(db),
7219 )
7220 }
7221 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7222 let kind = node.kind(db);
7223 assert_eq!(
7224 kind,
7225 SyntaxKind::ArgListBraced,
7226 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7227 kind,
7228 SyntaxKind::ArgListBraced
7229 );
7230 let children = db.get_children(node.clone());
7231 Self { node, children }
7232 }
7233 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7234 let kind = node.kind(db);
7235 if kind == SyntaxKind::ArgListBraced {
7236 Some(Self::from_syntax_node(db, node))
7237 } else {
7238 None
7239 }
7240 }
7241 fn as_syntax_node(&self) -> SyntaxNode {
7242 self.node.clone()
7243 }
7244 fn stable_ptr(&self) -> Self::StablePtr {
7245 ArgListBracedPtr(self.node.0.stable_ptr)
7246 }
7247}
7248impl From<&ArgListBraced> for SyntaxStablePtrId {
7249 fn from(node: &ArgListBraced) -> Self {
7250 node.stable_ptr().untyped()
7251 }
7252}
7253#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7254pub struct ArgListBracketed {
7255 node: SyntaxNode,
7256 children: Arc<[SyntaxNode]>,
7257}
7258impl ArgListBracketed {
7259 pub const INDEX_LBRACK: usize = 0;
7260 pub const INDEX_ARGUMENTS: usize = 1;
7261 pub const INDEX_RBRACK: usize = 2;
7262 pub fn new_green(
7263 db: &dyn SyntaxGroup,
7264 lbrack: TerminalLBrackGreen,
7265 arguments: ArgListGreen,
7266 rbrack: TerminalRBrackGreen,
7267 ) -> ArgListBracketedGreen {
7268 let children: Vec<GreenId> = vec![lbrack.0, arguments.0, rbrack.0];
7269 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7270 ArgListBracketedGreen(
7271 Arc::new(GreenNode {
7272 kind: SyntaxKind::ArgListBracketed,
7273 details: GreenNodeDetails::Node { children, width },
7274 })
7275 .intern(db),
7276 )
7277 }
7278}
7279impl ArgListBracketed {
7280 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
7281 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
7282 }
7283 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
7284 ArgList::from_syntax_node(db, self.children[1].clone())
7285 }
7286 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
7287 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
7288 }
7289}
7290#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7291pub struct ArgListBracketedPtr(pub SyntaxStablePtrId);
7292impl ArgListBracketedPtr {}
7293impl TypedStablePtr for ArgListBracketedPtr {
7294 type SyntaxNode = ArgListBracketed;
7295 fn untyped(&self) -> SyntaxStablePtrId {
7296 self.0
7297 }
7298 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListBracketed {
7299 ArgListBracketed::from_syntax_node(db, self.0.lookup(db))
7300 }
7301}
7302impl From<ArgListBracketedPtr> for SyntaxStablePtrId {
7303 fn from(ptr: ArgListBracketedPtr) -> Self {
7304 ptr.untyped()
7305 }
7306}
7307#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7308pub struct ArgListBracketedGreen(pub GreenId);
7309impl TypedSyntaxNode for ArgListBracketed {
7310 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListBracketed);
7311 type StablePtr = ArgListBracketedPtr;
7312 type Green = ArgListBracketedGreen;
7313 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7314 ArgListBracketedGreen(
7315 Arc::new(GreenNode {
7316 kind: SyntaxKind::ArgListBracketed,
7317 details: GreenNodeDetails::Node {
7318 children: vec![
7319 TerminalLBrack::missing(db).0,
7320 ArgList::missing(db).0,
7321 TerminalRBrack::missing(db).0,
7322 ],
7323 width: TextWidth::default(),
7324 },
7325 })
7326 .intern(db),
7327 )
7328 }
7329 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7330 let kind = node.kind(db);
7331 assert_eq!(
7332 kind,
7333 SyntaxKind::ArgListBracketed,
7334 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7335 kind,
7336 SyntaxKind::ArgListBracketed
7337 );
7338 let children = db.get_children(node.clone());
7339 Self { node, children }
7340 }
7341 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7342 let kind = node.kind(db);
7343 if kind == SyntaxKind::ArgListBracketed {
7344 Some(Self::from_syntax_node(db, node))
7345 } else {
7346 None
7347 }
7348 }
7349 fn as_syntax_node(&self) -> SyntaxNode {
7350 self.node.clone()
7351 }
7352 fn stable_ptr(&self) -> Self::StablePtr {
7353 ArgListBracketedPtr(self.node.0.stable_ptr)
7354 }
7355}
7356impl From<&ArgListBracketed> for SyntaxStablePtrId {
7357 fn from(node: &ArgListBracketed) -> Self {
7358 node.stable_ptr().untyped()
7359 }
7360}
7361#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7362pub enum WrappedArgList {
7363 BracketedArgList(ArgListBracketed),
7364 ParenthesizedArgList(ArgListParenthesized),
7365 BracedArgList(ArgListBraced),
7366 Missing(WrappedArgListMissing),
7367}
7368#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7369pub struct WrappedArgListPtr(pub SyntaxStablePtrId);
7370impl TypedStablePtr for WrappedArgListPtr {
7371 type SyntaxNode = WrappedArgList;
7372 fn untyped(&self) -> SyntaxStablePtrId {
7373 self.0
7374 }
7375 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
7376 WrappedArgList::from_syntax_node(db, self.0.lookup(db))
7377 }
7378}
7379impl From<WrappedArgListPtr> for SyntaxStablePtrId {
7380 fn from(ptr: WrappedArgListPtr) -> Self {
7381 ptr.untyped()
7382 }
7383}
7384impl From<ArgListBracketedPtr> for WrappedArgListPtr {
7385 fn from(value: ArgListBracketedPtr) -> Self {
7386 Self(value.0)
7387 }
7388}
7389impl From<ArgListParenthesizedPtr> for WrappedArgListPtr {
7390 fn from(value: ArgListParenthesizedPtr) -> Self {
7391 Self(value.0)
7392 }
7393}
7394impl From<ArgListBracedPtr> for WrappedArgListPtr {
7395 fn from(value: ArgListBracedPtr) -> Self {
7396 Self(value.0)
7397 }
7398}
7399impl From<WrappedArgListMissingPtr> for WrappedArgListPtr {
7400 fn from(value: WrappedArgListMissingPtr) -> Self {
7401 Self(value.0)
7402 }
7403}
7404impl From<ArgListBracketedGreen> for WrappedArgListGreen {
7405 fn from(value: ArgListBracketedGreen) -> Self {
7406 Self(value.0)
7407 }
7408}
7409impl From<ArgListParenthesizedGreen> for WrappedArgListGreen {
7410 fn from(value: ArgListParenthesizedGreen) -> Self {
7411 Self(value.0)
7412 }
7413}
7414impl From<ArgListBracedGreen> for WrappedArgListGreen {
7415 fn from(value: ArgListBracedGreen) -> Self {
7416 Self(value.0)
7417 }
7418}
7419impl From<WrappedArgListMissingGreen> for WrappedArgListGreen {
7420 fn from(value: WrappedArgListMissingGreen) -> Self {
7421 Self(value.0)
7422 }
7423}
7424#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7425pub struct WrappedArgListGreen(pub GreenId);
7426impl TypedSyntaxNode for WrappedArgList {
7427 const OPTIONAL_KIND: Option<SyntaxKind> = None;
7428 type StablePtr = WrappedArgListPtr;
7429 type Green = WrappedArgListGreen;
7430 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7431 WrappedArgListGreen(WrappedArgListMissing::missing(db).0)
7432 }
7433 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7434 let kind = node.kind(db);
7435 match kind {
7436 SyntaxKind::ArgListBracketed => {
7437 WrappedArgList::BracketedArgList(ArgListBracketed::from_syntax_node(db, node))
7438 }
7439 SyntaxKind::ArgListParenthesized => WrappedArgList::ParenthesizedArgList(
7440 ArgListParenthesized::from_syntax_node(db, node),
7441 ),
7442 SyntaxKind::ArgListBraced => {
7443 WrappedArgList::BracedArgList(ArgListBraced::from_syntax_node(db, node))
7444 }
7445 SyntaxKind::WrappedArgListMissing => {
7446 WrappedArgList::Missing(WrappedArgListMissing::from_syntax_node(db, node))
7447 }
7448 _ => {
7449 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "WrappedArgList")
7450 }
7451 }
7452 }
7453 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7454 let kind = node.kind(db);
7455 match kind {
7456 SyntaxKind::ArgListBracketed => {
7457 Some(WrappedArgList::BracketedArgList(ArgListBracketed::from_syntax_node(db, node)))
7458 }
7459 SyntaxKind::ArgListParenthesized => Some(WrappedArgList::ParenthesizedArgList(
7460 ArgListParenthesized::from_syntax_node(db, node),
7461 )),
7462 SyntaxKind::ArgListBraced => {
7463 Some(WrappedArgList::BracedArgList(ArgListBraced::from_syntax_node(db, node)))
7464 }
7465 SyntaxKind::WrappedArgListMissing => {
7466 Some(WrappedArgList::Missing(WrappedArgListMissing::from_syntax_node(db, node)))
7467 }
7468 _ => None,
7469 }
7470 }
7471 fn as_syntax_node(&self) -> SyntaxNode {
7472 match self {
7473 WrappedArgList::BracketedArgList(x) => x.as_syntax_node(),
7474 WrappedArgList::ParenthesizedArgList(x) => x.as_syntax_node(),
7475 WrappedArgList::BracedArgList(x) => x.as_syntax_node(),
7476 WrappedArgList::Missing(x) => x.as_syntax_node(),
7477 }
7478 }
7479 fn stable_ptr(&self) -> Self::StablePtr {
7480 WrappedArgListPtr(self.as_syntax_node().0.stable_ptr)
7481 }
7482}
7483impl From<&WrappedArgList> for SyntaxStablePtrId {
7484 fn from(node: &WrappedArgList) -> Self {
7485 node.stable_ptr().untyped()
7486 }
7487}
7488impl WrappedArgList {
7489 pub fn is_variant(kind: SyntaxKind) -> bool {
7491 matches!(
7492 kind,
7493 SyntaxKind::ArgListBracketed
7494 | SyntaxKind::ArgListParenthesized
7495 | SyntaxKind::ArgListBraced
7496 | SyntaxKind::WrappedArgListMissing
7497 )
7498 }
7499}
7500#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7501pub struct WrappedArgListMissing {
7502 node: SyntaxNode,
7503 children: Arc<[SyntaxNode]>,
7504}
7505impl WrappedArgListMissing {
7506 pub fn new_green(db: &dyn SyntaxGroup) -> WrappedArgListMissingGreen {
7507 let children: Vec<GreenId> = vec![];
7508 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7509 WrappedArgListMissingGreen(
7510 Arc::new(GreenNode {
7511 kind: SyntaxKind::WrappedArgListMissing,
7512 details: GreenNodeDetails::Node { children, width },
7513 })
7514 .intern(db),
7515 )
7516 }
7517}
7518impl WrappedArgListMissing {}
7519#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7520pub struct WrappedArgListMissingPtr(pub SyntaxStablePtrId);
7521impl WrappedArgListMissingPtr {}
7522impl TypedStablePtr for WrappedArgListMissingPtr {
7523 type SyntaxNode = WrappedArgListMissing;
7524 fn untyped(&self) -> SyntaxStablePtrId {
7525 self.0
7526 }
7527 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedArgListMissing {
7528 WrappedArgListMissing::from_syntax_node(db, self.0.lookup(db))
7529 }
7530}
7531impl From<WrappedArgListMissingPtr> for SyntaxStablePtrId {
7532 fn from(ptr: WrappedArgListMissingPtr) -> Self {
7533 ptr.untyped()
7534 }
7535}
7536#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7537pub struct WrappedArgListMissingGreen(pub GreenId);
7538impl TypedSyntaxNode for WrappedArgListMissing {
7539 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::WrappedArgListMissing);
7540 type StablePtr = WrappedArgListMissingPtr;
7541 type Green = WrappedArgListMissingGreen;
7542 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7543 WrappedArgListMissingGreen(
7544 Arc::new(GreenNode {
7545 kind: SyntaxKind::WrappedArgListMissing,
7546 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
7547 })
7548 .intern(db),
7549 )
7550 }
7551 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7552 let kind = node.kind(db);
7553 assert_eq!(
7554 kind,
7555 SyntaxKind::WrappedArgListMissing,
7556 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7557 kind,
7558 SyntaxKind::WrappedArgListMissing
7559 );
7560 let children = db.get_children(node.clone());
7561 Self { node, children }
7562 }
7563 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7564 let kind = node.kind(db);
7565 if kind == SyntaxKind::WrappedArgListMissing {
7566 Some(Self::from_syntax_node(db, node))
7567 } else {
7568 None
7569 }
7570 }
7571 fn as_syntax_node(&self) -> SyntaxNode {
7572 self.node.clone()
7573 }
7574 fn stable_ptr(&self) -> Self::StablePtr {
7575 WrappedArgListMissingPtr(self.node.0.stable_ptr)
7576 }
7577}
7578impl From<&WrappedArgListMissing> for SyntaxStablePtrId {
7579 fn from(node: &WrappedArgListMissing) -> Self {
7580 node.stable_ptr().untyped()
7581 }
7582}
7583#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7584pub enum Pattern {
7585 Underscore(TerminalUnderscore),
7586 Literal(TerminalLiteralNumber),
7587 False(TerminalFalse),
7588 True(TerminalTrue),
7589 ShortString(TerminalShortString),
7590 String(TerminalString),
7591 Identifier(PatternIdentifier),
7592 Struct(PatternStruct),
7593 Tuple(PatternTuple),
7594 Enum(PatternEnum),
7595 FixedSizeArray(PatternFixedSizeArray),
7596 Path(ExprPath),
7597}
7598#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7599pub struct PatternPtr(pub SyntaxStablePtrId);
7600impl TypedStablePtr for PatternPtr {
7601 type SyntaxNode = Pattern;
7602 fn untyped(&self) -> SyntaxStablePtrId {
7603 self.0
7604 }
7605 fn lookup(&self, db: &dyn SyntaxGroup) -> Pattern {
7606 Pattern::from_syntax_node(db, self.0.lookup(db))
7607 }
7608}
7609impl From<PatternPtr> for SyntaxStablePtrId {
7610 fn from(ptr: PatternPtr) -> Self {
7611 ptr.untyped()
7612 }
7613}
7614impl From<TerminalUnderscorePtr> for PatternPtr {
7615 fn from(value: TerminalUnderscorePtr) -> Self {
7616 Self(value.0)
7617 }
7618}
7619impl From<TerminalLiteralNumberPtr> for PatternPtr {
7620 fn from(value: TerminalLiteralNumberPtr) -> Self {
7621 Self(value.0)
7622 }
7623}
7624impl From<TerminalFalsePtr> for PatternPtr {
7625 fn from(value: TerminalFalsePtr) -> Self {
7626 Self(value.0)
7627 }
7628}
7629impl From<TerminalTruePtr> for PatternPtr {
7630 fn from(value: TerminalTruePtr) -> Self {
7631 Self(value.0)
7632 }
7633}
7634impl From<TerminalShortStringPtr> for PatternPtr {
7635 fn from(value: TerminalShortStringPtr) -> Self {
7636 Self(value.0)
7637 }
7638}
7639impl From<TerminalStringPtr> for PatternPtr {
7640 fn from(value: TerminalStringPtr) -> Self {
7641 Self(value.0)
7642 }
7643}
7644impl From<PatternIdentifierPtr> for PatternPtr {
7645 fn from(value: PatternIdentifierPtr) -> Self {
7646 Self(value.0)
7647 }
7648}
7649impl From<PatternStructPtr> for PatternPtr {
7650 fn from(value: PatternStructPtr) -> Self {
7651 Self(value.0)
7652 }
7653}
7654impl From<PatternTuplePtr> for PatternPtr {
7655 fn from(value: PatternTuplePtr) -> Self {
7656 Self(value.0)
7657 }
7658}
7659impl From<PatternEnumPtr> for PatternPtr {
7660 fn from(value: PatternEnumPtr) -> Self {
7661 Self(value.0)
7662 }
7663}
7664impl From<PatternFixedSizeArrayPtr> for PatternPtr {
7665 fn from(value: PatternFixedSizeArrayPtr) -> Self {
7666 Self(value.0)
7667 }
7668}
7669impl From<ExprPathPtr> for PatternPtr {
7670 fn from(value: ExprPathPtr) -> Self {
7671 Self(value.0)
7672 }
7673}
7674impl From<TerminalUnderscoreGreen> for PatternGreen {
7675 fn from(value: TerminalUnderscoreGreen) -> Self {
7676 Self(value.0)
7677 }
7678}
7679impl From<TerminalLiteralNumberGreen> for PatternGreen {
7680 fn from(value: TerminalLiteralNumberGreen) -> Self {
7681 Self(value.0)
7682 }
7683}
7684impl From<TerminalFalseGreen> for PatternGreen {
7685 fn from(value: TerminalFalseGreen) -> Self {
7686 Self(value.0)
7687 }
7688}
7689impl From<TerminalTrueGreen> for PatternGreen {
7690 fn from(value: TerminalTrueGreen) -> Self {
7691 Self(value.0)
7692 }
7693}
7694impl From<TerminalShortStringGreen> for PatternGreen {
7695 fn from(value: TerminalShortStringGreen) -> Self {
7696 Self(value.0)
7697 }
7698}
7699impl From<TerminalStringGreen> for PatternGreen {
7700 fn from(value: TerminalStringGreen) -> Self {
7701 Self(value.0)
7702 }
7703}
7704impl From<PatternIdentifierGreen> for PatternGreen {
7705 fn from(value: PatternIdentifierGreen) -> Self {
7706 Self(value.0)
7707 }
7708}
7709impl From<PatternStructGreen> for PatternGreen {
7710 fn from(value: PatternStructGreen) -> Self {
7711 Self(value.0)
7712 }
7713}
7714impl From<PatternTupleGreen> for PatternGreen {
7715 fn from(value: PatternTupleGreen) -> Self {
7716 Self(value.0)
7717 }
7718}
7719impl From<PatternEnumGreen> for PatternGreen {
7720 fn from(value: PatternEnumGreen) -> Self {
7721 Self(value.0)
7722 }
7723}
7724impl From<PatternFixedSizeArrayGreen> for PatternGreen {
7725 fn from(value: PatternFixedSizeArrayGreen) -> Self {
7726 Self(value.0)
7727 }
7728}
7729impl From<ExprPathGreen> for PatternGreen {
7730 fn from(value: ExprPathGreen) -> Self {
7731 Self(value.0)
7732 }
7733}
7734#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7735pub struct PatternGreen(pub GreenId);
7736impl TypedSyntaxNode for Pattern {
7737 const OPTIONAL_KIND: Option<SyntaxKind> = None;
7738 type StablePtr = PatternPtr;
7739 type Green = PatternGreen;
7740 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7741 panic!("No missing variant.");
7742 }
7743 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7744 let kind = node.kind(db);
7745 match kind {
7746 SyntaxKind::TerminalUnderscore => {
7747 Pattern::Underscore(TerminalUnderscore::from_syntax_node(db, node))
7748 }
7749 SyntaxKind::TerminalLiteralNumber => {
7750 Pattern::Literal(TerminalLiteralNumber::from_syntax_node(db, node))
7751 }
7752 SyntaxKind::TerminalFalse => Pattern::False(TerminalFalse::from_syntax_node(db, node)),
7753 SyntaxKind::TerminalTrue => Pattern::True(TerminalTrue::from_syntax_node(db, node)),
7754 SyntaxKind::TerminalShortString => {
7755 Pattern::ShortString(TerminalShortString::from_syntax_node(db, node))
7756 }
7757 SyntaxKind::TerminalString => {
7758 Pattern::String(TerminalString::from_syntax_node(db, node))
7759 }
7760 SyntaxKind::PatternIdentifier => {
7761 Pattern::Identifier(PatternIdentifier::from_syntax_node(db, node))
7762 }
7763 SyntaxKind::PatternStruct => Pattern::Struct(PatternStruct::from_syntax_node(db, node)),
7764 SyntaxKind::PatternTuple => Pattern::Tuple(PatternTuple::from_syntax_node(db, node)),
7765 SyntaxKind::PatternEnum => Pattern::Enum(PatternEnum::from_syntax_node(db, node)),
7766 SyntaxKind::PatternFixedSizeArray => {
7767 Pattern::FixedSizeArray(PatternFixedSizeArray::from_syntax_node(db, node))
7768 }
7769 SyntaxKind::ExprPath => Pattern::Path(ExprPath::from_syntax_node(db, node)),
7770 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Pattern"),
7771 }
7772 }
7773 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7774 let kind = node.kind(db);
7775 match kind {
7776 SyntaxKind::TerminalUnderscore => {
7777 Some(Pattern::Underscore(TerminalUnderscore::from_syntax_node(db, node)))
7778 }
7779 SyntaxKind::TerminalLiteralNumber => {
7780 Some(Pattern::Literal(TerminalLiteralNumber::from_syntax_node(db, node)))
7781 }
7782 SyntaxKind::TerminalFalse => {
7783 Some(Pattern::False(TerminalFalse::from_syntax_node(db, node)))
7784 }
7785 SyntaxKind::TerminalTrue => {
7786 Some(Pattern::True(TerminalTrue::from_syntax_node(db, node)))
7787 }
7788 SyntaxKind::TerminalShortString => {
7789 Some(Pattern::ShortString(TerminalShortString::from_syntax_node(db, node)))
7790 }
7791 SyntaxKind::TerminalString => {
7792 Some(Pattern::String(TerminalString::from_syntax_node(db, node)))
7793 }
7794 SyntaxKind::PatternIdentifier => {
7795 Some(Pattern::Identifier(PatternIdentifier::from_syntax_node(db, node)))
7796 }
7797 SyntaxKind::PatternStruct => {
7798 Some(Pattern::Struct(PatternStruct::from_syntax_node(db, node)))
7799 }
7800 SyntaxKind::PatternTuple => {
7801 Some(Pattern::Tuple(PatternTuple::from_syntax_node(db, node)))
7802 }
7803 SyntaxKind::PatternEnum => Some(Pattern::Enum(PatternEnum::from_syntax_node(db, node))),
7804 SyntaxKind::PatternFixedSizeArray => {
7805 Some(Pattern::FixedSizeArray(PatternFixedSizeArray::from_syntax_node(db, node)))
7806 }
7807 SyntaxKind::ExprPath => Some(Pattern::Path(ExprPath::from_syntax_node(db, node))),
7808 _ => None,
7809 }
7810 }
7811 fn as_syntax_node(&self) -> SyntaxNode {
7812 match self {
7813 Pattern::Underscore(x) => x.as_syntax_node(),
7814 Pattern::Literal(x) => x.as_syntax_node(),
7815 Pattern::False(x) => x.as_syntax_node(),
7816 Pattern::True(x) => x.as_syntax_node(),
7817 Pattern::ShortString(x) => x.as_syntax_node(),
7818 Pattern::String(x) => x.as_syntax_node(),
7819 Pattern::Identifier(x) => x.as_syntax_node(),
7820 Pattern::Struct(x) => x.as_syntax_node(),
7821 Pattern::Tuple(x) => x.as_syntax_node(),
7822 Pattern::Enum(x) => x.as_syntax_node(),
7823 Pattern::FixedSizeArray(x) => x.as_syntax_node(),
7824 Pattern::Path(x) => x.as_syntax_node(),
7825 }
7826 }
7827 fn stable_ptr(&self) -> Self::StablePtr {
7828 PatternPtr(self.as_syntax_node().0.stable_ptr)
7829 }
7830}
7831impl From<&Pattern> for SyntaxStablePtrId {
7832 fn from(node: &Pattern) -> Self {
7833 node.stable_ptr().untyped()
7834 }
7835}
7836impl Pattern {
7837 pub fn is_variant(kind: SyntaxKind) -> bool {
7839 matches!(
7840 kind,
7841 SyntaxKind::TerminalUnderscore
7842 | SyntaxKind::TerminalLiteralNumber
7843 | SyntaxKind::TerminalFalse
7844 | SyntaxKind::TerminalTrue
7845 | SyntaxKind::TerminalShortString
7846 | SyntaxKind::TerminalString
7847 | SyntaxKind::PatternIdentifier
7848 | SyntaxKind::PatternStruct
7849 | SyntaxKind::PatternTuple
7850 | SyntaxKind::PatternEnum
7851 | SyntaxKind::PatternFixedSizeArray
7852 | SyntaxKind::ExprPath
7853 )
7854 }
7855}
7856#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7857pub struct PatternIdentifier {
7858 node: SyntaxNode,
7859 children: Arc<[SyntaxNode]>,
7860}
7861impl PatternIdentifier {
7862 pub const INDEX_MODIFIERS: usize = 0;
7863 pub const INDEX_NAME: usize = 1;
7864 pub fn new_green(
7865 db: &dyn SyntaxGroup,
7866 modifiers: ModifierListGreen,
7867 name: TerminalIdentifierGreen,
7868 ) -> PatternIdentifierGreen {
7869 let children: Vec<GreenId> = vec![modifiers.0, name.0];
7870 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7871 PatternIdentifierGreen(
7872 Arc::new(GreenNode {
7873 kind: SyntaxKind::PatternIdentifier,
7874 details: GreenNodeDetails::Node { children, width },
7875 })
7876 .intern(db),
7877 )
7878 }
7879}
7880impl PatternIdentifier {
7881 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
7882 ModifierList::from_syntax_node(db, self.children[0].clone())
7883 }
7884 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
7885 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
7886 }
7887}
7888#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7889pub struct PatternIdentifierPtr(pub SyntaxStablePtrId);
7890impl PatternIdentifierPtr {
7891 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
7892 let ptr = self.0.lookup_intern(db);
7893 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
7894 TerminalIdentifierGreen(key_fields[0])
7895 } else {
7896 panic!("Unexpected key field query on root.");
7897 }
7898 }
7899}
7900impl TypedStablePtr for PatternIdentifierPtr {
7901 type SyntaxNode = PatternIdentifier;
7902 fn untyped(&self) -> SyntaxStablePtrId {
7903 self.0
7904 }
7905 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternIdentifier {
7906 PatternIdentifier::from_syntax_node(db, self.0.lookup(db))
7907 }
7908}
7909impl From<PatternIdentifierPtr> for SyntaxStablePtrId {
7910 fn from(ptr: PatternIdentifierPtr) -> Self {
7911 ptr.untyped()
7912 }
7913}
7914#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7915pub struct PatternIdentifierGreen(pub GreenId);
7916impl TypedSyntaxNode for PatternIdentifier {
7917 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternIdentifier);
7918 type StablePtr = PatternIdentifierPtr;
7919 type Green = PatternIdentifierGreen;
7920 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7921 PatternIdentifierGreen(
7922 Arc::new(GreenNode {
7923 kind: SyntaxKind::PatternIdentifier,
7924 details: GreenNodeDetails::Node {
7925 children: vec![ModifierList::missing(db).0, TerminalIdentifier::missing(db).0],
7926 width: TextWidth::default(),
7927 },
7928 })
7929 .intern(db),
7930 )
7931 }
7932 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7933 let kind = node.kind(db);
7934 assert_eq!(
7935 kind,
7936 SyntaxKind::PatternIdentifier,
7937 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7938 kind,
7939 SyntaxKind::PatternIdentifier
7940 );
7941 let children = db.get_children(node.clone());
7942 Self { node, children }
7943 }
7944 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
7945 let kind = node.kind(db);
7946 if kind == SyntaxKind::PatternIdentifier {
7947 Some(Self::from_syntax_node(db, node))
7948 } else {
7949 None
7950 }
7951 }
7952 fn as_syntax_node(&self) -> SyntaxNode {
7953 self.node.clone()
7954 }
7955 fn stable_ptr(&self) -> Self::StablePtr {
7956 PatternIdentifierPtr(self.node.0.stable_ptr)
7957 }
7958}
7959impl From<&PatternIdentifier> for SyntaxStablePtrId {
7960 fn from(node: &PatternIdentifier) -> Self {
7961 node.stable_ptr().untyped()
7962 }
7963}
7964#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7965pub struct PatternStruct {
7966 node: SyntaxNode,
7967 children: Arc<[SyntaxNode]>,
7968}
7969impl PatternStruct {
7970 pub const INDEX_PATH: usize = 0;
7971 pub const INDEX_LBRACE: usize = 1;
7972 pub const INDEX_PARAMS: usize = 2;
7973 pub const INDEX_RBRACE: usize = 3;
7974 pub fn new_green(
7975 db: &dyn SyntaxGroup,
7976 path: ExprPathGreen,
7977 lbrace: TerminalLBraceGreen,
7978 params: PatternStructParamListGreen,
7979 rbrace: TerminalRBraceGreen,
7980 ) -> PatternStructGreen {
7981 let children: Vec<GreenId> = vec![path.0, lbrace.0, params.0, rbrace.0];
7982 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7983 PatternStructGreen(
7984 Arc::new(GreenNode {
7985 kind: SyntaxKind::PatternStruct,
7986 details: GreenNodeDetails::Node { children, width },
7987 })
7988 .intern(db),
7989 )
7990 }
7991}
7992impl PatternStruct {
7993 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
7994 ExprPath::from_syntax_node(db, self.children[0].clone())
7995 }
7996 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
7997 TerminalLBrace::from_syntax_node(db, self.children[1].clone())
7998 }
7999 pub fn params(&self, db: &dyn SyntaxGroup) -> PatternStructParamList {
8000 PatternStructParamList::from_syntax_node(db, self.children[2].clone())
8001 }
8002 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
8003 TerminalRBrace::from_syntax_node(db, self.children[3].clone())
8004 }
8005}
8006#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8007pub struct PatternStructPtr(pub SyntaxStablePtrId);
8008impl PatternStructPtr {}
8009impl TypedStablePtr for PatternStructPtr {
8010 type SyntaxNode = PatternStruct;
8011 fn untyped(&self) -> SyntaxStablePtrId {
8012 self.0
8013 }
8014 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStruct {
8015 PatternStruct::from_syntax_node(db, self.0.lookup(db))
8016 }
8017}
8018impl From<PatternStructPtr> for SyntaxStablePtrId {
8019 fn from(ptr: PatternStructPtr) -> Self {
8020 ptr.untyped()
8021 }
8022}
8023#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8024pub struct PatternStructGreen(pub GreenId);
8025impl TypedSyntaxNode for PatternStruct {
8026 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStruct);
8027 type StablePtr = PatternStructPtr;
8028 type Green = PatternStructGreen;
8029 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8030 PatternStructGreen(
8031 Arc::new(GreenNode {
8032 kind: SyntaxKind::PatternStruct,
8033 details: GreenNodeDetails::Node {
8034 children: vec![
8035 ExprPath::missing(db).0,
8036 TerminalLBrace::missing(db).0,
8037 PatternStructParamList::missing(db).0,
8038 TerminalRBrace::missing(db).0,
8039 ],
8040 width: TextWidth::default(),
8041 },
8042 })
8043 .intern(db),
8044 )
8045 }
8046 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8047 let kind = node.kind(db);
8048 assert_eq!(
8049 kind,
8050 SyntaxKind::PatternStruct,
8051 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8052 kind,
8053 SyntaxKind::PatternStruct
8054 );
8055 let children = db.get_children(node.clone());
8056 Self { node, children }
8057 }
8058 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8059 let kind = node.kind(db);
8060 if kind == SyntaxKind::PatternStruct {
8061 Some(Self::from_syntax_node(db, node))
8062 } else {
8063 None
8064 }
8065 }
8066 fn as_syntax_node(&self) -> SyntaxNode {
8067 self.node.clone()
8068 }
8069 fn stable_ptr(&self) -> Self::StablePtr {
8070 PatternStructPtr(self.node.0.stable_ptr)
8071 }
8072}
8073impl From<&PatternStruct> for SyntaxStablePtrId {
8074 fn from(node: &PatternStruct) -> Self {
8075 node.stable_ptr().untyped()
8076 }
8077}
8078#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8079pub struct PatternStructParamList(ElementList<PatternStructParam, 2>);
8080impl Deref for PatternStructParamList {
8081 type Target = ElementList<PatternStructParam, 2>;
8082 fn deref(&self) -> &Self::Target {
8083 &self.0
8084 }
8085}
8086impl PatternStructParamList {
8087 pub fn new_green(
8088 db: &dyn SyntaxGroup,
8089 children: Vec<PatternStructParamListElementOrSeparatorGreen>,
8090 ) -> PatternStructParamListGreen {
8091 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
8092 PatternStructParamListGreen(
8093 Arc::new(GreenNode {
8094 kind: SyntaxKind::PatternStructParamList,
8095 details: GreenNodeDetails::Node {
8096 children: children.iter().map(|x| x.id()).collect(),
8097 width,
8098 },
8099 })
8100 .intern(db),
8101 )
8102 }
8103}
8104#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8105pub struct PatternStructParamListPtr(pub SyntaxStablePtrId);
8106impl TypedStablePtr for PatternStructParamListPtr {
8107 type SyntaxNode = PatternStructParamList;
8108 fn untyped(&self) -> SyntaxStablePtrId {
8109 self.0
8110 }
8111 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParamList {
8112 PatternStructParamList::from_syntax_node(db, self.0.lookup(db))
8113 }
8114}
8115impl From<PatternStructParamListPtr> for SyntaxStablePtrId {
8116 fn from(ptr: PatternStructParamListPtr) -> Self {
8117 ptr.untyped()
8118 }
8119}
8120#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8121pub enum PatternStructParamListElementOrSeparatorGreen {
8122 Separator(TerminalCommaGreen),
8123 Element(PatternStructParamGreen),
8124}
8125impl From<TerminalCommaGreen> for PatternStructParamListElementOrSeparatorGreen {
8126 fn from(value: TerminalCommaGreen) -> Self {
8127 PatternStructParamListElementOrSeparatorGreen::Separator(value)
8128 }
8129}
8130impl From<PatternStructParamGreen> for PatternStructParamListElementOrSeparatorGreen {
8131 fn from(value: PatternStructParamGreen) -> Self {
8132 PatternStructParamListElementOrSeparatorGreen::Element(value)
8133 }
8134}
8135impl PatternStructParamListElementOrSeparatorGreen {
8136 fn id(&self) -> GreenId {
8137 match self {
8138 PatternStructParamListElementOrSeparatorGreen::Separator(green) => green.0,
8139 PatternStructParamListElementOrSeparatorGreen::Element(green) => green.0,
8140 }
8141 }
8142}
8143#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8144pub struct PatternStructParamListGreen(pub GreenId);
8145impl TypedSyntaxNode for PatternStructParamList {
8146 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStructParamList);
8147 type StablePtr = PatternStructParamListPtr;
8148 type Green = PatternStructParamListGreen;
8149 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8150 PatternStructParamListGreen(
8151 Arc::new(GreenNode {
8152 kind: SyntaxKind::PatternStructParamList,
8153 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8154 })
8155 .intern(db),
8156 )
8157 }
8158 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8159 Self(ElementList::new(node))
8160 }
8161 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8162 if node.kind(db) == SyntaxKind::PatternStructParamList {
8163 Some(Self(ElementList::new(node)))
8164 } else {
8165 None
8166 }
8167 }
8168 fn as_syntax_node(&self) -> SyntaxNode {
8169 self.node.clone()
8170 }
8171 fn stable_ptr(&self) -> Self::StablePtr {
8172 PatternStructParamListPtr(self.node.0.stable_ptr)
8173 }
8174}
8175impl From<&PatternStructParamList> for SyntaxStablePtrId {
8176 fn from(node: &PatternStructParamList) -> Self {
8177 node.stable_ptr().untyped()
8178 }
8179}
8180#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8181pub struct PatternTuple {
8182 node: SyntaxNode,
8183 children: Arc<[SyntaxNode]>,
8184}
8185impl PatternTuple {
8186 pub const INDEX_LPAREN: usize = 0;
8187 pub const INDEX_PATTERNS: usize = 1;
8188 pub const INDEX_RPAREN: usize = 2;
8189 pub fn new_green(
8190 db: &dyn SyntaxGroup,
8191 lparen: TerminalLParenGreen,
8192 patterns: PatternListGreen,
8193 rparen: TerminalRParenGreen,
8194 ) -> PatternTupleGreen {
8195 let children: Vec<GreenId> = vec![lparen.0, patterns.0, rparen.0];
8196 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8197 PatternTupleGreen(
8198 Arc::new(GreenNode {
8199 kind: SyntaxKind::PatternTuple,
8200 details: GreenNodeDetails::Node { children, width },
8201 })
8202 .intern(db),
8203 )
8204 }
8205}
8206impl PatternTuple {
8207 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
8208 TerminalLParen::from_syntax_node(db, self.children[0].clone())
8209 }
8210 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternList {
8211 PatternList::from_syntax_node(db, self.children[1].clone())
8212 }
8213 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
8214 TerminalRParen::from_syntax_node(db, self.children[2].clone())
8215 }
8216}
8217#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8218pub struct PatternTuplePtr(pub SyntaxStablePtrId);
8219impl PatternTuplePtr {}
8220impl TypedStablePtr for PatternTuplePtr {
8221 type SyntaxNode = PatternTuple;
8222 fn untyped(&self) -> SyntaxStablePtrId {
8223 self.0
8224 }
8225 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternTuple {
8226 PatternTuple::from_syntax_node(db, self.0.lookup(db))
8227 }
8228}
8229impl From<PatternTuplePtr> for SyntaxStablePtrId {
8230 fn from(ptr: PatternTuplePtr) -> Self {
8231 ptr.untyped()
8232 }
8233}
8234#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8235pub struct PatternTupleGreen(pub GreenId);
8236impl TypedSyntaxNode for PatternTuple {
8237 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternTuple);
8238 type StablePtr = PatternTuplePtr;
8239 type Green = PatternTupleGreen;
8240 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8241 PatternTupleGreen(
8242 Arc::new(GreenNode {
8243 kind: SyntaxKind::PatternTuple,
8244 details: GreenNodeDetails::Node {
8245 children: vec![
8246 TerminalLParen::missing(db).0,
8247 PatternList::missing(db).0,
8248 TerminalRParen::missing(db).0,
8249 ],
8250 width: TextWidth::default(),
8251 },
8252 })
8253 .intern(db),
8254 )
8255 }
8256 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8257 let kind = node.kind(db);
8258 assert_eq!(
8259 kind,
8260 SyntaxKind::PatternTuple,
8261 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8262 kind,
8263 SyntaxKind::PatternTuple
8264 );
8265 let children = db.get_children(node.clone());
8266 Self { node, children }
8267 }
8268 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8269 let kind = node.kind(db);
8270 if kind == SyntaxKind::PatternTuple { Some(Self::from_syntax_node(db, node)) } else { None }
8271 }
8272 fn as_syntax_node(&self) -> SyntaxNode {
8273 self.node.clone()
8274 }
8275 fn stable_ptr(&self) -> Self::StablePtr {
8276 PatternTuplePtr(self.node.0.stable_ptr)
8277 }
8278}
8279impl From<&PatternTuple> for SyntaxStablePtrId {
8280 fn from(node: &PatternTuple) -> Self {
8281 node.stable_ptr().untyped()
8282 }
8283}
8284#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8285pub struct PatternFixedSizeArray {
8286 node: SyntaxNode,
8287 children: Arc<[SyntaxNode]>,
8288}
8289impl PatternFixedSizeArray {
8290 pub const INDEX_LBRACK: usize = 0;
8291 pub const INDEX_PATTERNS: usize = 1;
8292 pub const INDEX_RBRACK: usize = 2;
8293 pub fn new_green(
8294 db: &dyn SyntaxGroup,
8295 lbrack: TerminalLBrackGreen,
8296 patterns: PatternListGreen,
8297 rbrack: TerminalRBrackGreen,
8298 ) -> PatternFixedSizeArrayGreen {
8299 let children: Vec<GreenId> = vec![lbrack.0, patterns.0, rbrack.0];
8300 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8301 PatternFixedSizeArrayGreen(
8302 Arc::new(GreenNode {
8303 kind: SyntaxKind::PatternFixedSizeArray,
8304 details: GreenNodeDetails::Node { children, width },
8305 })
8306 .intern(db),
8307 )
8308 }
8309}
8310impl PatternFixedSizeArray {
8311 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
8312 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
8313 }
8314 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternList {
8315 PatternList::from_syntax_node(db, self.children[1].clone())
8316 }
8317 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
8318 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
8319 }
8320}
8321#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8322pub struct PatternFixedSizeArrayPtr(pub SyntaxStablePtrId);
8323impl PatternFixedSizeArrayPtr {}
8324impl TypedStablePtr for PatternFixedSizeArrayPtr {
8325 type SyntaxNode = PatternFixedSizeArray;
8326 fn untyped(&self) -> SyntaxStablePtrId {
8327 self.0
8328 }
8329 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternFixedSizeArray {
8330 PatternFixedSizeArray::from_syntax_node(db, self.0.lookup(db))
8331 }
8332}
8333impl From<PatternFixedSizeArrayPtr> for SyntaxStablePtrId {
8334 fn from(ptr: PatternFixedSizeArrayPtr) -> Self {
8335 ptr.untyped()
8336 }
8337}
8338#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8339pub struct PatternFixedSizeArrayGreen(pub GreenId);
8340impl TypedSyntaxNode for PatternFixedSizeArray {
8341 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternFixedSizeArray);
8342 type StablePtr = PatternFixedSizeArrayPtr;
8343 type Green = PatternFixedSizeArrayGreen;
8344 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8345 PatternFixedSizeArrayGreen(
8346 Arc::new(GreenNode {
8347 kind: SyntaxKind::PatternFixedSizeArray,
8348 details: GreenNodeDetails::Node {
8349 children: vec![
8350 TerminalLBrack::missing(db).0,
8351 PatternList::missing(db).0,
8352 TerminalRBrack::missing(db).0,
8353 ],
8354 width: TextWidth::default(),
8355 },
8356 })
8357 .intern(db),
8358 )
8359 }
8360 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8361 let kind = node.kind(db);
8362 assert_eq!(
8363 kind,
8364 SyntaxKind::PatternFixedSizeArray,
8365 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8366 kind,
8367 SyntaxKind::PatternFixedSizeArray
8368 );
8369 let children = db.get_children(node.clone());
8370 Self { node, children }
8371 }
8372 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8373 let kind = node.kind(db);
8374 if kind == SyntaxKind::PatternFixedSizeArray {
8375 Some(Self::from_syntax_node(db, node))
8376 } else {
8377 None
8378 }
8379 }
8380 fn as_syntax_node(&self) -> SyntaxNode {
8381 self.node.clone()
8382 }
8383 fn stable_ptr(&self) -> Self::StablePtr {
8384 PatternFixedSizeArrayPtr(self.node.0.stable_ptr)
8385 }
8386}
8387impl From<&PatternFixedSizeArray> for SyntaxStablePtrId {
8388 fn from(node: &PatternFixedSizeArray) -> Self {
8389 node.stable_ptr().untyped()
8390 }
8391}
8392#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8393pub struct PatternList(ElementList<Pattern, 2>);
8394impl Deref for PatternList {
8395 type Target = ElementList<Pattern, 2>;
8396 fn deref(&self) -> &Self::Target {
8397 &self.0
8398 }
8399}
8400impl PatternList {
8401 pub fn new_green(
8402 db: &dyn SyntaxGroup,
8403 children: Vec<PatternListElementOrSeparatorGreen>,
8404 ) -> PatternListGreen {
8405 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
8406 PatternListGreen(
8407 Arc::new(GreenNode {
8408 kind: SyntaxKind::PatternList,
8409 details: GreenNodeDetails::Node {
8410 children: children.iter().map(|x| x.id()).collect(),
8411 width,
8412 },
8413 })
8414 .intern(db),
8415 )
8416 }
8417}
8418#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8419pub struct PatternListPtr(pub SyntaxStablePtrId);
8420impl TypedStablePtr for PatternListPtr {
8421 type SyntaxNode = PatternList;
8422 fn untyped(&self) -> SyntaxStablePtrId {
8423 self.0
8424 }
8425 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternList {
8426 PatternList::from_syntax_node(db, self.0.lookup(db))
8427 }
8428}
8429impl From<PatternListPtr> for SyntaxStablePtrId {
8430 fn from(ptr: PatternListPtr) -> Self {
8431 ptr.untyped()
8432 }
8433}
8434#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8435pub enum PatternListElementOrSeparatorGreen {
8436 Separator(TerminalCommaGreen),
8437 Element(PatternGreen),
8438}
8439impl From<TerminalCommaGreen> for PatternListElementOrSeparatorGreen {
8440 fn from(value: TerminalCommaGreen) -> Self {
8441 PatternListElementOrSeparatorGreen::Separator(value)
8442 }
8443}
8444impl From<PatternGreen> for PatternListElementOrSeparatorGreen {
8445 fn from(value: PatternGreen) -> Self {
8446 PatternListElementOrSeparatorGreen::Element(value)
8447 }
8448}
8449impl PatternListElementOrSeparatorGreen {
8450 fn id(&self) -> GreenId {
8451 match self {
8452 PatternListElementOrSeparatorGreen::Separator(green) => green.0,
8453 PatternListElementOrSeparatorGreen::Element(green) => green.0,
8454 }
8455 }
8456}
8457#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8458pub struct PatternListGreen(pub GreenId);
8459impl TypedSyntaxNode for PatternList {
8460 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternList);
8461 type StablePtr = PatternListPtr;
8462 type Green = PatternListGreen;
8463 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8464 PatternListGreen(
8465 Arc::new(GreenNode {
8466 kind: SyntaxKind::PatternList,
8467 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8468 })
8469 .intern(db),
8470 )
8471 }
8472 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8473 Self(ElementList::new(node))
8474 }
8475 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8476 if node.kind(db) == SyntaxKind::PatternList {
8477 Some(Self(ElementList::new(node)))
8478 } else {
8479 None
8480 }
8481 }
8482 fn as_syntax_node(&self) -> SyntaxNode {
8483 self.node.clone()
8484 }
8485 fn stable_ptr(&self) -> Self::StablePtr {
8486 PatternListPtr(self.node.0.stable_ptr)
8487 }
8488}
8489impl From<&PatternList> for SyntaxStablePtrId {
8490 fn from(node: &PatternList) -> Self {
8491 node.stable_ptr().untyped()
8492 }
8493}
8494#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8495pub struct PatternListOr(ElementList<Pattern, 2>);
8496impl Deref for PatternListOr {
8497 type Target = ElementList<Pattern, 2>;
8498 fn deref(&self) -> &Self::Target {
8499 &self.0
8500 }
8501}
8502impl PatternListOr {
8503 pub fn new_green(
8504 db: &dyn SyntaxGroup,
8505 children: Vec<PatternListOrElementOrSeparatorGreen>,
8506 ) -> PatternListOrGreen {
8507 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
8508 PatternListOrGreen(
8509 Arc::new(GreenNode {
8510 kind: SyntaxKind::PatternListOr,
8511 details: GreenNodeDetails::Node {
8512 children: children.iter().map(|x| x.id()).collect(),
8513 width,
8514 },
8515 })
8516 .intern(db),
8517 )
8518 }
8519}
8520#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8521pub struct PatternListOrPtr(pub SyntaxStablePtrId);
8522impl TypedStablePtr for PatternListOrPtr {
8523 type SyntaxNode = PatternListOr;
8524 fn untyped(&self) -> SyntaxStablePtrId {
8525 self.0
8526 }
8527 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternListOr {
8528 PatternListOr::from_syntax_node(db, self.0.lookup(db))
8529 }
8530}
8531impl From<PatternListOrPtr> for SyntaxStablePtrId {
8532 fn from(ptr: PatternListOrPtr) -> Self {
8533 ptr.untyped()
8534 }
8535}
8536#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8537pub enum PatternListOrElementOrSeparatorGreen {
8538 Separator(TerminalOrGreen),
8539 Element(PatternGreen),
8540}
8541impl From<TerminalOrGreen> for PatternListOrElementOrSeparatorGreen {
8542 fn from(value: TerminalOrGreen) -> Self {
8543 PatternListOrElementOrSeparatorGreen::Separator(value)
8544 }
8545}
8546impl From<PatternGreen> for PatternListOrElementOrSeparatorGreen {
8547 fn from(value: PatternGreen) -> Self {
8548 PatternListOrElementOrSeparatorGreen::Element(value)
8549 }
8550}
8551impl PatternListOrElementOrSeparatorGreen {
8552 fn id(&self) -> GreenId {
8553 match self {
8554 PatternListOrElementOrSeparatorGreen::Separator(green) => green.0,
8555 PatternListOrElementOrSeparatorGreen::Element(green) => green.0,
8556 }
8557 }
8558}
8559#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8560pub struct PatternListOrGreen(pub GreenId);
8561impl TypedSyntaxNode for PatternListOr {
8562 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternListOr);
8563 type StablePtr = PatternListOrPtr;
8564 type Green = PatternListOrGreen;
8565 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8566 PatternListOrGreen(
8567 Arc::new(GreenNode {
8568 kind: SyntaxKind::PatternListOr,
8569 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8570 })
8571 .intern(db),
8572 )
8573 }
8574 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8575 Self(ElementList::new(node))
8576 }
8577 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8578 if node.kind(db) == SyntaxKind::PatternListOr {
8579 Some(Self(ElementList::new(node)))
8580 } else {
8581 None
8582 }
8583 }
8584 fn as_syntax_node(&self) -> SyntaxNode {
8585 self.node.clone()
8586 }
8587 fn stable_ptr(&self) -> Self::StablePtr {
8588 PatternListOrPtr(self.node.0.stable_ptr)
8589 }
8590}
8591impl From<&PatternListOr> for SyntaxStablePtrId {
8592 fn from(node: &PatternListOr) -> Self {
8593 node.stable_ptr().untyped()
8594 }
8595}
8596#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8597pub enum PatternStructParam {
8598 Single(PatternIdentifier),
8599 WithExpr(PatternStructParamWithExpr),
8600 Tail(TerminalDotDot),
8601}
8602#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8603pub struct PatternStructParamPtr(pub SyntaxStablePtrId);
8604impl TypedStablePtr for PatternStructParamPtr {
8605 type SyntaxNode = PatternStructParam;
8606 fn untyped(&self) -> SyntaxStablePtrId {
8607 self.0
8608 }
8609 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParam {
8610 PatternStructParam::from_syntax_node(db, self.0.lookup(db))
8611 }
8612}
8613impl From<PatternStructParamPtr> for SyntaxStablePtrId {
8614 fn from(ptr: PatternStructParamPtr) -> Self {
8615 ptr.untyped()
8616 }
8617}
8618impl From<PatternIdentifierPtr> for PatternStructParamPtr {
8619 fn from(value: PatternIdentifierPtr) -> Self {
8620 Self(value.0)
8621 }
8622}
8623impl From<PatternStructParamWithExprPtr> for PatternStructParamPtr {
8624 fn from(value: PatternStructParamWithExprPtr) -> Self {
8625 Self(value.0)
8626 }
8627}
8628impl From<TerminalDotDotPtr> for PatternStructParamPtr {
8629 fn from(value: TerminalDotDotPtr) -> Self {
8630 Self(value.0)
8631 }
8632}
8633impl From<PatternIdentifierGreen> for PatternStructParamGreen {
8634 fn from(value: PatternIdentifierGreen) -> Self {
8635 Self(value.0)
8636 }
8637}
8638impl From<PatternStructParamWithExprGreen> for PatternStructParamGreen {
8639 fn from(value: PatternStructParamWithExprGreen) -> Self {
8640 Self(value.0)
8641 }
8642}
8643impl From<TerminalDotDotGreen> for PatternStructParamGreen {
8644 fn from(value: TerminalDotDotGreen) -> Self {
8645 Self(value.0)
8646 }
8647}
8648#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8649pub struct PatternStructParamGreen(pub GreenId);
8650impl TypedSyntaxNode for PatternStructParam {
8651 const OPTIONAL_KIND: Option<SyntaxKind> = None;
8652 type StablePtr = PatternStructParamPtr;
8653 type Green = PatternStructParamGreen;
8654 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8655 panic!("No missing variant.");
8656 }
8657 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8658 let kind = node.kind(db);
8659 match kind {
8660 SyntaxKind::PatternIdentifier => {
8661 PatternStructParam::Single(PatternIdentifier::from_syntax_node(db, node))
8662 }
8663 SyntaxKind::PatternStructParamWithExpr => {
8664 PatternStructParam::WithExpr(PatternStructParamWithExpr::from_syntax_node(db, node))
8665 }
8666 SyntaxKind::TerminalDotDot => {
8667 PatternStructParam::Tail(TerminalDotDot::from_syntax_node(db, node))
8668 }
8669 _ => panic!(
8670 "Unexpected syntax kind {:?} when constructing {}.",
8671 kind, "PatternStructParam"
8672 ),
8673 }
8674 }
8675 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8676 let kind = node.kind(db);
8677 match kind {
8678 SyntaxKind::PatternIdentifier => {
8679 Some(PatternStructParam::Single(PatternIdentifier::from_syntax_node(db, node)))
8680 }
8681 SyntaxKind::PatternStructParamWithExpr => Some(PatternStructParam::WithExpr(
8682 PatternStructParamWithExpr::from_syntax_node(db, node),
8683 )),
8684 SyntaxKind::TerminalDotDot => {
8685 Some(PatternStructParam::Tail(TerminalDotDot::from_syntax_node(db, node)))
8686 }
8687 _ => None,
8688 }
8689 }
8690 fn as_syntax_node(&self) -> SyntaxNode {
8691 match self {
8692 PatternStructParam::Single(x) => x.as_syntax_node(),
8693 PatternStructParam::WithExpr(x) => x.as_syntax_node(),
8694 PatternStructParam::Tail(x) => x.as_syntax_node(),
8695 }
8696 }
8697 fn stable_ptr(&self) -> Self::StablePtr {
8698 PatternStructParamPtr(self.as_syntax_node().0.stable_ptr)
8699 }
8700}
8701impl From<&PatternStructParam> for SyntaxStablePtrId {
8702 fn from(node: &PatternStructParam) -> Self {
8703 node.stable_ptr().untyped()
8704 }
8705}
8706impl PatternStructParam {
8707 pub fn is_variant(kind: SyntaxKind) -> bool {
8709 matches!(
8710 kind,
8711 SyntaxKind::PatternIdentifier
8712 | SyntaxKind::PatternStructParamWithExpr
8713 | SyntaxKind::TerminalDotDot
8714 )
8715 }
8716}
8717#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8718pub struct PatternStructParamWithExpr {
8719 node: SyntaxNode,
8720 children: Arc<[SyntaxNode]>,
8721}
8722impl PatternStructParamWithExpr {
8723 pub const INDEX_MODIFIERS: usize = 0;
8724 pub const INDEX_NAME: usize = 1;
8725 pub const INDEX_COLON: usize = 2;
8726 pub const INDEX_PATTERN: usize = 3;
8727 pub fn new_green(
8728 db: &dyn SyntaxGroup,
8729 modifiers: ModifierListGreen,
8730 name: TerminalIdentifierGreen,
8731 colon: TerminalColonGreen,
8732 pattern: PatternGreen,
8733 ) -> PatternStructParamWithExprGreen {
8734 let children: Vec<GreenId> = vec![modifiers.0, name.0, colon.0, pattern.0];
8735 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8736 PatternStructParamWithExprGreen(
8737 Arc::new(GreenNode {
8738 kind: SyntaxKind::PatternStructParamWithExpr,
8739 details: GreenNodeDetails::Node { children, width },
8740 })
8741 .intern(db),
8742 )
8743 }
8744}
8745impl PatternStructParamWithExpr {
8746 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
8747 ModifierList::from_syntax_node(db, self.children[0].clone())
8748 }
8749 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
8750 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
8751 }
8752 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
8753 TerminalColon::from_syntax_node(db, self.children[2].clone())
8754 }
8755 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
8756 Pattern::from_syntax_node(db, self.children[3].clone())
8757 }
8758}
8759#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8760pub struct PatternStructParamWithExprPtr(pub SyntaxStablePtrId);
8761impl PatternStructParamWithExprPtr {}
8762impl TypedStablePtr for PatternStructParamWithExprPtr {
8763 type SyntaxNode = PatternStructParamWithExpr;
8764 fn untyped(&self) -> SyntaxStablePtrId {
8765 self.0
8766 }
8767 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParamWithExpr {
8768 PatternStructParamWithExpr::from_syntax_node(db, self.0.lookup(db))
8769 }
8770}
8771impl From<PatternStructParamWithExprPtr> for SyntaxStablePtrId {
8772 fn from(ptr: PatternStructParamWithExprPtr) -> Self {
8773 ptr.untyped()
8774 }
8775}
8776#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8777pub struct PatternStructParamWithExprGreen(pub GreenId);
8778impl TypedSyntaxNode for PatternStructParamWithExpr {
8779 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStructParamWithExpr);
8780 type StablePtr = PatternStructParamWithExprPtr;
8781 type Green = PatternStructParamWithExprGreen;
8782 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8783 PatternStructParamWithExprGreen(
8784 Arc::new(GreenNode {
8785 kind: SyntaxKind::PatternStructParamWithExpr,
8786 details: GreenNodeDetails::Node {
8787 children: vec![
8788 ModifierList::missing(db).0,
8789 TerminalIdentifier::missing(db).0,
8790 TerminalColon::missing(db).0,
8791 Pattern::missing(db).0,
8792 ],
8793 width: TextWidth::default(),
8794 },
8795 })
8796 .intern(db),
8797 )
8798 }
8799 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8800 let kind = node.kind(db);
8801 assert_eq!(
8802 kind,
8803 SyntaxKind::PatternStructParamWithExpr,
8804 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8805 kind,
8806 SyntaxKind::PatternStructParamWithExpr
8807 );
8808 let children = db.get_children(node.clone());
8809 Self { node, children }
8810 }
8811 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8812 let kind = node.kind(db);
8813 if kind == SyntaxKind::PatternStructParamWithExpr {
8814 Some(Self::from_syntax_node(db, node))
8815 } else {
8816 None
8817 }
8818 }
8819 fn as_syntax_node(&self) -> SyntaxNode {
8820 self.node.clone()
8821 }
8822 fn stable_ptr(&self) -> Self::StablePtr {
8823 PatternStructParamWithExprPtr(self.node.0.stable_ptr)
8824 }
8825}
8826impl From<&PatternStructParamWithExpr> for SyntaxStablePtrId {
8827 fn from(node: &PatternStructParamWithExpr) -> Self {
8828 node.stable_ptr().untyped()
8829 }
8830}
8831#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8832pub struct PatternEnum {
8833 node: SyntaxNode,
8834 children: Arc<[SyntaxNode]>,
8835}
8836impl PatternEnum {
8837 pub const INDEX_PATH: usize = 0;
8838 pub const INDEX_PATTERN: usize = 1;
8839 pub fn new_green(
8840 db: &dyn SyntaxGroup,
8841 path: ExprPathGreen,
8842 pattern: OptionPatternEnumInnerPatternGreen,
8843 ) -> PatternEnumGreen {
8844 let children: Vec<GreenId> = vec![path.0, pattern.0];
8845 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8846 PatternEnumGreen(
8847 Arc::new(GreenNode {
8848 kind: SyntaxKind::PatternEnum,
8849 details: GreenNodeDetails::Node { children, width },
8850 })
8851 .intern(db),
8852 )
8853 }
8854}
8855impl PatternEnum {
8856 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
8857 ExprPath::from_syntax_node(db, self.children[0].clone())
8858 }
8859 pub fn pattern(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPattern {
8860 OptionPatternEnumInnerPattern::from_syntax_node(db, self.children[1].clone())
8861 }
8862}
8863#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8864pub struct PatternEnumPtr(pub SyntaxStablePtrId);
8865impl PatternEnumPtr {}
8866impl TypedStablePtr for PatternEnumPtr {
8867 type SyntaxNode = PatternEnum;
8868 fn untyped(&self) -> SyntaxStablePtrId {
8869 self.0
8870 }
8871 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternEnum {
8872 PatternEnum::from_syntax_node(db, self.0.lookup(db))
8873 }
8874}
8875impl From<PatternEnumPtr> for SyntaxStablePtrId {
8876 fn from(ptr: PatternEnumPtr) -> Self {
8877 ptr.untyped()
8878 }
8879}
8880#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8881pub struct PatternEnumGreen(pub GreenId);
8882impl TypedSyntaxNode for PatternEnum {
8883 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternEnum);
8884 type StablePtr = PatternEnumPtr;
8885 type Green = PatternEnumGreen;
8886 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8887 PatternEnumGreen(
8888 Arc::new(GreenNode {
8889 kind: SyntaxKind::PatternEnum,
8890 details: GreenNodeDetails::Node {
8891 children: vec![
8892 ExprPath::missing(db).0,
8893 OptionPatternEnumInnerPattern::missing(db).0,
8894 ],
8895 width: TextWidth::default(),
8896 },
8897 })
8898 .intern(db),
8899 )
8900 }
8901 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8902 let kind = node.kind(db);
8903 assert_eq!(
8904 kind,
8905 SyntaxKind::PatternEnum,
8906 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8907 kind,
8908 SyntaxKind::PatternEnum
8909 );
8910 let children = db.get_children(node.clone());
8911 Self { node, children }
8912 }
8913 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
8914 let kind = node.kind(db);
8915 if kind == SyntaxKind::PatternEnum { Some(Self::from_syntax_node(db, node)) } else { None }
8916 }
8917 fn as_syntax_node(&self) -> SyntaxNode {
8918 self.node.clone()
8919 }
8920 fn stable_ptr(&self) -> Self::StablePtr {
8921 PatternEnumPtr(self.node.0.stable_ptr)
8922 }
8923}
8924impl From<&PatternEnum> for SyntaxStablePtrId {
8925 fn from(node: &PatternEnum) -> Self {
8926 node.stable_ptr().untyped()
8927 }
8928}
8929#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8930pub struct PatternEnumInnerPattern {
8931 node: SyntaxNode,
8932 children: Arc<[SyntaxNode]>,
8933}
8934impl PatternEnumInnerPattern {
8935 pub const INDEX_LPAREN: usize = 0;
8936 pub const INDEX_PATTERN: usize = 1;
8937 pub const INDEX_RPAREN: usize = 2;
8938 pub fn new_green(
8939 db: &dyn SyntaxGroup,
8940 lparen: TerminalLParenGreen,
8941 pattern: PatternGreen,
8942 rparen: TerminalRParenGreen,
8943 ) -> PatternEnumInnerPatternGreen {
8944 let children: Vec<GreenId> = vec![lparen.0, pattern.0, rparen.0];
8945 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8946 PatternEnumInnerPatternGreen(
8947 Arc::new(GreenNode {
8948 kind: SyntaxKind::PatternEnumInnerPattern,
8949 details: GreenNodeDetails::Node { children, width },
8950 })
8951 .intern(db),
8952 )
8953 }
8954}
8955impl PatternEnumInnerPattern {
8956 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
8957 TerminalLParen::from_syntax_node(db, self.children[0].clone())
8958 }
8959 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
8960 Pattern::from_syntax_node(db, self.children[1].clone())
8961 }
8962 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
8963 TerminalRParen::from_syntax_node(db, self.children[2].clone())
8964 }
8965}
8966#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8967pub struct PatternEnumInnerPatternPtr(pub SyntaxStablePtrId);
8968impl PatternEnumInnerPatternPtr {}
8969impl TypedStablePtr for PatternEnumInnerPatternPtr {
8970 type SyntaxNode = PatternEnumInnerPattern;
8971 fn untyped(&self) -> SyntaxStablePtrId {
8972 self.0
8973 }
8974 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternEnumInnerPattern {
8975 PatternEnumInnerPattern::from_syntax_node(db, self.0.lookup(db))
8976 }
8977}
8978impl From<PatternEnumInnerPatternPtr> for SyntaxStablePtrId {
8979 fn from(ptr: PatternEnumInnerPatternPtr) -> Self {
8980 ptr.untyped()
8981 }
8982}
8983#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8984pub struct PatternEnumInnerPatternGreen(pub GreenId);
8985impl TypedSyntaxNode for PatternEnumInnerPattern {
8986 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternEnumInnerPattern);
8987 type StablePtr = PatternEnumInnerPatternPtr;
8988 type Green = PatternEnumInnerPatternGreen;
8989 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8990 PatternEnumInnerPatternGreen(
8991 Arc::new(GreenNode {
8992 kind: SyntaxKind::PatternEnumInnerPattern,
8993 details: GreenNodeDetails::Node {
8994 children: vec![
8995 TerminalLParen::missing(db).0,
8996 Pattern::missing(db).0,
8997 TerminalRParen::missing(db).0,
8998 ],
8999 width: TextWidth::default(),
9000 },
9001 })
9002 .intern(db),
9003 )
9004 }
9005 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9006 let kind = node.kind(db);
9007 assert_eq!(
9008 kind,
9009 SyntaxKind::PatternEnumInnerPattern,
9010 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9011 kind,
9012 SyntaxKind::PatternEnumInnerPattern
9013 );
9014 let children = db.get_children(node.clone());
9015 Self { node, children }
9016 }
9017 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9018 let kind = node.kind(db);
9019 if kind == SyntaxKind::PatternEnumInnerPattern {
9020 Some(Self::from_syntax_node(db, node))
9021 } else {
9022 None
9023 }
9024 }
9025 fn as_syntax_node(&self) -> SyntaxNode {
9026 self.node.clone()
9027 }
9028 fn stable_ptr(&self) -> Self::StablePtr {
9029 PatternEnumInnerPatternPtr(self.node.0.stable_ptr)
9030 }
9031}
9032impl From<&PatternEnumInnerPattern> for SyntaxStablePtrId {
9033 fn from(node: &PatternEnumInnerPattern) -> Self {
9034 node.stable_ptr().untyped()
9035 }
9036}
9037#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9038pub enum OptionPatternEnumInnerPattern {
9039 Empty(OptionPatternEnumInnerPatternEmpty),
9040 PatternEnumInnerPattern(PatternEnumInnerPattern),
9041}
9042#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9043pub struct OptionPatternEnumInnerPatternPtr(pub SyntaxStablePtrId);
9044impl TypedStablePtr for OptionPatternEnumInnerPatternPtr {
9045 type SyntaxNode = OptionPatternEnumInnerPattern;
9046 fn untyped(&self) -> SyntaxStablePtrId {
9047 self.0
9048 }
9049 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPattern {
9050 OptionPatternEnumInnerPattern::from_syntax_node(db, self.0.lookup(db))
9051 }
9052}
9053impl From<OptionPatternEnumInnerPatternPtr> for SyntaxStablePtrId {
9054 fn from(ptr: OptionPatternEnumInnerPatternPtr) -> Self {
9055 ptr.untyped()
9056 }
9057}
9058impl From<OptionPatternEnumInnerPatternEmptyPtr> for OptionPatternEnumInnerPatternPtr {
9059 fn from(value: OptionPatternEnumInnerPatternEmptyPtr) -> Self {
9060 Self(value.0)
9061 }
9062}
9063impl From<PatternEnumInnerPatternPtr> for OptionPatternEnumInnerPatternPtr {
9064 fn from(value: PatternEnumInnerPatternPtr) -> Self {
9065 Self(value.0)
9066 }
9067}
9068impl From<OptionPatternEnumInnerPatternEmptyGreen> for OptionPatternEnumInnerPatternGreen {
9069 fn from(value: OptionPatternEnumInnerPatternEmptyGreen) -> Self {
9070 Self(value.0)
9071 }
9072}
9073impl From<PatternEnumInnerPatternGreen> for OptionPatternEnumInnerPatternGreen {
9074 fn from(value: PatternEnumInnerPatternGreen) -> Self {
9075 Self(value.0)
9076 }
9077}
9078#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9079pub struct OptionPatternEnumInnerPatternGreen(pub GreenId);
9080impl TypedSyntaxNode for OptionPatternEnumInnerPattern {
9081 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9082 type StablePtr = OptionPatternEnumInnerPatternPtr;
9083 type Green = OptionPatternEnumInnerPatternGreen;
9084 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9085 panic!("No missing variant.");
9086 }
9087 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9088 let kind = node.kind(db);
9089 match kind {
9090 SyntaxKind::OptionPatternEnumInnerPatternEmpty => OptionPatternEnumInnerPattern::Empty(
9091 OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, node),
9092 ),
9093 SyntaxKind::PatternEnumInnerPattern => {
9094 OptionPatternEnumInnerPattern::PatternEnumInnerPattern(
9095 PatternEnumInnerPattern::from_syntax_node(db, node),
9096 )
9097 }
9098 _ => panic!(
9099 "Unexpected syntax kind {:?} when constructing {}.",
9100 kind, "OptionPatternEnumInnerPattern"
9101 ),
9102 }
9103 }
9104 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9105 let kind = node.kind(db);
9106 match kind {
9107 SyntaxKind::OptionPatternEnumInnerPatternEmpty => {
9108 Some(OptionPatternEnumInnerPattern::Empty(
9109 OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, node),
9110 ))
9111 }
9112 SyntaxKind::PatternEnumInnerPattern => {
9113 Some(OptionPatternEnumInnerPattern::PatternEnumInnerPattern(
9114 PatternEnumInnerPattern::from_syntax_node(db, node),
9115 ))
9116 }
9117 _ => None,
9118 }
9119 }
9120 fn as_syntax_node(&self) -> SyntaxNode {
9121 match self {
9122 OptionPatternEnumInnerPattern::Empty(x) => x.as_syntax_node(),
9123 OptionPatternEnumInnerPattern::PatternEnumInnerPattern(x) => x.as_syntax_node(),
9124 }
9125 }
9126 fn stable_ptr(&self) -> Self::StablePtr {
9127 OptionPatternEnumInnerPatternPtr(self.as_syntax_node().0.stable_ptr)
9128 }
9129}
9130impl From<&OptionPatternEnumInnerPattern> for SyntaxStablePtrId {
9131 fn from(node: &OptionPatternEnumInnerPattern) -> Self {
9132 node.stable_ptr().untyped()
9133 }
9134}
9135impl OptionPatternEnumInnerPattern {
9136 pub fn is_variant(kind: SyntaxKind) -> bool {
9138 matches!(
9139 kind,
9140 SyntaxKind::OptionPatternEnumInnerPatternEmpty | SyntaxKind::PatternEnumInnerPattern
9141 )
9142 }
9143}
9144#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9145pub struct OptionPatternEnumInnerPatternEmpty {
9146 node: SyntaxNode,
9147 children: Arc<[SyntaxNode]>,
9148}
9149impl OptionPatternEnumInnerPatternEmpty {
9150 pub fn new_green(db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPatternEmptyGreen {
9151 let children: Vec<GreenId> = vec![];
9152 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9153 OptionPatternEnumInnerPatternEmptyGreen(
9154 Arc::new(GreenNode {
9155 kind: SyntaxKind::OptionPatternEnumInnerPatternEmpty,
9156 details: GreenNodeDetails::Node { children, width },
9157 })
9158 .intern(db),
9159 )
9160 }
9161}
9162impl OptionPatternEnumInnerPatternEmpty {}
9163#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9164pub struct OptionPatternEnumInnerPatternEmptyPtr(pub SyntaxStablePtrId);
9165impl OptionPatternEnumInnerPatternEmptyPtr {}
9166impl TypedStablePtr for OptionPatternEnumInnerPatternEmptyPtr {
9167 type SyntaxNode = OptionPatternEnumInnerPatternEmpty;
9168 fn untyped(&self) -> SyntaxStablePtrId {
9169 self.0
9170 }
9171 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPatternEmpty {
9172 OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, self.0.lookup(db))
9173 }
9174}
9175impl From<OptionPatternEnumInnerPatternEmptyPtr> for SyntaxStablePtrId {
9176 fn from(ptr: OptionPatternEnumInnerPatternEmptyPtr) -> Self {
9177 ptr.untyped()
9178 }
9179}
9180#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9181pub struct OptionPatternEnumInnerPatternEmptyGreen(pub GreenId);
9182impl TypedSyntaxNode for OptionPatternEnumInnerPatternEmpty {
9183 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionPatternEnumInnerPatternEmpty);
9184 type StablePtr = OptionPatternEnumInnerPatternEmptyPtr;
9185 type Green = OptionPatternEnumInnerPatternEmptyGreen;
9186 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9187 OptionPatternEnumInnerPatternEmptyGreen(
9188 Arc::new(GreenNode {
9189 kind: SyntaxKind::OptionPatternEnumInnerPatternEmpty,
9190 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9191 })
9192 .intern(db),
9193 )
9194 }
9195 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9196 let kind = node.kind(db);
9197 assert_eq!(
9198 kind,
9199 SyntaxKind::OptionPatternEnumInnerPatternEmpty,
9200 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9201 kind,
9202 SyntaxKind::OptionPatternEnumInnerPatternEmpty
9203 );
9204 let children = db.get_children(node.clone());
9205 Self { node, children }
9206 }
9207 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9208 let kind = node.kind(db);
9209 if kind == SyntaxKind::OptionPatternEnumInnerPatternEmpty {
9210 Some(Self::from_syntax_node(db, node))
9211 } else {
9212 None
9213 }
9214 }
9215 fn as_syntax_node(&self) -> SyntaxNode {
9216 self.node.clone()
9217 }
9218 fn stable_ptr(&self) -> Self::StablePtr {
9219 OptionPatternEnumInnerPatternEmptyPtr(self.node.0.stable_ptr)
9220 }
9221}
9222impl From<&OptionPatternEnumInnerPatternEmpty> for SyntaxStablePtrId {
9223 fn from(node: &OptionPatternEnumInnerPatternEmpty) -> Self {
9224 node.stable_ptr().untyped()
9225 }
9226}
9227#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9228pub struct TypeClause {
9229 node: SyntaxNode,
9230 children: Arc<[SyntaxNode]>,
9231}
9232impl TypeClause {
9233 pub const INDEX_COLON: usize = 0;
9234 pub const INDEX_TY: usize = 1;
9235 pub fn new_green(
9236 db: &dyn SyntaxGroup,
9237 colon: TerminalColonGreen,
9238 ty: ExprGreen,
9239 ) -> TypeClauseGreen {
9240 let children: Vec<GreenId> = vec![colon.0, ty.0];
9241 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9242 TypeClauseGreen(
9243 Arc::new(GreenNode {
9244 kind: SyntaxKind::TypeClause,
9245 details: GreenNodeDetails::Node { children, width },
9246 })
9247 .intern(db),
9248 )
9249 }
9250}
9251impl TypeClause {
9252 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
9253 TerminalColon::from_syntax_node(db, self.children[0].clone())
9254 }
9255 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
9256 Expr::from_syntax_node(db, self.children[1].clone())
9257 }
9258}
9259#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9260pub struct TypeClausePtr(pub SyntaxStablePtrId);
9261impl TypeClausePtr {}
9262impl TypedStablePtr for TypeClausePtr {
9263 type SyntaxNode = TypeClause;
9264 fn untyped(&self) -> SyntaxStablePtrId {
9265 self.0
9266 }
9267 fn lookup(&self, db: &dyn SyntaxGroup) -> TypeClause {
9268 TypeClause::from_syntax_node(db, self.0.lookup(db))
9269 }
9270}
9271impl From<TypeClausePtr> for SyntaxStablePtrId {
9272 fn from(ptr: TypeClausePtr) -> Self {
9273 ptr.untyped()
9274 }
9275}
9276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9277pub struct TypeClauseGreen(pub GreenId);
9278impl TypedSyntaxNode for TypeClause {
9279 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TypeClause);
9280 type StablePtr = TypeClausePtr;
9281 type Green = TypeClauseGreen;
9282 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9283 TypeClauseGreen(
9284 Arc::new(GreenNode {
9285 kind: SyntaxKind::TypeClause,
9286 details: GreenNodeDetails::Node {
9287 children: vec![TerminalColon::missing(db).0, Expr::missing(db).0],
9288 width: TextWidth::default(),
9289 },
9290 })
9291 .intern(db),
9292 )
9293 }
9294 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9295 let kind = node.kind(db);
9296 assert_eq!(
9297 kind,
9298 SyntaxKind::TypeClause,
9299 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9300 kind,
9301 SyntaxKind::TypeClause
9302 );
9303 let children = db.get_children(node.clone());
9304 Self { node, children }
9305 }
9306 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9307 let kind = node.kind(db);
9308 if kind == SyntaxKind::TypeClause { Some(Self::from_syntax_node(db, node)) } else { None }
9309 }
9310 fn as_syntax_node(&self) -> SyntaxNode {
9311 self.node.clone()
9312 }
9313 fn stable_ptr(&self) -> Self::StablePtr {
9314 TypeClausePtr(self.node.0.stable_ptr)
9315 }
9316}
9317impl From<&TypeClause> for SyntaxStablePtrId {
9318 fn from(node: &TypeClause) -> Self {
9319 node.stable_ptr().untyped()
9320 }
9321}
9322#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9323pub enum OptionTypeClause {
9324 Empty(OptionTypeClauseEmpty),
9325 TypeClause(TypeClause),
9326}
9327#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9328pub struct OptionTypeClausePtr(pub SyntaxStablePtrId);
9329impl TypedStablePtr for OptionTypeClausePtr {
9330 type SyntaxNode = OptionTypeClause;
9331 fn untyped(&self) -> SyntaxStablePtrId {
9332 self.0
9333 }
9334 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
9335 OptionTypeClause::from_syntax_node(db, self.0.lookup(db))
9336 }
9337}
9338impl From<OptionTypeClausePtr> for SyntaxStablePtrId {
9339 fn from(ptr: OptionTypeClausePtr) -> Self {
9340 ptr.untyped()
9341 }
9342}
9343impl From<OptionTypeClauseEmptyPtr> for OptionTypeClausePtr {
9344 fn from(value: OptionTypeClauseEmptyPtr) -> Self {
9345 Self(value.0)
9346 }
9347}
9348impl From<TypeClausePtr> for OptionTypeClausePtr {
9349 fn from(value: TypeClausePtr) -> Self {
9350 Self(value.0)
9351 }
9352}
9353impl From<OptionTypeClauseEmptyGreen> for OptionTypeClauseGreen {
9354 fn from(value: OptionTypeClauseEmptyGreen) -> Self {
9355 Self(value.0)
9356 }
9357}
9358impl From<TypeClauseGreen> for OptionTypeClauseGreen {
9359 fn from(value: TypeClauseGreen) -> Self {
9360 Self(value.0)
9361 }
9362}
9363#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9364pub struct OptionTypeClauseGreen(pub GreenId);
9365impl TypedSyntaxNode for OptionTypeClause {
9366 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9367 type StablePtr = OptionTypeClausePtr;
9368 type Green = OptionTypeClauseGreen;
9369 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9370 panic!("No missing variant.");
9371 }
9372 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9373 let kind = node.kind(db);
9374 match kind {
9375 SyntaxKind::OptionTypeClauseEmpty => {
9376 OptionTypeClause::Empty(OptionTypeClauseEmpty::from_syntax_node(db, node))
9377 }
9378 SyntaxKind::TypeClause => {
9379 OptionTypeClause::TypeClause(TypeClause::from_syntax_node(db, node))
9380 }
9381 _ => panic!(
9382 "Unexpected syntax kind {:?} when constructing {}.",
9383 kind, "OptionTypeClause"
9384 ),
9385 }
9386 }
9387 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9388 let kind = node.kind(db);
9389 match kind {
9390 SyntaxKind::OptionTypeClauseEmpty => {
9391 Some(OptionTypeClause::Empty(OptionTypeClauseEmpty::from_syntax_node(db, node)))
9392 }
9393 SyntaxKind::TypeClause => {
9394 Some(OptionTypeClause::TypeClause(TypeClause::from_syntax_node(db, node)))
9395 }
9396 _ => None,
9397 }
9398 }
9399 fn as_syntax_node(&self) -> SyntaxNode {
9400 match self {
9401 OptionTypeClause::Empty(x) => x.as_syntax_node(),
9402 OptionTypeClause::TypeClause(x) => x.as_syntax_node(),
9403 }
9404 }
9405 fn stable_ptr(&self) -> Self::StablePtr {
9406 OptionTypeClausePtr(self.as_syntax_node().0.stable_ptr)
9407 }
9408}
9409impl From<&OptionTypeClause> for SyntaxStablePtrId {
9410 fn from(node: &OptionTypeClause) -> Self {
9411 node.stable_ptr().untyped()
9412 }
9413}
9414impl OptionTypeClause {
9415 pub fn is_variant(kind: SyntaxKind) -> bool {
9417 matches!(kind, SyntaxKind::OptionTypeClauseEmpty | SyntaxKind::TypeClause)
9418 }
9419}
9420#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9421pub struct OptionTypeClauseEmpty {
9422 node: SyntaxNode,
9423 children: Arc<[SyntaxNode]>,
9424}
9425impl OptionTypeClauseEmpty {
9426 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTypeClauseEmptyGreen {
9427 let children: Vec<GreenId> = vec![];
9428 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9429 OptionTypeClauseEmptyGreen(
9430 Arc::new(GreenNode {
9431 kind: SyntaxKind::OptionTypeClauseEmpty,
9432 details: GreenNodeDetails::Node { children, width },
9433 })
9434 .intern(db),
9435 )
9436 }
9437}
9438impl OptionTypeClauseEmpty {}
9439#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9440pub struct OptionTypeClauseEmptyPtr(pub SyntaxStablePtrId);
9441impl OptionTypeClauseEmptyPtr {}
9442impl TypedStablePtr for OptionTypeClauseEmptyPtr {
9443 type SyntaxNode = OptionTypeClauseEmpty;
9444 fn untyped(&self) -> SyntaxStablePtrId {
9445 self.0
9446 }
9447 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTypeClauseEmpty {
9448 OptionTypeClauseEmpty::from_syntax_node(db, self.0.lookup(db))
9449 }
9450}
9451impl From<OptionTypeClauseEmptyPtr> for SyntaxStablePtrId {
9452 fn from(ptr: OptionTypeClauseEmptyPtr) -> Self {
9453 ptr.untyped()
9454 }
9455}
9456#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9457pub struct OptionTypeClauseEmptyGreen(pub GreenId);
9458impl TypedSyntaxNode for OptionTypeClauseEmpty {
9459 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTypeClauseEmpty);
9460 type StablePtr = OptionTypeClauseEmptyPtr;
9461 type Green = OptionTypeClauseEmptyGreen;
9462 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9463 OptionTypeClauseEmptyGreen(
9464 Arc::new(GreenNode {
9465 kind: SyntaxKind::OptionTypeClauseEmpty,
9466 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9467 })
9468 .intern(db),
9469 )
9470 }
9471 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9472 let kind = node.kind(db);
9473 assert_eq!(
9474 kind,
9475 SyntaxKind::OptionTypeClauseEmpty,
9476 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9477 kind,
9478 SyntaxKind::OptionTypeClauseEmpty
9479 );
9480 let children = db.get_children(node.clone());
9481 Self { node, children }
9482 }
9483 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9484 let kind = node.kind(db);
9485 if kind == SyntaxKind::OptionTypeClauseEmpty {
9486 Some(Self::from_syntax_node(db, node))
9487 } else {
9488 None
9489 }
9490 }
9491 fn as_syntax_node(&self) -> SyntaxNode {
9492 self.node.clone()
9493 }
9494 fn stable_ptr(&self) -> Self::StablePtr {
9495 OptionTypeClauseEmptyPtr(self.node.0.stable_ptr)
9496 }
9497}
9498impl From<&OptionTypeClauseEmpty> for SyntaxStablePtrId {
9499 fn from(node: &OptionTypeClauseEmpty) -> Self {
9500 node.stable_ptr().untyped()
9501 }
9502}
9503#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9504pub struct ReturnTypeClause {
9505 node: SyntaxNode,
9506 children: Arc<[SyntaxNode]>,
9507}
9508impl ReturnTypeClause {
9509 pub const INDEX_ARROW: usize = 0;
9510 pub const INDEX_TY: usize = 1;
9511 pub fn new_green(
9512 db: &dyn SyntaxGroup,
9513 arrow: TerminalArrowGreen,
9514 ty: ExprGreen,
9515 ) -> ReturnTypeClauseGreen {
9516 let children: Vec<GreenId> = vec![arrow.0, ty.0];
9517 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9518 ReturnTypeClauseGreen(
9519 Arc::new(GreenNode {
9520 kind: SyntaxKind::ReturnTypeClause,
9521 details: GreenNodeDetails::Node { children, width },
9522 })
9523 .intern(db),
9524 )
9525 }
9526}
9527impl ReturnTypeClause {
9528 pub fn arrow(&self, db: &dyn SyntaxGroup) -> TerminalArrow {
9529 TerminalArrow::from_syntax_node(db, self.children[0].clone())
9530 }
9531 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
9532 Expr::from_syntax_node(db, self.children[1].clone())
9533 }
9534}
9535#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9536pub struct ReturnTypeClausePtr(pub SyntaxStablePtrId);
9537impl ReturnTypeClausePtr {}
9538impl TypedStablePtr for ReturnTypeClausePtr {
9539 type SyntaxNode = ReturnTypeClause;
9540 fn untyped(&self) -> SyntaxStablePtrId {
9541 self.0
9542 }
9543 fn lookup(&self, db: &dyn SyntaxGroup) -> ReturnTypeClause {
9544 ReturnTypeClause::from_syntax_node(db, self.0.lookup(db))
9545 }
9546}
9547impl From<ReturnTypeClausePtr> for SyntaxStablePtrId {
9548 fn from(ptr: ReturnTypeClausePtr) -> Self {
9549 ptr.untyped()
9550 }
9551}
9552#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9553pub struct ReturnTypeClauseGreen(pub GreenId);
9554impl TypedSyntaxNode for ReturnTypeClause {
9555 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ReturnTypeClause);
9556 type StablePtr = ReturnTypeClausePtr;
9557 type Green = ReturnTypeClauseGreen;
9558 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9559 ReturnTypeClauseGreen(
9560 Arc::new(GreenNode {
9561 kind: SyntaxKind::ReturnTypeClause,
9562 details: GreenNodeDetails::Node {
9563 children: vec![TerminalArrow::missing(db).0, Expr::missing(db).0],
9564 width: TextWidth::default(),
9565 },
9566 })
9567 .intern(db),
9568 )
9569 }
9570 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9571 let kind = node.kind(db);
9572 assert_eq!(
9573 kind,
9574 SyntaxKind::ReturnTypeClause,
9575 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9576 kind,
9577 SyntaxKind::ReturnTypeClause
9578 );
9579 let children = db.get_children(node.clone());
9580 Self { node, children }
9581 }
9582 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9583 let kind = node.kind(db);
9584 if kind == SyntaxKind::ReturnTypeClause {
9585 Some(Self::from_syntax_node(db, node))
9586 } else {
9587 None
9588 }
9589 }
9590 fn as_syntax_node(&self) -> SyntaxNode {
9591 self.node.clone()
9592 }
9593 fn stable_ptr(&self) -> Self::StablePtr {
9594 ReturnTypeClausePtr(self.node.0.stable_ptr)
9595 }
9596}
9597impl From<&ReturnTypeClause> for SyntaxStablePtrId {
9598 fn from(node: &ReturnTypeClause) -> Self {
9599 node.stable_ptr().untyped()
9600 }
9601}
9602#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9603pub enum OptionReturnTypeClause {
9604 Empty(OptionReturnTypeClauseEmpty),
9605 ReturnTypeClause(ReturnTypeClause),
9606}
9607#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9608pub struct OptionReturnTypeClausePtr(pub SyntaxStablePtrId);
9609impl TypedStablePtr for OptionReturnTypeClausePtr {
9610 type SyntaxNode = OptionReturnTypeClause;
9611 fn untyped(&self) -> SyntaxStablePtrId {
9612 self.0
9613 }
9614 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
9615 OptionReturnTypeClause::from_syntax_node(db, self.0.lookup(db))
9616 }
9617}
9618impl From<OptionReturnTypeClausePtr> for SyntaxStablePtrId {
9619 fn from(ptr: OptionReturnTypeClausePtr) -> Self {
9620 ptr.untyped()
9621 }
9622}
9623impl From<OptionReturnTypeClauseEmptyPtr> for OptionReturnTypeClausePtr {
9624 fn from(value: OptionReturnTypeClauseEmptyPtr) -> Self {
9625 Self(value.0)
9626 }
9627}
9628impl From<ReturnTypeClausePtr> for OptionReturnTypeClausePtr {
9629 fn from(value: ReturnTypeClausePtr) -> Self {
9630 Self(value.0)
9631 }
9632}
9633impl From<OptionReturnTypeClauseEmptyGreen> for OptionReturnTypeClauseGreen {
9634 fn from(value: OptionReturnTypeClauseEmptyGreen) -> Self {
9635 Self(value.0)
9636 }
9637}
9638impl From<ReturnTypeClauseGreen> for OptionReturnTypeClauseGreen {
9639 fn from(value: ReturnTypeClauseGreen) -> Self {
9640 Self(value.0)
9641 }
9642}
9643#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9644pub struct OptionReturnTypeClauseGreen(pub GreenId);
9645impl TypedSyntaxNode for OptionReturnTypeClause {
9646 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9647 type StablePtr = OptionReturnTypeClausePtr;
9648 type Green = OptionReturnTypeClauseGreen;
9649 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9650 panic!("No missing variant.");
9651 }
9652 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9653 let kind = node.kind(db);
9654 match kind {
9655 SyntaxKind::OptionReturnTypeClauseEmpty => OptionReturnTypeClause::Empty(
9656 OptionReturnTypeClauseEmpty::from_syntax_node(db, node),
9657 ),
9658 SyntaxKind::ReturnTypeClause => OptionReturnTypeClause::ReturnTypeClause(
9659 ReturnTypeClause::from_syntax_node(db, node),
9660 ),
9661 _ => panic!(
9662 "Unexpected syntax kind {:?} when constructing {}.",
9663 kind, "OptionReturnTypeClause"
9664 ),
9665 }
9666 }
9667 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9668 let kind = node.kind(db);
9669 match kind {
9670 SyntaxKind::OptionReturnTypeClauseEmpty => Some(OptionReturnTypeClause::Empty(
9671 OptionReturnTypeClauseEmpty::from_syntax_node(db, node),
9672 )),
9673 SyntaxKind::ReturnTypeClause => Some(OptionReturnTypeClause::ReturnTypeClause(
9674 ReturnTypeClause::from_syntax_node(db, node),
9675 )),
9676 _ => None,
9677 }
9678 }
9679 fn as_syntax_node(&self) -> SyntaxNode {
9680 match self {
9681 OptionReturnTypeClause::Empty(x) => x.as_syntax_node(),
9682 OptionReturnTypeClause::ReturnTypeClause(x) => x.as_syntax_node(),
9683 }
9684 }
9685 fn stable_ptr(&self) -> Self::StablePtr {
9686 OptionReturnTypeClausePtr(self.as_syntax_node().0.stable_ptr)
9687 }
9688}
9689impl From<&OptionReturnTypeClause> for SyntaxStablePtrId {
9690 fn from(node: &OptionReturnTypeClause) -> Self {
9691 node.stable_ptr().untyped()
9692 }
9693}
9694impl OptionReturnTypeClause {
9695 pub fn is_variant(kind: SyntaxKind) -> bool {
9697 matches!(kind, SyntaxKind::OptionReturnTypeClauseEmpty | SyntaxKind::ReturnTypeClause)
9698 }
9699}
9700#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9701pub struct OptionReturnTypeClauseEmpty {
9702 node: SyntaxNode,
9703 children: Arc<[SyntaxNode]>,
9704}
9705impl OptionReturnTypeClauseEmpty {
9706 pub fn new_green(db: &dyn SyntaxGroup) -> OptionReturnTypeClauseEmptyGreen {
9707 let children: Vec<GreenId> = vec![];
9708 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9709 OptionReturnTypeClauseEmptyGreen(
9710 Arc::new(GreenNode {
9711 kind: SyntaxKind::OptionReturnTypeClauseEmpty,
9712 details: GreenNodeDetails::Node { children, width },
9713 })
9714 .intern(db),
9715 )
9716 }
9717}
9718impl OptionReturnTypeClauseEmpty {}
9719#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9720pub struct OptionReturnTypeClauseEmptyPtr(pub SyntaxStablePtrId);
9721impl OptionReturnTypeClauseEmptyPtr {}
9722impl TypedStablePtr for OptionReturnTypeClauseEmptyPtr {
9723 type SyntaxNode = OptionReturnTypeClauseEmpty;
9724 fn untyped(&self) -> SyntaxStablePtrId {
9725 self.0
9726 }
9727 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClauseEmpty {
9728 OptionReturnTypeClauseEmpty::from_syntax_node(db, self.0.lookup(db))
9729 }
9730}
9731impl From<OptionReturnTypeClauseEmptyPtr> for SyntaxStablePtrId {
9732 fn from(ptr: OptionReturnTypeClauseEmptyPtr) -> Self {
9733 ptr.untyped()
9734 }
9735}
9736#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9737pub struct OptionReturnTypeClauseEmptyGreen(pub GreenId);
9738impl TypedSyntaxNode for OptionReturnTypeClauseEmpty {
9739 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionReturnTypeClauseEmpty);
9740 type StablePtr = OptionReturnTypeClauseEmptyPtr;
9741 type Green = OptionReturnTypeClauseEmptyGreen;
9742 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9743 OptionReturnTypeClauseEmptyGreen(
9744 Arc::new(GreenNode {
9745 kind: SyntaxKind::OptionReturnTypeClauseEmpty,
9746 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9747 })
9748 .intern(db),
9749 )
9750 }
9751 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9752 let kind = node.kind(db);
9753 assert_eq!(
9754 kind,
9755 SyntaxKind::OptionReturnTypeClauseEmpty,
9756 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9757 kind,
9758 SyntaxKind::OptionReturnTypeClauseEmpty
9759 );
9760 let children = db.get_children(node.clone());
9761 Self { node, children }
9762 }
9763 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9764 let kind = node.kind(db);
9765 if kind == SyntaxKind::OptionReturnTypeClauseEmpty {
9766 Some(Self::from_syntax_node(db, node))
9767 } else {
9768 None
9769 }
9770 }
9771 fn as_syntax_node(&self) -> SyntaxNode {
9772 self.node.clone()
9773 }
9774 fn stable_ptr(&self) -> Self::StablePtr {
9775 OptionReturnTypeClauseEmptyPtr(self.node.0.stable_ptr)
9776 }
9777}
9778impl From<&OptionReturnTypeClauseEmpty> for SyntaxStablePtrId {
9779 fn from(node: &OptionReturnTypeClauseEmpty) -> Self {
9780 node.stable_ptr().untyped()
9781 }
9782}
9783#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9784pub enum Statement {
9785 Let(StatementLet),
9786 Expr(StatementExpr),
9787 Continue(StatementContinue),
9788 Return(StatementReturn),
9789 Break(StatementBreak),
9790 Item(StatementItem),
9791 Missing(StatementMissing),
9792}
9793#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9794pub struct StatementPtr(pub SyntaxStablePtrId);
9795impl TypedStablePtr for StatementPtr {
9796 type SyntaxNode = Statement;
9797 fn untyped(&self) -> SyntaxStablePtrId {
9798 self.0
9799 }
9800 fn lookup(&self, db: &dyn SyntaxGroup) -> Statement {
9801 Statement::from_syntax_node(db, self.0.lookup(db))
9802 }
9803}
9804impl From<StatementPtr> for SyntaxStablePtrId {
9805 fn from(ptr: StatementPtr) -> Self {
9806 ptr.untyped()
9807 }
9808}
9809impl From<StatementLetPtr> for StatementPtr {
9810 fn from(value: StatementLetPtr) -> Self {
9811 Self(value.0)
9812 }
9813}
9814impl From<StatementExprPtr> for StatementPtr {
9815 fn from(value: StatementExprPtr) -> Self {
9816 Self(value.0)
9817 }
9818}
9819impl From<StatementContinuePtr> for StatementPtr {
9820 fn from(value: StatementContinuePtr) -> Self {
9821 Self(value.0)
9822 }
9823}
9824impl From<StatementReturnPtr> for StatementPtr {
9825 fn from(value: StatementReturnPtr) -> Self {
9826 Self(value.0)
9827 }
9828}
9829impl From<StatementBreakPtr> for StatementPtr {
9830 fn from(value: StatementBreakPtr) -> Self {
9831 Self(value.0)
9832 }
9833}
9834impl From<StatementItemPtr> for StatementPtr {
9835 fn from(value: StatementItemPtr) -> Self {
9836 Self(value.0)
9837 }
9838}
9839impl From<StatementMissingPtr> for StatementPtr {
9840 fn from(value: StatementMissingPtr) -> Self {
9841 Self(value.0)
9842 }
9843}
9844impl From<StatementLetGreen> for StatementGreen {
9845 fn from(value: StatementLetGreen) -> Self {
9846 Self(value.0)
9847 }
9848}
9849impl From<StatementExprGreen> for StatementGreen {
9850 fn from(value: StatementExprGreen) -> Self {
9851 Self(value.0)
9852 }
9853}
9854impl From<StatementContinueGreen> for StatementGreen {
9855 fn from(value: StatementContinueGreen) -> Self {
9856 Self(value.0)
9857 }
9858}
9859impl From<StatementReturnGreen> for StatementGreen {
9860 fn from(value: StatementReturnGreen) -> Self {
9861 Self(value.0)
9862 }
9863}
9864impl From<StatementBreakGreen> for StatementGreen {
9865 fn from(value: StatementBreakGreen) -> Self {
9866 Self(value.0)
9867 }
9868}
9869impl From<StatementItemGreen> for StatementGreen {
9870 fn from(value: StatementItemGreen) -> Self {
9871 Self(value.0)
9872 }
9873}
9874impl From<StatementMissingGreen> for StatementGreen {
9875 fn from(value: StatementMissingGreen) -> Self {
9876 Self(value.0)
9877 }
9878}
9879#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9880pub struct StatementGreen(pub GreenId);
9881impl TypedSyntaxNode for Statement {
9882 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9883 type StablePtr = StatementPtr;
9884 type Green = StatementGreen;
9885 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9886 StatementGreen(StatementMissing::missing(db).0)
9887 }
9888 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9889 let kind = node.kind(db);
9890 match kind {
9891 SyntaxKind::StatementLet => Statement::Let(StatementLet::from_syntax_node(db, node)),
9892 SyntaxKind::StatementExpr => Statement::Expr(StatementExpr::from_syntax_node(db, node)),
9893 SyntaxKind::StatementContinue => {
9894 Statement::Continue(StatementContinue::from_syntax_node(db, node))
9895 }
9896 SyntaxKind::StatementReturn => {
9897 Statement::Return(StatementReturn::from_syntax_node(db, node))
9898 }
9899 SyntaxKind::StatementBreak => {
9900 Statement::Break(StatementBreak::from_syntax_node(db, node))
9901 }
9902 SyntaxKind::StatementItem => Statement::Item(StatementItem::from_syntax_node(db, node)),
9903 SyntaxKind::StatementMissing => {
9904 Statement::Missing(StatementMissing::from_syntax_node(db, node))
9905 }
9906 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Statement"),
9907 }
9908 }
9909 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
9910 let kind = node.kind(db);
9911 match kind {
9912 SyntaxKind::StatementLet => {
9913 Some(Statement::Let(StatementLet::from_syntax_node(db, node)))
9914 }
9915 SyntaxKind::StatementExpr => {
9916 Some(Statement::Expr(StatementExpr::from_syntax_node(db, node)))
9917 }
9918 SyntaxKind::StatementContinue => {
9919 Some(Statement::Continue(StatementContinue::from_syntax_node(db, node)))
9920 }
9921 SyntaxKind::StatementReturn => {
9922 Some(Statement::Return(StatementReturn::from_syntax_node(db, node)))
9923 }
9924 SyntaxKind::StatementBreak => {
9925 Some(Statement::Break(StatementBreak::from_syntax_node(db, node)))
9926 }
9927 SyntaxKind::StatementItem => {
9928 Some(Statement::Item(StatementItem::from_syntax_node(db, node)))
9929 }
9930 SyntaxKind::StatementMissing => {
9931 Some(Statement::Missing(StatementMissing::from_syntax_node(db, node)))
9932 }
9933 _ => None,
9934 }
9935 }
9936 fn as_syntax_node(&self) -> SyntaxNode {
9937 match self {
9938 Statement::Let(x) => x.as_syntax_node(),
9939 Statement::Expr(x) => x.as_syntax_node(),
9940 Statement::Continue(x) => x.as_syntax_node(),
9941 Statement::Return(x) => x.as_syntax_node(),
9942 Statement::Break(x) => x.as_syntax_node(),
9943 Statement::Item(x) => x.as_syntax_node(),
9944 Statement::Missing(x) => x.as_syntax_node(),
9945 }
9946 }
9947 fn stable_ptr(&self) -> Self::StablePtr {
9948 StatementPtr(self.as_syntax_node().0.stable_ptr)
9949 }
9950}
9951impl From<&Statement> for SyntaxStablePtrId {
9952 fn from(node: &Statement) -> Self {
9953 node.stable_ptr().untyped()
9954 }
9955}
9956impl Statement {
9957 pub fn is_variant(kind: SyntaxKind) -> bool {
9959 matches!(
9960 kind,
9961 SyntaxKind::StatementLet
9962 | SyntaxKind::StatementExpr
9963 | SyntaxKind::StatementContinue
9964 | SyntaxKind::StatementReturn
9965 | SyntaxKind::StatementBreak
9966 | SyntaxKind::StatementItem
9967 | SyntaxKind::StatementMissing
9968 )
9969 }
9970}
9971#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9972pub struct StatementList(ElementList<Statement, 1>);
9973impl Deref for StatementList {
9974 type Target = ElementList<Statement, 1>;
9975 fn deref(&self) -> &Self::Target {
9976 &self.0
9977 }
9978}
9979impl StatementList {
9980 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<StatementGreen>) -> StatementListGreen {
9981 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
9982 StatementListGreen(
9983 Arc::new(GreenNode {
9984 kind: SyntaxKind::StatementList,
9985 details: GreenNodeDetails::Node {
9986 children: children.iter().map(|x| x.0).collect(),
9987 width,
9988 },
9989 })
9990 .intern(db),
9991 )
9992 }
9993}
9994#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9995pub struct StatementListPtr(pub SyntaxStablePtrId);
9996impl TypedStablePtr for StatementListPtr {
9997 type SyntaxNode = StatementList;
9998 fn untyped(&self) -> SyntaxStablePtrId {
9999 self.0
10000 }
10001 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementList {
10002 StatementList::from_syntax_node(db, self.0.lookup(db))
10003 }
10004}
10005impl From<StatementListPtr> for SyntaxStablePtrId {
10006 fn from(ptr: StatementListPtr) -> Self {
10007 ptr.untyped()
10008 }
10009}
10010#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10011pub struct StatementListGreen(pub GreenId);
10012impl TypedSyntaxNode for StatementList {
10013 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementList);
10014 type StablePtr = StatementListPtr;
10015 type Green = StatementListGreen;
10016 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10017 StatementListGreen(
10018 Arc::new(GreenNode {
10019 kind: SyntaxKind::StatementList,
10020 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10021 })
10022 .intern(db),
10023 )
10024 }
10025 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10026 Self(ElementList::new(node))
10027 }
10028 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10029 if node.kind(db) == SyntaxKind::StatementList {
10030 Some(Self(ElementList::new(node)))
10031 } else {
10032 None
10033 }
10034 }
10035 fn as_syntax_node(&self) -> SyntaxNode {
10036 self.node.clone()
10037 }
10038 fn stable_ptr(&self) -> Self::StablePtr {
10039 StatementListPtr(self.node.0.stable_ptr)
10040 }
10041}
10042impl From<&StatementList> for SyntaxStablePtrId {
10043 fn from(node: &StatementList) -> Self {
10044 node.stable_ptr().untyped()
10045 }
10046}
10047#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10048pub struct StatementMissing {
10049 node: SyntaxNode,
10050 children: Arc<[SyntaxNode]>,
10051}
10052impl StatementMissing {
10053 pub fn new_green(db: &dyn SyntaxGroup) -> StatementMissingGreen {
10054 let children: Vec<GreenId> = vec![];
10055 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10056 StatementMissingGreen(
10057 Arc::new(GreenNode {
10058 kind: SyntaxKind::StatementMissing,
10059 details: GreenNodeDetails::Node { children, width },
10060 })
10061 .intern(db),
10062 )
10063 }
10064}
10065impl StatementMissing {}
10066#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10067pub struct StatementMissingPtr(pub SyntaxStablePtrId);
10068impl StatementMissingPtr {}
10069impl TypedStablePtr for StatementMissingPtr {
10070 type SyntaxNode = StatementMissing;
10071 fn untyped(&self) -> SyntaxStablePtrId {
10072 self.0
10073 }
10074 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementMissing {
10075 StatementMissing::from_syntax_node(db, self.0.lookup(db))
10076 }
10077}
10078impl From<StatementMissingPtr> for SyntaxStablePtrId {
10079 fn from(ptr: StatementMissingPtr) -> Self {
10080 ptr.untyped()
10081 }
10082}
10083#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10084pub struct StatementMissingGreen(pub GreenId);
10085impl TypedSyntaxNode for StatementMissing {
10086 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementMissing);
10087 type StablePtr = StatementMissingPtr;
10088 type Green = StatementMissingGreen;
10089 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10090 StatementMissingGreen(
10091 Arc::new(GreenNode {
10092 kind: SyntaxKind::StatementMissing,
10093 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10094 })
10095 .intern(db),
10096 )
10097 }
10098 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10099 let kind = node.kind(db);
10100 assert_eq!(
10101 kind,
10102 SyntaxKind::StatementMissing,
10103 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10104 kind,
10105 SyntaxKind::StatementMissing
10106 );
10107 let children = db.get_children(node.clone());
10108 Self { node, children }
10109 }
10110 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10111 let kind = node.kind(db);
10112 if kind == SyntaxKind::StatementMissing {
10113 Some(Self::from_syntax_node(db, node))
10114 } else {
10115 None
10116 }
10117 }
10118 fn as_syntax_node(&self) -> SyntaxNode {
10119 self.node.clone()
10120 }
10121 fn stable_ptr(&self) -> Self::StablePtr {
10122 StatementMissingPtr(self.node.0.stable_ptr)
10123 }
10124}
10125impl From<&StatementMissing> for SyntaxStablePtrId {
10126 fn from(node: &StatementMissing) -> Self {
10127 node.stable_ptr().untyped()
10128 }
10129}
10130#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10131pub struct StatementLet {
10132 node: SyntaxNode,
10133 children: Arc<[SyntaxNode]>,
10134}
10135impl StatementLet {
10136 pub const INDEX_ATTRIBUTES: usize = 0;
10137 pub const INDEX_LET_KW: usize = 1;
10138 pub const INDEX_PATTERN: usize = 2;
10139 pub const INDEX_TYPE_CLAUSE: usize = 3;
10140 pub const INDEX_EQ: usize = 4;
10141 pub const INDEX_RHS: usize = 5;
10142 pub const INDEX_SEMICOLON: usize = 6;
10143 pub fn new_green(
10144 db: &dyn SyntaxGroup,
10145 attributes: AttributeListGreen,
10146 let_kw: TerminalLetGreen,
10147 pattern: PatternGreen,
10148 type_clause: OptionTypeClauseGreen,
10149 eq: TerminalEqGreen,
10150 rhs: ExprGreen,
10151 semicolon: TerminalSemicolonGreen,
10152 ) -> StatementLetGreen {
10153 let children: Vec<GreenId> =
10154 vec![attributes.0, let_kw.0, pattern.0, type_clause.0, eq.0, rhs.0, semicolon.0];
10155 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10156 StatementLetGreen(
10157 Arc::new(GreenNode {
10158 kind: SyntaxKind::StatementLet,
10159 details: GreenNodeDetails::Node { children, width },
10160 })
10161 .intern(db),
10162 )
10163 }
10164}
10165impl StatementLet {
10166 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
10167 AttributeList::from_syntax_node(db, self.children[0].clone())
10168 }
10169 pub fn let_kw(&self, db: &dyn SyntaxGroup) -> TerminalLet {
10170 TerminalLet::from_syntax_node(db, self.children[1].clone())
10171 }
10172 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
10173 Pattern::from_syntax_node(db, self.children[2].clone())
10174 }
10175 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
10176 OptionTypeClause::from_syntax_node(db, self.children[3].clone())
10177 }
10178 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
10179 TerminalEq::from_syntax_node(db, self.children[4].clone())
10180 }
10181 pub fn rhs(&self, db: &dyn SyntaxGroup) -> Expr {
10182 Expr::from_syntax_node(db, self.children[5].clone())
10183 }
10184 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
10185 TerminalSemicolon::from_syntax_node(db, self.children[6].clone())
10186 }
10187}
10188#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10189pub struct StatementLetPtr(pub SyntaxStablePtrId);
10190impl StatementLetPtr {
10191 pub fn pattern_green(self, db: &dyn SyntaxGroup) -> PatternGreen {
10192 let ptr = self.0.lookup_intern(db);
10193 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
10194 PatternGreen(key_fields[0])
10195 } else {
10196 panic!("Unexpected key field query on root.");
10197 }
10198 }
10199}
10200impl TypedStablePtr for StatementLetPtr {
10201 type SyntaxNode = StatementLet;
10202 fn untyped(&self) -> SyntaxStablePtrId {
10203 self.0
10204 }
10205 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementLet {
10206 StatementLet::from_syntax_node(db, self.0.lookup(db))
10207 }
10208}
10209impl From<StatementLetPtr> for SyntaxStablePtrId {
10210 fn from(ptr: StatementLetPtr) -> Self {
10211 ptr.untyped()
10212 }
10213}
10214#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10215pub struct StatementLetGreen(pub GreenId);
10216impl TypedSyntaxNode for StatementLet {
10217 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementLet);
10218 type StablePtr = StatementLetPtr;
10219 type Green = StatementLetGreen;
10220 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10221 StatementLetGreen(
10222 Arc::new(GreenNode {
10223 kind: SyntaxKind::StatementLet,
10224 details: GreenNodeDetails::Node {
10225 children: vec![
10226 AttributeList::missing(db).0,
10227 TerminalLet::missing(db).0,
10228 Pattern::missing(db).0,
10229 OptionTypeClause::missing(db).0,
10230 TerminalEq::missing(db).0,
10231 Expr::missing(db).0,
10232 TerminalSemicolon::missing(db).0,
10233 ],
10234 width: TextWidth::default(),
10235 },
10236 })
10237 .intern(db),
10238 )
10239 }
10240 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10241 let kind = node.kind(db);
10242 assert_eq!(
10243 kind,
10244 SyntaxKind::StatementLet,
10245 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10246 kind,
10247 SyntaxKind::StatementLet
10248 );
10249 let children = db.get_children(node.clone());
10250 Self { node, children }
10251 }
10252 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10253 let kind = node.kind(db);
10254 if kind == SyntaxKind::StatementLet { Some(Self::from_syntax_node(db, node)) } else { None }
10255 }
10256 fn as_syntax_node(&self) -> SyntaxNode {
10257 self.node.clone()
10258 }
10259 fn stable_ptr(&self) -> Self::StablePtr {
10260 StatementLetPtr(self.node.0.stable_ptr)
10261 }
10262}
10263impl From<&StatementLet> for SyntaxStablePtrId {
10264 fn from(node: &StatementLet) -> Self {
10265 node.stable_ptr().untyped()
10266 }
10267}
10268#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10269pub enum OptionTerminalSemicolon {
10270 Empty(OptionTerminalSemicolonEmpty),
10271 TerminalSemicolon(TerminalSemicolon),
10272}
10273#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10274pub struct OptionTerminalSemicolonPtr(pub SyntaxStablePtrId);
10275impl TypedStablePtr for OptionTerminalSemicolonPtr {
10276 type SyntaxNode = OptionTerminalSemicolon;
10277 fn untyped(&self) -> SyntaxStablePtrId {
10278 self.0
10279 }
10280 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolon {
10281 OptionTerminalSemicolon::from_syntax_node(db, self.0.lookup(db))
10282 }
10283}
10284impl From<OptionTerminalSemicolonPtr> for SyntaxStablePtrId {
10285 fn from(ptr: OptionTerminalSemicolonPtr) -> Self {
10286 ptr.untyped()
10287 }
10288}
10289impl From<OptionTerminalSemicolonEmptyPtr> for OptionTerminalSemicolonPtr {
10290 fn from(value: OptionTerminalSemicolonEmptyPtr) -> Self {
10291 Self(value.0)
10292 }
10293}
10294impl From<TerminalSemicolonPtr> for OptionTerminalSemicolonPtr {
10295 fn from(value: TerminalSemicolonPtr) -> Self {
10296 Self(value.0)
10297 }
10298}
10299impl From<OptionTerminalSemicolonEmptyGreen> for OptionTerminalSemicolonGreen {
10300 fn from(value: OptionTerminalSemicolonEmptyGreen) -> Self {
10301 Self(value.0)
10302 }
10303}
10304impl From<TerminalSemicolonGreen> for OptionTerminalSemicolonGreen {
10305 fn from(value: TerminalSemicolonGreen) -> Self {
10306 Self(value.0)
10307 }
10308}
10309#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10310pub struct OptionTerminalSemicolonGreen(pub GreenId);
10311impl TypedSyntaxNode for OptionTerminalSemicolon {
10312 const OPTIONAL_KIND: Option<SyntaxKind> = None;
10313 type StablePtr = OptionTerminalSemicolonPtr;
10314 type Green = OptionTerminalSemicolonGreen;
10315 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10316 panic!("No missing variant.");
10317 }
10318 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10319 let kind = node.kind(db);
10320 match kind {
10321 SyntaxKind::OptionTerminalSemicolonEmpty => OptionTerminalSemicolon::Empty(
10322 OptionTerminalSemicolonEmpty::from_syntax_node(db, node),
10323 ),
10324 SyntaxKind::TerminalSemicolon => OptionTerminalSemicolon::TerminalSemicolon(
10325 TerminalSemicolon::from_syntax_node(db, node),
10326 ),
10327 _ => panic!(
10328 "Unexpected syntax kind {:?} when constructing {}.",
10329 kind, "OptionTerminalSemicolon"
10330 ),
10331 }
10332 }
10333 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10334 let kind = node.kind(db);
10335 match kind {
10336 SyntaxKind::OptionTerminalSemicolonEmpty => Some(OptionTerminalSemicolon::Empty(
10337 OptionTerminalSemicolonEmpty::from_syntax_node(db, node),
10338 )),
10339 SyntaxKind::TerminalSemicolon => Some(OptionTerminalSemicolon::TerminalSemicolon(
10340 TerminalSemicolon::from_syntax_node(db, node),
10341 )),
10342 _ => None,
10343 }
10344 }
10345 fn as_syntax_node(&self) -> SyntaxNode {
10346 match self {
10347 OptionTerminalSemicolon::Empty(x) => x.as_syntax_node(),
10348 OptionTerminalSemicolon::TerminalSemicolon(x) => x.as_syntax_node(),
10349 }
10350 }
10351 fn stable_ptr(&self) -> Self::StablePtr {
10352 OptionTerminalSemicolonPtr(self.as_syntax_node().0.stable_ptr)
10353 }
10354}
10355impl From<&OptionTerminalSemicolon> for SyntaxStablePtrId {
10356 fn from(node: &OptionTerminalSemicolon) -> Self {
10357 node.stable_ptr().untyped()
10358 }
10359}
10360impl OptionTerminalSemicolon {
10361 pub fn is_variant(kind: SyntaxKind) -> bool {
10363 matches!(kind, SyntaxKind::OptionTerminalSemicolonEmpty | SyntaxKind::TerminalSemicolon)
10364 }
10365}
10366#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10367pub struct OptionTerminalSemicolonEmpty {
10368 node: SyntaxNode,
10369 children: Arc<[SyntaxNode]>,
10370}
10371impl OptionTerminalSemicolonEmpty {
10372 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalSemicolonEmptyGreen {
10373 let children: Vec<GreenId> = vec![];
10374 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10375 OptionTerminalSemicolonEmptyGreen(
10376 Arc::new(GreenNode {
10377 kind: SyntaxKind::OptionTerminalSemicolonEmpty,
10378 details: GreenNodeDetails::Node { children, width },
10379 })
10380 .intern(db),
10381 )
10382 }
10383}
10384impl OptionTerminalSemicolonEmpty {}
10385#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10386pub struct OptionTerminalSemicolonEmptyPtr(pub SyntaxStablePtrId);
10387impl OptionTerminalSemicolonEmptyPtr {}
10388impl TypedStablePtr for OptionTerminalSemicolonEmptyPtr {
10389 type SyntaxNode = OptionTerminalSemicolonEmpty;
10390 fn untyped(&self) -> SyntaxStablePtrId {
10391 self.0
10392 }
10393 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolonEmpty {
10394 OptionTerminalSemicolonEmpty::from_syntax_node(db, self.0.lookup(db))
10395 }
10396}
10397impl From<OptionTerminalSemicolonEmptyPtr> for SyntaxStablePtrId {
10398 fn from(ptr: OptionTerminalSemicolonEmptyPtr) -> Self {
10399 ptr.untyped()
10400 }
10401}
10402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10403pub struct OptionTerminalSemicolonEmptyGreen(pub GreenId);
10404impl TypedSyntaxNode for OptionTerminalSemicolonEmpty {
10405 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalSemicolonEmpty);
10406 type StablePtr = OptionTerminalSemicolonEmptyPtr;
10407 type Green = OptionTerminalSemicolonEmptyGreen;
10408 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10409 OptionTerminalSemicolonEmptyGreen(
10410 Arc::new(GreenNode {
10411 kind: SyntaxKind::OptionTerminalSemicolonEmpty,
10412 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10413 })
10414 .intern(db),
10415 )
10416 }
10417 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10418 let kind = node.kind(db);
10419 assert_eq!(
10420 kind,
10421 SyntaxKind::OptionTerminalSemicolonEmpty,
10422 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10423 kind,
10424 SyntaxKind::OptionTerminalSemicolonEmpty
10425 );
10426 let children = db.get_children(node.clone());
10427 Self { node, children }
10428 }
10429 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10430 let kind = node.kind(db);
10431 if kind == SyntaxKind::OptionTerminalSemicolonEmpty {
10432 Some(Self::from_syntax_node(db, node))
10433 } else {
10434 None
10435 }
10436 }
10437 fn as_syntax_node(&self) -> SyntaxNode {
10438 self.node.clone()
10439 }
10440 fn stable_ptr(&self) -> Self::StablePtr {
10441 OptionTerminalSemicolonEmptyPtr(self.node.0.stable_ptr)
10442 }
10443}
10444impl From<&OptionTerminalSemicolonEmpty> for SyntaxStablePtrId {
10445 fn from(node: &OptionTerminalSemicolonEmpty) -> Self {
10446 node.stable_ptr().untyped()
10447 }
10448}
10449#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10450pub struct StatementExpr {
10451 node: SyntaxNode,
10452 children: Arc<[SyntaxNode]>,
10453}
10454impl StatementExpr {
10455 pub const INDEX_ATTRIBUTES: usize = 0;
10456 pub const INDEX_EXPR: usize = 1;
10457 pub const INDEX_SEMICOLON: usize = 2;
10458 pub fn new_green(
10459 db: &dyn SyntaxGroup,
10460 attributes: AttributeListGreen,
10461 expr: ExprGreen,
10462 semicolon: OptionTerminalSemicolonGreen,
10463 ) -> StatementExprGreen {
10464 let children: Vec<GreenId> = vec![attributes.0, expr.0, semicolon.0];
10465 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10466 StatementExprGreen(
10467 Arc::new(GreenNode {
10468 kind: SyntaxKind::StatementExpr,
10469 details: GreenNodeDetails::Node { children, width },
10470 })
10471 .intern(db),
10472 )
10473 }
10474}
10475impl StatementExpr {
10476 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
10477 AttributeList::from_syntax_node(db, self.children[0].clone())
10478 }
10479 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
10480 Expr::from_syntax_node(db, self.children[1].clone())
10481 }
10482 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolon {
10483 OptionTerminalSemicolon::from_syntax_node(db, self.children[2].clone())
10484 }
10485}
10486#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10487pub struct StatementExprPtr(pub SyntaxStablePtrId);
10488impl StatementExprPtr {}
10489impl TypedStablePtr for StatementExprPtr {
10490 type SyntaxNode = StatementExpr;
10491 fn untyped(&self) -> SyntaxStablePtrId {
10492 self.0
10493 }
10494 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementExpr {
10495 StatementExpr::from_syntax_node(db, self.0.lookup(db))
10496 }
10497}
10498impl From<StatementExprPtr> for SyntaxStablePtrId {
10499 fn from(ptr: StatementExprPtr) -> Self {
10500 ptr.untyped()
10501 }
10502}
10503#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10504pub struct StatementExprGreen(pub GreenId);
10505impl TypedSyntaxNode for StatementExpr {
10506 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementExpr);
10507 type StablePtr = StatementExprPtr;
10508 type Green = StatementExprGreen;
10509 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10510 StatementExprGreen(
10511 Arc::new(GreenNode {
10512 kind: SyntaxKind::StatementExpr,
10513 details: GreenNodeDetails::Node {
10514 children: vec![
10515 AttributeList::missing(db).0,
10516 Expr::missing(db).0,
10517 OptionTerminalSemicolon::missing(db).0,
10518 ],
10519 width: TextWidth::default(),
10520 },
10521 })
10522 .intern(db),
10523 )
10524 }
10525 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10526 let kind = node.kind(db);
10527 assert_eq!(
10528 kind,
10529 SyntaxKind::StatementExpr,
10530 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10531 kind,
10532 SyntaxKind::StatementExpr
10533 );
10534 let children = db.get_children(node.clone());
10535 Self { node, children }
10536 }
10537 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10538 let kind = node.kind(db);
10539 if kind == SyntaxKind::StatementExpr {
10540 Some(Self::from_syntax_node(db, node))
10541 } else {
10542 None
10543 }
10544 }
10545 fn as_syntax_node(&self) -> SyntaxNode {
10546 self.node.clone()
10547 }
10548 fn stable_ptr(&self) -> Self::StablePtr {
10549 StatementExprPtr(self.node.0.stable_ptr)
10550 }
10551}
10552impl From<&StatementExpr> for SyntaxStablePtrId {
10553 fn from(node: &StatementExpr) -> Self {
10554 node.stable_ptr().untyped()
10555 }
10556}
10557#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10558pub struct StatementContinue {
10559 node: SyntaxNode,
10560 children: Arc<[SyntaxNode]>,
10561}
10562impl StatementContinue {
10563 pub const INDEX_ATTRIBUTES: usize = 0;
10564 pub const INDEX_CONTINUE_KW: usize = 1;
10565 pub const INDEX_SEMICOLON: usize = 2;
10566 pub fn new_green(
10567 db: &dyn SyntaxGroup,
10568 attributes: AttributeListGreen,
10569 continue_kw: TerminalContinueGreen,
10570 semicolon: TerminalSemicolonGreen,
10571 ) -> StatementContinueGreen {
10572 let children: Vec<GreenId> = vec![attributes.0, continue_kw.0, semicolon.0];
10573 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10574 StatementContinueGreen(
10575 Arc::new(GreenNode {
10576 kind: SyntaxKind::StatementContinue,
10577 details: GreenNodeDetails::Node { children, width },
10578 })
10579 .intern(db),
10580 )
10581 }
10582}
10583impl StatementContinue {
10584 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
10585 AttributeList::from_syntax_node(db, self.children[0].clone())
10586 }
10587 pub fn continue_kw(&self, db: &dyn SyntaxGroup) -> TerminalContinue {
10588 TerminalContinue::from_syntax_node(db, self.children[1].clone())
10589 }
10590 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
10591 TerminalSemicolon::from_syntax_node(db, self.children[2].clone())
10592 }
10593}
10594#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10595pub struct StatementContinuePtr(pub SyntaxStablePtrId);
10596impl StatementContinuePtr {}
10597impl TypedStablePtr for StatementContinuePtr {
10598 type SyntaxNode = StatementContinue;
10599 fn untyped(&self) -> SyntaxStablePtrId {
10600 self.0
10601 }
10602 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementContinue {
10603 StatementContinue::from_syntax_node(db, self.0.lookup(db))
10604 }
10605}
10606impl From<StatementContinuePtr> for SyntaxStablePtrId {
10607 fn from(ptr: StatementContinuePtr) -> Self {
10608 ptr.untyped()
10609 }
10610}
10611#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10612pub struct StatementContinueGreen(pub GreenId);
10613impl TypedSyntaxNode for StatementContinue {
10614 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementContinue);
10615 type StablePtr = StatementContinuePtr;
10616 type Green = StatementContinueGreen;
10617 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10618 StatementContinueGreen(
10619 Arc::new(GreenNode {
10620 kind: SyntaxKind::StatementContinue,
10621 details: GreenNodeDetails::Node {
10622 children: vec![
10623 AttributeList::missing(db).0,
10624 TerminalContinue::missing(db).0,
10625 TerminalSemicolon::missing(db).0,
10626 ],
10627 width: TextWidth::default(),
10628 },
10629 })
10630 .intern(db),
10631 )
10632 }
10633 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10634 let kind = node.kind(db);
10635 assert_eq!(
10636 kind,
10637 SyntaxKind::StatementContinue,
10638 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10639 kind,
10640 SyntaxKind::StatementContinue
10641 );
10642 let children = db.get_children(node.clone());
10643 Self { node, children }
10644 }
10645 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10646 let kind = node.kind(db);
10647 if kind == SyntaxKind::StatementContinue {
10648 Some(Self::from_syntax_node(db, node))
10649 } else {
10650 None
10651 }
10652 }
10653 fn as_syntax_node(&self) -> SyntaxNode {
10654 self.node.clone()
10655 }
10656 fn stable_ptr(&self) -> Self::StablePtr {
10657 StatementContinuePtr(self.node.0.stable_ptr)
10658 }
10659}
10660impl From<&StatementContinue> for SyntaxStablePtrId {
10661 fn from(node: &StatementContinue) -> Self {
10662 node.stable_ptr().untyped()
10663 }
10664}
10665#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10666pub struct ExprClause {
10667 node: SyntaxNode,
10668 children: Arc<[SyntaxNode]>,
10669}
10670impl ExprClause {
10671 pub const INDEX_EXPR: usize = 0;
10672 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> ExprClauseGreen {
10673 let children: Vec<GreenId> = vec![expr.0];
10674 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10675 ExprClauseGreen(
10676 Arc::new(GreenNode {
10677 kind: SyntaxKind::ExprClause,
10678 details: GreenNodeDetails::Node { children, width },
10679 })
10680 .intern(db),
10681 )
10682 }
10683}
10684impl ExprClause {
10685 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
10686 Expr::from_syntax_node(db, self.children[0].clone())
10687 }
10688}
10689#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10690pub struct ExprClausePtr(pub SyntaxStablePtrId);
10691impl ExprClausePtr {}
10692impl TypedStablePtr for ExprClausePtr {
10693 type SyntaxNode = ExprClause;
10694 fn untyped(&self) -> SyntaxStablePtrId {
10695 self.0
10696 }
10697 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprClause {
10698 ExprClause::from_syntax_node(db, self.0.lookup(db))
10699 }
10700}
10701impl From<ExprClausePtr> for SyntaxStablePtrId {
10702 fn from(ptr: ExprClausePtr) -> Self {
10703 ptr.untyped()
10704 }
10705}
10706#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10707pub struct ExprClauseGreen(pub GreenId);
10708impl TypedSyntaxNode for ExprClause {
10709 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprClause);
10710 type StablePtr = ExprClausePtr;
10711 type Green = ExprClauseGreen;
10712 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10713 ExprClauseGreen(
10714 Arc::new(GreenNode {
10715 kind: SyntaxKind::ExprClause,
10716 details: GreenNodeDetails::Node {
10717 children: vec![Expr::missing(db).0],
10718 width: TextWidth::default(),
10719 },
10720 })
10721 .intern(db),
10722 )
10723 }
10724 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10725 let kind = node.kind(db);
10726 assert_eq!(
10727 kind,
10728 SyntaxKind::ExprClause,
10729 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10730 kind,
10731 SyntaxKind::ExprClause
10732 );
10733 let children = db.get_children(node.clone());
10734 Self { node, children }
10735 }
10736 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10737 let kind = node.kind(db);
10738 if kind == SyntaxKind::ExprClause { Some(Self::from_syntax_node(db, node)) } else { None }
10739 }
10740 fn as_syntax_node(&self) -> SyntaxNode {
10741 self.node.clone()
10742 }
10743 fn stable_ptr(&self) -> Self::StablePtr {
10744 ExprClausePtr(self.node.0.stable_ptr)
10745 }
10746}
10747impl From<&ExprClause> for SyntaxStablePtrId {
10748 fn from(node: &ExprClause) -> Self {
10749 node.stable_ptr().untyped()
10750 }
10751}
10752#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10753pub enum OptionExprClause {
10754 Empty(OptionExprClauseEmpty),
10755 ExprClause(ExprClause),
10756}
10757#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10758pub struct OptionExprClausePtr(pub SyntaxStablePtrId);
10759impl TypedStablePtr for OptionExprClausePtr {
10760 type SyntaxNode = OptionExprClause;
10761 fn untyped(&self) -> SyntaxStablePtrId {
10762 self.0
10763 }
10764 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
10765 OptionExprClause::from_syntax_node(db, self.0.lookup(db))
10766 }
10767}
10768impl From<OptionExprClausePtr> for SyntaxStablePtrId {
10769 fn from(ptr: OptionExprClausePtr) -> Self {
10770 ptr.untyped()
10771 }
10772}
10773impl From<OptionExprClauseEmptyPtr> for OptionExprClausePtr {
10774 fn from(value: OptionExprClauseEmptyPtr) -> Self {
10775 Self(value.0)
10776 }
10777}
10778impl From<ExprClausePtr> for OptionExprClausePtr {
10779 fn from(value: ExprClausePtr) -> Self {
10780 Self(value.0)
10781 }
10782}
10783impl From<OptionExprClauseEmptyGreen> for OptionExprClauseGreen {
10784 fn from(value: OptionExprClauseEmptyGreen) -> Self {
10785 Self(value.0)
10786 }
10787}
10788impl From<ExprClauseGreen> for OptionExprClauseGreen {
10789 fn from(value: ExprClauseGreen) -> Self {
10790 Self(value.0)
10791 }
10792}
10793#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10794pub struct OptionExprClauseGreen(pub GreenId);
10795impl TypedSyntaxNode for OptionExprClause {
10796 const OPTIONAL_KIND: Option<SyntaxKind> = None;
10797 type StablePtr = OptionExprClausePtr;
10798 type Green = OptionExprClauseGreen;
10799 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10800 panic!("No missing variant.");
10801 }
10802 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10803 let kind = node.kind(db);
10804 match kind {
10805 SyntaxKind::OptionExprClauseEmpty => {
10806 OptionExprClause::Empty(OptionExprClauseEmpty::from_syntax_node(db, node))
10807 }
10808 SyntaxKind::ExprClause => {
10809 OptionExprClause::ExprClause(ExprClause::from_syntax_node(db, node))
10810 }
10811 _ => panic!(
10812 "Unexpected syntax kind {:?} when constructing {}.",
10813 kind, "OptionExprClause"
10814 ),
10815 }
10816 }
10817 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10818 let kind = node.kind(db);
10819 match kind {
10820 SyntaxKind::OptionExprClauseEmpty => {
10821 Some(OptionExprClause::Empty(OptionExprClauseEmpty::from_syntax_node(db, node)))
10822 }
10823 SyntaxKind::ExprClause => {
10824 Some(OptionExprClause::ExprClause(ExprClause::from_syntax_node(db, node)))
10825 }
10826 _ => None,
10827 }
10828 }
10829 fn as_syntax_node(&self) -> SyntaxNode {
10830 match self {
10831 OptionExprClause::Empty(x) => x.as_syntax_node(),
10832 OptionExprClause::ExprClause(x) => x.as_syntax_node(),
10833 }
10834 }
10835 fn stable_ptr(&self) -> Self::StablePtr {
10836 OptionExprClausePtr(self.as_syntax_node().0.stable_ptr)
10837 }
10838}
10839impl From<&OptionExprClause> for SyntaxStablePtrId {
10840 fn from(node: &OptionExprClause) -> Self {
10841 node.stable_ptr().untyped()
10842 }
10843}
10844impl OptionExprClause {
10845 pub fn is_variant(kind: SyntaxKind) -> bool {
10847 matches!(kind, SyntaxKind::OptionExprClauseEmpty | SyntaxKind::ExprClause)
10848 }
10849}
10850#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10851pub struct OptionExprClauseEmpty {
10852 node: SyntaxNode,
10853 children: Arc<[SyntaxNode]>,
10854}
10855impl OptionExprClauseEmpty {
10856 pub fn new_green(db: &dyn SyntaxGroup) -> OptionExprClauseEmptyGreen {
10857 let children: Vec<GreenId> = vec![];
10858 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10859 OptionExprClauseEmptyGreen(
10860 Arc::new(GreenNode {
10861 kind: SyntaxKind::OptionExprClauseEmpty,
10862 details: GreenNodeDetails::Node { children, width },
10863 })
10864 .intern(db),
10865 )
10866 }
10867}
10868impl OptionExprClauseEmpty {}
10869#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10870pub struct OptionExprClauseEmptyPtr(pub SyntaxStablePtrId);
10871impl OptionExprClauseEmptyPtr {}
10872impl TypedStablePtr for OptionExprClauseEmptyPtr {
10873 type SyntaxNode = OptionExprClauseEmpty;
10874 fn untyped(&self) -> SyntaxStablePtrId {
10875 self.0
10876 }
10877 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionExprClauseEmpty {
10878 OptionExprClauseEmpty::from_syntax_node(db, self.0.lookup(db))
10879 }
10880}
10881impl From<OptionExprClauseEmptyPtr> for SyntaxStablePtrId {
10882 fn from(ptr: OptionExprClauseEmptyPtr) -> Self {
10883 ptr.untyped()
10884 }
10885}
10886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10887pub struct OptionExprClauseEmptyGreen(pub GreenId);
10888impl TypedSyntaxNode for OptionExprClauseEmpty {
10889 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionExprClauseEmpty);
10890 type StablePtr = OptionExprClauseEmptyPtr;
10891 type Green = OptionExprClauseEmptyGreen;
10892 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10893 OptionExprClauseEmptyGreen(
10894 Arc::new(GreenNode {
10895 kind: SyntaxKind::OptionExprClauseEmpty,
10896 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10897 })
10898 .intern(db),
10899 )
10900 }
10901 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10902 let kind = node.kind(db);
10903 assert_eq!(
10904 kind,
10905 SyntaxKind::OptionExprClauseEmpty,
10906 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10907 kind,
10908 SyntaxKind::OptionExprClauseEmpty
10909 );
10910 let children = db.get_children(node.clone());
10911 Self { node, children }
10912 }
10913 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
10914 let kind = node.kind(db);
10915 if kind == SyntaxKind::OptionExprClauseEmpty {
10916 Some(Self::from_syntax_node(db, node))
10917 } else {
10918 None
10919 }
10920 }
10921 fn as_syntax_node(&self) -> SyntaxNode {
10922 self.node.clone()
10923 }
10924 fn stable_ptr(&self) -> Self::StablePtr {
10925 OptionExprClauseEmptyPtr(self.node.0.stable_ptr)
10926 }
10927}
10928impl From<&OptionExprClauseEmpty> for SyntaxStablePtrId {
10929 fn from(node: &OptionExprClauseEmpty) -> Self {
10930 node.stable_ptr().untyped()
10931 }
10932}
10933#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10934pub struct StatementReturn {
10935 node: SyntaxNode,
10936 children: Arc<[SyntaxNode]>,
10937}
10938impl StatementReturn {
10939 pub const INDEX_ATTRIBUTES: usize = 0;
10940 pub const INDEX_RETURN_KW: usize = 1;
10941 pub const INDEX_EXPR_CLAUSE: usize = 2;
10942 pub const INDEX_SEMICOLON: usize = 3;
10943 pub fn new_green(
10944 db: &dyn SyntaxGroup,
10945 attributes: AttributeListGreen,
10946 return_kw: TerminalReturnGreen,
10947 expr_clause: OptionExprClauseGreen,
10948 semicolon: TerminalSemicolonGreen,
10949 ) -> StatementReturnGreen {
10950 let children: Vec<GreenId> = vec![attributes.0, return_kw.0, expr_clause.0, semicolon.0];
10951 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10952 StatementReturnGreen(
10953 Arc::new(GreenNode {
10954 kind: SyntaxKind::StatementReturn,
10955 details: GreenNodeDetails::Node { children, width },
10956 })
10957 .intern(db),
10958 )
10959 }
10960}
10961impl StatementReturn {
10962 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
10963 AttributeList::from_syntax_node(db, self.children[0].clone())
10964 }
10965 pub fn return_kw(&self, db: &dyn SyntaxGroup) -> TerminalReturn {
10966 TerminalReturn::from_syntax_node(db, self.children[1].clone())
10967 }
10968 pub fn expr_clause(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
10969 OptionExprClause::from_syntax_node(db, self.children[2].clone())
10970 }
10971 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
10972 TerminalSemicolon::from_syntax_node(db, self.children[3].clone())
10973 }
10974}
10975#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10976pub struct StatementReturnPtr(pub SyntaxStablePtrId);
10977impl StatementReturnPtr {}
10978impl TypedStablePtr for StatementReturnPtr {
10979 type SyntaxNode = StatementReturn;
10980 fn untyped(&self) -> SyntaxStablePtrId {
10981 self.0
10982 }
10983 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementReturn {
10984 StatementReturn::from_syntax_node(db, self.0.lookup(db))
10985 }
10986}
10987impl From<StatementReturnPtr> for SyntaxStablePtrId {
10988 fn from(ptr: StatementReturnPtr) -> Self {
10989 ptr.untyped()
10990 }
10991}
10992#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10993pub struct StatementReturnGreen(pub GreenId);
10994impl TypedSyntaxNode for StatementReturn {
10995 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementReturn);
10996 type StablePtr = StatementReturnPtr;
10997 type Green = StatementReturnGreen;
10998 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10999 StatementReturnGreen(
11000 Arc::new(GreenNode {
11001 kind: SyntaxKind::StatementReturn,
11002 details: GreenNodeDetails::Node {
11003 children: vec![
11004 AttributeList::missing(db).0,
11005 TerminalReturn::missing(db).0,
11006 OptionExprClause::missing(db).0,
11007 TerminalSemicolon::missing(db).0,
11008 ],
11009 width: TextWidth::default(),
11010 },
11011 })
11012 .intern(db),
11013 )
11014 }
11015 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11016 let kind = node.kind(db);
11017 assert_eq!(
11018 kind,
11019 SyntaxKind::StatementReturn,
11020 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11021 kind,
11022 SyntaxKind::StatementReturn
11023 );
11024 let children = db.get_children(node.clone());
11025 Self { node, children }
11026 }
11027 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11028 let kind = node.kind(db);
11029 if kind == SyntaxKind::StatementReturn {
11030 Some(Self::from_syntax_node(db, node))
11031 } else {
11032 None
11033 }
11034 }
11035 fn as_syntax_node(&self) -> SyntaxNode {
11036 self.node.clone()
11037 }
11038 fn stable_ptr(&self) -> Self::StablePtr {
11039 StatementReturnPtr(self.node.0.stable_ptr)
11040 }
11041}
11042impl From<&StatementReturn> for SyntaxStablePtrId {
11043 fn from(node: &StatementReturn) -> Self {
11044 node.stable_ptr().untyped()
11045 }
11046}
11047#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11048pub struct StatementBreak {
11049 node: SyntaxNode,
11050 children: Arc<[SyntaxNode]>,
11051}
11052impl StatementBreak {
11053 pub const INDEX_ATTRIBUTES: usize = 0;
11054 pub const INDEX_BREAK_KW: usize = 1;
11055 pub const INDEX_EXPR_CLAUSE: usize = 2;
11056 pub const INDEX_SEMICOLON: usize = 3;
11057 pub fn new_green(
11058 db: &dyn SyntaxGroup,
11059 attributes: AttributeListGreen,
11060 break_kw: TerminalBreakGreen,
11061 expr_clause: OptionExprClauseGreen,
11062 semicolon: TerminalSemicolonGreen,
11063 ) -> StatementBreakGreen {
11064 let children: Vec<GreenId> = vec![attributes.0, break_kw.0, expr_clause.0, semicolon.0];
11065 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11066 StatementBreakGreen(
11067 Arc::new(GreenNode {
11068 kind: SyntaxKind::StatementBreak,
11069 details: GreenNodeDetails::Node { children, width },
11070 })
11071 .intern(db),
11072 )
11073 }
11074}
11075impl StatementBreak {
11076 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
11077 AttributeList::from_syntax_node(db, self.children[0].clone())
11078 }
11079 pub fn break_kw(&self, db: &dyn SyntaxGroup) -> TerminalBreak {
11080 TerminalBreak::from_syntax_node(db, self.children[1].clone())
11081 }
11082 pub fn expr_clause(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
11083 OptionExprClause::from_syntax_node(db, self.children[2].clone())
11084 }
11085 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
11086 TerminalSemicolon::from_syntax_node(db, self.children[3].clone())
11087 }
11088}
11089#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11090pub struct StatementBreakPtr(pub SyntaxStablePtrId);
11091impl StatementBreakPtr {}
11092impl TypedStablePtr for StatementBreakPtr {
11093 type SyntaxNode = StatementBreak;
11094 fn untyped(&self) -> SyntaxStablePtrId {
11095 self.0
11096 }
11097 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementBreak {
11098 StatementBreak::from_syntax_node(db, self.0.lookup(db))
11099 }
11100}
11101impl From<StatementBreakPtr> for SyntaxStablePtrId {
11102 fn from(ptr: StatementBreakPtr) -> Self {
11103 ptr.untyped()
11104 }
11105}
11106#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11107pub struct StatementBreakGreen(pub GreenId);
11108impl TypedSyntaxNode for StatementBreak {
11109 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementBreak);
11110 type StablePtr = StatementBreakPtr;
11111 type Green = StatementBreakGreen;
11112 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11113 StatementBreakGreen(
11114 Arc::new(GreenNode {
11115 kind: SyntaxKind::StatementBreak,
11116 details: GreenNodeDetails::Node {
11117 children: vec![
11118 AttributeList::missing(db).0,
11119 TerminalBreak::missing(db).0,
11120 OptionExprClause::missing(db).0,
11121 TerminalSemicolon::missing(db).0,
11122 ],
11123 width: TextWidth::default(),
11124 },
11125 })
11126 .intern(db),
11127 )
11128 }
11129 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11130 let kind = node.kind(db);
11131 assert_eq!(
11132 kind,
11133 SyntaxKind::StatementBreak,
11134 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11135 kind,
11136 SyntaxKind::StatementBreak
11137 );
11138 let children = db.get_children(node.clone());
11139 Self { node, children }
11140 }
11141 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11142 let kind = node.kind(db);
11143 if kind == SyntaxKind::StatementBreak {
11144 Some(Self::from_syntax_node(db, node))
11145 } else {
11146 None
11147 }
11148 }
11149 fn as_syntax_node(&self) -> SyntaxNode {
11150 self.node.clone()
11151 }
11152 fn stable_ptr(&self) -> Self::StablePtr {
11153 StatementBreakPtr(self.node.0.stable_ptr)
11154 }
11155}
11156impl From<&StatementBreak> for SyntaxStablePtrId {
11157 fn from(node: &StatementBreak) -> Self {
11158 node.stable_ptr().untyped()
11159 }
11160}
11161#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11162pub struct StatementItem {
11163 node: SyntaxNode,
11164 children: Arc<[SyntaxNode]>,
11165}
11166impl StatementItem {
11167 pub const INDEX_ITEM: usize = 0;
11168 pub fn new_green(db: &dyn SyntaxGroup, item: ModuleItemGreen) -> StatementItemGreen {
11169 let children: Vec<GreenId> = vec![item.0];
11170 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11171 StatementItemGreen(
11172 Arc::new(GreenNode {
11173 kind: SyntaxKind::StatementItem,
11174 details: GreenNodeDetails::Node { children, width },
11175 })
11176 .intern(db),
11177 )
11178 }
11179}
11180impl StatementItem {
11181 pub fn item(&self, db: &dyn SyntaxGroup) -> ModuleItem {
11182 ModuleItem::from_syntax_node(db, self.children[0].clone())
11183 }
11184}
11185#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11186pub struct StatementItemPtr(pub SyntaxStablePtrId);
11187impl StatementItemPtr {}
11188impl TypedStablePtr for StatementItemPtr {
11189 type SyntaxNode = StatementItem;
11190 fn untyped(&self) -> SyntaxStablePtrId {
11191 self.0
11192 }
11193 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementItem {
11194 StatementItem::from_syntax_node(db, self.0.lookup(db))
11195 }
11196}
11197impl From<StatementItemPtr> for SyntaxStablePtrId {
11198 fn from(ptr: StatementItemPtr) -> Self {
11199 ptr.untyped()
11200 }
11201}
11202#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11203pub struct StatementItemGreen(pub GreenId);
11204impl TypedSyntaxNode for StatementItem {
11205 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementItem);
11206 type StablePtr = StatementItemPtr;
11207 type Green = StatementItemGreen;
11208 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11209 StatementItemGreen(
11210 Arc::new(GreenNode {
11211 kind: SyntaxKind::StatementItem,
11212 details: GreenNodeDetails::Node {
11213 children: vec![ModuleItem::missing(db).0],
11214 width: TextWidth::default(),
11215 },
11216 })
11217 .intern(db),
11218 )
11219 }
11220 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11221 let kind = node.kind(db);
11222 assert_eq!(
11223 kind,
11224 SyntaxKind::StatementItem,
11225 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11226 kind,
11227 SyntaxKind::StatementItem
11228 );
11229 let children = db.get_children(node.clone());
11230 Self { node, children }
11231 }
11232 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11233 let kind = node.kind(db);
11234 if kind == SyntaxKind::StatementItem {
11235 Some(Self::from_syntax_node(db, node))
11236 } else {
11237 None
11238 }
11239 }
11240 fn as_syntax_node(&self) -> SyntaxNode {
11241 self.node.clone()
11242 }
11243 fn stable_ptr(&self) -> Self::StablePtr {
11244 StatementItemPtr(self.node.0.stable_ptr)
11245 }
11246}
11247impl From<&StatementItem> for SyntaxStablePtrId {
11248 fn from(node: &StatementItem) -> Self {
11249 node.stable_ptr().untyped()
11250 }
11251}
11252#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11253pub struct Param {
11254 node: SyntaxNode,
11255 children: Arc<[SyntaxNode]>,
11256}
11257impl Param {
11258 pub const INDEX_MODIFIERS: usize = 0;
11259 pub const INDEX_NAME: usize = 1;
11260 pub const INDEX_TYPE_CLAUSE: usize = 2;
11261 pub fn new_green(
11262 db: &dyn SyntaxGroup,
11263 modifiers: ModifierListGreen,
11264 name: TerminalIdentifierGreen,
11265 type_clause: OptionTypeClauseGreen,
11266 ) -> ParamGreen {
11267 let children: Vec<GreenId> = vec![modifiers.0, name.0, type_clause.0];
11268 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11269 ParamGreen(
11270 Arc::new(GreenNode {
11271 kind: SyntaxKind::Param,
11272 details: GreenNodeDetails::Node { children, width },
11273 })
11274 .intern(db),
11275 )
11276 }
11277}
11278impl Param {
11279 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
11280 ModifierList::from_syntax_node(db, self.children[0].clone())
11281 }
11282 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
11283 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
11284 }
11285 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
11286 OptionTypeClause::from_syntax_node(db, self.children[2].clone())
11287 }
11288}
11289#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11290pub struct ParamPtr(pub SyntaxStablePtrId);
11291impl ParamPtr {
11292 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
11293 let ptr = self.0.lookup_intern(db);
11294 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
11295 TerminalIdentifierGreen(key_fields[0])
11296 } else {
11297 panic!("Unexpected key field query on root.");
11298 }
11299 }
11300}
11301impl TypedStablePtr for ParamPtr {
11302 type SyntaxNode = Param;
11303 fn untyped(&self) -> SyntaxStablePtrId {
11304 self.0
11305 }
11306 fn lookup(&self, db: &dyn SyntaxGroup) -> Param {
11307 Param::from_syntax_node(db, self.0.lookup(db))
11308 }
11309}
11310impl From<ParamPtr> for SyntaxStablePtrId {
11311 fn from(ptr: ParamPtr) -> Self {
11312 ptr.untyped()
11313 }
11314}
11315#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11316pub struct ParamGreen(pub GreenId);
11317impl TypedSyntaxNode for Param {
11318 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Param);
11319 type StablePtr = ParamPtr;
11320 type Green = ParamGreen;
11321 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11322 ParamGreen(
11323 Arc::new(GreenNode {
11324 kind: SyntaxKind::Param,
11325 details: GreenNodeDetails::Node {
11326 children: vec![
11327 ModifierList::missing(db).0,
11328 TerminalIdentifier::missing(db).0,
11329 OptionTypeClause::missing(db).0,
11330 ],
11331 width: TextWidth::default(),
11332 },
11333 })
11334 .intern(db),
11335 )
11336 }
11337 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11338 let kind = node.kind(db);
11339 assert_eq!(
11340 kind,
11341 SyntaxKind::Param,
11342 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11343 kind,
11344 SyntaxKind::Param
11345 );
11346 let children = db.get_children(node.clone());
11347 Self { node, children }
11348 }
11349 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11350 let kind = node.kind(db);
11351 if kind == SyntaxKind::Param { Some(Self::from_syntax_node(db, node)) } else { None }
11352 }
11353 fn as_syntax_node(&self) -> SyntaxNode {
11354 self.node.clone()
11355 }
11356 fn stable_ptr(&self) -> Self::StablePtr {
11357 ParamPtr(self.node.0.stable_ptr)
11358 }
11359}
11360impl From<&Param> for SyntaxStablePtrId {
11361 fn from(node: &Param) -> Self {
11362 node.stable_ptr().untyped()
11363 }
11364}
11365#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11366pub struct ModifierList(ElementList<Modifier, 1>);
11367impl Deref for ModifierList {
11368 type Target = ElementList<Modifier, 1>;
11369 fn deref(&self) -> &Self::Target {
11370 &self.0
11371 }
11372}
11373impl ModifierList {
11374 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ModifierGreen>) -> ModifierListGreen {
11375 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
11376 ModifierListGreen(
11377 Arc::new(GreenNode {
11378 kind: SyntaxKind::ModifierList,
11379 details: GreenNodeDetails::Node {
11380 children: children.iter().map(|x| x.0).collect(),
11381 width,
11382 },
11383 })
11384 .intern(db),
11385 )
11386 }
11387}
11388#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11389pub struct ModifierListPtr(pub SyntaxStablePtrId);
11390impl TypedStablePtr for ModifierListPtr {
11391 type SyntaxNode = ModifierList;
11392 fn untyped(&self) -> SyntaxStablePtrId {
11393 self.0
11394 }
11395 fn lookup(&self, db: &dyn SyntaxGroup) -> ModifierList {
11396 ModifierList::from_syntax_node(db, self.0.lookup(db))
11397 }
11398}
11399impl From<ModifierListPtr> for SyntaxStablePtrId {
11400 fn from(ptr: ModifierListPtr) -> Self {
11401 ptr.untyped()
11402 }
11403}
11404#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11405pub struct ModifierListGreen(pub GreenId);
11406impl TypedSyntaxNode for ModifierList {
11407 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModifierList);
11408 type StablePtr = ModifierListPtr;
11409 type Green = ModifierListGreen;
11410 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11411 ModifierListGreen(
11412 Arc::new(GreenNode {
11413 kind: SyntaxKind::ModifierList,
11414 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11415 })
11416 .intern(db),
11417 )
11418 }
11419 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11420 Self(ElementList::new(node))
11421 }
11422 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11423 if node.kind(db) == SyntaxKind::ModifierList {
11424 Some(Self(ElementList::new(node)))
11425 } else {
11426 None
11427 }
11428 }
11429 fn as_syntax_node(&self) -> SyntaxNode {
11430 self.node.clone()
11431 }
11432 fn stable_ptr(&self) -> Self::StablePtr {
11433 ModifierListPtr(self.node.0.stable_ptr)
11434 }
11435}
11436impl From<&ModifierList> for SyntaxStablePtrId {
11437 fn from(node: &ModifierList) -> Self {
11438 node.stable_ptr().untyped()
11439 }
11440}
11441#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11442pub enum Modifier {
11443 Ref(TerminalRef),
11444 Mut(TerminalMut),
11445}
11446#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11447pub struct ModifierPtr(pub SyntaxStablePtrId);
11448impl TypedStablePtr for ModifierPtr {
11449 type SyntaxNode = Modifier;
11450 fn untyped(&self) -> SyntaxStablePtrId {
11451 self.0
11452 }
11453 fn lookup(&self, db: &dyn SyntaxGroup) -> Modifier {
11454 Modifier::from_syntax_node(db, self.0.lookup(db))
11455 }
11456}
11457impl From<ModifierPtr> for SyntaxStablePtrId {
11458 fn from(ptr: ModifierPtr) -> Self {
11459 ptr.untyped()
11460 }
11461}
11462impl From<TerminalRefPtr> for ModifierPtr {
11463 fn from(value: TerminalRefPtr) -> Self {
11464 Self(value.0)
11465 }
11466}
11467impl From<TerminalMutPtr> for ModifierPtr {
11468 fn from(value: TerminalMutPtr) -> Self {
11469 Self(value.0)
11470 }
11471}
11472impl From<TerminalRefGreen> for ModifierGreen {
11473 fn from(value: TerminalRefGreen) -> Self {
11474 Self(value.0)
11475 }
11476}
11477impl From<TerminalMutGreen> for ModifierGreen {
11478 fn from(value: TerminalMutGreen) -> Self {
11479 Self(value.0)
11480 }
11481}
11482#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11483pub struct ModifierGreen(pub GreenId);
11484impl TypedSyntaxNode for Modifier {
11485 const OPTIONAL_KIND: Option<SyntaxKind> = None;
11486 type StablePtr = ModifierPtr;
11487 type Green = ModifierGreen;
11488 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11489 panic!("No missing variant.");
11490 }
11491 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11492 let kind = node.kind(db);
11493 match kind {
11494 SyntaxKind::TerminalRef => Modifier::Ref(TerminalRef::from_syntax_node(db, node)),
11495 SyntaxKind::TerminalMut => Modifier::Mut(TerminalMut::from_syntax_node(db, node)),
11496 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Modifier"),
11497 }
11498 }
11499 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11500 let kind = node.kind(db);
11501 match kind {
11502 SyntaxKind::TerminalRef => Some(Modifier::Ref(TerminalRef::from_syntax_node(db, node))),
11503 SyntaxKind::TerminalMut => Some(Modifier::Mut(TerminalMut::from_syntax_node(db, node))),
11504 _ => None,
11505 }
11506 }
11507 fn as_syntax_node(&self) -> SyntaxNode {
11508 match self {
11509 Modifier::Ref(x) => x.as_syntax_node(),
11510 Modifier::Mut(x) => x.as_syntax_node(),
11511 }
11512 }
11513 fn stable_ptr(&self) -> Self::StablePtr {
11514 ModifierPtr(self.as_syntax_node().0.stable_ptr)
11515 }
11516}
11517impl From<&Modifier> for SyntaxStablePtrId {
11518 fn from(node: &Modifier) -> Self {
11519 node.stable_ptr().untyped()
11520 }
11521}
11522impl Modifier {
11523 pub fn is_variant(kind: SyntaxKind) -> bool {
11525 matches!(kind, SyntaxKind::TerminalRef | SyntaxKind::TerminalMut)
11526 }
11527}
11528#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11529pub struct ParamList(ElementList<Param, 2>);
11530impl Deref for ParamList {
11531 type Target = ElementList<Param, 2>;
11532 fn deref(&self) -> &Self::Target {
11533 &self.0
11534 }
11535}
11536impl ParamList {
11537 pub fn new_green(
11538 db: &dyn SyntaxGroup,
11539 children: Vec<ParamListElementOrSeparatorGreen>,
11540 ) -> ParamListGreen {
11541 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
11542 ParamListGreen(
11543 Arc::new(GreenNode {
11544 kind: SyntaxKind::ParamList,
11545 details: GreenNodeDetails::Node {
11546 children: children.iter().map(|x| x.id()).collect(),
11547 width,
11548 },
11549 })
11550 .intern(db),
11551 )
11552 }
11553}
11554#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11555pub struct ParamListPtr(pub SyntaxStablePtrId);
11556impl TypedStablePtr for ParamListPtr {
11557 type SyntaxNode = ParamList;
11558 fn untyped(&self) -> SyntaxStablePtrId {
11559 self.0
11560 }
11561 fn lookup(&self, db: &dyn SyntaxGroup) -> ParamList {
11562 ParamList::from_syntax_node(db, self.0.lookup(db))
11563 }
11564}
11565impl From<ParamListPtr> for SyntaxStablePtrId {
11566 fn from(ptr: ParamListPtr) -> Self {
11567 ptr.untyped()
11568 }
11569}
11570#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11571pub enum ParamListElementOrSeparatorGreen {
11572 Separator(TerminalCommaGreen),
11573 Element(ParamGreen),
11574}
11575impl From<TerminalCommaGreen> for ParamListElementOrSeparatorGreen {
11576 fn from(value: TerminalCommaGreen) -> Self {
11577 ParamListElementOrSeparatorGreen::Separator(value)
11578 }
11579}
11580impl From<ParamGreen> for ParamListElementOrSeparatorGreen {
11581 fn from(value: ParamGreen) -> Self {
11582 ParamListElementOrSeparatorGreen::Element(value)
11583 }
11584}
11585impl ParamListElementOrSeparatorGreen {
11586 fn id(&self) -> GreenId {
11587 match self {
11588 ParamListElementOrSeparatorGreen::Separator(green) => green.0,
11589 ParamListElementOrSeparatorGreen::Element(green) => green.0,
11590 }
11591 }
11592}
11593#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11594pub struct ParamListGreen(pub GreenId);
11595impl TypedSyntaxNode for ParamList {
11596 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ParamList);
11597 type StablePtr = ParamListPtr;
11598 type Green = ParamListGreen;
11599 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11600 ParamListGreen(
11601 Arc::new(GreenNode {
11602 kind: SyntaxKind::ParamList,
11603 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11604 })
11605 .intern(db),
11606 )
11607 }
11608 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11609 Self(ElementList::new(node))
11610 }
11611 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11612 if node.kind(db) == SyntaxKind::ParamList {
11613 Some(Self(ElementList::new(node)))
11614 } else {
11615 None
11616 }
11617 }
11618 fn as_syntax_node(&self) -> SyntaxNode {
11619 self.node.clone()
11620 }
11621 fn stable_ptr(&self) -> Self::StablePtr {
11622 ParamListPtr(self.node.0.stable_ptr)
11623 }
11624}
11625impl From<&ParamList> for SyntaxStablePtrId {
11626 fn from(node: &ParamList) -> Self {
11627 node.stable_ptr().untyped()
11628 }
11629}
11630#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11631pub struct ImplicitsClause {
11632 node: SyntaxNode,
11633 children: Arc<[SyntaxNode]>,
11634}
11635impl ImplicitsClause {
11636 pub const INDEX_IMPLICITS_KW: usize = 0;
11637 pub const INDEX_LPAREN: usize = 1;
11638 pub const INDEX_IMPLICITS: usize = 2;
11639 pub const INDEX_RPAREN: usize = 3;
11640 pub fn new_green(
11641 db: &dyn SyntaxGroup,
11642 implicits_kw: TerminalImplicitsGreen,
11643 lparen: TerminalLParenGreen,
11644 implicits: ImplicitsListGreen,
11645 rparen: TerminalRParenGreen,
11646 ) -> ImplicitsClauseGreen {
11647 let children: Vec<GreenId> = vec![implicits_kw.0, lparen.0, implicits.0, rparen.0];
11648 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11649 ImplicitsClauseGreen(
11650 Arc::new(GreenNode {
11651 kind: SyntaxKind::ImplicitsClause,
11652 details: GreenNodeDetails::Node { children, width },
11653 })
11654 .intern(db),
11655 )
11656 }
11657}
11658impl ImplicitsClause {
11659 pub fn implicits_kw(&self, db: &dyn SyntaxGroup) -> TerminalImplicits {
11660 TerminalImplicits::from_syntax_node(db, self.children[0].clone())
11661 }
11662 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
11663 TerminalLParen::from_syntax_node(db, self.children[1].clone())
11664 }
11665 pub fn implicits(&self, db: &dyn SyntaxGroup) -> ImplicitsList {
11666 ImplicitsList::from_syntax_node(db, self.children[2].clone())
11667 }
11668 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
11669 TerminalRParen::from_syntax_node(db, self.children[3].clone())
11670 }
11671}
11672#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11673pub struct ImplicitsClausePtr(pub SyntaxStablePtrId);
11674impl ImplicitsClausePtr {}
11675impl TypedStablePtr for ImplicitsClausePtr {
11676 type SyntaxNode = ImplicitsClause;
11677 fn untyped(&self) -> SyntaxStablePtrId {
11678 self.0
11679 }
11680 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplicitsClause {
11681 ImplicitsClause::from_syntax_node(db, self.0.lookup(db))
11682 }
11683}
11684impl From<ImplicitsClausePtr> for SyntaxStablePtrId {
11685 fn from(ptr: ImplicitsClausePtr) -> Self {
11686 ptr.untyped()
11687 }
11688}
11689#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11690pub struct ImplicitsClauseGreen(pub GreenId);
11691impl TypedSyntaxNode for ImplicitsClause {
11692 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplicitsClause);
11693 type StablePtr = ImplicitsClausePtr;
11694 type Green = ImplicitsClauseGreen;
11695 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11696 ImplicitsClauseGreen(
11697 Arc::new(GreenNode {
11698 kind: SyntaxKind::ImplicitsClause,
11699 details: GreenNodeDetails::Node {
11700 children: vec![
11701 TerminalImplicits::missing(db).0,
11702 TerminalLParen::missing(db).0,
11703 ImplicitsList::missing(db).0,
11704 TerminalRParen::missing(db).0,
11705 ],
11706 width: TextWidth::default(),
11707 },
11708 })
11709 .intern(db),
11710 )
11711 }
11712 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11713 let kind = node.kind(db);
11714 assert_eq!(
11715 kind,
11716 SyntaxKind::ImplicitsClause,
11717 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11718 kind,
11719 SyntaxKind::ImplicitsClause
11720 );
11721 let children = db.get_children(node.clone());
11722 Self { node, children }
11723 }
11724 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11725 let kind = node.kind(db);
11726 if kind == SyntaxKind::ImplicitsClause {
11727 Some(Self::from_syntax_node(db, node))
11728 } else {
11729 None
11730 }
11731 }
11732 fn as_syntax_node(&self) -> SyntaxNode {
11733 self.node.clone()
11734 }
11735 fn stable_ptr(&self) -> Self::StablePtr {
11736 ImplicitsClausePtr(self.node.0.stable_ptr)
11737 }
11738}
11739impl From<&ImplicitsClause> for SyntaxStablePtrId {
11740 fn from(node: &ImplicitsClause) -> Self {
11741 node.stable_ptr().untyped()
11742 }
11743}
11744#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11745pub struct ImplicitsList(ElementList<ExprPath, 2>);
11746impl Deref for ImplicitsList {
11747 type Target = ElementList<ExprPath, 2>;
11748 fn deref(&self) -> &Self::Target {
11749 &self.0
11750 }
11751}
11752impl ImplicitsList {
11753 pub fn new_green(
11754 db: &dyn SyntaxGroup,
11755 children: Vec<ImplicitsListElementOrSeparatorGreen>,
11756 ) -> ImplicitsListGreen {
11757 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
11758 ImplicitsListGreen(
11759 Arc::new(GreenNode {
11760 kind: SyntaxKind::ImplicitsList,
11761 details: GreenNodeDetails::Node {
11762 children: children.iter().map(|x| x.id()).collect(),
11763 width,
11764 },
11765 })
11766 .intern(db),
11767 )
11768 }
11769}
11770#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11771pub struct ImplicitsListPtr(pub SyntaxStablePtrId);
11772impl TypedStablePtr for ImplicitsListPtr {
11773 type SyntaxNode = ImplicitsList;
11774 fn untyped(&self) -> SyntaxStablePtrId {
11775 self.0
11776 }
11777 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplicitsList {
11778 ImplicitsList::from_syntax_node(db, self.0.lookup(db))
11779 }
11780}
11781impl From<ImplicitsListPtr> for SyntaxStablePtrId {
11782 fn from(ptr: ImplicitsListPtr) -> Self {
11783 ptr.untyped()
11784 }
11785}
11786#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11787pub enum ImplicitsListElementOrSeparatorGreen {
11788 Separator(TerminalCommaGreen),
11789 Element(ExprPathGreen),
11790}
11791impl From<TerminalCommaGreen> for ImplicitsListElementOrSeparatorGreen {
11792 fn from(value: TerminalCommaGreen) -> Self {
11793 ImplicitsListElementOrSeparatorGreen::Separator(value)
11794 }
11795}
11796impl From<ExprPathGreen> for ImplicitsListElementOrSeparatorGreen {
11797 fn from(value: ExprPathGreen) -> Self {
11798 ImplicitsListElementOrSeparatorGreen::Element(value)
11799 }
11800}
11801impl ImplicitsListElementOrSeparatorGreen {
11802 fn id(&self) -> GreenId {
11803 match self {
11804 ImplicitsListElementOrSeparatorGreen::Separator(green) => green.0,
11805 ImplicitsListElementOrSeparatorGreen::Element(green) => green.0,
11806 }
11807 }
11808}
11809#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11810pub struct ImplicitsListGreen(pub GreenId);
11811impl TypedSyntaxNode for ImplicitsList {
11812 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplicitsList);
11813 type StablePtr = ImplicitsListPtr;
11814 type Green = ImplicitsListGreen;
11815 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11816 ImplicitsListGreen(
11817 Arc::new(GreenNode {
11818 kind: SyntaxKind::ImplicitsList,
11819 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11820 })
11821 .intern(db),
11822 )
11823 }
11824 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11825 Self(ElementList::new(node))
11826 }
11827 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11828 if node.kind(db) == SyntaxKind::ImplicitsList {
11829 Some(Self(ElementList::new(node)))
11830 } else {
11831 None
11832 }
11833 }
11834 fn as_syntax_node(&self) -> SyntaxNode {
11835 self.node.clone()
11836 }
11837 fn stable_ptr(&self) -> Self::StablePtr {
11838 ImplicitsListPtr(self.node.0.stable_ptr)
11839 }
11840}
11841impl From<&ImplicitsList> for SyntaxStablePtrId {
11842 fn from(node: &ImplicitsList) -> Self {
11843 node.stable_ptr().untyped()
11844 }
11845}
11846#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11847pub enum OptionImplicitsClause {
11848 Empty(OptionImplicitsClauseEmpty),
11849 ImplicitsClause(ImplicitsClause),
11850}
11851#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11852pub struct OptionImplicitsClausePtr(pub SyntaxStablePtrId);
11853impl TypedStablePtr for OptionImplicitsClausePtr {
11854 type SyntaxNode = OptionImplicitsClause;
11855 fn untyped(&self) -> SyntaxStablePtrId {
11856 self.0
11857 }
11858 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClause {
11859 OptionImplicitsClause::from_syntax_node(db, self.0.lookup(db))
11860 }
11861}
11862impl From<OptionImplicitsClausePtr> for SyntaxStablePtrId {
11863 fn from(ptr: OptionImplicitsClausePtr) -> Self {
11864 ptr.untyped()
11865 }
11866}
11867impl From<OptionImplicitsClauseEmptyPtr> for OptionImplicitsClausePtr {
11868 fn from(value: OptionImplicitsClauseEmptyPtr) -> Self {
11869 Self(value.0)
11870 }
11871}
11872impl From<ImplicitsClausePtr> for OptionImplicitsClausePtr {
11873 fn from(value: ImplicitsClausePtr) -> Self {
11874 Self(value.0)
11875 }
11876}
11877impl From<OptionImplicitsClauseEmptyGreen> for OptionImplicitsClauseGreen {
11878 fn from(value: OptionImplicitsClauseEmptyGreen) -> Self {
11879 Self(value.0)
11880 }
11881}
11882impl From<ImplicitsClauseGreen> for OptionImplicitsClauseGreen {
11883 fn from(value: ImplicitsClauseGreen) -> Self {
11884 Self(value.0)
11885 }
11886}
11887#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11888pub struct OptionImplicitsClauseGreen(pub GreenId);
11889impl TypedSyntaxNode for OptionImplicitsClause {
11890 const OPTIONAL_KIND: Option<SyntaxKind> = None;
11891 type StablePtr = OptionImplicitsClausePtr;
11892 type Green = OptionImplicitsClauseGreen;
11893 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11894 panic!("No missing variant.");
11895 }
11896 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11897 let kind = node.kind(db);
11898 match kind {
11899 SyntaxKind::OptionImplicitsClauseEmpty => {
11900 OptionImplicitsClause::Empty(OptionImplicitsClauseEmpty::from_syntax_node(db, node))
11901 }
11902 SyntaxKind::ImplicitsClause => {
11903 OptionImplicitsClause::ImplicitsClause(ImplicitsClause::from_syntax_node(db, node))
11904 }
11905 _ => panic!(
11906 "Unexpected syntax kind {:?} when constructing {}.",
11907 kind, "OptionImplicitsClause"
11908 ),
11909 }
11910 }
11911 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
11912 let kind = node.kind(db);
11913 match kind {
11914 SyntaxKind::OptionImplicitsClauseEmpty => Some(OptionImplicitsClause::Empty(
11915 OptionImplicitsClauseEmpty::from_syntax_node(db, node),
11916 )),
11917 SyntaxKind::ImplicitsClause => Some(OptionImplicitsClause::ImplicitsClause(
11918 ImplicitsClause::from_syntax_node(db, node),
11919 )),
11920 _ => None,
11921 }
11922 }
11923 fn as_syntax_node(&self) -> SyntaxNode {
11924 match self {
11925 OptionImplicitsClause::Empty(x) => x.as_syntax_node(),
11926 OptionImplicitsClause::ImplicitsClause(x) => x.as_syntax_node(),
11927 }
11928 }
11929 fn stable_ptr(&self) -> Self::StablePtr {
11930 OptionImplicitsClausePtr(self.as_syntax_node().0.stable_ptr)
11931 }
11932}
11933impl From<&OptionImplicitsClause> for SyntaxStablePtrId {
11934 fn from(node: &OptionImplicitsClause) -> Self {
11935 node.stable_ptr().untyped()
11936 }
11937}
11938impl OptionImplicitsClause {
11939 pub fn is_variant(kind: SyntaxKind) -> bool {
11941 matches!(kind, SyntaxKind::OptionImplicitsClauseEmpty | SyntaxKind::ImplicitsClause)
11942 }
11943}
11944#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11945pub struct OptionImplicitsClauseEmpty {
11946 node: SyntaxNode,
11947 children: Arc<[SyntaxNode]>,
11948}
11949impl OptionImplicitsClauseEmpty {
11950 pub fn new_green(db: &dyn SyntaxGroup) -> OptionImplicitsClauseEmptyGreen {
11951 let children: Vec<GreenId> = vec![];
11952 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11953 OptionImplicitsClauseEmptyGreen(
11954 Arc::new(GreenNode {
11955 kind: SyntaxKind::OptionImplicitsClauseEmpty,
11956 details: GreenNodeDetails::Node { children, width },
11957 })
11958 .intern(db),
11959 )
11960 }
11961}
11962impl OptionImplicitsClauseEmpty {}
11963#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11964pub struct OptionImplicitsClauseEmptyPtr(pub SyntaxStablePtrId);
11965impl OptionImplicitsClauseEmptyPtr {}
11966impl TypedStablePtr for OptionImplicitsClauseEmptyPtr {
11967 type SyntaxNode = OptionImplicitsClauseEmpty;
11968 fn untyped(&self) -> SyntaxStablePtrId {
11969 self.0
11970 }
11971 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClauseEmpty {
11972 OptionImplicitsClauseEmpty::from_syntax_node(db, self.0.lookup(db))
11973 }
11974}
11975impl From<OptionImplicitsClauseEmptyPtr> for SyntaxStablePtrId {
11976 fn from(ptr: OptionImplicitsClauseEmptyPtr) -> Self {
11977 ptr.untyped()
11978 }
11979}
11980#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11981pub struct OptionImplicitsClauseEmptyGreen(pub GreenId);
11982impl TypedSyntaxNode for OptionImplicitsClauseEmpty {
11983 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionImplicitsClauseEmpty);
11984 type StablePtr = OptionImplicitsClauseEmptyPtr;
11985 type Green = OptionImplicitsClauseEmptyGreen;
11986 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11987 OptionImplicitsClauseEmptyGreen(
11988 Arc::new(GreenNode {
11989 kind: SyntaxKind::OptionImplicitsClauseEmpty,
11990 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11991 })
11992 .intern(db),
11993 )
11994 }
11995 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11996 let kind = node.kind(db);
11997 assert_eq!(
11998 kind,
11999 SyntaxKind::OptionImplicitsClauseEmpty,
12000 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12001 kind,
12002 SyntaxKind::OptionImplicitsClauseEmpty
12003 );
12004 let children = db.get_children(node.clone());
12005 Self { node, children }
12006 }
12007 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12008 let kind = node.kind(db);
12009 if kind == SyntaxKind::OptionImplicitsClauseEmpty {
12010 Some(Self::from_syntax_node(db, node))
12011 } else {
12012 None
12013 }
12014 }
12015 fn as_syntax_node(&self) -> SyntaxNode {
12016 self.node.clone()
12017 }
12018 fn stable_ptr(&self) -> Self::StablePtr {
12019 OptionImplicitsClauseEmptyPtr(self.node.0.stable_ptr)
12020 }
12021}
12022impl From<&OptionImplicitsClauseEmpty> for SyntaxStablePtrId {
12023 fn from(node: &OptionImplicitsClauseEmpty) -> Self {
12024 node.stable_ptr().untyped()
12025 }
12026}
12027#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12028pub enum OptionTerminalNoPanic {
12029 Empty(OptionTerminalNoPanicEmpty),
12030 TerminalNoPanic(TerminalNoPanic),
12031}
12032#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12033pub struct OptionTerminalNoPanicPtr(pub SyntaxStablePtrId);
12034impl TypedStablePtr for OptionTerminalNoPanicPtr {
12035 type SyntaxNode = OptionTerminalNoPanic;
12036 fn untyped(&self) -> SyntaxStablePtrId {
12037 self.0
12038 }
12039 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
12040 OptionTerminalNoPanic::from_syntax_node(db, self.0.lookup(db))
12041 }
12042}
12043impl From<OptionTerminalNoPanicPtr> for SyntaxStablePtrId {
12044 fn from(ptr: OptionTerminalNoPanicPtr) -> Self {
12045 ptr.untyped()
12046 }
12047}
12048impl From<OptionTerminalNoPanicEmptyPtr> for OptionTerminalNoPanicPtr {
12049 fn from(value: OptionTerminalNoPanicEmptyPtr) -> Self {
12050 Self(value.0)
12051 }
12052}
12053impl From<TerminalNoPanicPtr> for OptionTerminalNoPanicPtr {
12054 fn from(value: TerminalNoPanicPtr) -> Self {
12055 Self(value.0)
12056 }
12057}
12058impl From<OptionTerminalNoPanicEmptyGreen> for OptionTerminalNoPanicGreen {
12059 fn from(value: OptionTerminalNoPanicEmptyGreen) -> Self {
12060 Self(value.0)
12061 }
12062}
12063impl From<TerminalNoPanicGreen> for OptionTerminalNoPanicGreen {
12064 fn from(value: TerminalNoPanicGreen) -> Self {
12065 Self(value.0)
12066 }
12067}
12068#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12069pub struct OptionTerminalNoPanicGreen(pub GreenId);
12070impl TypedSyntaxNode for OptionTerminalNoPanic {
12071 const OPTIONAL_KIND: Option<SyntaxKind> = None;
12072 type StablePtr = OptionTerminalNoPanicPtr;
12073 type Green = OptionTerminalNoPanicGreen;
12074 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12075 panic!("No missing variant.");
12076 }
12077 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12078 let kind = node.kind(db);
12079 match kind {
12080 SyntaxKind::OptionTerminalNoPanicEmpty => {
12081 OptionTerminalNoPanic::Empty(OptionTerminalNoPanicEmpty::from_syntax_node(db, node))
12082 }
12083 SyntaxKind::TerminalNoPanic => {
12084 OptionTerminalNoPanic::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node))
12085 }
12086 _ => panic!(
12087 "Unexpected syntax kind {:?} when constructing {}.",
12088 kind, "OptionTerminalNoPanic"
12089 ),
12090 }
12091 }
12092 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12093 let kind = node.kind(db);
12094 match kind {
12095 SyntaxKind::OptionTerminalNoPanicEmpty => Some(OptionTerminalNoPanic::Empty(
12096 OptionTerminalNoPanicEmpty::from_syntax_node(db, node),
12097 )),
12098 SyntaxKind::TerminalNoPanic => Some(OptionTerminalNoPanic::TerminalNoPanic(
12099 TerminalNoPanic::from_syntax_node(db, node),
12100 )),
12101 _ => None,
12102 }
12103 }
12104 fn as_syntax_node(&self) -> SyntaxNode {
12105 match self {
12106 OptionTerminalNoPanic::Empty(x) => x.as_syntax_node(),
12107 OptionTerminalNoPanic::TerminalNoPanic(x) => x.as_syntax_node(),
12108 }
12109 }
12110 fn stable_ptr(&self) -> Self::StablePtr {
12111 OptionTerminalNoPanicPtr(self.as_syntax_node().0.stable_ptr)
12112 }
12113}
12114impl From<&OptionTerminalNoPanic> for SyntaxStablePtrId {
12115 fn from(node: &OptionTerminalNoPanic) -> Self {
12116 node.stable_ptr().untyped()
12117 }
12118}
12119impl OptionTerminalNoPanic {
12120 pub fn is_variant(kind: SyntaxKind) -> bool {
12122 matches!(kind, SyntaxKind::OptionTerminalNoPanicEmpty | SyntaxKind::TerminalNoPanic)
12123 }
12124}
12125#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12126pub struct OptionTerminalNoPanicEmpty {
12127 node: SyntaxNode,
12128 children: Arc<[SyntaxNode]>,
12129}
12130impl OptionTerminalNoPanicEmpty {
12131 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalNoPanicEmptyGreen {
12132 let children: Vec<GreenId> = vec![];
12133 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12134 OptionTerminalNoPanicEmptyGreen(
12135 Arc::new(GreenNode {
12136 kind: SyntaxKind::OptionTerminalNoPanicEmpty,
12137 details: GreenNodeDetails::Node { children, width },
12138 })
12139 .intern(db),
12140 )
12141 }
12142}
12143impl OptionTerminalNoPanicEmpty {}
12144#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12145pub struct OptionTerminalNoPanicEmptyPtr(pub SyntaxStablePtrId);
12146impl OptionTerminalNoPanicEmptyPtr {}
12147impl TypedStablePtr for OptionTerminalNoPanicEmptyPtr {
12148 type SyntaxNode = OptionTerminalNoPanicEmpty;
12149 fn untyped(&self) -> SyntaxStablePtrId {
12150 self.0
12151 }
12152 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanicEmpty {
12153 OptionTerminalNoPanicEmpty::from_syntax_node(db, self.0.lookup(db))
12154 }
12155}
12156impl From<OptionTerminalNoPanicEmptyPtr> for SyntaxStablePtrId {
12157 fn from(ptr: OptionTerminalNoPanicEmptyPtr) -> Self {
12158 ptr.untyped()
12159 }
12160}
12161#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12162pub struct OptionTerminalNoPanicEmptyGreen(pub GreenId);
12163impl TypedSyntaxNode for OptionTerminalNoPanicEmpty {
12164 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalNoPanicEmpty);
12165 type StablePtr = OptionTerminalNoPanicEmptyPtr;
12166 type Green = OptionTerminalNoPanicEmptyGreen;
12167 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12168 OptionTerminalNoPanicEmptyGreen(
12169 Arc::new(GreenNode {
12170 kind: SyntaxKind::OptionTerminalNoPanicEmpty,
12171 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12172 })
12173 .intern(db),
12174 )
12175 }
12176 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12177 let kind = node.kind(db);
12178 assert_eq!(
12179 kind,
12180 SyntaxKind::OptionTerminalNoPanicEmpty,
12181 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12182 kind,
12183 SyntaxKind::OptionTerminalNoPanicEmpty
12184 );
12185 let children = db.get_children(node.clone());
12186 Self { node, children }
12187 }
12188 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12189 let kind = node.kind(db);
12190 if kind == SyntaxKind::OptionTerminalNoPanicEmpty {
12191 Some(Self::from_syntax_node(db, node))
12192 } else {
12193 None
12194 }
12195 }
12196 fn as_syntax_node(&self) -> SyntaxNode {
12197 self.node.clone()
12198 }
12199 fn stable_ptr(&self) -> Self::StablePtr {
12200 OptionTerminalNoPanicEmptyPtr(self.node.0.stable_ptr)
12201 }
12202}
12203impl From<&OptionTerminalNoPanicEmpty> for SyntaxStablePtrId {
12204 fn from(node: &OptionTerminalNoPanicEmpty) -> Self {
12205 node.stable_ptr().untyped()
12206 }
12207}
12208#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12209pub struct FunctionSignature {
12210 node: SyntaxNode,
12211 children: Arc<[SyntaxNode]>,
12212}
12213impl FunctionSignature {
12214 pub const INDEX_LPAREN: usize = 0;
12215 pub const INDEX_PARAMETERS: usize = 1;
12216 pub const INDEX_RPAREN: usize = 2;
12217 pub const INDEX_RET_TY: usize = 3;
12218 pub const INDEX_IMPLICITS_CLAUSE: usize = 4;
12219 pub const INDEX_OPTIONAL_NO_PANIC: usize = 5;
12220 pub fn new_green(
12221 db: &dyn SyntaxGroup,
12222 lparen: TerminalLParenGreen,
12223 parameters: ParamListGreen,
12224 rparen: TerminalRParenGreen,
12225 ret_ty: OptionReturnTypeClauseGreen,
12226 implicits_clause: OptionImplicitsClauseGreen,
12227 optional_no_panic: OptionTerminalNoPanicGreen,
12228 ) -> FunctionSignatureGreen {
12229 let children: Vec<GreenId> = vec![
12230 lparen.0,
12231 parameters.0,
12232 rparen.0,
12233 ret_ty.0,
12234 implicits_clause.0,
12235 optional_no_panic.0,
12236 ];
12237 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12238 FunctionSignatureGreen(
12239 Arc::new(GreenNode {
12240 kind: SyntaxKind::FunctionSignature,
12241 details: GreenNodeDetails::Node { children, width },
12242 })
12243 .intern(db),
12244 )
12245 }
12246}
12247impl FunctionSignature {
12248 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
12249 TerminalLParen::from_syntax_node(db, self.children[0].clone())
12250 }
12251 pub fn parameters(&self, db: &dyn SyntaxGroup) -> ParamList {
12252 ParamList::from_syntax_node(db, self.children[1].clone())
12253 }
12254 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
12255 TerminalRParen::from_syntax_node(db, self.children[2].clone())
12256 }
12257 pub fn ret_ty(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
12258 OptionReturnTypeClause::from_syntax_node(db, self.children[3].clone())
12259 }
12260 pub fn implicits_clause(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClause {
12261 OptionImplicitsClause::from_syntax_node(db, self.children[4].clone())
12262 }
12263 pub fn optional_no_panic(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
12264 OptionTerminalNoPanic::from_syntax_node(db, self.children[5].clone())
12265 }
12266}
12267#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12268pub struct FunctionSignaturePtr(pub SyntaxStablePtrId);
12269impl FunctionSignaturePtr {}
12270impl TypedStablePtr for FunctionSignaturePtr {
12271 type SyntaxNode = FunctionSignature;
12272 fn untyped(&self) -> SyntaxStablePtrId {
12273 self.0
12274 }
12275 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionSignature {
12276 FunctionSignature::from_syntax_node(db, self.0.lookup(db))
12277 }
12278}
12279impl From<FunctionSignaturePtr> for SyntaxStablePtrId {
12280 fn from(ptr: FunctionSignaturePtr) -> Self {
12281 ptr.untyped()
12282 }
12283}
12284#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12285pub struct FunctionSignatureGreen(pub GreenId);
12286impl TypedSyntaxNode for FunctionSignature {
12287 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionSignature);
12288 type StablePtr = FunctionSignaturePtr;
12289 type Green = FunctionSignatureGreen;
12290 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12291 FunctionSignatureGreen(
12292 Arc::new(GreenNode {
12293 kind: SyntaxKind::FunctionSignature,
12294 details: GreenNodeDetails::Node {
12295 children: vec![
12296 TerminalLParen::missing(db).0,
12297 ParamList::missing(db).0,
12298 TerminalRParen::missing(db).0,
12299 OptionReturnTypeClause::missing(db).0,
12300 OptionImplicitsClause::missing(db).0,
12301 OptionTerminalNoPanic::missing(db).0,
12302 ],
12303 width: TextWidth::default(),
12304 },
12305 })
12306 .intern(db),
12307 )
12308 }
12309 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12310 let kind = node.kind(db);
12311 assert_eq!(
12312 kind,
12313 SyntaxKind::FunctionSignature,
12314 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12315 kind,
12316 SyntaxKind::FunctionSignature
12317 );
12318 let children = db.get_children(node.clone());
12319 Self { node, children }
12320 }
12321 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12322 let kind = node.kind(db);
12323 if kind == SyntaxKind::FunctionSignature {
12324 Some(Self::from_syntax_node(db, node))
12325 } else {
12326 None
12327 }
12328 }
12329 fn as_syntax_node(&self) -> SyntaxNode {
12330 self.node.clone()
12331 }
12332 fn stable_ptr(&self) -> Self::StablePtr {
12333 FunctionSignaturePtr(self.node.0.stable_ptr)
12334 }
12335}
12336impl From<&FunctionSignature> for SyntaxStablePtrId {
12337 fn from(node: &FunctionSignature) -> Self {
12338 node.stable_ptr().untyped()
12339 }
12340}
12341#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12342pub struct Member {
12343 node: SyntaxNode,
12344 children: Arc<[SyntaxNode]>,
12345}
12346impl Member {
12347 pub const INDEX_ATTRIBUTES: usize = 0;
12348 pub const INDEX_VISIBILITY: usize = 1;
12349 pub const INDEX_NAME: usize = 2;
12350 pub const INDEX_TYPE_CLAUSE: usize = 3;
12351 pub fn new_green(
12352 db: &dyn SyntaxGroup,
12353 attributes: AttributeListGreen,
12354 visibility: VisibilityGreen,
12355 name: TerminalIdentifierGreen,
12356 type_clause: TypeClauseGreen,
12357 ) -> MemberGreen {
12358 let children: Vec<GreenId> = vec![attributes.0, visibility.0, name.0, type_clause.0];
12359 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12360 MemberGreen(
12361 Arc::new(GreenNode {
12362 kind: SyntaxKind::Member,
12363 details: GreenNodeDetails::Node { children, width },
12364 })
12365 .intern(db),
12366 )
12367 }
12368}
12369impl Member {
12370 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
12371 AttributeList::from_syntax_node(db, self.children[0].clone())
12372 }
12373 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
12374 Visibility::from_syntax_node(db, self.children[1].clone())
12375 }
12376 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
12377 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
12378 }
12379 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
12380 TypeClause::from_syntax_node(db, self.children[3].clone())
12381 }
12382}
12383#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12384pub struct MemberPtr(pub SyntaxStablePtrId);
12385impl MemberPtr {
12386 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
12387 let ptr = self.0.lookup_intern(db);
12388 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
12389 TerminalIdentifierGreen(key_fields[0])
12390 } else {
12391 panic!("Unexpected key field query on root.");
12392 }
12393 }
12394}
12395impl TypedStablePtr for MemberPtr {
12396 type SyntaxNode = Member;
12397 fn untyped(&self) -> SyntaxStablePtrId {
12398 self.0
12399 }
12400 fn lookup(&self, db: &dyn SyntaxGroup) -> Member {
12401 Member::from_syntax_node(db, self.0.lookup(db))
12402 }
12403}
12404impl From<MemberPtr> for SyntaxStablePtrId {
12405 fn from(ptr: MemberPtr) -> Self {
12406 ptr.untyped()
12407 }
12408}
12409#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12410pub struct MemberGreen(pub GreenId);
12411impl TypedSyntaxNode for Member {
12412 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Member);
12413 type StablePtr = MemberPtr;
12414 type Green = MemberGreen;
12415 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12416 MemberGreen(
12417 Arc::new(GreenNode {
12418 kind: SyntaxKind::Member,
12419 details: GreenNodeDetails::Node {
12420 children: vec![
12421 AttributeList::missing(db).0,
12422 Visibility::missing(db).0,
12423 TerminalIdentifier::missing(db).0,
12424 TypeClause::missing(db).0,
12425 ],
12426 width: TextWidth::default(),
12427 },
12428 })
12429 .intern(db),
12430 )
12431 }
12432 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12433 let kind = node.kind(db);
12434 assert_eq!(
12435 kind,
12436 SyntaxKind::Member,
12437 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12438 kind,
12439 SyntaxKind::Member
12440 );
12441 let children = db.get_children(node.clone());
12442 Self { node, children }
12443 }
12444 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12445 let kind = node.kind(db);
12446 if kind == SyntaxKind::Member { Some(Self::from_syntax_node(db, node)) } else { None }
12447 }
12448 fn as_syntax_node(&self) -> SyntaxNode {
12449 self.node.clone()
12450 }
12451 fn stable_ptr(&self) -> Self::StablePtr {
12452 MemberPtr(self.node.0.stable_ptr)
12453 }
12454}
12455impl From<&Member> for SyntaxStablePtrId {
12456 fn from(node: &Member) -> Self {
12457 node.stable_ptr().untyped()
12458 }
12459}
12460#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12461pub struct MemberList(ElementList<Member, 2>);
12462impl Deref for MemberList {
12463 type Target = ElementList<Member, 2>;
12464 fn deref(&self) -> &Self::Target {
12465 &self.0
12466 }
12467}
12468impl MemberList {
12469 pub fn new_green(
12470 db: &dyn SyntaxGroup,
12471 children: Vec<MemberListElementOrSeparatorGreen>,
12472 ) -> MemberListGreen {
12473 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
12474 MemberListGreen(
12475 Arc::new(GreenNode {
12476 kind: SyntaxKind::MemberList,
12477 details: GreenNodeDetails::Node {
12478 children: children.iter().map(|x| x.id()).collect(),
12479 width,
12480 },
12481 })
12482 .intern(db),
12483 )
12484 }
12485}
12486#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12487pub struct MemberListPtr(pub SyntaxStablePtrId);
12488impl TypedStablePtr for MemberListPtr {
12489 type SyntaxNode = MemberList;
12490 fn untyped(&self) -> SyntaxStablePtrId {
12491 self.0
12492 }
12493 fn lookup(&self, db: &dyn SyntaxGroup) -> MemberList {
12494 MemberList::from_syntax_node(db, self.0.lookup(db))
12495 }
12496}
12497impl From<MemberListPtr> for SyntaxStablePtrId {
12498 fn from(ptr: MemberListPtr) -> Self {
12499 ptr.untyped()
12500 }
12501}
12502#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12503pub enum MemberListElementOrSeparatorGreen {
12504 Separator(TerminalCommaGreen),
12505 Element(MemberGreen),
12506}
12507impl From<TerminalCommaGreen> for MemberListElementOrSeparatorGreen {
12508 fn from(value: TerminalCommaGreen) -> Self {
12509 MemberListElementOrSeparatorGreen::Separator(value)
12510 }
12511}
12512impl From<MemberGreen> for MemberListElementOrSeparatorGreen {
12513 fn from(value: MemberGreen) -> Self {
12514 MemberListElementOrSeparatorGreen::Element(value)
12515 }
12516}
12517impl MemberListElementOrSeparatorGreen {
12518 fn id(&self) -> GreenId {
12519 match self {
12520 MemberListElementOrSeparatorGreen::Separator(green) => green.0,
12521 MemberListElementOrSeparatorGreen::Element(green) => green.0,
12522 }
12523 }
12524}
12525#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12526pub struct MemberListGreen(pub GreenId);
12527impl TypedSyntaxNode for MemberList {
12528 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MemberList);
12529 type StablePtr = MemberListPtr;
12530 type Green = MemberListGreen;
12531 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12532 MemberListGreen(
12533 Arc::new(GreenNode {
12534 kind: SyntaxKind::MemberList,
12535 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12536 })
12537 .intern(db),
12538 )
12539 }
12540 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12541 Self(ElementList::new(node))
12542 }
12543 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12544 if node.kind(db) == SyntaxKind::MemberList {
12545 Some(Self(ElementList::new(node)))
12546 } else {
12547 None
12548 }
12549 }
12550 fn as_syntax_node(&self) -> SyntaxNode {
12551 self.node.clone()
12552 }
12553 fn stable_ptr(&self) -> Self::StablePtr {
12554 MemberListPtr(self.node.0.stable_ptr)
12555 }
12556}
12557impl From<&MemberList> for SyntaxStablePtrId {
12558 fn from(node: &MemberList) -> Self {
12559 node.stable_ptr().untyped()
12560 }
12561}
12562#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12563pub struct Variant {
12564 node: SyntaxNode,
12565 children: Arc<[SyntaxNode]>,
12566}
12567impl Variant {
12568 pub const INDEX_ATTRIBUTES: usize = 0;
12569 pub const INDEX_NAME: usize = 1;
12570 pub const INDEX_TYPE_CLAUSE: usize = 2;
12571 pub fn new_green(
12572 db: &dyn SyntaxGroup,
12573 attributes: AttributeListGreen,
12574 name: TerminalIdentifierGreen,
12575 type_clause: OptionTypeClauseGreen,
12576 ) -> VariantGreen {
12577 let children: Vec<GreenId> = vec![attributes.0, name.0, type_clause.0];
12578 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12579 VariantGreen(
12580 Arc::new(GreenNode {
12581 kind: SyntaxKind::Variant,
12582 details: GreenNodeDetails::Node { children, width },
12583 })
12584 .intern(db),
12585 )
12586 }
12587}
12588impl Variant {
12589 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
12590 AttributeList::from_syntax_node(db, self.children[0].clone())
12591 }
12592 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
12593 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
12594 }
12595 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
12596 OptionTypeClause::from_syntax_node(db, self.children[2].clone())
12597 }
12598}
12599#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12600pub struct VariantPtr(pub SyntaxStablePtrId);
12601impl VariantPtr {
12602 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
12603 let ptr = self.0.lookup_intern(db);
12604 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
12605 TerminalIdentifierGreen(key_fields[0])
12606 } else {
12607 panic!("Unexpected key field query on root.");
12608 }
12609 }
12610}
12611impl TypedStablePtr for VariantPtr {
12612 type SyntaxNode = Variant;
12613 fn untyped(&self) -> SyntaxStablePtrId {
12614 self.0
12615 }
12616 fn lookup(&self, db: &dyn SyntaxGroup) -> Variant {
12617 Variant::from_syntax_node(db, self.0.lookup(db))
12618 }
12619}
12620impl From<VariantPtr> for SyntaxStablePtrId {
12621 fn from(ptr: VariantPtr) -> Self {
12622 ptr.untyped()
12623 }
12624}
12625#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12626pub struct VariantGreen(pub GreenId);
12627impl TypedSyntaxNode for Variant {
12628 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Variant);
12629 type StablePtr = VariantPtr;
12630 type Green = VariantGreen;
12631 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12632 VariantGreen(
12633 Arc::new(GreenNode {
12634 kind: SyntaxKind::Variant,
12635 details: GreenNodeDetails::Node {
12636 children: vec![
12637 AttributeList::missing(db).0,
12638 TerminalIdentifier::missing(db).0,
12639 OptionTypeClause::missing(db).0,
12640 ],
12641 width: TextWidth::default(),
12642 },
12643 })
12644 .intern(db),
12645 )
12646 }
12647 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12648 let kind = node.kind(db);
12649 assert_eq!(
12650 kind,
12651 SyntaxKind::Variant,
12652 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12653 kind,
12654 SyntaxKind::Variant
12655 );
12656 let children = db.get_children(node.clone());
12657 Self { node, children }
12658 }
12659 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12660 let kind = node.kind(db);
12661 if kind == SyntaxKind::Variant { Some(Self::from_syntax_node(db, node)) } else { None }
12662 }
12663 fn as_syntax_node(&self) -> SyntaxNode {
12664 self.node.clone()
12665 }
12666 fn stable_ptr(&self) -> Self::StablePtr {
12667 VariantPtr(self.node.0.stable_ptr)
12668 }
12669}
12670impl From<&Variant> for SyntaxStablePtrId {
12671 fn from(node: &Variant) -> Self {
12672 node.stable_ptr().untyped()
12673 }
12674}
12675#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12676pub struct VariantList(ElementList<Variant, 2>);
12677impl Deref for VariantList {
12678 type Target = ElementList<Variant, 2>;
12679 fn deref(&self) -> &Self::Target {
12680 &self.0
12681 }
12682}
12683impl VariantList {
12684 pub fn new_green(
12685 db: &dyn SyntaxGroup,
12686 children: Vec<VariantListElementOrSeparatorGreen>,
12687 ) -> VariantListGreen {
12688 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
12689 VariantListGreen(
12690 Arc::new(GreenNode {
12691 kind: SyntaxKind::VariantList,
12692 details: GreenNodeDetails::Node {
12693 children: children.iter().map(|x| x.id()).collect(),
12694 width,
12695 },
12696 })
12697 .intern(db),
12698 )
12699 }
12700}
12701#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12702pub struct VariantListPtr(pub SyntaxStablePtrId);
12703impl TypedStablePtr for VariantListPtr {
12704 type SyntaxNode = VariantList;
12705 fn untyped(&self) -> SyntaxStablePtrId {
12706 self.0
12707 }
12708 fn lookup(&self, db: &dyn SyntaxGroup) -> VariantList {
12709 VariantList::from_syntax_node(db, self.0.lookup(db))
12710 }
12711}
12712impl From<VariantListPtr> for SyntaxStablePtrId {
12713 fn from(ptr: VariantListPtr) -> Self {
12714 ptr.untyped()
12715 }
12716}
12717#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12718pub enum VariantListElementOrSeparatorGreen {
12719 Separator(TerminalCommaGreen),
12720 Element(VariantGreen),
12721}
12722impl From<TerminalCommaGreen> for VariantListElementOrSeparatorGreen {
12723 fn from(value: TerminalCommaGreen) -> Self {
12724 VariantListElementOrSeparatorGreen::Separator(value)
12725 }
12726}
12727impl From<VariantGreen> for VariantListElementOrSeparatorGreen {
12728 fn from(value: VariantGreen) -> Self {
12729 VariantListElementOrSeparatorGreen::Element(value)
12730 }
12731}
12732impl VariantListElementOrSeparatorGreen {
12733 fn id(&self) -> GreenId {
12734 match self {
12735 VariantListElementOrSeparatorGreen::Separator(green) => green.0,
12736 VariantListElementOrSeparatorGreen::Element(green) => green.0,
12737 }
12738 }
12739}
12740#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12741pub struct VariantListGreen(pub GreenId);
12742impl TypedSyntaxNode for VariantList {
12743 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VariantList);
12744 type StablePtr = VariantListPtr;
12745 type Green = VariantListGreen;
12746 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12747 VariantListGreen(
12748 Arc::new(GreenNode {
12749 kind: SyntaxKind::VariantList,
12750 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12751 })
12752 .intern(db),
12753 )
12754 }
12755 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12756 Self(ElementList::new(node))
12757 }
12758 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
12759 if node.kind(db) == SyntaxKind::VariantList {
12760 Some(Self(ElementList::new(node)))
12761 } else {
12762 None
12763 }
12764 }
12765 fn as_syntax_node(&self) -> SyntaxNode {
12766 self.node.clone()
12767 }
12768 fn stable_ptr(&self) -> Self::StablePtr {
12769 VariantListPtr(self.node.0.stable_ptr)
12770 }
12771}
12772impl From<&VariantList> for SyntaxStablePtrId {
12773 fn from(node: &VariantList) -> Self {
12774 node.stable_ptr().untyped()
12775 }
12776}
12777#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12778pub enum ModuleItem {
12779 Constant(ItemConstant),
12780 Module(ItemModule),
12781 Use(ItemUse),
12782 FreeFunction(FunctionWithBody),
12783 ExternFunction(ItemExternFunction),
12784 ExternType(ItemExternType),
12785 Trait(ItemTrait),
12786 Impl(ItemImpl),
12787 ImplAlias(ItemImplAlias),
12788 Struct(ItemStruct),
12789 Enum(ItemEnum),
12790 TypeAlias(ItemTypeAlias),
12791 InlineMacro(ItemInlineMacro),
12792 HeaderDoc(ItemHeaderDoc),
12793 Missing(ModuleItemMissing),
12794}
12795#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12796pub struct ModuleItemPtr(pub SyntaxStablePtrId);
12797impl TypedStablePtr for ModuleItemPtr {
12798 type SyntaxNode = ModuleItem;
12799 fn untyped(&self) -> SyntaxStablePtrId {
12800 self.0
12801 }
12802 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItem {
12803 ModuleItem::from_syntax_node(db, self.0.lookup(db))
12804 }
12805}
12806impl From<ModuleItemPtr> for SyntaxStablePtrId {
12807 fn from(ptr: ModuleItemPtr) -> Self {
12808 ptr.untyped()
12809 }
12810}
12811impl From<ItemConstantPtr> for ModuleItemPtr {
12812 fn from(value: ItemConstantPtr) -> Self {
12813 Self(value.0)
12814 }
12815}
12816impl From<ItemModulePtr> for ModuleItemPtr {
12817 fn from(value: ItemModulePtr) -> Self {
12818 Self(value.0)
12819 }
12820}
12821impl From<ItemUsePtr> for ModuleItemPtr {
12822 fn from(value: ItemUsePtr) -> Self {
12823 Self(value.0)
12824 }
12825}
12826impl From<FunctionWithBodyPtr> for ModuleItemPtr {
12827 fn from(value: FunctionWithBodyPtr) -> Self {
12828 Self(value.0)
12829 }
12830}
12831impl From<ItemExternFunctionPtr> for ModuleItemPtr {
12832 fn from(value: ItemExternFunctionPtr) -> Self {
12833 Self(value.0)
12834 }
12835}
12836impl From<ItemExternTypePtr> for ModuleItemPtr {
12837 fn from(value: ItemExternTypePtr) -> Self {
12838 Self(value.0)
12839 }
12840}
12841impl From<ItemTraitPtr> for ModuleItemPtr {
12842 fn from(value: ItemTraitPtr) -> Self {
12843 Self(value.0)
12844 }
12845}
12846impl From<ItemImplPtr> for ModuleItemPtr {
12847 fn from(value: ItemImplPtr) -> Self {
12848 Self(value.0)
12849 }
12850}
12851impl From<ItemImplAliasPtr> for ModuleItemPtr {
12852 fn from(value: ItemImplAliasPtr) -> Self {
12853 Self(value.0)
12854 }
12855}
12856impl From<ItemStructPtr> for ModuleItemPtr {
12857 fn from(value: ItemStructPtr) -> Self {
12858 Self(value.0)
12859 }
12860}
12861impl From<ItemEnumPtr> for ModuleItemPtr {
12862 fn from(value: ItemEnumPtr) -> Self {
12863 Self(value.0)
12864 }
12865}
12866impl From<ItemTypeAliasPtr> for ModuleItemPtr {
12867 fn from(value: ItemTypeAliasPtr) -> Self {
12868 Self(value.0)
12869 }
12870}
12871impl From<ItemInlineMacroPtr> for ModuleItemPtr {
12872 fn from(value: ItemInlineMacroPtr) -> Self {
12873 Self(value.0)
12874 }
12875}
12876impl From<ItemHeaderDocPtr> for ModuleItemPtr {
12877 fn from(value: ItemHeaderDocPtr) -> Self {
12878 Self(value.0)
12879 }
12880}
12881impl From<ModuleItemMissingPtr> for ModuleItemPtr {
12882 fn from(value: ModuleItemMissingPtr) -> Self {
12883 Self(value.0)
12884 }
12885}
12886impl From<ItemConstantGreen> for ModuleItemGreen {
12887 fn from(value: ItemConstantGreen) -> Self {
12888 Self(value.0)
12889 }
12890}
12891impl From<ItemModuleGreen> for ModuleItemGreen {
12892 fn from(value: ItemModuleGreen) -> Self {
12893 Self(value.0)
12894 }
12895}
12896impl From<ItemUseGreen> for ModuleItemGreen {
12897 fn from(value: ItemUseGreen) -> Self {
12898 Self(value.0)
12899 }
12900}
12901impl From<FunctionWithBodyGreen> for ModuleItemGreen {
12902 fn from(value: FunctionWithBodyGreen) -> Self {
12903 Self(value.0)
12904 }
12905}
12906impl From<ItemExternFunctionGreen> for ModuleItemGreen {
12907 fn from(value: ItemExternFunctionGreen) -> Self {
12908 Self(value.0)
12909 }
12910}
12911impl From<ItemExternTypeGreen> for ModuleItemGreen {
12912 fn from(value: ItemExternTypeGreen) -> Self {
12913 Self(value.0)
12914 }
12915}
12916impl From<ItemTraitGreen> for ModuleItemGreen {
12917 fn from(value: ItemTraitGreen) -> Self {
12918 Self(value.0)
12919 }
12920}
12921impl From<ItemImplGreen> for ModuleItemGreen {
12922 fn from(value: ItemImplGreen) -> Self {
12923 Self(value.0)
12924 }
12925}
12926impl From<ItemImplAliasGreen> for ModuleItemGreen {
12927 fn from(value: ItemImplAliasGreen) -> Self {
12928 Self(value.0)
12929 }
12930}
12931impl From<ItemStructGreen> for ModuleItemGreen {
12932 fn from(value: ItemStructGreen) -> Self {
12933 Self(value.0)
12934 }
12935}
12936impl From<ItemEnumGreen> for ModuleItemGreen {
12937 fn from(value: ItemEnumGreen) -> Self {
12938 Self(value.0)
12939 }
12940}
12941impl From<ItemTypeAliasGreen> for ModuleItemGreen {
12942 fn from(value: ItemTypeAliasGreen) -> Self {
12943 Self(value.0)
12944 }
12945}
12946impl From<ItemInlineMacroGreen> for ModuleItemGreen {
12947 fn from(value: ItemInlineMacroGreen) -> Self {
12948 Self(value.0)
12949 }
12950}
12951impl From<ItemHeaderDocGreen> for ModuleItemGreen {
12952 fn from(value: ItemHeaderDocGreen) -> Self {
12953 Self(value.0)
12954 }
12955}
12956impl From<ModuleItemMissingGreen> for ModuleItemGreen {
12957 fn from(value: ModuleItemMissingGreen) -> Self {
12958 Self(value.0)
12959 }
12960}
12961#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12962pub struct ModuleItemGreen(pub GreenId);
12963impl TypedSyntaxNode for ModuleItem {
12964 const OPTIONAL_KIND: Option<SyntaxKind> = None;
12965 type StablePtr = ModuleItemPtr;
12966 type Green = ModuleItemGreen;
12967 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12968 ModuleItemGreen(ModuleItemMissing::missing(db).0)
12969 }
12970 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12971 let kind = node.kind(db);
12972 match kind {
12973 SyntaxKind::ItemConstant => {
12974 ModuleItem::Constant(ItemConstant::from_syntax_node(db, node))
12975 }
12976 SyntaxKind::ItemModule => ModuleItem::Module(ItemModule::from_syntax_node(db, node)),
12977 SyntaxKind::ItemUse => ModuleItem::Use(ItemUse::from_syntax_node(db, node)),
12978 SyntaxKind::FunctionWithBody => {
12979 ModuleItem::FreeFunction(FunctionWithBody::from_syntax_node(db, node))
12980 }
12981 SyntaxKind::ItemExternFunction => {
12982 ModuleItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))
12983 }
12984 SyntaxKind::ItemExternType => {
12985 ModuleItem::ExternType(ItemExternType::from_syntax_node(db, node))
12986 }
12987 SyntaxKind::ItemTrait => ModuleItem::Trait(ItemTrait::from_syntax_node(db, node)),
12988 SyntaxKind::ItemImpl => ModuleItem::Impl(ItemImpl::from_syntax_node(db, node)),
12989 SyntaxKind::ItemImplAlias => {
12990 ModuleItem::ImplAlias(ItemImplAlias::from_syntax_node(db, node))
12991 }
12992 SyntaxKind::ItemStruct => ModuleItem::Struct(ItemStruct::from_syntax_node(db, node)),
12993 SyntaxKind::ItemEnum => ModuleItem::Enum(ItemEnum::from_syntax_node(db, node)),
12994 SyntaxKind::ItemTypeAlias => {
12995 ModuleItem::TypeAlias(ItemTypeAlias::from_syntax_node(db, node))
12996 }
12997 SyntaxKind::ItemInlineMacro => {
12998 ModuleItem::InlineMacro(ItemInlineMacro::from_syntax_node(db, node))
12999 }
13000 SyntaxKind::ItemHeaderDoc => {
13001 ModuleItem::HeaderDoc(ItemHeaderDoc::from_syntax_node(db, node))
13002 }
13003 SyntaxKind::ModuleItemMissing => {
13004 ModuleItem::Missing(ModuleItemMissing::from_syntax_node(db, node))
13005 }
13006 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ModuleItem"),
13007 }
13008 }
13009 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13010 let kind = node.kind(db);
13011 match kind {
13012 SyntaxKind::ItemConstant => {
13013 Some(ModuleItem::Constant(ItemConstant::from_syntax_node(db, node)))
13014 }
13015 SyntaxKind::ItemModule => {
13016 Some(ModuleItem::Module(ItemModule::from_syntax_node(db, node)))
13017 }
13018 SyntaxKind::ItemUse => Some(ModuleItem::Use(ItemUse::from_syntax_node(db, node))),
13019 SyntaxKind::FunctionWithBody => {
13020 Some(ModuleItem::FreeFunction(FunctionWithBody::from_syntax_node(db, node)))
13021 }
13022 SyntaxKind::ItemExternFunction => {
13023 Some(ModuleItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node)))
13024 }
13025 SyntaxKind::ItemExternType => {
13026 Some(ModuleItem::ExternType(ItemExternType::from_syntax_node(db, node)))
13027 }
13028 SyntaxKind::ItemTrait => Some(ModuleItem::Trait(ItemTrait::from_syntax_node(db, node))),
13029 SyntaxKind::ItemImpl => Some(ModuleItem::Impl(ItemImpl::from_syntax_node(db, node))),
13030 SyntaxKind::ItemImplAlias => {
13031 Some(ModuleItem::ImplAlias(ItemImplAlias::from_syntax_node(db, node)))
13032 }
13033 SyntaxKind::ItemStruct => {
13034 Some(ModuleItem::Struct(ItemStruct::from_syntax_node(db, node)))
13035 }
13036 SyntaxKind::ItemEnum => Some(ModuleItem::Enum(ItemEnum::from_syntax_node(db, node))),
13037 SyntaxKind::ItemTypeAlias => {
13038 Some(ModuleItem::TypeAlias(ItemTypeAlias::from_syntax_node(db, node)))
13039 }
13040 SyntaxKind::ItemInlineMacro => {
13041 Some(ModuleItem::InlineMacro(ItemInlineMacro::from_syntax_node(db, node)))
13042 }
13043 SyntaxKind::ItemHeaderDoc => {
13044 Some(ModuleItem::HeaderDoc(ItemHeaderDoc::from_syntax_node(db, node)))
13045 }
13046 SyntaxKind::ModuleItemMissing => {
13047 Some(ModuleItem::Missing(ModuleItemMissing::from_syntax_node(db, node)))
13048 }
13049 _ => None,
13050 }
13051 }
13052 fn as_syntax_node(&self) -> SyntaxNode {
13053 match self {
13054 ModuleItem::Constant(x) => x.as_syntax_node(),
13055 ModuleItem::Module(x) => x.as_syntax_node(),
13056 ModuleItem::Use(x) => x.as_syntax_node(),
13057 ModuleItem::FreeFunction(x) => x.as_syntax_node(),
13058 ModuleItem::ExternFunction(x) => x.as_syntax_node(),
13059 ModuleItem::ExternType(x) => x.as_syntax_node(),
13060 ModuleItem::Trait(x) => x.as_syntax_node(),
13061 ModuleItem::Impl(x) => x.as_syntax_node(),
13062 ModuleItem::ImplAlias(x) => x.as_syntax_node(),
13063 ModuleItem::Struct(x) => x.as_syntax_node(),
13064 ModuleItem::Enum(x) => x.as_syntax_node(),
13065 ModuleItem::TypeAlias(x) => x.as_syntax_node(),
13066 ModuleItem::InlineMacro(x) => x.as_syntax_node(),
13067 ModuleItem::HeaderDoc(x) => x.as_syntax_node(),
13068 ModuleItem::Missing(x) => x.as_syntax_node(),
13069 }
13070 }
13071 fn stable_ptr(&self) -> Self::StablePtr {
13072 ModuleItemPtr(self.as_syntax_node().0.stable_ptr)
13073 }
13074}
13075impl From<&ModuleItem> for SyntaxStablePtrId {
13076 fn from(node: &ModuleItem) -> Self {
13077 node.stable_ptr().untyped()
13078 }
13079}
13080impl ModuleItem {
13081 pub fn is_variant(kind: SyntaxKind) -> bool {
13083 matches!(
13084 kind,
13085 SyntaxKind::ItemConstant
13086 | SyntaxKind::ItemModule
13087 | SyntaxKind::ItemUse
13088 | SyntaxKind::FunctionWithBody
13089 | SyntaxKind::ItemExternFunction
13090 | SyntaxKind::ItemExternType
13091 | SyntaxKind::ItemTrait
13092 | SyntaxKind::ItemImpl
13093 | SyntaxKind::ItemImplAlias
13094 | SyntaxKind::ItemStruct
13095 | SyntaxKind::ItemEnum
13096 | SyntaxKind::ItemTypeAlias
13097 | SyntaxKind::ItemInlineMacro
13098 | SyntaxKind::ItemHeaderDoc
13099 | SyntaxKind::ModuleItemMissing
13100 )
13101 }
13102}
13103#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13104pub struct ModuleItemList(ElementList<ModuleItem, 1>);
13105impl Deref for ModuleItemList {
13106 type Target = ElementList<ModuleItem, 1>;
13107 fn deref(&self) -> &Self::Target {
13108 &self.0
13109 }
13110}
13111impl ModuleItemList {
13112 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ModuleItemGreen>) -> ModuleItemListGreen {
13113 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
13114 ModuleItemListGreen(
13115 Arc::new(GreenNode {
13116 kind: SyntaxKind::ModuleItemList,
13117 details: GreenNodeDetails::Node {
13118 children: children.iter().map(|x| x.0).collect(),
13119 width,
13120 },
13121 })
13122 .intern(db),
13123 )
13124 }
13125}
13126#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13127pub struct ModuleItemListPtr(pub SyntaxStablePtrId);
13128impl TypedStablePtr for ModuleItemListPtr {
13129 type SyntaxNode = ModuleItemList;
13130 fn untyped(&self) -> SyntaxStablePtrId {
13131 self.0
13132 }
13133 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
13134 ModuleItemList::from_syntax_node(db, self.0.lookup(db))
13135 }
13136}
13137impl From<ModuleItemListPtr> for SyntaxStablePtrId {
13138 fn from(ptr: ModuleItemListPtr) -> Self {
13139 ptr.untyped()
13140 }
13141}
13142#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13143pub struct ModuleItemListGreen(pub GreenId);
13144impl TypedSyntaxNode for ModuleItemList {
13145 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleItemList);
13146 type StablePtr = ModuleItemListPtr;
13147 type Green = ModuleItemListGreen;
13148 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13149 ModuleItemListGreen(
13150 Arc::new(GreenNode {
13151 kind: SyntaxKind::ModuleItemList,
13152 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
13153 })
13154 .intern(db),
13155 )
13156 }
13157 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13158 Self(ElementList::new(node))
13159 }
13160 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13161 if node.kind(db) == SyntaxKind::ModuleItemList {
13162 Some(Self(ElementList::new(node)))
13163 } else {
13164 None
13165 }
13166 }
13167 fn as_syntax_node(&self) -> SyntaxNode {
13168 self.node.clone()
13169 }
13170 fn stable_ptr(&self) -> Self::StablePtr {
13171 ModuleItemListPtr(self.node.0.stable_ptr)
13172 }
13173}
13174impl From<&ModuleItemList> for SyntaxStablePtrId {
13175 fn from(node: &ModuleItemList) -> Self {
13176 node.stable_ptr().untyped()
13177 }
13178}
13179#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13180pub struct ModuleItemMissing {
13181 node: SyntaxNode,
13182 children: Arc<[SyntaxNode]>,
13183}
13184impl ModuleItemMissing {
13185 pub fn new_green(db: &dyn SyntaxGroup) -> ModuleItemMissingGreen {
13186 let children: Vec<GreenId> = vec![];
13187 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13188 ModuleItemMissingGreen(
13189 Arc::new(GreenNode {
13190 kind: SyntaxKind::ModuleItemMissing,
13191 details: GreenNodeDetails::Node { children, width },
13192 })
13193 .intern(db),
13194 )
13195 }
13196}
13197impl ModuleItemMissing {}
13198#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13199pub struct ModuleItemMissingPtr(pub SyntaxStablePtrId);
13200impl ModuleItemMissingPtr {}
13201impl TypedStablePtr for ModuleItemMissingPtr {
13202 type SyntaxNode = ModuleItemMissing;
13203 fn untyped(&self) -> SyntaxStablePtrId {
13204 self.0
13205 }
13206 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItemMissing {
13207 ModuleItemMissing::from_syntax_node(db, self.0.lookup(db))
13208 }
13209}
13210impl From<ModuleItemMissingPtr> for SyntaxStablePtrId {
13211 fn from(ptr: ModuleItemMissingPtr) -> Self {
13212 ptr.untyped()
13213 }
13214}
13215#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13216pub struct ModuleItemMissingGreen(pub GreenId);
13217impl TypedSyntaxNode for ModuleItemMissing {
13218 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleItemMissing);
13219 type StablePtr = ModuleItemMissingPtr;
13220 type Green = ModuleItemMissingGreen;
13221 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13222 ModuleItemMissingGreen(
13223 Arc::new(GreenNode {
13224 kind: SyntaxKind::ModuleItemMissing,
13225 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
13226 })
13227 .intern(db),
13228 )
13229 }
13230 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13231 let kind = node.kind(db);
13232 assert_eq!(
13233 kind,
13234 SyntaxKind::ModuleItemMissing,
13235 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13236 kind,
13237 SyntaxKind::ModuleItemMissing
13238 );
13239 let children = db.get_children(node.clone());
13240 Self { node, children }
13241 }
13242 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13243 let kind = node.kind(db);
13244 if kind == SyntaxKind::ModuleItemMissing {
13245 Some(Self::from_syntax_node(db, node))
13246 } else {
13247 None
13248 }
13249 }
13250 fn as_syntax_node(&self) -> SyntaxNode {
13251 self.node.clone()
13252 }
13253 fn stable_ptr(&self) -> Self::StablePtr {
13254 ModuleItemMissingPtr(self.node.0.stable_ptr)
13255 }
13256}
13257impl From<&ModuleItemMissing> for SyntaxStablePtrId {
13258 fn from(node: &ModuleItemMissing) -> Self {
13259 node.stable_ptr().untyped()
13260 }
13261}
13262#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13263pub struct Attribute {
13264 node: SyntaxNode,
13265 children: Arc<[SyntaxNode]>,
13266}
13267impl Attribute {
13268 pub const INDEX_HASH: usize = 0;
13269 pub const INDEX_LBRACK: usize = 1;
13270 pub const INDEX_ATTR: usize = 2;
13271 pub const INDEX_ARGUMENTS: usize = 3;
13272 pub const INDEX_RBRACK: usize = 4;
13273 pub fn new_green(
13274 db: &dyn SyntaxGroup,
13275 hash: TerminalHashGreen,
13276 lbrack: TerminalLBrackGreen,
13277 attr: ExprPathGreen,
13278 arguments: OptionArgListParenthesizedGreen,
13279 rbrack: TerminalRBrackGreen,
13280 ) -> AttributeGreen {
13281 let children: Vec<GreenId> = vec![hash.0, lbrack.0, attr.0, arguments.0, rbrack.0];
13282 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13283 AttributeGreen(
13284 Arc::new(GreenNode {
13285 kind: SyntaxKind::Attribute,
13286 details: GreenNodeDetails::Node { children, width },
13287 })
13288 .intern(db),
13289 )
13290 }
13291}
13292impl Attribute {
13293 pub fn hash(&self, db: &dyn SyntaxGroup) -> TerminalHash {
13294 TerminalHash::from_syntax_node(db, self.children[0].clone())
13295 }
13296 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
13297 TerminalLBrack::from_syntax_node(db, self.children[1].clone())
13298 }
13299 pub fn attr(&self, db: &dyn SyntaxGroup) -> ExprPath {
13300 ExprPath::from_syntax_node(db, self.children[2].clone())
13301 }
13302 pub fn arguments(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesized {
13303 OptionArgListParenthesized::from_syntax_node(db, self.children[3].clone())
13304 }
13305 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
13306 TerminalRBrack::from_syntax_node(db, self.children[4].clone())
13307 }
13308}
13309#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13310pub struct AttributePtr(pub SyntaxStablePtrId);
13311impl AttributePtr {}
13312impl TypedStablePtr for AttributePtr {
13313 type SyntaxNode = Attribute;
13314 fn untyped(&self) -> SyntaxStablePtrId {
13315 self.0
13316 }
13317 fn lookup(&self, db: &dyn SyntaxGroup) -> Attribute {
13318 Attribute::from_syntax_node(db, self.0.lookup(db))
13319 }
13320}
13321impl From<AttributePtr> for SyntaxStablePtrId {
13322 fn from(ptr: AttributePtr) -> Self {
13323 ptr.untyped()
13324 }
13325}
13326#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13327pub struct AttributeGreen(pub GreenId);
13328impl TypedSyntaxNode for Attribute {
13329 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Attribute);
13330 type StablePtr = AttributePtr;
13331 type Green = AttributeGreen;
13332 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13333 AttributeGreen(
13334 Arc::new(GreenNode {
13335 kind: SyntaxKind::Attribute,
13336 details: GreenNodeDetails::Node {
13337 children: vec![
13338 TerminalHash::missing(db).0,
13339 TerminalLBrack::missing(db).0,
13340 ExprPath::missing(db).0,
13341 OptionArgListParenthesized::missing(db).0,
13342 TerminalRBrack::missing(db).0,
13343 ],
13344 width: TextWidth::default(),
13345 },
13346 })
13347 .intern(db),
13348 )
13349 }
13350 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13351 let kind = node.kind(db);
13352 assert_eq!(
13353 kind,
13354 SyntaxKind::Attribute,
13355 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13356 kind,
13357 SyntaxKind::Attribute
13358 );
13359 let children = db.get_children(node.clone());
13360 Self { node, children }
13361 }
13362 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13363 let kind = node.kind(db);
13364 if kind == SyntaxKind::Attribute { Some(Self::from_syntax_node(db, node)) } else { None }
13365 }
13366 fn as_syntax_node(&self) -> SyntaxNode {
13367 self.node.clone()
13368 }
13369 fn stable_ptr(&self) -> Self::StablePtr {
13370 AttributePtr(self.node.0.stable_ptr)
13371 }
13372}
13373impl From<&Attribute> for SyntaxStablePtrId {
13374 fn from(node: &Attribute) -> Self {
13375 node.stable_ptr().untyped()
13376 }
13377}
13378#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13379pub struct AttributeList(ElementList<Attribute, 1>);
13380impl Deref for AttributeList {
13381 type Target = ElementList<Attribute, 1>;
13382 fn deref(&self) -> &Self::Target {
13383 &self.0
13384 }
13385}
13386impl AttributeList {
13387 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<AttributeGreen>) -> AttributeListGreen {
13388 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
13389 AttributeListGreen(
13390 Arc::new(GreenNode {
13391 kind: SyntaxKind::AttributeList,
13392 details: GreenNodeDetails::Node {
13393 children: children.iter().map(|x| x.0).collect(),
13394 width,
13395 },
13396 })
13397 .intern(db),
13398 )
13399 }
13400}
13401#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13402pub struct AttributeListPtr(pub SyntaxStablePtrId);
13403impl TypedStablePtr for AttributeListPtr {
13404 type SyntaxNode = AttributeList;
13405 fn untyped(&self) -> SyntaxStablePtrId {
13406 self.0
13407 }
13408 fn lookup(&self, db: &dyn SyntaxGroup) -> AttributeList {
13409 AttributeList::from_syntax_node(db, self.0.lookup(db))
13410 }
13411}
13412impl From<AttributeListPtr> for SyntaxStablePtrId {
13413 fn from(ptr: AttributeListPtr) -> Self {
13414 ptr.untyped()
13415 }
13416}
13417#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13418pub struct AttributeListGreen(pub GreenId);
13419impl TypedSyntaxNode for AttributeList {
13420 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AttributeList);
13421 type StablePtr = AttributeListPtr;
13422 type Green = AttributeListGreen;
13423 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13424 AttributeListGreen(
13425 Arc::new(GreenNode {
13426 kind: SyntaxKind::AttributeList,
13427 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
13428 })
13429 .intern(db),
13430 )
13431 }
13432 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13433 Self(ElementList::new(node))
13434 }
13435 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13436 if node.kind(db) == SyntaxKind::AttributeList {
13437 Some(Self(ElementList::new(node)))
13438 } else {
13439 None
13440 }
13441 }
13442 fn as_syntax_node(&self) -> SyntaxNode {
13443 self.node.clone()
13444 }
13445 fn stable_ptr(&self) -> Self::StablePtr {
13446 AttributeListPtr(self.node.0.stable_ptr)
13447 }
13448}
13449impl From<&AttributeList> for SyntaxStablePtrId {
13450 fn from(node: &AttributeList) -> Self {
13451 node.stable_ptr().untyped()
13452 }
13453}
13454#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13455pub struct VisibilityDefault {
13456 node: SyntaxNode,
13457 children: Arc<[SyntaxNode]>,
13458}
13459impl VisibilityDefault {
13460 pub fn new_green(db: &dyn SyntaxGroup) -> VisibilityDefaultGreen {
13461 let children: Vec<GreenId> = vec![];
13462 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13463 VisibilityDefaultGreen(
13464 Arc::new(GreenNode {
13465 kind: SyntaxKind::VisibilityDefault,
13466 details: GreenNodeDetails::Node { children, width },
13467 })
13468 .intern(db),
13469 )
13470 }
13471}
13472impl VisibilityDefault {}
13473#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13474pub struct VisibilityDefaultPtr(pub SyntaxStablePtrId);
13475impl VisibilityDefaultPtr {}
13476impl TypedStablePtr for VisibilityDefaultPtr {
13477 type SyntaxNode = VisibilityDefault;
13478 fn untyped(&self) -> SyntaxStablePtrId {
13479 self.0
13480 }
13481 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityDefault {
13482 VisibilityDefault::from_syntax_node(db, self.0.lookup(db))
13483 }
13484}
13485impl From<VisibilityDefaultPtr> for SyntaxStablePtrId {
13486 fn from(ptr: VisibilityDefaultPtr) -> Self {
13487 ptr.untyped()
13488 }
13489}
13490#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13491pub struct VisibilityDefaultGreen(pub GreenId);
13492impl TypedSyntaxNode for VisibilityDefault {
13493 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityDefault);
13494 type StablePtr = VisibilityDefaultPtr;
13495 type Green = VisibilityDefaultGreen;
13496 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13497 VisibilityDefaultGreen(
13498 Arc::new(GreenNode {
13499 kind: SyntaxKind::VisibilityDefault,
13500 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
13501 })
13502 .intern(db),
13503 )
13504 }
13505 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13506 let kind = node.kind(db);
13507 assert_eq!(
13508 kind,
13509 SyntaxKind::VisibilityDefault,
13510 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13511 kind,
13512 SyntaxKind::VisibilityDefault
13513 );
13514 let children = db.get_children(node.clone());
13515 Self { node, children }
13516 }
13517 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13518 let kind = node.kind(db);
13519 if kind == SyntaxKind::VisibilityDefault {
13520 Some(Self::from_syntax_node(db, node))
13521 } else {
13522 None
13523 }
13524 }
13525 fn as_syntax_node(&self) -> SyntaxNode {
13526 self.node.clone()
13527 }
13528 fn stable_ptr(&self) -> Self::StablePtr {
13529 VisibilityDefaultPtr(self.node.0.stable_ptr)
13530 }
13531}
13532impl From<&VisibilityDefault> for SyntaxStablePtrId {
13533 fn from(node: &VisibilityDefault) -> Self {
13534 node.stable_ptr().untyped()
13535 }
13536}
13537#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13538pub struct VisibilityPubArgumentClause {
13539 node: SyntaxNode,
13540 children: Arc<[SyntaxNode]>,
13541}
13542impl VisibilityPubArgumentClause {
13543 pub const INDEX_LPAREN: usize = 0;
13544 pub const INDEX_ARGUMENT: usize = 1;
13545 pub const INDEX_RPAREN: usize = 2;
13546 pub fn new_green(
13547 db: &dyn SyntaxGroup,
13548 lparen: TerminalLParenGreen,
13549 argument: TerminalIdentifierGreen,
13550 rparen: TerminalRParenGreen,
13551 ) -> VisibilityPubArgumentClauseGreen {
13552 let children: Vec<GreenId> = vec![lparen.0, argument.0, rparen.0];
13553 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13554 VisibilityPubArgumentClauseGreen(
13555 Arc::new(GreenNode {
13556 kind: SyntaxKind::VisibilityPubArgumentClause,
13557 details: GreenNodeDetails::Node { children, width },
13558 })
13559 .intern(db),
13560 )
13561 }
13562}
13563impl VisibilityPubArgumentClause {
13564 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
13565 TerminalLParen::from_syntax_node(db, self.children[0].clone())
13566 }
13567 pub fn argument(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
13568 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
13569 }
13570 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
13571 TerminalRParen::from_syntax_node(db, self.children[2].clone())
13572 }
13573}
13574#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13575pub struct VisibilityPubArgumentClausePtr(pub SyntaxStablePtrId);
13576impl VisibilityPubArgumentClausePtr {}
13577impl TypedStablePtr for VisibilityPubArgumentClausePtr {
13578 type SyntaxNode = VisibilityPubArgumentClause;
13579 fn untyped(&self) -> SyntaxStablePtrId {
13580 self.0
13581 }
13582 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityPubArgumentClause {
13583 VisibilityPubArgumentClause::from_syntax_node(db, self.0.lookup(db))
13584 }
13585}
13586impl From<VisibilityPubArgumentClausePtr> for SyntaxStablePtrId {
13587 fn from(ptr: VisibilityPubArgumentClausePtr) -> Self {
13588 ptr.untyped()
13589 }
13590}
13591#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13592pub struct VisibilityPubArgumentClauseGreen(pub GreenId);
13593impl TypedSyntaxNode for VisibilityPubArgumentClause {
13594 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityPubArgumentClause);
13595 type StablePtr = VisibilityPubArgumentClausePtr;
13596 type Green = VisibilityPubArgumentClauseGreen;
13597 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13598 VisibilityPubArgumentClauseGreen(
13599 Arc::new(GreenNode {
13600 kind: SyntaxKind::VisibilityPubArgumentClause,
13601 details: GreenNodeDetails::Node {
13602 children: vec![
13603 TerminalLParen::missing(db).0,
13604 TerminalIdentifier::missing(db).0,
13605 TerminalRParen::missing(db).0,
13606 ],
13607 width: TextWidth::default(),
13608 },
13609 })
13610 .intern(db),
13611 )
13612 }
13613 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13614 let kind = node.kind(db);
13615 assert_eq!(
13616 kind,
13617 SyntaxKind::VisibilityPubArgumentClause,
13618 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13619 kind,
13620 SyntaxKind::VisibilityPubArgumentClause
13621 );
13622 let children = db.get_children(node.clone());
13623 Self { node, children }
13624 }
13625 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13626 let kind = node.kind(db);
13627 if kind == SyntaxKind::VisibilityPubArgumentClause {
13628 Some(Self::from_syntax_node(db, node))
13629 } else {
13630 None
13631 }
13632 }
13633 fn as_syntax_node(&self) -> SyntaxNode {
13634 self.node.clone()
13635 }
13636 fn stable_ptr(&self) -> Self::StablePtr {
13637 VisibilityPubArgumentClausePtr(self.node.0.stable_ptr)
13638 }
13639}
13640impl From<&VisibilityPubArgumentClause> for SyntaxStablePtrId {
13641 fn from(node: &VisibilityPubArgumentClause) -> Self {
13642 node.stable_ptr().untyped()
13643 }
13644}
13645#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13646pub enum OptionVisibilityPubArgumentClause {
13647 Empty(OptionVisibilityPubArgumentClauseEmpty),
13648 VisibilityPubArgumentClause(VisibilityPubArgumentClause),
13649}
13650#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13651pub struct OptionVisibilityPubArgumentClausePtr(pub SyntaxStablePtrId);
13652impl TypedStablePtr for OptionVisibilityPubArgumentClausePtr {
13653 type SyntaxNode = OptionVisibilityPubArgumentClause;
13654 fn untyped(&self) -> SyntaxStablePtrId {
13655 self.0
13656 }
13657 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClause {
13658 OptionVisibilityPubArgumentClause::from_syntax_node(db, self.0.lookup(db))
13659 }
13660}
13661impl From<OptionVisibilityPubArgumentClausePtr> for SyntaxStablePtrId {
13662 fn from(ptr: OptionVisibilityPubArgumentClausePtr) -> Self {
13663 ptr.untyped()
13664 }
13665}
13666impl From<OptionVisibilityPubArgumentClauseEmptyPtr> for OptionVisibilityPubArgumentClausePtr {
13667 fn from(value: OptionVisibilityPubArgumentClauseEmptyPtr) -> Self {
13668 Self(value.0)
13669 }
13670}
13671impl From<VisibilityPubArgumentClausePtr> for OptionVisibilityPubArgumentClausePtr {
13672 fn from(value: VisibilityPubArgumentClausePtr) -> Self {
13673 Self(value.0)
13674 }
13675}
13676impl From<OptionVisibilityPubArgumentClauseEmptyGreen> for OptionVisibilityPubArgumentClauseGreen {
13677 fn from(value: OptionVisibilityPubArgumentClauseEmptyGreen) -> Self {
13678 Self(value.0)
13679 }
13680}
13681impl From<VisibilityPubArgumentClauseGreen> for OptionVisibilityPubArgumentClauseGreen {
13682 fn from(value: VisibilityPubArgumentClauseGreen) -> Self {
13683 Self(value.0)
13684 }
13685}
13686#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13687pub struct OptionVisibilityPubArgumentClauseGreen(pub GreenId);
13688impl TypedSyntaxNode for OptionVisibilityPubArgumentClause {
13689 const OPTIONAL_KIND: Option<SyntaxKind> = None;
13690 type StablePtr = OptionVisibilityPubArgumentClausePtr;
13691 type Green = OptionVisibilityPubArgumentClauseGreen;
13692 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13693 panic!("No missing variant.");
13694 }
13695 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13696 let kind = node.kind(db);
13697 match kind {
13698 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty => {
13699 OptionVisibilityPubArgumentClause::Empty(
13700 OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, node),
13701 )
13702 }
13703 SyntaxKind::VisibilityPubArgumentClause => {
13704 OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause(
13705 VisibilityPubArgumentClause::from_syntax_node(db, node),
13706 )
13707 }
13708 _ => panic!(
13709 "Unexpected syntax kind {:?} when constructing {}.",
13710 kind, "OptionVisibilityPubArgumentClause"
13711 ),
13712 }
13713 }
13714 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13715 let kind = node.kind(db);
13716 match kind {
13717 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty => {
13718 Some(OptionVisibilityPubArgumentClause::Empty(
13719 OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, node),
13720 ))
13721 }
13722 SyntaxKind::VisibilityPubArgumentClause => {
13723 Some(OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause(
13724 VisibilityPubArgumentClause::from_syntax_node(db, node),
13725 ))
13726 }
13727 _ => None,
13728 }
13729 }
13730 fn as_syntax_node(&self) -> SyntaxNode {
13731 match self {
13732 OptionVisibilityPubArgumentClause::Empty(x) => x.as_syntax_node(),
13733 OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause(x) => x.as_syntax_node(),
13734 }
13735 }
13736 fn stable_ptr(&self) -> Self::StablePtr {
13737 OptionVisibilityPubArgumentClausePtr(self.as_syntax_node().0.stable_ptr)
13738 }
13739}
13740impl From<&OptionVisibilityPubArgumentClause> for SyntaxStablePtrId {
13741 fn from(node: &OptionVisibilityPubArgumentClause) -> Self {
13742 node.stable_ptr().untyped()
13743 }
13744}
13745impl OptionVisibilityPubArgumentClause {
13746 pub fn is_variant(kind: SyntaxKind) -> bool {
13748 matches!(
13749 kind,
13750 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty
13751 | SyntaxKind::VisibilityPubArgumentClause
13752 )
13753 }
13754}
13755#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13756pub struct OptionVisibilityPubArgumentClauseEmpty {
13757 node: SyntaxNode,
13758 children: Arc<[SyntaxNode]>,
13759}
13760impl OptionVisibilityPubArgumentClauseEmpty {
13761 pub fn new_green(db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClauseEmptyGreen {
13762 let children: Vec<GreenId> = vec![];
13763 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13764 OptionVisibilityPubArgumentClauseEmptyGreen(
13765 Arc::new(GreenNode {
13766 kind: SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
13767 details: GreenNodeDetails::Node { children, width },
13768 })
13769 .intern(db),
13770 )
13771 }
13772}
13773impl OptionVisibilityPubArgumentClauseEmpty {}
13774#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13775pub struct OptionVisibilityPubArgumentClauseEmptyPtr(pub SyntaxStablePtrId);
13776impl OptionVisibilityPubArgumentClauseEmptyPtr {}
13777impl TypedStablePtr for OptionVisibilityPubArgumentClauseEmptyPtr {
13778 type SyntaxNode = OptionVisibilityPubArgumentClauseEmpty;
13779 fn untyped(&self) -> SyntaxStablePtrId {
13780 self.0
13781 }
13782 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClauseEmpty {
13783 OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, self.0.lookup(db))
13784 }
13785}
13786impl From<OptionVisibilityPubArgumentClauseEmptyPtr> for SyntaxStablePtrId {
13787 fn from(ptr: OptionVisibilityPubArgumentClauseEmptyPtr) -> Self {
13788 ptr.untyped()
13789 }
13790}
13791#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13792pub struct OptionVisibilityPubArgumentClauseEmptyGreen(pub GreenId);
13793impl TypedSyntaxNode for OptionVisibilityPubArgumentClauseEmpty {
13794 const OPTIONAL_KIND: Option<SyntaxKind> =
13795 Some(SyntaxKind::OptionVisibilityPubArgumentClauseEmpty);
13796 type StablePtr = OptionVisibilityPubArgumentClauseEmptyPtr;
13797 type Green = OptionVisibilityPubArgumentClauseEmptyGreen;
13798 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13799 OptionVisibilityPubArgumentClauseEmptyGreen(
13800 Arc::new(GreenNode {
13801 kind: SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
13802 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
13803 })
13804 .intern(db),
13805 )
13806 }
13807 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13808 let kind = node.kind(db);
13809 assert_eq!(
13810 kind,
13811 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
13812 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13813 kind,
13814 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty
13815 );
13816 let children = db.get_children(node.clone());
13817 Self { node, children }
13818 }
13819 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13820 let kind = node.kind(db);
13821 if kind == SyntaxKind::OptionVisibilityPubArgumentClauseEmpty {
13822 Some(Self::from_syntax_node(db, node))
13823 } else {
13824 None
13825 }
13826 }
13827 fn as_syntax_node(&self) -> SyntaxNode {
13828 self.node.clone()
13829 }
13830 fn stable_ptr(&self) -> Self::StablePtr {
13831 OptionVisibilityPubArgumentClauseEmptyPtr(self.node.0.stable_ptr)
13832 }
13833}
13834impl From<&OptionVisibilityPubArgumentClauseEmpty> for SyntaxStablePtrId {
13835 fn from(node: &OptionVisibilityPubArgumentClauseEmpty) -> Self {
13836 node.stable_ptr().untyped()
13837 }
13838}
13839#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13840pub struct VisibilityPub {
13841 node: SyntaxNode,
13842 children: Arc<[SyntaxNode]>,
13843}
13844impl VisibilityPub {
13845 pub const INDEX_PUB_KW: usize = 0;
13846 pub const INDEX_ARGUMENT_CLAUSE: usize = 1;
13847 pub fn new_green(
13848 db: &dyn SyntaxGroup,
13849 pub_kw: TerminalPubGreen,
13850 argument_clause: OptionVisibilityPubArgumentClauseGreen,
13851 ) -> VisibilityPubGreen {
13852 let children: Vec<GreenId> = vec![pub_kw.0, argument_clause.0];
13853 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13854 VisibilityPubGreen(
13855 Arc::new(GreenNode {
13856 kind: SyntaxKind::VisibilityPub,
13857 details: GreenNodeDetails::Node { children, width },
13858 })
13859 .intern(db),
13860 )
13861 }
13862}
13863impl VisibilityPub {
13864 pub fn pub_kw(&self, db: &dyn SyntaxGroup) -> TerminalPub {
13865 TerminalPub::from_syntax_node(db, self.children[0].clone())
13866 }
13867 pub fn argument_clause(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClause {
13868 OptionVisibilityPubArgumentClause::from_syntax_node(db, self.children[1].clone())
13869 }
13870}
13871#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13872pub struct VisibilityPubPtr(pub SyntaxStablePtrId);
13873impl VisibilityPubPtr {}
13874impl TypedStablePtr for VisibilityPubPtr {
13875 type SyntaxNode = VisibilityPub;
13876 fn untyped(&self) -> SyntaxStablePtrId {
13877 self.0
13878 }
13879 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityPub {
13880 VisibilityPub::from_syntax_node(db, self.0.lookup(db))
13881 }
13882}
13883impl From<VisibilityPubPtr> for SyntaxStablePtrId {
13884 fn from(ptr: VisibilityPubPtr) -> Self {
13885 ptr.untyped()
13886 }
13887}
13888#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13889pub struct VisibilityPubGreen(pub GreenId);
13890impl TypedSyntaxNode for VisibilityPub {
13891 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityPub);
13892 type StablePtr = VisibilityPubPtr;
13893 type Green = VisibilityPubGreen;
13894 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13895 VisibilityPubGreen(
13896 Arc::new(GreenNode {
13897 kind: SyntaxKind::VisibilityPub,
13898 details: GreenNodeDetails::Node {
13899 children: vec![
13900 TerminalPub::missing(db).0,
13901 OptionVisibilityPubArgumentClause::missing(db).0,
13902 ],
13903 width: TextWidth::default(),
13904 },
13905 })
13906 .intern(db),
13907 )
13908 }
13909 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13910 let kind = node.kind(db);
13911 assert_eq!(
13912 kind,
13913 SyntaxKind::VisibilityPub,
13914 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13915 kind,
13916 SyntaxKind::VisibilityPub
13917 );
13918 let children = db.get_children(node.clone());
13919 Self { node, children }
13920 }
13921 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
13922 let kind = node.kind(db);
13923 if kind == SyntaxKind::VisibilityPub {
13924 Some(Self::from_syntax_node(db, node))
13925 } else {
13926 None
13927 }
13928 }
13929 fn as_syntax_node(&self) -> SyntaxNode {
13930 self.node.clone()
13931 }
13932 fn stable_ptr(&self) -> Self::StablePtr {
13933 VisibilityPubPtr(self.node.0.stable_ptr)
13934 }
13935}
13936impl From<&VisibilityPub> for SyntaxStablePtrId {
13937 fn from(node: &VisibilityPub) -> Self {
13938 node.stable_ptr().untyped()
13939 }
13940}
13941#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13942pub enum Visibility {
13943 Default(VisibilityDefault),
13944 Pub(VisibilityPub),
13945}
13946#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13947pub struct VisibilityPtr(pub SyntaxStablePtrId);
13948impl TypedStablePtr for VisibilityPtr {
13949 type SyntaxNode = Visibility;
13950 fn untyped(&self) -> SyntaxStablePtrId {
13951 self.0
13952 }
13953 fn lookup(&self, db: &dyn SyntaxGroup) -> Visibility {
13954 Visibility::from_syntax_node(db, self.0.lookup(db))
13955 }
13956}
13957impl From<VisibilityPtr> for SyntaxStablePtrId {
13958 fn from(ptr: VisibilityPtr) -> Self {
13959 ptr.untyped()
13960 }
13961}
13962impl From<VisibilityDefaultPtr> for VisibilityPtr {
13963 fn from(value: VisibilityDefaultPtr) -> Self {
13964 Self(value.0)
13965 }
13966}
13967impl From<VisibilityPubPtr> for VisibilityPtr {
13968 fn from(value: VisibilityPubPtr) -> Self {
13969 Self(value.0)
13970 }
13971}
13972impl From<VisibilityDefaultGreen> for VisibilityGreen {
13973 fn from(value: VisibilityDefaultGreen) -> Self {
13974 Self(value.0)
13975 }
13976}
13977impl From<VisibilityPubGreen> for VisibilityGreen {
13978 fn from(value: VisibilityPubGreen) -> Self {
13979 Self(value.0)
13980 }
13981}
13982#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13983pub struct VisibilityGreen(pub GreenId);
13984impl TypedSyntaxNode for Visibility {
13985 const OPTIONAL_KIND: Option<SyntaxKind> = None;
13986 type StablePtr = VisibilityPtr;
13987 type Green = VisibilityGreen;
13988 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13989 panic!("No missing variant.");
13990 }
13991 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13992 let kind = node.kind(db);
13993 match kind {
13994 SyntaxKind::VisibilityDefault => {
13995 Visibility::Default(VisibilityDefault::from_syntax_node(db, node))
13996 }
13997 SyntaxKind::VisibilityPub => Visibility::Pub(VisibilityPub::from_syntax_node(db, node)),
13998 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Visibility"),
13999 }
14000 }
14001 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14002 let kind = node.kind(db);
14003 match kind {
14004 SyntaxKind::VisibilityDefault => {
14005 Some(Visibility::Default(VisibilityDefault::from_syntax_node(db, node)))
14006 }
14007 SyntaxKind::VisibilityPub => {
14008 Some(Visibility::Pub(VisibilityPub::from_syntax_node(db, node)))
14009 }
14010 _ => None,
14011 }
14012 }
14013 fn as_syntax_node(&self) -> SyntaxNode {
14014 match self {
14015 Visibility::Default(x) => x.as_syntax_node(),
14016 Visibility::Pub(x) => x.as_syntax_node(),
14017 }
14018 }
14019 fn stable_ptr(&self) -> Self::StablePtr {
14020 VisibilityPtr(self.as_syntax_node().0.stable_ptr)
14021 }
14022}
14023impl From<&Visibility> for SyntaxStablePtrId {
14024 fn from(node: &Visibility) -> Self {
14025 node.stable_ptr().untyped()
14026 }
14027}
14028impl Visibility {
14029 pub fn is_variant(kind: SyntaxKind) -> bool {
14031 matches!(kind, SyntaxKind::VisibilityDefault | SyntaxKind::VisibilityPub)
14032 }
14033}
14034#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14035pub struct ItemModule {
14036 node: SyntaxNode,
14037 children: Arc<[SyntaxNode]>,
14038}
14039impl ItemModule {
14040 pub const INDEX_ATTRIBUTES: usize = 0;
14041 pub const INDEX_VISIBILITY: usize = 1;
14042 pub const INDEX_MODULE_KW: usize = 2;
14043 pub const INDEX_NAME: usize = 3;
14044 pub const INDEX_BODY: usize = 4;
14045 pub fn new_green(
14046 db: &dyn SyntaxGroup,
14047 attributes: AttributeListGreen,
14048 visibility: VisibilityGreen,
14049 module_kw: TerminalModuleGreen,
14050 name: TerminalIdentifierGreen,
14051 body: MaybeModuleBodyGreen,
14052 ) -> ItemModuleGreen {
14053 let children: Vec<GreenId> = vec![attributes.0, visibility.0, module_kw.0, name.0, body.0];
14054 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14055 ItemModuleGreen(
14056 Arc::new(GreenNode {
14057 kind: SyntaxKind::ItemModule,
14058 details: GreenNodeDetails::Node { children, width },
14059 })
14060 .intern(db),
14061 )
14062 }
14063}
14064impl ItemModule {
14065 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14066 AttributeList::from_syntax_node(db, self.children[0].clone())
14067 }
14068 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14069 Visibility::from_syntax_node(db, self.children[1].clone())
14070 }
14071 pub fn module_kw(&self, db: &dyn SyntaxGroup) -> TerminalModule {
14072 TerminalModule::from_syntax_node(db, self.children[2].clone())
14073 }
14074 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14075 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
14076 }
14077 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeModuleBody {
14078 MaybeModuleBody::from_syntax_node(db, self.children[4].clone())
14079 }
14080}
14081#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14082pub struct ItemModulePtr(pub SyntaxStablePtrId);
14083impl ItemModulePtr {
14084 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14085 let ptr = self.0.lookup_intern(db);
14086 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14087 TerminalIdentifierGreen(key_fields[0])
14088 } else {
14089 panic!("Unexpected key field query on root.");
14090 }
14091 }
14092}
14093impl TypedStablePtr for ItemModulePtr {
14094 type SyntaxNode = ItemModule;
14095 fn untyped(&self) -> SyntaxStablePtrId {
14096 self.0
14097 }
14098 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemModule {
14099 ItemModule::from_syntax_node(db, self.0.lookup(db))
14100 }
14101}
14102impl From<ItemModulePtr> for SyntaxStablePtrId {
14103 fn from(ptr: ItemModulePtr) -> Self {
14104 ptr.untyped()
14105 }
14106}
14107#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14108pub struct ItemModuleGreen(pub GreenId);
14109impl TypedSyntaxNode for ItemModule {
14110 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemModule);
14111 type StablePtr = ItemModulePtr;
14112 type Green = ItemModuleGreen;
14113 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14114 ItemModuleGreen(
14115 Arc::new(GreenNode {
14116 kind: SyntaxKind::ItemModule,
14117 details: GreenNodeDetails::Node {
14118 children: vec![
14119 AttributeList::missing(db).0,
14120 Visibility::missing(db).0,
14121 TerminalModule::missing(db).0,
14122 TerminalIdentifier::missing(db).0,
14123 MaybeModuleBody::missing(db).0,
14124 ],
14125 width: TextWidth::default(),
14126 },
14127 })
14128 .intern(db),
14129 )
14130 }
14131 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14132 let kind = node.kind(db);
14133 assert_eq!(
14134 kind,
14135 SyntaxKind::ItemModule,
14136 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14137 kind,
14138 SyntaxKind::ItemModule
14139 );
14140 let children = db.get_children(node.clone());
14141 Self { node, children }
14142 }
14143 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14144 let kind = node.kind(db);
14145 if kind == SyntaxKind::ItemModule { Some(Self::from_syntax_node(db, node)) } else { None }
14146 }
14147 fn as_syntax_node(&self) -> SyntaxNode {
14148 self.node.clone()
14149 }
14150 fn stable_ptr(&self) -> Self::StablePtr {
14151 ItemModulePtr(self.node.0.stable_ptr)
14152 }
14153}
14154impl From<&ItemModule> for SyntaxStablePtrId {
14155 fn from(node: &ItemModule) -> Self {
14156 node.stable_ptr().untyped()
14157 }
14158}
14159#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14160pub enum MaybeModuleBody {
14161 Some(ModuleBody),
14162 None(TerminalSemicolon),
14163}
14164#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14165pub struct MaybeModuleBodyPtr(pub SyntaxStablePtrId);
14166impl TypedStablePtr for MaybeModuleBodyPtr {
14167 type SyntaxNode = MaybeModuleBody;
14168 fn untyped(&self) -> SyntaxStablePtrId {
14169 self.0
14170 }
14171 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeModuleBody {
14172 MaybeModuleBody::from_syntax_node(db, self.0.lookup(db))
14173 }
14174}
14175impl From<MaybeModuleBodyPtr> for SyntaxStablePtrId {
14176 fn from(ptr: MaybeModuleBodyPtr) -> Self {
14177 ptr.untyped()
14178 }
14179}
14180impl From<ModuleBodyPtr> for MaybeModuleBodyPtr {
14181 fn from(value: ModuleBodyPtr) -> Self {
14182 Self(value.0)
14183 }
14184}
14185impl From<TerminalSemicolonPtr> for MaybeModuleBodyPtr {
14186 fn from(value: TerminalSemicolonPtr) -> Self {
14187 Self(value.0)
14188 }
14189}
14190impl From<ModuleBodyGreen> for MaybeModuleBodyGreen {
14191 fn from(value: ModuleBodyGreen) -> Self {
14192 Self(value.0)
14193 }
14194}
14195impl From<TerminalSemicolonGreen> for MaybeModuleBodyGreen {
14196 fn from(value: TerminalSemicolonGreen) -> Self {
14197 Self(value.0)
14198 }
14199}
14200#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14201pub struct MaybeModuleBodyGreen(pub GreenId);
14202impl TypedSyntaxNode for MaybeModuleBody {
14203 const OPTIONAL_KIND: Option<SyntaxKind> = None;
14204 type StablePtr = MaybeModuleBodyPtr;
14205 type Green = MaybeModuleBodyGreen;
14206 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14207 panic!("No missing variant.");
14208 }
14209 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14210 let kind = node.kind(db);
14211 match kind {
14212 SyntaxKind::ModuleBody => MaybeModuleBody::Some(ModuleBody::from_syntax_node(db, node)),
14213 SyntaxKind::TerminalSemicolon => {
14214 MaybeModuleBody::None(TerminalSemicolon::from_syntax_node(db, node))
14215 }
14216 _ => {
14217 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeModuleBody")
14218 }
14219 }
14220 }
14221 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14222 let kind = node.kind(db);
14223 match kind {
14224 SyntaxKind::ModuleBody => {
14225 Some(MaybeModuleBody::Some(ModuleBody::from_syntax_node(db, node)))
14226 }
14227 SyntaxKind::TerminalSemicolon => {
14228 Some(MaybeModuleBody::None(TerminalSemicolon::from_syntax_node(db, node)))
14229 }
14230 _ => None,
14231 }
14232 }
14233 fn as_syntax_node(&self) -> SyntaxNode {
14234 match self {
14235 MaybeModuleBody::Some(x) => x.as_syntax_node(),
14236 MaybeModuleBody::None(x) => x.as_syntax_node(),
14237 }
14238 }
14239 fn stable_ptr(&self) -> Self::StablePtr {
14240 MaybeModuleBodyPtr(self.as_syntax_node().0.stable_ptr)
14241 }
14242}
14243impl From<&MaybeModuleBody> for SyntaxStablePtrId {
14244 fn from(node: &MaybeModuleBody) -> Self {
14245 node.stable_ptr().untyped()
14246 }
14247}
14248impl MaybeModuleBody {
14249 pub fn is_variant(kind: SyntaxKind) -> bool {
14251 matches!(kind, SyntaxKind::ModuleBody | SyntaxKind::TerminalSemicolon)
14252 }
14253}
14254#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14255pub struct ModuleBody {
14256 node: SyntaxNode,
14257 children: Arc<[SyntaxNode]>,
14258}
14259impl ModuleBody {
14260 pub const INDEX_LBRACE: usize = 0;
14261 pub const INDEX_ITEMS: usize = 1;
14262 pub const INDEX_RBRACE: usize = 2;
14263 pub fn new_green(
14264 db: &dyn SyntaxGroup,
14265 lbrace: TerminalLBraceGreen,
14266 items: ModuleItemListGreen,
14267 rbrace: TerminalRBraceGreen,
14268 ) -> ModuleBodyGreen {
14269 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
14270 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14271 ModuleBodyGreen(
14272 Arc::new(GreenNode {
14273 kind: SyntaxKind::ModuleBody,
14274 details: GreenNodeDetails::Node { children, width },
14275 })
14276 .intern(db),
14277 )
14278 }
14279}
14280impl ModuleBody {
14281 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
14282 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
14283 }
14284 pub fn items(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
14285 ModuleItemList::from_syntax_node(db, self.children[1].clone())
14286 }
14287 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
14288 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
14289 }
14290}
14291#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14292pub struct ModuleBodyPtr(pub SyntaxStablePtrId);
14293impl ModuleBodyPtr {}
14294impl TypedStablePtr for ModuleBodyPtr {
14295 type SyntaxNode = ModuleBody;
14296 fn untyped(&self) -> SyntaxStablePtrId {
14297 self.0
14298 }
14299 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleBody {
14300 ModuleBody::from_syntax_node(db, self.0.lookup(db))
14301 }
14302}
14303impl From<ModuleBodyPtr> for SyntaxStablePtrId {
14304 fn from(ptr: ModuleBodyPtr) -> Self {
14305 ptr.untyped()
14306 }
14307}
14308#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14309pub struct ModuleBodyGreen(pub GreenId);
14310impl TypedSyntaxNode for ModuleBody {
14311 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleBody);
14312 type StablePtr = ModuleBodyPtr;
14313 type Green = ModuleBodyGreen;
14314 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14315 ModuleBodyGreen(
14316 Arc::new(GreenNode {
14317 kind: SyntaxKind::ModuleBody,
14318 details: GreenNodeDetails::Node {
14319 children: vec![
14320 TerminalLBrace::missing(db).0,
14321 ModuleItemList::missing(db).0,
14322 TerminalRBrace::missing(db).0,
14323 ],
14324 width: TextWidth::default(),
14325 },
14326 })
14327 .intern(db),
14328 )
14329 }
14330 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14331 let kind = node.kind(db);
14332 assert_eq!(
14333 kind,
14334 SyntaxKind::ModuleBody,
14335 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14336 kind,
14337 SyntaxKind::ModuleBody
14338 );
14339 let children = db.get_children(node.clone());
14340 Self { node, children }
14341 }
14342 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14343 let kind = node.kind(db);
14344 if kind == SyntaxKind::ModuleBody { Some(Self::from_syntax_node(db, node)) } else { None }
14345 }
14346 fn as_syntax_node(&self) -> SyntaxNode {
14347 self.node.clone()
14348 }
14349 fn stable_ptr(&self) -> Self::StablePtr {
14350 ModuleBodyPtr(self.node.0.stable_ptr)
14351 }
14352}
14353impl From<&ModuleBody> for SyntaxStablePtrId {
14354 fn from(node: &ModuleBody) -> Self {
14355 node.stable_ptr().untyped()
14356 }
14357}
14358#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14359pub struct FunctionDeclaration {
14360 node: SyntaxNode,
14361 children: Arc<[SyntaxNode]>,
14362}
14363impl FunctionDeclaration {
14364 pub const INDEX_FUNCTION_KW: usize = 0;
14365 pub const INDEX_NAME: usize = 1;
14366 pub const INDEX_GENERIC_PARAMS: usize = 2;
14367 pub const INDEX_SIGNATURE: usize = 3;
14368 pub fn new_green(
14369 db: &dyn SyntaxGroup,
14370 function_kw: TerminalFunctionGreen,
14371 name: TerminalIdentifierGreen,
14372 generic_params: OptionWrappedGenericParamListGreen,
14373 signature: FunctionSignatureGreen,
14374 ) -> FunctionDeclarationGreen {
14375 let children: Vec<GreenId> = vec![function_kw.0, name.0, generic_params.0, signature.0];
14376 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14377 FunctionDeclarationGreen(
14378 Arc::new(GreenNode {
14379 kind: SyntaxKind::FunctionDeclaration,
14380 details: GreenNodeDetails::Node { children, width },
14381 })
14382 .intern(db),
14383 )
14384 }
14385}
14386impl FunctionDeclaration {
14387 pub fn function_kw(&self, db: &dyn SyntaxGroup) -> TerminalFunction {
14388 TerminalFunction::from_syntax_node(db, self.children[0].clone())
14389 }
14390 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14391 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
14392 }
14393 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
14394 OptionWrappedGenericParamList::from_syntax_node(db, self.children[2].clone())
14395 }
14396 pub fn signature(&self, db: &dyn SyntaxGroup) -> FunctionSignature {
14397 FunctionSignature::from_syntax_node(db, self.children[3].clone())
14398 }
14399}
14400#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14401pub struct FunctionDeclarationPtr(pub SyntaxStablePtrId);
14402impl FunctionDeclarationPtr {
14403 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14404 let ptr = self.0.lookup_intern(db);
14405 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14406 TerminalIdentifierGreen(key_fields[0])
14407 } else {
14408 panic!("Unexpected key field query on root.");
14409 }
14410 }
14411}
14412impl TypedStablePtr for FunctionDeclarationPtr {
14413 type SyntaxNode = FunctionDeclaration;
14414 fn untyped(&self) -> SyntaxStablePtrId {
14415 self.0
14416 }
14417 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
14418 FunctionDeclaration::from_syntax_node(db, self.0.lookup(db))
14419 }
14420}
14421impl From<FunctionDeclarationPtr> for SyntaxStablePtrId {
14422 fn from(ptr: FunctionDeclarationPtr) -> Self {
14423 ptr.untyped()
14424 }
14425}
14426#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14427pub struct FunctionDeclarationGreen(pub GreenId);
14428impl TypedSyntaxNode for FunctionDeclaration {
14429 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionDeclaration);
14430 type StablePtr = FunctionDeclarationPtr;
14431 type Green = FunctionDeclarationGreen;
14432 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14433 FunctionDeclarationGreen(
14434 Arc::new(GreenNode {
14435 kind: SyntaxKind::FunctionDeclaration,
14436 details: GreenNodeDetails::Node {
14437 children: vec![
14438 TerminalFunction::missing(db).0,
14439 TerminalIdentifier::missing(db).0,
14440 OptionWrappedGenericParamList::missing(db).0,
14441 FunctionSignature::missing(db).0,
14442 ],
14443 width: TextWidth::default(),
14444 },
14445 })
14446 .intern(db),
14447 )
14448 }
14449 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14450 let kind = node.kind(db);
14451 assert_eq!(
14452 kind,
14453 SyntaxKind::FunctionDeclaration,
14454 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14455 kind,
14456 SyntaxKind::FunctionDeclaration
14457 );
14458 let children = db.get_children(node.clone());
14459 Self { node, children }
14460 }
14461 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14462 let kind = node.kind(db);
14463 if kind == SyntaxKind::FunctionDeclaration {
14464 Some(Self::from_syntax_node(db, node))
14465 } else {
14466 None
14467 }
14468 }
14469 fn as_syntax_node(&self) -> SyntaxNode {
14470 self.node.clone()
14471 }
14472 fn stable_ptr(&self) -> Self::StablePtr {
14473 FunctionDeclarationPtr(self.node.0.stable_ptr)
14474 }
14475}
14476impl From<&FunctionDeclaration> for SyntaxStablePtrId {
14477 fn from(node: &FunctionDeclaration) -> Self {
14478 node.stable_ptr().untyped()
14479 }
14480}
14481#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14482pub struct ItemConstant {
14483 node: SyntaxNode,
14484 children: Arc<[SyntaxNode]>,
14485}
14486impl ItemConstant {
14487 pub const INDEX_ATTRIBUTES: usize = 0;
14488 pub const INDEX_VISIBILITY: usize = 1;
14489 pub const INDEX_CONST_KW: usize = 2;
14490 pub const INDEX_NAME: usize = 3;
14491 pub const INDEX_TYPE_CLAUSE: usize = 4;
14492 pub const INDEX_EQ: usize = 5;
14493 pub const INDEX_VALUE: usize = 6;
14494 pub const INDEX_SEMICOLON: usize = 7;
14495 pub fn new_green(
14496 db: &dyn SyntaxGroup,
14497 attributes: AttributeListGreen,
14498 visibility: VisibilityGreen,
14499 const_kw: TerminalConstGreen,
14500 name: TerminalIdentifierGreen,
14501 type_clause: TypeClauseGreen,
14502 eq: TerminalEqGreen,
14503 value: ExprGreen,
14504 semicolon: TerminalSemicolonGreen,
14505 ) -> ItemConstantGreen {
14506 let children: Vec<GreenId> = vec![
14507 attributes.0,
14508 visibility.0,
14509 const_kw.0,
14510 name.0,
14511 type_clause.0,
14512 eq.0,
14513 value.0,
14514 semicolon.0,
14515 ];
14516 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14517 ItemConstantGreen(
14518 Arc::new(GreenNode {
14519 kind: SyntaxKind::ItemConstant,
14520 details: GreenNodeDetails::Node { children, width },
14521 })
14522 .intern(db),
14523 )
14524 }
14525}
14526impl ItemConstant {
14527 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14528 AttributeList::from_syntax_node(db, self.children[0].clone())
14529 }
14530 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14531 Visibility::from_syntax_node(db, self.children[1].clone())
14532 }
14533 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
14534 TerminalConst::from_syntax_node(db, self.children[2].clone())
14535 }
14536 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14537 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
14538 }
14539 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
14540 TypeClause::from_syntax_node(db, self.children[4].clone())
14541 }
14542 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
14543 TerminalEq::from_syntax_node(db, self.children[5].clone())
14544 }
14545 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
14546 Expr::from_syntax_node(db, self.children[6].clone())
14547 }
14548 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14549 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
14550 }
14551}
14552#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14553pub struct ItemConstantPtr(pub SyntaxStablePtrId);
14554impl ItemConstantPtr {
14555 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14556 let ptr = self.0.lookup_intern(db);
14557 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14558 TerminalIdentifierGreen(key_fields[0])
14559 } else {
14560 panic!("Unexpected key field query on root.");
14561 }
14562 }
14563}
14564impl TypedStablePtr for ItemConstantPtr {
14565 type SyntaxNode = ItemConstant;
14566 fn untyped(&self) -> SyntaxStablePtrId {
14567 self.0
14568 }
14569 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemConstant {
14570 ItemConstant::from_syntax_node(db, self.0.lookup(db))
14571 }
14572}
14573impl From<ItemConstantPtr> for SyntaxStablePtrId {
14574 fn from(ptr: ItemConstantPtr) -> Self {
14575 ptr.untyped()
14576 }
14577}
14578#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14579pub struct ItemConstantGreen(pub GreenId);
14580impl TypedSyntaxNode for ItemConstant {
14581 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemConstant);
14582 type StablePtr = ItemConstantPtr;
14583 type Green = ItemConstantGreen;
14584 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14585 ItemConstantGreen(
14586 Arc::new(GreenNode {
14587 kind: SyntaxKind::ItemConstant,
14588 details: GreenNodeDetails::Node {
14589 children: vec![
14590 AttributeList::missing(db).0,
14591 Visibility::missing(db).0,
14592 TerminalConst::missing(db).0,
14593 TerminalIdentifier::missing(db).0,
14594 TypeClause::missing(db).0,
14595 TerminalEq::missing(db).0,
14596 Expr::missing(db).0,
14597 TerminalSemicolon::missing(db).0,
14598 ],
14599 width: TextWidth::default(),
14600 },
14601 })
14602 .intern(db),
14603 )
14604 }
14605 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14606 let kind = node.kind(db);
14607 assert_eq!(
14608 kind,
14609 SyntaxKind::ItemConstant,
14610 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14611 kind,
14612 SyntaxKind::ItemConstant
14613 );
14614 let children = db.get_children(node.clone());
14615 Self { node, children }
14616 }
14617 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14618 let kind = node.kind(db);
14619 if kind == SyntaxKind::ItemConstant { Some(Self::from_syntax_node(db, node)) } else { None }
14620 }
14621 fn as_syntax_node(&self) -> SyntaxNode {
14622 self.node.clone()
14623 }
14624 fn stable_ptr(&self) -> Self::StablePtr {
14625 ItemConstantPtr(self.node.0.stable_ptr)
14626 }
14627}
14628impl From<&ItemConstant> for SyntaxStablePtrId {
14629 fn from(node: &ItemConstant) -> Self {
14630 node.stable_ptr().untyped()
14631 }
14632}
14633#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14634pub struct FunctionWithBody {
14635 node: SyntaxNode,
14636 children: Arc<[SyntaxNode]>,
14637}
14638impl FunctionWithBody {
14639 pub const INDEX_ATTRIBUTES: usize = 0;
14640 pub const INDEX_VISIBILITY: usize = 1;
14641 pub const INDEX_DECLARATION: usize = 2;
14642 pub const INDEX_BODY: usize = 3;
14643 pub fn new_green(
14644 db: &dyn SyntaxGroup,
14645 attributes: AttributeListGreen,
14646 visibility: VisibilityGreen,
14647 declaration: FunctionDeclarationGreen,
14648 body: ExprBlockGreen,
14649 ) -> FunctionWithBodyGreen {
14650 let children: Vec<GreenId> = vec![attributes.0, visibility.0, declaration.0, body.0];
14651 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14652 FunctionWithBodyGreen(
14653 Arc::new(GreenNode {
14654 kind: SyntaxKind::FunctionWithBody,
14655 details: GreenNodeDetails::Node { children, width },
14656 })
14657 .intern(db),
14658 )
14659 }
14660}
14661impl FunctionWithBody {
14662 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14663 AttributeList::from_syntax_node(db, self.children[0].clone())
14664 }
14665 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14666 Visibility::from_syntax_node(db, self.children[1].clone())
14667 }
14668 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
14669 FunctionDeclaration::from_syntax_node(db, self.children[2].clone())
14670 }
14671 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
14672 ExprBlock::from_syntax_node(db, self.children[3].clone())
14673 }
14674}
14675#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14676pub struct FunctionWithBodyPtr(pub SyntaxStablePtrId);
14677impl FunctionWithBodyPtr {
14678 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
14679 let ptr = self.0.lookup_intern(db);
14680 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14681 FunctionDeclarationGreen(key_fields[0])
14682 } else {
14683 panic!("Unexpected key field query on root.");
14684 }
14685 }
14686}
14687impl TypedStablePtr for FunctionWithBodyPtr {
14688 type SyntaxNode = FunctionWithBody;
14689 fn untyped(&self) -> SyntaxStablePtrId {
14690 self.0
14691 }
14692 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionWithBody {
14693 FunctionWithBody::from_syntax_node(db, self.0.lookup(db))
14694 }
14695}
14696impl From<FunctionWithBodyPtr> for SyntaxStablePtrId {
14697 fn from(ptr: FunctionWithBodyPtr) -> Self {
14698 ptr.untyped()
14699 }
14700}
14701#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14702pub struct FunctionWithBodyGreen(pub GreenId);
14703impl TypedSyntaxNode for FunctionWithBody {
14704 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionWithBody);
14705 type StablePtr = FunctionWithBodyPtr;
14706 type Green = FunctionWithBodyGreen;
14707 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14708 FunctionWithBodyGreen(
14709 Arc::new(GreenNode {
14710 kind: SyntaxKind::FunctionWithBody,
14711 details: GreenNodeDetails::Node {
14712 children: vec![
14713 AttributeList::missing(db).0,
14714 Visibility::missing(db).0,
14715 FunctionDeclaration::missing(db).0,
14716 ExprBlock::missing(db).0,
14717 ],
14718 width: TextWidth::default(),
14719 },
14720 })
14721 .intern(db),
14722 )
14723 }
14724 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14725 let kind = node.kind(db);
14726 assert_eq!(
14727 kind,
14728 SyntaxKind::FunctionWithBody,
14729 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14730 kind,
14731 SyntaxKind::FunctionWithBody
14732 );
14733 let children = db.get_children(node.clone());
14734 Self { node, children }
14735 }
14736 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14737 let kind = node.kind(db);
14738 if kind == SyntaxKind::FunctionWithBody {
14739 Some(Self::from_syntax_node(db, node))
14740 } else {
14741 None
14742 }
14743 }
14744 fn as_syntax_node(&self) -> SyntaxNode {
14745 self.node.clone()
14746 }
14747 fn stable_ptr(&self) -> Self::StablePtr {
14748 FunctionWithBodyPtr(self.node.0.stable_ptr)
14749 }
14750}
14751impl From<&FunctionWithBody> for SyntaxStablePtrId {
14752 fn from(node: &FunctionWithBody) -> Self {
14753 node.stable_ptr().untyped()
14754 }
14755}
14756#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14757pub struct ItemExternFunction {
14758 node: SyntaxNode,
14759 children: Arc<[SyntaxNode]>,
14760}
14761impl ItemExternFunction {
14762 pub const INDEX_ATTRIBUTES: usize = 0;
14763 pub const INDEX_VISIBILITY: usize = 1;
14764 pub const INDEX_EXTERN_KW: usize = 2;
14765 pub const INDEX_DECLARATION: usize = 3;
14766 pub const INDEX_SEMICOLON: usize = 4;
14767 pub fn new_green(
14768 db: &dyn SyntaxGroup,
14769 attributes: AttributeListGreen,
14770 visibility: VisibilityGreen,
14771 extern_kw: TerminalExternGreen,
14772 declaration: FunctionDeclarationGreen,
14773 semicolon: TerminalSemicolonGreen,
14774 ) -> ItemExternFunctionGreen {
14775 let children: Vec<GreenId> =
14776 vec![attributes.0, visibility.0, extern_kw.0, declaration.0, semicolon.0];
14777 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14778 ItemExternFunctionGreen(
14779 Arc::new(GreenNode {
14780 kind: SyntaxKind::ItemExternFunction,
14781 details: GreenNodeDetails::Node { children, width },
14782 })
14783 .intern(db),
14784 )
14785 }
14786}
14787impl ItemExternFunction {
14788 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14789 AttributeList::from_syntax_node(db, self.children[0].clone())
14790 }
14791 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14792 Visibility::from_syntax_node(db, self.children[1].clone())
14793 }
14794 pub fn extern_kw(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
14795 TerminalExtern::from_syntax_node(db, self.children[2].clone())
14796 }
14797 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
14798 FunctionDeclaration::from_syntax_node(db, self.children[3].clone())
14799 }
14800 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14801 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
14802 }
14803}
14804#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14805pub struct ItemExternFunctionPtr(pub SyntaxStablePtrId);
14806impl ItemExternFunctionPtr {
14807 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
14808 let ptr = self.0.lookup_intern(db);
14809 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14810 FunctionDeclarationGreen(key_fields[0])
14811 } else {
14812 panic!("Unexpected key field query on root.");
14813 }
14814 }
14815}
14816impl TypedStablePtr for ItemExternFunctionPtr {
14817 type SyntaxNode = ItemExternFunction;
14818 fn untyped(&self) -> SyntaxStablePtrId {
14819 self.0
14820 }
14821 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemExternFunction {
14822 ItemExternFunction::from_syntax_node(db, self.0.lookup(db))
14823 }
14824}
14825impl From<ItemExternFunctionPtr> for SyntaxStablePtrId {
14826 fn from(ptr: ItemExternFunctionPtr) -> Self {
14827 ptr.untyped()
14828 }
14829}
14830#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14831pub struct ItemExternFunctionGreen(pub GreenId);
14832impl TypedSyntaxNode for ItemExternFunction {
14833 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemExternFunction);
14834 type StablePtr = ItemExternFunctionPtr;
14835 type Green = ItemExternFunctionGreen;
14836 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14837 ItemExternFunctionGreen(
14838 Arc::new(GreenNode {
14839 kind: SyntaxKind::ItemExternFunction,
14840 details: GreenNodeDetails::Node {
14841 children: vec![
14842 AttributeList::missing(db).0,
14843 Visibility::missing(db).0,
14844 TerminalExtern::missing(db).0,
14845 FunctionDeclaration::missing(db).0,
14846 TerminalSemicolon::missing(db).0,
14847 ],
14848 width: TextWidth::default(),
14849 },
14850 })
14851 .intern(db),
14852 )
14853 }
14854 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14855 let kind = node.kind(db);
14856 assert_eq!(
14857 kind,
14858 SyntaxKind::ItemExternFunction,
14859 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14860 kind,
14861 SyntaxKind::ItemExternFunction
14862 );
14863 let children = db.get_children(node.clone());
14864 Self { node, children }
14865 }
14866 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
14867 let kind = node.kind(db);
14868 if kind == SyntaxKind::ItemExternFunction {
14869 Some(Self::from_syntax_node(db, node))
14870 } else {
14871 None
14872 }
14873 }
14874 fn as_syntax_node(&self) -> SyntaxNode {
14875 self.node.clone()
14876 }
14877 fn stable_ptr(&self) -> Self::StablePtr {
14878 ItemExternFunctionPtr(self.node.0.stable_ptr)
14879 }
14880}
14881impl From<&ItemExternFunction> for SyntaxStablePtrId {
14882 fn from(node: &ItemExternFunction) -> Self {
14883 node.stable_ptr().untyped()
14884 }
14885}
14886#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14887pub struct ItemExternType {
14888 node: SyntaxNode,
14889 children: Arc<[SyntaxNode]>,
14890}
14891impl ItemExternType {
14892 pub const INDEX_ATTRIBUTES: usize = 0;
14893 pub const INDEX_VISIBILITY: usize = 1;
14894 pub const INDEX_EXTERN_KW: usize = 2;
14895 pub const INDEX_TYPE_KW: usize = 3;
14896 pub const INDEX_NAME: usize = 4;
14897 pub const INDEX_GENERIC_PARAMS: usize = 5;
14898 pub const INDEX_SEMICOLON: usize = 6;
14899 pub fn new_green(
14900 db: &dyn SyntaxGroup,
14901 attributes: AttributeListGreen,
14902 visibility: VisibilityGreen,
14903 extern_kw: TerminalExternGreen,
14904 type_kw: TerminalTypeGreen,
14905 name: TerminalIdentifierGreen,
14906 generic_params: OptionWrappedGenericParamListGreen,
14907 semicolon: TerminalSemicolonGreen,
14908 ) -> ItemExternTypeGreen {
14909 let children: Vec<GreenId> = vec![
14910 attributes.0,
14911 visibility.0,
14912 extern_kw.0,
14913 type_kw.0,
14914 name.0,
14915 generic_params.0,
14916 semicolon.0,
14917 ];
14918 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14919 ItemExternTypeGreen(
14920 Arc::new(GreenNode {
14921 kind: SyntaxKind::ItemExternType,
14922 details: GreenNodeDetails::Node { children, width },
14923 })
14924 .intern(db),
14925 )
14926 }
14927}
14928impl ItemExternType {
14929 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14930 AttributeList::from_syntax_node(db, self.children[0].clone())
14931 }
14932 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14933 Visibility::from_syntax_node(db, self.children[1].clone())
14934 }
14935 pub fn extern_kw(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
14936 TerminalExtern::from_syntax_node(db, self.children[2].clone())
14937 }
14938 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
14939 TerminalType::from_syntax_node(db, self.children[3].clone())
14940 }
14941 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14942 TerminalIdentifier::from_syntax_node(db, self.children[4].clone())
14943 }
14944 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
14945 OptionWrappedGenericParamList::from_syntax_node(db, self.children[5].clone())
14946 }
14947 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14948 TerminalSemicolon::from_syntax_node(db, self.children[6].clone())
14949 }
14950}
14951#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14952pub struct ItemExternTypePtr(pub SyntaxStablePtrId);
14953impl ItemExternTypePtr {
14954 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14955 let ptr = self.0.lookup_intern(db);
14956 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14957 TerminalIdentifierGreen(key_fields[0])
14958 } else {
14959 panic!("Unexpected key field query on root.");
14960 }
14961 }
14962}
14963impl TypedStablePtr for ItemExternTypePtr {
14964 type SyntaxNode = ItemExternType;
14965 fn untyped(&self) -> SyntaxStablePtrId {
14966 self.0
14967 }
14968 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemExternType {
14969 ItemExternType::from_syntax_node(db, self.0.lookup(db))
14970 }
14971}
14972impl From<ItemExternTypePtr> for SyntaxStablePtrId {
14973 fn from(ptr: ItemExternTypePtr) -> Self {
14974 ptr.untyped()
14975 }
14976}
14977#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14978pub struct ItemExternTypeGreen(pub GreenId);
14979impl TypedSyntaxNode for ItemExternType {
14980 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemExternType);
14981 type StablePtr = ItemExternTypePtr;
14982 type Green = ItemExternTypeGreen;
14983 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14984 ItemExternTypeGreen(
14985 Arc::new(GreenNode {
14986 kind: SyntaxKind::ItemExternType,
14987 details: GreenNodeDetails::Node {
14988 children: vec![
14989 AttributeList::missing(db).0,
14990 Visibility::missing(db).0,
14991 TerminalExtern::missing(db).0,
14992 TerminalType::missing(db).0,
14993 TerminalIdentifier::missing(db).0,
14994 OptionWrappedGenericParamList::missing(db).0,
14995 TerminalSemicolon::missing(db).0,
14996 ],
14997 width: TextWidth::default(),
14998 },
14999 })
15000 .intern(db),
15001 )
15002 }
15003 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15004 let kind = node.kind(db);
15005 assert_eq!(
15006 kind,
15007 SyntaxKind::ItemExternType,
15008 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15009 kind,
15010 SyntaxKind::ItemExternType
15011 );
15012 let children = db.get_children(node.clone());
15013 Self { node, children }
15014 }
15015 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15016 let kind = node.kind(db);
15017 if kind == SyntaxKind::ItemExternType {
15018 Some(Self::from_syntax_node(db, node))
15019 } else {
15020 None
15021 }
15022 }
15023 fn as_syntax_node(&self) -> SyntaxNode {
15024 self.node.clone()
15025 }
15026 fn stable_ptr(&self) -> Self::StablePtr {
15027 ItemExternTypePtr(self.node.0.stable_ptr)
15028 }
15029}
15030impl From<&ItemExternType> for SyntaxStablePtrId {
15031 fn from(node: &ItemExternType) -> Self {
15032 node.stable_ptr().untyped()
15033 }
15034}
15035#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15036pub struct ItemTrait {
15037 node: SyntaxNode,
15038 children: Arc<[SyntaxNode]>,
15039}
15040impl ItemTrait {
15041 pub const INDEX_ATTRIBUTES: usize = 0;
15042 pub const INDEX_VISIBILITY: usize = 1;
15043 pub const INDEX_TRAIT_KW: usize = 2;
15044 pub const INDEX_NAME: usize = 3;
15045 pub const INDEX_GENERIC_PARAMS: usize = 4;
15046 pub const INDEX_BODY: usize = 5;
15047 pub fn new_green(
15048 db: &dyn SyntaxGroup,
15049 attributes: AttributeListGreen,
15050 visibility: VisibilityGreen,
15051 trait_kw: TerminalTraitGreen,
15052 name: TerminalIdentifierGreen,
15053 generic_params: OptionWrappedGenericParamListGreen,
15054 body: MaybeTraitBodyGreen,
15055 ) -> ItemTraitGreen {
15056 let children: Vec<GreenId> =
15057 vec![attributes.0, visibility.0, trait_kw.0, name.0, generic_params.0, body.0];
15058 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15059 ItemTraitGreen(
15060 Arc::new(GreenNode {
15061 kind: SyntaxKind::ItemTrait,
15062 details: GreenNodeDetails::Node { children, width },
15063 })
15064 .intern(db),
15065 )
15066 }
15067}
15068impl ItemTrait {
15069 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15070 AttributeList::from_syntax_node(db, self.children[0].clone())
15071 }
15072 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
15073 Visibility::from_syntax_node(db, self.children[1].clone())
15074 }
15075 pub fn trait_kw(&self, db: &dyn SyntaxGroup) -> TerminalTrait {
15076 TerminalTrait::from_syntax_node(db, self.children[2].clone())
15077 }
15078 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
15079 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
15080 }
15081 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
15082 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
15083 }
15084 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeTraitBody {
15085 MaybeTraitBody::from_syntax_node(db, self.children[5].clone())
15086 }
15087}
15088#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15089pub struct ItemTraitPtr(pub SyntaxStablePtrId);
15090impl ItemTraitPtr {
15091 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
15092 let ptr = self.0.lookup_intern(db);
15093 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
15094 TerminalIdentifierGreen(key_fields[0])
15095 } else {
15096 panic!("Unexpected key field query on root.");
15097 }
15098 }
15099}
15100impl TypedStablePtr for ItemTraitPtr {
15101 type SyntaxNode = ItemTrait;
15102 fn untyped(&self) -> SyntaxStablePtrId {
15103 self.0
15104 }
15105 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemTrait {
15106 ItemTrait::from_syntax_node(db, self.0.lookup(db))
15107 }
15108}
15109impl From<ItemTraitPtr> for SyntaxStablePtrId {
15110 fn from(ptr: ItemTraitPtr) -> Self {
15111 ptr.untyped()
15112 }
15113}
15114#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15115pub struct ItemTraitGreen(pub GreenId);
15116impl TypedSyntaxNode for ItemTrait {
15117 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemTrait);
15118 type StablePtr = ItemTraitPtr;
15119 type Green = ItemTraitGreen;
15120 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15121 ItemTraitGreen(
15122 Arc::new(GreenNode {
15123 kind: SyntaxKind::ItemTrait,
15124 details: GreenNodeDetails::Node {
15125 children: vec![
15126 AttributeList::missing(db).0,
15127 Visibility::missing(db).0,
15128 TerminalTrait::missing(db).0,
15129 TerminalIdentifier::missing(db).0,
15130 OptionWrappedGenericParamList::missing(db).0,
15131 MaybeTraitBody::missing(db).0,
15132 ],
15133 width: TextWidth::default(),
15134 },
15135 })
15136 .intern(db),
15137 )
15138 }
15139 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15140 let kind = node.kind(db);
15141 assert_eq!(
15142 kind,
15143 SyntaxKind::ItemTrait,
15144 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15145 kind,
15146 SyntaxKind::ItemTrait
15147 );
15148 let children = db.get_children(node.clone());
15149 Self { node, children }
15150 }
15151 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15152 let kind = node.kind(db);
15153 if kind == SyntaxKind::ItemTrait { Some(Self::from_syntax_node(db, node)) } else { None }
15154 }
15155 fn as_syntax_node(&self) -> SyntaxNode {
15156 self.node.clone()
15157 }
15158 fn stable_ptr(&self) -> Self::StablePtr {
15159 ItemTraitPtr(self.node.0.stable_ptr)
15160 }
15161}
15162impl From<&ItemTrait> for SyntaxStablePtrId {
15163 fn from(node: &ItemTrait) -> Self {
15164 node.stable_ptr().untyped()
15165 }
15166}
15167#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15168pub enum MaybeTraitBody {
15169 Some(TraitBody),
15170 None(TerminalSemicolon),
15171}
15172#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15173pub struct MaybeTraitBodyPtr(pub SyntaxStablePtrId);
15174impl TypedStablePtr for MaybeTraitBodyPtr {
15175 type SyntaxNode = MaybeTraitBody;
15176 fn untyped(&self) -> SyntaxStablePtrId {
15177 self.0
15178 }
15179 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeTraitBody {
15180 MaybeTraitBody::from_syntax_node(db, self.0.lookup(db))
15181 }
15182}
15183impl From<MaybeTraitBodyPtr> for SyntaxStablePtrId {
15184 fn from(ptr: MaybeTraitBodyPtr) -> Self {
15185 ptr.untyped()
15186 }
15187}
15188impl From<TraitBodyPtr> for MaybeTraitBodyPtr {
15189 fn from(value: TraitBodyPtr) -> Self {
15190 Self(value.0)
15191 }
15192}
15193impl From<TerminalSemicolonPtr> for MaybeTraitBodyPtr {
15194 fn from(value: TerminalSemicolonPtr) -> Self {
15195 Self(value.0)
15196 }
15197}
15198impl From<TraitBodyGreen> for MaybeTraitBodyGreen {
15199 fn from(value: TraitBodyGreen) -> Self {
15200 Self(value.0)
15201 }
15202}
15203impl From<TerminalSemicolonGreen> for MaybeTraitBodyGreen {
15204 fn from(value: TerminalSemicolonGreen) -> Self {
15205 Self(value.0)
15206 }
15207}
15208#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15209pub struct MaybeTraitBodyGreen(pub GreenId);
15210impl TypedSyntaxNode for MaybeTraitBody {
15211 const OPTIONAL_KIND: Option<SyntaxKind> = None;
15212 type StablePtr = MaybeTraitBodyPtr;
15213 type Green = MaybeTraitBodyGreen;
15214 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15215 panic!("No missing variant.");
15216 }
15217 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15218 let kind = node.kind(db);
15219 match kind {
15220 SyntaxKind::TraitBody => MaybeTraitBody::Some(TraitBody::from_syntax_node(db, node)),
15221 SyntaxKind::TerminalSemicolon => {
15222 MaybeTraitBody::None(TerminalSemicolon::from_syntax_node(db, node))
15223 }
15224 _ => {
15225 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeTraitBody")
15226 }
15227 }
15228 }
15229 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15230 let kind = node.kind(db);
15231 match kind {
15232 SyntaxKind::TraitBody => {
15233 Some(MaybeTraitBody::Some(TraitBody::from_syntax_node(db, node)))
15234 }
15235 SyntaxKind::TerminalSemicolon => {
15236 Some(MaybeTraitBody::None(TerminalSemicolon::from_syntax_node(db, node)))
15237 }
15238 _ => None,
15239 }
15240 }
15241 fn as_syntax_node(&self) -> SyntaxNode {
15242 match self {
15243 MaybeTraitBody::Some(x) => x.as_syntax_node(),
15244 MaybeTraitBody::None(x) => x.as_syntax_node(),
15245 }
15246 }
15247 fn stable_ptr(&self) -> Self::StablePtr {
15248 MaybeTraitBodyPtr(self.as_syntax_node().0.stable_ptr)
15249 }
15250}
15251impl From<&MaybeTraitBody> for SyntaxStablePtrId {
15252 fn from(node: &MaybeTraitBody) -> Self {
15253 node.stable_ptr().untyped()
15254 }
15255}
15256impl MaybeTraitBody {
15257 pub fn is_variant(kind: SyntaxKind) -> bool {
15259 matches!(kind, SyntaxKind::TraitBody | SyntaxKind::TerminalSemicolon)
15260 }
15261}
15262#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15263pub struct TraitBody {
15264 node: SyntaxNode,
15265 children: Arc<[SyntaxNode]>,
15266}
15267impl TraitBody {
15268 pub const INDEX_LBRACE: usize = 0;
15269 pub const INDEX_ITEMS: usize = 1;
15270 pub const INDEX_RBRACE: usize = 2;
15271 pub fn new_green(
15272 db: &dyn SyntaxGroup,
15273 lbrace: TerminalLBraceGreen,
15274 items: TraitItemListGreen,
15275 rbrace: TerminalRBraceGreen,
15276 ) -> TraitBodyGreen {
15277 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
15278 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15279 TraitBodyGreen(
15280 Arc::new(GreenNode {
15281 kind: SyntaxKind::TraitBody,
15282 details: GreenNodeDetails::Node { children, width },
15283 })
15284 .intern(db),
15285 )
15286 }
15287}
15288impl TraitBody {
15289 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
15290 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
15291 }
15292 pub fn items(&self, db: &dyn SyntaxGroup) -> TraitItemList {
15293 TraitItemList::from_syntax_node(db, self.children[1].clone())
15294 }
15295 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
15296 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
15297 }
15298}
15299#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15300pub struct TraitBodyPtr(pub SyntaxStablePtrId);
15301impl TraitBodyPtr {}
15302impl TypedStablePtr for TraitBodyPtr {
15303 type SyntaxNode = TraitBody;
15304 fn untyped(&self) -> SyntaxStablePtrId {
15305 self.0
15306 }
15307 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitBody {
15308 TraitBody::from_syntax_node(db, self.0.lookup(db))
15309 }
15310}
15311impl From<TraitBodyPtr> for SyntaxStablePtrId {
15312 fn from(ptr: TraitBodyPtr) -> Self {
15313 ptr.untyped()
15314 }
15315}
15316#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15317pub struct TraitBodyGreen(pub GreenId);
15318impl TypedSyntaxNode for TraitBody {
15319 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitBody);
15320 type StablePtr = TraitBodyPtr;
15321 type Green = TraitBodyGreen;
15322 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15323 TraitBodyGreen(
15324 Arc::new(GreenNode {
15325 kind: SyntaxKind::TraitBody,
15326 details: GreenNodeDetails::Node {
15327 children: vec![
15328 TerminalLBrace::missing(db).0,
15329 TraitItemList::missing(db).0,
15330 TerminalRBrace::missing(db).0,
15331 ],
15332 width: TextWidth::default(),
15333 },
15334 })
15335 .intern(db),
15336 )
15337 }
15338 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15339 let kind = node.kind(db);
15340 assert_eq!(
15341 kind,
15342 SyntaxKind::TraitBody,
15343 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15344 kind,
15345 SyntaxKind::TraitBody
15346 );
15347 let children = db.get_children(node.clone());
15348 Self { node, children }
15349 }
15350 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15351 let kind = node.kind(db);
15352 if kind == SyntaxKind::TraitBody { Some(Self::from_syntax_node(db, node)) } else { None }
15353 }
15354 fn as_syntax_node(&self) -> SyntaxNode {
15355 self.node.clone()
15356 }
15357 fn stable_ptr(&self) -> Self::StablePtr {
15358 TraitBodyPtr(self.node.0.stable_ptr)
15359 }
15360}
15361impl From<&TraitBody> for SyntaxStablePtrId {
15362 fn from(node: &TraitBody) -> Self {
15363 node.stable_ptr().untyped()
15364 }
15365}
15366#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15367pub struct TraitItemList(ElementList<TraitItem, 1>);
15368impl Deref for TraitItemList {
15369 type Target = ElementList<TraitItem, 1>;
15370 fn deref(&self) -> &Self::Target {
15371 &self.0
15372 }
15373}
15374impl TraitItemList {
15375 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<TraitItemGreen>) -> TraitItemListGreen {
15376 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
15377 TraitItemListGreen(
15378 Arc::new(GreenNode {
15379 kind: SyntaxKind::TraitItemList,
15380 details: GreenNodeDetails::Node {
15381 children: children.iter().map(|x| x.0).collect(),
15382 width,
15383 },
15384 })
15385 .intern(db),
15386 )
15387 }
15388}
15389#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15390pub struct TraitItemListPtr(pub SyntaxStablePtrId);
15391impl TypedStablePtr for TraitItemListPtr {
15392 type SyntaxNode = TraitItemList;
15393 fn untyped(&self) -> SyntaxStablePtrId {
15394 self.0
15395 }
15396 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemList {
15397 TraitItemList::from_syntax_node(db, self.0.lookup(db))
15398 }
15399}
15400impl From<TraitItemListPtr> for SyntaxStablePtrId {
15401 fn from(ptr: TraitItemListPtr) -> Self {
15402 ptr.untyped()
15403 }
15404}
15405#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15406pub struct TraitItemListGreen(pub GreenId);
15407impl TypedSyntaxNode for TraitItemList {
15408 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemList);
15409 type StablePtr = TraitItemListPtr;
15410 type Green = TraitItemListGreen;
15411 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15412 TraitItemListGreen(
15413 Arc::new(GreenNode {
15414 kind: SyntaxKind::TraitItemList,
15415 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
15416 })
15417 .intern(db),
15418 )
15419 }
15420 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15421 Self(ElementList::new(node))
15422 }
15423 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15424 if node.kind(db) == SyntaxKind::TraitItemList {
15425 Some(Self(ElementList::new(node)))
15426 } else {
15427 None
15428 }
15429 }
15430 fn as_syntax_node(&self) -> SyntaxNode {
15431 self.node.clone()
15432 }
15433 fn stable_ptr(&self) -> Self::StablePtr {
15434 TraitItemListPtr(self.node.0.stable_ptr)
15435 }
15436}
15437impl From<&TraitItemList> for SyntaxStablePtrId {
15438 fn from(node: &TraitItemList) -> Self {
15439 node.stable_ptr().untyped()
15440 }
15441}
15442#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15443pub enum TraitItem {
15444 Function(TraitItemFunction),
15445 Type(TraitItemType),
15446 Constant(TraitItemConstant),
15447 Impl(TraitItemImpl),
15448 Missing(TraitItemMissing),
15449}
15450#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15451pub struct TraitItemPtr(pub SyntaxStablePtrId);
15452impl TypedStablePtr for TraitItemPtr {
15453 type SyntaxNode = TraitItem;
15454 fn untyped(&self) -> SyntaxStablePtrId {
15455 self.0
15456 }
15457 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItem {
15458 TraitItem::from_syntax_node(db, self.0.lookup(db))
15459 }
15460}
15461impl From<TraitItemPtr> for SyntaxStablePtrId {
15462 fn from(ptr: TraitItemPtr) -> Self {
15463 ptr.untyped()
15464 }
15465}
15466impl From<TraitItemFunctionPtr> for TraitItemPtr {
15467 fn from(value: TraitItemFunctionPtr) -> Self {
15468 Self(value.0)
15469 }
15470}
15471impl From<TraitItemTypePtr> for TraitItemPtr {
15472 fn from(value: TraitItemTypePtr) -> Self {
15473 Self(value.0)
15474 }
15475}
15476impl From<TraitItemConstantPtr> for TraitItemPtr {
15477 fn from(value: TraitItemConstantPtr) -> Self {
15478 Self(value.0)
15479 }
15480}
15481impl From<TraitItemImplPtr> for TraitItemPtr {
15482 fn from(value: TraitItemImplPtr) -> Self {
15483 Self(value.0)
15484 }
15485}
15486impl From<TraitItemMissingPtr> for TraitItemPtr {
15487 fn from(value: TraitItemMissingPtr) -> Self {
15488 Self(value.0)
15489 }
15490}
15491impl From<TraitItemFunctionGreen> for TraitItemGreen {
15492 fn from(value: TraitItemFunctionGreen) -> Self {
15493 Self(value.0)
15494 }
15495}
15496impl From<TraitItemTypeGreen> for TraitItemGreen {
15497 fn from(value: TraitItemTypeGreen) -> Self {
15498 Self(value.0)
15499 }
15500}
15501impl From<TraitItemConstantGreen> for TraitItemGreen {
15502 fn from(value: TraitItemConstantGreen) -> Self {
15503 Self(value.0)
15504 }
15505}
15506impl From<TraitItemImplGreen> for TraitItemGreen {
15507 fn from(value: TraitItemImplGreen) -> Self {
15508 Self(value.0)
15509 }
15510}
15511impl From<TraitItemMissingGreen> for TraitItemGreen {
15512 fn from(value: TraitItemMissingGreen) -> Self {
15513 Self(value.0)
15514 }
15515}
15516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15517pub struct TraitItemGreen(pub GreenId);
15518impl TypedSyntaxNode for TraitItem {
15519 const OPTIONAL_KIND: Option<SyntaxKind> = None;
15520 type StablePtr = TraitItemPtr;
15521 type Green = TraitItemGreen;
15522 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15523 TraitItemGreen(TraitItemMissing::missing(db).0)
15524 }
15525 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15526 let kind = node.kind(db);
15527 match kind {
15528 SyntaxKind::TraitItemFunction => {
15529 TraitItem::Function(TraitItemFunction::from_syntax_node(db, node))
15530 }
15531 SyntaxKind::TraitItemType => TraitItem::Type(TraitItemType::from_syntax_node(db, node)),
15532 SyntaxKind::TraitItemConstant => {
15533 TraitItem::Constant(TraitItemConstant::from_syntax_node(db, node))
15534 }
15535 SyntaxKind::TraitItemImpl => TraitItem::Impl(TraitItemImpl::from_syntax_node(db, node)),
15536 SyntaxKind::TraitItemMissing => {
15537 TraitItem::Missing(TraitItemMissing::from_syntax_node(db, node))
15538 }
15539 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TraitItem"),
15540 }
15541 }
15542 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15543 let kind = node.kind(db);
15544 match kind {
15545 SyntaxKind::TraitItemFunction => {
15546 Some(TraitItem::Function(TraitItemFunction::from_syntax_node(db, node)))
15547 }
15548 SyntaxKind::TraitItemType => {
15549 Some(TraitItem::Type(TraitItemType::from_syntax_node(db, node)))
15550 }
15551 SyntaxKind::TraitItemConstant => {
15552 Some(TraitItem::Constant(TraitItemConstant::from_syntax_node(db, node)))
15553 }
15554 SyntaxKind::TraitItemImpl => {
15555 Some(TraitItem::Impl(TraitItemImpl::from_syntax_node(db, node)))
15556 }
15557 SyntaxKind::TraitItemMissing => {
15558 Some(TraitItem::Missing(TraitItemMissing::from_syntax_node(db, node)))
15559 }
15560 _ => None,
15561 }
15562 }
15563 fn as_syntax_node(&self) -> SyntaxNode {
15564 match self {
15565 TraitItem::Function(x) => x.as_syntax_node(),
15566 TraitItem::Type(x) => x.as_syntax_node(),
15567 TraitItem::Constant(x) => x.as_syntax_node(),
15568 TraitItem::Impl(x) => x.as_syntax_node(),
15569 TraitItem::Missing(x) => x.as_syntax_node(),
15570 }
15571 }
15572 fn stable_ptr(&self) -> Self::StablePtr {
15573 TraitItemPtr(self.as_syntax_node().0.stable_ptr)
15574 }
15575}
15576impl From<&TraitItem> for SyntaxStablePtrId {
15577 fn from(node: &TraitItem) -> Self {
15578 node.stable_ptr().untyped()
15579 }
15580}
15581impl TraitItem {
15582 pub fn is_variant(kind: SyntaxKind) -> bool {
15584 matches!(
15585 kind,
15586 SyntaxKind::TraitItemFunction
15587 | SyntaxKind::TraitItemType
15588 | SyntaxKind::TraitItemConstant
15589 | SyntaxKind::TraitItemImpl
15590 | SyntaxKind::TraitItemMissing
15591 )
15592 }
15593}
15594#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15595pub struct TraitItemMissing {
15596 node: SyntaxNode,
15597 children: Arc<[SyntaxNode]>,
15598}
15599impl TraitItemMissing {
15600 pub fn new_green(db: &dyn SyntaxGroup) -> TraitItemMissingGreen {
15601 let children: Vec<GreenId> = vec![];
15602 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15603 TraitItemMissingGreen(
15604 Arc::new(GreenNode {
15605 kind: SyntaxKind::TraitItemMissing,
15606 details: GreenNodeDetails::Node { children, width },
15607 })
15608 .intern(db),
15609 )
15610 }
15611}
15612impl TraitItemMissing {}
15613#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15614pub struct TraitItemMissingPtr(pub SyntaxStablePtrId);
15615impl TraitItemMissingPtr {}
15616impl TypedStablePtr for TraitItemMissingPtr {
15617 type SyntaxNode = TraitItemMissing;
15618 fn untyped(&self) -> SyntaxStablePtrId {
15619 self.0
15620 }
15621 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemMissing {
15622 TraitItemMissing::from_syntax_node(db, self.0.lookup(db))
15623 }
15624}
15625impl From<TraitItemMissingPtr> for SyntaxStablePtrId {
15626 fn from(ptr: TraitItemMissingPtr) -> Self {
15627 ptr.untyped()
15628 }
15629}
15630#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15631pub struct TraitItemMissingGreen(pub GreenId);
15632impl TypedSyntaxNode for TraitItemMissing {
15633 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemMissing);
15634 type StablePtr = TraitItemMissingPtr;
15635 type Green = TraitItemMissingGreen;
15636 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15637 TraitItemMissingGreen(
15638 Arc::new(GreenNode {
15639 kind: SyntaxKind::TraitItemMissing,
15640 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
15641 })
15642 .intern(db),
15643 )
15644 }
15645 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15646 let kind = node.kind(db);
15647 assert_eq!(
15648 kind,
15649 SyntaxKind::TraitItemMissing,
15650 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15651 kind,
15652 SyntaxKind::TraitItemMissing
15653 );
15654 let children = db.get_children(node.clone());
15655 Self { node, children }
15656 }
15657 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15658 let kind = node.kind(db);
15659 if kind == SyntaxKind::TraitItemMissing {
15660 Some(Self::from_syntax_node(db, node))
15661 } else {
15662 None
15663 }
15664 }
15665 fn as_syntax_node(&self) -> SyntaxNode {
15666 self.node.clone()
15667 }
15668 fn stable_ptr(&self) -> Self::StablePtr {
15669 TraitItemMissingPtr(self.node.0.stable_ptr)
15670 }
15671}
15672impl From<&TraitItemMissing> for SyntaxStablePtrId {
15673 fn from(node: &TraitItemMissing) -> Self {
15674 node.stable_ptr().untyped()
15675 }
15676}
15677#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15678pub struct TraitItemFunction {
15679 node: SyntaxNode,
15680 children: Arc<[SyntaxNode]>,
15681}
15682impl TraitItemFunction {
15683 pub const INDEX_ATTRIBUTES: usize = 0;
15684 pub const INDEX_DECLARATION: usize = 1;
15685 pub const INDEX_BODY: usize = 2;
15686 pub fn new_green(
15687 db: &dyn SyntaxGroup,
15688 attributes: AttributeListGreen,
15689 declaration: FunctionDeclarationGreen,
15690 body: MaybeTraitFunctionBodyGreen,
15691 ) -> TraitItemFunctionGreen {
15692 let children: Vec<GreenId> = vec![attributes.0, declaration.0, body.0];
15693 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15694 TraitItemFunctionGreen(
15695 Arc::new(GreenNode {
15696 kind: SyntaxKind::TraitItemFunction,
15697 details: GreenNodeDetails::Node { children, width },
15698 })
15699 .intern(db),
15700 )
15701 }
15702}
15703impl TraitItemFunction {
15704 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15705 AttributeList::from_syntax_node(db, self.children[0].clone())
15706 }
15707 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
15708 FunctionDeclaration::from_syntax_node(db, self.children[1].clone())
15709 }
15710 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeTraitFunctionBody {
15711 MaybeTraitFunctionBody::from_syntax_node(db, self.children[2].clone())
15712 }
15713}
15714#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15715pub struct TraitItemFunctionPtr(pub SyntaxStablePtrId);
15716impl TraitItemFunctionPtr {
15717 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
15718 let ptr = self.0.lookup_intern(db);
15719 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
15720 FunctionDeclarationGreen(key_fields[0])
15721 } else {
15722 panic!("Unexpected key field query on root.");
15723 }
15724 }
15725}
15726impl TypedStablePtr for TraitItemFunctionPtr {
15727 type SyntaxNode = TraitItemFunction;
15728 fn untyped(&self) -> SyntaxStablePtrId {
15729 self.0
15730 }
15731 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemFunction {
15732 TraitItemFunction::from_syntax_node(db, self.0.lookup(db))
15733 }
15734}
15735impl From<TraitItemFunctionPtr> for SyntaxStablePtrId {
15736 fn from(ptr: TraitItemFunctionPtr) -> Self {
15737 ptr.untyped()
15738 }
15739}
15740#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15741pub struct TraitItemFunctionGreen(pub GreenId);
15742impl TypedSyntaxNode for TraitItemFunction {
15743 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemFunction);
15744 type StablePtr = TraitItemFunctionPtr;
15745 type Green = TraitItemFunctionGreen;
15746 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15747 TraitItemFunctionGreen(
15748 Arc::new(GreenNode {
15749 kind: SyntaxKind::TraitItemFunction,
15750 details: GreenNodeDetails::Node {
15751 children: vec![
15752 AttributeList::missing(db).0,
15753 FunctionDeclaration::missing(db).0,
15754 MaybeTraitFunctionBody::missing(db).0,
15755 ],
15756 width: TextWidth::default(),
15757 },
15758 })
15759 .intern(db),
15760 )
15761 }
15762 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15763 let kind = node.kind(db);
15764 assert_eq!(
15765 kind,
15766 SyntaxKind::TraitItemFunction,
15767 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15768 kind,
15769 SyntaxKind::TraitItemFunction
15770 );
15771 let children = db.get_children(node.clone());
15772 Self { node, children }
15773 }
15774 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15775 let kind = node.kind(db);
15776 if kind == SyntaxKind::TraitItemFunction {
15777 Some(Self::from_syntax_node(db, node))
15778 } else {
15779 None
15780 }
15781 }
15782 fn as_syntax_node(&self) -> SyntaxNode {
15783 self.node.clone()
15784 }
15785 fn stable_ptr(&self) -> Self::StablePtr {
15786 TraitItemFunctionPtr(self.node.0.stable_ptr)
15787 }
15788}
15789impl From<&TraitItemFunction> for SyntaxStablePtrId {
15790 fn from(node: &TraitItemFunction) -> Self {
15791 node.stable_ptr().untyped()
15792 }
15793}
15794#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15795pub struct TraitItemType {
15796 node: SyntaxNode,
15797 children: Arc<[SyntaxNode]>,
15798}
15799impl TraitItemType {
15800 pub const INDEX_ATTRIBUTES: usize = 0;
15801 pub const INDEX_TYPE_KW: usize = 1;
15802 pub const INDEX_NAME: usize = 2;
15803 pub const INDEX_GENERIC_PARAMS: usize = 3;
15804 pub const INDEX_SEMICOLON: usize = 4;
15805 pub fn new_green(
15806 db: &dyn SyntaxGroup,
15807 attributes: AttributeListGreen,
15808 type_kw: TerminalTypeGreen,
15809 name: TerminalIdentifierGreen,
15810 generic_params: OptionWrappedGenericParamListGreen,
15811 semicolon: TerminalSemicolonGreen,
15812 ) -> TraitItemTypeGreen {
15813 let children: Vec<GreenId> =
15814 vec![attributes.0, type_kw.0, name.0, generic_params.0, semicolon.0];
15815 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15816 TraitItemTypeGreen(
15817 Arc::new(GreenNode {
15818 kind: SyntaxKind::TraitItemType,
15819 details: GreenNodeDetails::Node { children, width },
15820 })
15821 .intern(db),
15822 )
15823 }
15824}
15825impl TraitItemType {
15826 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15827 AttributeList::from_syntax_node(db, self.children[0].clone())
15828 }
15829 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
15830 TerminalType::from_syntax_node(db, self.children[1].clone())
15831 }
15832 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
15833 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
15834 }
15835 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
15836 OptionWrappedGenericParamList::from_syntax_node(db, self.children[3].clone())
15837 }
15838 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
15839 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
15840 }
15841}
15842#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15843pub struct TraitItemTypePtr(pub SyntaxStablePtrId);
15844impl TraitItemTypePtr {
15845 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
15846 let ptr = self.0.lookup_intern(db);
15847 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
15848 TerminalIdentifierGreen(key_fields[0])
15849 } else {
15850 panic!("Unexpected key field query on root.");
15851 }
15852 }
15853}
15854impl TypedStablePtr for TraitItemTypePtr {
15855 type SyntaxNode = TraitItemType;
15856 fn untyped(&self) -> SyntaxStablePtrId {
15857 self.0
15858 }
15859 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemType {
15860 TraitItemType::from_syntax_node(db, self.0.lookup(db))
15861 }
15862}
15863impl From<TraitItemTypePtr> for SyntaxStablePtrId {
15864 fn from(ptr: TraitItemTypePtr) -> Self {
15865 ptr.untyped()
15866 }
15867}
15868#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15869pub struct TraitItemTypeGreen(pub GreenId);
15870impl TypedSyntaxNode for TraitItemType {
15871 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemType);
15872 type StablePtr = TraitItemTypePtr;
15873 type Green = TraitItemTypeGreen;
15874 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15875 TraitItemTypeGreen(
15876 Arc::new(GreenNode {
15877 kind: SyntaxKind::TraitItemType,
15878 details: GreenNodeDetails::Node {
15879 children: vec![
15880 AttributeList::missing(db).0,
15881 TerminalType::missing(db).0,
15882 TerminalIdentifier::missing(db).0,
15883 OptionWrappedGenericParamList::missing(db).0,
15884 TerminalSemicolon::missing(db).0,
15885 ],
15886 width: TextWidth::default(),
15887 },
15888 })
15889 .intern(db),
15890 )
15891 }
15892 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15893 let kind = node.kind(db);
15894 assert_eq!(
15895 kind,
15896 SyntaxKind::TraitItemType,
15897 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15898 kind,
15899 SyntaxKind::TraitItemType
15900 );
15901 let children = db.get_children(node.clone());
15902 Self { node, children }
15903 }
15904 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
15905 let kind = node.kind(db);
15906 if kind == SyntaxKind::TraitItemType {
15907 Some(Self::from_syntax_node(db, node))
15908 } else {
15909 None
15910 }
15911 }
15912 fn as_syntax_node(&self) -> SyntaxNode {
15913 self.node.clone()
15914 }
15915 fn stable_ptr(&self) -> Self::StablePtr {
15916 TraitItemTypePtr(self.node.0.stable_ptr)
15917 }
15918}
15919impl From<&TraitItemType> for SyntaxStablePtrId {
15920 fn from(node: &TraitItemType) -> Self {
15921 node.stable_ptr().untyped()
15922 }
15923}
15924#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15925pub struct TraitItemConstant {
15926 node: SyntaxNode,
15927 children: Arc<[SyntaxNode]>,
15928}
15929impl TraitItemConstant {
15930 pub const INDEX_ATTRIBUTES: usize = 0;
15931 pub const INDEX_CONST_KW: usize = 1;
15932 pub const INDEX_NAME: usize = 2;
15933 pub const INDEX_TYPE_CLAUSE: usize = 3;
15934 pub const INDEX_SEMICOLON: usize = 4;
15935 pub fn new_green(
15936 db: &dyn SyntaxGroup,
15937 attributes: AttributeListGreen,
15938 const_kw: TerminalConstGreen,
15939 name: TerminalIdentifierGreen,
15940 type_clause: TypeClauseGreen,
15941 semicolon: TerminalSemicolonGreen,
15942 ) -> TraitItemConstantGreen {
15943 let children: Vec<GreenId> =
15944 vec![attributes.0, const_kw.0, name.0, type_clause.0, semicolon.0];
15945 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15946 TraitItemConstantGreen(
15947 Arc::new(GreenNode {
15948 kind: SyntaxKind::TraitItemConstant,
15949 details: GreenNodeDetails::Node { children, width },
15950 })
15951 .intern(db),
15952 )
15953 }
15954}
15955impl TraitItemConstant {
15956 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15957 AttributeList::from_syntax_node(db, self.children[0].clone())
15958 }
15959 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
15960 TerminalConst::from_syntax_node(db, self.children[1].clone())
15961 }
15962 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
15963 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
15964 }
15965 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
15966 TypeClause::from_syntax_node(db, self.children[3].clone())
15967 }
15968 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
15969 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
15970 }
15971}
15972#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15973pub struct TraitItemConstantPtr(pub SyntaxStablePtrId);
15974impl TraitItemConstantPtr {
15975 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
15976 let ptr = self.0.lookup_intern(db);
15977 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
15978 TerminalIdentifierGreen(key_fields[0])
15979 } else {
15980 panic!("Unexpected key field query on root.");
15981 }
15982 }
15983}
15984impl TypedStablePtr for TraitItemConstantPtr {
15985 type SyntaxNode = TraitItemConstant;
15986 fn untyped(&self) -> SyntaxStablePtrId {
15987 self.0
15988 }
15989 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemConstant {
15990 TraitItemConstant::from_syntax_node(db, self.0.lookup(db))
15991 }
15992}
15993impl From<TraitItemConstantPtr> for SyntaxStablePtrId {
15994 fn from(ptr: TraitItemConstantPtr) -> Self {
15995 ptr.untyped()
15996 }
15997}
15998#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15999pub struct TraitItemConstantGreen(pub GreenId);
16000impl TypedSyntaxNode for TraitItemConstant {
16001 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemConstant);
16002 type StablePtr = TraitItemConstantPtr;
16003 type Green = TraitItemConstantGreen;
16004 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16005 TraitItemConstantGreen(
16006 Arc::new(GreenNode {
16007 kind: SyntaxKind::TraitItemConstant,
16008 details: GreenNodeDetails::Node {
16009 children: vec![
16010 AttributeList::missing(db).0,
16011 TerminalConst::missing(db).0,
16012 TerminalIdentifier::missing(db).0,
16013 TypeClause::missing(db).0,
16014 TerminalSemicolon::missing(db).0,
16015 ],
16016 width: TextWidth::default(),
16017 },
16018 })
16019 .intern(db),
16020 )
16021 }
16022 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16023 let kind = node.kind(db);
16024 assert_eq!(
16025 kind,
16026 SyntaxKind::TraitItemConstant,
16027 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16028 kind,
16029 SyntaxKind::TraitItemConstant
16030 );
16031 let children = db.get_children(node.clone());
16032 Self { node, children }
16033 }
16034 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16035 let kind = node.kind(db);
16036 if kind == SyntaxKind::TraitItemConstant {
16037 Some(Self::from_syntax_node(db, node))
16038 } else {
16039 None
16040 }
16041 }
16042 fn as_syntax_node(&self) -> SyntaxNode {
16043 self.node.clone()
16044 }
16045 fn stable_ptr(&self) -> Self::StablePtr {
16046 TraitItemConstantPtr(self.node.0.stable_ptr)
16047 }
16048}
16049impl From<&TraitItemConstant> for SyntaxStablePtrId {
16050 fn from(node: &TraitItemConstant) -> Self {
16051 node.stable_ptr().untyped()
16052 }
16053}
16054#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16055pub struct TraitItemImpl {
16056 node: SyntaxNode,
16057 children: Arc<[SyntaxNode]>,
16058}
16059impl TraitItemImpl {
16060 pub const INDEX_ATTRIBUTES: usize = 0;
16061 pub const INDEX_IMPL_KW: usize = 1;
16062 pub const INDEX_NAME: usize = 2;
16063 pub const INDEX_COLON: usize = 3;
16064 pub const INDEX_TRAIT_PATH: usize = 4;
16065 pub const INDEX_SEMICOLON: usize = 5;
16066 pub fn new_green(
16067 db: &dyn SyntaxGroup,
16068 attributes: AttributeListGreen,
16069 impl_kw: TerminalImplGreen,
16070 name: TerminalIdentifierGreen,
16071 colon: TerminalColonGreen,
16072 trait_path: ExprPathGreen,
16073 semicolon: TerminalSemicolonGreen,
16074 ) -> TraitItemImplGreen {
16075 let children: Vec<GreenId> =
16076 vec![attributes.0, impl_kw.0, name.0, colon.0, trait_path.0, semicolon.0];
16077 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16078 TraitItemImplGreen(
16079 Arc::new(GreenNode {
16080 kind: SyntaxKind::TraitItemImpl,
16081 details: GreenNodeDetails::Node { children, width },
16082 })
16083 .intern(db),
16084 )
16085 }
16086}
16087impl TraitItemImpl {
16088 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16089 AttributeList::from_syntax_node(db, self.children[0].clone())
16090 }
16091 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
16092 TerminalImpl::from_syntax_node(db, self.children[1].clone())
16093 }
16094 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16095 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
16096 }
16097 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
16098 TerminalColon::from_syntax_node(db, self.children[3].clone())
16099 }
16100 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
16101 ExprPath::from_syntax_node(db, self.children[4].clone())
16102 }
16103 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
16104 TerminalSemicolon::from_syntax_node(db, self.children[5].clone())
16105 }
16106}
16107#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16108pub struct TraitItemImplPtr(pub SyntaxStablePtrId);
16109impl TraitItemImplPtr {
16110 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
16111 let ptr = self.0.lookup_intern(db);
16112 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16113 TerminalIdentifierGreen(key_fields[0])
16114 } else {
16115 panic!("Unexpected key field query on root.");
16116 }
16117 }
16118}
16119impl TypedStablePtr for TraitItemImplPtr {
16120 type SyntaxNode = TraitItemImpl;
16121 fn untyped(&self) -> SyntaxStablePtrId {
16122 self.0
16123 }
16124 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemImpl {
16125 TraitItemImpl::from_syntax_node(db, self.0.lookup(db))
16126 }
16127}
16128impl From<TraitItemImplPtr> for SyntaxStablePtrId {
16129 fn from(ptr: TraitItemImplPtr) -> Self {
16130 ptr.untyped()
16131 }
16132}
16133#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16134pub struct TraitItemImplGreen(pub GreenId);
16135impl TypedSyntaxNode for TraitItemImpl {
16136 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemImpl);
16137 type StablePtr = TraitItemImplPtr;
16138 type Green = TraitItemImplGreen;
16139 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16140 TraitItemImplGreen(
16141 Arc::new(GreenNode {
16142 kind: SyntaxKind::TraitItemImpl,
16143 details: GreenNodeDetails::Node {
16144 children: vec![
16145 AttributeList::missing(db).0,
16146 TerminalImpl::missing(db).0,
16147 TerminalIdentifier::missing(db).0,
16148 TerminalColon::missing(db).0,
16149 ExprPath::missing(db).0,
16150 TerminalSemicolon::missing(db).0,
16151 ],
16152 width: TextWidth::default(),
16153 },
16154 })
16155 .intern(db),
16156 )
16157 }
16158 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16159 let kind = node.kind(db);
16160 assert_eq!(
16161 kind,
16162 SyntaxKind::TraitItemImpl,
16163 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16164 kind,
16165 SyntaxKind::TraitItemImpl
16166 );
16167 let children = db.get_children(node.clone());
16168 Self { node, children }
16169 }
16170 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16171 let kind = node.kind(db);
16172 if kind == SyntaxKind::TraitItemImpl {
16173 Some(Self::from_syntax_node(db, node))
16174 } else {
16175 None
16176 }
16177 }
16178 fn as_syntax_node(&self) -> SyntaxNode {
16179 self.node.clone()
16180 }
16181 fn stable_ptr(&self) -> Self::StablePtr {
16182 TraitItemImplPtr(self.node.0.stable_ptr)
16183 }
16184}
16185impl From<&TraitItemImpl> for SyntaxStablePtrId {
16186 fn from(node: &TraitItemImpl) -> Self {
16187 node.stable_ptr().untyped()
16188 }
16189}
16190#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16191pub enum MaybeTraitFunctionBody {
16192 Some(ExprBlock),
16193 None(TerminalSemicolon),
16194}
16195#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16196pub struct MaybeTraitFunctionBodyPtr(pub SyntaxStablePtrId);
16197impl TypedStablePtr for MaybeTraitFunctionBodyPtr {
16198 type SyntaxNode = MaybeTraitFunctionBody;
16199 fn untyped(&self) -> SyntaxStablePtrId {
16200 self.0
16201 }
16202 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeTraitFunctionBody {
16203 MaybeTraitFunctionBody::from_syntax_node(db, self.0.lookup(db))
16204 }
16205}
16206impl From<MaybeTraitFunctionBodyPtr> for SyntaxStablePtrId {
16207 fn from(ptr: MaybeTraitFunctionBodyPtr) -> Self {
16208 ptr.untyped()
16209 }
16210}
16211impl From<ExprBlockPtr> for MaybeTraitFunctionBodyPtr {
16212 fn from(value: ExprBlockPtr) -> Self {
16213 Self(value.0)
16214 }
16215}
16216impl From<TerminalSemicolonPtr> for MaybeTraitFunctionBodyPtr {
16217 fn from(value: TerminalSemicolonPtr) -> Self {
16218 Self(value.0)
16219 }
16220}
16221impl From<ExprBlockGreen> for MaybeTraitFunctionBodyGreen {
16222 fn from(value: ExprBlockGreen) -> Self {
16223 Self(value.0)
16224 }
16225}
16226impl From<TerminalSemicolonGreen> for MaybeTraitFunctionBodyGreen {
16227 fn from(value: TerminalSemicolonGreen) -> Self {
16228 Self(value.0)
16229 }
16230}
16231#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16232pub struct MaybeTraitFunctionBodyGreen(pub GreenId);
16233impl TypedSyntaxNode for MaybeTraitFunctionBody {
16234 const OPTIONAL_KIND: Option<SyntaxKind> = None;
16235 type StablePtr = MaybeTraitFunctionBodyPtr;
16236 type Green = MaybeTraitFunctionBodyGreen;
16237 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16238 panic!("No missing variant.");
16239 }
16240 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16241 let kind = node.kind(db);
16242 match kind {
16243 SyntaxKind::ExprBlock => {
16244 MaybeTraitFunctionBody::Some(ExprBlock::from_syntax_node(db, node))
16245 }
16246 SyntaxKind::TerminalSemicolon => {
16247 MaybeTraitFunctionBody::None(TerminalSemicolon::from_syntax_node(db, node))
16248 }
16249 _ => panic!(
16250 "Unexpected syntax kind {:?} when constructing {}.",
16251 kind, "MaybeTraitFunctionBody"
16252 ),
16253 }
16254 }
16255 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16256 let kind = node.kind(db);
16257 match kind {
16258 SyntaxKind::ExprBlock => {
16259 Some(MaybeTraitFunctionBody::Some(ExprBlock::from_syntax_node(db, node)))
16260 }
16261 SyntaxKind::TerminalSemicolon => {
16262 Some(MaybeTraitFunctionBody::None(TerminalSemicolon::from_syntax_node(db, node)))
16263 }
16264 _ => None,
16265 }
16266 }
16267 fn as_syntax_node(&self) -> SyntaxNode {
16268 match self {
16269 MaybeTraitFunctionBody::Some(x) => x.as_syntax_node(),
16270 MaybeTraitFunctionBody::None(x) => x.as_syntax_node(),
16271 }
16272 }
16273 fn stable_ptr(&self) -> Self::StablePtr {
16274 MaybeTraitFunctionBodyPtr(self.as_syntax_node().0.stable_ptr)
16275 }
16276}
16277impl From<&MaybeTraitFunctionBody> for SyntaxStablePtrId {
16278 fn from(node: &MaybeTraitFunctionBody) -> Self {
16279 node.stable_ptr().untyped()
16280 }
16281}
16282impl MaybeTraitFunctionBody {
16283 pub fn is_variant(kind: SyntaxKind) -> bool {
16285 matches!(kind, SyntaxKind::ExprBlock | SyntaxKind::TerminalSemicolon)
16286 }
16287}
16288#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16289pub struct ItemImpl {
16290 node: SyntaxNode,
16291 children: Arc<[SyntaxNode]>,
16292}
16293impl ItemImpl {
16294 pub const INDEX_ATTRIBUTES: usize = 0;
16295 pub const INDEX_VISIBILITY: usize = 1;
16296 pub const INDEX_IMPL_KW: usize = 2;
16297 pub const INDEX_NAME: usize = 3;
16298 pub const INDEX_GENERIC_PARAMS: usize = 4;
16299 pub const INDEX_OF_KW: usize = 5;
16300 pub const INDEX_TRAIT_PATH: usize = 6;
16301 pub const INDEX_BODY: usize = 7;
16302 pub fn new_green(
16303 db: &dyn SyntaxGroup,
16304 attributes: AttributeListGreen,
16305 visibility: VisibilityGreen,
16306 impl_kw: TerminalImplGreen,
16307 name: TerminalIdentifierGreen,
16308 generic_params: OptionWrappedGenericParamListGreen,
16309 of_kw: TerminalOfGreen,
16310 trait_path: ExprPathGreen,
16311 body: MaybeImplBodyGreen,
16312 ) -> ItemImplGreen {
16313 let children: Vec<GreenId> = vec![
16314 attributes.0,
16315 visibility.0,
16316 impl_kw.0,
16317 name.0,
16318 generic_params.0,
16319 of_kw.0,
16320 trait_path.0,
16321 body.0,
16322 ];
16323 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16324 ItemImplGreen(
16325 Arc::new(GreenNode {
16326 kind: SyntaxKind::ItemImpl,
16327 details: GreenNodeDetails::Node { children, width },
16328 })
16329 .intern(db),
16330 )
16331 }
16332}
16333impl ItemImpl {
16334 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16335 AttributeList::from_syntax_node(db, self.children[0].clone())
16336 }
16337 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
16338 Visibility::from_syntax_node(db, self.children[1].clone())
16339 }
16340 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
16341 TerminalImpl::from_syntax_node(db, self.children[2].clone())
16342 }
16343 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16344 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
16345 }
16346 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
16347 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
16348 }
16349 pub fn of_kw(&self, db: &dyn SyntaxGroup) -> TerminalOf {
16350 TerminalOf::from_syntax_node(db, self.children[5].clone())
16351 }
16352 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
16353 ExprPath::from_syntax_node(db, self.children[6].clone())
16354 }
16355 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeImplBody {
16356 MaybeImplBody::from_syntax_node(db, self.children[7].clone())
16357 }
16358}
16359#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16360pub struct ItemImplPtr(pub SyntaxStablePtrId);
16361impl ItemImplPtr {
16362 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
16363 let ptr = self.0.lookup_intern(db);
16364 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16365 TerminalIdentifierGreen(key_fields[0])
16366 } else {
16367 panic!("Unexpected key field query on root.");
16368 }
16369 }
16370}
16371impl TypedStablePtr for ItemImplPtr {
16372 type SyntaxNode = ItemImpl;
16373 fn untyped(&self) -> SyntaxStablePtrId {
16374 self.0
16375 }
16376 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemImpl {
16377 ItemImpl::from_syntax_node(db, self.0.lookup(db))
16378 }
16379}
16380impl From<ItemImplPtr> for SyntaxStablePtrId {
16381 fn from(ptr: ItemImplPtr) -> Self {
16382 ptr.untyped()
16383 }
16384}
16385#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16386pub struct ItemImplGreen(pub GreenId);
16387impl TypedSyntaxNode for ItemImpl {
16388 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemImpl);
16389 type StablePtr = ItemImplPtr;
16390 type Green = ItemImplGreen;
16391 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16392 ItemImplGreen(
16393 Arc::new(GreenNode {
16394 kind: SyntaxKind::ItemImpl,
16395 details: GreenNodeDetails::Node {
16396 children: vec![
16397 AttributeList::missing(db).0,
16398 Visibility::missing(db).0,
16399 TerminalImpl::missing(db).0,
16400 TerminalIdentifier::missing(db).0,
16401 OptionWrappedGenericParamList::missing(db).0,
16402 TerminalOf::missing(db).0,
16403 ExprPath::missing(db).0,
16404 MaybeImplBody::missing(db).0,
16405 ],
16406 width: TextWidth::default(),
16407 },
16408 })
16409 .intern(db),
16410 )
16411 }
16412 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16413 let kind = node.kind(db);
16414 assert_eq!(
16415 kind,
16416 SyntaxKind::ItemImpl,
16417 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16418 kind,
16419 SyntaxKind::ItemImpl
16420 );
16421 let children = db.get_children(node.clone());
16422 Self { node, children }
16423 }
16424 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16425 let kind = node.kind(db);
16426 if kind == SyntaxKind::ItemImpl { Some(Self::from_syntax_node(db, node)) } else { None }
16427 }
16428 fn as_syntax_node(&self) -> SyntaxNode {
16429 self.node.clone()
16430 }
16431 fn stable_ptr(&self) -> Self::StablePtr {
16432 ItemImplPtr(self.node.0.stable_ptr)
16433 }
16434}
16435impl From<&ItemImpl> for SyntaxStablePtrId {
16436 fn from(node: &ItemImpl) -> Self {
16437 node.stable_ptr().untyped()
16438 }
16439}
16440#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16441pub struct ItemInlineMacro {
16442 node: SyntaxNode,
16443 children: Arc<[SyntaxNode]>,
16444}
16445impl ItemInlineMacro {
16446 pub const INDEX_ATTRIBUTES: usize = 0;
16447 pub const INDEX_NAME: usize = 1;
16448 pub const INDEX_BANG: usize = 2;
16449 pub const INDEX_ARGUMENTS: usize = 3;
16450 pub const INDEX_SEMICOLON: usize = 4;
16451 pub fn new_green(
16452 db: &dyn SyntaxGroup,
16453 attributes: AttributeListGreen,
16454 name: TerminalIdentifierGreen,
16455 bang: TerminalNotGreen,
16456 arguments: WrappedArgListGreen,
16457 semicolon: TerminalSemicolonGreen,
16458 ) -> ItemInlineMacroGreen {
16459 let children: Vec<GreenId> = vec![attributes.0, name.0, bang.0, arguments.0, semicolon.0];
16460 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16461 ItemInlineMacroGreen(
16462 Arc::new(GreenNode {
16463 kind: SyntaxKind::ItemInlineMacro,
16464 details: GreenNodeDetails::Node { children, width },
16465 })
16466 .intern(db),
16467 )
16468 }
16469}
16470impl ItemInlineMacro {
16471 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16472 AttributeList::from_syntax_node(db, self.children[0].clone())
16473 }
16474 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16475 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
16476 }
16477 pub fn bang(&self, db: &dyn SyntaxGroup) -> TerminalNot {
16478 TerminalNot::from_syntax_node(db, self.children[2].clone())
16479 }
16480 pub fn arguments(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
16481 WrappedArgList::from_syntax_node(db, self.children[3].clone())
16482 }
16483 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
16484 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
16485 }
16486}
16487#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16488pub struct ItemInlineMacroPtr(pub SyntaxStablePtrId);
16489impl ItemInlineMacroPtr {}
16490impl TypedStablePtr for ItemInlineMacroPtr {
16491 type SyntaxNode = ItemInlineMacro;
16492 fn untyped(&self) -> SyntaxStablePtrId {
16493 self.0
16494 }
16495 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemInlineMacro {
16496 ItemInlineMacro::from_syntax_node(db, self.0.lookup(db))
16497 }
16498}
16499impl From<ItemInlineMacroPtr> for SyntaxStablePtrId {
16500 fn from(ptr: ItemInlineMacroPtr) -> Self {
16501 ptr.untyped()
16502 }
16503}
16504#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16505pub struct ItemInlineMacroGreen(pub GreenId);
16506impl TypedSyntaxNode for ItemInlineMacro {
16507 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemInlineMacro);
16508 type StablePtr = ItemInlineMacroPtr;
16509 type Green = ItemInlineMacroGreen;
16510 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16511 ItemInlineMacroGreen(
16512 Arc::new(GreenNode {
16513 kind: SyntaxKind::ItemInlineMacro,
16514 details: GreenNodeDetails::Node {
16515 children: vec![
16516 AttributeList::missing(db).0,
16517 TerminalIdentifier::missing(db).0,
16518 TerminalNot::missing(db).0,
16519 WrappedArgList::missing(db).0,
16520 TerminalSemicolon::missing(db).0,
16521 ],
16522 width: TextWidth::default(),
16523 },
16524 })
16525 .intern(db),
16526 )
16527 }
16528 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16529 let kind = node.kind(db);
16530 assert_eq!(
16531 kind,
16532 SyntaxKind::ItemInlineMacro,
16533 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16534 kind,
16535 SyntaxKind::ItemInlineMacro
16536 );
16537 let children = db.get_children(node.clone());
16538 Self { node, children }
16539 }
16540 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16541 let kind = node.kind(db);
16542 if kind == SyntaxKind::ItemInlineMacro {
16543 Some(Self::from_syntax_node(db, node))
16544 } else {
16545 None
16546 }
16547 }
16548 fn as_syntax_node(&self) -> SyntaxNode {
16549 self.node.clone()
16550 }
16551 fn stable_ptr(&self) -> Self::StablePtr {
16552 ItemInlineMacroPtr(self.node.0.stable_ptr)
16553 }
16554}
16555impl From<&ItemInlineMacro> for SyntaxStablePtrId {
16556 fn from(node: &ItemInlineMacro) -> Self {
16557 node.stable_ptr().untyped()
16558 }
16559}
16560#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16561pub struct ItemHeaderDoc {
16562 node: SyntaxNode,
16563 children: Arc<[SyntaxNode]>,
16564}
16565impl ItemHeaderDoc {
16566 pub const INDEX_EMPTY: usize = 0;
16567 pub fn new_green(db: &dyn SyntaxGroup, empty: TerminalEmptyGreen) -> ItemHeaderDocGreen {
16568 let children: Vec<GreenId> = vec![empty.0];
16569 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16570 ItemHeaderDocGreen(
16571 Arc::new(GreenNode {
16572 kind: SyntaxKind::ItemHeaderDoc,
16573 details: GreenNodeDetails::Node { children, width },
16574 })
16575 .intern(db),
16576 )
16577 }
16578}
16579impl ItemHeaderDoc {
16580 pub fn empty(&self, db: &dyn SyntaxGroup) -> TerminalEmpty {
16581 TerminalEmpty::from_syntax_node(db, self.children[0].clone())
16582 }
16583}
16584#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16585pub struct ItemHeaderDocPtr(pub SyntaxStablePtrId);
16586impl ItemHeaderDocPtr {}
16587impl TypedStablePtr for ItemHeaderDocPtr {
16588 type SyntaxNode = ItemHeaderDoc;
16589 fn untyped(&self) -> SyntaxStablePtrId {
16590 self.0
16591 }
16592 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemHeaderDoc {
16593 ItemHeaderDoc::from_syntax_node(db, self.0.lookup(db))
16594 }
16595}
16596impl From<ItemHeaderDocPtr> for SyntaxStablePtrId {
16597 fn from(ptr: ItemHeaderDocPtr) -> Self {
16598 ptr.untyped()
16599 }
16600}
16601#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16602pub struct ItemHeaderDocGreen(pub GreenId);
16603impl TypedSyntaxNode for ItemHeaderDoc {
16604 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemHeaderDoc);
16605 type StablePtr = ItemHeaderDocPtr;
16606 type Green = ItemHeaderDocGreen;
16607 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16608 ItemHeaderDocGreen(
16609 Arc::new(GreenNode {
16610 kind: SyntaxKind::ItemHeaderDoc,
16611 details: GreenNodeDetails::Node {
16612 children: vec![TerminalEmpty::missing(db).0],
16613 width: TextWidth::default(),
16614 },
16615 })
16616 .intern(db),
16617 )
16618 }
16619 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16620 let kind = node.kind(db);
16621 assert_eq!(
16622 kind,
16623 SyntaxKind::ItemHeaderDoc,
16624 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16625 kind,
16626 SyntaxKind::ItemHeaderDoc
16627 );
16628 let children = db.get_children(node.clone());
16629 Self { node, children }
16630 }
16631 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16632 let kind = node.kind(db);
16633 if kind == SyntaxKind::ItemHeaderDoc {
16634 Some(Self::from_syntax_node(db, node))
16635 } else {
16636 None
16637 }
16638 }
16639 fn as_syntax_node(&self) -> SyntaxNode {
16640 self.node.clone()
16641 }
16642 fn stable_ptr(&self) -> Self::StablePtr {
16643 ItemHeaderDocPtr(self.node.0.stable_ptr)
16644 }
16645}
16646impl From<&ItemHeaderDoc> for SyntaxStablePtrId {
16647 fn from(node: &ItemHeaderDoc) -> Self {
16648 node.stable_ptr().untyped()
16649 }
16650}
16651#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16652pub enum MaybeImplBody {
16653 Some(ImplBody),
16654 None(TerminalSemicolon),
16655}
16656#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16657pub struct MaybeImplBodyPtr(pub SyntaxStablePtrId);
16658impl TypedStablePtr for MaybeImplBodyPtr {
16659 type SyntaxNode = MaybeImplBody;
16660 fn untyped(&self) -> SyntaxStablePtrId {
16661 self.0
16662 }
16663 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeImplBody {
16664 MaybeImplBody::from_syntax_node(db, self.0.lookup(db))
16665 }
16666}
16667impl From<MaybeImplBodyPtr> for SyntaxStablePtrId {
16668 fn from(ptr: MaybeImplBodyPtr) -> Self {
16669 ptr.untyped()
16670 }
16671}
16672impl From<ImplBodyPtr> for MaybeImplBodyPtr {
16673 fn from(value: ImplBodyPtr) -> Self {
16674 Self(value.0)
16675 }
16676}
16677impl From<TerminalSemicolonPtr> for MaybeImplBodyPtr {
16678 fn from(value: TerminalSemicolonPtr) -> Self {
16679 Self(value.0)
16680 }
16681}
16682impl From<ImplBodyGreen> for MaybeImplBodyGreen {
16683 fn from(value: ImplBodyGreen) -> Self {
16684 Self(value.0)
16685 }
16686}
16687impl From<TerminalSemicolonGreen> for MaybeImplBodyGreen {
16688 fn from(value: TerminalSemicolonGreen) -> Self {
16689 Self(value.0)
16690 }
16691}
16692#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16693pub struct MaybeImplBodyGreen(pub GreenId);
16694impl TypedSyntaxNode for MaybeImplBody {
16695 const OPTIONAL_KIND: Option<SyntaxKind> = None;
16696 type StablePtr = MaybeImplBodyPtr;
16697 type Green = MaybeImplBodyGreen;
16698 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16699 panic!("No missing variant.");
16700 }
16701 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16702 let kind = node.kind(db);
16703 match kind {
16704 SyntaxKind::ImplBody => MaybeImplBody::Some(ImplBody::from_syntax_node(db, node)),
16705 SyntaxKind::TerminalSemicolon => {
16706 MaybeImplBody::None(TerminalSemicolon::from_syntax_node(db, node))
16707 }
16708 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeImplBody"),
16709 }
16710 }
16711 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16712 let kind = node.kind(db);
16713 match kind {
16714 SyntaxKind::ImplBody => Some(MaybeImplBody::Some(ImplBody::from_syntax_node(db, node))),
16715 SyntaxKind::TerminalSemicolon => {
16716 Some(MaybeImplBody::None(TerminalSemicolon::from_syntax_node(db, node)))
16717 }
16718 _ => None,
16719 }
16720 }
16721 fn as_syntax_node(&self) -> SyntaxNode {
16722 match self {
16723 MaybeImplBody::Some(x) => x.as_syntax_node(),
16724 MaybeImplBody::None(x) => x.as_syntax_node(),
16725 }
16726 }
16727 fn stable_ptr(&self) -> Self::StablePtr {
16728 MaybeImplBodyPtr(self.as_syntax_node().0.stable_ptr)
16729 }
16730}
16731impl From<&MaybeImplBody> for SyntaxStablePtrId {
16732 fn from(node: &MaybeImplBody) -> Self {
16733 node.stable_ptr().untyped()
16734 }
16735}
16736impl MaybeImplBody {
16737 pub fn is_variant(kind: SyntaxKind) -> bool {
16739 matches!(kind, SyntaxKind::ImplBody | SyntaxKind::TerminalSemicolon)
16740 }
16741}
16742#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16743pub struct ImplBody {
16744 node: SyntaxNode,
16745 children: Arc<[SyntaxNode]>,
16746}
16747impl ImplBody {
16748 pub const INDEX_LBRACE: usize = 0;
16749 pub const INDEX_ITEMS: usize = 1;
16750 pub const INDEX_RBRACE: usize = 2;
16751 pub fn new_green(
16752 db: &dyn SyntaxGroup,
16753 lbrace: TerminalLBraceGreen,
16754 items: ImplItemListGreen,
16755 rbrace: TerminalRBraceGreen,
16756 ) -> ImplBodyGreen {
16757 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
16758 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16759 ImplBodyGreen(
16760 Arc::new(GreenNode {
16761 kind: SyntaxKind::ImplBody,
16762 details: GreenNodeDetails::Node { children, width },
16763 })
16764 .intern(db),
16765 )
16766 }
16767}
16768impl ImplBody {
16769 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
16770 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
16771 }
16772 pub fn items(&self, db: &dyn SyntaxGroup) -> ImplItemList {
16773 ImplItemList::from_syntax_node(db, self.children[1].clone())
16774 }
16775 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
16776 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
16777 }
16778}
16779#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16780pub struct ImplBodyPtr(pub SyntaxStablePtrId);
16781impl ImplBodyPtr {}
16782impl TypedStablePtr for ImplBodyPtr {
16783 type SyntaxNode = ImplBody;
16784 fn untyped(&self) -> SyntaxStablePtrId {
16785 self.0
16786 }
16787 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplBody {
16788 ImplBody::from_syntax_node(db, self.0.lookup(db))
16789 }
16790}
16791impl From<ImplBodyPtr> for SyntaxStablePtrId {
16792 fn from(ptr: ImplBodyPtr) -> Self {
16793 ptr.untyped()
16794 }
16795}
16796#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16797pub struct ImplBodyGreen(pub GreenId);
16798impl TypedSyntaxNode for ImplBody {
16799 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplBody);
16800 type StablePtr = ImplBodyPtr;
16801 type Green = ImplBodyGreen;
16802 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16803 ImplBodyGreen(
16804 Arc::new(GreenNode {
16805 kind: SyntaxKind::ImplBody,
16806 details: GreenNodeDetails::Node {
16807 children: vec![
16808 TerminalLBrace::missing(db).0,
16809 ImplItemList::missing(db).0,
16810 TerminalRBrace::missing(db).0,
16811 ],
16812 width: TextWidth::default(),
16813 },
16814 })
16815 .intern(db),
16816 )
16817 }
16818 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16819 let kind = node.kind(db);
16820 assert_eq!(
16821 kind,
16822 SyntaxKind::ImplBody,
16823 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16824 kind,
16825 SyntaxKind::ImplBody
16826 );
16827 let children = db.get_children(node.clone());
16828 Self { node, children }
16829 }
16830 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16831 let kind = node.kind(db);
16832 if kind == SyntaxKind::ImplBody { Some(Self::from_syntax_node(db, node)) } else { None }
16833 }
16834 fn as_syntax_node(&self) -> SyntaxNode {
16835 self.node.clone()
16836 }
16837 fn stable_ptr(&self) -> Self::StablePtr {
16838 ImplBodyPtr(self.node.0.stable_ptr)
16839 }
16840}
16841impl From<&ImplBody> for SyntaxStablePtrId {
16842 fn from(node: &ImplBody) -> Self {
16843 node.stable_ptr().untyped()
16844 }
16845}
16846#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16847pub struct ImplItemList(ElementList<ImplItem, 1>);
16848impl Deref for ImplItemList {
16849 type Target = ElementList<ImplItem, 1>;
16850 fn deref(&self) -> &Self::Target {
16851 &self.0
16852 }
16853}
16854impl ImplItemList {
16855 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ImplItemGreen>) -> ImplItemListGreen {
16856 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
16857 ImplItemListGreen(
16858 Arc::new(GreenNode {
16859 kind: SyntaxKind::ImplItemList,
16860 details: GreenNodeDetails::Node {
16861 children: children.iter().map(|x| x.0).collect(),
16862 width,
16863 },
16864 })
16865 .intern(db),
16866 )
16867 }
16868}
16869#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16870pub struct ImplItemListPtr(pub SyntaxStablePtrId);
16871impl TypedStablePtr for ImplItemListPtr {
16872 type SyntaxNode = ImplItemList;
16873 fn untyped(&self) -> SyntaxStablePtrId {
16874 self.0
16875 }
16876 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItemList {
16877 ImplItemList::from_syntax_node(db, self.0.lookup(db))
16878 }
16879}
16880impl From<ImplItemListPtr> for SyntaxStablePtrId {
16881 fn from(ptr: ImplItemListPtr) -> Self {
16882 ptr.untyped()
16883 }
16884}
16885#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16886pub struct ImplItemListGreen(pub GreenId);
16887impl TypedSyntaxNode for ImplItemList {
16888 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplItemList);
16889 type StablePtr = ImplItemListPtr;
16890 type Green = ImplItemListGreen;
16891 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16892 ImplItemListGreen(
16893 Arc::new(GreenNode {
16894 kind: SyntaxKind::ImplItemList,
16895 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
16896 })
16897 .intern(db),
16898 )
16899 }
16900 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16901 Self(ElementList::new(node))
16902 }
16903 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
16904 if node.kind(db) == SyntaxKind::ImplItemList {
16905 Some(Self(ElementList::new(node)))
16906 } else {
16907 None
16908 }
16909 }
16910 fn as_syntax_node(&self) -> SyntaxNode {
16911 self.node.clone()
16912 }
16913 fn stable_ptr(&self) -> Self::StablePtr {
16914 ImplItemListPtr(self.node.0.stable_ptr)
16915 }
16916}
16917impl From<&ImplItemList> for SyntaxStablePtrId {
16918 fn from(node: &ImplItemList) -> Self {
16919 node.stable_ptr().untyped()
16920 }
16921}
16922#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16923pub enum ImplItem {
16924 Function(FunctionWithBody),
16925 Type(ItemTypeAlias),
16926 Constant(ItemConstant),
16927 Impl(ItemImplAlias),
16928 Module(ItemModule),
16929 Use(ItemUse),
16930 ExternFunction(ItemExternFunction),
16931 ExternType(ItemExternType),
16932 Trait(ItemTrait),
16933 Struct(ItemStruct),
16934 Enum(ItemEnum),
16935 Missing(ImplItemMissing),
16936}
16937#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16938pub struct ImplItemPtr(pub SyntaxStablePtrId);
16939impl TypedStablePtr for ImplItemPtr {
16940 type SyntaxNode = ImplItem;
16941 fn untyped(&self) -> SyntaxStablePtrId {
16942 self.0
16943 }
16944 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItem {
16945 ImplItem::from_syntax_node(db, self.0.lookup(db))
16946 }
16947}
16948impl From<ImplItemPtr> for SyntaxStablePtrId {
16949 fn from(ptr: ImplItemPtr) -> Self {
16950 ptr.untyped()
16951 }
16952}
16953impl From<FunctionWithBodyPtr> for ImplItemPtr {
16954 fn from(value: FunctionWithBodyPtr) -> Self {
16955 Self(value.0)
16956 }
16957}
16958impl From<ItemTypeAliasPtr> for ImplItemPtr {
16959 fn from(value: ItemTypeAliasPtr) -> Self {
16960 Self(value.0)
16961 }
16962}
16963impl From<ItemConstantPtr> for ImplItemPtr {
16964 fn from(value: ItemConstantPtr) -> Self {
16965 Self(value.0)
16966 }
16967}
16968impl From<ItemImplAliasPtr> for ImplItemPtr {
16969 fn from(value: ItemImplAliasPtr) -> Self {
16970 Self(value.0)
16971 }
16972}
16973impl From<ItemModulePtr> for ImplItemPtr {
16974 fn from(value: ItemModulePtr) -> Self {
16975 Self(value.0)
16976 }
16977}
16978impl From<ItemUsePtr> for ImplItemPtr {
16979 fn from(value: ItemUsePtr) -> Self {
16980 Self(value.0)
16981 }
16982}
16983impl From<ItemExternFunctionPtr> for ImplItemPtr {
16984 fn from(value: ItemExternFunctionPtr) -> Self {
16985 Self(value.0)
16986 }
16987}
16988impl From<ItemExternTypePtr> for ImplItemPtr {
16989 fn from(value: ItemExternTypePtr) -> Self {
16990 Self(value.0)
16991 }
16992}
16993impl From<ItemTraitPtr> for ImplItemPtr {
16994 fn from(value: ItemTraitPtr) -> Self {
16995 Self(value.0)
16996 }
16997}
16998impl From<ItemStructPtr> for ImplItemPtr {
16999 fn from(value: ItemStructPtr) -> Self {
17000 Self(value.0)
17001 }
17002}
17003impl From<ItemEnumPtr> for ImplItemPtr {
17004 fn from(value: ItemEnumPtr) -> Self {
17005 Self(value.0)
17006 }
17007}
17008impl From<ImplItemMissingPtr> for ImplItemPtr {
17009 fn from(value: ImplItemMissingPtr) -> Self {
17010 Self(value.0)
17011 }
17012}
17013impl From<FunctionWithBodyGreen> for ImplItemGreen {
17014 fn from(value: FunctionWithBodyGreen) -> Self {
17015 Self(value.0)
17016 }
17017}
17018impl From<ItemTypeAliasGreen> for ImplItemGreen {
17019 fn from(value: ItemTypeAliasGreen) -> Self {
17020 Self(value.0)
17021 }
17022}
17023impl From<ItemConstantGreen> for ImplItemGreen {
17024 fn from(value: ItemConstantGreen) -> Self {
17025 Self(value.0)
17026 }
17027}
17028impl From<ItemImplAliasGreen> for ImplItemGreen {
17029 fn from(value: ItemImplAliasGreen) -> Self {
17030 Self(value.0)
17031 }
17032}
17033impl From<ItemModuleGreen> for ImplItemGreen {
17034 fn from(value: ItemModuleGreen) -> Self {
17035 Self(value.0)
17036 }
17037}
17038impl From<ItemUseGreen> for ImplItemGreen {
17039 fn from(value: ItemUseGreen) -> Self {
17040 Self(value.0)
17041 }
17042}
17043impl From<ItemExternFunctionGreen> for ImplItemGreen {
17044 fn from(value: ItemExternFunctionGreen) -> Self {
17045 Self(value.0)
17046 }
17047}
17048impl From<ItemExternTypeGreen> for ImplItemGreen {
17049 fn from(value: ItemExternTypeGreen) -> Self {
17050 Self(value.0)
17051 }
17052}
17053impl From<ItemTraitGreen> for ImplItemGreen {
17054 fn from(value: ItemTraitGreen) -> Self {
17055 Self(value.0)
17056 }
17057}
17058impl From<ItemStructGreen> for ImplItemGreen {
17059 fn from(value: ItemStructGreen) -> Self {
17060 Self(value.0)
17061 }
17062}
17063impl From<ItemEnumGreen> for ImplItemGreen {
17064 fn from(value: ItemEnumGreen) -> Self {
17065 Self(value.0)
17066 }
17067}
17068impl From<ImplItemMissingGreen> for ImplItemGreen {
17069 fn from(value: ImplItemMissingGreen) -> Self {
17070 Self(value.0)
17071 }
17072}
17073#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17074pub struct ImplItemGreen(pub GreenId);
17075impl TypedSyntaxNode for ImplItem {
17076 const OPTIONAL_KIND: Option<SyntaxKind> = None;
17077 type StablePtr = ImplItemPtr;
17078 type Green = ImplItemGreen;
17079 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17080 ImplItemGreen(ImplItemMissing::missing(db).0)
17081 }
17082 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17083 let kind = node.kind(db);
17084 match kind {
17085 SyntaxKind::FunctionWithBody => {
17086 ImplItem::Function(FunctionWithBody::from_syntax_node(db, node))
17087 }
17088 SyntaxKind::ItemTypeAlias => ImplItem::Type(ItemTypeAlias::from_syntax_node(db, node)),
17089 SyntaxKind::ItemConstant => {
17090 ImplItem::Constant(ItemConstant::from_syntax_node(db, node))
17091 }
17092 SyntaxKind::ItemImplAlias => ImplItem::Impl(ItemImplAlias::from_syntax_node(db, node)),
17093 SyntaxKind::ItemModule => ImplItem::Module(ItemModule::from_syntax_node(db, node)),
17094 SyntaxKind::ItemUse => ImplItem::Use(ItemUse::from_syntax_node(db, node)),
17095 SyntaxKind::ItemExternFunction => {
17096 ImplItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))
17097 }
17098 SyntaxKind::ItemExternType => {
17099 ImplItem::ExternType(ItemExternType::from_syntax_node(db, node))
17100 }
17101 SyntaxKind::ItemTrait => ImplItem::Trait(ItemTrait::from_syntax_node(db, node)),
17102 SyntaxKind::ItemStruct => ImplItem::Struct(ItemStruct::from_syntax_node(db, node)),
17103 SyntaxKind::ItemEnum => ImplItem::Enum(ItemEnum::from_syntax_node(db, node)),
17104 SyntaxKind::ImplItemMissing => {
17105 ImplItem::Missing(ImplItemMissing::from_syntax_node(db, node))
17106 }
17107 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ImplItem"),
17108 }
17109 }
17110 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17111 let kind = node.kind(db);
17112 match kind {
17113 SyntaxKind::FunctionWithBody => {
17114 Some(ImplItem::Function(FunctionWithBody::from_syntax_node(db, node)))
17115 }
17116 SyntaxKind::ItemTypeAlias => {
17117 Some(ImplItem::Type(ItemTypeAlias::from_syntax_node(db, node)))
17118 }
17119 SyntaxKind::ItemConstant => {
17120 Some(ImplItem::Constant(ItemConstant::from_syntax_node(db, node)))
17121 }
17122 SyntaxKind::ItemImplAlias => {
17123 Some(ImplItem::Impl(ItemImplAlias::from_syntax_node(db, node)))
17124 }
17125 SyntaxKind::ItemModule => {
17126 Some(ImplItem::Module(ItemModule::from_syntax_node(db, node)))
17127 }
17128 SyntaxKind::ItemUse => Some(ImplItem::Use(ItemUse::from_syntax_node(db, node))),
17129 SyntaxKind::ItemExternFunction => {
17130 Some(ImplItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node)))
17131 }
17132 SyntaxKind::ItemExternType => {
17133 Some(ImplItem::ExternType(ItemExternType::from_syntax_node(db, node)))
17134 }
17135 SyntaxKind::ItemTrait => Some(ImplItem::Trait(ItemTrait::from_syntax_node(db, node))),
17136 SyntaxKind::ItemStruct => {
17137 Some(ImplItem::Struct(ItemStruct::from_syntax_node(db, node)))
17138 }
17139 SyntaxKind::ItemEnum => Some(ImplItem::Enum(ItemEnum::from_syntax_node(db, node))),
17140 SyntaxKind::ImplItemMissing => {
17141 Some(ImplItem::Missing(ImplItemMissing::from_syntax_node(db, node)))
17142 }
17143 _ => None,
17144 }
17145 }
17146 fn as_syntax_node(&self) -> SyntaxNode {
17147 match self {
17148 ImplItem::Function(x) => x.as_syntax_node(),
17149 ImplItem::Type(x) => x.as_syntax_node(),
17150 ImplItem::Constant(x) => x.as_syntax_node(),
17151 ImplItem::Impl(x) => x.as_syntax_node(),
17152 ImplItem::Module(x) => x.as_syntax_node(),
17153 ImplItem::Use(x) => x.as_syntax_node(),
17154 ImplItem::ExternFunction(x) => x.as_syntax_node(),
17155 ImplItem::ExternType(x) => x.as_syntax_node(),
17156 ImplItem::Trait(x) => x.as_syntax_node(),
17157 ImplItem::Struct(x) => x.as_syntax_node(),
17158 ImplItem::Enum(x) => x.as_syntax_node(),
17159 ImplItem::Missing(x) => x.as_syntax_node(),
17160 }
17161 }
17162 fn stable_ptr(&self) -> Self::StablePtr {
17163 ImplItemPtr(self.as_syntax_node().0.stable_ptr)
17164 }
17165}
17166impl From<&ImplItem> for SyntaxStablePtrId {
17167 fn from(node: &ImplItem) -> Self {
17168 node.stable_ptr().untyped()
17169 }
17170}
17171impl ImplItem {
17172 pub fn is_variant(kind: SyntaxKind) -> bool {
17174 matches!(
17175 kind,
17176 SyntaxKind::FunctionWithBody
17177 | SyntaxKind::ItemTypeAlias
17178 | SyntaxKind::ItemConstant
17179 | SyntaxKind::ItemImplAlias
17180 | SyntaxKind::ItemModule
17181 | SyntaxKind::ItemUse
17182 | SyntaxKind::ItemExternFunction
17183 | SyntaxKind::ItemExternType
17184 | SyntaxKind::ItemTrait
17185 | SyntaxKind::ItemStruct
17186 | SyntaxKind::ItemEnum
17187 | SyntaxKind::ImplItemMissing
17188 )
17189 }
17190}
17191#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17192pub struct ImplItemMissing {
17193 node: SyntaxNode,
17194 children: Arc<[SyntaxNode]>,
17195}
17196impl ImplItemMissing {
17197 pub fn new_green(db: &dyn SyntaxGroup) -> ImplItemMissingGreen {
17198 let children: Vec<GreenId> = vec![];
17199 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17200 ImplItemMissingGreen(
17201 Arc::new(GreenNode {
17202 kind: SyntaxKind::ImplItemMissing,
17203 details: GreenNodeDetails::Node { children, width },
17204 })
17205 .intern(db),
17206 )
17207 }
17208}
17209impl ImplItemMissing {}
17210#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17211pub struct ImplItemMissingPtr(pub SyntaxStablePtrId);
17212impl ImplItemMissingPtr {}
17213impl TypedStablePtr for ImplItemMissingPtr {
17214 type SyntaxNode = ImplItemMissing;
17215 fn untyped(&self) -> SyntaxStablePtrId {
17216 self.0
17217 }
17218 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItemMissing {
17219 ImplItemMissing::from_syntax_node(db, self.0.lookup(db))
17220 }
17221}
17222impl From<ImplItemMissingPtr> for SyntaxStablePtrId {
17223 fn from(ptr: ImplItemMissingPtr) -> Self {
17224 ptr.untyped()
17225 }
17226}
17227#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17228pub struct ImplItemMissingGreen(pub GreenId);
17229impl TypedSyntaxNode for ImplItemMissing {
17230 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplItemMissing);
17231 type StablePtr = ImplItemMissingPtr;
17232 type Green = ImplItemMissingGreen;
17233 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17234 ImplItemMissingGreen(
17235 Arc::new(GreenNode {
17236 kind: SyntaxKind::ImplItemMissing,
17237 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
17238 })
17239 .intern(db),
17240 )
17241 }
17242 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17243 let kind = node.kind(db);
17244 assert_eq!(
17245 kind,
17246 SyntaxKind::ImplItemMissing,
17247 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17248 kind,
17249 SyntaxKind::ImplItemMissing
17250 );
17251 let children = db.get_children(node.clone());
17252 Self { node, children }
17253 }
17254 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17255 let kind = node.kind(db);
17256 if kind == SyntaxKind::ImplItemMissing {
17257 Some(Self::from_syntax_node(db, node))
17258 } else {
17259 None
17260 }
17261 }
17262 fn as_syntax_node(&self) -> SyntaxNode {
17263 self.node.clone()
17264 }
17265 fn stable_ptr(&self) -> Self::StablePtr {
17266 ImplItemMissingPtr(self.node.0.stable_ptr)
17267 }
17268}
17269impl From<&ImplItemMissing> for SyntaxStablePtrId {
17270 fn from(node: &ImplItemMissing) -> Self {
17271 node.stable_ptr().untyped()
17272 }
17273}
17274#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17275pub struct ItemImplAlias {
17276 node: SyntaxNode,
17277 children: Arc<[SyntaxNode]>,
17278}
17279impl ItemImplAlias {
17280 pub const INDEX_ATTRIBUTES: usize = 0;
17281 pub const INDEX_VISIBILITY: usize = 1;
17282 pub const INDEX_IMPL_KW: usize = 2;
17283 pub const INDEX_NAME: usize = 3;
17284 pub const INDEX_GENERIC_PARAMS: usize = 4;
17285 pub const INDEX_EQ: usize = 5;
17286 pub const INDEX_IMPL_PATH: usize = 6;
17287 pub const INDEX_SEMICOLON: usize = 7;
17288 pub fn new_green(
17289 db: &dyn SyntaxGroup,
17290 attributes: AttributeListGreen,
17291 visibility: VisibilityGreen,
17292 impl_kw: TerminalImplGreen,
17293 name: TerminalIdentifierGreen,
17294 generic_params: OptionWrappedGenericParamListGreen,
17295 eq: TerminalEqGreen,
17296 impl_path: ExprPathGreen,
17297 semicolon: TerminalSemicolonGreen,
17298 ) -> ItemImplAliasGreen {
17299 let children: Vec<GreenId> = vec![
17300 attributes.0,
17301 visibility.0,
17302 impl_kw.0,
17303 name.0,
17304 generic_params.0,
17305 eq.0,
17306 impl_path.0,
17307 semicolon.0,
17308 ];
17309 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17310 ItemImplAliasGreen(
17311 Arc::new(GreenNode {
17312 kind: SyntaxKind::ItemImplAlias,
17313 details: GreenNodeDetails::Node { children, width },
17314 })
17315 .intern(db),
17316 )
17317 }
17318}
17319impl ItemImplAlias {
17320 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
17321 AttributeList::from_syntax_node(db, self.children[0].clone())
17322 }
17323 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
17324 Visibility::from_syntax_node(db, self.children[1].clone())
17325 }
17326 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
17327 TerminalImpl::from_syntax_node(db, self.children[2].clone())
17328 }
17329 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17330 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
17331 }
17332 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
17333 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
17334 }
17335 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
17336 TerminalEq::from_syntax_node(db, self.children[5].clone())
17337 }
17338 pub fn impl_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
17339 ExprPath::from_syntax_node(db, self.children[6].clone())
17340 }
17341 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
17342 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
17343 }
17344}
17345#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17346pub struct ItemImplAliasPtr(pub SyntaxStablePtrId);
17347impl ItemImplAliasPtr {
17348 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
17349 let ptr = self.0.lookup_intern(db);
17350 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17351 TerminalIdentifierGreen(key_fields[0])
17352 } else {
17353 panic!("Unexpected key field query on root.");
17354 }
17355 }
17356}
17357impl TypedStablePtr for ItemImplAliasPtr {
17358 type SyntaxNode = ItemImplAlias;
17359 fn untyped(&self) -> SyntaxStablePtrId {
17360 self.0
17361 }
17362 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemImplAlias {
17363 ItemImplAlias::from_syntax_node(db, self.0.lookup(db))
17364 }
17365}
17366impl From<ItemImplAliasPtr> for SyntaxStablePtrId {
17367 fn from(ptr: ItemImplAliasPtr) -> Self {
17368 ptr.untyped()
17369 }
17370}
17371#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17372pub struct ItemImplAliasGreen(pub GreenId);
17373impl TypedSyntaxNode for ItemImplAlias {
17374 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemImplAlias);
17375 type StablePtr = ItemImplAliasPtr;
17376 type Green = ItemImplAliasGreen;
17377 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17378 ItemImplAliasGreen(
17379 Arc::new(GreenNode {
17380 kind: SyntaxKind::ItemImplAlias,
17381 details: GreenNodeDetails::Node {
17382 children: vec![
17383 AttributeList::missing(db).0,
17384 Visibility::missing(db).0,
17385 TerminalImpl::missing(db).0,
17386 TerminalIdentifier::missing(db).0,
17387 OptionWrappedGenericParamList::missing(db).0,
17388 TerminalEq::missing(db).0,
17389 ExprPath::missing(db).0,
17390 TerminalSemicolon::missing(db).0,
17391 ],
17392 width: TextWidth::default(),
17393 },
17394 })
17395 .intern(db),
17396 )
17397 }
17398 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17399 let kind = node.kind(db);
17400 assert_eq!(
17401 kind,
17402 SyntaxKind::ItemImplAlias,
17403 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17404 kind,
17405 SyntaxKind::ItemImplAlias
17406 );
17407 let children = db.get_children(node.clone());
17408 Self { node, children }
17409 }
17410 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17411 let kind = node.kind(db);
17412 if kind == SyntaxKind::ItemImplAlias {
17413 Some(Self::from_syntax_node(db, node))
17414 } else {
17415 None
17416 }
17417 }
17418 fn as_syntax_node(&self) -> SyntaxNode {
17419 self.node.clone()
17420 }
17421 fn stable_ptr(&self) -> Self::StablePtr {
17422 ItemImplAliasPtr(self.node.0.stable_ptr)
17423 }
17424}
17425impl From<&ItemImplAlias> for SyntaxStablePtrId {
17426 fn from(node: &ItemImplAlias) -> Self {
17427 node.stable_ptr().untyped()
17428 }
17429}
17430#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17431pub struct ItemStruct {
17432 node: SyntaxNode,
17433 children: Arc<[SyntaxNode]>,
17434}
17435impl ItemStruct {
17436 pub const INDEX_ATTRIBUTES: usize = 0;
17437 pub const INDEX_VISIBILITY: usize = 1;
17438 pub const INDEX_STRUCT_KW: usize = 2;
17439 pub const INDEX_NAME: usize = 3;
17440 pub const INDEX_GENERIC_PARAMS: usize = 4;
17441 pub const INDEX_LBRACE: usize = 5;
17442 pub const INDEX_MEMBERS: usize = 6;
17443 pub const INDEX_RBRACE: usize = 7;
17444 pub fn new_green(
17445 db: &dyn SyntaxGroup,
17446 attributes: AttributeListGreen,
17447 visibility: VisibilityGreen,
17448 struct_kw: TerminalStructGreen,
17449 name: TerminalIdentifierGreen,
17450 generic_params: OptionWrappedGenericParamListGreen,
17451 lbrace: TerminalLBraceGreen,
17452 members: MemberListGreen,
17453 rbrace: TerminalRBraceGreen,
17454 ) -> ItemStructGreen {
17455 let children: Vec<GreenId> = vec![
17456 attributes.0,
17457 visibility.0,
17458 struct_kw.0,
17459 name.0,
17460 generic_params.0,
17461 lbrace.0,
17462 members.0,
17463 rbrace.0,
17464 ];
17465 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17466 ItemStructGreen(
17467 Arc::new(GreenNode {
17468 kind: SyntaxKind::ItemStruct,
17469 details: GreenNodeDetails::Node { children, width },
17470 })
17471 .intern(db),
17472 )
17473 }
17474}
17475impl ItemStruct {
17476 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
17477 AttributeList::from_syntax_node(db, self.children[0].clone())
17478 }
17479 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
17480 Visibility::from_syntax_node(db, self.children[1].clone())
17481 }
17482 pub fn struct_kw(&self, db: &dyn SyntaxGroup) -> TerminalStruct {
17483 TerminalStruct::from_syntax_node(db, self.children[2].clone())
17484 }
17485 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17486 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
17487 }
17488 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
17489 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
17490 }
17491 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
17492 TerminalLBrace::from_syntax_node(db, self.children[5].clone())
17493 }
17494 pub fn members(&self, db: &dyn SyntaxGroup) -> MemberList {
17495 MemberList::from_syntax_node(db, self.children[6].clone())
17496 }
17497 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
17498 TerminalRBrace::from_syntax_node(db, self.children[7].clone())
17499 }
17500}
17501#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17502pub struct ItemStructPtr(pub SyntaxStablePtrId);
17503impl ItemStructPtr {
17504 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
17505 let ptr = self.0.lookup_intern(db);
17506 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17507 TerminalIdentifierGreen(key_fields[0])
17508 } else {
17509 panic!("Unexpected key field query on root.");
17510 }
17511 }
17512}
17513impl TypedStablePtr for ItemStructPtr {
17514 type SyntaxNode = ItemStruct;
17515 fn untyped(&self) -> SyntaxStablePtrId {
17516 self.0
17517 }
17518 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemStruct {
17519 ItemStruct::from_syntax_node(db, self.0.lookup(db))
17520 }
17521}
17522impl From<ItemStructPtr> for SyntaxStablePtrId {
17523 fn from(ptr: ItemStructPtr) -> Self {
17524 ptr.untyped()
17525 }
17526}
17527#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17528pub struct ItemStructGreen(pub GreenId);
17529impl TypedSyntaxNode for ItemStruct {
17530 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemStruct);
17531 type StablePtr = ItemStructPtr;
17532 type Green = ItemStructGreen;
17533 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17534 ItemStructGreen(
17535 Arc::new(GreenNode {
17536 kind: SyntaxKind::ItemStruct,
17537 details: GreenNodeDetails::Node {
17538 children: vec![
17539 AttributeList::missing(db).0,
17540 Visibility::missing(db).0,
17541 TerminalStruct::missing(db).0,
17542 TerminalIdentifier::missing(db).0,
17543 OptionWrappedGenericParamList::missing(db).0,
17544 TerminalLBrace::missing(db).0,
17545 MemberList::missing(db).0,
17546 TerminalRBrace::missing(db).0,
17547 ],
17548 width: TextWidth::default(),
17549 },
17550 })
17551 .intern(db),
17552 )
17553 }
17554 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17555 let kind = node.kind(db);
17556 assert_eq!(
17557 kind,
17558 SyntaxKind::ItemStruct,
17559 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17560 kind,
17561 SyntaxKind::ItemStruct
17562 );
17563 let children = db.get_children(node.clone());
17564 Self { node, children }
17565 }
17566 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17567 let kind = node.kind(db);
17568 if kind == SyntaxKind::ItemStruct { Some(Self::from_syntax_node(db, node)) } else { None }
17569 }
17570 fn as_syntax_node(&self) -> SyntaxNode {
17571 self.node.clone()
17572 }
17573 fn stable_ptr(&self) -> Self::StablePtr {
17574 ItemStructPtr(self.node.0.stable_ptr)
17575 }
17576}
17577impl From<&ItemStruct> for SyntaxStablePtrId {
17578 fn from(node: &ItemStruct) -> Self {
17579 node.stable_ptr().untyped()
17580 }
17581}
17582#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17583pub struct ItemEnum {
17584 node: SyntaxNode,
17585 children: Arc<[SyntaxNode]>,
17586}
17587impl ItemEnum {
17588 pub const INDEX_ATTRIBUTES: usize = 0;
17589 pub const INDEX_VISIBILITY: usize = 1;
17590 pub const INDEX_ENUM_KW: usize = 2;
17591 pub const INDEX_NAME: usize = 3;
17592 pub const INDEX_GENERIC_PARAMS: usize = 4;
17593 pub const INDEX_LBRACE: usize = 5;
17594 pub const INDEX_VARIANTS: usize = 6;
17595 pub const INDEX_RBRACE: usize = 7;
17596 pub fn new_green(
17597 db: &dyn SyntaxGroup,
17598 attributes: AttributeListGreen,
17599 visibility: VisibilityGreen,
17600 enum_kw: TerminalEnumGreen,
17601 name: TerminalIdentifierGreen,
17602 generic_params: OptionWrappedGenericParamListGreen,
17603 lbrace: TerminalLBraceGreen,
17604 variants: VariantListGreen,
17605 rbrace: TerminalRBraceGreen,
17606 ) -> ItemEnumGreen {
17607 let children: Vec<GreenId> = vec![
17608 attributes.0,
17609 visibility.0,
17610 enum_kw.0,
17611 name.0,
17612 generic_params.0,
17613 lbrace.0,
17614 variants.0,
17615 rbrace.0,
17616 ];
17617 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17618 ItemEnumGreen(
17619 Arc::new(GreenNode {
17620 kind: SyntaxKind::ItemEnum,
17621 details: GreenNodeDetails::Node { children, width },
17622 })
17623 .intern(db),
17624 )
17625 }
17626}
17627impl ItemEnum {
17628 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
17629 AttributeList::from_syntax_node(db, self.children[0].clone())
17630 }
17631 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
17632 Visibility::from_syntax_node(db, self.children[1].clone())
17633 }
17634 pub fn enum_kw(&self, db: &dyn SyntaxGroup) -> TerminalEnum {
17635 TerminalEnum::from_syntax_node(db, self.children[2].clone())
17636 }
17637 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17638 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
17639 }
17640 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
17641 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
17642 }
17643 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
17644 TerminalLBrace::from_syntax_node(db, self.children[5].clone())
17645 }
17646 pub fn variants(&self, db: &dyn SyntaxGroup) -> VariantList {
17647 VariantList::from_syntax_node(db, self.children[6].clone())
17648 }
17649 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
17650 TerminalRBrace::from_syntax_node(db, self.children[7].clone())
17651 }
17652}
17653#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17654pub struct ItemEnumPtr(pub SyntaxStablePtrId);
17655impl ItemEnumPtr {
17656 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
17657 let ptr = self.0.lookup_intern(db);
17658 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17659 TerminalIdentifierGreen(key_fields[0])
17660 } else {
17661 panic!("Unexpected key field query on root.");
17662 }
17663 }
17664}
17665impl TypedStablePtr for ItemEnumPtr {
17666 type SyntaxNode = ItemEnum;
17667 fn untyped(&self) -> SyntaxStablePtrId {
17668 self.0
17669 }
17670 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemEnum {
17671 ItemEnum::from_syntax_node(db, self.0.lookup(db))
17672 }
17673}
17674impl From<ItemEnumPtr> for SyntaxStablePtrId {
17675 fn from(ptr: ItemEnumPtr) -> Self {
17676 ptr.untyped()
17677 }
17678}
17679#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17680pub struct ItemEnumGreen(pub GreenId);
17681impl TypedSyntaxNode for ItemEnum {
17682 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemEnum);
17683 type StablePtr = ItemEnumPtr;
17684 type Green = ItemEnumGreen;
17685 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17686 ItemEnumGreen(
17687 Arc::new(GreenNode {
17688 kind: SyntaxKind::ItemEnum,
17689 details: GreenNodeDetails::Node {
17690 children: vec![
17691 AttributeList::missing(db).0,
17692 Visibility::missing(db).0,
17693 TerminalEnum::missing(db).0,
17694 TerminalIdentifier::missing(db).0,
17695 OptionWrappedGenericParamList::missing(db).0,
17696 TerminalLBrace::missing(db).0,
17697 VariantList::missing(db).0,
17698 TerminalRBrace::missing(db).0,
17699 ],
17700 width: TextWidth::default(),
17701 },
17702 })
17703 .intern(db),
17704 )
17705 }
17706 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17707 let kind = node.kind(db);
17708 assert_eq!(
17709 kind,
17710 SyntaxKind::ItemEnum,
17711 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17712 kind,
17713 SyntaxKind::ItemEnum
17714 );
17715 let children = db.get_children(node.clone());
17716 Self { node, children }
17717 }
17718 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17719 let kind = node.kind(db);
17720 if kind == SyntaxKind::ItemEnum { Some(Self::from_syntax_node(db, node)) } else { None }
17721 }
17722 fn as_syntax_node(&self) -> SyntaxNode {
17723 self.node.clone()
17724 }
17725 fn stable_ptr(&self) -> Self::StablePtr {
17726 ItemEnumPtr(self.node.0.stable_ptr)
17727 }
17728}
17729impl From<&ItemEnum> for SyntaxStablePtrId {
17730 fn from(node: &ItemEnum) -> Self {
17731 node.stable_ptr().untyped()
17732 }
17733}
17734#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17735pub struct ItemTypeAlias {
17736 node: SyntaxNode,
17737 children: Arc<[SyntaxNode]>,
17738}
17739impl ItemTypeAlias {
17740 pub const INDEX_ATTRIBUTES: usize = 0;
17741 pub const INDEX_VISIBILITY: usize = 1;
17742 pub const INDEX_TYPE_KW: usize = 2;
17743 pub const INDEX_NAME: usize = 3;
17744 pub const INDEX_GENERIC_PARAMS: usize = 4;
17745 pub const INDEX_EQ: usize = 5;
17746 pub const INDEX_TY: usize = 6;
17747 pub const INDEX_SEMICOLON: usize = 7;
17748 pub fn new_green(
17749 db: &dyn SyntaxGroup,
17750 attributes: AttributeListGreen,
17751 visibility: VisibilityGreen,
17752 type_kw: TerminalTypeGreen,
17753 name: TerminalIdentifierGreen,
17754 generic_params: OptionWrappedGenericParamListGreen,
17755 eq: TerminalEqGreen,
17756 ty: ExprGreen,
17757 semicolon: TerminalSemicolonGreen,
17758 ) -> ItemTypeAliasGreen {
17759 let children: Vec<GreenId> = vec![
17760 attributes.0,
17761 visibility.0,
17762 type_kw.0,
17763 name.0,
17764 generic_params.0,
17765 eq.0,
17766 ty.0,
17767 semicolon.0,
17768 ];
17769 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17770 ItemTypeAliasGreen(
17771 Arc::new(GreenNode {
17772 kind: SyntaxKind::ItemTypeAlias,
17773 details: GreenNodeDetails::Node { children, width },
17774 })
17775 .intern(db),
17776 )
17777 }
17778}
17779impl ItemTypeAlias {
17780 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
17781 AttributeList::from_syntax_node(db, self.children[0].clone())
17782 }
17783 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
17784 Visibility::from_syntax_node(db, self.children[1].clone())
17785 }
17786 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
17787 TerminalType::from_syntax_node(db, self.children[2].clone())
17788 }
17789 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17790 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
17791 }
17792 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
17793 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
17794 }
17795 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
17796 TerminalEq::from_syntax_node(db, self.children[5].clone())
17797 }
17798 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
17799 Expr::from_syntax_node(db, self.children[6].clone())
17800 }
17801 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
17802 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
17803 }
17804}
17805#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17806pub struct ItemTypeAliasPtr(pub SyntaxStablePtrId);
17807impl ItemTypeAliasPtr {
17808 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
17809 let ptr = self.0.lookup_intern(db);
17810 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17811 TerminalIdentifierGreen(key_fields[0])
17812 } else {
17813 panic!("Unexpected key field query on root.");
17814 }
17815 }
17816}
17817impl TypedStablePtr for ItemTypeAliasPtr {
17818 type SyntaxNode = ItemTypeAlias;
17819 fn untyped(&self) -> SyntaxStablePtrId {
17820 self.0
17821 }
17822 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemTypeAlias {
17823 ItemTypeAlias::from_syntax_node(db, self.0.lookup(db))
17824 }
17825}
17826impl From<ItemTypeAliasPtr> for SyntaxStablePtrId {
17827 fn from(ptr: ItemTypeAliasPtr) -> Self {
17828 ptr.untyped()
17829 }
17830}
17831#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17832pub struct ItemTypeAliasGreen(pub GreenId);
17833impl TypedSyntaxNode for ItemTypeAlias {
17834 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemTypeAlias);
17835 type StablePtr = ItemTypeAliasPtr;
17836 type Green = ItemTypeAliasGreen;
17837 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17838 ItemTypeAliasGreen(
17839 Arc::new(GreenNode {
17840 kind: SyntaxKind::ItemTypeAlias,
17841 details: GreenNodeDetails::Node {
17842 children: vec![
17843 AttributeList::missing(db).0,
17844 Visibility::missing(db).0,
17845 TerminalType::missing(db).0,
17846 TerminalIdentifier::missing(db).0,
17847 OptionWrappedGenericParamList::missing(db).0,
17848 TerminalEq::missing(db).0,
17849 Expr::missing(db).0,
17850 TerminalSemicolon::missing(db).0,
17851 ],
17852 width: TextWidth::default(),
17853 },
17854 })
17855 .intern(db),
17856 )
17857 }
17858 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17859 let kind = node.kind(db);
17860 assert_eq!(
17861 kind,
17862 SyntaxKind::ItemTypeAlias,
17863 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17864 kind,
17865 SyntaxKind::ItemTypeAlias
17866 );
17867 let children = db.get_children(node.clone());
17868 Self { node, children }
17869 }
17870 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
17871 let kind = node.kind(db);
17872 if kind == SyntaxKind::ItemTypeAlias {
17873 Some(Self::from_syntax_node(db, node))
17874 } else {
17875 None
17876 }
17877 }
17878 fn as_syntax_node(&self) -> SyntaxNode {
17879 self.node.clone()
17880 }
17881 fn stable_ptr(&self) -> Self::StablePtr {
17882 ItemTypeAliasPtr(self.node.0.stable_ptr)
17883 }
17884}
17885impl From<&ItemTypeAlias> for SyntaxStablePtrId {
17886 fn from(node: &ItemTypeAlias) -> Self {
17887 node.stable_ptr().untyped()
17888 }
17889}
17890#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17891pub struct ItemUse {
17892 node: SyntaxNode,
17893 children: Arc<[SyntaxNode]>,
17894}
17895impl ItemUse {
17896 pub const INDEX_ATTRIBUTES: usize = 0;
17897 pub const INDEX_VISIBILITY: usize = 1;
17898 pub const INDEX_USE_KW: usize = 2;
17899 pub const INDEX_USE_PATH: usize = 3;
17900 pub const INDEX_SEMICOLON: usize = 4;
17901 pub fn new_green(
17902 db: &dyn SyntaxGroup,
17903 attributes: AttributeListGreen,
17904 visibility: VisibilityGreen,
17905 use_kw: TerminalUseGreen,
17906 use_path: UsePathGreen,
17907 semicolon: TerminalSemicolonGreen,
17908 ) -> ItemUseGreen {
17909 let children: Vec<GreenId> =
17910 vec![attributes.0, visibility.0, use_kw.0, use_path.0, semicolon.0];
17911 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17912 ItemUseGreen(
17913 Arc::new(GreenNode {
17914 kind: SyntaxKind::ItemUse,
17915 details: GreenNodeDetails::Node { children, width },
17916 })
17917 .intern(db),
17918 )
17919 }
17920}
17921impl ItemUse {
17922 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
17923 AttributeList::from_syntax_node(db, self.children[0].clone())
17924 }
17925 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
17926 Visibility::from_syntax_node(db, self.children[1].clone())
17927 }
17928 pub fn use_kw(&self, db: &dyn SyntaxGroup) -> TerminalUse {
17929 TerminalUse::from_syntax_node(db, self.children[2].clone())
17930 }
17931 pub fn use_path(&self, db: &dyn SyntaxGroup) -> UsePath {
17932 UsePath::from_syntax_node(db, self.children[3].clone())
17933 }
17934 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
17935 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
17936 }
17937}
17938#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17939pub struct ItemUsePtr(pub SyntaxStablePtrId);
17940impl ItemUsePtr {
17941 pub fn use_path_green(self, db: &dyn SyntaxGroup) -> UsePathGreen {
17942 let ptr = self.0.lookup_intern(db);
17943 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17944 UsePathGreen(key_fields[0])
17945 } else {
17946 panic!("Unexpected key field query on root.");
17947 }
17948 }
17949}
17950impl TypedStablePtr for ItemUsePtr {
17951 type SyntaxNode = ItemUse;
17952 fn untyped(&self) -> SyntaxStablePtrId {
17953 self.0
17954 }
17955 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemUse {
17956 ItemUse::from_syntax_node(db, self.0.lookup(db))
17957 }
17958}
17959impl From<ItemUsePtr> for SyntaxStablePtrId {
17960 fn from(ptr: ItemUsePtr) -> Self {
17961 ptr.untyped()
17962 }
17963}
17964#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17965pub struct ItemUseGreen(pub GreenId);
17966impl TypedSyntaxNode for ItemUse {
17967 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemUse);
17968 type StablePtr = ItemUsePtr;
17969 type Green = ItemUseGreen;
17970 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17971 ItemUseGreen(
17972 Arc::new(GreenNode {
17973 kind: SyntaxKind::ItemUse,
17974 details: GreenNodeDetails::Node {
17975 children: vec![
17976 AttributeList::missing(db).0,
17977 Visibility::missing(db).0,
17978 TerminalUse::missing(db).0,
17979 UsePath::missing(db).0,
17980 TerminalSemicolon::missing(db).0,
17981 ],
17982 width: TextWidth::default(),
17983 },
17984 })
17985 .intern(db),
17986 )
17987 }
17988 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17989 let kind = node.kind(db);
17990 assert_eq!(
17991 kind,
17992 SyntaxKind::ItemUse,
17993 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17994 kind,
17995 SyntaxKind::ItemUse
17996 );
17997 let children = db.get_children(node.clone());
17998 Self { node, children }
17999 }
18000 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18001 let kind = node.kind(db);
18002 if kind == SyntaxKind::ItemUse { Some(Self::from_syntax_node(db, node)) } else { None }
18003 }
18004 fn as_syntax_node(&self) -> SyntaxNode {
18005 self.node.clone()
18006 }
18007 fn stable_ptr(&self) -> Self::StablePtr {
18008 ItemUsePtr(self.node.0.stable_ptr)
18009 }
18010}
18011impl From<&ItemUse> for SyntaxStablePtrId {
18012 fn from(node: &ItemUse) -> Self {
18013 node.stable_ptr().untyped()
18014 }
18015}
18016#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18017pub enum UsePath {
18018 Leaf(UsePathLeaf),
18019 Single(UsePathSingle),
18020 Multi(UsePathMulti),
18021 Star(UsePathStar),
18022}
18023#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18024pub struct UsePathPtr(pub SyntaxStablePtrId);
18025impl TypedStablePtr for UsePathPtr {
18026 type SyntaxNode = UsePath;
18027 fn untyped(&self) -> SyntaxStablePtrId {
18028 self.0
18029 }
18030 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePath {
18031 UsePath::from_syntax_node(db, self.0.lookup(db))
18032 }
18033}
18034impl From<UsePathPtr> for SyntaxStablePtrId {
18035 fn from(ptr: UsePathPtr) -> Self {
18036 ptr.untyped()
18037 }
18038}
18039impl From<UsePathLeafPtr> for UsePathPtr {
18040 fn from(value: UsePathLeafPtr) -> Self {
18041 Self(value.0)
18042 }
18043}
18044impl From<UsePathSinglePtr> for UsePathPtr {
18045 fn from(value: UsePathSinglePtr) -> Self {
18046 Self(value.0)
18047 }
18048}
18049impl From<UsePathMultiPtr> for UsePathPtr {
18050 fn from(value: UsePathMultiPtr) -> Self {
18051 Self(value.0)
18052 }
18053}
18054impl From<UsePathStarPtr> for UsePathPtr {
18055 fn from(value: UsePathStarPtr) -> Self {
18056 Self(value.0)
18057 }
18058}
18059impl From<UsePathLeafGreen> for UsePathGreen {
18060 fn from(value: UsePathLeafGreen) -> Self {
18061 Self(value.0)
18062 }
18063}
18064impl From<UsePathSingleGreen> for UsePathGreen {
18065 fn from(value: UsePathSingleGreen) -> Self {
18066 Self(value.0)
18067 }
18068}
18069impl From<UsePathMultiGreen> for UsePathGreen {
18070 fn from(value: UsePathMultiGreen) -> Self {
18071 Self(value.0)
18072 }
18073}
18074impl From<UsePathStarGreen> for UsePathGreen {
18075 fn from(value: UsePathStarGreen) -> Self {
18076 Self(value.0)
18077 }
18078}
18079#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18080pub struct UsePathGreen(pub GreenId);
18081impl TypedSyntaxNode for UsePath {
18082 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18083 type StablePtr = UsePathPtr;
18084 type Green = UsePathGreen;
18085 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18086 panic!("No missing variant.");
18087 }
18088 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18089 let kind = node.kind(db);
18090 match kind {
18091 SyntaxKind::UsePathLeaf => UsePath::Leaf(UsePathLeaf::from_syntax_node(db, node)),
18092 SyntaxKind::UsePathSingle => UsePath::Single(UsePathSingle::from_syntax_node(db, node)),
18093 SyntaxKind::UsePathMulti => UsePath::Multi(UsePathMulti::from_syntax_node(db, node)),
18094 SyntaxKind::UsePathStar => UsePath::Star(UsePathStar::from_syntax_node(db, node)),
18095 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UsePath"),
18096 }
18097 }
18098 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18099 let kind = node.kind(db);
18100 match kind {
18101 SyntaxKind::UsePathLeaf => Some(UsePath::Leaf(UsePathLeaf::from_syntax_node(db, node))),
18102 SyntaxKind::UsePathSingle => {
18103 Some(UsePath::Single(UsePathSingle::from_syntax_node(db, node)))
18104 }
18105 SyntaxKind::UsePathMulti => {
18106 Some(UsePath::Multi(UsePathMulti::from_syntax_node(db, node)))
18107 }
18108 SyntaxKind::UsePathStar => Some(UsePath::Star(UsePathStar::from_syntax_node(db, node))),
18109 _ => None,
18110 }
18111 }
18112 fn as_syntax_node(&self) -> SyntaxNode {
18113 match self {
18114 UsePath::Leaf(x) => x.as_syntax_node(),
18115 UsePath::Single(x) => x.as_syntax_node(),
18116 UsePath::Multi(x) => x.as_syntax_node(),
18117 UsePath::Star(x) => x.as_syntax_node(),
18118 }
18119 }
18120 fn stable_ptr(&self) -> Self::StablePtr {
18121 UsePathPtr(self.as_syntax_node().0.stable_ptr)
18122 }
18123}
18124impl From<&UsePath> for SyntaxStablePtrId {
18125 fn from(node: &UsePath) -> Self {
18126 node.stable_ptr().untyped()
18127 }
18128}
18129impl UsePath {
18130 pub fn is_variant(kind: SyntaxKind) -> bool {
18132 matches!(
18133 kind,
18134 SyntaxKind::UsePathLeaf
18135 | SyntaxKind::UsePathSingle
18136 | SyntaxKind::UsePathMulti
18137 | SyntaxKind::UsePathStar
18138 )
18139 }
18140}
18141#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18142pub struct UsePathLeaf {
18143 node: SyntaxNode,
18144 children: Arc<[SyntaxNode]>,
18145}
18146impl UsePathLeaf {
18147 pub const INDEX_IDENT: usize = 0;
18148 pub const INDEX_ALIAS_CLAUSE: usize = 1;
18149 pub fn new_green(
18150 db: &dyn SyntaxGroup,
18151 ident: PathSegmentGreen,
18152 alias_clause: OptionAliasClauseGreen,
18153 ) -> UsePathLeafGreen {
18154 let children: Vec<GreenId> = vec![ident.0, alias_clause.0];
18155 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18156 UsePathLeafGreen(
18157 Arc::new(GreenNode {
18158 kind: SyntaxKind::UsePathLeaf,
18159 details: GreenNodeDetails::Node { children, width },
18160 })
18161 .intern(db),
18162 )
18163 }
18164}
18165impl UsePathLeaf {
18166 pub fn ident(&self, db: &dyn SyntaxGroup) -> PathSegment {
18167 PathSegment::from_syntax_node(db, self.children[0].clone())
18168 }
18169 pub fn alias_clause(&self, db: &dyn SyntaxGroup) -> OptionAliasClause {
18170 OptionAliasClause::from_syntax_node(db, self.children[1].clone())
18171 }
18172}
18173#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18174pub struct UsePathLeafPtr(pub SyntaxStablePtrId);
18175impl UsePathLeafPtr {
18176 pub fn ident_green(self, db: &dyn SyntaxGroup) -> PathSegmentGreen {
18177 let ptr = self.0.lookup_intern(db);
18178 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
18179 PathSegmentGreen(key_fields[0])
18180 } else {
18181 panic!("Unexpected key field query on root.");
18182 }
18183 }
18184 pub fn alias_clause_green(self, db: &dyn SyntaxGroup) -> OptionAliasClauseGreen {
18185 let ptr = self.0.lookup_intern(db);
18186 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
18187 OptionAliasClauseGreen(key_fields[1])
18188 } else {
18189 panic!("Unexpected key field query on root.");
18190 }
18191 }
18192}
18193impl TypedStablePtr for UsePathLeafPtr {
18194 type SyntaxNode = UsePathLeaf;
18195 fn untyped(&self) -> SyntaxStablePtrId {
18196 self.0
18197 }
18198 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathLeaf {
18199 UsePathLeaf::from_syntax_node(db, self.0.lookup(db))
18200 }
18201}
18202impl From<UsePathLeafPtr> for SyntaxStablePtrId {
18203 fn from(ptr: UsePathLeafPtr) -> Self {
18204 ptr.untyped()
18205 }
18206}
18207#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18208pub struct UsePathLeafGreen(pub GreenId);
18209impl TypedSyntaxNode for UsePathLeaf {
18210 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathLeaf);
18211 type StablePtr = UsePathLeafPtr;
18212 type Green = UsePathLeafGreen;
18213 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18214 UsePathLeafGreen(
18215 Arc::new(GreenNode {
18216 kind: SyntaxKind::UsePathLeaf,
18217 details: GreenNodeDetails::Node {
18218 children: vec![PathSegment::missing(db).0, OptionAliasClause::missing(db).0],
18219 width: TextWidth::default(),
18220 },
18221 })
18222 .intern(db),
18223 )
18224 }
18225 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18226 let kind = node.kind(db);
18227 assert_eq!(
18228 kind,
18229 SyntaxKind::UsePathLeaf,
18230 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18231 kind,
18232 SyntaxKind::UsePathLeaf
18233 );
18234 let children = db.get_children(node.clone());
18235 Self { node, children }
18236 }
18237 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18238 let kind = node.kind(db);
18239 if kind == SyntaxKind::UsePathLeaf { Some(Self::from_syntax_node(db, node)) } else { None }
18240 }
18241 fn as_syntax_node(&self) -> SyntaxNode {
18242 self.node.clone()
18243 }
18244 fn stable_ptr(&self) -> Self::StablePtr {
18245 UsePathLeafPtr(self.node.0.stable_ptr)
18246 }
18247}
18248impl From<&UsePathLeaf> for SyntaxStablePtrId {
18249 fn from(node: &UsePathLeaf) -> Self {
18250 node.stable_ptr().untyped()
18251 }
18252}
18253#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18254pub struct UsePathSingle {
18255 node: SyntaxNode,
18256 children: Arc<[SyntaxNode]>,
18257}
18258impl UsePathSingle {
18259 pub const INDEX_IDENT: usize = 0;
18260 pub const INDEX_COLON_COLON: usize = 1;
18261 pub const INDEX_USE_PATH: usize = 2;
18262 pub fn new_green(
18263 db: &dyn SyntaxGroup,
18264 ident: PathSegmentGreen,
18265 colon_colon: TerminalColonColonGreen,
18266 use_path: UsePathGreen,
18267 ) -> UsePathSingleGreen {
18268 let children: Vec<GreenId> = vec![ident.0, colon_colon.0, use_path.0];
18269 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18270 UsePathSingleGreen(
18271 Arc::new(GreenNode {
18272 kind: SyntaxKind::UsePathSingle,
18273 details: GreenNodeDetails::Node { children, width },
18274 })
18275 .intern(db),
18276 )
18277 }
18278}
18279impl UsePathSingle {
18280 pub fn ident(&self, db: &dyn SyntaxGroup) -> PathSegment {
18281 PathSegment::from_syntax_node(db, self.children[0].clone())
18282 }
18283 pub fn colon_colon(&self, db: &dyn SyntaxGroup) -> TerminalColonColon {
18284 TerminalColonColon::from_syntax_node(db, self.children[1].clone())
18285 }
18286 pub fn use_path(&self, db: &dyn SyntaxGroup) -> UsePath {
18287 UsePath::from_syntax_node(db, self.children[2].clone())
18288 }
18289}
18290#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18291pub struct UsePathSinglePtr(pub SyntaxStablePtrId);
18292impl UsePathSinglePtr {}
18293impl TypedStablePtr for UsePathSinglePtr {
18294 type SyntaxNode = UsePathSingle;
18295 fn untyped(&self) -> SyntaxStablePtrId {
18296 self.0
18297 }
18298 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathSingle {
18299 UsePathSingle::from_syntax_node(db, self.0.lookup(db))
18300 }
18301}
18302impl From<UsePathSinglePtr> for SyntaxStablePtrId {
18303 fn from(ptr: UsePathSinglePtr) -> Self {
18304 ptr.untyped()
18305 }
18306}
18307#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18308pub struct UsePathSingleGreen(pub GreenId);
18309impl TypedSyntaxNode for UsePathSingle {
18310 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathSingle);
18311 type StablePtr = UsePathSinglePtr;
18312 type Green = UsePathSingleGreen;
18313 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18314 UsePathSingleGreen(
18315 Arc::new(GreenNode {
18316 kind: SyntaxKind::UsePathSingle,
18317 details: GreenNodeDetails::Node {
18318 children: vec![
18319 PathSegment::missing(db).0,
18320 TerminalColonColon::missing(db).0,
18321 UsePath::missing(db).0,
18322 ],
18323 width: TextWidth::default(),
18324 },
18325 })
18326 .intern(db),
18327 )
18328 }
18329 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18330 let kind = node.kind(db);
18331 assert_eq!(
18332 kind,
18333 SyntaxKind::UsePathSingle,
18334 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18335 kind,
18336 SyntaxKind::UsePathSingle
18337 );
18338 let children = db.get_children(node.clone());
18339 Self { node, children }
18340 }
18341 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18342 let kind = node.kind(db);
18343 if kind == SyntaxKind::UsePathSingle {
18344 Some(Self::from_syntax_node(db, node))
18345 } else {
18346 None
18347 }
18348 }
18349 fn as_syntax_node(&self) -> SyntaxNode {
18350 self.node.clone()
18351 }
18352 fn stable_ptr(&self) -> Self::StablePtr {
18353 UsePathSinglePtr(self.node.0.stable_ptr)
18354 }
18355}
18356impl From<&UsePathSingle> for SyntaxStablePtrId {
18357 fn from(node: &UsePathSingle) -> Self {
18358 node.stable_ptr().untyped()
18359 }
18360}
18361#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18362pub struct UsePathMulti {
18363 node: SyntaxNode,
18364 children: Arc<[SyntaxNode]>,
18365}
18366impl UsePathMulti {
18367 pub const INDEX_LBRACE: usize = 0;
18368 pub const INDEX_USE_PATHS: usize = 1;
18369 pub const INDEX_RBRACE: usize = 2;
18370 pub fn new_green(
18371 db: &dyn SyntaxGroup,
18372 lbrace: TerminalLBraceGreen,
18373 use_paths: UsePathListGreen,
18374 rbrace: TerminalRBraceGreen,
18375 ) -> UsePathMultiGreen {
18376 let children: Vec<GreenId> = vec![lbrace.0, use_paths.0, rbrace.0];
18377 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18378 UsePathMultiGreen(
18379 Arc::new(GreenNode {
18380 kind: SyntaxKind::UsePathMulti,
18381 details: GreenNodeDetails::Node { children, width },
18382 })
18383 .intern(db),
18384 )
18385 }
18386}
18387impl UsePathMulti {
18388 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
18389 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
18390 }
18391 pub fn use_paths(&self, db: &dyn SyntaxGroup) -> UsePathList {
18392 UsePathList::from_syntax_node(db, self.children[1].clone())
18393 }
18394 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
18395 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
18396 }
18397}
18398#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18399pub struct UsePathMultiPtr(pub SyntaxStablePtrId);
18400impl UsePathMultiPtr {}
18401impl TypedStablePtr for UsePathMultiPtr {
18402 type SyntaxNode = UsePathMulti;
18403 fn untyped(&self) -> SyntaxStablePtrId {
18404 self.0
18405 }
18406 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathMulti {
18407 UsePathMulti::from_syntax_node(db, self.0.lookup(db))
18408 }
18409}
18410impl From<UsePathMultiPtr> for SyntaxStablePtrId {
18411 fn from(ptr: UsePathMultiPtr) -> Self {
18412 ptr.untyped()
18413 }
18414}
18415#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18416pub struct UsePathMultiGreen(pub GreenId);
18417impl TypedSyntaxNode for UsePathMulti {
18418 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathMulti);
18419 type StablePtr = UsePathMultiPtr;
18420 type Green = UsePathMultiGreen;
18421 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18422 UsePathMultiGreen(
18423 Arc::new(GreenNode {
18424 kind: SyntaxKind::UsePathMulti,
18425 details: GreenNodeDetails::Node {
18426 children: vec![
18427 TerminalLBrace::missing(db).0,
18428 UsePathList::missing(db).0,
18429 TerminalRBrace::missing(db).0,
18430 ],
18431 width: TextWidth::default(),
18432 },
18433 })
18434 .intern(db),
18435 )
18436 }
18437 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18438 let kind = node.kind(db);
18439 assert_eq!(
18440 kind,
18441 SyntaxKind::UsePathMulti,
18442 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18443 kind,
18444 SyntaxKind::UsePathMulti
18445 );
18446 let children = db.get_children(node.clone());
18447 Self { node, children }
18448 }
18449 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18450 let kind = node.kind(db);
18451 if kind == SyntaxKind::UsePathMulti { Some(Self::from_syntax_node(db, node)) } else { None }
18452 }
18453 fn as_syntax_node(&self) -> SyntaxNode {
18454 self.node.clone()
18455 }
18456 fn stable_ptr(&self) -> Self::StablePtr {
18457 UsePathMultiPtr(self.node.0.stable_ptr)
18458 }
18459}
18460impl From<&UsePathMulti> for SyntaxStablePtrId {
18461 fn from(node: &UsePathMulti) -> Self {
18462 node.stable_ptr().untyped()
18463 }
18464}
18465#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18466pub struct UsePathStar {
18467 node: SyntaxNode,
18468 children: Arc<[SyntaxNode]>,
18469}
18470impl UsePathStar {
18471 pub const INDEX_STAR: usize = 0;
18472 pub fn new_green(db: &dyn SyntaxGroup, star: TerminalMulGreen) -> UsePathStarGreen {
18473 let children: Vec<GreenId> = vec![star.0];
18474 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18475 UsePathStarGreen(
18476 Arc::new(GreenNode {
18477 kind: SyntaxKind::UsePathStar,
18478 details: GreenNodeDetails::Node { children, width },
18479 })
18480 .intern(db),
18481 )
18482 }
18483}
18484impl UsePathStar {
18485 pub fn star(&self, db: &dyn SyntaxGroup) -> TerminalMul {
18486 TerminalMul::from_syntax_node(db, self.children[0].clone())
18487 }
18488}
18489#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18490pub struct UsePathStarPtr(pub SyntaxStablePtrId);
18491impl UsePathStarPtr {}
18492impl TypedStablePtr for UsePathStarPtr {
18493 type SyntaxNode = UsePathStar;
18494 fn untyped(&self) -> SyntaxStablePtrId {
18495 self.0
18496 }
18497 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathStar {
18498 UsePathStar::from_syntax_node(db, self.0.lookup(db))
18499 }
18500}
18501impl From<UsePathStarPtr> for SyntaxStablePtrId {
18502 fn from(ptr: UsePathStarPtr) -> Self {
18503 ptr.untyped()
18504 }
18505}
18506#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18507pub struct UsePathStarGreen(pub GreenId);
18508impl TypedSyntaxNode for UsePathStar {
18509 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathStar);
18510 type StablePtr = UsePathStarPtr;
18511 type Green = UsePathStarGreen;
18512 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18513 UsePathStarGreen(
18514 Arc::new(GreenNode {
18515 kind: SyntaxKind::UsePathStar,
18516 details: GreenNodeDetails::Node {
18517 children: vec![TerminalMul::missing(db).0],
18518 width: TextWidth::default(),
18519 },
18520 })
18521 .intern(db),
18522 )
18523 }
18524 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18525 let kind = node.kind(db);
18526 assert_eq!(
18527 kind,
18528 SyntaxKind::UsePathStar,
18529 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18530 kind,
18531 SyntaxKind::UsePathStar
18532 );
18533 let children = db.get_children(node.clone());
18534 Self { node, children }
18535 }
18536 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18537 let kind = node.kind(db);
18538 if kind == SyntaxKind::UsePathStar { Some(Self::from_syntax_node(db, node)) } else { None }
18539 }
18540 fn as_syntax_node(&self) -> SyntaxNode {
18541 self.node.clone()
18542 }
18543 fn stable_ptr(&self) -> Self::StablePtr {
18544 UsePathStarPtr(self.node.0.stable_ptr)
18545 }
18546}
18547impl From<&UsePathStar> for SyntaxStablePtrId {
18548 fn from(node: &UsePathStar) -> Self {
18549 node.stable_ptr().untyped()
18550 }
18551}
18552#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18553pub struct UsePathList(ElementList<UsePath, 2>);
18554impl Deref for UsePathList {
18555 type Target = ElementList<UsePath, 2>;
18556 fn deref(&self) -> &Self::Target {
18557 &self.0
18558 }
18559}
18560impl UsePathList {
18561 pub fn new_green(
18562 db: &dyn SyntaxGroup,
18563 children: Vec<UsePathListElementOrSeparatorGreen>,
18564 ) -> UsePathListGreen {
18565 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
18566 UsePathListGreen(
18567 Arc::new(GreenNode {
18568 kind: SyntaxKind::UsePathList,
18569 details: GreenNodeDetails::Node {
18570 children: children.iter().map(|x| x.id()).collect(),
18571 width,
18572 },
18573 })
18574 .intern(db),
18575 )
18576 }
18577}
18578#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18579pub struct UsePathListPtr(pub SyntaxStablePtrId);
18580impl TypedStablePtr for UsePathListPtr {
18581 type SyntaxNode = UsePathList;
18582 fn untyped(&self) -> SyntaxStablePtrId {
18583 self.0
18584 }
18585 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathList {
18586 UsePathList::from_syntax_node(db, self.0.lookup(db))
18587 }
18588}
18589impl From<UsePathListPtr> for SyntaxStablePtrId {
18590 fn from(ptr: UsePathListPtr) -> Self {
18591 ptr.untyped()
18592 }
18593}
18594#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18595pub enum UsePathListElementOrSeparatorGreen {
18596 Separator(TerminalCommaGreen),
18597 Element(UsePathGreen),
18598}
18599impl From<TerminalCommaGreen> for UsePathListElementOrSeparatorGreen {
18600 fn from(value: TerminalCommaGreen) -> Self {
18601 UsePathListElementOrSeparatorGreen::Separator(value)
18602 }
18603}
18604impl From<UsePathGreen> for UsePathListElementOrSeparatorGreen {
18605 fn from(value: UsePathGreen) -> Self {
18606 UsePathListElementOrSeparatorGreen::Element(value)
18607 }
18608}
18609impl UsePathListElementOrSeparatorGreen {
18610 fn id(&self) -> GreenId {
18611 match self {
18612 UsePathListElementOrSeparatorGreen::Separator(green) => green.0,
18613 UsePathListElementOrSeparatorGreen::Element(green) => green.0,
18614 }
18615 }
18616}
18617#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18618pub struct UsePathListGreen(pub GreenId);
18619impl TypedSyntaxNode for UsePathList {
18620 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathList);
18621 type StablePtr = UsePathListPtr;
18622 type Green = UsePathListGreen;
18623 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18624 UsePathListGreen(
18625 Arc::new(GreenNode {
18626 kind: SyntaxKind::UsePathList,
18627 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18628 })
18629 .intern(db),
18630 )
18631 }
18632 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18633 Self(ElementList::new(node))
18634 }
18635 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18636 if node.kind(db) == SyntaxKind::UsePathList {
18637 Some(Self(ElementList::new(node)))
18638 } else {
18639 None
18640 }
18641 }
18642 fn as_syntax_node(&self) -> SyntaxNode {
18643 self.node.clone()
18644 }
18645 fn stable_ptr(&self) -> Self::StablePtr {
18646 UsePathListPtr(self.node.0.stable_ptr)
18647 }
18648}
18649impl From<&UsePathList> for SyntaxStablePtrId {
18650 fn from(node: &UsePathList) -> Self {
18651 node.stable_ptr().untyped()
18652 }
18653}
18654#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18655pub struct AliasClause {
18656 node: SyntaxNode,
18657 children: Arc<[SyntaxNode]>,
18658}
18659impl AliasClause {
18660 pub const INDEX_AS_KW: usize = 0;
18661 pub const INDEX_ALIAS: usize = 1;
18662 pub fn new_green(
18663 db: &dyn SyntaxGroup,
18664 as_kw: TerminalAsGreen,
18665 alias: TerminalIdentifierGreen,
18666 ) -> AliasClauseGreen {
18667 let children: Vec<GreenId> = vec![as_kw.0, alias.0];
18668 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18669 AliasClauseGreen(
18670 Arc::new(GreenNode {
18671 kind: SyntaxKind::AliasClause,
18672 details: GreenNodeDetails::Node { children, width },
18673 })
18674 .intern(db),
18675 )
18676 }
18677}
18678impl AliasClause {
18679 pub fn as_kw(&self, db: &dyn SyntaxGroup) -> TerminalAs {
18680 TerminalAs::from_syntax_node(db, self.children[0].clone())
18681 }
18682 pub fn alias(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
18683 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
18684 }
18685}
18686#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18687pub struct AliasClausePtr(pub SyntaxStablePtrId);
18688impl AliasClausePtr {
18689 pub fn alias_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
18690 let ptr = self.0.lookup_intern(db);
18691 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
18692 TerminalIdentifierGreen(key_fields[0])
18693 } else {
18694 panic!("Unexpected key field query on root.");
18695 }
18696 }
18697}
18698impl TypedStablePtr for AliasClausePtr {
18699 type SyntaxNode = AliasClause;
18700 fn untyped(&self) -> SyntaxStablePtrId {
18701 self.0
18702 }
18703 fn lookup(&self, db: &dyn SyntaxGroup) -> AliasClause {
18704 AliasClause::from_syntax_node(db, self.0.lookup(db))
18705 }
18706}
18707impl From<AliasClausePtr> for SyntaxStablePtrId {
18708 fn from(ptr: AliasClausePtr) -> Self {
18709 ptr.untyped()
18710 }
18711}
18712#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18713pub struct AliasClauseGreen(pub GreenId);
18714impl TypedSyntaxNode for AliasClause {
18715 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AliasClause);
18716 type StablePtr = AliasClausePtr;
18717 type Green = AliasClauseGreen;
18718 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18719 AliasClauseGreen(
18720 Arc::new(GreenNode {
18721 kind: SyntaxKind::AliasClause,
18722 details: GreenNodeDetails::Node {
18723 children: vec![TerminalAs::missing(db).0, TerminalIdentifier::missing(db).0],
18724 width: TextWidth::default(),
18725 },
18726 })
18727 .intern(db),
18728 )
18729 }
18730 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18731 let kind = node.kind(db);
18732 assert_eq!(
18733 kind,
18734 SyntaxKind::AliasClause,
18735 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18736 kind,
18737 SyntaxKind::AliasClause
18738 );
18739 let children = db.get_children(node.clone());
18740 Self { node, children }
18741 }
18742 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18743 let kind = node.kind(db);
18744 if kind == SyntaxKind::AliasClause { Some(Self::from_syntax_node(db, node)) } else { None }
18745 }
18746 fn as_syntax_node(&self) -> SyntaxNode {
18747 self.node.clone()
18748 }
18749 fn stable_ptr(&self) -> Self::StablePtr {
18750 AliasClausePtr(self.node.0.stable_ptr)
18751 }
18752}
18753impl From<&AliasClause> for SyntaxStablePtrId {
18754 fn from(node: &AliasClause) -> Self {
18755 node.stable_ptr().untyped()
18756 }
18757}
18758#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18759pub enum OptionAliasClause {
18760 Empty(OptionAliasClauseEmpty),
18761 AliasClause(AliasClause),
18762}
18763#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18764pub struct OptionAliasClausePtr(pub SyntaxStablePtrId);
18765impl TypedStablePtr for OptionAliasClausePtr {
18766 type SyntaxNode = OptionAliasClause;
18767 fn untyped(&self) -> SyntaxStablePtrId {
18768 self.0
18769 }
18770 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAliasClause {
18771 OptionAliasClause::from_syntax_node(db, self.0.lookup(db))
18772 }
18773}
18774impl From<OptionAliasClausePtr> for SyntaxStablePtrId {
18775 fn from(ptr: OptionAliasClausePtr) -> Self {
18776 ptr.untyped()
18777 }
18778}
18779impl From<OptionAliasClauseEmptyPtr> for OptionAliasClausePtr {
18780 fn from(value: OptionAliasClauseEmptyPtr) -> Self {
18781 Self(value.0)
18782 }
18783}
18784impl From<AliasClausePtr> for OptionAliasClausePtr {
18785 fn from(value: AliasClausePtr) -> Self {
18786 Self(value.0)
18787 }
18788}
18789impl From<OptionAliasClauseEmptyGreen> for OptionAliasClauseGreen {
18790 fn from(value: OptionAliasClauseEmptyGreen) -> Self {
18791 Self(value.0)
18792 }
18793}
18794impl From<AliasClauseGreen> for OptionAliasClauseGreen {
18795 fn from(value: AliasClauseGreen) -> Self {
18796 Self(value.0)
18797 }
18798}
18799#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18800pub struct OptionAliasClauseGreen(pub GreenId);
18801impl TypedSyntaxNode for OptionAliasClause {
18802 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18803 type StablePtr = OptionAliasClausePtr;
18804 type Green = OptionAliasClauseGreen;
18805 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18806 panic!("No missing variant.");
18807 }
18808 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18809 let kind = node.kind(db);
18810 match kind {
18811 SyntaxKind::OptionAliasClauseEmpty => {
18812 OptionAliasClause::Empty(OptionAliasClauseEmpty::from_syntax_node(db, node))
18813 }
18814 SyntaxKind::AliasClause => {
18815 OptionAliasClause::AliasClause(AliasClause::from_syntax_node(db, node))
18816 }
18817 _ => panic!(
18818 "Unexpected syntax kind {:?} when constructing {}.",
18819 kind, "OptionAliasClause"
18820 ),
18821 }
18822 }
18823 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18824 let kind = node.kind(db);
18825 match kind {
18826 SyntaxKind::OptionAliasClauseEmpty => {
18827 Some(OptionAliasClause::Empty(OptionAliasClauseEmpty::from_syntax_node(db, node)))
18828 }
18829 SyntaxKind::AliasClause => {
18830 Some(OptionAliasClause::AliasClause(AliasClause::from_syntax_node(db, node)))
18831 }
18832 _ => None,
18833 }
18834 }
18835 fn as_syntax_node(&self) -> SyntaxNode {
18836 match self {
18837 OptionAliasClause::Empty(x) => x.as_syntax_node(),
18838 OptionAliasClause::AliasClause(x) => x.as_syntax_node(),
18839 }
18840 }
18841 fn stable_ptr(&self) -> Self::StablePtr {
18842 OptionAliasClausePtr(self.as_syntax_node().0.stable_ptr)
18843 }
18844}
18845impl From<&OptionAliasClause> for SyntaxStablePtrId {
18846 fn from(node: &OptionAliasClause) -> Self {
18847 node.stable_ptr().untyped()
18848 }
18849}
18850impl OptionAliasClause {
18851 pub fn is_variant(kind: SyntaxKind) -> bool {
18853 matches!(kind, SyntaxKind::OptionAliasClauseEmpty | SyntaxKind::AliasClause)
18854 }
18855}
18856#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18857pub struct OptionAliasClauseEmpty {
18858 node: SyntaxNode,
18859 children: Arc<[SyntaxNode]>,
18860}
18861impl OptionAliasClauseEmpty {
18862 pub fn new_green(db: &dyn SyntaxGroup) -> OptionAliasClauseEmptyGreen {
18863 let children: Vec<GreenId> = vec![];
18864 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18865 OptionAliasClauseEmptyGreen(
18866 Arc::new(GreenNode {
18867 kind: SyntaxKind::OptionAliasClauseEmpty,
18868 details: GreenNodeDetails::Node { children, width },
18869 })
18870 .intern(db),
18871 )
18872 }
18873}
18874impl OptionAliasClauseEmpty {}
18875#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18876pub struct OptionAliasClauseEmptyPtr(pub SyntaxStablePtrId);
18877impl OptionAliasClauseEmptyPtr {}
18878impl TypedStablePtr for OptionAliasClauseEmptyPtr {
18879 type SyntaxNode = OptionAliasClauseEmpty;
18880 fn untyped(&self) -> SyntaxStablePtrId {
18881 self.0
18882 }
18883 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAliasClauseEmpty {
18884 OptionAliasClauseEmpty::from_syntax_node(db, self.0.lookup(db))
18885 }
18886}
18887impl From<OptionAliasClauseEmptyPtr> for SyntaxStablePtrId {
18888 fn from(ptr: OptionAliasClauseEmptyPtr) -> Self {
18889 ptr.untyped()
18890 }
18891}
18892#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18893pub struct OptionAliasClauseEmptyGreen(pub GreenId);
18894impl TypedSyntaxNode for OptionAliasClauseEmpty {
18895 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionAliasClauseEmpty);
18896 type StablePtr = OptionAliasClauseEmptyPtr;
18897 type Green = OptionAliasClauseEmptyGreen;
18898 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18899 OptionAliasClauseEmptyGreen(
18900 Arc::new(GreenNode {
18901 kind: SyntaxKind::OptionAliasClauseEmpty,
18902 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18903 })
18904 .intern(db),
18905 )
18906 }
18907 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18908 let kind = node.kind(db);
18909 assert_eq!(
18910 kind,
18911 SyntaxKind::OptionAliasClauseEmpty,
18912 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18913 kind,
18914 SyntaxKind::OptionAliasClauseEmpty
18915 );
18916 let children = db.get_children(node.clone());
18917 Self { node, children }
18918 }
18919 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
18920 let kind = node.kind(db);
18921 if kind == SyntaxKind::OptionAliasClauseEmpty {
18922 Some(Self::from_syntax_node(db, node))
18923 } else {
18924 None
18925 }
18926 }
18927 fn as_syntax_node(&self) -> SyntaxNode {
18928 self.node.clone()
18929 }
18930 fn stable_ptr(&self) -> Self::StablePtr {
18931 OptionAliasClauseEmptyPtr(self.node.0.stable_ptr)
18932 }
18933}
18934impl From<&OptionAliasClauseEmpty> for SyntaxStablePtrId {
18935 fn from(node: &OptionAliasClauseEmpty) -> Self {
18936 node.stable_ptr().untyped()
18937 }
18938}
18939#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18940pub enum GenericArg {
18941 Unnamed(GenericArgUnnamed),
18942 Named(GenericArgNamed),
18943}
18944#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18945pub struct GenericArgPtr(pub SyntaxStablePtrId);
18946impl TypedStablePtr for GenericArgPtr {
18947 type SyntaxNode = GenericArg;
18948 fn untyped(&self) -> SyntaxStablePtrId {
18949 self.0
18950 }
18951 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArg {
18952 GenericArg::from_syntax_node(db, self.0.lookup(db))
18953 }
18954}
18955impl From<GenericArgPtr> for SyntaxStablePtrId {
18956 fn from(ptr: GenericArgPtr) -> Self {
18957 ptr.untyped()
18958 }
18959}
18960impl From<GenericArgUnnamedPtr> for GenericArgPtr {
18961 fn from(value: GenericArgUnnamedPtr) -> Self {
18962 Self(value.0)
18963 }
18964}
18965impl From<GenericArgNamedPtr> for GenericArgPtr {
18966 fn from(value: GenericArgNamedPtr) -> Self {
18967 Self(value.0)
18968 }
18969}
18970impl From<GenericArgUnnamedGreen> for GenericArgGreen {
18971 fn from(value: GenericArgUnnamedGreen) -> Self {
18972 Self(value.0)
18973 }
18974}
18975impl From<GenericArgNamedGreen> for GenericArgGreen {
18976 fn from(value: GenericArgNamedGreen) -> Self {
18977 Self(value.0)
18978 }
18979}
18980#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18981pub struct GenericArgGreen(pub GreenId);
18982impl TypedSyntaxNode for GenericArg {
18983 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18984 type StablePtr = GenericArgPtr;
18985 type Green = GenericArgGreen;
18986 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18987 panic!("No missing variant.");
18988 }
18989 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18990 let kind = node.kind(db);
18991 match kind {
18992 SyntaxKind::GenericArgUnnamed => {
18993 GenericArg::Unnamed(GenericArgUnnamed::from_syntax_node(db, node))
18994 }
18995 SyntaxKind::GenericArgNamed => {
18996 GenericArg::Named(GenericArgNamed::from_syntax_node(db, node))
18997 }
18998 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericArg"),
18999 }
19000 }
19001 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19002 let kind = node.kind(db);
19003 match kind {
19004 SyntaxKind::GenericArgUnnamed => {
19005 Some(GenericArg::Unnamed(GenericArgUnnamed::from_syntax_node(db, node)))
19006 }
19007 SyntaxKind::GenericArgNamed => {
19008 Some(GenericArg::Named(GenericArgNamed::from_syntax_node(db, node)))
19009 }
19010 _ => None,
19011 }
19012 }
19013 fn as_syntax_node(&self) -> SyntaxNode {
19014 match self {
19015 GenericArg::Unnamed(x) => x.as_syntax_node(),
19016 GenericArg::Named(x) => x.as_syntax_node(),
19017 }
19018 }
19019 fn stable_ptr(&self) -> Self::StablePtr {
19020 GenericArgPtr(self.as_syntax_node().0.stable_ptr)
19021 }
19022}
19023impl From<&GenericArg> for SyntaxStablePtrId {
19024 fn from(node: &GenericArg) -> Self {
19025 node.stable_ptr().untyped()
19026 }
19027}
19028impl GenericArg {
19029 pub fn is_variant(kind: SyntaxKind) -> bool {
19031 matches!(kind, SyntaxKind::GenericArgUnnamed | SyntaxKind::GenericArgNamed)
19032 }
19033}
19034#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19035pub struct GenericArgNamed {
19036 node: SyntaxNode,
19037 children: Arc<[SyntaxNode]>,
19038}
19039impl GenericArgNamed {
19040 pub const INDEX_NAME: usize = 0;
19041 pub const INDEX_COLON: usize = 1;
19042 pub const INDEX_VALUE: usize = 2;
19043 pub fn new_green(
19044 db: &dyn SyntaxGroup,
19045 name: TerminalIdentifierGreen,
19046 colon: TerminalColonGreen,
19047 value: GenericArgValueGreen,
19048 ) -> GenericArgNamedGreen {
19049 let children: Vec<GreenId> = vec![name.0, colon.0, value.0];
19050 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19051 GenericArgNamedGreen(
19052 Arc::new(GreenNode {
19053 kind: SyntaxKind::GenericArgNamed,
19054 details: GreenNodeDetails::Node { children, width },
19055 })
19056 .intern(db),
19057 )
19058 }
19059}
19060impl GenericArgNamed {
19061 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
19062 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
19063 }
19064 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
19065 TerminalColon::from_syntax_node(db, self.children[1].clone())
19066 }
19067 pub fn value(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
19068 GenericArgValue::from_syntax_node(db, self.children[2].clone())
19069 }
19070}
19071#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19072pub struct GenericArgNamedPtr(pub SyntaxStablePtrId);
19073impl GenericArgNamedPtr {}
19074impl TypedStablePtr for GenericArgNamedPtr {
19075 type SyntaxNode = GenericArgNamed;
19076 fn untyped(&self) -> SyntaxStablePtrId {
19077 self.0
19078 }
19079 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgNamed {
19080 GenericArgNamed::from_syntax_node(db, self.0.lookup(db))
19081 }
19082}
19083impl From<GenericArgNamedPtr> for SyntaxStablePtrId {
19084 fn from(ptr: GenericArgNamedPtr) -> Self {
19085 ptr.untyped()
19086 }
19087}
19088#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19089pub struct GenericArgNamedGreen(pub GreenId);
19090impl TypedSyntaxNode for GenericArgNamed {
19091 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgNamed);
19092 type StablePtr = GenericArgNamedPtr;
19093 type Green = GenericArgNamedGreen;
19094 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19095 GenericArgNamedGreen(
19096 Arc::new(GreenNode {
19097 kind: SyntaxKind::GenericArgNamed,
19098 details: GreenNodeDetails::Node {
19099 children: vec![
19100 TerminalIdentifier::missing(db).0,
19101 TerminalColon::missing(db).0,
19102 GenericArgValue::missing(db).0,
19103 ],
19104 width: TextWidth::default(),
19105 },
19106 })
19107 .intern(db),
19108 )
19109 }
19110 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19111 let kind = node.kind(db);
19112 assert_eq!(
19113 kind,
19114 SyntaxKind::GenericArgNamed,
19115 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19116 kind,
19117 SyntaxKind::GenericArgNamed
19118 );
19119 let children = db.get_children(node.clone());
19120 Self { node, children }
19121 }
19122 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19123 let kind = node.kind(db);
19124 if kind == SyntaxKind::GenericArgNamed {
19125 Some(Self::from_syntax_node(db, node))
19126 } else {
19127 None
19128 }
19129 }
19130 fn as_syntax_node(&self) -> SyntaxNode {
19131 self.node.clone()
19132 }
19133 fn stable_ptr(&self) -> Self::StablePtr {
19134 GenericArgNamedPtr(self.node.0.stable_ptr)
19135 }
19136}
19137impl From<&GenericArgNamed> for SyntaxStablePtrId {
19138 fn from(node: &GenericArgNamed) -> Self {
19139 node.stable_ptr().untyped()
19140 }
19141}
19142#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19143pub struct GenericArgUnnamed {
19144 node: SyntaxNode,
19145 children: Arc<[SyntaxNode]>,
19146}
19147impl GenericArgUnnamed {
19148 pub const INDEX_VALUE: usize = 0;
19149 pub fn new_green(db: &dyn SyntaxGroup, value: GenericArgValueGreen) -> GenericArgUnnamedGreen {
19150 let children: Vec<GreenId> = vec![value.0];
19151 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19152 GenericArgUnnamedGreen(
19153 Arc::new(GreenNode {
19154 kind: SyntaxKind::GenericArgUnnamed,
19155 details: GreenNodeDetails::Node { children, width },
19156 })
19157 .intern(db),
19158 )
19159 }
19160}
19161impl GenericArgUnnamed {
19162 pub fn value(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
19163 GenericArgValue::from_syntax_node(db, self.children[0].clone())
19164 }
19165}
19166#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19167pub struct GenericArgUnnamedPtr(pub SyntaxStablePtrId);
19168impl GenericArgUnnamedPtr {}
19169impl TypedStablePtr for GenericArgUnnamedPtr {
19170 type SyntaxNode = GenericArgUnnamed;
19171 fn untyped(&self) -> SyntaxStablePtrId {
19172 self.0
19173 }
19174 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgUnnamed {
19175 GenericArgUnnamed::from_syntax_node(db, self.0.lookup(db))
19176 }
19177}
19178impl From<GenericArgUnnamedPtr> for SyntaxStablePtrId {
19179 fn from(ptr: GenericArgUnnamedPtr) -> Self {
19180 ptr.untyped()
19181 }
19182}
19183#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19184pub struct GenericArgUnnamedGreen(pub GreenId);
19185impl TypedSyntaxNode for GenericArgUnnamed {
19186 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgUnnamed);
19187 type StablePtr = GenericArgUnnamedPtr;
19188 type Green = GenericArgUnnamedGreen;
19189 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19190 GenericArgUnnamedGreen(
19191 Arc::new(GreenNode {
19192 kind: SyntaxKind::GenericArgUnnamed,
19193 details: GreenNodeDetails::Node {
19194 children: vec![GenericArgValue::missing(db).0],
19195 width: TextWidth::default(),
19196 },
19197 })
19198 .intern(db),
19199 )
19200 }
19201 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19202 let kind = node.kind(db);
19203 assert_eq!(
19204 kind,
19205 SyntaxKind::GenericArgUnnamed,
19206 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19207 kind,
19208 SyntaxKind::GenericArgUnnamed
19209 );
19210 let children = db.get_children(node.clone());
19211 Self { node, children }
19212 }
19213 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19214 let kind = node.kind(db);
19215 if kind == SyntaxKind::GenericArgUnnamed {
19216 Some(Self::from_syntax_node(db, node))
19217 } else {
19218 None
19219 }
19220 }
19221 fn as_syntax_node(&self) -> SyntaxNode {
19222 self.node.clone()
19223 }
19224 fn stable_ptr(&self) -> Self::StablePtr {
19225 GenericArgUnnamedPtr(self.node.0.stable_ptr)
19226 }
19227}
19228impl From<&GenericArgUnnamed> for SyntaxStablePtrId {
19229 fn from(node: &GenericArgUnnamed) -> Self {
19230 node.stable_ptr().untyped()
19231 }
19232}
19233#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19234pub enum GenericArgValue {
19235 Expr(GenericArgValueExpr),
19236 Underscore(TerminalUnderscore),
19237}
19238#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19239pub struct GenericArgValuePtr(pub SyntaxStablePtrId);
19240impl TypedStablePtr for GenericArgValuePtr {
19241 type SyntaxNode = GenericArgValue;
19242 fn untyped(&self) -> SyntaxStablePtrId {
19243 self.0
19244 }
19245 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
19246 GenericArgValue::from_syntax_node(db, self.0.lookup(db))
19247 }
19248}
19249impl From<GenericArgValuePtr> for SyntaxStablePtrId {
19250 fn from(ptr: GenericArgValuePtr) -> Self {
19251 ptr.untyped()
19252 }
19253}
19254impl From<GenericArgValueExprPtr> for GenericArgValuePtr {
19255 fn from(value: GenericArgValueExprPtr) -> Self {
19256 Self(value.0)
19257 }
19258}
19259impl From<TerminalUnderscorePtr> for GenericArgValuePtr {
19260 fn from(value: TerminalUnderscorePtr) -> Self {
19261 Self(value.0)
19262 }
19263}
19264impl From<GenericArgValueExprGreen> for GenericArgValueGreen {
19265 fn from(value: GenericArgValueExprGreen) -> Self {
19266 Self(value.0)
19267 }
19268}
19269impl From<TerminalUnderscoreGreen> for GenericArgValueGreen {
19270 fn from(value: TerminalUnderscoreGreen) -> Self {
19271 Self(value.0)
19272 }
19273}
19274#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19275pub struct GenericArgValueGreen(pub GreenId);
19276impl TypedSyntaxNode for GenericArgValue {
19277 const OPTIONAL_KIND: Option<SyntaxKind> = None;
19278 type StablePtr = GenericArgValuePtr;
19279 type Green = GenericArgValueGreen;
19280 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19281 panic!("No missing variant.");
19282 }
19283 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19284 let kind = node.kind(db);
19285 match kind {
19286 SyntaxKind::GenericArgValueExpr => {
19287 GenericArgValue::Expr(GenericArgValueExpr::from_syntax_node(db, node))
19288 }
19289 SyntaxKind::TerminalUnderscore => {
19290 GenericArgValue::Underscore(TerminalUnderscore::from_syntax_node(db, node))
19291 }
19292 _ => {
19293 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericArgValue")
19294 }
19295 }
19296 }
19297 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19298 let kind = node.kind(db);
19299 match kind {
19300 SyntaxKind::GenericArgValueExpr => {
19301 Some(GenericArgValue::Expr(GenericArgValueExpr::from_syntax_node(db, node)))
19302 }
19303 SyntaxKind::TerminalUnderscore => {
19304 Some(GenericArgValue::Underscore(TerminalUnderscore::from_syntax_node(db, node)))
19305 }
19306 _ => None,
19307 }
19308 }
19309 fn as_syntax_node(&self) -> SyntaxNode {
19310 match self {
19311 GenericArgValue::Expr(x) => x.as_syntax_node(),
19312 GenericArgValue::Underscore(x) => x.as_syntax_node(),
19313 }
19314 }
19315 fn stable_ptr(&self) -> Self::StablePtr {
19316 GenericArgValuePtr(self.as_syntax_node().0.stable_ptr)
19317 }
19318}
19319impl From<&GenericArgValue> for SyntaxStablePtrId {
19320 fn from(node: &GenericArgValue) -> Self {
19321 node.stable_ptr().untyped()
19322 }
19323}
19324impl GenericArgValue {
19325 pub fn is_variant(kind: SyntaxKind) -> bool {
19327 matches!(kind, SyntaxKind::GenericArgValueExpr | SyntaxKind::TerminalUnderscore)
19328 }
19329}
19330#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19331pub struct GenericArgValueExpr {
19332 node: SyntaxNode,
19333 children: Arc<[SyntaxNode]>,
19334}
19335impl GenericArgValueExpr {
19336 pub const INDEX_EXPR: usize = 0;
19337 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> GenericArgValueExprGreen {
19338 let children: Vec<GreenId> = vec![expr.0];
19339 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19340 GenericArgValueExprGreen(
19341 Arc::new(GreenNode {
19342 kind: SyntaxKind::GenericArgValueExpr,
19343 details: GreenNodeDetails::Node { children, width },
19344 })
19345 .intern(db),
19346 )
19347 }
19348}
19349impl GenericArgValueExpr {
19350 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
19351 Expr::from_syntax_node(db, self.children[0].clone())
19352 }
19353}
19354#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19355pub struct GenericArgValueExprPtr(pub SyntaxStablePtrId);
19356impl GenericArgValueExprPtr {}
19357impl TypedStablePtr for GenericArgValueExprPtr {
19358 type SyntaxNode = GenericArgValueExpr;
19359 fn untyped(&self) -> SyntaxStablePtrId {
19360 self.0
19361 }
19362 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgValueExpr {
19363 GenericArgValueExpr::from_syntax_node(db, self.0.lookup(db))
19364 }
19365}
19366impl From<GenericArgValueExprPtr> for SyntaxStablePtrId {
19367 fn from(ptr: GenericArgValueExprPtr) -> Self {
19368 ptr.untyped()
19369 }
19370}
19371#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19372pub struct GenericArgValueExprGreen(pub GreenId);
19373impl TypedSyntaxNode for GenericArgValueExpr {
19374 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgValueExpr);
19375 type StablePtr = GenericArgValueExprPtr;
19376 type Green = GenericArgValueExprGreen;
19377 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19378 GenericArgValueExprGreen(
19379 Arc::new(GreenNode {
19380 kind: SyntaxKind::GenericArgValueExpr,
19381 details: GreenNodeDetails::Node {
19382 children: vec![Expr::missing(db).0],
19383 width: TextWidth::default(),
19384 },
19385 })
19386 .intern(db),
19387 )
19388 }
19389 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19390 let kind = node.kind(db);
19391 assert_eq!(
19392 kind,
19393 SyntaxKind::GenericArgValueExpr,
19394 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19395 kind,
19396 SyntaxKind::GenericArgValueExpr
19397 );
19398 let children = db.get_children(node.clone());
19399 Self { node, children }
19400 }
19401 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19402 let kind = node.kind(db);
19403 if kind == SyntaxKind::GenericArgValueExpr {
19404 Some(Self::from_syntax_node(db, node))
19405 } else {
19406 None
19407 }
19408 }
19409 fn as_syntax_node(&self) -> SyntaxNode {
19410 self.node.clone()
19411 }
19412 fn stable_ptr(&self) -> Self::StablePtr {
19413 GenericArgValueExprPtr(self.node.0.stable_ptr)
19414 }
19415}
19416impl From<&GenericArgValueExpr> for SyntaxStablePtrId {
19417 fn from(node: &GenericArgValueExpr) -> Self {
19418 node.stable_ptr().untyped()
19419 }
19420}
19421#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19422pub struct GenericArgs {
19423 node: SyntaxNode,
19424 children: Arc<[SyntaxNode]>,
19425}
19426impl GenericArgs {
19427 pub const INDEX_LANGLE: usize = 0;
19428 pub const INDEX_GENERIC_ARGS: usize = 1;
19429 pub const INDEX_RANGLE: usize = 2;
19430 pub fn new_green(
19431 db: &dyn SyntaxGroup,
19432 langle: TerminalLTGreen,
19433 generic_args: GenericArgListGreen,
19434 rangle: TerminalGTGreen,
19435 ) -> GenericArgsGreen {
19436 let children: Vec<GreenId> = vec![langle.0, generic_args.0, rangle.0];
19437 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19438 GenericArgsGreen(
19439 Arc::new(GreenNode {
19440 kind: SyntaxKind::GenericArgs,
19441 details: GreenNodeDetails::Node { children, width },
19442 })
19443 .intern(db),
19444 )
19445 }
19446}
19447impl GenericArgs {
19448 pub fn langle(&self, db: &dyn SyntaxGroup) -> TerminalLT {
19449 TerminalLT::from_syntax_node(db, self.children[0].clone())
19450 }
19451 pub fn generic_args(&self, db: &dyn SyntaxGroup) -> GenericArgList {
19452 GenericArgList::from_syntax_node(db, self.children[1].clone())
19453 }
19454 pub fn rangle(&self, db: &dyn SyntaxGroup) -> TerminalGT {
19455 TerminalGT::from_syntax_node(db, self.children[2].clone())
19456 }
19457}
19458#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19459pub struct GenericArgsPtr(pub SyntaxStablePtrId);
19460impl GenericArgsPtr {}
19461impl TypedStablePtr for GenericArgsPtr {
19462 type SyntaxNode = GenericArgs;
19463 fn untyped(&self) -> SyntaxStablePtrId {
19464 self.0
19465 }
19466 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgs {
19467 GenericArgs::from_syntax_node(db, self.0.lookup(db))
19468 }
19469}
19470impl From<GenericArgsPtr> for SyntaxStablePtrId {
19471 fn from(ptr: GenericArgsPtr) -> Self {
19472 ptr.untyped()
19473 }
19474}
19475#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19476pub struct GenericArgsGreen(pub GreenId);
19477impl TypedSyntaxNode for GenericArgs {
19478 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgs);
19479 type StablePtr = GenericArgsPtr;
19480 type Green = GenericArgsGreen;
19481 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19482 GenericArgsGreen(
19483 Arc::new(GreenNode {
19484 kind: SyntaxKind::GenericArgs,
19485 details: GreenNodeDetails::Node {
19486 children: vec![
19487 TerminalLT::missing(db).0,
19488 GenericArgList::missing(db).0,
19489 TerminalGT::missing(db).0,
19490 ],
19491 width: TextWidth::default(),
19492 },
19493 })
19494 .intern(db),
19495 )
19496 }
19497 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19498 let kind = node.kind(db);
19499 assert_eq!(
19500 kind,
19501 SyntaxKind::GenericArgs,
19502 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19503 kind,
19504 SyntaxKind::GenericArgs
19505 );
19506 let children = db.get_children(node.clone());
19507 Self { node, children }
19508 }
19509 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19510 let kind = node.kind(db);
19511 if kind == SyntaxKind::GenericArgs { Some(Self::from_syntax_node(db, node)) } else { None }
19512 }
19513 fn as_syntax_node(&self) -> SyntaxNode {
19514 self.node.clone()
19515 }
19516 fn stable_ptr(&self) -> Self::StablePtr {
19517 GenericArgsPtr(self.node.0.stable_ptr)
19518 }
19519}
19520impl From<&GenericArgs> for SyntaxStablePtrId {
19521 fn from(node: &GenericArgs) -> Self {
19522 node.stable_ptr().untyped()
19523 }
19524}
19525#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19526pub struct GenericArgList(ElementList<GenericArg, 2>);
19527impl Deref for GenericArgList {
19528 type Target = ElementList<GenericArg, 2>;
19529 fn deref(&self) -> &Self::Target {
19530 &self.0
19531 }
19532}
19533impl GenericArgList {
19534 pub fn new_green(
19535 db: &dyn SyntaxGroup,
19536 children: Vec<GenericArgListElementOrSeparatorGreen>,
19537 ) -> GenericArgListGreen {
19538 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
19539 GenericArgListGreen(
19540 Arc::new(GreenNode {
19541 kind: SyntaxKind::GenericArgList,
19542 details: GreenNodeDetails::Node {
19543 children: children.iter().map(|x| x.id()).collect(),
19544 width,
19545 },
19546 })
19547 .intern(db),
19548 )
19549 }
19550}
19551#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19552pub struct GenericArgListPtr(pub SyntaxStablePtrId);
19553impl TypedStablePtr for GenericArgListPtr {
19554 type SyntaxNode = GenericArgList;
19555 fn untyped(&self) -> SyntaxStablePtrId {
19556 self.0
19557 }
19558 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgList {
19559 GenericArgList::from_syntax_node(db, self.0.lookup(db))
19560 }
19561}
19562impl From<GenericArgListPtr> for SyntaxStablePtrId {
19563 fn from(ptr: GenericArgListPtr) -> Self {
19564 ptr.untyped()
19565 }
19566}
19567#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19568pub enum GenericArgListElementOrSeparatorGreen {
19569 Separator(TerminalCommaGreen),
19570 Element(GenericArgGreen),
19571}
19572impl From<TerminalCommaGreen> for GenericArgListElementOrSeparatorGreen {
19573 fn from(value: TerminalCommaGreen) -> Self {
19574 GenericArgListElementOrSeparatorGreen::Separator(value)
19575 }
19576}
19577impl From<GenericArgGreen> for GenericArgListElementOrSeparatorGreen {
19578 fn from(value: GenericArgGreen) -> Self {
19579 GenericArgListElementOrSeparatorGreen::Element(value)
19580 }
19581}
19582impl GenericArgListElementOrSeparatorGreen {
19583 fn id(&self) -> GreenId {
19584 match self {
19585 GenericArgListElementOrSeparatorGreen::Separator(green) => green.0,
19586 GenericArgListElementOrSeparatorGreen::Element(green) => green.0,
19587 }
19588 }
19589}
19590#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19591pub struct GenericArgListGreen(pub GreenId);
19592impl TypedSyntaxNode for GenericArgList {
19593 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgList);
19594 type StablePtr = GenericArgListPtr;
19595 type Green = GenericArgListGreen;
19596 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19597 GenericArgListGreen(
19598 Arc::new(GreenNode {
19599 kind: SyntaxKind::GenericArgList,
19600 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
19601 })
19602 .intern(db),
19603 )
19604 }
19605 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19606 Self(ElementList::new(node))
19607 }
19608 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19609 if node.kind(db) == SyntaxKind::GenericArgList {
19610 Some(Self(ElementList::new(node)))
19611 } else {
19612 None
19613 }
19614 }
19615 fn as_syntax_node(&self) -> SyntaxNode {
19616 self.node.clone()
19617 }
19618 fn stable_ptr(&self) -> Self::StablePtr {
19619 GenericArgListPtr(self.node.0.stable_ptr)
19620 }
19621}
19622impl From<&GenericArgList> for SyntaxStablePtrId {
19623 fn from(node: &GenericArgList) -> Self {
19624 node.stable_ptr().untyped()
19625 }
19626}
19627#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19628pub struct AssociatedItemConstraint {
19629 node: SyntaxNode,
19630 children: Arc<[SyntaxNode]>,
19631}
19632impl AssociatedItemConstraint {
19633 pub const INDEX_ITEM: usize = 0;
19634 pub const INDEX_COLON: usize = 1;
19635 pub const INDEX_VALUE: usize = 2;
19636 pub fn new_green(
19637 db: &dyn SyntaxGroup,
19638 item: TerminalIdentifierGreen,
19639 colon: TerminalColonGreen,
19640 value: ExprGreen,
19641 ) -> AssociatedItemConstraintGreen {
19642 let children: Vec<GreenId> = vec![item.0, colon.0, value.0];
19643 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19644 AssociatedItemConstraintGreen(
19645 Arc::new(GreenNode {
19646 kind: SyntaxKind::AssociatedItemConstraint,
19647 details: GreenNodeDetails::Node { children, width },
19648 })
19649 .intern(db),
19650 )
19651 }
19652}
19653impl AssociatedItemConstraint {
19654 pub fn item(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
19655 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
19656 }
19657 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
19658 TerminalColon::from_syntax_node(db, self.children[1].clone())
19659 }
19660 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
19661 Expr::from_syntax_node(db, self.children[2].clone())
19662 }
19663}
19664#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19665pub struct AssociatedItemConstraintPtr(pub SyntaxStablePtrId);
19666impl AssociatedItemConstraintPtr {}
19667impl TypedStablePtr for AssociatedItemConstraintPtr {
19668 type SyntaxNode = AssociatedItemConstraint;
19669 fn untyped(&self) -> SyntaxStablePtrId {
19670 self.0
19671 }
19672 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraint {
19673 AssociatedItemConstraint::from_syntax_node(db, self.0.lookup(db))
19674 }
19675}
19676impl From<AssociatedItemConstraintPtr> for SyntaxStablePtrId {
19677 fn from(ptr: AssociatedItemConstraintPtr) -> Self {
19678 ptr.untyped()
19679 }
19680}
19681#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19682pub struct AssociatedItemConstraintGreen(pub GreenId);
19683impl TypedSyntaxNode for AssociatedItemConstraint {
19684 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraint);
19685 type StablePtr = AssociatedItemConstraintPtr;
19686 type Green = AssociatedItemConstraintGreen;
19687 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19688 AssociatedItemConstraintGreen(
19689 Arc::new(GreenNode {
19690 kind: SyntaxKind::AssociatedItemConstraint,
19691 details: GreenNodeDetails::Node {
19692 children: vec![
19693 TerminalIdentifier::missing(db).0,
19694 TerminalColon::missing(db).0,
19695 Expr::missing(db).0,
19696 ],
19697 width: TextWidth::default(),
19698 },
19699 })
19700 .intern(db),
19701 )
19702 }
19703 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19704 let kind = node.kind(db);
19705 assert_eq!(
19706 kind,
19707 SyntaxKind::AssociatedItemConstraint,
19708 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19709 kind,
19710 SyntaxKind::AssociatedItemConstraint
19711 );
19712 let children = db.get_children(node.clone());
19713 Self { node, children }
19714 }
19715 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19716 let kind = node.kind(db);
19717 if kind == SyntaxKind::AssociatedItemConstraint {
19718 Some(Self::from_syntax_node(db, node))
19719 } else {
19720 None
19721 }
19722 }
19723 fn as_syntax_node(&self) -> SyntaxNode {
19724 self.node.clone()
19725 }
19726 fn stable_ptr(&self) -> Self::StablePtr {
19727 AssociatedItemConstraintPtr(self.node.0.stable_ptr)
19728 }
19729}
19730impl From<&AssociatedItemConstraint> for SyntaxStablePtrId {
19731 fn from(node: &AssociatedItemConstraint) -> Self {
19732 node.stable_ptr().untyped()
19733 }
19734}
19735#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19736pub struct AssociatedItemConstraints {
19737 node: SyntaxNode,
19738 children: Arc<[SyntaxNode]>,
19739}
19740impl AssociatedItemConstraints {
19741 pub const INDEX_LBRACK: usize = 0;
19742 pub const INDEX_ASSOCIATED_ITEM_CONSTRAINTS: usize = 1;
19743 pub const INDEX_RBRACK: usize = 2;
19744 pub fn new_green(
19745 db: &dyn SyntaxGroup,
19746 lbrack: TerminalLBrackGreen,
19747 associated_item_constraints: AssociatedItemConstraintListGreen,
19748 rbrack: TerminalRBrackGreen,
19749 ) -> AssociatedItemConstraintsGreen {
19750 let children: Vec<GreenId> = vec![lbrack.0, associated_item_constraints.0, rbrack.0];
19751 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19752 AssociatedItemConstraintsGreen(
19753 Arc::new(GreenNode {
19754 kind: SyntaxKind::AssociatedItemConstraints,
19755 details: GreenNodeDetails::Node { children, width },
19756 })
19757 .intern(db),
19758 )
19759 }
19760}
19761impl AssociatedItemConstraints {
19762 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
19763 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
19764 }
19765 pub fn associated_item_constraints(
19766 &self,
19767 db: &dyn SyntaxGroup,
19768 ) -> AssociatedItemConstraintList {
19769 AssociatedItemConstraintList::from_syntax_node(db, self.children[1].clone())
19770 }
19771 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
19772 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
19773 }
19774}
19775#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19776pub struct AssociatedItemConstraintsPtr(pub SyntaxStablePtrId);
19777impl AssociatedItemConstraintsPtr {}
19778impl TypedStablePtr for AssociatedItemConstraintsPtr {
19779 type SyntaxNode = AssociatedItemConstraints;
19780 fn untyped(&self) -> SyntaxStablePtrId {
19781 self.0
19782 }
19783 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraints {
19784 AssociatedItemConstraints::from_syntax_node(db, self.0.lookup(db))
19785 }
19786}
19787impl From<AssociatedItemConstraintsPtr> for SyntaxStablePtrId {
19788 fn from(ptr: AssociatedItemConstraintsPtr) -> Self {
19789 ptr.untyped()
19790 }
19791}
19792#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19793pub struct AssociatedItemConstraintsGreen(pub GreenId);
19794impl TypedSyntaxNode for AssociatedItemConstraints {
19795 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraints);
19796 type StablePtr = AssociatedItemConstraintsPtr;
19797 type Green = AssociatedItemConstraintsGreen;
19798 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19799 AssociatedItemConstraintsGreen(
19800 Arc::new(GreenNode {
19801 kind: SyntaxKind::AssociatedItemConstraints,
19802 details: GreenNodeDetails::Node {
19803 children: vec![
19804 TerminalLBrack::missing(db).0,
19805 AssociatedItemConstraintList::missing(db).0,
19806 TerminalRBrack::missing(db).0,
19807 ],
19808 width: TextWidth::default(),
19809 },
19810 })
19811 .intern(db),
19812 )
19813 }
19814 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19815 let kind = node.kind(db);
19816 assert_eq!(
19817 kind,
19818 SyntaxKind::AssociatedItemConstraints,
19819 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19820 kind,
19821 SyntaxKind::AssociatedItemConstraints
19822 );
19823 let children = db.get_children(node.clone());
19824 Self { node, children }
19825 }
19826 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19827 let kind = node.kind(db);
19828 if kind == SyntaxKind::AssociatedItemConstraints {
19829 Some(Self::from_syntax_node(db, node))
19830 } else {
19831 None
19832 }
19833 }
19834 fn as_syntax_node(&self) -> SyntaxNode {
19835 self.node.clone()
19836 }
19837 fn stable_ptr(&self) -> Self::StablePtr {
19838 AssociatedItemConstraintsPtr(self.node.0.stable_ptr)
19839 }
19840}
19841impl From<&AssociatedItemConstraints> for SyntaxStablePtrId {
19842 fn from(node: &AssociatedItemConstraints) -> Self {
19843 node.stable_ptr().untyped()
19844 }
19845}
19846#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19847pub struct AssociatedItemConstraintList(ElementList<AssociatedItemConstraint, 2>);
19848impl Deref for AssociatedItemConstraintList {
19849 type Target = ElementList<AssociatedItemConstraint, 2>;
19850 fn deref(&self) -> &Self::Target {
19851 &self.0
19852 }
19853}
19854impl AssociatedItemConstraintList {
19855 pub fn new_green(
19856 db: &dyn SyntaxGroup,
19857 children: Vec<AssociatedItemConstraintListElementOrSeparatorGreen>,
19858 ) -> AssociatedItemConstraintListGreen {
19859 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
19860 AssociatedItemConstraintListGreen(
19861 Arc::new(GreenNode {
19862 kind: SyntaxKind::AssociatedItemConstraintList,
19863 details: GreenNodeDetails::Node {
19864 children: children.iter().map(|x| x.id()).collect(),
19865 width,
19866 },
19867 })
19868 .intern(db),
19869 )
19870 }
19871}
19872#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19873pub struct AssociatedItemConstraintListPtr(pub SyntaxStablePtrId);
19874impl TypedStablePtr for AssociatedItemConstraintListPtr {
19875 type SyntaxNode = AssociatedItemConstraintList;
19876 fn untyped(&self) -> SyntaxStablePtrId {
19877 self.0
19878 }
19879 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraintList {
19880 AssociatedItemConstraintList::from_syntax_node(db, self.0.lookup(db))
19881 }
19882}
19883impl From<AssociatedItemConstraintListPtr> for SyntaxStablePtrId {
19884 fn from(ptr: AssociatedItemConstraintListPtr) -> Self {
19885 ptr.untyped()
19886 }
19887}
19888#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19889pub enum AssociatedItemConstraintListElementOrSeparatorGreen {
19890 Separator(TerminalCommaGreen),
19891 Element(AssociatedItemConstraintGreen),
19892}
19893impl From<TerminalCommaGreen> for AssociatedItemConstraintListElementOrSeparatorGreen {
19894 fn from(value: TerminalCommaGreen) -> Self {
19895 AssociatedItemConstraintListElementOrSeparatorGreen::Separator(value)
19896 }
19897}
19898impl From<AssociatedItemConstraintGreen> for AssociatedItemConstraintListElementOrSeparatorGreen {
19899 fn from(value: AssociatedItemConstraintGreen) -> Self {
19900 AssociatedItemConstraintListElementOrSeparatorGreen::Element(value)
19901 }
19902}
19903impl AssociatedItemConstraintListElementOrSeparatorGreen {
19904 fn id(&self) -> GreenId {
19905 match self {
19906 AssociatedItemConstraintListElementOrSeparatorGreen::Separator(green) => green.0,
19907 AssociatedItemConstraintListElementOrSeparatorGreen::Element(green) => green.0,
19908 }
19909 }
19910}
19911#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19912pub struct AssociatedItemConstraintListGreen(pub GreenId);
19913impl TypedSyntaxNode for AssociatedItemConstraintList {
19914 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraintList);
19915 type StablePtr = AssociatedItemConstraintListPtr;
19916 type Green = AssociatedItemConstraintListGreen;
19917 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19918 AssociatedItemConstraintListGreen(
19919 Arc::new(GreenNode {
19920 kind: SyntaxKind::AssociatedItemConstraintList,
19921 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
19922 })
19923 .intern(db),
19924 )
19925 }
19926 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19927 Self(ElementList::new(node))
19928 }
19929 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
19930 if node.kind(db) == SyntaxKind::AssociatedItemConstraintList {
19931 Some(Self(ElementList::new(node)))
19932 } else {
19933 None
19934 }
19935 }
19936 fn as_syntax_node(&self) -> SyntaxNode {
19937 self.node.clone()
19938 }
19939 fn stable_ptr(&self) -> Self::StablePtr {
19940 AssociatedItemConstraintListPtr(self.node.0.stable_ptr)
19941 }
19942}
19943impl From<&AssociatedItemConstraintList> for SyntaxStablePtrId {
19944 fn from(node: &AssociatedItemConstraintList) -> Self {
19945 node.stable_ptr().untyped()
19946 }
19947}
19948#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19949pub enum OptionAssociatedItemConstraints {
19950 Empty(OptionAssociatedItemConstraintsEmpty),
19951 AssociatedItemConstraints(AssociatedItemConstraints),
19952}
19953#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19954pub struct OptionAssociatedItemConstraintsPtr(pub SyntaxStablePtrId);
19955impl TypedStablePtr for OptionAssociatedItemConstraintsPtr {
19956 type SyntaxNode = OptionAssociatedItemConstraints;
19957 fn untyped(&self) -> SyntaxStablePtrId {
19958 self.0
19959 }
19960 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
19961 OptionAssociatedItemConstraints::from_syntax_node(db, self.0.lookup(db))
19962 }
19963}
19964impl From<OptionAssociatedItemConstraintsPtr> for SyntaxStablePtrId {
19965 fn from(ptr: OptionAssociatedItemConstraintsPtr) -> Self {
19966 ptr.untyped()
19967 }
19968}
19969impl From<OptionAssociatedItemConstraintsEmptyPtr> for OptionAssociatedItemConstraintsPtr {
19970 fn from(value: OptionAssociatedItemConstraintsEmptyPtr) -> Self {
19971 Self(value.0)
19972 }
19973}
19974impl From<AssociatedItemConstraintsPtr> for OptionAssociatedItemConstraintsPtr {
19975 fn from(value: AssociatedItemConstraintsPtr) -> Self {
19976 Self(value.0)
19977 }
19978}
19979impl From<OptionAssociatedItemConstraintsEmptyGreen> for OptionAssociatedItemConstraintsGreen {
19980 fn from(value: OptionAssociatedItemConstraintsEmptyGreen) -> Self {
19981 Self(value.0)
19982 }
19983}
19984impl From<AssociatedItemConstraintsGreen> for OptionAssociatedItemConstraintsGreen {
19985 fn from(value: AssociatedItemConstraintsGreen) -> Self {
19986 Self(value.0)
19987 }
19988}
19989#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19990pub struct OptionAssociatedItemConstraintsGreen(pub GreenId);
19991impl TypedSyntaxNode for OptionAssociatedItemConstraints {
19992 const OPTIONAL_KIND: Option<SyntaxKind> = None;
19993 type StablePtr = OptionAssociatedItemConstraintsPtr;
19994 type Green = OptionAssociatedItemConstraintsGreen;
19995 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19996 panic!("No missing variant.");
19997 }
19998 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19999 let kind = node.kind(db);
20000 match kind {
20001 SyntaxKind::OptionAssociatedItemConstraintsEmpty => {
20002 OptionAssociatedItemConstraints::Empty(
20003 OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, node),
20004 )
20005 }
20006 SyntaxKind::AssociatedItemConstraints => {
20007 OptionAssociatedItemConstraints::AssociatedItemConstraints(
20008 AssociatedItemConstraints::from_syntax_node(db, node),
20009 )
20010 }
20011 _ => panic!(
20012 "Unexpected syntax kind {:?} when constructing {}.",
20013 kind, "OptionAssociatedItemConstraints"
20014 ),
20015 }
20016 }
20017 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20018 let kind = node.kind(db);
20019 match kind {
20020 SyntaxKind::OptionAssociatedItemConstraintsEmpty => {
20021 Some(OptionAssociatedItemConstraints::Empty(
20022 OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, node),
20023 ))
20024 }
20025 SyntaxKind::AssociatedItemConstraints => {
20026 Some(OptionAssociatedItemConstraints::AssociatedItemConstraints(
20027 AssociatedItemConstraints::from_syntax_node(db, node),
20028 ))
20029 }
20030 _ => None,
20031 }
20032 }
20033 fn as_syntax_node(&self) -> SyntaxNode {
20034 match self {
20035 OptionAssociatedItemConstraints::Empty(x) => x.as_syntax_node(),
20036 OptionAssociatedItemConstraints::AssociatedItemConstraints(x) => x.as_syntax_node(),
20037 }
20038 }
20039 fn stable_ptr(&self) -> Self::StablePtr {
20040 OptionAssociatedItemConstraintsPtr(self.as_syntax_node().0.stable_ptr)
20041 }
20042}
20043impl From<&OptionAssociatedItemConstraints> for SyntaxStablePtrId {
20044 fn from(node: &OptionAssociatedItemConstraints) -> Self {
20045 node.stable_ptr().untyped()
20046 }
20047}
20048impl OptionAssociatedItemConstraints {
20049 pub fn is_variant(kind: SyntaxKind) -> bool {
20051 matches!(
20052 kind,
20053 SyntaxKind::OptionAssociatedItemConstraintsEmpty
20054 | SyntaxKind::AssociatedItemConstraints
20055 )
20056 }
20057}
20058#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20059pub struct OptionAssociatedItemConstraintsEmpty {
20060 node: SyntaxNode,
20061 children: Arc<[SyntaxNode]>,
20062}
20063impl OptionAssociatedItemConstraintsEmpty {
20064 pub fn new_green(db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraintsEmptyGreen {
20065 let children: Vec<GreenId> = vec![];
20066 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20067 OptionAssociatedItemConstraintsEmptyGreen(
20068 Arc::new(GreenNode {
20069 kind: SyntaxKind::OptionAssociatedItemConstraintsEmpty,
20070 details: GreenNodeDetails::Node { children, width },
20071 })
20072 .intern(db),
20073 )
20074 }
20075}
20076impl OptionAssociatedItemConstraintsEmpty {}
20077#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20078pub struct OptionAssociatedItemConstraintsEmptyPtr(pub SyntaxStablePtrId);
20079impl OptionAssociatedItemConstraintsEmptyPtr {}
20080impl TypedStablePtr for OptionAssociatedItemConstraintsEmptyPtr {
20081 type SyntaxNode = OptionAssociatedItemConstraintsEmpty;
20082 fn untyped(&self) -> SyntaxStablePtrId {
20083 self.0
20084 }
20085 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraintsEmpty {
20086 OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, self.0.lookup(db))
20087 }
20088}
20089impl From<OptionAssociatedItemConstraintsEmptyPtr> for SyntaxStablePtrId {
20090 fn from(ptr: OptionAssociatedItemConstraintsEmptyPtr) -> Self {
20091 ptr.untyped()
20092 }
20093}
20094#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20095pub struct OptionAssociatedItemConstraintsEmptyGreen(pub GreenId);
20096impl TypedSyntaxNode for OptionAssociatedItemConstraintsEmpty {
20097 const OPTIONAL_KIND: Option<SyntaxKind> =
20098 Some(SyntaxKind::OptionAssociatedItemConstraintsEmpty);
20099 type StablePtr = OptionAssociatedItemConstraintsEmptyPtr;
20100 type Green = OptionAssociatedItemConstraintsEmptyGreen;
20101 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20102 OptionAssociatedItemConstraintsEmptyGreen(
20103 Arc::new(GreenNode {
20104 kind: SyntaxKind::OptionAssociatedItemConstraintsEmpty,
20105 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
20106 })
20107 .intern(db),
20108 )
20109 }
20110 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20111 let kind = node.kind(db);
20112 assert_eq!(
20113 kind,
20114 SyntaxKind::OptionAssociatedItemConstraintsEmpty,
20115 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20116 kind,
20117 SyntaxKind::OptionAssociatedItemConstraintsEmpty
20118 );
20119 let children = db.get_children(node.clone());
20120 Self { node, children }
20121 }
20122 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20123 let kind = node.kind(db);
20124 if kind == SyntaxKind::OptionAssociatedItemConstraintsEmpty {
20125 Some(Self::from_syntax_node(db, node))
20126 } else {
20127 None
20128 }
20129 }
20130 fn as_syntax_node(&self) -> SyntaxNode {
20131 self.node.clone()
20132 }
20133 fn stable_ptr(&self) -> Self::StablePtr {
20134 OptionAssociatedItemConstraintsEmptyPtr(self.node.0.stable_ptr)
20135 }
20136}
20137impl From<&OptionAssociatedItemConstraintsEmpty> for SyntaxStablePtrId {
20138 fn from(node: &OptionAssociatedItemConstraintsEmpty) -> Self {
20139 node.stable_ptr().untyped()
20140 }
20141}
20142#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20143pub enum OptionWrappedGenericParamList {
20144 Empty(OptionWrappedGenericParamListEmpty),
20145 WrappedGenericParamList(WrappedGenericParamList),
20146}
20147#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20148pub struct OptionWrappedGenericParamListPtr(pub SyntaxStablePtrId);
20149impl TypedStablePtr for OptionWrappedGenericParamListPtr {
20150 type SyntaxNode = OptionWrappedGenericParamList;
20151 fn untyped(&self) -> SyntaxStablePtrId {
20152 self.0
20153 }
20154 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
20155 OptionWrappedGenericParamList::from_syntax_node(db, self.0.lookup(db))
20156 }
20157}
20158impl From<OptionWrappedGenericParamListPtr> for SyntaxStablePtrId {
20159 fn from(ptr: OptionWrappedGenericParamListPtr) -> Self {
20160 ptr.untyped()
20161 }
20162}
20163impl From<OptionWrappedGenericParamListEmptyPtr> for OptionWrappedGenericParamListPtr {
20164 fn from(value: OptionWrappedGenericParamListEmptyPtr) -> Self {
20165 Self(value.0)
20166 }
20167}
20168impl From<WrappedGenericParamListPtr> for OptionWrappedGenericParamListPtr {
20169 fn from(value: WrappedGenericParamListPtr) -> Self {
20170 Self(value.0)
20171 }
20172}
20173impl From<OptionWrappedGenericParamListEmptyGreen> for OptionWrappedGenericParamListGreen {
20174 fn from(value: OptionWrappedGenericParamListEmptyGreen) -> Self {
20175 Self(value.0)
20176 }
20177}
20178impl From<WrappedGenericParamListGreen> for OptionWrappedGenericParamListGreen {
20179 fn from(value: WrappedGenericParamListGreen) -> Self {
20180 Self(value.0)
20181 }
20182}
20183#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20184pub struct OptionWrappedGenericParamListGreen(pub GreenId);
20185impl TypedSyntaxNode for OptionWrappedGenericParamList {
20186 const OPTIONAL_KIND: Option<SyntaxKind> = None;
20187 type StablePtr = OptionWrappedGenericParamListPtr;
20188 type Green = OptionWrappedGenericParamListGreen;
20189 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20190 panic!("No missing variant.");
20191 }
20192 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20193 let kind = node.kind(db);
20194 match kind {
20195 SyntaxKind::OptionWrappedGenericParamListEmpty => OptionWrappedGenericParamList::Empty(
20196 OptionWrappedGenericParamListEmpty::from_syntax_node(db, node),
20197 ),
20198 SyntaxKind::WrappedGenericParamList => {
20199 OptionWrappedGenericParamList::WrappedGenericParamList(
20200 WrappedGenericParamList::from_syntax_node(db, node),
20201 )
20202 }
20203 _ => panic!(
20204 "Unexpected syntax kind {:?} when constructing {}.",
20205 kind, "OptionWrappedGenericParamList"
20206 ),
20207 }
20208 }
20209 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20210 let kind = node.kind(db);
20211 match kind {
20212 SyntaxKind::OptionWrappedGenericParamListEmpty => {
20213 Some(OptionWrappedGenericParamList::Empty(
20214 OptionWrappedGenericParamListEmpty::from_syntax_node(db, node),
20215 ))
20216 }
20217 SyntaxKind::WrappedGenericParamList => {
20218 Some(OptionWrappedGenericParamList::WrappedGenericParamList(
20219 WrappedGenericParamList::from_syntax_node(db, node),
20220 ))
20221 }
20222 _ => None,
20223 }
20224 }
20225 fn as_syntax_node(&self) -> SyntaxNode {
20226 match self {
20227 OptionWrappedGenericParamList::Empty(x) => x.as_syntax_node(),
20228 OptionWrappedGenericParamList::WrappedGenericParamList(x) => x.as_syntax_node(),
20229 }
20230 }
20231 fn stable_ptr(&self) -> Self::StablePtr {
20232 OptionWrappedGenericParamListPtr(self.as_syntax_node().0.stable_ptr)
20233 }
20234}
20235impl From<&OptionWrappedGenericParamList> for SyntaxStablePtrId {
20236 fn from(node: &OptionWrappedGenericParamList) -> Self {
20237 node.stable_ptr().untyped()
20238 }
20239}
20240impl OptionWrappedGenericParamList {
20241 pub fn is_variant(kind: SyntaxKind) -> bool {
20243 matches!(
20244 kind,
20245 SyntaxKind::OptionWrappedGenericParamListEmpty | SyntaxKind::WrappedGenericParamList
20246 )
20247 }
20248}
20249#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20250pub struct OptionWrappedGenericParamListEmpty {
20251 node: SyntaxNode,
20252 children: Arc<[SyntaxNode]>,
20253}
20254impl OptionWrappedGenericParamListEmpty {
20255 pub fn new_green(db: &dyn SyntaxGroup) -> OptionWrappedGenericParamListEmptyGreen {
20256 let children: Vec<GreenId> = vec![];
20257 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20258 OptionWrappedGenericParamListEmptyGreen(
20259 Arc::new(GreenNode {
20260 kind: SyntaxKind::OptionWrappedGenericParamListEmpty,
20261 details: GreenNodeDetails::Node { children, width },
20262 })
20263 .intern(db),
20264 )
20265 }
20266}
20267impl OptionWrappedGenericParamListEmpty {}
20268#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20269pub struct OptionWrappedGenericParamListEmptyPtr(pub SyntaxStablePtrId);
20270impl OptionWrappedGenericParamListEmptyPtr {}
20271impl TypedStablePtr for OptionWrappedGenericParamListEmptyPtr {
20272 type SyntaxNode = OptionWrappedGenericParamListEmpty;
20273 fn untyped(&self) -> SyntaxStablePtrId {
20274 self.0
20275 }
20276 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamListEmpty {
20277 OptionWrappedGenericParamListEmpty::from_syntax_node(db, self.0.lookup(db))
20278 }
20279}
20280impl From<OptionWrappedGenericParamListEmptyPtr> for SyntaxStablePtrId {
20281 fn from(ptr: OptionWrappedGenericParamListEmptyPtr) -> Self {
20282 ptr.untyped()
20283 }
20284}
20285#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20286pub struct OptionWrappedGenericParamListEmptyGreen(pub GreenId);
20287impl TypedSyntaxNode for OptionWrappedGenericParamListEmpty {
20288 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionWrappedGenericParamListEmpty);
20289 type StablePtr = OptionWrappedGenericParamListEmptyPtr;
20290 type Green = OptionWrappedGenericParamListEmptyGreen;
20291 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20292 OptionWrappedGenericParamListEmptyGreen(
20293 Arc::new(GreenNode {
20294 kind: SyntaxKind::OptionWrappedGenericParamListEmpty,
20295 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
20296 })
20297 .intern(db),
20298 )
20299 }
20300 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20301 let kind = node.kind(db);
20302 assert_eq!(
20303 kind,
20304 SyntaxKind::OptionWrappedGenericParamListEmpty,
20305 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20306 kind,
20307 SyntaxKind::OptionWrappedGenericParamListEmpty
20308 );
20309 let children = db.get_children(node.clone());
20310 Self { node, children }
20311 }
20312 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20313 let kind = node.kind(db);
20314 if kind == SyntaxKind::OptionWrappedGenericParamListEmpty {
20315 Some(Self::from_syntax_node(db, node))
20316 } else {
20317 None
20318 }
20319 }
20320 fn as_syntax_node(&self) -> SyntaxNode {
20321 self.node.clone()
20322 }
20323 fn stable_ptr(&self) -> Self::StablePtr {
20324 OptionWrappedGenericParamListEmptyPtr(self.node.0.stable_ptr)
20325 }
20326}
20327impl From<&OptionWrappedGenericParamListEmpty> for SyntaxStablePtrId {
20328 fn from(node: &OptionWrappedGenericParamListEmpty) -> Self {
20329 node.stable_ptr().untyped()
20330 }
20331}
20332#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20333pub struct WrappedGenericParamList {
20334 node: SyntaxNode,
20335 children: Arc<[SyntaxNode]>,
20336}
20337impl WrappedGenericParamList {
20338 pub const INDEX_LANGLE: usize = 0;
20339 pub const INDEX_GENERIC_PARAMS: usize = 1;
20340 pub const INDEX_RANGLE: usize = 2;
20341 pub fn new_green(
20342 db: &dyn SyntaxGroup,
20343 langle: TerminalLTGreen,
20344 generic_params: GenericParamListGreen,
20345 rangle: TerminalGTGreen,
20346 ) -> WrappedGenericParamListGreen {
20347 let children: Vec<GreenId> = vec![langle.0, generic_params.0, rangle.0];
20348 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20349 WrappedGenericParamListGreen(
20350 Arc::new(GreenNode {
20351 kind: SyntaxKind::WrappedGenericParamList,
20352 details: GreenNodeDetails::Node { children, width },
20353 })
20354 .intern(db),
20355 )
20356 }
20357}
20358impl WrappedGenericParamList {
20359 pub fn langle(&self, db: &dyn SyntaxGroup) -> TerminalLT {
20360 TerminalLT::from_syntax_node(db, self.children[0].clone())
20361 }
20362 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> GenericParamList {
20363 GenericParamList::from_syntax_node(db, self.children[1].clone())
20364 }
20365 pub fn rangle(&self, db: &dyn SyntaxGroup) -> TerminalGT {
20366 TerminalGT::from_syntax_node(db, self.children[2].clone())
20367 }
20368}
20369#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20370pub struct WrappedGenericParamListPtr(pub SyntaxStablePtrId);
20371impl WrappedGenericParamListPtr {}
20372impl TypedStablePtr for WrappedGenericParamListPtr {
20373 type SyntaxNode = WrappedGenericParamList;
20374 fn untyped(&self) -> SyntaxStablePtrId {
20375 self.0
20376 }
20377 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedGenericParamList {
20378 WrappedGenericParamList::from_syntax_node(db, self.0.lookup(db))
20379 }
20380}
20381impl From<WrappedGenericParamListPtr> for SyntaxStablePtrId {
20382 fn from(ptr: WrappedGenericParamListPtr) -> Self {
20383 ptr.untyped()
20384 }
20385}
20386#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20387pub struct WrappedGenericParamListGreen(pub GreenId);
20388impl TypedSyntaxNode for WrappedGenericParamList {
20389 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::WrappedGenericParamList);
20390 type StablePtr = WrappedGenericParamListPtr;
20391 type Green = WrappedGenericParamListGreen;
20392 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20393 WrappedGenericParamListGreen(
20394 Arc::new(GreenNode {
20395 kind: SyntaxKind::WrappedGenericParamList,
20396 details: GreenNodeDetails::Node {
20397 children: vec![
20398 TerminalLT::missing(db).0,
20399 GenericParamList::missing(db).0,
20400 TerminalGT::missing(db).0,
20401 ],
20402 width: TextWidth::default(),
20403 },
20404 })
20405 .intern(db),
20406 )
20407 }
20408 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20409 let kind = node.kind(db);
20410 assert_eq!(
20411 kind,
20412 SyntaxKind::WrappedGenericParamList,
20413 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20414 kind,
20415 SyntaxKind::WrappedGenericParamList
20416 );
20417 let children = db.get_children(node.clone());
20418 Self { node, children }
20419 }
20420 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20421 let kind = node.kind(db);
20422 if kind == SyntaxKind::WrappedGenericParamList {
20423 Some(Self::from_syntax_node(db, node))
20424 } else {
20425 None
20426 }
20427 }
20428 fn as_syntax_node(&self) -> SyntaxNode {
20429 self.node.clone()
20430 }
20431 fn stable_ptr(&self) -> Self::StablePtr {
20432 WrappedGenericParamListPtr(self.node.0.stable_ptr)
20433 }
20434}
20435impl From<&WrappedGenericParamList> for SyntaxStablePtrId {
20436 fn from(node: &WrappedGenericParamList) -> Self {
20437 node.stable_ptr().untyped()
20438 }
20439}
20440#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20441pub struct GenericParamList(ElementList<GenericParam, 2>);
20442impl Deref for GenericParamList {
20443 type Target = ElementList<GenericParam, 2>;
20444 fn deref(&self) -> &Self::Target {
20445 &self.0
20446 }
20447}
20448impl GenericParamList {
20449 pub fn new_green(
20450 db: &dyn SyntaxGroup,
20451 children: Vec<GenericParamListElementOrSeparatorGreen>,
20452 ) -> GenericParamListGreen {
20453 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
20454 GenericParamListGreen(
20455 Arc::new(GreenNode {
20456 kind: SyntaxKind::GenericParamList,
20457 details: GreenNodeDetails::Node {
20458 children: children.iter().map(|x| x.id()).collect(),
20459 width,
20460 },
20461 })
20462 .intern(db),
20463 )
20464 }
20465}
20466#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20467pub struct GenericParamListPtr(pub SyntaxStablePtrId);
20468impl TypedStablePtr for GenericParamListPtr {
20469 type SyntaxNode = GenericParamList;
20470 fn untyped(&self) -> SyntaxStablePtrId {
20471 self.0
20472 }
20473 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamList {
20474 GenericParamList::from_syntax_node(db, self.0.lookup(db))
20475 }
20476}
20477impl From<GenericParamListPtr> for SyntaxStablePtrId {
20478 fn from(ptr: GenericParamListPtr) -> Self {
20479 ptr.untyped()
20480 }
20481}
20482#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20483pub enum GenericParamListElementOrSeparatorGreen {
20484 Separator(TerminalCommaGreen),
20485 Element(GenericParamGreen),
20486}
20487impl From<TerminalCommaGreen> for GenericParamListElementOrSeparatorGreen {
20488 fn from(value: TerminalCommaGreen) -> Self {
20489 GenericParamListElementOrSeparatorGreen::Separator(value)
20490 }
20491}
20492impl From<GenericParamGreen> for GenericParamListElementOrSeparatorGreen {
20493 fn from(value: GenericParamGreen) -> Self {
20494 GenericParamListElementOrSeparatorGreen::Element(value)
20495 }
20496}
20497impl GenericParamListElementOrSeparatorGreen {
20498 fn id(&self) -> GreenId {
20499 match self {
20500 GenericParamListElementOrSeparatorGreen::Separator(green) => green.0,
20501 GenericParamListElementOrSeparatorGreen::Element(green) => green.0,
20502 }
20503 }
20504}
20505#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20506pub struct GenericParamListGreen(pub GreenId);
20507impl TypedSyntaxNode for GenericParamList {
20508 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamList);
20509 type StablePtr = GenericParamListPtr;
20510 type Green = GenericParamListGreen;
20511 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20512 GenericParamListGreen(
20513 Arc::new(GreenNode {
20514 kind: SyntaxKind::GenericParamList,
20515 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
20516 })
20517 .intern(db),
20518 )
20519 }
20520 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20521 Self(ElementList::new(node))
20522 }
20523 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20524 if node.kind(db) == SyntaxKind::GenericParamList {
20525 Some(Self(ElementList::new(node)))
20526 } else {
20527 None
20528 }
20529 }
20530 fn as_syntax_node(&self) -> SyntaxNode {
20531 self.node.clone()
20532 }
20533 fn stable_ptr(&self) -> Self::StablePtr {
20534 GenericParamListPtr(self.node.0.stable_ptr)
20535 }
20536}
20537impl From<&GenericParamList> for SyntaxStablePtrId {
20538 fn from(node: &GenericParamList) -> Self {
20539 node.stable_ptr().untyped()
20540 }
20541}
20542#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20543pub enum GenericParam {
20544 Type(GenericParamType),
20545 Const(GenericParamConst),
20546 ImplNamed(GenericParamImplNamed),
20547 ImplAnonymous(GenericParamImplAnonymous),
20548 NegativeImpl(GenericParamNegativeImpl),
20549}
20550#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20551pub struct GenericParamPtr(pub SyntaxStablePtrId);
20552impl TypedStablePtr for GenericParamPtr {
20553 type SyntaxNode = GenericParam;
20554 fn untyped(&self) -> SyntaxStablePtrId {
20555 self.0
20556 }
20557 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParam {
20558 GenericParam::from_syntax_node(db, self.0.lookup(db))
20559 }
20560}
20561impl From<GenericParamPtr> for SyntaxStablePtrId {
20562 fn from(ptr: GenericParamPtr) -> Self {
20563 ptr.untyped()
20564 }
20565}
20566impl From<GenericParamTypePtr> for GenericParamPtr {
20567 fn from(value: GenericParamTypePtr) -> Self {
20568 Self(value.0)
20569 }
20570}
20571impl From<GenericParamConstPtr> for GenericParamPtr {
20572 fn from(value: GenericParamConstPtr) -> Self {
20573 Self(value.0)
20574 }
20575}
20576impl From<GenericParamImplNamedPtr> for GenericParamPtr {
20577 fn from(value: GenericParamImplNamedPtr) -> Self {
20578 Self(value.0)
20579 }
20580}
20581impl From<GenericParamImplAnonymousPtr> for GenericParamPtr {
20582 fn from(value: GenericParamImplAnonymousPtr) -> Self {
20583 Self(value.0)
20584 }
20585}
20586impl From<GenericParamNegativeImplPtr> for GenericParamPtr {
20587 fn from(value: GenericParamNegativeImplPtr) -> Self {
20588 Self(value.0)
20589 }
20590}
20591impl From<GenericParamTypeGreen> for GenericParamGreen {
20592 fn from(value: GenericParamTypeGreen) -> Self {
20593 Self(value.0)
20594 }
20595}
20596impl From<GenericParamConstGreen> for GenericParamGreen {
20597 fn from(value: GenericParamConstGreen) -> Self {
20598 Self(value.0)
20599 }
20600}
20601impl From<GenericParamImplNamedGreen> for GenericParamGreen {
20602 fn from(value: GenericParamImplNamedGreen) -> Self {
20603 Self(value.0)
20604 }
20605}
20606impl From<GenericParamImplAnonymousGreen> for GenericParamGreen {
20607 fn from(value: GenericParamImplAnonymousGreen) -> Self {
20608 Self(value.0)
20609 }
20610}
20611impl From<GenericParamNegativeImplGreen> for GenericParamGreen {
20612 fn from(value: GenericParamNegativeImplGreen) -> Self {
20613 Self(value.0)
20614 }
20615}
20616#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20617pub struct GenericParamGreen(pub GreenId);
20618impl TypedSyntaxNode for GenericParam {
20619 const OPTIONAL_KIND: Option<SyntaxKind> = None;
20620 type StablePtr = GenericParamPtr;
20621 type Green = GenericParamGreen;
20622 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20623 panic!("No missing variant.");
20624 }
20625 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20626 let kind = node.kind(db);
20627 match kind {
20628 SyntaxKind::GenericParamType => {
20629 GenericParam::Type(GenericParamType::from_syntax_node(db, node))
20630 }
20631 SyntaxKind::GenericParamConst => {
20632 GenericParam::Const(GenericParamConst::from_syntax_node(db, node))
20633 }
20634 SyntaxKind::GenericParamImplNamed => {
20635 GenericParam::ImplNamed(GenericParamImplNamed::from_syntax_node(db, node))
20636 }
20637 SyntaxKind::GenericParamImplAnonymous => {
20638 GenericParam::ImplAnonymous(GenericParamImplAnonymous::from_syntax_node(db, node))
20639 }
20640 SyntaxKind::GenericParamNegativeImpl => {
20641 GenericParam::NegativeImpl(GenericParamNegativeImpl::from_syntax_node(db, node))
20642 }
20643 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericParam"),
20644 }
20645 }
20646 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20647 let kind = node.kind(db);
20648 match kind {
20649 SyntaxKind::GenericParamType => {
20650 Some(GenericParam::Type(GenericParamType::from_syntax_node(db, node)))
20651 }
20652 SyntaxKind::GenericParamConst => {
20653 Some(GenericParam::Const(GenericParamConst::from_syntax_node(db, node)))
20654 }
20655 SyntaxKind::GenericParamImplNamed => {
20656 Some(GenericParam::ImplNamed(GenericParamImplNamed::from_syntax_node(db, node)))
20657 }
20658 SyntaxKind::GenericParamImplAnonymous => Some(GenericParam::ImplAnonymous(
20659 GenericParamImplAnonymous::from_syntax_node(db, node),
20660 )),
20661 SyntaxKind::GenericParamNegativeImpl => Some(GenericParam::NegativeImpl(
20662 GenericParamNegativeImpl::from_syntax_node(db, node),
20663 )),
20664 _ => None,
20665 }
20666 }
20667 fn as_syntax_node(&self) -> SyntaxNode {
20668 match self {
20669 GenericParam::Type(x) => x.as_syntax_node(),
20670 GenericParam::Const(x) => x.as_syntax_node(),
20671 GenericParam::ImplNamed(x) => x.as_syntax_node(),
20672 GenericParam::ImplAnonymous(x) => x.as_syntax_node(),
20673 GenericParam::NegativeImpl(x) => x.as_syntax_node(),
20674 }
20675 }
20676 fn stable_ptr(&self) -> Self::StablePtr {
20677 GenericParamPtr(self.as_syntax_node().0.stable_ptr)
20678 }
20679}
20680impl From<&GenericParam> for SyntaxStablePtrId {
20681 fn from(node: &GenericParam) -> Self {
20682 node.stable_ptr().untyped()
20683 }
20684}
20685impl GenericParam {
20686 pub fn is_variant(kind: SyntaxKind) -> bool {
20688 matches!(
20689 kind,
20690 SyntaxKind::GenericParamType
20691 | SyntaxKind::GenericParamConst
20692 | SyntaxKind::GenericParamImplNamed
20693 | SyntaxKind::GenericParamImplAnonymous
20694 | SyntaxKind::GenericParamNegativeImpl
20695 )
20696 }
20697}
20698#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20699pub struct GenericParamType {
20700 node: SyntaxNode,
20701 children: Arc<[SyntaxNode]>,
20702}
20703impl GenericParamType {
20704 pub const INDEX_NAME: usize = 0;
20705 pub fn new_green(db: &dyn SyntaxGroup, name: TerminalIdentifierGreen) -> GenericParamTypeGreen {
20706 let children: Vec<GreenId> = vec![name.0];
20707 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20708 GenericParamTypeGreen(
20709 Arc::new(GreenNode {
20710 kind: SyntaxKind::GenericParamType,
20711 details: GreenNodeDetails::Node { children, width },
20712 })
20713 .intern(db),
20714 )
20715 }
20716}
20717impl GenericParamType {
20718 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
20719 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
20720 }
20721}
20722#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20723pub struct GenericParamTypePtr(pub SyntaxStablePtrId);
20724impl GenericParamTypePtr {
20725 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
20726 let ptr = self.0.lookup_intern(db);
20727 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
20728 TerminalIdentifierGreen(key_fields[0])
20729 } else {
20730 panic!("Unexpected key field query on root.");
20731 }
20732 }
20733}
20734impl TypedStablePtr for GenericParamTypePtr {
20735 type SyntaxNode = GenericParamType;
20736 fn untyped(&self) -> SyntaxStablePtrId {
20737 self.0
20738 }
20739 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamType {
20740 GenericParamType::from_syntax_node(db, self.0.lookup(db))
20741 }
20742}
20743impl From<GenericParamTypePtr> for SyntaxStablePtrId {
20744 fn from(ptr: GenericParamTypePtr) -> Self {
20745 ptr.untyped()
20746 }
20747}
20748#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20749pub struct GenericParamTypeGreen(pub GreenId);
20750impl TypedSyntaxNode for GenericParamType {
20751 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamType);
20752 type StablePtr = GenericParamTypePtr;
20753 type Green = GenericParamTypeGreen;
20754 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20755 GenericParamTypeGreen(
20756 Arc::new(GreenNode {
20757 kind: SyntaxKind::GenericParamType,
20758 details: GreenNodeDetails::Node {
20759 children: vec![TerminalIdentifier::missing(db).0],
20760 width: TextWidth::default(),
20761 },
20762 })
20763 .intern(db),
20764 )
20765 }
20766 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20767 let kind = node.kind(db);
20768 assert_eq!(
20769 kind,
20770 SyntaxKind::GenericParamType,
20771 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20772 kind,
20773 SyntaxKind::GenericParamType
20774 );
20775 let children = db.get_children(node.clone());
20776 Self { node, children }
20777 }
20778 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20779 let kind = node.kind(db);
20780 if kind == SyntaxKind::GenericParamType {
20781 Some(Self::from_syntax_node(db, node))
20782 } else {
20783 None
20784 }
20785 }
20786 fn as_syntax_node(&self) -> SyntaxNode {
20787 self.node.clone()
20788 }
20789 fn stable_ptr(&self) -> Self::StablePtr {
20790 GenericParamTypePtr(self.node.0.stable_ptr)
20791 }
20792}
20793impl From<&GenericParamType> for SyntaxStablePtrId {
20794 fn from(node: &GenericParamType) -> Self {
20795 node.stable_ptr().untyped()
20796 }
20797}
20798#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20799pub struct GenericParamConst {
20800 node: SyntaxNode,
20801 children: Arc<[SyntaxNode]>,
20802}
20803impl GenericParamConst {
20804 pub const INDEX_CONST_KW: usize = 0;
20805 pub const INDEX_NAME: usize = 1;
20806 pub const INDEX_COLON: usize = 2;
20807 pub const INDEX_TY: usize = 3;
20808 pub fn new_green(
20809 db: &dyn SyntaxGroup,
20810 const_kw: TerminalConstGreen,
20811 name: TerminalIdentifierGreen,
20812 colon: TerminalColonGreen,
20813 ty: ExprGreen,
20814 ) -> GenericParamConstGreen {
20815 let children: Vec<GreenId> = vec![const_kw.0, name.0, colon.0, ty.0];
20816 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20817 GenericParamConstGreen(
20818 Arc::new(GreenNode {
20819 kind: SyntaxKind::GenericParamConst,
20820 details: GreenNodeDetails::Node { children, width },
20821 })
20822 .intern(db),
20823 )
20824 }
20825}
20826impl GenericParamConst {
20827 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
20828 TerminalConst::from_syntax_node(db, self.children[0].clone())
20829 }
20830 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
20831 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
20832 }
20833 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
20834 TerminalColon::from_syntax_node(db, self.children[2].clone())
20835 }
20836 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
20837 Expr::from_syntax_node(db, self.children[3].clone())
20838 }
20839}
20840#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20841pub struct GenericParamConstPtr(pub SyntaxStablePtrId);
20842impl GenericParamConstPtr {
20843 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
20844 let ptr = self.0.lookup_intern(db);
20845 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
20846 TerminalIdentifierGreen(key_fields[0])
20847 } else {
20848 panic!("Unexpected key field query on root.");
20849 }
20850 }
20851}
20852impl TypedStablePtr for GenericParamConstPtr {
20853 type SyntaxNode = GenericParamConst;
20854 fn untyped(&self) -> SyntaxStablePtrId {
20855 self.0
20856 }
20857 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamConst {
20858 GenericParamConst::from_syntax_node(db, self.0.lookup(db))
20859 }
20860}
20861impl From<GenericParamConstPtr> for SyntaxStablePtrId {
20862 fn from(ptr: GenericParamConstPtr) -> Self {
20863 ptr.untyped()
20864 }
20865}
20866#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20867pub struct GenericParamConstGreen(pub GreenId);
20868impl TypedSyntaxNode for GenericParamConst {
20869 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamConst);
20870 type StablePtr = GenericParamConstPtr;
20871 type Green = GenericParamConstGreen;
20872 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20873 GenericParamConstGreen(
20874 Arc::new(GreenNode {
20875 kind: SyntaxKind::GenericParamConst,
20876 details: GreenNodeDetails::Node {
20877 children: vec![
20878 TerminalConst::missing(db).0,
20879 TerminalIdentifier::missing(db).0,
20880 TerminalColon::missing(db).0,
20881 Expr::missing(db).0,
20882 ],
20883 width: TextWidth::default(),
20884 },
20885 })
20886 .intern(db),
20887 )
20888 }
20889 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20890 let kind = node.kind(db);
20891 assert_eq!(
20892 kind,
20893 SyntaxKind::GenericParamConst,
20894 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20895 kind,
20896 SyntaxKind::GenericParamConst
20897 );
20898 let children = db.get_children(node.clone());
20899 Self { node, children }
20900 }
20901 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
20902 let kind = node.kind(db);
20903 if kind == SyntaxKind::GenericParamConst {
20904 Some(Self::from_syntax_node(db, node))
20905 } else {
20906 None
20907 }
20908 }
20909 fn as_syntax_node(&self) -> SyntaxNode {
20910 self.node.clone()
20911 }
20912 fn stable_ptr(&self) -> Self::StablePtr {
20913 GenericParamConstPtr(self.node.0.stable_ptr)
20914 }
20915}
20916impl From<&GenericParamConst> for SyntaxStablePtrId {
20917 fn from(node: &GenericParamConst) -> Self {
20918 node.stable_ptr().untyped()
20919 }
20920}
20921#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20922pub struct GenericParamImplNamed {
20923 node: SyntaxNode,
20924 children: Arc<[SyntaxNode]>,
20925}
20926impl GenericParamImplNamed {
20927 pub const INDEX_IMPL_KW: usize = 0;
20928 pub const INDEX_NAME: usize = 1;
20929 pub const INDEX_COLON: usize = 2;
20930 pub const INDEX_TRAIT_PATH: usize = 3;
20931 pub const INDEX_TYPE_CONSTRAINS: usize = 4;
20932 pub fn new_green(
20933 db: &dyn SyntaxGroup,
20934 impl_kw: TerminalImplGreen,
20935 name: TerminalIdentifierGreen,
20936 colon: TerminalColonGreen,
20937 trait_path: ExprPathGreen,
20938 type_constrains: OptionAssociatedItemConstraintsGreen,
20939 ) -> GenericParamImplNamedGreen {
20940 let children: Vec<GreenId> =
20941 vec![impl_kw.0, name.0, colon.0, trait_path.0, type_constrains.0];
20942 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20943 GenericParamImplNamedGreen(
20944 Arc::new(GreenNode {
20945 kind: SyntaxKind::GenericParamImplNamed,
20946 details: GreenNodeDetails::Node { children, width },
20947 })
20948 .intern(db),
20949 )
20950 }
20951}
20952impl GenericParamImplNamed {
20953 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
20954 TerminalImpl::from_syntax_node(db, self.children[0].clone())
20955 }
20956 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
20957 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
20958 }
20959 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
20960 TerminalColon::from_syntax_node(db, self.children[2].clone())
20961 }
20962 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
20963 ExprPath::from_syntax_node(db, self.children[3].clone())
20964 }
20965 pub fn type_constrains(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
20966 OptionAssociatedItemConstraints::from_syntax_node(db, self.children[4].clone())
20967 }
20968}
20969#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20970pub struct GenericParamImplNamedPtr(pub SyntaxStablePtrId);
20971impl GenericParamImplNamedPtr {
20972 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
20973 let ptr = self.0.lookup_intern(db);
20974 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
20975 TerminalIdentifierGreen(key_fields[0])
20976 } else {
20977 panic!("Unexpected key field query on root.");
20978 }
20979 }
20980}
20981impl TypedStablePtr for GenericParamImplNamedPtr {
20982 type SyntaxNode = GenericParamImplNamed;
20983 fn untyped(&self) -> SyntaxStablePtrId {
20984 self.0
20985 }
20986 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamImplNamed {
20987 GenericParamImplNamed::from_syntax_node(db, self.0.lookup(db))
20988 }
20989}
20990impl From<GenericParamImplNamedPtr> for SyntaxStablePtrId {
20991 fn from(ptr: GenericParamImplNamedPtr) -> Self {
20992 ptr.untyped()
20993 }
20994}
20995#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20996pub struct GenericParamImplNamedGreen(pub GreenId);
20997impl TypedSyntaxNode for GenericParamImplNamed {
20998 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamImplNamed);
20999 type StablePtr = GenericParamImplNamedPtr;
21000 type Green = GenericParamImplNamedGreen;
21001 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21002 GenericParamImplNamedGreen(
21003 Arc::new(GreenNode {
21004 kind: SyntaxKind::GenericParamImplNamed,
21005 details: GreenNodeDetails::Node {
21006 children: vec![
21007 TerminalImpl::missing(db).0,
21008 TerminalIdentifier::missing(db).0,
21009 TerminalColon::missing(db).0,
21010 ExprPath::missing(db).0,
21011 OptionAssociatedItemConstraints::missing(db).0,
21012 ],
21013 width: TextWidth::default(),
21014 },
21015 })
21016 .intern(db),
21017 )
21018 }
21019 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21020 let kind = node.kind(db);
21021 assert_eq!(
21022 kind,
21023 SyntaxKind::GenericParamImplNamed,
21024 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21025 kind,
21026 SyntaxKind::GenericParamImplNamed
21027 );
21028 let children = db.get_children(node.clone());
21029 Self { node, children }
21030 }
21031 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21032 let kind = node.kind(db);
21033 if kind == SyntaxKind::GenericParamImplNamed {
21034 Some(Self::from_syntax_node(db, node))
21035 } else {
21036 None
21037 }
21038 }
21039 fn as_syntax_node(&self) -> SyntaxNode {
21040 self.node.clone()
21041 }
21042 fn stable_ptr(&self) -> Self::StablePtr {
21043 GenericParamImplNamedPtr(self.node.0.stable_ptr)
21044 }
21045}
21046impl From<&GenericParamImplNamed> for SyntaxStablePtrId {
21047 fn from(node: &GenericParamImplNamed) -> Self {
21048 node.stable_ptr().untyped()
21049 }
21050}
21051#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21052pub struct GenericParamImplAnonymous {
21053 node: SyntaxNode,
21054 children: Arc<[SyntaxNode]>,
21055}
21056impl GenericParamImplAnonymous {
21057 pub const INDEX_PLUS: usize = 0;
21058 pub const INDEX_TRAIT_PATH: usize = 1;
21059 pub const INDEX_TYPE_CONSTRAINS: usize = 2;
21060 pub fn new_green(
21061 db: &dyn SyntaxGroup,
21062 plus: TerminalPlusGreen,
21063 trait_path: ExprPathGreen,
21064 type_constrains: OptionAssociatedItemConstraintsGreen,
21065 ) -> GenericParamImplAnonymousGreen {
21066 let children: Vec<GreenId> = vec![plus.0, trait_path.0, type_constrains.0];
21067 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21068 GenericParamImplAnonymousGreen(
21069 Arc::new(GreenNode {
21070 kind: SyntaxKind::GenericParamImplAnonymous,
21071 details: GreenNodeDetails::Node { children, width },
21072 })
21073 .intern(db),
21074 )
21075 }
21076}
21077impl GenericParamImplAnonymous {
21078 pub fn plus(&self, db: &dyn SyntaxGroup) -> TerminalPlus {
21079 TerminalPlus::from_syntax_node(db, self.children[0].clone())
21080 }
21081 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
21082 ExprPath::from_syntax_node(db, self.children[1].clone())
21083 }
21084 pub fn type_constrains(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
21085 OptionAssociatedItemConstraints::from_syntax_node(db, self.children[2].clone())
21086 }
21087}
21088#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21089pub struct GenericParamImplAnonymousPtr(pub SyntaxStablePtrId);
21090impl GenericParamImplAnonymousPtr {}
21091impl TypedStablePtr for GenericParamImplAnonymousPtr {
21092 type SyntaxNode = GenericParamImplAnonymous;
21093 fn untyped(&self) -> SyntaxStablePtrId {
21094 self.0
21095 }
21096 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamImplAnonymous {
21097 GenericParamImplAnonymous::from_syntax_node(db, self.0.lookup(db))
21098 }
21099}
21100impl From<GenericParamImplAnonymousPtr> for SyntaxStablePtrId {
21101 fn from(ptr: GenericParamImplAnonymousPtr) -> Self {
21102 ptr.untyped()
21103 }
21104}
21105#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21106pub struct GenericParamImplAnonymousGreen(pub GreenId);
21107impl TypedSyntaxNode for GenericParamImplAnonymous {
21108 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamImplAnonymous);
21109 type StablePtr = GenericParamImplAnonymousPtr;
21110 type Green = GenericParamImplAnonymousGreen;
21111 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21112 GenericParamImplAnonymousGreen(
21113 Arc::new(GreenNode {
21114 kind: SyntaxKind::GenericParamImplAnonymous,
21115 details: GreenNodeDetails::Node {
21116 children: vec![
21117 TerminalPlus::missing(db).0,
21118 ExprPath::missing(db).0,
21119 OptionAssociatedItemConstraints::missing(db).0,
21120 ],
21121 width: TextWidth::default(),
21122 },
21123 })
21124 .intern(db),
21125 )
21126 }
21127 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21128 let kind = node.kind(db);
21129 assert_eq!(
21130 kind,
21131 SyntaxKind::GenericParamImplAnonymous,
21132 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21133 kind,
21134 SyntaxKind::GenericParamImplAnonymous
21135 );
21136 let children = db.get_children(node.clone());
21137 Self { node, children }
21138 }
21139 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21140 let kind = node.kind(db);
21141 if kind == SyntaxKind::GenericParamImplAnonymous {
21142 Some(Self::from_syntax_node(db, node))
21143 } else {
21144 None
21145 }
21146 }
21147 fn as_syntax_node(&self) -> SyntaxNode {
21148 self.node.clone()
21149 }
21150 fn stable_ptr(&self) -> Self::StablePtr {
21151 GenericParamImplAnonymousPtr(self.node.0.stable_ptr)
21152 }
21153}
21154impl From<&GenericParamImplAnonymous> for SyntaxStablePtrId {
21155 fn from(node: &GenericParamImplAnonymous) -> Self {
21156 node.stable_ptr().untyped()
21157 }
21158}
21159#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21160pub struct GenericParamNegativeImpl {
21161 node: SyntaxNode,
21162 children: Arc<[SyntaxNode]>,
21163}
21164impl GenericParamNegativeImpl {
21165 pub const INDEX_MINUS: usize = 0;
21166 pub const INDEX_TRAIT_PATH: usize = 1;
21167 pub fn new_green(
21168 db: &dyn SyntaxGroup,
21169 minus: TerminalMinusGreen,
21170 trait_path: ExprPathGreen,
21171 ) -> GenericParamNegativeImplGreen {
21172 let children: Vec<GreenId> = vec![minus.0, trait_path.0];
21173 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21174 GenericParamNegativeImplGreen(
21175 Arc::new(GreenNode {
21176 kind: SyntaxKind::GenericParamNegativeImpl,
21177 details: GreenNodeDetails::Node { children, width },
21178 })
21179 .intern(db),
21180 )
21181 }
21182}
21183impl GenericParamNegativeImpl {
21184 pub fn minus(&self, db: &dyn SyntaxGroup) -> TerminalMinus {
21185 TerminalMinus::from_syntax_node(db, self.children[0].clone())
21186 }
21187 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
21188 ExprPath::from_syntax_node(db, self.children[1].clone())
21189 }
21190}
21191#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21192pub struct GenericParamNegativeImplPtr(pub SyntaxStablePtrId);
21193impl GenericParamNegativeImplPtr {}
21194impl TypedStablePtr for GenericParamNegativeImplPtr {
21195 type SyntaxNode = GenericParamNegativeImpl;
21196 fn untyped(&self) -> SyntaxStablePtrId {
21197 self.0
21198 }
21199 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamNegativeImpl {
21200 GenericParamNegativeImpl::from_syntax_node(db, self.0.lookup(db))
21201 }
21202}
21203impl From<GenericParamNegativeImplPtr> for SyntaxStablePtrId {
21204 fn from(ptr: GenericParamNegativeImplPtr) -> Self {
21205 ptr.untyped()
21206 }
21207}
21208#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21209pub struct GenericParamNegativeImplGreen(pub GreenId);
21210impl TypedSyntaxNode for GenericParamNegativeImpl {
21211 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamNegativeImpl);
21212 type StablePtr = GenericParamNegativeImplPtr;
21213 type Green = GenericParamNegativeImplGreen;
21214 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21215 GenericParamNegativeImplGreen(
21216 Arc::new(GreenNode {
21217 kind: SyntaxKind::GenericParamNegativeImpl,
21218 details: GreenNodeDetails::Node {
21219 children: vec![TerminalMinus::missing(db).0, ExprPath::missing(db).0],
21220 width: TextWidth::default(),
21221 },
21222 })
21223 .intern(db),
21224 )
21225 }
21226 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21227 let kind = node.kind(db);
21228 assert_eq!(
21229 kind,
21230 SyntaxKind::GenericParamNegativeImpl,
21231 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21232 kind,
21233 SyntaxKind::GenericParamNegativeImpl
21234 );
21235 let children = db.get_children(node.clone());
21236 Self { node, children }
21237 }
21238 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21239 let kind = node.kind(db);
21240 if kind == SyntaxKind::GenericParamNegativeImpl {
21241 Some(Self::from_syntax_node(db, node))
21242 } else {
21243 None
21244 }
21245 }
21246 fn as_syntax_node(&self) -> SyntaxNode {
21247 self.node.clone()
21248 }
21249 fn stable_ptr(&self) -> Self::StablePtr {
21250 GenericParamNegativeImplPtr(self.node.0.stable_ptr)
21251 }
21252}
21253impl From<&GenericParamNegativeImpl> for SyntaxStablePtrId {
21254 fn from(node: &GenericParamNegativeImpl) -> Self {
21255 node.stable_ptr().untyped()
21256 }
21257}
21258#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21259pub struct TriviumSkippedNode {
21260 node: SyntaxNode,
21261 children: Arc<[SyntaxNode]>,
21262}
21263impl TriviumSkippedNode {
21264 pub const INDEX_NODE: usize = 0;
21265 pub fn new_green(db: &dyn SyntaxGroup, node: SkippedNodeGreen) -> TriviumSkippedNodeGreen {
21266 let children: Vec<GreenId> = vec![node.0];
21267 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21268 TriviumSkippedNodeGreen(
21269 Arc::new(GreenNode {
21270 kind: SyntaxKind::TriviumSkippedNode,
21271 details: GreenNodeDetails::Node { children, width },
21272 })
21273 .intern(db),
21274 )
21275 }
21276}
21277impl TriviumSkippedNode {
21278 pub fn node(&self, db: &dyn SyntaxGroup) -> SkippedNode {
21279 SkippedNode::from_syntax_node(db, self.children[0].clone())
21280 }
21281}
21282#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21283pub struct TriviumSkippedNodePtr(pub SyntaxStablePtrId);
21284impl TriviumSkippedNodePtr {}
21285impl TypedStablePtr for TriviumSkippedNodePtr {
21286 type SyntaxNode = TriviumSkippedNode;
21287 fn untyped(&self) -> SyntaxStablePtrId {
21288 self.0
21289 }
21290 fn lookup(&self, db: &dyn SyntaxGroup) -> TriviumSkippedNode {
21291 TriviumSkippedNode::from_syntax_node(db, self.0.lookup(db))
21292 }
21293}
21294impl From<TriviumSkippedNodePtr> for SyntaxStablePtrId {
21295 fn from(ptr: TriviumSkippedNodePtr) -> Self {
21296 ptr.untyped()
21297 }
21298}
21299#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21300pub struct TriviumSkippedNodeGreen(pub GreenId);
21301impl TypedSyntaxNode for TriviumSkippedNode {
21302 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TriviumSkippedNode);
21303 type StablePtr = TriviumSkippedNodePtr;
21304 type Green = TriviumSkippedNodeGreen;
21305 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21306 TriviumSkippedNodeGreen(
21307 Arc::new(GreenNode {
21308 kind: SyntaxKind::TriviumSkippedNode,
21309 details: GreenNodeDetails::Node {
21310 children: vec![SkippedNode::missing(db).0],
21311 width: TextWidth::default(),
21312 },
21313 })
21314 .intern(db),
21315 )
21316 }
21317 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21318 let kind = node.kind(db);
21319 assert_eq!(
21320 kind,
21321 SyntaxKind::TriviumSkippedNode,
21322 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21323 kind,
21324 SyntaxKind::TriviumSkippedNode
21325 );
21326 let children = db.get_children(node.clone());
21327 Self { node, children }
21328 }
21329 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21330 let kind = node.kind(db);
21331 if kind == SyntaxKind::TriviumSkippedNode {
21332 Some(Self::from_syntax_node(db, node))
21333 } else {
21334 None
21335 }
21336 }
21337 fn as_syntax_node(&self) -> SyntaxNode {
21338 self.node.clone()
21339 }
21340 fn stable_ptr(&self) -> Self::StablePtr {
21341 TriviumSkippedNodePtr(self.node.0.stable_ptr)
21342 }
21343}
21344impl From<&TriviumSkippedNode> for SyntaxStablePtrId {
21345 fn from(node: &TriviumSkippedNode) -> Self {
21346 node.stable_ptr().untyped()
21347 }
21348}
21349#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21350pub enum SkippedNode {
21351 AttributeList(AttributeList),
21352 VisibilityPub(VisibilityPub),
21353}
21354#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21355pub struct SkippedNodePtr(pub SyntaxStablePtrId);
21356impl TypedStablePtr for SkippedNodePtr {
21357 type SyntaxNode = SkippedNode;
21358 fn untyped(&self) -> SyntaxStablePtrId {
21359 self.0
21360 }
21361 fn lookup(&self, db: &dyn SyntaxGroup) -> SkippedNode {
21362 SkippedNode::from_syntax_node(db, self.0.lookup(db))
21363 }
21364}
21365impl From<SkippedNodePtr> for SyntaxStablePtrId {
21366 fn from(ptr: SkippedNodePtr) -> Self {
21367 ptr.untyped()
21368 }
21369}
21370impl From<AttributeListPtr> for SkippedNodePtr {
21371 fn from(value: AttributeListPtr) -> Self {
21372 Self(value.0)
21373 }
21374}
21375impl From<VisibilityPubPtr> for SkippedNodePtr {
21376 fn from(value: VisibilityPubPtr) -> Self {
21377 Self(value.0)
21378 }
21379}
21380impl From<AttributeListGreen> for SkippedNodeGreen {
21381 fn from(value: AttributeListGreen) -> Self {
21382 Self(value.0)
21383 }
21384}
21385impl From<VisibilityPubGreen> for SkippedNodeGreen {
21386 fn from(value: VisibilityPubGreen) -> Self {
21387 Self(value.0)
21388 }
21389}
21390#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21391pub struct SkippedNodeGreen(pub GreenId);
21392impl TypedSyntaxNode for SkippedNode {
21393 const OPTIONAL_KIND: Option<SyntaxKind> = None;
21394 type StablePtr = SkippedNodePtr;
21395 type Green = SkippedNodeGreen;
21396 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21397 panic!("No missing variant.");
21398 }
21399 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21400 let kind = node.kind(db);
21401 match kind {
21402 SyntaxKind::AttributeList => {
21403 SkippedNode::AttributeList(AttributeList::from_syntax_node(db, node))
21404 }
21405 SyntaxKind::VisibilityPub => {
21406 SkippedNode::VisibilityPub(VisibilityPub::from_syntax_node(db, node))
21407 }
21408 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "SkippedNode"),
21409 }
21410 }
21411 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21412 let kind = node.kind(db);
21413 match kind {
21414 SyntaxKind::AttributeList => {
21415 Some(SkippedNode::AttributeList(AttributeList::from_syntax_node(db, node)))
21416 }
21417 SyntaxKind::VisibilityPub => {
21418 Some(SkippedNode::VisibilityPub(VisibilityPub::from_syntax_node(db, node)))
21419 }
21420 _ => None,
21421 }
21422 }
21423 fn as_syntax_node(&self) -> SyntaxNode {
21424 match self {
21425 SkippedNode::AttributeList(x) => x.as_syntax_node(),
21426 SkippedNode::VisibilityPub(x) => x.as_syntax_node(),
21427 }
21428 }
21429 fn stable_ptr(&self) -> Self::StablePtr {
21430 SkippedNodePtr(self.as_syntax_node().0.stable_ptr)
21431 }
21432}
21433impl From<&SkippedNode> for SyntaxStablePtrId {
21434 fn from(node: &SkippedNode) -> Self {
21435 node.stable_ptr().untyped()
21436 }
21437}
21438impl SkippedNode {
21439 pub fn is_variant(kind: SyntaxKind) -> bool {
21441 matches!(kind, SyntaxKind::AttributeList | SyntaxKind::VisibilityPub)
21442 }
21443}
21444#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21445pub struct TokenIdentifier {
21446 node: SyntaxNode,
21447}
21448impl Token for TokenIdentifier {
21449 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21450 TokenIdentifierGreen(
21451 Arc::new(GreenNode {
21452 kind: SyntaxKind::TokenIdentifier,
21453 details: GreenNodeDetails::Token(text),
21454 })
21455 .intern(db),
21456 )
21457 }
21458 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21459 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21460 .clone()
21461 }
21462}
21463#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21464pub struct TokenIdentifierPtr(pub SyntaxStablePtrId);
21465impl TypedStablePtr for TokenIdentifierPtr {
21466 type SyntaxNode = TokenIdentifier;
21467 fn untyped(&self) -> SyntaxStablePtrId {
21468 self.0
21469 }
21470 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenIdentifier {
21471 TokenIdentifier::from_syntax_node(db, self.0.lookup(db))
21472 }
21473}
21474impl From<TokenIdentifierPtr> for SyntaxStablePtrId {
21475 fn from(ptr: TokenIdentifierPtr) -> Self {
21476 ptr.untyped()
21477 }
21478}
21479#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21480pub struct TokenIdentifierGreen(pub GreenId);
21481impl TokenIdentifierGreen {
21482 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21483 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21484 }
21485}
21486impl TypedSyntaxNode for TokenIdentifier {
21487 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenIdentifier);
21488 type StablePtr = TokenIdentifierPtr;
21489 type Green = TokenIdentifierGreen;
21490 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21491 TokenIdentifierGreen(
21492 Arc::new(GreenNode {
21493 kind: SyntaxKind::TokenMissing,
21494 details: GreenNodeDetails::Token("".into()),
21495 })
21496 .intern(db),
21497 )
21498 }
21499 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21500 match node.0.green.lookup_intern(db).details {
21501 GreenNodeDetails::Token(_) => Self { node },
21502 GreenNodeDetails::Node { .. } => {
21503 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenIdentifier)
21504 }
21505 }
21506 }
21507 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21508 match node.0.green.lookup_intern(db).details {
21509 GreenNodeDetails::Token(_) => Some(Self { node }),
21510 GreenNodeDetails::Node { .. } => None,
21511 }
21512 }
21513 fn as_syntax_node(&self) -> SyntaxNode {
21514 self.node.clone()
21515 }
21516 fn stable_ptr(&self) -> Self::StablePtr {
21517 TokenIdentifierPtr(self.node.0.stable_ptr)
21518 }
21519}
21520impl From<&TokenIdentifier> for SyntaxStablePtrId {
21521 fn from(node: &TokenIdentifier) -> Self {
21522 node.stable_ptr().untyped()
21523 }
21524}
21525#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21526pub struct TerminalIdentifier {
21527 node: SyntaxNode,
21528 children: Arc<[SyntaxNode]>,
21529}
21530impl Terminal for TerminalIdentifier {
21531 const KIND: SyntaxKind = SyntaxKind::TerminalIdentifier;
21532 type TokenType = TokenIdentifier;
21533 fn new_green(
21534 db: &dyn SyntaxGroup,
21535 leading_trivia: TriviaGreen,
21536 token: <<TerminalIdentifier as Terminal>::TokenType as TypedSyntaxNode>::Green,
21537 trailing_trivia: TriviaGreen,
21538 ) -> Self::Green {
21539 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21540 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21541 TerminalIdentifierGreen(
21542 Arc::new(GreenNode {
21543 kind: SyntaxKind::TerminalIdentifier,
21544 details: GreenNodeDetails::Node { children, width },
21545 })
21546 .intern(db),
21547 )
21548 }
21549 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21550 self.token(db).text(db)
21551 }
21552}
21553impl TerminalIdentifier {
21554 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21555 Trivia::from_syntax_node(db, self.children[0].clone())
21556 }
21557 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenIdentifier {
21558 TokenIdentifier::from_syntax_node(db, self.children[1].clone())
21559 }
21560 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21561 Trivia::from_syntax_node(db, self.children[2].clone())
21562 }
21563}
21564#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21565pub struct TerminalIdentifierPtr(pub SyntaxStablePtrId);
21566impl TerminalIdentifierPtr {}
21567impl TypedStablePtr for TerminalIdentifierPtr {
21568 type SyntaxNode = TerminalIdentifier;
21569 fn untyped(&self) -> SyntaxStablePtrId {
21570 self.0
21571 }
21572 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
21573 TerminalIdentifier::from_syntax_node(db, self.0.lookup(db))
21574 }
21575}
21576impl From<TerminalIdentifierPtr> for SyntaxStablePtrId {
21577 fn from(ptr: TerminalIdentifierPtr) -> Self {
21578 ptr.untyped()
21579 }
21580}
21581#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21582pub struct TerminalIdentifierGreen(pub GreenId);
21583impl TypedSyntaxNode for TerminalIdentifier {
21584 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalIdentifier);
21585 type StablePtr = TerminalIdentifierPtr;
21586 type Green = TerminalIdentifierGreen;
21587 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21588 TerminalIdentifierGreen(
21589 Arc::new(GreenNode {
21590 kind: SyntaxKind::TerminalIdentifier,
21591 details: GreenNodeDetails::Node {
21592 children: vec![
21593 Trivia::missing(db).0,
21594 TokenIdentifier::missing(db).0,
21595 Trivia::missing(db).0,
21596 ],
21597 width: TextWidth::default(),
21598 },
21599 })
21600 .intern(db),
21601 )
21602 }
21603 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21604 let kind = node.kind(db);
21605 assert_eq!(
21606 kind,
21607 SyntaxKind::TerminalIdentifier,
21608 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21609 kind,
21610 SyntaxKind::TerminalIdentifier
21611 );
21612 let children = db.get_children(node.clone());
21613 Self { node, children }
21614 }
21615 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21616 let kind = node.kind(db);
21617 if kind == SyntaxKind::TerminalIdentifier {
21618 Some(Self::from_syntax_node(db, node))
21619 } else {
21620 None
21621 }
21622 }
21623 fn as_syntax_node(&self) -> SyntaxNode {
21624 self.node.clone()
21625 }
21626 fn stable_ptr(&self) -> Self::StablePtr {
21627 TerminalIdentifierPtr(self.node.0.stable_ptr)
21628 }
21629}
21630impl From<&TerminalIdentifier> for SyntaxStablePtrId {
21631 fn from(node: &TerminalIdentifier) -> Self {
21632 node.stable_ptr().untyped()
21633 }
21634}
21635#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21636pub struct TokenLiteralNumber {
21637 node: SyntaxNode,
21638}
21639impl Token for TokenLiteralNumber {
21640 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21641 TokenLiteralNumberGreen(
21642 Arc::new(GreenNode {
21643 kind: SyntaxKind::TokenLiteralNumber,
21644 details: GreenNodeDetails::Token(text),
21645 })
21646 .intern(db),
21647 )
21648 }
21649 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21650 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21651 .clone()
21652 }
21653}
21654#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21655pub struct TokenLiteralNumberPtr(pub SyntaxStablePtrId);
21656impl TypedStablePtr for TokenLiteralNumberPtr {
21657 type SyntaxNode = TokenLiteralNumber;
21658 fn untyped(&self) -> SyntaxStablePtrId {
21659 self.0
21660 }
21661 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLiteralNumber {
21662 TokenLiteralNumber::from_syntax_node(db, self.0.lookup(db))
21663 }
21664}
21665impl From<TokenLiteralNumberPtr> for SyntaxStablePtrId {
21666 fn from(ptr: TokenLiteralNumberPtr) -> Self {
21667 ptr.untyped()
21668 }
21669}
21670#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21671pub struct TokenLiteralNumberGreen(pub GreenId);
21672impl TokenLiteralNumberGreen {
21673 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21674 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21675 }
21676}
21677impl TypedSyntaxNode for TokenLiteralNumber {
21678 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLiteralNumber);
21679 type StablePtr = TokenLiteralNumberPtr;
21680 type Green = TokenLiteralNumberGreen;
21681 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21682 TokenLiteralNumberGreen(
21683 Arc::new(GreenNode {
21684 kind: SyntaxKind::TokenMissing,
21685 details: GreenNodeDetails::Token("".into()),
21686 })
21687 .intern(db),
21688 )
21689 }
21690 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21691 match node.0.green.lookup_intern(db).details {
21692 GreenNodeDetails::Token(_) => Self { node },
21693 GreenNodeDetails::Node { .. } => panic!(
21694 "Expected a token {:?}, not an internal node",
21695 SyntaxKind::TokenLiteralNumber
21696 ),
21697 }
21698 }
21699 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21700 match node.0.green.lookup_intern(db).details {
21701 GreenNodeDetails::Token(_) => Some(Self { node }),
21702 GreenNodeDetails::Node { .. } => None,
21703 }
21704 }
21705 fn as_syntax_node(&self) -> SyntaxNode {
21706 self.node.clone()
21707 }
21708 fn stable_ptr(&self) -> Self::StablePtr {
21709 TokenLiteralNumberPtr(self.node.0.stable_ptr)
21710 }
21711}
21712impl From<&TokenLiteralNumber> for SyntaxStablePtrId {
21713 fn from(node: &TokenLiteralNumber) -> Self {
21714 node.stable_ptr().untyped()
21715 }
21716}
21717#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21718pub struct TerminalLiteralNumber {
21719 node: SyntaxNode,
21720 children: Arc<[SyntaxNode]>,
21721}
21722impl Terminal for TerminalLiteralNumber {
21723 const KIND: SyntaxKind = SyntaxKind::TerminalLiteralNumber;
21724 type TokenType = TokenLiteralNumber;
21725 fn new_green(
21726 db: &dyn SyntaxGroup,
21727 leading_trivia: TriviaGreen,
21728 token: <<TerminalLiteralNumber as Terminal>::TokenType as TypedSyntaxNode>::Green,
21729 trailing_trivia: TriviaGreen,
21730 ) -> Self::Green {
21731 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21732 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21733 TerminalLiteralNumberGreen(
21734 Arc::new(GreenNode {
21735 kind: SyntaxKind::TerminalLiteralNumber,
21736 details: GreenNodeDetails::Node { children, width },
21737 })
21738 .intern(db),
21739 )
21740 }
21741 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21742 self.token(db).text(db)
21743 }
21744}
21745impl TerminalLiteralNumber {
21746 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21747 Trivia::from_syntax_node(db, self.children[0].clone())
21748 }
21749 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLiteralNumber {
21750 TokenLiteralNumber::from_syntax_node(db, self.children[1].clone())
21751 }
21752 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21753 Trivia::from_syntax_node(db, self.children[2].clone())
21754 }
21755}
21756#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21757pub struct TerminalLiteralNumberPtr(pub SyntaxStablePtrId);
21758impl TerminalLiteralNumberPtr {}
21759impl TypedStablePtr for TerminalLiteralNumberPtr {
21760 type SyntaxNode = TerminalLiteralNumber;
21761 fn untyped(&self) -> SyntaxStablePtrId {
21762 self.0
21763 }
21764 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLiteralNumber {
21765 TerminalLiteralNumber::from_syntax_node(db, self.0.lookup(db))
21766 }
21767}
21768impl From<TerminalLiteralNumberPtr> for SyntaxStablePtrId {
21769 fn from(ptr: TerminalLiteralNumberPtr) -> Self {
21770 ptr.untyped()
21771 }
21772}
21773#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21774pub struct TerminalLiteralNumberGreen(pub GreenId);
21775impl TypedSyntaxNode for TerminalLiteralNumber {
21776 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLiteralNumber);
21777 type StablePtr = TerminalLiteralNumberPtr;
21778 type Green = TerminalLiteralNumberGreen;
21779 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21780 TerminalLiteralNumberGreen(
21781 Arc::new(GreenNode {
21782 kind: SyntaxKind::TerminalLiteralNumber,
21783 details: GreenNodeDetails::Node {
21784 children: vec![
21785 Trivia::missing(db).0,
21786 TokenLiteralNumber::missing(db).0,
21787 Trivia::missing(db).0,
21788 ],
21789 width: TextWidth::default(),
21790 },
21791 })
21792 .intern(db),
21793 )
21794 }
21795 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21796 let kind = node.kind(db);
21797 assert_eq!(
21798 kind,
21799 SyntaxKind::TerminalLiteralNumber,
21800 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21801 kind,
21802 SyntaxKind::TerminalLiteralNumber
21803 );
21804 let children = db.get_children(node.clone());
21805 Self { node, children }
21806 }
21807 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21808 let kind = node.kind(db);
21809 if kind == SyntaxKind::TerminalLiteralNumber {
21810 Some(Self::from_syntax_node(db, node))
21811 } else {
21812 None
21813 }
21814 }
21815 fn as_syntax_node(&self) -> SyntaxNode {
21816 self.node.clone()
21817 }
21818 fn stable_ptr(&self) -> Self::StablePtr {
21819 TerminalLiteralNumberPtr(self.node.0.stable_ptr)
21820 }
21821}
21822impl From<&TerminalLiteralNumber> for SyntaxStablePtrId {
21823 fn from(node: &TerminalLiteralNumber) -> Self {
21824 node.stable_ptr().untyped()
21825 }
21826}
21827#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21828pub struct TokenShortString {
21829 node: SyntaxNode,
21830}
21831impl Token for TokenShortString {
21832 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21833 TokenShortStringGreen(
21834 Arc::new(GreenNode {
21835 kind: SyntaxKind::TokenShortString,
21836 details: GreenNodeDetails::Token(text),
21837 })
21838 .intern(db),
21839 )
21840 }
21841 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21842 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21843 .clone()
21844 }
21845}
21846#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21847pub struct TokenShortStringPtr(pub SyntaxStablePtrId);
21848impl TypedStablePtr for TokenShortStringPtr {
21849 type SyntaxNode = TokenShortString;
21850 fn untyped(&self) -> SyntaxStablePtrId {
21851 self.0
21852 }
21853 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenShortString {
21854 TokenShortString::from_syntax_node(db, self.0.lookup(db))
21855 }
21856}
21857impl From<TokenShortStringPtr> for SyntaxStablePtrId {
21858 fn from(ptr: TokenShortStringPtr) -> Self {
21859 ptr.untyped()
21860 }
21861}
21862#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21863pub struct TokenShortStringGreen(pub GreenId);
21864impl TokenShortStringGreen {
21865 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21866 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21867 }
21868}
21869impl TypedSyntaxNode for TokenShortString {
21870 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenShortString);
21871 type StablePtr = TokenShortStringPtr;
21872 type Green = TokenShortStringGreen;
21873 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21874 TokenShortStringGreen(
21875 Arc::new(GreenNode {
21876 kind: SyntaxKind::TokenMissing,
21877 details: GreenNodeDetails::Token("".into()),
21878 })
21879 .intern(db),
21880 )
21881 }
21882 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21883 match node.0.green.lookup_intern(db).details {
21884 GreenNodeDetails::Token(_) => Self { node },
21885 GreenNodeDetails::Node { .. } => {
21886 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenShortString)
21887 }
21888 }
21889 }
21890 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21891 match node.0.green.lookup_intern(db).details {
21892 GreenNodeDetails::Token(_) => Some(Self { node }),
21893 GreenNodeDetails::Node { .. } => None,
21894 }
21895 }
21896 fn as_syntax_node(&self) -> SyntaxNode {
21897 self.node.clone()
21898 }
21899 fn stable_ptr(&self) -> Self::StablePtr {
21900 TokenShortStringPtr(self.node.0.stable_ptr)
21901 }
21902}
21903impl From<&TokenShortString> for SyntaxStablePtrId {
21904 fn from(node: &TokenShortString) -> Self {
21905 node.stable_ptr().untyped()
21906 }
21907}
21908#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21909pub struct TerminalShortString {
21910 node: SyntaxNode,
21911 children: Arc<[SyntaxNode]>,
21912}
21913impl Terminal for TerminalShortString {
21914 const KIND: SyntaxKind = SyntaxKind::TerminalShortString;
21915 type TokenType = TokenShortString;
21916 fn new_green(
21917 db: &dyn SyntaxGroup,
21918 leading_trivia: TriviaGreen,
21919 token: <<TerminalShortString as Terminal>::TokenType as TypedSyntaxNode>::Green,
21920 trailing_trivia: TriviaGreen,
21921 ) -> Self::Green {
21922 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21923 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21924 TerminalShortStringGreen(
21925 Arc::new(GreenNode {
21926 kind: SyntaxKind::TerminalShortString,
21927 details: GreenNodeDetails::Node { children, width },
21928 })
21929 .intern(db),
21930 )
21931 }
21932 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21933 self.token(db).text(db)
21934 }
21935}
21936impl TerminalShortString {
21937 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21938 Trivia::from_syntax_node(db, self.children[0].clone())
21939 }
21940 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenShortString {
21941 TokenShortString::from_syntax_node(db, self.children[1].clone())
21942 }
21943 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21944 Trivia::from_syntax_node(db, self.children[2].clone())
21945 }
21946}
21947#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21948pub struct TerminalShortStringPtr(pub SyntaxStablePtrId);
21949impl TerminalShortStringPtr {}
21950impl TypedStablePtr for TerminalShortStringPtr {
21951 type SyntaxNode = TerminalShortString;
21952 fn untyped(&self) -> SyntaxStablePtrId {
21953 self.0
21954 }
21955 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalShortString {
21956 TerminalShortString::from_syntax_node(db, self.0.lookup(db))
21957 }
21958}
21959impl From<TerminalShortStringPtr> for SyntaxStablePtrId {
21960 fn from(ptr: TerminalShortStringPtr) -> Self {
21961 ptr.untyped()
21962 }
21963}
21964#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21965pub struct TerminalShortStringGreen(pub GreenId);
21966impl TypedSyntaxNode for TerminalShortString {
21967 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalShortString);
21968 type StablePtr = TerminalShortStringPtr;
21969 type Green = TerminalShortStringGreen;
21970 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21971 TerminalShortStringGreen(
21972 Arc::new(GreenNode {
21973 kind: SyntaxKind::TerminalShortString,
21974 details: GreenNodeDetails::Node {
21975 children: vec![
21976 Trivia::missing(db).0,
21977 TokenShortString::missing(db).0,
21978 Trivia::missing(db).0,
21979 ],
21980 width: TextWidth::default(),
21981 },
21982 })
21983 .intern(db),
21984 )
21985 }
21986 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21987 let kind = node.kind(db);
21988 assert_eq!(
21989 kind,
21990 SyntaxKind::TerminalShortString,
21991 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21992 kind,
21993 SyntaxKind::TerminalShortString
21994 );
21995 let children = db.get_children(node.clone());
21996 Self { node, children }
21997 }
21998 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
21999 let kind = node.kind(db);
22000 if kind == SyntaxKind::TerminalShortString {
22001 Some(Self::from_syntax_node(db, node))
22002 } else {
22003 None
22004 }
22005 }
22006 fn as_syntax_node(&self) -> SyntaxNode {
22007 self.node.clone()
22008 }
22009 fn stable_ptr(&self) -> Self::StablePtr {
22010 TerminalShortStringPtr(self.node.0.stable_ptr)
22011 }
22012}
22013impl From<&TerminalShortString> for SyntaxStablePtrId {
22014 fn from(node: &TerminalShortString) -> Self {
22015 node.stable_ptr().untyped()
22016 }
22017}
22018#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22019pub struct TokenString {
22020 node: SyntaxNode,
22021}
22022impl Token for TokenString {
22023 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22024 TokenStringGreen(
22025 Arc::new(GreenNode {
22026 kind: SyntaxKind::TokenString,
22027 details: GreenNodeDetails::Token(text),
22028 })
22029 .intern(db),
22030 )
22031 }
22032 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22033 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22034 .clone()
22035 }
22036}
22037#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22038pub struct TokenStringPtr(pub SyntaxStablePtrId);
22039impl TypedStablePtr for TokenStringPtr {
22040 type SyntaxNode = TokenString;
22041 fn untyped(&self) -> SyntaxStablePtrId {
22042 self.0
22043 }
22044 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenString {
22045 TokenString::from_syntax_node(db, self.0.lookup(db))
22046 }
22047}
22048impl From<TokenStringPtr> for SyntaxStablePtrId {
22049 fn from(ptr: TokenStringPtr) -> Self {
22050 ptr.untyped()
22051 }
22052}
22053#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22054pub struct TokenStringGreen(pub GreenId);
22055impl TokenStringGreen {
22056 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22057 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22058 }
22059}
22060impl TypedSyntaxNode for TokenString {
22061 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenString);
22062 type StablePtr = TokenStringPtr;
22063 type Green = TokenStringGreen;
22064 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22065 TokenStringGreen(
22066 Arc::new(GreenNode {
22067 kind: SyntaxKind::TokenMissing,
22068 details: GreenNodeDetails::Token("".into()),
22069 })
22070 .intern(db),
22071 )
22072 }
22073 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22074 match node.0.green.lookup_intern(db).details {
22075 GreenNodeDetails::Token(_) => Self { node },
22076 GreenNodeDetails::Node { .. } => {
22077 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenString)
22078 }
22079 }
22080 }
22081 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22082 match node.0.green.lookup_intern(db).details {
22083 GreenNodeDetails::Token(_) => Some(Self { node }),
22084 GreenNodeDetails::Node { .. } => None,
22085 }
22086 }
22087 fn as_syntax_node(&self) -> SyntaxNode {
22088 self.node.clone()
22089 }
22090 fn stable_ptr(&self) -> Self::StablePtr {
22091 TokenStringPtr(self.node.0.stable_ptr)
22092 }
22093}
22094impl From<&TokenString> for SyntaxStablePtrId {
22095 fn from(node: &TokenString) -> Self {
22096 node.stable_ptr().untyped()
22097 }
22098}
22099#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22100pub struct TerminalString {
22101 node: SyntaxNode,
22102 children: Arc<[SyntaxNode]>,
22103}
22104impl Terminal for TerminalString {
22105 const KIND: SyntaxKind = SyntaxKind::TerminalString;
22106 type TokenType = TokenString;
22107 fn new_green(
22108 db: &dyn SyntaxGroup,
22109 leading_trivia: TriviaGreen,
22110 token: <<TerminalString as Terminal>::TokenType as TypedSyntaxNode>::Green,
22111 trailing_trivia: TriviaGreen,
22112 ) -> Self::Green {
22113 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22114 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22115 TerminalStringGreen(
22116 Arc::new(GreenNode {
22117 kind: SyntaxKind::TerminalString,
22118 details: GreenNodeDetails::Node { children, width },
22119 })
22120 .intern(db),
22121 )
22122 }
22123 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22124 self.token(db).text(db)
22125 }
22126}
22127impl TerminalString {
22128 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22129 Trivia::from_syntax_node(db, self.children[0].clone())
22130 }
22131 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenString {
22132 TokenString::from_syntax_node(db, self.children[1].clone())
22133 }
22134 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22135 Trivia::from_syntax_node(db, self.children[2].clone())
22136 }
22137}
22138#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22139pub struct TerminalStringPtr(pub SyntaxStablePtrId);
22140impl TerminalStringPtr {}
22141impl TypedStablePtr for TerminalStringPtr {
22142 type SyntaxNode = TerminalString;
22143 fn untyped(&self) -> SyntaxStablePtrId {
22144 self.0
22145 }
22146 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalString {
22147 TerminalString::from_syntax_node(db, self.0.lookup(db))
22148 }
22149}
22150impl From<TerminalStringPtr> for SyntaxStablePtrId {
22151 fn from(ptr: TerminalStringPtr) -> Self {
22152 ptr.untyped()
22153 }
22154}
22155#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22156pub struct TerminalStringGreen(pub GreenId);
22157impl TypedSyntaxNode for TerminalString {
22158 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalString);
22159 type StablePtr = TerminalStringPtr;
22160 type Green = TerminalStringGreen;
22161 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22162 TerminalStringGreen(
22163 Arc::new(GreenNode {
22164 kind: SyntaxKind::TerminalString,
22165 details: GreenNodeDetails::Node {
22166 children: vec![
22167 Trivia::missing(db).0,
22168 TokenString::missing(db).0,
22169 Trivia::missing(db).0,
22170 ],
22171 width: TextWidth::default(),
22172 },
22173 })
22174 .intern(db),
22175 )
22176 }
22177 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22178 let kind = node.kind(db);
22179 assert_eq!(
22180 kind,
22181 SyntaxKind::TerminalString,
22182 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22183 kind,
22184 SyntaxKind::TerminalString
22185 );
22186 let children = db.get_children(node.clone());
22187 Self { node, children }
22188 }
22189 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22190 let kind = node.kind(db);
22191 if kind == SyntaxKind::TerminalString {
22192 Some(Self::from_syntax_node(db, node))
22193 } else {
22194 None
22195 }
22196 }
22197 fn as_syntax_node(&self) -> SyntaxNode {
22198 self.node.clone()
22199 }
22200 fn stable_ptr(&self) -> Self::StablePtr {
22201 TerminalStringPtr(self.node.0.stable_ptr)
22202 }
22203}
22204impl From<&TerminalString> for SyntaxStablePtrId {
22205 fn from(node: &TerminalString) -> Self {
22206 node.stable_ptr().untyped()
22207 }
22208}
22209#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22210pub struct TokenAs {
22211 node: SyntaxNode,
22212}
22213impl Token for TokenAs {
22214 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22215 TokenAsGreen(
22216 Arc::new(GreenNode {
22217 kind: SyntaxKind::TokenAs,
22218 details: GreenNodeDetails::Token(text),
22219 })
22220 .intern(db),
22221 )
22222 }
22223 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22224 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22225 .clone()
22226 }
22227}
22228#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22229pub struct TokenAsPtr(pub SyntaxStablePtrId);
22230impl TypedStablePtr for TokenAsPtr {
22231 type SyntaxNode = TokenAs;
22232 fn untyped(&self) -> SyntaxStablePtrId {
22233 self.0
22234 }
22235 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAs {
22236 TokenAs::from_syntax_node(db, self.0.lookup(db))
22237 }
22238}
22239impl From<TokenAsPtr> for SyntaxStablePtrId {
22240 fn from(ptr: TokenAsPtr) -> Self {
22241 ptr.untyped()
22242 }
22243}
22244#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22245pub struct TokenAsGreen(pub GreenId);
22246impl TokenAsGreen {
22247 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22248 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22249 }
22250}
22251impl TypedSyntaxNode for TokenAs {
22252 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAs);
22253 type StablePtr = TokenAsPtr;
22254 type Green = TokenAsGreen;
22255 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22256 TokenAsGreen(
22257 Arc::new(GreenNode {
22258 kind: SyntaxKind::TokenMissing,
22259 details: GreenNodeDetails::Token("".into()),
22260 })
22261 .intern(db),
22262 )
22263 }
22264 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22265 match node.0.green.lookup_intern(db).details {
22266 GreenNodeDetails::Token(_) => Self { node },
22267 GreenNodeDetails::Node { .. } => {
22268 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAs)
22269 }
22270 }
22271 }
22272 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22273 match node.0.green.lookup_intern(db).details {
22274 GreenNodeDetails::Token(_) => Some(Self { node }),
22275 GreenNodeDetails::Node { .. } => None,
22276 }
22277 }
22278 fn as_syntax_node(&self) -> SyntaxNode {
22279 self.node.clone()
22280 }
22281 fn stable_ptr(&self) -> Self::StablePtr {
22282 TokenAsPtr(self.node.0.stable_ptr)
22283 }
22284}
22285impl From<&TokenAs> for SyntaxStablePtrId {
22286 fn from(node: &TokenAs) -> Self {
22287 node.stable_ptr().untyped()
22288 }
22289}
22290#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22291pub struct TerminalAs {
22292 node: SyntaxNode,
22293 children: Arc<[SyntaxNode]>,
22294}
22295impl Terminal for TerminalAs {
22296 const KIND: SyntaxKind = SyntaxKind::TerminalAs;
22297 type TokenType = TokenAs;
22298 fn new_green(
22299 db: &dyn SyntaxGroup,
22300 leading_trivia: TriviaGreen,
22301 token: <<TerminalAs as Terminal>::TokenType as TypedSyntaxNode>::Green,
22302 trailing_trivia: TriviaGreen,
22303 ) -> Self::Green {
22304 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22305 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22306 TerminalAsGreen(
22307 Arc::new(GreenNode {
22308 kind: SyntaxKind::TerminalAs,
22309 details: GreenNodeDetails::Node { children, width },
22310 })
22311 .intern(db),
22312 )
22313 }
22314 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22315 self.token(db).text(db)
22316 }
22317}
22318impl TerminalAs {
22319 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22320 Trivia::from_syntax_node(db, self.children[0].clone())
22321 }
22322 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAs {
22323 TokenAs::from_syntax_node(db, self.children[1].clone())
22324 }
22325 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22326 Trivia::from_syntax_node(db, self.children[2].clone())
22327 }
22328}
22329#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22330pub struct TerminalAsPtr(pub SyntaxStablePtrId);
22331impl TerminalAsPtr {}
22332impl TypedStablePtr for TerminalAsPtr {
22333 type SyntaxNode = TerminalAs;
22334 fn untyped(&self) -> SyntaxStablePtrId {
22335 self.0
22336 }
22337 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAs {
22338 TerminalAs::from_syntax_node(db, self.0.lookup(db))
22339 }
22340}
22341impl From<TerminalAsPtr> for SyntaxStablePtrId {
22342 fn from(ptr: TerminalAsPtr) -> Self {
22343 ptr.untyped()
22344 }
22345}
22346#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22347pub struct TerminalAsGreen(pub GreenId);
22348impl TypedSyntaxNode for TerminalAs {
22349 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAs);
22350 type StablePtr = TerminalAsPtr;
22351 type Green = TerminalAsGreen;
22352 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22353 TerminalAsGreen(
22354 Arc::new(GreenNode {
22355 kind: SyntaxKind::TerminalAs,
22356 details: GreenNodeDetails::Node {
22357 children: vec![
22358 Trivia::missing(db).0,
22359 TokenAs::missing(db).0,
22360 Trivia::missing(db).0,
22361 ],
22362 width: TextWidth::default(),
22363 },
22364 })
22365 .intern(db),
22366 )
22367 }
22368 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22369 let kind = node.kind(db);
22370 assert_eq!(
22371 kind,
22372 SyntaxKind::TerminalAs,
22373 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22374 kind,
22375 SyntaxKind::TerminalAs
22376 );
22377 let children = db.get_children(node.clone());
22378 Self { node, children }
22379 }
22380 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22381 let kind = node.kind(db);
22382 if kind == SyntaxKind::TerminalAs { Some(Self::from_syntax_node(db, node)) } else { None }
22383 }
22384 fn as_syntax_node(&self) -> SyntaxNode {
22385 self.node.clone()
22386 }
22387 fn stable_ptr(&self) -> Self::StablePtr {
22388 TerminalAsPtr(self.node.0.stable_ptr)
22389 }
22390}
22391impl From<&TerminalAs> for SyntaxStablePtrId {
22392 fn from(node: &TerminalAs) -> Self {
22393 node.stable_ptr().untyped()
22394 }
22395}
22396#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22397pub struct TokenConst {
22398 node: SyntaxNode,
22399}
22400impl Token for TokenConst {
22401 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22402 TokenConstGreen(
22403 Arc::new(GreenNode {
22404 kind: SyntaxKind::TokenConst,
22405 details: GreenNodeDetails::Token(text),
22406 })
22407 .intern(db),
22408 )
22409 }
22410 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22411 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22412 .clone()
22413 }
22414}
22415#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22416pub struct TokenConstPtr(pub SyntaxStablePtrId);
22417impl TypedStablePtr for TokenConstPtr {
22418 type SyntaxNode = TokenConst;
22419 fn untyped(&self) -> SyntaxStablePtrId {
22420 self.0
22421 }
22422 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenConst {
22423 TokenConst::from_syntax_node(db, self.0.lookup(db))
22424 }
22425}
22426impl From<TokenConstPtr> for SyntaxStablePtrId {
22427 fn from(ptr: TokenConstPtr) -> Self {
22428 ptr.untyped()
22429 }
22430}
22431#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22432pub struct TokenConstGreen(pub GreenId);
22433impl TokenConstGreen {
22434 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22435 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22436 }
22437}
22438impl TypedSyntaxNode for TokenConst {
22439 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenConst);
22440 type StablePtr = TokenConstPtr;
22441 type Green = TokenConstGreen;
22442 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22443 TokenConstGreen(
22444 Arc::new(GreenNode {
22445 kind: SyntaxKind::TokenMissing,
22446 details: GreenNodeDetails::Token("".into()),
22447 })
22448 .intern(db),
22449 )
22450 }
22451 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22452 match node.0.green.lookup_intern(db).details {
22453 GreenNodeDetails::Token(_) => Self { node },
22454 GreenNodeDetails::Node { .. } => {
22455 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenConst)
22456 }
22457 }
22458 }
22459 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22460 match node.0.green.lookup_intern(db).details {
22461 GreenNodeDetails::Token(_) => Some(Self { node }),
22462 GreenNodeDetails::Node { .. } => None,
22463 }
22464 }
22465 fn as_syntax_node(&self) -> SyntaxNode {
22466 self.node.clone()
22467 }
22468 fn stable_ptr(&self) -> Self::StablePtr {
22469 TokenConstPtr(self.node.0.stable_ptr)
22470 }
22471}
22472impl From<&TokenConst> for SyntaxStablePtrId {
22473 fn from(node: &TokenConst) -> Self {
22474 node.stable_ptr().untyped()
22475 }
22476}
22477#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22478pub struct TerminalConst {
22479 node: SyntaxNode,
22480 children: Arc<[SyntaxNode]>,
22481}
22482impl Terminal for TerminalConst {
22483 const KIND: SyntaxKind = SyntaxKind::TerminalConst;
22484 type TokenType = TokenConst;
22485 fn new_green(
22486 db: &dyn SyntaxGroup,
22487 leading_trivia: TriviaGreen,
22488 token: <<TerminalConst as Terminal>::TokenType as TypedSyntaxNode>::Green,
22489 trailing_trivia: TriviaGreen,
22490 ) -> Self::Green {
22491 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22492 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22493 TerminalConstGreen(
22494 Arc::new(GreenNode {
22495 kind: SyntaxKind::TerminalConst,
22496 details: GreenNodeDetails::Node { children, width },
22497 })
22498 .intern(db),
22499 )
22500 }
22501 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22502 self.token(db).text(db)
22503 }
22504}
22505impl TerminalConst {
22506 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22507 Trivia::from_syntax_node(db, self.children[0].clone())
22508 }
22509 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenConst {
22510 TokenConst::from_syntax_node(db, self.children[1].clone())
22511 }
22512 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22513 Trivia::from_syntax_node(db, self.children[2].clone())
22514 }
22515}
22516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22517pub struct TerminalConstPtr(pub SyntaxStablePtrId);
22518impl TerminalConstPtr {}
22519impl TypedStablePtr for TerminalConstPtr {
22520 type SyntaxNode = TerminalConst;
22521 fn untyped(&self) -> SyntaxStablePtrId {
22522 self.0
22523 }
22524 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalConst {
22525 TerminalConst::from_syntax_node(db, self.0.lookup(db))
22526 }
22527}
22528impl From<TerminalConstPtr> for SyntaxStablePtrId {
22529 fn from(ptr: TerminalConstPtr) -> Self {
22530 ptr.untyped()
22531 }
22532}
22533#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22534pub struct TerminalConstGreen(pub GreenId);
22535impl TypedSyntaxNode for TerminalConst {
22536 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalConst);
22537 type StablePtr = TerminalConstPtr;
22538 type Green = TerminalConstGreen;
22539 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22540 TerminalConstGreen(
22541 Arc::new(GreenNode {
22542 kind: SyntaxKind::TerminalConst,
22543 details: GreenNodeDetails::Node {
22544 children: vec![
22545 Trivia::missing(db).0,
22546 TokenConst::missing(db).0,
22547 Trivia::missing(db).0,
22548 ],
22549 width: TextWidth::default(),
22550 },
22551 })
22552 .intern(db),
22553 )
22554 }
22555 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22556 let kind = node.kind(db);
22557 assert_eq!(
22558 kind,
22559 SyntaxKind::TerminalConst,
22560 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22561 kind,
22562 SyntaxKind::TerminalConst
22563 );
22564 let children = db.get_children(node.clone());
22565 Self { node, children }
22566 }
22567 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22568 let kind = node.kind(db);
22569 if kind == SyntaxKind::TerminalConst {
22570 Some(Self::from_syntax_node(db, node))
22571 } else {
22572 None
22573 }
22574 }
22575 fn as_syntax_node(&self) -> SyntaxNode {
22576 self.node.clone()
22577 }
22578 fn stable_ptr(&self) -> Self::StablePtr {
22579 TerminalConstPtr(self.node.0.stable_ptr)
22580 }
22581}
22582impl From<&TerminalConst> for SyntaxStablePtrId {
22583 fn from(node: &TerminalConst) -> Self {
22584 node.stable_ptr().untyped()
22585 }
22586}
22587#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22588pub struct TokenElse {
22589 node: SyntaxNode,
22590}
22591impl Token for TokenElse {
22592 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22593 TokenElseGreen(
22594 Arc::new(GreenNode {
22595 kind: SyntaxKind::TokenElse,
22596 details: GreenNodeDetails::Token(text),
22597 })
22598 .intern(db),
22599 )
22600 }
22601 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22602 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22603 .clone()
22604 }
22605}
22606#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22607pub struct TokenElsePtr(pub SyntaxStablePtrId);
22608impl TypedStablePtr for TokenElsePtr {
22609 type SyntaxNode = TokenElse;
22610 fn untyped(&self) -> SyntaxStablePtrId {
22611 self.0
22612 }
22613 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenElse {
22614 TokenElse::from_syntax_node(db, self.0.lookup(db))
22615 }
22616}
22617impl From<TokenElsePtr> for SyntaxStablePtrId {
22618 fn from(ptr: TokenElsePtr) -> Self {
22619 ptr.untyped()
22620 }
22621}
22622#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22623pub struct TokenElseGreen(pub GreenId);
22624impl TokenElseGreen {
22625 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22626 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22627 }
22628}
22629impl TypedSyntaxNode for TokenElse {
22630 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenElse);
22631 type StablePtr = TokenElsePtr;
22632 type Green = TokenElseGreen;
22633 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22634 TokenElseGreen(
22635 Arc::new(GreenNode {
22636 kind: SyntaxKind::TokenMissing,
22637 details: GreenNodeDetails::Token("".into()),
22638 })
22639 .intern(db),
22640 )
22641 }
22642 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22643 match node.0.green.lookup_intern(db).details {
22644 GreenNodeDetails::Token(_) => Self { node },
22645 GreenNodeDetails::Node { .. } => {
22646 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenElse)
22647 }
22648 }
22649 }
22650 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22651 match node.0.green.lookup_intern(db).details {
22652 GreenNodeDetails::Token(_) => Some(Self { node }),
22653 GreenNodeDetails::Node { .. } => None,
22654 }
22655 }
22656 fn as_syntax_node(&self) -> SyntaxNode {
22657 self.node.clone()
22658 }
22659 fn stable_ptr(&self) -> Self::StablePtr {
22660 TokenElsePtr(self.node.0.stable_ptr)
22661 }
22662}
22663impl From<&TokenElse> for SyntaxStablePtrId {
22664 fn from(node: &TokenElse) -> Self {
22665 node.stable_ptr().untyped()
22666 }
22667}
22668#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22669pub struct TerminalElse {
22670 node: SyntaxNode,
22671 children: Arc<[SyntaxNode]>,
22672}
22673impl Terminal for TerminalElse {
22674 const KIND: SyntaxKind = SyntaxKind::TerminalElse;
22675 type TokenType = TokenElse;
22676 fn new_green(
22677 db: &dyn SyntaxGroup,
22678 leading_trivia: TriviaGreen,
22679 token: <<TerminalElse as Terminal>::TokenType as TypedSyntaxNode>::Green,
22680 trailing_trivia: TriviaGreen,
22681 ) -> Self::Green {
22682 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22683 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22684 TerminalElseGreen(
22685 Arc::new(GreenNode {
22686 kind: SyntaxKind::TerminalElse,
22687 details: GreenNodeDetails::Node { children, width },
22688 })
22689 .intern(db),
22690 )
22691 }
22692 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22693 self.token(db).text(db)
22694 }
22695}
22696impl TerminalElse {
22697 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22698 Trivia::from_syntax_node(db, self.children[0].clone())
22699 }
22700 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenElse {
22701 TokenElse::from_syntax_node(db, self.children[1].clone())
22702 }
22703 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22704 Trivia::from_syntax_node(db, self.children[2].clone())
22705 }
22706}
22707#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22708pub struct TerminalElsePtr(pub SyntaxStablePtrId);
22709impl TerminalElsePtr {}
22710impl TypedStablePtr for TerminalElsePtr {
22711 type SyntaxNode = TerminalElse;
22712 fn untyped(&self) -> SyntaxStablePtrId {
22713 self.0
22714 }
22715 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalElse {
22716 TerminalElse::from_syntax_node(db, self.0.lookup(db))
22717 }
22718}
22719impl From<TerminalElsePtr> for SyntaxStablePtrId {
22720 fn from(ptr: TerminalElsePtr) -> Self {
22721 ptr.untyped()
22722 }
22723}
22724#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22725pub struct TerminalElseGreen(pub GreenId);
22726impl TypedSyntaxNode for TerminalElse {
22727 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalElse);
22728 type StablePtr = TerminalElsePtr;
22729 type Green = TerminalElseGreen;
22730 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22731 TerminalElseGreen(
22732 Arc::new(GreenNode {
22733 kind: SyntaxKind::TerminalElse,
22734 details: GreenNodeDetails::Node {
22735 children: vec![
22736 Trivia::missing(db).0,
22737 TokenElse::missing(db).0,
22738 Trivia::missing(db).0,
22739 ],
22740 width: TextWidth::default(),
22741 },
22742 })
22743 .intern(db),
22744 )
22745 }
22746 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22747 let kind = node.kind(db);
22748 assert_eq!(
22749 kind,
22750 SyntaxKind::TerminalElse,
22751 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22752 kind,
22753 SyntaxKind::TerminalElse
22754 );
22755 let children = db.get_children(node.clone());
22756 Self { node, children }
22757 }
22758 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22759 let kind = node.kind(db);
22760 if kind == SyntaxKind::TerminalElse { Some(Self::from_syntax_node(db, node)) } else { None }
22761 }
22762 fn as_syntax_node(&self) -> SyntaxNode {
22763 self.node.clone()
22764 }
22765 fn stable_ptr(&self) -> Self::StablePtr {
22766 TerminalElsePtr(self.node.0.stable_ptr)
22767 }
22768}
22769impl From<&TerminalElse> for SyntaxStablePtrId {
22770 fn from(node: &TerminalElse) -> Self {
22771 node.stable_ptr().untyped()
22772 }
22773}
22774#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22775pub struct TokenEnum {
22776 node: SyntaxNode,
22777}
22778impl Token for TokenEnum {
22779 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22780 TokenEnumGreen(
22781 Arc::new(GreenNode {
22782 kind: SyntaxKind::TokenEnum,
22783 details: GreenNodeDetails::Token(text),
22784 })
22785 .intern(db),
22786 )
22787 }
22788 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22789 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22790 .clone()
22791 }
22792}
22793#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22794pub struct TokenEnumPtr(pub SyntaxStablePtrId);
22795impl TypedStablePtr for TokenEnumPtr {
22796 type SyntaxNode = TokenEnum;
22797 fn untyped(&self) -> SyntaxStablePtrId {
22798 self.0
22799 }
22800 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEnum {
22801 TokenEnum::from_syntax_node(db, self.0.lookup(db))
22802 }
22803}
22804impl From<TokenEnumPtr> for SyntaxStablePtrId {
22805 fn from(ptr: TokenEnumPtr) -> Self {
22806 ptr.untyped()
22807 }
22808}
22809#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22810pub struct TokenEnumGreen(pub GreenId);
22811impl TokenEnumGreen {
22812 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22813 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22814 }
22815}
22816impl TypedSyntaxNode for TokenEnum {
22817 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEnum);
22818 type StablePtr = TokenEnumPtr;
22819 type Green = TokenEnumGreen;
22820 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22821 TokenEnumGreen(
22822 Arc::new(GreenNode {
22823 kind: SyntaxKind::TokenMissing,
22824 details: GreenNodeDetails::Token("".into()),
22825 })
22826 .intern(db),
22827 )
22828 }
22829 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22830 match node.0.green.lookup_intern(db).details {
22831 GreenNodeDetails::Token(_) => Self { node },
22832 GreenNodeDetails::Node { .. } => {
22833 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEnum)
22834 }
22835 }
22836 }
22837 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22838 match node.0.green.lookup_intern(db).details {
22839 GreenNodeDetails::Token(_) => Some(Self { node }),
22840 GreenNodeDetails::Node { .. } => None,
22841 }
22842 }
22843 fn as_syntax_node(&self) -> SyntaxNode {
22844 self.node.clone()
22845 }
22846 fn stable_ptr(&self) -> Self::StablePtr {
22847 TokenEnumPtr(self.node.0.stable_ptr)
22848 }
22849}
22850impl From<&TokenEnum> for SyntaxStablePtrId {
22851 fn from(node: &TokenEnum) -> Self {
22852 node.stable_ptr().untyped()
22853 }
22854}
22855#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22856pub struct TerminalEnum {
22857 node: SyntaxNode,
22858 children: Arc<[SyntaxNode]>,
22859}
22860impl Terminal for TerminalEnum {
22861 const KIND: SyntaxKind = SyntaxKind::TerminalEnum;
22862 type TokenType = TokenEnum;
22863 fn new_green(
22864 db: &dyn SyntaxGroup,
22865 leading_trivia: TriviaGreen,
22866 token: <<TerminalEnum as Terminal>::TokenType as TypedSyntaxNode>::Green,
22867 trailing_trivia: TriviaGreen,
22868 ) -> Self::Green {
22869 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22870 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22871 TerminalEnumGreen(
22872 Arc::new(GreenNode {
22873 kind: SyntaxKind::TerminalEnum,
22874 details: GreenNodeDetails::Node { children, width },
22875 })
22876 .intern(db),
22877 )
22878 }
22879 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22880 self.token(db).text(db)
22881 }
22882}
22883impl TerminalEnum {
22884 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22885 Trivia::from_syntax_node(db, self.children[0].clone())
22886 }
22887 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEnum {
22888 TokenEnum::from_syntax_node(db, self.children[1].clone())
22889 }
22890 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22891 Trivia::from_syntax_node(db, self.children[2].clone())
22892 }
22893}
22894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22895pub struct TerminalEnumPtr(pub SyntaxStablePtrId);
22896impl TerminalEnumPtr {}
22897impl TypedStablePtr for TerminalEnumPtr {
22898 type SyntaxNode = TerminalEnum;
22899 fn untyped(&self) -> SyntaxStablePtrId {
22900 self.0
22901 }
22902 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEnum {
22903 TerminalEnum::from_syntax_node(db, self.0.lookup(db))
22904 }
22905}
22906impl From<TerminalEnumPtr> for SyntaxStablePtrId {
22907 fn from(ptr: TerminalEnumPtr) -> Self {
22908 ptr.untyped()
22909 }
22910}
22911#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22912pub struct TerminalEnumGreen(pub GreenId);
22913impl TypedSyntaxNode for TerminalEnum {
22914 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEnum);
22915 type StablePtr = TerminalEnumPtr;
22916 type Green = TerminalEnumGreen;
22917 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22918 TerminalEnumGreen(
22919 Arc::new(GreenNode {
22920 kind: SyntaxKind::TerminalEnum,
22921 details: GreenNodeDetails::Node {
22922 children: vec![
22923 Trivia::missing(db).0,
22924 TokenEnum::missing(db).0,
22925 Trivia::missing(db).0,
22926 ],
22927 width: TextWidth::default(),
22928 },
22929 })
22930 .intern(db),
22931 )
22932 }
22933 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22934 let kind = node.kind(db);
22935 assert_eq!(
22936 kind,
22937 SyntaxKind::TerminalEnum,
22938 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22939 kind,
22940 SyntaxKind::TerminalEnum
22941 );
22942 let children = db.get_children(node.clone());
22943 Self { node, children }
22944 }
22945 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
22946 let kind = node.kind(db);
22947 if kind == SyntaxKind::TerminalEnum { Some(Self::from_syntax_node(db, node)) } else { None }
22948 }
22949 fn as_syntax_node(&self) -> SyntaxNode {
22950 self.node.clone()
22951 }
22952 fn stable_ptr(&self) -> Self::StablePtr {
22953 TerminalEnumPtr(self.node.0.stable_ptr)
22954 }
22955}
22956impl From<&TerminalEnum> for SyntaxStablePtrId {
22957 fn from(node: &TerminalEnum) -> Self {
22958 node.stable_ptr().untyped()
22959 }
22960}
22961#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22962pub struct TokenExtern {
22963 node: SyntaxNode,
22964}
22965impl Token for TokenExtern {
22966 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22967 TokenExternGreen(
22968 Arc::new(GreenNode {
22969 kind: SyntaxKind::TokenExtern,
22970 details: GreenNodeDetails::Token(text),
22971 })
22972 .intern(db),
22973 )
22974 }
22975 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22976 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22977 .clone()
22978 }
22979}
22980#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22981pub struct TokenExternPtr(pub SyntaxStablePtrId);
22982impl TypedStablePtr for TokenExternPtr {
22983 type SyntaxNode = TokenExtern;
22984 fn untyped(&self) -> SyntaxStablePtrId {
22985 self.0
22986 }
22987 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenExtern {
22988 TokenExtern::from_syntax_node(db, self.0.lookup(db))
22989 }
22990}
22991impl From<TokenExternPtr> for SyntaxStablePtrId {
22992 fn from(ptr: TokenExternPtr) -> Self {
22993 ptr.untyped()
22994 }
22995}
22996#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22997pub struct TokenExternGreen(pub GreenId);
22998impl TokenExternGreen {
22999 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23000 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23001 }
23002}
23003impl TypedSyntaxNode for TokenExtern {
23004 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenExtern);
23005 type StablePtr = TokenExternPtr;
23006 type Green = TokenExternGreen;
23007 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23008 TokenExternGreen(
23009 Arc::new(GreenNode {
23010 kind: SyntaxKind::TokenMissing,
23011 details: GreenNodeDetails::Token("".into()),
23012 })
23013 .intern(db),
23014 )
23015 }
23016 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23017 match node.0.green.lookup_intern(db).details {
23018 GreenNodeDetails::Token(_) => Self { node },
23019 GreenNodeDetails::Node { .. } => {
23020 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenExtern)
23021 }
23022 }
23023 }
23024 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23025 match node.0.green.lookup_intern(db).details {
23026 GreenNodeDetails::Token(_) => Some(Self { node }),
23027 GreenNodeDetails::Node { .. } => None,
23028 }
23029 }
23030 fn as_syntax_node(&self) -> SyntaxNode {
23031 self.node.clone()
23032 }
23033 fn stable_ptr(&self) -> Self::StablePtr {
23034 TokenExternPtr(self.node.0.stable_ptr)
23035 }
23036}
23037impl From<&TokenExtern> for SyntaxStablePtrId {
23038 fn from(node: &TokenExtern) -> Self {
23039 node.stable_ptr().untyped()
23040 }
23041}
23042#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23043pub struct TerminalExtern {
23044 node: SyntaxNode,
23045 children: Arc<[SyntaxNode]>,
23046}
23047impl Terminal for TerminalExtern {
23048 const KIND: SyntaxKind = SyntaxKind::TerminalExtern;
23049 type TokenType = TokenExtern;
23050 fn new_green(
23051 db: &dyn SyntaxGroup,
23052 leading_trivia: TriviaGreen,
23053 token: <<TerminalExtern as Terminal>::TokenType as TypedSyntaxNode>::Green,
23054 trailing_trivia: TriviaGreen,
23055 ) -> Self::Green {
23056 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23057 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23058 TerminalExternGreen(
23059 Arc::new(GreenNode {
23060 kind: SyntaxKind::TerminalExtern,
23061 details: GreenNodeDetails::Node { children, width },
23062 })
23063 .intern(db),
23064 )
23065 }
23066 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23067 self.token(db).text(db)
23068 }
23069}
23070impl TerminalExtern {
23071 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23072 Trivia::from_syntax_node(db, self.children[0].clone())
23073 }
23074 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenExtern {
23075 TokenExtern::from_syntax_node(db, self.children[1].clone())
23076 }
23077 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23078 Trivia::from_syntax_node(db, self.children[2].clone())
23079 }
23080}
23081#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23082pub struct TerminalExternPtr(pub SyntaxStablePtrId);
23083impl TerminalExternPtr {}
23084impl TypedStablePtr for TerminalExternPtr {
23085 type SyntaxNode = TerminalExtern;
23086 fn untyped(&self) -> SyntaxStablePtrId {
23087 self.0
23088 }
23089 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
23090 TerminalExtern::from_syntax_node(db, self.0.lookup(db))
23091 }
23092}
23093impl From<TerminalExternPtr> for SyntaxStablePtrId {
23094 fn from(ptr: TerminalExternPtr) -> Self {
23095 ptr.untyped()
23096 }
23097}
23098#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23099pub struct TerminalExternGreen(pub GreenId);
23100impl TypedSyntaxNode for TerminalExtern {
23101 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalExtern);
23102 type StablePtr = TerminalExternPtr;
23103 type Green = TerminalExternGreen;
23104 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23105 TerminalExternGreen(
23106 Arc::new(GreenNode {
23107 kind: SyntaxKind::TerminalExtern,
23108 details: GreenNodeDetails::Node {
23109 children: vec![
23110 Trivia::missing(db).0,
23111 TokenExtern::missing(db).0,
23112 Trivia::missing(db).0,
23113 ],
23114 width: TextWidth::default(),
23115 },
23116 })
23117 .intern(db),
23118 )
23119 }
23120 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23121 let kind = node.kind(db);
23122 assert_eq!(
23123 kind,
23124 SyntaxKind::TerminalExtern,
23125 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23126 kind,
23127 SyntaxKind::TerminalExtern
23128 );
23129 let children = db.get_children(node.clone());
23130 Self { node, children }
23131 }
23132 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23133 let kind = node.kind(db);
23134 if kind == SyntaxKind::TerminalExtern {
23135 Some(Self::from_syntax_node(db, node))
23136 } else {
23137 None
23138 }
23139 }
23140 fn as_syntax_node(&self) -> SyntaxNode {
23141 self.node.clone()
23142 }
23143 fn stable_ptr(&self) -> Self::StablePtr {
23144 TerminalExternPtr(self.node.0.stable_ptr)
23145 }
23146}
23147impl From<&TerminalExtern> for SyntaxStablePtrId {
23148 fn from(node: &TerminalExtern) -> Self {
23149 node.stable_ptr().untyped()
23150 }
23151}
23152#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23153pub struct TokenFalse {
23154 node: SyntaxNode,
23155}
23156impl Token for TokenFalse {
23157 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23158 TokenFalseGreen(
23159 Arc::new(GreenNode {
23160 kind: SyntaxKind::TokenFalse,
23161 details: GreenNodeDetails::Token(text),
23162 })
23163 .intern(db),
23164 )
23165 }
23166 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23167 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23168 .clone()
23169 }
23170}
23171#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23172pub struct TokenFalsePtr(pub SyntaxStablePtrId);
23173impl TypedStablePtr for TokenFalsePtr {
23174 type SyntaxNode = TokenFalse;
23175 fn untyped(&self) -> SyntaxStablePtrId {
23176 self.0
23177 }
23178 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFalse {
23179 TokenFalse::from_syntax_node(db, self.0.lookup(db))
23180 }
23181}
23182impl From<TokenFalsePtr> for SyntaxStablePtrId {
23183 fn from(ptr: TokenFalsePtr) -> Self {
23184 ptr.untyped()
23185 }
23186}
23187#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23188pub struct TokenFalseGreen(pub GreenId);
23189impl TokenFalseGreen {
23190 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23191 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23192 }
23193}
23194impl TypedSyntaxNode for TokenFalse {
23195 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFalse);
23196 type StablePtr = TokenFalsePtr;
23197 type Green = TokenFalseGreen;
23198 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23199 TokenFalseGreen(
23200 Arc::new(GreenNode {
23201 kind: SyntaxKind::TokenMissing,
23202 details: GreenNodeDetails::Token("".into()),
23203 })
23204 .intern(db),
23205 )
23206 }
23207 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23208 match node.0.green.lookup_intern(db).details {
23209 GreenNodeDetails::Token(_) => Self { node },
23210 GreenNodeDetails::Node { .. } => {
23211 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFalse)
23212 }
23213 }
23214 }
23215 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23216 match node.0.green.lookup_intern(db).details {
23217 GreenNodeDetails::Token(_) => Some(Self { node }),
23218 GreenNodeDetails::Node { .. } => None,
23219 }
23220 }
23221 fn as_syntax_node(&self) -> SyntaxNode {
23222 self.node.clone()
23223 }
23224 fn stable_ptr(&self) -> Self::StablePtr {
23225 TokenFalsePtr(self.node.0.stable_ptr)
23226 }
23227}
23228impl From<&TokenFalse> for SyntaxStablePtrId {
23229 fn from(node: &TokenFalse) -> Self {
23230 node.stable_ptr().untyped()
23231 }
23232}
23233#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23234pub struct TerminalFalse {
23235 node: SyntaxNode,
23236 children: Arc<[SyntaxNode]>,
23237}
23238impl Terminal for TerminalFalse {
23239 const KIND: SyntaxKind = SyntaxKind::TerminalFalse;
23240 type TokenType = TokenFalse;
23241 fn new_green(
23242 db: &dyn SyntaxGroup,
23243 leading_trivia: TriviaGreen,
23244 token: <<TerminalFalse as Terminal>::TokenType as TypedSyntaxNode>::Green,
23245 trailing_trivia: TriviaGreen,
23246 ) -> Self::Green {
23247 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23248 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23249 TerminalFalseGreen(
23250 Arc::new(GreenNode {
23251 kind: SyntaxKind::TerminalFalse,
23252 details: GreenNodeDetails::Node { children, width },
23253 })
23254 .intern(db),
23255 )
23256 }
23257 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23258 self.token(db).text(db)
23259 }
23260}
23261impl TerminalFalse {
23262 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23263 Trivia::from_syntax_node(db, self.children[0].clone())
23264 }
23265 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFalse {
23266 TokenFalse::from_syntax_node(db, self.children[1].clone())
23267 }
23268 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23269 Trivia::from_syntax_node(db, self.children[2].clone())
23270 }
23271}
23272#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23273pub struct TerminalFalsePtr(pub SyntaxStablePtrId);
23274impl TerminalFalsePtr {}
23275impl TypedStablePtr for TerminalFalsePtr {
23276 type SyntaxNode = TerminalFalse;
23277 fn untyped(&self) -> SyntaxStablePtrId {
23278 self.0
23279 }
23280 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFalse {
23281 TerminalFalse::from_syntax_node(db, self.0.lookup(db))
23282 }
23283}
23284impl From<TerminalFalsePtr> for SyntaxStablePtrId {
23285 fn from(ptr: TerminalFalsePtr) -> Self {
23286 ptr.untyped()
23287 }
23288}
23289#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23290pub struct TerminalFalseGreen(pub GreenId);
23291impl TypedSyntaxNode for TerminalFalse {
23292 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFalse);
23293 type StablePtr = TerminalFalsePtr;
23294 type Green = TerminalFalseGreen;
23295 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23296 TerminalFalseGreen(
23297 Arc::new(GreenNode {
23298 kind: SyntaxKind::TerminalFalse,
23299 details: GreenNodeDetails::Node {
23300 children: vec![
23301 Trivia::missing(db).0,
23302 TokenFalse::missing(db).0,
23303 Trivia::missing(db).0,
23304 ],
23305 width: TextWidth::default(),
23306 },
23307 })
23308 .intern(db),
23309 )
23310 }
23311 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23312 let kind = node.kind(db);
23313 assert_eq!(
23314 kind,
23315 SyntaxKind::TerminalFalse,
23316 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23317 kind,
23318 SyntaxKind::TerminalFalse
23319 );
23320 let children = db.get_children(node.clone());
23321 Self { node, children }
23322 }
23323 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23324 let kind = node.kind(db);
23325 if kind == SyntaxKind::TerminalFalse {
23326 Some(Self::from_syntax_node(db, node))
23327 } else {
23328 None
23329 }
23330 }
23331 fn as_syntax_node(&self) -> SyntaxNode {
23332 self.node.clone()
23333 }
23334 fn stable_ptr(&self) -> Self::StablePtr {
23335 TerminalFalsePtr(self.node.0.stable_ptr)
23336 }
23337}
23338impl From<&TerminalFalse> for SyntaxStablePtrId {
23339 fn from(node: &TerminalFalse) -> Self {
23340 node.stable_ptr().untyped()
23341 }
23342}
23343#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23344pub struct TokenFunction {
23345 node: SyntaxNode,
23346}
23347impl Token for TokenFunction {
23348 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23349 TokenFunctionGreen(
23350 Arc::new(GreenNode {
23351 kind: SyntaxKind::TokenFunction,
23352 details: GreenNodeDetails::Token(text),
23353 })
23354 .intern(db),
23355 )
23356 }
23357 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23358 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23359 .clone()
23360 }
23361}
23362#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23363pub struct TokenFunctionPtr(pub SyntaxStablePtrId);
23364impl TypedStablePtr for TokenFunctionPtr {
23365 type SyntaxNode = TokenFunction;
23366 fn untyped(&self) -> SyntaxStablePtrId {
23367 self.0
23368 }
23369 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFunction {
23370 TokenFunction::from_syntax_node(db, self.0.lookup(db))
23371 }
23372}
23373impl From<TokenFunctionPtr> for SyntaxStablePtrId {
23374 fn from(ptr: TokenFunctionPtr) -> Self {
23375 ptr.untyped()
23376 }
23377}
23378#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23379pub struct TokenFunctionGreen(pub GreenId);
23380impl TokenFunctionGreen {
23381 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23382 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23383 }
23384}
23385impl TypedSyntaxNode for TokenFunction {
23386 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFunction);
23387 type StablePtr = TokenFunctionPtr;
23388 type Green = TokenFunctionGreen;
23389 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23390 TokenFunctionGreen(
23391 Arc::new(GreenNode {
23392 kind: SyntaxKind::TokenMissing,
23393 details: GreenNodeDetails::Token("".into()),
23394 })
23395 .intern(db),
23396 )
23397 }
23398 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23399 match node.0.green.lookup_intern(db).details {
23400 GreenNodeDetails::Token(_) => Self { node },
23401 GreenNodeDetails::Node { .. } => {
23402 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFunction)
23403 }
23404 }
23405 }
23406 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23407 match node.0.green.lookup_intern(db).details {
23408 GreenNodeDetails::Token(_) => Some(Self { node }),
23409 GreenNodeDetails::Node { .. } => None,
23410 }
23411 }
23412 fn as_syntax_node(&self) -> SyntaxNode {
23413 self.node.clone()
23414 }
23415 fn stable_ptr(&self) -> Self::StablePtr {
23416 TokenFunctionPtr(self.node.0.stable_ptr)
23417 }
23418}
23419impl From<&TokenFunction> for SyntaxStablePtrId {
23420 fn from(node: &TokenFunction) -> Self {
23421 node.stable_ptr().untyped()
23422 }
23423}
23424#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23425pub struct TerminalFunction {
23426 node: SyntaxNode,
23427 children: Arc<[SyntaxNode]>,
23428}
23429impl Terminal for TerminalFunction {
23430 const KIND: SyntaxKind = SyntaxKind::TerminalFunction;
23431 type TokenType = TokenFunction;
23432 fn new_green(
23433 db: &dyn SyntaxGroup,
23434 leading_trivia: TriviaGreen,
23435 token: <<TerminalFunction as Terminal>::TokenType as TypedSyntaxNode>::Green,
23436 trailing_trivia: TriviaGreen,
23437 ) -> Self::Green {
23438 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23439 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23440 TerminalFunctionGreen(
23441 Arc::new(GreenNode {
23442 kind: SyntaxKind::TerminalFunction,
23443 details: GreenNodeDetails::Node { children, width },
23444 })
23445 .intern(db),
23446 )
23447 }
23448 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23449 self.token(db).text(db)
23450 }
23451}
23452impl TerminalFunction {
23453 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23454 Trivia::from_syntax_node(db, self.children[0].clone())
23455 }
23456 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFunction {
23457 TokenFunction::from_syntax_node(db, self.children[1].clone())
23458 }
23459 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23460 Trivia::from_syntax_node(db, self.children[2].clone())
23461 }
23462}
23463#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23464pub struct TerminalFunctionPtr(pub SyntaxStablePtrId);
23465impl TerminalFunctionPtr {}
23466impl TypedStablePtr for TerminalFunctionPtr {
23467 type SyntaxNode = TerminalFunction;
23468 fn untyped(&self) -> SyntaxStablePtrId {
23469 self.0
23470 }
23471 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFunction {
23472 TerminalFunction::from_syntax_node(db, self.0.lookup(db))
23473 }
23474}
23475impl From<TerminalFunctionPtr> for SyntaxStablePtrId {
23476 fn from(ptr: TerminalFunctionPtr) -> Self {
23477 ptr.untyped()
23478 }
23479}
23480#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23481pub struct TerminalFunctionGreen(pub GreenId);
23482impl TypedSyntaxNode for TerminalFunction {
23483 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFunction);
23484 type StablePtr = TerminalFunctionPtr;
23485 type Green = TerminalFunctionGreen;
23486 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23487 TerminalFunctionGreen(
23488 Arc::new(GreenNode {
23489 kind: SyntaxKind::TerminalFunction,
23490 details: GreenNodeDetails::Node {
23491 children: vec![
23492 Trivia::missing(db).0,
23493 TokenFunction::missing(db).0,
23494 Trivia::missing(db).0,
23495 ],
23496 width: TextWidth::default(),
23497 },
23498 })
23499 .intern(db),
23500 )
23501 }
23502 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23503 let kind = node.kind(db);
23504 assert_eq!(
23505 kind,
23506 SyntaxKind::TerminalFunction,
23507 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23508 kind,
23509 SyntaxKind::TerminalFunction
23510 );
23511 let children = db.get_children(node.clone());
23512 Self { node, children }
23513 }
23514 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23515 let kind = node.kind(db);
23516 if kind == SyntaxKind::TerminalFunction {
23517 Some(Self::from_syntax_node(db, node))
23518 } else {
23519 None
23520 }
23521 }
23522 fn as_syntax_node(&self) -> SyntaxNode {
23523 self.node.clone()
23524 }
23525 fn stable_ptr(&self) -> Self::StablePtr {
23526 TerminalFunctionPtr(self.node.0.stable_ptr)
23527 }
23528}
23529impl From<&TerminalFunction> for SyntaxStablePtrId {
23530 fn from(node: &TerminalFunction) -> Self {
23531 node.stable_ptr().untyped()
23532 }
23533}
23534#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23535pub struct TokenIf {
23536 node: SyntaxNode,
23537}
23538impl Token for TokenIf {
23539 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23540 TokenIfGreen(
23541 Arc::new(GreenNode {
23542 kind: SyntaxKind::TokenIf,
23543 details: GreenNodeDetails::Token(text),
23544 })
23545 .intern(db),
23546 )
23547 }
23548 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23549 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23550 .clone()
23551 }
23552}
23553#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23554pub struct TokenIfPtr(pub SyntaxStablePtrId);
23555impl TypedStablePtr for TokenIfPtr {
23556 type SyntaxNode = TokenIf;
23557 fn untyped(&self) -> SyntaxStablePtrId {
23558 self.0
23559 }
23560 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenIf {
23561 TokenIf::from_syntax_node(db, self.0.lookup(db))
23562 }
23563}
23564impl From<TokenIfPtr> for SyntaxStablePtrId {
23565 fn from(ptr: TokenIfPtr) -> Self {
23566 ptr.untyped()
23567 }
23568}
23569#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23570pub struct TokenIfGreen(pub GreenId);
23571impl TokenIfGreen {
23572 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23573 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23574 }
23575}
23576impl TypedSyntaxNode for TokenIf {
23577 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenIf);
23578 type StablePtr = TokenIfPtr;
23579 type Green = TokenIfGreen;
23580 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23581 TokenIfGreen(
23582 Arc::new(GreenNode {
23583 kind: SyntaxKind::TokenMissing,
23584 details: GreenNodeDetails::Token("".into()),
23585 })
23586 .intern(db),
23587 )
23588 }
23589 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23590 match node.0.green.lookup_intern(db).details {
23591 GreenNodeDetails::Token(_) => Self { node },
23592 GreenNodeDetails::Node { .. } => {
23593 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenIf)
23594 }
23595 }
23596 }
23597 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23598 match node.0.green.lookup_intern(db).details {
23599 GreenNodeDetails::Token(_) => Some(Self { node }),
23600 GreenNodeDetails::Node { .. } => None,
23601 }
23602 }
23603 fn as_syntax_node(&self) -> SyntaxNode {
23604 self.node.clone()
23605 }
23606 fn stable_ptr(&self) -> Self::StablePtr {
23607 TokenIfPtr(self.node.0.stable_ptr)
23608 }
23609}
23610impl From<&TokenIf> for SyntaxStablePtrId {
23611 fn from(node: &TokenIf) -> Self {
23612 node.stable_ptr().untyped()
23613 }
23614}
23615#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23616pub struct TerminalIf {
23617 node: SyntaxNode,
23618 children: Arc<[SyntaxNode]>,
23619}
23620impl Terminal for TerminalIf {
23621 const KIND: SyntaxKind = SyntaxKind::TerminalIf;
23622 type TokenType = TokenIf;
23623 fn new_green(
23624 db: &dyn SyntaxGroup,
23625 leading_trivia: TriviaGreen,
23626 token: <<TerminalIf as Terminal>::TokenType as TypedSyntaxNode>::Green,
23627 trailing_trivia: TriviaGreen,
23628 ) -> Self::Green {
23629 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23630 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23631 TerminalIfGreen(
23632 Arc::new(GreenNode {
23633 kind: SyntaxKind::TerminalIf,
23634 details: GreenNodeDetails::Node { children, width },
23635 })
23636 .intern(db),
23637 )
23638 }
23639 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23640 self.token(db).text(db)
23641 }
23642}
23643impl TerminalIf {
23644 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23645 Trivia::from_syntax_node(db, self.children[0].clone())
23646 }
23647 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenIf {
23648 TokenIf::from_syntax_node(db, self.children[1].clone())
23649 }
23650 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23651 Trivia::from_syntax_node(db, self.children[2].clone())
23652 }
23653}
23654#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23655pub struct TerminalIfPtr(pub SyntaxStablePtrId);
23656impl TerminalIfPtr {}
23657impl TypedStablePtr for TerminalIfPtr {
23658 type SyntaxNode = TerminalIf;
23659 fn untyped(&self) -> SyntaxStablePtrId {
23660 self.0
23661 }
23662 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalIf {
23663 TerminalIf::from_syntax_node(db, self.0.lookup(db))
23664 }
23665}
23666impl From<TerminalIfPtr> for SyntaxStablePtrId {
23667 fn from(ptr: TerminalIfPtr) -> Self {
23668 ptr.untyped()
23669 }
23670}
23671#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23672pub struct TerminalIfGreen(pub GreenId);
23673impl TypedSyntaxNode for TerminalIf {
23674 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalIf);
23675 type StablePtr = TerminalIfPtr;
23676 type Green = TerminalIfGreen;
23677 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23678 TerminalIfGreen(
23679 Arc::new(GreenNode {
23680 kind: SyntaxKind::TerminalIf,
23681 details: GreenNodeDetails::Node {
23682 children: vec![
23683 Trivia::missing(db).0,
23684 TokenIf::missing(db).0,
23685 Trivia::missing(db).0,
23686 ],
23687 width: TextWidth::default(),
23688 },
23689 })
23690 .intern(db),
23691 )
23692 }
23693 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23694 let kind = node.kind(db);
23695 assert_eq!(
23696 kind,
23697 SyntaxKind::TerminalIf,
23698 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23699 kind,
23700 SyntaxKind::TerminalIf
23701 );
23702 let children = db.get_children(node.clone());
23703 Self { node, children }
23704 }
23705 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23706 let kind = node.kind(db);
23707 if kind == SyntaxKind::TerminalIf { Some(Self::from_syntax_node(db, node)) } else { None }
23708 }
23709 fn as_syntax_node(&self) -> SyntaxNode {
23710 self.node.clone()
23711 }
23712 fn stable_ptr(&self) -> Self::StablePtr {
23713 TerminalIfPtr(self.node.0.stable_ptr)
23714 }
23715}
23716impl From<&TerminalIf> for SyntaxStablePtrId {
23717 fn from(node: &TerminalIf) -> Self {
23718 node.stable_ptr().untyped()
23719 }
23720}
23721#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23722pub struct TokenWhile {
23723 node: SyntaxNode,
23724}
23725impl Token for TokenWhile {
23726 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23727 TokenWhileGreen(
23728 Arc::new(GreenNode {
23729 kind: SyntaxKind::TokenWhile,
23730 details: GreenNodeDetails::Token(text),
23731 })
23732 .intern(db),
23733 )
23734 }
23735 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23736 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23737 .clone()
23738 }
23739}
23740#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23741pub struct TokenWhilePtr(pub SyntaxStablePtrId);
23742impl TypedStablePtr for TokenWhilePtr {
23743 type SyntaxNode = TokenWhile;
23744 fn untyped(&self) -> SyntaxStablePtrId {
23745 self.0
23746 }
23747 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenWhile {
23748 TokenWhile::from_syntax_node(db, self.0.lookup(db))
23749 }
23750}
23751impl From<TokenWhilePtr> for SyntaxStablePtrId {
23752 fn from(ptr: TokenWhilePtr) -> Self {
23753 ptr.untyped()
23754 }
23755}
23756#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23757pub struct TokenWhileGreen(pub GreenId);
23758impl TokenWhileGreen {
23759 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23760 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23761 }
23762}
23763impl TypedSyntaxNode for TokenWhile {
23764 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenWhile);
23765 type StablePtr = TokenWhilePtr;
23766 type Green = TokenWhileGreen;
23767 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23768 TokenWhileGreen(
23769 Arc::new(GreenNode {
23770 kind: SyntaxKind::TokenMissing,
23771 details: GreenNodeDetails::Token("".into()),
23772 })
23773 .intern(db),
23774 )
23775 }
23776 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23777 match node.0.green.lookup_intern(db).details {
23778 GreenNodeDetails::Token(_) => Self { node },
23779 GreenNodeDetails::Node { .. } => {
23780 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenWhile)
23781 }
23782 }
23783 }
23784 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23785 match node.0.green.lookup_intern(db).details {
23786 GreenNodeDetails::Token(_) => Some(Self { node }),
23787 GreenNodeDetails::Node { .. } => None,
23788 }
23789 }
23790 fn as_syntax_node(&self) -> SyntaxNode {
23791 self.node.clone()
23792 }
23793 fn stable_ptr(&self) -> Self::StablePtr {
23794 TokenWhilePtr(self.node.0.stable_ptr)
23795 }
23796}
23797impl From<&TokenWhile> for SyntaxStablePtrId {
23798 fn from(node: &TokenWhile) -> Self {
23799 node.stable_ptr().untyped()
23800 }
23801}
23802#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23803pub struct TerminalWhile {
23804 node: SyntaxNode,
23805 children: Arc<[SyntaxNode]>,
23806}
23807impl Terminal for TerminalWhile {
23808 const KIND: SyntaxKind = SyntaxKind::TerminalWhile;
23809 type TokenType = TokenWhile;
23810 fn new_green(
23811 db: &dyn SyntaxGroup,
23812 leading_trivia: TriviaGreen,
23813 token: <<TerminalWhile as Terminal>::TokenType as TypedSyntaxNode>::Green,
23814 trailing_trivia: TriviaGreen,
23815 ) -> Self::Green {
23816 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23817 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23818 TerminalWhileGreen(
23819 Arc::new(GreenNode {
23820 kind: SyntaxKind::TerminalWhile,
23821 details: GreenNodeDetails::Node { children, width },
23822 })
23823 .intern(db),
23824 )
23825 }
23826 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23827 self.token(db).text(db)
23828 }
23829}
23830impl TerminalWhile {
23831 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23832 Trivia::from_syntax_node(db, self.children[0].clone())
23833 }
23834 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenWhile {
23835 TokenWhile::from_syntax_node(db, self.children[1].clone())
23836 }
23837 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23838 Trivia::from_syntax_node(db, self.children[2].clone())
23839 }
23840}
23841#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23842pub struct TerminalWhilePtr(pub SyntaxStablePtrId);
23843impl TerminalWhilePtr {}
23844impl TypedStablePtr for TerminalWhilePtr {
23845 type SyntaxNode = TerminalWhile;
23846 fn untyped(&self) -> SyntaxStablePtrId {
23847 self.0
23848 }
23849 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalWhile {
23850 TerminalWhile::from_syntax_node(db, self.0.lookup(db))
23851 }
23852}
23853impl From<TerminalWhilePtr> for SyntaxStablePtrId {
23854 fn from(ptr: TerminalWhilePtr) -> Self {
23855 ptr.untyped()
23856 }
23857}
23858#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23859pub struct TerminalWhileGreen(pub GreenId);
23860impl TypedSyntaxNode for TerminalWhile {
23861 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalWhile);
23862 type StablePtr = TerminalWhilePtr;
23863 type Green = TerminalWhileGreen;
23864 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23865 TerminalWhileGreen(
23866 Arc::new(GreenNode {
23867 kind: SyntaxKind::TerminalWhile,
23868 details: GreenNodeDetails::Node {
23869 children: vec![
23870 Trivia::missing(db).0,
23871 TokenWhile::missing(db).0,
23872 Trivia::missing(db).0,
23873 ],
23874 width: TextWidth::default(),
23875 },
23876 })
23877 .intern(db),
23878 )
23879 }
23880 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23881 let kind = node.kind(db);
23882 assert_eq!(
23883 kind,
23884 SyntaxKind::TerminalWhile,
23885 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23886 kind,
23887 SyntaxKind::TerminalWhile
23888 );
23889 let children = db.get_children(node.clone());
23890 Self { node, children }
23891 }
23892 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23893 let kind = node.kind(db);
23894 if kind == SyntaxKind::TerminalWhile {
23895 Some(Self::from_syntax_node(db, node))
23896 } else {
23897 None
23898 }
23899 }
23900 fn as_syntax_node(&self) -> SyntaxNode {
23901 self.node.clone()
23902 }
23903 fn stable_ptr(&self) -> Self::StablePtr {
23904 TerminalWhilePtr(self.node.0.stable_ptr)
23905 }
23906}
23907impl From<&TerminalWhile> for SyntaxStablePtrId {
23908 fn from(node: &TerminalWhile) -> Self {
23909 node.stable_ptr().untyped()
23910 }
23911}
23912#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23913pub struct TokenFor {
23914 node: SyntaxNode,
23915}
23916impl Token for TokenFor {
23917 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23918 TokenForGreen(
23919 Arc::new(GreenNode {
23920 kind: SyntaxKind::TokenFor,
23921 details: GreenNodeDetails::Token(text),
23922 })
23923 .intern(db),
23924 )
23925 }
23926 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23927 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23928 .clone()
23929 }
23930}
23931#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23932pub struct TokenForPtr(pub SyntaxStablePtrId);
23933impl TypedStablePtr for TokenForPtr {
23934 type SyntaxNode = TokenFor;
23935 fn untyped(&self) -> SyntaxStablePtrId {
23936 self.0
23937 }
23938 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFor {
23939 TokenFor::from_syntax_node(db, self.0.lookup(db))
23940 }
23941}
23942impl From<TokenForPtr> for SyntaxStablePtrId {
23943 fn from(ptr: TokenForPtr) -> Self {
23944 ptr.untyped()
23945 }
23946}
23947#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23948pub struct TokenForGreen(pub GreenId);
23949impl TokenForGreen {
23950 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23951 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23952 }
23953}
23954impl TypedSyntaxNode for TokenFor {
23955 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFor);
23956 type StablePtr = TokenForPtr;
23957 type Green = TokenForGreen;
23958 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23959 TokenForGreen(
23960 Arc::new(GreenNode {
23961 kind: SyntaxKind::TokenMissing,
23962 details: GreenNodeDetails::Token("".into()),
23963 })
23964 .intern(db),
23965 )
23966 }
23967 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23968 match node.0.green.lookup_intern(db).details {
23969 GreenNodeDetails::Token(_) => Self { node },
23970 GreenNodeDetails::Node { .. } => {
23971 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFor)
23972 }
23973 }
23974 }
23975 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
23976 match node.0.green.lookup_intern(db).details {
23977 GreenNodeDetails::Token(_) => Some(Self { node }),
23978 GreenNodeDetails::Node { .. } => None,
23979 }
23980 }
23981 fn as_syntax_node(&self) -> SyntaxNode {
23982 self.node.clone()
23983 }
23984 fn stable_ptr(&self) -> Self::StablePtr {
23985 TokenForPtr(self.node.0.stable_ptr)
23986 }
23987}
23988impl From<&TokenFor> for SyntaxStablePtrId {
23989 fn from(node: &TokenFor) -> Self {
23990 node.stable_ptr().untyped()
23991 }
23992}
23993#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23994pub struct TerminalFor {
23995 node: SyntaxNode,
23996 children: Arc<[SyntaxNode]>,
23997}
23998impl Terminal for TerminalFor {
23999 const KIND: SyntaxKind = SyntaxKind::TerminalFor;
24000 type TokenType = TokenFor;
24001 fn new_green(
24002 db: &dyn SyntaxGroup,
24003 leading_trivia: TriviaGreen,
24004 token: <<TerminalFor as Terminal>::TokenType as TypedSyntaxNode>::Green,
24005 trailing_trivia: TriviaGreen,
24006 ) -> Self::Green {
24007 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24008 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24009 TerminalForGreen(
24010 Arc::new(GreenNode {
24011 kind: SyntaxKind::TerminalFor,
24012 details: GreenNodeDetails::Node { children, width },
24013 })
24014 .intern(db),
24015 )
24016 }
24017 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24018 self.token(db).text(db)
24019 }
24020}
24021impl TerminalFor {
24022 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24023 Trivia::from_syntax_node(db, self.children[0].clone())
24024 }
24025 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFor {
24026 TokenFor::from_syntax_node(db, self.children[1].clone())
24027 }
24028 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24029 Trivia::from_syntax_node(db, self.children[2].clone())
24030 }
24031}
24032#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24033pub struct TerminalForPtr(pub SyntaxStablePtrId);
24034impl TerminalForPtr {}
24035impl TypedStablePtr for TerminalForPtr {
24036 type SyntaxNode = TerminalFor;
24037 fn untyped(&self) -> SyntaxStablePtrId {
24038 self.0
24039 }
24040 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFor {
24041 TerminalFor::from_syntax_node(db, self.0.lookup(db))
24042 }
24043}
24044impl From<TerminalForPtr> for SyntaxStablePtrId {
24045 fn from(ptr: TerminalForPtr) -> Self {
24046 ptr.untyped()
24047 }
24048}
24049#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24050pub struct TerminalForGreen(pub GreenId);
24051impl TypedSyntaxNode for TerminalFor {
24052 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFor);
24053 type StablePtr = TerminalForPtr;
24054 type Green = TerminalForGreen;
24055 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24056 TerminalForGreen(
24057 Arc::new(GreenNode {
24058 kind: SyntaxKind::TerminalFor,
24059 details: GreenNodeDetails::Node {
24060 children: vec![
24061 Trivia::missing(db).0,
24062 TokenFor::missing(db).0,
24063 Trivia::missing(db).0,
24064 ],
24065 width: TextWidth::default(),
24066 },
24067 })
24068 .intern(db),
24069 )
24070 }
24071 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24072 let kind = node.kind(db);
24073 assert_eq!(
24074 kind,
24075 SyntaxKind::TerminalFor,
24076 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24077 kind,
24078 SyntaxKind::TerminalFor
24079 );
24080 let children = db.get_children(node.clone());
24081 Self { node, children }
24082 }
24083 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24084 let kind = node.kind(db);
24085 if kind == SyntaxKind::TerminalFor { Some(Self::from_syntax_node(db, node)) } else { None }
24086 }
24087 fn as_syntax_node(&self) -> SyntaxNode {
24088 self.node.clone()
24089 }
24090 fn stable_ptr(&self) -> Self::StablePtr {
24091 TerminalForPtr(self.node.0.stable_ptr)
24092 }
24093}
24094impl From<&TerminalFor> for SyntaxStablePtrId {
24095 fn from(node: &TerminalFor) -> Self {
24096 node.stable_ptr().untyped()
24097 }
24098}
24099#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24100pub struct TokenLoop {
24101 node: SyntaxNode,
24102}
24103impl Token for TokenLoop {
24104 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24105 TokenLoopGreen(
24106 Arc::new(GreenNode {
24107 kind: SyntaxKind::TokenLoop,
24108 details: GreenNodeDetails::Token(text),
24109 })
24110 .intern(db),
24111 )
24112 }
24113 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24114 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24115 .clone()
24116 }
24117}
24118#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24119pub struct TokenLoopPtr(pub SyntaxStablePtrId);
24120impl TypedStablePtr for TokenLoopPtr {
24121 type SyntaxNode = TokenLoop;
24122 fn untyped(&self) -> SyntaxStablePtrId {
24123 self.0
24124 }
24125 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLoop {
24126 TokenLoop::from_syntax_node(db, self.0.lookup(db))
24127 }
24128}
24129impl From<TokenLoopPtr> for SyntaxStablePtrId {
24130 fn from(ptr: TokenLoopPtr) -> Self {
24131 ptr.untyped()
24132 }
24133}
24134#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24135pub struct TokenLoopGreen(pub GreenId);
24136impl TokenLoopGreen {
24137 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24138 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24139 }
24140}
24141impl TypedSyntaxNode for TokenLoop {
24142 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLoop);
24143 type StablePtr = TokenLoopPtr;
24144 type Green = TokenLoopGreen;
24145 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24146 TokenLoopGreen(
24147 Arc::new(GreenNode {
24148 kind: SyntaxKind::TokenMissing,
24149 details: GreenNodeDetails::Token("".into()),
24150 })
24151 .intern(db),
24152 )
24153 }
24154 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24155 match node.0.green.lookup_intern(db).details {
24156 GreenNodeDetails::Token(_) => Self { node },
24157 GreenNodeDetails::Node { .. } => {
24158 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLoop)
24159 }
24160 }
24161 }
24162 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24163 match node.0.green.lookup_intern(db).details {
24164 GreenNodeDetails::Token(_) => Some(Self { node }),
24165 GreenNodeDetails::Node { .. } => None,
24166 }
24167 }
24168 fn as_syntax_node(&self) -> SyntaxNode {
24169 self.node.clone()
24170 }
24171 fn stable_ptr(&self) -> Self::StablePtr {
24172 TokenLoopPtr(self.node.0.stable_ptr)
24173 }
24174}
24175impl From<&TokenLoop> for SyntaxStablePtrId {
24176 fn from(node: &TokenLoop) -> Self {
24177 node.stable_ptr().untyped()
24178 }
24179}
24180#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24181pub struct TerminalLoop {
24182 node: SyntaxNode,
24183 children: Arc<[SyntaxNode]>,
24184}
24185impl Terminal for TerminalLoop {
24186 const KIND: SyntaxKind = SyntaxKind::TerminalLoop;
24187 type TokenType = TokenLoop;
24188 fn new_green(
24189 db: &dyn SyntaxGroup,
24190 leading_trivia: TriviaGreen,
24191 token: <<TerminalLoop as Terminal>::TokenType as TypedSyntaxNode>::Green,
24192 trailing_trivia: TriviaGreen,
24193 ) -> Self::Green {
24194 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24195 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24196 TerminalLoopGreen(
24197 Arc::new(GreenNode {
24198 kind: SyntaxKind::TerminalLoop,
24199 details: GreenNodeDetails::Node { children, width },
24200 })
24201 .intern(db),
24202 )
24203 }
24204 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24205 self.token(db).text(db)
24206 }
24207}
24208impl TerminalLoop {
24209 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24210 Trivia::from_syntax_node(db, self.children[0].clone())
24211 }
24212 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLoop {
24213 TokenLoop::from_syntax_node(db, self.children[1].clone())
24214 }
24215 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24216 Trivia::from_syntax_node(db, self.children[2].clone())
24217 }
24218}
24219#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24220pub struct TerminalLoopPtr(pub SyntaxStablePtrId);
24221impl TerminalLoopPtr {}
24222impl TypedStablePtr for TerminalLoopPtr {
24223 type SyntaxNode = TerminalLoop;
24224 fn untyped(&self) -> SyntaxStablePtrId {
24225 self.0
24226 }
24227 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLoop {
24228 TerminalLoop::from_syntax_node(db, self.0.lookup(db))
24229 }
24230}
24231impl From<TerminalLoopPtr> for SyntaxStablePtrId {
24232 fn from(ptr: TerminalLoopPtr) -> Self {
24233 ptr.untyped()
24234 }
24235}
24236#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24237pub struct TerminalLoopGreen(pub GreenId);
24238impl TypedSyntaxNode for TerminalLoop {
24239 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLoop);
24240 type StablePtr = TerminalLoopPtr;
24241 type Green = TerminalLoopGreen;
24242 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24243 TerminalLoopGreen(
24244 Arc::new(GreenNode {
24245 kind: SyntaxKind::TerminalLoop,
24246 details: GreenNodeDetails::Node {
24247 children: vec![
24248 Trivia::missing(db).0,
24249 TokenLoop::missing(db).0,
24250 Trivia::missing(db).0,
24251 ],
24252 width: TextWidth::default(),
24253 },
24254 })
24255 .intern(db),
24256 )
24257 }
24258 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24259 let kind = node.kind(db);
24260 assert_eq!(
24261 kind,
24262 SyntaxKind::TerminalLoop,
24263 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24264 kind,
24265 SyntaxKind::TerminalLoop
24266 );
24267 let children = db.get_children(node.clone());
24268 Self { node, children }
24269 }
24270 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24271 let kind = node.kind(db);
24272 if kind == SyntaxKind::TerminalLoop { Some(Self::from_syntax_node(db, node)) } else { None }
24273 }
24274 fn as_syntax_node(&self) -> SyntaxNode {
24275 self.node.clone()
24276 }
24277 fn stable_ptr(&self) -> Self::StablePtr {
24278 TerminalLoopPtr(self.node.0.stable_ptr)
24279 }
24280}
24281impl From<&TerminalLoop> for SyntaxStablePtrId {
24282 fn from(node: &TerminalLoop) -> Self {
24283 node.stable_ptr().untyped()
24284 }
24285}
24286#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24287pub struct TokenImpl {
24288 node: SyntaxNode,
24289}
24290impl Token for TokenImpl {
24291 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24292 TokenImplGreen(
24293 Arc::new(GreenNode {
24294 kind: SyntaxKind::TokenImpl,
24295 details: GreenNodeDetails::Token(text),
24296 })
24297 .intern(db),
24298 )
24299 }
24300 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24301 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24302 .clone()
24303 }
24304}
24305#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24306pub struct TokenImplPtr(pub SyntaxStablePtrId);
24307impl TypedStablePtr for TokenImplPtr {
24308 type SyntaxNode = TokenImpl;
24309 fn untyped(&self) -> SyntaxStablePtrId {
24310 self.0
24311 }
24312 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenImpl {
24313 TokenImpl::from_syntax_node(db, self.0.lookup(db))
24314 }
24315}
24316impl From<TokenImplPtr> for SyntaxStablePtrId {
24317 fn from(ptr: TokenImplPtr) -> Self {
24318 ptr.untyped()
24319 }
24320}
24321#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24322pub struct TokenImplGreen(pub GreenId);
24323impl TokenImplGreen {
24324 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24325 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24326 }
24327}
24328impl TypedSyntaxNode for TokenImpl {
24329 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenImpl);
24330 type StablePtr = TokenImplPtr;
24331 type Green = TokenImplGreen;
24332 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24333 TokenImplGreen(
24334 Arc::new(GreenNode {
24335 kind: SyntaxKind::TokenMissing,
24336 details: GreenNodeDetails::Token("".into()),
24337 })
24338 .intern(db),
24339 )
24340 }
24341 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24342 match node.0.green.lookup_intern(db).details {
24343 GreenNodeDetails::Token(_) => Self { node },
24344 GreenNodeDetails::Node { .. } => {
24345 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenImpl)
24346 }
24347 }
24348 }
24349 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24350 match node.0.green.lookup_intern(db).details {
24351 GreenNodeDetails::Token(_) => Some(Self { node }),
24352 GreenNodeDetails::Node { .. } => None,
24353 }
24354 }
24355 fn as_syntax_node(&self) -> SyntaxNode {
24356 self.node.clone()
24357 }
24358 fn stable_ptr(&self) -> Self::StablePtr {
24359 TokenImplPtr(self.node.0.stable_ptr)
24360 }
24361}
24362impl From<&TokenImpl> for SyntaxStablePtrId {
24363 fn from(node: &TokenImpl) -> Self {
24364 node.stable_ptr().untyped()
24365 }
24366}
24367#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24368pub struct TerminalImpl {
24369 node: SyntaxNode,
24370 children: Arc<[SyntaxNode]>,
24371}
24372impl Terminal for TerminalImpl {
24373 const KIND: SyntaxKind = SyntaxKind::TerminalImpl;
24374 type TokenType = TokenImpl;
24375 fn new_green(
24376 db: &dyn SyntaxGroup,
24377 leading_trivia: TriviaGreen,
24378 token: <<TerminalImpl as Terminal>::TokenType as TypedSyntaxNode>::Green,
24379 trailing_trivia: TriviaGreen,
24380 ) -> Self::Green {
24381 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24382 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24383 TerminalImplGreen(
24384 Arc::new(GreenNode {
24385 kind: SyntaxKind::TerminalImpl,
24386 details: GreenNodeDetails::Node { children, width },
24387 })
24388 .intern(db),
24389 )
24390 }
24391 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24392 self.token(db).text(db)
24393 }
24394}
24395impl TerminalImpl {
24396 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24397 Trivia::from_syntax_node(db, self.children[0].clone())
24398 }
24399 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenImpl {
24400 TokenImpl::from_syntax_node(db, self.children[1].clone())
24401 }
24402 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24403 Trivia::from_syntax_node(db, self.children[2].clone())
24404 }
24405}
24406#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24407pub struct TerminalImplPtr(pub SyntaxStablePtrId);
24408impl TerminalImplPtr {}
24409impl TypedStablePtr for TerminalImplPtr {
24410 type SyntaxNode = TerminalImpl;
24411 fn untyped(&self) -> SyntaxStablePtrId {
24412 self.0
24413 }
24414 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
24415 TerminalImpl::from_syntax_node(db, self.0.lookup(db))
24416 }
24417}
24418impl From<TerminalImplPtr> for SyntaxStablePtrId {
24419 fn from(ptr: TerminalImplPtr) -> Self {
24420 ptr.untyped()
24421 }
24422}
24423#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24424pub struct TerminalImplGreen(pub GreenId);
24425impl TypedSyntaxNode for TerminalImpl {
24426 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalImpl);
24427 type StablePtr = TerminalImplPtr;
24428 type Green = TerminalImplGreen;
24429 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24430 TerminalImplGreen(
24431 Arc::new(GreenNode {
24432 kind: SyntaxKind::TerminalImpl,
24433 details: GreenNodeDetails::Node {
24434 children: vec![
24435 Trivia::missing(db).0,
24436 TokenImpl::missing(db).0,
24437 Trivia::missing(db).0,
24438 ],
24439 width: TextWidth::default(),
24440 },
24441 })
24442 .intern(db),
24443 )
24444 }
24445 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24446 let kind = node.kind(db);
24447 assert_eq!(
24448 kind,
24449 SyntaxKind::TerminalImpl,
24450 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24451 kind,
24452 SyntaxKind::TerminalImpl
24453 );
24454 let children = db.get_children(node.clone());
24455 Self { node, children }
24456 }
24457 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24458 let kind = node.kind(db);
24459 if kind == SyntaxKind::TerminalImpl { Some(Self::from_syntax_node(db, node)) } else { None }
24460 }
24461 fn as_syntax_node(&self) -> SyntaxNode {
24462 self.node.clone()
24463 }
24464 fn stable_ptr(&self) -> Self::StablePtr {
24465 TerminalImplPtr(self.node.0.stable_ptr)
24466 }
24467}
24468impl From<&TerminalImpl> for SyntaxStablePtrId {
24469 fn from(node: &TerminalImpl) -> Self {
24470 node.stable_ptr().untyped()
24471 }
24472}
24473#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24474pub struct TokenImplicits {
24475 node: SyntaxNode,
24476}
24477impl Token for TokenImplicits {
24478 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24479 TokenImplicitsGreen(
24480 Arc::new(GreenNode {
24481 kind: SyntaxKind::TokenImplicits,
24482 details: GreenNodeDetails::Token(text),
24483 })
24484 .intern(db),
24485 )
24486 }
24487 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24488 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24489 .clone()
24490 }
24491}
24492#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24493pub struct TokenImplicitsPtr(pub SyntaxStablePtrId);
24494impl TypedStablePtr for TokenImplicitsPtr {
24495 type SyntaxNode = TokenImplicits;
24496 fn untyped(&self) -> SyntaxStablePtrId {
24497 self.0
24498 }
24499 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenImplicits {
24500 TokenImplicits::from_syntax_node(db, self.0.lookup(db))
24501 }
24502}
24503impl From<TokenImplicitsPtr> for SyntaxStablePtrId {
24504 fn from(ptr: TokenImplicitsPtr) -> Self {
24505 ptr.untyped()
24506 }
24507}
24508#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24509pub struct TokenImplicitsGreen(pub GreenId);
24510impl TokenImplicitsGreen {
24511 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24512 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24513 }
24514}
24515impl TypedSyntaxNode for TokenImplicits {
24516 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenImplicits);
24517 type StablePtr = TokenImplicitsPtr;
24518 type Green = TokenImplicitsGreen;
24519 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24520 TokenImplicitsGreen(
24521 Arc::new(GreenNode {
24522 kind: SyntaxKind::TokenMissing,
24523 details: GreenNodeDetails::Token("".into()),
24524 })
24525 .intern(db),
24526 )
24527 }
24528 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24529 match node.0.green.lookup_intern(db).details {
24530 GreenNodeDetails::Token(_) => Self { node },
24531 GreenNodeDetails::Node { .. } => {
24532 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenImplicits)
24533 }
24534 }
24535 }
24536 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24537 match node.0.green.lookup_intern(db).details {
24538 GreenNodeDetails::Token(_) => Some(Self { node }),
24539 GreenNodeDetails::Node { .. } => None,
24540 }
24541 }
24542 fn as_syntax_node(&self) -> SyntaxNode {
24543 self.node.clone()
24544 }
24545 fn stable_ptr(&self) -> Self::StablePtr {
24546 TokenImplicitsPtr(self.node.0.stable_ptr)
24547 }
24548}
24549impl From<&TokenImplicits> for SyntaxStablePtrId {
24550 fn from(node: &TokenImplicits) -> Self {
24551 node.stable_ptr().untyped()
24552 }
24553}
24554#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24555pub struct TerminalImplicits {
24556 node: SyntaxNode,
24557 children: Arc<[SyntaxNode]>,
24558}
24559impl Terminal for TerminalImplicits {
24560 const KIND: SyntaxKind = SyntaxKind::TerminalImplicits;
24561 type TokenType = TokenImplicits;
24562 fn new_green(
24563 db: &dyn SyntaxGroup,
24564 leading_trivia: TriviaGreen,
24565 token: <<TerminalImplicits as Terminal>::TokenType as TypedSyntaxNode>::Green,
24566 trailing_trivia: TriviaGreen,
24567 ) -> Self::Green {
24568 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24569 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24570 TerminalImplicitsGreen(
24571 Arc::new(GreenNode {
24572 kind: SyntaxKind::TerminalImplicits,
24573 details: GreenNodeDetails::Node { children, width },
24574 })
24575 .intern(db),
24576 )
24577 }
24578 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24579 self.token(db).text(db)
24580 }
24581}
24582impl TerminalImplicits {
24583 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24584 Trivia::from_syntax_node(db, self.children[0].clone())
24585 }
24586 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenImplicits {
24587 TokenImplicits::from_syntax_node(db, self.children[1].clone())
24588 }
24589 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24590 Trivia::from_syntax_node(db, self.children[2].clone())
24591 }
24592}
24593#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24594pub struct TerminalImplicitsPtr(pub SyntaxStablePtrId);
24595impl TerminalImplicitsPtr {}
24596impl TypedStablePtr for TerminalImplicitsPtr {
24597 type SyntaxNode = TerminalImplicits;
24598 fn untyped(&self) -> SyntaxStablePtrId {
24599 self.0
24600 }
24601 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalImplicits {
24602 TerminalImplicits::from_syntax_node(db, self.0.lookup(db))
24603 }
24604}
24605impl From<TerminalImplicitsPtr> for SyntaxStablePtrId {
24606 fn from(ptr: TerminalImplicitsPtr) -> Self {
24607 ptr.untyped()
24608 }
24609}
24610#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24611pub struct TerminalImplicitsGreen(pub GreenId);
24612impl TypedSyntaxNode for TerminalImplicits {
24613 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalImplicits);
24614 type StablePtr = TerminalImplicitsPtr;
24615 type Green = TerminalImplicitsGreen;
24616 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24617 TerminalImplicitsGreen(
24618 Arc::new(GreenNode {
24619 kind: SyntaxKind::TerminalImplicits,
24620 details: GreenNodeDetails::Node {
24621 children: vec![
24622 Trivia::missing(db).0,
24623 TokenImplicits::missing(db).0,
24624 Trivia::missing(db).0,
24625 ],
24626 width: TextWidth::default(),
24627 },
24628 })
24629 .intern(db),
24630 )
24631 }
24632 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24633 let kind = node.kind(db);
24634 assert_eq!(
24635 kind,
24636 SyntaxKind::TerminalImplicits,
24637 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24638 kind,
24639 SyntaxKind::TerminalImplicits
24640 );
24641 let children = db.get_children(node.clone());
24642 Self { node, children }
24643 }
24644 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24645 let kind = node.kind(db);
24646 if kind == SyntaxKind::TerminalImplicits {
24647 Some(Self::from_syntax_node(db, node))
24648 } else {
24649 None
24650 }
24651 }
24652 fn as_syntax_node(&self) -> SyntaxNode {
24653 self.node.clone()
24654 }
24655 fn stable_ptr(&self) -> Self::StablePtr {
24656 TerminalImplicitsPtr(self.node.0.stable_ptr)
24657 }
24658}
24659impl From<&TerminalImplicits> for SyntaxStablePtrId {
24660 fn from(node: &TerminalImplicits) -> Self {
24661 node.stable_ptr().untyped()
24662 }
24663}
24664#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24665pub struct TokenLet {
24666 node: SyntaxNode,
24667}
24668impl Token for TokenLet {
24669 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24670 TokenLetGreen(
24671 Arc::new(GreenNode {
24672 kind: SyntaxKind::TokenLet,
24673 details: GreenNodeDetails::Token(text),
24674 })
24675 .intern(db),
24676 )
24677 }
24678 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24679 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24680 .clone()
24681 }
24682}
24683#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24684pub struct TokenLetPtr(pub SyntaxStablePtrId);
24685impl TypedStablePtr for TokenLetPtr {
24686 type SyntaxNode = TokenLet;
24687 fn untyped(&self) -> SyntaxStablePtrId {
24688 self.0
24689 }
24690 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLet {
24691 TokenLet::from_syntax_node(db, self.0.lookup(db))
24692 }
24693}
24694impl From<TokenLetPtr> for SyntaxStablePtrId {
24695 fn from(ptr: TokenLetPtr) -> Self {
24696 ptr.untyped()
24697 }
24698}
24699#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24700pub struct TokenLetGreen(pub GreenId);
24701impl TokenLetGreen {
24702 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24703 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24704 }
24705}
24706impl TypedSyntaxNode for TokenLet {
24707 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLet);
24708 type StablePtr = TokenLetPtr;
24709 type Green = TokenLetGreen;
24710 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24711 TokenLetGreen(
24712 Arc::new(GreenNode {
24713 kind: SyntaxKind::TokenMissing,
24714 details: GreenNodeDetails::Token("".into()),
24715 })
24716 .intern(db),
24717 )
24718 }
24719 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24720 match node.0.green.lookup_intern(db).details {
24721 GreenNodeDetails::Token(_) => Self { node },
24722 GreenNodeDetails::Node { .. } => {
24723 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLet)
24724 }
24725 }
24726 }
24727 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24728 match node.0.green.lookup_intern(db).details {
24729 GreenNodeDetails::Token(_) => Some(Self { node }),
24730 GreenNodeDetails::Node { .. } => None,
24731 }
24732 }
24733 fn as_syntax_node(&self) -> SyntaxNode {
24734 self.node.clone()
24735 }
24736 fn stable_ptr(&self) -> Self::StablePtr {
24737 TokenLetPtr(self.node.0.stable_ptr)
24738 }
24739}
24740impl From<&TokenLet> for SyntaxStablePtrId {
24741 fn from(node: &TokenLet) -> Self {
24742 node.stable_ptr().untyped()
24743 }
24744}
24745#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24746pub struct TerminalLet {
24747 node: SyntaxNode,
24748 children: Arc<[SyntaxNode]>,
24749}
24750impl Terminal for TerminalLet {
24751 const KIND: SyntaxKind = SyntaxKind::TerminalLet;
24752 type TokenType = TokenLet;
24753 fn new_green(
24754 db: &dyn SyntaxGroup,
24755 leading_trivia: TriviaGreen,
24756 token: <<TerminalLet as Terminal>::TokenType as TypedSyntaxNode>::Green,
24757 trailing_trivia: TriviaGreen,
24758 ) -> Self::Green {
24759 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24760 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24761 TerminalLetGreen(
24762 Arc::new(GreenNode {
24763 kind: SyntaxKind::TerminalLet,
24764 details: GreenNodeDetails::Node { children, width },
24765 })
24766 .intern(db),
24767 )
24768 }
24769 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24770 self.token(db).text(db)
24771 }
24772}
24773impl TerminalLet {
24774 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24775 Trivia::from_syntax_node(db, self.children[0].clone())
24776 }
24777 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLet {
24778 TokenLet::from_syntax_node(db, self.children[1].clone())
24779 }
24780 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24781 Trivia::from_syntax_node(db, self.children[2].clone())
24782 }
24783}
24784#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24785pub struct TerminalLetPtr(pub SyntaxStablePtrId);
24786impl TerminalLetPtr {}
24787impl TypedStablePtr for TerminalLetPtr {
24788 type SyntaxNode = TerminalLet;
24789 fn untyped(&self) -> SyntaxStablePtrId {
24790 self.0
24791 }
24792 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLet {
24793 TerminalLet::from_syntax_node(db, self.0.lookup(db))
24794 }
24795}
24796impl From<TerminalLetPtr> for SyntaxStablePtrId {
24797 fn from(ptr: TerminalLetPtr) -> Self {
24798 ptr.untyped()
24799 }
24800}
24801#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24802pub struct TerminalLetGreen(pub GreenId);
24803impl TypedSyntaxNode for TerminalLet {
24804 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLet);
24805 type StablePtr = TerminalLetPtr;
24806 type Green = TerminalLetGreen;
24807 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24808 TerminalLetGreen(
24809 Arc::new(GreenNode {
24810 kind: SyntaxKind::TerminalLet,
24811 details: GreenNodeDetails::Node {
24812 children: vec![
24813 Trivia::missing(db).0,
24814 TokenLet::missing(db).0,
24815 Trivia::missing(db).0,
24816 ],
24817 width: TextWidth::default(),
24818 },
24819 })
24820 .intern(db),
24821 )
24822 }
24823 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24824 let kind = node.kind(db);
24825 assert_eq!(
24826 kind,
24827 SyntaxKind::TerminalLet,
24828 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24829 kind,
24830 SyntaxKind::TerminalLet
24831 );
24832 let children = db.get_children(node.clone());
24833 Self { node, children }
24834 }
24835 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24836 let kind = node.kind(db);
24837 if kind == SyntaxKind::TerminalLet { Some(Self::from_syntax_node(db, node)) } else { None }
24838 }
24839 fn as_syntax_node(&self) -> SyntaxNode {
24840 self.node.clone()
24841 }
24842 fn stable_ptr(&self) -> Self::StablePtr {
24843 TerminalLetPtr(self.node.0.stable_ptr)
24844 }
24845}
24846impl From<&TerminalLet> for SyntaxStablePtrId {
24847 fn from(node: &TerminalLet) -> Self {
24848 node.stable_ptr().untyped()
24849 }
24850}
24851#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24852pub struct TokenMatch {
24853 node: SyntaxNode,
24854}
24855impl Token for TokenMatch {
24856 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24857 TokenMatchGreen(
24858 Arc::new(GreenNode {
24859 kind: SyntaxKind::TokenMatch,
24860 details: GreenNodeDetails::Token(text),
24861 })
24862 .intern(db),
24863 )
24864 }
24865 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24866 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24867 .clone()
24868 }
24869}
24870#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24871pub struct TokenMatchPtr(pub SyntaxStablePtrId);
24872impl TypedStablePtr for TokenMatchPtr {
24873 type SyntaxNode = TokenMatch;
24874 fn untyped(&self) -> SyntaxStablePtrId {
24875 self.0
24876 }
24877 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMatch {
24878 TokenMatch::from_syntax_node(db, self.0.lookup(db))
24879 }
24880}
24881impl From<TokenMatchPtr> for SyntaxStablePtrId {
24882 fn from(ptr: TokenMatchPtr) -> Self {
24883 ptr.untyped()
24884 }
24885}
24886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24887pub struct TokenMatchGreen(pub GreenId);
24888impl TokenMatchGreen {
24889 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24890 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24891 }
24892}
24893impl TypedSyntaxNode for TokenMatch {
24894 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMatch);
24895 type StablePtr = TokenMatchPtr;
24896 type Green = TokenMatchGreen;
24897 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24898 TokenMatchGreen(
24899 Arc::new(GreenNode {
24900 kind: SyntaxKind::TokenMissing,
24901 details: GreenNodeDetails::Token("".into()),
24902 })
24903 .intern(db),
24904 )
24905 }
24906 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24907 match node.0.green.lookup_intern(db).details {
24908 GreenNodeDetails::Token(_) => Self { node },
24909 GreenNodeDetails::Node { .. } => {
24910 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMatch)
24911 }
24912 }
24913 }
24914 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
24915 match node.0.green.lookup_intern(db).details {
24916 GreenNodeDetails::Token(_) => Some(Self { node }),
24917 GreenNodeDetails::Node { .. } => None,
24918 }
24919 }
24920 fn as_syntax_node(&self) -> SyntaxNode {
24921 self.node.clone()
24922 }
24923 fn stable_ptr(&self) -> Self::StablePtr {
24924 TokenMatchPtr(self.node.0.stable_ptr)
24925 }
24926}
24927impl From<&TokenMatch> for SyntaxStablePtrId {
24928 fn from(node: &TokenMatch) -> Self {
24929 node.stable_ptr().untyped()
24930 }
24931}
24932#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24933pub struct TerminalMatch {
24934 node: SyntaxNode,
24935 children: Arc<[SyntaxNode]>,
24936}
24937impl Terminal for TerminalMatch {
24938 const KIND: SyntaxKind = SyntaxKind::TerminalMatch;
24939 type TokenType = TokenMatch;
24940 fn new_green(
24941 db: &dyn SyntaxGroup,
24942 leading_trivia: TriviaGreen,
24943 token: <<TerminalMatch as Terminal>::TokenType as TypedSyntaxNode>::Green,
24944 trailing_trivia: TriviaGreen,
24945 ) -> Self::Green {
24946 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24947 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24948 TerminalMatchGreen(
24949 Arc::new(GreenNode {
24950 kind: SyntaxKind::TerminalMatch,
24951 details: GreenNodeDetails::Node { children, width },
24952 })
24953 .intern(db),
24954 )
24955 }
24956 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24957 self.token(db).text(db)
24958 }
24959}
24960impl TerminalMatch {
24961 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24962 Trivia::from_syntax_node(db, self.children[0].clone())
24963 }
24964 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMatch {
24965 TokenMatch::from_syntax_node(db, self.children[1].clone())
24966 }
24967 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24968 Trivia::from_syntax_node(db, self.children[2].clone())
24969 }
24970}
24971#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24972pub struct TerminalMatchPtr(pub SyntaxStablePtrId);
24973impl TerminalMatchPtr {}
24974impl TypedStablePtr for TerminalMatchPtr {
24975 type SyntaxNode = TerminalMatch;
24976 fn untyped(&self) -> SyntaxStablePtrId {
24977 self.0
24978 }
24979 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMatch {
24980 TerminalMatch::from_syntax_node(db, self.0.lookup(db))
24981 }
24982}
24983impl From<TerminalMatchPtr> for SyntaxStablePtrId {
24984 fn from(ptr: TerminalMatchPtr) -> Self {
24985 ptr.untyped()
24986 }
24987}
24988#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24989pub struct TerminalMatchGreen(pub GreenId);
24990impl TypedSyntaxNode for TerminalMatch {
24991 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMatch);
24992 type StablePtr = TerminalMatchPtr;
24993 type Green = TerminalMatchGreen;
24994 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24995 TerminalMatchGreen(
24996 Arc::new(GreenNode {
24997 kind: SyntaxKind::TerminalMatch,
24998 details: GreenNodeDetails::Node {
24999 children: vec![
25000 Trivia::missing(db).0,
25001 TokenMatch::missing(db).0,
25002 Trivia::missing(db).0,
25003 ],
25004 width: TextWidth::default(),
25005 },
25006 })
25007 .intern(db),
25008 )
25009 }
25010 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25011 let kind = node.kind(db);
25012 assert_eq!(
25013 kind,
25014 SyntaxKind::TerminalMatch,
25015 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25016 kind,
25017 SyntaxKind::TerminalMatch
25018 );
25019 let children = db.get_children(node.clone());
25020 Self { node, children }
25021 }
25022 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25023 let kind = node.kind(db);
25024 if kind == SyntaxKind::TerminalMatch {
25025 Some(Self::from_syntax_node(db, node))
25026 } else {
25027 None
25028 }
25029 }
25030 fn as_syntax_node(&self) -> SyntaxNode {
25031 self.node.clone()
25032 }
25033 fn stable_ptr(&self) -> Self::StablePtr {
25034 TerminalMatchPtr(self.node.0.stable_ptr)
25035 }
25036}
25037impl From<&TerminalMatch> for SyntaxStablePtrId {
25038 fn from(node: &TerminalMatch) -> Self {
25039 node.stable_ptr().untyped()
25040 }
25041}
25042#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25043pub struct TokenModule {
25044 node: SyntaxNode,
25045}
25046impl Token for TokenModule {
25047 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25048 TokenModuleGreen(
25049 Arc::new(GreenNode {
25050 kind: SyntaxKind::TokenModule,
25051 details: GreenNodeDetails::Token(text),
25052 })
25053 .intern(db),
25054 )
25055 }
25056 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25057 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25058 .clone()
25059 }
25060}
25061#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25062pub struct TokenModulePtr(pub SyntaxStablePtrId);
25063impl TypedStablePtr for TokenModulePtr {
25064 type SyntaxNode = TokenModule;
25065 fn untyped(&self) -> SyntaxStablePtrId {
25066 self.0
25067 }
25068 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenModule {
25069 TokenModule::from_syntax_node(db, self.0.lookup(db))
25070 }
25071}
25072impl From<TokenModulePtr> for SyntaxStablePtrId {
25073 fn from(ptr: TokenModulePtr) -> Self {
25074 ptr.untyped()
25075 }
25076}
25077#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25078pub struct TokenModuleGreen(pub GreenId);
25079impl TokenModuleGreen {
25080 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25081 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25082 }
25083}
25084impl TypedSyntaxNode for TokenModule {
25085 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenModule);
25086 type StablePtr = TokenModulePtr;
25087 type Green = TokenModuleGreen;
25088 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25089 TokenModuleGreen(
25090 Arc::new(GreenNode {
25091 kind: SyntaxKind::TokenMissing,
25092 details: GreenNodeDetails::Token("".into()),
25093 })
25094 .intern(db),
25095 )
25096 }
25097 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25098 match node.0.green.lookup_intern(db).details {
25099 GreenNodeDetails::Token(_) => Self { node },
25100 GreenNodeDetails::Node { .. } => {
25101 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenModule)
25102 }
25103 }
25104 }
25105 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25106 match node.0.green.lookup_intern(db).details {
25107 GreenNodeDetails::Token(_) => Some(Self { node }),
25108 GreenNodeDetails::Node { .. } => None,
25109 }
25110 }
25111 fn as_syntax_node(&self) -> SyntaxNode {
25112 self.node.clone()
25113 }
25114 fn stable_ptr(&self) -> Self::StablePtr {
25115 TokenModulePtr(self.node.0.stable_ptr)
25116 }
25117}
25118impl From<&TokenModule> for SyntaxStablePtrId {
25119 fn from(node: &TokenModule) -> Self {
25120 node.stable_ptr().untyped()
25121 }
25122}
25123#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25124pub struct TerminalModule {
25125 node: SyntaxNode,
25126 children: Arc<[SyntaxNode]>,
25127}
25128impl Terminal for TerminalModule {
25129 const KIND: SyntaxKind = SyntaxKind::TerminalModule;
25130 type TokenType = TokenModule;
25131 fn new_green(
25132 db: &dyn SyntaxGroup,
25133 leading_trivia: TriviaGreen,
25134 token: <<TerminalModule as Terminal>::TokenType as TypedSyntaxNode>::Green,
25135 trailing_trivia: TriviaGreen,
25136 ) -> Self::Green {
25137 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25138 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25139 TerminalModuleGreen(
25140 Arc::new(GreenNode {
25141 kind: SyntaxKind::TerminalModule,
25142 details: GreenNodeDetails::Node { children, width },
25143 })
25144 .intern(db),
25145 )
25146 }
25147 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25148 self.token(db).text(db)
25149 }
25150}
25151impl TerminalModule {
25152 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25153 Trivia::from_syntax_node(db, self.children[0].clone())
25154 }
25155 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenModule {
25156 TokenModule::from_syntax_node(db, self.children[1].clone())
25157 }
25158 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25159 Trivia::from_syntax_node(db, self.children[2].clone())
25160 }
25161}
25162#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25163pub struct TerminalModulePtr(pub SyntaxStablePtrId);
25164impl TerminalModulePtr {}
25165impl TypedStablePtr for TerminalModulePtr {
25166 type SyntaxNode = TerminalModule;
25167 fn untyped(&self) -> SyntaxStablePtrId {
25168 self.0
25169 }
25170 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalModule {
25171 TerminalModule::from_syntax_node(db, self.0.lookup(db))
25172 }
25173}
25174impl From<TerminalModulePtr> for SyntaxStablePtrId {
25175 fn from(ptr: TerminalModulePtr) -> Self {
25176 ptr.untyped()
25177 }
25178}
25179#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25180pub struct TerminalModuleGreen(pub GreenId);
25181impl TypedSyntaxNode for TerminalModule {
25182 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalModule);
25183 type StablePtr = TerminalModulePtr;
25184 type Green = TerminalModuleGreen;
25185 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25186 TerminalModuleGreen(
25187 Arc::new(GreenNode {
25188 kind: SyntaxKind::TerminalModule,
25189 details: GreenNodeDetails::Node {
25190 children: vec![
25191 Trivia::missing(db).0,
25192 TokenModule::missing(db).0,
25193 Trivia::missing(db).0,
25194 ],
25195 width: TextWidth::default(),
25196 },
25197 })
25198 .intern(db),
25199 )
25200 }
25201 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25202 let kind = node.kind(db);
25203 assert_eq!(
25204 kind,
25205 SyntaxKind::TerminalModule,
25206 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25207 kind,
25208 SyntaxKind::TerminalModule
25209 );
25210 let children = db.get_children(node.clone());
25211 Self { node, children }
25212 }
25213 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25214 let kind = node.kind(db);
25215 if kind == SyntaxKind::TerminalModule {
25216 Some(Self::from_syntax_node(db, node))
25217 } else {
25218 None
25219 }
25220 }
25221 fn as_syntax_node(&self) -> SyntaxNode {
25222 self.node.clone()
25223 }
25224 fn stable_ptr(&self) -> Self::StablePtr {
25225 TerminalModulePtr(self.node.0.stable_ptr)
25226 }
25227}
25228impl From<&TerminalModule> for SyntaxStablePtrId {
25229 fn from(node: &TerminalModule) -> Self {
25230 node.stable_ptr().untyped()
25231 }
25232}
25233#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25234pub struct TokenMut {
25235 node: SyntaxNode,
25236}
25237impl Token for TokenMut {
25238 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25239 TokenMutGreen(
25240 Arc::new(GreenNode {
25241 kind: SyntaxKind::TokenMut,
25242 details: GreenNodeDetails::Token(text),
25243 })
25244 .intern(db),
25245 )
25246 }
25247 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25248 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25249 .clone()
25250 }
25251}
25252#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25253pub struct TokenMutPtr(pub SyntaxStablePtrId);
25254impl TypedStablePtr for TokenMutPtr {
25255 type SyntaxNode = TokenMut;
25256 fn untyped(&self) -> SyntaxStablePtrId {
25257 self.0
25258 }
25259 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMut {
25260 TokenMut::from_syntax_node(db, self.0.lookup(db))
25261 }
25262}
25263impl From<TokenMutPtr> for SyntaxStablePtrId {
25264 fn from(ptr: TokenMutPtr) -> Self {
25265 ptr.untyped()
25266 }
25267}
25268#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25269pub struct TokenMutGreen(pub GreenId);
25270impl TokenMutGreen {
25271 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25272 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25273 }
25274}
25275impl TypedSyntaxNode for TokenMut {
25276 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMut);
25277 type StablePtr = TokenMutPtr;
25278 type Green = TokenMutGreen;
25279 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25280 TokenMutGreen(
25281 Arc::new(GreenNode {
25282 kind: SyntaxKind::TokenMissing,
25283 details: GreenNodeDetails::Token("".into()),
25284 })
25285 .intern(db),
25286 )
25287 }
25288 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25289 match node.0.green.lookup_intern(db).details {
25290 GreenNodeDetails::Token(_) => Self { node },
25291 GreenNodeDetails::Node { .. } => {
25292 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMut)
25293 }
25294 }
25295 }
25296 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25297 match node.0.green.lookup_intern(db).details {
25298 GreenNodeDetails::Token(_) => Some(Self { node }),
25299 GreenNodeDetails::Node { .. } => None,
25300 }
25301 }
25302 fn as_syntax_node(&self) -> SyntaxNode {
25303 self.node.clone()
25304 }
25305 fn stable_ptr(&self) -> Self::StablePtr {
25306 TokenMutPtr(self.node.0.stable_ptr)
25307 }
25308}
25309impl From<&TokenMut> for SyntaxStablePtrId {
25310 fn from(node: &TokenMut) -> Self {
25311 node.stable_ptr().untyped()
25312 }
25313}
25314#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25315pub struct TerminalMut {
25316 node: SyntaxNode,
25317 children: Arc<[SyntaxNode]>,
25318}
25319impl Terminal for TerminalMut {
25320 const KIND: SyntaxKind = SyntaxKind::TerminalMut;
25321 type TokenType = TokenMut;
25322 fn new_green(
25323 db: &dyn SyntaxGroup,
25324 leading_trivia: TriviaGreen,
25325 token: <<TerminalMut as Terminal>::TokenType as TypedSyntaxNode>::Green,
25326 trailing_trivia: TriviaGreen,
25327 ) -> Self::Green {
25328 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25329 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25330 TerminalMutGreen(
25331 Arc::new(GreenNode {
25332 kind: SyntaxKind::TerminalMut,
25333 details: GreenNodeDetails::Node { children, width },
25334 })
25335 .intern(db),
25336 )
25337 }
25338 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25339 self.token(db).text(db)
25340 }
25341}
25342impl TerminalMut {
25343 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25344 Trivia::from_syntax_node(db, self.children[0].clone())
25345 }
25346 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMut {
25347 TokenMut::from_syntax_node(db, self.children[1].clone())
25348 }
25349 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25350 Trivia::from_syntax_node(db, self.children[2].clone())
25351 }
25352}
25353#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25354pub struct TerminalMutPtr(pub SyntaxStablePtrId);
25355impl TerminalMutPtr {}
25356impl TypedStablePtr for TerminalMutPtr {
25357 type SyntaxNode = TerminalMut;
25358 fn untyped(&self) -> SyntaxStablePtrId {
25359 self.0
25360 }
25361 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMut {
25362 TerminalMut::from_syntax_node(db, self.0.lookup(db))
25363 }
25364}
25365impl From<TerminalMutPtr> for SyntaxStablePtrId {
25366 fn from(ptr: TerminalMutPtr) -> Self {
25367 ptr.untyped()
25368 }
25369}
25370#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25371pub struct TerminalMutGreen(pub GreenId);
25372impl TypedSyntaxNode for TerminalMut {
25373 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMut);
25374 type StablePtr = TerminalMutPtr;
25375 type Green = TerminalMutGreen;
25376 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25377 TerminalMutGreen(
25378 Arc::new(GreenNode {
25379 kind: SyntaxKind::TerminalMut,
25380 details: GreenNodeDetails::Node {
25381 children: vec![
25382 Trivia::missing(db).0,
25383 TokenMut::missing(db).0,
25384 Trivia::missing(db).0,
25385 ],
25386 width: TextWidth::default(),
25387 },
25388 })
25389 .intern(db),
25390 )
25391 }
25392 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25393 let kind = node.kind(db);
25394 assert_eq!(
25395 kind,
25396 SyntaxKind::TerminalMut,
25397 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25398 kind,
25399 SyntaxKind::TerminalMut
25400 );
25401 let children = db.get_children(node.clone());
25402 Self { node, children }
25403 }
25404 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25405 let kind = node.kind(db);
25406 if kind == SyntaxKind::TerminalMut { Some(Self::from_syntax_node(db, node)) } else { None }
25407 }
25408 fn as_syntax_node(&self) -> SyntaxNode {
25409 self.node.clone()
25410 }
25411 fn stable_ptr(&self) -> Self::StablePtr {
25412 TerminalMutPtr(self.node.0.stable_ptr)
25413 }
25414}
25415impl From<&TerminalMut> for SyntaxStablePtrId {
25416 fn from(node: &TerminalMut) -> Self {
25417 node.stable_ptr().untyped()
25418 }
25419}
25420#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25421pub struct TokenNoPanic {
25422 node: SyntaxNode,
25423}
25424impl Token for TokenNoPanic {
25425 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25426 TokenNoPanicGreen(
25427 Arc::new(GreenNode {
25428 kind: SyntaxKind::TokenNoPanic,
25429 details: GreenNodeDetails::Token(text),
25430 })
25431 .intern(db),
25432 )
25433 }
25434 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25435 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25436 .clone()
25437 }
25438}
25439#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25440pub struct TokenNoPanicPtr(pub SyntaxStablePtrId);
25441impl TypedStablePtr for TokenNoPanicPtr {
25442 type SyntaxNode = TokenNoPanic;
25443 fn untyped(&self) -> SyntaxStablePtrId {
25444 self.0
25445 }
25446 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNoPanic {
25447 TokenNoPanic::from_syntax_node(db, self.0.lookup(db))
25448 }
25449}
25450impl From<TokenNoPanicPtr> for SyntaxStablePtrId {
25451 fn from(ptr: TokenNoPanicPtr) -> Self {
25452 ptr.untyped()
25453 }
25454}
25455#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25456pub struct TokenNoPanicGreen(pub GreenId);
25457impl TokenNoPanicGreen {
25458 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25459 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25460 }
25461}
25462impl TypedSyntaxNode for TokenNoPanic {
25463 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNoPanic);
25464 type StablePtr = TokenNoPanicPtr;
25465 type Green = TokenNoPanicGreen;
25466 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25467 TokenNoPanicGreen(
25468 Arc::new(GreenNode {
25469 kind: SyntaxKind::TokenMissing,
25470 details: GreenNodeDetails::Token("".into()),
25471 })
25472 .intern(db),
25473 )
25474 }
25475 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25476 match node.0.green.lookup_intern(db).details {
25477 GreenNodeDetails::Token(_) => Self { node },
25478 GreenNodeDetails::Node { .. } => {
25479 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNoPanic)
25480 }
25481 }
25482 }
25483 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25484 match node.0.green.lookup_intern(db).details {
25485 GreenNodeDetails::Token(_) => Some(Self { node }),
25486 GreenNodeDetails::Node { .. } => None,
25487 }
25488 }
25489 fn as_syntax_node(&self) -> SyntaxNode {
25490 self.node.clone()
25491 }
25492 fn stable_ptr(&self) -> Self::StablePtr {
25493 TokenNoPanicPtr(self.node.0.stable_ptr)
25494 }
25495}
25496impl From<&TokenNoPanic> for SyntaxStablePtrId {
25497 fn from(node: &TokenNoPanic) -> Self {
25498 node.stable_ptr().untyped()
25499 }
25500}
25501#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25502pub struct TerminalNoPanic {
25503 node: SyntaxNode,
25504 children: Arc<[SyntaxNode]>,
25505}
25506impl Terminal for TerminalNoPanic {
25507 const KIND: SyntaxKind = SyntaxKind::TerminalNoPanic;
25508 type TokenType = TokenNoPanic;
25509 fn new_green(
25510 db: &dyn SyntaxGroup,
25511 leading_trivia: TriviaGreen,
25512 token: <<TerminalNoPanic as Terminal>::TokenType as TypedSyntaxNode>::Green,
25513 trailing_trivia: TriviaGreen,
25514 ) -> Self::Green {
25515 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25516 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25517 TerminalNoPanicGreen(
25518 Arc::new(GreenNode {
25519 kind: SyntaxKind::TerminalNoPanic,
25520 details: GreenNodeDetails::Node { children, width },
25521 })
25522 .intern(db),
25523 )
25524 }
25525 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25526 self.token(db).text(db)
25527 }
25528}
25529impl TerminalNoPanic {
25530 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25531 Trivia::from_syntax_node(db, self.children[0].clone())
25532 }
25533 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNoPanic {
25534 TokenNoPanic::from_syntax_node(db, self.children[1].clone())
25535 }
25536 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25537 Trivia::from_syntax_node(db, self.children[2].clone())
25538 }
25539}
25540#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25541pub struct TerminalNoPanicPtr(pub SyntaxStablePtrId);
25542impl TerminalNoPanicPtr {}
25543impl TypedStablePtr for TerminalNoPanicPtr {
25544 type SyntaxNode = TerminalNoPanic;
25545 fn untyped(&self) -> SyntaxStablePtrId {
25546 self.0
25547 }
25548 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNoPanic {
25549 TerminalNoPanic::from_syntax_node(db, self.0.lookup(db))
25550 }
25551}
25552impl From<TerminalNoPanicPtr> for SyntaxStablePtrId {
25553 fn from(ptr: TerminalNoPanicPtr) -> Self {
25554 ptr.untyped()
25555 }
25556}
25557#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25558pub struct TerminalNoPanicGreen(pub GreenId);
25559impl TypedSyntaxNode for TerminalNoPanic {
25560 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNoPanic);
25561 type StablePtr = TerminalNoPanicPtr;
25562 type Green = TerminalNoPanicGreen;
25563 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25564 TerminalNoPanicGreen(
25565 Arc::new(GreenNode {
25566 kind: SyntaxKind::TerminalNoPanic,
25567 details: GreenNodeDetails::Node {
25568 children: vec![
25569 Trivia::missing(db).0,
25570 TokenNoPanic::missing(db).0,
25571 Trivia::missing(db).0,
25572 ],
25573 width: TextWidth::default(),
25574 },
25575 })
25576 .intern(db),
25577 )
25578 }
25579 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25580 let kind = node.kind(db);
25581 assert_eq!(
25582 kind,
25583 SyntaxKind::TerminalNoPanic,
25584 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25585 kind,
25586 SyntaxKind::TerminalNoPanic
25587 );
25588 let children = db.get_children(node.clone());
25589 Self { node, children }
25590 }
25591 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25592 let kind = node.kind(db);
25593 if kind == SyntaxKind::TerminalNoPanic {
25594 Some(Self::from_syntax_node(db, node))
25595 } else {
25596 None
25597 }
25598 }
25599 fn as_syntax_node(&self) -> SyntaxNode {
25600 self.node.clone()
25601 }
25602 fn stable_ptr(&self) -> Self::StablePtr {
25603 TerminalNoPanicPtr(self.node.0.stable_ptr)
25604 }
25605}
25606impl From<&TerminalNoPanic> for SyntaxStablePtrId {
25607 fn from(node: &TerminalNoPanic) -> Self {
25608 node.stable_ptr().untyped()
25609 }
25610}
25611#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25612pub struct TokenOf {
25613 node: SyntaxNode,
25614}
25615impl Token for TokenOf {
25616 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25617 TokenOfGreen(
25618 Arc::new(GreenNode {
25619 kind: SyntaxKind::TokenOf,
25620 details: GreenNodeDetails::Token(text),
25621 })
25622 .intern(db),
25623 )
25624 }
25625 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25626 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25627 .clone()
25628 }
25629}
25630#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25631pub struct TokenOfPtr(pub SyntaxStablePtrId);
25632impl TypedStablePtr for TokenOfPtr {
25633 type SyntaxNode = TokenOf;
25634 fn untyped(&self) -> SyntaxStablePtrId {
25635 self.0
25636 }
25637 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOf {
25638 TokenOf::from_syntax_node(db, self.0.lookup(db))
25639 }
25640}
25641impl From<TokenOfPtr> for SyntaxStablePtrId {
25642 fn from(ptr: TokenOfPtr) -> Self {
25643 ptr.untyped()
25644 }
25645}
25646#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25647pub struct TokenOfGreen(pub GreenId);
25648impl TokenOfGreen {
25649 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25650 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25651 }
25652}
25653impl TypedSyntaxNode for TokenOf {
25654 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOf);
25655 type StablePtr = TokenOfPtr;
25656 type Green = TokenOfGreen;
25657 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25658 TokenOfGreen(
25659 Arc::new(GreenNode {
25660 kind: SyntaxKind::TokenMissing,
25661 details: GreenNodeDetails::Token("".into()),
25662 })
25663 .intern(db),
25664 )
25665 }
25666 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25667 match node.0.green.lookup_intern(db).details {
25668 GreenNodeDetails::Token(_) => Self { node },
25669 GreenNodeDetails::Node { .. } => {
25670 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOf)
25671 }
25672 }
25673 }
25674 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25675 match node.0.green.lookup_intern(db).details {
25676 GreenNodeDetails::Token(_) => Some(Self { node }),
25677 GreenNodeDetails::Node { .. } => None,
25678 }
25679 }
25680 fn as_syntax_node(&self) -> SyntaxNode {
25681 self.node.clone()
25682 }
25683 fn stable_ptr(&self) -> Self::StablePtr {
25684 TokenOfPtr(self.node.0.stable_ptr)
25685 }
25686}
25687impl From<&TokenOf> for SyntaxStablePtrId {
25688 fn from(node: &TokenOf) -> Self {
25689 node.stable_ptr().untyped()
25690 }
25691}
25692#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25693pub struct TerminalOf {
25694 node: SyntaxNode,
25695 children: Arc<[SyntaxNode]>,
25696}
25697impl Terminal for TerminalOf {
25698 const KIND: SyntaxKind = SyntaxKind::TerminalOf;
25699 type TokenType = TokenOf;
25700 fn new_green(
25701 db: &dyn SyntaxGroup,
25702 leading_trivia: TriviaGreen,
25703 token: <<TerminalOf as Terminal>::TokenType as TypedSyntaxNode>::Green,
25704 trailing_trivia: TriviaGreen,
25705 ) -> Self::Green {
25706 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25707 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25708 TerminalOfGreen(
25709 Arc::new(GreenNode {
25710 kind: SyntaxKind::TerminalOf,
25711 details: GreenNodeDetails::Node { children, width },
25712 })
25713 .intern(db),
25714 )
25715 }
25716 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25717 self.token(db).text(db)
25718 }
25719}
25720impl TerminalOf {
25721 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25722 Trivia::from_syntax_node(db, self.children[0].clone())
25723 }
25724 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOf {
25725 TokenOf::from_syntax_node(db, self.children[1].clone())
25726 }
25727 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25728 Trivia::from_syntax_node(db, self.children[2].clone())
25729 }
25730}
25731#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25732pub struct TerminalOfPtr(pub SyntaxStablePtrId);
25733impl TerminalOfPtr {}
25734impl TypedStablePtr for TerminalOfPtr {
25735 type SyntaxNode = TerminalOf;
25736 fn untyped(&self) -> SyntaxStablePtrId {
25737 self.0
25738 }
25739 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOf {
25740 TerminalOf::from_syntax_node(db, self.0.lookup(db))
25741 }
25742}
25743impl From<TerminalOfPtr> for SyntaxStablePtrId {
25744 fn from(ptr: TerminalOfPtr) -> Self {
25745 ptr.untyped()
25746 }
25747}
25748#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25749pub struct TerminalOfGreen(pub GreenId);
25750impl TypedSyntaxNode for TerminalOf {
25751 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOf);
25752 type StablePtr = TerminalOfPtr;
25753 type Green = TerminalOfGreen;
25754 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25755 TerminalOfGreen(
25756 Arc::new(GreenNode {
25757 kind: SyntaxKind::TerminalOf,
25758 details: GreenNodeDetails::Node {
25759 children: vec![
25760 Trivia::missing(db).0,
25761 TokenOf::missing(db).0,
25762 Trivia::missing(db).0,
25763 ],
25764 width: TextWidth::default(),
25765 },
25766 })
25767 .intern(db),
25768 )
25769 }
25770 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25771 let kind = node.kind(db);
25772 assert_eq!(
25773 kind,
25774 SyntaxKind::TerminalOf,
25775 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25776 kind,
25777 SyntaxKind::TerminalOf
25778 );
25779 let children = db.get_children(node.clone());
25780 Self { node, children }
25781 }
25782 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25783 let kind = node.kind(db);
25784 if kind == SyntaxKind::TerminalOf { Some(Self::from_syntax_node(db, node)) } else { None }
25785 }
25786 fn as_syntax_node(&self) -> SyntaxNode {
25787 self.node.clone()
25788 }
25789 fn stable_ptr(&self) -> Self::StablePtr {
25790 TerminalOfPtr(self.node.0.stable_ptr)
25791 }
25792}
25793impl From<&TerminalOf> for SyntaxStablePtrId {
25794 fn from(node: &TerminalOf) -> Self {
25795 node.stable_ptr().untyped()
25796 }
25797}
25798#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25799pub struct TokenRef {
25800 node: SyntaxNode,
25801}
25802impl Token for TokenRef {
25803 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25804 TokenRefGreen(
25805 Arc::new(GreenNode {
25806 kind: SyntaxKind::TokenRef,
25807 details: GreenNodeDetails::Token(text),
25808 })
25809 .intern(db),
25810 )
25811 }
25812 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25813 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25814 .clone()
25815 }
25816}
25817#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25818pub struct TokenRefPtr(pub SyntaxStablePtrId);
25819impl TypedStablePtr for TokenRefPtr {
25820 type SyntaxNode = TokenRef;
25821 fn untyped(&self) -> SyntaxStablePtrId {
25822 self.0
25823 }
25824 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRef {
25825 TokenRef::from_syntax_node(db, self.0.lookup(db))
25826 }
25827}
25828impl From<TokenRefPtr> for SyntaxStablePtrId {
25829 fn from(ptr: TokenRefPtr) -> Self {
25830 ptr.untyped()
25831 }
25832}
25833#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25834pub struct TokenRefGreen(pub GreenId);
25835impl TokenRefGreen {
25836 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25837 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25838 }
25839}
25840impl TypedSyntaxNode for TokenRef {
25841 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRef);
25842 type StablePtr = TokenRefPtr;
25843 type Green = TokenRefGreen;
25844 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25845 TokenRefGreen(
25846 Arc::new(GreenNode {
25847 kind: SyntaxKind::TokenMissing,
25848 details: GreenNodeDetails::Token("".into()),
25849 })
25850 .intern(db),
25851 )
25852 }
25853 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25854 match node.0.green.lookup_intern(db).details {
25855 GreenNodeDetails::Token(_) => Self { node },
25856 GreenNodeDetails::Node { .. } => {
25857 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRef)
25858 }
25859 }
25860 }
25861 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25862 match node.0.green.lookup_intern(db).details {
25863 GreenNodeDetails::Token(_) => Some(Self { node }),
25864 GreenNodeDetails::Node { .. } => None,
25865 }
25866 }
25867 fn as_syntax_node(&self) -> SyntaxNode {
25868 self.node.clone()
25869 }
25870 fn stable_ptr(&self) -> Self::StablePtr {
25871 TokenRefPtr(self.node.0.stable_ptr)
25872 }
25873}
25874impl From<&TokenRef> for SyntaxStablePtrId {
25875 fn from(node: &TokenRef) -> Self {
25876 node.stable_ptr().untyped()
25877 }
25878}
25879#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25880pub struct TerminalRef {
25881 node: SyntaxNode,
25882 children: Arc<[SyntaxNode]>,
25883}
25884impl Terminal for TerminalRef {
25885 const KIND: SyntaxKind = SyntaxKind::TerminalRef;
25886 type TokenType = TokenRef;
25887 fn new_green(
25888 db: &dyn SyntaxGroup,
25889 leading_trivia: TriviaGreen,
25890 token: <<TerminalRef as Terminal>::TokenType as TypedSyntaxNode>::Green,
25891 trailing_trivia: TriviaGreen,
25892 ) -> Self::Green {
25893 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25894 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25895 TerminalRefGreen(
25896 Arc::new(GreenNode {
25897 kind: SyntaxKind::TerminalRef,
25898 details: GreenNodeDetails::Node { children, width },
25899 })
25900 .intern(db),
25901 )
25902 }
25903 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25904 self.token(db).text(db)
25905 }
25906}
25907impl TerminalRef {
25908 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25909 Trivia::from_syntax_node(db, self.children[0].clone())
25910 }
25911 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRef {
25912 TokenRef::from_syntax_node(db, self.children[1].clone())
25913 }
25914 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25915 Trivia::from_syntax_node(db, self.children[2].clone())
25916 }
25917}
25918#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25919pub struct TerminalRefPtr(pub SyntaxStablePtrId);
25920impl TerminalRefPtr {}
25921impl TypedStablePtr for TerminalRefPtr {
25922 type SyntaxNode = TerminalRef;
25923 fn untyped(&self) -> SyntaxStablePtrId {
25924 self.0
25925 }
25926 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRef {
25927 TerminalRef::from_syntax_node(db, self.0.lookup(db))
25928 }
25929}
25930impl From<TerminalRefPtr> for SyntaxStablePtrId {
25931 fn from(ptr: TerminalRefPtr) -> Self {
25932 ptr.untyped()
25933 }
25934}
25935#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25936pub struct TerminalRefGreen(pub GreenId);
25937impl TypedSyntaxNode for TerminalRef {
25938 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRef);
25939 type StablePtr = TerminalRefPtr;
25940 type Green = TerminalRefGreen;
25941 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25942 TerminalRefGreen(
25943 Arc::new(GreenNode {
25944 kind: SyntaxKind::TerminalRef,
25945 details: GreenNodeDetails::Node {
25946 children: vec![
25947 Trivia::missing(db).0,
25948 TokenRef::missing(db).0,
25949 Trivia::missing(db).0,
25950 ],
25951 width: TextWidth::default(),
25952 },
25953 })
25954 .intern(db),
25955 )
25956 }
25957 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25958 let kind = node.kind(db);
25959 assert_eq!(
25960 kind,
25961 SyntaxKind::TerminalRef,
25962 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25963 kind,
25964 SyntaxKind::TerminalRef
25965 );
25966 let children = db.get_children(node.clone());
25967 Self { node, children }
25968 }
25969 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
25970 let kind = node.kind(db);
25971 if kind == SyntaxKind::TerminalRef { Some(Self::from_syntax_node(db, node)) } else { None }
25972 }
25973 fn as_syntax_node(&self) -> SyntaxNode {
25974 self.node.clone()
25975 }
25976 fn stable_ptr(&self) -> Self::StablePtr {
25977 TerminalRefPtr(self.node.0.stable_ptr)
25978 }
25979}
25980impl From<&TerminalRef> for SyntaxStablePtrId {
25981 fn from(node: &TerminalRef) -> Self {
25982 node.stable_ptr().untyped()
25983 }
25984}
25985#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25986pub struct TokenContinue {
25987 node: SyntaxNode,
25988}
25989impl Token for TokenContinue {
25990 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25991 TokenContinueGreen(
25992 Arc::new(GreenNode {
25993 kind: SyntaxKind::TokenContinue,
25994 details: GreenNodeDetails::Token(text),
25995 })
25996 .intern(db),
25997 )
25998 }
25999 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26000 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26001 .clone()
26002 }
26003}
26004#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26005pub struct TokenContinuePtr(pub SyntaxStablePtrId);
26006impl TypedStablePtr for TokenContinuePtr {
26007 type SyntaxNode = TokenContinue;
26008 fn untyped(&self) -> SyntaxStablePtrId {
26009 self.0
26010 }
26011 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenContinue {
26012 TokenContinue::from_syntax_node(db, self.0.lookup(db))
26013 }
26014}
26015impl From<TokenContinuePtr> for SyntaxStablePtrId {
26016 fn from(ptr: TokenContinuePtr) -> Self {
26017 ptr.untyped()
26018 }
26019}
26020#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26021pub struct TokenContinueGreen(pub GreenId);
26022impl TokenContinueGreen {
26023 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26024 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26025 }
26026}
26027impl TypedSyntaxNode for TokenContinue {
26028 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenContinue);
26029 type StablePtr = TokenContinuePtr;
26030 type Green = TokenContinueGreen;
26031 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26032 TokenContinueGreen(
26033 Arc::new(GreenNode {
26034 kind: SyntaxKind::TokenMissing,
26035 details: GreenNodeDetails::Token("".into()),
26036 })
26037 .intern(db),
26038 )
26039 }
26040 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26041 match node.0.green.lookup_intern(db).details {
26042 GreenNodeDetails::Token(_) => Self { node },
26043 GreenNodeDetails::Node { .. } => {
26044 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenContinue)
26045 }
26046 }
26047 }
26048 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26049 match node.0.green.lookup_intern(db).details {
26050 GreenNodeDetails::Token(_) => Some(Self { node }),
26051 GreenNodeDetails::Node { .. } => None,
26052 }
26053 }
26054 fn as_syntax_node(&self) -> SyntaxNode {
26055 self.node.clone()
26056 }
26057 fn stable_ptr(&self) -> Self::StablePtr {
26058 TokenContinuePtr(self.node.0.stable_ptr)
26059 }
26060}
26061impl From<&TokenContinue> for SyntaxStablePtrId {
26062 fn from(node: &TokenContinue) -> Self {
26063 node.stable_ptr().untyped()
26064 }
26065}
26066#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26067pub struct TerminalContinue {
26068 node: SyntaxNode,
26069 children: Arc<[SyntaxNode]>,
26070}
26071impl Terminal for TerminalContinue {
26072 const KIND: SyntaxKind = SyntaxKind::TerminalContinue;
26073 type TokenType = TokenContinue;
26074 fn new_green(
26075 db: &dyn SyntaxGroup,
26076 leading_trivia: TriviaGreen,
26077 token: <<TerminalContinue as Terminal>::TokenType as TypedSyntaxNode>::Green,
26078 trailing_trivia: TriviaGreen,
26079 ) -> Self::Green {
26080 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26081 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26082 TerminalContinueGreen(
26083 Arc::new(GreenNode {
26084 kind: SyntaxKind::TerminalContinue,
26085 details: GreenNodeDetails::Node { children, width },
26086 })
26087 .intern(db),
26088 )
26089 }
26090 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26091 self.token(db).text(db)
26092 }
26093}
26094impl TerminalContinue {
26095 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26096 Trivia::from_syntax_node(db, self.children[0].clone())
26097 }
26098 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenContinue {
26099 TokenContinue::from_syntax_node(db, self.children[1].clone())
26100 }
26101 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26102 Trivia::from_syntax_node(db, self.children[2].clone())
26103 }
26104}
26105#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26106pub struct TerminalContinuePtr(pub SyntaxStablePtrId);
26107impl TerminalContinuePtr {}
26108impl TypedStablePtr for TerminalContinuePtr {
26109 type SyntaxNode = TerminalContinue;
26110 fn untyped(&self) -> SyntaxStablePtrId {
26111 self.0
26112 }
26113 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalContinue {
26114 TerminalContinue::from_syntax_node(db, self.0.lookup(db))
26115 }
26116}
26117impl From<TerminalContinuePtr> for SyntaxStablePtrId {
26118 fn from(ptr: TerminalContinuePtr) -> Self {
26119 ptr.untyped()
26120 }
26121}
26122#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26123pub struct TerminalContinueGreen(pub GreenId);
26124impl TypedSyntaxNode for TerminalContinue {
26125 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalContinue);
26126 type StablePtr = TerminalContinuePtr;
26127 type Green = TerminalContinueGreen;
26128 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26129 TerminalContinueGreen(
26130 Arc::new(GreenNode {
26131 kind: SyntaxKind::TerminalContinue,
26132 details: GreenNodeDetails::Node {
26133 children: vec![
26134 Trivia::missing(db).0,
26135 TokenContinue::missing(db).0,
26136 Trivia::missing(db).0,
26137 ],
26138 width: TextWidth::default(),
26139 },
26140 })
26141 .intern(db),
26142 )
26143 }
26144 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26145 let kind = node.kind(db);
26146 assert_eq!(
26147 kind,
26148 SyntaxKind::TerminalContinue,
26149 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26150 kind,
26151 SyntaxKind::TerminalContinue
26152 );
26153 let children = db.get_children(node.clone());
26154 Self { node, children }
26155 }
26156 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26157 let kind = node.kind(db);
26158 if kind == SyntaxKind::TerminalContinue {
26159 Some(Self::from_syntax_node(db, node))
26160 } else {
26161 None
26162 }
26163 }
26164 fn as_syntax_node(&self) -> SyntaxNode {
26165 self.node.clone()
26166 }
26167 fn stable_ptr(&self) -> Self::StablePtr {
26168 TerminalContinuePtr(self.node.0.stable_ptr)
26169 }
26170}
26171impl From<&TerminalContinue> for SyntaxStablePtrId {
26172 fn from(node: &TerminalContinue) -> Self {
26173 node.stable_ptr().untyped()
26174 }
26175}
26176#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26177pub struct TokenReturn {
26178 node: SyntaxNode,
26179}
26180impl Token for TokenReturn {
26181 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26182 TokenReturnGreen(
26183 Arc::new(GreenNode {
26184 kind: SyntaxKind::TokenReturn,
26185 details: GreenNodeDetails::Token(text),
26186 })
26187 .intern(db),
26188 )
26189 }
26190 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26191 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26192 .clone()
26193 }
26194}
26195#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26196pub struct TokenReturnPtr(pub SyntaxStablePtrId);
26197impl TypedStablePtr for TokenReturnPtr {
26198 type SyntaxNode = TokenReturn;
26199 fn untyped(&self) -> SyntaxStablePtrId {
26200 self.0
26201 }
26202 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenReturn {
26203 TokenReturn::from_syntax_node(db, self.0.lookup(db))
26204 }
26205}
26206impl From<TokenReturnPtr> for SyntaxStablePtrId {
26207 fn from(ptr: TokenReturnPtr) -> Self {
26208 ptr.untyped()
26209 }
26210}
26211#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26212pub struct TokenReturnGreen(pub GreenId);
26213impl TokenReturnGreen {
26214 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26215 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26216 }
26217}
26218impl TypedSyntaxNode for TokenReturn {
26219 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenReturn);
26220 type StablePtr = TokenReturnPtr;
26221 type Green = TokenReturnGreen;
26222 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26223 TokenReturnGreen(
26224 Arc::new(GreenNode {
26225 kind: SyntaxKind::TokenMissing,
26226 details: GreenNodeDetails::Token("".into()),
26227 })
26228 .intern(db),
26229 )
26230 }
26231 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26232 match node.0.green.lookup_intern(db).details {
26233 GreenNodeDetails::Token(_) => Self { node },
26234 GreenNodeDetails::Node { .. } => {
26235 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenReturn)
26236 }
26237 }
26238 }
26239 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26240 match node.0.green.lookup_intern(db).details {
26241 GreenNodeDetails::Token(_) => Some(Self { node }),
26242 GreenNodeDetails::Node { .. } => None,
26243 }
26244 }
26245 fn as_syntax_node(&self) -> SyntaxNode {
26246 self.node.clone()
26247 }
26248 fn stable_ptr(&self) -> Self::StablePtr {
26249 TokenReturnPtr(self.node.0.stable_ptr)
26250 }
26251}
26252impl From<&TokenReturn> for SyntaxStablePtrId {
26253 fn from(node: &TokenReturn) -> Self {
26254 node.stable_ptr().untyped()
26255 }
26256}
26257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26258pub struct TerminalReturn {
26259 node: SyntaxNode,
26260 children: Arc<[SyntaxNode]>,
26261}
26262impl Terminal for TerminalReturn {
26263 const KIND: SyntaxKind = SyntaxKind::TerminalReturn;
26264 type TokenType = TokenReturn;
26265 fn new_green(
26266 db: &dyn SyntaxGroup,
26267 leading_trivia: TriviaGreen,
26268 token: <<TerminalReturn as Terminal>::TokenType as TypedSyntaxNode>::Green,
26269 trailing_trivia: TriviaGreen,
26270 ) -> Self::Green {
26271 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26272 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26273 TerminalReturnGreen(
26274 Arc::new(GreenNode {
26275 kind: SyntaxKind::TerminalReturn,
26276 details: GreenNodeDetails::Node { children, width },
26277 })
26278 .intern(db),
26279 )
26280 }
26281 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26282 self.token(db).text(db)
26283 }
26284}
26285impl TerminalReturn {
26286 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26287 Trivia::from_syntax_node(db, self.children[0].clone())
26288 }
26289 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenReturn {
26290 TokenReturn::from_syntax_node(db, self.children[1].clone())
26291 }
26292 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26293 Trivia::from_syntax_node(db, self.children[2].clone())
26294 }
26295}
26296#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26297pub struct TerminalReturnPtr(pub SyntaxStablePtrId);
26298impl TerminalReturnPtr {}
26299impl TypedStablePtr for TerminalReturnPtr {
26300 type SyntaxNode = TerminalReturn;
26301 fn untyped(&self) -> SyntaxStablePtrId {
26302 self.0
26303 }
26304 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalReturn {
26305 TerminalReturn::from_syntax_node(db, self.0.lookup(db))
26306 }
26307}
26308impl From<TerminalReturnPtr> for SyntaxStablePtrId {
26309 fn from(ptr: TerminalReturnPtr) -> Self {
26310 ptr.untyped()
26311 }
26312}
26313#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26314pub struct TerminalReturnGreen(pub GreenId);
26315impl TypedSyntaxNode for TerminalReturn {
26316 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalReturn);
26317 type StablePtr = TerminalReturnPtr;
26318 type Green = TerminalReturnGreen;
26319 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26320 TerminalReturnGreen(
26321 Arc::new(GreenNode {
26322 kind: SyntaxKind::TerminalReturn,
26323 details: GreenNodeDetails::Node {
26324 children: vec![
26325 Trivia::missing(db).0,
26326 TokenReturn::missing(db).0,
26327 Trivia::missing(db).0,
26328 ],
26329 width: TextWidth::default(),
26330 },
26331 })
26332 .intern(db),
26333 )
26334 }
26335 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26336 let kind = node.kind(db);
26337 assert_eq!(
26338 kind,
26339 SyntaxKind::TerminalReturn,
26340 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26341 kind,
26342 SyntaxKind::TerminalReturn
26343 );
26344 let children = db.get_children(node.clone());
26345 Self { node, children }
26346 }
26347 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26348 let kind = node.kind(db);
26349 if kind == SyntaxKind::TerminalReturn {
26350 Some(Self::from_syntax_node(db, node))
26351 } else {
26352 None
26353 }
26354 }
26355 fn as_syntax_node(&self) -> SyntaxNode {
26356 self.node.clone()
26357 }
26358 fn stable_ptr(&self) -> Self::StablePtr {
26359 TerminalReturnPtr(self.node.0.stable_ptr)
26360 }
26361}
26362impl From<&TerminalReturn> for SyntaxStablePtrId {
26363 fn from(node: &TerminalReturn) -> Self {
26364 node.stable_ptr().untyped()
26365 }
26366}
26367#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26368pub struct TokenBreak {
26369 node: SyntaxNode,
26370}
26371impl Token for TokenBreak {
26372 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26373 TokenBreakGreen(
26374 Arc::new(GreenNode {
26375 kind: SyntaxKind::TokenBreak,
26376 details: GreenNodeDetails::Token(text),
26377 })
26378 .intern(db),
26379 )
26380 }
26381 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26382 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26383 .clone()
26384 }
26385}
26386#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26387pub struct TokenBreakPtr(pub SyntaxStablePtrId);
26388impl TypedStablePtr for TokenBreakPtr {
26389 type SyntaxNode = TokenBreak;
26390 fn untyped(&self) -> SyntaxStablePtrId {
26391 self.0
26392 }
26393 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBreak {
26394 TokenBreak::from_syntax_node(db, self.0.lookup(db))
26395 }
26396}
26397impl From<TokenBreakPtr> for SyntaxStablePtrId {
26398 fn from(ptr: TokenBreakPtr) -> Self {
26399 ptr.untyped()
26400 }
26401}
26402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26403pub struct TokenBreakGreen(pub GreenId);
26404impl TokenBreakGreen {
26405 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26406 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26407 }
26408}
26409impl TypedSyntaxNode for TokenBreak {
26410 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBreak);
26411 type StablePtr = TokenBreakPtr;
26412 type Green = TokenBreakGreen;
26413 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26414 TokenBreakGreen(
26415 Arc::new(GreenNode {
26416 kind: SyntaxKind::TokenMissing,
26417 details: GreenNodeDetails::Token("".into()),
26418 })
26419 .intern(db),
26420 )
26421 }
26422 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26423 match node.0.green.lookup_intern(db).details {
26424 GreenNodeDetails::Token(_) => Self { node },
26425 GreenNodeDetails::Node { .. } => {
26426 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenBreak)
26427 }
26428 }
26429 }
26430 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26431 match node.0.green.lookup_intern(db).details {
26432 GreenNodeDetails::Token(_) => Some(Self { node }),
26433 GreenNodeDetails::Node { .. } => None,
26434 }
26435 }
26436 fn as_syntax_node(&self) -> SyntaxNode {
26437 self.node.clone()
26438 }
26439 fn stable_ptr(&self) -> Self::StablePtr {
26440 TokenBreakPtr(self.node.0.stable_ptr)
26441 }
26442}
26443impl From<&TokenBreak> for SyntaxStablePtrId {
26444 fn from(node: &TokenBreak) -> Self {
26445 node.stable_ptr().untyped()
26446 }
26447}
26448#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26449pub struct TerminalBreak {
26450 node: SyntaxNode,
26451 children: Arc<[SyntaxNode]>,
26452}
26453impl Terminal for TerminalBreak {
26454 const KIND: SyntaxKind = SyntaxKind::TerminalBreak;
26455 type TokenType = TokenBreak;
26456 fn new_green(
26457 db: &dyn SyntaxGroup,
26458 leading_trivia: TriviaGreen,
26459 token: <<TerminalBreak as Terminal>::TokenType as TypedSyntaxNode>::Green,
26460 trailing_trivia: TriviaGreen,
26461 ) -> Self::Green {
26462 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26463 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26464 TerminalBreakGreen(
26465 Arc::new(GreenNode {
26466 kind: SyntaxKind::TerminalBreak,
26467 details: GreenNodeDetails::Node { children, width },
26468 })
26469 .intern(db),
26470 )
26471 }
26472 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26473 self.token(db).text(db)
26474 }
26475}
26476impl TerminalBreak {
26477 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26478 Trivia::from_syntax_node(db, self.children[0].clone())
26479 }
26480 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBreak {
26481 TokenBreak::from_syntax_node(db, self.children[1].clone())
26482 }
26483 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26484 Trivia::from_syntax_node(db, self.children[2].clone())
26485 }
26486}
26487#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26488pub struct TerminalBreakPtr(pub SyntaxStablePtrId);
26489impl TerminalBreakPtr {}
26490impl TypedStablePtr for TerminalBreakPtr {
26491 type SyntaxNode = TerminalBreak;
26492 fn untyped(&self) -> SyntaxStablePtrId {
26493 self.0
26494 }
26495 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBreak {
26496 TerminalBreak::from_syntax_node(db, self.0.lookup(db))
26497 }
26498}
26499impl From<TerminalBreakPtr> for SyntaxStablePtrId {
26500 fn from(ptr: TerminalBreakPtr) -> Self {
26501 ptr.untyped()
26502 }
26503}
26504#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26505pub struct TerminalBreakGreen(pub GreenId);
26506impl TypedSyntaxNode for TerminalBreak {
26507 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBreak);
26508 type StablePtr = TerminalBreakPtr;
26509 type Green = TerminalBreakGreen;
26510 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26511 TerminalBreakGreen(
26512 Arc::new(GreenNode {
26513 kind: SyntaxKind::TerminalBreak,
26514 details: GreenNodeDetails::Node {
26515 children: vec![
26516 Trivia::missing(db).0,
26517 TokenBreak::missing(db).0,
26518 Trivia::missing(db).0,
26519 ],
26520 width: TextWidth::default(),
26521 },
26522 })
26523 .intern(db),
26524 )
26525 }
26526 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26527 let kind = node.kind(db);
26528 assert_eq!(
26529 kind,
26530 SyntaxKind::TerminalBreak,
26531 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26532 kind,
26533 SyntaxKind::TerminalBreak
26534 );
26535 let children = db.get_children(node.clone());
26536 Self { node, children }
26537 }
26538 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26539 let kind = node.kind(db);
26540 if kind == SyntaxKind::TerminalBreak {
26541 Some(Self::from_syntax_node(db, node))
26542 } else {
26543 None
26544 }
26545 }
26546 fn as_syntax_node(&self) -> SyntaxNode {
26547 self.node.clone()
26548 }
26549 fn stable_ptr(&self) -> Self::StablePtr {
26550 TerminalBreakPtr(self.node.0.stable_ptr)
26551 }
26552}
26553impl From<&TerminalBreak> for SyntaxStablePtrId {
26554 fn from(node: &TerminalBreak) -> Self {
26555 node.stable_ptr().untyped()
26556 }
26557}
26558#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26559pub struct TokenStruct {
26560 node: SyntaxNode,
26561}
26562impl Token for TokenStruct {
26563 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26564 TokenStructGreen(
26565 Arc::new(GreenNode {
26566 kind: SyntaxKind::TokenStruct,
26567 details: GreenNodeDetails::Token(text),
26568 })
26569 .intern(db),
26570 )
26571 }
26572 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26573 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26574 .clone()
26575 }
26576}
26577#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26578pub struct TokenStructPtr(pub SyntaxStablePtrId);
26579impl TypedStablePtr for TokenStructPtr {
26580 type SyntaxNode = TokenStruct;
26581 fn untyped(&self) -> SyntaxStablePtrId {
26582 self.0
26583 }
26584 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenStruct {
26585 TokenStruct::from_syntax_node(db, self.0.lookup(db))
26586 }
26587}
26588impl From<TokenStructPtr> for SyntaxStablePtrId {
26589 fn from(ptr: TokenStructPtr) -> Self {
26590 ptr.untyped()
26591 }
26592}
26593#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26594pub struct TokenStructGreen(pub GreenId);
26595impl TokenStructGreen {
26596 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26597 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26598 }
26599}
26600impl TypedSyntaxNode for TokenStruct {
26601 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenStruct);
26602 type StablePtr = TokenStructPtr;
26603 type Green = TokenStructGreen;
26604 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26605 TokenStructGreen(
26606 Arc::new(GreenNode {
26607 kind: SyntaxKind::TokenMissing,
26608 details: GreenNodeDetails::Token("".into()),
26609 })
26610 .intern(db),
26611 )
26612 }
26613 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26614 match node.0.green.lookup_intern(db).details {
26615 GreenNodeDetails::Token(_) => Self { node },
26616 GreenNodeDetails::Node { .. } => {
26617 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenStruct)
26618 }
26619 }
26620 }
26621 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26622 match node.0.green.lookup_intern(db).details {
26623 GreenNodeDetails::Token(_) => Some(Self { node }),
26624 GreenNodeDetails::Node { .. } => None,
26625 }
26626 }
26627 fn as_syntax_node(&self) -> SyntaxNode {
26628 self.node.clone()
26629 }
26630 fn stable_ptr(&self) -> Self::StablePtr {
26631 TokenStructPtr(self.node.0.stable_ptr)
26632 }
26633}
26634impl From<&TokenStruct> for SyntaxStablePtrId {
26635 fn from(node: &TokenStruct) -> Self {
26636 node.stable_ptr().untyped()
26637 }
26638}
26639#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26640pub struct TerminalStruct {
26641 node: SyntaxNode,
26642 children: Arc<[SyntaxNode]>,
26643}
26644impl Terminal for TerminalStruct {
26645 const KIND: SyntaxKind = SyntaxKind::TerminalStruct;
26646 type TokenType = TokenStruct;
26647 fn new_green(
26648 db: &dyn SyntaxGroup,
26649 leading_trivia: TriviaGreen,
26650 token: <<TerminalStruct as Terminal>::TokenType as TypedSyntaxNode>::Green,
26651 trailing_trivia: TriviaGreen,
26652 ) -> Self::Green {
26653 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26654 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26655 TerminalStructGreen(
26656 Arc::new(GreenNode {
26657 kind: SyntaxKind::TerminalStruct,
26658 details: GreenNodeDetails::Node { children, width },
26659 })
26660 .intern(db),
26661 )
26662 }
26663 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26664 self.token(db).text(db)
26665 }
26666}
26667impl TerminalStruct {
26668 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26669 Trivia::from_syntax_node(db, self.children[0].clone())
26670 }
26671 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenStruct {
26672 TokenStruct::from_syntax_node(db, self.children[1].clone())
26673 }
26674 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26675 Trivia::from_syntax_node(db, self.children[2].clone())
26676 }
26677}
26678#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26679pub struct TerminalStructPtr(pub SyntaxStablePtrId);
26680impl TerminalStructPtr {}
26681impl TypedStablePtr for TerminalStructPtr {
26682 type SyntaxNode = TerminalStruct;
26683 fn untyped(&self) -> SyntaxStablePtrId {
26684 self.0
26685 }
26686 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalStruct {
26687 TerminalStruct::from_syntax_node(db, self.0.lookup(db))
26688 }
26689}
26690impl From<TerminalStructPtr> for SyntaxStablePtrId {
26691 fn from(ptr: TerminalStructPtr) -> Self {
26692 ptr.untyped()
26693 }
26694}
26695#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26696pub struct TerminalStructGreen(pub GreenId);
26697impl TypedSyntaxNode for TerminalStruct {
26698 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalStruct);
26699 type StablePtr = TerminalStructPtr;
26700 type Green = TerminalStructGreen;
26701 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26702 TerminalStructGreen(
26703 Arc::new(GreenNode {
26704 kind: SyntaxKind::TerminalStruct,
26705 details: GreenNodeDetails::Node {
26706 children: vec![
26707 Trivia::missing(db).0,
26708 TokenStruct::missing(db).0,
26709 Trivia::missing(db).0,
26710 ],
26711 width: TextWidth::default(),
26712 },
26713 })
26714 .intern(db),
26715 )
26716 }
26717 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26718 let kind = node.kind(db);
26719 assert_eq!(
26720 kind,
26721 SyntaxKind::TerminalStruct,
26722 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26723 kind,
26724 SyntaxKind::TerminalStruct
26725 );
26726 let children = db.get_children(node.clone());
26727 Self { node, children }
26728 }
26729 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26730 let kind = node.kind(db);
26731 if kind == SyntaxKind::TerminalStruct {
26732 Some(Self::from_syntax_node(db, node))
26733 } else {
26734 None
26735 }
26736 }
26737 fn as_syntax_node(&self) -> SyntaxNode {
26738 self.node.clone()
26739 }
26740 fn stable_ptr(&self) -> Self::StablePtr {
26741 TerminalStructPtr(self.node.0.stable_ptr)
26742 }
26743}
26744impl From<&TerminalStruct> for SyntaxStablePtrId {
26745 fn from(node: &TerminalStruct) -> Self {
26746 node.stable_ptr().untyped()
26747 }
26748}
26749#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26750pub struct TokenTrait {
26751 node: SyntaxNode,
26752}
26753impl Token for TokenTrait {
26754 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26755 TokenTraitGreen(
26756 Arc::new(GreenNode {
26757 kind: SyntaxKind::TokenTrait,
26758 details: GreenNodeDetails::Token(text),
26759 })
26760 .intern(db),
26761 )
26762 }
26763 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26764 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26765 .clone()
26766 }
26767}
26768#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26769pub struct TokenTraitPtr(pub SyntaxStablePtrId);
26770impl TypedStablePtr for TokenTraitPtr {
26771 type SyntaxNode = TokenTrait;
26772 fn untyped(&self) -> SyntaxStablePtrId {
26773 self.0
26774 }
26775 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenTrait {
26776 TokenTrait::from_syntax_node(db, self.0.lookup(db))
26777 }
26778}
26779impl From<TokenTraitPtr> for SyntaxStablePtrId {
26780 fn from(ptr: TokenTraitPtr) -> Self {
26781 ptr.untyped()
26782 }
26783}
26784#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26785pub struct TokenTraitGreen(pub GreenId);
26786impl TokenTraitGreen {
26787 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26788 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26789 }
26790}
26791impl TypedSyntaxNode for TokenTrait {
26792 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenTrait);
26793 type StablePtr = TokenTraitPtr;
26794 type Green = TokenTraitGreen;
26795 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26796 TokenTraitGreen(
26797 Arc::new(GreenNode {
26798 kind: SyntaxKind::TokenMissing,
26799 details: GreenNodeDetails::Token("".into()),
26800 })
26801 .intern(db),
26802 )
26803 }
26804 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26805 match node.0.green.lookup_intern(db).details {
26806 GreenNodeDetails::Token(_) => Self { node },
26807 GreenNodeDetails::Node { .. } => {
26808 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenTrait)
26809 }
26810 }
26811 }
26812 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26813 match node.0.green.lookup_intern(db).details {
26814 GreenNodeDetails::Token(_) => Some(Self { node }),
26815 GreenNodeDetails::Node { .. } => None,
26816 }
26817 }
26818 fn as_syntax_node(&self) -> SyntaxNode {
26819 self.node.clone()
26820 }
26821 fn stable_ptr(&self) -> Self::StablePtr {
26822 TokenTraitPtr(self.node.0.stable_ptr)
26823 }
26824}
26825impl From<&TokenTrait> for SyntaxStablePtrId {
26826 fn from(node: &TokenTrait) -> Self {
26827 node.stable_ptr().untyped()
26828 }
26829}
26830#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26831pub struct TerminalTrait {
26832 node: SyntaxNode,
26833 children: Arc<[SyntaxNode]>,
26834}
26835impl Terminal for TerminalTrait {
26836 const KIND: SyntaxKind = SyntaxKind::TerminalTrait;
26837 type TokenType = TokenTrait;
26838 fn new_green(
26839 db: &dyn SyntaxGroup,
26840 leading_trivia: TriviaGreen,
26841 token: <<TerminalTrait as Terminal>::TokenType as TypedSyntaxNode>::Green,
26842 trailing_trivia: TriviaGreen,
26843 ) -> Self::Green {
26844 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26845 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26846 TerminalTraitGreen(
26847 Arc::new(GreenNode {
26848 kind: SyntaxKind::TerminalTrait,
26849 details: GreenNodeDetails::Node { children, width },
26850 })
26851 .intern(db),
26852 )
26853 }
26854 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26855 self.token(db).text(db)
26856 }
26857}
26858impl TerminalTrait {
26859 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26860 Trivia::from_syntax_node(db, self.children[0].clone())
26861 }
26862 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenTrait {
26863 TokenTrait::from_syntax_node(db, self.children[1].clone())
26864 }
26865 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26866 Trivia::from_syntax_node(db, self.children[2].clone())
26867 }
26868}
26869#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26870pub struct TerminalTraitPtr(pub SyntaxStablePtrId);
26871impl TerminalTraitPtr {}
26872impl TypedStablePtr for TerminalTraitPtr {
26873 type SyntaxNode = TerminalTrait;
26874 fn untyped(&self) -> SyntaxStablePtrId {
26875 self.0
26876 }
26877 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalTrait {
26878 TerminalTrait::from_syntax_node(db, self.0.lookup(db))
26879 }
26880}
26881impl From<TerminalTraitPtr> for SyntaxStablePtrId {
26882 fn from(ptr: TerminalTraitPtr) -> Self {
26883 ptr.untyped()
26884 }
26885}
26886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26887pub struct TerminalTraitGreen(pub GreenId);
26888impl TypedSyntaxNode for TerminalTrait {
26889 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalTrait);
26890 type StablePtr = TerminalTraitPtr;
26891 type Green = TerminalTraitGreen;
26892 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26893 TerminalTraitGreen(
26894 Arc::new(GreenNode {
26895 kind: SyntaxKind::TerminalTrait,
26896 details: GreenNodeDetails::Node {
26897 children: vec![
26898 Trivia::missing(db).0,
26899 TokenTrait::missing(db).0,
26900 Trivia::missing(db).0,
26901 ],
26902 width: TextWidth::default(),
26903 },
26904 })
26905 .intern(db),
26906 )
26907 }
26908 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26909 let kind = node.kind(db);
26910 assert_eq!(
26911 kind,
26912 SyntaxKind::TerminalTrait,
26913 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26914 kind,
26915 SyntaxKind::TerminalTrait
26916 );
26917 let children = db.get_children(node.clone());
26918 Self { node, children }
26919 }
26920 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
26921 let kind = node.kind(db);
26922 if kind == SyntaxKind::TerminalTrait {
26923 Some(Self::from_syntax_node(db, node))
26924 } else {
26925 None
26926 }
26927 }
26928 fn as_syntax_node(&self) -> SyntaxNode {
26929 self.node.clone()
26930 }
26931 fn stable_ptr(&self) -> Self::StablePtr {
26932 TerminalTraitPtr(self.node.0.stable_ptr)
26933 }
26934}
26935impl From<&TerminalTrait> for SyntaxStablePtrId {
26936 fn from(node: &TerminalTrait) -> Self {
26937 node.stable_ptr().untyped()
26938 }
26939}
26940#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26941pub struct TokenTrue {
26942 node: SyntaxNode,
26943}
26944impl Token for TokenTrue {
26945 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26946 TokenTrueGreen(
26947 Arc::new(GreenNode {
26948 kind: SyntaxKind::TokenTrue,
26949 details: GreenNodeDetails::Token(text),
26950 })
26951 .intern(db),
26952 )
26953 }
26954 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26955 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26956 .clone()
26957 }
26958}
26959#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26960pub struct TokenTruePtr(pub SyntaxStablePtrId);
26961impl TypedStablePtr for TokenTruePtr {
26962 type SyntaxNode = TokenTrue;
26963 fn untyped(&self) -> SyntaxStablePtrId {
26964 self.0
26965 }
26966 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenTrue {
26967 TokenTrue::from_syntax_node(db, self.0.lookup(db))
26968 }
26969}
26970impl From<TokenTruePtr> for SyntaxStablePtrId {
26971 fn from(ptr: TokenTruePtr) -> Self {
26972 ptr.untyped()
26973 }
26974}
26975#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26976pub struct TokenTrueGreen(pub GreenId);
26977impl TokenTrueGreen {
26978 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26979 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26980 }
26981}
26982impl TypedSyntaxNode for TokenTrue {
26983 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenTrue);
26984 type StablePtr = TokenTruePtr;
26985 type Green = TokenTrueGreen;
26986 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26987 TokenTrueGreen(
26988 Arc::new(GreenNode {
26989 kind: SyntaxKind::TokenMissing,
26990 details: GreenNodeDetails::Token("".into()),
26991 })
26992 .intern(db),
26993 )
26994 }
26995 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26996 match node.0.green.lookup_intern(db).details {
26997 GreenNodeDetails::Token(_) => Self { node },
26998 GreenNodeDetails::Node { .. } => {
26999 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenTrue)
27000 }
27001 }
27002 }
27003 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27004 match node.0.green.lookup_intern(db).details {
27005 GreenNodeDetails::Token(_) => Some(Self { node }),
27006 GreenNodeDetails::Node { .. } => None,
27007 }
27008 }
27009 fn as_syntax_node(&self) -> SyntaxNode {
27010 self.node.clone()
27011 }
27012 fn stable_ptr(&self) -> Self::StablePtr {
27013 TokenTruePtr(self.node.0.stable_ptr)
27014 }
27015}
27016impl From<&TokenTrue> for SyntaxStablePtrId {
27017 fn from(node: &TokenTrue) -> Self {
27018 node.stable_ptr().untyped()
27019 }
27020}
27021#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27022pub struct TerminalTrue {
27023 node: SyntaxNode,
27024 children: Arc<[SyntaxNode]>,
27025}
27026impl Terminal for TerminalTrue {
27027 const KIND: SyntaxKind = SyntaxKind::TerminalTrue;
27028 type TokenType = TokenTrue;
27029 fn new_green(
27030 db: &dyn SyntaxGroup,
27031 leading_trivia: TriviaGreen,
27032 token: <<TerminalTrue as Terminal>::TokenType as TypedSyntaxNode>::Green,
27033 trailing_trivia: TriviaGreen,
27034 ) -> Self::Green {
27035 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27036 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27037 TerminalTrueGreen(
27038 Arc::new(GreenNode {
27039 kind: SyntaxKind::TerminalTrue,
27040 details: GreenNodeDetails::Node { children, width },
27041 })
27042 .intern(db),
27043 )
27044 }
27045 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27046 self.token(db).text(db)
27047 }
27048}
27049impl TerminalTrue {
27050 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27051 Trivia::from_syntax_node(db, self.children[0].clone())
27052 }
27053 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenTrue {
27054 TokenTrue::from_syntax_node(db, self.children[1].clone())
27055 }
27056 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27057 Trivia::from_syntax_node(db, self.children[2].clone())
27058 }
27059}
27060#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27061pub struct TerminalTruePtr(pub SyntaxStablePtrId);
27062impl TerminalTruePtr {}
27063impl TypedStablePtr for TerminalTruePtr {
27064 type SyntaxNode = TerminalTrue;
27065 fn untyped(&self) -> SyntaxStablePtrId {
27066 self.0
27067 }
27068 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalTrue {
27069 TerminalTrue::from_syntax_node(db, self.0.lookup(db))
27070 }
27071}
27072impl From<TerminalTruePtr> for SyntaxStablePtrId {
27073 fn from(ptr: TerminalTruePtr) -> Self {
27074 ptr.untyped()
27075 }
27076}
27077#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27078pub struct TerminalTrueGreen(pub GreenId);
27079impl TypedSyntaxNode for TerminalTrue {
27080 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalTrue);
27081 type StablePtr = TerminalTruePtr;
27082 type Green = TerminalTrueGreen;
27083 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27084 TerminalTrueGreen(
27085 Arc::new(GreenNode {
27086 kind: SyntaxKind::TerminalTrue,
27087 details: GreenNodeDetails::Node {
27088 children: vec![
27089 Trivia::missing(db).0,
27090 TokenTrue::missing(db).0,
27091 Trivia::missing(db).0,
27092 ],
27093 width: TextWidth::default(),
27094 },
27095 })
27096 .intern(db),
27097 )
27098 }
27099 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27100 let kind = node.kind(db);
27101 assert_eq!(
27102 kind,
27103 SyntaxKind::TerminalTrue,
27104 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27105 kind,
27106 SyntaxKind::TerminalTrue
27107 );
27108 let children = db.get_children(node.clone());
27109 Self { node, children }
27110 }
27111 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27112 let kind = node.kind(db);
27113 if kind == SyntaxKind::TerminalTrue { Some(Self::from_syntax_node(db, node)) } else { None }
27114 }
27115 fn as_syntax_node(&self) -> SyntaxNode {
27116 self.node.clone()
27117 }
27118 fn stable_ptr(&self) -> Self::StablePtr {
27119 TerminalTruePtr(self.node.0.stable_ptr)
27120 }
27121}
27122impl From<&TerminalTrue> for SyntaxStablePtrId {
27123 fn from(node: &TerminalTrue) -> Self {
27124 node.stable_ptr().untyped()
27125 }
27126}
27127#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27128pub struct TokenType {
27129 node: SyntaxNode,
27130}
27131impl Token for TokenType {
27132 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27133 TokenTypeGreen(
27134 Arc::new(GreenNode {
27135 kind: SyntaxKind::TokenType,
27136 details: GreenNodeDetails::Token(text),
27137 })
27138 .intern(db),
27139 )
27140 }
27141 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27142 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27143 .clone()
27144 }
27145}
27146#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27147pub struct TokenTypePtr(pub SyntaxStablePtrId);
27148impl TypedStablePtr for TokenTypePtr {
27149 type SyntaxNode = TokenType;
27150 fn untyped(&self) -> SyntaxStablePtrId {
27151 self.0
27152 }
27153 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenType {
27154 TokenType::from_syntax_node(db, self.0.lookup(db))
27155 }
27156}
27157impl From<TokenTypePtr> for SyntaxStablePtrId {
27158 fn from(ptr: TokenTypePtr) -> Self {
27159 ptr.untyped()
27160 }
27161}
27162#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27163pub struct TokenTypeGreen(pub GreenId);
27164impl TokenTypeGreen {
27165 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27166 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27167 }
27168}
27169impl TypedSyntaxNode for TokenType {
27170 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenType);
27171 type StablePtr = TokenTypePtr;
27172 type Green = TokenTypeGreen;
27173 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27174 TokenTypeGreen(
27175 Arc::new(GreenNode {
27176 kind: SyntaxKind::TokenMissing,
27177 details: GreenNodeDetails::Token("".into()),
27178 })
27179 .intern(db),
27180 )
27181 }
27182 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27183 match node.0.green.lookup_intern(db).details {
27184 GreenNodeDetails::Token(_) => Self { node },
27185 GreenNodeDetails::Node { .. } => {
27186 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenType)
27187 }
27188 }
27189 }
27190 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27191 match node.0.green.lookup_intern(db).details {
27192 GreenNodeDetails::Token(_) => Some(Self { node }),
27193 GreenNodeDetails::Node { .. } => None,
27194 }
27195 }
27196 fn as_syntax_node(&self) -> SyntaxNode {
27197 self.node.clone()
27198 }
27199 fn stable_ptr(&self) -> Self::StablePtr {
27200 TokenTypePtr(self.node.0.stable_ptr)
27201 }
27202}
27203impl From<&TokenType> for SyntaxStablePtrId {
27204 fn from(node: &TokenType) -> Self {
27205 node.stable_ptr().untyped()
27206 }
27207}
27208#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27209pub struct TerminalType {
27210 node: SyntaxNode,
27211 children: Arc<[SyntaxNode]>,
27212}
27213impl Terminal for TerminalType {
27214 const KIND: SyntaxKind = SyntaxKind::TerminalType;
27215 type TokenType = TokenType;
27216 fn new_green(
27217 db: &dyn SyntaxGroup,
27218 leading_trivia: TriviaGreen,
27219 token: <<TerminalType as Terminal>::TokenType as TypedSyntaxNode>::Green,
27220 trailing_trivia: TriviaGreen,
27221 ) -> Self::Green {
27222 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27223 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27224 TerminalTypeGreen(
27225 Arc::new(GreenNode {
27226 kind: SyntaxKind::TerminalType,
27227 details: GreenNodeDetails::Node { children, width },
27228 })
27229 .intern(db),
27230 )
27231 }
27232 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27233 self.token(db).text(db)
27234 }
27235}
27236impl TerminalType {
27237 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27238 Trivia::from_syntax_node(db, self.children[0].clone())
27239 }
27240 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenType {
27241 TokenType::from_syntax_node(db, self.children[1].clone())
27242 }
27243 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27244 Trivia::from_syntax_node(db, self.children[2].clone())
27245 }
27246}
27247#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27248pub struct TerminalTypePtr(pub SyntaxStablePtrId);
27249impl TerminalTypePtr {}
27250impl TypedStablePtr for TerminalTypePtr {
27251 type SyntaxNode = TerminalType;
27252 fn untyped(&self) -> SyntaxStablePtrId {
27253 self.0
27254 }
27255 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalType {
27256 TerminalType::from_syntax_node(db, self.0.lookup(db))
27257 }
27258}
27259impl From<TerminalTypePtr> for SyntaxStablePtrId {
27260 fn from(ptr: TerminalTypePtr) -> Self {
27261 ptr.untyped()
27262 }
27263}
27264#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27265pub struct TerminalTypeGreen(pub GreenId);
27266impl TypedSyntaxNode for TerminalType {
27267 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalType);
27268 type StablePtr = TerminalTypePtr;
27269 type Green = TerminalTypeGreen;
27270 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27271 TerminalTypeGreen(
27272 Arc::new(GreenNode {
27273 kind: SyntaxKind::TerminalType,
27274 details: GreenNodeDetails::Node {
27275 children: vec![
27276 Trivia::missing(db).0,
27277 TokenType::missing(db).0,
27278 Trivia::missing(db).0,
27279 ],
27280 width: TextWidth::default(),
27281 },
27282 })
27283 .intern(db),
27284 )
27285 }
27286 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27287 let kind = node.kind(db);
27288 assert_eq!(
27289 kind,
27290 SyntaxKind::TerminalType,
27291 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27292 kind,
27293 SyntaxKind::TerminalType
27294 );
27295 let children = db.get_children(node.clone());
27296 Self { node, children }
27297 }
27298 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27299 let kind = node.kind(db);
27300 if kind == SyntaxKind::TerminalType { Some(Self::from_syntax_node(db, node)) } else { None }
27301 }
27302 fn as_syntax_node(&self) -> SyntaxNode {
27303 self.node.clone()
27304 }
27305 fn stable_ptr(&self) -> Self::StablePtr {
27306 TerminalTypePtr(self.node.0.stable_ptr)
27307 }
27308}
27309impl From<&TerminalType> for SyntaxStablePtrId {
27310 fn from(node: &TerminalType) -> Self {
27311 node.stable_ptr().untyped()
27312 }
27313}
27314#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27315pub struct TokenUse {
27316 node: SyntaxNode,
27317}
27318impl Token for TokenUse {
27319 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27320 TokenUseGreen(
27321 Arc::new(GreenNode {
27322 kind: SyntaxKind::TokenUse,
27323 details: GreenNodeDetails::Token(text),
27324 })
27325 .intern(db),
27326 )
27327 }
27328 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27329 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27330 .clone()
27331 }
27332}
27333#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27334pub struct TokenUsePtr(pub SyntaxStablePtrId);
27335impl TypedStablePtr for TokenUsePtr {
27336 type SyntaxNode = TokenUse;
27337 fn untyped(&self) -> SyntaxStablePtrId {
27338 self.0
27339 }
27340 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenUse {
27341 TokenUse::from_syntax_node(db, self.0.lookup(db))
27342 }
27343}
27344impl From<TokenUsePtr> for SyntaxStablePtrId {
27345 fn from(ptr: TokenUsePtr) -> Self {
27346 ptr.untyped()
27347 }
27348}
27349#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27350pub struct TokenUseGreen(pub GreenId);
27351impl TokenUseGreen {
27352 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27353 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27354 }
27355}
27356impl TypedSyntaxNode for TokenUse {
27357 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenUse);
27358 type StablePtr = TokenUsePtr;
27359 type Green = TokenUseGreen;
27360 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27361 TokenUseGreen(
27362 Arc::new(GreenNode {
27363 kind: SyntaxKind::TokenMissing,
27364 details: GreenNodeDetails::Token("".into()),
27365 })
27366 .intern(db),
27367 )
27368 }
27369 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27370 match node.0.green.lookup_intern(db).details {
27371 GreenNodeDetails::Token(_) => Self { node },
27372 GreenNodeDetails::Node { .. } => {
27373 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenUse)
27374 }
27375 }
27376 }
27377 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27378 match node.0.green.lookup_intern(db).details {
27379 GreenNodeDetails::Token(_) => Some(Self { node }),
27380 GreenNodeDetails::Node { .. } => None,
27381 }
27382 }
27383 fn as_syntax_node(&self) -> SyntaxNode {
27384 self.node.clone()
27385 }
27386 fn stable_ptr(&self) -> Self::StablePtr {
27387 TokenUsePtr(self.node.0.stable_ptr)
27388 }
27389}
27390impl From<&TokenUse> for SyntaxStablePtrId {
27391 fn from(node: &TokenUse) -> Self {
27392 node.stable_ptr().untyped()
27393 }
27394}
27395#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27396pub struct TerminalUse {
27397 node: SyntaxNode,
27398 children: Arc<[SyntaxNode]>,
27399}
27400impl Terminal for TerminalUse {
27401 const KIND: SyntaxKind = SyntaxKind::TerminalUse;
27402 type TokenType = TokenUse;
27403 fn new_green(
27404 db: &dyn SyntaxGroup,
27405 leading_trivia: TriviaGreen,
27406 token: <<TerminalUse as Terminal>::TokenType as TypedSyntaxNode>::Green,
27407 trailing_trivia: TriviaGreen,
27408 ) -> Self::Green {
27409 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27410 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27411 TerminalUseGreen(
27412 Arc::new(GreenNode {
27413 kind: SyntaxKind::TerminalUse,
27414 details: GreenNodeDetails::Node { children, width },
27415 })
27416 .intern(db),
27417 )
27418 }
27419 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27420 self.token(db).text(db)
27421 }
27422}
27423impl TerminalUse {
27424 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27425 Trivia::from_syntax_node(db, self.children[0].clone())
27426 }
27427 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenUse {
27428 TokenUse::from_syntax_node(db, self.children[1].clone())
27429 }
27430 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27431 Trivia::from_syntax_node(db, self.children[2].clone())
27432 }
27433}
27434#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27435pub struct TerminalUsePtr(pub SyntaxStablePtrId);
27436impl TerminalUsePtr {}
27437impl TypedStablePtr for TerminalUsePtr {
27438 type SyntaxNode = TerminalUse;
27439 fn untyped(&self) -> SyntaxStablePtrId {
27440 self.0
27441 }
27442 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalUse {
27443 TerminalUse::from_syntax_node(db, self.0.lookup(db))
27444 }
27445}
27446impl From<TerminalUsePtr> for SyntaxStablePtrId {
27447 fn from(ptr: TerminalUsePtr) -> Self {
27448 ptr.untyped()
27449 }
27450}
27451#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27452pub struct TerminalUseGreen(pub GreenId);
27453impl TypedSyntaxNode for TerminalUse {
27454 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalUse);
27455 type StablePtr = TerminalUsePtr;
27456 type Green = TerminalUseGreen;
27457 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27458 TerminalUseGreen(
27459 Arc::new(GreenNode {
27460 kind: SyntaxKind::TerminalUse,
27461 details: GreenNodeDetails::Node {
27462 children: vec![
27463 Trivia::missing(db).0,
27464 TokenUse::missing(db).0,
27465 Trivia::missing(db).0,
27466 ],
27467 width: TextWidth::default(),
27468 },
27469 })
27470 .intern(db),
27471 )
27472 }
27473 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27474 let kind = node.kind(db);
27475 assert_eq!(
27476 kind,
27477 SyntaxKind::TerminalUse,
27478 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27479 kind,
27480 SyntaxKind::TerminalUse
27481 );
27482 let children = db.get_children(node.clone());
27483 Self { node, children }
27484 }
27485 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27486 let kind = node.kind(db);
27487 if kind == SyntaxKind::TerminalUse { Some(Self::from_syntax_node(db, node)) } else { None }
27488 }
27489 fn as_syntax_node(&self) -> SyntaxNode {
27490 self.node.clone()
27491 }
27492 fn stable_ptr(&self) -> Self::StablePtr {
27493 TerminalUsePtr(self.node.0.stable_ptr)
27494 }
27495}
27496impl From<&TerminalUse> for SyntaxStablePtrId {
27497 fn from(node: &TerminalUse) -> Self {
27498 node.stable_ptr().untyped()
27499 }
27500}
27501#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27502pub struct TokenPub {
27503 node: SyntaxNode,
27504}
27505impl Token for TokenPub {
27506 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27507 TokenPubGreen(
27508 Arc::new(GreenNode {
27509 kind: SyntaxKind::TokenPub,
27510 details: GreenNodeDetails::Token(text),
27511 })
27512 .intern(db),
27513 )
27514 }
27515 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27516 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27517 .clone()
27518 }
27519}
27520#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27521pub struct TokenPubPtr(pub SyntaxStablePtrId);
27522impl TypedStablePtr for TokenPubPtr {
27523 type SyntaxNode = TokenPub;
27524 fn untyped(&self) -> SyntaxStablePtrId {
27525 self.0
27526 }
27527 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPub {
27528 TokenPub::from_syntax_node(db, self.0.lookup(db))
27529 }
27530}
27531impl From<TokenPubPtr> for SyntaxStablePtrId {
27532 fn from(ptr: TokenPubPtr) -> Self {
27533 ptr.untyped()
27534 }
27535}
27536#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27537pub struct TokenPubGreen(pub GreenId);
27538impl TokenPubGreen {
27539 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27540 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27541 }
27542}
27543impl TypedSyntaxNode for TokenPub {
27544 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPub);
27545 type StablePtr = TokenPubPtr;
27546 type Green = TokenPubGreen;
27547 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27548 TokenPubGreen(
27549 Arc::new(GreenNode {
27550 kind: SyntaxKind::TokenMissing,
27551 details: GreenNodeDetails::Token("".into()),
27552 })
27553 .intern(db),
27554 )
27555 }
27556 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27557 match node.0.green.lookup_intern(db).details {
27558 GreenNodeDetails::Token(_) => Self { node },
27559 GreenNodeDetails::Node { .. } => {
27560 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPub)
27561 }
27562 }
27563 }
27564 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27565 match node.0.green.lookup_intern(db).details {
27566 GreenNodeDetails::Token(_) => Some(Self { node }),
27567 GreenNodeDetails::Node { .. } => None,
27568 }
27569 }
27570 fn as_syntax_node(&self) -> SyntaxNode {
27571 self.node.clone()
27572 }
27573 fn stable_ptr(&self) -> Self::StablePtr {
27574 TokenPubPtr(self.node.0.stable_ptr)
27575 }
27576}
27577impl From<&TokenPub> for SyntaxStablePtrId {
27578 fn from(node: &TokenPub) -> Self {
27579 node.stable_ptr().untyped()
27580 }
27581}
27582#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27583pub struct TerminalPub {
27584 node: SyntaxNode,
27585 children: Arc<[SyntaxNode]>,
27586}
27587impl Terminal for TerminalPub {
27588 const KIND: SyntaxKind = SyntaxKind::TerminalPub;
27589 type TokenType = TokenPub;
27590 fn new_green(
27591 db: &dyn SyntaxGroup,
27592 leading_trivia: TriviaGreen,
27593 token: <<TerminalPub as Terminal>::TokenType as TypedSyntaxNode>::Green,
27594 trailing_trivia: TriviaGreen,
27595 ) -> Self::Green {
27596 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27597 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27598 TerminalPubGreen(
27599 Arc::new(GreenNode {
27600 kind: SyntaxKind::TerminalPub,
27601 details: GreenNodeDetails::Node { children, width },
27602 })
27603 .intern(db),
27604 )
27605 }
27606 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27607 self.token(db).text(db)
27608 }
27609}
27610impl TerminalPub {
27611 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27612 Trivia::from_syntax_node(db, self.children[0].clone())
27613 }
27614 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPub {
27615 TokenPub::from_syntax_node(db, self.children[1].clone())
27616 }
27617 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27618 Trivia::from_syntax_node(db, self.children[2].clone())
27619 }
27620}
27621#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27622pub struct TerminalPubPtr(pub SyntaxStablePtrId);
27623impl TerminalPubPtr {}
27624impl TypedStablePtr for TerminalPubPtr {
27625 type SyntaxNode = TerminalPub;
27626 fn untyped(&self) -> SyntaxStablePtrId {
27627 self.0
27628 }
27629 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPub {
27630 TerminalPub::from_syntax_node(db, self.0.lookup(db))
27631 }
27632}
27633impl From<TerminalPubPtr> for SyntaxStablePtrId {
27634 fn from(ptr: TerminalPubPtr) -> Self {
27635 ptr.untyped()
27636 }
27637}
27638#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27639pub struct TerminalPubGreen(pub GreenId);
27640impl TypedSyntaxNode for TerminalPub {
27641 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPub);
27642 type StablePtr = TerminalPubPtr;
27643 type Green = TerminalPubGreen;
27644 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27645 TerminalPubGreen(
27646 Arc::new(GreenNode {
27647 kind: SyntaxKind::TerminalPub,
27648 details: GreenNodeDetails::Node {
27649 children: vec![
27650 Trivia::missing(db).0,
27651 TokenPub::missing(db).0,
27652 Trivia::missing(db).0,
27653 ],
27654 width: TextWidth::default(),
27655 },
27656 })
27657 .intern(db),
27658 )
27659 }
27660 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27661 let kind = node.kind(db);
27662 assert_eq!(
27663 kind,
27664 SyntaxKind::TerminalPub,
27665 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27666 kind,
27667 SyntaxKind::TerminalPub
27668 );
27669 let children = db.get_children(node.clone());
27670 Self { node, children }
27671 }
27672 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27673 let kind = node.kind(db);
27674 if kind == SyntaxKind::TerminalPub { Some(Self::from_syntax_node(db, node)) } else { None }
27675 }
27676 fn as_syntax_node(&self) -> SyntaxNode {
27677 self.node.clone()
27678 }
27679 fn stable_ptr(&self) -> Self::StablePtr {
27680 TerminalPubPtr(self.node.0.stable_ptr)
27681 }
27682}
27683impl From<&TerminalPub> for SyntaxStablePtrId {
27684 fn from(node: &TerminalPub) -> Self {
27685 node.stable_ptr().untyped()
27686 }
27687}
27688#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27689pub struct TokenAnd {
27690 node: SyntaxNode,
27691}
27692impl Token for TokenAnd {
27693 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27694 TokenAndGreen(
27695 Arc::new(GreenNode {
27696 kind: SyntaxKind::TokenAnd,
27697 details: GreenNodeDetails::Token(text),
27698 })
27699 .intern(db),
27700 )
27701 }
27702 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27703 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27704 .clone()
27705 }
27706}
27707#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27708pub struct TokenAndPtr(pub SyntaxStablePtrId);
27709impl TypedStablePtr for TokenAndPtr {
27710 type SyntaxNode = TokenAnd;
27711 fn untyped(&self) -> SyntaxStablePtrId {
27712 self.0
27713 }
27714 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAnd {
27715 TokenAnd::from_syntax_node(db, self.0.lookup(db))
27716 }
27717}
27718impl From<TokenAndPtr> for SyntaxStablePtrId {
27719 fn from(ptr: TokenAndPtr) -> Self {
27720 ptr.untyped()
27721 }
27722}
27723#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27724pub struct TokenAndGreen(pub GreenId);
27725impl TokenAndGreen {
27726 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27727 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27728 }
27729}
27730impl TypedSyntaxNode for TokenAnd {
27731 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAnd);
27732 type StablePtr = TokenAndPtr;
27733 type Green = TokenAndGreen;
27734 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27735 TokenAndGreen(
27736 Arc::new(GreenNode {
27737 kind: SyntaxKind::TokenMissing,
27738 details: GreenNodeDetails::Token("".into()),
27739 })
27740 .intern(db),
27741 )
27742 }
27743 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27744 match node.0.green.lookup_intern(db).details {
27745 GreenNodeDetails::Token(_) => Self { node },
27746 GreenNodeDetails::Node { .. } => {
27747 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAnd)
27748 }
27749 }
27750 }
27751 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27752 match node.0.green.lookup_intern(db).details {
27753 GreenNodeDetails::Token(_) => Some(Self { node }),
27754 GreenNodeDetails::Node { .. } => None,
27755 }
27756 }
27757 fn as_syntax_node(&self) -> SyntaxNode {
27758 self.node.clone()
27759 }
27760 fn stable_ptr(&self) -> Self::StablePtr {
27761 TokenAndPtr(self.node.0.stable_ptr)
27762 }
27763}
27764impl From<&TokenAnd> for SyntaxStablePtrId {
27765 fn from(node: &TokenAnd) -> Self {
27766 node.stable_ptr().untyped()
27767 }
27768}
27769#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27770pub struct TerminalAnd {
27771 node: SyntaxNode,
27772 children: Arc<[SyntaxNode]>,
27773}
27774impl Terminal for TerminalAnd {
27775 const KIND: SyntaxKind = SyntaxKind::TerminalAnd;
27776 type TokenType = TokenAnd;
27777 fn new_green(
27778 db: &dyn SyntaxGroup,
27779 leading_trivia: TriviaGreen,
27780 token: <<TerminalAnd as Terminal>::TokenType as TypedSyntaxNode>::Green,
27781 trailing_trivia: TriviaGreen,
27782 ) -> Self::Green {
27783 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27784 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27785 TerminalAndGreen(
27786 Arc::new(GreenNode {
27787 kind: SyntaxKind::TerminalAnd,
27788 details: GreenNodeDetails::Node { children, width },
27789 })
27790 .intern(db),
27791 )
27792 }
27793 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27794 self.token(db).text(db)
27795 }
27796}
27797impl TerminalAnd {
27798 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27799 Trivia::from_syntax_node(db, self.children[0].clone())
27800 }
27801 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAnd {
27802 TokenAnd::from_syntax_node(db, self.children[1].clone())
27803 }
27804 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27805 Trivia::from_syntax_node(db, self.children[2].clone())
27806 }
27807}
27808#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27809pub struct TerminalAndPtr(pub SyntaxStablePtrId);
27810impl TerminalAndPtr {}
27811impl TypedStablePtr for TerminalAndPtr {
27812 type SyntaxNode = TerminalAnd;
27813 fn untyped(&self) -> SyntaxStablePtrId {
27814 self.0
27815 }
27816 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAnd {
27817 TerminalAnd::from_syntax_node(db, self.0.lookup(db))
27818 }
27819}
27820impl From<TerminalAndPtr> for SyntaxStablePtrId {
27821 fn from(ptr: TerminalAndPtr) -> Self {
27822 ptr.untyped()
27823 }
27824}
27825#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27826pub struct TerminalAndGreen(pub GreenId);
27827impl TypedSyntaxNode for TerminalAnd {
27828 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAnd);
27829 type StablePtr = TerminalAndPtr;
27830 type Green = TerminalAndGreen;
27831 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27832 TerminalAndGreen(
27833 Arc::new(GreenNode {
27834 kind: SyntaxKind::TerminalAnd,
27835 details: GreenNodeDetails::Node {
27836 children: vec![
27837 Trivia::missing(db).0,
27838 TokenAnd::missing(db).0,
27839 Trivia::missing(db).0,
27840 ],
27841 width: TextWidth::default(),
27842 },
27843 })
27844 .intern(db),
27845 )
27846 }
27847 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27848 let kind = node.kind(db);
27849 assert_eq!(
27850 kind,
27851 SyntaxKind::TerminalAnd,
27852 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27853 kind,
27854 SyntaxKind::TerminalAnd
27855 );
27856 let children = db.get_children(node.clone());
27857 Self { node, children }
27858 }
27859 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27860 let kind = node.kind(db);
27861 if kind == SyntaxKind::TerminalAnd { Some(Self::from_syntax_node(db, node)) } else { None }
27862 }
27863 fn as_syntax_node(&self) -> SyntaxNode {
27864 self.node.clone()
27865 }
27866 fn stable_ptr(&self) -> Self::StablePtr {
27867 TerminalAndPtr(self.node.0.stable_ptr)
27868 }
27869}
27870impl From<&TerminalAnd> for SyntaxStablePtrId {
27871 fn from(node: &TerminalAnd) -> Self {
27872 node.stable_ptr().untyped()
27873 }
27874}
27875#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27876pub struct TokenAndAnd {
27877 node: SyntaxNode,
27878}
27879impl Token for TokenAndAnd {
27880 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27881 TokenAndAndGreen(
27882 Arc::new(GreenNode {
27883 kind: SyntaxKind::TokenAndAnd,
27884 details: GreenNodeDetails::Token(text),
27885 })
27886 .intern(db),
27887 )
27888 }
27889 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27890 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27891 .clone()
27892 }
27893}
27894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27895pub struct TokenAndAndPtr(pub SyntaxStablePtrId);
27896impl TypedStablePtr for TokenAndAndPtr {
27897 type SyntaxNode = TokenAndAnd;
27898 fn untyped(&self) -> SyntaxStablePtrId {
27899 self.0
27900 }
27901 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAndAnd {
27902 TokenAndAnd::from_syntax_node(db, self.0.lookup(db))
27903 }
27904}
27905impl From<TokenAndAndPtr> for SyntaxStablePtrId {
27906 fn from(ptr: TokenAndAndPtr) -> Self {
27907 ptr.untyped()
27908 }
27909}
27910#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27911pub struct TokenAndAndGreen(pub GreenId);
27912impl TokenAndAndGreen {
27913 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27914 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27915 }
27916}
27917impl TypedSyntaxNode for TokenAndAnd {
27918 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAndAnd);
27919 type StablePtr = TokenAndAndPtr;
27920 type Green = TokenAndAndGreen;
27921 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27922 TokenAndAndGreen(
27923 Arc::new(GreenNode {
27924 kind: SyntaxKind::TokenMissing,
27925 details: GreenNodeDetails::Token("".into()),
27926 })
27927 .intern(db),
27928 )
27929 }
27930 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27931 match node.0.green.lookup_intern(db).details {
27932 GreenNodeDetails::Token(_) => Self { node },
27933 GreenNodeDetails::Node { .. } => {
27934 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAndAnd)
27935 }
27936 }
27937 }
27938 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
27939 match node.0.green.lookup_intern(db).details {
27940 GreenNodeDetails::Token(_) => Some(Self { node }),
27941 GreenNodeDetails::Node { .. } => None,
27942 }
27943 }
27944 fn as_syntax_node(&self) -> SyntaxNode {
27945 self.node.clone()
27946 }
27947 fn stable_ptr(&self) -> Self::StablePtr {
27948 TokenAndAndPtr(self.node.0.stable_ptr)
27949 }
27950}
27951impl From<&TokenAndAnd> for SyntaxStablePtrId {
27952 fn from(node: &TokenAndAnd) -> Self {
27953 node.stable_ptr().untyped()
27954 }
27955}
27956#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27957pub struct TerminalAndAnd {
27958 node: SyntaxNode,
27959 children: Arc<[SyntaxNode]>,
27960}
27961impl Terminal for TerminalAndAnd {
27962 const KIND: SyntaxKind = SyntaxKind::TerminalAndAnd;
27963 type TokenType = TokenAndAnd;
27964 fn new_green(
27965 db: &dyn SyntaxGroup,
27966 leading_trivia: TriviaGreen,
27967 token: <<TerminalAndAnd as Terminal>::TokenType as TypedSyntaxNode>::Green,
27968 trailing_trivia: TriviaGreen,
27969 ) -> Self::Green {
27970 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27971 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27972 TerminalAndAndGreen(
27973 Arc::new(GreenNode {
27974 kind: SyntaxKind::TerminalAndAnd,
27975 details: GreenNodeDetails::Node { children, width },
27976 })
27977 .intern(db),
27978 )
27979 }
27980 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27981 self.token(db).text(db)
27982 }
27983}
27984impl TerminalAndAnd {
27985 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27986 Trivia::from_syntax_node(db, self.children[0].clone())
27987 }
27988 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAndAnd {
27989 TokenAndAnd::from_syntax_node(db, self.children[1].clone())
27990 }
27991 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27992 Trivia::from_syntax_node(db, self.children[2].clone())
27993 }
27994}
27995#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27996pub struct TerminalAndAndPtr(pub SyntaxStablePtrId);
27997impl TerminalAndAndPtr {}
27998impl TypedStablePtr for TerminalAndAndPtr {
27999 type SyntaxNode = TerminalAndAnd;
28000 fn untyped(&self) -> SyntaxStablePtrId {
28001 self.0
28002 }
28003 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAndAnd {
28004 TerminalAndAnd::from_syntax_node(db, self.0.lookup(db))
28005 }
28006}
28007impl From<TerminalAndAndPtr> for SyntaxStablePtrId {
28008 fn from(ptr: TerminalAndAndPtr) -> Self {
28009 ptr.untyped()
28010 }
28011}
28012#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28013pub struct TerminalAndAndGreen(pub GreenId);
28014impl TypedSyntaxNode for TerminalAndAnd {
28015 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAndAnd);
28016 type StablePtr = TerminalAndAndPtr;
28017 type Green = TerminalAndAndGreen;
28018 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28019 TerminalAndAndGreen(
28020 Arc::new(GreenNode {
28021 kind: SyntaxKind::TerminalAndAnd,
28022 details: GreenNodeDetails::Node {
28023 children: vec![
28024 Trivia::missing(db).0,
28025 TokenAndAnd::missing(db).0,
28026 Trivia::missing(db).0,
28027 ],
28028 width: TextWidth::default(),
28029 },
28030 })
28031 .intern(db),
28032 )
28033 }
28034 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28035 let kind = node.kind(db);
28036 assert_eq!(
28037 kind,
28038 SyntaxKind::TerminalAndAnd,
28039 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28040 kind,
28041 SyntaxKind::TerminalAndAnd
28042 );
28043 let children = db.get_children(node.clone());
28044 Self { node, children }
28045 }
28046 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28047 let kind = node.kind(db);
28048 if kind == SyntaxKind::TerminalAndAnd {
28049 Some(Self::from_syntax_node(db, node))
28050 } else {
28051 None
28052 }
28053 }
28054 fn as_syntax_node(&self) -> SyntaxNode {
28055 self.node.clone()
28056 }
28057 fn stable_ptr(&self) -> Self::StablePtr {
28058 TerminalAndAndPtr(self.node.0.stable_ptr)
28059 }
28060}
28061impl From<&TerminalAndAnd> for SyntaxStablePtrId {
28062 fn from(node: &TerminalAndAnd) -> Self {
28063 node.stable_ptr().untyped()
28064 }
28065}
28066#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28067pub struct TokenArrow {
28068 node: SyntaxNode,
28069}
28070impl Token for TokenArrow {
28071 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28072 TokenArrowGreen(
28073 Arc::new(GreenNode {
28074 kind: SyntaxKind::TokenArrow,
28075 details: GreenNodeDetails::Token(text),
28076 })
28077 .intern(db),
28078 )
28079 }
28080 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28081 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28082 .clone()
28083 }
28084}
28085#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28086pub struct TokenArrowPtr(pub SyntaxStablePtrId);
28087impl TypedStablePtr for TokenArrowPtr {
28088 type SyntaxNode = TokenArrow;
28089 fn untyped(&self) -> SyntaxStablePtrId {
28090 self.0
28091 }
28092 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenArrow {
28093 TokenArrow::from_syntax_node(db, self.0.lookup(db))
28094 }
28095}
28096impl From<TokenArrowPtr> for SyntaxStablePtrId {
28097 fn from(ptr: TokenArrowPtr) -> Self {
28098 ptr.untyped()
28099 }
28100}
28101#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28102pub struct TokenArrowGreen(pub GreenId);
28103impl TokenArrowGreen {
28104 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28105 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28106 }
28107}
28108impl TypedSyntaxNode for TokenArrow {
28109 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenArrow);
28110 type StablePtr = TokenArrowPtr;
28111 type Green = TokenArrowGreen;
28112 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28113 TokenArrowGreen(
28114 Arc::new(GreenNode {
28115 kind: SyntaxKind::TokenMissing,
28116 details: GreenNodeDetails::Token("".into()),
28117 })
28118 .intern(db),
28119 )
28120 }
28121 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28122 match node.0.green.lookup_intern(db).details {
28123 GreenNodeDetails::Token(_) => Self { node },
28124 GreenNodeDetails::Node { .. } => {
28125 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenArrow)
28126 }
28127 }
28128 }
28129 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28130 match node.0.green.lookup_intern(db).details {
28131 GreenNodeDetails::Token(_) => Some(Self { node }),
28132 GreenNodeDetails::Node { .. } => None,
28133 }
28134 }
28135 fn as_syntax_node(&self) -> SyntaxNode {
28136 self.node.clone()
28137 }
28138 fn stable_ptr(&self) -> Self::StablePtr {
28139 TokenArrowPtr(self.node.0.stable_ptr)
28140 }
28141}
28142impl From<&TokenArrow> for SyntaxStablePtrId {
28143 fn from(node: &TokenArrow) -> Self {
28144 node.stable_ptr().untyped()
28145 }
28146}
28147#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28148pub struct TerminalArrow {
28149 node: SyntaxNode,
28150 children: Arc<[SyntaxNode]>,
28151}
28152impl Terminal for TerminalArrow {
28153 const KIND: SyntaxKind = SyntaxKind::TerminalArrow;
28154 type TokenType = TokenArrow;
28155 fn new_green(
28156 db: &dyn SyntaxGroup,
28157 leading_trivia: TriviaGreen,
28158 token: <<TerminalArrow as Terminal>::TokenType as TypedSyntaxNode>::Green,
28159 trailing_trivia: TriviaGreen,
28160 ) -> Self::Green {
28161 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28162 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28163 TerminalArrowGreen(
28164 Arc::new(GreenNode {
28165 kind: SyntaxKind::TerminalArrow,
28166 details: GreenNodeDetails::Node { children, width },
28167 })
28168 .intern(db),
28169 )
28170 }
28171 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28172 self.token(db).text(db)
28173 }
28174}
28175impl TerminalArrow {
28176 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28177 Trivia::from_syntax_node(db, self.children[0].clone())
28178 }
28179 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenArrow {
28180 TokenArrow::from_syntax_node(db, self.children[1].clone())
28181 }
28182 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28183 Trivia::from_syntax_node(db, self.children[2].clone())
28184 }
28185}
28186#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28187pub struct TerminalArrowPtr(pub SyntaxStablePtrId);
28188impl TerminalArrowPtr {}
28189impl TypedStablePtr for TerminalArrowPtr {
28190 type SyntaxNode = TerminalArrow;
28191 fn untyped(&self) -> SyntaxStablePtrId {
28192 self.0
28193 }
28194 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalArrow {
28195 TerminalArrow::from_syntax_node(db, self.0.lookup(db))
28196 }
28197}
28198impl From<TerminalArrowPtr> for SyntaxStablePtrId {
28199 fn from(ptr: TerminalArrowPtr) -> Self {
28200 ptr.untyped()
28201 }
28202}
28203#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28204pub struct TerminalArrowGreen(pub GreenId);
28205impl TypedSyntaxNode for TerminalArrow {
28206 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalArrow);
28207 type StablePtr = TerminalArrowPtr;
28208 type Green = TerminalArrowGreen;
28209 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28210 TerminalArrowGreen(
28211 Arc::new(GreenNode {
28212 kind: SyntaxKind::TerminalArrow,
28213 details: GreenNodeDetails::Node {
28214 children: vec![
28215 Trivia::missing(db).0,
28216 TokenArrow::missing(db).0,
28217 Trivia::missing(db).0,
28218 ],
28219 width: TextWidth::default(),
28220 },
28221 })
28222 .intern(db),
28223 )
28224 }
28225 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28226 let kind = node.kind(db);
28227 assert_eq!(
28228 kind,
28229 SyntaxKind::TerminalArrow,
28230 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28231 kind,
28232 SyntaxKind::TerminalArrow
28233 );
28234 let children = db.get_children(node.clone());
28235 Self { node, children }
28236 }
28237 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28238 let kind = node.kind(db);
28239 if kind == SyntaxKind::TerminalArrow {
28240 Some(Self::from_syntax_node(db, node))
28241 } else {
28242 None
28243 }
28244 }
28245 fn as_syntax_node(&self) -> SyntaxNode {
28246 self.node.clone()
28247 }
28248 fn stable_ptr(&self) -> Self::StablePtr {
28249 TerminalArrowPtr(self.node.0.stable_ptr)
28250 }
28251}
28252impl From<&TerminalArrow> for SyntaxStablePtrId {
28253 fn from(node: &TerminalArrow) -> Self {
28254 node.stable_ptr().untyped()
28255 }
28256}
28257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28258pub struct TokenAt {
28259 node: SyntaxNode,
28260}
28261impl Token for TokenAt {
28262 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28263 TokenAtGreen(
28264 Arc::new(GreenNode {
28265 kind: SyntaxKind::TokenAt,
28266 details: GreenNodeDetails::Token(text),
28267 })
28268 .intern(db),
28269 )
28270 }
28271 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28272 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28273 .clone()
28274 }
28275}
28276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28277pub struct TokenAtPtr(pub SyntaxStablePtrId);
28278impl TypedStablePtr for TokenAtPtr {
28279 type SyntaxNode = TokenAt;
28280 fn untyped(&self) -> SyntaxStablePtrId {
28281 self.0
28282 }
28283 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAt {
28284 TokenAt::from_syntax_node(db, self.0.lookup(db))
28285 }
28286}
28287impl From<TokenAtPtr> for SyntaxStablePtrId {
28288 fn from(ptr: TokenAtPtr) -> Self {
28289 ptr.untyped()
28290 }
28291}
28292#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28293pub struct TokenAtGreen(pub GreenId);
28294impl TokenAtGreen {
28295 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28296 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28297 }
28298}
28299impl TypedSyntaxNode for TokenAt {
28300 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAt);
28301 type StablePtr = TokenAtPtr;
28302 type Green = TokenAtGreen;
28303 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28304 TokenAtGreen(
28305 Arc::new(GreenNode {
28306 kind: SyntaxKind::TokenMissing,
28307 details: GreenNodeDetails::Token("".into()),
28308 })
28309 .intern(db),
28310 )
28311 }
28312 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28313 match node.0.green.lookup_intern(db).details {
28314 GreenNodeDetails::Token(_) => Self { node },
28315 GreenNodeDetails::Node { .. } => {
28316 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAt)
28317 }
28318 }
28319 }
28320 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28321 match node.0.green.lookup_intern(db).details {
28322 GreenNodeDetails::Token(_) => Some(Self { node }),
28323 GreenNodeDetails::Node { .. } => None,
28324 }
28325 }
28326 fn as_syntax_node(&self) -> SyntaxNode {
28327 self.node.clone()
28328 }
28329 fn stable_ptr(&self) -> Self::StablePtr {
28330 TokenAtPtr(self.node.0.stable_ptr)
28331 }
28332}
28333impl From<&TokenAt> for SyntaxStablePtrId {
28334 fn from(node: &TokenAt) -> Self {
28335 node.stable_ptr().untyped()
28336 }
28337}
28338#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28339pub struct TerminalAt {
28340 node: SyntaxNode,
28341 children: Arc<[SyntaxNode]>,
28342}
28343impl Terminal for TerminalAt {
28344 const KIND: SyntaxKind = SyntaxKind::TerminalAt;
28345 type TokenType = TokenAt;
28346 fn new_green(
28347 db: &dyn SyntaxGroup,
28348 leading_trivia: TriviaGreen,
28349 token: <<TerminalAt as Terminal>::TokenType as TypedSyntaxNode>::Green,
28350 trailing_trivia: TriviaGreen,
28351 ) -> Self::Green {
28352 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28353 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28354 TerminalAtGreen(
28355 Arc::new(GreenNode {
28356 kind: SyntaxKind::TerminalAt,
28357 details: GreenNodeDetails::Node { children, width },
28358 })
28359 .intern(db),
28360 )
28361 }
28362 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28363 self.token(db).text(db)
28364 }
28365}
28366impl TerminalAt {
28367 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28368 Trivia::from_syntax_node(db, self.children[0].clone())
28369 }
28370 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAt {
28371 TokenAt::from_syntax_node(db, self.children[1].clone())
28372 }
28373 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28374 Trivia::from_syntax_node(db, self.children[2].clone())
28375 }
28376}
28377#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28378pub struct TerminalAtPtr(pub SyntaxStablePtrId);
28379impl TerminalAtPtr {}
28380impl TypedStablePtr for TerminalAtPtr {
28381 type SyntaxNode = TerminalAt;
28382 fn untyped(&self) -> SyntaxStablePtrId {
28383 self.0
28384 }
28385 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAt {
28386 TerminalAt::from_syntax_node(db, self.0.lookup(db))
28387 }
28388}
28389impl From<TerminalAtPtr> for SyntaxStablePtrId {
28390 fn from(ptr: TerminalAtPtr) -> Self {
28391 ptr.untyped()
28392 }
28393}
28394#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28395pub struct TerminalAtGreen(pub GreenId);
28396impl TypedSyntaxNode for TerminalAt {
28397 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAt);
28398 type StablePtr = TerminalAtPtr;
28399 type Green = TerminalAtGreen;
28400 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28401 TerminalAtGreen(
28402 Arc::new(GreenNode {
28403 kind: SyntaxKind::TerminalAt,
28404 details: GreenNodeDetails::Node {
28405 children: vec![
28406 Trivia::missing(db).0,
28407 TokenAt::missing(db).0,
28408 Trivia::missing(db).0,
28409 ],
28410 width: TextWidth::default(),
28411 },
28412 })
28413 .intern(db),
28414 )
28415 }
28416 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28417 let kind = node.kind(db);
28418 assert_eq!(
28419 kind,
28420 SyntaxKind::TerminalAt,
28421 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28422 kind,
28423 SyntaxKind::TerminalAt
28424 );
28425 let children = db.get_children(node.clone());
28426 Self { node, children }
28427 }
28428 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28429 let kind = node.kind(db);
28430 if kind == SyntaxKind::TerminalAt { Some(Self::from_syntax_node(db, node)) } else { None }
28431 }
28432 fn as_syntax_node(&self) -> SyntaxNode {
28433 self.node.clone()
28434 }
28435 fn stable_ptr(&self) -> Self::StablePtr {
28436 TerminalAtPtr(self.node.0.stable_ptr)
28437 }
28438}
28439impl From<&TerminalAt> for SyntaxStablePtrId {
28440 fn from(node: &TerminalAt) -> Self {
28441 node.stable_ptr().untyped()
28442 }
28443}
28444#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28445pub struct TokenBadCharacters {
28446 node: SyntaxNode,
28447}
28448impl Token for TokenBadCharacters {
28449 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28450 TokenBadCharactersGreen(
28451 Arc::new(GreenNode {
28452 kind: SyntaxKind::TokenBadCharacters,
28453 details: GreenNodeDetails::Token(text),
28454 })
28455 .intern(db),
28456 )
28457 }
28458 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28459 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28460 .clone()
28461 }
28462}
28463#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28464pub struct TokenBadCharactersPtr(pub SyntaxStablePtrId);
28465impl TypedStablePtr for TokenBadCharactersPtr {
28466 type SyntaxNode = TokenBadCharacters;
28467 fn untyped(&self) -> SyntaxStablePtrId {
28468 self.0
28469 }
28470 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBadCharacters {
28471 TokenBadCharacters::from_syntax_node(db, self.0.lookup(db))
28472 }
28473}
28474impl From<TokenBadCharactersPtr> for SyntaxStablePtrId {
28475 fn from(ptr: TokenBadCharactersPtr) -> Self {
28476 ptr.untyped()
28477 }
28478}
28479#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28480pub struct TokenBadCharactersGreen(pub GreenId);
28481impl TokenBadCharactersGreen {
28482 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28483 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28484 }
28485}
28486impl TypedSyntaxNode for TokenBadCharacters {
28487 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBadCharacters);
28488 type StablePtr = TokenBadCharactersPtr;
28489 type Green = TokenBadCharactersGreen;
28490 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28491 TokenBadCharactersGreen(
28492 Arc::new(GreenNode {
28493 kind: SyntaxKind::TokenMissing,
28494 details: GreenNodeDetails::Token("".into()),
28495 })
28496 .intern(db),
28497 )
28498 }
28499 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28500 match node.0.green.lookup_intern(db).details {
28501 GreenNodeDetails::Token(_) => Self { node },
28502 GreenNodeDetails::Node { .. } => panic!(
28503 "Expected a token {:?}, not an internal node",
28504 SyntaxKind::TokenBadCharacters
28505 ),
28506 }
28507 }
28508 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28509 match node.0.green.lookup_intern(db).details {
28510 GreenNodeDetails::Token(_) => Some(Self { node }),
28511 GreenNodeDetails::Node { .. } => None,
28512 }
28513 }
28514 fn as_syntax_node(&self) -> SyntaxNode {
28515 self.node.clone()
28516 }
28517 fn stable_ptr(&self) -> Self::StablePtr {
28518 TokenBadCharactersPtr(self.node.0.stable_ptr)
28519 }
28520}
28521impl From<&TokenBadCharacters> for SyntaxStablePtrId {
28522 fn from(node: &TokenBadCharacters) -> Self {
28523 node.stable_ptr().untyped()
28524 }
28525}
28526#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28527pub struct TerminalBadCharacters {
28528 node: SyntaxNode,
28529 children: Arc<[SyntaxNode]>,
28530}
28531impl Terminal for TerminalBadCharacters {
28532 const KIND: SyntaxKind = SyntaxKind::TerminalBadCharacters;
28533 type TokenType = TokenBadCharacters;
28534 fn new_green(
28535 db: &dyn SyntaxGroup,
28536 leading_trivia: TriviaGreen,
28537 token: <<TerminalBadCharacters as Terminal>::TokenType as TypedSyntaxNode>::Green,
28538 trailing_trivia: TriviaGreen,
28539 ) -> Self::Green {
28540 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28541 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28542 TerminalBadCharactersGreen(
28543 Arc::new(GreenNode {
28544 kind: SyntaxKind::TerminalBadCharacters,
28545 details: GreenNodeDetails::Node { children, width },
28546 })
28547 .intern(db),
28548 )
28549 }
28550 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28551 self.token(db).text(db)
28552 }
28553}
28554impl TerminalBadCharacters {
28555 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28556 Trivia::from_syntax_node(db, self.children[0].clone())
28557 }
28558 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBadCharacters {
28559 TokenBadCharacters::from_syntax_node(db, self.children[1].clone())
28560 }
28561 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28562 Trivia::from_syntax_node(db, self.children[2].clone())
28563 }
28564}
28565#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28566pub struct TerminalBadCharactersPtr(pub SyntaxStablePtrId);
28567impl TerminalBadCharactersPtr {}
28568impl TypedStablePtr for TerminalBadCharactersPtr {
28569 type SyntaxNode = TerminalBadCharacters;
28570 fn untyped(&self) -> SyntaxStablePtrId {
28571 self.0
28572 }
28573 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBadCharacters {
28574 TerminalBadCharacters::from_syntax_node(db, self.0.lookup(db))
28575 }
28576}
28577impl From<TerminalBadCharactersPtr> for SyntaxStablePtrId {
28578 fn from(ptr: TerminalBadCharactersPtr) -> Self {
28579 ptr.untyped()
28580 }
28581}
28582#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28583pub struct TerminalBadCharactersGreen(pub GreenId);
28584impl TypedSyntaxNode for TerminalBadCharacters {
28585 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBadCharacters);
28586 type StablePtr = TerminalBadCharactersPtr;
28587 type Green = TerminalBadCharactersGreen;
28588 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28589 TerminalBadCharactersGreen(
28590 Arc::new(GreenNode {
28591 kind: SyntaxKind::TerminalBadCharacters,
28592 details: GreenNodeDetails::Node {
28593 children: vec![
28594 Trivia::missing(db).0,
28595 TokenBadCharacters::missing(db).0,
28596 Trivia::missing(db).0,
28597 ],
28598 width: TextWidth::default(),
28599 },
28600 })
28601 .intern(db),
28602 )
28603 }
28604 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28605 let kind = node.kind(db);
28606 assert_eq!(
28607 kind,
28608 SyntaxKind::TerminalBadCharacters,
28609 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28610 kind,
28611 SyntaxKind::TerminalBadCharacters
28612 );
28613 let children = db.get_children(node.clone());
28614 Self { node, children }
28615 }
28616 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28617 let kind = node.kind(db);
28618 if kind == SyntaxKind::TerminalBadCharacters {
28619 Some(Self::from_syntax_node(db, node))
28620 } else {
28621 None
28622 }
28623 }
28624 fn as_syntax_node(&self) -> SyntaxNode {
28625 self.node.clone()
28626 }
28627 fn stable_ptr(&self) -> Self::StablePtr {
28628 TerminalBadCharactersPtr(self.node.0.stable_ptr)
28629 }
28630}
28631impl From<&TerminalBadCharacters> for SyntaxStablePtrId {
28632 fn from(node: &TerminalBadCharacters) -> Self {
28633 node.stable_ptr().untyped()
28634 }
28635}
28636#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28637pub struct TokenColon {
28638 node: SyntaxNode,
28639}
28640impl Token for TokenColon {
28641 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28642 TokenColonGreen(
28643 Arc::new(GreenNode {
28644 kind: SyntaxKind::TokenColon,
28645 details: GreenNodeDetails::Token(text),
28646 })
28647 .intern(db),
28648 )
28649 }
28650 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28651 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28652 .clone()
28653 }
28654}
28655#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28656pub struct TokenColonPtr(pub SyntaxStablePtrId);
28657impl TypedStablePtr for TokenColonPtr {
28658 type SyntaxNode = TokenColon;
28659 fn untyped(&self) -> SyntaxStablePtrId {
28660 self.0
28661 }
28662 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenColon {
28663 TokenColon::from_syntax_node(db, self.0.lookup(db))
28664 }
28665}
28666impl From<TokenColonPtr> for SyntaxStablePtrId {
28667 fn from(ptr: TokenColonPtr) -> Self {
28668 ptr.untyped()
28669 }
28670}
28671#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28672pub struct TokenColonGreen(pub GreenId);
28673impl TokenColonGreen {
28674 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28675 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28676 }
28677}
28678impl TypedSyntaxNode for TokenColon {
28679 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenColon);
28680 type StablePtr = TokenColonPtr;
28681 type Green = TokenColonGreen;
28682 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28683 TokenColonGreen(
28684 Arc::new(GreenNode {
28685 kind: SyntaxKind::TokenMissing,
28686 details: GreenNodeDetails::Token("".into()),
28687 })
28688 .intern(db),
28689 )
28690 }
28691 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28692 match node.0.green.lookup_intern(db).details {
28693 GreenNodeDetails::Token(_) => Self { node },
28694 GreenNodeDetails::Node { .. } => {
28695 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenColon)
28696 }
28697 }
28698 }
28699 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28700 match node.0.green.lookup_intern(db).details {
28701 GreenNodeDetails::Token(_) => Some(Self { node }),
28702 GreenNodeDetails::Node { .. } => None,
28703 }
28704 }
28705 fn as_syntax_node(&self) -> SyntaxNode {
28706 self.node.clone()
28707 }
28708 fn stable_ptr(&self) -> Self::StablePtr {
28709 TokenColonPtr(self.node.0.stable_ptr)
28710 }
28711}
28712impl From<&TokenColon> for SyntaxStablePtrId {
28713 fn from(node: &TokenColon) -> Self {
28714 node.stable_ptr().untyped()
28715 }
28716}
28717#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28718pub struct TerminalColon {
28719 node: SyntaxNode,
28720 children: Arc<[SyntaxNode]>,
28721}
28722impl Terminal for TerminalColon {
28723 const KIND: SyntaxKind = SyntaxKind::TerminalColon;
28724 type TokenType = TokenColon;
28725 fn new_green(
28726 db: &dyn SyntaxGroup,
28727 leading_trivia: TriviaGreen,
28728 token: <<TerminalColon as Terminal>::TokenType as TypedSyntaxNode>::Green,
28729 trailing_trivia: TriviaGreen,
28730 ) -> Self::Green {
28731 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28732 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28733 TerminalColonGreen(
28734 Arc::new(GreenNode {
28735 kind: SyntaxKind::TerminalColon,
28736 details: GreenNodeDetails::Node { children, width },
28737 })
28738 .intern(db),
28739 )
28740 }
28741 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28742 self.token(db).text(db)
28743 }
28744}
28745impl TerminalColon {
28746 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28747 Trivia::from_syntax_node(db, self.children[0].clone())
28748 }
28749 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenColon {
28750 TokenColon::from_syntax_node(db, self.children[1].clone())
28751 }
28752 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28753 Trivia::from_syntax_node(db, self.children[2].clone())
28754 }
28755}
28756#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28757pub struct TerminalColonPtr(pub SyntaxStablePtrId);
28758impl TerminalColonPtr {}
28759impl TypedStablePtr for TerminalColonPtr {
28760 type SyntaxNode = TerminalColon;
28761 fn untyped(&self) -> SyntaxStablePtrId {
28762 self.0
28763 }
28764 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalColon {
28765 TerminalColon::from_syntax_node(db, self.0.lookup(db))
28766 }
28767}
28768impl From<TerminalColonPtr> for SyntaxStablePtrId {
28769 fn from(ptr: TerminalColonPtr) -> Self {
28770 ptr.untyped()
28771 }
28772}
28773#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28774pub struct TerminalColonGreen(pub GreenId);
28775impl TypedSyntaxNode for TerminalColon {
28776 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalColon);
28777 type StablePtr = TerminalColonPtr;
28778 type Green = TerminalColonGreen;
28779 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28780 TerminalColonGreen(
28781 Arc::new(GreenNode {
28782 kind: SyntaxKind::TerminalColon,
28783 details: GreenNodeDetails::Node {
28784 children: vec![
28785 Trivia::missing(db).0,
28786 TokenColon::missing(db).0,
28787 Trivia::missing(db).0,
28788 ],
28789 width: TextWidth::default(),
28790 },
28791 })
28792 .intern(db),
28793 )
28794 }
28795 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28796 let kind = node.kind(db);
28797 assert_eq!(
28798 kind,
28799 SyntaxKind::TerminalColon,
28800 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28801 kind,
28802 SyntaxKind::TerminalColon
28803 );
28804 let children = db.get_children(node.clone());
28805 Self { node, children }
28806 }
28807 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28808 let kind = node.kind(db);
28809 if kind == SyntaxKind::TerminalColon {
28810 Some(Self::from_syntax_node(db, node))
28811 } else {
28812 None
28813 }
28814 }
28815 fn as_syntax_node(&self) -> SyntaxNode {
28816 self.node.clone()
28817 }
28818 fn stable_ptr(&self) -> Self::StablePtr {
28819 TerminalColonPtr(self.node.0.stable_ptr)
28820 }
28821}
28822impl From<&TerminalColon> for SyntaxStablePtrId {
28823 fn from(node: &TerminalColon) -> Self {
28824 node.stable_ptr().untyped()
28825 }
28826}
28827#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28828pub struct TokenColonColon {
28829 node: SyntaxNode,
28830}
28831impl Token for TokenColonColon {
28832 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28833 TokenColonColonGreen(
28834 Arc::new(GreenNode {
28835 kind: SyntaxKind::TokenColonColon,
28836 details: GreenNodeDetails::Token(text),
28837 })
28838 .intern(db),
28839 )
28840 }
28841 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28842 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28843 .clone()
28844 }
28845}
28846#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28847pub struct TokenColonColonPtr(pub SyntaxStablePtrId);
28848impl TypedStablePtr for TokenColonColonPtr {
28849 type SyntaxNode = TokenColonColon;
28850 fn untyped(&self) -> SyntaxStablePtrId {
28851 self.0
28852 }
28853 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenColonColon {
28854 TokenColonColon::from_syntax_node(db, self.0.lookup(db))
28855 }
28856}
28857impl From<TokenColonColonPtr> for SyntaxStablePtrId {
28858 fn from(ptr: TokenColonColonPtr) -> Self {
28859 ptr.untyped()
28860 }
28861}
28862#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28863pub struct TokenColonColonGreen(pub GreenId);
28864impl TokenColonColonGreen {
28865 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28866 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28867 }
28868}
28869impl TypedSyntaxNode for TokenColonColon {
28870 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenColonColon);
28871 type StablePtr = TokenColonColonPtr;
28872 type Green = TokenColonColonGreen;
28873 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28874 TokenColonColonGreen(
28875 Arc::new(GreenNode {
28876 kind: SyntaxKind::TokenMissing,
28877 details: GreenNodeDetails::Token("".into()),
28878 })
28879 .intern(db),
28880 )
28881 }
28882 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28883 match node.0.green.lookup_intern(db).details {
28884 GreenNodeDetails::Token(_) => Self { node },
28885 GreenNodeDetails::Node { .. } => {
28886 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenColonColon)
28887 }
28888 }
28889 }
28890 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28891 match node.0.green.lookup_intern(db).details {
28892 GreenNodeDetails::Token(_) => Some(Self { node }),
28893 GreenNodeDetails::Node { .. } => None,
28894 }
28895 }
28896 fn as_syntax_node(&self) -> SyntaxNode {
28897 self.node.clone()
28898 }
28899 fn stable_ptr(&self) -> Self::StablePtr {
28900 TokenColonColonPtr(self.node.0.stable_ptr)
28901 }
28902}
28903impl From<&TokenColonColon> for SyntaxStablePtrId {
28904 fn from(node: &TokenColonColon) -> Self {
28905 node.stable_ptr().untyped()
28906 }
28907}
28908#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28909pub struct TerminalColonColon {
28910 node: SyntaxNode,
28911 children: Arc<[SyntaxNode]>,
28912}
28913impl Terminal for TerminalColonColon {
28914 const KIND: SyntaxKind = SyntaxKind::TerminalColonColon;
28915 type TokenType = TokenColonColon;
28916 fn new_green(
28917 db: &dyn SyntaxGroup,
28918 leading_trivia: TriviaGreen,
28919 token: <<TerminalColonColon as Terminal>::TokenType as TypedSyntaxNode>::Green,
28920 trailing_trivia: TriviaGreen,
28921 ) -> Self::Green {
28922 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28923 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28924 TerminalColonColonGreen(
28925 Arc::new(GreenNode {
28926 kind: SyntaxKind::TerminalColonColon,
28927 details: GreenNodeDetails::Node { children, width },
28928 })
28929 .intern(db),
28930 )
28931 }
28932 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28933 self.token(db).text(db)
28934 }
28935}
28936impl TerminalColonColon {
28937 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28938 Trivia::from_syntax_node(db, self.children[0].clone())
28939 }
28940 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenColonColon {
28941 TokenColonColon::from_syntax_node(db, self.children[1].clone())
28942 }
28943 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28944 Trivia::from_syntax_node(db, self.children[2].clone())
28945 }
28946}
28947#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28948pub struct TerminalColonColonPtr(pub SyntaxStablePtrId);
28949impl TerminalColonColonPtr {}
28950impl TypedStablePtr for TerminalColonColonPtr {
28951 type SyntaxNode = TerminalColonColon;
28952 fn untyped(&self) -> SyntaxStablePtrId {
28953 self.0
28954 }
28955 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalColonColon {
28956 TerminalColonColon::from_syntax_node(db, self.0.lookup(db))
28957 }
28958}
28959impl From<TerminalColonColonPtr> for SyntaxStablePtrId {
28960 fn from(ptr: TerminalColonColonPtr) -> Self {
28961 ptr.untyped()
28962 }
28963}
28964#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28965pub struct TerminalColonColonGreen(pub GreenId);
28966impl TypedSyntaxNode for TerminalColonColon {
28967 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalColonColon);
28968 type StablePtr = TerminalColonColonPtr;
28969 type Green = TerminalColonColonGreen;
28970 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28971 TerminalColonColonGreen(
28972 Arc::new(GreenNode {
28973 kind: SyntaxKind::TerminalColonColon,
28974 details: GreenNodeDetails::Node {
28975 children: vec![
28976 Trivia::missing(db).0,
28977 TokenColonColon::missing(db).0,
28978 Trivia::missing(db).0,
28979 ],
28980 width: TextWidth::default(),
28981 },
28982 })
28983 .intern(db),
28984 )
28985 }
28986 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28987 let kind = node.kind(db);
28988 assert_eq!(
28989 kind,
28990 SyntaxKind::TerminalColonColon,
28991 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28992 kind,
28993 SyntaxKind::TerminalColonColon
28994 );
28995 let children = db.get_children(node.clone());
28996 Self { node, children }
28997 }
28998 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
28999 let kind = node.kind(db);
29000 if kind == SyntaxKind::TerminalColonColon {
29001 Some(Self::from_syntax_node(db, node))
29002 } else {
29003 None
29004 }
29005 }
29006 fn as_syntax_node(&self) -> SyntaxNode {
29007 self.node.clone()
29008 }
29009 fn stable_ptr(&self) -> Self::StablePtr {
29010 TerminalColonColonPtr(self.node.0.stable_ptr)
29011 }
29012}
29013impl From<&TerminalColonColon> for SyntaxStablePtrId {
29014 fn from(node: &TerminalColonColon) -> Self {
29015 node.stable_ptr().untyped()
29016 }
29017}
29018#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29019pub struct TokenComma {
29020 node: SyntaxNode,
29021}
29022impl Token for TokenComma {
29023 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29024 TokenCommaGreen(
29025 Arc::new(GreenNode {
29026 kind: SyntaxKind::TokenComma,
29027 details: GreenNodeDetails::Token(text),
29028 })
29029 .intern(db),
29030 )
29031 }
29032 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29033 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29034 .clone()
29035 }
29036}
29037#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29038pub struct TokenCommaPtr(pub SyntaxStablePtrId);
29039impl TypedStablePtr for TokenCommaPtr {
29040 type SyntaxNode = TokenComma;
29041 fn untyped(&self) -> SyntaxStablePtrId {
29042 self.0
29043 }
29044 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenComma {
29045 TokenComma::from_syntax_node(db, self.0.lookup(db))
29046 }
29047}
29048impl From<TokenCommaPtr> for SyntaxStablePtrId {
29049 fn from(ptr: TokenCommaPtr) -> Self {
29050 ptr.untyped()
29051 }
29052}
29053#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29054pub struct TokenCommaGreen(pub GreenId);
29055impl TokenCommaGreen {
29056 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29057 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29058 }
29059}
29060impl TypedSyntaxNode for TokenComma {
29061 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenComma);
29062 type StablePtr = TokenCommaPtr;
29063 type Green = TokenCommaGreen;
29064 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29065 TokenCommaGreen(
29066 Arc::new(GreenNode {
29067 kind: SyntaxKind::TokenMissing,
29068 details: GreenNodeDetails::Token("".into()),
29069 })
29070 .intern(db),
29071 )
29072 }
29073 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29074 match node.0.green.lookup_intern(db).details {
29075 GreenNodeDetails::Token(_) => Self { node },
29076 GreenNodeDetails::Node { .. } => {
29077 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenComma)
29078 }
29079 }
29080 }
29081 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29082 match node.0.green.lookup_intern(db).details {
29083 GreenNodeDetails::Token(_) => Some(Self { node }),
29084 GreenNodeDetails::Node { .. } => None,
29085 }
29086 }
29087 fn as_syntax_node(&self) -> SyntaxNode {
29088 self.node.clone()
29089 }
29090 fn stable_ptr(&self) -> Self::StablePtr {
29091 TokenCommaPtr(self.node.0.stable_ptr)
29092 }
29093}
29094impl From<&TokenComma> for SyntaxStablePtrId {
29095 fn from(node: &TokenComma) -> Self {
29096 node.stable_ptr().untyped()
29097 }
29098}
29099#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29100pub struct TerminalComma {
29101 node: SyntaxNode,
29102 children: Arc<[SyntaxNode]>,
29103}
29104impl Terminal for TerminalComma {
29105 const KIND: SyntaxKind = SyntaxKind::TerminalComma;
29106 type TokenType = TokenComma;
29107 fn new_green(
29108 db: &dyn SyntaxGroup,
29109 leading_trivia: TriviaGreen,
29110 token: <<TerminalComma as Terminal>::TokenType as TypedSyntaxNode>::Green,
29111 trailing_trivia: TriviaGreen,
29112 ) -> Self::Green {
29113 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29114 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29115 TerminalCommaGreen(
29116 Arc::new(GreenNode {
29117 kind: SyntaxKind::TerminalComma,
29118 details: GreenNodeDetails::Node { children, width },
29119 })
29120 .intern(db),
29121 )
29122 }
29123 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29124 self.token(db).text(db)
29125 }
29126}
29127impl TerminalComma {
29128 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29129 Trivia::from_syntax_node(db, self.children[0].clone())
29130 }
29131 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenComma {
29132 TokenComma::from_syntax_node(db, self.children[1].clone())
29133 }
29134 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29135 Trivia::from_syntax_node(db, self.children[2].clone())
29136 }
29137}
29138#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29139pub struct TerminalCommaPtr(pub SyntaxStablePtrId);
29140impl TerminalCommaPtr {}
29141impl TypedStablePtr for TerminalCommaPtr {
29142 type SyntaxNode = TerminalComma;
29143 fn untyped(&self) -> SyntaxStablePtrId {
29144 self.0
29145 }
29146 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalComma {
29147 TerminalComma::from_syntax_node(db, self.0.lookup(db))
29148 }
29149}
29150impl From<TerminalCommaPtr> for SyntaxStablePtrId {
29151 fn from(ptr: TerminalCommaPtr) -> Self {
29152 ptr.untyped()
29153 }
29154}
29155#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29156pub struct TerminalCommaGreen(pub GreenId);
29157impl TypedSyntaxNode for TerminalComma {
29158 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalComma);
29159 type StablePtr = TerminalCommaPtr;
29160 type Green = TerminalCommaGreen;
29161 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29162 TerminalCommaGreen(
29163 Arc::new(GreenNode {
29164 kind: SyntaxKind::TerminalComma,
29165 details: GreenNodeDetails::Node {
29166 children: vec![
29167 Trivia::missing(db).0,
29168 TokenComma::missing(db).0,
29169 Trivia::missing(db).0,
29170 ],
29171 width: TextWidth::default(),
29172 },
29173 })
29174 .intern(db),
29175 )
29176 }
29177 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29178 let kind = node.kind(db);
29179 assert_eq!(
29180 kind,
29181 SyntaxKind::TerminalComma,
29182 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29183 kind,
29184 SyntaxKind::TerminalComma
29185 );
29186 let children = db.get_children(node.clone());
29187 Self { node, children }
29188 }
29189 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29190 let kind = node.kind(db);
29191 if kind == SyntaxKind::TerminalComma {
29192 Some(Self::from_syntax_node(db, node))
29193 } else {
29194 None
29195 }
29196 }
29197 fn as_syntax_node(&self) -> SyntaxNode {
29198 self.node.clone()
29199 }
29200 fn stable_ptr(&self) -> Self::StablePtr {
29201 TerminalCommaPtr(self.node.0.stable_ptr)
29202 }
29203}
29204impl From<&TerminalComma> for SyntaxStablePtrId {
29205 fn from(node: &TerminalComma) -> Self {
29206 node.stable_ptr().untyped()
29207 }
29208}
29209#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29210pub struct TokenDiv {
29211 node: SyntaxNode,
29212}
29213impl Token for TokenDiv {
29214 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29215 TokenDivGreen(
29216 Arc::new(GreenNode {
29217 kind: SyntaxKind::TokenDiv,
29218 details: GreenNodeDetails::Token(text),
29219 })
29220 .intern(db),
29221 )
29222 }
29223 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29224 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29225 .clone()
29226 }
29227}
29228#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29229pub struct TokenDivPtr(pub SyntaxStablePtrId);
29230impl TypedStablePtr for TokenDivPtr {
29231 type SyntaxNode = TokenDiv;
29232 fn untyped(&self) -> SyntaxStablePtrId {
29233 self.0
29234 }
29235 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDiv {
29236 TokenDiv::from_syntax_node(db, self.0.lookup(db))
29237 }
29238}
29239impl From<TokenDivPtr> for SyntaxStablePtrId {
29240 fn from(ptr: TokenDivPtr) -> Self {
29241 ptr.untyped()
29242 }
29243}
29244#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29245pub struct TokenDivGreen(pub GreenId);
29246impl TokenDivGreen {
29247 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29248 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29249 }
29250}
29251impl TypedSyntaxNode for TokenDiv {
29252 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDiv);
29253 type StablePtr = TokenDivPtr;
29254 type Green = TokenDivGreen;
29255 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29256 TokenDivGreen(
29257 Arc::new(GreenNode {
29258 kind: SyntaxKind::TokenMissing,
29259 details: GreenNodeDetails::Token("".into()),
29260 })
29261 .intern(db),
29262 )
29263 }
29264 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29265 match node.0.green.lookup_intern(db).details {
29266 GreenNodeDetails::Token(_) => Self { node },
29267 GreenNodeDetails::Node { .. } => {
29268 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDiv)
29269 }
29270 }
29271 }
29272 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29273 match node.0.green.lookup_intern(db).details {
29274 GreenNodeDetails::Token(_) => Some(Self { node }),
29275 GreenNodeDetails::Node { .. } => None,
29276 }
29277 }
29278 fn as_syntax_node(&self) -> SyntaxNode {
29279 self.node.clone()
29280 }
29281 fn stable_ptr(&self) -> Self::StablePtr {
29282 TokenDivPtr(self.node.0.stable_ptr)
29283 }
29284}
29285impl From<&TokenDiv> for SyntaxStablePtrId {
29286 fn from(node: &TokenDiv) -> Self {
29287 node.stable_ptr().untyped()
29288 }
29289}
29290#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29291pub struct TerminalDiv {
29292 node: SyntaxNode,
29293 children: Arc<[SyntaxNode]>,
29294}
29295impl Terminal for TerminalDiv {
29296 const KIND: SyntaxKind = SyntaxKind::TerminalDiv;
29297 type TokenType = TokenDiv;
29298 fn new_green(
29299 db: &dyn SyntaxGroup,
29300 leading_trivia: TriviaGreen,
29301 token: <<TerminalDiv as Terminal>::TokenType as TypedSyntaxNode>::Green,
29302 trailing_trivia: TriviaGreen,
29303 ) -> Self::Green {
29304 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29305 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29306 TerminalDivGreen(
29307 Arc::new(GreenNode {
29308 kind: SyntaxKind::TerminalDiv,
29309 details: GreenNodeDetails::Node { children, width },
29310 })
29311 .intern(db),
29312 )
29313 }
29314 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29315 self.token(db).text(db)
29316 }
29317}
29318impl TerminalDiv {
29319 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29320 Trivia::from_syntax_node(db, self.children[0].clone())
29321 }
29322 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDiv {
29323 TokenDiv::from_syntax_node(db, self.children[1].clone())
29324 }
29325 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29326 Trivia::from_syntax_node(db, self.children[2].clone())
29327 }
29328}
29329#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29330pub struct TerminalDivPtr(pub SyntaxStablePtrId);
29331impl TerminalDivPtr {}
29332impl TypedStablePtr for TerminalDivPtr {
29333 type SyntaxNode = TerminalDiv;
29334 fn untyped(&self) -> SyntaxStablePtrId {
29335 self.0
29336 }
29337 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDiv {
29338 TerminalDiv::from_syntax_node(db, self.0.lookup(db))
29339 }
29340}
29341impl From<TerminalDivPtr> for SyntaxStablePtrId {
29342 fn from(ptr: TerminalDivPtr) -> Self {
29343 ptr.untyped()
29344 }
29345}
29346#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29347pub struct TerminalDivGreen(pub GreenId);
29348impl TypedSyntaxNode for TerminalDiv {
29349 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDiv);
29350 type StablePtr = TerminalDivPtr;
29351 type Green = TerminalDivGreen;
29352 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29353 TerminalDivGreen(
29354 Arc::new(GreenNode {
29355 kind: SyntaxKind::TerminalDiv,
29356 details: GreenNodeDetails::Node {
29357 children: vec![
29358 Trivia::missing(db).0,
29359 TokenDiv::missing(db).0,
29360 Trivia::missing(db).0,
29361 ],
29362 width: TextWidth::default(),
29363 },
29364 })
29365 .intern(db),
29366 )
29367 }
29368 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29369 let kind = node.kind(db);
29370 assert_eq!(
29371 kind,
29372 SyntaxKind::TerminalDiv,
29373 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29374 kind,
29375 SyntaxKind::TerminalDiv
29376 );
29377 let children = db.get_children(node.clone());
29378 Self { node, children }
29379 }
29380 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29381 let kind = node.kind(db);
29382 if kind == SyntaxKind::TerminalDiv { Some(Self::from_syntax_node(db, node)) } else { None }
29383 }
29384 fn as_syntax_node(&self) -> SyntaxNode {
29385 self.node.clone()
29386 }
29387 fn stable_ptr(&self) -> Self::StablePtr {
29388 TerminalDivPtr(self.node.0.stable_ptr)
29389 }
29390}
29391impl From<&TerminalDiv> for SyntaxStablePtrId {
29392 fn from(node: &TerminalDiv) -> Self {
29393 node.stable_ptr().untyped()
29394 }
29395}
29396#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29397pub struct TokenDivEq {
29398 node: SyntaxNode,
29399}
29400impl Token for TokenDivEq {
29401 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29402 TokenDivEqGreen(
29403 Arc::new(GreenNode {
29404 kind: SyntaxKind::TokenDivEq,
29405 details: GreenNodeDetails::Token(text),
29406 })
29407 .intern(db),
29408 )
29409 }
29410 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29411 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29412 .clone()
29413 }
29414}
29415#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29416pub struct TokenDivEqPtr(pub SyntaxStablePtrId);
29417impl TypedStablePtr for TokenDivEqPtr {
29418 type SyntaxNode = TokenDivEq;
29419 fn untyped(&self) -> SyntaxStablePtrId {
29420 self.0
29421 }
29422 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDivEq {
29423 TokenDivEq::from_syntax_node(db, self.0.lookup(db))
29424 }
29425}
29426impl From<TokenDivEqPtr> for SyntaxStablePtrId {
29427 fn from(ptr: TokenDivEqPtr) -> Self {
29428 ptr.untyped()
29429 }
29430}
29431#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29432pub struct TokenDivEqGreen(pub GreenId);
29433impl TokenDivEqGreen {
29434 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29435 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29436 }
29437}
29438impl TypedSyntaxNode for TokenDivEq {
29439 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDivEq);
29440 type StablePtr = TokenDivEqPtr;
29441 type Green = TokenDivEqGreen;
29442 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29443 TokenDivEqGreen(
29444 Arc::new(GreenNode {
29445 kind: SyntaxKind::TokenMissing,
29446 details: GreenNodeDetails::Token("".into()),
29447 })
29448 .intern(db),
29449 )
29450 }
29451 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29452 match node.0.green.lookup_intern(db).details {
29453 GreenNodeDetails::Token(_) => Self { node },
29454 GreenNodeDetails::Node { .. } => {
29455 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDivEq)
29456 }
29457 }
29458 }
29459 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29460 match node.0.green.lookup_intern(db).details {
29461 GreenNodeDetails::Token(_) => Some(Self { node }),
29462 GreenNodeDetails::Node { .. } => None,
29463 }
29464 }
29465 fn as_syntax_node(&self) -> SyntaxNode {
29466 self.node.clone()
29467 }
29468 fn stable_ptr(&self) -> Self::StablePtr {
29469 TokenDivEqPtr(self.node.0.stable_ptr)
29470 }
29471}
29472impl From<&TokenDivEq> for SyntaxStablePtrId {
29473 fn from(node: &TokenDivEq) -> Self {
29474 node.stable_ptr().untyped()
29475 }
29476}
29477#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29478pub struct TerminalDivEq {
29479 node: SyntaxNode,
29480 children: Arc<[SyntaxNode]>,
29481}
29482impl Terminal for TerminalDivEq {
29483 const KIND: SyntaxKind = SyntaxKind::TerminalDivEq;
29484 type TokenType = TokenDivEq;
29485 fn new_green(
29486 db: &dyn SyntaxGroup,
29487 leading_trivia: TriviaGreen,
29488 token: <<TerminalDivEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
29489 trailing_trivia: TriviaGreen,
29490 ) -> Self::Green {
29491 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29492 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29493 TerminalDivEqGreen(
29494 Arc::new(GreenNode {
29495 kind: SyntaxKind::TerminalDivEq,
29496 details: GreenNodeDetails::Node { children, width },
29497 })
29498 .intern(db),
29499 )
29500 }
29501 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29502 self.token(db).text(db)
29503 }
29504}
29505impl TerminalDivEq {
29506 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29507 Trivia::from_syntax_node(db, self.children[0].clone())
29508 }
29509 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDivEq {
29510 TokenDivEq::from_syntax_node(db, self.children[1].clone())
29511 }
29512 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29513 Trivia::from_syntax_node(db, self.children[2].clone())
29514 }
29515}
29516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29517pub struct TerminalDivEqPtr(pub SyntaxStablePtrId);
29518impl TerminalDivEqPtr {}
29519impl TypedStablePtr for TerminalDivEqPtr {
29520 type SyntaxNode = TerminalDivEq;
29521 fn untyped(&self) -> SyntaxStablePtrId {
29522 self.0
29523 }
29524 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDivEq {
29525 TerminalDivEq::from_syntax_node(db, self.0.lookup(db))
29526 }
29527}
29528impl From<TerminalDivEqPtr> for SyntaxStablePtrId {
29529 fn from(ptr: TerminalDivEqPtr) -> Self {
29530 ptr.untyped()
29531 }
29532}
29533#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29534pub struct TerminalDivEqGreen(pub GreenId);
29535impl TypedSyntaxNode for TerminalDivEq {
29536 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDivEq);
29537 type StablePtr = TerminalDivEqPtr;
29538 type Green = TerminalDivEqGreen;
29539 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29540 TerminalDivEqGreen(
29541 Arc::new(GreenNode {
29542 kind: SyntaxKind::TerminalDivEq,
29543 details: GreenNodeDetails::Node {
29544 children: vec![
29545 Trivia::missing(db).0,
29546 TokenDivEq::missing(db).0,
29547 Trivia::missing(db).0,
29548 ],
29549 width: TextWidth::default(),
29550 },
29551 })
29552 .intern(db),
29553 )
29554 }
29555 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29556 let kind = node.kind(db);
29557 assert_eq!(
29558 kind,
29559 SyntaxKind::TerminalDivEq,
29560 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29561 kind,
29562 SyntaxKind::TerminalDivEq
29563 );
29564 let children = db.get_children(node.clone());
29565 Self { node, children }
29566 }
29567 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29568 let kind = node.kind(db);
29569 if kind == SyntaxKind::TerminalDivEq {
29570 Some(Self::from_syntax_node(db, node))
29571 } else {
29572 None
29573 }
29574 }
29575 fn as_syntax_node(&self) -> SyntaxNode {
29576 self.node.clone()
29577 }
29578 fn stable_ptr(&self) -> Self::StablePtr {
29579 TerminalDivEqPtr(self.node.0.stable_ptr)
29580 }
29581}
29582impl From<&TerminalDivEq> for SyntaxStablePtrId {
29583 fn from(node: &TerminalDivEq) -> Self {
29584 node.stable_ptr().untyped()
29585 }
29586}
29587#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29588pub struct TokenDot {
29589 node: SyntaxNode,
29590}
29591impl Token for TokenDot {
29592 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29593 TokenDotGreen(
29594 Arc::new(GreenNode {
29595 kind: SyntaxKind::TokenDot,
29596 details: GreenNodeDetails::Token(text),
29597 })
29598 .intern(db),
29599 )
29600 }
29601 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29602 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29603 .clone()
29604 }
29605}
29606#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29607pub struct TokenDotPtr(pub SyntaxStablePtrId);
29608impl TypedStablePtr for TokenDotPtr {
29609 type SyntaxNode = TokenDot;
29610 fn untyped(&self) -> SyntaxStablePtrId {
29611 self.0
29612 }
29613 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDot {
29614 TokenDot::from_syntax_node(db, self.0.lookup(db))
29615 }
29616}
29617impl From<TokenDotPtr> for SyntaxStablePtrId {
29618 fn from(ptr: TokenDotPtr) -> Self {
29619 ptr.untyped()
29620 }
29621}
29622#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29623pub struct TokenDotGreen(pub GreenId);
29624impl TokenDotGreen {
29625 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29626 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29627 }
29628}
29629impl TypedSyntaxNode for TokenDot {
29630 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDot);
29631 type StablePtr = TokenDotPtr;
29632 type Green = TokenDotGreen;
29633 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29634 TokenDotGreen(
29635 Arc::new(GreenNode {
29636 kind: SyntaxKind::TokenMissing,
29637 details: GreenNodeDetails::Token("".into()),
29638 })
29639 .intern(db),
29640 )
29641 }
29642 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29643 match node.0.green.lookup_intern(db).details {
29644 GreenNodeDetails::Token(_) => Self { node },
29645 GreenNodeDetails::Node { .. } => {
29646 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDot)
29647 }
29648 }
29649 }
29650 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29651 match node.0.green.lookup_intern(db).details {
29652 GreenNodeDetails::Token(_) => Some(Self { node }),
29653 GreenNodeDetails::Node { .. } => None,
29654 }
29655 }
29656 fn as_syntax_node(&self) -> SyntaxNode {
29657 self.node.clone()
29658 }
29659 fn stable_ptr(&self) -> Self::StablePtr {
29660 TokenDotPtr(self.node.0.stable_ptr)
29661 }
29662}
29663impl From<&TokenDot> for SyntaxStablePtrId {
29664 fn from(node: &TokenDot) -> Self {
29665 node.stable_ptr().untyped()
29666 }
29667}
29668#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29669pub struct TerminalDot {
29670 node: SyntaxNode,
29671 children: Arc<[SyntaxNode]>,
29672}
29673impl Terminal for TerminalDot {
29674 const KIND: SyntaxKind = SyntaxKind::TerminalDot;
29675 type TokenType = TokenDot;
29676 fn new_green(
29677 db: &dyn SyntaxGroup,
29678 leading_trivia: TriviaGreen,
29679 token: <<TerminalDot as Terminal>::TokenType as TypedSyntaxNode>::Green,
29680 trailing_trivia: TriviaGreen,
29681 ) -> Self::Green {
29682 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29683 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29684 TerminalDotGreen(
29685 Arc::new(GreenNode {
29686 kind: SyntaxKind::TerminalDot,
29687 details: GreenNodeDetails::Node { children, width },
29688 })
29689 .intern(db),
29690 )
29691 }
29692 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29693 self.token(db).text(db)
29694 }
29695}
29696impl TerminalDot {
29697 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29698 Trivia::from_syntax_node(db, self.children[0].clone())
29699 }
29700 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDot {
29701 TokenDot::from_syntax_node(db, self.children[1].clone())
29702 }
29703 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29704 Trivia::from_syntax_node(db, self.children[2].clone())
29705 }
29706}
29707#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29708pub struct TerminalDotPtr(pub SyntaxStablePtrId);
29709impl TerminalDotPtr {}
29710impl TypedStablePtr for TerminalDotPtr {
29711 type SyntaxNode = TerminalDot;
29712 fn untyped(&self) -> SyntaxStablePtrId {
29713 self.0
29714 }
29715 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDot {
29716 TerminalDot::from_syntax_node(db, self.0.lookup(db))
29717 }
29718}
29719impl From<TerminalDotPtr> for SyntaxStablePtrId {
29720 fn from(ptr: TerminalDotPtr) -> Self {
29721 ptr.untyped()
29722 }
29723}
29724#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29725pub struct TerminalDotGreen(pub GreenId);
29726impl TypedSyntaxNode for TerminalDot {
29727 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDot);
29728 type StablePtr = TerminalDotPtr;
29729 type Green = TerminalDotGreen;
29730 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29731 TerminalDotGreen(
29732 Arc::new(GreenNode {
29733 kind: SyntaxKind::TerminalDot,
29734 details: GreenNodeDetails::Node {
29735 children: vec![
29736 Trivia::missing(db).0,
29737 TokenDot::missing(db).0,
29738 Trivia::missing(db).0,
29739 ],
29740 width: TextWidth::default(),
29741 },
29742 })
29743 .intern(db),
29744 )
29745 }
29746 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29747 let kind = node.kind(db);
29748 assert_eq!(
29749 kind,
29750 SyntaxKind::TerminalDot,
29751 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29752 kind,
29753 SyntaxKind::TerminalDot
29754 );
29755 let children = db.get_children(node.clone());
29756 Self { node, children }
29757 }
29758 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29759 let kind = node.kind(db);
29760 if kind == SyntaxKind::TerminalDot { Some(Self::from_syntax_node(db, node)) } else { None }
29761 }
29762 fn as_syntax_node(&self) -> SyntaxNode {
29763 self.node.clone()
29764 }
29765 fn stable_ptr(&self) -> Self::StablePtr {
29766 TerminalDotPtr(self.node.0.stable_ptr)
29767 }
29768}
29769impl From<&TerminalDot> for SyntaxStablePtrId {
29770 fn from(node: &TerminalDot) -> Self {
29771 node.stable_ptr().untyped()
29772 }
29773}
29774#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29775pub struct TokenDotDot {
29776 node: SyntaxNode,
29777}
29778impl Token for TokenDotDot {
29779 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29780 TokenDotDotGreen(
29781 Arc::new(GreenNode {
29782 kind: SyntaxKind::TokenDotDot,
29783 details: GreenNodeDetails::Token(text),
29784 })
29785 .intern(db),
29786 )
29787 }
29788 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29789 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29790 .clone()
29791 }
29792}
29793#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29794pub struct TokenDotDotPtr(pub SyntaxStablePtrId);
29795impl TypedStablePtr for TokenDotDotPtr {
29796 type SyntaxNode = TokenDotDot;
29797 fn untyped(&self) -> SyntaxStablePtrId {
29798 self.0
29799 }
29800 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDotDot {
29801 TokenDotDot::from_syntax_node(db, self.0.lookup(db))
29802 }
29803}
29804impl From<TokenDotDotPtr> for SyntaxStablePtrId {
29805 fn from(ptr: TokenDotDotPtr) -> Self {
29806 ptr.untyped()
29807 }
29808}
29809#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29810pub struct TokenDotDotGreen(pub GreenId);
29811impl TokenDotDotGreen {
29812 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29813 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29814 }
29815}
29816impl TypedSyntaxNode for TokenDotDot {
29817 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDotDot);
29818 type StablePtr = TokenDotDotPtr;
29819 type Green = TokenDotDotGreen;
29820 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29821 TokenDotDotGreen(
29822 Arc::new(GreenNode {
29823 kind: SyntaxKind::TokenMissing,
29824 details: GreenNodeDetails::Token("".into()),
29825 })
29826 .intern(db),
29827 )
29828 }
29829 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29830 match node.0.green.lookup_intern(db).details {
29831 GreenNodeDetails::Token(_) => Self { node },
29832 GreenNodeDetails::Node { .. } => {
29833 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDotDot)
29834 }
29835 }
29836 }
29837 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29838 match node.0.green.lookup_intern(db).details {
29839 GreenNodeDetails::Token(_) => Some(Self { node }),
29840 GreenNodeDetails::Node { .. } => None,
29841 }
29842 }
29843 fn as_syntax_node(&self) -> SyntaxNode {
29844 self.node.clone()
29845 }
29846 fn stable_ptr(&self) -> Self::StablePtr {
29847 TokenDotDotPtr(self.node.0.stable_ptr)
29848 }
29849}
29850impl From<&TokenDotDot> for SyntaxStablePtrId {
29851 fn from(node: &TokenDotDot) -> Self {
29852 node.stable_ptr().untyped()
29853 }
29854}
29855#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29856pub struct TerminalDotDot {
29857 node: SyntaxNode,
29858 children: Arc<[SyntaxNode]>,
29859}
29860impl Terminal for TerminalDotDot {
29861 const KIND: SyntaxKind = SyntaxKind::TerminalDotDot;
29862 type TokenType = TokenDotDot;
29863 fn new_green(
29864 db: &dyn SyntaxGroup,
29865 leading_trivia: TriviaGreen,
29866 token: <<TerminalDotDot as Terminal>::TokenType as TypedSyntaxNode>::Green,
29867 trailing_trivia: TriviaGreen,
29868 ) -> Self::Green {
29869 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29870 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29871 TerminalDotDotGreen(
29872 Arc::new(GreenNode {
29873 kind: SyntaxKind::TerminalDotDot,
29874 details: GreenNodeDetails::Node { children, width },
29875 })
29876 .intern(db),
29877 )
29878 }
29879 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29880 self.token(db).text(db)
29881 }
29882}
29883impl TerminalDotDot {
29884 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29885 Trivia::from_syntax_node(db, self.children[0].clone())
29886 }
29887 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDotDot {
29888 TokenDotDot::from_syntax_node(db, self.children[1].clone())
29889 }
29890 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29891 Trivia::from_syntax_node(db, self.children[2].clone())
29892 }
29893}
29894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29895pub struct TerminalDotDotPtr(pub SyntaxStablePtrId);
29896impl TerminalDotDotPtr {}
29897impl TypedStablePtr for TerminalDotDotPtr {
29898 type SyntaxNode = TerminalDotDot;
29899 fn untyped(&self) -> SyntaxStablePtrId {
29900 self.0
29901 }
29902 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDotDot {
29903 TerminalDotDot::from_syntax_node(db, self.0.lookup(db))
29904 }
29905}
29906impl From<TerminalDotDotPtr> for SyntaxStablePtrId {
29907 fn from(ptr: TerminalDotDotPtr) -> Self {
29908 ptr.untyped()
29909 }
29910}
29911#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29912pub struct TerminalDotDotGreen(pub GreenId);
29913impl TypedSyntaxNode for TerminalDotDot {
29914 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDotDot);
29915 type StablePtr = TerminalDotDotPtr;
29916 type Green = TerminalDotDotGreen;
29917 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29918 TerminalDotDotGreen(
29919 Arc::new(GreenNode {
29920 kind: SyntaxKind::TerminalDotDot,
29921 details: GreenNodeDetails::Node {
29922 children: vec![
29923 Trivia::missing(db).0,
29924 TokenDotDot::missing(db).0,
29925 Trivia::missing(db).0,
29926 ],
29927 width: TextWidth::default(),
29928 },
29929 })
29930 .intern(db),
29931 )
29932 }
29933 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29934 let kind = node.kind(db);
29935 assert_eq!(
29936 kind,
29937 SyntaxKind::TerminalDotDot,
29938 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29939 kind,
29940 SyntaxKind::TerminalDotDot
29941 );
29942 let children = db.get_children(node.clone());
29943 Self { node, children }
29944 }
29945 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
29946 let kind = node.kind(db);
29947 if kind == SyntaxKind::TerminalDotDot {
29948 Some(Self::from_syntax_node(db, node))
29949 } else {
29950 None
29951 }
29952 }
29953 fn as_syntax_node(&self) -> SyntaxNode {
29954 self.node.clone()
29955 }
29956 fn stable_ptr(&self) -> Self::StablePtr {
29957 TerminalDotDotPtr(self.node.0.stable_ptr)
29958 }
29959}
29960impl From<&TerminalDotDot> for SyntaxStablePtrId {
29961 fn from(node: &TerminalDotDot) -> Self {
29962 node.stable_ptr().untyped()
29963 }
29964}
29965#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29966pub struct TokenEndOfFile {
29967 node: SyntaxNode,
29968}
29969impl Token for TokenEndOfFile {
29970 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29971 TokenEndOfFileGreen(
29972 Arc::new(GreenNode {
29973 kind: SyntaxKind::TokenEndOfFile,
29974 details: GreenNodeDetails::Token(text),
29975 })
29976 .intern(db),
29977 )
29978 }
29979 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29980 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29981 .clone()
29982 }
29983}
29984#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29985pub struct TokenEndOfFilePtr(pub SyntaxStablePtrId);
29986impl TypedStablePtr for TokenEndOfFilePtr {
29987 type SyntaxNode = TokenEndOfFile;
29988 fn untyped(&self) -> SyntaxStablePtrId {
29989 self.0
29990 }
29991 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEndOfFile {
29992 TokenEndOfFile::from_syntax_node(db, self.0.lookup(db))
29993 }
29994}
29995impl From<TokenEndOfFilePtr> for SyntaxStablePtrId {
29996 fn from(ptr: TokenEndOfFilePtr) -> Self {
29997 ptr.untyped()
29998 }
29999}
30000#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30001pub struct TokenEndOfFileGreen(pub GreenId);
30002impl TokenEndOfFileGreen {
30003 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30004 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30005 }
30006}
30007impl TypedSyntaxNode for TokenEndOfFile {
30008 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEndOfFile);
30009 type StablePtr = TokenEndOfFilePtr;
30010 type Green = TokenEndOfFileGreen;
30011 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30012 TokenEndOfFileGreen(
30013 Arc::new(GreenNode {
30014 kind: SyntaxKind::TokenMissing,
30015 details: GreenNodeDetails::Token("".into()),
30016 })
30017 .intern(db),
30018 )
30019 }
30020 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30021 match node.0.green.lookup_intern(db).details {
30022 GreenNodeDetails::Token(_) => Self { node },
30023 GreenNodeDetails::Node { .. } => {
30024 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEndOfFile)
30025 }
30026 }
30027 }
30028 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30029 match node.0.green.lookup_intern(db).details {
30030 GreenNodeDetails::Token(_) => Some(Self { node }),
30031 GreenNodeDetails::Node { .. } => None,
30032 }
30033 }
30034 fn as_syntax_node(&self) -> SyntaxNode {
30035 self.node.clone()
30036 }
30037 fn stable_ptr(&self) -> Self::StablePtr {
30038 TokenEndOfFilePtr(self.node.0.stable_ptr)
30039 }
30040}
30041impl From<&TokenEndOfFile> for SyntaxStablePtrId {
30042 fn from(node: &TokenEndOfFile) -> Self {
30043 node.stable_ptr().untyped()
30044 }
30045}
30046#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30047pub struct TerminalEndOfFile {
30048 node: SyntaxNode,
30049 children: Arc<[SyntaxNode]>,
30050}
30051impl Terminal for TerminalEndOfFile {
30052 const KIND: SyntaxKind = SyntaxKind::TerminalEndOfFile;
30053 type TokenType = TokenEndOfFile;
30054 fn new_green(
30055 db: &dyn SyntaxGroup,
30056 leading_trivia: TriviaGreen,
30057 token: <<TerminalEndOfFile as Terminal>::TokenType as TypedSyntaxNode>::Green,
30058 trailing_trivia: TriviaGreen,
30059 ) -> Self::Green {
30060 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30061 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30062 TerminalEndOfFileGreen(
30063 Arc::new(GreenNode {
30064 kind: SyntaxKind::TerminalEndOfFile,
30065 details: GreenNodeDetails::Node { children, width },
30066 })
30067 .intern(db),
30068 )
30069 }
30070 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30071 self.token(db).text(db)
30072 }
30073}
30074impl TerminalEndOfFile {
30075 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30076 Trivia::from_syntax_node(db, self.children[0].clone())
30077 }
30078 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEndOfFile {
30079 TokenEndOfFile::from_syntax_node(db, self.children[1].clone())
30080 }
30081 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30082 Trivia::from_syntax_node(db, self.children[2].clone())
30083 }
30084}
30085#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30086pub struct TerminalEndOfFilePtr(pub SyntaxStablePtrId);
30087impl TerminalEndOfFilePtr {}
30088impl TypedStablePtr for TerminalEndOfFilePtr {
30089 type SyntaxNode = TerminalEndOfFile;
30090 fn untyped(&self) -> SyntaxStablePtrId {
30091 self.0
30092 }
30093 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEndOfFile {
30094 TerminalEndOfFile::from_syntax_node(db, self.0.lookup(db))
30095 }
30096}
30097impl From<TerminalEndOfFilePtr> for SyntaxStablePtrId {
30098 fn from(ptr: TerminalEndOfFilePtr) -> Self {
30099 ptr.untyped()
30100 }
30101}
30102#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30103pub struct TerminalEndOfFileGreen(pub GreenId);
30104impl TypedSyntaxNode for TerminalEndOfFile {
30105 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEndOfFile);
30106 type StablePtr = TerminalEndOfFilePtr;
30107 type Green = TerminalEndOfFileGreen;
30108 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30109 TerminalEndOfFileGreen(
30110 Arc::new(GreenNode {
30111 kind: SyntaxKind::TerminalEndOfFile,
30112 details: GreenNodeDetails::Node {
30113 children: vec![
30114 Trivia::missing(db).0,
30115 TokenEndOfFile::missing(db).0,
30116 Trivia::missing(db).0,
30117 ],
30118 width: TextWidth::default(),
30119 },
30120 })
30121 .intern(db),
30122 )
30123 }
30124 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30125 let kind = node.kind(db);
30126 assert_eq!(
30127 kind,
30128 SyntaxKind::TerminalEndOfFile,
30129 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30130 kind,
30131 SyntaxKind::TerminalEndOfFile
30132 );
30133 let children = db.get_children(node.clone());
30134 Self { node, children }
30135 }
30136 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30137 let kind = node.kind(db);
30138 if kind == SyntaxKind::TerminalEndOfFile {
30139 Some(Self::from_syntax_node(db, node))
30140 } else {
30141 None
30142 }
30143 }
30144 fn as_syntax_node(&self) -> SyntaxNode {
30145 self.node.clone()
30146 }
30147 fn stable_ptr(&self) -> Self::StablePtr {
30148 TerminalEndOfFilePtr(self.node.0.stable_ptr)
30149 }
30150}
30151impl From<&TerminalEndOfFile> for SyntaxStablePtrId {
30152 fn from(node: &TerminalEndOfFile) -> Self {
30153 node.stable_ptr().untyped()
30154 }
30155}
30156#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30157pub struct TokenEq {
30158 node: SyntaxNode,
30159}
30160impl Token for TokenEq {
30161 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30162 TokenEqGreen(
30163 Arc::new(GreenNode {
30164 kind: SyntaxKind::TokenEq,
30165 details: GreenNodeDetails::Token(text),
30166 })
30167 .intern(db),
30168 )
30169 }
30170 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30171 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30172 .clone()
30173 }
30174}
30175#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30176pub struct TokenEqPtr(pub SyntaxStablePtrId);
30177impl TypedStablePtr for TokenEqPtr {
30178 type SyntaxNode = TokenEq;
30179 fn untyped(&self) -> SyntaxStablePtrId {
30180 self.0
30181 }
30182 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEq {
30183 TokenEq::from_syntax_node(db, self.0.lookup(db))
30184 }
30185}
30186impl From<TokenEqPtr> for SyntaxStablePtrId {
30187 fn from(ptr: TokenEqPtr) -> Self {
30188 ptr.untyped()
30189 }
30190}
30191#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30192pub struct TokenEqGreen(pub GreenId);
30193impl TokenEqGreen {
30194 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30195 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30196 }
30197}
30198impl TypedSyntaxNode for TokenEq {
30199 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEq);
30200 type StablePtr = TokenEqPtr;
30201 type Green = TokenEqGreen;
30202 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30203 TokenEqGreen(
30204 Arc::new(GreenNode {
30205 kind: SyntaxKind::TokenMissing,
30206 details: GreenNodeDetails::Token("".into()),
30207 })
30208 .intern(db),
30209 )
30210 }
30211 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30212 match node.0.green.lookup_intern(db).details {
30213 GreenNodeDetails::Token(_) => Self { node },
30214 GreenNodeDetails::Node { .. } => {
30215 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEq)
30216 }
30217 }
30218 }
30219 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30220 match node.0.green.lookup_intern(db).details {
30221 GreenNodeDetails::Token(_) => Some(Self { node }),
30222 GreenNodeDetails::Node { .. } => None,
30223 }
30224 }
30225 fn as_syntax_node(&self) -> SyntaxNode {
30226 self.node.clone()
30227 }
30228 fn stable_ptr(&self) -> Self::StablePtr {
30229 TokenEqPtr(self.node.0.stable_ptr)
30230 }
30231}
30232impl From<&TokenEq> for SyntaxStablePtrId {
30233 fn from(node: &TokenEq) -> Self {
30234 node.stable_ptr().untyped()
30235 }
30236}
30237#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30238pub struct TerminalEq {
30239 node: SyntaxNode,
30240 children: Arc<[SyntaxNode]>,
30241}
30242impl Terminal for TerminalEq {
30243 const KIND: SyntaxKind = SyntaxKind::TerminalEq;
30244 type TokenType = TokenEq;
30245 fn new_green(
30246 db: &dyn SyntaxGroup,
30247 leading_trivia: TriviaGreen,
30248 token: <<TerminalEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30249 trailing_trivia: TriviaGreen,
30250 ) -> Self::Green {
30251 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30252 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30253 TerminalEqGreen(
30254 Arc::new(GreenNode {
30255 kind: SyntaxKind::TerminalEq,
30256 details: GreenNodeDetails::Node { children, width },
30257 })
30258 .intern(db),
30259 )
30260 }
30261 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30262 self.token(db).text(db)
30263 }
30264}
30265impl TerminalEq {
30266 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30267 Trivia::from_syntax_node(db, self.children[0].clone())
30268 }
30269 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEq {
30270 TokenEq::from_syntax_node(db, self.children[1].clone())
30271 }
30272 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30273 Trivia::from_syntax_node(db, self.children[2].clone())
30274 }
30275}
30276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30277pub struct TerminalEqPtr(pub SyntaxStablePtrId);
30278impl TerminalEqPtr {}
30279impl TypedStablePtr for TerminalEqPtr {
30280 type SyntaxNode = TerminalEq;
30281 fn untyped(&self) -> SyntaxStablePtrId {
30282 self.0
30283 }
30284 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEq {
30285 TerminalEq::from_syntax_node(db, self.0.lookup(db))
30286 }
30287}
30288impl From<TerminalEqPtr> for SyntaxStablePtrId {
30289 fn from(ptr: TerminalEqPtr) -> Self {
30290 ptr.untyped()
30291 }
30292}
30293#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30294pub struct TerminalEqGreen(pub GreenId);
30295impl TypedSyntaxNode for TerminalEq {
30296 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEq);
30297 type StablePtr = TerminalEqPtr;
30298 type Green = TerminalEqGreen;
30299 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30300 TerminalEqGreen(
30301 Arc::new(GreenNode {
30302 kind: SyntaxKind::TerminalEq,
30303 details: GreenNodeDetails::Node {
30304 children: vec![
30305 Trivia::missing(db).0,
30306 TokenEq::missing(db).0,
30307 Trivia::missing(db).0,
30308 ],
30309 width: TextWidth::default(),
30310 },
30311 })
30312 .intern(db),
30313 )
30314 }
30315 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30316 let kind = node.kind(db);
30317 assert_eq!(
30318 kind,
30319 SyntaxKind::TerminalEq,
30320 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30321 kind,
30322 SyntaxKind::TerminalEq
30323 );
30324 let children = db.get_children(node.clone());
30325 Self { node, children }
30326 }
30327 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30328 let kind = node.kind(db);
30329 if kind == SyntaxKind::TerminalEq { Some(Self::from_syntax_node(db, node)) } else { None }
30330 }
30331 fn as_syntax_node(&self) -> SyntaxNode {
30332 self.node.clone()
30333 }
30334 fn stable_ptr(&self) -> Self::StablePtr {
30335 TerminalEqPtr(self.node.0.stable_ptr)
30336 }
30337}
30338impl From<&TerminalEq> for SyntaxStablePtrId {
30339 fn from(node: &TerminalEq) -> Self {
30340 node.stable_ptr().untyped()
30341 }
30342}
30343#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30344pub struct TokenEqEq {
30345 node: SyntaxNode,
30346}
30347impl Token for TokenEqEq {
30348 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30349 TokenEqEqGreen(
30350 Arc::new(GreenNode {
30351 kind: SyntaxKind::TokenEqEq,
30352 details: GreenNodeDetails::Token(text),
30353 })
30354 .intern(db),
30355 )
30356 }
30357 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30358 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30359 .clone()
30360 }
30361}
30362#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30363pub struct TokenEqEqPtr(pub SyntaxStablePtrId);
30364impl TypedStablePtr for TokenEqEqPtr {
30365 type SyntaxNode = TokenEqEq;
30366 fn untyped(&self) -> SyntaxStablePtrId {
30367 self.0
30368 }
30369 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEqEq {
30370 TokenEqEq::from_syntax_node(db, self.0.lookup(db))
30371 }
30372}
30373impl From<TokenEqEqPtr> for SyntaxStablePtrId {
30374 fn from(ptr: TokenEqEqPtr) -> Self {
30375 ptr.untyped()
30376 }
30377}
30378#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30379pub struct TokenEqEqGreen(pub GreenId);
30380impl TokenEqEqGreen {
30381 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30382 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30383 }
30384}
30385impl TypedSyntaxNode for TokenEqEq {
30386 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEqEq);
30387 type StablePtr = TokenEqEqPtr;
30388 type Green = TokenEqEqGreen;
30389 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30390 TokenEqEqGreen(
30391 Arc::new(GreenNode {
30392 kind: SyntaxKind::TokenMissing,
30393 details: GreenNodeDetails::Token("".into()),
30394 })
30395 .intern(db),
30396 )
30397 }
30398 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30399 match node.0.green.lookup_intern(db).details {
30400 GreenNodeDetails::Token(_) => Self { node },
30401 GreenNodeDetails::Node { .. } => {
30402 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEqEq)
30403 }
30404 }
30405 }
30406 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30407 match node.0.green.lookup_intern(db).details {
30408 GreenNodeDetails::Token(_) => Some(Self { node }),
30409 GreenNodeDetails::Node { .. } => None,
30410 }
30411 }
30412 fn as_syntax_node(&self) -> SyntaxNode {
30413 self.node.clone()
30414 }
30415 fn stable_ptr(&self) -> Self::StablePtr {
30416 TokenEqEqPtr(self.node.0.stable_ptr)
30417 }
30418}
30419impl From<&TokenEqEq> for SyntaxStablePtrId {
30420 fn from(node: &TokenEqEq) -> Self {
30421 node.stable_ptr().untyped()
30422 }
30423}
30424#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30425pub struct TerminalEqEq {
30426 node: SyntaxNode,
30427 children: Arc<[SyntaxNode]>,
30428}
30429impl Terminal for TerminalEqEq {
30430 const KIND: SyntaxKind = SyntaxKind::TerminalEqEq;
30431 type TokenType = TokenEqEq;
30432 fn new_green(
30433 db: &dyn SyntaxGroup,
30434 leading_trivia: TriviaGreen,
30435 token: <<TerminalEqEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30436 trailing_trivia: TriviaGreen,
30437 ) -> Self::Green {
30438 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30439 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30440 TerminalEqEqGreen(
30441 Arc::new(GreenNode {
30442 kind: SyntaxKind::TerminalEqEq,
30443 details: GreenNodeDetails::Node { children, width },
30444 })
30445 .intern(db),
30446 )
30447 }
30448 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30449 self.token(db).text(db)
30450 }
30451}
30452impl TerminalEqEq {
30453 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30454 Trivia::from_syntax_node(db, self.children[0].clone())
30455 }
30456 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEqEq {
30457 TokenEqEq::from_syntax_node(db, self.children[1].clone())
30458 }
30459 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30460 Trivia::from_syntax_node(db, self.children[2].clone())
30461 }
30462}
30463#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30464pub struct TerminalEqEqPtr(pub SyntaxStablePtrId);
30465impl TerminalEqEqPtr {}
30466impl TypedStablePtr for TerminalEqEqPtr {
30467 type SyntaxNode = TerminalEqEq;
30468 fn untyped(&self) -> SyntaxStablePtrId {
30469 self.0
30470 }
30471 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEqEq {
30472 TerminalEqEq::from_syntax_node(db, self.0.lookup(db))
30473 }
30474}
30475impl From<TerminalEqEqPtr> for SyntaxStablePtrId {
30476 fn from(ptr: TerminalEqEqPtr) -> Self {
30477 ptr.untyped()
30478 }
30479}
30480#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30481pub struct TerminalEqEqGreen(pub GreenId);
30482impl TypedSyntaxNode for TerminalEqEq {
30483 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEqEq);
30484 type StablePtr = TerminalEqEqPtr;
30485 type Green = TerminalEqEqGreen;
30486 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30487 TerminalEqEqGreen(
30488 Arc::new(GreenNode {
30489 kind: SyntaxKind::TerminalEqEq,
30490 details: GreenNodeDetails::Node {
30491 children: vec![
30492 Trivia::missing(db).0,
30493 TokenEqEq::missing(db).0,
30494 Trivia::missing(db).0,
30495 ],
30496 width: TextWidth::default(),
30497 },
30498 })
30499 .intern(db),
30500 )
30501 }
30502 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30503 let kind = node.kind(db);
30504 assert_eq!(
30505 kind,
30506 SyntaxKind::TerminalEqEq,
30507 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30508 kind,
30509 SyntaxKind::TerminalEqEq
30510 );
30511 let children = db.get_children(node.clone());
30512 Self { node, children }
30513 }
30514 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30515 let kind = node.kind(db);
30516 if kind == SyntaxKind::TerminalEqEq { Some(Self::from_syntax_node(db, node)) } else { None }
30517 }
30518 fn as_syntax_node(&self) -> SyntaxNode {
30519 self.node.clone()
30520 }
30521 fn stable_ptr(&self) -> Self::StablePtr {
30522 TerminalEqEqPtr(self.node.0.stable_ptr)
30523 }
30524}
30525impl From<&TerminalEqEq> for SyntaxStablePtrId {
30526 fn from(node: &TerminalEqEq) -> Self {
30527 node.stable_ptr().untyped()
30528 }
30529}
30530#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30531pub struct TokenGE {
30532 node: SyntaxNode,
30533}
30534impl Token for TokenGE {
30535 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30536 TokenGEGreen(
30537 Arc::new(GreenNode {
30538 kind: SyntaxKind::TokenGE,
30539 details: GreenNodeDetails::Token(text),
30540 })
30541 .intern(db),
30542 )
30543 }
30544 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30545 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30546 .clone()
30547 }
30548}
30549#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30550pub struct TokenGEPtr(pub SyntaxStablePtrId);
30551impl TypedStablePtr for TokenGEPtr {
30552 type SyntaxNode = TokenGE;
30553 fn untyped(&self) -> SyntaxStablePtrId {
30554 self.0
30555 }
30556 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenGE {
30557 TokenGE::from_syntax_node(db, self.0.lookup(db))
30558 }
30559}
30560impl From<TokenGEPtr> for SyntaxStablePtrId {
30561 fn from(ptr: TokenGEPtr) -> Self {
30562 ptr.untyped()
30563 }
30564}
30565#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30566pub struct TokenGEGreen(pub GreenId);
30567impl TokenGEGreen {
30568 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30569 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30570 }
30571}
30572impl TypedSyntaxNode for TokenGE {
30573 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenGE);
30574 type StablePtr = TokenGEPtr;
30575 type Green = TokenGEGreen;
30576 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30577 TokenGEGreen(
30578 Arc::new(GreenNode {
30579 kind: SyntaxKind::TokenMissing,
30580 details: GreenNodeDetails::Token("".into()),
30581 })
30582 .intern(db),
30583 )
30584 }
30585 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30586 match node.0.green.lookup_intern(db).details {
30587 GreenNodeDetails::Token(_) => Self { node },
30588 GreenNodeDetails::Node { .. } => {
30589 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenGE)
30590 }
30591 }
30592 }
30593 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30594 match node.0.green.lookup_intern(db).details {
30595 GreenNodeDetails::Token(_) => Some(Self { node }),
30596 GreenNodeDetails::Node { .. } => None,
30597 }
30598 }
30599 fn as_syntax_node(&self) -> SyntaxNode {
30600 self.node.clone()
30601 }
30602 fn stable_ptr(&self) -> Self::StablePtr {
30603 TokenGEPtr(self.node.0.stable_ptr)
30604 }
30605}
30606impl From<&TokenGE> for SyntaxStablePtrId {
30607 fn from(node: &TokenGE) -> Self {
30608 node.stable_ptr().untyped()
30609 }
30610}
30611#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30612pub struct TerminalGE {
30613 node: SyntaxNode,
30614 children: Arc<[SyntaxNode]>,
30615}
30616impl Terminal for TerminalGE {
30617 const KIND: SyntaxKind = SyntaxKind::TerminalGE;
30618 type TokenType = TokenGE;
30619 fn new_green(
30620 db: &dyn SyntaxGroup,
30621 leading_trivia: TriviaGreen,
30622 token: <<TerminalGE as Terminal>::TokenType as TypedSyntaxNode>::Green,
30623 trailing_trivia: TriviaGreen,
30624 ) -> Self::Green {
30625 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30626 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30627 TerminalGEGreen(
30628 Arc::new(GreenNode {
30629 kind: SyntaxKind::TerminalGE,
30630 details: GreenNodeDetails::Node { children, width },
30631 })
30632 .intern(db),
30633 )
30634 }
30635 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30636 self.token(db).text(db)
30637 }
30638}
30639impl TerminalGE {
30640 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30641 Trivia::from_syntax_node(db, self.children[0].clone())
30642 }
30643 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenGE {
30644 TokenGE::from_syntax_node(db, self.children[1].clone())
30645 }
30646 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30647 Trivia::from_syntax_node(db, self.children[2].clone())
30648 }
30649}
30650#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30651pub struct TerminalGEPtr(pub SyntaxStablePtrId);
30652impl TerminalGEPtr {}
30653impl TypedStablePtr for TerminalGEPtr {
30654 type SyntaxNode = TerminalGE;
30655 fn untyped(&self) -> SyntaxStablePtrId {
30656 self.0
30657 }
30658 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalGE {
30659 TerminalGE::from_syntax_node(db, self.0.lookup(db))
30660 }
30661}
30662impl From<TerminalGEPtr> for SyntaxStablePtrId {
30663 fn from(ptr: TerminalGEPtr) -> Self {
30664 ptr.untyped()
30665 }
30666}
30667#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30668pub struct TerminalGEGreen(pub GreenId);
30669impl TypedSyntaxNode for TerminalGE {
30670 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalGE);
30671 type StablePtr = TerminalGEPtr;
30672 type Green = TerminalGEGreen;
30673 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30674 TerminalGEGreen(
30675 Arc::new(GreenNode {
30676 kind: SyntaxKind::TerminalGE,
30677 details: GreenNodeDetails::Node {
30678 children: vec![
30679 Trivia::missing(db).0,
30680 TokenGE::missing(db).0,
30681 Trivia::missing(db).0,
30682 ],
30683 width: TextWidth::default(),
30684 },
30685 })
30686 .intern(db),
30687 )
30688 }
30689 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30690 let kind = node.kind(db);
30691 assert_eq!(
30692 kind,
30693 SyntaxKind::TerminalGE,
30694 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30695 kind,
30696 SyntaxKind::TerminalGE
30697 );
30698 let children = db.get_children(node.clone());
30699 Self { node, children }
30700 }
30701 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30702 let kind = node.kind(db);
30703 if kind == SyntaxKind::TerminalGE { Some(Self::from_syntax_node(db, node)) } else { None }
30704 }
30705 fn as_syntax_node(&self) -> SyntaxNode {
30706 self.node.clone()
30707 }
30708 fn stable_ptr(&self) -> Self::StablePtr {
30709 TerminalGEPtr(self.node.0.stable_ptr)
30710 }
30711}
30712impl From<&TerminalGE> for SyntaxStablePtrId {
30713 fn from(node: &TerminalGE) -> Self {
30714 node.stable_ptr().untyped()
30715 }
30716}
30717#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30718pub struct TokenGT {
30719 node: SyntaxNode,
30720}
30721impl Token for TokenGT {
30722 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30723 TokenGTGreen(
30724 Arc::new(GreenNode {
30725 kind: SyntaxKind::TokenGT,
30726 details: GreenNodeDetails::Token(text),
30727 })
30728 .intern(db),
30729 )
30730 }
30731 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30732 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30733 .clone()
30734 }
30735}
30736#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30737pub struct TokenGTPtr(pub SyntaxStablePtrId);
30738impl TypedStablePtr for TokenGTPtr {
30739 type SyntaxNode = TokenGT;
30740 fn untyped(&self) -> SyntaxStablePtrId {
30741 self.0
30742 }
30743 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenGT {
30744 TokenGT::from_syntax_node(db, self.0.lookup(db))
30745 }
30746}
30747impl From<TokenGTPtr> for SyntaxStablePtrId {
30748 fn from(ptr: TokenGTPtr) -> Self {
30749 ptr.untyped()
30750 }
30751}
30752#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30753pub struct TokenGTGreen(pub GreenId);
30754impl TokenGTGreen {
30755 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30756 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30757 }
30758}
30759impl TypedSyntaxNode for TokenGT {
30760 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenGT);
30761 type StablePtr = TokenGTPtr;
30762 type Green = TokenGTGreen;
30763 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30764 TokenGTGreen(
30765 Arc::new(GreenNode {
30766 kind: SyntaxKind::TokenMissing,
30767 details: GreenNodeDetails::Token("".into()),
30768 })
30769 .intern(db),
30770 )
30771 }
30772 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30773 match node.0.green.lookup_intern(db).details {
30774 GreenNodeDetails::Token(_) => Self { node },
30775 GreenNodeDetails::Node { .. } => {
30776 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenGT)
30777 }
30778 }
30779 }
30780 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30781 match node.0.green.lookup_intern(db).details {
30782 GreenNodeDetails::Token(_) => Some(Self { node }),
30783 GreenNodeDetails::Node { .. } => None,
30784 }
30785 }
30786 fn as_syntax_node(&self) -> SyntaxNode {
30787 self.node.clone()
30788 }
30789 fn stable_ptr(&self) -> Self::StablePtr {
30790 TokenGTPtr(self.node.0.stable_ptr)
30791 }
30792}
30793impl From<&TokenGT> for SyntaxStablePtrId {
30794 fn from(node: &TokenGT) -> Self {
30795 node.stable_ptr().untyped()
30796 }
30797}
30798#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30799pub struct TerminalGT {
30800 node: SyntaxNode,
30801 children: Arc<[SyntaxNode]>,
30802}
30803impl Terminal for TerminalGT {
30804 const KIND: SyntaxKind = SyntaxKind::TerminalGT;
30805 type TokenType = TokenGT;
30806 fn new_green(
30807 db: &dyn SyntaxGroup,
30808 leading_trivia: TriviaGreen,
30809 token: <<TerminalGT as Terminal>::TokenType as TypedSyntaxNode>::Green,
30810 trailing_trivia: TriviaGreen,
30811 ) -> Self::Green {
30812 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30813 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30814 TerminalGTGreen(
30815 Arc::new(GreenNode {
30816 kind: SyntaxKind::TerminalGT,
30817 details: GreenNodeDetails::Node { children, width },
30818 })
30819 .intern(db),
30820 )
30821 }
30822 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30823 self.token(db).text(db)
30824 }
30825}
30826impl TerminalGT {
30827 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30828 Trivia::from_syntax_node(db, self.children[0].clone())
30829 }
30830 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenGT {
30831 TokenGT::from_syntax_node(db, self.children[1].clone())
30832 }
30833 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30834 Trivia::from_syntax_node(db, self.children[2].clone())
30835 }
30836}
30837#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30838pub struct TerminalGTPtr(pub SyntaxStablePtrId);
30839impl TerminalGTPtr {}
30840impl TypedStablePtr for TerminalGTPtr {
30841 type SyntaxNode = TerminalGT;
30842 fn untyped(&self) -> SyntaxStablePtrId {
30843 self.0
30844 }
30845 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalGT {
30846 TerminalGT::from_syntax_node(db, self.0.lookup(db))
30847 }
30848}
30849impl From<TerminalGTPtr> for SyntaxStablePtrId {
30850 fn from(ptr: TerminalGTPtr) -> Self {
30851 ptr.untyped()
30852 }
30853}
30854#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30855pub struct TerminalGTGreen(pub GreenId);
30856impl TypedSyntaxNode for TerminalGT {
30857 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalGT);
30858 type StablePtr = TerminalGTPtr;
30859 type Green = TerminalGTGreen;
30860 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30861 TerminalGTGreen(
30862 Arc::new(GreenNode {
30863 kind: SyntaxKind::TerminalGT,
30864 details: GreenNodeDetails::Node {
30865 children: vec![
30866 Trivia::missing(db).0,
30867 TokenGT::missing(db).0,
30868 Trivia::missing(db).0,
30869 ],
30870 width: TextWidth::default(),
30871 },
30872 })
30873 .intern(db),
30874 )
30875 }
30876 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30877 let kind = node.kind(db);
30878 assert_eq!(
30879 kind,
30880 SyntaxKind::TerminalGT,
30881 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30882 kind,
30883 SyntaxKind::TerminalGT
30884 );
30885 let children = db.get_children(node.clone());
30886 Self { node, children }
30887 }
30888 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30889 let kind = node.kind(db);
30890 if kind == SyntaxKind::TerminalGT { Some(Self::from_syntax_node(db, node)) } else { None }
30891 }
30892 fn as_syntax_node(&self) -> SyntaxNode {
30893 self.node.clone()
30894 }
30895 fn stable_ptr(&self) -> Self::StablePtr {
30896 TerminalGTPtr(self.node.0.stable_ptr)
30897 }
30898}
30899impl From<&TerminalGT> for SyntaxStablePtrId {
30900 fn from(node: &TerminalGT) -> Self {
30901 node.stable_ptr().untyped()
30902 }
30903}
30904#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30905pub struct TokenHash {
30906 node: SyntaxNode,
30907}
30908impl Token for TokenHash {
30909 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30910 TokenHashGreen(
30911 Arc::new(GreenNode {
30912 kind: SyntaxKind::TokenHash,
30913 details: GreenNodeDetails::Token(text),
30914 })
30915 .intern(db),
30916 )
30917 }
30918 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30919 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30920 .clone()
30921 }
30922}
30923#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30924pub struct TokenHashPtr(pub SyntaxStablePtrId);
30925impl TypedStablePtr for TokenHashPtr {
30926 type SyntaxNode = TokenHash;
30927 fn untyped(&self) -> SyntaxStablePtrId {
30928 self.0
30929 }
30930 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenHash {
30931 TokenHash::from_syntax_node(db, self.0.lookup(db))
30932 }
30933}
30934impl From<TokenHashPtr> for SyntaxStablePtrId {
30935 fn from(ptr: TokenHashPtr) -> Self {
30936 ptr.untyped()
30937 }
30938}
30939#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30940pub struct TokenHashGreen(pub GreenId);
30941impl TokenHashGreen {
30942 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30943 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30944 }
30945}
30946impl TypedSyntaxNode for TokenHash {
30947 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenHash);
30948 type StablePtr = TokenHashPtr;
30949 type Green = TokenHashGreen;
30950 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30951 TokenHashGreen(
30952 Arc::new(GreenNode {
30953 kind: SyntaxKind::TokenMissing,
30954 details: GreenNodeDetails::Token("".into()),
30955 })
30956 .intern(db),
30957 )
30958 }
30959 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30960 match node.0.green.lookup_intern(db).details {
30961 GreenNodeDetails::Token(_) => Self { node },
30962 GreenNodeDetails::Node { .. } => {
30963 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenHash)
30964 }
30965 }
30966 }
30967 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
30968 match node.0.green.lookup_intern(db).details {
30969 GreenNodeDetails::Token(_) => Some(Self { node }),
30970 GreenNodeDetails::Node { .. } => None,
30971 }
30972 }
30973 fn as_syntax_node(&self) -> SyntaxNode {
30974 self.node.clone()
30975 }
30976 fn stable_ptr(&self) -> Self::StablePtr {
30977 TokenHashPtr(self.node.0.stable_ptr)
30978 }
30979}
30980impl From<&TokenHash> for SyntaxStablePtrId {
30981 fn from(node: &TokenHash) -> Self {
30982 node.stable_ptr().untyped()
30983 }
30984}
30985#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30986pub struct TerminalHash {
30987 node: SyntaxNode,
30988 children: Arc<[SyntaxNode]>,
30989}
30990impl Terminal for TerminalHash {
30991 const KIND: SyntaxKind = SyntaxKind::TerminalHash;
30992 type TokenType = TokenHash;
30993 fn new_green(
30994 db: &dyn SyntaxGroup,
30995 leading_trivia: TriviaGreen,
30996 token: <<TerminalHash as Terminal>::TokenType as TypedSyntaxNode>::Green,
30997 trailing_trivia: TriviaGreen,
30998 ) -> Self::Green {
30999 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31000 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31001 TerminalHashGreen(
31002 Arc::new(GreenNode {
31003 kind: SyntaxKind::TerminalHash,
31004 details: GreenNodeDetails::Node { children, width },
31005 })
31006 .intern(db),
31007 )
31008 }
31009 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31010 self.token(db).text(db)
31011 }
31012}
31013impl TerminalHash {
31014 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31015 Trivia::from_syntax_node(db, self.children[0].clone())
31016 }
31017 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenHash {
31018 TokenHash::from_syntax_node(db, self.children[1].clone())
31019 }
31020 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31021 Trivia::from_syntax_node(db, self.children[2].clone())
31022 }
31023}
31024#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31025pub struct TerminalHashPtr(pub SyntaxStablePtrId);
31026impl TerminalHashPtr {}
31027impl TypedStablePtr for TerminalHashPtr {
31028 type SyntaxNode = TerminalHash;
31029 fn untyped(&self) -> SyntaxStablePtrId {
31030 self.0
31031 }
31032 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalHash {
31033 TerminalHash::from_syntax_node(db, self.0.lookup(db))
31034 }
31035}
31036impl From<TerminalHashPtr> for SyntaxStablePtrId {
31037 fn from(ptr: TerminalHashPtr) -> Self {
31038 ptr.untyped()
31039 }
31040}
31041#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31042pub struct TerminalHashGreen(pub GreenId);
31043impl TypedSyntaxNode for TerminalHash {
31044 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalHash);
31045 type StablePtr = TerminalHashPtr;
31046 type Green = TerminalHashGreen;
31047 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31048 TerminalHashGreen(
31049 Arc::new(GreenNode {
31050 kind: SyntaxKind::TerminalHash,
31051 details: GreenNodeDetails::Node {
31052 children: vec![
31053 Trivia::missing(db).0,
31054 TokenHash::missing(db).0,
31055 Trivia::missing(db).0,
31056 ],
31057 width: TextWidth::default(),
31058 },
31059 })
31060 .intern(db),
31061 )
31062 }
31063 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31064 let kind = node.kind(db);
31065 assert_eq!(
31066 kind,
31067 SyntaxKind::TerminalHash,
31068 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31069 kind,
31070 SyntaxKind::TerminalHash
31071 );
31072 let children = db.get_children(node.clone());
31073 Self { node, children }
31074 }
31075 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31076 let kind = node.kind(db);
31077 if kind == SyntaxKind::TerminalHash { Some(Self::from_syntax_node(db, node)) } else { None }
31078 }
31079 fn as_syntax_node(&self) -> SyntaxNode {
31080 self.node.clone()
31081 }
31082 fn stable_ptr(&self) -> Self::StablePtr {
31083 TerminalHashPtr(self.node.0.stable_ptr)
31084 }
31085}
31086impl From<&TerminalHash> for SyntaxStablePtrId {
31087 fn from(node: &TerminalHash) -> Self {
31088 node.stable_ptr().untyped()
31089 }
31090}
31091#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31092pub struct TokenLBrace {
31093 node: SyntaxNode,
31094}
31095impl Token for TokenLBrace {
31096 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31097 TokenLBraceGreen(
31098 Arc::new(GreenNode {
31099 kind: SyntaxKind::TokenLBrace,
31100 details: GreenNodeDetails::Token(text),
31101 })
31102 .intern(db),
31103 )
31104 }
31105 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31106 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31107 .clone()
31108 }
31109}
31110#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31111pub struct TokenLBracePtr(pub SyntaxStablePtrId);
31112impl TypedStablePtr for TokenLBracePtr {
31113 type SyntaxNode = TokenLBrace;
31114 fn untyped(&self) -> SyntaxStablePtrId {
31115 self.0
31116 }
31117 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLBrace {
31118 TokenLBrace::from_syntax_node(db, self.0.lookup(db))
31119 }
31120}
31121impl From<TokenLBracePtr> for SyntaxStablePtrId {
31122 fn from(ptr: TokenLBracePtr) -> Self {
31123 ptr.untyped()
31124 }
31125}
31126#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31127pub struct TokenLBraceGreen(pub GreenId);
31128impl TokenLBraceGreen {
31129 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31130 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31131 }
31132}
31133impl TypedSyntaxNode for TokenLBrace {
31134 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLBrace);
31135 type StablePtr = TokenLBracePtr;
31136 type Green = TokenLBraceGreen;
31137 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31138 TokenLBraceGreen(
31139 Arc::new(GreenNode {
31140 kind: SyntaxKind::TokenMissing,
31141 details: GreenNodeDetails::Token("".into()),
31142 })
31143 .intern(db),
31144 )
31145 }
31146 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31147 match node.0.green.lookup_intern(db).details {
31148 GreenNodeDetails::Token(_) => Self { node },
31149 GreenNodeDetails::Node { .. } => {
31150 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLBrace)
31151 }
31152 }
31153 }
31154 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31155 match node.0.green.lookup_intern(db).details {
31156 GreenNodeDetails::Token(_) => Some(Self { node }),
31157 GreenNodeDetails::Node { .. } => None,
31158 }
31159 }
31160 fn as_syntax_node(&self) -> SyntaxNode {
31161 self.node.clone()
31162 }
31163 fn stable_ptr(&self) -> Self::StablePtr {
31164 TokenLBracePtr(self.node.0.stable_ptr)
31165 }
31166}
31167impl From<&TokenLBrace> for SyntaxStablePtrId {
31168 fn from(node: &TokenLBrace) -> Self {
31169 node.stable_ptr().untyped()
31170 }
31171}
31172#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31173pub struct TerminalLBrace {
31174 node: SyntaxNode,
31175 children: Arc<[SyntaxNode]>,
31176}
31177impl Terminal for TerminalLBrace {
31178 const KIND: SyntaxKind = SyntaxKind::TerminalLBrace;
31179 type TokenType = TokenLBrace;
31180 fn new_green(
31181 db: &dyn SyntaxGroup,
31182 leading_trivia: TriviaGreen,
31183 token: <<TerminalLBrace as Terminal>::TokenType as TypedSyntaxNode>::Green,
31184 trailing_trivia: TriviaGreen,
31185 ) -> Self::Green {
31186 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31187 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31188 TerminalLBraceGreen(
31189 Arc::new(GreenNode {
31190 kind: SyntaxKind::TerminalLBrace,
31191 details: GreenNodeDetails::Node { children, width },
31192 })
31193 .intern(db),
31194 )
31195 }
31196 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31197 self.token(db).text(db)
31198 }
31199}
31200impl TerminalLBrace {
31201 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31202 Trivia::from_syntax_node(db, self.children[0].clone())
31203 }
31204 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLBrace {
31205 TokenLBrace::from_syntax_node(db, self.children[1].clone())
31206 }
31207 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31208 Trivia::from_syntax_node(db, self.children[2].clone())
31209 }
31210}
31211#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31212pub struct TerminalLBracePtr(pub SyntaxStablePtrId);
31213impl TerminalLBracePtr {}
31214impl TypedStablePtr for TerminalLBracePtr {
31215 type SyntaxNode = TerminalLBrace;
31216 fn untyped(&self) -> SyntaxStablePtrId {
31217 self.0
31218 }
31219 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
31220 TerminalLBrace::from_syntax_node(db, self.0.lookup(db))
31221 }
31222}
31223impl From<TerminalLBracePtr> for SyntaxStablePtrId {
31224 fn from(ptr: TerminalLBracePtr) -> Self {
31225 ptr.untyped()
31226 }
31227}
31228#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31229pub struct TerminalLBraceGreen(pub GreenId);
31230impl TypedSyntaxNode for TerminalLBrace {
31231 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLBrace);
31232 type StablePtr = TerminalLBracePtr;
31233 type Green = TerminalLBraceGreen;
31234 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31235 TerminalLBraceGreen(
31236 Arc::new(GreenNode {
31237 kind: SyntaxKind::TerminalLBrace,
31238 details: GreenNodeDetails::Node {
31239 children: vec![
31240 Trivia::missing(db).0,
31241 TokenLBrace::missing(db).0,
31242 Trivia::missing(db).0,
31243 ],
31244 width: TextWidth::default(),
31245 },
31246 })
31247 .intern(db),
31248 )
31249 }
31250 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31251 let kind = node.kind(db);
31252 assert_eq!(
31253 kind,
31254 SyntaxKind::TerminalLBrace,
31255 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31256 kind,
31257 SyntaxKind::TerminalLBrace
31258 );
31259 let children = db.get_children(node.clone());
31260 Self { node, children }
31261 }
31262 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31263 let kind = node.kind(db);
31264 if kind == SyntaxKind::TerminalLBrace {
31265 Some(Self::from_syntax_node(db, node))
31266 } else {
31267 None
31268 }
31269 }
31270 fn as_syntax_node(&self) -> SyntaxNode {
31271 self.node.clone()
31272 }
31273 fn stable_ptr(&self) -> Self::StablePtr {
31274 TerminalLBracePtr(self.node.0.stable_ptr)
31275 }
31276}
31277impl From<&TerminalLBrace> for SyntaxStablePtrId {
31278 fn from(node: &TerminalLBrace) -> Self {
31279 node.stable_ptr().untyped()
31280 }
31281}
31282#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31283pub struct TokenLBrack {
31284 node: SyntaxNode,
31285}
31286impl Token for TokenLBrack {
31287 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31288 TokenLBrackGreen(
31289 Arc::new(GreenNode {
31290 kind: SyntaxKind::TokenLBrack,
31291 details: GreenNodeDetails::Token(text),
31292 })
31293 .intern(db),
31294 )
31295 }
31296 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31297 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31298 .clone()
31299 }
31300}
31301#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31302pub struct TokenLBrackPtr(pub SyntaxStablePtrId);
31303impl TypedStablePtr for TokenLBrackPtr {
31304 type SyntaxNode = TokenLBrack;
31305 fn untyped(&self) -> SyntaxStablePtrId {
31306 self.0
31307 }
31308 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLBrack {
31309 TokenLBrack::from_syntax_node(db, self.0.lookup(db))
31310 }
31311}
31312impl From<TokenLBrackPtr> for SyntaxStablePtrId {
31313 fn from(ptr: TokenLBrackPtr) -> Self {
31314 ptr.untyped()
31315 }
31316}
31317#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31318pub struct TokenLBrackGreen(pub GreenId);
31319impl TokenLBrackGreen {
31320 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31321 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31322 }
31323}
31324impl TypedSyntaxNode for TokenLBrack {
31325 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLBrack);
31326 type StablePtr = TokenLBrackPtr;
31327 type Green = TokenLBrackGreen;
31328 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31329 TokenLBrackGreen(
31330 Arc::new(GreenNode {
31331 kind: SyntaxKind::TokenMissing,
31332 details: GreenNodeDetails::Token("".into()),
31333 })
31334 .intern(db),
31335 )
31336 }
31337 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31338 match node.0.green.lookup_intern(db).details {
31339 GreenNodeDetails::Token(_) => Self { node },
31340 GreenNodeDetails::Node { .. } => {
31341 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLBrack)
31342 }
31343 }
31344 }
31345 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31346 match node.0.green.lookup_intern(db).details {
31347 GreenNodeDetails::Token(_) => Some(Self { node }),
31348 GreenNodeDetails::Node { .. } => None,
31349 }
31350 }
31351 fn as_syntax_node(&self) -> SyntaxNode {
31352 self.node.clone()
31353 }
31354 fn stable_ptr(&self) -> Self::StablePtr {
31355 TokenLBrackPtr(self.node.0.stable_ptr)
31356 }
31357}
31358impl From<&TokenLBrack> for SyntaxStablePtrId {
31359 fn from(node: &TokenLBrack) -> Self {
31360 node.stable_ptr().untyped()
31361 }
31362}
31363#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31364pub struct TerminalLBrack {
31365 node: SyntaxNode,
31366 children: Arc<[SyntaxNode]>,
31367}
31368impl Terminal for TerminalLBrack {
31369 const KIND: SyntaxKind = SyntaxKind::TerminalLBrack;
31370 type TokenType = TokenLBrack;
31371 fn new_green(
31372 db: &dyn SyntaxGroup,
31373 leading_trivia: TriviaGreen,
31374 token: <<TerminalLBrack as Terminal>::TokenType as TypedSyntaxNode>::Green,
31375 trailing_trivia: TriviaGreen,
31376 ) -> Self::Green {
31377 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31378 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31379 TerminalLBrackGreen(
31380 Arc::new(GreenNode {
31381 kind: SyntaxKind::TerminalLBrack,
31382 details: GreenNodeDetails::Node { children, width },
31383 })
31384 .intern(db),
31385 )
31386 }
31387 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31388 self.token(db).text(db)
31389 }
31390}
31391impl TerminalLBrack {
31392 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31393 Trivia::from_syntax_node(db, self.children[0].clone())
31394 }
31395 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLBrack {
31396 TokenLBrack::from_syntax_node(db, self.children[1].clone())
31397 }
31398 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31399 Trivia::from_syntax_node(db, self.children[2].clone())
31400 }
31401}
31402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31403pub struct TerminalLBrackPtr(pub SyntaxStablePtrId);
31404impl TerminalLBrackPtr {}
31405impl TypedStablePtr for TerminalLBrackPtr {
31406 type SyntaxNode = TerminalLBrack;
31407 fn untyped(&self) -> SyntaxStablePtrId {
31408 self.0
31409 }
31410 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
31411 TerminalLBrack::from_syntax_node(db, self.0.lookup(db))
31412 }
31413}
31414impl From<TerminalLBrackPtr> for SyntaxStablePtrId {
31415 fn from(ptr: TerminalLBrackPtr) -> Self {
31416 ptr.untyped()
31417 }
31418}
31419#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31420pub struct TerminalLBrackGreen(pub GreenId);
31421impl TypedSyntaxNode for TerminalLBrack {
31422 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLBrack);
31423 type StablePtr = TerminalLBrackPtr;
31424 type Green = TerminalLBrackGreen;
31425 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31426 TerminalLBrackGreen(
31427 Arc::new(GreenNode {
31428 kind: SyntaxKind::TerminalLBrack,
31429 details: GreenNodeDetails::Node {
31430 children: vec![
31431 Trivia::missing(db).0,
31432 TokenLBrack::missing(db).0,
31433 Trivia::missing(db).0,
31434 ],
31435 width: TextWidth::default(),
31436 },
31437 })
31438 .intern(db),
31439 )
31440 }
31441 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31442 let kind = node.kind(db);
31443 assert_eq!(
31444 kind,
31445 SyntaxKind::TerminalLBrack,
31446 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31447 kind,
31448 SyntaxKind::TerminalLBrack
31449 );
31450 let children = db.get_children(node.clone());
31451 Self { node, children }
31452 }
31453 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31454 let kind = node.kind(db);
31455 if kind == SyntaxKind::TerminalLBrack {
31456 Some(Self::from_syntax_node(db, node))
31457 } else {
31458 None
31459 }
31460 }
31461 fn as_syntax_node(&self) -> SyntaxNode {
31462 self.node.clone()
31463 }
31464 fn stable_ptr(&self) -> Self::StablePtr {
31465 TerminalLBrackPtr(self.node.0.stable_ptr)
31466 }
31467}
31468impl From<&TerminalLBrack> for SyntaxStablePtrId {
31469 fn from(node: &TerminalLBrack) -> Self {
31470 node.stable_ptr().untyped()
31471 }
31472}
31473#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31474pub struct TokenLE {
31475 node: SyntaxNode,
31476}
31477impl Token for TokenLE {
31478 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31479 TokenLEGreen(
31480 Arc::new(GreenNode {
31481 kind: SyntaxKind::TokenLE,
31482 details: GreenNodeDetails::Token(text),
31483 })
31484 .intern(db),
31485 )
31486 }
31487 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31488 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31489 .clone()
31490 }
31491}
31492#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31493pub struct TokenLEPtr(pub SyntaxStablePtrId);
31494impl TypedStablePtr for TokenLEPtr {
31495 type SyntaxNode = TokenLE;
31496 fn untyped(&self) -> SyntaxStablePtrId {
31497 self.0
31498 }
31499 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLE {
31500 TokenLE::from_syntax_node(db, self.0.lookup(db))
31501 }
31502}
31503impl From<TokenLEPtr> for SyntaxStablePtrId {
31504 fn from(ptr: TokenLEPtr) -> Self {
31505 ptr.untyped()
31506 }
31507}
31508#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31509pub struct TokenLEGreen(pub GreenId);
31510impl TokenLEGreen {
31511 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31512 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31513 }
31514}
31515impl TypedSyntaxNode for TokenLE {
31516 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLE);
31517 type StablePtr = TokenLEPtr;
31518 type Green = TokenLEGreen;
31519 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31520 TokenLEGreen(
31521 Arc::new(GreenNode {
31522 kind: SyntaxKind::TokenMissing,
31523 details: GreenNodeDetails::Token("".into()),
31524 })
31525 .intern(db),
31526 )
31527 }
31528 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31529 match node.0.green.lookup_intern(db).details {
31530 GreenNodeDetails::Token(_) => Self { node },
31531 GreenNodeDetails::Node { .. } => {
31532 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLE)
31533 }
31534 }
31535 }
31536 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31537 match node.0.green.lookup_intern(db).details {
31538 GreenNodeDetails::Token(_) => Some(Self { node }),
31539 GreenNodeDetails::Node { .. } => None,
31540 }
31541 }
31542 fn as_syntax_node(&self) -> SyntaxNode {
31543 self.node.clone()
31544 }
31545 fn stable_ptr(&self) -> Self::StablePtr {
31546 TokenLEPtr(self.node.0.stable_ptr)
31547 }
31548}
31549impl From<&TokenLE> for SyntaxStablePtrId {
31550 fn from(node: &TokenLE) -> Self {
31551 node.stable_ptr().untyped()
31552 }
31553}
31554#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31555pub struct TerminalLE {
31556 node: SyntaxNode,
31557 children: Arc<[SyntaxNode]>,
31558}
31559impl Terminal for TerminalLE {
31560 const KIND: SyntaxKind = SyntaxKind::TerminalLE;
31561 type TokenType = TokenLE;
31562 fn new_green(
31563 db: &dyn SyntaxGroup,
31564 leading_trivia: TriviaGreen,
31565 token: <<TerminalLE as Terminal>::TokenType as TypedSyntaxNode>::Green,
31566 trailing_trivia: TriviaGreen,
31567 ) -> Self::Green {
31568 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31569 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31570 TerminalLEGreen(
31571 Arc::new(GreenNode {
31572 kind: SyntaxKind::TerminalLE,
31573 details: GreenNodeDetails::Node { children, width },
31574 })
31575 .intern(db),
31576 )
31577 }
31578 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31579 self.token(db).text(db)
31580 }
31581}
31582impl TerminalLE {
31583 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31584 Trivia::from_syntax_node(db, self.children[0].clone())
31585 }
31586 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLE {
31587 TokenLE::from_syntax_node(db, self.children[1].clone())
31588 }
31589 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31590 Trivia::from_syntax_node(db, self.children[2].clone())
31591 }
31592}
31593#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31594pub struct TerminalLEPtr(pub SyntaxStablePtrId);
31595impl TerminalLEPtr {}
31596impl TypedStablePtr for TerminalLEPtr {
31597 type SyntaxNode = TerminalLE;
31598 fn untyped(&self) -> SyntaxStablePtrId {
31599 self.0
31600 }
31601 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLE {
31602 TerminalLE::from_syntax_node(db, self.0.lookup(db))
31603 }
31604}
31605impl From<TerminalLEPtr> for SyntaxStablePtrId {
31606 fn from(ptr: TerminalLEPtr) -> Self {
31607 ptr.untyped()
31608 }
31609}
31610#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31611pub struct TerminalLEGreen(pub GreenId);
31612impl TypedSyntaxNode for TerminalLE {
31613 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLE);
31614 type StablePtr = TerminalLEPtr;
31615 type Green = TerminalLEGreen;
31616 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31617 TerminalLEGreen(
31618 Arc::new(GreenNode {
31619 kind: SyntaxKind::TerminalLE,
31620 details: GreenNodeDetails::Node {
31621 children: vec![
31622 Trivia::missing(db).0,
31623 TokenLE::missing(db).0,
31624 Trivia::missing(db).0,
31625 ],
31626 width: TextWidth::default(),
31627 },
31628 })
31629 .intern(db),
31630 )
31631 }
31632 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31633 let kind = node.kind(db);
31634 assert_eq!(
31635 kind,
31636 SyntaxKind::TerminalLE,
31637 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31638 kind,
31639 SyntaxKind::TerminalLE
31640 );
31641 let children = db.get_children(node.clone());
31642 Self { node, children }
31643 }
31644 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31645 let kind = node.kind(db);
31646 if kind == SyntaxKind::TerminalLE { Some(Self::from_syntax_node(db, node)) } else { None }
31647 }
31648 fn as_syntax_node(&self) -> SyntaxNode {
31649 self.node.clone()
31650 }
31651 fn stable_ptr(&self) -> Self::StablePtr {
31652 TerminalLEPtr(self.node.0.stable_ptr)
31653 }
31654}
31655impl From<&TerminalLE> for SyntaxStablePtrId {
31656 fn from(node: &TerminalLE) -> Self {
31657 node.stable_ptr().untyped()
31658 }
31659}
31660#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31661pub struct TokenLParen {
31662 node: SyntaxNode,
31663}
31664impl Token for TokenLParen {
31665 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31666 TokenLParenGreen(
31667 Arc::new(GreenNode {
31668 kind: SyntaxKind::TokenLParen,
31669 details: GreenNodeDetails::Token(text),
31670 })
31671 .intern(db),
31672 )
31673 }
31674 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31675 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31676 .clone()
31677 }
31678}
31679#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31680pub struct TokenLParenPtr(pub SyntaxStablePtrId);
31681impl TypedStablePtr for TokenLParenPtr {
31682 type SyntaxNode = TokenLParen;
31683 fn untyped(&self) -> SyntaxStablePtrId {
31684 self.0
31685 }
31686 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLParen {
31687 TokenLParen::from_syntax_node(db, self.0.lookup(db))
31688 }
31689}
31690impl From<TokenLParenPtr> for SyntaxStablePtrId {
31691 fn from(ptr: TokenLParenPtr) -> Self {
31692 ptr.untyped()
31693 }
31694}
31695#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31696pub struct TokenLParenGreen(pub GreenId);
31697impl TokenLParenGreen {
31698 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31699 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31700 }
31701}
31702impl TypedSyntaxNode for TokenLParen {
31703 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLParen);
31704 type StablePtr = TokenLParenPtr;
31705 type Green = TokenLParenGreen;
31706 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31707 TokenLParenGreen(
31708 Arc::new(GreenNode {
31709 kind: SyntaxKind::TokenMissing,
31710 details: GreenNodeDetails::Token("".into()),
31711 })
31712 .intern(db),
31713 )
31714 }
31715 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31716 match node.0.green.lookup_intern(db).details {
31717 GreenNodeDetails::Token(_) => Self { node },
31718 GreenNodeDetails::Node { .. } => {
31719 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLParen)
31720 }
31721 }
31722 }
31723 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31724 match node.0.green.lookup_intern(db).details {
31725 GreenNodeDetails::Token(_) => Some(Self { node }),
31726 GreenNodeDetails::Node { .. } => None,
31727 }
31728 }
31729 fn as_syntax_node(&self) -> SyntaxNode {
31730 self.node.clone()
31731 }
31732 fn stable_ptr(&self) -> Self::StablePtr {
31733 TokenLParenPtr(self.node.0.stable_ptr)
31734 }
31735}
31736impl From<&TokenLParen> for SyntaxStablePtrId {
31737 fn from(node: &TokenLParen) -> Self {
31738 node.stable_ptr().untyped()
31739 }
31740}
31741#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31742pub struct TerminalLParen {
31743 node: SyntaxNode,
31744 children: Arc<[SyntaxNode]>,
31745}
31746impl Terminal for TerminalLParen {
31747 const KIND: SyntaxKind = SyntaxKind::TerminalLParen;
31748 type TokenType = TokenLParen;
31749 fn new_green(
31750 db: &dyn SyntaxGroup,
31751 leading_trivia: TriviaGreen,
31752 token: <<TerminalLParen as Terminal>::TokenType as TypedSyntaxNode>::Green,
31753 trailing_trivia: TriviaGreen,
31754 ) -> Self::Green {
31755 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31756 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31757 TerminalLParenGreen(
31758 Arc::new(GreenNode {
31759 kind: SyntaxKind::TerminalLParen,
31760 details: GreenNodeDetails::Node { children, width },
31761 })
31762 .intern(db),
31763 )
31764 }
31765 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31766 self.token(db).text(db)
31767 }
31768}
31769impl TerminalLParen {
31770 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31771 Trivia::from_syntax_node(db, self.children[0].clone())
31772 }
31773 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLParen {
31774 TokenLParen::from_syntax_node(db, self.children[1].clone())
31775 }
31776 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31777 Trivia::from_syntax_node(db, self.children[2].clone())
31778 }
31779}
31780#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31781pub struct TerminalLParenPtr(pub SyntaxStablePtrId);
31782impl TerminalLParenPtr {}
31783impl TypedStablePtr for TerminalLParenPtr {
31784 type SyntaxNode = TerminalLParen;
31785 fn untyped(&self) -> SyntaxStablePtrId {
31786 self.0
31787 }
31788 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
31789 TerminalLParen::from_syntax_node(db, self.0.lookup(db))
31790 }
31791}
31792impl From<TerminalLParenPtr> for SyntaxStablePtrId {
31793 fn from(ptr: TerminalLParenPtr) -> Self {
31794 ptr.untyped()
31795 }
31796}
31797#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31798pub struct TerminalLParenGreen(pub GreenId);
31799impl TypedSyntaxNode for TerminalLParen {
31800 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLParen);
31801 type StablePtr = TerminalLParenPtr;
31802 type Green = TerminalLParenGreen;
31803 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31804 TerminalLParenGreen(
31805 Arc::new(GreenNode {
31806 kind: SyntaxKind::TerminalLParen,
31807 details: GreenNodeDetails::Node {
31808 children: vec![
31809 Trivia::missing(db).0,
31810 TokenLParen::missing(db).0,
31811 Trivia::missing(db).0,
31812 ],
31813 width: TextWidth::default(),
31814 },
31815 })
31816 .intern(db),
31817 )
31818 }
31819 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31820 let kind = node.kind(db);
31821 assert_eq!(
31822 kind,
31823 SyntaxKind::TerminalLParen,
31824 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31825 kind,
31826 SyntaxKind::TerminalLParen
31827 );
31828 let children = db.get_children(node.clone());
31829 Self { node, children }
31830 }
31831 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31832 let kind = node.kind(db);
31833 if kind == SyntaxKind::TerminalLParen {
31834 Some(Self::from_syntax_node(db, node))
31835 } else {
31836 None
31837 }
31838 }
31839 fn as_syntax_node(&self) -> SyntaxNode {
31840 self.node.clone()
31841 }
31842 fn stable_ptr(&self) -> Self::StablePtr {
31843 TerminalLParenPtr(self.node.0.stable_ptr)
31844 }
31845}
31846impl From<&TerminalLParen> for SyntaxStablePtrId {
31847 fn from(node: &TerminalLParen) -> Self {
31848 node.stable_ptr().untyped()
31849 }
31850}
31851#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31852pub struct TokenLT {
31853 node: SyntaxNode,
31854}
31855impl Token for TokenLT {
31856 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31857 TokenLTGreen(
31858 Arc::new(GreenNode {
31859 kind: SyntaxKind::TokenLT,
31860 details: GreenNodeDetails::Token(text),
31861 })
31862 .intern(db),
31863 )
31864 }
31865 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31866 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31867 .clone()
31868 }
31869}
31870#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31871pub struct TokenLTPtr(pub SyntaxStablePtrId);
31872impl TypedStablePtr for TokenLTPtr {
31873 type SyntaxNode = TokenLT;
31874 fn untyped(&self) -> SyntaxStablePtrId {
31875 self.0
31876 }
31877 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLT {
31878 TokenLT::from_syntax_node(db, self.0.lookup(db))
31879 }
31880}
31881impl From<TokenLTPtr> for SyntaxStablePtrId {
31882 fn from(ptr: TokenLTPtr) -> Self {
31883 ptr.untyped()
31884 }
31885}
31886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31887pub struct TokenLTGreen(pub GreenId);
31888impl TokenLTGreen {
31889 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31890 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31891 }
31892}
31893impl TypedSyntaxNode for TokenLT {
31894 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLT);
31895 type StablePtr = TokenLTPtr;
31896 type Green = TokenLTGreen;
31897 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31898 TokenLTGreen(
31899 Arc::new(GreenNode {
31900 kind: SyntaxKind::TokenMissing,
31901 details: GreenNodeDetails::Token("".into()),
31902 })
31903 .intern(db),
31904 )
31905 }
31906 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31907 match node.0.green.lookup_intern(db).details {
31908 GreenNodeDetails::Token(_) => Self { node },
31909 GreenNodeDetails::Node { .. } => {
31910 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLT)
31911 }
31912 }
31913 }
31914 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
31915 match node.0.green.lookup_intern(db).details {
31916 GreenNodeDetails::Token(_) => Some(Self { node }),
31917 GreenNodeDetails::Node { .. } => None,
31918 }
31919 }
31920 fn as_syntax_node(&self) -> SyntaxNode {
31921 self.node.clone()
31922 }
31923 fn stable_ptr(&self) -> Self::StablePtr {
31924 TokenLTPtr(self.node.0.stable_ptr)
31925 }
31926}
31927impl From<&TokenLT> for SyntaxStablePtrId {
31928 fn from(node: &TokenLT) -> Self {
31929 node.stable_ptr().untyped()
31930 }
31931}
31932#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31933pub struct TerminalLT {
31934 node: SyntaxNode,
31935 children: Arc<[SyntaxNode]>,
31936}
31937impl Terminal for TerminalLT {
31938 const KIND: SyntaxKind = SyntaxKind::TerminalLT;
31939 type TokenType = TokenLT;
31940 fn new_green(
31941 db: &dyn SyntaxGroup,
31942 leading_trivia: TriviaGreen,
31943 token: <<TerminalLT as Terminal>::TokenType as TypedSyntaxNode>::Green,
31944 trailing_trivia: TriviaGreen,
31945 ) -> Self::Green {
31946 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31947 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31948 TerminalLTGreen(
31949 Arc::new(GreenNode {
31950 kind: SyntaxKind::TerminalLT,
31951 details: GreenNodeDetails::Node { children, width },
31952 })
31953 .intern(db),
31954 )
31955 }
31956 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31957 self.token(db).text(db)
31958 }
31959}
31960impl TerminalLT {
31961 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31962 Trivia::from_syntax_node(db, self.children[0].clone())
31963 }
31964 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLT {
31965 TokenLT::from_syntax_node(db, self.children[1].clone())
31966 }
31967 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31968 Trivia::from_syntax_node(db, self.children[2].clone())
31969 }
31970}
31971#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31972pub struct TerminalLTPtr(pub SyntaxStablePtrId);
31973impl TerminalLTPtr {}
31974impl TypedStablePtr for TerminalLTPtr {
31975 type SyntaxNode = TerminalLT;
31976 fn untyped(&self) -> SyntaxStablePtrId {
31977 self.0
31978 }
31979 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLT {
31980 TerminalLT::from_syntax_node(db, self.0.lookup(db))
31981 }
31982}
31983impl From<TerminalLTPtr> for SyntaxStablePtrId {
31984 fn from(ptr: TerminalLTPtr) -> Self {
31985 ptr.untyped()
31986 }
31987}
31988#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31989pub struct TerminalLTGreen(pub GreenId);
31990impl TypedSyntaxNode for TerminalLT {
31991 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLT);
31992 type StablePtr = TerminalLTPtr;
31993 type Green = TerminalLTGreen;
31994 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31995 TerminalLTGreen(
31996 Arc::new(GreenNode {
31997 kind: SyntaxKind::TerminalLT,
31998 details: GreenNodeDetails::Node {
31999 children: vec![
32000 Trivia::missing(db).0,
32001 TokenLT::missing(db).0,
32002 Trivia::missing(db).0,
32003 ],
32004 width: TextWidth::default(),
32005 },
32006 })
32007 .intern(db),
32008 )
32009 }
32010 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32011 let kind = node.kind(db);
32012 assert_eq!(
32013 kind,
32014 SyntaxKind::TerminalLT,
32015 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32016 kind,
32017 SyntaxKind::TerminalLT
32018 );
32019 let children = db.get_children(node.clone());
32020 Self { node, children }
32021 }
32022 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32023 let kind = node.kind(db);
32024 if kind == SyntaxKind::TerminalLT { Some(Self::from_syntax_node(db, node)) } else { None }
32025 }
32026 fn as_syntax_node(&self) -> SyntaxNode {
32027 self.node.clone()
32028 }
32029 fn stable_ptr(&self) -> Self::StablePtr {
32030 TerminalLTPtr(self.node.0.stable_ptr)
32031 }
32032}
32033impl From<&TerminalLT> for SyntaxStablePtrId {
32034 fn from(node: &TerminalLT) -> Self {
32035 node.stable_ptr().untyped()
32036 }
32037}
32038#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32039pub struct TokenMatchArrow {
32040 node: SyntaxNode,
32041}
32042impl Token for TokenMatchArrow {
32043 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32044 TokenMatchArrowGreen(
32045 Arc::new(GreenNode {
32046 kind: SyntaxKind::TokenMatchArrow,
32047 details: GreenNodeDetails::Token(text),
32048 })
32049 .intern(db),
32050 )
32051 }
32052 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32053 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32054 .clone()
32055 }
32056}
32057#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32058pub struct TokenMatchArrowPtr(pub SyntaxStablePtrId);
32059impl TypedStablePtr for TokenMatchArrowPtr {
32060 type SyntaxNode = TokenMatchArrow;
32061 fn untyped(&self) -> SyntaxStablePtrId {
32062 self.0
32063 }
32064 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMatchArrow {
32065 TokenMatchArrow::from_syntax_node(db, self.0.lookup(db))
32066 }
32067}
32068impl From<TokenMatchArrowPtr> for SyntaxStablePtrId {
32069 fn from(ptr: TokenMatchArrowPtr) -> Self {
32070 ptr.untyped()
32071 }
32072}
32073#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32074pub struct TokenMatchArrowGreen(pub GreenId);
32075impl TokenMatchArrowGreen {
32076 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32077 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32078 }
32079}
32080impl TypedSyntaxNode for TokenMatchArrow {
32081 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMatchArrow);
32082 type StablePtr = TokenMatchArrowPtr;
32083 type Green = TokenMatchArrowGreen;
32084 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32085 TokenMatchArrowGreen(
32086 Arc::new(GreenNode {
32087 kind: SyntaxKind::TokenMissing,
32088 details: GreenNodeDetails::Token("".into()),
32089 })
32090 .intern(db),
32091 )
32092 }
32093 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32094 match node.0.green.lookup_intern(db).details {
32095 GreenNodeDetails::Token(_) => Self { node },
32096 GreenNodeDetails::Node { .. } => {
32097 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMatchArrow)
32098 }
32099 }
32100 }
32101 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32102 match node.0.green.lookup_intern(db).details {
32103 GreenNodeDetails::Token(_) => Some(Self { node }),
32104 GreenNodeDetails::Node { .. } => None,
32105 }
32106 }
32107 fn as_syntax_node(&self) -> SyntaxNode {
32108 self.node.clone()
32109 }
32110 fn stable_ptr(&self) -> Self::StablePtr {
32111 TokenMatchArrowPtr(self.node.0.stable_ptr)
32112 }
32113}
32114impl From<&TokenMatchArrow> for SyntaxStablePtrId {
32115 fn from(node: &TokenMatchArrow) -> Self {
32116 node.stable_ptr().untyped()
32117 }
32118}
32119#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32120pub struct TerminalMatchArrow {
32121 node: SyntaxNode,
32122 children: Arc<[SyntaxNode]>,
32123}
32124impl Terminal for TerminalMatchArrow {
32125 const KIND: SyntaxKind = SyntaxKind::TerminalMatchArrow;
32126 type TokenType = TokenMatchArrow;
32127 fn new_green(
32128 db: &dyn SyntaxGroup,
32129 leading_trivia: TriviaGreen,
32130 token: <<TerminalMatchArrow as Terminal>::TokenType as TypedSyntaxNode>::Green,
32131 trailing_trivia: TriviaGreen,
32132 ) -> Self::Green {
32133 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32134 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32135 TerminalMatchArrowGreen(
32136 Arc::new(GreenNode {
32137 kind: SyntaxKind::TerminalMatchArrow,
32138 details: GreenNodeDetails::Node { children, width },
32139 })
32140 .intern(db),
32141 )
32142 }
32143 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32144 self.token(db).text(db)
32145 }
32146}
32147impl TerminalMatchArrow {
32148 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32149 Trivia::from_syntax_node(db, self.children[0].clone())
32150 }
32151 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMatchArrow {
32152 TokenMatchArrow::from_syntax_node(db, self.children[1].clone())
32153 }
32154 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32155 Trivia::from_syntax_node(db, self.children[2].clone())
32156 }
32157}
32158#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32159pub struct TerminalMatchArrowPtr(pub SyntaxStablePtrId);
32160impl TerminalMatchArrowPtr {}
32161impl TypedStablePtr for TerminalMatchArrowPtr {
32162 type SyntaxNode = TerminalMatchArrow;
32163 fn untyped(&self) -> SyntaxStablePtrId {
32164 self.0
32165 }
32166 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMatchArrow {
32167 TerminalMatchArrow::from_syntax_node(db, self.0.lookup(db))
32168 }
32169}
32170impl From<TerminalMatchArrowPtr> for SyntaxStablePtrId {
32171 fn from(ptr: TerminalMatchArrowPtr) -> Self {
32172 ptr.untyped()
32173 }
32174}
32175#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32176pub struct TerminalMatchArrowGreen(pub GreenId);
32177impl TypedSyntaxNode for TerminalMatchArrow {
32178 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMatchArrow);
32179 type StablePtr = TerminalMatchArrowPtr;
32180 type Green = TerminalMatchArrowGreen;
32181 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32182 TerminalMatchArrowGreen(
32183 Arc::new(GreenNode {
32184 kind: SyntaxKind::TerminalMatchArrow,
32185 details: GreenNodeDetails::Node {
32186 children: vec![
32187 Trivia::missing(db).0,
32188 TokenMatchArrow::missing(db).0,
32189 Trivia::missing(db).0,
32190 ],
32191 width: TextWidth::default(),
32192 },
32193 })
32194 .intern(db),
32195 )
32196 }
32197 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32198 let kind = node.kind(db);
32199 assert_eq!(
32200 kind,
32201 SyntaxKind::TerminalMatchArrow,
32202 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32203 kind,
32204 SyntaxKind::TerminalMatchArrow
32205 );
32206 let children = db.get_children(node.clone());
32207 Self { node, children }
32208 }
32209 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32210 let kind = node.kind(db);
32211 if kind == SyntaxKind::TerminalMatchArrow {
32212 Some(Self::from_syntax_node(db, node))
32213 } else {
32214 None
32215 }
32216 }
32217 fn as_syntax_node(&self) -> SyntaxNode {
32218 self.node.clone()
32219 }
32220 fn stable_ptr(&self) -> Self::StablePtr {
32221 TerminalMatchArrowPtr(self.node.0.stable_ptr)
32222 }
32223}
32224impl From<&TerminalMatchArrow> for SyntaxStablePtrId {
32225 fn from(node: &TerminalMatchArrow) -> Self {
32226 node.stable_ptr().untyped()
32227 }
32228}
32229#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32230pub struct TokenMinus {
32231 node: SyntaxNode,
32232}
32233impl Token for TokenMinus {
32234 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32235 TokenMinusGreen(
32236 Arc::new(GreenNode {
32237 kind: SyntaxKind::TokenMinus,
32238 details: GreenNodeDetails::Token(text),
32239 })
32240 .intern(db),
32241 )
32242 }
32243 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32244 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32245 .clone()
32246 }
32247}
32248#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32249pub struct TokenMinusPtr(pub SyntaxStablePtrId);
32250impl TypedStablePtr for TokenMinusPtr {
32251 type SyntaxNode = TokenMinus;
32252 fn untyped(&self) -> SyntaxStablePtrId {
32253 self.0
32254 }
32255 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMinus {
32256 TokenMinus::from_syntax_node(db, self.0.lookup(db))
32257 }
32258}
32259impl From<TokenMinusPtr> for SyntaxStablePtrId {
32260 fn from(ptr: TokenMinusPtr) -> Self {
32261 ptr.untyped()
32262 }
32263}
32264#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32265pub struct TokenMinusGreen(pub GreenId);
32266impl TokenMinusGreen {
32267 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32268 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32269 }
32270}
32271impl TypedSyntaxNode for TokenMinus {
32272 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMinus);
32273 type StablePtr = TokenMinusPtr;
32274 type Green = TokenMinusGreen;
32275 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32276 TokenMinusGreen(
32277 Arc::new(GreenNode {
32278 kind: SyntaxKind::TokenMissing,
32279 details: GreenNodeDetails::Token("".into()),
32280 })
32281 .intern(db),
32282 )
32283 }
32284 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32285 match node.0.green.lookup_intern(db).details {
32286 GreenNodeDetails::Token(_) => Self { node },
32287 GreenNodeDetails::Node { .. } => {
32288 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMinus)
32289 }
32290 }
32291 }
32292 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32293 match node.0.green.lookup_intern(db).details {
32294 GreenNodeDetails::Token(_) => Some(Self { node }),
32295 GreenNodeDetails::Node { .. } => None,
32296 }
32297 }
32298 fn as_syntax_node(&self) -> SyntaxNode {
32299 self.node.clone()
32300 }
32301 fn stable_ptr(&self) -> Self::StablePtr {
32302 TokenMinusPtr(self.node.0.stable_ptr)
32303 }
32304}
32305impl From<&TokenMinus> for SyntaxStablePtrId {
32306 fn from(node: &TokenMinus) -> Self {
32307 node.stable_ptr().untyped()
32308 }
32309}
32310#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32311pub struct TerminalMinus {
32312 node: SyntaxNode,
32313 children: Arc<[SyntaxNode]>,
32314}
32315impl Terminal for TerminalMinus {
32316 const KIND: SyntaxKind = SyntaxKind::TerminalMinus;
32317 type TokenType = TokenMinus;
32318 fn new_green(
32319 db: &dyn SyntaxGroup,
32320 leading_trivia: TriviaGreen,
32321 token: <<TerminalMinus as Terminal>::TokenType as TypedSyntaxNode>::Green,
32322 trailing_trivia: TriviaGreen,
32323 ) -> Self::Green {
32324 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32325 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32326 TerminalMinusGreen(
32327 Arc::new(GreenNode {
32328 kind: SyntaxKind::TerminalMinus,
32329 details: GreenNodeDetails::Node { children, width },
32330 })
32331 .intern(db),
32332 )
32333 }
32334 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32335 self.token(db).text(db)
32336 }
32337}
32338impl TerminalMinus {
32339 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32340 Trivia::from_syntax_node(db, self.children[0].clone())
32341 }
32342 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMinus {
32343 TokenMinus::from_syntax_node(db, self.children[1].clone())
32344 }
32345 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32346 Trivia::from_syntax_node(db, self.children[2].clone())
32347 }
32348}
32349#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32350pub struct TerminalMinusPtr(pub SyntaxStablePtrId);
32351impl TerminalMinusPtr {}
32352impl TypedStablePtr for TerminalMinusPtr {
32353 type SyntaxNode = TerminalMinus;
32354 fn untyped(&self) -> SyntaxStablePtrId {
32355 self.0
32356 }
32357 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMinus {
32358 TerminalMinus::from_syntax_node(db, self.0.lookup(db))
32359 }
32360}
32361impl From<TerminalMinusPtr> for SyntaxStablePtrId {
32362 fn from(ptr: TerminalMinusPtr) -> Self {
32363 ptr.untyped()
32364 }
32365}
32366#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32367pub struct TerminalMinusGreen(pub GreenId);
32368impl TypedSyntaxNode for TerminalMinus {
32369 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMinus);
32370 type StablePtr = TerminalMinusPtr;
32371 type Green = TerminalMinusGreen;
32372 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32373 TerminalMinusGreen(
32374 Arc::new(GreenNode {
32375 kind: SyntaxKind::TerminalMinus,
32376 details: GreenNodeDetails::Node {
32377 children: vec![
32378 Trivia::missing(db).0,
32379 TokenMinus::missing(db).0,
32380 Trivia::missing(db).0,
32381 ],
32382 width: TextWidth::default(),
32383 },
32384 })
32385 .intern(db),
32386 )
32387 }
32388 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32389 let kind = node.kind(db);
32390 assert_eq!(
32391 kind,
32392 SyntaxKind::TerminalMinus,
32393 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32394 kind,
32395 SyntaxKind::TerminalMinus
32396 );
32397 let children = db.get_children(node.clone());
32398 Self { node, children }
32399 }
32400 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32401 let kind = node.kind(db);
32402 if kind == SyntaxKind::TerminalMinus {
32403 Some(Self::from_syntax_node(db, node))
32404 } else {
32405 None
32406 }
32407 }
32408 fn as_syntax_node(&self) -> SyntaxNode {
32409 self.node.clone()
32410 }
32411 fn stable_ptr(&self) -> Self::StablePtr {
32412 TerminalMinusPtr(self.node.0.stable_ptr)
32413 }
32414}
32415impl From<&TerminalMinus> for SyntaxStablePtrId {
32416 fn from(node: &TerminalMinus) -> Self {
32417 node.stable_ptr().untyped()
32418 }
32419}
32420#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32421pub struct TokenMinusEq {
32422 node: SyntaxNode,
32423}
32424impl Token for TokenMinusEq {
32425 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32426 TokenMinusEqGreen(
32427 Arc::new(GreenNode {
32428 kind: SyntaxKind::TokenMinusEq,
32429 details: GreenNodeDetails::Token(text),
32430 })
32431 .intern(db),
32432 )
32433 }
32434 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32435 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32436 .clone()
32437 }
32438}
32439#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32440pub struct TokenMinusEqPtr(pub SyntaxStablePtrId);
32441impl TypedStablePtr for TokenMinusEqPtr {
32442 type SyntaxNode = TokenMinusEq;
32443 fn untyped(&self) -> SyntaxStablePtrId {
32444 self.0
32445 }
32446 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMinusEq {
32447 TokenMinusEq::from_syntax_node(db, self.0.lookup(db))
32448 }
32449}
32450impl From<TokenMinusEqPtr> for SyntaxStablePtrId {
32451 fn from(ptr: TokenMinusEqPtr) -> Self {
32452 ptr.untyped()
32453 }
32454}
32455#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32456pub struct TokenMinusEqGreen(pub GreenId);
32457impl TokenMinusEqGreen {
32458 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32459 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32460 }
32461}
32462impl TypedSyntaxNode for TokenMinusEq {
32463 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMinusEq);
32464 type StablePtr = TokenMinusEqPtr;
32465 type Green = TokenMinusEqGreen;
32466 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32467 TokenMinusEqGreen(
32468 Arc::new(GreenNode {
32469 kind: SyntaxKind::TokenMissing,
32470 details: GreenNodeDetails::Token("".into()),
32471 })
32472 .intern(db),
32473 )
32474 }
32475 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32476 match node.0.green.lookup_intern(db).details {
32477 GreenNodeDetails::Token(_) => Self { node },
32478 GreenNodeDetails::Node { .. } => {
32479 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMinusEq)
32480 }
32481 }
32482 }
32483 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32484 match node.0.green.lookup_intern(db).details {
32485 GreenNodeDetails::Token(_) => Some(Self { node }),
32486 GreenNodeDetails::Node { .. } => None,
32487 }
32488 }
32489 fn as_syntax_node(&self) -> SyntaxNode {
32490 self.node.clone()
32491 }
32492 fn stable_ptr(&self) -> Self::StablePtr {
32493 TokenMinusEqPtr(self.node.0.stable_ptr)
32494 }
32495}
32496impl From<&TokenMinusEq> for SyntaxStablePtrId {
32497 fn from(node: &TokenMinusEq) -> Self {
32498 node.stable_ptr().untyped()
32499 }
32500}
32501#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32502pub struct TerminalMinusEq {
32503 node: SyntaxNode,
32504 children: Arc<[SyntaxNode]>,
32505}
32506impl Terminal for TerminalMinusEq {
32507 const KIND: SyntaxKind = SyntaxKind::TerminalMinusEq;
32508 type TokenType = TokenMinusEq;
32509 fn new_green(
32510 db: &dyn SyntaxGroup,
32511 leading_trivia: TriviaGreen,
32512 token: <<TerminalMinusEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
32513 trailing_trivia: TriviaGreen,
32514 ) -> Self::Green {
32515 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32516 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32517 TerminalMinusEqGreen(
32518 Arc::new(GreenNode {
32519 kind: SyntaxKind::TerminalMinusEq,
32520 details: GreenNodeDetails::Node { children, width },
32521 })
32522 .intern(db),
32523 )
32524 }
32525 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32526 self.token(db).text(db)
32527 }
32528}
32529impl TerminalMinusEq {
32530 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32531 Trivia::from_syntax_node(db, self.children[0].clone())
32532 }
32533 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMinusEq {
32534 TokenMinusEq::from_syntax_node(db, self.children[1].clone())
32535 }
32536 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32537 Trivia::from_syntax_node(db, self.children[2].clone())
32538 }
32539}
32540#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32541pub struct TerminalMinusEqPtr(pub SyntaxStablePtrId);
32542impl TerminalMinusEqPtr {}
32543impl TypedStablePtr for TerminalMinusEqPtr {
32544 type SyntaxNode = TerminalMinusEq;
32545 fn untyped(&self) -> SyntaxStablePtrId {
32546 self.0
32547 }
32548 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMinusEq {
32549 TerminalMinusEq::from_syntax_node(db, self.0.lookup(db))
32550 }
32551}
32552impl From<TerminalMinusEqPtr> for SyntaxStablePtrId {
32553 fn from(ptr: TerminalMinusEqPtr) -> Self {
32554 ptr.untyped()
32555 }
32556}
32557#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32558pub struct TerminalMinusEqGreen(pub GreenId);
32559impl TypedSyntaxNode for TerminalMinusEq {
32560 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMinusEq);
32561 type StablePtr = TerminalMinusEqPtr;
32562 type Green = TerminalMinusEqGreen;
32563 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32564 TerminalMinusEqGreen(
32565 Arc::new(GreenNode {
32566 kind: SyntaxKind::TerminalMinusEq,
32567 details: GreenNodeDetails::Node {
32568 children: vec![
32569 Trivia::missing(db).0,
32570 TokenMinusEq::missing(db).0,
32571 Trivia::missing(db).0,
32572 ],
32573 width: TextWidth::default(),
32574 },
32575 })
32576 .intern(db),
32577 )
32578 }
32579 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32580 let kind = node.kind(db);
32581 assert_eq!(
32582 kind,
32583 SyntaxKind::TerminalMinusEq,
32584 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32585 kind,
32586 SyntaxKind::TerminalMinusEq
32587 );
32588 let children = db.get_children(node.clone());
32589 Self { node, children }
32590 }
32591 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32592 let kind = node.kind(db);
32593 if kind == SyntaxKind::TerminalMinusEq {
32594 Some(Self::from_syntax_node(db, node))
32595 } else {
32596 None
32597 }
32598 }
32599 fn as_syntax_node(&self) -> SyntaxNode {
32600 self.node.clone()
32601 }
32602 fn stable_ptr(&self) -> Self::StablePtr {
32603 TerminalMinusEqPtr(self.node.0.stable_ptr)
32604 }
32605}
32606impl From<&TerminalMinusEq> for SyntaxStablePtrId {
32607 fn from(node: &TerminalMinusEq) -> Self {
32608 node.stable_ptr().untyped()
32609 }
32610}
32611#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32612pub struct TokenMod {
32613 node: SyntaxNode,
32614}
32615impl Token for TokenMod {
32616 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32617 TokenModGreen(
32618 Arc::new(GreenNode {
32619 kind: SyntaxKind::TokenMod,
32620 details: GreenNodeDetails::Token(text),
32621 })
32622 .intern(db),
32623 )
32624 }
32625 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32626 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32627 .clone()
32628 }
32629}
32630#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32631pub struct TokenModPtr(pub SyntaxStablePtrId);
32632impl TypedStablePtr for TokenModPtr {
32633 type SyntaxNode = TokenMod;
32634 fn untyped(&self) -> SyntaxStablePtrId {
32635 self.0
32636 }
32637 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMod {
32638 TokenMod::from_syntax_node(db, self.0.lookup(db))
32639 }
32640}
32641impl From<TokenModPtr> for SyntaxStablePtrId {
32642 fn from(ptr: TokenModPtr) -> Self {
32643 ptr.untyped()
32644 }
32645}
32646#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32647pub struct TokenModGreen(pub GreenId);
32648impl TokenModGreen {
32649 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32650 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32651 }
32652}
32653impl TypedSyntaxNode for TokenMod {
32654 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMod);
32655 type StablePtr = TokenModPtr;
32656 type Green = TokenModGreen;
32657 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32658 TokenModGreen(
32659 Arc::new(GreenNode {
32660 kind: SyntaxKind::TokenMissing,
32661 details: GreenNodeDetails::Token("".into()),
32662 })
32663 .intern(db),
32664 )
32665 }
32666 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32667 match node.0.green.lookup_intern(db).details {
32668 GreenNodeDetails::Token(_) => Self { node },
32669 GreenNodeDetails::Node { .. } => {
32670 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMod)
32671 }
32672 }
32673 }
32674 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32675 match node.0.green.lookup_intern(db).details {
32676 GreenNodeDetails::Token(_) => Some(Self { node }),
32677 GreenNodeDetails::Node { .. } => None,
32678 }
32679 }
32680 fn as_syntax_node(&self) -> SyntaxNode {
32681 self.node.clone()
32682 }
32683 fn stable_ptr(&self) -> Self::StablePtr {
32684 TokenModPtr(self.node.0.stable_ptr)
32685 }
32686}
32687impl From<&TokenMod> for SyntaxStablePtrId {
32688 fn from(node: &TokenMod) -> Self {
32689 node.stable_ptr().untyped()
32690 }
32691}
32692#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32693pub struct TerminalMod {
32694 node: SyntaxNode,
32695 children: Arc<[SyntaxNode]>,
32696}
32697impl Terminal for TerminalMod {
32698 const KIND: SyntaxKind = SyntaxKind::TerminalMod;
32699 type TokenType = TokenMod;
32700 fn new_green(
32701 db: &dyn SyntaxGroup,
32702 leading_trivia: TriviaGreen,
32703 token: <<TerminalMod as Terminal>::TokenType as TypedSyntaxNode>::Green,
32704 trailing_trivia: TriviaGreen,
32705 ) -> Self::Green {
32706 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32707 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32708 TerminalModGreen(
32709 Arc::new(GreenNode {
32710 kind: SyntaxKind::TerminalMod,
32711 details: GreenNodeDetails::Node { children, width },
32712 })
32713 .intern(db),
32714 )
32715 }
32716 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32717 self.token(db).text(db)
32718 }
32719}
32720impl TerminalMod {
32721 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32722 Trivia::from_syntax_node(db, self.children[0].clone())
32723 }
32724 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMod {
32725 TokenMod::from_syntax_node(db, self.children[1].clone())
32726 }
32727 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32728 Trivia::from_syntax_node(db, self.children[2].clone())
32729 }
32730}
32731#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32732pub struct TerminalModPtr(pub SyntaxStablePtrId);
32733impl TerminalModPtr {}
32734impl TypedStablePtr for TerminalModPtr {
32735 type SyntaxNode = TerminalMod;
32736 fn untyped(&self) -> SyntaxStablePtrId {
32737 self.0
32738 }
32739 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMod {
32740 TerminalMod::from_syntax_node(db, self.0.lookup(db))
32741 }
32742}
32743impl From<TerminalModPtr> for SyntaxStablePtrId {
32744 fn from(ptr: TerminalModPtr) -> Self {
32745 ptr.untyped()
32746 }
32747}
32748#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32749pub struct TerminalModGreen(pub GreenId);
32750impl TypedSyntaxNode for TerminalMod {
32751 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMod);
32752 type StablePtr = TerminalModPtr;
32753 type Green = TerminalModGreen;
32754 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32755 TerminalModGreen(
32756 Arc::new(GreenNode {
32757 kind: SyntaxKind::TerminalMod,
32758 details: GreenNodeDetails::Node {
32759 children: vec![
32760 Trivia::missing(db).0,
32761 TokenMod::missing(db).0,
32762 Trivia::missing(db).0,
32763 ],
32764 width: TextWidth::default(),
32765 },
32766 })
32767 .intern(db),
32768 )
32769 }
32770 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32771 let kind = node.kind(db);
32772 assert_eq!(
32773 kind,
32774 SyntaxKind::TerminalMod,
32775 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32776 kind,
32777 SyntaxKind::TerminalMod
32778 );
32779 let children = db.get_children(node.clone());
32780 Self { node, children }
32781 }
32782 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32783 let kind = node.kind(db);
32784 if kind == SyntaxKind::TerminalMod { Some(Self::from_syntax_node(db, node)) } else { None }
32785 }
32786 fn as_syntax_node(&self) -> SyntaxNode {
32787 self.node.clone()
32788 }
32789 fn stable_ptr(&self) -> Self::StablePtr {
32790 TerminalModPtr(self.node.0.stable_ptr)
32791 }
32792}
32793impl From<&TerminalMod> for SyntaxStablePtrId {
32794 fn from(node: &TerminalMod) -> Self {
32795 node.stable_ptr().untyped()
32796 }
32797}
32798#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32799pub struct TokenModEq {
32800 node: SyntaxNode,
32801}
32802impl Token for TokenModEq {
32803 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32804 TokenModEqGreen(
32805 Arc::new(GreenNode {
32806 kind: SyntaxKind::TokenModEq,
32807 details: GreenNodeDetails::Token(text),
32808 })
32809 .intern(db),
32810 )
32811 }
32812 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32813 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32814 .clone()
32815 }
32816}
32817#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32818pub struct TokenModEqPtr(pub SyntaxStablePtrId);
32819impl TypedStablePtr for TokenModEqPtr {
32820 type SyntaxNode = TokenModEq;
32821 fn untyped(&self) -> SyntaxStablePtrId {
32822 self.0
32823 }
32824 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenModEq {
32825 TokenModEq::from_syntax_node(db, self.0.lookup(db))
32826 }
32827}
32828impl From<TokenModEqPtr> for SyntaxStablePtrId {
32829 fn from(ptr: TokenModEqPtr) -> Self {
32830 ptr.untyped()
32831 }
32832}
32833#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32834pub struct TokenModEqGreen(pub GreenId);
32835impl TokenModEqGreen {
32836 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32837 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32838 }
32839}
32840impl TypedSyntaxNode for TokenModEq {
32841 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenModEq);
32842 type StablePtr = TokenModEqPtr;
32843 type Green = TokenModEqGreen;
32844 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32845 TokenModEqGreen(
32846 Arc::new(GreenNode {
32847 kind: SyntaxKind::TokenMissing,
32848 details: GreenNodeDetails::Token("".into()),
32849 })
32850 .intern(db),
32851 )
32852 }
32853 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32854 match node.0.green.lookup_intern(db).details {
32855 GreenNodeDetails::Token(_) => Self { node },
32856 GreenNodeDetails::Node { .. } => {
32857 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenModEq)
32858 }
32859 }
32860 }
32861 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32862 match node.0.green.lookup_intern(db).details {
32863 GreenNodeDetails::Token(_) => Some(Self { node }),
32864 GreenNodeDetails::Node { .. } => None,
32865 }
32866 }
32867 fn as_syntax_node(&self) -> SyntaxNode {
32868 self.node.clone()
32869 }
32870 fn stable_ptr(&self) -> Self::StablePtr {
32871 TokenModEqPtr(self.node.0.stable_ptr)
32872 }
32873}
32874impl From<&TokenModEq> for SyntaxStablePtrId {
32875 fn from(node: &TokenModEq) -> Self {
32876 node.stable_ptr().untyped()
32877 }
32878}
32879#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32880pub struct TerminalModEq {
32881 node: SyntaxNode,
32882 children: Arc<[SyntaxNode]>,
32883}
32884impl Terminal for TerminalModEq {
32885 const KIND: SyntaxKind = SyntaxKind::TerminalModEq;
32886 type TokenType = TokenModEq;
32887 fn new_green(
32888 db: &dyn SyntaxGroup,
32889 leading_trivia: TriviaGreen,
32890 token: <<TerminalModEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
32891 trailing_trivia: TriviaGreen,
32892 ) -> Self::Green {
32893 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32894 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32895 TerminalModEqGreen(
32896 Arc::new(GreenNode {
32897 kind: SyntaxKind::TerminalModEq,
32898 details: GreenNodeDetails::Node { children, width },
32899 })
32900 .intern(db),
32901 )
32902 }
32903 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32904 self.token(db).text(db)
32905 }
32906}
32907impl TerminalModEq {
32908 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32909 Trivia::from_syntax_node(db, self.children[0].clone())
32910 }
32911 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenModEq {
32912 TokenModEq::from_syntax_node(db, self.children[1].clone())
32913 }
32914 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32915 Trivia::from_syntax_node(db, self.children[2].clone())
32916 }
32917}
32918#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32919pub struct TerminalModEqPtr(pub SyntaxStablePtrId);
32920impl TerminalModEqPtr {}
32921impl TypedStablePtr for TerminalModEqPtr {
32922 type SyntaxNode = TerminalModEq;
32923 fn untyped(&self) -> SyntaxStablePtrId {
32924 self.0
32925 }
32926 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalModEq {
32927 TerminalModEq::from_syntax_node(db, self.0.lookup(db))
32928 }
32929}
32930impl From<TerminalModEqPtr> for SyntaxStablePtrId {
32931 fn from(ptr: TerminalModEqPtr) -> Self {
32932 ptr.untyped()
32933 }
32934}
32935#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32936pub struct TerminalModEqGreen(pub GreenId);
32937impl TypedSyntaxNode for TerminalModEq {
32938 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalModEq);
32939 type StablePtr = TerminalModEqPtr;
32940 type Green = TerminalModEqGreen;
32941 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32942 TerminalModEqGreen(
32943 Arc::new(GreenNode {
32944 kind: SyntaxKind::TerminalModEq,
32945 details: GreenNodeDetails::Node {
32946 children: vec![
32947 Trivia::missing(db).0,
32948 TokenModEq::missing(db).0,
32949 Trivia::missing(db).0,
32950 ],
32951 width: TextWidth::default(),
32952 },
32953 })
32954 .intern(db),
32955 )
32956 }
32957 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32958 let kind = node.kind(db);
32959 assert_eq!(
32960 kind,
32961 SyntaxKind::TerminalModEq,
32962 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32963 kind,
32964 SyntaxKind::TerminalModEq
32965 );
32966 let children = db.get_children(node.clone());
32967 Self { node, children }
32968 }
32969 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
32970 let kind = node.kind(db);
32971 if kind == SyntaxKind::TerminalModEq {
32972 Some(Self::from_syntax_node(db, node))
32973 } else {
32974 None
32975 }
32976 }
32977 fn as_syntax_node(&self) -> SyntaxNode {
32978 self.node.clone()
32979 }
32980 fn stable_ptr(&self) -> Self::StablePtr {
32981 TerminalModEqPtr(self.node.0.stable_ptr)
32982 }
32983}
32984impl From<&TerminalModEq> for SyntaxStablePtrId {
32985 fn from(node: &TerminalModEq) -> Self {
32986 node.stable_ptr().untyped()
32987 }
32988}
32989#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32990pub struct TokenMul {
32991 node: SyntaxNode,
32992}
32993impl Token for TokenMul {
32994 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32995 TokenMulGreen(
32996 Arc::new(GreenNode {
32997 kind: SyntaxKind::TokenMul,
32998 details: GreenNodeDetails::Token(text),
32999 })
33000 .intern(db),
33001 )
33002 }
33003 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33004 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33005 .clone()
33006 }
33007}
33008#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33009pub struct TokenMulPtr(pub SyntaxStablePtrId);
33010impl TypedStablePtr for TokenMulPtr {
33011 type SyntaxNode = TokenMul;
33012 fn untyped(&self) -> SyntaxStablePtrId {
33013 self.0
33014 }
33015 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMul {
33016 TokenMul::from_syntax_node(db, self.0.lookup(db))
33017 }
33018}
33019impl From<TokenMulPtr> for SyntaxStablePtrId {
33020 fn from(ptr: TokenMulPtr) -> Self {
33021 ptr.untyped()
33022 }
33023}
33024#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33025pub struct TokenMulGreen(pub GreenId);
33026impl TokenMulGreen {
33027 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33028 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33029 }
33030}
33031impl TypedSyntaxNode for TokenMul {
33032 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMul);
33033 type StablePtr = TokenMulPtr;
33034 type Green = TokenMulGreen;
33035 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33036 TokenMulGreen(
33037 Arc::new(GreenNode {
33038 kind: SyntaxKind::TokenMissing,
33039 details: GreenNodeDetails::Token("".into()),
33040 })
33041 .intern(db),
33042 )
33043 }
33044 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33045 match node.0.green.lookup_intern(db).details {
33046 GreenNodeDetails::Token(_) => Self { node },
33047 GreenNodeDetails::Node { .. } => {
33048 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMul)
33049 }
33050 }
33051 }
33052 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33053 match node.0.green.lookup_intern(db).details {
33054 GreenNodeDetails::Token(_) => Some(Self { node }),
33055 GreenNodeDetails::Node { .. } => None,
33056 }
33057 }
33058 fn as_syntax_node(&self) -> SyntaxNode {
33059 self.node.clone()
33060 }
33061 fn stable_ptr(&self) -> Self::StablePtr {
33062 TokenMulPtr(self.node.0.stable_ptr)
33063 }
33064}
33065impl From<&TokenMul> for SyntaxStablePtrId {
33066 fn from(node: &TokenMul) -> Self {
33067 node.stable_ptr().untyped()
33068 }
33069}
33070#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33071pub struct TerminalMul {
33072 node: SyntaxNode,
33073 children: Arc<[SyntaxNode]>,
33074}
33075impl Terminal for TerminalMul {
33076 const KIND: SyntaxKind = SyntaxKind::TerminalMul;
33077 type TokenType = TokenMul;
33078 fn new_green(
33079 db: &dyn SyntaxGroup,
33080 leading_trivia: TriviaGreen,
33081 token: <<TerminalMul as Terminal>::TokenType as TypedSyntaxNode>::Green,
33082 trailing_trivia: TriviaGreen,
33083 ) -> Self::Green {
33084 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33085 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33086 TerminalMulGreen(
33087 Arc::new(GreenNode {
33088 kind: SyntaxKind::TerminalMul,
33089 details: GreenNodeDetails::Node { children, width },
33090 })
33091 .intern(db),
33092 )
33093 }
33094 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33095 self.token(db).text(db)
33096 }
33097}
33098impl TerminalMul {
33099 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33100 Trivia::from_syntax_node(db, self.children[0].clone())
33101 }
33102 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMul {
33103 TokenMul::from_syntax_node(db, self.children[1].clone())
33104 }
33105 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33106 Trivia::from_syntax_node(db, self.children[2].clone())
33107 }
33108}
33109#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33110pub struct TerminalMulPtr(pub SyntaxStablePtrId);
33111impl TerminalMulPtr {}
33112impl TypedStablePtr for TerminalMulPtr {
33113 type SyntaxNode = TerminalMul;
33114 fn untyped(&self) -> SyntaxStablePtrId {
33115 self.0
33116 }
33117 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMul {
33118 TerminalMul::from_syntax_node(db, self.0.lookup(db))
33119 }
33120}
33121impl From<TerminalMulPtr> for SyntaxStablePtrId {
33122 fn from(ptr: TerminalMulPtr) -> Self {
33123 ptr.untyped()
33124 }
33125}
33126#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33127pub struct TerminalMulGreen(pub GreenId);
33128impl TypedSyntaxNode for TerminalMul {
33129 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMul);
33130 type StablePtr = TerminalMulPtr;
33131 type Green = TerminalMulGreen;
33132 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33133 TerminalMulGreen(
33134 Arc::new(GreenNode {
33135 kind: SyntaxKind::TerminalMul,
33136 details: GreenNodeDetails::Node {
33137 children: vec![
33138 Trivia::missing(db).0,
33139 TokenMul::missing(db).0,
33140 Trivia::missing(db).0,
33141 ],
33142 width: TextWidth::default(),
33143 },
33144 })
33145 .intern(db),
33146 )
33147 }
33148 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33149 let kind = node.kind(db);
33150 assert_eq!(
33151 kind,
33152 SyntaxKind::TerminalMul,
33153 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33154 kind,
33155 SyntaxKind::TerminalMul
33156 );
33157 let children = db.get_children(node.clone());
33158 Self { node, children }
33159 }
33160 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33161 let kind = node.kind(db);
33162 if kind == SyntaxKind::TerminalMul { Some(Self::from_syntax_node(db, node)) } else { None }
33163 }
33164 fn as_syntax_node(&self) -> SyntaxNode {
33165 self.node.clone()
33166 }
33167 fn stable_ptr(&self) -> Self::StablePtr {
33168 TerminalMulPtr(self.node.0.stable_ptr)
33169 }
33170}
33171impl From<&TerminalMul> for SyntaxStablePtrId {
33172 fn from(node: &TerminalMul) -> Self {
33173 node.stable_ptr().untyped()
33174 }
33175}
33176#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33177pub struct TokenMulEq {
33178 node: SyntaxNode,
33179}
33180impl Token for TokenMulEq {
33181 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33182 TokenMulEqGreen(
33183 Arc::new(GreenNode {
33184 kind: SyntaxKind::TokenMulEq,
33185 details: GreenNodeDetails::Token(text),
33186 })
33187 .intern(db),
33188 )
33189 }
33190 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33191 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33192 .clone()
33193 }
33194}
33195#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33196pub struct TokenMulEqPtr(pub SyntaxStablePtrId);
33197impl TypedStablePtr for TokenMulEqPtr {
33198 type SyntaxNode = TokenMulEq;
33199 fn untyped(&self) -> SyntaxStablePtrId {
33200 self.0
33201 }
33202 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMulEq {
33203 TokenMulEq::from_syntax_node(db, self.0.lookup(db))
33204 }
33205}
33206impl From<TokenMulEqPtr> for SyntaxStablePtrId {
33207 fn from(ptr: TokenMulEqPtr) -> Self {
33208 ptr.untyped()
33209 }
33210}
33211#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33212pub struct TokenMulEqGreen(pub GreenId);
33213impl TokenMulEqGreen {
33214 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33215 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33216 }
33217}
33218impl TypedSyntaxNode for TokenMulEq {
33219 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMulEq);
33220 type StablePtr = TokenMulEqPtr;
33221 type Green = TokenMulEqGreen;
33222 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33223 TokenMulEqGreen(
33224 Arc::new(GreenNode {
33225 kind: SyntaxKind::TokenMissing,
33226 details: GreenNodeDetails::Token("".into()),
33227 })
33228 .intern(db),
33229 )
33230 }
33231 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33232 match node.0.green.lookup_intern(db).details {
33233 GreenNodeDetails::Token(_) => Self { node },
33234 GreenNodeDetails::Node { .. } => {
33235 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMulEq)
33236 }
33237 }
33238 }
33239 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33240 match node.0.green.lookup_intern(db).details {
33241 GreenNodeDetails::Token(_) => Some(Self { node }),
33242 GreenNodeDetails::Node { .. } => None,
33243 }
33244 }
33245 fn as_syntax_node(&self) -> SyntaxNode {
33246 self.node.clone()
33247 }
33248 fn stable_ptr(&self) -> Self::StablePtr {
33249 TokenMulEqPtr(self.node.0.stable_ptr)
33250 }
33251}
33252impl From<&TokenMulEq> for SyntaxStablePtrId {
33253 fn from(node: &TokenMulEq) -> Self {
33254 node.stable_ptr().untyped()
33255 }
33256}
33257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33258pub struct TerminalMulEq {
33259 node: SyntaxNode,
33260 children: Arc<[SyntaxNode]>,
33261}
33262impl Terminal for TerminalMulEq {
33263 const KIND: SyntaxKind = SyntaxKind::TerminalMulEq;
33264 type TokenType = TokenMulEq;
33265 fn new_green(
33266 db: &dyn SyntaxGroup,
33267 leading_trivia: TriviaGreen,
33268 token: <<TerminalMulEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
33269 trailing_trivia: TriviaGreen,
33270 ) -> Self::Green {
33271 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33272 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33273 TerminalMulEqGreen(
33274 Arc::new(GreenNode {
33275 kind: SyntaxKind::TerminalMulEq,
33276 details: GreenNodeDetails::Node { children, width },
33277 })
33278 .intern(db),
33279 )
33280 }
33281 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33282 self.token(db).text(db)
33283 }
33284}
33285impl TerminalMulEq {
33286 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33287 Trivia::from_syntax_node(db, self.children[0].clone())
33288 }
33289 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMulEq {
33290 TokenMulEq::from_syntax_node(db, self.children[1].clone())
33291 }
33292 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33293 Trivia::from_syntax_node(db, self.children[2].clone())
33294 }
33295}
33296#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33297pub struct TerminalMulEqPtr(pub SyntaxStablePtrId);
33298impl TerminalMulEqPtr {}
33299impl TypedStablePtr for TerminalMulEqPtr {
33300 type SyntaxNode = TerminalMulEq;
33301 fn untyped(&self) -> SyntaxStablePtrId {
33302 self.0
33303 }
33304 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMulEq {
33305 TerminalMulEq::from_syntax_node(db, self.0.lookup(db))
33306 }
33307}
33308impl From<TerminalMulEqPtr> for SyntaxStablePtrId {
33309 fn from(ptr: TerminalMulEqPtr) -> Self {
33310 ptr.untyped()
33311 }
33312}
33313#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33314pub struct TerminalMulEqGreen(pub GreenId);
33315impl TypedSyntaxNode for TerminalMulEq {
33316 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMulEq);
33317 type StablePtr = TerminalMulEqPtr;
33318 type Green = TerminalMulEqGreen;
33319 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33320 TerminalMulEqGreen(
33321 Arc::new(GreenNode {
33322 kind: SyntaxKind::TerminalMulEq,
33323 details: GreenNodeDetails::Node {
33324 children: vec![
33325 Trivia::missing(db).0,
33326 TokenMulEq::missing(db).0,
33327 Trivia::missing(db).0,
33328 ],
33329 width: TextWidth::default(),
33330 },
33331 })
33332 .intern(db),
33333 )
33334 }
33335 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33336 let kind = node.kind(db);
33337 assert_eq!(
33338 kind,
33339 SyntaxKind::TerminalMulEq,
33340 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33341 kind,
33342 SyntaxKind::TerminalMulEq
33343 );
33344 let children = db.get_children(node.clone());
33345 Self { node, children }
33346 }
33347 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33348 let kind = node.kind(db);
33349 if kind == SyntaxKind::TerminalMulEq {
33350 Some(Self::from_syntax_node(db, node))
33351 } else {
33352 None
33353 }
33354 }
33355 fn as_syntax_node(&self) -> SyntaxNode {
33356 self.node.clone()
33357 }
33358 fn stable_ptr(&self) -> Self::StablePtr {
33359 TerminalMulEqPtr(self.node.0.stable_ptr)
33360 }
33361}
33362impl From<&TerminalMulEq> for SyntaxStablePtrId {
33363 fn from(node: &TerminalMulEq) -> Self {
33364 node.stable_ptr().untyped()
33365 }
33366}
33367#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33368pub struct TokenNeq {
33369 node: SyntaxNode,
33370}
33371impl Token for TokenNeq {
33372 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33373 TokenNeqGreen(
33374 Arc::new(GreenNode {
33375 kind: SyntaxKind::TokenNeq,
33376 details: GreenNodeDetails::Token(text),
33377 })
33378 .intern(db),
33379 )
33380 }
33381 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33382 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33383 .clone()
33384 }
33385}
33386#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33387pub struct TokenNeqPtr(pub SyntaxStablePtrId);
33388impl TypedStablePtr for TokenNeqPtr {
33389 type SyntaxNode = TokenNeq;
33390 fn untyped(&self) -> SyntaxStablePtrId {
33391 self.0
33392 }
33393 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNeq {
33394 TokenNeq::from_syntax_node(db, self.0.lookup(db))
33395 }
33396}
33397impl From<TokenNeqPtr> for SyntaxStablePtrId {
33398 fn from(ptr: TokenNeqPtr) -> Self {
33399 ptr.untyped()
33400 }
33401}
33402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33403pub struct TokenNeqGreen(pub GreenId);
33404impl TokenNeqGreen {
33405 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33406 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33407 }
33408}
33409impl TypedSyntaxNode for TokenNeq {
33410 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNeq);
33411 type StablePtr = TokenNeqPtr;
33412 type Green = TokenNeqGreen;
33413 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33414 TokenNeqGreen(
33415 Arc::new(GreenNode {
33416 kind: SyntaxKind::TokenMissing,
33417 details: GreenNodeDetails::Token("".into()),
33418 })
33419 .intern(db),
33420 )
33421 }
33422 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33423 match node.0.green.lookup_intern(db).details {
33424 GreenNodeDetails::Token(_) => Self { node },
33425 GreenNodeDetails::Node { .. } => {
33426 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNeq)
33427 }
33428 }
33429 }
33430 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33431 match node.0.green.lookup_intern(db).details {
33432 GreenNodeDetails::Token(_) => Some(Self { node }),
33433 GreenNodeDetails::Node { .. } => None,
33434 }
33435 }
33436 fn as_syntax_node(&self) -> SyntaxNode {
33437 self.node.clone()
33438 }
33439 fn stable_ptr(&self) -> Self::StablePtr {
33440 TokenNeqPtr(self.node.0.stable_ptr)
33441 }
33442}
33443impl From<&TokenNeq> for SyntaxStablePtrId {
33444 fn from(node: &TokenNeq) -> Self {
33445 node.stable_ptr().untyped()
33446 }
33447}
33448#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33449pub struct TerminalNeq {
33450 node: SyntaxNode,
33451 children: Arc<[SyntaxNode]>,
33452}
33453impl Terminal for TerminalNeq {
33454 const KIND: SyntaxKind = SyntaxKind::TerminalNeq;
33455 type TokenType = TokenNeq;
33456 fn new_green(
33457 db: &dyn SyntaxGroup,
33458 leading_trivia: TriviaGreen,
33459 token: <<TerminalNeq as Terminal>::TokenType as TypedSyntaxNode>::Green,
33460 trailing_trivia: TriviaGreen,
33461 ) -> Self::Green {
33462 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33463 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33464 TerminalNeqGreen(
33465 Arc::new(GreenNode {
33466 kind: SyntaxKind::TerminalNeq,
33467 details: GreenNodeDetails::Node { children, width },
33468 })
33469 .intern(db),
33470 )
33471 }
33472 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33473 self.token(db).text(db)
33474 }
33475}
33476impl TerminalNeq {
33477 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33478 Trivia::from_syntax_node(db, self.children[0].clone())
33479 }
33480 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNeq {
33481 TokenNeq::from_syntax_node(db, self.children[1].clone())
33482 }
33483 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33484 Trivia::from_syntax_node(db, self.children[2].clone())
33485 }
33486}
33487#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33488pub struct TerminalNeqPtr(pub SyntaxStablePtrId);
33489impl TerminalNeqPtr {}
33490impl TypedStablePtr for TerminalNeqPtr {
33491 type SyntaxNode = TerminalNeq;
33492 fn untyped(&self) -> SyntaxStablePtrId {
33493 self.0
33494 }
33495 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNeq {
33496 TerminalNeq::from_syntax_node(db, self.0.lookup(db))
33497 }
33498}
33499impl From<TerminalNeqPtr> for SyntaxStablePtrId {
33500 fn from(ptr: TerminalNeqPtr) -> Self {
33501 ptr.untyped()
33502 }
33503}
33504#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33505pub struct TerminalNeqGreen(pub GreenId);
33506impl TypedSyntaxNode for TerminalNeq {
33507 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNeq);
33508 type StablePtr = TerminalNeqPtr;
33509 type Green = TerminalNeqGreen;
33510 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33511 TerminalNeqGreen(
33512 Arc::new(GreenNode {
33513 kind: SyntaxKind::TerminalNeq,
33514 details: GreenNodeDetails::Node {
33515 children: vec![
33516 Trivia::missing(db).0,
33517 TokenNeq::missing(db).0,
33518 Trivia::missing(db).0,
33519 ],
33520 width: TextWidth::default(),
33521 },
33522 })
33523 .intern(db),
33524 )
33525 }
33526 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33527 let kind = node.kind(db);
33528 assert_eq!(
33529 kind,
33530 SyntaxKind::TerminalNeq,
33531 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33532 kind,
33533 SyntaxKind::TerminalNeq
33534 );
33535 let children = db.get_children(node.clone());
33536 Self { node, children }
33537 }
33538 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33539 let kind = node.kind(db);
33540 if kind == SyntaxKind::TerminalNeq { Some(Self::from_syntax_node(db, node)) } else { None }
33541 }
33542 fn as_syntax_node(&self) -> SyntaxNode {
33543 self.node.clone()
33544 }
33545 fn stable_ptr(&self) -> Self::StablePtr {
33546 TerminalNeqPtr(self.node.0.stable_ptr)
33547 }
33548}
33549impl From<&TerminalNeq> for SyntaxStablePtrId {
33550 fn from(node: &TerminalNeq) -> Self {
33551 node.stable_ptr().untyped()
33552 }
33553}
33554#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33555pub struct TokenNot {
33556 node: SyntaxNode,
33557}
33558impl Token for TokenNot {
33559 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33560 TokenNotGreen(
33561 Arc::new(GreenNode {
33562 kind: SyntaxKind::TokenNot,
33563 details: GreenNodeDetails::Token(text),
33564 })
33565 .intern(db),
33566 )
33567 }
33568 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33569 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33570 .clone()
33571 }
33572}
33573#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33574pub struct TokenNotPtr(pub SyntaxStablePtrId);
33575impl TypedStablePtr for TokenNotPtr {
33576 type SyntaxNode = TokenNot;
33577 fn untyped(&self) -> SyntaxStablePtrId {
33578 self.0
33579 }
33580 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNot {
33581 TokenNot::from_syntax_node(db, self.0.lookup(db))
33582 }
33583}
33584impl From<TokenNotPtr> for SyntaxStablePtrId {
33585 fn from(ptr: TokenNotPtr) -> Self {
33586 ptr.untyped()
33587 }
33588}
33589#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33590pub struct TokenNotGreen(pub GreenId);
33591impl TokenNotGreen {
33592 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33593 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33594 }
33595}
33596impl TypedSyntaxNode for TokenNot {
33597 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNot);
33598 type StablePtr = TokenNotPtr;
33599 type Green = TokenNotGreen;
33600 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33601 TokenNotGreen(
33602 Arc::new(GreenNode {
33603 kind: SyntaxKind::TokenMissing,
33604 details: GreenNodeDetails::Token("".into()),
33605 })
33606 .intern(db),
33607 )
33608 }
33609 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33610 match node.0.green.lookup_intern(db).details {
33611 GreenNodeDetails::Token(_) => Self { node },
33612 GreenNodeDetails::Node { .. } => {
33613 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNot)
33614 }
33615 }
33616 }
33617 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33618 match node.0.green.lookup_intern(db).details {
33619 GreenNodeDetails::Token(_) => Some(Self { node }),
33620 GreenNodeDetails::Node { .. } => None,
33621 }
33622 }
33623 fn as_syntax_node(&self) -> SyntaxNode {
33624 self.node.clone()
33625 }
33626 fn stable_ptr(&self) -> Self::StablePtr {
33627 TokenNotPtr(self.node.0.stable_ptr)
33628 }
33629}
33630impl From<&TokenNot> for SyntaxStablePtrId {
33631 fn from(node: &TokenNot) -> Self {
33632 node.stable_ptr().untyped()
33633 }
33634}
33635#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33636pub struct TerminalNot {
33637 node: SyntaxNode,
33638 children: Arc<[SyntaxNode]>,
33639}
33640impl Terminal for TerminalNot {
33641 const KIND: SyntaxKind = SyntaxKind::TerminalNot;
33642 type TokenType = TokenNot;
33643 fn new_green(
33644 db: &dyn SyntaxGroup,
33645 leading_trivia: TriviaGreen,
33646 token: <<TerminalNot as Terminal>::TokenType as TypedSyntaxNode>::Green,
33647 trailing_trivia: TriviaGreen,
33648 ) -> Self::Green {
33649 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33650 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33651 TerminalNotGreen(
33652 Arc::new(GreenNode {
33653 kind: SyntaxKind::TerminalNot,
33654 details: GreenNodeDetails::Node { children, width },
33655 })
33656 .intern(db),
33657 )
33658 }
33659 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33660 self.token(db).text(db)
33661 }
33662}
33663impl TerminalNot {
33664 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33665 Trivia::from_syntax_node(db, self.children[0].clone())
33666 }
33667 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNot {
33668 TokenNot::from_syntax_node(db, self.children[1].clone())
33669 }
33670 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33671 Trivia::from_syntax_node(db, self.children[2].clone())
33672 }
33673}
33674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33675pub struct TerminalNotPtr(pub SyntaxStablePtrId);
33676impl TerminalNotPtr {}
33677impl TypedStablePtr for TerminalNotPtr {
33678 type SyntaxNode = TerminalNot;
33679 fn untyped(&self) -> SyntaxStablePtrId {
33680 self.0
33681 }
33682 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNot {
33683 TerminalNot::from_syntax_node(db, self.0.lookup(db))
33684 }
33685}
33686impl From<TerminalNotPtr> for SyntaxStablePtrId {
33687 fn from(ptr: TerminalNotPtr) -> Self {
33688 ptr.untyped()
33689 }
33690}
33691#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33692pub struct TerminalNotGreen(pub GreenId);
33693impl TypedSyntaxNode for TerminalNot {
33694 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNot);
33695 type StablePtr = TerminalNotPtr;
33696 type Green = TerminalNotGreen;
33697 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33698 TerminalNotGreen(
33699 Arc::new(GreenNode {
33700 kind: SyntaxKind::TerminalNot,
33701 details: GreenNodeDetails::Node {
33702 children: vec![
33703 Trivia::missing(db).0,
33704 TokenNot::missing(db).0,
33705 Trivia::missing(db).0,
33706 ],
33707 width: TextWidth::default(),
33708 },
33709 })
33710 .intern(db),
33711 )
33712 }
33713 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33714 let kind = node.kind(db);
33715 assert_eq!(
33716 kind,
33717 SyntaxKind::TerminalNot,
33718 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33719 kind,
33720 SyntaxKind::TerminalNot
33721 );
33722 let children = db.get_children(node.clone());
33723 Self { node, children }
33724 }
33725 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33726 let kind = node.kind(db);
33727 if kind == SyntaxKind::TerminalNot { Some(Self::from_syntax_node(db, node)) } else { None }
33728 }
33729 fn as_syntax_node(&self) -> SyntaxNode {
33730 self.node.clone()
33731 }
33732 fn stable_ptr(&self) -> Self::StablePtr {
33733 TerminalNotPtr(self.node.0.stable_ptr)
33734 }
33735}
33736impl From<&TerminalNot> for SyntaxStablePtrId {
33737 fn from(node: &TerminalNot) -> Self {
33738 node.stable_ptr().untyped()
33739 }
33740}
33741#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33742pub struct TokenBitNot {
33743 node: SyntaxNode,
33744}
33745impl Token for TokenBitNot {
33746 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33747 TokenBitNotGreen(
33748 Arc::new(GreenNode {
33749 kind: SyntaxKind::TokenBitNot,
33750 details: GreenNodeDetails::Token(text),
33751 })
33752 .intern(db),
33753 )
33754 }
33755 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33756 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33757 .clone()
33758 }
33759}
33760#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33761pub struct TokenBitNotPtr(pub SyntaxStablePtrId);
33762impl TypedStablePtr for TokenBitNotPtr {
33763 type SyntaxNode = TokenBitNot;
33764 fn untyped(&self) -> SyntaxStablePtrId {
33765 self.0
33766 }
33767 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBitNot {
33768 TokenBitNot::from_syntax_node(db, self.0.lookup(db))
33769 }
33770}
33771impl From<TokenBitNotPtr> for SyntaxStablePtrId {
33772 fn from(ptr: TokenBitNotPtr) -> Self {
33773 ptr.untyped()
33774 }
33775}
33776#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33777pub struct TokenBitNotGreen(pub GreenId);
33778impl TokenBitNotGreen {
33779 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33780 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33781 }
33782}
33783impl TypedSyntaxNode for TokenBitNot {
33784 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBitNot);
33785 type StablePtr = TokenBitNotPtr;
33786 type Green = TokenBitNotGreen;
33787 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33788 TokenBitNotGreen(
33789 Arc::new(GreenNode {
33790 kind: SyntaxKind::TokenMissing,
33791 details: GreenNodeDetails::Token("".into()),
33792 })
33793 .intern(db),
33794 )
33795 }
33796 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33797 match node.0.green.lookup_intern(db).details {
33798 GreenNodeDetails::Token(_) => Self { node },
33799 GreenNodeDetails::Node { .. } => {
33800 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenBitNot)
33801 }
33802 }
33803 }
33804 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33805 match node.0.green.lookup_intern(db).details {
33806 GreenNodeDetails::Token(_) => Some(Self { node }),
33807 GreenNodeDetails::Node { .. } => None,
33808 }
33809 }
33810 fn as_syntax_node(&self) -> SyntaxNode {
33811 self.node.clone()
33812 }
33813 fn stable_ptr(&self) -> Self::StablePtr {
33814 TokenBitNotPtr(self.node.0.stable_ptr)
33815 }
33816}
33817impl From<&TokenBitNot> for SyntaxStablePtrId {
33818 fn from(node: &TokenBitNot) -> Self {
33819 node.stable_ptr().untyped()
33820 }
33821}
33822#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33823pub struct TerminalBitNot {
33824 node: SyntaxNode,
33825 children: Arc<[SyntaxNode]>,
33826}
33827impl Terminal for TerminalBitNot {
33828 const KIND: SyntaxKind = SyntaxKind::TerminalBitNot;
33829 type TokenType = TokenBitNot;
33830 fn new_green(
33831 db: &dyn SyntaxGroup,
33832 leading_trivia: TriviaGreen,
33833 token: <<TerminalBitNot as Terminal>::TokenType as TypedSyntaxNode>::Green,
33834 trailing_trivia: TriviaGreen,
33835 ) -> Self::Green {
33836 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33837 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33838 TerminalBitNotGreen(
33839 Arc::new(GreenNode {
33840 kind: SyntaxKind::TerminalBitNot,
33841 details: GreenNodeDetails::Node { children, width },
33842 })
33843 .intern(db),
33844 )
33845 }
33846 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33847 self.token(db).text(db)
33848 }
33849}
33850impl TerminalBitNot {
33851 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33852 Trivia::from_syntax_node(db, self.children[0].clone())
33853 }
33854 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBitNot {
33855 TokenBitNot::from_syntax_node(db, self.children[1].clone())
33856 }
33857 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33858 Trivia::from_syntax_node(db, self.children[2].clone())
33859 }
33860}
33861#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33862pub struct TerminalBitNotPtr(pub SyntaxStablePtrId);
33863impl TerminalBitNotPtr {}
33864impl TypedStablePtr for TerminalBitNotPtr {
33865 type SyntaxNode = TerminalBitNot;
33866 fn untyped(&self) -> SyntaxStablePtrId {
33867 self.0
33868 }
33869 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBitNot {
33870 TerminalBitNot::from_syntax_node(db, self.0.lookup(db))
33871 }
33872}
33873impl From<TerminalBitNotPtr> for SyntaxStablePtrId {
33874 fn from(ptr: TerminalBitNotPtr) -> Self {
33875 ptr.untyped()
33876 }
33877}
33878#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33879pub struct TerminalBitNotGreen(pub GreenId);
33880impl TypedSyntaxNode for TerminalBitNot {
33881 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBitNot);
33882 type StablePtr = TerminalBitNotPtr;
33883 type Green = TerminalBitNotGreen;
33884 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33885 TerminalBitNotGreen(
33886 Arc::new(GreenNode {
33887 kind: SyntaxKind::TerminalBitNot,
33888 details: GreenNodeDetails::Node {
33889 children: vec![
33890 Trivia::missing(db).0,
33891 TokenBitNot::missing(db).0,
33892 Trivia::missing(db).0,
33893 ],
33894 width: TextWidth::default(),
33895 },
33896 })
33897 .intern(db),
33898 )
33899 }
33900 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33901 let kind = node.kind(db);
33902 assert_eq!(
33903 kind,
33904 SyntaxKind::TerminalBitNot,
33905 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33906 kind,
33907 SyntaxKind::TerminalBitNot
33908 );
33909 let children = db.get_children(node.clone());
33910 Self { node, children }
33911 }
33912 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33913 let kind = node.kind(db);
33914 if kind == SyntaxKind::TerminalBitNot {
33915 Some(Self::from_syntax_node(db, node))
33916 } else {
33917 None
33918 }
33919 }
33920 fn as_syntax_node(&self) -> SyntaxNode {
33921 self.node.clone()
33922 }
33923 fn stable_ptr(&self) -> Self::StablePtr {
33924 TerminalBitNotPtr(self.node.0.stable_ptr)
33925 }
33926}
33927impl From<&TerminalBitNot> for SyntaxStablePtrId {
33928 fn from(node: &TerminalBitNot) -> Self {
33929 node.stable_ptr().untyped()
33930 }
33931}
33932#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33933pub struct TokenOr {
33934 node: SyntaxNode,
33935}
33936impl Token for TokenOr {
33937 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33938 TokenOrGreen(
33939 Arc::new(GreenNode {
33940 kind: SyntaxKind::TokenOr,
33941 details: GreenNodeDetails::Token(text),
33942 })
33943 .intern(db),
33944 )
33945 }
33946 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33947 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33948 .clone()
33949 }
33950}
33951#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33952pub struct TokenOrPtr(pub SyntaxStablePtrId);
33953impl TypedStablePtr for TokenOrPtr {
33954 type SyntaxNode = TokenOr;
33955 fn untyped(&self) -> SyntaxStablePtrId {
33956 self.0
33957 }
33958 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOr {
33959 TokenOr::from_syntax_node(db, self.0.lookup(db))
33960 }
33961}
33962impl From<TokenOrPtr> for SyntaxStablePtrId {
33963 fn from(ptr: TokenOrPtr) -> Self {
33964 ptr.untyped()
33965 }
33966}
33967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33968pub struct TokenOrGreen(pub GreenId);
33969impl TokenOrGreen {
33970 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33971 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33972 }
33973}
33974impl TypedSyntaxNode for TokenOr {
33975 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOr);
33976 type StablePtr = TokenOrPtr;
33977 type Green = TokenOrGreen;
33978 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33979 TokenOrGreen(
33980 Arc::new(GreenNode {
33981 kind: SyntaxKind::TokenMissing,
33982 details: GreenNodeDetails::Token("".into()),
33983 })
33984 .intern(db),
33985 )
33986 }
33987 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33988 match node.0.green.lookup_intern(db).details {
33989 GreenNodeDetails::Token(_) => Self { node },
33990 GreenNodeDetails::Node { .. } => {
33991 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOr)
33992 }
33993 }
33994 }
33995 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
33996 match node.0.green.lookup_intern(db).details {
33997 GreenNodeDetails::Token(_) => Some(Self { node }),
33998 GreenNodeDetails::Node { .. } => None,
33999 }
34000 }
34001 fn as_syntax_node(&self) -> SyntaxNode {
34002 self.node.clone()
34003 }
34004 fn stable_ptr(&self) -> Self::StablePtr {
34005 TokenOrPtr(self.node.0.stable_ptr)
34006 }
34007}
34008impl From<&TokenOr> for SyntaxStablePtrId {
34009 fn from(node: &TokenOr) -> Self {
34010 node.stable_ptr().untyped()
34011 }
34012}
34013#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34014pub struct TerminalOr {
34015 node: SyntaxNode,
34016 children: Arc<[SyntaxNode]>,
34017}
34018impl Terminal for TerminalOr {
34019 const KIND: SyntaxKind = SyntaxKind::TerminalOr;
34020 type TokenType = TokenOr;
34021 fn new_green(
34022 db: &dyn SyntaxGroup,
34023 leading_trivia: TriviaGreen,
34024 token: <<TerminalOr as Terminal>::TokenType as TypedSyntaxNode>::Green,
34025 trailing_trivia: TriviaGreen,
34026 ) -> Self::Green {
34027 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34028 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34029 TerminalOrGreen(
34030 Arc::new(GreenNode {
34031 kind: SyntaxKind::TerminalOr,
34032 details: GreenNodeDetails::Node { children, width },
34033 })
34034 .intern(db),
34035 )
34036 }
34037 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34038 self.token(db).text(db)
34039 }
34040}
34041impl TerminalOr {
34042 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34043 Trivia::from_syntax_node(db, self.children[0].clone())
34044 }
34045 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOr {
34046 TokenOr::from_syntax_node(db, self.children[1].clone())
34047 }
34048 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34049 Trivia::from_syntax_node(db, self.children[2].clone())
34050 }
34051}
34052#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34053pub struct TerminalOrPtr(pub SyntaxStablePtrId);
34054impl TerminalOrPtr {}
34055impl TypedStablePtr for TerminalOrPtr {
34056 type SyntaxNode = TerminalOr;
34057 fn untyped(&self) -> SyntaxStablePtrId {
34058 self.0
34059 }
34060 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOr {
34061 TerminalOr::from_syntax_node(db, self.0.lookup(db))
34062 }
34063}
34064impl From<TerminalOrPtr> for SyntaxStablePtrId {
34065 fn from(ptr: TerminalOrPtr) -> Self {
34066 ptr.untyped()
34067 }
34068}
34069#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34070pub struct TerminalOrGreen(pub GreenId);
34071impl TypedSyntaxNode for TerminalOr {
34072 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOr);
34073 type StablePtr = TerminalOrPtr;
34074 type Green = TerminalOrGreen;
34075 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34076 TerminalOrGreen(
34077 Arc::new(GreenNode {
34078 kind: SyntaxKind::TerminalOr,
34079 details: GreenNodeDetails::Node {
34080 children: vec![
34081 Trivia::missing(db).0,
34082 TokenOr::missing(db).0,
34083 Trivia::missing(db).0,
34084 ],
34085 width: TextWidth::default(),
34086 },
34087 })
34088 .intern(db),
34089 )
34090 }
34091 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34092 let kind = node.kind(db);
34093 assert_eq!(
34094 kind,
34095 SyntaxKind::TerminalOr,
34096 "Unexpected SyntaxKind {:?}. Expected {:?}.",
34097 kind,
34098 SyntaxKind::TerminalOr
34099 );
34100 let children = db.get_children(node.clone());
34101 Self { node, children }
34102 }
34103 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34104 let kind = node.kind(db);
34105 if kind == SyntaxKind::TerminalOr { Some(Self::from_syntax_node(db, node)) } else { None }
34106 }
34107 fn as_syntax_node(&self) -> SyntaxNode {
34108 self.node.clone()
34109 }
34110 fn stable_ptr(&self) -> Self::StablePtr {
34111 TerminalOrPtr(self.node.0.stable_ptr)
34112 }
34113}
34114impl From<&TerminalOr> for SyntaxStablePtrId {
34115 fn from(node: &TerminalOr) -> Self {
34116 node.stable_ptr().untyped()
34117 }
34118}
34119#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34120pub struct TokenOrOr {
34121 node: SyntaxNode,
34122}
34123impl Token for TokenOrOr {
34124 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34125 TokenOrOrGreen(
34126 Arc::new(GreenNode {
34127 kind: SyntaxKind::TokenOrOr,
34128 details: GreenNodeDetails::Token(text),
34129 })
34130 .intern(db),
34131 )
34132 }
34133 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34134 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34135 .clone()
34136 }
34137}
34138#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34139pub struct TokenOrOrPtr(pub SyntaxStablePtrId);
34140impl TypedStablePtr for TokenOrOrPtr {
34141 type SyntaxNode = TokenOrOr;
34142 fn untyped(&self) -> SyntaxStablePtrId {
34143 self.0
34144 }
34145 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOrOr {
34146 TokenOrOr::from_syntax_node(db, self.0.lookup(db))
34147 }
34148}
34149impl From<TokenOrOrPtr> for SyntaxStablePtrId {
34150 fn from(ptr: TokenOrOrPtr) -> Self {
34151 ptr.untyped()
34152 }
34153}
34154#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34155pub struct TokenOrOrGreen(pub GreenId);
34156impl TokenOrOrGreen {
34157 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34158 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34159 }
34160}
34161impl TypedSyntaxNode for TokenOrOr {
34162 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOrOr);
34163 type StablePtr = TokenOrOrPtr;
34164 type Green = TokenOrOrGreen;
34165 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34166 TokenOrOrGreen(
34167 Arc::new(GreenNode {
34168 kind: SyntaxKind::TokenMissing,
34169 details: GreenNodeDetails::Token("".into()),
34170 })
34171 .intern(db),
34172 )
34173 }
34174 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34175 match node.0.green.lookup_intern(db).details {
34176 GreenNodeDetails::Token(_) => Self { node },
34177 GreenNodeDetails::Node { .. } => {
34178 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOrOr)
34179 }
34180 }
34181 }
34182 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34183 match node.0.green.lookup_intern(db).details {
34184 GreenNodeDetails::Token(_) => Some(Self { node }),
34185 GreenNodeDetails::Node { .. } => None,
34186 }
34187 }
34188 fn as_syntax_node(&self) -> SyntaxNode {
34189 self.node.clone()
34190 }
34191 fn stable_ptr(&self) -> Self::StablePtr {
34192 TokenOrOrPtr(self.node.0.stable_ptr)
34193 }
34194}
34195impl From<&TokenOrOr> for SyntaxStablePtrId {
34196 fn from(node: &TokenOrOr) -> Self {
34197 node.stable_ptr().untyped()
34198 }
34199}
34200#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34201pub struct TerminalOrOr {
34202 node: SyntaxNode,
34203 children: Arc<[SyntaxNode]>,
34204}
34205impl Terminal for TerminalOrOr {
34206 const KIND: SyntaxKind = SyntaxKind::TerminalOrOr;
34207 type TokenType = TokenOrOr;
34208 fn new_green(
34209 db: &dyn SyntaxGroup,
34210 leading_trivia: TriviaGreen,
34211 token: <<TerminalOrOr as Terminal>::TokenType as TypedSyntaxNode>::Green,
34212 trailing_trivia: TriviaGreen,
34213 ) -> Self::Green {
34214 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34215 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34216 TerminalOrOrGreen(
34217 Arc::new(GreenNode {
34218 kind: SyntaxKind::TerminalOrOr,
34219 details: GreenNodeDetails::Node { children, width },
34220 })
34221 .intern(db),
34222 )
34223 }
34224 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34225 self.token(db).text(db)
34226 }
34227}
34228impl TerminalOrOr {
34229 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34230 Trivia::from_syntax_node(db, self.children[0].clone())
34231 }
34232 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOrOr {
34233 TokenOrOr::from_syntax_node(db, self.children[1].clone())
34234 }
34235 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34236 Trivia::from_syntax_node(db, self.children[2].clone())
34237 }
34238}
34239#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34240pub struct TerminalOrOrPtr(pub SyntaxStablePtrId);
34241impl TerminalOrOrPtr {}
34242impl TypedStablePtr for TerminalOrOrPtr {
34243 type SyntaxNode = TerminalOrOr;
34244 fn untyped(&self) -> SyntaxStablePtrId {
34245 self.0
34246 }
34247 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOrOr {
34248 TerminalOrOr::from_syntax_node(db, self.0.lookup(db))
34249 }
34250}
34251impl From<TerminalOrOrPtr> for SyntaxStablePtrId {
34252 fn from(ptr: TerminalOrOrPtr) -> Self {
34253 ptr.untyped()
34254 }
34255}
34256#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34257pub struct TerminalOrOrGreen(pub GreenId);
34258impl TypedSyntaxNode for TerminalOrOr {
34259 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOrOr);
34260 type StablePtr = TerminalOrOrPtr;
34261 type Green = TerminalOrOrGreen;
34262 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34263 TerminalOrOrGreen(
34264 Arc::new(GreenNode {
34265 kind: SyntaxKind::TerminalOrOr,
34266 details: GreenNodeDetails::Node {
34267 children: vec![
34268 Trivia::missing(db).0,
34269 TokenOrOr::missing(db).0,
34270 Trivia::missing(db).0,
34271 ],
34272 width: TextWidth::default(),
34273 },
34274 })
34275 .intern(db),
34276 )
34277 }
34278 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34279 let kind = node.kind(db);
34280 assert_eq!(
34281 kind,
34282 SyntaxKind::TerminalOrOr,
34283 "Unexpected SyntaxKind {:?}. Expected {:?}.",
34284 kind,
34285 SyntaxKind::TerminalOrOr
34286 );
34287 let children = db.get_children(node.clone());
34288 Self { node, children }
34289 }
34290 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34291 let kind = node.kind(db);
34292 if kind == SyntaxKind::TerminalOrOr { Some(Self::from_syntax_node(db, node)) } else { None }
34293 }
34294 fn as_syntax_node(&self) -> SyntaxNode {
34295 self.node.clone()
34296 }
34297 fn stable_ptr(&self) -> Self::StablePtr {
34298 TerminalOrOrPtr(self.node.0.stable_ptr)
34299 }
34300}
34301impl From<&TerminalOrOr> for SyntaxStablePtrId {
34302 fn from(node: &TerminalOrOr) -> Self {
34303 node.stable_ptr().untyped()
34304 }
34305}
34306#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34307pub struct TokenPlus {
34308 node: SyntaxNode,
34309}
34310impl Token for TokenPlus {
34311 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34312 TokenPlusGreen(
34313 Arc::new(GreenNode {
34314 kind: SyntaxKind::TokenPlus,
34315 details: GreenNodeDetails::Token(text),
34316 })
34317 .intern(db),
34318 )
34319 }
34320 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34321 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34322 .clone()
34323 }
34324}
34325#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34326pub struct TokenPlusPtr(pub SyntaxStablePtrId);
34327impl TypedStablePtr for TokenPlusPtr {
34328 type SyntaxNode = TokenPlus;
34329 fn untyped(&self) -> SyntaxStablePtrId {
34330 self.0
34331 }
34332 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPlus {
34333 TokenPlus::from_syntax_node(db, self.0.lookup(db))
34334 }
34335}
34336impl From<TokenPlusPtr> for SyntaxStablePtrId {
34337 fn from(ptr: TokenPlusPtr) -> Self {
34338 ptr.untyped()
34339 }
34340}
34341#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34342pub struct TokenPlusGreen(pub GreenId);
34343impl TokenPlusGreen {
34344 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34345 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34346 }
34347}
34348impl TypedSyntaxNode for TokenPlus {
34349 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPlus);
34350 type StablePtr = TokenPlusPtr;
34351 type Green = TokenPlusGreen;
34352 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34353 TokenPlusGreen(
34354 Arc::new(GreenNode {
34355 kind: SyntaxKind::TokenMissing,
34356 details: GreenNodeDetails::Token("".into()),
34357 })
34358 .intern(db),
34359 )
34360 }
34361 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34362 match node.0.green.lookup_intern(db).details {
34363 GreenNodeDetails::Token(_) => Self { node },
34364 GreenNodeDetails::Node { .. } => {
34365 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPlus)
34366 }
34367 }
34368 }
34369 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34370 match node.0.green.lookup_intern(db).details {
34371 GreenNodeDetails::Token(_) => Some(Self { node }),
34372 GreenNodeDetails::Node { .. } => None,
34373 }
34374 }
34375 fn as_syntax_node(&self) -> SyntaxNode {
34376 self.node.clone()
34377 }
34378 fn stable_ptr(&self) -> Self::StablePtr {
34379 TokenPlusPtr(self.node.0.stable_ptr)
34380 }
34381}
34382impl From<&TokenPlus> for SyntaxStablePtrId {
34383 fn from(node: &TokenPlus) -> Self {
34384 node.stable_ptr().untyped()
34385 }
34386}
34387#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34388pub struct TerminalPlus {
34389 node: SyntaxNode,
34390 children: Arc<[SyntaxNode]>,
34391}
34392impl Terminal for TerminalPlus {
34393 const KIND: SyntaxKind = SyntaxKind::TerminalPlus;
34394 type TokenType = TokenPlus;
34395 fn new_green(
34396 db: &dyn SyntaxGroup,
34397 leading_trivia: TriviaGreen,
34398 token: <<TerminalPlus as Terminal>::TokenType as TypedSyntaxNode>::Green,
34399 trailing_trivia: TriviaGreen,
34400 ) -> Self::Green {
34401 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34402 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34403 TerminalPlusGreen(
34404 Arc::new(GreenNode {
34405 kind: SyntaxKind::TerminalPlus,
34406 details: GreenNodeDetails::Node { children, width },
34407 })
34408 .intern(db),
34409 )
34410 }
34411 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34412 self.token(db).text(db)
34413 }
34414}
34415impl TerminalPlus {
34416 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34417 Trivia::from_syntax_node(db, self.children[0].clone())
34418 }
34419 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPlus {
34420 TokenPlus::from_syntax_node(db, self.children[1].clone())
34421 }
34422 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34423 Trivia::from_syntax_node(db, self.children[2].clone())
34424 }
34425}
34426#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34427pub struct TerminalPlusPtr(pub SyntaxStablePtrId);
34428impl TerminalPlusPtr {}
34429impl TypedStablePtr for TerminalPlusPtr {
34430 type SyntaxNode = TerminalPlus;
34431 fn untyped(&self) -> SyntaxStablePtrId {
34432 self.0
34433 }
34434 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPlus {
34435 TerminalPlus::from_syntax_node(db, self.0.lookup(db))
34436 }
34437}
34438impl From<TerminalPlusPtr> for SyntaxStablePtrId {
34439 fn from(ptr: TerminalPlusPtr) -> Self {
34440 ptr.untyped()
34441 }
34442}
34443#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34444pub struct TerminalPlusGreen(pub GreenId);
34445impl TypedSyntaxNode for TerminalPlus {
34446 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPlus);
34447 type StablePtr = TerminalPlusPtr;
34448 type Green = TerminalPlusGreen;
34449 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34450 TerminalPlusGreen(
34451 Arc::new(GreenNode {
34452 kind: SyntaxKind::TerminalPlus,
34453 details: GreenNodeDetails::Node {
34454 children: vec![
34455 Trivia::missing(db).0,
34456 TokenPlus::missing(db).0,
34457 Trivia::missing(db).0,
34458 ],
34459 width: TextWidth::default(),
34460 },
34461 })
34462 .intern(db),
34463 )
34464 }
34465 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34466 let kind = node.kind(db);
34467 assert_eq!(
34468 kind,
34469 SyntaxKind::TerminalPlus,
34470 "Unexpected SyntaxKind {:?}. Expected {:?}.",
34471 kind,
34472 SyntaxKind::TerminalPlus
34473 );
34474 let children = db.get_children(node.clone());
34475 Self { node, children }
34476 }
34477 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34478 let kind = node.kind(db);
34479 if kind == SyntaxKind::TerminalPlus { Some(Self::from_syntax_node(db, node)) } else { None }
34480 }
34481 fn as_syntax_node(&self) -> SyntaxNode {
34482 self.node.clone()
34483 }
34484 fn stable_ptr(&self) -> Self::StablePtr {
34485 TerminalPlusPtr(self.node.0.stable_ptr)
34486 }
34487}
34488impl From<&TerminalPlus> for SyntaxStablePtrId {
34489 fn from(node: &TerminalPlus) -> Self {
34490 node.stable_ptr().untyped()
34491 }
34492}
34493#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34494pub struct TokenPlusEq {
34495 node: SyntaxNode,
34496}
34497impl Token for TokenPlusEq {
34498 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34499 TokenPlusEqGreen(
34500 Arc::new(GreenNode {
34501 kind: SyntaxKind::TokenPlusEq,
34502 details: GreenNodeDetails::Token(text),
34503 })
34504 .intern(db),
34505 )
34506 }
34507 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34508 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34509 .clone()
34510 }
34511}
34512#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34513pub struct TokenPlusEqPtr(pub SyntaxStablePtrId);
34514impl TypedStablePtr for TokenPlusEqPtr {
34515 type SyntaxNode = TokenPlusEq;
34516 fn untyped(&self) -> SyntaxStablePtrId {
34517 self.0
34518 }
34519 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPlusEq {
34520 TokenPlusEq::from_syntax_node(db, self.0.lookup(db))
34521 }
34522}
34523impl From<TokenPlusEqPtr> for SyntaxStablePtrId {
34524 fn from(ptr: TokenPlusEqPtr) -> Self {
34525 ptr.untyped()
34526 }
34527}
34528#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34529pub struct TokenPlusEqGreen(pub GreenId);
34530impl TokenPlusEqGreen {
34531 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34532 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34533 }
34534}
34535impl TypedSyntaxNode for TokenPlusEq {
34536 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPlusEq);
34537 type StablePtr = TokenPlusEqPtr;
34538 type Green = TokenPlusEqGreen;
34539 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34540 TokenPlusEqGreen(
34541 Arc::new(GreenNode {
34542 kind: SyntaxKind::TokenMissing,
34543 details: GreenNodeDetails::Token("".into()),
34544 })
34545 .intern(db),
34546 )
34547 }
34548 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34549 match node.0.green.lookup_intern(db).details {
34550 GreenNodeDetails::Token(_) => Self { node },
34551 GreenNodeDetails::Node { .. } => {
34552 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPlusEq)
34553 }
34554 }
34555 }
34556 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34557 match node.0.green.lookup_intern(db).details {
34558 GreenNodeDetails::Token(_) => Some(Self { node }),
34559 GreenNodeDetails::Node { .. } => None,
34560 }
34561 }
34562 fn as_syntax_node(&self) -> SyntaxNode {
34563 self.node.clone()
34564 }
34565 fn stable_ptr(&self) -> Self::StablePtr {
34566 TokenPlusEqPtr(self.node.0.stable_ptr)
34567 }
34568}
34569impl From<&TokenPlusEq> for SyntaxStablePtrId {
34570 fn from(node: &TokenPlusEq) -> Self {
34571 node.stable_ptr().untyped()
34572 }
34573}
34574#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34575pub struct TerminalPlusEq {
34576 node: SyntaxNode,
34577 children: Arc<[SyntaxNode]>,
34578}
34579impl Terminal for TerminalPlusEq {
34580 const KIND: SyntaxKind = SyntaxKind::TerminalPlusEq;
34581 type TokenType = TokenPlusEq;
34582 fn new_green(
34583 db: &dyn SyntaxGroup,
34584 leading_trivia: TriviaGreen,
34585 token: <<TerminalPlusEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
34586 trailing_trivia: TriviaGreen,
34587 ) -> Self::Green {
34588 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34589 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34590 TerminalPlusEqGreen(
34591 Arc::new(GreenNode {
34592 kind: SyntaxKind::TerminalPlusEq,
34593 details: GreenNodeDetails::Node { children, width },
34594 })
34595 .intern(db),
34596 )
34597 }
34598 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34599 self.token(db).text(db)
34600 }
34601}
34602impl TerminalPlusEq {
34603 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34604 Trivia::from_syntax_node(db, self.children[0].clone())
34605 }
34606 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPlusEq {
34607 TokenPlusEq::from_syntax_node(db, self.children[1].clone())
34608 }
34609 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34610 Trivia::from_syntax_node(db, self.children[2].clone())
34611 }
34612}
34613#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34614pub struct TerminalPlusEqPtr(pub SyntaxStablePtrId);
34615impl TerminalPlusEqPtr {}
34616impl TypedStablePtr for TerminalPlusEqPtr {
34617 type SyntaxNode = TerminalPlusEq;
34618 fn untyped(&self) -> SyntaxStablePtrId {
34619 self.0
34620 }
34621 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPlusEq {
34622 TerminalPlusEq::from_syntax_node(db, self.0.lookup(db))
34623 }
34624}
34625impl From<TerminalPlusEqPtr> for SyntaxStablePtrId {
34626 fn from(ptr: TerminalPlusEqPtr) -> Self {
34627 ptr.untyped()
34628 }
34629}
34630#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34631pub struct TerminalPlusEqGreen(pub GreenId);
34632impl TypedSyntaxNode for TerminalPlusEq {
34633 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPlusEq);
34634 type StablePtr = TerminalPlusEqPtr;
34635 type Green = TerminalPlusEqGreen;
34636 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34637 TerminalPlusEqGreen(
34638 Arc::new(GreenNode {
34639 kind: SyntaxKind::TerminalPlusEq,
34640 details: GreenNodeDetails::Node {
34641 children: vec![
34642 Trivia::missing(db).0,
34643 TokenPlusEq::missing(db).0,
34644 Trivia::missing(db).0,
34645 ],
34646 width: TextWidth::default(),
34647 },
34648 })
34649 .intern(db),
34650 )
34651 }
34652 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34653 let kind = node.kind(db);
34654 assert_eq!(
34655 kind,
34656 SyntaxKind::TerminalPlusEq,
34657 "Unexpected SyntaxKind {:?}. Expected {:?}.",
34658 kind,
34659 SyntaxKind::TerminalPlusEq
34660 );
34661 let children = db.get_children(node.clone());
34662 Self { node, children }
34663 }
34664 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34665 let kind = node.kind(db);
34666 if kind == SyntaxKind::TerminalPlusEq {
34667 Some(Self::from_syntax_node(db, node))
34668 } else {
34669 None
34670 }
34671 }
34672 fn as_syntax_node(&self) -> SyntaxNode {
34673 self.node.clone()
34674 }
34675 fn stable_ptr(&self) -> Self::StablePtr {
34676 TerminalPlusEqPtr(self.node.0.stable_ptr)
34677 }
34678}
34679impl From<&TerminalPlusEq> for SyntaxStablePtrId {
34680 fn from(node: &TerminalPlusEq) -> Self {
34681 node.stable_ptr().untyped()
34682 }
34683}
34684#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34685pub struct TokenQuestionMark {
34686 node: SyntaxNode,
34687}
34688impl Token for TokenQuestionMark {
34689 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34690 TokenQuestionMarkGreen(
34691 Arc::new(GreenNode {
34692 kind: SyntaxKind::TokenQuestionMark,
34693 details: GreenNodeDetails::Token(text),
34694 })
34695 .intern(db),
34696 )
34697 }
34698 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34699 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34700 .clone()
34701 }
34702}
34703#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34704pub struct TokenQuestionMarkPtr(pub SyntaxStablePtrId);
34705impl TypedStablePtr for TokenQuestionMarkPtr {
34706 type SyntaxNode = TokenQuestionMark;
34707 fn untyped(&self) -> SyntaxStablePtrId {
34708 self.0
34709 }
34710 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenQuestionMark {
34711 TokenQuestionMark::from_syntax_node(db, self.0.lookup(db))
34712 }
34713}
34714impl From<TokenQuestionMarkPtr> for SyntaxStablePtrId {
34715 fn from(ptr: TokenQuestionMarkPtr) -> Self {
34716 ptr.untyped()
34717 }
34718}
34719#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34720pub struct TokenQuestionMarkGreen(pub GreenId);
34721impl TokenQuestionMarkGreen {
34722 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34723 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34724 }
34725}
34726impl TypedSyntaxNode for TokenQuestionMark {
34727 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenQuestionMark);
34728 type StablePtr = TokenQuestionMarkPtr;
34729 type Green = TokenQuestionMarkGreen;
34730 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34731 TokenQuestionMarkGreen(
34732 Arc::new(GreenNode {
34733 kind: SyntaxKind::TokenMissing,
34734 details: GreenNodeDetails::Token("".into()),
34735 })
34736 .intern(db),
34737 )
34738 }
34739 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34740 match node.0.green.lookup_intern(db).details {
34741 GreenNodeDetails::Token(_) => Self { node },
34742 GreenNodeDetails::Node { .. } => {
34743 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenQuestionMark)
34744 }
34745 }
34746 }
34747 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34748 match node.0.green.lookup_intern(db).details {
34749 GreenNodeDetails::Token(_) => Some(Self { node }),
34750 GreenNodeDetails::Node { .. } => None,
34751 }
34752 }
34753 fn as_syntax_node(&self) -> SyntaxNode {
34754 self.node.clone()
34755 }
34756 fn stable_ptr(&self) -> Self::StablePtr {
34757 TokenQuestionMarkPtr(self.node.0.stable_ptr)
34758 }
34759}
34760impl From<&TokenQuestionMark> for SyntaxStablePtrId {
34761 fn from(node: &TokenQuestionMark) -> Self {
34762 node.stable_ptr().untyped()
34763 }
34764}
34765#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34766pub struct TerminalQuestionMark {
34767 node: SyntaxNode,
34768 children: Arc<[SyntaxNode]>,
34769}
34770impl Terminal for TerminalQuestionMark {
34771 const KIND: SyntaxKind = SyntaxKind::TerminalQuestionMark;
34772 type TokenType = TokenQuestionMark;
34773 fn new_green(
34774 db: &dyn SyntaxGroup,
34775 leading_trivia: TriviaGreen,
34776 token: <<TerminalQuestionMark as Terminal>::TokenType as TypedSyntaxNode>::Green,
34777 trailing_trivia: TriviaGreen,
34778 ) -> Self::Green {
34779 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34780 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34781 TerminalQuestionMarkGreen(
34782 Arc::new(GreenNode {
34783 kind: SyntaxKind::TerminalQuestionMark,
34784 details: GreenNodeDetails::Node { children, width },
34785 })
34786 .intern(db),
34787 )
34788 }
34789 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34790 self.token(db).text(db)
34791 }
34792}
34793impl TerminalQuestionMark {
34794 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34795 Trivia::from_syntax_node(db, self.children[0].clone())
34796 }
34797 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenQuestionMark {
34798 TokenQuestionMark::from_syntax_node(db, self.children[1].clone())
34799 }
34800 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34801 Trivia::from_syntax_node(db, self.children[2].clone())
34802 }
34803}
34804#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34805pub struct TerminalQuestionMarkPtr(pub SyntaxStablePtrId);
34806impl TerminalQuestionMarkPtr {}
34807impl TypedStablePtr for TerminalQuestionMarkPtr {
34808 type SyntaxNode = TerminalQuestionMark;
34809 fn untyped(&self) -> SyntaxStablePtrId {
34810 self.0
34811 }
34812 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalQuestionMark {
34813 TerminalQuestionMark::from_syntax_node(db, self.0.lookup(db))
34814 }
34815}
34816impl From<TerminalQuestionMarkPtr> for SyntaxStablePtrId {
34817 fn from(ptr: TerminalQuestionMarkPtr) -> Self {
34818 ptr.untyped()
34819 }
34820}
34821#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34822pub struct TerminalQuestionMarkGreen(pub GreenId);
34823impl TypedSyntaxNode for TerminalQuestionMark {
34824 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalQuestionMark);
34825 type StablePtr = TerminalQuestionMarkPtr;
34826 type Green = TerminalQuestionMarkGreen;
34827 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34828 TerminalQuestionMarkGreen(
34829 Arc::new(GreenNode {
34830 kind: SyntaxKind::TerminalQuestionMark,
34831 details: GreenNodeDetails::Node {
34832 children: vec![
34833 Trivia::missing(db).0,
34834 TokenQuestionMark::missing(db).0,
34835 Trivia::missing(db).0,
34836 ],
34837 width: TextWidth::default(),
34838 },
34839 })
34840 .intern(db),
34841 )
34842 }
34843 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34844 let kind = node.kind(db);
34845 assert_eq!(
34846 kind,
34847 SyntaxKind::TerminalQuestionMark,
34848 "Unexpected SyntaxKind {:?}. Expected {:?}.",
34849 kind,
34850 SyntaxKind::TerminalQuestionMark
34851 );
34852 let children = db.get_children(node.clone());
34853 Self { node, children }
34854 }
34855 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34856 let kind = node.kind(db);
34857 if kind == SyntaxKind::TerminalQuestionMark {
34858 Some(Self::from_syntax_node(db, node))
34859 } else {
34860 None
34861 }
34862 }
34863 fn as_syntax_node(&self) -> SyntaxNode {
34864 self.node.clone()
34865 }
34866 fn stable_ptr(&self) -> Self::StablePtr {
34867 TerminalQuestionMarkPtr(self.node.0.stable_ptr)
34868 }
34869}
34870impl From<&TerminalQuestionMark> for SyntaxStablePtrId {
34871 fn from(node: &TerminalQuestionMark) -> Self {
34872 node.stable_ptr().untyped()
34873 }
34874}
34875#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34876pub struct TokenRBrace {
34877 node: SyntaxNode,
34878}
34879impl Token for TokenRBrace {
34880 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34881 TokenRBraceGreen(
34882 Arc::new(GreenNode {
34883 kind: SyntaxKind::TokenRBrace,
34884 details: GreenNodeDetails::Token(text),
34885 })
34886 .intern(db),
34887 )
34888 }
34889 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34890 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34891 .clone()
34892 }
34893}
34894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34895pub struct TokenRBracePtr(pub SyntaxStablePtrId);
34896impl TypedStablePtr for TokenRBracePtr {
34897 type SyntaxNode = TokenRBrace;
34898 fn untyped(&self) -> SyntaxStablePtrId {
34899 self.0
34900 }
34901 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRBrace {
34902 TokenRBrace::from_syntax_node(db, self.0.lookup(db))
34903 }
34904}
34905impl From<TokenRBracePtr> for SyntaxStablePtrId {
34906 fn from(ptr: TokenRBracePtr) -> Self {
34907 ptr.untyped()
34908 }
34909}
34910#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34911pub struct TokenRBraceGreen(pub GreenId);
34912impl TokenRBraceGreen {
34913 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34914 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34915 }
34916}
34917impl TypedSyntaxNode for TokenRBrace {
34918 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRBrace);
34919 type StablePtr = TokenRBracePtr;
34920 type Green = TokenRBraceGreen;
34921 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34922 TokenRBraceGreen(
34923 Arc::new(GreenNode {
34924 kind: SyntaxKind::TokenMissing,
34925 details: GreenNodeDetails::Token("".into()),
34926 })
34927 .intern(db),
34928 )
34929 }
34930 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34931 match node.0.green.lookup_intern(db).details {
34932 GreenNodeDetails::Token(_) => Self { node },
34933 GreenNodeDetails::Node { .. } => {
34934 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRBrace)
34935 }
34936 }
34937 }
34938 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
34939 match node.0.green.lookup_intern(db).details {
34940 GreenNodeDetails::Token(_) => Some(Self { node }),
34941 GreenNodeDetails::Node { .. } => None,
34942 }
34943 }
34944 fn as_syntax_node(&self) -> SyntaxNode {
34945 self.node.clone()
34946 }
34947 fn stable_ptr(&self) -> Self::StablePtr {
34948 TokenRBracePtr(self.node.0.stable_ptr)
34949 }
34950}
34951impl From<&TokenRBrace> for SyntaxStablePtrId {
34952 fn from(node: &TokenRBrace) -> Self {
34953 node.stable_ptr().untyped()
34954 }
34955}
34956#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34957pub struct TerminalRBrace {
34958 node: SyntaxNode,
34959 children: Arc<[SyntaxNode]>,
34960}
34961impl Terminal for TerminalRBrace {
34962 const KIND: SyntaxKind = SyntaxKind::TerminalRBrace;
34963 type TokenType = TokenRBrace;
34964 fn new_green(
34965 db: &dyn SyntaxGroup,
34966 leading_trivia: TriviaGreen,
34967 token: <<TerminalRBrace as Terminal>::TokenType as TypedSyntaxNode>::Green,
34968 trailing_trivia: TriviaGreen,
34969 ) -> Self::Green {
34970 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
34971 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
34972 TerminalRBraceGreen(
34973 Arc::new(GreenNode {
34974 kind: SyntaxKind::TerminalRBrace,
34975 details: GreenNodeDetails::Node { children, width },
34976 })
34977 .intern(db),
34978 )
34979 }
34980 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34981 self.token(db).text(db)
34982 }
34983}
34984impl TerminalRBrace {
34985 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34986 Trivia::from_syntax_node(db, self.children[0].clone())
34987 }
34988 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRBrace {
34989 TokenRBrace::from_syntax_node(db, self.children[1].clone())
34990 }
34991 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
34992 Trivia::from_syntax_node(db, self.children[2].clone())
34993 }
34994}
34995#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34996pub struct TerminalRBracePtr(pub SyntaxStablePtrId);
34997impl TerminalRBracePtr {}
34998impl TypedStablePtr for TerminalRBracePtr {
34999 type SyntaxNode = TerminalRBrace;
35000 fn untyped(&self) -> SyntaxStablePtrId {
35001 self.0
35002 }
35003 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
35004 TerminalRBrace::from_syntax_node(db, self.0.lookup(db))
35005 }
35006}
35007impl From<TerminalRBracePtr> for SyntaxStablePtrId {
35008 fn from(ptr: TerminalRBracePtr) -> Self {
35009 ptr.untyped()
35010 }
35011}
35012#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35013pub struct TerminalRBraceGreen(pub GreenId);
35014impl TypedSyntaxNode for TerminalRBrace {
35015 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRBrace);
35016 type StablePtr = TerminalRBracePtr;
35017 type Green = TerminalRBraceGreen;
35018 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35019 TerminalRBraceGreen(
35020 Arc::new(GreenNode {
35021 kind: SyntaxKind::TerminalRBrace,
35022 details: GreenNodeDetails::Node {
35023 children: vec![
35024 Trivia::missing(db).0,
35025 TokenRBrace::missing(db).0,
35026 Trivia::missing(db).0,
35027 ],
35028 width: TextWidth::default(),
35029 },
35030 })
35031 .intern(db),
35032 )
35033 }
35034 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35035 let kind = node.kind(db);
35036 assert_eq!(
35037 kind,
35038 SyntaxKind::TerminalRBrace,
35039 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35040 kind,
35041 SyntaxKind::TerminalRBrace
35042 );
35043 let children = db.get_children(node.clone());
35044 Self { node, children }
35045 }
35046 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35047 let kind = node.kind(db);
35048 if kind == SyntaxKind::TerminalRBrace {
35049 Some(Self::from_syntax_node(db, node))
35050 } else {
35051 None
35052 }
35053 }
35054 fn as_syntax_node(&self) -> SyntaxNode {
35055 self.node.clone()
35056 }
35057 fn stable_ptr(&self) -> Self::StablePtr {
35058 TerminalRBracePtr(self.node.0.stable_ptr)
35059 }
35060}
35061impl From<&TerminalRBrace> for SyntaxStablePtrId {
35062 fn from(node: &TerminalRBrace) -> Self {
35063 node.stable_ptr().untyped()
35064 }
35065}
35066#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35067pub struct TokenRBrack {
35068 node: SyntaxNode,
35069}
35070impl Token for TokenRBrack {
35071 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
35072 TokenRBrackGreen(
35073 Arc::new(GreenNode {
35074 kind: SyntaxKind::TokenRBrack,
35075 details: GreenNodeDetails::Token(text),
35076 })
35077 .intern(db),
35078 )
35079 }
35080 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35081 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
35082 .clone()
35083 }
35084}
35085#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35086pub struct TokenRBrackPtr(pub SyntaxStablePtrId);
35087impl TypedStablePtr for TokenRBrackPtr {
35088 type SyntaxNode = TokenRBrack;
35089 fn untyped(&self) -> SyntaxStablePtrId {
35090 self.0
35091 }
35092 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRBrack {
35093 TokenRBrack::from_syntax_node(db, self.0.lookup(db))
35094 }
35095}
35096impl From<TokenRBrackPtr> for SyntaxStablePtrId {
35097 fn from(ptr: TokenRBrackPtr) -> Self {
35098 ptr.untyped()
35099 }
35100}
35101#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35102pub struct TokenRBrackGreen(pub GreenId);
35103impl TokenRBrackGreen {
35104 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35105 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
35106 }
35107}
35108impl TypedSyntaxNode for TokenRBrack {
35109 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRBrack);
35110 type StablePtr = TokenRBrackPtr;
35111 type Green = TokenRBrackGreen;
35112 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35113 TokenRBrackGreen(
35114 Arc::new(GreenNode {
35115 kind: SyntaxKind::TokenMissing,
35116 details: GreenNodeDetails::Token("".into()),
35117 })
35118 .intern(db),
35119 )
35120 }
35121 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35122 match node.0.green.lookup_intern(db).details {
35123 GreenNodeDetails::Token(_) => Self { node },
35124 GreenNodeDetails::Node { .. } => {
35125 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRBrack)
35126 }
35127 }
35128 }
35129 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35130 match node.0.green.lookup_intern(db).details {
35131 GreenNodeDetails::Token(_) => Some(Self { node }),
35132 GreenNodeDetails::Node { .. } => None,
35133 }
35134 }
35135 fn as_syntax_node(&self) -> SyntaxNode {
35136 self.node.clone()
35137 }
35138 fn stable_ptr(&self) -> Self::StablePtr {
35139 TokenRBrackPtr(self.node.0.stable_ptr)
35140 }
35141}
35142impl From<&TokenRBrack> for SyntaxStablePtrId {
35143 fn from(node: &TokenRBrack) -> Self {
35144 node.stable_ptr().untyped()
35145 }
35146}
35147#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35148pub struct TerminalRBrack {
35149 node: SyntaxNode,
35150 children: Arc<[SyntaxNode]>,
35151}
35152impl Terminal for TerminalRBrack {
35153 const KIND: SyntaxKind = SyntaxKind::TerminalRBrack;
35154 type TokenType = TokenRBrack;
35155 fn new_green(
35156 db: &dyn SyntaxGroup,
35157 leading_trivia: TriviaGreen,
35158 token: <<TerminalRBrack as Terminal>::TokenType as TypedSyntaxNode>::Green,
35159 trailing_trivia: TriviaGreen,
35160 ) -> Self::Green {
35161 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
35162 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
35163 TerminalRBrackGreen(
35164 Arc::new(GreenNode {
35165 kind: SyntaxKind::TerminalRBrack,
35166 details: GreenNodeDetails::Node { children, width },
35167 })
35168 .intern(db),
35169 )
35170 }
35171 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35172 self.token(db).text(db)
35173 }
35174}
35175impl TerminalRBrack {
35176 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35177 Trivia::from_syntax_node(db, self.children[0].clone())
35178 }
35179 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRBrack {
35180 TokenRBrack::from_syntax_node(db, self.children[1].clone())
35181 }
35182 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35183 Trivia::from_syntax_node(db, self.children[2].clone())
35184 }
35185}
35186#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35187pub struct TerminalRBrackPtr(pub SyntaxStablePtrId);
35188impl TerminalRBrackPtr {}
35189impl TypedStablePtr for TerminalRBrackPtr {
35190 type SyntaxNode = TerminalRBrack;
35191 fn untyped(&self) -> SyntaxStablePtrId {
35192 self.0
35193 }
35194 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
35195 TerminalRBrack::from_syntax_node(db, self.0.lookup(db))
35196 }
35197}
35198impl From<TerminalRBrackPtr> for SyntaxStablePtrId {
35199 fn from(ptr: TerminalRBrackPtr) -> Self {
35200 ptr.untyped()
35201 }
35202}
35203#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35204pub struct TerminalRBrackGreen(pub GreenId);
35205impl TypedSyntaxNode for TerminalRBrack {
35206 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRBrack);
35207 type StablePtr = TerminalRBrackPtr;
35208 type Green = TerminalRBrackGreen;
35209 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35210 TerminalRBrackGreen(
35211 Arc::new(GreenNode {
35212 kind: SyntaxKind::TerminalRBrack,
35213 details: GreenNodeDetails::Node {
35214 children: vec![
35215 Trivia::missing(db).0,
35216 TokenRBrack::missing(db).0,
35217 Trivia::missing(db).0,
35218 ],
35219 width: TextWidth::default(),
35220 },
35221 })
35222 .intern(db),
35223 )
35224 }
35225 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35226 let kind = node.kind(db);
35227 assert_eq!(
35228 kind,
35229 SyntaxKind::TerminalRBrack,
35230 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35231 kind,
35232 SyntaxKind::TerminalRBrack
35233 );
35234 let children = db.get_children(node.clone());
35235 Self { node, children }
35236 }
35237 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35238 let kind = node.kind(db);
35239 if kind == SyntaxKind::TerminalRBrack {
35240 Some(Self::from_syntax_node(db, node))
35241 } else {
35242 None
35243 }
35244 }
35245 fn as_syntax_node(&self) -> SyntaxNode {
35246 self.node.clone()
35247 }
35248 fn stable_ptr(&self) -> Self::StablePtr {
35249 TerminalRBrackPtr(self.node.0.stable_ptr)
35250 }
35251}
35252impl From<&TerminalRBrack> for SyntaxStablePtrId {
35253 fn from(node: &TerminalRBrack) -> Self {
35254 node.stable_ptr().untyped()
35255 }
35256}
35257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35258pub struct TokenRParen {
35259 node: SyntaxNode,
35260}
35261impl Token for TokenRParen {
35262 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
35263 TokenRParenGreen(
35264 Arc::new(GreenNode {
35265 kind: SyntaxKind::TokenRParen,
35266 details: GreenNodeDetails::Token(text),
35267 })
35268 .intern(db),
35269 )
35270 }
35271 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35272 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
35273 .clone()
35274 }
35275}
35276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35277pub struct TokenRParenPtr(pub SyntaxStablePtrId);
35278impl TypedStablePtr for TokenRParenPtr {
35279 type SyntaxNode = TokenRParen;
35280 fn untyped(&self) -> SyntaxStablePtrId {
35281 self.0
35282 }
35283 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRParen {
35284 TokenRParen::from_syntax_node(db, self.0.lookup(db))
35285 }
35286}
35287impl From<TokenRParenPtr> for SyntaxStablePtrId {
35288 fn from(ptr: TokenRParenPtr) -> Self {
35289 ptr.untyped()
35290 }
35291}
35292#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35293pub struct TokenRParenGreen(pub GreenId);
35294impl TokenRParenGreen {
35295 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35296 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
35297 }
35298}
35299impl TypedSyntaxNode for TokenRParen {
35300 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRParen);
35301 type StablePtr = TokenRParenPtr;
35302 type Green = TokenRParenGreen;
35303 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35304 TokenRParenGreen(
35305 Arc::new(GreenNode {
35306 kind: SyntaxKind::TokenMissing,
35307 details: GreenNodeDetails::Token("".into()),
35308 })
35309 .intern(db),
35310 )
35311 }
35312 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35313 match node.0.green.lookup_intern(db).details {
35314 GreenNodeDetails::Token(_) => Self { node },
35315 GreenNodeDetails::Node { .. } => {
35316 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRParen)
35317 }
35318 }
35319 }
35320 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35321 match node.0.green.lookup_intern(db).details {
35322 GreenNodeDetails::Token(_) => Some(Self { node }),
35323 GreenNodeDetails::Node { .. } => None,
35324 }
35325 }
35326 fn as_syntax_node(&self) -> SyntaxNode {
35327 self.node.clone()
35328 }
35329 fn stable_ptr(&self) -> Self::StablePtr {
35330 TokenRParenPtr(self.node.0.stable_ptr)
35331 }
35332}
35333impl From<&TokenRParen> for SyntaxStablePtrId {
35334 fn from(node: &TokenRParen) -> Self {
35335 node.stable_ptr().untyped()
35336 }
35337}
35338#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35339pub struct TerminalRParen {
35340 node: SyntaxNode,
35341 children: Arc<[SyntaxNode]>,
35342}
35343impl Terminal for TerminalRParen {
35344 const KIND: SyntaxKind = SyntaxKind::TerminalRParen;
35345 type TokenType = TokenRParen;
35346 fn new_green(
35347 db: &dyn SyntaxGroup,
35348 leading_trivia: TriviaGreen,
35349 token: <<TerminalRParen as Terminal>::TokenType as TypedSyntaxNode>::Green,
35350 trailing_trivia: TriviaGreen,
35351 ) -> Self::Green {
35352 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
35353 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
35354 TerminalRParenGreen(
35355 Arc::new(GreenNode {
35356 kind: SyntaxKind::TerminalRParen,
35357 details: GreenNodeDetails::Node { children, width },
35358 })
35359 .intern(db),
35360 )
35361 }
35362 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35363 self.token(db).text(db)
35364 }
35365}
35366impl TerminalRParen {
35367 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35368 Trivia::from_syntax_node(db, self.children[0].clone())
35369 }
35370 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRParen {
35371 TokenRParen::from_syntax_node(db, self.children[1].clone())
35372 }
35373 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35374 Trivia::from_syntax_node(db, self.children[2].clone())
35375 }
35376}
35377#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35378pub struct TerminalRParenPtr(pub SyntaxStablePtrId);
35379impl TerminalRParenPtr {}
35380impl TypedStablePtr for TerminalRParenPtr {
35381 type SyntaxNode = TerminalRParen;
35382 fn untyped(&self) -> SyntaxStablePtrId {
35383 self.0
35384 }
35385 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
35386 TerminalRParen::from_syntax_node(db, self.0.lookup(db))
35387 }
35388}
35389impl From<TerminalRParenPtr> for SyntaxStablePtrId {
35390 fn from(ptr: TerminalRParenPtr) -> Self {
35391 ptr.untyped()
35392 }
35393}
35394#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35395pub struct TerminalRParenGreen(pub GreenId);
35396impl TypedSyntaxNode for TerminalRParen {
35397 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRParen);
35398 type StablePtr = TerminalRParenPtr;
35399 type Green = TerminalRParenGreen;
35400 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35401 TerminalRParenGreen(
35402 Arc::new(GreenNode {
35403 kind: SyntaxKind::TerminalRParen,
35404 details: GreenNodeDetails::Node {
35405 children: vec![
35406 Trivia::missing(db).0,
35407 TokenRParen::missing(db).0,
35408 Trivia::missing(db).0,
35409 ],
35410 width: TextWidth::default(),
35411 },
35412 })
35413 .intern(db),
35414 )
35415 }
35416 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35417 let kind = node.kind(db);
35418 assert_eq!(
35419 kind,
35420 SyntaxKind::TerminalRParen,
35421 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35422 kind,
35423 SyntaxKind::TerminalRParen
35424 );
35425 let children = db.get_children(node.clone());
35426 Self { node, children }
35427 }
35428 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35429 let kind = node.kind(db);
35430 if kind == SyntaxKind::TerminalRParen {
35431 Some(Self::from_syntax_node(db, node))
35432 } else {
35433 None
35434 }
35435 }
35436 fn as_syntax_node(&self) -> SyntaxNode {
35437 self.node.clone()
35438 }
35439 fn stable_ptr(&self) -> Self::StablePtr {
35440 TerminalRParenPtr(self.node.0.stable_ptr)
35441 }
35442}
35443impl From<&TerminalRParen> for SyntaxStablePtrId {
35444 fn from(node: &TerminalRParen) -> Self {
35445 node.stable_ptr().untyped()
35446 }
35447}
35448#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35449pub struct TokenSemicolon {
35450 node: SyntaxNode,
35451}
35452impl Token for TokenSemicolon {
35453 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
35454 TokenSemicolonGreen(
35455 Arc::new(GreenNode {
35456 kind: SyntaxKind::TokenSemicolon,
35457 details: GreenNodeDetails::Token(text),
35458 })
35459 .intern(db),
35460 )
35461 }
35462 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35463 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
35464 .clone()
35465 }
35466}
35467#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35468pub struct TokenSemicolonPtr(pub SyntaxStablePtrId);
35469impl TypedStablePtr for TokenSemicolonPtr {
35470 type SyntaxNode = TokenSemicolon;
35471 fn untyped(&self) -> SyntaxStablePtrId {
35472 self.0
35473 }
35474 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSemicolon {
35475 TokenSemicolon::from_syntax_node(db, self.0.lookup(db))
35476 }
35477}
35478impl From<TokenSemicolonPtr> for SyntaxStablePtrId {
35479 fn from(ptr: TokenSemicolonPtr) -> Self {
35480 ptr.untyped()
35481 }
35482}
35483#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35484pub struct TokenSemicolonGreen(pub GreenId);
35485impl TokenSemicolonGreen {
35486 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35487 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
35488 }
35489}
35490impl TypedSyntaxNode for TokenSemicolon {
35491 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSemicolon);
35492 type StablePtr = TokenSemicolonPtr;
35493 type Green = TokenSemicolonGreen;
35494 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35495 TokenSemicolonGreen(
35496 Arc::new(GreenNode {
35497 kind: SyntaxKind::TokenMissing,
35498 details: GreenNodeDetails::Token("".into()),
35499 })
35500 .intern(db),
35501 )
35502 }
35503 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35504 match node.0.green.lookup_intern(db).details {
35505 GreenNodeDetails::Token(_) => Self { node },
35506 GreenNodeDetails::Node { .. } => {
35507 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenSemicolon)
35508 }
35509 }
35510 }
35511 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35512 match node.0.green.lookup_intern(db).details {
35513 GreenNodeDetails::Token(_) => Some(Self { node }),
35514 GreenNodeDetails::Node { .. } => None,
35515 }
35516 }
35517 fn as_syntax_node(&self) -> SyntaxNode {
35518 self.node.clone()
35519 }
35520 fn stable_ptr(&self) -> Self::StablePtr {
35521 TokenSemicolonPtr(self.node.0.stable_ptr)
35522 }
35523}
35524impl From<&TokenSemicolon> for SyntaxStablePtrId {
35525 fn from(node: &TokenSemicolon) -> Self {
35526 node.stable_ptr().untyped()
35527 }
35528}
35529#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35530pub struct TerminalSemicolon {
35531 node: SyntaxNode,
35532 children: Arc<[SyntaxNode]>,
35533}
35534impl Terminal for TerminalSemicolon {
35535 const KIND: SyntaxKind = SyntaxKind::TerminalSemicolon;
35536 type TokenType = TokenSemicolon;
35537 fn new_green(
35538 db: &dyn SyntaxGroup,
35539 leading_trivia: TriviaGreen,
35540 token: <<TerminalSemicolon as Terminal>::TokenType as TypedSyntaxNode>::Green,
35541 trailing_trivia: TriviaGreen,
35542 ) -> Self::Green {
35543 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
35544 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
35545 TerminalSemicolonGreen(
35546 Arc::new(GreenNode {
35547 kind: SyntaxKind::TerminalSemicolon,
35548 details: GreenNodeDetails::Node { children, width },
35549 })
35550 .intern(db),
35551 )
35552 }
35553 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35554 self.token(db).text(db)
35555 }
35556}
35557impl TerminalSemicolon {
35558 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35559 Trivia::from_syntax_node(db, self.children[0].clone())
35560 }
35561 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenSemicolon {
35562 TokenSemicolon::from_syntax_node(db, self.children[1].clone())
35563 }
35564 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35565 Trivia::from_syntax_node(db, self.children[2].clone())
35566 }
35567}
35568#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35569pub struct TerminalSemicolonPtr(pub SyntaxStablePtrId);
35570impl TerminalSemicolonPtr {}
35571impl TypedStablePtr for TerminalSemicolonPtr {
35572 type SyntaxNode = TerminalSemicolon;
35573 fn untyped(&self) -> SyntaxStablePtrId {
35574 self.0
35575 }
35576 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
35577 TerminalSemicolon::from_syntax_node(db, self.0.lookup(db))
35578 }
35579}
35580impl From<TerminalSemicolonPtr> for SyntaxStablePtrId {
35581 fn from(ptr: TerminalSemicolonPtr) -> Self {
35582 ptr.untyped()
35583 }
35584}
35585#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35586pub struct TerminalSemicolonGreen(pub GreenId);
35587impl TypedSyntaxNode for TerminalSemicolon {
35588 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalSemicolon);
35589 type StablePtr = TerminalSemicolonPtr;
35590 type Green = TerminalSemicolonGreen;
35591 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35592 TerminalSemicolonGreen(
35593 Arc::new(GreenNode {
35594 kind: SyntaxKind::TerminalSemicolon,
35595 details: GreenNodeDetails::Node {
35596 children: vec![
35597 Trivia::missing(db).0,
35598 TokenSemicolon::missing(db).0,
35599 Trivia::missing(db).0,
35600 ],
35601 width: TextWidth::default(),
35602 },
35603 })
35604 .intern(db),
35605 )
35606 }
35607 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35608 let kind = node.kind(db);
35609 assert_eq!(
35610 kind,
35611 SyntaxKind::TerminalSemicolon,
35612 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35613 kind,
35614 SyntaxKind::TerminalSemicolon
35615 );
35616 let children = db.get_children(node.clone());
35617 Self { node, children }
35618 }
35619 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35620 let kind = node.kind(db);
35621 if kind == SyntaxKind::TerminalSemicolon {
35622 Some(Self::from_syntax_node(db, node))
35623 } else {
35624 None
35625 }
35626 }
35627 fn as_syntax_node(&self) -> SyntaxNode {
35628 self.node.clone()
35629 }
35630 fn stable_ptr(&self) -> Self::StablePtr {
35631 TerminalSemicolonPtr(self.node.0.stable_ptr)
35632 }
35633}
35634impl From<&TerminalSemicolon> for SyntaxStablePtrId {
35635 fn from(node: &TerminalSemicolon) -> Self {
35636 node.stable_ptr().untyped()
35637 }
35638}
35639#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35640pub struct TokenUnderscore {
35641 node: SyntaxNode,
35642}
35643impl Token for TokenUnderscore {
35644 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
35645 TokenUnderscoreGreen(
35646 Arc::new(GreenNode {
35647 kind: SyntaxKind::TokenUnderscore,
35648 details: GreenNodeDetails::Token(text),
35649 })
35650 .intern(db),
35651 )
35652 }
35653 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35654 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
35655 .clone()
35656 }
35657}
35658#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35659pub struct TokenUnderscorePtr(pub SyntaxStablePtrId);
35660impl TypedStablePtr for TokenUnderscorePtr {
35661 type SyntaxNode = TokenUnderscore;
35662 fn untyped(&self) -> SyntaxStablePtrId {
35663 self.0
35664 }
35665 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenUnderscore {
35666 TokenUnderscore::from_syntax_node(db, self.0.lookup(db))
35667 }
35668}
35669impl From<TokenUnderscorePtr> for SyntaxStablePtrId {
35670 fn from(ptr: TokenUnderscorePtr) -> Self {
35671 ptr.untyped()
35672 }
35673}
35674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35675pub struct TokenUnderscoreGreen(pub GreenId);
35676impl TokenUnderscoreGreen {
35677 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35678 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
35679 }
35680}
35681impl TypedSyntaxNode for TokenUnderscore {
35682 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenUnderscore);
35683 type StablePtr = TokenUnderscorePtr;
35684 type Green = TokenUnderscoreGreen;
35685 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35686 TokenUnderscoreGreen(
35687 Arc::new(GreenNode {
35688 kind: SyntaxKind::TokenMissing,
35689 details: GreenNodeDetails::Token("".into()),
35690 })
35691 .intern(db),
35692 )
35693 }
35694 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35695 match node.0.green.lookup_intern(db).details {
35696 GreenNodeDetails::Token(_) => Self { node },
35697 GreenNodeDetails::Node { .. } => {
35698 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenUnderscore)
35699 }
35700 }
35701 }
35702 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35703 match node.0.green.lookup_intern(db).details {
35704 GreenNodeDetails::Token(_) => Some(Self { node }),
35705 GreenNodeDetails::Node { .. } => None,
35706 }
35707 }
35708 fn as_syntax_node(&self) -> SyntaxNode {
35709 self.node.clone()
35710 }
35711 fn stable_ptr(&self) -> Self::StablePtr {
35712 TokenUnderscorePtr(self.node.0.stable_ptr)
35713 }
35714}
35715impl From<&TokenUnderscore> for SyntaxStablePtrId {
35716 fn from(node: &TokenUnderscore) -> Self {
35717 node.stable_ptr().untyped()
35718 }
35719}
35720#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35721pub struct TerminalUnderscore {
35722 node: SyntaxNode,
35723 children: Arc<[SyntaxNode]>,
35724}
35725impl Terminal for TerminalUnderscore {
35726 const KIND: SyntaxKind = SyntaxKind::TerminalUnderscore;
35727 type TokenType = TokenUnderscore;
35728 fn new_green(
35729 db: &dyn SyntaxGroup,
35730 leading_trivia: TriviaGreen,
35731 token: <<TerminalUnderscore as Terminal>::TokenType as TypedSyntaxNode>::Green,
35732 trailing_trivia: TriviaGreen,
35733 ) -> Self::Green {
35734 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
35735 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
35736 TerminalUnderscoreGreen(
35737 Arc::new(GreenNode {
35738 kind: SyntaxKind::TerminalUnderscore,
35739 details: GreenNodeDetails::Node { children, width },
35740 })
35741 .intern(db),
35742 )
35743 }
35744 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35745 self.token(db).text(db)
35746 }
35747}
35748impl TerminalUnderscore {
35749 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35750 Trivia::from_syntax_node(db, self.children[0].clone())
35751 }
35752 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenUnderscore {
35753 TokenUnderscore::from_syntax_node(db, self.children[1].clone())
35754 }
35755 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35756 Trivia::from_syntax_node(db, self.children[2].clone())
35757 }
35758}
35759#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35760pub struct TerminalUnderscorePtr(pub SyntaxStablePtrId);
35761impl TerminalUnderscorePtr {}
35762impl TypedStablePtr for TerminalUnderscorePtr {
35763 type SyntaxNode = TerminalUnderscore;
35764 fn untyped(&self) -> SyntaxStablePtrId {
35765 self.0
35766 }
35767 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalUnderscore {
35768 TerminalUnderscore::from_syntax_node(db, self.0.lookup(db))
35769 }
35770}
35771impl From<TerminalUnderscorePtr> for SyntaxStablePtrId {
35772 fn from(ptr: TerminalUnderscorePtr) -> Self {
35773 ptr.untyped()
35774 }
35775}
35776#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35777pub struct TerminalUnderscoreGreen(pub GreenId);
35778impl TypedSyntaxNode for TerminalUnderscore {
35779 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalUnderscore);
35780 type StablePtr = TerminalUnderscorePtr;
35781 type Green = TerminalUnderscoreGreen;
35782 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35783 TerminalUnderscoreGreen(
35784 Arc::new(GreenNode {
35785 kind: SyntaxKind::TerminalUnderscore,
35786 details: GreenNodeDetails::Node {
35787 children: vec![
35788 Trivia::missing(db).0,
35789 TokenUnderscore::missing(db).0,
35790 Trivia::missing(db).0,
35791 ],
35792 width: TextWidth::default(),
35793 },
35794 })
35795 .intern(db),
35796 )
35797 }
35798 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35799 let kind = node.kind(db);
35800 assert_eq!(
35801 kind,
35802 SyntaxKind::TerminalUnderscore,
35803 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35804 kind,
35805 SyntaxKind::TerminalUnderscore
35806 );
35807 let children = db.get_children(node.clone());
35808 Self { node, children }
35809 }
35810 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35811 let kind = node.kind(db);
35812 if kind == SyntaxKind::TerminalUnderscore {
35813 Some(Self::from_syntax_node(db, node))
35814 } else {
35815 None
35816 }
35817 }
35818 fn as_syntax_node(&self) -> SyntaxNode {
35819 self.node.clone()
35820 }
35821 fn stable_ptr(&self) -> Self::StablePtr {
35822 TerminalUnderscorePtr(self.node.0.stable_ptr)
35823 }
35824}
35825impl From<&TerminalUnderscore> for SyntaxStablePtrId {
35826 fn from(node: &TerminalUnderscore) -> Self {
35827 node.stable_ptr().untyped()
35828 }
35829}
35830#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35831pub struct TokenXor {
35832 node: SyntaxNode,
35833}
35834impl Token for TokenXor {
35835 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
35836 TokenXorGreen(
35837 Arc::new(GreenNode {
35838 kind: SyntaxKind::TokenXor,
35839 details: GreenNodeDetails::Token(text),
35840 })
35841 .intern(db),
35842 )
35843 }
35844 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35845 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
35846 .clone()
35847 }
35848}
35849#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35850pub struct TokenXorPtr(pub SyntaxStablePtrId);
35851impl TypedStablePtr for TokenXorPtr {
35852 type SyntaxNode = TokenXor;
35853 fn untyped(&self) -> SyntaxStablePtrId {
35854 self.0
35855 }
35856 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenXor {
35857 TokenXor::from_syntax_node(db, self.0.lookup(db))
35858 }
35859}
35860impl From<TokenXorPtr> for SyntaxStablePtrId {
35861 fn from(ptr: TokenXorPtr) -> Self {
35862 ptr.untyped()
35863 }
35864}
35865#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35866pub struct TokenXorGreen(pub GreenId);
35867impl TokenXorGreen {
35868 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35869 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
35870 }
35871}
35872impl TypedSyntaxNode for TokenXor {
35873 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenXor);
35874 type StablePtr = TokenXorPtr;
35875 type Green = TokenXorGreen;
35876 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35877 TokenXorGreen(
35878 Arc::new(GreenNode {
35879 kind: SyntaxKind::TokenMissing,
35880 details: GreenNodeDetails::Token("".into()),
35881 })
35882 .intern(db),
35883 )
35884 }
35885 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35886 match node.0.green.lookup_intern(db).details {
35887 GreenNodeDetails::Token(_) => Self { node },
35888 GreenNodeDetails::Node { .. } => {
35889 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenXor)
35890 }
35891 }
35892 }
35893 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
35894 match node.0.green.lookup_intern(db).details {
35895 GreenNodeDetails::Token(_) => Some(Self { node }),
35896 GreenNodeDetails::Node { .. } => None,
35897 }
35898 }
35899 fn as_syntax_node(&self) -> SyntaxNode {
35900 self.node.clone()
35901 }
35902 fn stable_ptr(&self) -> Self::StablePtr {
35903 TokenXorPtr(self.node.0.stable_ptr)
35904 }
35905}
35906impl From<&TokenXor> for SyntaxStablePtrId {
35907 fn from(node: &TokenXor) -> Self {
35908 node.stable_ptr().untyped()
35909 }
35910}
35911#[derive(Clone, Debug, Eq, Hash, PartialEq)]
35912pub struct TerminalXor {
35913 node: SyntaxNode,
35914 children: Arc<[SyntaxNode]>,
35915}
35916impl Terminal for TerminalXor {
35917 const KIND: SyntaxKind = SyntaxKind::TerminalXor;
35918 type TokenType = TokenXor;
35919 fn new_green(
35920 db: &dyn SyntaxGroup,
35921 leading_trivia: TriviaGreen,
35922 token: <<TerminalXor as Terminal>::TokenType as TypedSyntaxNode>::Green,
35923 trailing_trivia: TriviaGreen,
35924 ) -> Self::Green {
35925 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
35926 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
35927 TerminalXorGreen(
35928 Arc::new(GreenNode {
35929 kind: SyntaxKind::TerminalXor,
35930 details: GreenNodeDetails::Node { children, width },
35931 })
35932 .intern(db),
35933 )
35934 }
35935 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
35936 self.token(db).text(db)
35937 }
35938}
35939impl TerminalXor {
35940 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35941 Trivia::from_syntax_node(db, self.children[0].clone())
35942 }
35943 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenXor {
35944 TokenXor::from_syntax_node(db, self.children[1].clone())
35945 }
35946 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
35947 Trivia::from_syntax_node(db, self.children[2].clone())
35948 }
35949}
35950#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35951pub struct TerminalXorPtr(pub SyntaxStablePtrId);
35952impl TerminalXorPtr {}
35953impl TypedStablePtr for TerminalXorPtr {
35954 type SyntaxNode = TerminalXor;
35955 fn untyped(&self) -> SyntaxStablePtrId {
35956 self.0
35957 }
35958 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalXor {
35959 TerminalXor::from_syntax_node(db, self.0.lookup(db))
35960 }
35961}
35962impl From<TerminalXorPtr> for SyntaxStablePtrId {
35963 fn from(ptr: TerminalXorPtr) -> Self {
35964 ptr.untyped()
35965 }
35966}
35967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
35968pub struct TerminalXorGreen(pub GreenId);
35969impl TypedSyntaxNode for TerminalXor {
35970 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalXor);
35971 type StablePtr = TerminalXorPtr;
35972 type Green = TerminalXorGreen;
35973 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
35974 TerminalXorGreen(
35975 Arc::new(GreenNode {
35976 kind: SyntaxKind::TerminalXor,
35977 details: GreenNodeDetails::Node {
35978 children: vec![
35979 Trivia::missing(db).0,
35980 TokenXor::missing(db).0,
35981 Trivia::missing(db).0,
35982 ],
35983 width: TextWidth::default(),
35984 },
35985 })
35986 .intern(db),
35987 )
35988 }
35989 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
35990 let kind = node.kind(db);
35991 assert_eq!(
35992 kind,
35993 SyntaxKind::TerminalXor,
35994 "Unexpected SyntaxKind {:?}. Expected {:?}.",
35995 kind,
35996 SyntaxKind::TerminalXor
35997 );
35998 let children = db.get_children(node.clone());
35999 Self { node, children }
36000 }
36001 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36002 let kind = node.kind(db);
36003 if kind == SyntaxKind::TerminalXor { Some(Self::from_syntax_node(db, node)) } else { None }
36004 }
36005 fn as_syntax_node(&self) -> SyntaxNode {
36006 self.node.clone()
36007 }
36008 fn stable_ptr(&self) -> Self::StablePtr {
36009 TerminalXorPtr(self.node.0.stable_ptr)
36010 }
36011}
36012impl From<&TerminalXor> for SyntaxStablePtrId {
36013 fn from(node: &TerminalXor) -> Self {
36014 node.stable_ptr().untyped()
36015 }
36016}
36017#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36018pub struct SyntaxFile {
36019 node: SyntaxNode,
36020 children: Arc<[SyntaxNode]>,
36021}
36022impl SyntaxFile {
36023 pub const INDEX_ITEMS: usize = 0;
36024 pub const INDEX_EOF: usize = 1;
36025 pub fn new_green(
36026 db: &dyn SyntaxGroup,
36027 items: ModuleItemListGreen,
36028 eof: TerminalEndOfFileGreen,
36029 ) -> SyntaxFileGreen {
36030 let children: Vec<GreenId> = vec![items.0, eof.0];
36031 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
36032 SyntaxFileGreen(
36033 Arc::new(GreenNode {
36034 kind: SyntaxKind::SyntaxFile,
36035 details: GreenNodeDetails::Node { children, width },
36036 })
36037 .intern(db),
36038 )
36039 }
36040}
36041impl SyntaxFile {
36042 pub fn items(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
36043 ModuleItemList::from_syntax_node(db, self.children[0].clone())
36044 }
36045 pub fn eof(&self, db: &dyn SyntaxGroup) -> TerminalEndOfFile {
36046 TerminalEndOfFile::from_syntax_node(db, self.children[1].clone())
36047 }
36048}
36049#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36050pub struct SyntaxFilePtr(pub SyntaxStablePtrId);
36051impl SyntaxFilePtr {}
36052impl TypedStablePtr for SyntaxFilePtr {
36053 type SyntaxNode = SyntaxFile;
36054 fn untyped(&self) -> SyntaxStablePtrId {
36055 self.0
36056 }
36057 fn lookup(&self, db: &dyn SyntaxGroup) -> SyntaxFile {
36058 SyntaxFile::from_syntax_node(db, self.0.lookup(db))
36059 }
36060}
36061impl From<SyntaxFilePtr> for SyntaxStablePtrId {
36062 fn from(ptr: SyntaxFilePtr) -> Self {
36063 ptr.untyped()
36064 }
36065}
36066#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36067pub struct SyntaxFileGreen(pub GreenId);
36068impl TypedSyntaxNode for SyntaxFile {
36069 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::SyntaxFile);
36070 type StablePtr = SyntaxFilePtr;
36071 type Green = SyntaxFileGreen;
36072 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36073 SyntaxFileGreen(
36074 Arc::new(GreenNode {
36075 kind: SyntaxKind::SyntaxFile,
36076 details: GreenNodeDetails::Node {
36077 children: vec![ModuleItemList::missing(db).0, TerminalEndOfFile::missing(db).0],
36078 width: TextWidth::default(),
36079 },
36080 })
36081 .intern(db),
36082 )
36083 }
36084 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36085 let kind = node.kind(db);
36086 assert_eq!(
36087 kind,
36088 SyntaxKind::SyntaxFile,
36089 "Unexpected SyntaxKind {:?}. Expected {:?}.",
36090 kind,
36091 SyntaxKind::SyntaxFile
36092 );
36093 let children = db.get_children(node.clone());
36094 Self { node, children }
36095 }
36096 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36097 let kind = node.kind(db);
36098 if kind == SyntaxKind::SyntaxFile { Some(Self::from_syntax_node(db, node)) } else { None }
36099 }
36100 fn as_syntax_node(&self) -> SyntaxNode {
36101 self.node.clone()
36102 }
36103 fn stable_ptr(&self) -> Self::StablePtr {
36104 SyntaxFilePtr(self.node.0.stable_ptr)
36105 }
36106}
36107impl From<&SyntaxFile> for SyntaxStablePtrId {
36108 fn from(node: &SyntaxFile) -> Self {
36109 node.stable_ptr().untyped()
36110 }
36111}
36112#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36113pub struct TokenEmpty {
36114 node: SyntaxNode,
36115}
36116impl Token for TokenEmpty {
36117 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36118 TokenEmptyGreen(
36119 Arc::new(GreenNode {
36120 kind: SyntaxKind::TokenEmpty,
36121 details: GreenNodeDetails::Token(text),
36122 })
36123 .intern(db),
36124 )
36125 }
36126 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36127 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36128 .clone()
36129 }
36130}
36131#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36132pub struct TokenEmptyPtr(pub SyntaxStablePtrId);
36133impl TypedStablePtr for TokenEmptyPtr {
36134 type SyntaxNode = TokenEmpty;
36135 fn untyped(&self) -> SyntaxStablePtrId {
36136 self.0
36137 }
36138 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEmpty {
36139 TokenEmpty::from_syntax_node(db, self.0.lookup(db))
36140 }
36141}
36142impl From<TokenEmptyPtr> for SyntaxStablePtrId {
36143 fn from(ptr: TokenEmptyPtr) -> Self {
36144 ptr.untyped()
36145 }
36146}
36147#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36148pub struct TokenEmptyGreen(pub GreenId);
36149impl TokenEmptyGreen {
36150 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36151 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36152 }
36153}
36154impl TypedSyntaxNode for TokenEmpty {
36155 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEmpty);
36156 type StablePtr = TokenEmptyPtr;
36157 type Green = TokenEmptyGreen;
36158 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36159 TokenEmptyGreen(
36160 Arc::new(GreenNode {
36161 kind: SyntaxKind::TokenMissing,
36162 details: GreenNodeDetails::Token("".into()),
36163 })
36164 .intern(db),
36165 )
36166 }
36167 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36168 match node.0.green.lookup_intern(db).details {
36169 GreenNodeDetails::Token(_) => Self { node },
36170 GreenNodeDetails::Node { .. } => {
36171 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEmpty)
36172 }
36173 }
36174 }
36175 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36176 match node.0.green.lookup_intern(db).details {
36177 GreenNodeDetails::Token(_) => Some(Self { node }),
36178 GreenNodeDetails::Node { .. } => None,
36179 }
36180 }
36181 fn as_syntax_node(&self) -> SyntaxNode {
36182 self.node.clone()
36183 }
36184 fn stable_ptr(&self) -> Self::StablePtr {
36185 TokenEmptyPtr(self.node.0.stable_ptr)
36186 }
36187}
36188impl From<&TokenEmpty> for SyntaxStablePtrId {
36189 fn from(node: &TokenEmpty) -> Self {
36190 node.stable_ptr().untyped()
36191 }
36192}
36193#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36194pub struct TerminalEmpty {
36195 node: SyntaxNode,
36196 children: Arc<[SyntaxNode]>,
36197}
36198impl Terminal for TerminalEmpty {
36199 const KIND: SyntaxKind = SyntaxKind::TerminalEmpty;
36200 type TokenType = TokenEmpty;
36201 fn new_green(
36202 db: &dyn SyntaxGroup,
36203 leading_trivia: TriviaGreen,
36204 token: <<TerminalEmpty as Terminal>::TokenType as TypedSyntaxNode>::Green,
36205 trailing_trivia: TriviaGreen,
36206 ) -> Self::Green {
36207 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
36208 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
36209 TerminalEmptyGreen(
36210 Arc::new(GreenNode {
36211 kind: SyntaxKind::TerminalEmpty,
36212 details: GreenNodeDetails::Node { children, width },
36213 })
36214 .intern(db),
36215 )
36216 }
36217 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36218 self.token(db).text(db)
36219 }
36220}
36221impl TerminalEmpty {
36222 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
36223 Trivia::from_syntax_node(db, self.children[0].clone())
36224 }
36225 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEmpty {
36226 TokenEmpty::from_syntax_node(db, self.children[1].clone())
36227 }
36228 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
36229 Trivia::from_syntax_node(db, self.children[2].clone())
36230 }
36231}
36232#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36233pub struct TerminalEmptyPtr(pub SyntaxStablePtrId);
36234impl TerminalEmptyPtr {}
36235impl TypedStablePtr for TerminalEmptyPtr {
36236 type SyntaxNode = TerminalEmpty;
36237 fn untyped(&self) -> SyntaxStablePtrId {
36238 self.0
36239 }
36240 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEmpty {
36241 TerminalEmpty::from_syntax_node(db, self.0.lookup(db))
36242 }
36243}
36244impl From<TerminalEmptyPtr> for SyntaxStablePtrId {
36245 fn from(ptr: TerminalEmptyPtr) -> Self {
36246 ptr.untyped()
36247 }
36248}
36249#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36250pub struct TerminalEmptyGreen(pub GreenId);
36251impl TypedSyntaxNode for TerminalEmpty {
36252 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEmpty);
36253 type StablePtr = TerminalEmptyPtr;
36254 type Green = TerminalEmptyGreen;
36255 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36256 TerminalEmptyGreen(
36257 Arc::new(GreenNode {
36258 kind: SyntaxKind::TerminalEmpty,
36259 details: GreenNodeDetails::Node {
36260 children: vec![
36261 Trivia::missing(db).0,
36262 TokenEmpty::missing(db).0,
36263 Trivia::missing(db).0,
36264 ],
36265 width: TextWidth::default(),
36266 },
36267 })
36268 .intern(db),
36269 )
36270 }
36271 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36272 let kind = node.kind(db);
36273 assert_eq!(
36274 kind,
36275 SyntaxKind::TerminalEmpty,
36276 "Unexpected SyntaxKind {:?}. Expected {:?}.",
36277 kind,
36278 SyntaxKind::TerminalEmpty
36279 );
36280 let children = db.get_children(node.clone());
36281 Self { node, children }
36282 }
36283 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36284 let kind = node.kind(db);
36285 if kind == SyntaxKind::TerminalEmpty {
36286 Some(Self::from_syntax_node(db, node))
36287 } else {
36288 None
36289 }
36290 }
36291 fn as_syntax_node(&self) -> SyntaxNode {
36292 self.node.clone()
36293 }
36294 fn stable_ptr(&self) -> Self::StablePtr {
36295 TerminalEmptyPtr(self.node.0.stable_ptr)
36296 }
36297}
36298impl From<&TerminalEmpty> for SyntaxStablePtrId {
36299 fn from(node: &TerminalEmpty) -> Self {
36300 node.stable_ptr().untyped()
36301 }
36302}
36303#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36304pub struct TokenSingleLineComment {
36305 node: SyntaxNode,
36306}
36307impl Token for TokenSingleLineComment {
36308 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36309 TokenSingleLineCommentGreen(
36310 Arc::new(GreenNode {
36311 kind: SyntaxKind::TokenSingleLineComment,
36312 details: GreenNodeDetails::Token(text),
36313 })
36314 .intern(db),
36315 )
36316 }
36317 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36318 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36319 .clone()
36320 }
36321}
36322#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36323pub struct TokenSingleLineCommentPtr(pub SyntaxStablePtrId);
36324impl TypedStablePtr for TokenSingleLineCommentPtr {
36325 type SyntaxNode = TokenSingleLineComment;
36326 fn untyped(&self) -> SyntaxStablePtrId {
36327 self.0
36328 }
36329 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineComment {
36330 TokenSingleLineComment::from_syntax_node(db, self.0.lookup(db))
36331 }
36332}
36333impl From<TokenSingleLineCommentPtr> for SyntaxStablePtrId {
36334 fn from(ptr: TokenSingleLineCommentPtr) -> Self {
36335 ptr.untyped()
36336 }
36337}
36338#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36339pub struct TokenSingleLineCommentGreen(pub GreenId);
36340impl TokenSingleLineCommentGreen {
36341 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36342 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36343 }
36344}
36345impl TypedSyntaxNode for TokenSingleLineComment {
36346 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineComment);
36347 type StablePtr = TokenSingleLineCommentPtr;
36348 type Green = TokenSingleLineCommentGreen;
36349 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36350 TokenSingleLineCommentGreen(
36351 Arc::new(GreenNode {
36352 kind: SyntaxKind::TokenMissing,
36353 details: GreenNodeDetails::Token("".into()),
36354 })
36355 .intern(db),
36356 )
36357 }
36358 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36359 match node.0.green.lookup_intern(db).details {
36360 GreenNodeDetails::Token(_) => Self { node },
36361 GreenNodeDetails::Node { .. } => panic!(
36362 "Expected a token {:?}, not an internal node",
36363 SyntaxKind::TokenSingleLineComment
36364 ),
36365 }
36366 }
36367 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36368 match node.0.green.lookup_intern(db).details {
36369 GreenNodeDetails::Token(_) => Some(Self { node }),
36370 GreenNodeDetails::Node { .. } => None,
36371 }
36372 }
36373 fn as_syntax_node(&self) -> SyntaxNode {
36374 self.node.clone()
36375 }
36376 fn stable_ptr(&self) -> Self::StablePtr {
36377 TokenSingleLineCommentPtr(self.node.0.stable_ptr)
36378 }
36379}
36380impl From<&TokenSingleLineComment> for SyntaxStablePtrId {
36381 fn from(node: &TokenSingleLineComment) -> Self {
36382 node.stable_ptr().untyped()
36383 }
36384}
36385#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36386pub struct TokenSingleLineInnerComment {
36387 node: SyntaxNode,
36388}
36389impl Token for TokenSingleLineInnerComment {
36390 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36391 TokenSingleLineInnerCommentGreen(
36392 Arc::new(GreenNode {
36393 kind: SyntaxKind::TokenSingleLineInnerComment,
36394 details: GreenNodeDetails::Token(text),
36395 })
36396 .intern(db),
36397 )
36398 }
36399 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36400 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36401 .clone()
36402 }
36403}
36404#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36405pub struct TokenSingleLineInnerCommentPtr(pub SyntaxStablePtrId);
36406impl TypedStablePtr for TokenSingleLineInnerCommentPtr {
36407 type SyntaxNode = TokenSingleLineInnerComment;
36408 fn untyped(&self) -> SyntaxStablePtrId {
36409 self.0
36410 }
36411 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineInnerComment {
36412 TokenSingleLineInnerComment::from_syntax_node(db, self.0.lookup(db))
36413 }
36414}
36415impl From<TokenSingleLineInnerCommentPtr> for SyntaxStablePtrId {
36416 fn from(ptr: TokenSingleLineInnerCommentPtr) -> Self {
36417 ptr.untyped()
36418 }
36419}
36420#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36421pub struct TokenSingleLineInnerCommentGreen(pub GreenId);
36422impl TokenSingleLineInnerCommentGreen {
36423 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36424 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36425 }
36426}
36427impl TypedSyntaxNode for TokenSingleLineInnerComment {
36428 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineInnerComment);
36429 type StablePtr = TokenSingleLineInnerCommentPtr;
36430 type Green = TokenSingleLineInnerCommentGreen;
36431 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36432 TokenSingleLineInnerCommentGreen(
36433 Arc::new(GreenNode {
36434 kind: SyntaxKind::TokenMissing,
36435 details: GreenNodeDetails::Token("".into()),
36436 })
36437 .intern(db),
36438 )
36439 }
36440 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36441 match node.0.green.lookup_intern(db).details {
36442 GreenNodeDetails::Token(_) => Self { node },
36443 GreenNodeDetails::Node { .. } => panic!(
36444 "Expected a token {:?}, not an internal node",
36445 SyntaxKind::TokenSingleLineInnerComment
36446 ),
36447 }
36448 }
36449 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36450 match node.0.green.lookup_intern(db).details {
36451 GreenNodeDetails::Token(_) => Some(Self { node }),
36452 GreenNodeDetails::Node { .. } => None,
36453 }
36454 }
36455 fn as_syntax_node(&self) -> SyntaxNode {
36456 self.node.clone()
36457 }
36458 fn stable_ptr(&self) -> Self::StablePtr {
36459 TokenSingleLineInnerCommentPtr(self.node.0.stable_ptr)
36460 }
36461}
36462impl From<&TokenSingleLineInnerComment> for SyntaxStablePtrId {
36463 fn from(node: &TokenSingleLineInnerComment) -> Self {
36464 node.stable_ptr().untyped()
36465 }
36466}
36467#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36468pub struct TokenSingleLineDocComment {
36469 node: SyntaxNode,
36470}
36471impl Token for TokenSingleLineDocComment {
36472 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36473 TokenSingleLineDocCommentGreen(
36474 Arc::new(GreenNode {
36475 kind: SyntaxKind::TokenSingleLineDocComment,
36476 details: GreenNodeDetails::Token(text),
36477 })
36478 .intern(db),
36479 )
36480 }
36481 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36482 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36483 .clone()
36484 }
36485}
36486#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36487pub struct TokenSingleLineDocCommentPtr(pub SyntaxStablePtrId);
36488impl TypedStablePtr for TokenSingleLineDocCommentPtr {
36489 type SyntaxNode = TokenSingleLineDocComment;
36490 fn untyped(&self) -> SyntaxStablePtrId {
36491 self.0
36492 }
36493 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineDocComment {
36494 TokenSingleLineDocComment::from_syntax_node(db, self.0.lookup(db))
36495 }
36496}
36497impl From<TokenSingleLineDocCommentPtr> for SyntaxStablePtrId {
36498 fn from(ptr: TokenSingleLineDocCommentPtr) -> Self {
36499 ptr.untyped()
36500 }
36501}
36502#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36503pub struct TokenSingleLineDocCommentGreen(pub GreenId);
36504impl TokenSingleLineDocCommentGreen {
36505 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36506 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36507 }
36508}
36509impl TypedSyntaxNode for TokenSingleLineDocComment {
36510 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineDocComment);
36511 type StablePtr = TokenSingleLineDocCommentPtr;
36512 type Green = TokenSingleLineDocCommentGreen;
36513 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36514 TokenSingleLineDocCommentGreen(
36515 Arc::new(GreenNode {
36516 kind: SyntaxKind::TokenMissing,
36517 details: GreenNodeDetails::Token("".into()),
36518 })
36519 .intern(db),
36520 )
36521 }
36522 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36523 match node.0.green.lookup_intern(db).details {
36524 GreenNodeDetails::Token(_) => Self { node },
36525 GreenNodeDetails::Node { .. } => panic!(
36526 "Expected a token {:?}, not an internal node",
36527 SyntaxKind::TokenSingleLineDocComment
36528 ),
36529 }
36530 }
36531 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36532 match node.0.green.lookup_intern(db).details {
36533 GreenNodeDetails::Token(_) => Some(Self { node }),
36534 GreenNodeDetails::Node { .. } => None,
36535 }
36536 }
36537 fn as_syntax_node(&self) -> SyntaxNode {
36538 self.node.clone()
36539 }
36540 fn stable_ptr(&self) -> Self::StablePtr {
36541 TokenSingleLineDocCommentPtr(self.node.0.stable_ptr)
36542 }
36543}
36544impl From<&TokenSingleLineDocComment> for SyntaxStablePtrId {
36545 fn from(node: &TokenSingleLineDocComment) -> Self {
36546 node.stable_ptr().untyped()
36547 }
36548}
36549#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36550pub struct TokenWhitespace {
36551 node: SyntaxNode,
36552}
36553impl Token for TokenWhitespace {
36554 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36555 TokenWhitespaceGreen(
36556 Arc::new(GreenNode {
36557 kind: SyntaxKind::TokenWhitespace,
36558 details: GreenNodeDetails::Token(text),
36559 })
36560 .intern(db),
36561 )
36562 }
36563 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36564 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36565 .clone()
36566 }
36567}
36568#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36569pub struct TokenWhitespacePtr(pub SyntaxStablePtrId);
36570impl TypedStablePtr for TokenWhitespacePtr {
36571 type SyntaxNode = TokenWhitespace;
36572 fn untyped(&self) -> SyntaxStablePtrId {
36573 self.0
36574 }
36575 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenWhitespace {
36576 TokenWhitespace::from_syntax_node(db, self.0.lookup(db))
36577 }
36578}
36579impl From<TokenWhitespacePtr> for SyntaxStablePtrId {
36580 fn from(ptr: TokenWhitespacePtr) -> Self {
36581 ptr.untyped()
36582 }
36583}
36584#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36585pub struct TokenWhitespaceGreen(pub GreenId);
36586impl TokenWhitespaceGreen {
36587 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36588 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36589 }
36590}
36591impl TypedSyntaxNode for TokenWhitespace {
36592 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenWhitespace);
36593 type StablePtr = TokenWhitespacePtr;
36594 type Green = TokenWhitespaceGreen;
36595 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36596 TokenWhitespaceGreen(
36597 Arc::new(GreenNode {
36598 kind: SyntaxKind::TokenMissing,
36599 details: GreenNodeDetails::Token("".into()),
36600 })
36601 .intern(db),
36602 )
36603 }
36604 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36605 match node.0.green.lookup_intern(db).details {
36606 GreenNodeDetails::Token(_) => Self { node },
36607 GreenNodeDetails::Node { .. } => {
36608 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenWhitespace)
36609 }
36610 }
36611 }
36612 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36613 match node.0.green.lookup_intern(db).details {
36614 GreenNodeDetails::Token(_) => Some(Self { node }),
36615 GreenNodeDetails::Node { .. } => None,
36616 }
36617 }
36618 fn as_syntax_node(&self) -> SyntaxNode {
36619 self.node.clone()
36620 }
36621 fn stable_ptr(&self) -> Self::StablePtr {
36622 TokenWhitespacePtr(self.node.0.stable_ptr)
36623 }
36624}
36625impl From<&TokenWhitespace> for SyntaxStablePtrId {
36626 fn from(node: &TokenWhitespace) -> Self {
36627 node.stable_ptr().untyped()
36628 }
36629}
36630#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36631pub struct TokenNewline {
36632 node: SyntaxNode,
36633}
36634impl Token for TokenNewline {
36635 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36636 TokenNewlineGreen(
36637 Arc::new(GreenNode {
36638 kind: SyntaxKind::TokenNewline,
36639 details: GreenNodeDetails::Token(text),
36640 })
36641 .intern(db),
36642 )
36643 }
36644 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36645 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36646 .clone()
36647 }
36648}
36649#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36650pub struct TokenNewlinePtr(pub SyntaxStablePtrId);
36651impl TypedStablePtr for TokenNewlinePtr {
36652 type SyntaxNode = TokenNewline;
36653 fn untyped(&self) -> SyntaxStablePtrId {
36654 self.0
36655 }
36656 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNewline {
36657 TokenNewline::from_syntax_node(db, self.0.lookup(db))
36658 }
36659}
36660impl From<TokenNewlinePtr> for SyntaxStablePtrId {
36661 fn from(ptr: TokenNewlinePtr) -> Self {
36662 ptr.untyped()
36663 }
36664}
36665#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36666pub struct TokenNewlineGreen(pub GreenId);
36667impl TokenNewlineGreen {
36668 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36669 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36670 }
36671}
36672impl TypedSyntaxNode for TokenNewline {
36673 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNewline);
36674 type StablePtr = TokenNewlinePtr;
36675 type Green = TokenNewlineGreen;
36676 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36677 TokenNewlineGreen(
36678 Arc::new(GreenNode {
36679 kind: SyntaxKind::TokenMissing,
36680 details: GreenNodeDetails::Token("".into()),
36681 })
36682 .intern(db),
36683 )
36684 }
36685 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36686 match node.0.green.lookup_intern(db).details {
36687 GreenNodeDetails::Token(_) => Self { node },
36688 GreenNodeDetails::Node { .. } => {
36689 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNewline)
36690 }
36691 }
36692 }
36693 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36694 match node.0.green.lookup_intern(db).details {
36695 GreenNodeDetails::Token(_) => Some(Self { node }),
36696 GreenNodeDetails::Node { .. } => None,
36697 }
36698 }
36699 fn as_syntax_node(&self) -> SyntaxNode {
36700 self.node.clone()
36701 }
36702 fn stable_ptr(&self) -> Self::StablePtr {
36703 TokenNewlinePtr(self.node.0.stable_ptr)
36704 }
36705}
36706impl From<&TokenNewline> for SyntaxStablePtrId {
36707 fn from(node: &TokenNewline) -> Self {
36708 node.stable_ptr().untyped()
36709 }
36710}
36711#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36712pub struct TokenMissing {
36713 node: SyntaxNode,
36714}
36715impl Token for TokenMissing {
36716 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36717 TokenMissingGreen(
36718 Arc::new(GreenNode {
36719 kind: SyntaxKind::TokenMissing,
36720 details: GreenNodeDetails::Token(text),
36721 })
36722 .intern(db),
36723 )
36724 }
36725 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36726 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36727 .clone()
36728 }
36729}
36730#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36731pub struct TokenMissingPtr(pub SyntaxStablePtrId);
36732impl TypedStablePtr for TokenMissingPtr {
36733 type SyntaxNode = TokenMissing;
36734 fn untyped(&self) -> SyntaxStablePtrId {
36735 self.0
36736 }
36737 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMissing {
36738 TokenMissing::from_syntax_node(db, self.0.lookup(db))
36739 }
36740}
36741impl From<TokenMissingPtr> for SyntaxStablePtrId {
36742 fn from(ptr: TokenMissingPtr) -> Self {
36743 ptr.untyped()
36744 }
36745}
36746#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36747pub struct TokenMissingGreen(pub GreenId);
36748impl TokenMissingGreen {
36749 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36750 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36751 }
36752}
36753impl TypedSyntaxNode for TokenMissing {
36754 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMissing);
36755 type StablePtr = TokenMissingPtr;
36756 type Green = TokenMissingGreen;
36757 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36758 TokenMissingGreen(
36759 Arc::new(GreenNode {
36760 kind: SyntaxKind::TokenMissing,
36761 details: GreenNodeDetails::Token("".into()),
36762 })
36763 .intern(db),
36764 )
36765 }
36766 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36767 match node.0.green.lookup_intern(db).details {
36768 GreenNodeDetails::Token(_) => Self { node },
36769 GreenNodeDetails::Node { .. } => {
36770 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMissing)
36771 }
36772 }
36773 }
36774 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36775 match node.0.green.lookup_intern(db).details {
36776 GreenNodeDetails::Token(_) => Some(Self { node }),
36777 GreenNodeDetails::Node { .. } => None,
36778 }
36779 }
36780 fn as_syntax_node(&self) -> SyntaxNode {
36781 self.node.clone()
36782 }
36783 fn stable_ptr(&self) -> Self::StablePtr {
36784 TokenMissingPtr(self.node.0.stable_ptr)
36785 }
36786}
36787impl From<&TokenMissing> for SyntaxStablePtrId {
36788 fn from(node: &TokenMissing) -> Self {
36789 node.stable_ptr().untyped()
36790 }
36791}
36792#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36793pub struct TokenSkipped {
36794 node: SyntaxNode,
36795}
36796impl Token for TokenSkipped {
36797 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
36798 TokenSkippedGreen(
36799 Arc::new(GreenNode {
36800 kind: SyntaxKind::TokenSkipped,
36801 details: GreenNodeDetails::Token(text),
36802 })
36803 .intern(db),
36804 )
36805 }
36806 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36807 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
36808 .clone()
36809 }
36810}
36811#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36812pub struct TokenSkippedPtr(pub SyntaxStablePtrId);
36813impl TypedStablePtr for TokenSkippedPtr {
36814 type SyntaxNode = TokenSkipped;
36815 fn untyped(&self) -> SyntaxStablePtrId {
36816 self.0
36817 }
36818 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSkipped {
36819 TokenSkipped::from_syntax_node(db, self.0.lookup(db))
36820 }
36821}
36822impl From<TokenSkippedPtr> for SyntaxStablePtrId {
36823 fn from(ptr: TokenSkippedPtr) -> Self {
36824 ptr.untyped()
36825 }
36826}
36827#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36828pub struct TokenSkippedGreen(pub GreenId);
36829impl TokenSkippedGreen {
36830 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
36831 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
36832 }
36833}
36834impl TypedSyntaxNode for TokenSkipped {
36835 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSkipped);
36836 type StablePtr = TokenSkippedPtr;
36837 type Green = TokenSkippedGreen;
36838 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
36839 TokenSkippedGreen(
36840 Arc::new(GreenNode {
36841 kind: SyntaxKind::TokenMissing,
36842 details: GreenNodeDetails::Token("".into()),
36843 })
36844 .intern(db),
36845 )
36846 }
36847 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
36848 match node.0.green.lookup_intern(db).details {
36849 GreenNodeDetails::Token(_) => Self { node },
36850 GreenNodeDetails::Node { .. } => {
36851 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenSkipped)
36852 }
36853 }
36854 }
36855 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
36856 match node.0.green.lookup_intern(db).details {
36857 GreenNodeDetails::Token(_) => Some(Self { node }),
36858 GreenNodeDetails::Node { .. } => None,
36859 }
36860 }
36861 fn as_syntax_node(&self) -> SyntaxNode {
36862 self.node.clone()
36863 }
36864 fn stable_ptr(&self) -> Self::StablePtr {
36865 TokenSkippedPtr(self.node.0.stable_ptr)
36866 }
36867}
36868impl From<&TokenSkipped> for SyntaxStablePtrId {
36869 fn from(node: &TokenSkipped) -> Self {
36870 node.stable_ptr().untyped()
36871 }
36872}
36873#[derive(Clone, Debug, Eq, Hash, PartialEq)]
36874pub enum TokenNode {
36875 TerminalIdentifier(TerminalIdentifier),
36876 TerminalLiteralNumber(TerminalLiteralNumber),
36877 TerminalShortString(TerminalShortString),
36878 TerminalString(TerminalString),
36879 TerminalAs(TerminalAs),
36880 TerminalConst(TerminalConst),
36881 TerminalElse(TerminalElse),
36882 TerminalEnum(TerminalEnum),
36883 TerminalExtern(TerminalExtern),
36884 TerminalFalse(TerminalFalse),
36885 TerminalFunction(TerminalFunction),
36886 TerminalIf(TerminalIf),
36887 TerminalWhile(TerminalWhile),
36888 TerminalFor(TerminalFor),
36889 TerminalLoop(TerminalLoop),
36890 TerminalImpl(TerminalImpl),
36891 TerminalImplicits(TerminalImplicits),
36892 TerminalLet(TerminalLet),
36893 TerminalMatch(TerminalMatch),
36894 TerminalModule(TerminalModule),
36895 TerminalMut(TerminalMut),
36896 TerminalNoPanic(TerminalNoPanic),
36897 TerminalOf(TerminalOf),
36898 TerminalRef(TerminalRef),
36899 TerminalContinue(TerminalContinue),
36900 TerminalReturn(TerminalReturn),
36901 TerminalBreak(TerminalBreak),
36902 TerminalStruct(TerminalStruct),
36903 TerminalTrait(TerminalTrait),
36904 TerminalTrue(TerminalTrue),
36905 TerminalType(TerminalType),
36906 TerminalUse(TerminalUse),
36907 TerminalPub(TerminalPub),
36908 TerminalAnd(TerminalAnd),
36909 TerminalAndAnd(TerminalAndAnd),
36910 TerminalArrow(TerminalArrow),
36911 TerminalAt(TerminalAt),
36912 TerminalBadCharacters(TerminalBadCharacters),
36913 TerminalColon(TerminalColon),
36914 TerminalColonColon(TerminalColonColon),
36915 TerminalComma(TerminalComma),
36916 TerminalDiv(TerminalDiv),
36917 TerminalDivEq(TerminalDivEq),
36918 TerminalDot(TerminalDot),
36919 TerminalDotDot(TerminalDotDot),
36920 TerminalEndOfFile(TerminalEndOfFile),
36921 TerminalEq(TerminalEq),
36922 TerminalEqEq(TerminalEqEq),
36923 TerminalGE(TerminalGE),
36924 TerminalGT(TerminalGT),
36925 TerminalHash(TerminalHash),
36926 TerminalLBrace(TerminalLBrace),
36927 TerminalLBrack(TerminalLBrack),
36928 TerminalLE(TerminalLE),
36929 TerminalLParen(TerminalLParen),
36930 TerminalLT(TerminalLT),
36931 TerminalMatchArrow(TerminalMatchArrow),
36932 TerminalMinus(TerminalMinus),
36933 TerminalMinusEq(TerminalMinusEq),
36934 TerminalMod(TerminalMod),
36935 TerminalModEq(TerminalModEq),
36936 TerminalMul(TerminalMul),
36937 TerminalMulEq(TerminalMulEq),
36938 TerminalNeq(TerminalNeq),
36939 TerminalNot(TerminalNot),
36940 TerminalBitNot(TerminalBitNot),
36941 TerminalOr(TerminalOr),
36942 TerminalOrOr(TerminalOrOr),
36943 TerminalPlus(TerminalPlus),
36944 TerminalPlusEq(TerminalPlusEq),
36945 TerminalQuestionMark(TerminalQuestionMark),
36946 TerminalRBrace(TerminalRBrace),
36947 TerminalRBrack(TerminalRBrack),
36948 TerminalRParen(TerminalRParen),
36949 TerminalSemicolon(TerminalSemicolon),
36950 TerminalUnderscore(TerminalUnderscore),
36951 TerminalXor(TerminalXor),
36952 TerminalEmpty(TerminalEmpty),
36953}
36954#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
36955pub struct TokenNodePtr(pub SyntaxStablePtrId);
36956impl TypedStablePtr for TokenNodePtr {
36957 type SyntaxNode = TokenNode;
36958 fn untyped(&self) -> SyntaxStablePtrId {
36959 self.0
36960 }
36961 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNode {
36962 TokenNode::from_syntax_node(db, self.0.lookup(db))
36963 }
36964}
36965impl From<TokenNodePtr> for SyntaxStablePtrId {
36966 fn from(ptr: TokenNodePtr) -> Self {
36967 ptr.untyped()
36968 }
36969}
36970impl From<TerminalIdentifierPtr> for TokenNodePtr {
36971 fn from(value: TerminalIdentifierPtr) -> Self {
36972 Self(value.0)
36973 }
36974}
36975impl From<TerminalLiteralNumberPtr> for TokenNodePtr {
36976 fn from(value: TerminalLiteralNumberPtr) -> Self {
36977 Self(value.0)
36978 }
36979}
36980impl From<TerminalShortStringPtr> for TokenNodePtr {
36981 fn from(value: TerminalShortStringPtr) -> Self {
36982 Self(value.0)
36983 }
36984}
36985impl From<TerminalStringPtr> for TokenNodePtr {
36986 fn from(value: TerminalStringPtr) -> Self {
36987 Self(value.0)
36988 }
36989}
36990impl From<TerminalAsPtr> for TokenNodePtr {
36991 fn from(value: TerminalAsPtr) -> Self {
36992 Self(value.0)
36993 }
36994}
36995impl From<TerminalConstPtr> for TokenNodePtr {
36996 fn from(value: TerminalConstPtr) -> Self {
36997 Self(value.0)
36998 }
36999}
37000impl From<TerminalElsePtr> for TokenNodePtr {
37001 fn from(value: TerminalElsePtr) -> Self {
37002 Self(value.0)
37003 }
37004}
37005impl From<TerminalEnumPtr> for TokenNodePtr {
37006 fn from(value: TerminalEnumPtr) -> Self {
37007 Self(value.0)
37008 }
37009}
37010impl From<TerminalExternPtr> for TokenNodePtr {
37011 fn from(value: TerminalExternPtr) -> Self {
37012 Self(value.0)
37013 }
37014}
37015impl From<TerminalFalsePtr> for TokenNodePtr {
37016 fn from(value: TerminalFalsePtr) -> Self {
37017 Self(value.0)
37018 }
37019}
37020impl From<TerminalFunctionPtr> for TokenNodePtr {
37021 fn from(value: TerminalFunctionPtr) -> Self {
37022 Self(value.0)
37023 }
37024}
37025impl From<TerminalIfPtr> for TokenNodePtr {
37026 fn from(value: TerminalIfPtr) -> Self {
37027 Self(value.0)
37028 }
37029}
37030impl From<TerminalWhilePtr> for TokenNodePtr {
37031 fn from(value: TerminalWhilePtr) -> Self {
37032 Self(value.0)
37033 }
37034}
37035impl From<TerminalForPtr> for TokenNodePtr {
37036 fn from(value: TerminalForPtr) -> Self {
37037 Self(value.0)
37038 }
37039}
37040impl From<TerminalLoopPtr> for TokenNodePtr {
37041 fn from(value: TerminalLoopPtr) -> Self {
37042 Self(value.0)
37043 }
37044}
37045impl From<TerminalImplPtr> for TokenNodePtr {
37046 fn from(value: TerminalImplPtr) -> Self {
37047 Self(value.0)
37048 }
37049}
37050impl From<TerminalImplicitsPtr> for TokenNodePtr {
37051 fn from(value: TerminalImplicitsPtr) -> Self {
37052 Self(value.0)
37053 }
37054}
37055impl From<TerminalLetPtr> for TokenNodePtr {
37056 fn from(value: TerminalLetPtr) -> Self {
37057 Self(value.0)
37058 }
37059}
37060impl From<TerminalMatchPtr> for TokenNodePtr {
37061 fn from(value: TerminalMatchPtr) -> Self {
37062 Self(value.0)
37063 }
37064}
37065impl From<TerminalModulePtr> for TokenNodePtr {
37066 fn from(value: TerminalModulePtr) -> Self {
37067 Self(value.0)
37068 }
37069}
37070impl From<TerminalMutPtr> for TokenNodePtr {
37071 fn from(value: TerminalMutPtr) -> Self {
37072 Self(value.0)
37073 }
37074}
37075impl From<TerminalNoPanicPtr> for TokenNodePtr {
37076 fn from(value: TerminalNoPanicPtr) -> Self {
37077 Self(value.0)
37078 }
37079}
37080impl From<TerminalOfPtr> for TokenNodePtr {
37081 fn from(value: TerminalOfPtr) -> Self {
37082 Self(value.0)
37083 }
37084}
37085impl From<TerminalRefPtr> for TokenNodePtr {
37086 fn from(value: TerminalRefPtr) -> Self {
37087 Self(value.0)
37088 }
37089}
37090impl From<TerminalContinuePtr> for TokenNodePtr {
37091 fn from(value: TerminalContinuePtr) -> Self {
37092 Self(value.0)
37093 }
37094}
37095impl From<TerminalReturnPtr> for TokenNodePtr {
37096 fn from(value: TerminalReturnPtr) -> Self {
37097 Self(value.0)
37098 }
37099}
37100impl From<TerminalBreakPtr> for TokenNodePtr {
37101 fn from(value: TerminalBreakPtr) -> Self {
37102 Self(value.0)
37103 }
37104}
37105impl From<TerminalStructPtr> for TokenNodePtr {
37106 fn from(value: TerminalStructPtr) -> Self {
37107 Self(value.0)
37108 }
37109}
37110impl From<TerminalTraitPtr> for TokenNodePtr {
37111 fn from(value: TerminalTraitPtr) -> Self {
37112 Self(value.0)
37113 }
37114}
37115impl From<TerminalTruePtr> for TokenNodePtr {
37116 fn from(value: TerminalTruePtr) -> Self {
37117 Self(value.0)
37118 }
37119}
37120impl From<TerminalTypePtr> for TokenNodePtr {
37121 fn from(value: TerminalTypePtr) -> Self {
37122 Self(value.0)
37123 }
37124}
37125impl From<TerminalUsePtr> for TokenNodePtr {
37126 fn from(value: TerminalUsePtr) -> Self {
37127 Self(value.0)
37128 }
37129}
37130impl From<TerminalPubPtr> for TokenNodePtr {
37131 fn from(value: TerminalPubPtr) -> Self {
37132 Self(value.0)
37133 }
37134}
37135impl From<TerminalAndPtr> for TokenNodePtr {
37136 fn from(value: TerminalAndPtr) -> Self {
37137 Self(value.0)
37138 }
37139}
37140impl From<TerminalAndAndPtr> for TokenNodePtr {
37141 fn from(value: TerminalAndAndPtr) -> Self {
37142 Self(value.0)
37143 }
37144}
37145impl From<TerminalArrowPtr> for TokenNodePtr {
37146 fn from(value: TerminalArrowPtr) -> Self {
37147 Self(value.0)
37148 }
37149}
37150impl From<TerminalAtPtr> for TokenNodePtr {
37151 fn from(value: TerminalAtPtr) -> Self {
37152 Self(value.0)
37153 }
37154}
37155impl From<TerminalBadCharactersPtr> for TokenNodePtr {
37156 fn from(value: TerminalBadCharactersPtr) -> Self {
37157 Self(value.0)
37158 }
37159}
37160impl From<TerminalColonPtr> for TokenNodePtr {
37161 fn from(value: TerminalColonPtr) -> Self {
37162 Self(value.0)
37163 }
37164}
37165impl From<TerminalColonColonPtr> for TokenNodePtr {
37166 fn from(value: TerminalColonColonPtr) -> Self {
37167 Self(value.0)
37168 }
37169}
37170impl From<TerminalCommaPtr> for TokenNodePtr {
37171 fn from(value: TerminalCommaPtr) -> Self {
37172 Self(value.0)
37173 }
37174}
37175impl From<TerminalDivPtr> for TokenNodePtr {
37176 fn from(value: TerminalDivPtr) -> Self {
37177 Self(value.0)
37178 }
37179}
37180impl From<TerminalDivEqPtr> for TokenNodePtr {
37181 fn from(value: TerminalDivEqPtr) -> Self {
37182 Self(value.0)
37183 }
37184}
37185impl From<TerminalDotPtr> for TokenNodePtr {
37186 fn from(value: TerminalDotPtr) -> Self {
37187 Self(value.0)
37188 }
37189}
37190impl From<TerminalDotDotPtr> for TokenNodePtr {
37191 fn from(value: TerminalDotDotPtr) -> Self {
37192 Self(value.0)
37193 }
37194}
37195impl From<TerminalEndOfFilePtr> for TokenNodePtr {
37196 fn from(value: TerminalEndOfFilePtr) -> Self {
37197 Self(value.0)
37198 }
37199}
37200impl From<TerminalEqPtr> for TokenNodePtr {
37201 fn from(value: TerminalEqPtr) -> Self {
37202 Self(value.0)
37203 }
37204}
37205impl From<TerminalEqEqPtr> for TokenNodePtr {
37206 fn from(value: TerminalEqEqPtr) -> Self {
37207 Self(value.0)
37208 }
37209}
37210impl From<TerminalGEPtr> for TokenNodePtr {
37211 fn from(value: TerminalGEPtr) -> Self {
37212 Self(value.0)
37213 }
37214}
37215impl From<TerminalGTPtr> for TokenNodePtr {
37216 fn from(value: TerminalGTPtr) -> Self {
37217 Self(value.0)
37218 }
37219}
37220impl From<TerminalHashPtr> for TokenNodePtr {
37221 fn from(value: TerminalHashPtr) -> Self {
37222 Self(value.0)
37223 }
37224}
37225impl From<TerminalLBracePtr> for TokenNodePtr {
37226 fn from(value: TerminalLBracePtr) -> Self {
37227 Self(value.0)
37228 }
37229}
37230impl From<TerminalLBrackPtr> for TokenNodePtr {
37231 fn from(value: TerminalLBrackPtr) -> Self {
37232 Self(value.0)
37233 }
37234}
37235impl From<TerminalLEPtr> for TokenNodePtr {
37236 fn from(value: TerminalLEPtr) -> Self {
37237 Self(value.0)
37238 }
37239}
37240impl From<TerminalLParenPtr> for TokenNodePtr {
37241 fn from(value: TerminalLParenPtr) -> Self {
37242 Self(value.0)
37243 }
37244}
37245impl From<TerminalLTPtr> for TokenNodePtr {
37246 fn from(value: TerminalLTPtr) -> Self {
37247 Self(value.0)
37248 }
37249}
37250impl From<TerminalMatchArrowPtr> for TokenNodePtr {
37251 fn from(value: TerminalMatchArrowPtr) -> Self {
37252 Self(value.0)
37253 }
37254}
37255impl From<TerminalMinusPtr> for TokenNodePtr {
37256 fn from(value: TerminalMinusPtr) -> Self {
37257 Self(value.0)
37258 }
37259}
37260impl From<TerminalMinusEqPtr> for TokenNodePtr {
37261 fn from(value: TerminalMinusEqPtr) -> Self {
37262 Self(value.0)
37263 }
37264}
37265impl From<TerminalModPtr> for TokenNodePtr {
37266 fn from(value: TerminalModPtr) -> Self {
37267 Self(value.0)
37268 }
37269}
37270impl From<TerminalModEqPtr> for TokenNodePtr {
37271 fn from(value: TerminalModEqPtr) -> Self {
37272 Self(value.0)
37273 }
37274}
37275impl From<TerminalMulPtr> for TokenNodePtr {
37276 fn from(value: TerminalMulPtr) -> Self {
37277 Self(value.0)
37278 }
37279}
37280impl From<TerminalMulEqPtr> for TokenNodePtr {
37281 fn from(value: TerminalMulEqPtr) -> Self {
37282 Self(value.0)
37283 }
37284}
37285impl From<TerminalNeqPtr> for TokenNodePtr {
37286 fn from(value: TerminalNeqPtr) -> Self {
37287 Self(value.0)
37288 }
37289}
37290impl From<TerminalNotPtr> for TokenNodePtr {
37291 fn from(value: TerminalNotPtr) -> Self {
37292 Self(value.0)
37293 }
37294}
37295impl From<TerminalBitNotPtr> for TokenNodePtr {
37296 fn from(value: TerminalBitNotPtr) -> Self {
37297 Self(value.0)
37298 }
37299}
37300impl From<TerminalOrPtr> for TokenNodePtr {
37301 fn from(value: TerminalOrPtr) -> Self {
37302 Self(value.0)
37303 }
37304}
37305impl From<TerminalOrOrPtr> for TokenNodePtr {
37306 fn from(value: TerminalOrOrPtr) -> Self {
37307 Self(value.0)
37308 }
37309}
37310impl From<TerminalPlusPtr> for TokenNodePtr {
37311 fn from(value: TerminalPlusPtr) -> Self {
37312 Self(value.0)
37313 }
37314}
37315impl From<TerminalPlusEqPtr> for TokenNodePtr {
37316 fn from(value: TerminalPlusEqPtr) -> Self {
37317 Self(value.0)
37318 }
37319}
37320impl From<TerminalQuestionMarkPtr> for TokenNodePtr {
37321 fn from(value: TerminalQuestionMarkPtr) -> Self {
37322 Self(value.0)
37323 }
37324}
37325impl From<TerminalRBracePtr> for TokenNodePtr {
37326 fn from(value: TerminalRBracePtr) -> Self {
37327 Self(value.0)
37328 }
37329}
37330impl From<TerminalRBrackPtr> for TokenNodePtr {
37331 fn from(value: TerminalRBrackPtr) -> Self {
37332 Self(value.0)
37333 }
37334}
37335impl From<TerminalRParenPtr> for TokenNodePtr {
37336 fn from(value: TerminalRParenPtr) -> Self {
37337 Self(value.0)
37338 }
37339}
37340impl From<TerminalSemicolonPtr> for TokenNodePtr {
37341 fn from(value: TerminalSemicolonPtr) -> Self {
37342 Self(value.0)
37343 }
37344}
37345impl From<TerminalUnderscorePtr> for TokenNodePtr {
37346 fn from(value: TerminalUnderscorePtr) -> Self {
37347 Self(value.0)
37348 }
37349}
37350impl From<TerminalXorPtr> for TokenNodePtr {
37351 fn from(value: TerminalXorPtr) -> Self {
37352 Self(value.0)
37353 }
37354}
37355impl From<TerminalEmptyPtr> for TokenNodePtr {
37356 fn from(value: TerminalEmptyPtr) -> Self {
37357 Self(value.0)
37358 }
37359}
37360impl From<TerminalIdentifierGreen> for TokenNodeGreen {
37361 fn from(value: TerminalIdentifierGreen) -> Self {
37362 Self(value.0)
37363 }
37364}
37365impl From<TerminalLiteralNumberGreen> for TokenNodeGreen {
37366 fn from(value: TerminalLiteralNumberGreen) -> Self {
37367 Self(value.0)
37368 }
37369}
37370impl From<TerminalShortStringGreen> for TokenNodeGreen {
37371 fn from(value: TerminalShortStringGreen) -> Self {
37372 Self(value.0)
37373 }
37374}
37375impl From<TerminalStringGreen> for TokenNodeGreen {
37376 fn from(value: TerminalStringGreen) -> Self {
37377 Self(value.0)
37378 }
37379}
37380impl From<TerminalAsGreen> for TokenNodeGreen {
37381 fn from(value: TerminalAsGreen) -> Self {
37382 Self(value.0)
37383 }
37384}
37385impl From<TerminalConstGreen> for TokenNodeGreen {
37386 fn from(value: TerminalConstGreen) -> Self {
37387 Self(value.0)
37388 }
37389}
37390impl From<TerminalElseGreen> for TokenNodeGreen {
37391 fn from(value: TerminalElseGreen) -> Self {
37392 Self(value.0)
37393 }
37394}
37395impl From<TerminalEnumGreen> for TokenNodeGreen {
37396 fn from(value: TerminalEnumGreen) -> Self {
37397 Self(value.0)
37398 }
37399}
37400impl From<TerminalExternGreen> for TokenNodeGreen {
37401 fn from(value: TerminalExternGreen) -> Self {
37402 Self(value.0)
37403 }
37404}
37405impl From<TerminalFalseGreen> for TokenNodeGreen {
37406 fn from(value: TerminalFalseGreen) -> Self {
37407 Self(value.0)
37408 }
37409}
37410impl From<TerminalFunctionGreen> for TokenNodeGreen {
37411 fn from(value: TerminalFunctionGreen) -> Self {
37412 Self(value.0)
37413 }
37414}
37415impl From<TerminalIfGreen> for TokenNodeGreen {
37416 fn from(value: TerminalIfGreen) -> Self {
37417 Self(value.0)
37418 }
37419}
37420impl From<TerminalWhileGreen> for TokenNodeGreen {
37421 fn from(value: TerminalWhileGreen) -> Self {
37422 Self(value.0)
37423 }
37424}
37425impl From<TerminalForGreen> for TokenNodeGreen {
37426 fn from(value: TerminalForGreen) -> Self {
37427 Self(value.0)
37428 }
37429}
37430impl From<TerminalLoopGreen> for TokenNodeGreen {
37431 fn from(value: TerminalLoopGreen) -> Self {
37432 Self(value.0)
37433 }
37434}
37435impl From<TerminalImplGreen> for TokenNodeGreen {
37436 fn from(value: TerminalImplGreen) -> Self {
37437 Self(value.0)
37438 }
37439}
37440impl From<TerminalImplicitsGreen> for TokenNodeGreen {
37441 fn from(value: TerminalImplicitsGreen) -> Self {
37442 Self(value.0)
37443 }
37444}
37445impl From<TerminalLetGreen> for TokenNodeGreen {
37446 fn from(value: TerminalLetGreen) -> Self {
37447 Self(value.0)
37448 }
37449}
37450impl From<TerminalMatchGreen> for TokenNodeGreen {
37451 fn from(value: TerminalMatchGreen) -> Self {
37452 Self(value.0)
37453 }
37454}
37455impl From<TerminalModuleGreen> for TokenNodeGreen {
37456 fn from(value: TerminalModuleGreen) -> Self {
37457 Self(value.0)
37458 }
37459}
37460impl From<TerminalMutGreen> for TokenNodeGreen {
37461 fn from(value: TerminalMutGreen) -> Self {
37462 Self(value.0)
37463 }
37464}
37465impl From<TerminalNoPanicGreen> for TokenNodeGreen {
37466 fn from(value: TerminalNoPanicGreen) -> Self {
37467 Self(value.0)
37468 }
37469}
37470impl From<TerminalOfGreen> for TokenNodeGreen {
37471 fn from(value: TerminalOfGreen) -> Self {
37472 Self(value.0)
37473 }
37474}
37475impl From<TerminalRefGreen> for TokenNodeGreen {
37476 fn from(value: TerminalRefGreen) -> Self {
37477 Self(value.0)
37478 }
37479}
37480impl From<TerminalContinueGreen> for TokenNodeGreen {
37481 fn from(value: TerminalContinueGreen) -> Self {
37482 Self(value.0)
37483 }
37484}
37485impl From<TerminalReturnGreen> for TokenNodeGreen {
37486 fn from(value: TerminalReturnGreen) -> Self {
37487 Self(value.0)
37488 }
37489}
37490impl From<TerminalBreakGreen> for TokenNodeGreen {
37491 fn from(value: TerminalBreakGreen) -> Self {
37492 Self(value.0)
37493 }
37494}
37495impl From<TerminalStructGreen> for TokenNodeGreen {
37496 fn from(value: TerminalStructGreen) -> Self {
37497 Self(value.0)
37498 }
37499}
37500impl From<TerminalTraitGreen> for TokenNodeGreen {
37501 fn from(value: TerminalTraitGreen) -> Self {
37502 Self(value.0)
37503 }
37504}
37505impl From<TerminalTrueGreen> for TokenNodeGreen {
37506 fn from(value: TerminalTrueGreen) -> Self {
37507 Self(value.0)
37508 }
37509}
37510impl From<TerminalTypeGreen> for TokenNodeGreen {
37511 fn from(value: TerminalTypeGreen) -> Self {
37512 Self(value.0)
37513 }
37514}
37515impl From<TerminalUseGreen> for TokenNodeGreen {
37516 fn from(value: TerminalUseGreen) -> Self {
37517 Self(value.0)
37518 }
37519}
37520impl From<TerminalPubGreen> for TokenNodeGreen {
37521 fn from(value: TerminalPubGreen) -> Self {
37522 Self(value.0)
37523 }
37524}
37525impl From<TerminalAndGreen> for TokenNodeGreen {
37526 fn from(value: TerminalAndGreen) -> Self {
37527 Self(value.0)
37528 }
37529}
37530impl From<TerminalAndAndGreen> for TokenNodeGreen {
37531 fn from(value: TerminalAndAndGreen) -> Self {
37532 Self(value.0)
37533 }
37534}
37535impl From<TerminalArrowGreen> for TokenNodeGreen {
37536 fn from(value: TerminalArrowGreen) -> Self {
37537 Self(value.0)
37538 }
37539}
37540impl From<TerminalAtGreen> for TokenNodeGreen {
37541 fn from(value: TerminalAtGreen) -> Self {
37542 Self(value.0)
37543 }
37544}
37545impl From<TerminalBadCharactersGreen> for TokenNodeGreen {
37546 fn from(value: TerminalBadCharactersGreen) -> Self {
37547 Self(value.0)
37548 }
37549}
37550impl From<TerminalColonGreen> for TokenNodeGreen {
37551 fn from(value: TerminalColonGreen) -> Self {
37552 Self(value.0)
37553 }
37554}
37555impl From<TerminalColonColonGreen> for TokenNodeGreen {
37556 fn from(value: TerminalColonColonGreen) -> Self {
37557 Self(value.0)
37558 }
37559}
37560impl From<TerminalCommaGreen> for TokenNodeGreen {
37561 fn from(value: TerminalCommaGreen) -> Self {
37562 Self(value.0)
37563 }
37564}
37565impl From<TerminalDivGreen> for TokenNodeGreen {
37566 fn from(value: TerminalDivGreen) -> Self {
37567 Self(value.0)
37568 }
37569}
37570impl From<TerminalDivEqGreen> for TokenNodeGreen {
37571 fn from(value: TerminalDivEqGreen) -> Self {
37572 Self(value.0)
37573 }
37574}
37575impl From<TerminalDotGreen> for TokenNodeGreen {
37576 fn from(value: TerminalDotGreen) -> Self {
37577 Self(value.0)
37578 }
37579}
37580impl From<TerminalDotDotGreen> for TokenNodeGreen {
37581 fn from(value: TerminalDotDotGreen) -> Self {
37582 Self(value.0)
37583 }
37584}
37585impl From<TerminalEndOfFileGreen> for TokenNodeGreen {
37586 fn from(value: TerminalEndOfFileGreen) -> Self {
37587 Self(value.0)
37588 }
37589}
37590impl From<TerminalEqGreen> for TokenNodeGreen {
37591 fn from(value: TerminalEqGreen) -> Self {
37592 Self(value.0)
37593 }
37594}
37595impl From<TerminalEqEqGreen> for TokenNodeGreen {
37596 fn from(value: TerminalEqEqGreen) -> Self {
37597 Self(value.0)
37598 }
37599}
37600impl From<TerminalGEGreen> for TokenNodeGreen {
37601 fn from(value: TerminalGEGreen) -> Self {
37602 Self(value.0)
37603 }
37604}
37605impl From<TerminalGTGreen> for TokenNodeGreen {
37606 fn from(value: TerminalGTGreen) -> Self {
37607 Self(value.0)
37608 }
37609}
37610impl From<TerminalHashGreen> for TokenNodeGreen {
37611 fn from(value: TerminalHashGreen) -> Self {
37612 Self(value.0)
37613 }
37614}
37615impl From<TerminalLBraceGreen> for TokenNodeGreen {
37616 fn from(value: TerminalLBraceGreen) -> Self {
37617 Self(value.0)
37618 }
37619}
37620impl From<TerminalLBrackGreen> for TokenNodeGreen {
37621 fn from(value: TerminalLBrackGreen) -> Self {
37622 Self(value.0)
37623 }
37624}
37625impl From<TerminalLEGreen> for TokenNodeGreen {
37626 fn from(value: TerminalLEGreen) -> Self {
37627 Self(value.0)
37628 }
37629}
37630impl From<TerminalLParenGreen> for TokenNodeGreen {
37631 fn from(value: TerminalLParenGreen) -> Self {
37632 Self(value.0)
37633 }
37634}
37635impl From<TerminalLTGreen> for TokenNodeGreen {
37636 fn from(value: TerminalLTGreen) -> Self {
37637 Self(value.0)
37638 }
37639}
37640impl From<TerminalMatchArrowGreen> for TokenNodeGreen {
37641 fn from(value: TerminalMatchArrowGreen) -> Self {
37642 Self(value.0)
37643 }
37644}
37645impl From<TerminalMinusGreen> for TokenNodeGreen {
37646 fn from(value: TerminalMinusGreen) -> Self {
37647 Self(value.0)
37648 }
37649}
37650impl From<TerminalMinusEqGreen> for TokenNodeGreen {
37651 fn from(value: TerminalMinusEqGreen) -> Self {
37652 Self(value.0)
37653 }
37654}
37655impl From<TerminalModGreen> for TokenNodeGreen {
37656 fn from(value: TerminalModGreen) -> Self {
37657 Self(value.0)
37658 }
37659}
37660impl From<TerminalModEqGreen> for TokenNodeGreen {
37661 fn from(value: TerminalModEqGreen) -> Self {
37662 Self(value.0)
37663 }
37664}
37665impl From<TerminalMulGreen> for TokenNodeGreen {
37666 fn from(value: TerminalMulGreen) -> Self {
37667 Self(value.0)
37668 }
37669}
37670impl From<TerminalMulEqGreen> for TokenNodeGreen {
37671 fn from(value: TerminalMulEqGreen) -> Self {
37672 Self(value.0)
37673 }
37674}
37675impl From<TerminalNeqGreen> for TokenNodeGreen {
37676 fn from(value: TerminalNeqGreen) -> Self {
37677 Self(value.0)
37678 }
37679}
37680impl From<TerminalNotGreen> for TokenNodeGreen {
37681 fn from(value: TerminalNotGreen) -> Self {
37682 Self(value.0)
37683 }
37684}
37685impl From<TerminalBitNotGreen> for TokenNodeGreen {
37686 fn from(value: TerminalBitNotGreen) -> Self {
37687 Self(value.0)
37688 }
37689}
37690impl From<TerminalOrGreen> for TokenNodeGreen {
37691 fn from(value: TerminalOrGreen) -> Self {
37692 Self(value.0)
37693 }
37694}
37695impl From<TerminalOrOrGreen> for TokenNodeGreen {
37696 fn from(value: TerminalOrOrGreen) -> Self {
37697 Self(value.0)
37698 }
37699}
37700impl From<TerminalPlusGreen> for TokenNodeGreen {
37701 fn from(value: TerminalPlusGreen) -> Self {
37702 Self(value.0)
37703 }
37704}
37705impl From<TerminalPlusEqGreen> for TokenNodeGreen {
37706 fn from(value: TerminalPlusEqGreen) -> Self {
37707 Self(value.0)
37708 }
37709}
37710impl From<TerminalQuestionMarkGreen> for TokenNodeGreen {
37711 fn from(value: TerminalQuestionMarkGreen) -> Self {
37712 Self(value.0)
37713 }
37714}
37715impl From<TerminalRBraceGreen> for TokenNodeGreen {
37716 fn from(value: TerminalRBraceGreen) -> Self {
37717 Self(value.0)
37718 }
37719}
37720impl From<TerminalRBrackGreen> for TokenNodeGreen {
37721 fn from(value: TerminalRBrackGreen) -> Self {
37722 Self(value.0)
37723 }
37724}
37725impl From<TerminalRParenGreen> for TokenNodeGreen {
37726 fn from(value: TerminalRParenGreen) -> Self {
37727 Self(value.0)
37728 }
37729}
37730impl From<TerminalSemicolonGreen> for TokenNodeGreen {
37731 fn from(value: TerminalSemicolonGreen) -> Self {
37732 Self(value.0)
37733 }
37734}
37735impl From<TerminalUnderscoreGreen> for TokenNodeGreen {
37736 fn from(value: TerminalUnderscoreGreen) -> Self {
37737 Self(value.0)
37738 }
37739}
37740impl From<TerminalXorGreen> for TokenNodeGreen {
37741 fn from(value: TerminalXorGreen) -> Self {
37742 Self(value.0)
37743 }
37744}
37745impl From<TerminalEmptyGreen> for TokenNodeGreen {
37746 fn from(value: TerminalEmptyGreen) -> Self {
37747 Self(value.0)
37748 }
37749}
37750#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
37751pub struct TokenNodeGreen(pub GreenId);
37752impl TypedSyntaxNode for TokenNode {
37753 const OPTIONAL_KIND: Option<SyntaxKind> = None;
37754 type StablePtr = TokenNodePtr;
37755 type Green = TokenNodeGreen;
37756 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
37757 panic!("No missing variant.");
37758 }
37759 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
37760 let kind = node.kind(db);
37761 match kind {
37762 SyntaxKind::TerminalIdentifier => {
37763 TokenNode::TerminalIdentifier(TerminalIdentifier::from_syntax_node(db, node))
37764 }
37765 SyntaxKind::TerminalLiteralNumber => {
37766 TokenNode::TerminalLiteralNumber(TerminalLiteralNumber::from_syntax_node(db, node))
37767 }
37768 SyntaxKind::TerminalShortString => {
37769 TokenNode::TerminalShortString(TerminalShortString::from_syntax_node(db, node))
37770 }
37771 SyntaxKind::TerminalString => {
37772 TokenNode::TerminalString(TerminalString::from_syntax_node(db, node))
37773 }
37774 SyntaxKind::TerminalAs => TokenNode::TerminalAs(TerminalAs::from_syntax_node(db, node)),
37775 SyntaxKind::TerminalConst => {
37776 TokenNode::TerminalConst(TerminalConst::from_syntax_node(db, node))
37777 }
37778 SyntaxKind::TerminalElse => {
37779 TokenNode::TerminalElse(TerminalElse::from_syntax_node(db, node))
37780 }
37781 SyntaxKind::TerminalEnum => {
37782 TokenNode::TerminalEnum(TerminalEnum::from_syntax_node(db, node))
37783 }
37784 SyntaxKind::TerminalExtern => {
37785 TokenNode::TerminalExtern(TerminalExtern::from_syntax_node(db, node))
37786 }
37787 SyntaxKind::TerminalFalse => {
37788 TokenNode::TerminalFalse(TerminalFalse::from_syntax_node(db, node))
37789 }
37790 SyntaxKind::TerminalFunction => {
37791 TokenNode::TerminalFunction(TerminalFunction::from_syntax_node(db, node))
37792 }
37793 SyntaxKind::TerminalIf => TokenNode::TerminalIf(TerminalIf::from_syntax_node(db, node)),
37794 SyntaxKind::TerminalWhile => {
37795 TokenNode::TerminalWhile(TerminalWhile::from_syntax_node(db, node))
37796 }
37797 SyntaxKind::TerminalFor => {
37798 TokenNode::TerminalFor(TerminalFor::from_syntax_node(db, node))
37799 }
37800 SyntaxKind::TerminalLoop => {
37801 TokenNode::TerminalLoop(TerminalLoop::from_syntax_node(db, node))
37802 }
37803 SyntaxKind::TerminalImpl => {
37804 TokenNode::TerminalImpl(TerminalImpl::from_syntax_node(db, node))
37805 }
37806 SyntaxKind::TerminalImplicits => {
37807 TokenNode::TerminalImplicits(TerminalImplicits::from_syntax_node(db, node))
37808 }
37809 SyntaxKind::TerminalLet => {
37810 TokenNode::TerminalLet(TerminalLet::from_syntax_node(db, node))
37811 }
37812 SyntaxKind::TerminalMatch => {
37813 TokenNode::TerminalMatch(TerminalMatch::from_syntax_node(db, node))
37814 }
37815 SyntaxKind::TerminalModule => {
37816 TokenNode::TerminalModule(TerminalModule::from_syntax_node(db, node))
37817 }
37818 SyntaxKind::TerminalMut => {
37819 TokenNode::TerminalMut(TerminalMut::from_syntax_node(db, node))
37820 }
37821 SyntaxKind::TerminalNoPanic => {
37822 TokenNode::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node))
37823 }
37824 SyntaxKind::TerminalOf => TokenNode::TerminalOf(TerminalOf::from_syntax_node(db, node)),
37825 SyntaxKind::TerminalRef => {
37826 TokenNode::TerminalRef(TerminalRef::from_syntax_node(db, node))
37827 }
37828 SyntaxKind::TerminalContinue => {
37829 TokenNode::TerminalContinue(TerminalContinue::from_syntax_node(db, node))
37830 }
37831 SyntaxKind::TerminalReturn => {
37832 TokenNode::TerminalReturn(TerminalReturn::from_syntax_node(db, node))
37833 }
37834 SyntaxKind::TerminalBreak => {
37835 TokenNode::TerminalBreak(TerminalBreak::from_syntax_node(db, node))
37836 }
37837 SyntaxKind::TerminalStruct => {
37838 TokenNode::TerminalStruct(TerminalStruct::from_syntax_node(db, node))
37839 }
37840 SyntaxKind::TerminalTrait => {
37841 TokenNode::TerminalTrait(TerminalTrait::from_syntax_node(db, node))
37842 }
37843 SyntaxKind::TerminalTrue => {
37844 TokenNode::TerminalTrue(TerminalTrue::from_syntax_node(db, node))
37845 }
37846 SyntaxKind::TerminalType => {
37847 TokenNode::TerminalType(TerminalType::from_syntax_node(db, node))
37848 }
37849 SyntaxKind::TerminalUse => {
37850 TokenNode::TerminalUse(TerminalUse::from_syntax_node(db, node))
37851 }
37852 SyntaxKind::TerminalPub => {
37853 TokenNode::TerminalPub(TerminalPub::from_syntax_node(db, node))
37854 }
37855 SyntaxKind::TerminalAnd => {
37856 TokenNode::TerminalAnd(TerminalAnd::from_syntax_node(db, node))
37857 }
37858 SyntaxKind::TerminalAndAnd => {
37859 TokenNode::TerminalAndAnd(TerminalAndAnd::from_syntax_node(db, node))
37860 }
37861 SyntaxKind::TerminalArrow => {
37862 TokenNode::TerminalArrow(TerminalArrow::from_syntax_node(db, node))
37863 }
37864 SyntaxKind::TerminalAt => TokenNode::TerminalAt(TerminalAt::from_syntax_node(db, node)),
37865 SyntaxKind::TerminalBadCharacters => {
37866 TokenNode::TerminalBadCharacters(TerminalBadCharacters::from_syntax_node(db, node))
37867 }
37868 SyntaxKind::TerminalColon => {
37869 TokenNode::TerminalColon(TerminalColon::from_syntax_node(db, node))
37870 }
37871 SyntaxKind::TerminalColonColon => {
37872 TokenNode::TerminalColonColon(TerminalColonColon::from_syntax_node(db, node))
37873 }
37874 SyntaxKind::TerminalComma => {
37875 TokenNode::TerminalComma(TerminalComma::from_syntax_node(db, node))
37876 }
37877 SyntaxKind::TerminalDiv => {
37878 TokenNode::TerminalDiv(TerminalDiv::from_syntax_node(db, node))
37879 }
37880 SyntaxKind::TerminalDivEq => {
37881 TokenNode::TerminalDivEq(TerminalDivEq::from_syntax_node(db, node))
37882 }
37883 SyntaxKind::TerminalDot => {
37884 TokenNode::TerminalDot(TerminalDot::from_syntax_node(db, node))
37885 }
37886 SyntaxKind::TerminalDotDot => {
37887 TokenNode::TerminalDotDot(TerminalDotDot::from_syntax_node(db, node))
37888 }
37889 SyntaxKind::TerminalEndOfFile => {
37890 TokenNode::TerminalEndOfFile(TerminalEndOfFile::from_syntax_node(db, node))
37891 }
37892 SyntaxKind::TerminalEq => TokenNode::TerminalEq(TerminalEq::from_syntax_node(db, node)),
37893 SyntaxKind::TerminalEqEq => {
37894 TokenNode::TerminalEqEq(TerminalEqEq::from_syntax_node(db, node))
37895 }
37896 SyntaxKind::TerminalGE => TokenNode::TerminalGE(TerminalGE::from_syntax_node(db, node)),
37897 SyntaxKind::TerminalGT => TokenNode::TerminalGT(TerminalGT::from_syntax_node(db, node)),
37898 SyntaxKind::TerminalHash => {
37899 TokenNode::TerminalHash(TerminalHash::from_syntax_node(db, node))
37900 }
37901 SyntaxKind::TerminalLBrace => {
37902 TokenNode::TerminalLBrace(TerminalLBrace::from_syntax_node(db, node))
37903 }
37904 SyntaxKind::TerminalLBrack => {
37905 TokenNode::TerminalLBrack(TerminalLBrack::from_syntax_node(db, node))
37906 }
37907 SyntaxKind::TerminalLE => TokenNode::TerminalLE(TerminalLE::from_syntax_node(db, node)),
37908 SyntaxKind::TerminalLParen => {
37909 TokenNode::TerminalLParen(TerminalLParen::from_syntax_node(db, node))
37910 }
37911 SyntaxKind::TerminalLT => TokenNode::TerminalLT(TerminalLT::from_syntax_node(db, node)),
37912 SyntaxKind::TerminalMatchArrow => {
37913 TokenNode::TerminalMatchArrow(TerminalMatchArrow::from_syntax_node(db, node))
37914 }
37915 SyntaxKind::TerminalMinus => {
37916 TokenNode::TerminalMinus(TerminalMinus::from_syntax_node(db, node))
37917 }
37918 SyntaxKind::TerminalMinusEq => {
37919 TokenNode::TerminalMinusEq(TerminalMinusEq::from_syntax_node(db, node))
37920 }
37921 SyntaxKind::TerminalMod => {
37922 TokenNode::TerminalMod(TerminalMod::from_syntax_node(db, node))
37923 }
37924 SyntaxKind::TerminalModEq => {
37925 TokenNode::TerminalModEq(TerminalModEq::from_syntax_node(db, node))
37926 }
37927 SyntaxKind::TerminalMul => {
37928 TokenNode::TerminalMul(TerminalMul::from_syntax_node(db, node))
37929 }
37930 SyntaxKind::TerminalMulEq => {
37931 TokenNode::TerminalMulEq(TerminalMulEq::from_syntax_node(db, node))
37932 }
37933 SyntaxKind::TerminalNeq => {
37934 TokenNode::TerminalNeq(TerminalNeq::from_syntax_node(db, node))
37935 }
37936 SyntaxKind::TerminalNot => {
37937 TokenNode::TerminalNot(TerminalNot::from_syntax_node(db, node))
37938 }
37939 SyntaxKind::TerminalBitNot => {
37940 TokenNode::TerminalBitNot(TerminalBitNot::from_syntax_node(db, node))
37941 }
37942 SyntaxKind::TerminalOr => TokenNode::TerminalOr(TerminalOr::from_syntax_node(db, node)),
37943 SyntaxKind::TerminalOrOr => {
37944 TokenNode::TerminalOrOr(TerminalOrOr::from_syntax_node(db, node))
37945 }
37946 SyntaxKind::TerminalPlus => {
37947 TokenNode::TerminalPlus(TerminalPlus::from_syntax_node(db, node))
37948 }
37949 SyntaxKind::TerminalPlusEq => {
37950 TokenNode::TerminalPlusEq(TerminalPlusEq::from_syntax_node(db, node))
37951 }
37952 SyntaxKind::TerminalQuestionMark => {
37953 TokenNode::TerminalQuestionMark(TerminalQuestionMark::from_syntax_node(db, node))
37954 }
37955 SyntaxKind::TerminalRBrace => {
37956 TokenNode::TerminalRBrace(TerminalRBrace::from_syntax_node(db, node))
37957 }
37958 SyntaxKind::TerminalRBrack => {
37959 TokenNode::TerminalRBrack(TerminalRBrack::from_syntax_node(db, node))
37960 }
37961 SyntaxKind::TerminalRParen => {
37962 TokenNode::TerminalRParen(TerminalRParen::from_syntax_node(db, node))
37963 }
37964 SyntaxKind::TerminalSemicolon => {
37965 TokenNode::TerminalSemicolon(TerminalSemicolon::from_syntax_node(db, node))
37966 }
37967 SyntaxKind::TerminalUnderscore => {
37968 TokenNode::TerminalUnderscore(TerminalUnderscore::from_syntax_node(db, node))
37969 }
37970 SyntaxKind::TerminalXor => {
37971 TokenNode::TerminalXor(TerminalXor::from_syntax_node(db, node))
37972 }
37973 SyntaxKind::TerminalEmpty => {
37974 TokenNode::TerminalEmpty(TerminalEmpty::from_syntax_node(db, node))
37975 }
37976 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TokenNode"),
37977 }
37978 }
37979 fn cast(db: &dyn SyntaxGroup, node: SyntaxNode) -> Option<Self> {
37980 let kind = node.kind(db);
37981 match kind {
37982 SyntaxKind::TerminalIdentifier => {
37983 Some(TokenNode::TerminalIdentifier(TerminalIdentifier::from_syntax_node(db, node)))
37984 }
37985 SyntaxKind::TerminalLiteralNumber => Some(TokenNode::TerminalLiteralNumber(
37986 TerminalLiteralNumber::from_syntax_node(db, node),
37987 )),
37988 SyntaxKind::TerminalShortString => Some(TokenNode::TerminalShortString(
37989 TerminalShortString::from_syntax_node(db, node),
37990 )),
37991 SyntaxKind::TerminalString => {
37992 Some(TokenNode::TerminalString(TerminalString::from_syntax_node(db, node)))
37993 }
37994 SyntaxKind::TerminalAs => {
37995 Some(TokenNode::TerminalAs(TerminalAs::from_syntax_node(db, node)))
37996 }
37997 SyntaxKind::TerminalConst => {
37998 Some(TokenNode::TerminalConst(TerminalConst::from_syntax_node(db, node)))
37999 }
38000 SyntaxKind::TerminalElse => {
38001 Some(TokenNode::TerminalElse(TerminalElse::from_syntax_node(db, node)))
38002 }
38003 SyntaxKind::TerminalEnum => {
38004 Some(TokenNode::TerminalEnum(TerminalEnum::from_syntax_node(db, node)))
38005 }
38006 SyntaxKind::TerminalExtern => {
38007 Some(TokenNode::TerminalExtern(TerminalExtern::from_syntax_node(db, node)))
38008 }
38009 SyntaxKind::TerminalFalse => {
38010 Some(TokenNode::TerminalFalse(TerminalFalse::from_syntax_node(db, node)))
38011 }
38012 SyntaxKind::TerminalFunction => {
38013 Some(TokenNode::TerminalFunction(TerminalFunction::from_syntax_node(db, node)))
38014 }
38015 SyntaxKind::TerminalIf => {
38016 Some(TokenNode::TerminalIf(TerminalIf::from_syntax_node(db, node)))
38017 }
38018 SyntaxKind::TerminalWhile => {
38019 Some(TokenNode::TerminalWhile(TerminalWhile::from_syntax_node(db, node)))
38020 }
38021 SyntaxKind::TerminalFor => {
38022 Some(TokenNode::TerminalFor(TerminalFor::from_syntax_node(db, node)))
38023 }
38024 SyntaxKind::TerminalLoop => {
38025 Some(TokenNode::TerminalLoop(TerminalLoop::from_syntax_node(db, node)))
38026 }
38027 SyntaxKind::TerminalImpl => {
38028 Some(TokenNode::TerminalImpl(TerminalImpl::from_syntax_node(db, node)))
38029 }
38030 SyntaxKind::TerminalImplicits => {
38031 Some(TokenNode::TerminalImplicits(TerminalImplicits::from_syntax_node(db, node)))
38032 }
38033 SyntaxKind::TerminalLet => {
38034 Some(TokenNode::TerminalLet(TerminalLet::from_syntax_node(db, node)))
38035 }
38036 SyntaxKind::TerminalMatch => {
38037 Some(TokenNode::TerminalMatch(TerminalMatch::from_syntax_node(db, node)))
38038 }
38039 SyntaxKind::TerminalModule => {
38040 Some(TokenNode::TerminalModule(TerminalModule::from_syntax_node(db, node)))
38041 }
38042 SyntaxKind::TerminalMut => {
38043 Some(TokenNode::TerminalMut(TerminalMut::from_syntax_node(db, node)))
38044 }
38045 SyntaxKind::TerminalNoPanic => {
38046 Some(TokenNode::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node)))
38047 }
38048 SyntaxKind::TerminalOf => {
38049 Some(TokenNode::TerminalOf(TerminalOf::from_syntax_node(db, node)))
38050 }
38051 SyntaxKind::TerminalRef => {
38052 Some(TokenNode::TerminalRef(TerminalRef::from_syntax_node(db, node)))
38053 }
38054 SyntaxKind::TerminalContinue => {
38055 Some(TokenNode::TerminalContinue(TerminalContinue::from_syntax_node(db, node)))
38056 }
38057 SyntaxKind::TerminalReturn => {
38058 Some(TokenNode::TerminalReturn(TerminalReturn::from_syntax_node(db, node)))
38059 }
38060 SyntaxKind::TerminalBreak => {
38061 Some(TokenNode::TerminalBreak(TerminalBreak::from_syntax_node(db, node)))
38062 }
38063 SyntaxKind::TerminalStruct => {
38064 Some(TokenNode::TerminalStruct(TerminalStruct::from_syntax_node(db, node)))
38065 }
38066 SyntaxKind::TerminalTrait => {
38067 Some(TokenNode::TerminalTrait(TerminalTrait::from_syntax_node(db, node)))
38068 }
38069 SyntaxKind::TerminalTrue => {
38070 Some(TokenNode::TerminalTrue(TerminalTrue::from_syntax_node(db, node)))
38071 }
38072 SyntaxKind::TerminalType => {
38073 Some(TokenNode::TerminalType(TerminalType::from_syntax_node(db, node)))
38074 }
38075 SyntaxKind::TerminalUse => {
38076 Some(TokenNode::TerminalUse(TerminalUse::from_syntax_node(db, node)))
38077 }
38078 SyntaxKind::TerminalPub => {
38079 Some(TokenNode::TerminalPub(TerminalPub::from_syntax_node(db, node)))
38080 }
38081 SyntaxKind::TerminalAnd => {
38082 Some(TokenNode::TerminalAnd(TerminalAnd::from_syntax_node(db, node)))
38083 }
38084 SyntaxKind::TerminalAndAnd => {
38085 Some(TokenNode::TerminalAndAnd(TerminalAndAnd::from_syntax_node(db, node)))
38086 }
38087 SyntaxKind::TerminalArrow => {
38088 Some(TokenNode::TerminalArrow(TerminalArrow::from_syntax_node(db, node)))
38089 }
38090 SyntaxKind::TerminalAt => {
38091 Some(TokenNode::TerminalAt(TerminalAt::from_syntax_node(db, node)))
38092 }
38093 SyntaxKind::TerminalBadCharacters => Some(TokenNode::TerminalBadCharacters(
38094 TerminalBadCharacters::from_syntax_node(db, node),
38095 )),
38096 SyntaxKind::TerminalColon => {
38097 Some(TokenNode::TerminalColon(TerminalColon::from_syntax_node(db, node)))
38098 }
38099 SyntaxKind::TerminalColonColon => {
38100 Some(TokenNode::TerminalColonColon(TerminalColonColon::from_syntax_node(db, node)))
38101 }
38102 SyntaxKind::TerminalComma => {
38103 Some(TokenNode::TerminalComma(TerminalComma::from_syntax_node(db, node)))
38104 }
38105 SyntaxKind::TerminalDiv => {
38106 Some(TokenNode::TerminalDiv(TerminalDiv::from_syntax_node(db, node)))
38107 }
38108 SyntaxKind::TerminalDivEq => {
38109 Some(TokenNode::TerminalDivEq(TerminalDivEq::from_syntax_node(db, node)))
38110 }
38111 SyntaxKind::TerminalDot => {
38112 Some(TokenNode::TerminalDot(TerminalDot::from_syntax_node(db, node)))
38113 }
38114 SyntaxKind::TerminalDotDot => {
38115 Some(TokenNode::TerminalDotDot(TerminalDotDot::from_syntax_node(db, node)))
38116 }
38117 SyntaxKind::TerminalEndOfFile => {
38118 Some(TokenNode::TerminalEndOfFile(TerminalEndOfFile::from_syntax_node(db, node)))
38119 }
38120 SyntaxKind::TerminalEq => {
38121 Some(TokenNode::TerminalEq(TerminalEq::from_syntax_node(db, node)))
38122 }
38123 SyntaxKind::TerminalEqEq => {
38124 Some(TokenNode::TerminalEqEq(TerminalEqEq::from_syntax_node(db, node)))
38125 }
38126 SyntaxKind::TerminalGE => {
38127 Some(TokenNode::TerminalGE(TerminalGE::from_syntax_node(db, node)))
38128 }
38129 SyntaxKind::TerminalGT => {
38130 Some(TokenNode::TerminalGT(TerminalGT::from_syntax_node(db, node)))
38131 }
38132 SyntaxKind::TerminalHash => {
38133 Some(TokenNode::TerminalHash(TerminalHash::from_syntax_node(db, node)))
38134 }
38135 SyntaxKind::TerminalLBrace => {
38136 Some(TokenNode::TerminalLBrace(TerminalLBrace::from_syntax_node(db, node)))
38137 }
38138 SyntaxKind::TerminalLBrack => {
38139 Some(TokenNode::TerminalLBrack(TerminalLBrack::from_syntax_node(db, node)))
38140 }
38141 SyntaxKind::TerminalLE => {
38142 Some(TokenNode::TerminalLE(TerminalLE::from_syntax_node(db, node)))
38143 }
38144 SyntaxKind::TerminalLParen => {
38145 Some(TokenNode::TerminalLParen(TerminalLParen::from_syntax_node(db, node)))
38146 }
38147 SyntaxKind::TerminalLT => {
38148 Some(TokenNode::TerminalLT(TerminalLT::from_syntax_node(db, node)))
38149 }
38150 SyntaxKind::TerminalMatchArrow => {
38151 Some(TokenNode::TerminalMatchArrow(TerminalMatchArrow::from_syntax_node(db, node)))
38152 }
38153 SyntaxKind::TerminalMinus => {
38154 Some(TokenNode::TerminalMinus(TerminalMinus::from_syntax_node(db, node)))
38155 }
38156 SyntaxKind::TerminalMinusEq => {
38157 Some(TokenNode::TerminalMinusEq(TerminalMinusEq::from_syntax_node(db, node)))
38158 }
38159 SyntaxKind::TerminalMod => {
38160 Some(TokenNode::TerminalMod(TerminalMod::from_syntax_node(db, node)))
38161 }
38162 SyntaxKind::TerminalModEq => {
38163 Some(TokenNode::TerminalModEq(TerminalModEq::from_syntax_node(db, node)))
38164 }
38165 SyntaxKind::TerminalMul => {
38166 Some(TokenNode::TerminalMul(TerminalMul::from_syntax_node(db, node)))
38167 }
38168 SyntaxKind::TerminalMulEq => {
38169 Some(TokenNode::TerminalMulEq(TerminalMulEq::from_syntax_node(db, node)))
38170 }
38171 SyntaxKind::TerminalNeq => {
38172 Some(TokenNode::TerminalNeq(TerminalNeq::from_syntax_node(db, node)))
38173 }
38174 SyntaxKind::TerminalNot => {
38175 Some(TokenNode::TerminalNot(TerminalNot::from_syntax_node(db, node)))
38176 }
38177 SyntaxKind::TerminalBitNot => {
38178 Some(TokenNode::TerminalBitNot(TerminalBitNot::from_syntax_node(db, node)))
38179 }
38180 SyntaxKind::TerminalOr => {
38181 Some(TokenNode::TerminalOr(TerminalOr::from_syntax_node(db, node)))
38182 }
38183 SyntaxKind::TerminalOrOr => {
38184 Some(TokenNode::TerminalOrOr(TerminalOrOr::from_syntax_node(db, node)))
38185 }
38186 SyntaxKind::TerminalPlus => {
38187 Some(TokenNode::TerminalPlus(TerminalPlus::from_syntax_node(db, node)))
38188 }
38189 SyntaxKind::TerminalPlusEq => {
38190 Some(TokenNode::TerminalPlusEq(TerminalPlusEq::from_syntax_node(db, node)))
38191 }
38192 SyntaxKind::TerminalQuestionMark => Some(TokenNode::TerminalQuestionMark(
38193 TerminalQuestionMark::from_syntax_node(db, node),
38194 )),
38195 SyntaxKind::TerminalRBrace => {
38196 Some(TokenNode::TerminalRBrace(TerminalRBrace::from_syntax_node(db, node)))
38197 }
38198 SyntaxKind::TerminalRBrack => {
38199 Some(TokenNode::TerminalRBrack(TerminalRBrack::from_syntax_node(db, node)))
38200 }
38201 SyntaxKind::TerminalRParen => {
38202 Some(TokenNode::TerminalRParen(TerminalRParen::from_syntax_node(db, node)))
38203 }
38204 SyntaxKind::TerminalSemicolon => {
38205 Some(TokenNode::TerminalSemicolon(TerminalSemicolon::from_syntax_node(db, node)))
38206 }
38207 SyntaxKind::TerminalUnderscore => {
38208 Some(TokenNode::TerminalUnderscore(TerminalUnderscore::from_syntax_node(db, node)))
38209 }
38210 SyntaxKind::TerminalXor => {
38211 Some(TokenNode::TerminalXor(TerminalXor::from_syntax_node(db, node)))
38212 }
38213 SyntaxKind::TerminalEmpty => {
38214 Some(TokenNode::TerminalEmpty(TerminalEmpty::from_syntax_node(db, node)))
38215 }
38216 _ => None,
38217 }
38218 }
38219 fn as_syntax_node(&self) -> SyntaxNode {
38220 match self {
38221 TokenNode::TerminalIdentifier(x) => x.as_syntax_node(),
38222 TokenNode::TerminalLiteralNumber(x) => x.as_syntax_node(),
38223 TokenNode::TerminalShortString(x) => x.as_syntax_node(),
38224 TokenNode::TerminalString(x) => x.as_syntax_node(),
38225 TokenNode::TerminalAs(x) => x.as_syntax_node(),
38226 TokenNode::TerminalConst(x) => x.as_syntax_node(),
38227 TokenNode::TerminalElse(x) => x.as_syntax_node(),
38228 TokenNode::TerminalEnum(x) => x.as_syntax_node(),
38229 TokenNode::TerminalExtern(x) => x.as_syntax_node(),
38230 TokenNode::TerminalFalse(x) => x.as_syntax_node(),
38231 TokenNode::TerminalFunction(x) => x.as_syntax_node(),
38232 TokenNode::TerminalIf(x) => x.as_syntax_node(),
38233 TokenNode::TerminalWhile(x) => x.as_syntax_node(),
38234 TokenNode::TerminalFor(x) => x.as_syntax_node(),
38235 TokenNode::TerminalLoop(x) => x.as_syntax_node(),
38236 TokenNode::TerminalImpl(x) => x.as_syntax_node(),
38237 TokenNode::TerminalImplicits(x) => x.as_syntax_node(),
38238 TokenNode::TerminalLet(x) => x.as_syntax_node(),
38239 TokenNode::TerminalMatch(x) => x.as_syntax_node(),
38240 TokenNode::TerminalModule(x) => x.as_syntax_node(),
38241 TokenNode::TerminalMut(x) => x.as_syntax_node(),
38242 TokenNode::TerminalNoPanic(x) => x.as_syntax_node(),
38243 TokenNode::TerminalOf(x) => x.as_syntax_node(),
38244 TokenNode::TerminalRef(x) => x.as_syntax_node(),
38245 TokenNode::TerminalContinue(x) => x.as_syntax_node(),
38246 TokenNode::TerminalReturn(x) => x.as_syntax_node(),
38247 TokenNode::TerminalBreak(x) => x.as_syntax_node(),
38248 TokenNode::TerminalStruct(x) => x.as_syntax_node(),
38249 TokenNode::TerminalTrait(x) => x.as_syntax_node(),
38250 TokenNode::TerminalTrue(x) => x.as_syntax_node(),
38251 TokenNode::TerminalType(x) => x.as_syntax_node(),
38252 TokenNode::TerminalUse(x) => x.as_syntax_node(),
38253 TokenNode::TerminalPub(x) => x.as_syntax_node(),
38254 TokenNode::TerminalAnd(x) => x.as_syntax_node(),
38255 TokenNode::TerminalAndAnd(x) => x.as_syntax_node(),
38256 TokenNode::TerminalArrow(x) => x.as_syntax_node(),
38257 TokenNode::TerminalAt(x) => x.as_syntax_node(),
38258 TokenNode::TerminalBadCharacters(x) => x.as_syntax_node(),
38259 TokenNode::TerminalColon(x) => x.as_syntax_node(),
38260 TokenNode::TerminalColonColon(x) => x.as_syntax_node(),
38261 TokenNode::TerminalComma(x) => x.as_syntax_node(),
38262 TokenNode::TerminalDiv(x) => x.as_syntax_node(),
38263 TokenNode::TerminalDivEq(x) => x.as_syntax_node(),
38264 TokenNode::TerminalDot(x) => x.as_syntax_node(),
38265 TokenNode::TerminalDotDot(x) => x.as_syntax_node(),
38266 TokenNode::TerminalEndOfFile(x) => x.as_syntax_node(),
38267 TokenNode::TerminalEq(x) => x.as_syntax_node(),
38268 TokenNode::TerminalEqEq(x) => x.as_syntax_node(),
38269 TokenNode::TerminalGE(x) => x.as_syntax_node(),
38270 TokenNode::TerminalGT(x) => x.as_syntax_node(),
38271 TokenNode::TerminalHash(x) => x.as_syntax_node(),
38272 TokenNode::TerminalLBrace(x) => x.as_syntax_node(),
38273 TokenNode::TerminalLBrack(x) => x.as_syntax_node(),
38274 TokenNode::TerminalLE(x) => x.as_syntax_node(),
38275 TokenNode::TerminalLParen(x) => x.as_syntax_node(),
38276 TokenNode::TerminalLT(x) => x.as_syntax_node(),
38277 TokenNode::TerminalMatchArrow(x) => x.as_syntax_node(),
38278 TokenNode::TerminalMinus(x) => x.as_syntax_node(),
38279 TokenNode::TerminalMinusEq(x) => x.as_syntax_node(),
38280 TokenNode::TerminalMod(x) => x.as_syntax_node(),
38281 TokenNode::TerminalModEq(x) => x.as_syntax_node(),
38282 TokenNode::TerminalMul(x) => x.as_syntax_node(),
38283 TokenNode::TerminalMulEq(x) => x.as_syntax_node(),
38284 TokenNode::TerminalNeq(x) => x.as_syntax_node(),
38285 TokenNode::TerminalNot(x) => x.as_syntax_node(),
38286 TokenNode::TerminalBitNot(x) => x.as_syntax_node(),
38287 TokenNode::TerminalOr(x) => x.as_syntax_node(),
38288 TokenNode::TerminalOrOr(x) => x.as_syntax_node(),
38289 TokenNode::TerminalPlus(x) => x.as_syntax_node(),
38290 TokenNode::TerminalPlusEq(x) => x.as_syntax_node(),
38291 TokenNode::TerminalQuestionMark(x) => x.as_syntax_node(),
38292 TokenNode::TerminalRBrace(x) => x.as_syntax_node(),
38293 TokenNode::TerminalRBrack(x) => x.as_syntax_node(),
38294 TokenNode::TerminalRParen(x) => x.as_syntax_node(),
38295 TokenNode::TerminalSemicolon(x) => x.as_syntax_node(),
38296 TokenNode::TerminalUnderscore(x) => x.as_syntax_node(),
38297 TokenNode::TerminalXor(x) => x.as_syntax_node(),
38298 TokenNode::TerminalEmpty(x) => x.as_syntax_node(),
38299 }
38300 }
38301 fn stable_ptr(&self) -> Self::StablePtr {
38302 TokenNodePtr(self.as_syntax_node().0.stable_ptr)
38303 }
38304}
38305impl From<&TokenNode> for SyntaxStablePtrId {
38306 fn from(node: &TokenNode) -> Self {
38307 node.stable_ptr().untyped()
38308 }
38309}
38310impl TokenNode {
38311 pub fn is_variant(kind: SyntaxKind) -> bool {
38313 matches!(
38314 kind,
38315 SyntaxKind::TerminalIdentifier
38316 | SyntaxKind::TerminalLiteralNumber
38317 | SyntaxKind::TerminalShortString
38318 | SyntaxKind::TerminalString
38319 | SyntaxKind::TerminalAs
38320 | SyntaxKind::TerminalConst
38321 | SyntaxKind::TerminalElse
38322 | SyntaxKind::TerminalEnum
38323 | SyntaxKind::TerminalExtern
38324 | SyntaxKind::TerminalFalse
38325 | SyntaxKind::TerminalFunction
38326 | SyntaxKind::TerminalIf
38327 | SyntaxKind::TerminalWhile
38328 | SyntaxKind::TerminalFor
38329 | SyntaxKind::TerminalLoop
38330 | SyntaxKind::TerminalImpl
38331 | SyntaxKind::TerminalImplicits
38332 | SyntaxKind::TerminalLet
38333 | SyntaxKind::TerminalMatch
38334 | SyntaxKind::TerminalModule
38335 | SyntaxKind::TerminalMut
38336 | SyntaxKind::TerminalNoPanic
38337 | SyntaxKind::TerminalOf
38338 | SyntaxKind::TerminalRef
38339 | SyntaxKind::TerminalContinue
38340 | SyntaxKind::TerminalReturn
38341 | SyntaxKind::TerminalBreak
38342 | SyntaxKind::TerminalStruct
38343 | SyntaxKind::TerminalTrait
38344 | SyntaxKind::TerminalTrue
38345 | SyntaxKind::TerminalType
38346 | SyntaxKind::TerminalUse
38347 | SyntaxKind::TerminalPub
38348 | SyntaxKind::TerminalAnd
38349 | SyntaxKind::TerminalAndAnd
38350 | SyntaxKind::TerminalArrow
38351 | SyntaxKind::TerminalAt
38352 | SyntaxKind::TerminalBadCharacters
38353 | SyntaxKind::TerminalColon
38354 | SyntaxKind::TerminalColonColon
38355 | SyntaxKind::TerminalComma
38356 | SyntaxKind::TerminalDiv
38357 | SyntaxKind::TerminalDivEq
38358 | SyntaxKind::TerminalDot
38359 | SyntaxKind::TerminalDotDot
38360 | SyntaxKind::TerminalEndOfFile
38361 | SyntaxKind::TerminalEq
38362 | SyntaxKind::TerminalEqEq
38363 | SyntaxKind::TerminalGE
38364 | SyntaxKind::TerminalGT
38365 | SyntaxKind::TerminalHash
38366 | SyntaxKind::TerminalLBrace
38367 | SyntaxKind::TerminalLBrack
38368 | SyntaxKind::TerminalLE
38369 | SyntaxKind::TerminalLParen
38370 | SyntaxKind::TerminalLT
38371 | SyntaxKind::TerminalMatchArrow
38372 | SyntaxKind::TerminalMinus
38373 | SyntaxKind::TerminalMinusEq
38374 | SyntaxKind::TerminalMod
38375 | SyntaxKind::TerminalModEq
38376 | SyntaxKind::TerminalMul
38377 | SyntaxKind::TerminalMulEq
38378 | SyntaxKind::TerminalNeq
38379 | SyntaxKind::TerminalNot
38380 | SyntaxKind::TerminalBitNot
38381 | SyntaxKind::TerminalOr
38382 | SyntaxKind::TerminalOrOr
38383 | SyntaxKind::TerminalPlus
38384 | SyntaxKind::TerminalPlusEq
38385 | SyntaxKind::TerminalQuestionMark
38386 | SyntaxKind::TerminalRBrace
38387 | SyntaxKind::TerminalRBrack
38388 | SyntaxKind::TerminalRParen
38389 | SyntaxKind::TerminalSemicolon
38390 | SyntaxKind::TerminalUnderscore
38391 | SyntaxKind::TerminalXor
38392 | SyntaxKind::TerminalEmpty
38393 )
38394 }
38395}