cairo_lang_syntax/node/
ast.rs

1// Autogenerated file. To regenerate, please run `cargo run --bin generate-syntax`.
2#![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    /// Checks if a kind of a variant of [Trivium].
271    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    /// Checks if a kind of a variant of [Expr].
733    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    /// Checks if a kind of a variant of [ArgClause].
1070    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    /// Checks if a kind of a variant of [PathSegment].
1742    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    /// Checks if a kind of a variant of [OptionTerminalColonColon].
1934    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    /// Checks if a kind of a variant of [UnaryOperator].
2575    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    /// Checks if a kind of a variant of [BinaryOperator].
3169    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    /// Checks if a kind of a variant of [OptionArgListParenthesized].
3611    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    /// Checks if a kind of a variant of [Condition].
4531    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    /// Checks if a kind of a variant of [BlockOrIf].
4819    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    /// Checks if a kind of a variant of [OptionElseClause].
5344    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    /// Checks if a kind of a variant of [OptionFixedSizeArraySize].
6055    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    /// Checks if a kind of a variant of [ClosureParamWrapper].
6346    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    /// Checks if a kind of a variant of [OptionStructArgExpr].
6651    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    /// Checks if a kind of a variant of [StructArg].
7039    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    /// Checks if a kind of a variant of [WrappedArgList].
7490    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    /// Checks if a kind of a variant of [Pattern].
7838    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    /// Checks if a kind of a variant of [PatternStructParam].
8708    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    /// Checks if a kind of a variant of [OptionPatternEnumInnerPattern].
9137    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    /// Checks if a kind of a variant of [OptionTypeClause].
9416    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    /// Checks if a kind of a variant of [OptionReturnTypeClause].
9696    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    /// Checks if a kind of a variant of [Statement].
9958    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    /// Checks if a kind of a variant of [OptionTerminalSemicolon].
10362    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    /// Checks if a kind of a variant of [OptionExprClause].
10846    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    /// Checks if a kind of a variant of [Modifier].
11524    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    /// Checks if a kind of a variant of [OptionImplicitsClause].
11940    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    /// Checks if a kind of a variant of [OptionTerminalNoPanic].
12121    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    /// Checks if a kind of a variant of [ModuleItem].
13082    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    /// Checks if a kind of a variant of [OptionVisibilityPubArgumentClause].
13747    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    /// Checks if a kind of a variant of [Visibility].
14030    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    /// Checks if a kind of a variant of [MaybeModuleBody].
14250    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    /// Checks if a kind of a variant of [MaybeTraitBody].
15258    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    /// Checks if a kind of a variant of [TraitItem].
15583    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    /// Checks if a kind of a variant of [MaybeTraitFunctionBody].
16284    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    /// Checks if a kind of a variant of [MaybeImplBody].
16738    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    /// Checks if a kind of a variant of [ImplItem].
17173    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    /// Checks if a kind of a variant of [UsePath].
18131    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    /// Checks if a kind of a variant of [OptionAliasClause].
18852    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    /// Checks if a kind of a variant of [GenericArg].
19030    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    /// Checks if a kind of a variant of [GenericArgValue].
19326    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    /// Checks if a kind of a variant of [OptionAssociatedItemConstraints].
20050    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    /// Checks if a kind of a variant of [OptionWrappedGenericParamList].
20242    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    /// Checks if a kind of a variant of [GenericParam].
20687    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    /// Checks if a kind of a variant of [SkippedNode].
21440    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    /// Checks if a kind of a variant of [TokenNode].
38312    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}