1#![allow(clippy::match_single_binding)]
3#![allow(clippy::too_many_arguments)]
4#![allow(dead_code)]
5#![allow(unused_variables)]
6use std::ops::Deref;
7use std::sync::Arc;
8
9use cairo_lang_filesystem::span::TextWidth;
10use cairo_lang_utils::{Intern, LookupIntern, extract_matches};
11use smol_str::SmolStr;
12
13use super::element_list::ElementList;
14use super::green::GreenNodeDetails;
15use super::kind::SyntaxKind;
16use super::{
17 GreenId, GreenNode, SyntaxGroup, SyntaxNode, SyntaxStablePtr, SyntaxStablePtrId, Terminal,
18 Token, TypedStablePtr, TypedSyntaxNode,
19};
20#[path = "ast_ext.rs"]
21mod ast_ext;
22#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23pub struct Trivia(ElementList<Trivium, 1>);
24impl Deref for Trivia {
25 type Target = ElementList<Trivium, 1>;
26 fn deref(&self) -> &Self::Target {
27 &self.0
28 }
29}
30impl Trivia {
31 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<TriviumGreen>) -> TriviaGreen {
32 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
33 TriviaGreen(
34 Arc::new(GreenNode {
35 kind: SyntaxKind::Trivia,
36 details: GreenNodeDetails::Node {
37 children: children.iter().map(|x| x.0).collect(),
38 width,
39 },
40 })
41 .intern(db),
42 )
43 }
44}
45#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
46pub struct TriviaPtr(pub SyntaxStablePtrId);
47impl TypedStablePtr for TriviaPtr {
48 type SyntaxNode = Trivia;
49 fn untyped(&self) -> SyntaxStablePtrId {
50 self.0
51 }
52 fn lookup(&self, db: &dyn SyntaxGroup) -> Trivia {
53 Trivia::from_syntax_node(db, self.0.lookup(db))
54 }
55}
56impl From<TriviaPtr> for SyntaxStablePtrId {
57 fn from(ptr: TriviaPtr) -> Self {
58 ptr.untyped()
59 }
60}
61#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
62pub struct TriviaGreen(pub GreenId);
63impl TypedSyntaxNode for Trivia {
64 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Trivia);
65 type StablePtr = TriviaPtr;
66 type Green = TriviaGreen;
67 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
68 TriviaGreen(
69 Arc::new(GreenNode {
70 kind: SyntaxKind::Trivia,
71 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
72 })
73 .intern(db),
74 )
75 }
76 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
77 Self(ElementList::new(node))
78 }
79 fn as_syntax_node(&self) -> SyntaxNode {
80 self.node.clone()
81 }
82 fn stable_ptr(&self) -> Self::StablePtr {
83 TriviaPtr(self.node.0.stable_ptr)
84 }
85}
86impl From<&Trivia> for SyntaxStablePtrId {
87 fn from(node: &Trivia) -> Self {
88 node.stable_ptr().untyped()
89 }
90}
91#[derive(Clone, Debug, Eq, Hash, PartialEq)]
92pub enum Trivium {
93 SingleLineComment(TokenSingleLineComment),
94 SingleLineDocComment(TokenSingleLineDocComment),
95 SingleLineInnerComment(TokenSingleLineInnerComment),
96 Whitespace(TokenWhitespace),
97 Newline(TokenNewline),
98 Skipped(TokenSkipped),
99 SkippedNode(TriviumSkippedNode),
100}
101#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
102pub struct TriviumPtr(pub SyntaxStablePtrId);
103impl TypedStablePtr for TriviumPtr {
104 type SyntaxNode = Trivium;
105 fn untyped(&self) -> SyntaxStablePtrId {
106 self.0
107 }
108 fn lookup(&self, db: &dyn SyntaxGroup) -> Trivium {
109 Trivium::from_syntax_node(db, self.0.lookup(db))
110 }
111}
112impl From<TriviumPtr> for SyntaxStablePtrId {
113 fn from(ptr: TriviumPtr) -> Self {
114 ptr.untyped()
115 }
116}
117impl From<TokenSingleLineCommentPtr> for TriviumPtr {
118 fn from(value: TokenSingleLineCommentPtr) -> Self {
119 Self(value.0)
120 }
121}
122impl From<TokenSingleLineDocCommentPtr> for TriviumPtr {
123 fn from(value: TokenSingleLineDocCommentPtr) -> Self {
124 Self(value.0)
125 }
126}
127impl From<TokenSingleLineInnerCommentPtr> for TriviumPtr {
128 fn from(value: TokenSingleLineInnerCommentPtr) -> Self {
129 Self(value.0)
130 }
131}
132impl From<TokenWhitespacePtr> for TriviumPtr {
133 fn from(value: TokenWhitespacePtr) -> Self {
134 Self(value.0)
135 }
136}
137impl From<TokenNewlinePtr> for TriviumPtr {
138 fn from(value: TokenNewlinePtr) -> Self {
139 Self(value.0)
140 }
141}
142impl From<TokenSkippedPtr> for TriviumPtr {
143 fn from(value: TokenSkippedPtr) -> Self {
144 Self(value.0)
145 }
146}
147impl From<TriviumSkippedNodePtr> for TriviumPtr {
148 fn from(value: TriviumSkippedNodePtr) -> Self {
149 Self(value.0)
150 }
151}
152impl From<TokenSingleLineCommentGreen> for TriviumGreen {
153 fn from(value: TokenSingleLineCommentGreen) -> Self {
154 Self(value.0)
155 }
156}
157impl From<TokenSingleLineDocCommentGreen> for TriviumGreen {
158 fn from(value: TokenSingleLineDocCommentGreen) -> Self {
159 Self(value.0)
160 }
161}
162impl From<TokenSingleLineInnerCommentGreen> for TriviumGreen {
163 fn from(value: TokenSingleLineInnerCommentGreen) -> Self {
164 Self(value.0)
165 }
166}
167impl From<TokenWhitespaceGreen> for TriviumGreen {
168 fn from(value: TokenWhitespaceGreen) -> Self {
169 Self(value.0)
170 }
171}
172impl From<TokenNewlineGreen> for TriviumGreen {
173 fn from(value: TokenNewlineGreen) -> Self {
174 Self(value.0)
175 }
176}
177impl From<TokenSkippedGreen> for TriviumGreen {
178 fn from(value: TokenSkippedGreen) -> Self {
179 Self(value.0)
180 }
181}
182impl From<TriviumSkippedNodeGreen> for TriviumGreen {
183 fn from(value: TriviumSkippedNodeGreen) -> Self {
184 Self(value.0)
185 }
186}
187#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
188pub struct TriviumGreen(pub GreenId);
189impl TypedSyntaxNode for Trivium {
190 const OPTIONAL_KIND: Option<SyntaxKind> = None;
191 type StablePtr = TriviumPtr;
192 type Green = TriviumGreen;
193 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
194 panic!("No missing variant.");
195 }
196 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
197 let kind = node.kind(db);
198 match kind {
199 SyntaxKind::TokenSingleLineComment => {
200 Trivium::SingleLineComment(TokenSingleLineComment::from_syntax_node(db, node))
201 }
202 SyntaxKind::TokenSingleLineDocComment => {
203 Trivium::SingleLineDocComment(TokenSingleLineDocComment::from_syntax_node(db, node))
204 }
205 SyntaxKind::TokenSingleLineInnerComment => Trivium::SingleLineInnerComment(
206 TokenSingleLineInnerComment::from_syntax_node(db, node),
207 ),
208 SyntaxKind::TokenWhitespace => {
209 Trivium::Whitespace(TokenWhitespace::from_syntax_node(db, node))
210 }
211 SyntaxKind::TokenNewline => Trivium::Newline(TokenNewline::from_syntax_node(db, node)),
212 SyntaxKind::TokenSkipped => Trivium::Skipped(TokenSkipped::from_syntax_node(db, node)),
213 SyntaxKind::TriviumSkippedNode => {
214 Trivium::SkippedNode(TriviumSkippedNode::from_syntax_node(db, node))
215 }
216 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Trivium"),
217 }
218 }
219 fn as_syntax_node(&self) -> SyntaxNode {
220 match self {
221 Trivium::SingleLineComment(x) => x.as_syntax_node(),
222 Trivium::SingleLineDocComment(x) => x.as_syntax_node(),
223 Trivium::SingleLineInnerComment(x) => x.as_syntax_node(),
224 Trivium::Whitespace(x) => x.as_syntax_node(),
225 Trivium::Newline(x) => x.as_syntax_node(),
226 Trivium::Skipped(x) => x.as_syntax_node(),
227 Trivium::SkippedNode(x) => x.as_syntax_node(),
228 }
229 }
230 fn stable_ptr(&self) -> Self::StablePtr {
231 TriviumPtr(self.as_syntax_node().0.stable_ptr)
232 }
233}
234impl From<&Trivium> for SyntaxStablePtrId {
235 fn from(node: &Trivium) -> Self {
236 node.stable_ptr().untyped()
237 }
238}
239impl Trivium {
240 pub fn is_variant(kind: SyntaxKind) -> bool {
242 matches!(
243 kind,
244 SyntaxKind::TokenSingleLineComment
245 | SyntaxKind::TokenSingleLineDocComment
246 | SyntaxKind::TokenSingleLineInnerComment
247 | SyntaxKind::TokenWhitespace
248 | SyntaxKind::TokenNewline
249 | SyntaxKind::TokenSkipped
250 | SyntaxKind::TriviumSkippedNode
251 )
252 }
253}
254#[derive(Clone, Debug, Eq, Hash, PartialEq)]
255pub enum Expr {
256 Path(ExprPath),
257 Literal(TerminalLiteralNumber),
258 ShortString(TerminalShortString),
259 String(TerminalString),
260 False(TerminalFalse),
261 True(TerminalTrue),
262 Parenthesized(ExprParenthesized),
263 Unary(ExprUnary),
264 Binary(ExprBinary),
265 Tuple(ExprListParenthesized),
266 FunctionCall(ExprFunctionCall),
267 StructCtorCall(ExprStructCtorCall),
268 Block(ExprBlock),
269 Match(ExprMatch),
270 If(ExprIf),
271 Loop(ExprLoop),
272 While(ExprWhile),
273 For(ExprFor),
274 Closure(ExprClosure),
275 ErrorPropagate(ExprErrorPropagate),
276 FieldInitShorthand(ExprFieldInitShorthand),
277 Indexed(ExprIndexed),
278 InlineMacro(ExprInlineMacro),
279 FixedSizeArray(ExprFixedSizeArray),
280 Missing(ExprMissing),
281}
282#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
283pub struct ExprPtr(pub SyntaxStablePtrId);
284impl TypedStablePtr for ExprPtr {
285 type SyntaxNode = Expr;
286 fn untyped(&self) -> SyntaxStablePtrId {
287 self.0
288 }
289 fn lookup(&self, db: &dyn SyntaxGroup) -> Expr {
290 Expr::from_syntax_node(db, self.0.lookup(db))
291 }
292}
293impl From<ExprPtr> for SyntaxStablePtrId {
294 fn from(ptr: ExprPtr) -> Self {
295 ptr.untyped()
296 }
297}
298impl From<ExprPathPtr> for ExprPtr {
299 fn from(value: ExprPathPtr) -> Self {
300 Self(value.0)
301 }
302}
303impl From<TerminalLiteralNumberPtr> for ExprPtr {
304 fn from(value: TerminalLiteralNumberPtr) -> Self {
305 Self(value.0)
306 }
307}
308impl From<TerminalShortStringPtr> for ExprPtr {
309 fn from(value: TerminalShortStringPtr) -> Self {
310 Self(value.0)
311 }
312}
313impl From<TerminalStringPtr> for ExprPtr {
314 fn from(value: TerminalStringPtr) -> Self {
315 Self(value.0)
316 }
317}
318impl From<TerminalFalsePtr> for ExprPtr {
319 fn from(value: TerminalFalsePtr) -> Self {
320 Self(value.0)
321 }
322}
323impl From<TerminalTruePtr> for ExprPtr {
324 fn from(value: TerminalTruePtr) -> Self {
325 Self(value.0)
326 }
327}
328impl From<ExprParenthesizedPtr> for ExprPtr {
329 fn from(value: ExprParenthesizedPtr) -> Self {
330 Self(value.0)
331 }
332}
333impl From<ExprUnaryPtr> for ExprPtr {
334 fn from(value: ExprUnaryPtr) -> Self {
335 Self(value.0)
336 }
337}
338impl From<ExprBinaryPtr> for ExprPtr {
339 fn from(value: ExprBinaryPtr) -> Self {
340 Self(value.0)
341 }
342}
343impl From<ExprListParenthesizedPtr> for ExprPtr {
344 fn from(value: ExprListParenthesizedPtr) -> Self {
345 Self(value.0)
346 }
347}
348impl From<ExprFunctionCallPtr> for ExprPtr {
349 fn from(value: ExprFunctionCallPtr) -> Self {
350 Self(value.0)
351 }
352}
353impl From<ExprStructCtorCallPtr> for ExprPtr {
354 fn from(value: ExprStructCtorCallPtr) -> Self {
355 Self(value.0)
356 }
357}
358impl From<ExprBlockPtr> for ExprPtr {
359 fn from(value: ExprBlockPtr) -> Self {
360 Self(value.0)
361 }
362}
363impl From<ExprMatchPtr> for ExprPtr {
364 fn from(value: ExprMatchPtr) -> Self {
365 Self(value.0)
366 }
367}
368impl From<ExprIfPtr> for ExprPtr {
369 fn from(value: ExprIfPtr) -> Self {
370 Self(value.0)
371 }
372}
373impl From<ExprLoopPtr> for ExprPtr {
374 fn from(value: ExprLoopPtr) -> Self {
375 Self(value.0)
376 }
377}
378impl From<ExprWhilePtr> for ExprPtr {
379 fn from(value: ExprWhilePtr) -> Self {
380 Self(value.0)
381 }
382}
383impl From<ExprForPtr> for ExprPtr {
384 fn from(value: ExprForPtr) -> Self {
385 Self(value.0)
386 }
387}
388impl From<ExprClosurePtr> for ExprPtr {
389 fn from(value: ExprClosurePtr) -> Self {
390 Self(value.0)
391 }
392}
393impl From<ExprErrorPropagatePtr> for ExprPtr {
394 fn from(value: ExprErrorPropagatePtr) -> Self {
395 Self(value.0)
396 }
397}
398impl From<ExprFieldInitShorthandPtr> for ExprPtr {
399 fn from(value: ExprFieldInitShorthandPtr) -> Self {
400 Self(value.0)
401 }
402}
403impl From<ExprIndexedPtr> for ExprPtr {
404 fn from(value: ExprIndexedPtr) -> Self {
405 Self(value.0)
406 }
407}
408impl From<ExprInlineMacroPtr> for ExprPtr {
409 fn from(value: ExprInlineMacroPtr) -> Self {
410 Self(value.0)
411 }
412}
413impl From<ExprFixedSizeArrayPtr> for ExprPtr {
414 fn from(value: ExprFixedSizeArrayPtr) -> Self {
415 Self(value.0)
416 }
417}
418impl From<ExprMissingPtr> for ExprPtr {
419 fn from(value: ExprMissingPtr) -> Self {
420 Self(value.0)
421 }
422}
423impl From<ExprPathGreen> for ExprGreen {
424 fn from(value: ExprPathGreen) -> Self {
425 Self(value.0)
426 }
427}
428impl From<TerminalLiteralNumberGreen> for ExprGreen {
429 fn from(value: TerminalLiteralNumberGreen) -> Self {
430 Self(value.0)
431 }
432}
433impl From<TerminalShortStringGreen> for ExprGreen {
434 fn from(value: TerminalShortStringGreen) -> Self {
435 Self(value.0)
436 }
437}
438impl From<TerminalStringGreen> for ExprGreen {
439 fn from(value: TerminalStringGreen) -> Self {
440 Self(value.0)
441 }
442}
443impl From<TerminalFalseGreen> for ExprGreen {
444 fn from(value: TerminalFalseGreen) -> Self {
445 Self(value.0)
446 }
447}
448impl From<TerminalTrueGreen> for ExprGreen {
449 fn from(value: TerminalTrueGreen) -> Self {
450 Self(value.0)
451 }
452}
453impl From<ExprParenthesizedGreen> for ExprGreen {
454 fn from(value: ExprParenthesizedGreen) -> Self {
455 Self(value.0)
456 }
457}
458impl From<ExprUnaryGreen> for ExprGreen {
459 fn from(value: ExprUnaryGreen) -> Self {
460 Self(value.0)
461 }
462}
463impl From<ExprBinaryGreen> for ExprGreen {
464 fn from(value: ExprBinaryGreen) -> Self {
465 Self(value.0)
466 }
467}
468impl From<ExprListParenthesizedGreen> for ExprGreen {
469 fn from(value: ExprListParenthesizedGreen) -> Self {
470 Self(value.0)
471 }
472}
473impl From<ExprFunctionCallGreen> for ExprGreen {
474 fn from(value: ExprFunctionCallGreen) -> Self {
475 Self(value.0)
476 }
477}
478impl From<ExprStructCtorCallGreen> for ExprGreen {
479 fn from(value: ExprStructCtorCallGreen) -> Self {
480 Self(value.0)
481 }
482}
483impl From<ExprBlockGreen> for ExprGreen {
484 fn from(value: ExprBlockGreen) -> Self {
485 Self(value.0)
486 }
487}
488impl From<ExprMatchGreen> for ExprGreen {
489 fn from(value: ExprMatchGreen) -> Self {
490 Self(value.0)
491 }
492}
493impl From<ExprIfGreen> for ExprGreen {
494 fn from(value: ExprIfGreen) -> Self {
495 Self(value.0)
496 }
497}
498impl From<ExprLoopGreen> for ExprGreen {
499 fn from(value: ExprLoopGreen) -> Self {
500 Self(value.0)
501 }
502}
503impl From<ExprWhileGreen> for ExprGreen {
504 fn from(value: ExprWhileGreen) -> Self {
505 Self(value.0)
506 }
507}
508impl From<ExprForGreen> for ExprGreen {
509 fn from(value: ExprForGreen) -> Self {
510 Self(value.0)
511 }
512}
513impl From<ExprClosureGreen> for ExprGreen {
514 fn from(value: ExprClosureGreen) -> Self {
515 Self(value.0)
516 }
517}
518impl From<ExprErrorPropagateGreen> for ExprGreen {
519 fn from(value: ExprErrorPropagateGreen) -> Self {
520 Self(value.0)
521 }
522}
523impl From<ExprFieldInitShorthandGreen> for ExprGreen {
524 fn from(value: ExprFieldInitShorthandGreen) -> Self {
525 Self(value.0)
526 }
527}
528impl From<ExprIndexedGreen> for ExprGreen {
529 fn from(value: ExprIndexedGreen) -> Self {
530 Self(value.0)
531 }
532}
533impl From<ExprInlineMacroGreen> for ExprGreen {
534 fn from(value: ExprInlineMacroGreen) -> Self {
535 Self(value.0)
536 }
537}
538impl From<ExprFixedSizeArrayGreen> for ExprGreen {
539 fn from(value: ExprFixedSizeArrayGreen) -> Self {
540 Self(value.0)
541 }
542}
543impl From<ExprMissingGreen> for ExprGreen {
544 fn from(value: ExprMissingGreen) -> Self {
545 Self(value.0)
546 }
547}
548#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
549pub struct ExprGreen(pub GreenId);
550impl TypedSyntaxNode for Expr {
551 const OPTIONAL_KIND: Option<SyntaxKind> = None;
552 type StablePtr = ExprPtr;
553 type Green = ExprGreen;
554 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
555 ExprGreen(ExprMissing::missing(db).0)
556 }
557 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
558 let kind = node.kind(db);
559 match kind {
560 SyntaxKind::ExprPath => Expr::Path(ExprPath::from_syntax_node(db, node)),
561 SyntaxKind::TerminalLiteralNumber => {
562 Expr::Literal(TerminalLiteralNumber::from_syntax_node(db, node))
563 }
564 SyntaxKind::TerminalShortString => {
565 Expr::ShortString(TerminalShortString::from_syntax_node(db, node))
566 }
567 SyntaxKind::TerminalString => Expr::String(TerminalString::from_syntax_node(db, node)),
568 SyntaxKind::TerminalFalse => Expr::False(TerminalFalse::from_syntax_node(db, node)),
569 SyntaxKind::TerminalTrue => Expr::True(TerminalTrue::from_syntax_node(db, node)),
570 SyntaxKind::ExprParenthesized => {
571 Expr::Parenthesized(ExprParenthesized::from_syntax_node(db, node))
572 }
573 SyntaxKind::ExprUnary => Expr::Unary(ExprUnary::from_syntax_node(db, node)),
574 SyntaxKind::ExprBinary => Expr::Binary(ExprBinary::from_syntax_node(db, node)),
575 SyntaxKind::ExprListParenthesized => {
576 Expr::Tuple(ExprListParenthesized::from_syntax_node(db, node))
577 }
578 SyntaxKind::ExprFunctionCall => {
579 Expr::FunctionCall(ExprFunctionCall::from_syntax_node(db, node))
580 }
581 SyntaxKind::ExprStructCtorCall => {
582 Expr::StructCtorCall(ExprStructCtorCall::from_syntax_node(db, node))
583 }
584 SyntaxKind::ExprBlock => Expr::Block(ExprBlock::from_syntax_node(db, node)),
585 SyntaxKind::ExprMatch => Expr::Match(ExprMatch::from_syntax_node(db, node)),
586 SyntaxKind::ExprIf => Expr::If(ExprIf::from_syntax_node(db, node)),
587 SyntaxKind::ExprLoop => Expr::Loop(ExprLoop::from_syntax_node(db, node)),
588 SyntaxKind::ExprWhile => Expr::While(ExprWhile::from_syntax_node(db, node)),
589 SyntaxKind::ExprFor => Expr::For(ExprFor::from_syntax_node(db, node)),
590 SyntaxKind::ExprClosure => Expr::Closure(ExprClosure::from_syntax_node(db, node)),
591 SyntaxKind::ExprErrorPropagate => {
592 Expr::ErrorPropagate(ExprErrorPropagate::from_syntax_node(db, node))
593 }
594 SyntaxKind::ExprFieldInitShorthand => {
595 Expr::FieldInitShorthand(ExprFieldInitShorthand::from_syntax_node(db, node))
596 }
597 SyntaxKind::ExprIndexed => Expr::Indexed(ExprIndexed::from_syntax_node(db, node)),
598 SyntaxKind::ExprInlineMacro => {
599 Expr::InlineMacro(ExprInlineMacro::from_syntax_node(db, node))
600 }
601 SyntaxKind::ExprFixedSizeArray => {
602 Expr::FixedSizeArray(ExprFixedSizeArray::from_syntax_node(db, node))
603 }
604 SyntaxKind::ExprMissing => Expr::Missing(ExprMissing::from_syntax_node(db, node)),
605 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Expr"),
606 }
607 }
608 fn as_syntax_node(&self) -> SyntaxNode {
609 match self {
610 Expr::Path(x) => x.as_syntax_node(),
611 Expr::Literal(x) => x.as_syntax_node(),
612 Expr::ShortString(x) => x.as_syntax_node(),
613 Expr::String(x) => x.as_syntax_node(),
614 Expr::False(x) => x.as_syntax_node(),
615 Expr::True(x) => x.as_syntax_node(),
616 Expr::Parenthesized(x) => x.as_syntax_node(),
617 Expr::Unary(x) => x.as_syntax_node(),
618 Expr::Binary(x) => x.as_syntax_node(),
619 Expr::Tuple(x) => x.as_syntax_node(),
620 Expr::FunctionCall(x) => x.as_syntax_node(),
621 Expr::StructCtorCall(x) => x.as_syntax_node(),
622 Expr::Block(x) => x.as_syntax_node(),
623 Expr::Match(x) => x.as_syntax_node(),
624 Expr::If(x) => x.as_syntax_node(),
625 Expr::Loop(x) => x.as_syntax_node(),
626 Expr::While(x) => x.as_syntax_node(),
627 Expr::For(x) => x.as_syntax_node(),
628 Expr::Closure(x) => x.as_syntax_node(),
629 Expr::ErrorPropagate(x) => x.as_syntax_node(),
630 Expr::FieldInitShorthand(x) => x.as_syntax_node(),
631 Expr::Indexed(x) => x.as_syntax_node(),
632 Expr::InlineMacro(x) => x.as_syntax_node(),
633 Expr::FixedSizeArray(x) => x.as_syntax_node(),
634 Expr::Missing(x) => x.as_syntax_node(),
635 }
636 }
637 fn stable_ptr(&self) -> Self::StablePtr {
638 ExprPtr(self.as_syntax_node().0.stable_ptr)
639 }
640}
641impl From<&Expr> for SyntaxStablePtrId {
642 fn from(node: &Expr) -> Self {
643 node.stable_ptr().untyped()
644 }
645}
646impl Expr {
647 pub fn is_variant(kind: SyntaxKind) -> bool {
649 matches!(
650 kind,
651 SyntaxKind::ExprPath
652 | SyntaxKind::TerminalLiteralNumber
653 | SyntaxKind::TerminalShortString
654 | SyntaxKind::TerminalString
655 | SyntaxKind::TerminalFalse
656 | SyntaxKind::TerminalTrue
657 | SyntaxKind::ExprParenthesized
658 | SyntaxKind::ExprUnary
659 | SyntaxKind::ExprBinary
660 | SyntaxKind::ExprListParenthesized
661 | SyntaxKind::ExprFunctionCall
662 | SyntaxKind::ExprStructCtorCall
663 | SyntaxKind::ExprBlock
664 | SyntaxKind::ExprMatch
665 | SyntaxKind::ExprIf
666 | SyntaxKind::ExprLoop
667 | SyntaxKind::ExprWhile
668 | SyntaxKind::ExprFor
669 | SyntaxKind::ExprClosure
670 | SyntaxKind::ExprErrorPropagate
671 | SyntaxKind::ExprFieldInitShorthand
672 | SyntaxKind::ExprIndexed
673 | SyntaxKind::ExprInlineMacro
674 | SyntaxKind::ExprFixedSizeArray
675 | SyntaxKind::ExprMissing
676 )
677 }
678}
679#[derive(Clone, Debug, Eq, Hash, PartialEq)]
680pub struct ExprList(ElementList<Expr, 2>);
681impl Deref for ExprList {
682 type Target = ElementList<Expr, 2>;
683 fn deref(&self) -> &Self::Target {
684 &self.0
685 }
686}
687impl ExprList {
688 pub fn new_green(
689 db: &dyn SyntaxGroup,
690 children: Vec<ExprListElementOrSeparatorGreen>,
691 ) -> ExprListGreen {
692 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
693 ExprListGreen(
694 Arc::new(GreenNode {
695 kind: SyntaxKind::ExprList,
696 details: GreenNodeDetails::Node {
697 children: children.iter().map(|x| x.id()).collect(),
698 width,
699 },
700 })
701 .intern(db),
702 )
703 }
704}
705#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
706pub struct ExprListPtr(pub SyntaxStablePtrId);
707impl TypedStablePtr for ExprListPtr {
708 type SyntaxNode = ExprList;
709 fn untyped(&self) -> SyntaxStablePtrId {
710 self.0
711 }
712 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprList {
713 ExprList::from_syntax_node(db, self.0.lookup(db))
714 }
715}
716impl From<ExprListPtr> for SyntaxStablePtrId {
717 fn from(ptr: ExprListPtr) -> Self {
718 ptr.untyped()
719 }
720}
721#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
722pub enum ExprListElementOrSeparatorGreen {
723 Separator(TerminalCommaGreen),
724 Element(ExprGreen),
725}
726impl From<TerminalCommaGreen> for ExprListElementOrSeparatorGreen {
727 fn from(value: TerminalCommaGreen) -> Self {
728 ExprListElementOrSeparatorGreen::Separator(value)
729 }
730}
731impl From<ExprGreen> for ExprListElementOrSeparatorGreen {
732 fn from(value: ExprGreen) -> Self {
733 ExprListElementOrSeparatorGreen::Element(value)
734 }
735}
736impl ExprListElementOrSeparatorGreen {
737 fn id(&self) -> GreenId {
738 match self {
739 ExprListElementOrSeparatorGreen::Separator(green) => green.0,
740 ExprListElementOrSeparatorGreen::Element(green) => green.0,
741 }
742 }
743}
744#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
745pub struct ExprListGreen(pub GreenId);
746impl TypedSyntaxNode for ExprList {
747 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprList);
748 type StablePtr = ExprListPtr;
749 type Green = ExprListGreen;
750 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
751 ExprListGreen(
752 Arc::new(GreenNode {
753 kind: SyntaxKind::ExprList,
754 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
755 })
756 .intern(db),
757 )
758 }
759 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
760 Self(ElementList::new(node))
761 }
762 fn as_syntax_node(&self) -> SyntaxNode {
763 self.node.clone()
764 }
765 fn stable_ptr(&self) -> Self::StablePtr {
766 ExprListPtr(self.node.0.stable_ptr)
767 }
768}
769impl From<&ExprList> for SyntaxStablePtrId {
770 fn from(node: &ExprList) -> Self {
771 node.stable_ptr().untyped()
772 }
773}
774#[derive(Clone, Debug, Eq, Hash, PartialEq)]
775pub struct Arg {
776 node: SyntaxNode,
777 children: Arc<[SyntaxNode]>,
778}
779impl Arg {
780 pub const INDEX_MODIFIERS: usize = 0;
781 pub const INDEX_ARG_CLAUSE: usize = 1;
782 pub fn new_green(
783 db: &dyn SyntaxGroup,
784 modifiers: ModifierListGreen,
785 arg_clause: ArgClauseGreen,
786 ) -> ArgGreen {
787 let children: Vec<GreenId> = vec![modifiers.0, arg_clause.0];
788 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
789 ArgGreen(
790 Arc::new(GreenNode {
791 kind: SyntaxKind::Arg,
792 details: GreenNodeDetails::Node { children, width },
793 })
794 .intern(db),
795 )
796 }
797}
798impl Arg {
799 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
800 ModifierList::from_syntax_node(db, self.children[0].clone())
801 }
802 pub fn arg_clause(&self, db: &dyn SyntaxGroup) -> ArgClause {
803 ArgClause::from_syntax_node(db, self.children[1].clone())
804 }
805}
806#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
807pub struct ArgPtr(pub SyntaxStablePtrId);
808impl ArgPtr {}
809impl TypedStablePtr for ArgPtr {
810 type SyntaxNode = Arg;
811 fn untyped(&self) -> SyntaxStablePtrId {
812 self.0
813 }
814 fn lookup(&self, db: &dyn SyntaxGroup) -> Arg {
815 Arg::from_syntax_node(db, self.0.lookup(db))
816 }
817}
818impl From<ArgPtr> for SyntaxStablePtrId {
819 fn from(ptr: ArgPtr) -> Self {
820 ptr.untyped()
821 }
822}
823#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
824pub struct ArgGreen(pub GreenId);
825impl TypedSyntaxNode for Arg {
826 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Arg);
827 type StablePtr = ArgPtr;
828 type Green = ArgGreen;
829 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
830 ArgGreen(
831 Arc::new(GreenNode {
832 kind: SyntaxKind::Arg,
833 details: GreenNodeDetails::Node {
834 children: vec![ModifierList::missing(db).0, ArgClause::missing(db).0],
835 width: TextWidth::default(),
836 },
837 })
838 .intern(db),
839 )
840 }
841 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
842 let kind = node.kind(db);
843 assert_eq!(
844 kind,
845 SyntaxKind::Arg,
846 "Unexpected SyntaxKind {:?}. Expected {:?}.",
847 kind,
848 SyntaxKind::Arg
849 );
850 let children = db.get_children(node.clone());
851 Self { node, children }
852 }
853 fn as_syntax_node(&self) -> SyntaxNode {
854 self.node.clone()
855 }
856 fn stable_ptr(&self) -> Self::StablePtr {
857 ArgPtr(self.node.0.stable_ptr)
858 }
859}
860impl From<&Arg> for SyntaxStablePtrId {
861 fn from(node: &Arg) -> Self {
862 node.stable_ptr().untyped()
863 }
864}
865#[derive(Clone, Debug, Eq, Hash, PartialEq)]
866pub enum ArgClause {
867 Unnamed(ArgClauseUnnamed),
868 Named(ArgClauseNamed),
869 FieldInitShorthand(ArgClauseFieldInitShorthand),
870}
871#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
872pub struct ArgClausePtr(pub SyntaxStablePtrId);
873impl TypedStablePtr for ArgClausePtr {
874 type SyntaxNode = ArgClause;
875 fn untyped(&self) -> SyntaxStablePtrId {
876 self.0
877 }
878 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClause {
879 ArgClause::from_syntax_node(db, self.0.lookup(db))
880 }
881}
882impl From<ArgClausePtr> for SyntaxStablePtrId {
883 fn from(ptr: ArgClausePtr) -> Self {
884 ptr.untyped()
885 }
886}
887impl From<ArgClauseUnnamedPtr> for ArgClausePtr {
888 fn from(value: ArgClauseUnnamedPtr) -> Self {
889 Self(value.0)
890 }
891}
892impl From<ArgClauseNamedPtr> for ArgClausePtr {
893 fn from(value: ArgClauseNamedPtr) -> Self {
894 Self(value.0)
895 }
896}
897impl From<ArgClauseFieldInitShorthandPtr> for ArgClausePtr {
898 fn from(value: ArgClauseFieldInitShorthandPtr) -> Self {
899 Self(value.0)
900 }
901}
902impl From<ArgClauseUnnamedGreen> for ArgClauseGreen {
903 fn from(value: ArgClauseUnnamedGreen) -> Self {
904 Self(value.0)
905 }
906}
907impl From<ArgClauseNamedGreen> for ArgClauseGreen {
908 fn from(value: ArgClauseNamedGreen) -> Self {
909 Self(value.0)
910 }
911}
912impl From<ArgClauseFieldInitShorthandGreen> for ArgClauseGreen {
913 fn from(value: ArgClauseFieldInitShorthandGreen) -> Self {
914 Self(value.0)
915 }
916}
917#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
918pub struct ArgClauseGreen(pub GreenId);
919impl TypedSyntaxNode for ArgClause {
920 const OPTIONAL_KIND: Option<SyntaxKind> = None;
921 type StablePtr = ArgClausePtr;
922 type Green = ArgClauseGreen;
923 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
924 panic!("No missing variant.");
925 }
926 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
927 let kind = node.kind(db);
928 match kind {
929 SyntaxKind::ArgClauseUnnamed => {
930 ArgClause::Unnamed(ArgClauseUnnamed::from_syntax_node(db, node))
931 }
932 SyntaxKind::ArgClauseNamed => {
933 ArgClause::Named(ArgClauseNamed::from_syntax_node(db, node))
934 }
935 SyntaxKind::ArgClauseFieldInitShorthand => ArgClause::FieldInitShorthand(
936 ArgClauseFieldInitShorthand::from_syntax_node(db, node),
937 ),
938 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ArgClause"),
939 }
940 }
941 fn as_syntax_node(&self) -> SyntaxNode {
942 match self {
943 ArgClause::Unnamed(x) => x.as_syntax_node(),
944 ArgClause::Named(x) => x.as_syntax_node(),
945 ArgClause::FieldInitShorthand(x) => x.as_syntax_node(),
946 }
947 }
948 fn stable_ptr(&self) -> Self::StablePtr {
949 ArgClausePtr(self.as_syntax_node().0.stable_ptr)
950 }
951}
952impl From<&ArgClause> for SyntaxStablePtrId {
953 fn from(node: &ArgClause) -> Self {
954 node.stable_ptr().untyped()
955 }
956}
957impl ArgClause {
958 pub fn is_variant(kind: SyntaxKind) -> bool {
960 matches!(
961 kind,
962 SyntaxKind::ArgClauseUnnamed
963 | SyntaxKind::ArgClauseNamed
964 | SyntaxKind::ArgClauseFieldInitShorthand
965 )
966 }
967}
968#[derive(Clone, Debug, Eq, Hash, PartialEq)]
969pub struct ArgClauseNamed {
970 node: SyntaxNode,
971 children: Arc<[SyntaxNode]>,
972}
973impl ArgClauseNamed {
974 pub const INDEX_NAME: usize = 0;
975 pub const INDEX_COLON: usize = 1;
976 pub const INDEX_VALUE: usize = 2;
977 pub fn new_green(
978 db: &dyn SyntaxGroup,
979 name: TerminalIdentifierGreen,
980 colon: TerminalColonGreen,
981 value: ExprGreen,
982 ) -> ArgClauseNamedGreen {
983 let children: Vec<GreenId> = vec![name.0, colon.0, value.0];
984 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
985 ArgClauseNamedGreen(
986 Arc::new(GreenNode {
987 kind: SyntaxKind::ArgClauseNamed,
988 details: GreenNodeDetails::Node { children, width },
989 })
990 .intern(db),
991 )
992 }
993}
994impl ArgClauseNamed {
995 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
996 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
997 }
998 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
999 TerminalColon::from_syntax_node(db, self.children[1].clone())
1000 }
1001 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
1002 Expr::from_syntax_node(db, self.children[2].clone())
1003 }
1004}
1005#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1006pub struct ArgClauseNamedPtr(pub SyntaxStablePtrId);
1007impl ArgClauseNamedPtr {}
1008impl TypedStablePtr for ArgClauseNamedPtr {
1009 type SyntaxNode = ArgClauseNamed;
1010 fn untyped(&self) -> SyntaxStablePtrId {
1011 self.0
1012 }
1013 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseNamed {
1014 ArgClauseNamed::from_syntax_node(db, self.0.lookup(db))
1015 }
1016}
1017impl From<ArgClauseNamedPtr> for SyntaxStablePtrId {
1018 fn from(ptr: ArgClauseNamedPtr) -> Self {
1019 ptr.untyped()
1020 }
1021}
1022#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1023pub struct ArgClauseNamedGreen(pub GreenId);
1024impl TypedSyntaxNode for ArgClauseNamed {
1025 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseNamed);
1026 type StablePtr = ArgClauseNamedPtr;
1027 type Green = ArgClauseNamedGreen;
1028 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1029 ArgClauseNamedGreen(
1030 Arc::new(GreenNode {
1031 kind: SyntaxKind::ArgClauseNamed,
1032 details: GreenNodeDetails::Node {
1033 children: vec![
1034 TerminalIdentifier::missing(db).0,
1035 TerminalColon::missing(db).0,
1036 Expr::missing(db).0,
1037 ],
1038 width: TextWidth::default(),
1039 },
1040 })
1041 .intern(db),
1042 )
1043 }
1044 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1045 let kind = node.kind(db);
1046 assert_eq!(
1047 kind,
1048 SyntaxKind::ArgClauseNamed,
1049 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1050 kind,
1051 SyntaxKind::ArgClauseNamed
1052 );
1053 let children = db.get_children(node.clone());
1054 Self { node, children }
1055 }
1056 fn as_syntax_node(&self) -> SyntaxNode {
1057 self.node.clone()
1058 }
1059 fn stable_ptr(&self) -> Self::StablePtr {
1060 ArgClauseNamedPtr(self.node.0.stable_ptr)
1061 }
1062}
1063impl From<&ArgClauseNamed> for SyntaxStablePtrId {
1064 fn from(node: &ArgClauseNamed) -> Self {
1065 node.stable_ptr().untyped()
1066 }
1067}
1068#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1069pub struct ArgClauseUnnamed {
1070 node: SyntaxNode,
1071 children: Arc<[SyntaxNode]>,
1072}
1073impl ArgClauseUnnamed {
1074 pub const INDEX_VALUE: usize = 0;
1075 pub fn new_green(db: &dyn SyntaxGroup, value: ExprGreen) -> ArgClauseUnnamedGreen {
1076 let children: Vec<GreenId> = vec![value.0];
1077 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1078 ArgClauseUnnamedGreen(
1079 Arc::new(GreenNode {
1080 kind: SyntaxKind::ArgClauseUnnamed,
1081 details: GreenNodeDetails::Node { children, width },
1082 })
1083 .intern(db),
1084 )
1085 }
1086}
1087impl ArgClauseUnnamed {
1088 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
1089 Expr::from_syntax_node(db, self.children[0].clone())
1090 }
1091}
1092#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1093pub struct ArgClauseUnnamedPtr(pub SyntaxStablePtrId);
1094impl ArgClauseUnnamedPtr {}
1095impl TypedStablePtr for ArgClauseUnnamedPtr {
1096 type SyntaxNode = ArgClauseUnnamed;
1097 fn untyped(&self) -> SyntaxStablePtrId {
1098 self.0
1099 }
1100 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseUnnamed {
1101 ArgClauseUnnamed::from_syntax_node(db, self.0.lookup(db))
1102 }
1103}
1104impl From<ArgClauseUnnamedPtr> for SyntaxStablePtrId {
1105 fn from(ptr: ArgClauseUnnamedPtr) -> Self {
1106 ptr.untyped()
1107 }
1108}
1109#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1110pub struct ArgClauseUnnamedGreen(pub GreenId);
1111impl TypedSyntaxNode for ArgClauseUnnamed {
1112 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseUnnamed);
1113 type StablePtr = ArgClauseUnnamedPtr;
1114 type Green = ArgClauseUnnamedGreen;
1115 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1116 ArgClauseUnnamedGreen(
1117 Arc::new(GreenNode {
1118 kind: SyntaxKind::ArgClauseUnnamed,
1119 details: GreenNodeDetails::Node {
1120 children: vec![Expr::missing(db).0],
1121 width: TextWidth::default(),
1122 },
1123 })
1124 .intern(db),
1125 )
1126 }
1127 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1128 let kind = node.kind(db);
1129 assert_eq!(
1130 kind,
1131 SyntaxKind::ArgClauseUnnamed,
1132 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1133 kind,
1134 SyntaxKind::ArgClauseUnnamed
1135 );
1136 let children = db.get_children(node.clone());
1137 Self { node, children }
1138 }
1139 fn as_syntax_node(&self) -> SyntaxNode {
1140 self.node.clone()
1141 }
1142 fn stable_ptr(&self) -> Self::StablePtr {
1143 ArgClauseUnnamedPtr(self.node.0.stable_ptr)
1144 }
1145}
1146impl From<&ArgClauseUnnamed> for SyntaxStablePtrId {
1147 fn from(node: &ArgClauseUnnamed) -> Self {
1148 node.stable_ptr().untyped()
1149 }
1150}
1151#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1152pub struct ArgClauseFieldInitShorthand {
1153 node: SyntaxNode,
1154 children: Arc<[SyntaxNode]>,
1155}
1156impl ArgClauseFieldInitShorthand {
1157 pub const INDEX_COLON: usize = 0;
1158 pub const INDEX_NAME: usize = 1;
1159 pub fn new_green(
1160 db: &dyn SyntaxGroup,
1161 colon: TerminalColonGreen,
1162 name: ExprFieldInitShorthandGreen,
1163 ) -> ArgClauseFieldInitShorthandGreen {
1164 let children: Vec<GreenId> = vec![colon.0, name.0];
1165 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1166 ArgClauseFieldInitShorthandGreen(
1167 Arc::new(GreenNode {
1168 kind: SyntaxKind::ArgClauseFieldInitShorthand,
1169 details: GreenNodeDetails::Node { children, width },
1170 })
1171 .intern(db),
1172 )
1173 }
1174}
1175impl ArgClauseFieldInitShorthand {
1176 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
1177 TerminalColon::from_syntax_node(db, self.children[0].clone())
1178 }
1179 pub fn name(&self, db: &dyn SyntaxGroup) -> ExprFieldInitShorthand {
1180 ExprFieldInitShorthand::from_syntax_node(db, self.children[1].clone())
1181 }
1182}
1183#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1184pub struct ArgClauseFieldInitShorthandPtr(pub SyntaxStablePtrId);
1185impl ArgClauseFieldInitShorthandPtr {}
1186impl TypedStablePtr for ArgClauseFieldInitShorthandPtr {
1187 type SyntaxNode = ArgClauseFieldInitShorthand;
1188 fn untyped(&self) -> SyntaxStablePtrId {
1189 self.0
1190 }
1191 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgClauseFieldInitShorthand {
1192 ArgClauseFieldInitShorthand::from_syntax_node(db, self.0.lookup(db))
1193 }
1194}
1195impl From<ArgClauseFieldInitShorthandPtr> for SyntaxStablePtrId {
1196 fn from(ptr: ArgClauseFieldInitShorthandPtr) -> Self {
1197 ptr.untyped()
1198 }
1199}
1200#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1201pub struct ArgClauseFieldInitShorthandGreen(pub GreenId);
1202impl TypedSyntaxNode for ArgClauseFieldInitShorthand {
1203 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgClauseFieldInitShorthand);
1204 type StablePtr = ArgClauseFieldInitShorthandPtr;
1205 type Green = ArgClauseFieldInitShorthandGreen;
1206 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1207 ArgClauseFieldInitShorthandGreen(
1208 Arc::new(GreenNode {
1209 kind: SyntaxKind::ArgClauseFieldInitShorthand,
1210 details: GreenNodeDetails::Node {
1211 children: vec![
1212 TerminalColon::missing(db).0,
1213 ExprFieldInitShorthand::missing(db).0,
1214 ],
1215 width: TextWidth::default(),
1216 },
1217 })
1218 .intern(db),
1219 )
1220 }
1221 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1222 let kind = node.kind(db);
1223 assert_eq!(
1224 kind,
1225 SyntaxKind::ArgClauseFieldInitShorthand,
1226 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1227 kind,
1228 SyntaxKind::ArgClauseFieldInitShorthand
1229 );
1230 let children = db.get_children(node.clone());
1231 Self { node, children }
1232 }
1233 fn as_syntax_node(&self) -> SyntaxNode {
1234 self.node.clone()
1235 }
1236 fn stable_ptr(&self) -> Self::StablePtr {
1237 ArgClauseFieldInitShorthandPtr(self.node.0.stable_ptr)
1238 }
1239}
1240impl From<&ArgClauseFieldInitShorthand> for SyntaxStablePtrId {
1241 fn from(node: &ArgClauseFieldInitShorthand) -> Self {
1242 node.stable_ptr().untyped()
1243 }
1244}
1245#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1246pub struct ExprFieldInitShorthand {
1247 node: SyntaxNode,
1248 children: Arc<[SyntaxNode]>,
1249}
1250impl ExprFieldInitShorthand {
1251 pub const INDEX_NAME: usize = 0;
1252 pub fn new_green(
1253 db: &dyn SyntaxGroup,
1254 name: TerminalIdentifierGreen,
1255 ) -> ExprFieldInitShorthandGreen {
1256 let children: Vec<GreenId> = vec![name.0];
1257 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1258 ExprFieldInitShorthandGreen(
1259 Arc::new(GreenNode {
1260 kind: SyntaxKind::ExprFieldInitShorthand,
1261 details: GreenNodeDetails::Node { children, width },
1262 })
1263 .intern(db),
1264 )
1265 }
1266}
1267impl ExprFieldInitShorthand {
1268 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1269 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1270 }
1271}
1272#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1273pub struct ExprFieldInitShorthandPtr(pub SyntaxStablePtrId);
1274impl ExprFieldInitShorthandPtr {}
1275impl TypedStablePtr for ExprFieldInitShorthandPtr {
1276 type SyntaxNode = ExprFieldInitShorthand;
1277 fn untyped(&self) -> SyntaxStablePtrId {
1278 self.0
1279 }
1280 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFieldInitShorthand {
1281 ExprFieldInitShorthand::from_syntax_node(db, self.0.lookup(db))
1282 }
1283}
1284impl From<ExprFieldInitShorthandPtr> for SyntaxStablePtrId {
1285 fn from(ptr: ExprFieldInitShorthandPtr) -> Self {
1286 ptr.untyped()
1287 }
1288}
1289#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1290pub struct ExprFieldInitShorthandGreen(pub GreenId);
1291impl TypedSyntaxNode for ExprFieldInitShorthand {
1292 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFieldInitShorthand);
1293 type StablePtr = ExprFieldInitShorthandPtr;
1294 type Green = ExprFieldInitShorthandGreen;
1295 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1296 ExprFieldInitShorthandGreen(
1297 Arc::new(GreenNode {
1298 kind: SyntaxKind::ExprFieldInitShorthand,
1299 details: GreenNodeDetails::Node {
1300 children: vec![TerminalIdentifier::missing(db).0],
1301 width: TextWidth::default(),
1302 },
1303 })
1304 .intern(db),
1305 )
1306 }
1307 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1308 let kind = node.kind(db);
1309 assert_eq!(
1310 kind,
1311 SyntaxKind::ExprFieldInitShorthand,
1312 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1313 kind,
1314 SyntaxKind::ExprFieldInitShorthand
1315 );
1316 let children = db.get_children(node.clone());
1317 Self { node, children }
1318 }
1319 fn as_syntax_node(&self) -> SyntaxNode {
1320 self.node.clone()
1321 }
1322 fn stable_ptr(&self) -> Self::StablePtr {
1323 ExprFieldInitShorthandPtr(self.node.0.stable_ptr)
1324 }
1325}
1326impl From<&ExprFieldInitShorthand> for SyntaxStablePtrId {
1327 fn from(node: &ExprFieldInitShorthand) -> Self {
1328 node.stable_ptr().untyped()
1329 }
1330}
1331#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1332pub struct ArgList(ElementList<Arg, 2>);
1333impl Deref for ArgList {
1334 type Target = ElementList<Arg, 2>;
1335 fn deref(&self) -> &Self::Target {
1336 &self.0
1337 }
1338}
1339impl ArgList {
1340 pub fn new_green(
1341 db: &dyn SyntaxGroup,
1342 children: Vec<ArgListElementOrSeparatorGreen>,
1343 ) -> ArgListGreen {
1344 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
1345 ArgListGreen(
1346 Arc::new(GreenNode {
1347 kind: SyntaxKind::ArgList,
1348 details: GreenNodeDetails::Node {
1349 children: children.iter().map(|x| x.id()).collect(),
1350 width,
1351 },
1352 })
1353 .intern(db),
1354 )
1355 }
1356}
1357#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1358pub struct ArgListPtr(pub SyntaxStablePtrId);
1359impl TypedStablePtr for ArgListPtr {
1360 type SyntaxNode = ArgList;
1361 fn untyped(&self) -> SyntaxStablePtrId {
1362 self.0
1363 }
1364 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgList {
1365 ArgList::from_syntax_node(db, self.0.lookup(db))
1366 }
1367}
1368impl From<ArgListPtr> for SyntaxStablePtrId {
1369 fn from(ptr: ArgListPtr) -> Self {
1370 ptr.untyped()
1371 }
1372}
1373#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1374pub enum ArgListElementOrSeparatorGreen {
1375 Separator(TerminalCommaGreen),
1376 Element(ArgGreen),
1377}
1378impl From<TerminalCommaGreen> for ArgListElementOrSeparatorGreen {
1379 fn from(value: TerminalCommaGreen) -> Self {
1380 ArgListElementOrSeparatorGreen::Separator(value)
1381 }
1382}
1383impl From<ArgGreen> for ArgListElementOrSeparatorGreen {
1384 fn from(value: ArgGreen) -> Self {
1385 ArgListElementOrSeparatorGreen::Element(value)
1386 }
1387}
1388impl ArgListElementOrSeparatorGreen {
1389 fn id(&self) -> GreenId {
1390 match self {
1391 ArgListElementOrSeparatorGreen::Separator(green) => green.0,
1392 ArgListElementOrSeparatorGreen::Element(green) => green.0,
1393 }
1394 }
1395}
1396#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1397pub struct ArgListGreen(pub GreenId);
1398impl TypedSyntaxNode for ArgList {
1399 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgList);
1400 type StablePtr = ArgListPtr;
1401 type Green = ArgListGreen;
1402 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1403 ArgListGreen(
1404 Arc::new(GreenNode {
1405 kind: SyntaxKind::ArgList,
1406 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1407 })
1408 .intern(db),
1409 )
1410 }
1411 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1412 Self(ElementList::new(node))
1413 }
1414 fn as_syntax_node(&self) -> SyntaxNode {
1415 self.node.clone()
1416 }
1417 fn stable_ptr(&self) -> Self::StablePtr {
1418 ArgListPtr(self.node.0.stable_ptr)
1419 }
1420}
1421impl From<&ArgList> for SyntaxStablePtrId {
1422 fn from(node: &ArgList) -> Self {
1423 node.stable_ptr().untyped()
1424 }
1425}
1426#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1427pub struct ExprMissing {
1428 node: SyntaxNode,
1429 children: Arc<[SyntaxNode]>,
1430}
1431impl ExprMissing {
1432 pub fn new_green(db: &dyn SyntaxGroup) -> ExprMissingGreen {
1433 let children: Vec<GreenId> = vec![];
1434 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1435 ExprMissingGreen(
1436 Arc::new(GreenNode {
1437 kind: SyntaxKind::ExprMissing,
1438 details: GreenNodeDetails::Node { children, width },
1439 })
1440 .intern(db),
1441 )
1442 }
1443}
1444impl ExprMissing {}
1445#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1446pub struct ExprMissingPtr(pub SyntaxStablePtrId);
1447impl ExprMissingPtr {}
1448impl TypedStablePtr for ExprMissingPtr {
1449 type SyntaxNode = ExprMissing;
1450 fn untyped(&self) -> SyntaxStablePtrId {
1451 self.0
1452 }
1453 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprMissing {
1454 ExprMissing::from_syntax_node(db, self.0.lookup(db))
1455 }
1456}
1457impl From<ExprMissingPtr> for SyntaxStablePtrId {
1458 fn from(ptr: ExprMissingPtr) -> Self {
1459 ptr.untyped()
1460 }
1461}
1462#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1463pub struct ExprMissingGreen(pub GreenId);
1464impl TypedSyntaxNode for ExprMissing {
1465 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprMissing);
1466 type StablePtr = ExprMissingPtr;
1467 type Green = ExprMissingGreen;
1468 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1469 ExprMissingGreen(
1470 Arc::new(GreenNode {
1471 kind: SyntaxKind::ExprMissing,
1472 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1473 })
1474 .intern(db),
1475 )
1476 }
1477 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1478 let kind = node.kind(db);
1479 assert_eq!(
1480 kind,
1481 SyntaxKind::ExprMissing,
1482 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1483 kind,
1484 SyntaxKind::ExprMissing
1485 );
1486 let children = db.get_children(node.clone());
1487 Self { node, children }
1488 }
1489 fn as_syntax_node(&self) -> SyntaxNode {
1490 self.node.clone()
1491 }
1492 fn stable_ptr(&self) -> Self::StablePtr {
1493 ExprMissingPtr(self.node.0.stable_ptr)
1494 }
1495}
1496impl From<&ExprMissing> for SyntaxStablePtrId {
1497 fn from(node: &ExprMissing) -> Self {
1498 node.stable_ptr().untyped()
1499 }
1500}
1501#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1502pub enum PathSegment {
1503 WithGenericArgs(PathSegmentWithGenericArgs),
1504 Simple(PathSegmentSimple),
1505}
1506#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1507pub struct PathSegmentPtr(pub SyntaxStablePtrId);
1508impl TypedStablePtr for PathSegmentPtr {
1509 type SyntaxNode = PathSegment;
1510 fn untyped(&self) -> SyntaxStablePtrId {
1511 self.0
1512 }
1513 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegment {
1514 PathSegment::from_syntax_node(db, self.0.lookup(db))
1515 }
1516}
1517impl From<PathSegmentPtr> for SyntaxStablePtrId {
1518 fn from(ptr: PathSegmentPtr) -> Self {
1519 ptr.untyped()
1520 }
1521}
1522impl From<PathSegmentWithGenericArgsPtr> for PathSegmentPtr {
1523 fn from(value: PathSegmentWithGenericArgsPtr) -> Self {
1524 Self(value.0)
1525 }
1526}
1527impl From<PathSegmentSimplePtr> for PathSegmentPtr {
1528 fn from(value: PathSegmentSimplePtr) -> Self {
1529 Self(value.0)
1530 }
1531}
1532impl From<PathSegmentWithGenericArgsGreen> for PathSegmentGreen {
1533 fn from(value: PathSegmentWithGenericArgsGreen) -> Self {
1534 Self(value.0)
1535 }
1536}
1537impl From<PathSegmentSimpleGreen> for PathSegmentGreen {
1538 fn from(value: PathSegmentSimpleGreen) -> Self {
1539 Self(value.0)
1540 }
1541}
1542#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1543pub struct PathSegmentGreen(pub GreenId);
1544impl TypedSyntaxNode for PathSegment {
1545 const OPTIONAL_KIND: Option<SyntaxKind> = None;
1546 type StablePtr = PathSegmentPtr;
1547 type Green = PathSegmentGreen;
1548 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1549 PathSegmentGreen(PathSegmentSimple::missing(db).0)
1550 }
1551 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1552 let kind = node.kind(db);
1553 match kind {
1554 SyntaxKind::PathSegmentWithGenericArgs => {
1555 PathSegment::WithGenericArgs(PathSegmentWithGenericArgs::from_syntax_node(db, node))
1556 }
1557 SyntaxKind::PathSegmentSimple => {
1558 PathSegment::Simple(PathSegmentSimple::from_syntax_node(db, node))
1559 }
1560 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "PathSegment"),
1561 }
1562 }
1563 fn as_syntax_node(&self) -> SyntaxNode {
1564 match self {
1565 PathSegment::WithGenericArgs(x) => x.as_syntax_node(),
1566 PathSegment::Simple(x) => x.as_syntax_node(),
1567 }
1568 }
1569 fn stable_ptr(&self) -> Self::StablePtr {
1570 PathSegmentPtr(self.as_syntax_node().0.stable_ptr)
1571 }
1572}
1573impl From<&PathSegment> for SyntaxStablePtrId {
1574 fn from(node: &PathSegment) -> Self {
1575 node.stable_ptr().untyped()
1576 }
1577}
1578impl PathSegment {
1579 pub fn is_variant(kind: SyntaxKind) -> bool {
1581 matches!(kind, SyntaxKind::PathSegmentWithGenericArgs | SyntaxKind::PathSegmentSimple)
1582 }
1583}
1584#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1585pub struct PathSegmentSimple {
1586 node: SyntaxNode,
1587 children: Arc<[SyntaxNode]>,
1588}
1589impl PathSegmentSimple {
1590 pub const INDEX_IDENT: usize = 0;
1591 pub fn new_green(
1592 db: &dyn SyntaxGroup,
1593 ident: TerminalIdentifierGreen,
1594 ) -> PathSegmentSimpleGreen {
1595 let children: Vec<GreenId> = vec![ident.0];
1596 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1597 PathSegmentSimpleGreen(
1598 Arc::new(GreenNode {
1599 kind: SyntaxKind::PathSegmentSimple,
1600 details: GreenNodeDetails::Node { children, width },
1601 })
1602 .intern(db),
1603 )
1604 }
1605}
1606impl PathSegmentSimple {
1607 pub fn ident(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1608 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1609 }
1610}
1611#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1612pub struct PathSegmentSimplePtr(pub SyntaxStablePtrId);
1613impl PathSegmentSimplePtr {}
1614impl TypedStablePtr for PathSegmentSimplePtr {
1615 type SyntaxNode = PathSegmentSimple;
1616 fn untyped(&self) -> SyntaxStablePtrId {
1617 self.0
1618 }
1619 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegmentSimple {
1620 PathSegmentSimple::from_syntax_node(db, self.0.lookup(db))
1621 }
1622}
1623impl From<PathSegmentSimplePtr> for SyntaxStablePtrId {
1624 fn from(ptr: PathSegmentSimplePtr) -> Self {
1625 ptr.untyped()
1626 }
1627}
1628#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1629pub struct PathSegmentSimpleGreen(pub GreenId);
1630impl TypedSyntaxNode for PathSegmentSimple {
1631 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PathSegmentSimple);
1632 type StablePtr = PathSegmentSimplePtr;
1633 type Green = PathSegmentSimpleGreen;
1634 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1635 PathSegmentSimpleGreen(
1636 Arc::new(GreenNode {
1637 kind: SyntaxKind::PathSegmentSimple,
1638 details: GreenNodeDetails::Node {
1639 children: vec![TerminalIdentifier::missing(db).0],
1640 width: TextWidth::default(),
1641 },
1642 })
1643 .intern(db),
1644 )
1645 }
1646 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1647 let kind = node.kind(db);
1648 assert_eq!(
1649 kind,
1650 SyntaxKind::PathSegmentSimple,
1651 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1652 kind,
1653 SyntaxKind::PathSegmentSimple
1654 );
1655 let children = db.get_children(node.clone());
1656 Self { node, children }
1657 }
1658 fn as_syntax_node(&self) -> SyntaxNode {
1659 self.node.clone()
1660 }
1661 fn stable_ptr(&self) -> Self::StablePtr {
1662 PathSegmentSimplePtr(self.node.0.stable_ptr)
1663 }
1664}
1665impl From<&PathSegmentSimple> for SyntaxStablePtrId {
1666 fn from(node: &PathSegmentSimple) -> Self {
1667 node.stable_ptr().untyped()
1668 }
1669}
1670#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1671pub enum OptionTerminalColonColon {
1672 Empty(OptionTerminalColonColonEmpty),
1673 TerminalColonColon(TerminalColonColon),
1674}
1675#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1676pub struct OptionTerminalColonColonPtr(pub SyntaxStablePtrId);
1677impl TypedStablePtr for OptionTerminalColonColonPtr {
1678 type SyntaxNode = OptionTerminalColonColon;
1679 fn untyped(&self) -> SyntaxStablePtrId {
1680 self.0
1681 }
1682 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColon {
1683 OptionTerminalColonColon::from_syntax_node(db, self.0.lookup(db))
1684 }
1685}
1686impl From<OptionTerminalColonColonPtr> for SyntaxStablePtrId {
1687 fn from(ptr: OptionTerminalColonColonPtr) -> Self {
1688 ptr.untyped()
1689 }
1690}
1691impl From<OptionTerminalColonColonEmptyPtr> for OptionTerminalColonColonPtr {
1692 fn from(value: OptionTerminalColonColonEmptyPtr) -> Self {
1693 Self(value.0)
1694 }
1695}
1696impl From<TerminalColonColonPtr> for OptionTerminalColonColonPtr {
1697 fn from(value: TerminalColonColonPtr) -> Self {
1698 Self(value.0)
1699 }
1700}
1701impl From<OptionTerminalColonColonEmptyGreen> for OptionTerminalColonColonGreen {
1702 fn from(value: OptionTerminalColonColonEmptyGreen) -> Self {
1703 Self(value.0)
1704 }
1705}
1706impl From<TerminalColonColonGreen> for OptionTerminalColonColonGreen {
1707 fn from(value: TerminalColonColonGreen) -> Self {
1708 Self(value.0)
1709 }
1710}
1711#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1712pub struct OptionTerminalColonColonGreen(pub GreenId);
1713impl TypedSyntaxNode for OptionTerminalColonColon {
1714 const OPTIONAL_KIND: Option<SyntaxKind> = None;
1715 type StablePtr = OptionTerminalColonColonPtr;
1716 type Green = OptionTerminalColonColonGreen;
1717 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1718 panic!("No missing variant.");
1719 }
1720 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1721 let kind = node.kind(db);
1722 match kind {
1723 SyntaxKind::OptionTerminalColonColonEmpty => OptionTerminalColonColon::Empty(
1724 OptionTerminalColonColonEmpty::from_syntax_node(db, node),
1725 ),
1726 SyntaxKind::TerminalColonColon => OptionTerminalColonColon::TerminalColonColon(
1727 TerminalColonColon::from_syntax_node(db, node),
1728 ),
1729 _ => panic!(
1730 "Unexpected syntax kind {:?} when constructing {}.",
1731 kind, "OptionTerminalColonColon"
1732 ),
1733 }
1734 }
1735 fn as_syntax_node(&self) -> SyntaxNode {
1736 match self {
1737 OptionTerminalColonColon::Empty(x) => x.as_syntax_node(),
1738 OptionTerminalColonColon::TerminalColonColon(x) => x.as_syntax_node(),
1739 }
1740 }
1741 fn stable_ptr(&self) -> Self::StablePtr {
1742 OptionTerminalColonColonPtr(self.as_syntax_node().0.stable_ptr)
1743 }
1744}
1745impl From<&OptionTerminalColonColon> for SyntaxStablePtrId {
1746 fn from(node: &OptionTerminalColonColon) -> Self {
1747 node.stable_ptr().untyped()
1748 }
1749}
1750impl OptionTerminalColonColon {
1751 pub fn is_variant(kind: SyntaxKind) -> bool {
1753 matches!(kind, SyntaxKind::OptionTerminalColonColonEmpty | SyntaxKind::TerminalColonColon)
1754 }
1755}
1756#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1757pub struct OptionTerminalColonColonEmpty {
1758 node: SyntaxNode,
1759 children: Arc<[SyntaxNode]>,
1760}
1761impl OptionTerminalColonColonEmpty {
1762 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalColonColonEmptyGreen {
1763 let children: Vec<GreenId> = vec![];
1764 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1765 OptionTerminalColonColonEmptyGreen(
1766 Arc::new(GreenNode {
1767 kind: SyntaxKind::OptionTerminalColonColonEmpty,
1768 details: GreenNodeDetails::Node { children, width },
1769 })
1770 .intern(db),
1771 )
1772 }
1773}
1774impl OptionTerminalColonColonEmpty {}
1775#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1776pub struct OptionTerminalColonColonEmptyPtr(pub SyntaxStablePtrId);
1777impl OptionTerminalColonColonEmptyPtr {}
1778impl TypedStablePtr for OptionTerminalColonColonEmptyPtr {
1779 type SyntaxNode = OptionTerminalColonColonEmpty;
1780 fn untyped(&self) -> SyntaxStablePtrId {
1781 self.0
1782 }
1783 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColonEmpty {
1784 OptionTerminalColonColonEmpty::from_syntax_node(db, self.0.lookup(db))
1785 }
1786}
1787impl From<OptionTerminalColonColonEmptyPtr> for SyntaxStablePtrId {
1788 fn from(ptr: OptionTerminalColonColonEmptyPtr) -> Self {
1789 ptr.untyped()
1790 }
1791}
1792#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1793pub struct OptionTerminalColonColonEmptyGreen(pub GreenId);
1794impl TypedSyntaxNode for OptionTerminalColonColonEmpty {
1795 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalColonColonEmpty);
1796 type StablePtr = OptionTerminalColonColonEmptyPtr;
1797 type Green = OptionTerminalColonColonEmptyGreen;
1798 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1799 OptionTerminalColonColonEmptyGreen(
1800 Arc::new(GreenNode {
1801 kind: SyntaxKind::OptionTerminalColonColonEmpty,
1802 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
1803 })
1804 .intern(db),
1805 )
1806 }
1807 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1808 let kind = node.kind(db);
1809 assert_eq!(
1810 kind,
1811 SyntaxKind::OptionTerminalColonColonEmpty,
1812 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1813 kind,
1814 SyntaxKind::OptionTerminalColonColonEmpty
1815 );
1816 let children = db.get_children(node.clone());
1817 Self { node, children }
1818 }
1819 fn as_syntax_node(&self) -> SyntaxNode {
1820 self.node.clone()
1821 }
1822 fn stable_ptr(&self) -> Self::StablePtr {
1823 OptionTerminalColonColonEmptyPtr(self.node.0.stable_ptr)
1824 }
1825}
1826impl From<&OptionTerminalColonColonEmpty> for SyntaxStablePtrId {
1827 fn from(node: &OptionTerminalColonColonEmpty) -> Self {
1828 node.stable_ptr().untyped()
1829 }
1830}
1831#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1832pub struct PathSegmentWithGenericArgs {
1833 node: SyntaxNode,
1834 children: Arc<[SyntaxNode]>,
1835}
1836impl PathSegmentWithGenericArgs {
1837 pub const INDEX_IDENT: usize = 0;
1838 pub const INDEX_SEPARATOR: usize = 1;
1839 pub const INDEX_GENERIC_ARGS: usize = 2;
1840 pub fn new_green(
1841 db: &dyn SyntaxGroup,
1842 ident: TerminalIdentifierGreen,
1843 separator: OptionTerminalColonColonGreen,
1844 generic_args: GenericArgsGreen,
1845 ) -> PathSegmentWithGenericArgsGreen {
1846 let children: Vec<GreenId> = vec![ident.0, separator.0, generic_args.0];
1847 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
1848 PathSegmentWithGenericArgsGreen(
1849 Arc::new(GreenNode {
1850 kind: SyntaxKind::PathSegmentWithGenericArgs,
1851 details: GreenNodeDetails::Node { children, width },
1852 })
1853 .intern(db),
1854 )
1855 }
1856}
1857impl PathSegmentWithGenericArgs {
1858 pub fn ident(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
1859 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
1860 }
1861 pub fn separator(&self, db: &dyn SyntaxGroup) -> OptionTerminalColonColon {
1862 OptionTerminalColonColon::from_syntax_node(db, self.children[1].clone())
1863 }
1864 pub fn generic_args(&self, db: &dyn SyntaxGroup) -> GenericArgs {
1865 GenericArgs::from_syntax_node(db, self.children[2].clone())
1866 }
1867}
1868#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1869pub struct PathSegmentWithGenericArgsPtr(pub SyntaxStablePtrId);
1870impl PathSegmentWithGenericArgsPtr {}
1871impl TypedStablePtr for PathSegmentWithGenericArgsPtr {
1872 type SyntaxNode = PathSegmentWithGenericArgs;
1873 fn untyped(&self) -> SyntaxStablePtrId {
1874 self.0
1875 }
1876 fn lookup(&self, db: &dyn SyntaxGroup) -> PathSegmentWithGenericArgs {
1877 PathSegmentWithGenericArgs::from_syntax_node(db, self.0.lookup(db))
1878 }
1879}
1880impl From<PathSegmentWithGenericArgsPtr> for SyntaxStablePtrId {
1881 fn from(ptr: PathSegmentWithGenericArgsPtr) -> Self {
1882 ptr.untyped()
1883 }
1884}
1885#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1886pub struct PathSegmentWithGenericArgsGreen(pub GreenId);
1887impl TypedSyntaxNode for PathSegmentWithGenericArgs {
1888 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PathSegmentWithGenericArgs);
1889 type StablePtr = PathSegmentWithGenericArgsPtr;
1890 type Green = PathSegmentWithGenericArgsGreen;
1891 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
1892 PathSegmentWithGenericArgsGreen(
1893 Arc::new(GreenNode {
1894 kind: SyntaxKind::PathSegmentWithGenericArgs,
1895 details: GreenNodeDetails::Node {
1896 children: vec![
1897 TerminalIdentifier::missing(db).0,
1898 OptionTerminalColonColon::missing(db).0,
1899 GenericArgs::missing(db).0,
1900 ],
1901 width: TextWidth::default(),
1902 },
1903 })
1904 .intern(db),
1905 )
1906 }
1907 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
1908 let kind = node.kind(db);
1909 assert_eq!(
1910 kind,
1911 SyntaxKind::PathSegmentWithGenericArgs,
1912 "Unexpected SyntaxKind {:?}. Expected {:?}.",
1913 kind,
1914 SyntaxKind::PathSegmentWithGenericArgs
1915 );
1916 let children = db.get_children(node.clone());
1917 Self { node, children }
1918 }
1919 fn as_syntax_node(&self) -> SyntaxNode {
1920 self.node.clone()
1921 }
1922 fn stable_ptr(&self) -> Self::StablePtr {
1923 PathSegmentWithGenericArgsPtr(self.node.0.stable_ptr)
1924 }
1925}
1926impl From<&PathSegmentWithGenericArgs> for SyntaxStablePtrId {
1927 fn from(node: &PathSegmentWithGenericArgs) -> Self {
1928 node.stable_ptr().untyped()
1929 }
1930}
1931#[derive(Clone, Debug, Eq, Hash, PartialEq)]
1932pub struct ExprPath(ElementList<PathSegment, 2>);
1933impl Deref for ExprPath {
1934 type Target = ElementList<PathSegment, 2>;
1935 fn deref(&self) -> &Self::Target {
1936 &self.0
1937 }
1938}
1939impl ExprPath {
1940 pub fn new_green(
1941 db: &dyn SyntaxGroup,
1942 children: Vec<ExprPathElementOrSeparatorGreen>,
1943 ) -> ExprPathGreen {
1944 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
1945 ExprPathGreen(
1946 Arc::new(GreenNode {
1947 kind: SyntaxKind::ExprPath,
1948 details: GreenNodeDetails::Node {
1949 children: children.iter().map(|x| x.id()).collect(),
1950 width,
1951 },
1952 })
1953 .intern(db),
1954 )
1955 }
1956}
1957#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1958pub struct ExprPathPtr(pub SyntaxStablePtrId);
1959impl TypedStablePtr for ExprPathPtr {
1960 type SyntaxNode = ExprPath;
1961 fn untyped(&self) -> SyntaxStablePtrId {
1962 self.0
1963 }
1964 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprPath {
1965 ExprPath::from_syntax_node(db, self.0.lookup(db))
1966 }
1967}
1968impl From<ExprPathPtr> for SyntaxStablePtrId {
1969 fn from(ptr: ExprPathPtr) -> Self {
1970 ptr.untyped()
1971 }
1972}
1973#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1974pub enum ExprPathElementOrSeparatorGreen {
1975 Separator(TerminalColonColonGreen),
1976 Element(PathSegmentGreen),
1977}
1978impl From<TerminalColonColonGreen> for ExprPathElementOrSeparatorGreen {
1979 fn from(value: TerminalColonColonGreen) -> Self {
1980 ExprPathElementOrSeparatorGreen::Separator(value)
1981 }
1982}
1983impl From<PathSegmentGreen> for ExprPathElementOrSeparatorGreen {
1984 fn from(value: PathSegmentGreen) -> Self {
1985 ExprPathElementOrSeparatorGreen::Element(value)
1986 }
1987}
1988impl ExprPathElementOrSeparatorGreen {
1989 fn id(&self) -> GreenId {
1990 match self {
1991 ExprPathElementOrSeparatorGreen::Separator(green) => green.0,
1992 ExprPathElementOrSeparatorGreen::Element(green) => green.0,
1993 }
1994 }
1995}
1996#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
1997pub struct ExprPathGreen(pub GreenId);
1998impl TypedSyntaxNode for ExprPath {
1999 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprPath);
2000 type StablePtr = ExprPathPtr;
2001 type Green = ExprPathGreen;
2002 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2003 ExprPathGreen(
2004 Arc::new(GreenNode {
2005 kind: SyntaxKind::ExprPath,
2006 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
2007 })
2008 .intern(db),
2009 )
2010 }
2011 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2012 Self(ElementList::new(node))
2013 }
2014 fn as_syntax_node(&self) -> SyntaxNode {
2015 self.node.clone()
2016 }
2017 fn stable_ptr(&self) -> Self::StablePtr {
2018 ExprPathPtr(self.node.0.stable_ptr)
2019 }
2020}
2021impl From<&ExprPath> for SyntaxStablePtrId {
2022 fn from(node: &ExprPath) -> Self {
2023 node.stable_ptr().untyped()
2024 }
2025}
2026#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2027pub struct ExprParenthesized {
2028 node: SyntaxNode,
2029 children: Arc<[SyntaxNode]>,
2030}
2031impl ExprParenthesized {
2032 pub const INDEX_LPAREN: usize = 0;
2033 pub const INDEX_EXPR: usize = 1;
2034 pub const INDEX_RPAREN: usize = 2;
2035 pub fn new_green(
2036 db: &dyn SyntaxGroup,
2037 lparen: TerminalLParenGreen,
2038 expr: ExprGreen,
2039 rparen: TerminalRParenGreen,
2040 ) -> ExprParenthesizedGreen {
2041 let children: Vec<GreenId> = vec![lparen.0, expr.0, rparen.0];
2042 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2043 ExprParenthesizedGreen(
2044 Arc::new(GreenNode {
2045 kind: SyntaxKind::ExprParenthesized,
2046 details: GreenNodeDetails::Node { children, width },
2047 })
2048 .intern(db),
2049 )
2050 }
2051}
2052impl ExprParenthesized {
2053 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
2054 TerminalLParen::from_syntax_node(db, self.children[0].clone())
2055 }
2056 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
2057 Expr::from_syntax_node(db, self.children[1].clone())
2058 }
2059 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
2060 TerminalRParen::from_syntax_node(db, self.children[2].clone())
2061 }
2062}
2063#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2064pub struct ExprParenthesizedPtr(pub SyntaxStablePtrId);
2065impl ExprParenthesizedPtr {}
2066impl TypedStablePtr for ExprParenthesizedPtr {
2067 type SyntaxNode = ExprParenthesized;
2068 fn untyped(&self) -> SyntaxStablePtrId {
2069 self.0
2070 }
2071 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprParenthesized {
2072 ExprParenthesized::from_syntax_node(db, self.0.lookup(db))
2073 }
2074}
2075impl From<ExprParenthesizedPtr> for SyntaxStablePtrId {
2076 fn from(ptr: ExprParenthesizedPtr) -> Self {
2077 ptr.untyped()
2078 }
2079}
2080#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2081pub struct ExprParenthesizedGreen(pub GreenId);
2082impl TypedSyntaxNode for ExprParenthesized {
2083 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprParenthesized);
2084 type StablePtr = ExprParenthesizedPtr;
2085 type Green = ExprParenthesizedGreen;
2086 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2087 ExprParenthesizedGreen(
2088 Arc::new(GreenNode {
2089 kind: SyntaxKind::ExprParenthesized,
2090 details: GreenNodeDetails::Node {
2091 children: vec![
2092 TerminalLParen::missing(db).0,
2093 Expr::missing(db).0,
2094 TerminalRParen::missing(db).0,
2095 ],
2096 width: TextWidth::default(),
2097 },
2098 })
2099 .intern(db),
2100 )
2101 }
2102 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2103 let kind = node.kind(db);
2104 assert_eq!(
2105 kind,
2106 SyntaxKind::ExprParenthesized,
2107 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2108 kind,
2109 SyntaxKind::ExprParenthesized
2110 );
2111 let children = db.get_children(node.clone());
2112 Self { node, children }
2113 }
2114 fn as_syntax_node(&self) -> SyntaxNode {
2115 self.node.clone()
2116 }
2117 fn stable_ptr(&self) -> Self::StablePtr {
2118 ExprParenthesizedPtr(self.node.0.stable_ptr)
2119 }
2120}
2121impl From<&ExprParenthesized> for SyntaxStablePtrId {
2122 fn from(node: &ExprParenthesized) -> Self {
2123 node.stable_ptr().untyped()
2124 }
2125}
2126#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2127pub struct ExprUnary {
2128 node: SyntaxNode,
2129 children: Arc<[SyntaxNode]>,
2130}
2131impl ExprUnary {
2132 pub const INDEX_OP: usize = 0;
2133 pub const INDEX_EXPR: usize = 1;
2134 pub fn new_green(
2135 db: &dyn SyntaxGroup,
2136 op: UnaryOperatorGreen,
2137 expr: ExprGreen,
2138 ) -> ExprUnaryGreen {
2139 let children: Vec<GreenId> = vec![op.0, expr.0];
2140 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2141 ExprUnaryGreen(
2142 Arc::new(GreenNode {
2143 kind: SyntaxKind::ExprUnary,
2144 details: GreenNodeDetails::Node { children, width },
2145 })
2146 .intern(db),
2147 )
2148 }
2149}
2150impl ExprUnary {
2151 pub fn op(&self, db: &dyn SyntaxGroup) -> UnaryOperator {
2152 UnaryOperator::from_syntax_node(db, self.children[0].clone())
2153 }
2154 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
2155 Expr::from_syntax_node(db, self.children[1].clone())
2156 }
2157}
2158#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2159pub struct ExprUnaryPtr(pub SyntaxStablePtrId);
2160impl ExprUnaryPtr {}
2161impl TypedStablePtr for ExprUnaryPtr {
2162 type SyntaxNode = ExprUnary;
2163 fn untyped(&self) -> SyntaxStablePtrId {
2164 self.0
2165 }
2166 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprUnary {
2167 ExprUnary::from_syntax_node(db, self.0.lookup(db))
2168 }
2169}
2170impl From<ExprUnaryPtr> for SyntaxStablePtrId {
2171 fn from(ptr: ExprUnaryPtr) -> Self {
2172 ptr.untyped()
2173 }
2174}
2175#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2176pub struct ExprUnaryGreen(pub GreenId);
2177impl TypedSyntaxNode for ExprUnary {
2178 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprUnary);
2179 type StablePtr = ExprUnaryPtr;
2180 type Green = ExprUnaryGreen;
2181 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2182 ExprUnaryGreen(
2183 Arc::new(GreenNode {
2184 kind: SyntaxKind::ExprUnary,
2185 details: GreenNodeDetails::Node {
2186 children: vec![UnaryOperator::missing(db).0, Expr::missing(db).0],
2187 width: TextWidth::default(),
2188 },
2189 })
2190 .intern(db),
2191 )
2192 }
2193 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2194 let kind = node.kind(db);
2195 assert_eq!(
2196 kind,
2197 SyntaxKind::ExprUnary,
2198 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2199 kind,
2200 SyntaxKind::ExprUnary
2201 );
2202 let children = db.get_children(node.clone());
2203 Self { node, children }
2204 }
2205 fn as_syntax_node(&self) -> SyntaxNode {
2206 self.node.clone()
2207 }
2208 fn stable_ptr(&self) -> Self::StablePtr {
2209 ExprUnaryPtr(self.node.0.stable_ptr)
2210 }
2211}
2212impl From<&ExprUnary> for SyntaxStablePtrId {
2213 fn from(node: &ExprUnary) -> Self {
2214 node.stable_ptr().untyped()
2215 }
2216}
2217#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2218pub enum UnaryOperator {
2219 Not(TerminalNot),
2220 BitNot(TerminalBitNot),
2221 Minus(TerminalMinus),
2222 At(TerminalAt),
2223 Desnap(TerminalMul),
2224}
2225#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2226pub struct UnaryOperatorPtr(pub SyntaxStablePtrId);
2227impl TypedStablePtr for UnaryOperatorPtr {
2228 type SyntaxNode = UnaryOperator;
2229 fn untyped(&self) -> SyntaxStablePtrId {
2230 self.0
2231 }
2232 fn lookup(&self, db: &dyn SyntaxGroup) -> UnaryOperator {
2233 UnaryOperator::from_syntax_node(db, self.0.lookup(db))
2234 }
2235}
2236impl From<UnaryOperatorPtr> for SyntaxStablePtrId {
2237 fn from(ptr: UnaryOperatorPtr) -> Self {
2238 ptr.untyped()
2239 }
2240}
2241impl From<TerminalNotPtr> for UnaryOperatorPtr {
2242 fn from(value: TerminalNotPtr) -> Self {
2243 Self(value.0)
2244 }
2245}
2246impl From<TerminalBitNotPtr> for UnaryOperatorPtr {
2247 fn from(value: TerminalBitNotPtr) -> Self {
2248 Self(value.0)
2249 }
2250}
2251impl From<TerminalMinusPtr> for UnaryOperatorPtr {
2252 fn from(value: TerminalMinusPtr) -> Self {
2253 Self(value.0)
2254 }
2255}
2256impl From<TerminalAtPtr> for UnaryOperatorPtr {
2257 fn from(value: TerminalAtPtr) -> Self {
2258 Self(value.0)
2259 }
2260}
2261impl From<TerminalMulPtr> for UnaryOperatorPtr {
2262 fn from(value: TerminalMulPtr) -> Self {
2263 Self(value.0)
2264 }
2265}
2266impl From<TerminalNotGreen> for UnaryOperatorGreen {
2267 fn from(value: TerminalNotGreen) -> Self {
2268 Self(value.0)
2269 }
2270}
2271impl From<TerminalBitNotGreen> for UnaryOperatorGreen {
2272 fn from(value: TerminalBitNotGreen) -> Self {
2273 Self(value.0)
2274 }
2275}
2276impl From<TerminalMinusGreen> for UnaryOperatorGreen {
2277 fn from(value: TerminalMinusGreen) -> Self {
2278 Self(value.0)
2279 }
2280}
2281impl From<TerminalAtGreen> for UnaryOperatorGreen {
2282 fn from(value: TerminalAtGreen) -> Self {
2283 Self(value.0)
2284 }
2285}
2286impl From<TerminalMulGreen> for UnaryOperatorGreen {
2287 fn from(value: TerminalMulGreen) -> Self {
2288 Self(value.0)
2289 }
2290}
2291#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2292pub struct UnaryOperatorGreen(pub GreenId);
2293impl TypedSyntaxNode for UnaryOperator {
2294 const OPTIONAL_KIND: Option<SyntaxKind> = None;
2295 type StablePtr = UnaryOperatorPtr;
2296 type Green = UnaryOperatorGreen;
2297 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2298 panic!("No missing variant.");
2299 }
2300 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2301 let kind = node.kind(db);
2302 match kind {
2303 SyntaxKind::TerminalNot => UnaryOperator::Not(TerminalNot::from_syntax_node(db, node)),
2304 SyntaxKind::TerminalBitNot => {
2305 UnaryOperator::BitNot(TerminalBitNot::from_syntax_node(db, node))
2306 }
2307 SyntaxKind::TerminalMinus => {
2308 UnaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))
2309 }
2310 SyntaxKind::TerminalAt => UnaryOperator::At(TerminalAt::from_syntax_node(db, node)),
2311 SyntaxKind::TerminalMul => {
2312 UnaryOperator::Desnap(TerminalMul::from_syntax_node(db, node))
2313 }
2314 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UnaryOperator"),
2315 }
2316 }
2317 fn as_syntax_node(&self) -> SyntaxNode {
2318 match self {
2319 UnaryOperator::Not(x) => x.as_syntax_node(),
2320 UnaryOperator::BitNot(x) => x.as_syntax_node(),
2321 UnaryOperator::Minus(x) => x.as_syntax_node(),
2322 UnaryOperator::At(x) => x.as_syntax_node(),
2323 UnaryOperator::Desnap(x) => x.as_syntax_node(),
2324 }
2325 }
2326 fn stable_ptr(&self) -> Self::StablePtr {
2327 UnaryOperatorPtr(self.as_syntax_node().0.stable_ptr)
2328 }
2329}
2330impl From<&UnaryOperator> for SyntaxStablePtrId {
2331 fn from(node: &UnaryOperator) -> Self {
2332 node.stable_ptr().untyped()
2333 }
2334}
2335impl UnaryOperator {
2336 pub fn is_variant(kind: SyntaxKind) -> bool {
2338 matches!(
2339 kind,
2340 SyntaxKind::TerminalNot
2341 | SyntaxKind::TerminalBitNot
2342 | SyntaxKind::TerminalMinus
2343 | SyntaxKind::TerminalAt
2344 | SyntaxKind::TerminalMul
2345 )
2346 }
2347}
2348#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2349pub struct ExprBinary {
2350 node: SyntaxNode,
2351 children: Arc<[SyntaxNode]>,
2352}
2353impl ExprBinary {
2354 pub const INDEX_LHS: usize = 0;
2355 pub const INDEX_OP: usize = 1;
2356 pub const INDEX_RHS: usize = 2;
2357 pub fn new_green(
2358 db: &dyn SyntaxGroup,
2359 lhs: ExprGreen,
2360 op: BinaryOperatorGreen,
2361 rhs: ExprGreen,
2362 ) -> ExprBinaryGreen {
2363 let children: Vec<GreenId> = vec![lhs.0, op.0, rhs.0];
2364 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2365 ExprBinaryGreen(
2366 Arc::new(GreenNode {
2367 kind: SyntaxKind::ExprBinary,
2368 details: GreenNodeDetails::Node { children, width },
2369 })
2370 .intern(db),
2371 )
2372 }
2373}
2374impl ExprBinary {
2375 pub fn lhs(&self, db: &dyn SyntaxGroup) -> Expr {
2376 Expr::from_syntax_node(db, self.children[0].clone())
2377 }
2378 pub fn op(&self, db: &dyn SyntaxGroup) -> BinaryOperator {
2379 BinaryOperator::from_syntax_node(db, self.children[1].clone())
2380 }
2381 pub fn rhs(&self, db: &dyn SyntaxGroup) -> Expr {
2382 Expr::from_syntax_node(db, self.children[2].clone())
2383 }
2384}
2385#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2386pub struct ExprBinaryPtr(pub SyntaxStablePtrId);
2387impl ExprBinaryPtr {}
2388impl TypedStablePtr for ExprBinaryPtr {
2389 type SyntaxNode = ExprBinary;
2390 fn untyped(&self) -> SyntaxStablePtrId {
2391 self.0
2392 }
2393 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprBinary {
2394 ExprBinary::from_syntax_node(db, self.0.lookup(db))
2395 }
2396}
2397impl From<ExprBinaryPtr> for SyntaxStablePtrId {
2398 fn from(ptr: ExprBinaryPtr) -> Self {
2399 ptr.untyped()
2400 }
2401}
2402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2403pub struct ExprBinaryGreen(pub GreenId);
2404impl TypedSyntaxNode for ExprBinary {
2405 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprBinary);
2406 type StablePtr = ExprBinaryPtr;
2407 type Green = ExprBinaryGreen;
2408 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2409 ExprBinaryGreen(
2410 Arc::new(GreenNode {
2411 kind: SyntaxKind::ExprBinary,
2412 details: GreenNodeDetails::Node {
2413 children: vec![
2414 Expr::missing(db).0,
2415 BinaryOperator::missing(db).0,
2416 Expr::missing(db).0,
2417 ],
2418 width: TextWidth::default(),
2419 },
2420 })
2421 .intern(db),
2422 )
2423 }
2424 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2425 let kind = node.kind(db);
2426 assert_eq!(
2427 kind,
2428 SyntaxKind::ExprBinary,
2429 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2430 kind,
2431 SyntaxKind::ExprBinary
2432 );
2433 let children = db.get_children(node.clone());
2434 Self { node, children }
2435 }
2436 fn as_syntax_node(&self) -> SyntaxNode {
2437 self.node.clone()
2438 }
2439 fn stable_ptr(&self) -> Self::StablePtr {
2440 ExprBinaryPtr(self.node.0.stable_ptr)
2441 }
2442}
2443impl From<&ExprBinary> for SyntaxStablePtrId {
2444 fn from(node: &ExprBinary) -> Self {
2445 node.stable_ptr().untyped()
2446 }
2447}
2448#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2449pub enum BinaryOperator {
2450 Dot(TerminalDot),
2451 Not(TerminalNot),
2452 Mul(TerminalMul),
2453 MulEq(TerminalMulEq),
2454 Div(TerminalDiv),
2455 DivEq(TerminalDivEq),
2456 Mod(TerminalMod),
2457 ModEq(TerminalModEq),
2458 Plus(TerminalPlus),
2459 PlusEq(TerminalPlusEq),
2460 Minus(TerminalMinus),
2461 MinusEq(TerminalMinusEq),
2462 EqEq(TerminalEqEq),
2463 Neq(TerminalNeq),
2464 Eq(TerminalEq),
2465 And(TerminalAnd),
2466 AndAnd(TerminalAndAnd),
2467 Or(TerminalOr),
2468 OrOr(TerminalOrOr),
2469 Xor(TerminalXor),
2470 LE(TerminalLE),
2471 GE(TerminalGE),
2472 LT(TerminalLT),
2473 GT(TerminalGT),
2474 DotDot(TerminalDotDot),
2475}
2476#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2477pub struct BinaryOperatorPtr(pub SyntaxStablePtrId);
2478impl TypedStablePtr for BinaryOperatorPtr {
2479 type SyntaxNode = BinaryOperator;
2480 fn untyped(&self) -> SyntaxStablePtrId {
2481 self.0
2482 }
2483 fn lookup(&self, db: &dyn SyntaxGroup) -> BinaryOperator {
2484 BinaryOperator::from_syntax_node(db, self.0.lookup(db))
2485 }
2486}
2487impl From<BinaryOperatorPtr> for SyntaxStablePtrId {
2488 fn from(ptr: BinaryOperatorPtr) -> Self {
2489 ptr.untyped()
2490 }
2491}
2492impl From<TerminalDotPtr> for BinaryOperatorPtr {
2493 fn from(value: TerminalDotPtr) -> Self {
2494 Self(value.0)
2495 }
2496}
2497impl From<TerminalNotPtr> for BinaryOperatorPtr {
2498 fn from(value: TerminalNotPtr) -> Self {
2499 Self(value.0)
2500 }
2501}
2502impl From<TerminalMulPtr> for BinaryOperatorPtr {
2503 fn from(value: TerminalMulPtr) -> Self {
2504 Self(value.0)
2505 }
2506}
2507impl From<TerminalMulEqPtr> for BinaryOperatorPtr {
2508 fn from(value: TerminalMulEqPtr) -> Self {
2509 Self(value.0)
2510 }
2511}
2512impl From<TerminalDivPtr> for BinaryOperatorPtr {
2513 fn from(value: TerminalDivPtr) -> Self {
2514 Self(value.0)
2515 }
2516}
2517impl From<TerminalDivEqPtr> for BinaryOperatorPtr {
2518 fn from(value: TerminalDivEqPtr) -> Self {
2519 Self(value.0)
2520 }
2521}
2522impl From<TerminalModPtr> for BinaryOperatorPtr {
2523 fn from(value: TerminalModPtr) -> Self {
2524 Self(value.0)
2525 }
2526}
2527impl From<TerminalModEqPtr> for BinaryOperatorPtr {
2528 fn from(value: TerminalModEqPtr) -> Self {
2529 Self(value.0)
2530 }
2531}
2532impl From<TerminalPlusPtr> for BinaryOperatorPtr {
2533 fn from(value: TerminalPlusPtr) -> Self {
2534 Self(value.0)
2535 }
2536}
2537impl From<TerminalPlusEqPtr> for BinaryOperatorPtr {
2538 fn from(value: TerminalPlusEqPtr) -> Self {
2539 Self(value.0)
2540 }
2541}
2542impl From<TerminalMinusPtr> for BinaryOperatorPtr {
2543 fn from(value: TerminalMinusPtr) -> Self {
2544 Self(value.0)
2545 }
2546}
2547impl From<TerminalMinusEqPtr> for BinaryOperatorPtr {
2548 fn from(value: TerminalMinusEqPtr) -> Self {
2549 Self(value.0)
2550 }
2551}
2552impl From<TerminalEqEqPtr> for BinaryOperatorPtr {
2553 fn from(value: TerminalEqEqPtr) -> Self {
2554 Self(value.0)
2555 }
2556}
2557impl From<TerminalNeqPtr> for BinaryOperatorPtr {
2558 fn from(value: TerminalNeqPtr) -> Self {
2559 Self(value.0)
2560 }
2561}
2562impl From<TerminalEqPtr> for BinaryOperatorPtr {
2563 fn from(value: TerminalEqPtr) -> Self {
2564 Self(value.0)
2565 }
2566}
2567impl From<TerminalAndPtr> for BinaryOperatorPtr {
2568 fn from(value: TerminalAndPtr) -> Self {
2569 Self(value.0)
2570 }
2571}
2572impl From<TerminalAndAndPtr> for BinaryOperatorPtr {
2573 fn from(value: TerminalAndAndPtr) -> Self {
2574 Self(value.0)
2575 }
2576}
2577impl From<TerminalOrPtr> for BinaryOperatorPtr {
2578 fn from(value: TerminalOrPtr) -> Self {
2579 Self(value.0)
2580 }
2581}
2582impl From<TerminalOrOrPtr> for BinaryOperatorPtr {
2583 fn from(value: TerminalOrOrPtr) -> Self {
2584 Self(value.0)
2585 }
2586}
2587impl From<TerminalXorPtr> for BinaryOperatorPtr {
2588 fn from(value: TerminalXorPtr) -> Self {
2589 Self(value.0)
2590 }
2591}
2592impl From<TerminalLEPtr> for BinaryOperatorPtr {
2593 fn from(value: TerminalLEPtr) -> Self {
2594 Self(value.0)
2595 }
2596}
2597impl From<TerminalGEPtr> for BinaryOperatorPtr {
2598 fn from(value: TerminalGEPtr) -> Self {
2599 Self(value.0)
2600 }
2601}
2602impl From<TerminalLTPtr> for BinaryOperatorPtr {
2603 fn from(value: TerminalLTPtr) -> Self {
2604 Self(value.0)
2605 }
2606}
2607impl From<TerminalGTPtr> for BinaryOperatorPtr {
2608 fn from(value: TerminalGTPtr) -> Self {
2609 Self(value.0)
2610 }
2611}
2612impl From<TerminalDotDotPtr> for BinaryOperatorPtr {
2613 fn from(value: TerminalDotDotPtr) -> Self {
2614 Self(value.0)
2615 }
2616}
2617impl From<TerminalDotGreen> for BinaryOperatorGreen {
2618 fn from(value: TerminalDotGreen) -> Self {
2619 Self(value.0)
2620 }
2621}
2622impl From<TerminalNotGreen> for BinaryOperatorGreen {
2623 fn from(value: TerminalNotGreen) -> Self {
2624 Self(value.0)
2625 }
2626}
2627impl From<TerminalMulGreen> for BinaryOperatorGreen {
2628 fn from(value: TerminalMulGreen) -> Self {
2629 Self(value.0)
2630 }
2631}
2632impl From<TerminalMulEqGreen> for BinaryOperatorGreen {
2633 fn from(value: TerminalMulEqGreen) -> Self {
2634 Self(value.0)
2635 }
2636}
2637impl From<TerminalDivGreen> for BinaryOperatorGreen {
2638 fn from(value: TerminalDivGreen) -> Self {
2639 Self(value.0)
2640 }
2641}
2642impl From<TerminalDivEqGreen> for BinaryOperatorGreen {
2643 fn from(value: TerminalDivEqGreen) -> Self {
2644 Self(value.0)
2645 }
2646}
2647impl From<TerminalModGreen> for BinaryOperatorGreen {
2648 fn from(value: TerminalModGreen) -> Self {
2649 Self(value.0)
2650 }
2651}
2652impl From<TerminalModEqGreen> for BinaryOperatorGreen {
2653 fn from(value: TerminalModEqGreen) -> Self {
2654 Self(value.0)
2655 }
2656}
2657impl From<TerminalPlusGreen> for BinaryOperatorGreen {
2658 fn from(value: TerminalPlusGreen) -> Self {
2659 Self(value.0)
2660 }
2661}
2662impl From<TerminalPlusEqGreen> for BinaryOperatorGreen {
2663 fn from(value: TerminalPlusEqGreen) -> Self {
2664 Self(value.0)
2665 }
2666}
2667impl From<TerminalMinusGreen> for BinaryOperatorGreen {
2668 fn from(value: TerminalMinusGreen) -> Self {
2669 Self(value.0)
2670 }
2671}
2672impl From<TerminalMinusEqGreen> for BinaryOperatorGreen {
2673 fn from(value: TerminalMinusEqGreen) -> Self {
2674 Self(value.0)
2675 }
2676}
2677impl From<TerminalEqEqGreen> for BinaryOperatorGreen {
2678 fn from(value: TerminalEqEqGreen) -> Self {
2679 Self(value.0)
2680 }
2681}
2682impl From<TerminalNeqGreen> for BinaryOperatorGreen {
2683 fn from(value: TerminalNeqGreen) -> Self {
2684 Self(value.0)
2685 }
2686}
2687impl From<TerminalEqGreen> for BinaryOperatorGreen {
2688 fn from(value: TerminalEqGreen) -> Self {
2689 Self(value.0)
2690 }
2691}
2692impl From<TerminalAndGreen> for BinaryOperatorGreen {
2693 fn from(value: TerminalAndGreen) -> Self {
2694 Self(value.0)
2695 }
2696}
2697impl From<TerminalAndAndGreen> for BinaryOperatorGreen {
2698 fn from(value: TerminalAndAndGreen) -> Self {
2699 Self(value.0)
2700 }
2701}
2702impl From<TerminalOrGreen> for BinaryOperatorGreen {
2703 fn from(value: TerminalOrGreen) -> Self {
2704 Self(value.0)
2705 }
2706}
2707impl From<TerminalOrOrGreen> for BinaryOperatorGreen {
2708 fn from(value: TerminalOrOrGreen) -> Self {
2709 Self(value.0)
2710 }
2711}
2712impl From<TerminalXorGreen> for BinaryOperatorGreen {
2713 fn from(value: TerminalXorGreen) -> Self {
2714 Self(value.0)
2715 }
2716}
2717impl From<TerminalLEGreen> for BinaryOperatorGreen {
2718 fn from(value: TerminalLEGreen) -> Self {
2719 Self(value.0)
2720 }
2721}
2722impl From<TerminalGEGreen> for BinaryOperatorGreen {
2723 fn from(value: TerminalGEGreen) -> Self {
2724 Self(value.0)
2725 }
2726}
2727impl From<TerminalLTGreen> for BinaryOperatorGreen {
2728 fn from(value: TerminalLTGreen) -> Self {
2729 Self(value.0)
2730 }
2731}
2732impl From<TerminalGTGreen> for BinaryOperatorGreen {
2733 fn from(value: TerminalGTGreen) -> Self {
2734 Self(value.0)
2735 }
2736}
2737impl From<TerminalDotDotGreen> for BinaryOperatorGreen {
2738 fn from(value: TerminalDotDotGreen) -> Self {
2739 Self(value.0)
2740 }
2741}
2742#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2743pub struct BinaryOperatorGreen(pub GreenId);
2744impl TypedSyntaxNode for BinaryOperator {
2745 const OPTIONAL_KIND: Option<SyntaxKind> = None;
2746 type StablePtr = BinaryOperatorPtr;
2747 type Green = BinaryOperatorGreen;
2748 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2749 panic!("No missing variant.");
2750 }
2751 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2752 let kind = node.kind(db);
2753 match kind {
2754 SyntaxKind::TerminalDot => BinaryOperator::Dot(TerminalDot::from_syntax_node(db, node)),
2755 SyntaxKind::TerminalNot => BinaryOperator::Not(TerminalNot::from_syntax_node(db, node)),
2756 SyntaxKind::TerminalMul => BinaryOperator::Mul(TerminalMul::from_syntax_node(db, node)),
2757 SyntaxKind::TerminalMulEq => {
2758 BinaryOperator::MulEq(TerminalMulEq::from_syntax_node(db, node))
2759 }
2760 SyntaxKind::TerminalDiv => BinaryOperator::Div(TerminalDiv::from_syntax_node(db, node)),
2761 SyntaxKind::TerminalDivEq => {
2762 BinaryOperator::DivEq(TerminalDivEq::from_syntax_node(db, node))
2763 }
2764 SyntaxKind::TerminalMod => BinaryOperator::Mod(TerminalMod::from_syntax_node(db, node)),
2765 SyntaxKind::TerminalModEq => {
2766 BinaryOperator::ModEq(TerminalModEq::from_syntax_node(db, node))
2767 }
2768 SyntaxKind::TerminalPlus => {
2769 BinaryOperator::Plus(TerminalPlus::from_syntax_node(db, node))
2770 }
2771 SyntaxKind::TerminalPlusEq => {
2772 BinaryOperator::PlusEq(TerminalPlusEq::from_syntax_node(db, node))
2773 }
2774 SyntaxKind::TerminalMinus => {
2775 BinaryOperator::Minus(TerminalMinus::from_syntax_node(db, node))
2776 }
2777 SyntaxKind::TerminalMinusEq => {
2778 BinaryOperator::MinusEq(TerminalMinusEq::from_syntax_node(db, node))
2779 }
2780 SyntaxKind::TerminalEqEq => {
2781 BinaryOperator::EqEq(TerminalEqEq::from_syntax_node(db, node))
2782 }
2783 SyntaxKind::TerminalNeq => BinaryOperator::Neq(TerminalNeq::from_syntax_node(db, node)),
2784 SyntaxKind::TerminalEq => BinaryOperator::Eq(TerminalEq::from_syntax_node(db, node)),
2785 SyntaxKind::TerminalAnd => BinaryOperator::And(TerminalAnd::from_syntax_node(db, node)),
2786 SyntaxKind::TerminalAndAnd => {
2787 BinaryOperator::AndAnd(TerminalAndAnd::from_syntax_node(db, node))
2788 }
2789 SyntaxKind::TerminalOr => BinaryOperator::Or(TerminalOr::from_syntax_node(db, node)),
2790 SyntaxKind::TerminalOrOr => {
2791 BinaryOperator::OrOr(TerminalOrOr::from_syntax_node(db, node))
2792 }
2793 SyntaxKind::TerminalXor => BinaryOperator::Xor(TerminalXor::from_syntax_node(db, node)),
2794 SyntaxKind::TerminalLE => BinaryOperator::LE(TerminalLE::from_syntax_node(db, node)),
2795 SyntaxKind::TerminalGE => BinaryOperator::GE(TerminalGE::from_syntax_node(db, node)),
2796 SyntaxKind::TerminalLT => BinaryOperator::LT(TerminalLT::from_syntax_node(db, node)),
2797 SyntaxKind::TerminalGT => BinaryOperator::GT(TerminalGT::from_syntax_node(db, node)),
2798 SyntaxKind::TerminalDotDot => {
2799 BinaryOperator::DotDot(TerminalDotDot::from_syntax_node(db, node))
2800 }
2801 _ => {
2802 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "BinaryOperator")
2803 }
2804 }
2805 }
2806 fn as_syntax_node(&self) -> SyntaxNode {
2807 match self {
2808 BinaryOperator::Dot(x) => x.as_syntax_node(),
2809 BinaryOperator::Not(x) => x.as_syntax_node(),
2810 BinaryOperator::Mul(x) => x.as_syntax_node(),
2811 BinaryOperator::MulEq(x) => x.as_syntax_node(),
2812 BinaryOperator::Div(x) => x.as_syntax_node(),
2813 BinaryOperator::DivEq(x) => x.as_syntax_node(),
2814 BinaryOperator::Mod(x) => x.as_syntax_node(),
2815 BinaryOperator::ModEq(x) => x.as_syntax_node(),
2816 BinaryOperator::Plus(x) => x.as_syntax_node(),
2817 BinaryOperator::PlusEq(x) => x.as_syntax_node(),
2818 BinaryOperator::Minus(x) => x.as_syntax_node(),
2819 BinaryOperator::MinusEq(x) => x.as_syntax_node(),
2820 BinaryOperator::EqEq(x) => x.as_syntax_node(),
2821 BinaryOperator::Neq(x) => x.as_syntax_node(),
2822 BinaryOperator::Eq(x) => x.as_syntax_node(),
2823 BinaryOperator::And(x) => x.as_syntax_node(),
2824 BinaryOperator::AndAnd(x) => x.as_syntax_node(),
2825 BinaryOperator::Or(x) => x.as_syntax_node(),
2826 BinaryOperator::OrOr(x) => x.as_syntax_node(),
2827 BinaryOperator::Xor(x) => x.as_syntax_node(),
2828 BinaryOperator::LE(x) => x.as_syntax_node(),
2829 BinaryOperator::GE(x) => x.as_syntax_node(),
2830 BinaryOperator::LT(x) => x.as_syntax_node(),
2831 BinaryOperator::GT(x) => x.as_syntax_node(),
2832 BinaryOperator::DotDot(x) => x.as_syntax_node(),
2833 }
2834 }
2835 fn stable_ptr(&self) -> Self::StablePtr {
2836 BinaryOperatorPtr(self.as_syntax_node().0.stable_ptr)
2837 }
2838}
2839impl From<&BinaryOperator> for SyntaxStablePtrId {
2840 fn from(node: &BinaryOperator) -> Self {
2841 node.stable_ptr().untyped()
2842 }
2843}
2844impl BinaryOperator {
2845 pub fn is_variant(kind: SyntaxKind) -> bool {
2847 matches!(
2848 kind,
2849 SyntaxKind::TerminalDot
2850 | SyntaxKind::TerminalNot
2851 | SyntaxKind::TerminalMul
2852 | SyntaxKind::TerminalMulEq
2853 | SyntaxKind::TerminalDiv
2854 | SyntaxKind::TerminalDivEq
2855 | SyntaxKind::TerminalMod
2856 | SyntaxKind::TerminalModEq
2857 | SyntaxKind::TerminalPlus
2858 | SyntaxKind::TerminalPlusEq
2859 | SyntaxKind::TerminalMinus
2860 | SyntaxKind::TerminalMinusEq
2861 | SyntaxKind::TerminalEqEq
2862 | SyntaxKind::TerminalNeq
2863 | SyntaxKind::TerminalEq
2864 | SyntaxKind::TerminalAnd
2865 | SyntaxKind::TerminalAndAnd
2866 | SyntaxKind::TerminalOr
2867 | SyntaxKind::TerminalOrOr
2868 | SyntaxKind::TerminalXor
2869 | SyntaxKind::TerminalLE
2870 | SyntaxKind::TerminalGE
2871 | SyntaxKind::TerminalLT
2872 | SyntaxKind::TerminalGT
2873 | SyntaxKind::TerminalDotDot
2874 )
2875 }
2876}
2877#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2878pub struct ExprListParenthesized {
2879 node: SyntaxNode,
2880 children: Arc<[SyntaxNode]>,
2881}
2882impl ExprListParenthesized {
2883 pub const INDEX_LPAREN: usize = 0;
2884 pub const INDEX_EXPRESSIONS: usize = 1;
2885 pub const INDEX_RPAREN: usize = 2;
2886 pub fn new_green(
2887 db: &dyn SyntaxGroup,
2888 lparen: TerminalLParenGreen,
2889 expressions: ExprListGreen,
2890 rparen: TerminalRParenGreen,
2891 ) -> ExprListParenthesizedGreen {
2892 let children: Vec<GreenId> = vec![lparen.0, expressions.0, rparen.0];
2893 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2894 ExprListParenthesizedGreen(
2895 Arc::new(GreenNode {
2896 kind: SyntaxKind::ExprListParenthesized,
2897 details: GreenNodeDetails::Node { children, width },
2898 })
2899 .intern(db),
2900 )
2901 }
2902}
2903impl ExprListParenthesized {
2904 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
2905 TerminalLParen::from_syntax_node(db, self.children[0].clone())
2906 }
2907 pub fn expressions(&self, db: &dyn SyntaxGroup) -> ExprList {
2908 ExprList::from_syntax_node(db, self.children[1].clone())
2909 }
2910 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
2911 TerminalRParen::from_syntax_node(db, self.children[2].clone())
2912 }
2913}
2914#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2915pub struct ExprListParenthesizedPtr(pub SyntaxStablePtrId);
2916impl ExprListParenthesizedPtr {}
2917impl TypedStablePtr for ExprListParenthesizedPtr {
2918 type SyntaxNode = ExprListParenthesized;
2919 fn untyped(&self) -> SyntaxStablePtrId {
2920 self.0
2921 }
2922 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprListParenthesized {
2923 ExprListParenthesized::from_syntax_node(db, self.0.lookup(db))
2924 }
2925}
2926impl From<ExprListParenthesizedPtr> for SyntaxStablePtrId {
2927 fn from(ptr: ExprListParenthesizedPtr) -> Self {
2928 ptr.untyped()
2929 }
2930}
2931#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
2932pub struct ExprListParenthesizedGreen(pub GreenId);
2933impl TypedSyntaxNode for ExprListParenthesized {
2934 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprListParenthesized);
2935 type StablePtr = ExprListParenthesizedPtr;
2936 type Green = ExprListParenthesizedGreen;
2937 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
2938 ExprListParenthesizedGreen(
2939 Arc::new(GreenNode {
2940 kind: SyntaxKind::ExprListParenthesized,
2941 details: GreenNodeDetails::Node {
2942 children: vec![
2943 TerminalLParen::missing(db).0,
2944 ExprList::missing(db).0,
2945 TerminalRParen::missing(db).0,
2946 ],
2947 width: TextWidth::default(),
2948 },
2949 })
2950 .intern(db),
2951 )
2952 }
2953 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
2954 let kind = node.kind(db);
2955 assert_eq!(
2956 kind,
2957 SyntaxKind::ExprListParenthesized,
2958 "Unexpected SyntaxKind {:?}. Expected {:?}.",
2959 kind,
2960 SyntaxKind::ExprListParenthesized
2961 );
2962 let children = db.get_children(node.clone());
2963 Self { node, children }
2964 }
2965 fn as_syntax_node(&self) -> SyntaxNode {
2966 self.node.clone()
2967 }
2968 fn stable_ptr(&self) -> Self::StablePtr {
2969 ExprListParenthesizedPtr(self.node.0.stable_ptr)
2970 }
2971}
2972impl From<&ExprListParenthesized> for SyntaxStablePtrId {
2973 fn from(node: &ExprListParenthesized) -> Self {
2974 node.stable_ptr().untyped()
2975 }
2976}
2977#[derive(Clone, Debug, Eq, Hash, PartialEq)]
2978pub struct ExprFunctionCall {
2979 node: SyntaxNode,
2980 children: Arc<[SyntaxNode]>,
2981}
2982impl ExprFunctionCall {
2983 pub const INDEX_PATH: usize = 0;
2984 pub const INDEX_ARGUMENTS: usize = 1;
2985 pub fn new_green(
2986 db: &dyn SyntaxGroup,
2987 path: ExprPathGreen,
2988 arguments: ArgListParenthesizedGreen,
2989 ) -> ExprFunctionCallGreen {
2990 let children: Vec<GreenId> = vec![path.0, arguments.0];
2991 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
2992 ExprFunctionCallGreen(
2993 Arc::new(GreenNode {
2994 kind: SyntaxKind::ExprFunctionCall,
2995 details: GreenNodeDetails::Node { children, width },
2996 })
2997 .intern(db),
2998 )
2999 }
3000}
3001impl ExprFunctionCall {
3002 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
3003 ExprPath::from_syntax_node(db, self.children[0].clone())
3004 }
3005 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgListParenthesized {
3006 ArgListParenthesized::from_syntax_node(db, self.children[1].clone())
3007 }
3008}
3009#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3010pub struct ExprFunctionCallPtr(pub SyntaxStablePtrId);
3011impl ExprFunctionCallPtr {}
3012impl TypedStablePtr for ExprFunctionCallPtr {
3013 type SyntaxNode = ExprFunctionCall;
3014 fn untyped(&self) -> SyntaxStablePtrId {
3015 self.0
3016 }
3017 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFunctionCall {
3018 ExprFunctionCall::from_syntax_node(db, self.0.lookup(db))
3019 }
3020}
3021impl From<ExprFunctionCallPtr> for SyntaxStablePtrId {
3022 fn from(ptr: ExprFunctionCallPtr) -> Self {
3023 ptr.untyped()
3024 }
3025}
3026#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3027pub struct ExprFunctionCallGreen(pub GreenId);
3028impl TypedSyntaxNode for ExprFunctionCall {
3029 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFunctionCall);
3030 type StablePtr = ExprFunctionCallPtr;
3031 type Green = ExprFunctionCallGreen;
3032 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3033 ExprFunctionCallGreen(
3034 Arc::new(GreenNode {
3035 kind: SyntaxKind::ExprFunctionCall,
3036 details: GreenNodeDetails::Node {
3037 children: vec![ExprPath::missing(db).0, ArgListParenthesized::missing(db).0],
3038 width: TextWidth::default(),
3039 },
3040 })
3041 .intern(db),
3042 )
3043 }
3044 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3045 let kind = node.kind(db);
3046 assert_eq!(
3047 kind,
3048 SyntaxKind::ExprFunctionCall,
3049 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3050 kind,
3051 SyntaxKind::ExprFunctionCall
3052 );
3053 let children = db.get_children(node.clone());
3054 Self { node, children }
3055 }
3056 fn as_syntax_node(&self) -> SyntaxNode {
3057 self.node.clone()
3058 }
3059 fn stable_ptr(&self) -> Self::StablePtr {
3060 ExprFunctionCallPtr(self.node.0.stable_ptr)
3061 }
3062}
3063impl From<&ExprFunctionCall> for SyntaxStablePtrId {
3064 fn from(node: &ExprFunctionCall) -> Self {
3065 node.stable_ptr().untyped()
3066 }
3067}
3068#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3069pub struct ArgListParenthesized {
3070 node: SyntaxNode,
3071 children: Arc<[SyntaxNode]>,
3072}
3073impl ArgListParenthesized {
3074 pub const INDEX_LPAREN: usize = 0;
3075 pub const INDEX_ARGUMENTS: usize = 1;
3076 pub const INDEX_RPAREN: usize = 2;
3077 pub fn new_green(
3078 db: &dyn SyntaxGroup,
3079 lparen: TerminalLParenGreen,
3080 arguments: ArgListGreen,
3081 rparen: TerminalRParenGreen,
3082 ) -> ArgListParenthesizedGreen {
3083 let children: Vec<GreenId> = vec![lparen.0, arguments.0, rparen.0];
3084 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3085 ArgListParenthesizedGreen(
3086 Arc::new(GreenNode {
3087 kind: SyntaxKind::ArgListParenthesized,
3088 details: GreenNodeDetails::Node { children, width },
3089 })
3090 .intern(db),
3091 )
3092 }
3093}
3094impl ArgListParenthesized {
3095 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
3096 TerminalLParen::from_syntax_node(db, self.children[0].clone())
3097 }
3098 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
3099 ArgList::from_syntax_node(db, self.children[1].clone())
3100 }
3101 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
3102 TerminalRParen::from_syntax_node(db, self.children[2].clone())
3103 }
3104}
3105#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3106pub struct ArgListParenthesizedPtr(pub SyntaxStablePtrId);
3107impl ArgListParenthesizedPtr {}
3108impl TypedStablePtr for ArgListParenthesizedPtr {
3109 type SyntaxNode = ArgListParenthesized;
3110 fn untyped(&self) -> SyntaxStablePtrId {
3111 self.0
3112 }
3113 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListParenthesized {
3114 ArgListParenthesized::from_syntax_node(db, self.0.lookup(db))
3115 }
3116}
3117impl From<ArgListParenthesizedPtr> for SyntaxStablePtrId {
3118 fn from(ptr: ArgListParenthesizedPtr) -> Self {
3119 ptr.untyped()
3120 }
3121}
3122#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3123pub struct ArgListParenthesizedGreen(pub GreenId);
3124impl TypedSyntaxNode for ArgListParenthesized {
3125 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListParenthesized);
3126 type StablePtr = ArgListParenthesizedPtr;
3127 type Green = ArgListParenthesizedGreen;
3128 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3129 ArgListParenthesizedGreen(
3130 Arc::new(GreenNode {
3131 kind: SyntaxKind::ArgListParenthesized,
3132 details: GreenNodeDetails::Node {
3133 children: vec![
3134 TerminalLParen::missing(db).0,
3135 ArgList::missing(db).0,
3136 TerminalRParen::missing(db).0,
3137 ],
3138 width: TextWidth::default(),
3139 },
3140 })
3141 .intern(db),
3142 )
3143 }
3144 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3145 let kind = node.kind(db);
3146 assert_eq!(
3147 kind,
3148 SyntaxKind::ArgListParenthesized,
3149 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3150 kind,
3151 SyntaxKind::ArgListParenthesized
3152 );
3153 let children = db.get_children(node.clone());
3154 Self { node, children }
3155 }
3156 fn as_syntax_node(&self) -> SyntaxNode {
3157 self.node.clone()
3158 }
3159 fn stable_ptr(&self) -> Self::StablePtr {
3160 ArgListParenthesizedPtr(self.node.0.stable_ptr)
3161 }
3162}
3163impl From<&ArgListParenthesized> for SyntaxStablePtrId {
3164 fn from(node: &ArgListParenthesized) -> Self {
3165 node.stable_ptr().untyped()
3166 }
3167}
3168#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3169pub enum OptionArgListParenthesized {
3170 Empty(OptionArgListParenthesizedEmpty),
3171 ArgListParenthesized(ArgListParenthesized),
3172}
3173#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3174pub struct OptionArgListParenthesizedPtr(pub SyntaxStablePtrId);
3175impl TypedStablePtr for OptionArgListParenthesizedPtr {
3176 type SyntaxNode = OptionArgListParenthesized;
3177 fn untyped(&self) -> SyntaxStablePtrId {
3178 self.0
3179 }
3180 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesized {
3181 OptionArgListParenthesized::from_syntax_node(db, self.0.lookup(db))
3182 }
3183}
3184impl From<OptionArgListParenthesizedPtr> for SyntaxStablePtrId {
3185 fn from(ptr: OptionArgListParenthesizedPtr) -> Self {
3186 ptr.untyped()
3187 }
3188}
3189impl From<OptionArgListParenthesizedEmptyPtr> for OptionArgListParenthesizedPtr {
3190 fn from(value: OptionArgListParenthesizedEmptyPtr) -> Self {
3191 Self(value.0)
3192 }
3193}
3194impl From<ArgListParenthesizedPtr> for OptionArgListParenthesizedPtr {
3195 fn from(value: ArgListParenthesizedPtr) -> Self {
3196 Self(value.0)
3197 }
3198}
3199impl From<OptionArgListParenthesizedEmptyGreen> for OptionArgListParenthesizedGreen {
3200 fn from(value: OptionArgListParenthesizedEmptyGreen) -> Self {
3201 Self(value.0)
3202 }
3203}
3204impl From<ArgListParenthesizedGreen> for OptionArgListParenthesizedGreen {
3205 fn from(value: ArgListParenthesizedGreen) -> Self {
3206 Self(value.0)
3207 }
3208}
3209#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3210pub struct OptionArgListParenthesizedGreen(pub GreenId);
3211impl TypedSyntaxNode for OptionArgListParenthesized {
3212 const OPTIONAL_KIND: Option<SyntaxKind> = None;
3213 type StablePtr = OptionArgListParenthesizedPtr;
3214 type Green = OptionArgListParenthesizedGreen;
3215 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3216 panic!("No missing variant.");
3217 }
3218 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3219 let kind = node.kind(db);
3220 match kind {
3221 SyntaxKind::OptionArgListParenthesizedEmpty => OptionArgListParenthesized::Empty(
3222 OptionArgListParenthesizedEmpty::from_syntax_node(db, node),
3223 ),
3224 SyntaxKind::ArgListParenthesized => OptionArgListParenthesized::ArgListParenthesized(
3225 ArgListParenthesized::from_syntax_node(db, node),
3226 ),
3227 _ => panic!(
3228 "Unexpected syntax kind {:?} when constructing {}.",
3229 kind, "OptionArgListParenthesized"
3230 ),
3231 }
3232 }
3233 fn as_syntax_node(&self) -> SyntaxNode {
3234 match self {
3235 OptionArgListParenthesized::Empty(x) => x.as_syntax_node(),
3236 OptionArgListParenthesized::ArgListParenthesized(x) => x.as_syntax_node(),
3237 }
3238 }
3239 fn stable_ptr(&self) -> Self::StablePtr {
3240 OptionArgListParenthesizedPtr(self.as_syntax_node().0.stable_ptr)
3241 }
3242}
3243impl From<&OptionArgListParenthesized> for SyntaxStablePtrId {
3244 fn from(node: &OptionArgListParenthesized) -> Self {
3245 node.stable_ptr().untyped()
3246 }
3247}
3248impl OptionArgListParenthesized {
3249 pub fn is_variant(kind: SyntaxKind) -> bool {
3251 matches!(
3252 kind,
3253 SyntaxKind::OptionArgListParenthesizedEmpty | SyntaxKind::ArgListParenthesized
3254 )
3255 }
3256}
3257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3258pub struct OptionArgListParenthesizedEmpty {
3259 node: SyntaxNode,
3260 children: Arc<[SyntaxNode]>,
3261}
3262impl OptionArgListParenthesizedEmpty {
3263 pub fn new_green(db: &dyn SyntaxGroup) -> OptionArgListParenthesizedEmptyGreen {
3264 let children: Vec<GreenId> = vec![];
3265 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3266 OptionArgListParenthesizedEmptyGreen(
3267 Arc::new(GreenNode {
3268 kind: SyntaxKind::OptionArgListParenthesizedEmpty,
3269 details: GreenNodeDetails::Node { children, width },
3270 })
3271 .intern(db),
3272 )
3273 }
3274}
3275impl OptionArgListParenthesizedEmpty {}
3276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3277pub struct OptionArgListParenthesizedEmptyPtr(pub SyntaxStablePtrId);
3278impl OptionArgListParenthesizedEmptyPtr {}
3279impl TypedStablePtr for OptionArgListParenthesizedEmptyPtr {
3280 type SyntaxNode = OptionArgListParenthesizedEmpty;
3281 fn untyped(&self) -> SyntaxStablePtrId {
3282 self.0
3283 }
3284 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesizedEmpty {
3285 OptionArgListParenthesizedEmpty::from_syntax_node(db, self.0.lookup(db))
3286 }
3287}
3288impl From<OptionArgListParenthesizedEmptyPtr> for SyntaxStablePtrId {
3289 fn from(ptr: OptionArgListParenthesizedEmptyPtr) -> Self {
3290 ptr.untyped()
3291 }
3292}
3293#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3294pub struct OptionArgListParenthesizedEmptyGreen(pub GreenId);
3295impl TypedSyntaxNode for OptionArgListParenthesizedEmpty {
3296 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionArgListParenthesizedEmpty);
3297 type StablePtr = OptionArgListParenthesizedEmptyPtr;
3298 type Green = OptionArgListParenthesizedEmptyGreen;
3299 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3300 OptionArgListParenthesizedEmptyGreen(
3301 Arc::new(GreenNode {
3302 kind: SyntaxKind::OptionArgListParenthesizedEmpty,
3303 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
3304 })
3305 .intern(db),
3306 )
3307 }
3308 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3309 let kind = node.kind(db);
3310 assert_eq!(
3311 kind,
3312 SyntaxKind::OptionArgListParenthesizedEmpty,
3313 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3314 kind,
3315 SyntaxKind::OptionArgListParenthesizedEmpty
3316 );
3317 let children = db.get_children(node.clone());
3318 Self { node, children }
3319 }
3320 fn as_syntax_node(&self) -> SyntaxNode {
3321 self.node.clone()
3322 }
3323 fn stable_ptr(&self) -> Self::StablePtr {
3324 OptionArgListParenthesizedEmptyPtr(self.node.0.stable_ptr)
3325 }
3326}
3327impl From<&OptionArgListParenthesizedEmpty> for SyntaxStablePtrId {
3328 fn from(node: &OptionArgListParenthesizedEmpty) -> Self {
3329 node.stable_ptr().untyped()
3330 }
3331}
3332#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3333pub struct ExprStructCtorCall {
3334 node: SyntaxNode,
3335 children: Arc<[SyntaxNode]>,
3336}
3337impl ExprStructCtorCall {
3338 pub const INDEX_PATH: usize = 0;
3339 pub const INDEX_ARGUMENTS: usize = 1;
3340 pub fn new_green(
3341 db: &dyn SyntaxGroup,
3342 path: ExprPathGreen,
3343 arguments: StructArgListBracedGreen,
3344 ) -> ExprStructCtorCallGreen {
3345 let children: Vec<GreenId> = vec![path.0, arguments.0];
3346 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3347 ExprStructCtorCallGreen(
3348 Arc::new(GreenNode {
3349 kind: SyntaxKind::ExprStructCtorCall,
3350 details: GreenNodeDetails::Node { children, width },
3351 })
3352 .intern(db),
3353 )
3354 }
3355}
3356impl ExprStructCtorCall {
3357 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
3358 ExprPath::from_syntax_node(db, self.children[0].clone())
3359 }
3360 pub fn arguments(&self, db: &dyn SyntaxGroup) -> StructArgListBraced {
3361 StructArgListBraced::from_syntax_node(db, self.children[1].clone())
3362 }
3363}
3364#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3365pub struct ExprStructCtorCallPtr(pub SyntaxStablePtrId);
3366impl ExprStructCtorCallPtr {}
3367impl TypedStablePtr for ExprStructCtorCallPtr {
3368 type SyntaxNode = ExprStructCtorCall;
3369 fn untyped(&self) -> SyntaxStablePtrId {
3370 self.0
3371 }
3372 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprStructCtorCall {
3373 ExprStructCtorCall::from_syntax_node(db, self.0.lookup(db))
3374 }
3375}
3376impl From<ExprStructCtorCallPtr> for SyntaxStablePtrId {
3377 fn from(ptr: ExprStructCtorCallPtr) -> Self {
3378 ptr.untyped()
3379 }
3380}
3381#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3382pub struct ExprStructCtorCallGreen(pub GreenId);
3383impl TypedSyntaxNode for ExprStructCtorCall {
3384 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprStructCtorCall);
3385 type StablePtr = ExprStructCtorCallPtr;
3386 type Green = ExprStructCtorCallGreen;
3387 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3388 ExprStructCtorCallGreen(
3389 Arc::new(GreenNode {
3390 kind: SyntaxKind::ExprStructCtorCall,
3391 details: GreenNodeDetails::Node {
3392 children: vec![ExprPath::missing(db).0, StructArgListBraced::missing(db).0],
3393 width: TextWidth::default(),
3394 },
3395 })
3396 .intern(db),
3397 )
3398 }
3399 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3400 let kind = node.kind(db);
3401 assert_eq!(
3402 kind,
3403 SyntaxKind::ExprStructCtorCall,
3404 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3405 kind,
3406 SyntaxKind::ExprStructCtorCall
3407 );
3408 let children = db.get_children(node.clone());
3409 Self { node, children }
3410 }
3411 fn as_syntax_node(&self) -> SyntaxNode {
3412 self.node.clone()
3413 }
3414 fn stable_ptr(&self) -> Self::StablePtr {
3415 ExprStructCtorCallPtr(self.node.0.stable_ptr)
3416 }
3417}
3418impl From<&ExprStructCtorCall> for SyntaxStablePtrId {
3419 fn from(node: &ExprStructCtorCall) -> Self {
3420 node.stable_ptr().untyped()
3421 }
3422}
3423#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3424pub struct StructArgListBraced {
3425 node: SyntaxNode,
3426 children: Arc<[SyntaxNode]>,
3427}
3428impl StructArgListBraced {
3429 pub const INDEX_LBRACE: usize = 0;
3430 pub const INDEX_ARGUMENTS: usize = 1;
3431 pub const INDEX_RBRACE: usize = 2;
3432 pub fn new_green(
3433 db: &dyn SyntaxGroup,
3434 lbrace: TerminalLBraceGreen,
3435 arguments: StructArgListGreen,
3436 rbrace: TerminalRBraceGreen,
3437 ) -> StructArgListBracedGreen {
3438 let children: Vec<GreenId> = vec![lbrace.0, arguments.0, rbrace.0];
3439 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3440 StructArgListBracedGreen(
3441 Arc::new(GreenNode {
3442 kind: SyntaxKind::StructArgListBraced,
3443 details: GreenNodeDetails::Node { children, width },
3444 })
3445 .intern(db),
3446 )
3447 }
3448}
3449impl StructArgListBraced {
3450 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
3451 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
3452 }
3453 pub fn arguments(&self, db: &dyn SyntaxGroup) -> StructArgList {
3454 StructArgList::from_syntax_node(db, self.children[1].clone())
3455 }
3456 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
3457 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
3458 }
3459}
3460#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3461pub struct StructArgListBracedPtr(pub SyntaxStablePtrId);
3462impl StructArgListBracedPtr {}
3463impl TypedStablePtr for StructArgListBracedPtr {
3464 type SyntaxNode = StructArgListBraced;
3465 fn untyped(&self) -> SyntaxStablePtrId {
3466 self.0
3467 }
3468 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgListBraced {
3469 StructArgListBraced::from_syntax_node(db, self.0.lookup(db))
3470 }
3471}
3472impl From<StructArgListBracedPtr> for SyntaxStablePtrId {
3473 fn from(ptr: StructArgListBracedPtr) -> Self {
3474 ptr.untyped()
3475 }
3476}
3477#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3478pub struct StructArgListBracedGreen(pub GreenId);
3479impl TypedSyntaxNode for StructArgListBraced {
3480 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgListBraced);
3481 type StablePtr = StructArgListBracedPtr;
3482 type Green = StructArgListBracedGreen;
3483 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3484 StructArgListBracedGreen(
3485 Arc::new(GreenNode {
3486 kind: SyntaxKind::StructArgListBraced,
3487 details: GreenNodeDetails::Node {
3488 children: vec![
3489 TerminalLBrace::missing(db).0,
3490 StructArgList::missing(db).0,
3491 TerminalRBrace::missing(db).0,
3492 ],
3493 width: TextWidth::default(),
3494 },
3495 })
3496 .intern(db),
3497 )
3498 }
3499 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3500 let kind = node.kind(db);
3501 assert_eq!(
3502 kind,
3503 SyntaxKind::StructArgListBraced,
3504 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3505 kind,
3506 SyntaxKind::StructArgListBraced
3507 );
3508 let children = db.get_children(node.clone());
3509 Self { node, children }
3510 }
3511 fn as_syntax_node(&self) -> SyntaxNode {
3512 self.node.clone()
3513 }
3514 fn stable_ptr(&self) -> Self::StablePtr {
3515 StructArgListBracedPtr(self.node.0.stable_ptr)
3516 }
3517}
3518impl From<&StructArgListBraced> for SyntaxStablePtrId {
3519 fn from(node: &StructArgListBraced) -> Self {
3520 node.stable_ptr().untyped()
3521 }
3522}
3523#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3524pub struct ExprBlock {
3525 node: SyntaxNode,
3526 children: Arc<[SyntaxNode]>,
3527}
3528impl ExprBlock {
3529 pub const INDEX_LBRACE: usize = 0;
3530 pub const INDEX_STATEMENTS: usize = 1;
3531 pub const INDEX_RBRACE: usize = 2;
3532 pub fn new_green(
3533 db: &dyn SyntaxGroup,
3534 lbrace: TerminalLBraceGreen,
3535 statements: StatementListGreen,
3536 rbrace: TerminalRBraceGreen,
3537 ) -> ExprBlockGreen {
3538 let children: Vec<GreenId> = vec![lbrace.0, statements.0, rbrace.0];
3539 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3540 ExprBlockGreen(
3541 Arc::new(GreenNode {
3542 kind: SyntaxKind::ExprBlock,
3543 details: GreenNodeDetails::Node { children, width },
3544 })
3545 .intern(db),
3546 )
3547 }
3548}
3549impl ExprBlock {
3550 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
3551 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
3552 }
3553 pub fn statements(&self, db: &dyn SyntaxGroup) -> StatementList {
3554 StatementList::from_syntax_node(db, self.children[1].clone())
3555 }
3556 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
3557 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
3558 }
3559}
3560#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3561pub struct ExprBlockPtr(pub SyntaxStablePtrId);
3562impl ExprBlockPtr {}
3563impl TypedStablePtr for ExprBlockPtr {
3564 type SyntaxNode = ExprBlock;
3565 fn untyped(&self) -> SyntaxStablePtrId {
3566 self.0
3567 }
3568 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprBlock {
3569 ExprBlock::from_syntax_node(db, self.0.lookup(db))
3570 }
3571}
3572impl From<ExprBlockPtr> for SyntaxStablePtrId {
3573 fn from(ptr: ExprBlockPtr) -> Self {
3574 ptr.untyped()
3575 }
3576}
3577#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3578pub struct ExprBlockGreen(pub GreenId);
3579impl TypedSyntaxNode for ExprBlock {
3580 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprBlock);
3581 type StablePtr = ExprBlockPtr;
3582 type Green = ExprBlockGreen;
3583 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3584 ExprBlockGreen(
3585 Arc::new(GreenNode {
3586 kind: SyntaxKind::ExprBlock,
3587 details: GreenNodeDetails::Node {
3588 children: vec![
3589 TerminalLBrace::missing(db).0,
3590 StatementList::missing(db).0,
3591 TerminalRBrace::missing(db).0,
3592 ],
3593 width: TextWidth::default(),
3594 },
3595 })
3596 .intern(db),
3597 )
3598 }
3599 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3600 let kind = node.kind(db);
3601 assert_eq!(
3602 kind,
3603 SyntaxKind::ExprBlock,
3604 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3605 kind,
3606 SyntaxKind::ExprBlock
3607 );
3608 let children = db.get_children(node.clone());
3609 Self { node, children }
3610 }
3611 fn as_syntax_node(&self) -> SyntaxNode {
3612 self.node.clone()
3613 }
3614 fn stable_ptr(&self) -> Self::StablePtr {
3615 ExprBlockPtr(self.node.0.stable_ptr)
3616 }
3617}
3618impl From<&ExprBlock> for SyntaxStablePtrId {
3619 fn from(node: &ExprBlock) -> Self {
3620 node.stable_ptr().untyped()
3621 }
3622}
3623#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3624pub struct ExprMatch {
3625 node: SyntaxNode,
3626 children: Arc<[SyntaxNode]>,
3627}
3628impl ExprMatch {
3629 pub const INDEX_MATCH_KW: usize = 0;
3630 pub const INDEX_EXPR: usize = 1;
3631 pub const INDEX_LBRACE: usize = 2;
3632 pub const INDEX_ARMS: usize = 3;
3633 pub const INDEX_RBRACE: usize = 4;
3634 pub fn new_green(
3635 db: &dyn SyntaxGroup,
3636 match_kw: TerminalMatchGreen,
3637 expr: ExprGreen,
3638 lbrace: TerminalLBraceGreen,
3639 arms: MatchArmsGreen,
3640 rbrace: TerminalRBraceGreen,
3641 ) -> ExprMatchGreen {
3642 let children: Vec<GreenId> = vec![match_kw.0, expr.0, lbrace.0, arms.0, rbrace.0];
3643 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3644 ExprMatchGreen(
3645 Arc::new(GreenNode {
3646 kind: SyntaxKind::ExprMatch,
3647 details: GreenNodeDetails::Node { children, width },
3648 })
3649 .intern(db),
3650 )
3651 }
3652}
3653impl ExprMatch {
3654 pub fn match_kw(&self, db: &dyn SyntaxGroup) -> TerminalMatch {
3655 TerminalMatch::from_syntax_node(db, self.children[0].clone())
3656 }
3657 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
3658 Expr::from_syntax_node(db, self.children[1].clone())
3659 }
3660 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
3661 TerminalLBrace::from_syntax_node(db, self.children[2].clone())
3662 }
3663 pub fn arms(&self, db: &dyn SyntaxGroup) -> MatchArms {
3664 MatchArms::from_syntax_node(db, self.children[3].clone())
3665 }
3666 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
3667 TerminalRBrace::from_syntax_node(db, self.children[4].clone())
3668 }
3669}
3670#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3671pub struct ExprMatchPtr(pub SyntaxStablePtrId);
3672impl ExprMatchPtr {}
3673impl TypedStablePtr for ExprMatchPtr {
3674 type SyntaxNode = ExprMatch;
3675 fn untyped(&self) -> SyntaxStablePtrId {
3676 self.0
3677 }
3678 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprMatch {
3679 ExprMatch::from_syntax_node(db, self.0.lookup(db))
3680 }
3681}
3682impl From<ExprMatchPtr> for SyntaxStablePtrId {
3683 fn from(ptr: ExprMatchPtr) -> Self {
3684 ptr.untyped()
3685 }
3686}
3687#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3688pub struct ExprMatchGreen(pub GreenId);
3689impl TypedSyntaxNode for ExprMatch {
3690 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprMatch);
3691 type StablePtr = ExprMatchPtr;
3692 type Green = ExprMatchGreen;
3693 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3694 ExprMatchGreen(
3695 Arc::new(GreenNode {
3696 kind: SyntaxKind::ExprMatch,
3697 details: GreenNodeDetails::Node {
3698 children: vec![
3699 TerminalMatch::missing(db).0,
3700 Expr::missing(db).0,
3701 TerminalLBrace::missing(db).0,
3702 MatchArms::missing(db).0,
3703 TerminalRBrace::missing(db).0,
3704 ],
3705 width: TextWidth::default(),
3706 },
3707 })
3708 .intern(db),
3709 )
3710 }
3711 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3712 let kind = node.kind(db);
3713 assert_eq!(
3714 kind,
3715 SyntaxKind::ExprMatch,
3716 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3717 kind,
3718 SyntaxKind::ExprMatch
3719 );
3720 let children = db.get_children(node.clone());
3721 Self { node, children }
3722 }
3723 fn as_syntax_node(&self) -> SyntaxNode {
3724 self.node.clone()
3725 }
3726 fn stable_ptr(&self) -> Self::StablePtr {
3727 ExprMatchPtr(self.node.0.stable_ptr)
3728 }
3729}
3730impl From<&ExprMatch> for SyntaxStablePtrId {
3731 fn from(node: &ExprMatch) -> Self {
3732 node.stable_ptr().untyped()
3733 }
3734}
3735#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3736pub struct MatchArms(ElementList<MatchArm, 2>);
3737impl Deref for MatchArms {
3738 type Target = ElementList<MatchArm, 2>;
3739 fn deref(&self) -> &Self::Target {
3740 &self.0
3741 }
3742}
3743impl MatchArms {
3744 pub fn new_green(
3745 db: &dyn SyntaxGroup,
3746 children: Vec<MatchArmsElementOrSeparatorGreen>,
3747 ) -> MatchArmsGreen {
3748 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
3749 MatchArmsGreen(
3750 Arc::new(GreenNode {
3751 kind: SyntaxKind::MatchArms,
3752 details: GreenNodeDetails::Node {
3753 children: children.iter().map(|x| x.id()).collect(),
3754 width,
3755 },
3756 })
3757 .intern(db),
3758 )
3759 }
3760}
3761#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3762pub struct MatchArmsPtr(pub SyntaxStablePtrId);
3763impl TypedStablePtr for MatchArmsPtr {
3764 type SyntaxNode = MatchArms;
3765 fn untyped(&self) -> SyntaxStablePtrId {
3766 self.0
3767 }
3768 fn lookup(&self, db: &dyn SyntaxGroup) -> MatchArms {
3769 MatchArms::from_syntax_node(db, self.0.lookup(db))
3770 }
3771}
3772impl From<MatchArmsPtr> for SyntaxStablePtrId {
3773 fn from(ptr: MatchArmsPtr) -> Self {
3774 ptr.untyped()
3775 }
3776}
3777#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3778pub enum MatchArmsElementOrSeparatorGreen {
3779 Separator(TerminalCommaGreen),
3780 Element(MatchArmGreen),
3781}
3782impl From<TerminalCommaGreen> for MatchArmsElementOrSeparatorGreen {
3783 fn from(value: TerminalCommaGreen) -> Self {
3784 MatchArmsElementOrSeparatorGreen::Separator(value)
3785 }
3786}
3787impl From<MatchArmGreen> for MatchArmsElementOrSeparatorGreen {
3788 fn from(value: MatchArmGreen) -> Self {
3789 MatchArmsElementOrSeparatorGreen::Element(value)
3790 }
3791}
3792impl MatchArmsElementOrSeparatorGreen {
3793 fn id(&self) -> GreenId {
3794 match self {
3795 MatchArmsElementOrSeparatorGreen::Separator(green) => green.0,
3796 MatchArmsElementOrSeparatorGreen::Element(green) => green.0,
3797 }
3798 }
3799}
3800#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3801pub struct MatchArmsGreen(pub GreenId);
3802impl TypedSyntaxNode for MatchArms {
3803 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MatchArms);
3804 type StablePtr = MatchArmsPtr;
3805 type Green = MatchArmsGreen;
3806 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3807 MatchArmsGreen(
3808 Arc::new(GreenNode {
3809 kind: SyntaxKind::MatchArms,
3810 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
3811 })
3812 .intern(db),
3813 )
3814 }
3815 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3816 Self(ElementList::new(node))
3817 }
3818 fn as_syntax_node(&self) -> SyntaxNode {
3819 self.node.clone()
3820 }
3821 fn stable_ptr(&self) -> Self::StablePtr {
3822 MatchArmsPtr(self.node.0.stable_ptr)
3823 }
3824}
3825impl From<&MatchArms> for SyntaxStablePtrId {
3826 fn from(node: &MatchArms) -> Self {
3827 node.stable_ptr().untyped()
3828 }
3829}
3830#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3831pub struct MatchArm {
3832 node: SyntaxNode,
3833 children: Arc<[SyntaxNode]>,
3834}
3835impl MatchArm {
3836 pub const INDEX_PATTERNS: usize = 0;
3837 pub const INDEX_ARROW: usize = 1;
3838 pub const INDEX_EXPRESSION: usize = 2;
3839 pub fn new_green(
3840 db: &dyn SyntaxGroup,
3841 patterns: PatternListOrGreen,
3842 arrow: TerminalMatchArrowGreen,
3843 expression: ExprGreen,
3844 ) -> MatchArmGreen {
3845 let children: Vec<GreenId> = vec![patterns.0, arrow.0, expression.0];
3846 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3847 MatchArmGreen(
3848 Arc::new(GreenNode {
3849 kind: SyntaxKind::MatchArm,
3850 details: GreenNodeDetails::Node { children, width },
3851 })
3852 .intern(db),
3853 )
3854 }
3855}
3856impl MatchArm {
3857 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternListOr {
3858 PatternListOr::from_syntax_node(db, self.children[0].clone())
3859 }
3860 pub fn arrow(&self, db: &dyn SyntaxGroup) -> TerminalMatchArrow {
3861 TerminalMatchArrow::from_syntax_node(db, self.children[1].clone())
3862 }
3863 pub fn expression(&self, db: &dyn SyntaxGroup) -> Expr {
3864 Expr::from_syntax_node(db, self.children[2].clone())
3865 }
3866}
3867#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3868pub struct MatchArmPtr(pub SyntaxStablePtrId);
3869impl MatchArmPtr {}
3870impl TypedStablePtr for MatchArmPtr {
3871 type SyntaxNode = MatchArm;
3872 fn untyped(&self) -> SyntaxStablePtrId {
3873 self.0
3874 }
3875 fn lookup(&self, db: &dyn SyntaxGroup) -> MatchArm {
3876 MatchArm::from_syntax_node(db, self.0.lookup(db))
3877 }
3878}
3879impl From<MatchArmPtr> for SyntaxStablePtrId {
3880 fn from(ptr: MatchArmPtr) -> Self {
3881 ptr.untyped()
3882 }
3883}
3884#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3885pub struct MatchArmGreen(pub GreenId);
3886impl TypedSyntaxNode for MatchArm {
3887 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MatchArm);
3888 type StablePtr = MatchArmPtr;
3889 type Green = MatchArmGreen;
3890 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3891 MatchArmGreen(
3892 Arc::new(GreenNode {
3893 kind: SyntaxKind::MatchArm,
3894 details: GreenNodeDetails::Node {
3895 children: vec![
3896 PatternListOr::missing(db).0,
3897 TerminalMatchArrow::missing(db).0,
3898 Expr::missing(db).0,
3899 ],
3900 width: TextWidth::default(),
3901 },
3902 })
3903 .intern(db),
3904 )
3905 }
3906 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
3907 let kind = node.kind(db);
3908 assert_eq!(
3909 kind,
3910 SyntaxKind::MatchArm,
3911 "Unexpected SyntaxKind {:?}. Expected {:?}.",
3912 kind,
3913 SyntaxKind::MatchArm
3914 );
3915 let children = db.get_children(node.clone());
3916 Self { node, children }
3917 }
3918 fn as_syntax_node(&self) -> SyntaxNode {
3919 self.node.clone()
3920 }
3921 fn stable_ptr(&self) -> Self::StablePtr {
3922 MatchArmPtr(self.node.0.stable_ptr)
3923 }
3924}
3925impl From<&MatchArm> for SyntaxStablePtrId {
3926 fn from(node: &MatchArm) -> Self {
3927 node.stable_ptr().untyped()
3928 }
3929}
3930#[derive(Clone, Debug, Eq, Hash, PartialEq)]
3931pub struct ExprIf {
3932 node: SyntaxNode,
3933 children: Arc<[SyntaxNode]>,
3934}
3935impl ExprIf {
3936 pub const INDEX_IF_KW: usize = 0;
3937 pub const INDEX_CONDITION: usize = 1;
3938 pub const INDEX_IF_BLOCK: usize = 2;
3939 pub const INDEX_ELSE_CLAUSE: usize = 3;
3940 pub fn new_green(
3941 db: &dyn SyntaxGroup,
3942 if_kw: TerminalIfGreen,
3943 condition: ConditionGreen,
3944 if_block: ExprBlockGreen,
3945 else_clause: OptionElseClauseGreen,
3946 ) -> ExprIfGreen {
3947 let children: Vec<GreenId> = vec![if_kw.0, condition.0, if_block.0, else_clause.0];
3948 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
3949 ExprIfGreen(
3950 Arc::new(GreenNode {
3951 kind: SyntaxKind::ExprIf,
3952 details: GreenNodeDetails::Node { children, width },
3953 })
3954 .intern(db),
3955 )
3956 }
3957}
3958impl ExprIf {
3959 pub fn if_kw(&self, db: &dyn SyntaxGroup) -> TerminalIf {
3960 TerminalIf::from_syntax_node(db, self.children[0].clone())
3961 }
3962 pub fn condition(&self, db: &dyn SyntaxGroup) -> Condition {
3963 Condition::from_syntax_node(db, self.children[1].clone())
3964 }
3965 pub fn if_block(&self, db: &dyn SyntaxGroup) -> ExprBlock {
3966 ExprBlock::from_syntax_node(db, self.children[2].clone())
3967 }
3968 pub fn else_clause(&self, db: &dyn SyntaxGroup) -> OptionElseClause {
3969 OptionElseClause::from_syntax_node(db, self.children[3].clone())
3970 }
3971}
3972#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3973pub struct ExprIfPtr(pub SyntaxStablePtrId);
3974impl ExprIfPtr {}
3975impl TypedStablePtr for ExprIfPtr {
3976 type SyntaxNode = ExprIf;
3977 fn untyped(&self) -> SyntaxStablePtrId {
3978 self.0
3979 }
3980 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprIf {
3981 ExprIf::from_syntax_node(db, self.0.lookup(db))
3982 }
3983}
3984impl From<ExprIfPtr> for SyntaxStablePtrId {
3985 fn from(ptr: ExprIfPtr) -> Self {
3986 ptr.untyped()
3987 }
3988}
3989#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
3990pub struct ExprIfGreen(pub GreenId);
3991impl TypedSyntaxNode for ExprIf {
3992 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprIf);
3993 type StablePtr = ExprIfPtr;
3994 type Green = ExprIfGreen;
3995 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
3996 ExprIfGreen(
3997 Arc::new(GreenNode {
3998 kind: SyntaxKind::ExprIf,
3999 details: GreenNodeDetails::Node {
4000 children: vec![
4001 TerminalIf::missing(db).0,
4002 Condition::missing(db).0,
4003 ExprBlock::missing(db).0,
4004 OptionElseClause::missing(db).0,
4005 ],
4006 width: TextWidth::default(),
4007 },
4008 })
4009 .intern(db),
4010 )
4011 }
4012 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4013 let kind = node.kind(db);
4014 assert_eq!(
4015 kind,
4016 SyntaxKind::ExprIf,
4017 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4018 kind,
4019 SyntaxKind::ExprIf
4020 );
4021 let children = db.get_children(node.clone());
4022 Self { node, children }
4023 }
4024 fn as_syntax_node(&self) -> SyntaxNode {
4025 self.node.clone()
4026 }
4027 fn stable_ptr(&self) -> Self::StablePtr {
4028 ExprIfPtr(self.node.0.stable_ptr)
4029 }
4030}
4031impl From<&ExprIf> for SyntaxStablePtrId {
4032 fn from(node: &ExprIf) -> Self {
4033 node.stable_ptr().untyped()
4034 }
4035}
4036#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4037pub enum Condition {
4038 Let(ConditionLet),
4039 Expr(ConditionExpr),
4040}
4041#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4042pub struct ConditionPtr(pub SyntaxStablePtrId);
4043impl TypedStablePtr for ConditionPtr {
4044 type SyntaxNode = Condition;
4045 fn untyped(&self) -> SyntaxStablePtrId {
4046 self.0
4047 }
4048 fn lookup(&self, db: &dyn SyntaxGroup) -> Condition {
4049 Condition::from_syntax_node(db, self.0.lookup(db))
4050 }
4051}
4052impl From<ConditionPtr> for SyntaxStablePtrId {
4053 fn from(ptr: ConditionPtr) -> Self {
4054 ptr.untyped()
4055 }
4056}
4057impl From<ConditionLetPtr> for ConditionPtr {
4058 fn from(value: ConditionLetPtr) -> Self {
4059 Self(value.0)
4060 }
4061}
4062impl From<ConditionExprPtr> for ConditionPtr {
4063 fn from(value: ConditionExprPtr) -> Self {
4064 Self(value.0)
4065 }
4066}
4067impl From<ConditionLetGreen> for ConditionGreen {
4068 fn from(value: ConditionLetGreen) -> Self {
4069 Self(value.0)
4070 }
4071}
4072impl From<ConditionExprGreen> for ConditionGreen {
4073 fn from(value: ConditionExprGreen) -> Self {
4074 Self(value.0)
4075 }
4076}
4077#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4078pub struct ConditionGreen(pub GreenId);
4079impl TypedSyntaxNode for Condition {
4080 const OPTIONAL_KIND: Option<SyntaxKind> = None;
4081 type StablePtr = ConditionPtr;
4082 type Green = ConditionGreen;
4083 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4084 panic!("No missing variant.");
4085 }
4086 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4087 let kind = node.kind(db);
4088 match kind {
4089 SyntaxKind::ConditionLet => Condition::Let(ConditionLet::from_syntax_node(db, node)),
4090 SyntaxKind::ConditionExpr => Condition::Expr(ConditionExpr::from_syntax_node(db, node)),
4091 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Condition"),
4092 }
4093 }
4094 fn as_syntax_node(&self) -> SyntaxNode {
4095 match self {
4096 Condition::Let(x) => x.as_syntax_node(),
4097 Condition::Expr(x) => x.as_syntax_node(),
4098 }
4099 }
4100 fn stable_ptr(&self) -> Self::StablePtr {
4101 ConditionPtr(self.as_syntax_node().0.stable_ptr)
4102 }
4103}
4104impl From<&Condition> for SyntaxStablePtrId {
4105 fn from(node: &Condition) -> Self {
4106 node.stable_ptr().untyped()
4107 }
4108}
4109impl Condition {
4110 pub fn is_variant(kind: SyntaxKind) -> bool {
4112 matches!(kind, SyntaxKind::ConditionLet | SyntaxKind::ConditionExpr)
4113 }
4114}
4115#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4116pub struct ConditionLet {
4117 node: SyntaxNode,
4118 children: Arc<[SyntaxNode]>,
4119}
4120impl ConditionLet {
4121 pub const INDEX_LET_KW: usize = 0;
4122 pub const INDEX_PATTERNS: usize = 1;
4123 pub const INDEX_EQ: usize = 2;
4124 pub const INDEX_EXPR: usize = 3;
4125 pub fn new_green(
4126 db: &dyn SyntaxGroup,
4127 let_kw: TerminalLetGreen,
4128 patterns: PatternListOrGreen,
4129 eq: TerminalEqGreen,
4130 expr: ExprGreen,
4131 ) -> ConditionLetGreen {
4132 let children: Vec<GreenId> = vec![let_kw.0, patterns.0, eq.0, expr.0];
4133 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4134 ConditionLetGreen(
4135 Arc::new(GreenNode {
4136 kind: SyntaxKind::ConditionLet,
4137 details: GreenNodeDetails::Node { children, width },
4138 })
4139 .intern(db),
4140 )
4141 }
4142}
4143impl ConditionLet {
4144 pub fn let_kw(&self, db: &dyn SyntaxGroup) -> TerminalLet {
4145 TerminalLet::from_syntax_node(db, self.children[0].clone())
4146 }
4147 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternListOr {
4148 PatternListOr::from_syntax_node(db, self.children[1].clone())
4149 }
4150 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
4151 TerminalEq::from_syntax_node(db, self.children[2].clone())
4152 }
4153 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4154 Expr::from_syntax_node(db, self.children[3].clone())
4155 }
4156}
4157#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4158pub struct ConditionLetPtr(pub SyntaxStablePtrId);
4159impl ConditionLetPtr {}
4160impl TypedStablePtr for ConditionLetPtr {
4161 type SyntaxNode = ConditionLet;
4162 fn untyped(&self) -> SyntaxStablePtrId {
4163 self.0
4164 }
4165 fn lookup(&self, db: &dyn SyntaxGroup) -> ConditionLet {
4166 ConditionLet::from_syntax_node(db, self.0.lookup(db))
4167 }
4168}
4169impl From<ConditionLetPtr> for SyntaxStablePtrId {
4170 fn from(ptr: ConditionLetPtr) -> Self {
4171 ptr.untyped()
4172 }
4173}
4174#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4175pub struct ConditionLetGreen(pub GreenId);
4176impl TypedSyntaxNode for ConditionLet {
4177 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ConditionLet);
4178 type StablePtr = ConditionLetPtr;
4179 type Green = ConditionLetGreen;
4180 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4181 ConditionLetGreen(
4182 Arc::new(GreenNode {
4183 kind: SyntaxKind::ConditionLet,
4184 details: GreenNodeDetails::Node {
4185 children: vec![
4186 TerminalLet::missing(db).0,
4187 PatternListOr::missing(db).0,
4188 TerminalEq::missing(db).0,
4189 Expr::missing(db).0,
4190 ],
4191 width: TextWidth::default(),
4192 },
4193 })
4194 .intern(db),
4195 )
4196 }
4197 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4198 let kind = node.kind(db);
4199 assert_eq!(
4200 kind,
4201 SyntaxKind::ConditionLet,
4202 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4203 kind,
4204 SyntaxKind::ConditionLet
4205 );
4206 let children = db.get_children(node.clone());
4207 Self { node, children }
4208 }
4209 fn as_syntax_node(&self) -> SyntaxNode {
4210 self.node.clone()
4211 }
4212 fn stable_ptr(&self) -> Self::StablePtr {
4213 ConditionLetPtr(self.node.0.stable_ptr)
4214 }
4215}
4216impl From<&ConditionLet> for SyntaxStablePtrId {
4217 fn from(node: &ConditionLet) -> Self {
4218 node.stable_ptr().untyped()
4219 }
4220}
4221#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4222pub struct ConditionExpr {
4223 node: SyntaxNode,
4224 children: Arc<[SyntaxNode]>,
4225}
4226impl ConditionExpr {
4227 pub const INDEX_EXPR: usize = 0;
4228 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> ConditionExprGreen {
4229 let children: Vec<GreenId> = vec![expr.0];
4230 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4231 ConditionExprGreen(
4232 Arc::new(GreenNode {
4233 kind: SyntaxKind::ConditionExpr,
4234 details: GreenNodeDetails::Node { children, width },
4235 })
4236 .intern(db),
4237 )
4238 }
4239}
4240impl ConditionExpr {
4241 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4242 Expr::from_syntax_node(db, self.children[0].clone())
4243 }
4244}
4245#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4246pub struct ConditionExprPtr(pub SyntaxStablePtrId);
4247impl ConditionExprPtr {}
4248impl TypedStablePtr for ConditionExprPtr {
4249 type SyntaxNode = ConditionExpr;
4250 fn untyped(&self) -> SyntaxStablePtrId {
4251 self.0
4252 }
4253 fn lookup(&self, db: &dyn SyntaxGroup) -> ConditionExpr {
4254 ConditionExpr::from_syntax_node(db, self.0.lookup(db))
4255 }
4256}
4257impl From<ConditionExprPtr> for SyntaxStablePtrId {
4258 fn from(ptr: ConditionExprPtr) -> Self {
4259 ptr.untyped()
4260 }
4261}
4262#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4263pub struct ConditionExprGreen(pub GreenId);
4264impl TypedSyntaxNode for ConditionExpr {
4265 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ConditionExpr);
4266 type StablePtr = ConditionExprPtr;
4267 type Green = ConditionExprGreen;
4268 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4269 ConditionExprGreen(
4270 Arc::new(GreenNode {
4271 kind: SyntaxKind::ConditionExpr,
4272 details: GreenNodeDetails::Node {
4273 children: vec![Expr::missing(db).0],
4274 width: TextWidth::default(),
4275 },
4276 })
4277 .intern(db),
4278 )
4279 }
4280 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4281 let kind = node.kind(db);
4282 assert_eq!(
4283 kind,
4284 SyntaxKind::ConditionExpr,
4285 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4286 kind,
4287 SyntaxKind::ConditionExpr
4288 );
4289 let children = db.get_children(node.clone());
4290 Self { node, children }
4291 }
4292 fn as_syntax_node(&self) -> SyntaxNode {
4293 self.node.clone()
4294 }
4295 fn stable_ptr(&self) -> Self::StablePtr {
4296 ConditionExprPtr(self.node.0.stable_ptr)
4297 }
4298}
4299impl From<&ConditionExpr> for SyntaxStablePtrId {
4300 fn from(node: &ConditionExpr) -> Self {
4301 node.stable_ptr().untyped()
4302 }
4303}
4304#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4305pub enum BlockOrIf {
4306 Block(ExprBlock),
4307 If(ExprIf),
4308}
4309#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4310pub struct BlockOrIfPtr(pub SyntaxStablePtrId);
4311impl TypedStablePtr for BlockOrIfPtr {
4312 type SyntaxNode = BlockOrIf;
4313 fn untyped(&self) -> SyntaxStablePtrId {
4314 self.0
4315 }
4316 fn lookup(&self, db: &dyn SyntaxGroup) -> BlockOrIf {
4317 BlockOrIf::from_syntax_node(db, self.0.lookup(db))
4318 }
4319}
4320impl From<BlockOrIfPtr> for SyntaxStablePtrId {
4321 fn from(ptr: BlockOrIfPtr) -> Self {
4322 ptr.untyped()
4323 }
4324}
4325impl From<ExprBlockPtr> for BlockOrIfPtr {
4326 fn from(value: ExprBlockPtr) -> Self {
4327 Self(value.0)
4328 }
4329}
4330impl From<ExprIfPtr> for BlockOrIfPtr {
4331 fn from(value: ExprIfPtr) -> Self {
4332 Self(value.0)
4333 }
4334}
4335impl From<ExprBlockGreen> for BlockOrIfGreen {
4336 fn from(value: ExprBlockGreen) -> Self {
4337 Self(value.0)
4338 }
4339}
4340impl From<ExprIfGreen> for BlockOrIfGreen {
4341 fn from(value: ExprIfGreen) -> Self {
4342 Self(value.0)
4343 }
4344}
4345#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4346pub struct BlockOrIfGreen(pub GreenId);
4347impl TypedSyntaxNode for BlockOrIf {
4348 const OPTIONAL_KIND: Option<SyntaxKind> = None;
4349 type StablePtr = BlockOrIfPtr;
4350 type Green = BlockOrIfGreen;
4351 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4352 panic!("No missing variant.");
4353 }
4354 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4355 let kind = node.kind(db);
4356 match kind {
4357 SyntaxKind::ExprBlock => BlockOrIf::Block(ExprBlock::from_syntax_node(db, node)),
4358 SyntaxKind::ExprIf => BlockOrIf::If(ExprIf::from_syntax_node(db, node)),
4359 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "BlockOrIf"),
4360 }
4361 }
4362 fn as_syntax_node(&self) -> SyntaxNode {
4363 match self {
4364 BlockOrIf::Block(x) => x.as_syntax_node(),
4365 BlockOrIf::If(x) => x.as_syntax_node(),
4366 }
4367 }
4368 fn stable_ptr(&self) -> Self::StablePtr {
4369 BlockOrIfPtr(self.as_syntax_node().0.stable_ptr)
4370 }
4371}
4372impl From<&BlockOrIf> for SyntaxStablePtrId {
4373 fn from(node: &BlockOrIf) -> Self {
4374 node.stable_ptr().untyped()
4375 }
4376}
4377impl BlockOrIf {
4378 pub fn is_variant(kind: SyntaxKind) -> bool {
4380 matches!(kind, SyntaxKind::ExprBlock | SyntaxKind::ExprIf)
4381 }
4382}
4383#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4384pub struct ExprLoop {
4385 node: SyntaxNode,
4386 children: Arc<[SyntaxNode]>,
4387}
4388impl ExprLoop {
4389 pub const INDEX_LOOP_KW: usize = 0;
4390 pub const INDEX_BODY: usize = 1;
4391 pub fn new_green(
4392 db: &dyn SyntaxGroup,
4393 loop_kw: TerminalLoopGreen,
4394 body: ExprBlockGreen,
4395 ) -> ExprLoopGreen {
4396 let children: Vec<GreenId> = vec![loop_kw.0, body.0];
4397 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4398 ExprLoopGreen(
4399 Arc::new(GreenNode {
4400 kind: SyntaxKind::ExprLoop,
4401 details: GreenNodeDetails::Node { children, width },
4402 })
4403 .intern(db),
4404 )
4405 }
4406}
4407impl ExprLoop {
4408 pub fn loop_kw(&self, db: &dyn SyntaxGroup) -> TerminalLoop {
4409 TerminalLoop::from_syntax_node(db, self.children[0].clone())
4410 }
4411 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4412 ExprBlock::from_syntax_node(db, self.children[1].clone())
4413 }
4414}
4415#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4416pub struct ExprLoopPtr(pub SyntaxStablePtrId);
4417impl ExprLoopPtr {}
4418impl TypedStablePtr for ExprLoopPtr {
4419 type SyntaxNode = ExprLoop;
4420 fn untyped(&self) -> SyntaxStablePtrId {
4421 self.0
4422 }
4423 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprLoop {
4424 ExprLoop::from_syntax_node(db, self.0.lookup(db))
4425 }
4426}
4427impl From<ExprLoopPtr> for SyntaxStablePtrId {
4428 fn from(ptr: ExprLoopPtr) -> Self {
4429 ptr.untyped()
4430 }
4431}
4432#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4433pub struct ExprLoopGreen(pub GreenId);
4434impl TypedSyntaxNode for ExprLoop {
4435 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprLoop);
4436 type StablePtr = ExprLoopPtr;
4437 type Green = ExprLoopGreen;
4438 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4439 ExprLoopGreen(
4440 Arc::new(GreenNode {
4441 kind: SyntaxKind::ExprLoop,
4442 details: GreenNodeDetails::Node {
4443 children: vec![TerminalLoop::missing(db).0, ExprBlock::missing(db).0],
4444 width: TextWidth::default(),
4445 },
4446 })
4447 .intern(db),
4448 )
4449 }
4450 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4451 let kind = node.kind(db);
4452 assert_eq!(
4453 kind,
4454 SyntaxKind::ExprLoop,
4455 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4456 kind,
4457 SyntaxKind::ExprLoop
4458 );
4459 let children = db.get_children(node.clone());
4460 Self { node, children }
4461 }
4462 fn as_syntax_node(&self) -> SyntaxNode {
4463 self.node.clone()
4464 }
4465 fn stable_ptr(&self) -> Self::StablePtr {
4466 ExprLoopPtr(self.node.0.stable_ptr)
4467 }
4468}
4469impl From<&ExprLoop> for SyntaxStablePtrId {
4470 fn from(node: &ExprLoop) -> Self {
4471 node.stable_ptr().untyped()
4472 }
4473}
4474#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4475pub struct ExprWhile {
4476 node: SyntaxNode,
4477 children: Arc<[SyntaxNode]>,
4478}
4479impl ExprWhile {
4480 pub const INDEX_WHILE_KW: usize = 0;
4481 pub const INDEX_CONDITION: usize = 1;
4482 pub const INDEX_BODY: usize = 2;
4483 pub fn new_green(
4484 db: &dyn SyntaxGroup,
4485 while_kw: TerminalWhileGreen,
4486 condition: ConditionGreen,
4487 body: ExprBlockGreen,
4488 ) -> ExprWhileGreen {
4489 let children: Vec<GreenId> = vec![while_kw.0, condition.0, body.0];
4490 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4491 ExprWhileGreen(
4492 Arc::new(GreenNode {
4493 kind: SyntaxKind::ExprWhile,
4494 details: GreenNodeDetails::Node { children, width },
4495 })
4496 .intern(db),
4497 )
4498 }
4499}
4500impl ExprWhile {
4501 pub fn while_kw(&self, db: &dyn SyntaxGroup) -> TerminalWhile {
4502 TerminalWhile::from_syntax_node(db, self.children[0].clone())
4503 }
4504 pub fn condition(&self, db: &dyn SyntaxGroup) -> Condition {
4505 Condition::from_syntax_node(db, self.children[1].clone())
4506 }
4507 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4508 ExprBlock::from_syntax_node(db, self.children[2].clone())
4509 }
4510}
4511#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4512pub struct ExprWhilePtr(pub SyntaxStablePtrId);
4513impl ExprWhilePtr {}
4514impl TypedStablePtr for ExprWhilePtr {
4515 type SyntaxNode = ExprWhile;
4516 fn untyped(&self) -> SyntaxStablePtrId {
4517 self.0
4518 }
4519 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprWhile {
4520 ExprWhile::from_syntax_node(db, self.0.lookup(db))
4521 }
4522}
4523impl From<ExprWhilePtr> for SyntaxStablePtrId {
4524 fn from(ptr: ExprWhilePtr) -> Self {
4525 ptr.untyped()
4526 }
4527}
4528#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4529pub struct ExprWhileGreen(pub GreenId);
4530impl TypedSyntaxNode for ExprWhile {
4531 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprWhile);
4532 type StablePtr = ExprWhilePtr;
4533 type Green = ExprWhileGreen;
4534 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4535 ExprWhileGreen(
4536 Arc::new(GreenNode {
4537 kind: SyntaxKind::ExprWhile,
4538 details: GreenNodeDetails::Node {
4539 children: vec![
4540 TerminalWhile::missing(db).0,
4541 Condition::missing(db).0,
4542 ExprBlock::missing(db).0,
4543 ],
4544 width: TextWidth::default(),
4545 },
4546 })
4547 .intern(db),
4548 )
4549 }
4550 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4551 let kind = node.kind(db);
4552 assert_eq!(
4553 kind,
4554 SyntaxKind::ExprWhile,
4555 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4556 kind,
4557 SyntaxKind::ExprWhile
4558 );
4559 let children = db.get_children(node.clone());
4560 Self { node, children }
4561 }
4562 fn as_syntax_node(&self) -> SyntaxNode {
4563 self.node.clone()
4564 }
4565 fn stable_ptr(&self) -> Self::StablePtr {
4566 ExprWhilePtr(self.node.0.stable_ptr)
4567 }
4568}
4569impl From<&ExprWhile> for SyntaxStablePtrId {
4570 fn from(node: &ExprWhile) -> Self {
4571 node.stable_ptr().untyped()
4572 }
4573}
4574#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4575pub struct ExprFor {
4576 node: SyntaxNode,
4577 children: Arc<[SyntaxNode]>,
4578}
4579impl ExprFor {
4580 pub const INDEX_FOR_KW: usize = 0;
4581 pub const INDEX_PATTERN: usize = 1;
4582 pub const INDEX_IDENTIFIER: usize = 2;
4583 pub const INDEX_EXPR: usize = 3;
4584 pub const INDEX_BODY: usize = 4;
4585 pub fn new_green(
4586 db: &dyn SyntaxGroup,
4587 for_kw: TerminalForGreen,
4588 pattern: PatternGreen,
4589 identifier: TerminalIdentifierGreen,
4590 expr: ExprGreen,
4591 body: ExprBlockGreen,
4592 ) -> ExprForGreen {
4593 let children: Vec<GreenId> = vec![for_kw.0, pattern.0, identifier.0, expr.0, body.0];
4594 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4595 ExprForGreen(
4596 Arc::new(GreenNode {
4597 kind: SyntaxKind::ExprFor,
4598 details: GreenNodeDetails::Node { children, width },
4599 })
4600 .intern(db),
4601 )
4602 }
4603}
4604impl ExprFor {
4605 pub fn for_kw(&self, db: &dyn SyntaxGroup) -> TerminalFor {
4606 TerminalFor::from_syntax_node(db, self.children[0].clone())
4607 }
4608 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
4609 Pattern::from_syntax_node(db, self.children[1].clone())
4610 }
4611 pub fn identifier(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
4612 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
4613 }
4614 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4615 Expr::from_syntax_node(db, self.children[3].clone())
4616 }
4617 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
4618 ExprBlock::from_syntax_node(db, self.children[4].clone())
4619 }
4620}
4621#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4622pub struct ExprForPtr(pub SyntaxStablePtrId);
4623impl ExprForPtr {
4624 pub fn pattern_green(self, db: &dyn SyntaxGroup) -> PatternGreen {
4625 let ptr = self.0.lookup_intern(db);
4626 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
4627 PatternGreen(key_fields[0])
4628 } else {
4629 panic!("Unexpected key field query on root.");
4630 }
4631 }
4632 pub fn identifier_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
4633 let ptr = self.0.lookup_intern(db);
4634 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
4635 TerminalIdentifierGreen(key_fields[1])
4636 } else {
4637 panic!("Unexpected key field query on root.");
4638 }
4639 }
4640}
4641impl TypedStablePtr for ExprForPtr {
4642 type SyntaxNode = ExprFor;
4643 fn untyped(&self) -> SyntaxStablePtrId {
4644 self.0
4645 }
4646 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFor {
4647 ExprFor::from_syntax_node(db, self.0.lookup(db))
4648 }
4649}
4650impl From<ExprForPtr> for SyntaxStablePtrId {
4651 fn from(ptr: ExprForPtr) -> Self {
4652 ptr.untyped()
4653 }
4654}
4655#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4656pub struct ExprForGreen(pub GreenId);
4657impl TypedSyntaxNode for ExprFor {
4658 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFor);
4659 type StablePtr = ExprForPtr;
4660 type Green = ExprForGreen;
4661 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4662 ExprForGreen(
4663 Arc::new(GreenNode {
4664 kind: SyntaxKind::ExprFor,
4665 details: GreenNodeDetails::Node {
4666 children: vec![
4667 TerminalFor::missing(db).0,
4668 Pattern::missing(db).0,
4669 TerminalIdentifier::missing(db).0,
4670 Expr::missing(db).0,
4671 ExprBlock::missing(db).0,
4672 ],
4673 width: TextWidth::default(),
4674 },
4675 })
4676 .intern(db),
4677 )
4678 }
4679 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4680 let kind = node.kind(db);
4681 assert_eq!(
4682 kind,
4683 SyntaxKind::ExprFor,
4684 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4685 kind,
4686 SyntaxKind::ExprFor
4687 );
4688 let children = db.get_children(node.clone());
4689 Self { node, children }
4690 }
4691 fn as_syntax_node(&self) -> SyntaxNode {
4692 self.node.clone()
4693 }
4694 fn stable_ptr(&self) -> Self::StablePtr {
4695 ExprForPtr(self.node.0.stable_ptr)
4696 }
4697}
4698impl From<&ExprFor> for SyntaxStablePtrId {
4699 fn from(node: &ExprFor) -> Self {
4700 node.stable_ptr().untyped()
4701 }
4702}
4703#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4704pub struct ElseClause {
4705 node: SyntaxNode,
4706 children: Arc<[SyntaxNode]>,
4707}
4708impl ElseClause {
4709 pub const INDEX_ELSE_KW: usize = 0;
4710 pub const INDEX_ELSE_BLOCK_OR_IF: usize = 1;
4711 pub fn new_green(
4712 db: &dyn SyntaxGroup,
4713 else_kw: TerminalElseGreen,
4714 else_block_or_if: BlockOrIfGreen,
4715 ) -> ElseClauseGreen {
4716 let children: Vec<GreenId> = vec![else_kw.0, else_block_or_if.0];
4717 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4718 ElseClauseGreen(
4719 Arc::new(GreenNode {
4720 kind: SyntaxKind::ElseClause,
4721 details: GreenNodeDetails::Node { children, width },
4722 })
4723 .intern(db),
4724 )
4725 }
4726}
4727impl ElseClause {
4728 pub fn else_kw(&self, db: &dyn SyntaxGroup) -> TerminalElse {
4729 TerminalElse::from_syntax_node(db, self.children[0].clone())
4730 }
4731 pub fn else_block_or_if(&self, db: &dyn SyntaxGroup) -> BlockOrIf {
4732 BlockOrIf::from_syntax_node(db, self.children[1].clone())
4733 }
4734}
4735#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4736pub struct ElseClausePtr(pub SyntaxStablePtrId);
4737impl ElseClausePtr {}
4738impl TypedStablePtr for ElseClausePtr {
4739 type SyntaxNode = ElseClause;
4740 fn untyped(&self) -> SyntaxStablePtrId {
4741 self.0
4742 }
4743 fn lookup(&self, db: &dyn SyntaxGroup) -> ElseClause {
4744 ElseClause::from_syntax_node(db, self.0.lookup(db))
4745 }
4746}
4747impl From<ElseClausePtr> for SyntaxStablePtrId {
4748 fn from(ptr: ElseClausePtr) -> Self {
4749 ptr.untyped()
4750 }
4751}
4752#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4753pub struct ElseClauseGreen(pub GreenId);
4754impl TypedSyntaxNode for ElseClause {
4755 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ElseClause);
4756 type StablePtr = ElseClausePtr;
4757 type Green = ElseClauseGreen;
4758 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4759 ElseClauseGreen(
4760 Arc::new(GreenNode {
4761 kind: SyntaxKind::ElseClause,
4762 details: GreenNodeDetails::Node {
4763 children: vec![TerminalElse::missing(db).0, BlockOrIf::missing(db).0],
4764 width: TextWidth::default(),
4765 },
4766 })
4767 .intern(db),
4768 )
4769 }
4770 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4771 let kind = node.kind(db);
4772 assert_eq!(
4773 kind,
4774 SyntaxKind::ElseClause,
4775 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4776 kind,
4777 SyntaxKind::ElseClause
4778 );
4779 let children = db.get_children(node.clone());
4780 Self { node, children }
4781 }
4782 fn as_syntax_node(&self) -> SyntaxNode {
4783 self.node.clone()
4784 }
4785 fn stable_ptr(&self) -> Self::StablePtr {
4786 ElseClausePtr(self.node.0.stable_ptr)
4787 }
4788}
4789impl From<&ElseClause> for SyntaxStablePtrId {
4790 fn from(node: &ElseClause) -> Self {
4791 node.stable_ptr().untyped()
4792 }
4793}
4794#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4795pub enum OptionElseClause {
4796 Empty(OptionElseClauseEmpty),
4797 ElseClause(ElseClause),
4798}
4799#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4800pub struct OptionElseClausePtr(pub SyntaxStablePtrId);
4801impl TypedStablePtr for OptionElseClausePtr {
4802 type SyntaxNode = OptionElseClause;
4803 fn untyped(&self) -> SyntaxStablePtrId {
4804 self.0
4805 }
4806 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionElseClause {
4807 OptionElseClause::from_syntax_node(db, self.0.lookup(db))
4808 }
4809}
4810impl From<OptionElseClausePtr> for SyntaxStablePtrId {
4811 fn from(ptr: OptionElseClausePtr) -> Self {
4812 ptr.untyped()
4813 }
4814}
4815impl From<OptionElseClauseEmptyPtr> for OptionElseClausePtr {
4816 fn from(value: OptionElseClauseEmptyPtr) -> Self {
4817 Self(value.0)
4818 }
4819}
4820impl From<ElseClausePtr> for OptionElseClausePtr {
4821 fn from(value: ElseClausePtr) -> Self {
4822 Self(value.0)
4823 }
4824}
4825impl From<OptionElseClauseEmptyGreen> for OptionElseClauseGreen {
4826 fn from(value: OptionElseClauseEmptyGreen) -> Self {
4827 Self(value.0)
4828 }
4829}
4830impl From<ElseClauseGreen> for OptionElseClauseGreen {
4831 fn from(value: ElseClauseGreen) -> Self {
4832 Self(value.0)
4833 }
4834}
4835#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4836pub struct OptionElseClauseGreen(pub GreenId);
4837impl TypedSyntaxNode for OptionElseClause {
4838 const OPTIONAL_KIND: Option<SyntaxKind> = None;
4839 type StablePtr = OptionElseClausePtr;
4840 type Green = OptionElseClauseGreen;
4841 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4842 panic!("No missing variant.");
4843 }
4844 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4845 let kind = node.kind(db);
4846 match kind {
4847 SyntaxKind::OptionElseClauseEmpty => {
4848 OptionElseClause::Empty(OptionElseClauseEmpty::from_syntax_node(db, node))
4849 }
4850 SyntaxKind::ElseClause => {
4851 OptionElseClause::ElseClause(ElseClause::from_syntax_node(db, node))
4852 }
4853 _ => panic!(
4854 "Unexpected syntax kind {:?} when constructing {}.",
4855 kind, "OptionElseClause"
4856 ),
4857 }
4858 }
4859 fn as_syntax_node(&self) -> SyntaxNode {
4860 match self {
4861 OptionElseClause::Empty(x) => x.as_syntax_node(),
4862 OptionElseClause::ElseClause(x) => x.as_syntax_node(),
4863 }
4864 }
4865 fn stable_ptr(&self) -> Self::StablePtr {
4866 OptionElseClausePtr(self.as_syntax_node().0.stable_ptr)
4867 }
4868}
4869impl From<&OptionElseClause> for SyntaxStablePtrId {
4870 fn from(node: &OptionElseClause) -> Self {
4871 node.stable_ptr().untyped()
4872 }
4873}
4874impl OptionElseClause {
4875 pub fn is_variant(kind: SyntaxKind) -> bool {
4877 matches!(kind, SyntaxKind::OptionElseClauseEmpty | SyntaxKind::ElseClause)
4878 }
4879}
4880#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4881pub struct OptionElseClauseEmpty {
4882 node: SyntaxNode,
4883 children: Arc<[SyntaxNode]>,
4884}
4885impl OptionElseClauseEmpty {
4886 pub fn new_green(db: &dyn SyntaxGroup) -> OptionElseClauseEmptyGreen {
4887 let children: Vec<GreenId> = vec![];
4888 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4889 OptionElseClauseEmptyGreen(
4890 Arc::new(GreenNode {
4891 kind: SyntaxKind::OptionElseClauseEmpty,
4892 details: GreenNodeDetails::Node { children, width },
4893 })
4894 .intern(db),
4895 )
4896 }
4897}
4898impl OptionElseClauseEmpty {}
4899#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4900pub struct OptionElseClauseEmptyPtr(pub SyntaxStablePtrId);
4901impl OptionElseClauseEmptyPtr {}
4902impl TypedStablePtr for OptionElseClauseEmptyPtr {
4903 type SyntaxNode = OptionElseClauseEmpty;
4904 fn untyped(&self) -> SyntaxStablePtrId {
4905 self.0
4906 }
4907 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionElseClauseEmpty {
4908 OptionElseClauseEmpty::from_syntax_node(db, self.0.lookup(db))
4909 }
4910}
4911impl From<OptionElseClauseEmptyPtr> for SyntaxStablePtrId {
4912 fn from(ptr: OptionElseClauseEmptyPtr) -> Self {
4913 ptr.untyped()
4914 }
4915}
4916#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4917pub struct OptionElseClauseEmptyGreen(pub GreenId);
4918impl TypedSyntaxNode for OptionElseClauseEmpty {
4919 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionElseClauseEmpty);
4920 type StablePtr = OptionElseClauseEmptyPtr;
4921 type Green = OptionElseClauseEmptyGreen;
4922 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
4923 OptionElseClauseEmptyGreen(
4924 Arc::new(GreenNode {
4925 kind: SyntaxKind::OptionElseClauseEmpty,
4926 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
4927 })
4928 .intern(db),
4929 )
4930 }
4931 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
4932 let kind = node.kind(db);
4933 assert_eq!(
4934 kind,
4935 SyntaxKind::OptionElseClauseEmpty,
4936 "Unexpected SyntaxKind {:?}. Expected {:?}.",
4937 kind,
4938 SyntaxKind::OptionElseClauseEmpty
4939 );
4940 let children = db.get_children(node.clone());
4941 Self { node, children }
4942 }
4943 fn as_syntax_node(&self) -> SyntaxNode {
4944 self.node.clone()
4945 }
4946 fn stable_ptr(&self) -> Self::StablePtr {
4947 OptionElseClauseEmptyPtr(self.node.0.stable_ptr)
4948 }
4949}
4950impl From<&OptionElseClauseEmpty> for SyntaxStablePtrId {
4951 fn from(node: &OptionElseClauseEmpty) -> Self {
4952 node.stable_ptr().untyped()
4953 }
4954}
4955#[derive(Clone, Debug, Eq, Hash, PartialEq)]
4956pub struct ExprErrorPropagate {
4957 node: SyntaxNode,
4958 children: Arc<[SyntaxNode]>,
4959}
4960impl ExprErrorPropagate {
4961 pub const INDEX_EXPR: usize = 0;
4962 pub const INDEX_OP: usize = 1;
4963 pub fn new_green(
4964 db: &dyn SyntaxGroup,
4965 expr: ExprGreen,
4966 op: TerminalQuestionMarkGreen,
4967 ) -> ExprErrorPropagateGreen {
4968 let children: Vec<GreenId> = vec![expr.0, op.0];
4969 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
4970 ExprErrorPropagateGreen(
4971 Arc::new(GreenNode {
4972 kind: SyntaxKind::ExprErrorPropagate,
4973 details: GreenNodeDetails::Node { children, width },
4974 })
4975 .intern(db),
4976 )
4977 }
4978}
4979impl ExprErrorPropagate {
4980 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
4981 Expr::from_syntax_node(db, self.children[0].clone())
4982 }
4983 pub fn op(&self, db: &dyn SyntaxGroup) -> TerminalQuestionMark {
4984 TerminalQuestionMark::from_syntax_node(db, self.children[1].clone())
4985 }
4986}
4987#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
4988pub struct ExprErrorPropagatePtr(pub SyntaxStablePtrId);
4989impl ExprErrorPropagatePtr {}
4990impl TypedStablePtr for ExprErrorPropagatePtr {
4991 type SyntaxNode = ExprErrorPropagate;
4992 fn untyped(&self) -> SyntaxStablePtrId {
4993 self.0
4994 }
4995 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprErrorPropagate {
4996 ExprErrorPropagate::from_syntax_node(db, self.0.lookup(db))
4997 }
4998}
4999impl From<ExprErrorPropagatePtr> for SyntaxStablePtrId {
5000 fn from(ptr: ExprErrorPropagatePtr) -> Self {
5001 ptr.untyped()
5002 }
5003}
5004#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5005pub struct ExprErrorPropagateGreen(pub GreenId);
5006impl TypedSyntaxNode for ExprErrorPropagate {
5007 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprErrorPropagate);
5008 type StablePtr = ExprErrorPropagatePtr;
5009 type Green = ExprErrorPropagateGreen;
5010 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5011 ExprErrorPropagateGreen(
5012 Arc::new(GreenNode {
5013 kind: SyntaxKind::ExprErrorPropagate,
5014 details: GreenNodeDetails::Node {
5015 children: vec![Expr::missing(db).0, TerminalQuestionMark::missing(db).0],
5016 width: TextWidth::default(),
5017 },
5018 })
5019 .intern(db),
5020 )
5021 }
5022 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5023 let kind = node.kind(db);
5024 assert_eq!(
5025 kind,
5026 SyntaxKind::ExprErrorPropagate,
5027 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5028 kind,
5029 SyntaxKind::ExprErrorPropagate
5030 );
5031 let children = db.get_children(node.clone());
5032 Self { node, children }
5033 }
5034 fn as_syntax_node(&self) -> SyntaxNode {
5035 self.node.clone()
5036 }
5037 fn stable_ptr(&self) -> Self::StablePtr {
5038 ExprErrorPropagatePtr(self.node.0.stable_ptr)
5039 }
5040}
5041impl From<&ExprErrorPropagate> for SyntaxStablePtrId {
5042 fn from(node: &ExprErrorPropagate) -> Self {
5043 node.stable_ptr().untyped()
5044 }
5045}
5046#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5047pub struct ExprIndexed {
5048 node: SyntaxNode,
5049 children: Arc<[SyntaxNode]>,
5050}
5051impl ExprIndexed {
5052 pub const INDEX_EXPR: usize = 0;
5053 pub const INDEX_LBRACK: usize = 1;
5054 pub const INDEX_INDEX_EXPR: usize = 2;
5055 pub const INDEX_RBRACK: usize = 3;
5056 pub fn new_green(
5057 db: &dyn SyntaxGroup,
5058 expr: ExprGreen,
5059 lbrack: TerminalLBrackGreen,
5060 index_expr: ExprGreen,
5061 rbrack: TerminalRBrackGreen,
5062 ) -> ExprIndexedGreen {
5063 let children: Vec<GreenId> = vec![expr.0, lbrack.0, index_expr.0, rbrack.0];
5064 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5065 ExprIndexedGreen(
5066 Arc::new(GreenNode {
5067 kind: SyntaxKind::ExprIndexed,
5068 details: GreenNodeDetails::Node { children, width },
5069 })
5070 .intern(db),
5071 )
5072 }
5073}
5074impl ExprIndexed {
5075 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5076 Expr::from_syntax_node(db, self.children[0].clone())
5077 }
5078 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
5079 TerminalLBrack::from_syntax_node(db, self.children[1].clone())
5080 }
5081 pub fn index_expr(&self, db: &dyn SyntaxGroup) -> Expr {
5082 Expr::from_syntax_node(db, self.children[2].clone())
5083 }
5084 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
5085 TerminalRBrack::from_syntax_node(db, self.children[3].clone())
5086 }
5087}
5088#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5089pub struct ExprIndexedPtr(pub SyntaxStablePtrId);
5090impl ExprIndexedPtr {}
5091impl TypedStablePtr for ExprIndexedPtr {
5092 type SyntaxNode = ExprIndexed;
5093 fn untyped(&self) -> SyntaxStablePtrId {
5094 self.0
5095 }
5096 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprIndexed {
5097 ExprIndexed::from_syntax_node(db, self.0.lookup(db))
5098 }
5099}
5100impl From<ExprIndexedPtr> for SyntaxStablePtrId {
5101 fn from(ptr: ExprIndexedPtr) -> Self {
5102 ptr.untyped()
5103 }
5104}
5105#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5106pub struct ExprIndexedGreen(pub GreenId);
5107impl TypedSyntaxNode for ExprIndexed {
5108 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprIndexed);
5109 type StablePtr = ExprIndexedPtr;
5110 type Green = ExprIndexedGreen;
5111 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5112 ExprIndexedGreen(
5113 Arc::new(GreenNode {
5114 kind: SyntaxKind::ExprIndexed,
5115 details: GreenNodeDetails::Node {
5116 children: vec![
5117 Expr::missing(db).0,
5118 TerminalLBrack::missing(db).0,
5119 Expr::missing(db).0,
5120 TerminalRBrack::missing(db).0,
5121 ],
5122 width: TextWidth::default(),
5123 },
5124 })
5125 .intern(db),
5126 )
5127 }
5128 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5129 let kind = node.kind(db);
5130 assert_eq!(
5131 kind,
5132 SyntaxKind::ExprIndexed,
5133 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5134 kind,
5135 SyntaxKind::ExprIndexed
5136 );
5137 let children = db.get_children(node.clone());
5138 Self { node, children }
5139 }
5140 fn as_syntax_node(&self) -> SyntaxNode {
5141 self.node.clone()
5142 }
5143 fn stable_ptr(&self) -> Self::StablePtr {
5144 ExprIndexedPtr(self.node.0.stable_ptr)
5145 }
5146}
5147impl From<&ExprIndexed> for SyntaxStablePtrId {
5148 fn from(node: &ExprIndexed) -> Self {
5149 node.stable_ptr().untyped()
5150 }
5151}
5152#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5153pub struct ExprInlineMacro {
5154 node: SyntaxNode,
5155 children: Arc<[SyntaxNode]>,
5156}
5157impl ExprInlineMacro {
5158 pub const INDEX_PATH: usize = 0;
5159 pub const INDEX_BANG: usize = 1;
5160 pub const INDEX_ARGUMENTS: usize = 2;
5161 pub fn new_green(
5162 db: &dyn SyntaxGroup,
5163 path: ExprPathGreen,
5164 bang: TerminalNotGreen,
5165 arguments: WrappedArgListGreen,
5166 ) -> ExprInlineMacroGreen {
5167 let children: Vec<GreenId> = vec![path.0, bang.0, arguments.0];
5168 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5169 ExprInlineMacroGreen(
5170 Arc::new(GreenNode {
5171 kind: SyntaxKind::ExprInlineMacro,
5172 details: GreenNodeDetails::Node { children, width },
5173 })
5174 .intern(db),
5175 )
5176 }
5177}
5178impl ExprInlineMacro {
5179 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
5180 ExprPath::from_syntax_node(db, self.children[0].clone())
5181 }
5182 pub fn bang(&self, db: &dyn SyntaxGroup) -> TerminalNot {
5183 TerminalNot::from_syntax_node(db, self.children[1].clone())
5184 }
5185 pub fn arguments(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
5186 WrappedArgList::from_syntax_node(db, self.children[2].clone())
5187 }
5188}
5189#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5190pub struct ExprInlineMacroPtr(pub SyntaxStablePtrId);
5191impl ExprInlineMacroPtr {}
5192impl TypedStablePtr for ExprInlineMacroPtr {
5193 type SyntaxNode = ExprInlineMacro;
5194 fn untyped(&self) -> SyntaxStablePtrId {
5195 self.0
5196 }
5197 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprInlineMacro {
5198 ExprInlineMacro::from_syntax_node(db, self.0.lookup(db))
5199 }
5200}
5201impl From<ExprInlineMacroPtr> for SyntaxStablePtrId {
5202 fn from(ptr: ExprInlineMacroPtr) -> Self {
5203 ptr.untyped()
5204 }
5205}
5206#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5207pub struct ExprInlineMacroGreen(pub GreenId);
5208impl TypedSyntaxNode for ExprInlineMacro {
5209 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprInlineMacro);
5210 type StablePtr = ExprInlineMacroPtr;
5211 type Green = ExprInlineMacroGreen;
5212 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5213 ExprInlineMacroGreen(
5214 Arc::new(GreenNode {
5215 kind: SyntaxKind::ExprInlineMacro,
5216 details: GreenNodeDetails::Node {
5217 children: vec![
5218 ExprPath::missing(db).0,
5219 TerminalNot::missing(db).0,
5220 WrappedArgList::missing(db).0,
5221 ],
5222 width: TextWidth::default(),
5223 },
5224 })
5225 .intern(db),
5226 )
5227 }
5228 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5229 let kind = node.kind(db);
5230 assert_eq!(
5231 kind,
5232 SyntaxKind::ExprInlineMacro,
5233 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5234 kind,
5235 SyntaxKind::ExprInlineMacro
5236 );
5237 let children = db.get_children(node.clone());
5238 Self { node, children }
5239 }
5240 fn as_syntax_node(&self) -> SyntaxNode {
5241 self.node.clone()
5242 }
5243 fn stable_ptr(&self) -> Self::StablePtr {
5244 ExprInlineMacroPtr(self.node.0.stable_ptr)
5245 }
5246}
5247impl From<&ExprInlineMacro> for SyntaxStablePtrId {
5248 fn from(node: &ExprInlineMacro) -> Self {
5249 node.stable_ptr().untyped()
5250 }
5251}
5252#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5253pub struct ExprFixedSizeArray {
5254 node: SyntaxNode,
5255 children: Arc<[SyntaxNode]>,
5256}
5257impl ExprFixedSizeArray {
5258 pub const INDEX_LBRACK: usize = 0;
5259 pub const INDEX_EXPRS: usize = 1;
5260 pub const INDEX_SIZE: usize = 2;
5261 pub const INDEX_RBRACK: usize = 3;
5262 pub fn new_green(
5263 db: &dyn SyntaxGroup,
5264 lbrack: TerminalLBrackGreen,
5265 exprs: ExprListGreen,
5266 size: OptionFixedSizeArraySizeGreen,
5267 rbrack: TerminalRBrackGreen,
5268 ) -> ExprFixedSizeArrayGreen {
5269 let children: Vec<GreenId> = vec![lbrack.0, exprs.0, size.0, rbrack.0];
5270 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5271 ExprFixedSizeArrayGreen(
5272 Arc::new(GreenNode {
5273 kind: SyntaxKind::ExprFixedSizeArray,
5274 details: GreenNodeDetails::Node { children, width },
5275 })
5276 .intern(db),
5277 )
5278 }
5279}
5280impl ExprFixedSizeArray {
5281 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
5282 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
5283 }
5284 pub fn exprs(&self, db: &dyn SyntaxGroup) -> ExprList {
5285 ExprList::from_syntax_node(db, self.children[1].clone())
5286 }
5287 pub fn size(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySize {
5288 OptionFixedSizeArraySize::from_syntax_node(db, self.children[2].clone())
5289 }
5290 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
5291 TerminalRBrack::from_syntax_node(db, self.children[3].clone())
5292 }
5293}
5294#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5295pub struct ExprFixedSizeArrayPtr(pub SyntaxStablePtrId);
5296impl ExprFixedSizeArrayPtr {}
5297impl TypedStablePtr for ExprFixedSizeArrayPtr {
5298 type SyntaxNode = ExprFixedSizeArray;
5299 fn untyped(&self) -> SyntaxStablePtrId {
5300 self.0
5301 }
5302 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprFixedSizeArray {
5303 ExprFixedSizeArray::from_syntax_node(db, self.0.lookup(db))
5304 }
5305}
5306impl From<ExprFixedSizeArrayPtr> for SyntaxStablePtrId {
5307 fn from(ptr: ExprFixedSizeArrayPtr) -> Self {
5308 ptr.untyped()
5309 }
5310}
5311#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5312pub struct ExprFixedSizeArrayGreen(pub GreenId);
5313impl TypedSyntaxNode for ExprFixedSizeArray {
5314 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprFixedSizeArray);
5315 type StablePtr = ExprFixedSizeArrayPtr;
5316 type Green = ExprFixedSizeArrayGreen;
5317 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5318 ExprFixedSizeArrayGreen(
5319 Arc::new(GreenNode {
5320 kind: SyntaxKind::ExprFixedSizeArray,
5321 details: GreenNodeDetails::Node {
5322 children: vec![
5323 TerminalLBrack::missing(db).0,
5324 ExprList::missing(db).0,
5325 OptionFixedSizeArraySize::missing(db).0,
5326 TerminalRBrack::missing(db).0,
5327 ],
5328 width: TextWidth::default(),
5329 },
5330 })
5331 .intern(db),
5332 )
5333 }
5334 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5335 let kind = node.kind(db);
5336 assert_eq!(
5337 kind,
5338 SyntaxKind::ExprFixedSizeArray,
5339 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5340 kind,
5341 SyntaxKind::ExprFixedSizeArray
5342 );
5343 let children = db.get_children(node.clone());
5344 Self { node, children }
5345 }
5346 fn as_syntax_node(&self) -> SyntaxNode {
5347 self.node.clone()
5348 }
5349 fn stable_ptr(&self) -> Self::StablePtr {
5350 ExprFixedSizeArrayPtr(self.node.0.stable_ptr)
5351 }
5352}
5353impl From<&ExprFixedSizeArray> for SyntaxStablePtrId {
5354 fn from(node: &ExprFixedSizeArray) -> Self {
5355 node.stable_ptr().untyped()
5356 }
5357}
5358#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5359pub struct FixedSizeArraySize {
5360 node: SyntaxNode,
5361 children: Arc<[SyntaxNode]>,
5362}
5363impl FixedSizeArraySize {
5364 pub const INDEX_SEMICOLON: usize = 0;
5365 pub const INDEX_SIZE: usize = 1;
5366 pub fn new_green(
5367 db: &dyn SyntaxGroup,
5368 semicolon: TerminalSemicolonGreen,
5369 size: ExprGreen,
5370 ) -> FixedSizeArraySizeGreen {
5371 let children: Vec<GreenId> = vec![semicolon.0, size.0];
5372 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5373 FixedSizeArraySizeGreen(
5374 Arc::new(GreenNode {
5375 kind: SyntaxKind::FixedSizeArraySize,
5376 details: GreenNodeDetails::Node { children, width },
5377 })
5378 .intern(db),
5379 )
5380 }
5381}
5382impl FixedSizeArraySize {
5383 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
5384 TerminalSemicolon::from_syntax_node(db, self.children[0].clone())
5385 }
5386 pub fn size(&self, db: &dyn SyntaxGroup) -> Expr {
5387 Expr::from_syntax_node(db, self.children[1].clone())
5388 }
5389}
5390#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5391pub struct FixedSizeArraySizePtr(pub SyntaxStablePtrId);
5392impl FixedSizeArraySizePtr {}
5393impl TypedStablePtr for FixedSizeArraySizePtr {
5394 type SyntaxNode = FixedSizeArraySize;
5395 fn untyped(&self) -> SyntaxStablePtrId {
5396 self.0
5397 }
5398 fn lookup(&self, db: &dyn SyntaxGroup) -> FixedSizeArraySize {
5399 FixedSizeArraySize::from_syntax_node(db, self.0.lookup(db))
5400 }
5401}
5402impl From<FixedSizeArraySizePtr> for SyntaxStablePtrId {
5403 fn from(ptr: FixedSizeArraySizePtr) -> Self {
5404 ptr.untyped()
5405 }
5406}
5407#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5408pub struct FixedSizeArraySizeGreen(pub GreenId);
5409impl TypedSyntaxNode for FixedSizeArraySize {
5410 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FixedSizeArraySize);
5411 type StablePtr = FixedSizeArraySizePtr;
5412 type Green = FixedSizeArraySizeGreen;
5413 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5414 FixedSizeArraySizeGreen(
5415 Arc::new(GreenNode {
5416 kind: SyntaxKind::FixedSizeArraySize,
5417 details: GreenNodeDetails::Node {
5418 children: vec![TerminalSemicolon::missing(db).0, Expr::missing(db).0],
5419 width: TextWidth::default(),
5420 },
5421 })
5422 .intern(db),
5423 )
5424 }
5425 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5426 let kind = node.kind(db);
5427 assert_eq!(
5428 kind,
5429 SyntaxKind::FixedSizeArraySize,
5430 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5431 kind,
5432 SyntaxKind::FixedSizeArraySize
5433 );
5434 let children = db.get_children(node.clone());
5435 Self { node, children }
5436 }
5437 fn as_syntax_node(&self) -> SyntaxNode {
5438 self.node.clone()
5439 }
5440 fn stable_ptr(&self) -> Self::StablePtr {
5441 FixedSizeArraySizePtr(self.node.0.stable_ptr)
5442 }
5443}
5444impl From<&FixedSizeArraySize> for SyntaxStablePtrId {
5445 fn from(node: &FixedSizeArraySize) -> Self {
5446 node.stable_ptr().untyped()
5447 }
5448}
5449#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5450pub enum OptionFixedSizeArraySize {
5451 Empty(OptionFixedSizeArraySizeEmpty),
5452 FixedSizeArraySize(FixedSizeArraySize),
5453}
5454#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5455pub struct OptionFixedSizeArraySizePtr(pub SyntaxStablePtrId);
5456impl TypedStablePtr for OptionFixedSizeArraySizePtr {
5457 type SyntaxNode = OptionFixedSizeArraySize;
5458 fn untyped(&self) -> SyntaxStablePtrId {
5459 self.0
5460 }
5461 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySize {
5462 OptionFixedSizeArraySize::from_syntax_node(db, self.0.lookup(db))
5463 }
5464}
5465impl From<OptionFixedSizeArraySizePtr> for SyntaxStablePtrId {
5466 fn from(ptr: OptionFixedSizeArraySizePtr) -> Self {
5467 ptr.untyped()
5468 }
5469}
5470impl From<OptionFixedSizeArraySizeEmptyPtr> for OptionFixedSizeArraySizePtr {
5471 fn from(value: OptionFixedSizeArraySizeEmptyPtr) -> Self {
5472 Self(value.0)
5473 }
5474}
5475impl From<FixedSizeArraySizePtr> for OptionFixedSizeArraySizePtr {
5476 fn from(value: FixedSizeArraySizePtr) -> Self {
5477 Self(value.0)
5478 }
5479}
5480impl From<OptionFixedSizeArraySizeEmptyGreen> for OptionFixedSizeArraySizeGreen {
5481 fn from(value: OptionFixedSizeArraySizeEmptyGreen) -> Self {
5482 Self(value.0)
5483 }
5484}
5485impl From<FixedSizeArraySizeGreen> for OptionFixedSizeArraySizeGreen {
5486 fn from(value: FixedSizeArraySizeGreen) -> Self {
5487 Self(value.0)
5488 }
5489}
5490#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5491pub struct OptionFixedSizeArraySizeGreen(pub GreenId);
5492impl TypedSyntaxNode for OptionFixedSizeArraySize {
5493 const OPTIONAL_KIND: Option<SyntaxKind> = None;
5494 type StablePtr = OptionFixedSizeArraySizePtr;
5495 type Green = OptionFixedSizeArraySizeGreen;
5496 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5497 panic!("No missing variant.");
5498 }
5499 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5500 let kind = node.kind(db);
5501 match kind {
5502 SyntaxKind::OptionFixedSizeArraySizeEmpty => OptionFixedSizeArraySize::Empty(
5503 OptionFixedSizeArraySizeEmpty::from_syntax_node(db, node),
5504 ),
5505 SyntaxKind::FixedSizeArraySize => OptionFixedSizeArraySize::FixedSizeArraySize(
5506 FixedSizeArraySize::from_syntax_node(db, node),
5507 ),
5508 _ => panic!(
5509 "Unexpected syntax kind {:?} when constructing {}.",
5510 kind, "OptionFixedSizeArraySize"
5511 ),
5512 }
5513 }
5514 fn as_syntax_node(&self) -> SyntaxNode {
5515 match self {
5516 OptionFixedSizeArraySize::Empty(x) => x.as_syntax_node(),
5517 OptionFixedSizeArraySize::FixedSizeArraySize(x) => x.as_syntax_node(),
5518 }
5519 }
5520 fn stable_ptr(&self) -> Self::StablePtr {
5521 OptionFixedSizeArraySizePtr(self.as_syntax_node().0.stable_ptr)
5522 }
5523}
5524impl From<&OptionFixedSizeArraySize> for SyntaxStablePtrId {
5525 fn from(node: &OptionFixedSizeArraySize) -> Self {
5526 node.stable_ptr().untyped()
5527 }
5528}
5529impl OptionFixedSizeArraySize {
5530 pub fn is_variant(kind: SyntaxKind) -> bool {
5532 matches!(kind, SyntaxKind::OptionFixedSizeArraySizeEmpty | SyntaxKind::FixedSizeArraySize)
5533 }
5534}
5535#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5536pub struct OptionFixedSizeArraySizeEmpty {
5537 node: SyntaxNode,
5538 children: Arc<[SyntaxNode]>,
5539}
5540impl OptionFixedSizeArraySizeEmpty {
5541 pub fn new_green(db: &dyn SyntaxGroup) -> OptionFixedSizeArraySizeEmptyGreen {
5542 let children: Vec<GreenId> = vec![];
5543 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5544 OptionFixedSizeArraySizeEmptyGreen(
5545 Arc::new(GreenNode {
5546 kind: SyntaxKind::OptionFixedSizeArraySizeEmpty,
5547 details: GreenNodeDetails::Node { children, width },
5548 })
5549 .intern(db),
5550 )
5551 }
5552}
5553impl OptionFixedSizeArraySizeEmpty {}
5554#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5555pub struct OptionFixedSizeArraySizeEmptyPtr(pub SyntaxStablePtrId);
5556impl OptionFixedSizeArraySizeEmptyPtr {}
5557impl TypedStablePtr for OptionFixedSizeArraySizeEmptyPtr {
5558 type SyntaxNode = OptionFixedSizeArraySizeEmpty;
5559 fn untyped(&self) -> SyntaxStablePtrId {
5560 self.0
5561 }
5562 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionFixedSizeArraySizeEmpty {
5563 OptionFixedSizeArraySizeEmpty::from_syntax_node(db, self.0.lookup(db))
5564 }
5565}
5566impl From<OptionFixedSizeArraySizeEmptyPtr> for SyntaxStablePtrId {
5567 fn from(ptr: OptionFixedSizeArraySizeEmptyPtr) -> Self {
5568 ptr.untyped()
5569 }
5570}
5571#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5572pub struct OptionFixedSizeArraySizeEmptyGreen(pub GreenId);
5573impl TypedSyntaxNode for OptionFixedSizeArraySizeEmpty {
5574 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionFixedSizeArraySizeEmpty);
5575 type StablePtr = OptionFixedSizeArraySizeEmptyPtr;
5576 type Green = OptionFixedSizeArraySizeEmptyGreen;
5577 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5578 OptionFixedSizeArraySizeEmptyGreen(
5579 Arc::new(GreenNode {
5580 kind: SyntaxKind::OptionFixedSizeArraySizeEmpty,
5581 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
5582 })
5583 .intern(db),
5584 )
5585 }
5586 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5587 let kind = node.kind(db);
5588 assert_eq!(
5589 kind,
5590 SyntaxKind::OptionFixedSizeArraySizeEmpty,
5591 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5592 kind,
5593 SyntaxKind::OptionFixedSizeArraySizeEmpty
5594 );
5595 let children = db.get_children(node.clone());
5596 Self { node, children }
5597 }
5598 fn as_syntax_node(&self) -> SyntaxNode {
5599 self.node.clone()
5600 }
5601 fn stable_ptr(&self) -> Self::StablePtr {
5602 OptionFixedSizeArraySizeEmptyPtr(self.node.0.stable_ptr)
5603 }
5604}
5605impl From<&OptionFixedSizeArraySizeEmpty> for SyntaxStablePtrId {
5606 fn from(node: &OptionFixedSizeArraySizeEmpty) -> Self {
5607 node.stable_ptr().untyped()
5608 }
5609}
5610#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5611pub struct ExprClosure {
5612 node: SyntaxNode,
5613 children: Arc<[SyntaxNode]>,
5614}
5615impl ExprClosure {
5616 pub const INDEX_WRAPPER: usize = 0;
5617 pub const INDEX_RET_TY: usize = 1;
5618 pub const INDEX_OPTIONAL_NO_PANIC: usize = 2;
5619 pub const INDEX_EXPR: usize = 3;
5620 pub fn new_green(
5621 db: &dyn SyntaxGroup,
5622 wrapper: ClosureParamWrapperGreen,
5623 ret_ty: OptionReturnTypeClauseGreen,
5624 optional_no_panic: OptionTerminalNoPanicGreen,
5625 expr: ExprGreen,
5626 ) -> ExprClosureGreen {
5627 let children: Vec<GreenId> = vec![wrapper.0, ret_ty.0, optional_no_panic.0, expr.0];
5628 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5629 ExprClosureGreen(
5630 Arc::new(GreenNode {
5631 kind: SyntaxKind::ExprClosure,
5632 details: GreenNodeDetails::Node { children, width },
5633 })
5634 .intern(db),
5635 )
5636 }
5637}
5638impl ExprClosure {
5639 pub fn wrapper(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapper {
5640 ClosureParamWrapper::from_syntax_node(db, self.children[0].clone())
5641 }
5642 pub fn ret_ty(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
5643 OptionReturnTypeClause::from_syntax_node(db, self.children[1].clone())
5644 }
5645 pub fn optional_no_panic(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
5646 OptionTerminalNoPanic::from_syntax_node(db, self.children[2].clone())
5647 }
5648 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5649 Expr::from_syntax_node(db, self.children[3].clone())
5650 }
5651}
5652#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5653pub struct ExprClosurePtr(pub SyntaxStablePtrId);
5654impl ExprClosurePtr {}
5655impl TypedStablePtr for ExprClosurePtr {
5656 type SyntaxNode = ExprClosure;
5657 fn untyped(&self) -> SyntaxStablePtrId {
5658 self.0
5659 }
5660 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprClosure {
5661 ExprClosure::from_syntax_node(db, self.0.lookup(db))
5662 }
5663}
5664impl From<ExprClosurePtr> for SyntaxStablePtrId {
5665 fn from(ptr: ExprClosurePtr) -> Self {
5666 ptr.untyped()
5667 }
5668}
5669#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5670pub struct ExprClosureGreen(pub GreenId);
5671impl TypedSyntaxNode for ExprClosure {
5672 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprClosure);
5673 type StablePtr = ExprClosurePtr;
5674 type Green = ExprClosureGreen;
5675 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5676 ExprClosureGreen(
5677 Arc::new(GreenNode {
5678 kind: SyntaxKind::ExprClosure,
5679 details: GreenNodeDetails::Node {
5680 children: vec![
5681 ClosureParamWrapper::missing(db).0,
5682 OptionReturnTypeClause::missing(db).0,
5683 OptionTerminalNoPanic::missing(db).0,
5684 Expr::missing(db).0,
5685 ],
5686 width: TextWidth::default(),
5687 },
5688 })
5689 .intern(db),
5690 )
5691 }
5692 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5693 let kind = node.kind(db);
5694 assert_eq!(
5695 kind,
5696 SyntaxKind::ExprClosure,
5697 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5698 kind,
5699 SyntaxKind::ExprClosure
5700 );
5701 let children = db.get_children(node.clone());
5702 Self { node, children }
5703 }
5704 fn as_syntax_node(&self) -> SyntaxNode {
5705 self.node.clone()
5706 }
5707 fn stable_ptr(&self) -> Self::StablePtr {
5708 ExprClosurePtr(self.node.0.stable_ptr)
5709 }
5710}
5711impl From<&ExprClosure> for SyntaxStablePtrId {
5712 fn from(node: &ExprClosure) -> Self {
5713 node.stable_ptr().untyped()
5714 }
5715}
5716#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5717pub enum ClosureParamWrapper {
5718 Nullary(TerminalOrOr),
5719 NAry(ClosureParamWrapperNAry),
5720}
5721#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5722pub struct ClosureParamWrapperPtr(pub SyntaxStablePtrId);
5723impl TypedStablePtr for ClosureParamWrapperPtr {
5724 type SyntaxNode = ClosureParamWrapper;
5725 fn untyped(&self) -> SyntaxStablePtrId {
5726 self.0
5727 }
5728 fn lookup(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapper {
5729 ClosureParamWrapper::from_syntax_node(db, self.0.lookup(db))
5730 }
5731}
5732impl From<ClosureParamWrapperPtr> for SyntaxStablePtrId {
5733 fn from(ptr: ClosureParamWrapperPtr) -> Self {
5734 ptr.untyped()
5735 }
5736}
5737impl From<TerminalOrOrPtr> for ClosureParamWrapperPtr {
5738 fn from(value: TerminalOrOrPtr) -> Self {
5739 Self(value.0)
5740 }
5741}
5742impl From<ClosureParamWrapperNAryPtr> for ClosureParamWrapperPtr {
5743 fn from(value: ClosureParamWrapperNAryPtr) -> Self {
5744 Self(value.0)
5745 }
5746}
5747impl From<TerminalOrOrGreen> for ClosureParamWrapperGreen {
5748 fn from(value: TerminalOrOrGreen) -> Self {
5749 Self(value.0)
5750 }
5751}
5752impl From<ClosureParamWrapperNAryGreen> for ClosureParamWrapperGreen {
5753 fn from(value: ClosureParamWrapperNAryGreen) -> Self {
5754 Self(value.0)
5755 }
5756}
5757#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5758pub struct ClosureParamWrapperGreen(pub GreenId);
5759impl TypedSyntaxNode for ClosureParamWrapper {
5760 const OPTIONAL_KIND: Option<SyntaxKind> = None;
5761 type StablePtr = ClosureParamWrapperPtr;
5762 type Green = ClosureParamWrapperGreen;
5763 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5764 panic!("No missing variant.");
5765 }
5766 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5767 let kind = node.kind(db);
5768 match kind {
5769 SyntaxKind::TerminalOrOr => {
5770 ClosureParamWrapper::Nullary(TerminalOrOr::from_syntax_node(db, node))
5771 }
5772 SyntaxKind::ClosureParamWrapperNAry => {
5773 ClosureParamWrapper::NAry(ClosureParamWrapperNAry::from_syntax_node(db, node))
5774 }
5775 _ => panic!(
5776 "Unexpected syntax kind {:?} when constructing {}.",
5777 kind, "ClosureParamWrapper"
5778 ),
5779 }
5780 }
5781 fn as_syntax_node(&self) -> SyntaxNode {
5782 match self {
5783 ClosureParamWrapper::Nullary(x) => x.as_syntax_node(),
5784 ClosureParamWrapper::NAry(x) => x.as_syntax_node(),
5785 }
5786 }
5787 fn stable_ptr(&self) -> Self::StablePtr {
5788 ClosureParamWrapperPtr(self.as_syntax_node().0.stable_ptr)
5789 }
5790}
5791impl From<&ClosureParamWrapper> for SyntaxStablePtrId {
5792 fn from(node: &ClosureParamWrapper) -> Self {
5793 node.stable_ptr().untyped()
5794 }
5795}
5796impl ClosureParamWrapper {
5797 pub fn is_variant(kind: SyntaxKind) -> bool {
5799 matches!(kind, SyntaxKind::TerminalOrOr | SyntaxKind::ClosureParamWrapperNAry)
5800 }
5801}
5802#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5803pub struct ClosureParamWrapperNAry {
5804 node: SyntaxNode,
5805 children: Arc<[SyntaxNode]>,
5806}
5807impl ClosureParamWrapperNAry {
5808 pub const INDEX_LEFTOR: usize = 0;
5809 pub const INDEX_PARAMS: usize = 1;
5810 pub const INDEX_RIGHTOR: usize = 2;
5811 pub fn new_green(
5812 db: &dyn SyntaxGroup,
5813 leftor: TerminalOrGreen,
5814 params: ParamListGreen,
5815 rightor: TerminalOrGreen,
5816 ) -> ClosureParamWrapperNAryGreen {
5817 let children: Vec<GreenId> = vec![leftor.0, params.0, rightor.0];
5818 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5819 ClosureParamWrapperNAryGreen(
5820 Arc::new(GreenNode {
5821 kind: SyntaxKind::ClosureParamWrapperNAry,
5822 details: GreenNodeDetails::Node { children, width },
5823 })
5824 .intern(db),
5825 )
5826 }
5827}
5828impl ClosureParamWrapperNAry {
5829 pub fn leftor(&self, db: &dyn SyntaxGroup) -> TerminalOr {
5830 TerminalOr::from_syntax_node(db, self.children[0].clone())
5831 }
5832 pub fn params(&self, db: &dyn SyntaxGroup) -> ParamList {
5833 ParamList::from_syntax_node(db, self.children[1].clone())
5834 }
5835 pub fn rightor(&self, db: &dyn SyntaxGroup) -> TerminalOr {
5836 TerminalOr::from_syntax_node(db, self.children[2].clone())
5837 }
5838}
5839#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5840pub struct ClosureParamWrapperNAryPtr(pub SyntaxStablePtrId);
5841impl ClosureParamWrapperNAryPtr {}
5842impl TypedStablePtr for ClosureParamWrapperNAryPtr {
5843 type SyntaxNode = ClosureParamWrapperNAry;
5844 fn untyped(&self) -> SyntaxStablePtrId {
5845 self.0
5846 }
5847 fn lookup(&self, db: &dyn SyntaxGroup) -> ClosureParamWrapperNAry {
5848 ClosureParamWrapperNAry::from_syntax_node(db, self.0.lookup(db))
5849 }
5850}
5851impl From<ClosureParamWrapperNAryPtr> for SyntaxStablePtrId {
5852 fn from(ptr: ClosureParamWrapperNAryPtr) -> Self {
5853 ptr.untyped()
5854 }
5855}
5856#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5857pub struct ClosureParamWrapperNAryGreen(pub GreenId);
5858impl TypedSyntaxNode for ClosureParamWrapperNAry {
5859 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ClosureParamWrapperNAry);
5860 type StablePtr = ClosureParamWrapperNAryPtr;
5861 type Green = ClosureParamWrapperNAryGreen;
5862 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5863 ClosureParamWrapperNAryGreen(
5864 Arc::new(GreenNode {
5865 kind: SyntaxKind::ClosureParamWrapperNAry,
5866 details: GreenNodeDetails::Node {
5867 children: vec![
5868 TerminalOr::missing(db).0,
5869 ParamList::missing(db).0,
5870 TerminalOr::missing(db).0,
5871 ],
5872 width: TextWidth::default(),
5873 },
5874 })
5875 .intern(db),
5876 )
5877 }
5878 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5879 let kind = node.kind(db);
5880 assert_eq!(
5881 kind,
5882 SyntaxKind::ClosureParamWrapperNAry,
5883 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5884 kind,
5885 SyntaxKind::ClosureParamWrapperNAry
5886 );
5887 let children = db.get_children(node.clone());
5888 Self { node, children }
5889 }
5890 fn as_syntax_node(&self) -> SyntaxNode {
5891 self.node.clone()
5892 }
5893 fn stable_ptr(&self) -> Self::StablePtr {
5894 ClosureParamWrapperNAryPtr(self.node.0.stable_ptr)
5895 }
5896}
5897impl From<&ClosureParamWrapperNAry> for SyntaxStablePtrId {
5898 fn from(node: &ClosureParamWrapperNAry) -> Self {
5899 node.stable_ptr().untyped()
5900 }
5901}
5902#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5903pub struct StructArgExpr {
5904 node: SyntaxNode,
5905 children: Arc<[SyntaxNode]>,
5906}
5907impl StructArgExpr {
5908 pub const INDEX_COLON: usize = 0;
5909 pub const INDEX_EXPR: usize = 1;
5910 pub fn new_green(
5911 db: &dyn SyntaxGroup,
5912 colon: TerminalColonGreen,
5913 expr: ExprGreen,
5914 ) -> StructArgExprGreen {
5915 let children: Vec<GreenId> = vec![colon.0, expr.0];
5916 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
5917 StructArgExprGreen(
5918 Arc::new(GreenNode {
5919 kind: SyntaxKind::StructArgExpr,
5920 details: GreenNodeDetails::Node { children, width },
5921 })
5922 .intern(db),
5923 )
5924 }
5925}
5926impl StructArgExpr {
5927 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
5928 TerminalColon::from_syntax_node(db, self.children[0].clone())
5929 }
5930 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
5931 Expr::from_syntax_node(db, self.children[1].clone())
5932 }
5933}
5934#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5935pub struct StructArgExprPtr(pub SyntaxStablePtrId);
5936impl StructArgExprPtr {}
5937impl TypedStablePtr for StructArgExprPtr {
5938 type SyntaxNode = StructArgExpr;
5939 fn untyped(&self) -> SyntaxStablePtrId {
5940 self.0
5941 }
5942 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgExpr {
5943 StructArgExpr::from_syntax_node(db, self.0.lookup(db))
5944 }
5945}
5946impl From<StructArgExprPtr> for SyntaxStablePtrId {
5947 fn from(ptr: StructArgExprPtr) -> Self {
5948 ptr.untyped()
5949 }
5950}
5951#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5952pub struct StructArgExprGreen(pub GreenId);
5953impl TypedSyntaxNode for StructArgExpr {
5954 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgExpr);
5955 type StablePtr = StructArgExprPtr;
5956 type Green = StructArgExprGreen;
5957 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
5958 StructArgExprGreen(
5959 Arc::new(GreenNode {
5960 kind: SyntaxKind::StructArgExpr,
5961 details: GreenNodeDetails::Node {
5962 children: vec![TerminalColon::missing(db).0, Expr::missing(db).0],
5963 width: TextWidth::default(),
5964 },
5965 })
5966 .intern(db),
5967 )
5968 }
5969 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
5970 let kind = node.kind(db);
5971 assert_eq!(
5972 kind,
5973 SyntaxKind::StructArgExpr,
5974 "Unexpected SyntaxKind {:?}. Expected {:?}.",
5975 kind,
5976 SyntaxKind::StructArgExpr
5977 );
5978 let children = db.get_children(node.clone());
5979 Self { node, children }
5980 }
5981 fn as_syntax_node(&self) -> SyntaxNode {
5982 self.node.clone()
5983 }
5984 fn stable_ptr(&self) -> Self::StablePtr {
5985 StructArgExprPtr(self.node.0.stable_ptr)
5986 }
5987}
5988impl From<&StructArgExpr> for SyntaxStablePtrId {
5989 fn from(node: &StructArgExpr) -> Self {
5990 node.stable_ptr().untyped()
5991 }
5992}
5993#[derive(Clone, Debug, Eq, Hash, PartialEq)]
5994pub enum OptionStructArgExpr {
5995 Empty(OptionStructArgExprEmpty),
5996 StructArgExpr(StructArgExpr),
5997}
5998#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
5999pub struct OptionStructArgExprPtr(pub SyntaxStablePtrId);
6000impl TypedStablePtr for OptionStructArgExprPtr {
6001 type SyntaxNode = OptionStructArgExpr;
6002 fn untyped(&self) -> SyntaxStablePtrId {
6003 self.0
6004 }
6005 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionStructArgExpr {
6006 OptionStructArgExpr::from_syntax_node(db, self.0.lookup(db))
6007 }
6008}
6009impl From<OptionStructArgExprPtr> for SyntaxStablePtrId {
6010 fn from(ptr: OptionStructArgExprPtr) -> Self {
6011 ptr.untyped()
6012 }
6013}
6014impl From<OptionStructArgExprEmptyPtr> for OptionStructArgExprPtr {
6015 fn from(value: OptionStructArgExprEmptyPtr) -> Self {
6016 Self(value.0)
6017 }
6018}
6019impl From<StructArgExprPtr> for OptionStructArgExprPtr {
6020 fn from(value: StructArgExprPtr) -> Self {
6021 Self(value.0)
6022 }
6023}
6024impl From<OptionStructArgExprEmptyGreen> for OptionStructArgExprGreen {
6025 fn from(value: OptionStructArgExprEmptyGreen) -> Self {
6026 Self(value.0)
6027 }
6028}
6029impl From<StructArgExprGreen> for OptionStructArgExprGreen {
6030 fn from(value: StructArgExprGreen) -> Self {
6031 Self(value.0)
6032 }
6033}
6034#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6035pub struct OptionStructArgExprGreen(pub GreenId);
6036impl TypedSyntaxNode for OptionStructArgExpr {
6037 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6038 type StablePtr = OptionStructArgExprPtr;
6039 type Green = OptionStructArgExprGreen;
6040 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6041 panic!("No missing variant.");
6042 }
6043 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6044 let kind = node.kind(db);
6045 match kind {
6046 SyntaxKind::OptionStructArgExprEmpty => {
6047 OptionStructArgExpr::Empty(OptionStructArgExprEmpty::from_syntax_node(db, node))
6048 }
6049 SyntaxKind::StructArgExpr => {
6050 OptionStructArgExpr::StructArgExpr(StructArgExpr::from_syntax_node(db, node))
6051 }
6052 _ => panic!(
6053 "Unexpected syntax kind {:?} when constructing {}.",
6054 kind, "OptionStructArgExpr"
6055 ),
6056 }
6057 }
6058 fn as_syntax_node(&self) -> SyntaxNode {
6059 match self {
6060 OptionStructArgExpr::Empty(x) => x.as_syntax_node(),
6061 OptionStructArgExpr::StructArgExpr(x) => x.as_syntax_node(),
6062 }
6063 }
6064 fn stable_ptr(&self) -> Self::StablePtr {
6065 OptionStructArgExprPtr(self.as_syntax_node().0.stable_ptr)
6066 }
6067}
6068impl From<&OptionStructArgExpr> for SyntaxStablePtrId {
6069 fn from(node: &OptionStructArgExpr) -> Self {
6070 node.stable_ptr().untyped()
6071 }
6072}
6073impl OptionStructArgExpr {
6074 pub fn is_variant(kind: SyntaxKind) -> bool {
6076 matches!(kind, SyntaxKind::OptionStructArgExprEmpty | SyntaxKind::StructArgExpr)
6077 }
6078}
6079#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6080pub struct OptionStructArgExprEmpty {
6081 node: SyntaxNode,
6082 children: Arc<[SyntaxNode]>,
6083}
6084impl OptionStructArgExprEmpty {
6085 pub fn new_green(db: &dyn SyntaxGroup) -> OptionStructArgExprEmptyGreen {
6086 let children: Vec<GreenId> = vec![];
6087 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6088 OptionStructArgExprEmptyGreen(
6089 Arc::new(GreenNode {
6090 kind: SyntaxKind::OptionStructArgExprEmpty,
6091 details: GreenNodeDetails::Node { children, width },
6092 })
6093 .intern(db),
6094 )
6095 }
6096}
6097impl OptionStructArgExprEmpty {}
6098#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6099pub struct OptionStructArgExprEmptyPtr(pub SyntaxStablePtrId);
6100impl OptionStructArgExprEmptyPtr {}
6101impl TypedStablePtr for OptionStructArgExprEmptyPtr {
6102 type SyntaxNode = OptionStructArgExprEmpty;
6103 fn untyped(&self) -> SyntaxStablePtrId {
6104 self.0
6105 }
6106 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionStructArgExprEmpty {
6107 OptionStructArgExprEmpty::from_syntax_node(db, self.0.lookup(db))
6108 }
6109}
6110impl From<OptionStructArgExprEmptyPtr> for SyntaxStablePtrId {
6111 fn from(ptr: OptionStructArgExprEmptyPtr) -> Self {
6112 ptr.untyped()
6113 }
6114}
6115#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6116pub struct OptionStructArgExprEmptyGreen(pub GreenId);
6117impl TypedSyntaxNode for OptionStructArgExprEmpty {
6118 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionStructArgExprEmpty);
6119 type StablePtr = OptionStructArgExprEmptyPtr;
6120 type Green = OptionStructArgExprEmptyGreen;
6121 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6122 OptionStructArgExprEmptyGreen(
6123 Arc::new(GreenNode {
6124 kind: SyntaxKind::OptionStructArgExprEmpty,
6125 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
6126 })
6127 .intern(db),
6128 )
6129 }
6130 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6131 let kind = node.kind(db);
6132 assert_eq!(
6133 kind,
6134 SyntaxKind::OptionStructArgExprEmpty,
6135 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6136 kind,
6137 SyntaxKind::OptionStructArgExprEmpty
6138 );
6139 let children = db.get_children(node.clone());
6140 Self { node, children }
6141 }
6142 fn as_syntax_node(&self) -> SyntaxNode {
6143 self.node.clone()
6144 }
6145 fn stable_ptr(&self) -> Self::StablePtr {
6146 OptionStructArgExprEmptyPtr(self.node.0.stable_ptr)
6147 }
6148}
6149impl From<&OptionStructArgExprEmpty> for SyntaxStablePtrId {
6150 fn from(node: &OptionStructArgExprEmpty) -> Self {
6151 node.stable_ptr().untyped()
6152 }
6153}
6154#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6155pub struct StructArgSingle {
6156 node: SyntaxNode,
6157 children: Arc<[SyntaxNode]>,
6158}
6159impl StructArgSingle {
6160 pub const INDEX_IDENTIFIER: usize = 0;
6161 pub const INDEX_ARG_EXPR: usize = 1;
6162 pub fn new_green(
6163 db: &dyn SyntaxGroup,
6164 identifier: TerminalIdentifierGreen,
6165 arg_expr: OptionStructArgExprGreen,
6166 ) -> StructArgSingleGreen {
6167 let children: Vec<GreenId> = vec![identifier.0, arg_expr.0];
6168 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6169 StructArgSingleGreen(
6170 Arc::new(GreenNode {
6171 kind: SyntaxKind::StructArgSingle,
6172 details: GreenNodeDetails::Node { children, width },
6173 })
6174 .intern(db),
6175 )
6176 }
6177}
6178impl StructArgSingle {
6179 pub fn identifier(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
6180 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
6181 }
6182 pub fn arg_expr(&self, db: &dyn SyntaxGroup) -> OptionStructArgExpr {
6183 OptionStructArgExpr::from_syntax_node(db, self.children[1].clone())
6184 }
6185}
6186#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6187pub struct StructArgSinglePtr(pub SyntaxStablePtrId);
6188impl StructArgSinglePtr {
6189 pub fn identifier_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
6190 let ptr = self.0.lookup_intern(db);
6191 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
6192 TerminalIdentifierGreen(key_fields[0])
6193 } else {
6194 panic!("Unexpected key field query on root.");
6195 }
6196 }
6197}
6198impl TypedStablePtr for StructArgSinglePtr {
6199 type SyntaxNode = StructArgSingle;
6200 fn untyped(&self) -> SyntaxStablePtrId {
6201 self.0
6202 }
6203 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgSingle {
6204 StructArgSingle::from_syntax_node(db, self.0.lookup(db))
6205 }
6206}
6207impl From<StructArgSinglePtr> for SyntaxStablePtrId {
6208 fn from(ptr: StructArgSinglePtr) -> Self {
6209 ptr.untyped()
6210 }
6211}
6212#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6213pub struct StructArgSingleGreen(pub GreenId);
6214impl TypedSyntaxNode for StructArgSingle {
6215 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgSingle);
6216 type StablePtr = StructArgSinglePtr;
6217 type Green = StructArgSingleGreen;
6218 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6219 StructArgSingleGreen(
6220 Arc::new(GreenNode {
6221 kind: SyntaxKind::StructArgSingle,
6222 details: GreenNodeDetails::Node {
6223 children: vec![
6224 TerminalIdentifier::missing(db).0,
6225 OptionStructArgExpr::missing(db).0,
6226 ],
6227 width: TextWidth::default(),
6228 },
6229 })
6230 .intern(db),
6231 )
6232 }
6233 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6234 let kind = node.kind(db);
6235 assert_eq!(
6236 kind,
6237 SyntaxKind::StructArgSingle,
6238 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6239 kind,
6240 SyntaxKind::StructArgSingle
6241 );
6242 let children = db.get_children(node.clone());
6243 Self { node, children }
6244 }
6245 fn as_syntax_node(&self) -> SyntaxNode {
6246 self.node.clone()
6247 }
6248 fn stable_ptr(&self) -> Self::StablePtr {
6249 StructArgSinglePtr(self.node.0.stable_ptr)
6250 }
6251}
6252impl From<&StructArgSingle> for SyntaxStablePtrId {
6253 fn from(node: &StructArgSingle) -> Self {
6254 node.stable_ptr().untyped()
6255 }
6256}
6257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6258pub struct StructArgTail {
6259 node: SyntaxNode,
6260 children: Arc<[SyntaxNode]>,
6261}
6262impl StructArgTail {
6263 pub const INDEX_DOTDOT: usize = 0;
6264 pub const INDEX_EXPRESSION: usize = 1;
6265 pub fn new_green(
6266 db: &dyn SyntaxGroup,
6267 dotdot: TerminalDotDotGreen,
6268 expression: ExprGreen,
6269 ) -> StructArgTailGreen {
6270 let children: Vec<GreenId> = vec![dotdot.0, expression.0];
6271 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6272 StructArgTailGreen(
6273 Arc::new(GreenNode {
6274 kind: SyntaxKind::StructArgTail,
6275 details: GreenNodeDetails::Node { children, width },
6276 })
6277 .intern(db),
6278 )
6279 }
6280}
6281impl StructArgTail {
6282 pub fn dotdot(&self, db: &dyn SyntaxGroup) -> TerminalDotDot {
6283 TerminalDotDot::from_syntax_node(db, self.children[0].clone())
6284 }
6285 pub fn expression(&self, db: &dyn SyntaxGroup) -> Expr {
6286 Expr::from_syntax_node(db, self.children[1].clone())
6287 }
6288}
6289#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6290pub struct StructArgTailPtr(pub SyntaxStablePtrId);
6291impl StructArgTailPtr {}
6292impl TypedStablePtr for StructArgTailPtr {
6293 type SyntaxNode = StructArgTail;
6294 fn untyped(&self) -> SyntaxStablePtrId {
6295 self.0
6296 }
6297 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgTail {
6298 StructArgTail::from_syntax_node(db, self.0.lookup(db))
6299 }
6300}
6301impl From<StructArgTailPtr> for SyntaxStablePtrId {
6302 fn from(ptr: StructArgTailPtr) -> Self {
6303 ptr.untyped()
6304 }
6305}
6306#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6307pub struct StructArgTailGreen(pub GreenId);
6308impl TypedSyntaxNode for StructArgTail {
6309 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgTail);
6310 type StablePtr = StructArgTailPtr;
6311 type Green = StructArgTailGreen;
6312 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6313 StructArgTailGreen(
6314 Arc::new(GreenNode {
6315 kind: SyntaxKind::StructArgTail,
6316 details: GreenNodeDetails::Node {
6317 children: vec![TerminalDotDot::missing(db).0, Expr::missing(db).0],
6318 width: TextWidth::default(),
6319 },
6320 })
6321 .intern(db),
6322 )
6323 }
6324 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6325 let kind = node.kind(db);
6326 assert_eq!(
6327 kind,
6328 SyntaxKind::StructArgTail,
6329 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6330 kind,
6331 SyntaxKind::StructArgTail
6332 );
6333 let children = db.get_children(node.clone());
6334 Self { node, children }
6335 }
6336 fn as_syntax_node(&self) -> SyntaxNode {
6337 self.node.clone()
6338 }
6339 fn stable_ptr(&self) -> Self::StablePtr {
6340 StructArgTailPtr(self.node.0.stable_ptr)
6341 }
6342}
6343impl From<&StructArgTail> for SyntaxStablePtrId {
6344 fn from(node: &StructArgTail) -> Self {
6345 node.stable_ptr().untyped()
6346 }
6347}
6348#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6349pub enum StructArg {
6350 StructArgSingle(StructArgSingle),
6351 StructArgTail(StructArgTail),
6352}
6353#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6354pub struct StructArgPtr(pub SyntaxStablePtrId);
6355impl TypedStablePtr for StructArgPtr {
6356 type SyntaxNode = StructArg;
6357 fn untyped(&self) -> SyntaxStablePtrId {
6358 self.0
6359 }
6360 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArg {
6361 StructArg::from_syntax_node(db, self.0.lookup(db))
6362 }
6363}
6364impl From<StructArgPtr> for SyntaxStablePtrId {
6365 fn from(ptr: StructArgPtr) -> Self {
6366 ptr.untyped()
6367 }
6368}
6369impl From<StructArgSinglePtr> for StructArgPtr {
6370 fn from(value: StructArgSinglePtr) -> Self {
6371 Self(value.0)
6372 }
6373}
6374impl From<StructArgTailPtr> for StructArgPtr {
6375 fn from(value: StructArgTailPtr) -> Self {
6376 Self(value.0)
6377 }
6378}
6379impl From<StructArgSingleGreen> for StructArgGreen {
6380 fn from(value: StructArgSingleGreen) -> Self {
6381 Self(value.0)
6382 }
6383}
6384impl From<StructArgTailGreen> for StructArgGreen {
6385 fn from(value: StructArgTailGreen) -> Self {
6386 Self(value.0)
6387 }
6388}
6389#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6390pub struct StructArgGreen(pub GreenId);
6391impl TypedSyntaxNode for StructArg {
6392 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6393 type StablePtr = StructArgPtr;
6394 type Green = StructArgGreen;
6395 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6396 panic!("No missing variant.");
6397 }
6398 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6399 let kind = node.kind(db);
6400 match kind {
6401 SyntaxKind::StructArgSingle => {
6402 StructArg::StructArgSingle(StructArgSingle::from_syntax_node(db, node))
6403 }
6404 SyntaxKind::StructArgTail => {
6405 StructArg::StructArgTail(StructArgTail::from_syntax_node(db, node))
6406 }
6407 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "StructArg"),
6408 }
6409 }
6410 fn as_syntax_node(&self) -> SyntaxNode {
6411 match self {
6412 StructArg::StructArgSingle(x) => x.as_syntax_node(),
6413 StructArg::StructArgTail(x) => x.as_syntax_node(),
6414 }
6415 }
6416 fn stable_ptr(&self) -> Self::StablePtr {
6417 StructArgPtr(self.as_syntax_node().0.stable_ptr)
6418 }
6419}
6420impl From<&StructArg> for SyntaxStablePtrId {
6421 fn from(node: &StructArg) -> Self {
6422 node.stable_ptr().untyped()
6423 }
6424}
6425impl StructArg {
6426 pub fn is_variant(kind: SyntaxKind) -> bool {
6428 matches!(kind, SyntaxKind::StructArgSingle | SyntaxKind::StructArgTail)
6429 }
6430}
6431#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6432pub struct StructArgList(ElementList<StructArg, 2>);
6433impl Deref for StructArgList {
6434 type Target = ElementList<StructArg, 2>;
6435 fn deref(&self) -> &Self::Target {
6436 &self.0
6437 }
6438}
6439impl StructArgList {
6440 pub fn new_green(
6441 db: &dyn SyntaxGroup,
6442 children: Vec<StructArgListElementOrSeparatorGreen>,
6443 ) -> StructArgListGreen {
6444 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
6445 StructArgListGreen(
6446 Arc::new(GreenNode {
6447 kind: SyntaxKind::StructArgList,
6448 details: GreenNodeDetails::Node {
6449 children: children.iter().map(|x| x.id()).collect(),
6450 width,
6451 },
6452 })
6453 .intern(db),
6454 )
6455 }
6456}
6457#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6458pub struct StructArgListPtr(pub SyntaxStablePtrId);
6459impl TypedStablePtr for StructArgListPtr {
6460 type SyntaxNode = StructArgList;
6461 fn untyped(&self) -> SyntaxStablePtrId {
6462 self.0
6463 }
6464 fn lookup(&self, db: &dyn SyntaxGroup) -> StructArgList {
6465 StructArgList::from_syntax_node(db, self.0.lookup(db))
6466 }
6467}
6468impl From<StructArgListPtr> for SyntaxStablePtrId {
6469 fn from(ptr: StructArgListPtr) -> Self {
6470 ptr.untyped()
6471 }
6472}
6473#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6474pub enum StructArgListElementOrSeparatorGreen {
6475 Separator(TerminalCommaGreen),
6476 Element(StructArgGreen),
6477}
6478impl From<TerminalCommaGreen> for StructArgListElementOrSeparatorGreen {
6479 fn from(value: TerminalCommaGreen) -> Self {
6480 StructArgListElementOrSeparatorGreen::Separator(value)
6481 }
6482}
6483impl From<StructArgGreen> for StructArgListElementOrSeparatorGreen {
6484 fn from(value: StructArgGreen) -> Self {
6485 StructArgListElementOrSeparatorGreen::Element(value)
6486 }
6487}
6488impl StructArgListElementOrSeparatorGreen {
6489 fn id(&self) -> GreenId {
6490 match self {
6491 StructArgListElementOrSeparatorGreen::Separator(green) => green.0,
6492 StructArgListElementOrSeparatorGreen::Element(green) => green.0,
6493 }
6494 }
6495}
6496#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6497pub struct StructArgListGreen(pub GreenId);
6498impl TypedSyntaxNode for StructArgList {
6499 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StructArgList);
6500 type StablePtr = StructArgListPtr;
6501 type Green = StructArgListGreen;
6502 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6503 StructArgListGreen(
6504 Arc::new(GreenNode {
6505 kind: SyntaxKind::StructArgList,
6506 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
6507 })
6508 .intern(db),
6509 )
6510 }
6511 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6512 Self(ElementList::new(node))
6513 }
6514 fn as_syntax_node(&self) -> SyntaxNode {
6515 self.node.clone()
6516 }
6517 fn stable_ptr(&self) -> Self::StablePtr {
6518 StructArgListPtr(self.node.0.stable_ptr)
6519 }
6520}
6521impl From<&StructArgList> for SyntaxStablePtrId {
6522 fn from(node: &StructArgList) -> Self {
6523 node.stable_ptr().untyped()
6524 }
6525}
6526#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6527pub struct ArgListBraced {
6528 node: SyntaxNode,
6529 children: Arc<[SyntaxNode]>,
6530}
6531impl ArgListBraced {
6532 pub const INDEX_LBRACE: usize = 0;
6533 pub const INDEX_ARGUMENTS: usize = 1;
6534 pub const INDEX_RBRACE: usize = 2;
6535 pub fn new_green(
6536 db: &dyn SyntaxGroup,
6537 lbrace: TerminalLBraceGreen,
6538 arguments: ArgListGreen,
6539 rbrace: TerminalRBraceGreen,
6540 ) -> ArgListBracedGreen {
6541 let children: Vec<GreenId> = vec![lbrace.0, arguments.0, rbrace.0];
6542 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6543 ArgListBracedGreen(
6544 Arc::new(GreenNode {
6545 kind: SyntaxKind::ArgListBraced,
6546 details: GreenNodeDetails::Node { children, width },
6547 })
6548 .intern(db),
6549 )
6550 }
6551}
6552impl ArgListBraced {
6553 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
6554 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
6555 }
6556 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
6557 ArgList::from_syntax_node(db, self.children[1].clone())
6558 }
6559 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
6560 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
6561 }
6562}
6563#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6564pub struct ArgListBracedPtr(pub SyntaxStablePtrId);
6565impl ArgListBracedPtr {}
6566impl TypedStablePtr for ArgListBracedPtr {
6567 type SyntaxNode = ArgListBraced;
6568 fn untyped(&self) -> SyntaxStablePtrId {
6569 self.0
6570 }
6571 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListBraced {
6572 ArgListBraced::from_syntax_node(db, self.0.lookup(db))
6573 }
6574}
6575impl From<ArgListBracedPtr> for SyntaxStablePtrId {
6576 fn from(ptr: ArgListBracedPtr) -> Self {
6577 ptr.untyped()
6578 }
6579}
6580#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6581pub struct ArgListBracedGreen(pub GreenId);
6582impl TypedSyntaxNode for ArgListBraced {
6583 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListBraced);
6584 type StablePtr = ArgListBracedPtr;
6585 type Green = ArgListBracedGreen;
6586 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6587 ArgListBracedGreen(
6588 Arc::new(GreenNode {
6589 kind: SyntaxKind::ArgListBraced,
6590 details: GreenNodeDetails::Node {
6591 children: vec![
6592 TerminalLBrace::missing(db).0,
6593 ArgList::missing(db).0,
6594 TerminalRBrace::missing(db).0,
6595 ],
6596 width: TextWidth::default(),
6597 },
6598 })
6599 .intern(db),
6600 )
6601 }
6602 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6603 let kind = node.kind(db);
6604 assert_eq!(
6605 kind,
6606 SyntaxKind::ArgListBraced,
6607 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6608 kind,
6609 SyntaxKind::ArgListBraced
6610 );
6611 let children = db.get_children(node.clone());
6612 Self { node, children }
6613 }
6614 fn as_syntax_node(&self) -> SyntaxNode {
6615 self.node.clone()
6616 }
6617 fn stable_ptr(&self) -> Self::StablePtr {
6618 ArgListBracedPtr(self.node.0.stable_ptr)
6619 }
6620}
6621impl From<&ArgListBraced> for SyntaxStablePtrId {
6622 fn from(node: &ArgListBraced) -> Self {
6623 node.stable_ptr().untyped()
6624 }
6625}
6626#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6627pub struct ArgListBracketed {
6628 node: SyntaxNode,
6629 children: Arc<[SyntaxNode]>,
6630}
6631impl ArgListBracketed {
6632 pub const INDEX_LBRACK: usize = 0;
6633 pub const INDEX_ARGUMENTS: usize = 1;
6634 pub const INDEX_RBRACK: usize = 2;
6635 pub fn new_green(
6636 db: &dyn SyntaxGroup,
6637 lbrack: TerminalLBrackGreen,
6638 arguments: ArgListGreen,
6639 rbrack: TerminalRBrackGreen,
6640 ) -> ArgListBracketedGreen {
6641 let children: Vec<GreenId> = vec![lbrack.0, arguments.0, rbrack.0];
6642 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6643 ArgListBracketedGreen(
6644 Arc::new(GreenNode {
6645 kind: SyntaxKind::ArgListBracketed,
6646 details: GreenNodeDetails::Node { children, width },
6647 })
6648 .intern(db),
6649 )
6650 }
6651}
6652impl ArgListBracketed {
6653 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
6654 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
6655 }
6656 pub fn arguments(&self, db: &dyn SyntaxGroup) -> ArgList {
6657 ArgList::from_syntax_node(db, self.children[1].clone())
6658 }
6659 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
6660 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
6661 }
6662}
6663#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6664pub struct ArgListBracketedPtr(pub SyntaxStablePtrId);
6665impl ArgListBracketedPtr {}
6666impl TypedStablePtr for ArgListBracketedPtr {
6667 type SyntaxNode = ArgListBracketed;
6668 fn untyped(&self) -> SyntaxStablePtrId {
6669 self.0
6670 }
6671 fn lookup(&self, db: &dyn SyntaxGroup) -> ArgListBracketed {
6672 ArgListBracketed::from_syntax_node(db, self.0.lookup(db))
6673 }
6674}
6675impl From<ArgListBracketedPtr> for SyntaxStablePtrId {
6676 fn from(ptr: ArgListBracketedPtr) -> Self {
6677 ptr.untyped()
6678 }
6679}
6680#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6681pub struct ArgListBracketedGreen(pub GreenId);
6682impl TypedSyntaxNode for ArgListBracketed {
6683 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ArgListBracketed);
6684 type StablePtr = ArgListBracketedPtr;
6685 type Green = ArgListBracketedGreen;
6686 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6687 ArgListBracketedGreen(
6688 Arc::new(GreenNode {
6689 kind: SyntaxKind::ArgListBracketed,
6690 details: GreenNodeDetails::Node {
6691 children: vec![
6692 TerminalLBrack::missing(db).0,
6693 ArgList::missing(db).0,
6694 TerminalRBrack::missing(db).0,
6695 ],
6696 width: TextWidth::default(),
6697 },
6698 })
6699 .intern(db),
6700 )
6701 }
6702 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6703 let kind = node.kind(db);
6704 assert_eq!(
6705 kind,
6706 SyntaxKind::ArgListBracketed,
6707 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6708 kind,
6709 SyntaxKind::ArgListBracketed
6710 );
6711 let children = db.get_children(node.clone());
6712 Self { node, children }
6713 }
6714 fn as_syntax_node(&self) -> SyntaxNode {
6715 self.node.clone()
6716 }
6717 fn stable_ptr(&self) -> Self::StablePtr {
6718 ArgListBracketedPtr(self.node.0.stable_ptr)
6719 }
6720}
6721impl From<&ArgListBracketed> for SyntaxStablePtrId {
6722 fn from(node: &ArgListBracketed) -> Self {
6723 node.stable_ptr().untyped()
6724 }
6725}
6726#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6727pub enum WrappedArgList {
6728 BracketedArgList(ArgListBracketed),
6729 ParenthesizedArgList(ArgListParenthesized),
6730 BracedArgList(ArgListBraced),
6731 Missing(WrappedArgListMissing),
6732}
6733#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6734pub struct WrappedArgListPtr(pub SyntaxStablePtrId);
6735impl TypedStablePtr for WrappedArgListPtr {
6736 type SyntaxNode = WrappedArgList;
6737 fn untyped(&self) -> SyntaxStablePtrId {
6738 self.0
6739 }
6740 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
6741 WrappedArgList::from_syntax_node(db, self.0.lookup(db))
6742 }
6743}
6744impl From<WrappedArgListPtr> for SyntaxStablePtrId {
6745 fn from(ptr: WrappedArgListPtr) -> Self {
6746 ptr.untyped()
6747 }
6748}
6749impl From<ArgListBracketedPtr> for WrappedArgListPtr {
6750 fn from(value: ArgListBracketedPtr) -> Self {
6751 Self(value.0)
6752 }
6753}
6754impl From<ArgListParenthesizedPtr> for WrappedArgListPtr {
6755 fn from(value: ArgListParenthesizedPtr) -> Self {
6756 Self(value.0)
6757 }
6758}
6759impl From<ArgListBracedPtr> for WrappedArgListPtr {
6760 fn from(value: ArgListBracedPtr) -> Self {
6761 Self(value.0)
6762 }
6763}
6764impl From<WrappedArgListMissingPtr> for WrappedArgListPtr {
6765 fn from(value: WrappedArgListMissingPtr) -> Self {
6766 Self(value.0)
6767 }
6768}
6769impl From<ArgListBracketedGreen> for WrappedArgListGreen {
6770 fn from(value: ArgListBracketedGreen) -> Self {
6771 Self(value.0)
6772 }
6773}
6774impl From<ArgListParenthesizedGreen> for WrappedArgListGreen {
6775 fn from(value: ArgListParenthesizedGreen) -> Self {
6776 Self(value.0)
6777 }
6778}
6779impl From<ArgListBracedGreen> for WrappedArgListGreen {
6780 fn from(value: ArgListBracedGreen) -> Self {
6781 Self(value.0)
6782 }
6783}
6784impl From<WrappedArgListMissingGreen> for WrappedArgListGreen {
6785 fn from(value: WrappedArgListMissingGreen) -> Self {
6786 Self(value.0)
6787 }
6788}
6789#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6790pub struct WrappedArgListGreen(pub GreenId);
6791impl TypedSyntaxNode for WrappedArgList {
6792 const OPTIONAL_KIND: Option<SyntaxKind> = None;
6793 type StablePtr = WrappedArgListPtr;
6794 type Green = WrappedArgListGreen;
6795 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6796 WrappedArgListGreen(WrappedArgListMissing::missing(db).0)
6797 }
6798 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6799 let kind = node.kind(db);
6800 match kind {
6801 SyntaxKind::ArgListBracketed => {
6802 WrappedArgList::BracketedArgList(ArgListBracketed::from_syntax_node(db, node))
6803 }
6804 SyntaxKind::ArgListParenthesized => WrappedArgList::ParenthesizedArgList(
6805 ArgListParenthesized::from_syntax_node(db, node),
6806 ),
6807 SyntaxKind::ArgListBraced => {
6808 WrappedArgList::BracedArgList(ArgListBraced::from_syntax_node(db, node))
6809 }
6810 SyntaxKind::WrappedArgListMissing => {
6811 WrappedArgList::Missing(WrappedArgListMissing::from_syntax_node(db, node))
6812 }
6813 _ => {
6814 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "WrappedArgList")
6815 }
6816 }
6817 }
6818 fn as_syntax_node(&self) -> SyntaxNode {
6819 match self {
6820 WrappedArgList::BracketedArgList(x) => x.as_syntax_node(),
6821 WrappedArgList::ParenthesizedArgList(x) => x.as_syntax_node(),
6822 WrappedArgList::BracedArgList(x) => x.as_syntax_node(),
6823 WrappedArgList::Missing(x) => x.as_syntax_node(),
6824 }
6825 }
6826 fn stable_ptr(&self) -> Self::StablePtr {
6827 WrappedArgListPtr(self.as_syntax_node().0.stable_ptr)
6828 }
6829}
6830impl From<&WrappedArgList> for SyntaxStablePtrId {
6831 fn from(node: &WrappedArgList) -> Self {
6832 node.stable_ptr().untyped()
6833 }
6834}
6835impl WrappedArgList {
6836 pub fn is_variant(kind: SyntaxKind) -> bool {
6838 matches!(
6839 kind,
6840 SyntaxKind::ArgListBracketed
6841 | SyntaxKind::ArgListParenthesized
6842 | SyntaxKind::ArgListBraced
6843 | SyntaxKind::WrappedArgListMissing
6844 )
6845 }
6846}
6847#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6848pub struct WrappedArgListMissing {
6849 node: SyntaxNode,
6850 children: Arc<[SyntaxNode]>,
6851}
6852impl WrappedArgListMissing {
6853 pub fn new_green(db: &dyn SyntaxGroup) -> WrappedArgListMissingGreen {
6854 let children: Vec<GreenId> = vec![];
6855 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
6856 WrappedArgListMissingGreen(
6857 Arc::new(GreenNode {
6858 kind: SyntaxKind::WrappedArgListMissing,
6859 details: GreenNodeDetails::Node { children, width },
6860 })
6861 .intern(db),
6862 )
6863 }
6864}
6865impl WrappedArgListMissing {}
6866#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6867pub struct WrappedArgListMissingPtr(pub SyntaxStablePtrId);
6868impl WrappedArgListMissingPtr {}
6869impl TypedStablePtr for WrappedArgListMissingPtr {
6870 type SyntaxNode = WrappedArgListMissing;
6871 fn untyped(&self) -> SyntaxStablePtrId {
6872 self.0
6873 }
6874 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedArgListMissing {
6875 WrappedArgListMissing::from_syntax_node(db, self.0.lookup(db))
6876 }
6877}
6878impl From<WrappedArgListMissingPtr> for SyntaxStablePtrId {
6879 fn from(ptr: WrappedArgListMissingPtr) -> Self {
6880 ptr.untyped()
6881 }
6882}
6883#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6884pub struct WrappedArgListMissingGreen(pub GreenId);
6885impl TypedSyntaxNode for WrappedArgListMissing {
6886 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::WrappedArgListMissing);
6887 type StablePtr = WrappedArgListMissingPtr;
6888 type Green = WrappedArgListMissingGreen;
6889 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
6890 WrappedArgListMissingGreen(
6891 Arc::new(GreenNode {
6892 kind: SyntaxKind::WrappedArgListMissing,
6893 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
6894 })
6895 .intern(db),
6896 )
6897 }
6898 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
6899 let kind = node.kind(db);
6900 assert_eq!(
6901 kind,
6902 SyntaxKind::WrappedArgListMissing,
6903 "Unexpected SyntaxKind {:?}. Expected {:?}.",
6904 kind,
6905 SyntaxKind::WrappedArgListMissing
6906 );
6907 let children = db.get_children(node.clone());
6908 Self { node, children }
6909 }
6910 fn as_syntax_node(&self) -> SyntaxNode {
6911 self.node.clone()
6912 }
6913 fn stable_ptr(&self) -> Self::StablePtr {
6914 WrappedArgListMissingPtr(self.node.0.stable_ptr)
6915 }
6916}
6917impl From<&WrappedArgListMissing> for SyntaxStablePtrId {
6918 fn from(node: &WrappedArgListMissing) -> Self {
6919 node.stable_ptr().untyped()
6920 }
6921}
6922#[derive(Clone, Debug, Eq, Hash, PartialEq)]
6923pub enum Pattern {
6924 Underscore(TerminalUnderscore),
6925 Literal(TerminalLiteralNumber),
6926 False(TerminalFalse),
6927 True(TerminalTrue),
6928 ShortString(TerminalShortString),
6929 String(TerminalString),
6930 Identifier(PatternIdentifier),
6931 Struct(PatternStruct),
6932 Tuple(PatternTuple),
6933 Enum(PatternEnum),
6934 FixedSizeArray(PatternFixedSizeArray),
6935 Path(ExprPath),
6936}
6937#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
6938pub struct PatternPtr(pub SyntaxStablePtrId);
6939impl TypedStablePtr for PatternPtr {
6940 type SyntaxNode = Pattern;
6941 fn untyped(&self) -> SyntaxStablePtrId {
6942 self.0
6943 }
6944 fn lookup(&self, db: &dyn SyntaxGroup) -> Pattern {
6945 Pattern::from_syntax_node(db, self.0.lookup(db))
6946 }
6947}
6948impl From<PatternPtr> for SyntaxStablePtrId {
6949 fn from(ptr: PatternPtr) -> Self {
6950 ptr.untyped()
6951 }
6952}
6953impl From<TerminalUnderscorePtr> for PatternPtr {
6954 fn from(value: TerminalUnderscorePtr) -> Self {
6955 Self(value.0)
6956 }
6957}
6958impl From<TerminalLiteralNumberPtr> for PatternPtr {
6959 fn from(value: TerminalLiteralNumberPtr) -> Self {
6960 Self(value.0)
6961 }
6962}
6963impl From<TerminalFalsePtr> for PatternPtr {
6964 fn from(value: TerminalFalsePtr) -> Self {
6965 Self(value.0)
6966 }
6967}
6968impl From<TerminalTruePtr> for PatternPtr {
6969 fn from(value: TerminalTruePtr) -> Self {
6970 Self(value.0)
6971 }
6972}
6973impl From<TerminalShortStringPtr> for PatternPtr {
6974 fn from(value: TerminalShortStringPtr) -> Self {
6975 Self(value.0)
6976 }
6977}
6978impl From<TerminalStringPtr> for PatternPtr {
6979 fn from(value: TerminalStringPtr) -> Self {
6980 Self(value.0)
6981 }
6982}
6983impl From<PatternIdentifierPtr> for PatternPtr {
6984 fn from(value: PatternIdentifierPtr) -> Self {
6985 Self(value.0)
6986 }
6987}
6988impl From<PatternStructPtr> for PatternPtr {
6989 fn from(value: PatternStructPtr) -> Self {
6990 Self(value.0)
6991 }
6992}
6993impl From<PatternTuplePtr> for PatternPtr {
6994 fn from(value: PatternTuplePtr) -> Self {
6995 Self(value.0)
6996 }
6997}
6998impl From<PatternEnumPtr> for PatternPtr {
6999 fn from(value: PatternEnumPtr) -> Self {
7000 Self(value.0)
7001 }
7002}
7003impl From<PatternFixedSizeArrayPtr> for PatternPtr {
7004 fn from(value: PatternFixedSizeArrayPtr) -> Self {
7005 Self(value.0)
7006 }
7007}
7008impl From<ExprPathPtr> for PatternPtr {
7009 fn from(value: ExprPathPtr) -> Self {
7010 Self(value.0)
7011 }
7012}
7013impl From<TerminalUnderscoreGreen> for PatternGreen {
7014 fn from(value: TerminalUnderscoreGreen) -> Self {
7015 Self(value.0)
7016 }
7017}
7018impl From<TerminalLiteralNumberGreen> for PatternGreen {
7019 fn from(value: TerminalLiteralNumberGreen) -> Self {
7020 Self(value.0)
7021 }
7022}
7023impl From<TerminalFalseGreen> for PatternGreen {
7024 fn from(value: TerminalFalseGreen) -> Self {
7025 Self(value.0)
7026 }
7027}
7028impl From<TerminalTrueGreen> for PatternGreen {
7029 fn from(value: TerminalTrueGreen) -> Self {
7030 Self(value.0)
7031 }
7032}
7033impl From<TerminalShortStringGreen> for PatternGreen {
7034 fn from(value: TerminalShortStringGreen) -> Self {
7035 Self(value.0)
7036 }
7037}
7038impl From<TerminalStringGreen> for PatternGreen {
7039 fn from(value: TerminalStringGreen) -> Self {
7040 Self(value.0)
7041 }
7042}
7043impl From<PatternIdentifierGreen> for PatternGreen {
7044 fn from(value: PatternIdentifierGreen) -> Self {
7045 Self(value.0)
7046 }
7047}
7048impl From<PatternStructGreen> for PatternGreen {
7049 fn from(value: PatternStructGreen) -> Self {
7050 Self(value.0)
7051 }
7052}
7053impl From<PatternTupleGreen> for PatternGreen {
7054 fn from(value: PatternTupleGreen) -> Self {
7055 Self(value.0)
7056 }
7057}
7058impl From<PatternEnumGreen> for PatternGreen {
7059 fn from(value: PatternEnumGreen) -> Self {
7060 Self(value.0)
7061 }
7062}
7063impl From<PatternFixedSizeArrayGreen> for PatternGreen {
7064 fn from(value: PatternFixedSizeArrayGreen) -> Self {
7065 Self(value.0)
7066 }
7067}
7068impl From<ExprPathGreen> for PatternGreen {
7069 fn from(value: ExprPathGreen) -> Self {
7070 Self(value.0)
7071 }
7072}
7073#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7074pub struct PatternGreen(pub GreenId);
7075impl TypedSyntaxNode for Pattern {
7076 const OPTIONAL_KIND: Option<SyntaxKind> = None;
7077 type StablePtr = PatternPtr;
7078 type Green = PatternGreen;
7079 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7080 panic!("No missing variant.");
7081 }
7082 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7083 let kind = node.kind(db);
7084 match kind {
7085 SyntaxKind::TerminalUnderscore => {
7086 Pattern::Underscore(TerminalUnderscore::from_syntax_node(db, node))
7087 }
7088 SyntaxKind::TerminalLiteralNumber => {
7089 Pattern::Literal(TerminalLiteralNumber::from_syntax_node(db, node))
7090 }
7091 SyntaxKind::TerminalFalse => Pattern::False(TerminalFalse::from_syntax_node(db, node)),
7092 SyntaxKind::TerminalTrue => Pattern::True(TerminalTrue::from_syntax_node(db, node)),
7093 SyntaxKind::TerminalShortString => {
7094 Pattern::ShortString(TerminalShortString::from_syntax_node(db, node))
7095 }
7096 SyntaxKind::TerminalString => {
7097 Pattern::String(TerminalString::from_syntax_node(db, node))
7098 }
7099 SyntaxKind::PatternIdentifier => {
7100 Pattern::Identifier(PatternIdentifier::from_syntax_node(db, node))
7101 }
7102 SyntaxKind::PatternStruct => Pattern::Struct(PatternStruct::from_syntax_node(db, node)),
7103 SyntaxKind::PatternTuple => Pattern::Tuple(PatternTuple::from_syntax_node(db, node)),
7104 SyntaxKind::PatternEnum => Pattern::Enum(PatternEnum::from_syntax_node(db, node)),
7105 SyntaxKind::PatternFixedSizeArray => {
7106 Pattern::FixedSizeArray(PatternFixedSizeArray::from_syntax_node(db, node))
7107 }
7108 SyntaxKind::ExprPath => Pattern::Path(ExprPath::from_syntax_node(db, node)),
7109 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Pattern"),
7110 }
7111 }
7112 fn as_syntax_node(&self) -> SyntaxNode {
7113 match self {
7114 Pattern::Underscore(x) => x.as_syntax_node(),
7115 Pattern::Literal(x) => x.as_syntax_node(),
7116 Pattern::False(x) => x.as_syntax_node(),
7117 Pattern::True(x) => x.as_syntax_node(),
7118 Pattern::ShortString(x) => x.as_syntax_node(),
7119 Pattern::String(x) => x.as_syntax_node(),
7120 Pattern::Identifier(x) => x.as_syntax_node(),
7121 Pattern::Struct(x) => x.as_syntax_node(),
7122 Pattern::Tuple(x) => x.as_syntax_node(),
7123 Pattern::Enum(x) => x.as_syntax_node(),
7124 Pattern::FixedSizeArray(x) => x.as_syntax_node(),
7125 Pattern::Path(x) => x.as_syntax_node(),
7126 }
7127 }
7128 fn stable_ptr(&self) -> Self::StablePtr {
7129 PatternPtr(self.as_syntax_node().0.stable_ptr)
7130 }
7131}
7132impl From<&Pattern> for SyntaxStablePtrId {
7133 fn from(node: &Pattern) -> Self {
7134 node.stable_ptr().untyped()
7135 }
7136}
7137impl Pattern {
7138 pub fn is_variant(kind: SyntaxKind) -> bool {
7140 matches!(
7141 kind,
7142 SyntaxKind::TerminalUnderscore
7143 | SyntaxKind::TerminalLiteralNumber
7144 | SyntaxKind::TerminalFalse
7145 | SyntaxKind::TerminalTrue
7146 | SyntaxKind::TerminalShortString
7147 | SyntaxKind::TerminalString
7148 | SyntaxKind::PatternIdentifier
7149 | SyntaxKind::PatternStruct
7150 | SyntaxKind::PatternTuple
7151 | SyntaxKind::PatternEnum
7152 | SyntaxKind::PatternFixedSizeArray
7153 | SyntaxKind::ExprPath
7154 )
7155 }
7156}
7157#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7158pub struct PatternIdentifier {
7159 node: SyntaxNode,
7160 children: Arc<[SyntaxNode]>,
7161}
7162impl PatternIdentifier {
7163 pub const INDEX_MODIFIERS: usize = 0;
7164 pub const INDEX_NAME: usize = 1;
7165 pub fn new_green(
7166 db: &dyn SyntaxGroup,
7167 modifiers: ModifierListGreen,
7168 name: TerminalIdentifierGreen,
7169 ) -> PatternIdentifierGreen {
7170 let children: Vec<GreenId> = vec![modifiers.0, name.0];
7171 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7172 PatternIdentifierGreen(
7173 Arc::new(GreenNode {
7174 kind: SyntaxKind::PatternIdentifier,
7175 details: GreenNodeDetails::Node { children, width },
7176 })
7177 .intern(db),
7178 )
7179 }
7180}
7181impl PatternIdentifier {
7182 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
7183 ModifierList::from_syntax_node(db, self.children[0].clone())
7184 }
7185 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
7186 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
7187 }
7188}
7189#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7190pub struct PatternIdentifierPtr(pub SyntaxStablePtrId);
7191impl PatternIdentifierPtr {
7192 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
7193 let ptr = self.0.lookup_intern(db);
7194 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
7195 TerminalIdentifierGreen(key_fields[0])
7196 } else {
7197 panic!("Unexpected key field query on root.");
7198 }
7199 }
7200}
7201impl TypedStablePtr for PatternIdentifierPtr {
7202 type SyntaxNode = PatternIdentifier;
7203 fn untyped(&self) -> SyntaxStablePtrId {
7204 self.0
7205 }
7206 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternIdentifier {
7207 PatternIdentifier::from_syntax_node(db, self.0.lookup(db))
7208 }
7209}
7210impl From<PatternIdentifierPtr> for SyntaxStablePtrId {
7211 fn from(ptr: PatternIdentifierPtr) -> Self {
7212 ptr.untyped()
7213 }
7214}
7215#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7216pub struct PatternIdentifierGreen(pub GreenId);
7217impl TypedSyntaxNode for PatternIdentifier {
7218 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternIdentifier);
7219 type StablePtr = PatternIdentifierPtr;
7220 type Green = PatternIdentifierGreen;
7221 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7222 PatternIdentifierGreen(
7223 Arc::new(GreenNode {
7224 kind: SyntaxKind::PatternIdentifier,
7225 details: GreenNodeDetails::Node {
7226 children: vec![ModifierList::missing(db).0, TerminalIdentifier::missing(db).0],
7227 width: TextWidth::default(),
7228 },
7229 })
7230 .intern(db),
7231 )
7232 }
7233 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7234 let kind = node.kind(db);
7235 assert_eq!(
7236 kind,
7237 SyntaxKind::PatternIdentifier,
7238 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7239 kind,
7240 SyntaxKind::PatternIdentifier
7241 );
7242 let children = db.get_children(node.clone());
7243 Self { node, children }
7244 }
7245 fn as_syntax_node(&self) -> SyntaxNode {
7246 self.node.clone()
7247 }
7248 fn stable_ptr(&self) -> Self::StablePtr {
7249 PatternIdentifierPtr(self.node.0.stable_ptr)
7250 }
7251}
7252impl From<&PatternIdentifier> for SyntaxStablePtrId {
7253 fn from(node: &PatternIdentifier) -> Self {
7254 node.stable_ptr().untyped()
7255 }
7256}
7257#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7258pub struct PatternStruct {
7259 node: SyntaxNode,
7260 children: Arc<[SyntaxNode]>,
7261}
7262impl PatternStruct {
7263 pub const INDEX_PATH: usize = 0;
7264 pub const INDEX_LBRACE: usize = 1;
7265 pub const INDEX_PARAMS: usize = 2;
7266 pub const INDEX_RBRACE: usize = 3;
7267 pub fn new_green(
7268 db: &dyn SyntaxGroup,
7269 path: ExprPathGreen,
7270 lbrace: TerminalLBraceGreen,
7271 params: PatternStructParamListGreen,
7272 rbrace: TerminalRBraceGreen,
7273 ) -> PatternStructGreen {
7274 let children: Vec<GreenId> = vec![path.0, lbrace.0, params.0, rbrace.0];
7275 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7276 PatternStructGreen(
7277 Arc::new(GreenNode {
7278 kind: SyntaxKind::PatternStruct,
7279 details: GreenNodeDetails::Node { children, width },
7280 })
7281 .intern(db),
7282 )
7283 }
7284}
7285impl PatternStruct {
7286 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
7287 ExprPath::from_syntax_node(db, self.children[0].clone())
7288 }
7289 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
7290 TerminalLBrace::from_syntax_node(db, self.children[1].clone())
7291 }
7292 pub fn params(&self, db: &dyn SyntaxGroup) -> PatternStructParamList {
7293 PatternStructParamList::from_syntax_node(db, self.children[2].clone())
7294 }
7295 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
7296 TerminalRBrace::from_syntax_node(db, self.children[3].clone())
7297 }
7298}
7299#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7300pub struct PatternStructPtr(pub SyntaxStablePtrId);
7301impl PatternStructPtr {}
7302impl TypedStablePtr for PatternStructPtr {
7303 type SyntaxNode = PatternStruct;
7304 fn untyped(&self) -> SyntaxStablePtrId {
7305 self.0
7306 }
7307 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStruct {
7308 PatternStruct::from_syntax_node(db, self.0.lookup(db))
7309 }
7310}
7311impl From<PatternStructPtr> for SyntaxStablePtrId {
7312 fn from(ptr: PatternStructPtr) -> Self {
7313 ptr.untyped()
7314 }
7315}
7316#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7317pub struct PatternStructGreen(pub GreenId);
7318impl TypedSyntaxNode for PatternStruct {
7319 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStruct);
7320 type StablePtr = PatternStructPtr;
7321 type Green = PatternStructGreen;
7322 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7323 PatternStructGreen(
7324 Arc::new(GreenNode {
7325 kind: SyntaxKind::PatternStruct,
7326 details: GreenNodeDetails::Node {
7327 children: vec![
7328 ExprPath::missing(db).0,
7329 TerminalLBrace::missing(db).0,
7330 PatternStructParamList::missing(db).0,
7331 TerminalRBrace::missing(db).0,
7332 ],
7333 width: TextWidth::default(),
7334 },
7335 })
7336 .intern(db),
7337 )
7338 }
7339 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7340 let kind = node.kind(db);
7341 assert_eq!(
7342 kind,
7343 SyntaxKind::PatternStruct,
7344 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7345 kind,
7346 SyntaxKind::PatternStruct
7347 );
7348 let children = db.get_children(node.clone());
7349 Self { node, children }
7350 }
7351 fn as_syntax_node(&self) -> SyntaxNode {
7352 self.node.clone()
7353 }
7354 fn stable_ptr(&self) -> Self::StablePtr {
7355 PatternStructPtr(self.node.0.stable_ptr)
7356 }
7357}
7358impl From<&PatternStruct> for SyntaxStablePtrId {
7359 fn from(node: &PatternStruct) -> Self {
7360 node.stable_ptr().untyped()
7361 }
7362}
7363#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7364pub struct PatternStructParamList(ElementList<PatternStructParam, 2>);
7365impl Deref for PatternStructParamList {
7366 type Target = ElementList<PatternStructParam, 2>;
7367 fn deref(&self) -> &Self::Target {
7368 &self.0
7369 }
7370}
7371impl PatternStructParamList {
7372 pub fn new_green(
7373 db: &dyn SyntaxGroup,
7374 children: Vec<PatternStructParamListElementOrSeparatorGreen>,
7375 ) -> PatternStructParamListGreen {
7376 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
7377 PatternStructParamListGreen(
7378 Arc::new(GreenNode {
7379 kind: SyntaxKind::PatternStructParamList,
7380 details: GreenNodeDetails::Node {
7381 children: children.iter().map(|x| x.id()).collect(),
7382 width,
7383 },
7384 })
7385 .intern(db),
7386 )
7387 }
7388}
7389#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7390pub struct PatternStructParamListPtr(pub SyntaxStablePtrId);
7391impl TypedStablePtr for PatternStructParamListPtr {
7392 type SyntaxNode = PatternStructParamList;
7393 fn untyped(&self) -> SyntaxStablePtrId {
7394 self.0
7395 }
7396 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParamList {
7397 PatternStructParamList::from_syntax_node(db, self.0.lookup(db))
7398 }
7399}
7400impl From<PatternStructParamListPtr> for SyntaxStablePtrId {
7401 fn from(ptr: PatternStructParamListPtr) -> Self {
7402 ptr.untyped()
7403 }
7404}
7405#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7406pub enum PatternStructParamListElementOrSeparatorGreen {
7407 Separator(TerminalCommaGreen),
7408 Element(PatternStructParamGreen),
7409}
7410impl From<TerminalCommaGreen> for PatternStructParamListElementOrSeparatorGreen {
7411 fn from(value: TerminalCommaGreen) -> Self {
7412 PatternStructParamListElementOrSeparatorGreen::Separator(value)
7413 }
7414}
7415impl From<PatternStructParamGreen> for PatternStructParamListElementOrSeparatorGreen {
7416 fn from(value: PatternStructParamGreen) -> Self {
7417 PatternStructParamListElementOrSeparatorGreen::Element(value)
7418 }
7419}
7420impl PatternStructParamListElementOrSeparatorGreen {
7421 fn id(&self) -> GreenId {
7422 match self {
7423 PatternStructParamListElementOrSeparatorGreen::Separator(green) => green.0,
7424 PatternStructParamListElementOrSeparatorGreen::Element(green) => green.0,
7425 }
7426 }
7427}
7428#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7429pub struct PatternStructParamListGreen(pub GreenId);
7430impl TypedSyntaxNode for PatternStructParamList {
7431 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStructParamList);
7432 type StablePtr = PatternStructParamListPtr;
7433 type Green = PatternStructParamListGreen;
7434 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7435 PatternStructParamListGreen(
7436 Arc::new(GreenNode {
7437 kind: SyntaxKind::PatternStructParamList,
7438 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
7439 })
7440 .intern(db),
7441 )
7442 }
7443 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7444 Self(ElementList::new(node))
7445 }
7446 fn as_syntax_node(&self) -> SyntaxNode {
7447 self.node.clone()
7448 }
7449 fn stable_ptr(&self) -> Self::StablePtr {
7450 PatternStructParamListPtr(self.node.0.stable_ptr)
7451 }
7452}
7453impl From<&PatternStructParamList> for SyntaxStablePtrId {
7454 fn from(node: &PatternStructParamList) -> Self {
7455 node.stable_ptr().untyped()
7456 }
7457}
7458#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7459pub struct PatternTuple {
7460 node: SyntaxNode,
7461 children: Arc<[SyntaxNode]>,
7462}
7463impl PatternTuple {
7464 pub const INDEX_LPAREN: usize = 0;
7465 pub const INDEX_PATTERNS: usize = 1;
7466 pub const INDEX_RPAREN: usize = 2;
7467 pub fn new_green(
7468 db: &dyn SyntaxGroup,
7469 lparen: TerminalLParenGreen,
7470 patterns: PatternListGreen,
7471 rparen: TerminalRParenGreen,
7472 ) -> PatternTupleGreen {
7473 let children: Vec<GreenId> = vec![lparen.0, patterns.0, rparen.0];
7474 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7475 PatternTupleGreen(
7476 Arc::new(GreenNode {
7477 kind: SyntaxKind::PatternTuple,
7478 details: GreenNodeDetails::Node { children, width },
7479 })
7480 .intern(db),
7481 )
7482 }
7483}
7484impl PatternTuple {
7485 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
7486 TerminalLParen::from_syntax_node(db, self.children[0].clone())
7487 }
7488 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternList {
7489 PatternList::from_syntax_node(db, self.children[1].clone())
7490 }
7491 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
7492 TerminalRParen::from_syntax_node(db, self.children[2].clone())
7493 }
7494}
7495#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7496pub struct PatternTuplePtr(pub SyntaxStablePtrId);
7497impl PatternTuplePtr {}
7498impl TypedStablePtr for PatternTuplePtr {
7499 type SyntaxNode = PatternTuple;
7500 fn untyped(&self) -> SyntaxStablePtrId {
7501 self.0
7502 }
7503 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternTuple {
7504 PatternTuple::from_syntax_node(db, self.0.lookup(db))
7505 }
7506}
7507impl From<PatternTuplePtr> for SyntaxStablePtrId {
7508 fn from(ptr: PatternTuplePtr) -> Self {
7509 ptr.untyped()
7510 }
7511}
7512#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7513pub struct PatternTupleGreen(pub GreenId);
7514impl TypedSyntaxNode for PatternTuple {
7515 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternTuple);
7516 type StablePtr = PatternTuplePtr;
7517 type Green = PatternTupleGreen;
7518 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7519 PatternTupleGreen(
7520 Arc::new(GreenNode {
7521 kind: SyntaxKind::PatternTuple,
7522 details: GreenNodeDetails::Node {
7523 children: vec![
7524 TerminalLParen::missing(db).0,
7525 PatternList::missing(db).0,
7526 TerminalRParen::missing(db).0,
7527 ],
7528 width: TextWidth::default(),
7529 },
7530 })
7531 .intern(db),
7532 )
7533 }
7534 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7535 let kind = node.kind(db);
7536 assert_eq!(
7537 kind,
7538 SyntaxKind::PatternTuple,
7539 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7540 kind,
7541 SyntaxKind::PatternTuple
7542 );
7543 let children = db.get_children(node.clone());
7544 Self { node, children }
7545 }
7546 fn as_syntax_node(&self) -> SyntaxNode {
7547 self.node.clone()
7548 }
7549 fn stable_ptr(&self) -> Self::StablePtr {
7550 PatternTuplePtr(self.node.0.stable_ptr)
7551 }
7552}
7553impl From<&PatternTuple> for SyntaxStablePtrId {
7554 fn from(node: &PatternTuple) -> Self {
7555 node.stable_ptr().untyped()
7556 }
7557}
7558#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7559pub struct PatternFixedSizeArray {
7560 node: SyntaxNode,
7561 children: Arc<[SyntaxNode]>,
7562}
7563impl PatternFixedSizeArray {
7564 pub const INDEX_LBRACK: usize = 0;
7565 pub const INDEX_PATTERNS: usize = 1;
7566 pub const INDEX_RBRACK: usize = 2;
7567 pub fn new_green(
7568 db: &dyn SyntaxGroup,
7569 lbrack: TerminalLBrackGreen,
7570 patterns: PatternListGreen,
7571 rbrack: TerminalRBrackGreen,
7572 ) -> PatternFixedSizeArrayGreen {
7573 let children: Vec<GreenId> = vec![lbrack.0, patterns.0, rbrack.0];
7574 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7575 PatternFixedSizeArrayGreen(
7576 Arc::new(GreenNode {
7577 kind: SyntaxKind::PatternFixedSizeArray,
7578 details: GreenNodeDetails::Node { children, width },
7579 })
7580 .intern(db),
7581 )
7582 }
7583}
7584impl PatternFixedSizeArray {
7585 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
7586 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
7587 }
7588 pub fn patterns(&self, db: &dyn SyntaxGroup) -> PatternList {
7589 PatternList::from_syntax_node(db, self.children[1].clone())
7590 }
7591 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
7592 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
7593 }
7594}
7595#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7596pub struct PatternFixedSizeArrayPtr(pub SyntaxStablePtrId);
7597impl PatternFixedSizeArrayPtr {}
7598impl TypedStablePtr for PatternFixedSizeArrayPtr {
7599 type SyntaxNode = PatternFixedSizeArray;
7600 fn untyped(&self) -> SyntaxStablePtrId {
7601 self.0
7602 }
7603 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternFixedSizeArray {
7604 PatternFixedSizeArray::from_syntax_node(db, self.0.lookup(db))
7605 }
7606}
7607impl From<PatternFixedSizeArrayPtr> for SyntaxStablePtrId {
7608 fn from(ptr: PatternFixedSizeArrayPtr) -> Self {
7609 ptr.untyped()
7610 }
7611}
7612#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7613pub struct PatternFixedSizeArrayGreen(pub GreenId);
7614impl TypedSyntaxNode for PatternFixedSizeArray {
7615 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternFixedSizeArray);
7616 type StablePtr = PatternFixedSizeArrayPtr;
7617 type Green = PatternFixedSizeArrayGreen;
7618 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7619 PatternFixedSizeArrayGreen(
7620 Arc::new(GreenNode {
7621 kind: SyntaxKind::PatternFixedSizeArray,
7622 details: GreenNodeDetails::Node {
7623 children: vec![
7624 TerminalLBrack::missing(db).0,
7625 PatternList::missing(db).0,
7626 TerminalRBrack::missing(db).0,
7627 ],
7628 width: TextWidth::default(),
7629 },
7630 })
7631 .intern(db),
7632 )
7633 }
7634 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7635 let kind = node.kind(db);
7636 assert_eq!(
7637 kind,
7638 SyntaxKind::PatternFixedSizeArray,
7639 "Unexpected SyntaxKind {:?}. Expected {:?}.",
7640 kind,
7641 SyntaxKind::PatternFixedSizeArray
7642 );
7643 let children = db.get_children(node.clone());
7644 Self { node, children }
7645 }
7646 fn as_syntax_node(&self) -> SyntaxNode {
7647 self.node.clone()
7648 }
7649 fn stable_ptr(&self) -> Self::StablePtr {
7650 PatternFixedSizeArrayPtr(self.node.0.stable_ptr)
7651 }
7652}
7653impl From<&PatternFixedSizeArray> for SyntaxStablePtrId {
7654 fn from(node: &PatternFixedSizeArray) -> Self {
7655 node.stable_ptr().untyped()
7656 }
7657}
7658#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7659pub struct PatternList(ElementList<Pattern, 2>);
7660impl Deref for PatternList {
7661 type Target = ElementList<Pattern, 2>;
7662 fn deref(&self) -> &Self::Target {
7663 &self.0
7664 }
7665}
7666impl PatternList {
7667 pub fn new_green(
7668 db: &dyn SyntaxGroup,
7669 children: Vec<PatternListElementOrSeparatorGreen>,
7670 ) -> PatternListGreen {
7671 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
7672 PatternListGreen(
7673 Arc::new(GreenNode {
7674 kind: SyntaxKind::PatternList,
7675 details: GreenNodeDetails::Node {
7676 children: children.iter().map(|x| x.id()).collect(),
7677 width,
7678 },
7679 })
7680 .intern(db),
7681 )
7682 }
7683}
7684#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7685pub struct PatternListPtr(pub SyntaxStablePtrId);
7686impl TypedStablePtr for PatternListPtr {
7687 type SyntaxNode = PatternList;
7688 fn untyped(&self) -> SyntaxStablePtrId {
7689 self.0
7690 }
7691 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternList {
7692 PatternList::from_syntax_node(db, self.0.lookup(db))
7693 }
7694}
7695impl From<PatternListPtr> for SyntaxStablePtrId {
7696 fn from(ptr: PatternListPtr) -> Self {
7697 ptr.untyped()
7698 }
7699}
7700#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7701pub enum PatternListElementOrSeparatorGreen {
7702 Separator(TerminalCommaGreen),
7703 Element(PatternGreen),
7704}
7705impl From<TerminalCommaGreen> for PatternListElementOrSeparatorGreen {
7706 fn from(value: TerminalCommaGreen) -> Self {
7707 PatternListElementOrSeparatorGreen::Separator(value)
7708 }
7709}
7710impl From<PatternGreen> for PatternListElementOrSeparatorGreen {
7711 fn from(value: PatternGreen) -> Self {
7712 PatternListElementOrSeparatorGreen::Element(value)
7713 }
7714}
7715impl PatternListElementOrSeparatorGreen {
7716 fn id(&self) -> GreenId {
7717 match self {
7718 PatternListElementOrSeparatorGreen::Separator(green) => green.0,
7719 PatternListElementOrSeparatorGreen::Element(green) => green.0,
7720 }
7721 }
7722}
7723#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7724pub struct PatternListGreen(pub GreenId);
7725impl TypedSyntaxNode for PatternList {
7726 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternList);
7727 type StablePtr = PatternListPtr;
7728 type Green = PatternListGreen;
7729 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7730 PatternListGreen(
7731 Arc::new(GreenNode {
7732 kind: SyntaxKind::PatternList,
7733 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
7734 })
7735 .intern(db),
7736 )
7737 }
7738 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7739 Self(ElementList::new(node))
7740 }
7741 fn as_syntax_node(&self) -> SyntaxNode {
7742 self.node.clone()
7743 }
7744 fn stable_ptr(&self) -> Self::StablePtr {
7745 PatternListPtr(self.node.0.stable_ptr)
7746 }
7747}
7748impl From<&PatternList> for SyntaxStablePtrId {
7749 fn from(node: &PatternList) -> Self {
7750 node.stable_ptr().untyped()
7751 }
7752}
7753#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7754pub struct PatternListOr(ElementList<Pattern, 2>);
7755impl Deref for PatternListOr {
7756 type Target = ElementList<Pattern, 2>;
7757 fn deref(&self) -> &Self::Target {
7758 &self.0
7759 }
7760}
7761impl PatternListOr {
7762 pub fn new_green(
7763 db: &dyn SyntaxGroup,
7764 children: Vec<PatternListOrElementOrSeparatorGreen>,
7765 ) -> PatternListOrGreen {
7766 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
7767 PatternListOrGreen(
7768 Arc::new(GreenNode {
7769 kind: SyntaxKind::PatternListOr,
7770 details: GreenNodeDetails::Node {
7771 children: children.iter().map(|x| x.id()).collect(),
7772 width,
7773 },
7774 })
7775 .intern(db),
7776 )
7777 }
7778}
7779#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7780pub struct PatternListOrPtr(pub SyntaxStablePtrId);
7781impl TypedStablePtr for PatternListOrPtr {
7782 type SyntaxNode = PatternListOr;
7783 fn untyped(&self) -> SyntaxStablePtrId {
7784 self.0
7785 }
7786 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternListOr {
7787 PatternListOr::from_syntax_node(db, self.0.lookup(db))
7788 }
7789}
7790impl From<PatternListOrPtr> for SyntaxStablePtrId {
7791 fn from(ptr: PatternListOrPtr) -> Self {
7792 ptr.untyped()
7793 }
7794}
7795#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7796pub enum PatternListOrElementOrSeparatorGreen {
7797 Separator(TerminalOrGreen),
7798 Element(PatternGreen),
7799}
7800impl From<TerminalOrGreen> for PatternListOrElementOrSeparatorGreen {
7801 fn from(value: TerminalOrGreen) -> Self {
7802 PatternListOrElementOrSeparatorGreen::Separator(value)
7803 }
7804}
7805impl From<PatternGreen> for PatternListOrElementOrSeparatorGreen {
7806 fn from(value: PatternGreen) -> Self {
7807 PatternListOrElementOrSeparatorGreen::Element(value)
7808 }
7809}
7810impl PatternListOrElementOrSeparatorGreen {
7811 fn id(&self) -> GreenId {
7812 match self {
7813 PatternListOrElementOrSeparatorGreen::Separator(green) => green.0,
7814 PatternListOrElementOrSeparatorGreen::Element(green) => green.0,
7815 }
7816 }
7817}
7818#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7819pub struct PatternListOrGreen(pub GreenId);
7820impl TypedSyntaxNode for PatternListOr {
7821 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternListOr);
7822 type StablePtr = PatternListOrPtr;
7823 type Green = PatternListOrGreen;
7824 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7825 PatternListOrGreen(
7826 Arc::new(GreenNode {
7827 kind: SyntaxKind::PatternListOr,
7828 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
7829 })
7830 .intern(db),
7831 )
7832 }
7833 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7834 Self(ElementList::new(node))
7835 }
7836 fn as_syntax_node(&self) -> SyntaxNode {
7837 self.node.clone()
7838 }
7839 fn stable_ptr(&self) -> Self::StablePtr {
7840 PatternListOrPtr(self.node.0.stable_ptr)
7841 }
7842}
7843impl From<&PatternListOr> for SyntaxStablePtrId {
7844 fn from(node: &PatternListOr) -> Self {
7845 node.stable_ptr().untyped()
7846 }
7847}
7848#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7849pub enum PatternStructParam {
7850 Single(PatternIdentifier),
7851 WithExpr(PatternStructParamWithExpr),
7852 Tail(TerminalDotDot),
7853}
7854#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7855pub struct PatternStructParamPtr(pub SyntaxStablePtrId);
7856impl TypedStablePtr for PatternStructParamPtr {
7857 type SyntaxNode = PatternStructParam;
7858 fn untyped(&self) -> SyntaxStablePtrId {
7859 self.0
7860 }
7861 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParam {
7862 PatternStructParam::from_syntax_node(db, self.0.lookup(db))
7863 }
7864}
7865impl From<PatternStructParamPtr> for SyntaxStablePtrId {
7866 fn from(ptr: PatternStructParamPtr) -> Self {
7867 ptr.untyped()
7868 }
7869}
7870impl From<PatternIdentifierPtr> for PatternStructParamPtr {
7871 fn from(value: PatternIdentifierPtr) -> Self {
7872 Self(value.0)
7873 }
7874}
7875impl From<PatternStructParamWithExprPtr> for PatternStructParamPtr {
7876 fn from(value: PatternStructParamWithExprPtr) -> Self {
7877 Self(value.0)
7878 }
7879}
7880impl From<TerminalDotDotPtr> for PatternStructParamPtr {
7881 fn from(value: TerminalDotDotPtr) -> Self {
7882 Self(value.0)
7883 }
7884}
7885impl From<PatternIdentifierGreen> for PatternStructParamGreen {
7886 fn from(value: PatternIdentifierGreen) -> Self {
7887 Self(value.0)
7888 }
7889}
7890impl From<PatternStructParamWithExprGreen> for PatternStructParamGreen {
7891 fn from(value: PatternStructParamWithExprGreen) -> Self {
7892 Self(value.0)
7893 }
7894}
7895impl From<TerminalDotDotGreen> for PatternStructParamGreen {
7896 fn from(value: TerminalDotDotGreen) -> Self {
7897 Self(value.0)
7898 }
7899}
7900#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7901pub struct PatternStructParamGreen(pub GreenId);
7902impl TypedSyntaxNode for PatternStructParam {
7903 const OPTIONAL_KIND: Option<SyntaxKind> = None;
7904 type StablePtr = PatternStructParamPtr;
7905 type Green = PatternStructParamGreen;
7906 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
7907 panic!("No missing variant.");
7908 }
7909 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
7910 let kind = node.kind(db);
7911 match kind {
7912 SyntaxKind::PatternIdentifier => {
7913 PatternStructParam::Single(PatternIdentifier::from_syntax_node(db, node))
7914 }
7915 SyntaxKind::PatternStructParamWithExpr => {
7916 PatternStructParam::WithExpr(PatternStructParamWithExpr::from_syntax_node(db, node))
7917 }
7918 SyntaxKind::TerminalDotDot => {
7919 PatternStructParam::Tail(TerminalDotDot::from_syntax_node(db, node))
7920 }
7921 _ => panic!(
7922 "Unexpected syntax kind {:?} when constructing {}.",
7923 kind, "PatternStructParam"
7924 ),
7925 }
7926 }
7927 fn as_syntax_node(&self) -> SyntaxNode {
7928 match self {
7929 PatternStructParam::Single(x) => x.as_syntax_node(),
7930 PatternStructParam::WithExpr(x) => x.as_syntax_node(),
7931 PatternStructParam::Tail(x) => x.as_syntax_node(),
7932 }
7933 }
7934 fn stable_ptr(&self) -> Self::StablePtr {
7935 PatternStructParamPtr(self.as_syntax_node().0.stable_ptr)
7936 }
7937}
7938impl From<&PatternStructParam> for SyntaxStablePtrId {
7939 fn from(node: &PatternStructParam) -> Self {
7940 node.stable_ptr().untyped()
7941 }
7942}
7943impl PatternStructParam {
7944 pub fn is_variant(kind: SyntaxKind) -> bool {
7946 matches!(
7947 kind,
7948 SyntaxKind::PatternIdentifier
7949 | SyntaxKind::PatternStructParamWithExpr
7950 | SyntaxKind::TerminalDotDot
7951 )
7952 }
7953}
7954#[derive(Clone, Debug, Eq, Hash, PartialEq)]
7955pub struct PatternStructParamWithExpr {
7956 node: SyntaxNode,
7957 children: Arc<[SyntaxNode]>,
7958}
7959impl PatternStructParamWithExpr {
7960 pub const INDEX_MODIFIERS: usize = 0;
7961 pub const INDEX_NAME: usize = 1;
7962 pub const INDEX_COLON: usize = 2;
7963 pub const INDEX_PATTERN: usize = 3;
7964 pub fn new_green(
7965 db: &dyn SyntaxGroup,
7966 modifiers: ModifierListGreen,
7967 name: TerminalIdentifierGreen,
7968 colon: TerminalColonGreen,
7969 pattern: PatternGreen,
7970 ) -> PatternStructParamWithExprGreen {
7971 let children: Vec<GreenId> = vec![modifiers.0, name.0, colon.0, pattern.0];
7972 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
7973 PatternStructParamWithExprGreen(
7974 Arc::new(GreenNode {
7975 kind: SyntaxKind::PatternStructParamWithExpr,
7976 details: GreenNodeDetails::Node { children, width },
7977 })
7978 .intern(db),
7979 )
7980 }
7981}
7982impl PatternStructParamWithExpr {
7983 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
7984 ModifierList::from_syntax_node(db, self.children[0].clone())
7985 }
7986 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
7987 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
7988 }
7989 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
7990 TerminalColon::from_syntax_node(db, self.children[2].clone())
7991 }
7992 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
7993 Pattern::from_syntax_node(db, self.children[3].clone())
7994 }
7995}
7996#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
7997pub struct PatternStructParamWithExprPtr(pub SyntaxStablePtrId);
7998impl PatternStructParamWithExprPtr {}
7999impl TypedStablePtr for PatternStructParamWithExprPtr {
8000 type SyntaxNode = PatternStructParamWithExpr;
8001 fn untyped(&self) -> SyntaxStablePtrId {
8002 self.0
8003 }
8004 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternStructParamWithExpr {
8005 PatternStructParamWithExpr::from_syntax_node(db, self.0.lookup(db))
8006 }
8007}
8008impl From<PatternStructParamWithExprPtr> for SyntaxStablePtrId {
8009 fn from(ptr: PatternStructParamWithExprPtr) -> Self {
8010 ptr.untyped()
8011 }
8012}
8013#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8014pub struct PatternStructParamWithExprGreen(pub GreenId);
8015impl TypedSyntaxNode for PatternStructParamWithExpr {
8016 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternStructParamWithExpr);
8017 type StablePtr = PatternStructParamWithExprPtr;
8018 type Green = PatternStructParamWithExprGreen;
8019 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8020 PatternStructParamWithExprGreen(
8021 Arc::new(GreenNode {
8022 kind: SyntaxKind::PatternStructParamWithExpr,
8023 details: GreenNodeDetails::Node {
8024 children: vec![
8025 ModifierList::missing(db).0,
8026 TerminalIdentifier::missing(db).0,
8027 TerminalColon::missing(db).0,
8028 Pattern::missing(db).0,
8029 ],
8030 width: TextWidth::default(),
8031 },
8032 })
8033 .intern(db),
8034 )
8035 }
8036 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8037 let kind = node.kind(db);
8038 assert_eq!(
8039 kind,
8040 SyntaxKind::PatternStructParamWithExpr,
8041 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8042 kind,
8043 SyntaxKind::PatternStructParamWithExpr
8044 );
8045 let children = db.get_children(node.clone());
8046 Self { node, children }
8047 }
8048 fn as_syntax_node(&self) -> SyntaxNode {
8049 self.node.clone()
8050 }
8051 fn stable_ptr(&self) -> Self::StablePtr {
8052 PatternStructParamWithExprPtr(self.node.0.stable_ptr)
8053 }
8054}
8055impl From<&PatternStructParamWithExpr> for SyntaxStablePtrId {
8056 fn from(node: &PatternStructParamWithExpr) -> Self {
8057 node.stable_ptr().untyped()
8058 }
8059}
8060#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8061pub struct PatternEnum {
8062 node: SyntaxNode,
8063 children: Arc<[SyntaxNode]>,
8064}
8065impl PatternEnum {
8066 pub const INDEX_PATH: usize = 0;
8067 pub const INDEX_PATTERN: usize = 1;
8068 pub fn new_green(
8069 db: &dyn SyntaxGroup,
8070 path: ExprPathGreen,
8071 pattern: OptionPatternEnumInnerPatternGreen,
8072 ) -> PatternEnumGreen {
8073 let children: Vec<GreenId> = vec![path.0, pattern.0];
8074 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8075 PatternEnumGreen(
8076 Arc::new(GreenNode {
8077 kind: SyntaxKind::PatternEnum,
8078 details: GreenNodeDetails::Node { children, width },
8079 })
8080 .intern(db),
8081 )
8082 }
8083}
8084impl PatternEnum {
8085 pub fn path(&self, db: &dyn SyntaxGroup) -> ExprPath {
8086 ExprPath::from_syntax_node(db, self.children[0].clone())
8087 }
8088 pub fn pattern(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPattern {
8089 OptionPatternEnumInnerPattern::from_syntax_node(db, self.children[1].clone())
8090 }
8091}
8092#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8093pub struct PatternEnumPtr(pub SyntaxStablePtrId);
8094impl PatternEnumPtr {}
8095impl TypedStablePtr for PatternEnumPtr {
8096 type SyntaxNode = PatternEnum;
8097 fn untyped(&self) -> SyntaxStablePtrId {
8098 self.0
8099 }
8100 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternEnum {
8101 PatternEnum::from_syntax_node(db, self.0.lookup(db))
8102 }
8103}
8104impl From<PatternEnumPtr> for SyntaxStablePtrId {
8105 fn from(ptr: PatternEnumPtr) -> Self {
8106 ptr.untyped()
8107 }
8108}
8109#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8110pub struct PatternEnumGreen(pub GreenId);
8111impl TypedSyntaxNode for PatternEnum {
8112 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternEnum);
8113 type StablePtr = PatternEnumPtr;
8114 type Green = PatternEnumGreen;
8115 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8116 PatternEnumGreen(
8117 Arc::new(GreenNode {
8118 kind: SyntaxKind::PatternEnum,
8119 details: GreenNodeDetails::Node {
8120 children: vec![
8121 ExprPath::missing(db).0,
8122 OptionPatternEnumInnerPattern::missing(db).0,
8123 ],
8124 width: TextWidth::default(),
8125 },
8126 })
8127 .intern(db),
8128 )
8129 }
8130 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8131 let kind = node.kind(db);
8132 assert_eq!(
8133 kind,
8134 SyntaxKind::PatternEnum,
8135 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8136 kind,
8137 SyntaxKind::PatternEnum
8138 );
8139 let children = db.get_children(node.clone());
8140 Self { node, children }
8141 }
8142 fn as_syntax_node(&self) -> SyntaxNode {
8143 self.node.clone()
8144 }
8145 fn stable_ptr(&self) -> Self::StablePtr {
8146 PatternEnumPtr(self.node.0.stable_ptr)
8147 }
8148}
8149impl From<&PatternEnum> for SyntaxStablePtrId {
8150 fn from(node: &PatternEnum) -> Self {
8151 node.stable_ptr().untyped()
8152 }
8153}
8154#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8155pub struct PatternEnumInnerPattern {
8156 node: SyntaxNode,
8157 children: Arc<[SyntaxNode]>,
8158}
8159impl PatternEnumInnerPattern {
8160 pub const INDEX_LPAREN: usize = 0;
8161 pub const INDEX_PATTERN: usize = 1;
8162 pub const INDEX_RPAREN: usize = 2;
8163 pub fn new_green(
8164 db: &dyn SyntaxGroup,
8165 lparen: TerminalLParenGreen,
8166 pattern: PatternGreen,
8167 rparen: TerminalRParenGreen,
8168 ) -> PatternEnumInnerPatternGreen {
8169 let children: Vec<GreenId> = vec![lparen.0, pattern.0, rparen.0];
8170 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8171 PatternEnumInnerPatternGreen(
8172 Arc::new(GreenNode {
8173 kind: SyntaxKind::PatternEnumInnerPattern,
8174 details: GreenNodeDetails::Node { children, width },
8175 })
8176 .intern(db),
8177 )
8178 }
8179}
8180impl PatternEnumInnerPattern {
8181 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
8182 TerminalLParen::from_syntax_node(db, self.children[0].clone())
8183 }
8184 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
8185 Pattern::from_syntax_node(db, self.children[1].clone())
8186 }
8187 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
8188 TerminalRParen::from_syntax_node(db, self.children[2].clone())
8189 }
8190}
8191#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8192pub struct PatternEnumInnerPatternPtr(pub SyntaxStablePtrId);
8193impl PatternEnumInnerPatternPtr {}
8194impl TypedStablePtr for PatternEnumInnerPatternPtr {
8195 type SyntaxNode = PatternEnumInnerPattern;
8196 fn untyped(&self) -> SyntaxStablePtrId {
8197 self.0
8198 }
8199 fn lookup(&self, db: &dyn SyntaxGroup) -> PatternEnumInnerPattern {
8200 PatternEnumInnerPattern::from_syntax_node(db, self.0.lookup(db))
8201 }
8202}
8203impl From<PatternEnumInnerPatternPtr> for SyntaxStablePtrId {
8204 fn from(ptr: PatternEnumInnerPatternPtr) -> Self {
8205 ptr.untyped()
8206 }
8207}
8208#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8209pub struct PatternEnumInnerPatternGreen(pub GreenId);
8210impl TypedSyntaxNode for PatternEnumInnerPattern {
8211 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::PatternEnumInnerPattern);
8212 type StablePtr = PatternEnumInnerPatternPtr;
8213 type Green = PatternEnumInnerPatternGreen;
8214 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8215 PatternEnumInnerPatternGreen(
8216 Arc::new(GreenNode {
8217 kind: SyntaxKind::PatternEnumInnerPattern,
8218 details: GreenNodeDetails::Node {
8219 children: vec![
8220 TerminalLParen::missing(db).0,
8221 Pattern::missing(db).0,
8222 TerminalRParen::missing(db).0,
8223 ],
8224 width: TextWidth::default(),
8225 },
8226 })
8227 .intern(db),
8228 )
8229 }
8230 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8231 let kind = node.kind(db);
8232 assert_eq!(
8233 kind,
8234 SyntaxKind::PatternEnumInnerPattern,
8235 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8236 kind,
8237 SyntaxKind::PatternEnumInnerPattern
8238 );
8239 let children = db.get_children(node.clone());
8240 Self { node, children }
8241 }
8242 fn as_syntax_node(&self) -> SyntaxNode {
8243 self.node.clone()
8244 }
8245 fn stable_ptr(&self) -> Self::StablePtr {
8246 PatternEnumInnerPatternPtr(self.node.0.stable_ptr)
8247 }
8248}
8249impl From<&PatternEnumInnerPattern> for SyntaxStablePtrId {
8250 fn from(node: &PatternEnumInnerPattern) -> Self {
8251 node.stable_ptr().untyped()
8252 }
8253}
8254#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8255pub enum OptionPatternEnumInnerPattern {
8256 Empty(OptionPatternEnumInnerPatternEmpty),
8257 PatternEnumInnerPattern(PatternEnumInnerPattern),
8258}
8259#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8260pub struct OptionPatternEnumInnerPatternPtr(pub SyntaxStablePtrId);
8261impl TypedStablePtr for OptionPatternEnumInnerPatternPtr {
8262 type SyntaxNode = OptionPatternEnumInnerPattern;
8263 fn untyped(&self) -> SyntaxStablePtrId {
8264 self.0
8265 }
8266 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPattern {
8267 OptionPatternEnumInnerPattern::from_syntax_node(db, self.0.lookup(db))
8268 }
8269}
8270impl From<OptionPatternEnumInnerPatternPtr> for SyntaxStablePtrId {
8271 fn from(ptr: OptionPatternEnumInnerPatternPtr) -> Self {
8272 ptr.untyped()
8273 }
8274}
8275impl From<OptionPatternEnumInnerPatternEmptyPtr> for OptionPatternEnumInnerPatternPtr {
8276 fn from(value: OptionPatternEnumInnerPatternEmptyPtr) -> Self {
8277 Self(value.0)
8278 }
8279}
8280impl From<PatternEnumInnerPatternPtr> for OptionPatternEnumInnerPatternPtr {
8281 fn from(value: PatternEnumInnerPatternPtr) -> Self {
8282 Self(value.0)
8283 }
8284}
8285impl From<OptionPatternEnumInnerPatternEmptyGreen> for OptionPatternEnumInnerPatternGreen {
8286 fn from(value: OptionPatternEnumInnerPatternEmptyGreen) -> Self {
8287 Self(value.0)
8288 }
8289}
8290impl From<PatternEnumInnerPatternGreen> for OptionPatternEnumInnerPatternGreen {
8291 fn from(value: PatternEnumInnerPatternGreen) -> Self {
8292 Self(value.0)
8293 }
8294}
8295#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8296pub struct OptionPatternEnumInnerPatternGreen(pub GreenId);
8297impl TypedSyntaxNode for OptionPatternEnumInnerPattern {
8298 const OPTIONAL_KIND: Option<SyntaxKind> = None;
8299 type StablePtr = OptionPatternEnumInnerPatternPtr;
8300 type Green = OptionPatternEnumInnerPatternGreen;
8301 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8302 panic!("No missing variant.");
8303 }
8304 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8305 let kind = node.kind(db);
8306 match kind {
8307 SyntaxKind::OptionPatternEnumInnerPatternEmpty => OptionPatternEnumInnerPattern::Empty(
8308 OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, node),
8309 ),
8310 SyntaxKind::PatternEnumInnerPattern => {
8311 OptionPatternEnumInnerPattern::PatternEnumInnerPattern(
8312 PatternEnumInnerPattern::from_syntax_node(db, node),
8313 )
8314 }
8315 _ => panic!(
8316 "Unexpected syntax kind {:?} when constructing {}.",
8317 kind, "OptionPatternEnumInnerPattern"
8318 ),
8319 }
8320 }
8321 fn as_syntax_node(&self) -> SyntaxNode {
8322 match self {
8323 OptionPatternEnumInnerPattern::Empty(x) => x.as_syntax_node(),
8324 OptionPatternEnumInnerPattern::PatternEnumInnerPattern(x) => x.as_syntax_node(),
8325 }
8326 }
8327 fn stable_ptr(&self) -> Self::StablePtr {
8328 OptionPatternEnumInnerPatternPtr(self.as_syntax_node().0.stable_ptr)
8329 }
8330}
8331impl From<&OptionPatternEnumInnerPattern> for SyntaxStablePtrId {
8332 fn from(node: &OptionPatternEnumInnerPattern) -> Self {
8333 node.stable_ptr().untyped()
8334 }
8335}
8336impl OptionPatternEnumInnerPattern {
8337 pub fn is_variant(kind: SyntaxKind) -> bool {
8339 matches!(
8340 kind,
8341 SyntaxKind::OptionPatternEnumInnerPatternEmpty | SyntaxKind::PatternEnumInnerPattern
8342 )
8343 }
8344}
8345#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8346pub struct OptionPatternEnumInnerPatternEmpty {
8347 node: SyntaxNode,
8348 children: Arc<[SyntaxNode]>,
8349}
8350impl OptionPatternEnumInnerPatternEmpty {
8351 pub fn new_green(db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPatternEmptyGreen {
8352 let children: Vec<GreenId> = vec![];
8353 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8354 OptionPatternEnumInnerPatternEmptyGreen(
8355 Arc::new(GreenNode {
8356 kind: SyntaxKind::OptionPatternEnumInnerPatternEmpty,
8357 details: GreenNodeDetails::Node { children, width },
8358 })
8359 .intern(db),
8360 )
8361 }
8362}
8363impl OptionPatternEnumInnerPatternEmpty {}
8364#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8365pub struct OptionPatternEnumInnerPatternEmptyPtr(pub SyntaxStablePtrId);
8366impl OptionPatternEnumInnerPatternEmptyPtr {}
8367impl TypedStablePtr for OptionPatternEnumInnerPatternEmptyPtr {
8368 type SyntaxNode = OptionPatternEnumInnerPatternEmpty;
8369 fn untyped(&self) -> SyntaxStablePtrId {
8370 self.0
8371 }
8372 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionPatternEnumInnerPatternEmpty {
8373 OptionPatternEnumInnerPatternEmpty::from_syntax_node(db, self.0.lookup(db))
8374 }
8375}
8376impl From<OptionPatternEnumInnerPatternEmptyPtr> for SyntaxStablePtrId {
8377 fn from(ptr: OptionPatternEnumInnerPatternEmptyPtr) -> Self {
8378 ptr.untyped()
8379 }
8380}
8381#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8382pub struct OptionPatternEnumInnerPatternEmptyGreen(pub GreenId);
8383impl TypedSyntaxNode for OptionPatternEnumInnerPatternEmpty {
8384 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionPatternEnumInnerPatternEmpty);
8385 type StablePtr = OptionPatternEnumInnerPatternEmptyPtr;
8386 type Green = OptionPatternEnumInnerPatternEmptyGreen;
8387 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8388 OptionPatternEnumInnerPatternEmptyGreen(
8389 Arc::new(GreenNode {
8390 kind: SyntaxKind::OptionPatternEnumInnerPatternEmpty,
8391 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8392 })
8393 .intern(db),
8394 )
8395 }
8396 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8397 let kind = node.kind(db);
8398 assert_eq!(
8399 kind,
8400 SyntaxKind::OptionPatternEnumInnerPatternEmpty,
8401 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8402 kind,
8403 SyntaxKind::OptionPatternEnumInnerPatternEmpty
8404 );
8405 let children = db.get_children(node.clone());
8406 Self { node, children }
8407 }
8408 fn as_syntax_node(&self) -> SyntaxNode {
8409 self.node.clone()
8410 }
8411 fn stable_ptr(&self) -> Self::StablePtr {
8412 OptionPatternEnumInnerPatternEmptyPtr(self.node.0.stable_ptr)
8413 }
8414}
8415impl From<&OptionPatternEnumInnerPatternEmpty> for SyntaxStablePtrId {
8416 fn from(node: &OptionPatternEnumInnerPatternEmpty) -> Self {
8417 node.stable_ptr().untyped()
8418 }
8419}
8420#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8421pub struct TypeClause {
8422 node: SyntaxNode,
8423 children: Arc<[SyntaxNode]>,
8424}
8425impl TypeClause {
8426 pub const INDEX_COLON: usize = 0;
8427 pub const INDEX_TY: usize = 1;
8428 pub fn new_green(
8429 db: &dyn SyntaxGroup,
8430 colon: TerminalColonGreen,
8431 ty: ExprGreen,
8432 ) -> TypeClauseGreen {
8433 let children: Vec<GreenId> = vec![colon.0, ty.0];
8434 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8435 TypeClauseGreen(
8436 Arc::new(GreenNode {
8437 kind: SyntaxKind::TypeClause,
8438 details: GreenNodeDetails::Node { children, width },
8439 })
8440 .intern(db),
8441 )
8442 }
8443}
8444impl TypeClause {
8445 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
8446 TerminalColon::from_syntax_node(db, self.children[0].clone())
8447 }
8448 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
8449 Expr::from_syntax_node(db, self.children[1].clone())
8450 }
8451}
8452#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8453pub struct TypeClausePtr(pub SyntaxStablePtrId);
8454impl TypeClausePtr {}
8455impl TypedStablePtr for TypeClausePtr {
8456 type SyntaxNode = TypeClause;
8457 fn untyped(&self) -> SyntaxStablePtrId {
8458 self.0
8459 }
8460 fn lookup(&self, db: &dyn SyntaxGroup) -> TypeClause {
8461 TypeClause::from_syntax_node(db, self.0.lookup(db))
8462 }
8463}
8464impl From<TypeClausePtr> for SyntaxStablePtrId {
8465 fn from(ptr: TypeClausePtr) -> Self {
8466 ptr.untyped()
8467 }
8468}
8469#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8470pub struct TypeClauseGreen(pub GreenId);
8471impl TypedSyntaxNode for TypeClause {
8472 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TypeClause);
8473 type StablePtr = TypeClausePtr;
8474 type Green = TypeClauseGreen;
8475 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8476 TypeClauseGreen(
8477 Arc::new(GreenNode {
8478 kind: SyntaxKind::TypeClause,
8479 details: GreenNodeDetails::Node {
8480 children: vec![TerminalColon::missing(db).0, Expr::missing(db).0],
8481 width: TextWidth::default(),
8482 },
8483 })
8484 .intern(db),
8485 )
8486 }
8487 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8488 let kind = node.kind(db);
8489 assert_eq!(
8490 kind,
8491 SyntaxKind::TypeClause,
8492 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8493 kind,
8494 SyntaxKind::TypeClause
8495 );
8496 let children = db.get_children(node.clone());
8497 Self { node, children }
8498 }
8499 fn as_syntax_node(&self) -> SyntaxNode {
8500 self.node.clone()
8501 }
8502 fn stable_ptr(&self) -> Self::StablePtr {
8503 TypeClausePtr(self.node.0.stable_ptr)
8504 }
8505}
8506impl From<&TypeClause> for SyntaxStablePtrId {
8507 fn from(node: &TypeClause) -> Self {
8508 node.stable_ptr().untyped()
8509 }
8510}
8511#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8512pub enum OptionTypeClause {
8513 Empty(OptionTypeClauseEmpty),
8514 TypeClause(TypeClause),
8515}
8516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8517pub struct OptionTypeClausePtr(pub SyntaxStablePtrId);
8518impl TypedStablePtr for OptionTypeClausePtr {
8519 type SyntaxNode = OptionTypeClause;
8520 fn untyped(&self) -> SyntaxStablePtrId {
8521 self.0
8522 }
8523 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
8524 OptionTypeClause::from_syntax_node(db, self.0.lookup(db))
8525 }
8526}
8527impl From<OptionTypeClausePtr> for SyntaxStablePtrId {
8528 fn from(ptr: OptionTypeClausePtr) -> Self {
8529 ptr.untyped()
8530 }
8531}
8532impl From<OptionTypeClauseEmptyPtr> for OptionTypeClausePtr {
8533 fn from(value: OptionTypeClauseEmptyPtr) -> Self {
8534 Self(value.0)
8535 }
8536}
8537impl From<TypeClausePtr> for OptionTypeClausePtr {
8538 fn from(value: TypeClausePtr) -> Self {
8539 Self(value.0)
8540 }
8541}
8542impl From<OptionTypeClauseEmptyGreen> for OptionTypeClauseGreen {
8543 fn from(value: OptionTypeClauseEmptyGreen) -> Self {
8544 Self(value.0)
8545 }
8546}
8547impl From<TypeClauseGreen> for OptionTypeClauseGreen {
8548 fn from(value: TypeClauseGreen) -> Self {
8549 Self(value.0)
8550 }
8551}
8552#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8553pub struct OptionTypeClauseGreen(pub GreenId);
8554impl TypedSyntaxNode for OptionTypeClause {
8555 const OPTIONAL_KIND: Option<SyntaxKind> = None;
8556 type StablePtr = OptionTypeClausePtr;
8557 type Green = OptionTypeClauseGreen;
8558 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8559 panic!("No missing variant.");
8560 }
8561 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8562 let kind = node.kind(db);
8563 match kind {
8564 SyntaxKind::OptionTypeClauseEmpty => {
8565 OptionTypeClause::Empty(OptionTypeClauseEmpty::from_syntax_node(db, node))
8566 }
8567 SyntaxKind::TypeClause => {
8568 OptionTypeClause::TypeClause(TypeClause::from_syntax_node(db, node))
8569 }
8570 _ => panic!(
8571 "Unexpected syntax kind {:?} when constructing {}.",
8572 kind, "OptionTypeClause"
8573 ),
8574 }
8575 }
8576 fn as_syntax_node(&self) -> SyntaxNode {
8577 match self {
8578 OptionTypeClause::Empty(x) => x.as_syntax_node(),
8579 OptionTypeClause::TypeClause(x) => x.as_syntax_node(),
8580 }
8581 }
8582 fn stable_ptr(&self) -> Self::StablePtr {
8583 OptionTypeClausePtr(self.as_syntax_node().0.stable_ptr)
8584 }
8585}
8586impl From<&OptionTypeClause> for SyntaxStablePtrId {
8587 fn from(node: &OptionTypeClause) -> Self {
8588 node.stable_ptr().untyped()
8589 }
8590}
8591impl OptionTypeClause {
8592 pub fn is_variant(kind: SyntaxKind) -> bool {
8594 matches!(kind, SyntaxKind::OptionTypeClauseEmpty | SyntaxKind::TypeClause)
8595 }
8596}
8597#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8598pub struct OptionTypeClauseEmpty {
8599 node: SyntaxNode,
8600 children: Arc<[SyntaxNode]>,
8601}
8602impl OptionTypeClauseEmpty {
8603 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTypeClauseEmptyGreen {
8604 let children: Vec<GreenId> = vec![];
8605 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8606 OptionTypeClauseEmptyGreen(
8607 Arc::new(GreenNode {
8608 kind: SyntaxKind::OptionTypeClauseEmpty,
8609 details: GreenNodeDetails::Node { children, width },
8610 })
8611 .intern(db),
8612 )
8613 }
8614}
8615impl OptionTypeClauseEmpty {}
8616#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8617pub struct OptionTypeClauseEmptyPtr(pub SyntaxStablePtrId);
8618impl OptionTypeClauseEmptyPtr {}
8619impl TypedStablePtr for OptionTypeClauseEmptyPtr {
8620 type SyntaxNode = OptionTypeClauseEmpty;
8621 fn untyped(&self) -> SyntaxStablePtrId {
8622 self.0
8623 }
8624 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTypeClauseEmpty {
8625 OptionTypeClauseEmpty::from_syntax_node(db, self.0.lookup(db))
8626 }
8627}
8628impl From<OptionTypeClauseEmptyPtr> for SyntaxStablePtrId {
8629 fn from(ptr: OptionTypeClauseEmptyPtr) -> Self {
8630 ptr.untyped()
8631 }
8632}
8633#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8634pub struct OptionTypeClauseEmptyGreen(pub GreenId);
8635impl TypedSyntaxNode for OptionTypeClauseEmpty {
8636 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTypeClauseEmpty);
8637 type StablePtr = OptionTypeClauseEmptyPtr;
8638 type Green = OptionTypeClauseEmptyGreen;
8639 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8640 OptionTypeClauseEmptyGreen(
8641 Arc::new(GreenNode {
8642 kind: SyntaxKind::OptionTypeClauseEmpty,
8643 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8644 })
8645 .intern(db),
8646 )
8647 }
8648 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8649 let kind = node.kind(db);
8650 assert_eq!(
8651 kind,
8652 SyntaxKind::OptionTypeClauseEmpty,
8653 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8654 kind,
8655 SyntaxKind::OptionTypeClauseEmpty
8656 );
8657 let children = db.get_children(node.clone());
8658 Self { node, children }
8659 }
8660 fn as_syntax_node(&self) -> SyntaxNode {
8661 self.node.clone()
8662 }
8663 fn stable_ptr(&self) -> Self::StablePtr {
8664 OptionTypeClauseEmptyPtr(self.node.0.stable_ptr)
8665 }
8666}
8667impl From<&OptionTypeClauseEmpty> for SyntaxStablePtrId {
8668 fn from(node: &OptionTypeClauseEmpty) -> Self {
8669 node.stable_ptr().untyped()
8670 }
8671}
8672#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8673pub struct ReturnTypeClause {
8674 node: SyntaxNode,
8675 children: Arc<[SyntaxNode]>,
8676}
8677impl ReturnTypeClause {
8678 pub const INDEX_ARROW: usize = 0;
8679 pub const INDEX_TY: usize = 1;
8680 pub fn new_green(
8681 db: &dyn SyntaxGroup,
8682 arrow: TerminalArrowGreen,
8683 ty: ExprGreen,
8684 ) -> ReturnTypeClauseGreen {
8685 let children: Vec<GreenId> = vec![arrow.0, ty.0];
8686 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8687 ReturnTypeClauseGreen(
8688 Arc::new(GreenNode {
8689 kind: SyntaxKind::ReturnTypeClause,
8690 details: GreenNodeDetails::Node { children, width },
8691 })
8692 .intern(db),
8693 )
8694 }
8695}
8696impl ReturnTypeClause {
8697 pub fn arrow(&self, db: &dyn SyntaxGroup) -> TerminalArrow {
8698 TerminalArrow::from_syntax_node(db, self.children[0].clone())
8699 }
8700 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
8701 Expr::from_syntax_node(db, self.children[1].clone())
8702 }
8703}
8704#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8705pub struct ReturnTypeClausePtr(pub SyntaxStablePtrId);
8706impl ReturnTypeClausePtr {}
8707impl TypedStablePtr for ReturnTypeClausePtr {
8708 type SyntaxNode = ReturnTypeClause;
8709 fn untyped(&self) -> SyntaxStablePtrId {
8710 self.0
8711 }
8712 fn lookup(&self, db: &dyn SyntaxGroup) -> ReturnTypeClause {
8713 ReturnTypeClause::from_syntax_node(db, self.0.lookup(db))
8714 }
8715}
8716impl From<ReturnTypeClausePtr> for SyntaxStablePtrId {
8717 fn from(ptr: ReturnTypeClausePtr) -> Self {
8718 ptr.untyped()
8719 }
8720}
8721#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8722pub struct ReturnTypeClauseGreen(pub GreenId);
8723impl TypedSyntaxNode for ReturnTypeClause {
8724 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ReturnTypeClause);
8725 type StablePtr = ReturnTypeClausePtr;
8726 type Green = ReturnTypeClauseGreen;
8727 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8728 ReturnTypeClauseGreen(
8729 Arc::new(GreenNode {
8730 kind: SyntaxKind::ReturnTypeClause,
8731 details: GreenNodeDetails::Node {
8732 children: vec![TerminalArrow::missing(db).0, Expr::missing(db).0],
8733 width: TextWidth::default(),
8734 },
8735 })
8736 .intern(db),
8737 )
8738 }
8739 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8740 let kind = node.kind(db);
8741 assert_eq!(
8742 kind,
8743 SyntaxKind::ReturnTypeClause,
8744 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8745 kind,
8746 SyntaxKind::ReturnTypeClause
8747 );
8748 let children = db.get_children(node.clone());
8749 Self { node, children }
8750 }
8751 fn as_syntax_node(&self) -> SyntaxNode {
8752 self.node.clone()
8753 }
8754 fn stable_ptr(&self) -> Self::StablePtr {
8755 ReturnTypeClausePtr(self.node.0.stable_ptr)
8756 }
8757}
8758impl From<&ReturnTypeClause> for SyntaxStablePtrId {
8759 fn from(node: &ReturnTypeClause) -> Self {
8760 node.stable_ptr().untyped()
8761 }
8762}
8763#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8764pub enum OptionReturnTypeClause {
8765 Empty(OptionReturnTypeClauseEmpty),
8766 ReturnTypeClause(ReturnTypeClause),
8767}
8768#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8769pub struct OptionReturnTypeClausePtr(pub SyntaxStablePtrId);
8770impl TypedStablePtr for OptionReturnTypeClausePtr {
8771 type SyntaxNode = OptionReturnTypeClause;
8772 fn untyped(&self) -> SyntaxStablePtrId {
8773 self.0
8774 }
8775 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
8776 OptionReturnTypeClause::from_syntax_node(db, self.0.lookup(db))
8777 }
8778}
8779impl From<OptionReturnTypeClausePtr> for SyntaxStablePtrId {
8780 fn from(ptr: OptionReturnTypeClausePtr) -> Self {
8781 ptr.untyped()
8782 }
8783}
8784impl From<OptionReturnTypeClauseEmptyPtr> for OptionReturnTypeClausePtr {
8785 fn from(value: OptionReturnTypeClauseEmptyPtr) -> Self {
8786 Self(value.0)
8787 }
8788}
8789impl From<ReturnTypeClausePtr> for OptionReturnTypeClausePtr {
8790 fn from(value: ReturnTypeClausePtr) -> Self {
8791 Self(value.0)
8792 }
8793}
8794impl From<OptionReturnTypeClauseEmptyGreen> for OptionReturnTypeClauseGreen {
8795 fn from(value: OptionReturnTypeClauseEmptyGreen) -> Self {
8796 Self(value.0)
8797 }
8798}
8799impl From<ReturnTypeClauseGreen> for OptionReturnTypeClauseGreen {
8800 fn from(value: ReturnTypeClauseGreen) -> Self {
8801 Self(value.0)
8802 }
8803}
8804#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8805pub struct OptionReturnTypeClauseGreen(pub GreenId);
8806impl TypedSyntaxNode for OptionReturnTypeClause {
8807 const OPTIONAL_KIND: Option<SyntaxKind> = None;
8808 type StablePtr = OptionReturnTypeClausePtr;
8809 type Green = OptionReturnTypeClauseGreen;
8810 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8811 panic!("No missing variant.");
8812 }
8813 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8814 let kind = node.kind(db);
8815 match kind {
8816 SyntaxKind::OptionReturnTypeClauseEmpty => OptionReturnTypeClause::Empty(
8817 OptionReturnTypeClauseEmpty::from_syntax_node(db, node),
8818 ),
8819 SyntaxKind::ReturnTypeClause => OptionReturnTypeClause::ReturnTypeClause(
8820 ReturnTypeClause::from_syntax_node(db, node),
8821 ),
8822 _ => panic!(
8823 "Unexpected syntax kind {:?} when constructing {}.",
8824 kind, "OptionReturnTypeClause"
8825 ),
8826 }
8827 }
8828 fn as_syntax_node(&self) -> SyntaxNode {
8829 match self {
8830 OptionReturnTypeClause::Empty(x) => x.as_syntax_node(),
8831 OptionReturnTypeClause::ReturnTypeClause(x) => x.as_syntax_node(),
8832 }
8833 }
8834 fn stable_ptr(&self) -> Self::StablePtr {
8835 OptionReturnTypeClausePtr(self.as_syntax_node().0.stable_ptr)
8836 }
8837}
8838impl From<&OptionReturnTypeClause> for SyntaxStablePtrId {
8839 fn from(node: &OptionReturnTypeClause) -> Self {
8840 node.stable_ptr().untyped()
8841 }
8842}
8843impl OptionReturnTypeClause {
8844 pub fn is_variant(kind: SyntaxKind) -> bool {
8846 matches!(kind, SyntaxKind::OptionReturnTypeClauseEmpty | SyntaxKind::ReturnTypeClause)
8847 }
8848}
8849#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8850pub struct OptionReturnTypeClauseEmpty {
8851 node: SyntaxNode,
8852 children: Arc<[SyntaxNode]>,
8853}
8854impl OptionReturnTypeClauseEmpty {
8855 pub fn new_green(db: &dyn SyntaxGroup) -> OptionReturnTypeClauseEmptyGreen {
8856 let children: Vec<GreenId> = vec![];
8857 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
8858 OptionReturnTypeClauseEmptyGreen(
8859 Arc::new(GreenNode {
8860 kind: SyntaxKind::OptionReturnTypeClauseEmpty,
8861 details: GreenNodeDetails::Node { children, width },
8862 })
8863 .intern(db),
8864 )
8865 }
8866}
8867impl OptionReturnTypeClauseEmpty {}
8868#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8869pub struct OptionReturnTypeClauseEmptyPtr(pub SyntaxStablePtrId);
8870impl OptionReturnTypeClauseEmptyPtr {}
8871impl TypedStablePtr for OptionReturnTypeClauseEmptyPtr {
8872 type SyntaxNode = OptionReturnTypeClauseEmpty;
8873 fn untyped(&self) -> SyntaxStablePtrId {
8874 self.0
8875 }
8876 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClauseEmpty {
8877 OptionReturnTypeClauseEmpty::from_syntax_node(db, self.0.lookup(db))
8878 }
8879}
8880impl From<OptionReturnTypeClauseEmptyPtr> for SyntaxStablePtrId {
8881 fn from(ptr: OptionReturnTypeClauseEmptyPtr) -> Self {
8882 ptr.untyped()
8883 }
8884}
8885#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8886pub struct OptionReturnTypeClauseEmptyGreen(pub GreenId);
8887impl TypedSyntaxNode for OptionReturnTypeClauseEmpty {
8888 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionReturnTypeClauseEmpty);
8889 type StablePtr = OptionReturnTypeClauseEmptyPtr;
8890 type Green = OptionReturnTypeClauseEmptyGreen;
8891 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
8892 OptionReturnTypeClauseEmptyGreen(
8893 Arc::new(GreenNode {
8894 kind: SyntaxKind::OptionReturnTypeClauseEmpty,
8895 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
8896 })
8897 .intern(db),
8898 )
8899 }
8900 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
8901 let kind = node.kind(db);
8902 assert_eq!(
8903 kind,
8904 SyntaxKind::OptionReturnTypeClauseEmpty,
8905 "Unexpected SyntaxKind {:?}. Expected {:?}.",
8906 kind,
8907 SyntaxKind::OptionReturnTypeClauseEmpty
8908 );
8909 let children = db.get_children(node.clone());
8910 Self { node, children }
8911 }
8912 fn as_syntax_node(&self) -> SyntaxNode {
8913 self.node.clone()
8914 }
8915 fn stable_ptr(&self) -> Self::StablePtr {
8916 OptionReturnTypeClauseEmptyPtr(self.node.0.stable_ptr)
8917 }
8918}
8919impl From<&OptionReturnTypeClauseEmpty> for SyntaxStablePtrId {
8920 fn from(node: &OptionReturnTypeClauseEmpty) -> Self {
8921 node.stable_ptr().untyped()
8922 }
8923}
8924#[derive(Clone, Debug, Eq, Hash, PartialEq)]
8925pub enum Statement {
8926 Let(StatementLet),
8927 Expr(StatementExpr),
8928 Continue(StatementContinue),
8929 Return(StatementReturn),
8930 Break(StatementBreak),
8931 Item(StatementItem),
8932 Missing(StatementMissing),
8933}
8934#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
8935pub struct StatementPtr(pub SyntaxStablePtrId);
8936impl TypedStablePtr for StatementPtr {
8937 type SyntaxNode = Statement;
8938 fn untyped(&self) -> SyntaxStablePtrId {
8939 self.0
8940 }
8941 fn lookup(&self, db: &dyn SyntaxGroup) -> Statement {
8942 Statement::from_syntax_node(db, self.0.lookup(db))
8943 }
8944}
8945impl From<StatementPtr> for SyntaxStablePtrId {
8946 fn from(ptr: StatementPtr) -> Self {
8947 ptr.untyped()
8948 }
8949}
8950impl From<StatementLetPtr> for StatementPtr {
8951 fn from(value: StatementLetPtr) -> Self {
8952 Self(value.0)
8953 }
8954}
8955impl From<StatementExprPtr> for StatementPtr {
8956 fn from(value: StatementExprPtr) -> Self {
8957 Self(value.0)
8958 }
8959}
8960impl From<StatementContinuePtr> for StatementPtr {
8961 fn from(value: StatementContinuePtr) -> Self {
8962 Self(value.0)
8963 }
8964}
8965impl From<StatementReturnPtr> for StatementPtr {
8966 fn from(value: StatementReturnPtr) -> Self {
8967 Self(value.0)
8968 }
8969}
8970impl From<StatementBreakPtr> for StatementPtr {
8971 fn from(value: StatementBreakPtr) -> Self {
8972 Self(value.0)
8973 }
8974}
8975impl From<StatementItemPtr> for StatementPtr {
8976 fn from(value: StatementItemPtr) -> Self {
8977 Self(value.0)
8978 }
8979}
8980impl From<StatementMissingPtr> for StatementPtr {
8981 fn from(value: StatementMissingPtr) -> Self {
8982 Self(value.0)
8983 }
8984}
8985impl From<StatementLetGreen> for StatementGreen {
8986 fn from(value: StatementLetGreen) -> Self {
8987 Self(value.0)
8988 }
8989}
8990impl From<StatementExprGreen> for StatementGreen {
8991 fn from(value: StatementExprGreen) -> Self {
8992 Self(value.0)
8993 }
8994}
8995impl From<StatementContinueGreen> for StatementGreen {
8996 fn from(value: StatementContinueGreen) -> Self {
8997 Self(value.0)
8998 }
8999}
9000impl From<StatementReturnGreen> for StatementGreen {
9001 fn from(value: StatementReturnGreen) -> Self {
9002 Self(value.0)
9003 }
9004}
9005impl From<StatementBreakGreen> for StatementGreen {
9006 fn from(value: StatementBreakGreen) -> Self {
9007 Self(value.0)
9008 }
9009}
9010impl From<StatementItemGreen> for StatementGreen {
9011 fn from(value: StatementItemGreen) -> Self {
9012 Self(value.0)
9013 }
9014}
9015impl From<StatementMissingGreen> for StatementGreen {
9016 fn from(value: StatementMissingGreen) -> Self {
9017 Self(value.0)
9018 }
9019}
9020#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9021pub struct StatementGreen(pub GreenId);
9022impl TypedSyntaxNode for Statement {
9023 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9024 type StablePtr = StatementPtr;
9025 type Green = StatementGreen;
9026 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9027 StatementGreen(StatementMissing::missing(db).0)
9028 }
9029 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9030 let kind = node.kind(db);
9031 match kind {
9032 SyntaxKind::StatementLet => Statement::Let(StatementLet::from_syntax_node(db, node)),
9033 SyntaxKind::StatementExpr => Statement::Expr(StatementExpr::from_syntax_node(db, node)),
9034 SyntaxKind::StatementContinue => {
9035 Statement::Continue(StatementContinue::from_syntax_node(db, node))
9036 }
9037 SyntaxKind::StatementReturn => {
9038 Statement::Return(StatementReturn::from_syntax_node(db, node))
9039 }
9040 SyntaxKind::StatementBreak => {
9041 Statement::Break(StatementBreak::from_syntax_node(db, node))
9042 }
9043 SyntaxKind::StatementItem => Statement::Item(StatementItem::from_syntax_node(db, node)),
9044 SyntaxKind::StatementMissing => {
9045 Statement::Missing(StatementMissing::from_syntax_node(db, node))
9046 }
9047 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Statement"),
9048 }
9049 }
9050 fn as_syntax_node(&self) -> SyntaxNode {
9051 match self {
9052 Statement::Let(x) => x.as_syntax_node(),
9053 Statement::Expr(x) => x.as_syntax_node(),
9054 Statement::Continue(x) => x.as_syntax_node(),
9055 Statement::Return(x) => x.as_syntax_node(),
9056 Statement::Break(x) => x.as_syntax_node(),
9057 Statement::Item(x) => x.as_syntax_node(),
9058 Statement::Missing(x) => x.as_syntax_node(),
9059 }
9060 }
9061 fn stable_ptr(&self) -> Self::StablePtr {
9062 StatementPtr(self.as_syntax_node().0.stable_ptr)
9063 }
9064}
9065impl From<&Statement> for SyntaxStablePtrId {
9066 fn from(node: &Statement) -> Self {
9067 node.stable_ptr().untyped()
9068 }
9069}
9070impl Statement {
9071 pub fn is_variant(kind: SyntaxKind) -> bool {
9073 matches!(
9074 kind,
9075 SyntaxKind::StatementLet
9076 | SyntaxKind::StatementExpr
9077 | SyntaxKind::StatementContinue
9078 | SyntaxKind::StatementReturn
9079 | SyntaxKind::StatementBreak
9080 | SyntaxKind::StatementItem
9081 | SyntaxKind::StatementMissing
9082 )
9083 }
9084}
9085#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9086pub struct StatementList(ElementList<Statement, 1>);
9087impl Deref for StatementList {
9088 type Target = ElementList<Statement, 1>;
9089 fn deref(&self) -> &Self::Target {
9090 &self.0
9091 }
9092}
9093impl StatementList {
9094 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<StatementGreen>) -> StatementListGreen {
9095 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
9096 StatementListGreen(
9097 Arc::new(GreenNode {
9098 kind: SyntaxKind::StatementList,
9099 details: GreenNodeDetails::Node {
9100 children: children.iter().map(|x| x.0).collect(),
9101 width,
9102 },
9103 })
9104 .intern(db),
9105 )
9106 }
9107}
9108#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9109pub struct StatementListPtr(pub SyntaxStablePtrId);
9110impl TypedStablePtr for StatementListPtr {
9111 type SyntaxNode = StatementList;
9112 fn untyped(&self) -> SyntaxStablePtrId {
9113 self.0
9114 }
9115 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementList {
9116 StatementList::from_syntax_node(db, self.0.lookup(db))
9117 }
9118}
9119impl From<StatementListPtr> for SyntaxStablePtrId {
9120 fn from(ptr: StatementListPtr) -> Self {
9121 ptr.untyped()
9122 }
9123}
9124#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9125pub struct StatementListGreen(pub GreenId);
9126impl TypedSyntaxNode for StatementList {
9127 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementList);
9128 type StablePtr = StatementListPtr;
9129 type Green = StatementListGreen;
9130 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9131 StatementListGreen(
9132 Arc::new(GreenNode {
9133 kind: SyntaxKind::StatementList,
9134 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9135 })
9136 .intern(db),
9137 )
9138 }
9139 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9140 Self(ElementList::new(node))
9141 }
9142 fn as_syntax_node(&self) -> SyntaxNode {
9143 self.node.clone()
9144 }
9145 fn stable_ptr(&self) -> Self::StablePtr {
9146 StatementListPtr(self.node.0.stable_ptr)
9147 }
9148}
9149impl From<&StatementList> for SyntaxStablePtrId {
9150 fn from(node: &StatementList) -> Self {
9151 node.stable_ptr().untyped()
9152 }
9153}
9154#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9155pub struct StatementMissing {
9156 node: SyntaxNode,
9157 children: Arc<[SyntaxNode]>,
9158}
9159impl StatementMissing {
9160 pub fn new_green(db: &dyn SyntaxGroup) -> StatementMissingGreen {
9161 let children: Vec<GreenId> = vec![];
9162 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9163 StatementMissingGreen(
9164 Arc::new(GreenNode {
9165 kind: SyntaxKind::StatementMissing,
9166 details: GreenNodeDetails::Node { children, width },
9167 })
9168 .intern(db),
9169 )
9170 }
9171}
9172impl StatementMissing {}
9173#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9174pub struct StatementMissingPtr(pub SyntaxStablePtrId);
9175impl StatementMissingPtr {}
9176impl TypedStablePtr for StatementMissingPtr {
9177 type SyntaxNode = StatementMissing;
9178 fn untyped(&self) -> SyntaxStablePtrId {
9179 self.0
9180 }
9181 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementMissing {
9182 StatementMissing::from_syntax_node(db, self.0.lookup(db))
9183 }
9184}
9185impl From<StatementMissingPtr> for SyntaxStablePtrId {
9186 fn from(ptr: StatementMissingPtr) -> Self {
9187 ptr.untyped()
9188 }
9189}
9190#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9191pub struct StatementMissingGreen(pub GreenId);
9192impl TypedSyntaxNode for StatementMissing {
9193 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementMissing);
9194 type StablePtr = StatementMissingPtr;
9195 type Green = StatementMissingGreen;
9196 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9197 StatementMissingGreen(
9198 Arc::new(GreenNode {
9199 kind: SyntaxKind::StatementMissing,
9200 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9201 })
9202 .intern(db),
9203 )
9204 }
9205 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9206 let kind = node.kind(db);
9207 assert_eq!(
9208 kind,
9209 SyntaxKind::StatementMissing,
9210 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9211 kind,
9212 SyntaxKind::StatementMissing
9213 );
9214 let children = db.get_children(node.clone());
9215 Self { node, children }
9216 }
9217 fn as_syntax_node(&self) -> SyntaxNode {
9218 self.node.clone()
9219 }
9220 fn stable_ptr(&self) -> Self::StablePtr {
9221 StatementMissingPtr(self.node.0.stable_ptr)
9222 }
9223}
9224impl From<&StatementMissing> for SyntaxStablePtrId {
9225 fn from(node: &StatementMissing) -> Self {
9226 node.stable_ptr().untyped()
9227 }
9228}
9229#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9230pub struct StatementLet {
9231 node: SyntaxNode,
9232 children: Arc<[SyntaxNode]>,
9233}
9234impl StatementLet {
9235 pub const INDEX_ATTRIBUTES: usize = 0;
9236 pub const INDEX_LET_KW: usize = 1;
9237 pub const INDEX_PATTERN: usize = 2;
9238 pub const INDEX_TYPE_CLAUSE: usize = 3;
9239 pub const INDEX_EQ: usize = 4;
9240 pub const INDEX_RHS: usize = 5;
9241 pub const INDEX_SEMICOLON: usize = 6;
9242 pub fn new_green(
9243 db: &dyn SyntaxGroup,
9244 attributes: AttributeListGreen,
9245 let_kw: TerminalLetGreen,
9246 pattern: PatternGreen,
9247 type_clause: OptionTypeClauseGreen,
9248 eq: TerminalEqGreen,
9249 rhs: ExprGreen,
9250 semicolon: TerminalSemicolonGreen,
9251 ) -> StatementLetGreen {
9252 let children: Vec<GreenId> =
9253 vec![attributes.0, let_kw.0, pattern.0, type_clause.0, eq.0, rhs.0, semicolon.0];
9254 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9255 StatementLetGreen(
9256 Arc::new(GreenNode {
9257 kind: SyntaxKind::StatementLet,
9258 details: GreenNodeDetails::Node { children, width },
9259 })
9260 .intern(db),
9261 )
9262 }
9263}
9264impl StatementLet {
9265 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
9266 AttributeList::from_syntax_node(db, self.children[0].clone())
9267 }
9268 pub fn let_kw(&self, db: &dyn SyntaxGroup) -> TerminalLet {
9269 TerminalLet::from_syntax_node(db, self.children[1].clone())
9270 }
9271 pub fn pattern(&self, db: &dyn SyntaxGroup) -> Pattern {
9272 Pattern::from_syntax_node(db, self.children[2].clone())
9273 }
9274 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
9275 OptionTypeClause::from_syntax_node(db, self.children[3].clone())
9276 }
9277 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
9278 TerminalEq::from_syntax_node(db, self.children[4].clone())
9279 }
9280 pub fn rhs(&self, db: &dyn SyntaxGroup) -> Expr {
9281 Expr::from_syntax_node(db, self.children[5].clone())
9282 }
9283 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
9284 TerminalSemicolon::from_syntax_node(db, self.children[6].clone())
9285 }
9286}
9287#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9288pub struct StatementLetPtr(pub SyntaxStablePtrId);
9289impl StatementLetPtr {
9290 pub fn pattern_green(self, db: &dyn SyntaxGroup) -> PatternGreen {
9291 let ptr = self.0.lookup_intern(db);
9292 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
9293 PatternGreen(key_fields[0])
9294 } else {
9295 panic!("Unexpected key field query on root.");
9296 }
9297 }
9298}
9299impl TypedStablePtr for StatementLetPtr {
9300 type SyntaxNode = StatementLet;
9301 fn untyped(&self) -> SyntaxStablePtrId {
9302 self.0
9303 }
9304 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementLet {
9305 StatementLet::from_syntax_node(db, self.0.lookup(db))
9306 }
9307}
9308impl From<StatementLetPtr> for SyntaxStablePtrId {
9309 fn from(ptr: StatementLetPtr) -> Self {
9310 ptr.untyped()
9311 }
9312}
9313#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9314pub struct StatementLetGreen(pub GreenId);
9315impl TypedSyntaxNode for StatementLet {
9316 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementLet);
9317 type StablePtr = StatementLetPtr;
9318 type Green = StatementLetGreen;
9319 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9320 StatementLetGreen(
9321 Arc::new(GreenNode {
9322 kind: SyntaxKind::StatementLet,
9323 details: GreenNodeDetails::Node {
9324 children: vec![
9325 AttributeList::missing(db).0,
9326 TerminalLet::missing(db).0,
9327 Pattern::missing(db).0,
9328 OptionTypeClause::missing(db).0,
9329 TerminalEq::missing(db).0,
9330 Expr::missing(db).0,
9331 TerminalSemicolon::missing(db).0,
9332 ],
9333 width: TextWidth::default(),
9334 },
9335 })
9336 .intern(db),
9337 )
9338 }
9339 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9340 let kind = node.kind(db);
9341 assert_eq!(
9342 kind,
9343 SyntaxKind::StatementLet,
9344 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9345 kind,
9346 SyntaxKind::StatementLet
9347 );
9348 let children = db.get_children(node.clone());
9349 Self { node, children }
9350 }
9351 fn as_syntax_node(&self) -> SyntaxNode {
9352 self.node.clone()
9353 }
9354 fn stable_ptr(&self) -> Self::StablePtr {
9355 StatementLetPtr(self.node.0.stable_ptr)
9356 }
9357}
9358impl From<&StatementLet> for SyntaxStablePtrId {
9359 fn from(node: &StatementLet) -> Self {
9360 node.stable_ptr().untyped()
9361 }
9362}
9363#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9364pub enum OptionTerminalSemicolon {
9365 Empty(OptionTerminalSemicolonEmpty),
9366 TerminalSemicolon(TerminalSemicolon),
9367}
9368#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9369pub struct OptionTerminalSemicolonPtr(pub SyntaxStablePtrId);
9370impl TypedStablePtr for OptionTerminalSemicolonPtr {
9371 type SyntaxNode = OptionTerminalSemicolon;
9372 fn untyped(&self) -> SyntaxStablePtrId {
9373 self.0
9374 }
9375 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolon {
9376 OptionTerminalSemicolon::from_syntax_node(db, self.0.lookup(db))
9377 }
9378}
9379impl From<OptionTerminalSemicolonPtr> for SyntaxStablePtrId {
9380 fn from(ptr: OptionTerminalSemicolonPtr) -> Self {
9381 ptr.untyped()
9382 }
9383}
9384impl From<OptionTerminalSemicolonEmptyPtr> for OptionTerminalSemicolonPtr {
9385 fn from(value: OptionTerminalSemicolonEmptyPtr) -> Self {
9386 Self(value.0)
9387 }
9388}
9389impl From<TerminalSemicolonPtr> for OptionTerminalSemicolonPtr {
9390 fn from(value: TerminalSemicolonPtr) -> Self {
9391 Self(value.0)
9392 }
9393}
9394impl From<OptionTerminalSemicolonEmptyGreen> for OptionTerminalSemicolonGreen {
9395 fn from(value: OptionTerminalSemicolonEmptyGreen) -> Self {
9396 Self(value.0)
9397 }
9398}
9399impl From<TerminalSemicolonGreen> for OptionTerminalSemicolonGreen {
9400 fn from(value: TerminalSemicolonGreen) -> Self {
9401 Self(value.0)
9402 }
9403}
9404#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9405pub struct OptionTerminalSemicolonGreen(pub GreenId);
9406impl TypedSyntaxNode for OptionTerminalSemicolon {
9407 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9408 type StablePtr = OptionTerminalSemicolonPtr;
9409 type Green = OptionTerminalSemicolonGreen;
9410 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9411 panic!("No missing variant.");
9412 }
9413 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9414 let kind = node.kind(db);
9415 match kind {
9416 SyntaxKind::OptionTerminalSemicolonEmpty => OptionTerminalSemicolon::Empty(
9417 OptionTerminalSemicolonEmpty::from_syntax_node(db, node),
9418 ),
9419 SyntaxKind::TerminalSemicolon => OptionTerminalSemicolon::TerminalSemicolon(
9420 TerminalSemicolon::from_syntax_node(db, node),
9421 ),
9422 _ => panic!(
9423 "Unexpected syntax kind {:?} when constructing {}.",
9424 kind, "OptionTerminalSemicolon"
9425 ),
9426 }
9427 }
9428 fn as_syntax_node(&self) -> SyntaxNode {
9429 match self {
9430 OptionTerminalSemicolon::Empty(x) => x.as_syntax_node(),
9431 OptionTerminalSemicolon::TerminalSemicolon(x) => x.as_syntax_node(),
9432 }
9433 }
9434 fn stable_ptr(&self) -> Self::StablePtr {
9435 OptionTerminalSemicolonPtr(self.as_syntax_node().0.stable_ptr)
9436 }
9437}
9438impl From<&OptionTerminalSemicolon> for SyntaxStablePtrId {
9439 fn from(node: &OptionTerminalSemicolon) -> Self {
9440 node.stable_ptr().untyped()
9441 }
9442}
9443impl OptionTerminalSemicolon {
9444 pub fn is_variant(kind: SyntaxKind) -> bool {
9446 matches!(kind, SyntaxKind::OptionTerminalSemicolonEmpty | SyntaxKind::TerminalSemicolon)
9447 }
9448}
9449#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9450pub struct OptionTerminalSemicolonEmpty {
9451 node: SyntaxNode,
9452 children: Arc<[SyntaxNode]>,
9453}
9454impl OptionTerminalSemicolonEmpty {
9455 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalSemicolonEmptyGreen {
9456 let children: Vec<GreenId> = vec![];
9457 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9458 OptionTerminalSemicolonEmptyGreen(
9459 Arc::new(GreenNode {
9460 kind: SyntaxKind::OptionTerminalSemicolonEmpty,
9461 details: GreenNodeDetails::Node { children, width },
9462 })
9463 .intern(db),
9464 )
9465 }
9466}
9467impl OptionTerminalSemicolonEmpty {}
9468#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9469pub struct OptionTerminalSemicolonEmptyPtr(pub SyntaxStablePtrId);
9470impl OptionTerminalSemicolonEmptyPtr {}
9471impl TypedStablePtr for OptionTerminalSemicolonEmptyPtr {
9472 type SyntaxNode = OptionTerminalSemicolonEmpty;
9473 fn untyped(&self) -> SyntaxStablePtrId {
9474 self.0
9475 }
9476 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolonEmpty {
9477 OptionTerminalSemicolonEmpty::from_syntax_node(db, self.0.lookup(db))
9478 }
9479}
9480impl From<OptionTerminalSemicolonEmptyPtr> for SyntaxStablePtrId {
9481 fn from(ptr: OptionTerminalSemicolonEmptyPtr) -> Self {
9482 ptr.untyped()
9483 }
9484}
9485#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9486pub struct OptionTerminalSemicolonEmptyGreen(pub GreenId);
9487impl TypedSyntaxNode for OptionTerminalSemicolonEmpty {
9488 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalSemicolonEmpty);
9489 type StablePtr = OptionTerminalSemicolonEmptyPtr;
9490 type Green = OptionTerminalSemicolonEmptyGreen;
9491 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9492 OptionTerminalSemicolonEmptyGreen(
9493 Arc::new(GreenNode {
9494 kind: SyntaxKind::OptionTerminalSemicolonEmpty,
9495 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9496 })
9497 .intern(db),
9498 )
9499 }
9500 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9501 let kind = node.kind(db);
9502 assert_eq!(
9503 kind,
9504 SyntaxKind::OptionTerminalSemicolonEmpty,
9505 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9506 kind,
9507 SyntaxKind::OptionTerminalSemicolonEmpty
9508 );
9509 let children = db.get_children(node.clone());
9510 Self { node, children }
9511 }
9512 fn as_syntax_node(&self) -> SyntaxNode {
9513 self.node.clone()
9514 }
9515 fn stable_ptr(&self) -> Self::StablePtr {
9516 OptionTerminalSemicolonEmptyPtr(self.node.0.stable_ptr)
9517 }
9518}
9519impl From<&OptionTerminalSemicolonEmpty> for SyntaxStablePtrId {
9520 fn from(node: &OptionTerminalSemicolonEmpty) -> Self {
9521 node.stable_ptr().untyped()
9522 }
9523}
9524#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9525pub struct StatementExpr {
9526 node: SyntaxNode,
9527 children: Arc<[SyntaxNode]>,
9528}
9529impl StatementExpr {
9530 pub const INDEX_ATTRIBUTES: usize = 0;
9531 pub const INDEX_EXPR: usize = 1;
9532 pub const INDEX_SEMICOLON: usize = 2;
9533 pub fn new_green(
9534 db: &dyn SyntaxGroup,
9535 attributes: AttributeListGreen,
9536 expr: ExprGreen,
9537 semicolon: OptionTerminalSemicolonGreen,
9538 ) -> StatementExprGreen {
9539 let children: Vec<GreenId> = vec![attributes.0, expr.0, semicolon.0];
9540 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9541 StatementExprGreen(
9542 Arc::new(GreenNode {
9543 kind: SyntaxKind::StatementExpr,
9544 details: GreenNodeDetails::Node { children, width },
9545 })
9546 .intern(db),
9547 )
9548 }
9549}
9550impl StatementExpr {
9551 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
9552 AttributeList::from_syntax_node(db, self.children[0].clone())
9553 }
9554 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
9555 Expr::from_syntax_node(db, self.children[1].clone())
9556 }
9557 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> OptionTerminalSemicolon {
9558 OptionTerminalSemicolon::from_syntax_node(db, self.children[2].clone())
9559 }
9560}
9561#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9562pub struct StatementExprPtr(pub SyntaxStablePtrId);
9563impl StatementExprPtr {}
9564impl TypedStablePtr for StatementExprPtr {
9565 type SyntaxNode = StatementExpr;
9566 fn untyped(&self) -> SyntaxStablePtrId {
9567 self.0
9568 }
9569 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementExpr {
9570 StatementExpr::from_syntax_node(db, self.0.lookup(db))
9571 }
9572}
9573impl From<StatementExprPtr> for SyntaxStablePtrId {
9574 fn from(ptr: StatementExprPtr) -> Self {
9575 ptr.untyped()
9576 }
9577}
9578#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9579pub struct StatementExprGreen(pub GreenId);
9580impl TypedSyntaxNode for StatementExpr {
9581 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementExpr);
9582 type StablePtr = StatementExprPtr;
9583 type Green = StatementExprGreen;
9584 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9585 StatementExprGreen(
9586 Arc::new(GreenNode {
9587 kind: SyntaxKind::StatementExpr,
9588 details: GreenNodeDetails::Node {
9589 children: vec![
9590 AttributeList::missing(db).0,
9591 Expr::missing(db).0,
9592 OptionTerminalSemicolon::missing(db).0,
9593 ],
9594 width: TextWidth::default(),
9595 },
9596 })
9597 .intern(db),
9598 )
9599 }
9600 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9601 let kind = node.kind(db);
9602 assert_eq!(
9603 kind,
9604 SyntaxKind::StatementExpr,
9605 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9606 kind,
9607 SyntaxKind::StatementExpr
9608 );
9609 let children = db.get_children(node.clone());
9610 Self { node, children }
9611 }
9612 fn as_syntax_node(&self) -> SyntaxNode {
9613 self.node.clone()
9614 }
9615 fn stable_ptr(&self) -> Self::StablePtr {
9616 StatementExprPtr(self.node.0.stable_ptr)
9617 }
9618}
9619impl From<&StatementExpr> for SyntaxStablePtrId {
9620 fn from(node: &StatementExpr) -> Self {
9621 node.stable_ptr().untyped()
9622 }
9623}
9624#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9625pub struct StatementContinue {
9626 node: SyntaxNode,
9627 children: Arc<[SyntaxNode]>,
9628}
9629impl StatementContinue {
9630 pub const INDEX_ATTRIBUTES: usize = 0;
9631 pub const INDEX_CONTINUE_KW: usize = 1;
9632 pub const INDEX_SEMICOLON: usize = 2;
9633 pub fn new_green(
9634 db: &dyn SyntaxGroup,
9635 attributes: AttributeListGreen,
9636 continue_kw: TerminalContinueGreen,
9637 semicolon: TerminalSemicolonGreen,
9638 ) -> StatementContinueGreen {
9639 let children: Vec<GreenId> = vec![attributes.0, continue_kw.0, semicolon.0];
9640 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9641 StatementContinueGreen(
9642 Arc::new(GreenNode {
9643 kind: SyntaxKind::StatementContinue,
9644 details: GreenNodeDetails::Node { children, width },
9645 })
9646 .intern(db),
9647 )
9648 }
9649}
9650impl StatementContinue {
9651 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
9652 AttributeList::from_syntax_node(db, self.children[0].clone())
9653 }
9654 pub fn continue_kw(&self, db: &dyn SyntaxGroup) -> TerminalContinue {
9655 TerminalContinue::from_syntax_node(db, self.children[1].clone())
9656 }
9657 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
9658 TerminalSemicolon::from_syntax_node(db, self.children[2].clone())
9659 }
9660}
9661#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9662pub struct StatementContinuePtr(pub SyntaxStablePtrId);
9663impl StatementContinuePtr {}
9664impl TypedStablePtr for StatementContinuePtr {
9665 type SyntaxNode = StatementContinue;
9666 fn untyped(&self) -> SyntaxStablePtrId {
9667 self.0
9668 }
9669 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementContinue {
9670 StatementContinue::from_syntax_node(db, self.0.lookup(db))
9671 }
9672}
9673impl From<StatementContinuePtr> for SyntaxStablePtrId {
9674 fn from(ptr: StatementContinuePtr) -> Self {
9675 ptr.untyped()
9676 }
9677}
9678#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9679pub struct StatementContinueGreen(pub GreenId);
9680impl TypedSyntaxNode for StatementContinue {
9681 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementContinue);
9682 type StablePtr = StatementContinuePtr;
9683 type Green = StatementContinueGreen;
9684 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9685 StatementContinueGreen(
9686 Arc::new(GreenNode {
9687 kind: SyntaxKind::StatementContinue,
9688 details: GreenNodeDetails::Node {
9689 children: vec![
9690 AttributeList::missing(db).0,
9691 TerminalContinue::missing(db).0,
9692 TerminalSemicolon::missing(db).0,
9693 ],
9694 width: TextWidth::default(),
9695 },
9696 })
9697 .intern(db),
9698 )
9699 }
9700 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9701 let kind = node.kind(db);
9702 assert_eq!(
9703 kind,
9704 SyntaxKind::StatementContinue,
9705 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9706 kind,
9707 SyntaxKind::StatementContinue
9708 );
9709 let children = db.get_children(node.clone());
9710 Self { node, children }
9711 }
9712 fn as_syntax_node(&self) -> SyntaxNode {
9713 self.node.clone()
9714 }
9715 fn stable_ptr(&self) -> Self::StablePtr {
9716 StatementContinuePtr(self.node.0.stable_ptr)
9717 }
9718}
9719impl From<&StatementContinue> for SyntaxStablePtrId {
9720 fn from(node: &StatementContinue) -> Self {
9721 node.stable_ptr().untyped()
9722 }
9723}
9724#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9725pub struct ExprClause {
9726 node: SyntaxNode,
9727 children: Arc<[SyntaxNode]>,
9728}
9729impl ExprClause {
9730 pub const INDEX_EXPR: usize = 0;
9731 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> ExprClauseGreen {
9732 let children: Vec<GreenId> = vec![expr.0];
9733 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9734 ExprClauseGreen(
9735 Arc::new(GreenNode {
9736 kind: SyntaxKind::ExprClause,
9737 details: GreenNodeDetails::Node { children, width },
9738 })
9739 .intern(db),
9740 )
9741 }
9742}
9743impl ExprClause {
9744 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
9745 Expr::from_syntax_node(db, self.children[0].clone())
9746 }
9747}
9748#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9749pub struct ExprClausePtr(pub SyntaxStablePtrId);
9750impl ExprClausePtr {}
9751impl TypedStablePtr for ExprClausePtr {
9752 type SyntaxNode = ExprClause;
9753 fn untyped(&self) -> SyntaxStablePtrId {
9754 self.0
9755 }
9756 fn lookup(&self, db: &dyn SyntaxGroup) -> ExprClause {
9757 ExprClause::from_syntax_node(db, self.0.lookup(db))
9758 }
9759}
9760impl From<ExprClausePtr> for SyntaxStablePtrId {
9761 fn from(ptr: ExprClausePtr) -> Self {
9762 ptr.untyped()
9763 }
9764}
9765#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9766pub struct ExprClauseGreen(pub GreenId);
9767impl TypedSyntaxNode for ExprClause {
9768 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ExprClause);
9769 type StablePtr = ExprClausePtr;
9770 type Green = ExprClauseGreen;
9771 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9772 ExprClauseGreen(
9773 Arc::new(GreenNode {
9774 kind: SyntaxKind::ExprClause,
9775 details: GreenNodeDetails::Node {
9776 children: vec![Expr::missing(db).0],
9777 width: TextWidth::default(),
9778 },
9779 })
9780 .intern(db),
9781 )
9782 }
9783 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9784 let kind = node.kind(db);
9785 assert_eq!(
9786 kind,
9787 SyntaxKind::ExprClause,
9788 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9789 kind,
9790 SyntaxKind::ExprClause
9791 );
9792 let children = db.get_children(node.clone());
9793 Self { node, children }
9794 }
9795 fn as_syntax_node(&self) -> SyntaxNode {
9796 self.node.clone()
9797 }
9798 fn stable_ptr(&self) -> Self::StablePtr {
9799 ExprClausePtr(self.node.0.stable_ptr)
9800 }
9801}
9802impl From<&ExprClause> for SyntaxStablePtrId {
9803 fn from(node: &ExprClause) -> Self {
9804 node.stable_ptr().untyped()
9805 }
9806}
9807#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9808pub enum OptionExprClause {
9809 Empty(OptionExprClauseEmpty),
9810 ExprClause(ExprClause),
9811}
9812#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9813pub struct OptionExprClausePtr(pub SyntaxStablePtrId);
9814impl TypedStablePtr for OptionExprClausePtr {
9815 type SyntaxNode = OptionExprClause;
9816 fn untyped(&self) -> SyntaxStablePtrId {
9817 self.0
9818 }
9819 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
9820 OptionExprClause::from_syntax_node(db, self.0.lookup(db))
9821 }
9822}
9823impl From<OptionExprClausePtr> for SyntaxStablePtrId {
9824 fn from(ptr: OptionExprClausePtr) -> Self {
9825 ptr.untyped()
9826 }
9827}
9828impl From<OptionExprClauseEmptyPtr> for OptionExprClausePtr {
9829 fn from(value: OptionExprClauseEmptyPtr) -> Self {
9830 Self(value.0)
9831 }
9832}
9833impl From<ExprClausePtr> for OptionExprClausePtr {
9834 fn from(value: ExprClausePtr) -> Self {
9835 Self(value.0)
9836 }
9837}
9838impl From<OptionExprClauseEmptyGreen> for OptionExprClauseGreen {
9839 fn from(value: OptionExprClauseEmptyGreen) -> Self {
9840 Self(value.0)
9841 }
9842}
9843impl From<ExprClauseGreen> for OptionExprClauseGreen {
9844 fn from(value: ExprClauseGreen) -> Self {
9845 Self(value.0)
9846 }
9847}
9848#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9849pub struct OptionExprClauseGreen(pub GreenId);
9850impl TypedSyntaxNode for OptionExprClause {
9851 const OPTIONAL_KIND: Option<SyntaxKind> = None;
9852 type StablePtr = OptionExprClausePtr;
9853 type Green = OptionExprClauseGreen;
9854 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9855 panic!("No missing variant.");
9856 }
9857 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9858 let kind = node.kind(db);
9859 match kind {
9860 SyntaxKind::OptionExprClauseEmpty => {
9861 OptionExprClause::Empty(OptionExprClauseEmpty::from_syntax_node(db, node))
9862 }
9863 SyntaxKind::ExprClause => {
9864 OptionExprClause::ExprClause(ExprClause::from_syntax_node(db, node))
9865 }
9866 _ => panic!(
9867 "Unexpected syntax kind {:?} when constructing {}.",
9868 kind, "OptionExprClause"
9869 ),
9870 }
9871 }
9872 fn as_syntax_node(&self) -> SyntaxNode {
9873 match self {
9874 OptionExprClause::Empty(x) => x.as_syntax_node(),
9875 OptionExprClause::ExprClause(x) => x.as_syntax_node(),
9876 }
9877 }
9878 fn stable_ptr(&self) -> Self::StablePtr {
9879 OptionExprClausePtr(self.as_syntax_node().0.stable_ptr)
9880 }
9881}
9882impl From<&OptionExprClause> for SyntaxStablePtrId {
9883 fn from(node: &OptionExprClause) -> Self {
9884 node.stable_ptr().untyped()
9885 }
9886}
9887impl OptionExprClause {
9888 pub fn is_variant(kind: SyntaxKind) -> bool {
9890 matches!(kind, SyntaxKind::OptionExprClauseEmpty | SyntaxKind::ExprClause)
9891 }
9892}
9893#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9894pub struct OptionExprClauseEmpty {
9895 node: SyntaxNode,
9896 children: Arc<[SyntaxNode]>,
9897}
9898impl OptionExprClauseEmpty {
9899 pub fn new_green(db: &dyn SyntaxGroup) -> OptionExprClauseEmptyGreen {
9900 let children: Vec<GreenId> = vec![];
9901 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9902 OptionExprClauseEmptyGreen(
9903 Arc::new(GreenNode {
9904 kind: SyntaxKind::OptionExprClauseEmpty,
9905 details: GreenNodeDetails::Node { children, width },
9906 })
9907 .intern(db),
9908 )
9909 }
9910}
9911impl OptionExprClauseEmpty {}
9912#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9913pub struct OptionExprClauseEmptyPtr(pub SyntaxStablePtrId);
9914impl OptionExprClauseEmptyPtr {}
9915impl TypedStablePtr for OptionExprClauseEmptyPtr {
9916 type SyntaxNode = OptionExprClauseEmpty;
9917 fn untyped(&self) -> SyntaxStablePtrId {
9918 self.0
9919 }
9920 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionExprClauseEmpty {
9921 OptionExprClauseEmpty::from_syntax_node(db, self.0.lookup(db))
9922 }
9923}
9924impl From<OptionExprClauseEmptyPtr> for SyntaxStablePtrId {
9925 fn from(ptr: OptionExprClauseEmptyPtr) -> Self {
9926 ptr.untyped()
9927 }
9928}
9929#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
9930pub struct OptionExprClauseEmptyGreen(pub GreenId);
9931impl TypedSyntaxNode for OptionExprClauseEmpty {
9932 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionExprClauseEmpty);
9933 type StablePtr = OptionExprClauseEmptyPtr;
9934 type Green = OptionExprClauseEmptyGreen;
9935 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
9936 OptionExprClauseEmptyGreen(
9937 Arc::new(GreenNode {
9938 kind: SyntaxKind::OptionExprClauseEmpty,
9939 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
9940 })
9941 .intern(db),
9942 )
9943 }
9944 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
9945 let kind = node.kind(db);
9946 assert_eq!(
9947 kind,
9948 SyntaxKind::OptionExprClauseEmpty,
9949 "Unexpected SyntaxKind {:?}. Expected {:?}.",
9950 kind,
9951 SyntaxKind::OptionExprClauseEmpty
9952 );
9953 let children = db.get_children(node.clone());
9954 Self { node, children }
9955 }
9956 fn as_syntax_node(&self) -> SyntaxNode {
9957 self.node.clone()
9958 }
9959 fn stable_ptr(&self) -> Self::StablePtr {
9960 OptionExprClauseEmptyPtr(self.node.0.stable_ptr)
9961 }
9962}
9963impl From<&OptionExprClauseEmpty> for SyntaxStablePtrId {
9964 fn from(node: &OptionExprClauseEmpty) -> Self {
9965 node.stable_ptr().untyped()
9966 }
9967}
9968#[derive(Clone, Debug, Eq, Hash, PartialEq)]
9969pub struct StatementReturn {
9970 node: SyntaxNode,
9971 children: Arc<[SyntaxNode]>,
9972}
9973impl StatementReturn {
9974 pub const INDEX_ATTRIBUTES: usize = 0;
9975 pub const INDEX_RETURN_KW: usize = 1;
9976 pub const INDEX_EXPR_CLAUSE: usize = 2;
9977 pub const INDEX_SEMICOLON: usize = 3;
9978 pub fn new_green(
9979 db: &dyn SyntaxGroup,
9980 attributes: AttributeListGreen,
9981 return_kw: TerminalReturnGreen,
9982 expr_clause: OptionExprClauseGreen,
9983 semicolon: TerminalSemicolonGreen,
9984 ) -> StatementReturnGreen {
9985 let children: Vec<GreenId> = vec![attributes.0, return_kw.0, expr_clause.0, semicolon.0];
9986 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
9987 StatementReturnGreen(
9988 Arc::new(GreenNode {
9989 kind: SyntaxKind::StatementReturn,
9990 details: GreenNodeDetails::Node { children, width },
9991 })
9992 .intern(db),
9993 )
9994 }
9995}
9996impl StatementReturn {
9997 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
9998 AttributeList::from_syntax_node(db, self.children[0].clone())
9999 }
10000 pub fn return_kw(&self, db: &dyn SyntaxGroup) -> TerminalReturn {
10001 TerminalReturn::from_syntax_node(db, self.children[1].clone())
10002 }
10003 pub fn expr_clause(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
10004 OptionExprClause::from_syntax_node(db, self.children[2].clone())
10005 }
10006 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
10007 TerminalSemicolon::from_syntax_node(db, self.children[3].clone())
10008 }
10009}
10010#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10011pub struct StatementReturnPtr(pub SyntaxStablePtrId);
10012impl StatementReturnPtr {}
10013impl TypedStablePtr for StatementReturnPtr {
10014 type SyntaxNode = StatementReturn;
10015 fn untyped(&self) -> SyntaxStablePtrId {
10016 self.0
10017 }
10018 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementReturn {
10019 StatementReturn::from_syntax_node(db, self.0.lookup(db))
10020 }
10021}
10022impl From<StatementReturnPtr> for SyntaxStablePtrId {
10023 fn from(ptr: StatementReturnPtr) -> Self {
10024 ptr.untyped()
10025 }
10026}
10027#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10028pub struct StatementReturnGreen(pub GreenId);
10029impl TypedSyntaxNode for StatementReturn {
10030 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementReturn);
10031 type StablePtr = StatementReturnPtr;
10032 type Green = StatementReturnGreen;
10033 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10034 StatementReturnGreen(
10035 Arc::new(GreenNode {
10036 kind: SyntaxKind::StatementReturn,
10037 details: GreenNodeDetails::Node {
10038 children: vec![
10039 AttributeList::missing(db).0,
10040 TerminalReturn::missing(db).0,
10041 OptionExprClause::missing(db).0,
10042 TerminalSemicolon::missing(db).0,
10043 ],
10044 width: TextWidth::default(),
10045 },
10046 })
10047 .intern(db),
10048 )
10049 }
10050 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10051 let kind = node.kind(db);
10052 assert_eq!(
10053 kind,
10054 SyntaxKind::StatementReturn,
10055 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10056 kind,
10057 SyntaxKind::StatementReturn
10058 );
10059 let children = db.get_children(node.clone());
10060 Self { node, children }
10061 }
10062 fn as_syntax_node(&self) -> SyntaxNode {
10063 self.node.clone()
10064 }
10065 fn stable_ptr(&self) -> Self::StablePtr {
10066 StatementReturnPtr(self.node.0.stable_ptr)
10067 }
10068}
10069impl From<&StatementReturn> for SyntaxStablePtrId {
10070 fn from(node: &StatementReturn) -> Self {
10071 node.stable_ptr().untyped()
10072 }
10073}
10074#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10075pub struct StatementBreak {
10076 node: SyntaxNode,
10077 children: Arc<[SyntaxNode]>,
10078}
10079impl StatementBreak {
10080 pub const INDEX_ATTRIBUTES: usize = 0;
10081 pub const INDEX_BREAK_KW: usize = 1;
10082 pub const INDEX_EXPR_CLAUSE: usize = 2;
10083 pub const INDEX_SEMICOLON: usize = 3;
10084 pub fn new_green(
10085 db: &dyn SyntaxGroup,
10086 attributes: AttributeListGreen,
10087 break_kw: TerminalBreakGreen,
10088 expr_clause: OptionExprClauseGreen,
10089 semicolon: TerminalSemicolonGreen,
10090 ) -> StatementBreakGreen {
10091 let children: Vec<GreenId> = vec![attributes.0, break_kw.0, expr_clause.0, semicolon.0];
10092 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10093 StatementBreakGreen(
10094 Arc::new(GreenNode {
10095 kind: SyntaxKind::StatementBreak,
10096 details: GreenNodeDetails::Node { children, width },
10097 })
10098 .intern(db),
10099 )
10100 }
10101}
10102impl StatementBreak {
10103 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
10104 AttributeList::from_syntax_node(db, self.children[0].clone())
10105 }
10106 pub fn break_kw(&self, db: &dyn SyntaxGroup) -> TerminalBreak {
10107 TerminalBreak::from_syntax_node(db, self.children[1].clone())
10108 }
10109 pub fn expr_clause(&self, db: &dyn SyntaxGroup) -> OptionExprClause {
10110 OptionExprClause::from_syntax_node(db, self.children[2].clone())
10111 }
10112 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
10113 TerminalSemicolon::from_syntax_node(db, self.children[3].clone())
10114 }
10115}
10116#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10117pub struct StatementBreakPtr(pub SyntaxStablePtrId);
10118impl StatementBreakPtr {}
10119impl TypedStablePtr for StatementBreakPtr {
10120 type SyntaxNode = StatementBreak;
10121 fn untyped(&self) -> SyntaxStablePtrId {
10122 self.0
10123 }
10124 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementBreak {
10125 StatementBreak::from_syntax_node(db, self.0.lookup(db))
10126 }
10127}
10128impl From<StatementBreakPtr> for SyntaxStablePtrId {
10129 fn from(ptr: StatementBreakPtr) -> Self {
10130 ptr.untyped()
10131 }
10132}
10133#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10134pub struct StatementBreakGreen(pub GreenId);
10135impl TypedSyntaxNode for StatementBreak {
10136 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementBreak);
10137 type StablePtr = StatementBreakPtr;
10138 type Green = StatementBreakGreen;
10139 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10140 StatementBreakGreen(
10141 Arc::new(GreenNode {
10142 kind: SyntaxKind::StatementBreak,
10143 details: GreenNodeDetails::Node {
10144 children: vec![
10145 AttributeList::missing(db).0,
10146 TerminalBreak::missing(db).0,
10147 OptionExprClause::missing(db).0,
10148 TerminalSemicolon::missing(db).0,
10149 ],
10150 width: TextWidth::default(),
10151 },
10152 })
10153 .intern(db),
10154 )
10155 }
10156 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10157 let kind = node.kind(db);
10158 assert_eq!(
10159 kind,
10160 SyntaxKind::StatementBreak,
10161 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10162 kind,
10163 SyntaxKind::StatementBreak
10164 );
10165 let children = db.get_children(node.clone());
10166 Self { node, children }
10167 }
10168 fn as_syntax_node(&self) -> SyntaxNode {
10169 self.node.clone()
10170 }
10171 fn stable_ptr(&self) -> Self::StablePtr {
10172 StatementBreakPtr(self.node.0.stable_ptr)
10173 }
10174}
10175impl From<&StatementBreak> for SyntaxStablePtrId {
10176 fn from(node: &StatementBreak) -> Self {
10177 node.stable_ptr().untyped()
10178 }
10179}
10180#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10181pub struct StatementItem {
10182 node: SyntaxNode,
10183 children: Arc<[SyntaxNode]>,
10184}
10185impl StatementItem {
10186 pub const INDEX_ITEM: usize = 0;
10187 pub fn new_green(db: &dyn SyntaxGroup, item: ModuleItemGreen) -> StatementItemGreen {
10188 let children: Vec<GreenId> = vec![item.0];
10189 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10190 StatementItemGreen(
10191 Arc::new(GreenNode {
10192 kind: SyntaxKind::StatementItem,
10193 details: GreenNodeDetails::Node { children, width },
10194 })
10195 .intern(db),
10196 )
10197 }
10198}
10199impl StatementItem {
10200 pub fn item(&self, db: &dyn SyntaxGroup) -> ModuleItem {
10201 ModuleItem::from_syntax_node(db, self.children[0].clone())
10202 }
10203}
10204#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10205pub struct StatementItemPtr(pub SyntaxStablePtrId);
10206impl StatementItemPtr {}
10207impl TypedStablePtr for StatementItemPtr {
10208 type SyntaxNode = StatementItem;
10209 fn untyped(&self) -> SyntaxStablePtrId {
10210 self.0
10211 }
10212 fn lookup(&self, db: &dyn SyntaxGroup) -> StatementItem {
10213 StatementItem::from_syntax_node(db, self.0.lookup(db))
10214 }
10215}
10216impl From<StatementItemPtr> for SyntaxStablePtrId {
10217 fn from(ptr: StatementItemPtr) -> Self {
10218 ptr.untyped()
10219 }
10220}
10221#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10222pub struct StatementItemGreen(pub GreenId);
10223impl TypedSyntaxNode for StatementItem {
10224 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::StatementItem);
10225 type StablePtr = StatementItemPtr;
10226 type Green = StatementItemGreen;
10227 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10228 StatementItemGreen(
10229 Arc::new(GreenNode {
10230 kind: SyntaxKind::StatementItem,
10231 details: GreenNodeDetails::Node {
10232 children: vec![ModuleItem::missing(db).0],
10233 width: TextWidth::default(),
10234 },
10235 })
10236 .intern(db),
10237 )
10238 }
10239 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10240 let kind = node.kind(db);
10241 assert_eq!(
10242 kind,
10243 SyntaxKind::StatementItem,
10244 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10245 kind,
10246 SyntaxKind::StatementItem
10247 );
10248 let children = db.get_children(node.clone());
10249 Self { node, children }
10250 }
10251 fn as_syntax_node(&self) -> SyntaxNode {
10252 self.node.clone()
10253 }
10254 fn stable_ptr(&self) -> Self::StablePtr {
10255 StatementItemPtr(self.node.0.stable_ptr)
10256 }
10257}
10258impl From<&StatementItem> for SyntaxStablePtrId {
10259 fn from(node: &StatementItem) -> Self {
10260 node.stable_ptr().untyped()
10261 }
10262}
10263#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10264pub struct Param {
10265 node: SyntaxNode,
10266 children: Arc<[SyntaxNode]>,
10267}
10268impl Param {
10269 pub const INDEX_MODIFIERS: usize = 0;
10270 pub const INDEX_NAME: usize = 1;
10271 pub const INDEX_TYPE_CLAUSE: usize = 2;
10272 pub fn new_green(
10273 db: &dyn SyntaxGroup,
10274 modifiers: ModifierListGreen,
10275 name: TerminalIdentifierGreen,
10276 type_clause: OptionTypeClauseGreen,
10277 ) -> ParamGreen {
10278 let children: Vec<GreenId> = vec![modifiers.0, name.0, type_clause.0];
10279 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10280 ParamGreen(
10281 Arc::new(GreenNode {
10282 kind: SyntaxKind::Param,
10283 details: GreenNodeDetails::Node { children, width },
10284 })
10285 .intern(db),
10286 )
10287 }
10288}
10289impl Param {
10290 pub fn modifiers(&self, db: &dyn SyntaxGroup) -> ModifierList {
10291 ModifierList::from_syntax_node(db, self.children[0].clone())
10292 }
10293 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
10294 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
10295 }
10296 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
10297 OptionTypeClause::from_syntax_node(db, self.children[2].clone())
10298 }
10299}
10300#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10301pub struct ParamPtr(pub SyntaxStablePtrId);
10302impl ParamPtr {
10303 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
10304 let ptr = self.0.lookup_intern(db);
10305 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
10306 TerminalIdentifierGreen(key_fields[0])
10307 } else {
10308 panic!("Unexpected key field query on root.");
10309 }
10310 }
10311}
10312impl TypedStablePtr for ParamPtr {
10313 type SyntaxNode = Param;
10314 fn untyped(&self) -> SyntaxStablePtrId {
10315 self.0
10316 }
10317 fn lookup(&self, db: &dyn SyntaxGroup) -> Param {
10318 Param::from_syntax_node(db, self.0.lookup(db))
10319 }
10320}
10321impl From<ParamPtr> for SyntaxStablePtrId {
10322 fn from(ptr: ParamPtr) -> Self {
10323 ptr.untyped()
10324 }
10325}
10326#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10327pub struct ParamGreen(pub GreenId);
10328impl TypedSyntaxNode for Param {
10329 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Param);
10330 type StablePtr = ParamPtr;
10331 type Green = ParamGreen;
10332 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10333 ParamGreen(
10334 Arc::new(GreenNode {
10335 kind: SyntaxKind::Param,
10336 details: GreenNodeDetails::Node {
10337 children: vec![
10338 ModifierList::missing(db).0,
10339 TerminalIdentifier::missing(db).0,
10340 OptionTypeClause::missing(db).0,
10341 ],
10342 width: TextWidth::default(),
10343 },
10344 })
10345 .intern(db),
10346 )
10347 }
10348 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10349 let kind = node.kind(db);
10350 assert_eq!(
10351 kind,
10352 SyntaxKind::Param,
10353 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10354 kind,
10355 SyntaxKind::Param
10356 );
10357 let children = db.get_children(node.clone());
10358 Self { node, children }
10359 }
10360 fn as_syntax_node(&self) -> SyntaxNode {
10361 self.node.clone()
10362 }
10363 fn stable_ptr(&self) -> Self::StablePtr {
10364 ParamPtr(self.node.0.stable_ptr)
10365 }
10366}
10367impl From<&Param> for SyntaxStablePtrId {
10368 fn from(node: &Param) -> Self {
10369 node.stable_ptr().untyped()
10370 }
10371}
10372#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10373pub struct ModifierList(ElementList<Modifier, 1>);
10374impl Deref for ModifierList {
10375 type Target = ElementList<Modifier, 1>;
10376 fn deref(&self) -> &Self::Target {
10377 &self.0
10378 }
10379}
10380impl ModifierList {
10381 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ModifierGreen>) -> ModifierListGreen {
10382 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
10383 ModifierListGreen(
10384 Arc::new(GreenNode {
10385 kind: SyntaxKind::ModifierList,
10386 details: GreenNodeDetails::Node {
10387 children: children.iter().map(|x| x.0).collect(),
10388 width,
10389 },
10390 })
10391 .intern(db),
10392 )
10393 }
10394}
10395#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10396pub struct ModifierListPtr(pub SyntaxStablePtrId);
10397impl TypedStablePtr for ModifierListPtr {
10398 type SyntaxNode = ModifierList;
10399 fn untyped(&self) -> SyntaxStablePtrId {
10400 self.0
10401 }
10402 fn lookup(&self, db: &dyn SyntaxGroup) -> ModifierList {
10403 ModifierList::from_syntax_node(db, self.0.lookup(db))
10404 }
10405}
10406impl From<ModifierListPtr> for SyntaxStablePtrId {
10407 fn from(ptr: ModifierListPtr) -> Self {
10408 ptr.untyped()
10409 }
10410}
10411#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10412pub struct ModifierListGreen(pub GreenId);
10413impl TypedSyntaxNode for ModifierList {
10414 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModifierList);
10415 type StablePtr = ModifierListPtr;
10416 type Green = ModifierListGreen;
10417 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10418 ModifierListGreen(
10419 Arc::new(GreenNode {
10420 kind: SyntaxKind::ModifierList,
10421 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10422 })
10423 .intern(db),
10424 )
10425 }
10426 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10427 Self(ElementList::new(node))
10428 }
10429 fn as_syntax_node(&self) -> SyntaxNode {
10430 self.node.clone()
10431 }
10432 fn stable_ptr(&self) -> Self::StablePtr {
10433 ModifierListPtr(self.node.0.stable_ptr)
10434 }
10435}
10436impl From<&ModifierList> for SyntaxStablePtrId {
10437 fn from(node: &ModifierList) -> Self {
10438 node.stable_ptr().untyped()
10439 }
10440}
10441#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10442pub enum Modifier {
10443 Ref(TerminalRef),
10444 Mut(TerminalMut),
10445}
10446#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10447pub struct ModifierPtr(pub SyntaxStablePtrId);
10448impl TypedStablePtr for ModifierPtr {
10449 type SyntaxNode = Modifier;
10450 fn untyped(&self) -> SyntaxStablePtrId {
10451 self.0
10452 }
10453 fn lookup(&self, db: &dyn SyntaxGroup) -> Modifier {
10454 Modifier::from_syntax_node(db, self.0.lookup(db))
10455 }
10456}
10457impl From<ModifierPtr> for SyntaxStablePtrId {
10458 fn from(ptr: ModifierPtr) -> Self {
10459 ptr.untyped()
10460 }
10461}
10462impl From<TerminalRefPtr> for ModifierPtr {
10463 fn from(value: TerminalRefPtr) -> Self {
10464 Self(value.0)
10465 }
10466}
10467impl From<TerminalMutPtr> for ModifierPtr {
10468 fn from(value: TerminalMutPtr) -> Self {
10469 Self(value.0)
10470 }
10471}
10472impl From<TerminalRefGreen> for ModifierGreen {
10473 fn from(value: TerminalRefGreen) -> Self {
10474 Self(value.0)
10475 }
10476}
10477impl From<TerminalMutGreen> for ModifierGreen {
10478 fn from(value: TerminalMutGreen) -> Self {
10479 Self(value.0)
10480 }
10481}
10482#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10483pub struct ModifierGreen(pub GreenId);
10484impl TypedSyntaxNode for Modifier {
10485 const OPTIONAL_KIND: Option<SyntaxKind> = None;
10486 type StablePtr = ModifierPtr;
10487 type Green = ModifierGreen;
10488 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10489 panic!("No missing variant.");
10490 }
10491 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10492 let kind = node.kind(db);
10493 match kind {
10494 SyntaxKind::TerminalRef => Modifier::Ref(TerminalRef::from_syntax_node(db, node)),
10495 SyntaxKind::TerminalMut => Modifier::Mut(TerminalMut::from_syntax_node(db, node)),
10496 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Modifier"),
10497 }
10498 }
10499 fn as_syntax_node(&self) -> SyntaxNode {
10500 match self {
10501 Modifier::Ref(x) => x.as_syntax_node(),
10502 Modifier::Mut(x) => x.as_syntax_node(),
10503 }
10504 }
10505 fn stable_ptr(&self) -> Self::StablePtr {
10506 ModifierPtr(self.as_syntax_node().0.stable_ptr)
10507 }
10508}
10509impl From<&Modifier> for SyntaxStablePtrId {
10510 fn from(node: &Modifier) -> Self {
10511 node.stable_ptr().untyped()
10512 }
10513}
10514impl Modifier {
10515 pub fn is_variant(kind: SyntaxKind) -> bool {
10517 matches!(kind, SyntaxKind::TerminalRef | SyntaxKind::TerminalMut)
10518 }
10519}
10520#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10521pub struct ParamList(ElementList<Param, 2>);
10522impl Deref for ParamList {
10523 type Target = ElementList<Param, 2>;
10524 fn deref(&self) -> &Self::Target {
10525 &self.0
10526 }
10527}
10528impl ParamList {
10529 pub fn new_green(
10530 db: &dyn SyntaxGroup,
10531 children: Vec<ParamListElementOrSeparatorGreen>,
10532 ) -> ParamListGreen {
10533 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
10534 ParamListGreen(
10535 Arc::new(GreenNode {
10536 kind: SyntaxKind::ParamList,
10537 details: GreenNodeDetails::Node {
10538 children: children.iter().map(|x| x.id()).collect(),
10539 width,
10540 },
10541 })
10542 .intern(db),
10543 )
10544 }
10545}
10546#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10547pub struct ParamListPtr(pub SyntaxStablePtrId);
10548impl TypedStablePtr for ParamListPtr {
10549 type SyntaxNode = ParamList;
10550 fn untyped(&self) -> SyntaxStablePtrId {
10551 self.0
10552 }
10553 fn lookup(&self, db: &dyn SyntaxGroup) -> ParamList {
10554 ParamList::from_syntax_node(db, self.0.lookup(db))
10555 }
10556}
10557impl From<ParamListPtr> for SyntaxStablePtrId {
10558 fn from(ptr: ParamListPtr) -> Self {
10559 ptr.untyped()
10560 }
10561}
10562#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10563pub enum ParamListElementOrSeparatorGreen {
10564 Separator(TerminalCommaGreen),
10565 Element(ParamGreen),
10566}
10567impl From<TerminalCommaGreen> for ParamListElementOrSeparatorGreen {
10568 fn from(value: TerminalCommaGreen) -> Self {
10569 ParamListElementOrSeparatorGreen::Separator(value)
10570 }
10571}
10572impl From<ParamGreen> for ParamListElementOrSeparatorGreen {
10573 fn from(value: ParamGreen) -> Self {
10574 ParamListElementOrSeparatorGreen::Element(value)
10575 }
10576}
10577impl ParamListElementOrSeparatorGreen {
10578 fn id(&self) -> GreenId {
10579 match self {
10580 ParamListElementOrSeparatorGreen::Separator(green) => green.0,
10581 ParamListElementOrSeparatorGreen::Element(green) => green.0,
10582 }
10583 }
10584}
10585#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10586pub struct ParamListGreen(pub GreenId);
10587impl TypedSyntaxNode for ParamList {
10588 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ParamList);
10589 type StablePtr = ParamListPtr;
10590 type Green = ParamListGreen;
10591 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10592 ParamListGreen(
10593 Arc::new(GreenNode {
10594 kind: SyntaxKind::ParamList,
10595 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10596 })
10597 .intern(db),
10598 )
10599 }
10600 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10601 Self(ElementList::new(node))
10602 }
10603 fn as_syntax_node(&self) -> SyntaxNode {
10604 self.node.clone()
10605 }
10606 fn stable_ptr(&self) -> Self::StablePtr {
10607 ParamListPtr(self.node.0.stable_ptr)
10608 }
10609}
10610impl From<&ParamList> for SyntaxStablePtrId {
10611 fn from(node: &ParamList) -> Self {
10612 node.stable_ptr().untyped()
10613 }
10614}
10615#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10616pub struct ImplicitsClause {
10617 node: SyntaxNode,
10618 children: Arc<[SyntaxNode]>,
10619}
10620impl ImplicitsClause {
10621 pub const INDEX_IMPLICITS_KW: usize = 0;
10622 pub const INDEX_LPAREN: usize = 1;
10623 pub const INDEX_IMPLICITS: usize = 2;
10624 pub const INDEX_RPAREN: usize = 3;
10625 pub fn new_green(
10626 db: &dyn SyntaxGroup,
10627 implicits_kw: TerminalImplicitsGreen,
10628 lparen: TerminalLParenGreen,
10629 implicits: ImplicitsListGreen,
10630 rparen: TerminalRParenGreen,
10631 ) -> ImplicitsClauseGreen {
10632 let children: Vec<GreenId> = vec![implicits_kw.0, lparen.0, implicits.0, rparen.0];
10633 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10634 ImplicitsClauseGreen(
10635 Arc::new(GreenNode {
10636 kind: SyntaxKind::ImplicitsClause,
10637 details: GreenNodeDetails::Node { children, width },
10638 })
10639 .intern(db),
10640 )
10641 }
10642}
10643impl ImplicitsClause {
10644 pub fn implicits_kw(&self, db: &dyn SyntaxGroup) -> TerminalImplicits {
10645 TerminalImplicits::from_syntax_node(db, self.children[0].clone())
10646 }
10647 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
10648 TerminalLParen::from_syntax_node(db, self.children[1].clone())
10649 }
10650 pub fn implicits(&self, db: &dyn SyntaxGroup) -> ImplicitsList {
10651 ImplicitsList::from_syntax_node(db, self.children[2].clone())
10652 }
10653 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
10654 TerminalRParen::from_syntax_node(db, self.children[3].clone())
10655 }
10656}
10657#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10658pub struct ImplicitsClausePtr(pub SyntaxStablePtrId);
10659impl ImplicitsClausePtr {}
10660impl TypedStablePtr for ImplicitsClausePtr {
10661 type SyntaxNode = ImplicitsClause;
10662 fn untyped(&self) -> SyntaxStablePtrId {
10663 self.0
10664 }
10665 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplicitsClause {
10666 ImplicitsClause::from_syntax_node(db, self.0.lookup(db))
10667 }
10668}
10669impl From<ImplicitsClausePtr> for SyntaxStablePtrId {
10670 fn from(ptr: ImplicitsClausePtr) -> Self {
10671 ptr.untyped()
10672 }
10673}
10674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10675pub struct ImplicitsClauseGreen(pub GreenId);
10676impl TypedSyntaxNode for ImplicitsClause {
10677 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplicitsClause);
10678 type StablePtr = ImplicitsClausePtr;
10679 type Green = ImplicitsClauseGreen;
10680 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10681 ImplicitsClauseGreen(
10682 Arc::new(GreenNode {
10683 kind: SyntaxKind::ImplicitsClause,
10684 details: GreenNodeDetails::Node {
10685 children: vec![
10686 TerminalImplicits::missing(db).0,
10687 TerminalLParen::missing(db).0,
10688 ImplicitsList::missing(db).0,
10689 TerminalRParen::missing(db).0,
10690 ],
10691 width: TextWidth::default(),
10692 },
10693 })
10694 .intern(db),
10695 )
10696 }
10697 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10698 let kind = node.kind(db);
10699 assert_eq!(
10700 kind,
10701 SyntaxKind::ImplicitsClause,
10702 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10703 kind,
10704 SyntaxKind::ImplicitsClause
10705 );
10706 let children = db.get_children(node.clone());
10707 Self { node, children }
10708 }
10709 fn as_syntax_node(&self) -> SyntaxNode {
10710 self.node.clone()
10711 }
10712 fn stable_ptr(&self) -> Self::StablePtr {
10713 ImplicitsClausePtr(self.node.0.stable_ptr)
10714 }
10715}
10716impl From<&ImplicitsClause> for SyntaxStablePtrId {
10717 fn from(node: &ImplicitsClause) -> Self {
10718 node.stable_ptr().untyped()
10719 }
10720}
10721#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10722pub struct ImplicitsList(ElementList<ExprPath, 2>);
10723impl Deref for ImplicitsList {
10724 type Target = ElementList<ExprPath, 2>;
10725 fn deref(&self) -> &Self::Target {
10726 &self.0
10727 }
10728}
10729impl ImplicitsList {
10730 pub fn new_green(
10731 db: &dyn SyntaxGroup,
10732 children: Vec<ImplicitsListElementOrSeparatorGreen>,
10733 ) -> ImplicitsListGreen {
10734 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
10735 ImplicitsListGreen(
10736 Arc::new(GreenNode {
10737 kind: SyntaxKind::ImplicitsList,
10738 details: GreenNodeDetails::Node {
10739 children: children.iter().map(|x| x.id()).collect(),
10740 width,
10741 },
10742 })
10743 .intern(db),
10744 )
10745 }
10746}
10747#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10748pub struct ImplicitsListPtr(pub SyntaxStablePtrId);
10749impl TypedStablePtr for ImplicitsListPtr {
10750 type SyntaxNode = ImplicitsList;
10751 fn untyped(&self) -> SyntaxStablePtrId {
10752 self.0
10753 }
10754 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplicitsList {
10755 ImplicitsList::from_syntax_node(db, self.0.lookup(db))
10756 }
10757}
10758impl From<ImplicitsListPtr> for SyntaxStablePtrId {
10759 fn from(ptr: ImplicitsListPtr) -> Self {
10760 ptr.untyped()
10761 }
10762}
10763#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10764pub enum ImplicitsListElementOrSeparatorGreen {
10765 Separator(TerminalCommaGreen),
10766 Element(ExprPathGreen),
10767}
10768impl From<TerminalCommaGreen> for ImplicitsListElementOrSeparatorGreen {
10769 fn from(value: TerminalCommaGreen) -> Self {
10770 ImplicitsListElementOrSeparatorGreen::Separator(value)
10771 }
10772}
10773impl From<ExprPathGreen> for ImplicitsListElementOrSeparatorGreen {
10774 fn from(value: ExprPathGreen) -> Self {
10775 ImplicitsListElementOrSeparatorGreen::Element(value)
10776 }
10777}
10778impl ImplicitsListElementOrSeparatorGreen {
10779 fn id(&self) -> GreenId {
10780 match self {
10781 ImplicitsListElementOrSeparatorGreen::Separator(green) => green.0,
10782 ImplicitsListElementOrSeparatorGreen::Element(green) => green.0,
10783 }
10784 }
10785}
10786#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10787pub struct ImplicitsListGreen(pub GreenId);
10788impl TypedSyntaxNode for ImplicitsList {
10789 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplicitsList);
10790 type StablePtr = ImplicitsListPtr;
10791 type Green = ImplicitsListGreen;
10792 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10793 ImplicitsListGreen(
10794 Arc::new(GreenNode {
10795 kind: SyntaxKind::ImplicitsList,
10796 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10797 })
10798 .intern(db),
10799 )
10800 }
10801 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10802 Self(ElementList::new(node))
10803 }
10804 fn as_syntax_node(&self) -> SyntaxNode {
10805 self.node.clone()
10806 }
10807 fn stable_ptr(&self) -> Self::StablePtr {
10808 ImplicitsListPtr(self.node.0.stable_ptr)
10809 }
10810}
10811impl From<&ImplicitsList> for SyntaxStablePtrId {
10812 fn from(node: &ImplicitsList) -> Self {
10813 node.stable_ptr().untyped()
10814 }
10815}
10816#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10817pub enum OptionImplicitsClause {
10818 Empty(OptionImplicitsClauseEmpty),
10819 ImplicitsClause(ImplicitsClause),
10820}
10821#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10822pub struct OptionImplicitsClausePtr(pub SyntaxStablePtrId);
10823impl TypedStablePtr for OptionImplicitsClausePtr {
10824 type SyntaxNode = OptionImplicitsClause;
10825 fn untyped(&self) -> SyntaxStablePtrId {
10826 self.0
10827 }
10828 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClause {
10829 OptionImplicitsClause::from_syntax_node(db, self.0.lookup(db))
10830 }
10831}
10832impl From<OptionImplicitsClausePtr> for SyntaxStablePtrId {
10833 fn from(ptr: OptionImplicitsClausePtr) -> Self {
10834 ptr.untyped()
10835 }
10836}
10837impl From<OptionImplicitsClauseEmptyPtr> for OptionImplicitsClausePtr {
10838 fn from(value: OptionImplicitsClauseEmptyPtr) -> Self {
10839 Self(value.0)
10840 }
10841}
10842impl From<ImplicitsClausePtr> for OptionImplicitsClausePtr {
10843 fn from(value: ImplicitsClausePtr) -> Self {
10844 Self(value.0)
10845 }
10846}
10847impl From<OptionImplicitsClauseEmptyGreen> for OptionImplicitsClauseGreen {
10848 fn from(value: OptionImplicitsClauseEmptyGreen) -> Self {
10849 Self(value.0)
10850 }
10851}
10852impl From<ImplicitsClauseGreen> for OptionImplicitsClauseGreen {
10853 fn from(value: ImplicitsClauseGreen) -> Self {
10854 Self(value.0)
10855 }
10856}
10857#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10858pub struct OptionImplicitsClauseGreen(pub GreenId);
10859impl TypedSyntaxNode for OptionImplicitsClause {
10860 const OPTIONAL_KIND: Option<SyntaxKind> = None;
10861 type StablePtr = OptionImplicitsClausePtr;
10862 type Green = OptionImplicitsClauseGreen;
10863 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10864 panic!("No missing variant.");
10865 }
10866 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10867 let kind = node.kind(db);
10868 match kind {
10869 SyntaxKind::OptionImplicitsClauseEmpty => {
10870 OptionImplicitsClause::Empty(OptionImplicitsClauseEmpty::from_syntax_node(db, node))
10871 }
10872 SyntaxKind::ImplicitsClause => {
10873 OptionImplicitsClause::ImplicitsClause(ImplicitsClause::from_syntax_node(db, node))
10874 }
10875 _ => panic!(
10876 "Unexpected syntax kind {:?} when constructing {}.",
10877 kind, "OptionImplicitsClause"
10878 ),
10879 }
10880 }
10881 fn as_syntax_node(&self) -> SyntaxNode {
10882 match self {
10883 OptionImplicitsClause::Empty(x) => x.as_syntax_node(),
10884 OptionImplicitsClause::ImplicitsClause(x) => x.as_syntax_node(),
10885 }
10886 }
10887 fn stable_ptr(&self) -> Self::StablePtr {
10888 OptionImplicitsClausePtr(self.as_syntax_node().0.stable_ptr)
10889 }
10890}
10891impl From<&OptionImplicitsClause> for SyntaxStablePtrId {
10892 fn from(node: &OptionImplicitsClause) -> Self {
10893 node.stable_ptr().untyped()
10894 }
10895}
10896impl OptionImplicitsClause {
10897 pub fn is_variant(kind: SyntaxKind) -> bool {
10899 matches!(kind, SyntaxKind::OptionImplicitsClauseEmpty | SyntaxKind::ImplicitsClause)
10900 }
10901}
10902#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10903pub struct OptionImplicitsClauseEmpty {
10904 node: SyntaxNode,
10905 children: Arc<[SyntaxNode]>,
10906}
10907impl OptionImplicitsClauseEmpty {
10908 pub fn new_green(db: &dyn SyntaxGroup) -> OptionImplicitsClauseEmptyGreen {
10909 let children: Vec<GreenId> = vec![];
10910 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
10911 OptionImplicitsClauseEmptyGreen(
10912 Arc::new(GreenNode {
10913 kind: SyntaxKind::OptionImplicitsClauseEmpty,
10914 details: GreenNodeDetails::Node { children, width },
10915 })
10916 .intern(db),
10917 )
10918 }
10919}
10920impl OptionImplicitsClauseEmpty {}
10921#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10922pub struct OptionImplicitsClauseEmptyPtr(pub SyntaxStablePtrId);
10923impl OptionImplicitsClauseEmptyPtr {}
10924impl TypedStablePtr for OptionImplicitsClauseEmptyPtr {
10925 type SyntaxNode = OptionImplicitsClauseEmpty;
10926 fn untyped(&self) -> SyntaxStablePtrId {
10927 self.0
10928 }
10929 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClauseEmpty {
10930 OptionImplicitsClauseEmpty::from_syntax_node(db, self.0.lookup(db))
10931 }
10932}
10933impl From<OptionImplicitsClauseEmptyPtr> for SyntaxStablePtrId {
10934 fn from(ptr: OptionImplicitsClauseEmptyPtr) -> Self {
10935 ptr.untyped()
10936 }
10937}
10938#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10939pub struct OptionImplicitsClauseEmptyGreen(pub GreenId);
10940impl TypedSyntaxNode for OptionImplicitsClauseEmpty {
10941 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionImplicitsClauseEmpty);
10942 type StablePtr = OptionImplicitsClauseEmptyPtr;
10943 type Green = OptionImplicitsClauseEmptyGreen;
10944 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
10945 OptionImplicitsClauseEmptyGreen(
10946 Arc::new(GreenNode {
10947 kind: SyntaxKind::OptionImplicitsClauseEmpty,
10948 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
10949 })
10950 .intern(db),
10951 )
10952 }
10953 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
10954 let kind = node.kind(db);
10955 assert_eq!(
10956 kind,
10957 SyntaxKind::OptionImplicitsClauseEmpty,
10958 "Unexpected SyntaxKind {:?}. Expected {:?}.",
10959 kind,
10960 SyntaxKind::OptionImplicitsClauseEmpty
10961 );
10962 let children = db.get_children(node.clone());
10963 Self { node, children }
10964 }
10965 fn as_syntax_node(&self) -> SyntaxNode {
10966 self.node.clone()
10967 }
10968 fn stable_ptr(&self) -> Self::StablePtr {
10969 OptionImplicitsClauseEmptyPtr(self.node.0.stable_ptr)
10970 }
10971}
10972impl From<&OptionImplicitsClauseEmpty> for SyntaxStablePtrId {
10973 fn from(node: &OptionImplicitsClauseEmpty) -> Self {
10974 node.stable_ptr().untyped()
10975 }
10976}
10977#[derive(Clone, Debug, Eq, Hash, PartialEq)]
10978pub enum OptionTerminalNoPanic {
10979 Empty(OptionTerminalNoPanicEmpty),
10980 TerminalNoPanic(TerminalNoPanic),
10981}
10982#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
10983pub struct OptionTerminalNoPanicPtr(pub SyntaxStablePtrId);
10984impl TypedStablePtr for OptionTerminalNoPanicPtr {
10985 type SyntaxNode = OptionTerminalNoPanic;
10986 fn untyped(&self) -> SyntaxStablePtrId {
10987 self.0
10988 }
10989 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
10990 OptionTerminalNoPanic::from_syntax_node(db, self.0.lookup(db))
10991 }
10992}
10993impl From<OptionTerminalNoPanicPtr> for SyntaxStablePtrId {
10994 fn from(ptr: OptionTerminalNoPanicPtr) -> Self {
10995 ptr.untyped()
10996 }
10997}
10998impl From<OptionTerminalNoPanicEmptyPtr> for OptionTerminalNoPanicPtr {
10999 fn from(value: OptionTerminalNoPanicEmptyPtr) -> Self {
11000 Self(value.0)
11001 }
11002}
11003impl From<TerminalNoPanicPtr> for OptionTerminalNoPanicPtr {
11004 fn from(value: TerminalNoPanicPtr) -> Self {
11005 Self(value.0)
11006 }
11007}
11008impl From<OptionTerminalNoPanicEmptyGreen> for OptionTerminalNoPanicGreen {
11009 fn from(value: OptionTerminalNoPanicEmptyGreen) -> Self {
11010 Self(value.0)
11011 }
11012}
11013impl From<TerminalNoPanicGreen> for OptionTerminalNoPanicGreen {
11014 fn from(value: TerminalNoPanicGreen) -> Self {
11015 Self(value.0)
11016 }
11017}
11018#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11019pub struct OptionTerminalNoPanicGreen(pub GreenId);
11020impl TypedSyntaxNode for OptionTerminalNoPanic {
11021 const OPTIONAL_KIND: Option<SyntaxKind> = None;
11022 type StablePtr = OptionTerminalNoPanicPtr;
11023 type Green = OptionTerminalNoPanicGreen;
11024 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11025 panic!("No missing variant.");
11026 }
11027 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11028 let kind = node.kind(db);
11029 match kind {
11030 SyntaxKind::OptionTerminalNoPanicEmpty => {
11031 OptionTerminalNoPanic::Empty(OptionTerminalNoPanicEmpty::from_syntax_node(db, node))
11032 }
11033 SyntaxKind::TerminalNoPanic => {
11034 OptionTerminalNoPanic::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node))
11035 }
11036 _ => panic!(
11037 "Unexpected syntax kind {:?} when constructing {}.",
11038 kind, "OptionTerminalNoPanic"
11039 ),
11040 }
11041 }
11042 fn as_syntax_node(&self) -> SyntaxNode {
11043 match self {
11044 OptionTerminalNoPanic::Empty(x) => x.as_syntax_node(),
11045 OptionTerminalNoPanic::TerminalNoPanic(x) => x.as_syntax_node(),
11046 }
11047 }
11048 fn stable_ptr(&self) -> Self::StablePtr {
11049 OptionTerminalNoPanicPtr(self.as_syntax_node().0.stable_ptr)
11050 }
11051}
11052impl From<&OptionTerminalNoPanic> for SyntaxStablePtrId {
11053 fn from(node: &OptionTerminalNoPanic) -> Self {
11054 node.stable_ptr().untyped()
11055 }
11056}
11057impl OptionTerminalNoPanic {
11058 pub fn is_variant(kind: SyntaxKind) -> bool {
11060 matches!(kind, SyntaxKind::OptionTerminalNoPanicEmpty | SyntaxKind::TerminalNoPanic)
11061 }
11062}
11063#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11064pub struct OptionTerminalNoPanicEmpty {
11065 node: SyntaxNode,
11066 children: Arc<[SyntaxNode]>,
11067}
11068impl OptionTerminalNoPanicEmpty {
11069 pub fn new_green(db: &dyn SyntaxGroup) -> OptionTerminalNoPanicEmptyGreen {
11070 let children: Vec<GreenId> = vec![];
11071 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11072 OptionTerminalNoPanicEmptyGreen(
11073 Arc::new(GreenNode {
11074 kind: SyntaxKind::OptionTerminalNoPanicEmpty,
11075 details: GreenNodeDetails::Node { children, width },
11076 })
11077 .intern(db),
11078 )
11079 }
11080}
11081impl OptionTerminalNoPanicEmpty {}
11082#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11083pub struct OptionTerminalNoPanicEmptyPtr(pub SyntaxStablePtrId);
11084impl OptionTerminalNoPanicEmptyPtr {}
11085impl TypedStablePtr for OptionTerminalNoPanicEmptyPtr {
11086 type SyntaxNode = OptionTerminalNoPanicEmpty;
11087 fn untyped(&self) -> SyntaxStablePtrId {
11088 self.0
11089 }
11090 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanicEmpty {
11091 OptionTerminalNoPanicEmpty::from_syntax_node(db, self.0.lookup(db))
11092 }
11093}
11094impl From<OptionTerminalNoPanicEmptyPtr> for SyntaxStablePtrId {
11095 fn from(ptr: OptionTerminalNoPanicEmptyPtr) -> Self {
11096 ptr.untyped()
11097 }
11098}
11099#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11100pub struct OptionTerminalNoPanicEmptyGreen(pub GreenId);
11101impl TypedSyntaxNode for OptionTerminalNoPanicEmpty {
11102 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionTerminalNoPanicEmpty);
11103 type StablePtr = OptionTerminalNoPanicEmptyPtr;
11104 type Green = OptionTerminalNoPanicEmptyGreen;
11105 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11106 OptionTerminalNoPanicEmptyGreen(
11107 Arc::new(GreenNode {
11108 kind: SyntaxKind::OptionTerminalNoPanicEmpty,
11109 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11110 })
11111 .intern(db),
11112 )
11113 }
11114 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11115 let kind = node.kind(db);
11116 assert_eq!(
11117 kind,
11118 SyntaxKind::OptionTerminalNoPanicEmpty,
11119 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11120 kind,
11121 SyntaxKind::OptionTerminalNoPanicEmpty
11122 );
11123 let children = db.get_children(node.clone());
11124 Self { node, children }
11125 }
11126 fn as_syntax_node(&self) -> SyntaxNode {
11127 self.node.clone()
11128 }
11129 fn stable_ptr(&self) -> Self::StablePtr {
11130 OptionTerminalNoPanicEmptyPtr(self.node.0.stable_ptr)
11131 }
11132}
11133impl From<&OptionTerminalNoPanicEmpty> for SyntaxStablePtrId {
11134 fn from(node: &OptionTerminalNoPanicEmpty) -> Self {
11135 node.stable_ptr().untyped()
11136 }
11137}
11138#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11139pub struct FunctionSignature {
11140 node: SyntaxNode,
11141 children: Arc<[SyntaxNode]>,
11142}
11143impl FunctionSignature {
11144 pub const INDEX_LPAREN: usize = 0;
11145 pub const INDEX_PARAMETERS: usize = 1;
11146 pub const INDEX_RPAREN: usize = 2;
11147 pub const INDEX_RET_TY: usize = 3;
11148 pub const INDEX_IMPLICITS_CLAUSE: usize = 4;
11149 pub const INDEX_OPTIONAL_NO_PANIC: usize = 5;
11150 pub fn new_green(
11151 db: &dyn SyntaxGroup,
11152 lparen: TerminalLParenGreen,
11153 parameters: ParamListGreen,
11154 rparen: TerminalRParenGreen,
11155 ret_ty: OptionReturnTypeClauseGreen,
11156 implicits_clause: OptionImplicitsClauseGreen,
11157 optional_no_panic: OptionTerminalNoPanicGreen,
11158 ) -> FunctionSignatureGreen {
11159 let children: Vec<GreenId> = vec![
11160 lparen.0,
11161 parameters.0,
11162 rparen.0,
11163 ret_ty.0,
11164 implicits_clause.0,
11165 optional_no_panic.0,
11166 ];
11167 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11168 FunctionSignatureGreen(
11169 Arc::new(GreenNode {
11170 kind: SyntaxKind::FunctionSignature,
11171 details: GreenNodeDetails::Node { children, width },
11172 })
11173 .intern(db),
11174 )
11175 }
11176}
11177impl FunctionSignature {
11178 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
11179 TerminalLParen::from_syntax_node(db, self.children[0].clone())
11180 }
11181 pub fn parameters(&self, db: &dyn SyntaxGroup) -> ParamList {
11182 ParamList::from_syntax_node(db, self.children[1].clone())
11183 }
11184 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
11185 TerminalRParen::from_syntax_node(db, self.children[2].clone())
11186 }
11187 pub fn ret_ty(&self, db: &dyn SyntaxGroup) -> OptionReturnTypeClause {
11188 OptionReturnTypeClause::from_syntax_node(db, self.children[3].clone())
11189 }
11190 pub fn implicits_clause(&self, db: &dyn SyntaxGroup) -> OptionImplicitsClause {
11191 OptionImplicitsClause::from_syntax_node(db, self.children[4].clone())
11192 }
11193 pub fn optional_no_panic(&self, db: &dyn SyntaxGroup) -> OptionTerminalNoPanic {
11194 OptionTerminalNoPanic::from_syntax_node(db, self.children[5].clone())
11195 }
11196}
11197#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11198pub struct FunctionSignaturePtr(pub SyntaxStablePtrId);
11199impl FunctionSignaturePtr {}
11200impl TypedStablePtr for FunctionSignaturePtr {
11201 type SyntaxNode = FunctionSignature;
11202 fn untyped(&self) -> SyntaxStablePtrId {
11203 self.0
11204 }
11205 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionSignature {
11206 FunctionSignature::from_syntax_node(db, self.0.lookup(db))
11207 }
11208}
11209impl From<FunctionSignaturePtr> for SyntaxStablePtrId {
11210 fn from(ptr: FunctionSignaturePtr) -> Self {
11211 ptr.untyped()
11212 }
11213}
11214#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11215pub struct FunctionSignatureGreen(pub GreenId);
11216impl TypedSyntaxNode for FunctionSignature {
11217 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionSignature);
11218 type StablePtr = FunctionSignaturePtr;
11219 type Green = FunctionSignatureGreen;
11220 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11221 FunctionSignatureGreen(
11222 Arc::new(GreenNode {
11223 kind: SyntaxKind::FunctionSignature,
11224 details: GreenNodeDetails::Node {
11225 children: vec![
11226 TerminalLParen::missing(db).0,
11227 ParamList::missing(db).0,
11228 TerminalRParen::missing(db).0,
11229 OptionReturnTypeClause::missing(db).0,
11230 OptionImplicitsClause::missing(db).0,
11231 OptionTerminalNoPanic::missing(db).0,
11232 ],
11233 width: TextWidth::default(),
11234 },
11235 })
11236 .intern(db),
11237 )
11238 }
11239 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11240 let kind = node.kind(db);
11241 assert_eq!(
11242 kind,
11243 SyntaxKind::FunctionSignature,
11244 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11245 kind,
11246 SyntaxKind::FunctionSignature
11247 );
11248 let children = db.get_children(node.clone());
11249 Self { node, children }
11250 }
11251 fn as_syntax_node(&self) -> SyntaxNode {
11252 self.node.clone()
11253 }
11254 fn stable_ptr(&self) -> Self::StablePtr {
11255 FunctionSignaturePtr(self.node.0.stable_ptr)
11256 }
11257}
11258impl From<&FunctionSignature> for SyntaxStablePtrId {
11259 fn from(node: &FunctionSignature) -> Self {
11260 node.stable_ptr().untyped()
11261 }
11262}
11263#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11264pub struct Member {
11265 node: SyntaxNode,
11266 children: Arc<[SyntaxNode]>,
11267}
11268impl Member {
11269 pub const INDEX_ATTRIBUTES: usize = 0;
11270 pub const INDEX_VISIBILITY: usize = 1;
11271 pub const INDEX_NAME: usize = 2;
11272 pub const INDEX_TYPE_CLAUSE: usize = 3;
11273 pub fn new_green(
11274 db: &dyn SyntaxGroup,
11275 attributes: AttributeListGreen,
11276 visibility: VisibilityGreen,
11277 name: TerminalIdentifierGreen,
11278 type_clause: TypeClauseGreen,
11279 ) -> MemberGreen {
11280 let children: Vec<GreenId> = vec![attributes.0, visibility.0, name.0, type_clause.0];
11281 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11282 MemberGreen(
11283 Arc::new(GreenNode {
11284 kind: SyntaxKind::Member,
11285 details: GreenNodeDetails::Node { children, width },
11286 })
11287 .intern(db),
11288 )
11289 }
11290}
11291impl Member {
11292 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
11293 AttributeList::from_syntax_node(db, self.children[0].clone())
11294 }
11295 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
11296 Visibility::from_syntax_node(db, self.children[1].clone())
11297 }
11298 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
11299 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
11300 }
11301 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
11302 TypeClause::from_syntax_node(db, self.children[3].clone())
11303 }
11304}
11305#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11306pub struct MemberPtr(pub SyntaxStablePtrId);
11307impl MemberPtr {
11308 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
11309 let ptr = self.0.lookup_intern(db);
11310 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
11311 TerminalIdentifierGreen(key_fields[0])
11312 } else {
11313 panic!("Unexpected key field query on root.");
11314 }
11315 }
11316}
11317impl TypedStablePtr for MemberPtr {
11318 type SyntaxNode = Member;
11319 fn untyped(&self) -> SyntaxStablePtrId {
11320 self.0
11321 }
11322 fn lookup(&self, db: &dyn SyntaxGroup) -> Member {
11323 Member::from_syntax_node(db, self.0.lookup(db))
11324 }
11325}
11326impl From<MemberPtr> for SyntaxStablePtrId {
11327 fn from(ptr: MemberPtr) -> Self {
11328 ptr.untyped()
11329 }
11330}
11331#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11332pub struct MemberGreen(pub GreenId);
11333impl TypedSyntaxNode for Member {
11334 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Member);
11335 type StablePtr = MemberPtr;
11336 type Green = MemberGreen;
11337 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11338 MemberGreen(
11339 Arc::new(GreenNode {
11340 kind: SyntaxKind::Member,
11341 details: GreenNodeDetails::Node {
11342 children: vec![
11343 AttributeList::missing(db).0,
11344 Visibility::missing(db).0,
11345 TerminalIdentifier::missing(db).0,
11346 TypeClause::missing(db).0,
11347 ],
11348 width: TextWidth::default(),
11349 },
11350 })
11351 .intern(db),
11352 )
11353 }
11354 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11355 let kind = node.kind(db);
11356 assert_eq!(
11357 kind,
11358 SyntaxKind::Member,
11359 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11360 kind,
11361 SyntaxKind::Member
11362 );
11363 let children = db.get_children(node.clone());
11364 Self { node, children }
11365 }
11366 fn as_syntax_node(&self) -> SyntaxNode {
11367 self.node.clone()
11368 }
11369 fn stable_ptr(&self) -> Self::StablePtr {
11370 MemberPtr(self.node.0.stable_ptr)
11371 }
11372}
11373impl From<&Member> for SyntaxStablePtrId {
11374 fn from(node: &Member) -> Self {
11375 node.stable_ptr().untyped()
11376 }
11377}
11378#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11379pub struct MemberList(ElementList<Member, 2>);
11380impl Deref for MemberList {
11381 type Target = ElementList<Member, 2>;
11382 fn deref(&self) -> &Self::Target {
11383 &self.0
11384 }
11385}
11386impl MemberList {
11387 pub fn new_green(
11388 db: &dyn SyntaxGroup,
11389 children: Vec<MemberListElementOrSeparatorGreen>,
11390 ) -> MemberListGreen {
11391 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
11392 MemberListGreen(
11393 Arc::new(GreenNode {
11394 kind: SyntaxKind::MemberList,
11395 details: GreenNodeDetails::Node {
11396 children: children.iter().map(|x| x.id()).collect(),
11397 width,
11398 },
11399 })
11400 .intern(db),
11401 )
11402 }
11403}
11404#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11405pub struct MemberListPtr(pub SyntaxStablePtrId);
11406impl TypedStablePtr for MemberListPtr {
11407 type SyntaxNode = MemberList;
11408 fn untyped(&self) -> SyntaxStablePtrId {
11409 self.0
11410 }
11411 fn lookup(&self, db: &dyn SyntaxGroup) -> MemberList {
11412 MemberList::from_syntax_node(db, self.0.lookup(db))
11413 }
11414}
11415impl From<MemberListPtr> for SyntaxStablePtrId {
11416 fn from(ptr: MemberListPtr) -> Self {
11417 ptr.untyped()
11418 }
11419}
11420#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11421pub enum MemberListElementOrSeparatorGreen {
11422 Separator(TerminalCommaGreen),
11423 Element(MemberGreen),
11424}
11425impl From<TerminalCommaGreen> for MemberListElementOrSeparatorGreen {
11426 fn from(value: TerminalCommaGreen) -> Self {
11427 MemberListElementOrSeparatorGreen::Separator(value)
11428 }
11429}
11430impl From<MemberGreen> for MemberListElementOrSeparatorGreen {
11431 fn from(value: MemberGreen) -> Self {
11432 MemberListElementOrSeparatorGreen::Element(value)
11433 }
11434}
11435impl MemberListElementOrSeparatorGreen {
11436 fn id(&self) -> GreenId {
11437 match self {
11438 MemberListElementOrSeparatorGreen::Separator(green) => green.0,
11439 MemberListElementOrSeparatorGreen::Element(green) => green.0,
11440 }
11441 }
11442}
11443#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11444pub struct MemberListGreen(pub GreenId);
11445impl TypedSyntaxNode for MemberList {
11446 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::MemberList);
11447 type StablePtr = MemberListPtr;
11448 type Green = MemberListGreen;
11449 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11450 MemberListGreen(
11451 Arc::new(GreenNode {
11452 kind: SyntaxKind::MemberList,
11453 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11454 })
11455 .intern(db),
11456 )
11457 }
11458 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11459 Self(ElementList::new(node))
11460 }
11461 fn as_syntax_node(&self) -> SyntaxNode {
11462 self.node.clone()
11463 }
11464 fn stable_ptr(&self) -> Self::StablePtr {
11465 MemberListPtr(self.node.0.stable_ptr)
11466 }
11467}
11468impl From<&MemberList> for SyntaxStablePtrId {
11469 fn from(node: &MemberList) -> Self {
11470 node.stable_ptr().untyped()
11471 }
11472}
11473#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11474pub struct Variant {
11475 node: SyntaxNode,
11476 children: Arc<[SyntaxNode]>,
11477}
11478impl Variant {
11479 pub const INDEX_ATTRIBUTES: usize = 0;
11480 pub const INDEX_NAME: usize = 1;
11481 pub const INDEX_TYPE_CLAUSE: usize = 2;
11482 pub fn new_green(
11483 db: &dyn SyntaxGroup,
11484 attributes: AttributeListGreen,
11485 name: TerminalIdentifierGreen,
11486 type_clause: OptionTypeClauseGreen,
11487 ) -> VariantGreen {
11488 let children: Vec<GreenId> = vec![attributes.0, name.0, type_clause.0];
11489 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
11490 VariantGreen(
11491 Arc::new(GreenNode {
11492 kind: SyntaxKind::Variant,
11493 details: GreenNodeDetails::Node { children, width },
11494 })
11495 .intern(db),
11496 )
11497 }
11498}
11499impl Variant {
11500 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
11501 AttributeList::from_syntax_node(db, self.children[0].clone())
11502 }
11503 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
11504 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
11505 }
11506 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> OptionTypeClause {
11507 OptionTypeClause::from_syntax_node(db, self.children[2].clone())
11508 }
11509}
11510#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11511pub struct VariantPtr(pub SyntaxStablePtrId);
11512impl VariantPtr {
11513 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
11514 let ptr = self.0.lookup_intern(db);
11515 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
11516 TerminalIdentifierGreen(key_fields[0])
11517 } else {
11518 panic!("Unexpected key field query on root.");
11519 }
11520 }
11521}
11522impl TypedStablePtr for VariantPtr {
11523 type SyntaxNode = Variant;
11524 fn untyped(&self) -> SyntaxStablePtrId {
11525 self.0
11526 }
11527 fn lookup(&self, db: &dyn SyntaxGroup) -> Variant {
11528 Variant::from_syntax_node(db, self.0.lookup(db))
11529 }
11530}
11531impl From<VariantPtr> for SyntaxStablePtrId {
11532 fn from(ptr: VariantPtr) -> Self {
11533 ptr.untyped()
11534 }
11535}
11536#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11537pub struct VariantGreen(pub GreenId);
11538impl TypedSyntaxNode for Variant {
11539 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Variant);
11540 type StablePtr = VariantPtr;
11541 type Green = VariantGreen;
11542 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11543 VariantGreen(
11544 Arc::new(GreenNode {
11545 kind: SyntaxKind::Variant,
11546 details: GreenNodeDetails::Node {
11547 children: vec![
11548 AttributeList::missing(db).0,
11549 TerminalIdentifier::missing(db).0,
11550 OptionTypeClause::missing(db).0,
11551 ],
11552 width: TextWidth::default(),
11553 },
11554 })
11555 .intern(db),
11556 )
11557 }
11558 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11559 let kind = node.kind(db);
11560 assert_eq!(
11561 kind,
11562 SyntaxKind::Variant,
11563 "Unexpected SyntaxKind {:?}. Expected {:?}.",
11564 kind,
11565 SyntaxKind::Variant
11566 );
11567 let children = db.get_children(node.clone());
11568 Self { node, children }
11569 }
11570 fn as_syntax_node(&self) -> SyntaxNode {
11571 self.node.clone()
11572 }
11573 fn stable_ptr(&self) -> Self::StablePtr {
11574 VariantPtr(self.node.0.stable_ptr)
11575 }
11576}
11577impl From<&Variant> for SyntaxStablePtrId {
11578 fn from(node: &Variant) -> Self {
11579 node.stable_ptr().untyped()
11580 }
11581}
11582#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11583pub struct VariantList(ElementList<Variant, 2>);
11584impl Deref for VariantList {
11585 type Target = ElementList<Variant, 2>;
11586 fn deref(&self) -> &Self::Target {
11587 &self.0
11588 }
11589}
11590impl VariantList {
11591 pub fn new_green(
11592 db: &dyn SyntaxGroup,
11593 children: Vec<VariantListElementOrSeparatorGreen>,
11594 ) -> VariantListGreen {
11595 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
11596 VariantListGreen(
11597 Arc::new(GreenNode {
11598 kind: SyntaxKind::VariantList,
11599 details: GreenNodeDetails::Node {
11600 children: children.iter().map(|x| x.id()).collect(),
11601 width,
11602 },
11603 })
11604 .intern(db),
11605 )
11606 }
11607}
11608#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11609pub struct VariantListPtr(pub SyntaxStablePtrId);
11610impl TypedStablePtr for VariantListPtr {
11611 type SyntaxNode = VariantList;
11612 fn untyped(&self) -> SyntaxStablePtrId {
11613 self.0
11614 }
11615 fn lookup(&self, db: &dyn SyntaxGroup) -> VariantList {
11616 VariantList::from_syntax_node(db, self.0.lookup(db))
11617 }
11618}
11619impl From<VariantListPtr> for SyntaxStablePtrId {
11620 fn from(ptr: VariantListPtr) -> Self {
11621 ptr.untyped()
11622 }
11623}
11624#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11625pub enum VariantListElementOrSeparatorGreen {
11626 Separator(TerminalCommaGreen),
11627 Element(VariantGreen),
11628}
11629impl From<TerminalCommaGreen> for VariantListElementOrSeparatorGreen {
11630 fn from(value: TerminalCommaGreen) -> Self {
11631 VariantListElementOrSeparatorGreen::Separator(value)
11632 }
11633}
11634impl From<VariantGreen> for VariantListElementOrSeparatorGreen {
11635 fn from(value: VariantGreen) -> Self {
11636 VariantListElementOrSeparatorGreen::Element(value)
11637 }
11638}
11639impl VariantListElementOrSeparatorGreen {
11640 fn id(&self) -> GreenId {
11641 match self {
11642 VariantListElementOrSeparatorGreen::Separator(green) => green.0,
11643 VariantListElementOrSeparatorGreen::Element(green) => green.0,
11644 }
11645 }
11646}
11647#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11648pub struct VariantListGreen(pub GreenId);
11649impl TypedSyntaxNode for VariantList {
11650 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VariantList);
11651 type StablePtr = VariantListPtr;
11652 type Green = VariantListGreen;
11653 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11654 VariantListGreen(
11655 Arc::new(GreenNode {
11656 kind: SyntaxKind::VariantList,
11657 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
11658 })
11659 .intern(db),
11660 )
11661 }
11662 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11663 Self(ElementList::new(node))
11664 }
11665 fn as_syntax_node(&self) -> SyntaxNode {
11666 self.node.clone()
11667 }
11668 fn stable_ptr(&self) -> Self::StablePtr {
11669 VariantListPtr(self.node.0.stable_ptr)
11670 }
11671}
11672impl From<&VariantList> for SyntaxStablePtrId {
11673 fn from(node: &VariantList) -> Self {
11674 node.stable_ptr().untyped()
11675 }
11676}
11677#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11678pub enum ModuleItem {
11679 Constant(ItemConstant),
11680 Module(ItemModule),
11681 Use(ItemUse),
11682 FreeFunction(FunctionWithBody),
11683 ExternFunction(ItemExternFunction),
11684 ExternType(ItemExternType),
11685 Trait(ItemTrait),
11686 Impl(ItemImpl),
11687 ImplAlias(ItemImplAlias),
11688 Struct(ItemStruct),
11689 Enum(ItemEnum),
11690 TypeAlias(ItemTypeAlias),
11691 InlineMacro(ItemInlineMacro),
11692 HeaderDoc(ItemHeaderDoc),
11693 Missing(ModuleItemMissing),
11694}
11695#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11696pub struct ModuleItemPtr(pub SyntaxStablePtrId);
11697impl TypedStablePtr for ModuleItemPtr {
11698 type SyntaxNode = ModuleItem;
11699 fn untyped(&self) -> SyntaxStablePtrId {
11700 self.0
11701 }
11702 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItem {
11703 ModuleItem::from_syntax_node(db, self.0.lookup(db))
11704 }
11705}
11706impl From<ModuleItemPtr> for SyntaxStablePtrId {
11707 fn from(ptr: ModuleItemPtr) -> Self {
11708 ptr.untyped()
11709 }
11710}
11711impl From<ItemConstantPtr> for ModuleItemPtr {
11712 fn from(value: ItemConstantPtr) -> Self {
11713 Self(value.0)
11714 }
11715}
11716impl From<ItemModulePtr> for ModuleItemPtr {
11717 fn from(value: ItemModulePtr) -> Self {
11718 Self(value.0)
11719 }
11720}
11721impl From<ItemUsePtr> for ModuleItemPtr {
11722 fn from(value: ItemUsePtr) -> Self {
11723 Self(value.0)
11724 }
11725}
11726impl From<FunctionWithBodyPtr> for ModuleItemPtr {
11727 fn from(value: FunctionWithBodyPtr) -> Self {
11728 Self(value.0)
11729 }
11730}
11731impl From<ItemExternFunctionPtr> for ModuleItemPtr {
11732 fn from(value: ItemExternFunctionPtr) -> Self {
11733 Self(value.0)
11734 }
11735}
11736impl From<ItemExternTypePtr> for ModuleItemPtr {
11737 fn from(value: ItemExternTypePtr) -> Self {
11738 Self(value.0)
11739 }
11740}
11741impl From<ItemTraitPtr> for ModuleItemPtr {
11742 fn from(value: ItemTraitPtr) -> Self {
11743 Self(value.0)
11744 }
11745}
11746impl From<ItemImplPtr> for ModuleItemPtr {
11747 fn from(value: ItemImplPtr) -> Self {
11748 Self(value.0)
11749 }
11750}
11751impl From<ItemImplAliasPtr> for ModuleItemPtr {
11752 fn from(value: ItemImplAliasPtr) -> Self {
11753 Self(value.0)
11754 }
11755}
11756impl From<ItemStructPtr> for ModuleItemPtr {
11757 fn from(value: ItemStructPtr) -> Self {
11758 Self(value.0)
11759 }
11760}
11761impl From<ItemEnumPtr> for ModuleItemPtr {
11762 fn from(value: ItemEnumPtr) -> Self {
11763 Self(value.0)
11764 }
11765}
11766impl From<ItemTypeAliasPtr> for ModuleItemPtr {
11767 fn from(value: ItemTypeAliasPtr) -> Self {
11768 Self(value.0)
11769 }
11770}
11771impl From<ItemInlineMacroPtr> for ModuleItemPtr {
11772 fn from(value: ItemInlineMacroPtr) -> Self {
11773 Self(value.0)
11774 }
11775}
11776impl From<ItemHeaderDocPtr> for ModuleItemPtr {
11777 fn from(value: ItemHeaderDocPtr) -> Self {
11778 Self(value.0)
11779 }
11780}
11781impl From<ModuleItemMissingPtr> for ModuleItemPtr {
11782 fn from(value: ModuleItemMissingPtr) -> Self {
11783 Self(value.0)
11784 }
11785}
11786impl From<ItemConstantGreen> for ModuleItemGreen {
11787 fn from(value: ItemConstantGreen) -> Self {
11788 Self(value.0)
11789 }
11790}
11791impl From<ItemModuleGreen> for ModuleItemGreen {
11792 fn from(value: ItemModuleGreen) -> Self {
11793 Self(value.0)
11794 }
11795}
11796impl From<ItemUseGreen> for ModuleItemGreen {
11797 fn from(value: ItemUseGreen) -> Self {
11798 Self(value.0)
11799 }
11800}
11801impl From<FunctionWithBodyGreen> for ModuleItemGreen {
11802 fn from(value: FunctionWithBodyGreen) -> Self {
11803 Self(value.0)
11804 }
11805}
11806impl From<ItemExternFunctionGreen> for ModuleItemGreen {
11807 fn from(value: ItemExternFunctionGreen) -> Self {
11808 Self(value.0)
11809 }
11810}
11811impl From<ItemExternTypeGreen> for ModuleItemGreen {
11812 fn from(value: ItemExternTypeGreen) -> Self {
11813 Self(value.0)
11814 }
11815}
11816impl From<ItemTraitGreen> for ModuleItemGreen {
11817 fn from(value: ItemTraitGreen) -> Self {
11818 Self(value.0)
11819 }
11820}
11821impl From<ItemImplGreen> for ModuleItemGreen {
11822 fn from(value: ItemImplGreen) -> Self {
11823 Self(value.0)
11824 }
11825}
11826impl From<ItemImplAliasGreen> for ModuleItemGreen {
11827 fn from(value: ItemImplAliasGreen) -> Self {
11828 Self(value.0)
11829 }
11830}
11831impl From<ItemStructGreen> for ModuleItemGreen {
11832 fn from(value: ItemStructGreen) -> Self {
11833 Self(value.0)
11834 }
11835}
11836impl From<ItemEnumGreen> for ModuleItemGreen {
11837 fn from(value: ItemEnumGreen) -> Self {
11838 Self(value.0)
11839 }
11840}
11841impl From<ItemTypeAliasGreen> for ModuleItemGreen {
11842 fn from(value: ItemTypeAliasGreen) -> Self {
11843 Self(value.0)
11844 }
11845}
11846impl From<ItemInlineMacroGreen> for ModuleItemGreen {
11847 fn from(value: ItemInlineMacroGreen) -> Self {
11848 Self(value.0)
11849 }
11850}
11851impl From<ItemHeaderDocGreen> for ModuleItemGreen {
11852 fn from(value: ItemHeaderDocGreen) -> Self {
11853 Self(value.0)
11854 }
11855}
11856impl From<ModuleItemMissingGreen> for ModuleItemGreen {
11857 fn from(value: ModuleItemMissingGreen) -> Self {
11858 Self(value.0)
11859 }
11860}
11861#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11862pub struct ModuleItemGreen(pub GreenId);
11863impl TypedSyntaxNode for ModuleItem {
11864 const OPTIONAL_KIND: Option<SyntaxKind> = None;
11865 type StablePtr = ModuleItemPtr;
11866 type Green = ModuleItemGreen;
11867 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
11868 ModuleItemGreen(ModuleItemMissing::missing(db).0)
11869 }
11870 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
11871 let kind = node.kind(db);
11872 match kind {
11873 SyntaxKind::ItemConstant => {
11874 ModuleItem::Constant(ItemConstant::from_syntax_node(db, node))
11875 }
11876 SyntaxKind::ItemModule => ModuleItem::Module(ItemModule::from_syntax_node(db, node)),
11877 SyntaxKind::ItemUse => ModuleItem::Use(ItemUse::from_syntax_node(db, node)),
11878 SyntaxKind::FunctionWithBody => {
11879 ModuleItem::FreeFunction(FunctionWithBody::from_syntax_node(db, node))
11880 }
11881 SyntaxKind::ItemExternFunction => {
11882 ModuleItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))
11883 }
11884 SyntaxKind::ItemExternType => {
11885 ModuleItem::ExternType(ItemExternType::from_syntax_node(db, node))
11886 }
11887 SyntaxKind::ItemTrait => ModuleItem::Trait(ItemTrait::from_syntax_node(db, node)),
11888 SyntaxKind::ItemImpl => ModuleItem::Impl(ItemImpl::from_syntax_node(db, node)),
11889 SyntaxKind::ItemImplAlias => {
11890 ModuleItem::ImplAlias(ItemImplAlias::from_syntax_node(db, node))
11891 }
11892 SyntaxKind::ItemStruct => ModuleItem::Struct(ItemStruct::from_syntax_node(db, node)),
11893 SyntaxKind::ItemEnum => ModuleItem::Enum(ItemEnum::from_syntax_node(db, node)),
11894 SyntaxKind::ItemTypeAlias => {
11895 ModuleItem::TypeAlias(ItemTypeAlias::from_syntax_node(db, node))
11896 }
11897 SyntaxKind::ItemInlineMacro => {
11898 ModuleItem::InlineMacro(ItemInlineMacro::from_syntax_node(db, node))
11899 }
11900 SyntaxKind::ItemHeaderDoc => {
11901 ModuleItem::HeaderDoc(ItemHeaderDoc::from_syntax_node(db, node))
11902 }
11903 SyntaxKind::ModuleItemMissing => {
11904 ModuleItem::Missing(ModuleItemMissing::from_syntax_node(db, node))
11905 }
11906 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ModuleItem"),
11907 }
11908 }
11909 fn as_syntax_node(&self) -> SyntaxNode {
11910 match self {
11911 ModuleItem::Constant(x) => x.as_syntax_node(),
11912 ModuleItem::Module(x) => x.as_syntax_node(),
11913 ModuleItem::Use(x) => x.as_syntax_node(),
11914 ModuleItem::FreeFunction(x) => x.as_syntax_node(),
11915 ModuleItem::ExternFunction(x) => x.as_syntax_node(),
11916 ModuleItem::ExternType(x) => x.as_syntax_node(),
11917 ModuleItem::Trait(x) => x.as_syntax_node(),
11918 ModuleItem::Impl(x) => x.as_syntax_node(),
11919 ModuleItem::ImplAlias(x) => x.as_syntax_node(),
11920 ModuleItem::Struct(x) => x.as_syntax_node(),
11921 ModuleItem::Enum(x) => x.as_syntax_node(),
11922 ModuleItem::TypeAlias(x) => x.as_syntax_node(),
11923 ModuleItem::InlineMacro(x) => x.as_syntax_node(),
11924 ModuleItem::HeaderDoc(x) => x.as_syntax_node(),
11925 ModuleItem::Missing(x) => x.as_syntax_node(),
11926 }
11927 }
11928 fn stable_ptr(&self) -> Self::StablePtr {
11929 ModuleItemPtr(self.as_syntax_node().0.stable_ptr)
11930 }
11931}
11932impl From<&ModuleItem> for SyntaxStablePtrId {
11933 fn from(node: &ModuleItem) -> Self {
11934 node.stable_ptr().untyped()
11935 }
11936}
11937impl ModuleItem {
11938 pub fn is_variant(kind: SyntaxKind) -> bool {
11940 matches!(
11941 kind,
11942 SyntaxKind::ItemConstant
11943 | SyntaxKind::ItemModule
11944 | SyntaxKind::ItemUse
11945 | SyntaxKind::FunctionWithBody
11946 | SyntaxKind::ItemExternFunction
11947 | SyntaxKind::ItemExternType
11948 | SyntaxKind::ItemTrait
11949 | SyntaxKind::ItemImpl
11950 | SyntaxKind::ItemImplAlias
11951 | SyntaxKind::ItemStruct
11952 | SyntaxKind::ItemEnum
11953 | SyntaxKind::ItemTypeAlias
11954 | SyntaxKind::ItemInlineMacro
11955 | SyntaxKind::ItemHeaderDoc
11956 | SyntaxKind::ModuleItemMissing
11957 )
11958 }
11959}
11960#[derive(Clone, Debug, Eq, Hash, PartialEq)]
11961pub struct ModuleItemList(ElementList<ModuleItem, 1>);
11962impl Deref for ModuleItemList {
11963 type Target = ElementList<ModuleItem, 1>;
11964 fn deref(&self) -> &Self::Target {
11965 &self.0
11966 }
11967}
11968impl ModuleItemList {
11969 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ModuleItemGreen>) -> ModuleItemListGreen {
11970 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
11971 ModuleItemListGreen(
11972 Arc::new(GreenNode {
11973 kind: SyntaxKind::ModuleItemList,
11974 details: GreenNodeDetails::Node {
11975 children: children.iter().map(|x| x.0).collect(),
11976 width,
11977 },
11978 })
11979 .intern(db),
11980 )
11981 }
11982}
11983#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
11984pub struct ModuleItemListPtr(pub SyntaxStablePtrId);
11985impl TypedStablePtr for ModuleItemListPtr {
11986 type SyntaxNode = ModuleItemList;
11987 fn untyped(&self) -> SyntaxStablePtrId {
11988 self.0
11989 }
11990 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
11991 ModuleItemList::from_syntax_node(db, self.0.lookup(db))
11992 }
11993}
11994impl From<ModuleItemListPtr> for SyntaxStablePtrId {
11995 fn from(ptr: ModuleItemListPtr) -> Self {
11996 ptr.untyped()
11997 }
11998}
11999#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12000pub struct ModuleItemListGreen(pub GreenId);
12001impl TypedSyntaxNode for ModuleItemList {
12002 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleItemList);
12003 type StablePtr = ModuleItemListPtr;
12004 type Green = ModuleItemListGreen;
12005 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12006 ModuleItemListGreen(
12007 Arc::new(GreenNode {
12008 kind: SyntaxKind::ModuleItemList,
12009 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12010 })
12011 .intern(db),
12012 )
12013 }
12014 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12015 Self(ElementList::new(node))
12016 }
12017 fn as_syntax_node(&self) -> SyntaxNode {
12018 self.node.clone()
12019 }
12020 fn stable_ptr(&self) -> Self::StablePtr {
12021 ModuleItemListPtr(self.node.0.stable_ptr)
12022 }
12023}
12024impl From<&ModuleItemList> for SyntaxStablePtrId {
12025 fn from(node: &ModuleItemList) -> Self {
12026 node.stable_ptr().untyped()
12027 }
12028}
12029#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12030pub struct ModuleItemMissing {
12031 node: SyntaxNode,
12032 children: Arc<[SyntaxNode]>,
12033}
12034impl ModuleItemMissing {
12035 pub fn new_green(db: &dyn SyntaxGroup) -> ModuleItemMissingGreen {
12036 let children: Vec<GreenId> = vec![];
12037 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12038 ModuleItemMissingGreen(
12039 Arc::new(GreenNode {
12040 kind: SyntaxKind::ModuleItemMissing,
12041 details: GreenNodeDetails::Node { children, width },
12042 })
12043 .intern(db),
12044 )
12045 }
12046}
12047impl ModuleItemMissing {}
12048#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12049pub struct ModuleItemMissingPtr(pub SyntaxStablePtrId);
12050impl ModuleItemMissingPtr {}
12051impl TypedStablePtr for ModuleItemMissingPtr {
12052 type SyntaxNode = ModuleItemMissing;
12053 fn untyped(&self) -> SyntaxStablePtrId {
12054 self.0
12055 }
12056 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleItemMissing {
12057 ModuleItemMissing::from_syntax_node(db, self.0.lookup(db))
12058 }
12059}
12060impl From<ModuleItemMissingPtr> for SyntaxStablePtrId {
12061 fn from(ptr: ModuleItemMissingPtr) -> Self {
12062 ptr.untyped()
12063 }
12064}
12065#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12066pub struct ModuleItemMissingGreen(pub GreenId);
12067impl TypedSyntaxNode for ModuleItemMissing {
12068 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleItemMissing);
12069 type StablePtr = ModuleItemMissingPtr;
12070 type Green = ModuleItemMissingGreen;
12071 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12072 ModuleItemMissingGreen(
12073 Arc::new(GreenNode {
12074 kind: SyntaxKind::ModuleItemMissing,
12075 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12076 })
12077 .intern(db),
12078 )
12079 }
12080 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12081 let kind = node.kind(db);
12082 assert_eq!(
12083 kind,
12084 SyntaxKind::ModuleItemMissing,
12085 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12086 kind,
12087 SyntaxKind::ModuleItemMissing
12088 );
12089 let children = db.get_children(node.clone());
12090 Self { node, children }
12091 }
12092 fn as_syntax_node(&self) -> SyntaxNode {
12093 self.node.clone()
12094 }
12095 fn stable_ptr(&self) -> Self::StablePtr {
12096 ModuleItemMissingPtr(self.node.0.stable_ptr)
12097 }
12098}
12099impl From<&ModuleItemMissing> for SyntaxStablePtrId {
12100 fn from(node: &ModuleItemMissing) -> Self {
12101 node.stable_ptr().untyped()
12102 }
12103}
12104#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12105pub struct Attribute {
12106 node: SyntaxNode,
12107 children: Arc<[SyntaxNode]>,
12108}
12109impl Attribute {
12110 pub const INDEX_HASH: usize = 0;
12111 pub const INDEX_LBRACK: usize = 1;
12112 pub const INDEX_ATTR: usize = 2;
12113 pub const INDEX_ARGUMENTS: usize = 3;
12114 pub const INDEX_RBRACK: usize = 4;
12115 pub fn new_green(
12116 db: &dyn SyntaxGroup,
12117 hash: TerminalHashGreen,
12118 lbrack: TerminalLBrackGreen,
12119 attr: ExprPathGreen,
12120 arguments: OptionArgListParenthesizedGreen,
12121 rbrack: TerminalRBrackGreen,
12122 ) -> AttributeGreen {
12123 let children: Vec<GreenId> = vec![hash.0, lbrack.0, attr.0, arguments.0, rbrack.0];
12124 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12125 AttributeGreen(
12126 Arc::new(GreenNode {
12127 kind: SyntaxKind::Attribute,
12128 details: GreenNodeDetails::Node { children, width },
12129 })
12130 .intern(db),
12131 )
12132 }
12133}
12134impl Attribute {
12135 pub fn hash(&self, db: &dyn SyntaxGroup) -> TerminalHash {
12136 TerminalHash::from_syntax_node(db, self.children[0].clone())
12137 }
12138 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
12139 TerminalLBrack::from_syntax_node(db, self.children[1].clone())
12140 }
12141 pub fn attr(&self, db: &dyn SyntaxGroup) -> ExprPath {
12142 ExprPath::from_syntax_node(db, self.children[2].clone())
12143 }
12144 pub fn arguments(&self, db: &dyn SyntaxGroup) -> OptionArgListParenthesized {
12145 OptionArgListParenthesized::from_syntax_node(db, self.children[3].clone())
12146 }
12147 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
12148 TerminalRBrack::from_syntax_node(db, self.children[4].clone())
12149 }
12150}
12151#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12152pub struct AttributePtr(pub SyntaxStablePtrId);
12153impl AttributePtr {}
12154impl TypedStablePtr for AttributePtr {
12155 type SyntaxNode = Attribute;
12156 fn untyped(&self) -> SyntaxStablePtrId {
12157 self.0
12158 }
12159 fn lookup(&self, db: &dyn SyntaxGroup) -> Attribute {
12160 Attribute::from_syntax_node(db, self.0.lookup(db))
12161 }
12162}
12163impl From<AttributePtr> for SyntaxStablePtrId {
12164 fn from(ptr: AttributePtr) -> Self {
12165 ptr.untyped()
12166 }
12167}
12168#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12169pub struct AttributeGreen(pub GreenId);
12170impl TypedSyntaxNode for Attribute {
12171 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::Attribute);
12172 type StablePtr = AttributePtr;
12173 type Green = AttributeGreen;
12174 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12175 AttributeGreen(
12176 Arc::new(GreenNode {
12177 kind: SyntaxKind::Attribute,
12178 details: GreenNodeDetails::Node {
12179 children: vec![
12180 TerminalHash::missing(db).0,
12181 TerminalLBrack::missing(db).0,
12182 ExprPath::missing(db).0,
12183 OptionArgListParenthesized::missing(db).0,
12184 TerminalRBrack::missing(db).0,
12185 ],
12186 width: TextWidth::default(),
12187 },
12188 })
12189 .intern(db),
12190 )
12191 }
12192 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12193 let kind = node.kind(db);
12194 assert_eq!(
12195 kind,
12196 SyntaxKind::Attribute,
12197 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12198 kind,
12199 SyntaxKind::Attribute
12200 );
12201 let children = db.get_children(node.clone());
12202 Self { node, children }
12203 }
12204 fn as_syntax_node(&self) -> SyntaxNode {
12205 self.node.clone()
12206 }
12207 fn stable_ptr(&self) -> Self::StablePtr {
12208 AttributePtr(self.node.0.stable_ptr)
12209 }
12210}
12211impl From<&Attribute> for SyntaxStablePtrId {
12212 fn from(node: &Attribute) -> Self {
12213 node.stable_ptr().untyped()
12214 }
12215}
12216#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12217pub struct AttributeList(ElementList<Attribute, 1>);
12218impl Deref for AttributeList {
12219 type Target = ElementList<Attribute, 1>;
12220 fn deref(&self) -> &Self::Target {
12221 &self.0
12222 }
12223}
12224impl AttributeList {
12225 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<AttributeGreen>) -> AttributeListGreen {
12226 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
12227 AttributeListGreen(
12228 Arc::new(GreenNode {
12229 kind: SyntaxKind::AttributeList,
12230 details: GreenNodeDetails::Node {
12231 children: children.iter().map(|x| x.0).collect(),
12232 width,
12233 },
12234 })
12235 .intern(db),
12236 )
12237 }
12238}
12239#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12240pub struct AttributeListPtr(pub SyntaxStablePtrId);
12241impl TypedStablePtr for AttributeListPtr {
12242 type SyntaxNode = AttributeList;
12243 fn untyped(&self) -> SyntaxStablePtrId {
12244 self.0
12245 }
12246 fn lookup(&self, db: &dyn SyntaxGroup) -> AttributeList {
12247 AttributeList::from_syntax_node(db, self.0.lookup(db))
12248 }
12249}
12250impl From<AttributeListPtr> for SyntaxStablePtrId {
12251 fn from(ptr: AttributeListPtr) -> Self {
12252 ptr.untyped()
12253 }
12254}
12255#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12256pub struct AttributeListGreen(pub GreenId);
12257impl TypedSyntaxNode for AttributeList {
12258 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AttributeList);
12259 type StablePtr = AttributeListPtr;
12260 type Green = AttributeListGreen;
12261 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12262 AttributeListGreen(
12263 Arc::new(GreenNode {
12264 kind: SyntaxKind::AttributeList,
12265 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12266 })
12267 .intern(db),
12268 )
12269 }
12270 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12271 Self(ElementList::new(node))
12272 }
12273 fn as_syntax_node(&self) -> SyntaxNode {
12274 self.node.clone()
12275 }
12276 fn stable_ptr(&self) -> Self::StablePtr {
12277 AttributeListPtr(self.node.0.stable_ptr)
12278 }
12279}
12280impl From<&AttributeList> for SyntaxStablePtrId {
12281 fn from(node: &AttributeList) -> Self {
12282 node.stable_ptr().untyped()
12283 }
12284}
12285#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12286pub struct VisibilityDefault {
12287 node: SyntaxNode,
12288 children: Arc<[SyntaxNode]>,
12289}
12290impl VisibilityDefault {
12291 pub fn new_green(db: &dyn SyntaxGroup) -> VisibilityDefaultGreen {
12292 let children: Vec<GreenId> = vec![];
12293 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12294 VisibilityDefaultGreen(
12295 Arc::new(GreenNode {
12296 kind: SyntaxKind::VisibilityDefault,
12297 details: GreenNodeDetails::Node { children, width },
12298 })
12299 .intern(db),
12300 )
12301 }
12302}
12303impl VisibilityDefault {}
12304#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12305pub struct VisibilityDefaultPtr(pub SyntaxStablePtrId);
12306impl VisibilityDefaultPtr {}
12307impl TypedStablePtr for VisibilityDefaultPtr {
12308 type SyntaxNode = VisibilityDefault;
12309 fn untyped(&self) -> SyntaxStablePtrId {
12310 self.0
12311 }
12312 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityDefault {
12313 VisibilityDefault::from_syntax_node(db, self.0.lookup(db))
12314 }
12315}
12316impl From<VisibilityDefaultPtr> for SyntaxStablePtrId {
12317 fn from(ptr: VisibilityDefaultPtr) -> Self {
12318 ptr.untyped()
12319 }
12320}
12321#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12322pub struct VisibilityDefaultGreen(pub GreenId);
12323impl TypedSyntaxNode for VisibilityDefault {
12324 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityDefault);
12325 type StablePtr = VisibilityDefaultPtr;
12326 type Green = VisibilityDefaultGreen;
12327 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12328 VisibilityDefaultGreen(
12329 Arc::new(GreenNode {
12330 kind: SyntaxKind::VisibilityDefault,
12331 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12332 })
12333 .intern(db),
12334 )
12335 }
12336 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12337 let kind = node.kind(db);
12338 assert_eq!(
12339 kind,
12340 SyntaxKind::VisibilityDefault,
12341 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12342 kind,
12343 SyntaxKind::VisibilityDefault
12344 );
12345 let children = db.get_children(node.clone());
12346 Self { node, children }
12347 }
12348 fn as_syntax_node(&self) -> SyntaxNode {
12349 self.node.clone()
12350 }
12351 fn stable_ptr(&self) -> Self::StablePtr {
12352 VisibilityDefaultPtr(self.node.0.stable_ptr)
12353 }
12354}
12355impl From<&VisibilityDefault> for SyntaxStablePtrId {
12356 fn from(node: &VisibilityDefault) -> Self {
12357 node.stable_ptr().untyped()
12358 }
12359}
12360#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12361pub struct VisibilityPubArgumentClause {
12362 node: SyntaxNode,
12363 children: Arc<[SyntaxNode]>,
12364}
12365impl VisibilityPubArgumentClause {
12366 pub const INDEX_LPAREN: usize = 0;
12367 pub const INDEX_ARGUMENT: usize = 1;
12368 pub const INDEX_RPAREN: usize = 2;
12369 pub fn new_green(
12370 db: &dyn SyntaxGroup,
12371 lparen: TerminalLParenGreen,
12372 argument: TerminalIdentifierGreen,
12373 rparen: TerminalRParenGreen,
12374 ) -> VisibilityPubArgumentClauseGreen {
12375 let children: Vec<GreenId> = vec![lparen.0, argument.0, rparen.0];
12376 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12377 VisibilityPubArgumentClauseGreen(
12378 Arc::new(GreenNode {
12379 kind: SyntaxKind::VisibilityPubArgumentClause,
12380 details: GreenNodeDetails::Node { children, width },
12381 })
12382 .intern(db),
12383 )
12384 }
12385}
12386impl VisibilityPubArgumentClause {
12387 pub fn lparen(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
12388 TerminalLParen::from_syntax_node(db, self.children[0].clone())
12389 }
12390 pub fn argument(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
12391 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
12392 }
12393 pub fn rparen(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
12394 TerminalRParen::from_syntax_node(db, self.children[2].clone())
12395 }
12396}
12397#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12398pub struct VisibilityPubArgumentClausePtr(pub SyntaxStablePtrId);
12399impl VisibilityPubArgumentClausePtr {}
12400impl TypedStablePtr for VisibilityPubArgumentClausePtr {
12401 type SyntaxNode = VisibilityPubArgumentClause;
12402 fn untyped(&self) -> SyntaxStablePtrId {
12403 self.0
12404 }
12405 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityPubArgumentClause {
12406 VisibilityPubArgumentClause::from_syntax_node(db, self.0.lookup(db))
12407 }
12408}
12409impl From<VisibilityPubArgumentClausePtr> for SyntaxStablePtrId {
12410 fn from(ptr: VisibilityPubArgumentClausePtr) -> Self {
12411 ptr.untyped()
12412 }
12413}
12414#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12415pub struct VisibilityPubArgumentClauseGreen(pub GreenId);
12416impl TypedSyntaxNode for VisibilityPubArgumentClause {
12417 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityPubArgumentClause);
12418 type StablePtr = VisibilityPubArgumentClausePtr;
12419 type Green = VisibilityPubArgumentClauseGreen;
12420 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12421 VisibilityPubArgumentClauseGreen(
12422 Arc::new(GreenNode {
12423 kind: SyntaxKind::VisibilityPubArgumentClause,
12424 details: GreenNodeDetails::Node {
12425 children: vec![
12426 TerminalLParen::missing(db).0,
12427 TerminalIdentifier::missing(db).0,
12428 TerminalRParen::missing(db).0,
12429 ],
12430 width: TextWidth::default(),
12431 },
12432 })
12433 .intern(db),
12434 )
12435 }
12436 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12437 let kind = node.kind(db);
12438 assert_eq!(
12439 kind,
12440 SyntaxKind::VisibilityPubArgumentClause,
12441 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12442 kind,
12443 SyntaxKind::VisibilityPubArgumentClause
12444 );
12445 let children = db.get_children(node.clone());
12446 Self { node, children }
12447 }
12448 fn as_syntax_node(&self) -> SyntaxNode {
12449 self.node.clone()
12450 }
12451 fn stable_ptr(&self) -> Self::StablePtr {
12452 VisibilityPubArgumentClausePtr(self.node.0.stable_ptr)
12453 }
12454}
12455impl From<&VisibilityPubArgumentClause> for SyntaxStablePtrId {
12456 fn from(node: &VisibilityPubArgumentClause) -> Self {
12457 node.stable_ptr().untyped()
12458 }
12459}
12460#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12461pub enum OptionVisibilityPubArgumentClause {
12462 Empty(OptionVisibilityPubArgumentClauseEmpty),
12463 VisibilityPubArgumentClause(VisibilityPubArgumentClause),
12464}
12465#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12466pub struct OptionVisibilityPubArgumentClausePtr(pub SyntaxStablePtrId);
12467impl TypedStablePtr for OptionVisibilityPubArgumentClausePtr {
12468 type SyntaxNode = OptionVisibilityPubArgumentClause;
12469 fn untyped(&self) -> SyntaxStablePtrId {
12470 self.0
12471 }
12472 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClause {
12473 OptionVisibilityPubArgumentClause::from_syntax_node(db, self.0.lookup(db))
12474 }
12475}
12476impl From<OptionVisibilityPubArgumentClausePtr> for SyntaxStablePtrId {
12477 fn from(ptr: OptionVisibilityPubArgumentClausePtr) -> Self {
12478 ptr.untyped()
12479 }
12480}
12481impl From<OptionVisibilityPubArgumentClauseEmptyPtr> for OptionVisibilityPubArgumentClausePtr {
12482 fn from(value: OptionVisibilityPubArgumentClauseEmptyPtr) -> Self {
12483 Self(value.0)
12484 }
12485}
12486impl From<VisibilityPubArgumentClausePtr> for OptionVisibilityPubArgumentClausePtr {
12487 fn from(value: VisibilityPubArgumentClausePtr) -> Self {
12488 Self(value.0)
12489 }
12490}
12491impl From<OptionVisibilityPubArgumentClauseEmptyGreen> for OptionVisibilityPubArgumentClauseGreen {
12492 fn from(value: OptionVisibilityPubArgumentClauseEmptyGreen) -> Self {
12493 Self(value.0)
12494 }
12495}
12496impl From<VisibilityPubArgumentClauseGreen> for OptionVisibilityPubArgumentClauseGreen {
12497 fn from(value: VisibilityPubArgumentClauseGreen) -> Self {
12498 Self(value.0)
12499 }
12500}
12501#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12502pub struct OptionVisibilityPubArgumentClauseGreen(pub GreenId);
12503impl TypedSyntaxNode for OptionVisibilityPubArgumentClause {
12504 const OPTIONAL_KIND: Option<SyntaxKind> = None;
12505 type StablePtr = OptionVisibilityPubArgumentClausePtr;
12506 type Green = OptionVisibilityPubArgumentClauseGreen;
12507 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12508 panic!("No missing variant.");
12509 }
12510 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12511 let kind = node.kind(db);
12512 match kind {
12513 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty => {
12514 OptionVisibilityPubArgumentClause::Empty(
12515 OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, node),
12516 )
12517 }
12518 SyntaxKind::VisibilityPubArgumentClause => {
12519 OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause(
12520 VisibilityPubArgumentClause::from_syntax_node(db, node),
12521 )
12522 }
12523 _ => panic!(
12524 "Unexpected syntax kind {:?} when constructing {}.",
12525 kind, "OptionVisibilityPubArgumentClause"
12526 ),
12527 }
12528 }
12529 fn as_syntax_node(&self) -> SyntaxNode {
12530 match self {
12531 OptionVisibilityPubArgumentClause::Empty(x) => x.as_syntax_node(),
12532 OptionVisibilityPubArgumentClause::VisibilityPubArgumentClause(x) => x.as_syntax_node(),
12533 }
12534 }
12535 fn stable_ptr(&self) -> Self::StablePtr {
12536 OptionVisibilityPubArgumentClausePtr(self.as_syntax_node().0.stable_ptr)
12537 }
12538}
12539impl From<&OptionVisibilityPubArgumentClause> for SyntaxStablePtrId {
12540 fn from(node: &OptionVisibilityPubArgumentClause) -> Self {
12541 node.stable_ptr().untyped()
12542 }
12543}
12544impl OptionVisibilityPubArgumentClause {
12545 pub fn is_variant(kind: SyntaxKind) -> bool {
12547 matches!(
12548 kind,
12549 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty
12550 | SyntaxKind::VisibilityPubArgumentClause
12551 )
12552 }
12553}
12554#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12555pub struct OptionVisibilityPubArgumentClauseEmpty {
12556 node: SyntaxNode,
12557 children: Arc<[SyntaxNode]>,
12558}
12559impl OptionVisibilityPubArgumentClauseEmpty {
12560 pub fn new_green(db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClauseEmptyGreen {
12561 let children: Vec<GreenId> = vec![];
12562 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12563 OptionVisibilityPubArgumentClauseEmptyGreen(
12564 Arc::new(GreenNode {
12565 kind: SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
12566 details: GreenNodeDetails::Node { children, width },
12567 })
12568 .intern(db),
12569 )
12570 }
12571}
12572impl OptionVisibilityPubArgumentClauseEmpty {}
12573#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12574pub struct OptionVisibilityPubArgumentClauseEmptyPtr(pub SyntaxStablePtrId);
12575impl OptionVisibilityPubArgumentClauseEmptyPtr {}
12576impl TypedStablePtr for OptionVisibilityPubArgumentClauseEmptyPtr {
12577 type SyntaxNode = OptionVisibilityPubArgumentClauseEmpty;
12578 fn untyped(&self) -> SyntaxStablePtrId {
12579 self.0
12580 }
12581 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClauseEmpty {
12582 OptionVisibilityPubArgumentClauseEmpty::from_syntax_node(db, self.0.lookup(db))
12583 }
12584}
12585impl From<OptionVisibilityPubArgumentClauseEmptyPtr> for SyntaxStablePtrId {
12586 fn from(ptr: OptionVisibilityPubArgumentClauseEmptyPtr) -> Self {
12587 ptr.untyped()
12588 }
12589}
12590#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12591pub struct OptionVisibilityPubArgumentClauseEmptyGreen(pub GreenId);
12592impl TypedSyntaxNode for OptionVisibilityPubArgumentClauseEmpty {
12593 const OPTIONAL_KIND: Option<SyntaxKind> =
12594 Some(SyntaxKind::OptionVisibilityPubArgumentClauseEmpty);
12595 type StablePtr = OptionVisibilityPubArgumentClauseEmptyPtr;
12596 type Green = OptionVisibilityPubArgumentClauseEmptyGreen;
12597 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12598 OptionVisibilityPubArgumentClauseEmptyGreen(
12599 Arc::new(GreenNode {
12600 kind: SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
12601 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
12602 })
12603 .intern(db),
12604 )
12605 }
12606 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12607 let kind = node.kind(db);
12608 assert_eq!(
12609 kind,
12610 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty,
12611 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12612 kind,
12613 SyntaxKind::OptionVisibilityPubArgumentClauseEmpty
12614 );
12615 let children = db.get_children(node.clone());
12616 Self { node, children }
12617 }
12618 fn as_syntax_node(&self) -> SyntaxNode {
12619 self.node.clone()
12620 }
12621 fn stable_ptr(&self) -> Self::StablePtr {
12622 OptionVisibilityPubArgumentClauseEmptyPtr(self.node.0.stable_ptr)
12623 }
12624}
12625impl From<&OptionVisibilityPubArgumentClauseEmpty> for SyntaxStablePtrId {
12626 fn from(node: &OptionVisibilityPubArgumentClauseEmpty) -> Self {
12627 node.stable_ptr().untyped()
12628 }
12629}
12630#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12631pub struct VisibilityPub {
12632 node: SyntaxNode,
12633 children: Arc<[SyntaxNode]>,
12634}
12635impl VisibilityPub {
12636 pub const INDEX_PUB_KW: usize = 0;
12637 pub const INDEX_ARGUMENT_CLAUSE: usize = 1;
12638 pub fn new_green(
12639 db: &dyn SyntaxGroup,
12640 pub_kw: TerminalPubGreen,
12641 argument_clause: OptionVisibilityPubArgumentClauseGreen,
12642 ) -> VisibilityPubGreen {
12643 let children: Vec<GreenId> = vec![pub_kw.0, argument_clause.0];
12644 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12645 VisibilityPubGreen(
12646 Arc::new(GreenNode {
12647 kind: SyntaxKind::VisibilityPub,
12648 details: GreenNodeDetails::Node { children, width },
12649 })
12650 .intern(db),
12651 )
12652 }
12653}
12654impl VisibilityPub {
12655 pub fn pub_kw(&self, db: &dyn SyntaxGroup) -> TerminalPub {
12656 TerminalPub::from_syntax_node(db, self.children[0].clone())
12657 }
12658 pub fn argument_clause(&self, db: &dyn SyntaxGroup) -> OptionVisibilityPubArgumentClause {
12659 OptionVisibilityPubArgumentClause::from_syntax_node(db, self.children[1].clone())
12660 }
12661}
12662#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12663pub struct VisibilityPubPtr(pub SyntaxStablePtrId);
12664impl VisibilityPubPtr {}
12665impl TypedStablePtr for VisibilityPubPtr {
12666 type SyntaxNode = VisibilityPub;
12667 fn untyped(&self) -> SyntaxStablePtrId {
12668 self.0
12669 }
12670 fn lookup(&self, db: &dyn SyntaxGroup) -> VisibilityPub {
12671 VisibilityPub::from_syntax_node(db, self.0.lookup(db))
12672 }
12673}
12674impl From<VisibilityPubPtr> for SyntaxStablePtrId {
12675 fn from(ptr: VisibilityPubPtr) -> Self {
12676 ptr.untyped()
12677 }
12678}
12679#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12680pub struct VisibilityPubGreen(pub GreenId);
12681impl TypedSyntaxNode for VisibilityPub {
12682 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::VisibilityPub);
12683 type StablePtr = VisibilityPubPtr;
12684 type Green = VisibilityPubGreen;
12685 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12686 VisibilityPubGreen(
12687 Arc::new(GreenNode {
12688 kind: SyntaxKind::VisibilityPub,
12689 details: GreenNodeDetails::Node {
12690 children: vec![
12691 TerminalPub::missing(db).0,
12692 OptionVisibilityPubArgumentClause::missing(db).0,
12693 ],
12694 width: TextWidth::default(),
12695 },
12696 })
12697 .intern(db),
12698 )
12699 }
12700 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12701 let kind = node.kind(db);
12702 assert_eq!(
12703 kind,
12704 SyntaxKind::VisibilityPub,
12705 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12706 kind,
12707 SyntaxKind::VisibilityPub
12708 );
12709 let children = db.get_children(node.clone());
12710 Self { node, children }
12711 }
12712 fn as_syntax_node(&self) -> SyntaxNode {
12713 self.node.clone()
12714 }
12715 fn stable_ptr(&self) -> Self::StablePtr {
12716 VisibilityPubPtr(self.node.0.stable_ptr)
12717 }
12718}
12719impl From<&VisibilityPub> for SyntaxStablePtrId {
12720 fn from(node: &VisibilityPub) -> Self {
12721 node.stable_ptr().untyped()
12722 }
12723}
12724#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12725pub enum Visibility {
12726 Default(VisibilityDefault),
12727 Pub(VisibilityPub),
12728}
12729#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12730pub struct VisibilityPtr(pub SyntaxStablePtrId);
12731impl TypedStablePtr for VisibilityPtr {
12732 type SyntaxNode = Visibility;
12733 fn untyped(&self) -> SyntaxStablePtrId {
12734 self.0
12735 }
12736 fn lookup(&self, db: &dyn SyntaxGroup) -> Visibility {
12737 Visibility::from_syntax_node(db, self.0.lookup(db))
12738 }
12739}
12740impl From<VisibilityPtr> for SyntaxStablePtrId {
12741 fn from(ptr: VisibilityPtr) -> Self {
12742 ptr.untyped()
12743 }
12744}
12745impl From<VisibilityDefaultPtr> for VisibilityPtr {
12746 fn from(value: VisibilityDefaultPtr) -> Self {
12747 Self(value.0)
12748 }
12749}
12750impl From<VisibilityPubPtr> for VisibilityPtr {
12751 fn from(value: VisibilityPubPtr) -> Self {
12752 Self(value.0)
12753 }
12754}
12755impl From<VisibilityDefaultGreen> for VisibilityGreen {
12756 fn from(value: VisibilityDefaultGreen) -> Self {
12757 Self(value.0)
12758 }
12759}
12760impl From<VisibilityPubGreen> for VisibilityGreen {
12761 fn from(value: VisibilityPubGreen) -> Self {
12762 Self(value.0)
12763 }
12764}
12765#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12766pub struct VisibilityGreen(pub GreenId);
12767impl TypedSyntaxNode for Visibility {
12768 const OPTIONAL_KIND: Option<SyntaxKind> = None;
12769 type StablePtr = VisibilityPtr;
12770 type Green = VisibilityGreen;
12771 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12772 panic!("No missing variant.");
12773 }
12774 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12775 let kind = node.kind(db);
12776 match kind {
12777 SyntaxKind::VisibilityDefault => {
12778 Visibility::Default(VisibilityDefault::from_syntax_node(db, node))
12779 }
12780 SyntaxKind::VisibilityPub => Visibility::Pub(VisibilityPub::from_syntax_node(db, node)),
12781 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "Visibility"),
12782 }
12783 }
12784 fn as_syntax_node(&self) -> SyntaxNode {
12785 match self {
12786 Visibility::Default(x) => x.as_syntax_node(),
12787 Visibility::Pub(x) => x.as_syntax_node(),
12788 }
12789 }
12790 fn stable_ptr(&self) -> Self::StablePtr {
12791 VisibilityPtr(self.as_syntax_node().0.stable_ptr)
12792 }
12793}
12794impl From<&Visibility> for SyntaxStablePtrId {
12795 fn from(node: &Visibility) -> Self {
12796 node.stable_ptr().untyped()
12797 }
12798}
12799impl Visibility {
12800 pub fn is_variant(kind: SyntaxKind) -> bool {
12802 matches!(kind, SyntaxKind::VisibilityDefault | SyntaxKind::VisibilityPub)
12803 }
12804}
12805#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12806pub struct ItemModule {
12807 node: SyntaxNode,
12808 children: Arc<[SyntaxNode]>,
12809}
12810impl ItemModule {
12811 pub const INDEX_ATTRIBUTES: usize = 0;
12812 pub const INDEX_VISIBILITY: usize = 1;
12813 pub const INDEX_MODULE_KW: usize = 2;
12814 pub const INDEX_NAME: usize = 3;
12815 pub const INDEX_BODY: usize = 4;
12816 pub fn new_green(
12817 db: &dyn SyntaxGroup,
12818 attributes: AttributeListGreen,
12819 visibility: VisibilityGreen,
12820 module_kw: TerminalModuleGreen,
12821 name: TerminalIdentifierGreen,
12822 body: MaybeModuleBodyGreen,
12823 ) -> ItemModuleGreen {
12824 let children: Vec<GreenId> = vec![attributes.0, visibility.0, module_kw.0, name.0, body.0];
12825 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
12826 ItemModuleGreen(
12827 Arc::new(GreenNode {
12828 kind: SyntaxKind::ItemModule,
12829 details: GreenNodeDetails::Node { children, width },
12830 })
12831 .intern(db),
12832 )
12833 }
12834}
12835impl ItemModule {
12836 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
12837 AttributeList::from_syntax_node(db, self.children[0].clone())
12838 }
12839 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
12840 Visibility::from_syntax_node(db, self.children[1].clone())
12841 }
12842 pub fn module_kw(&self, db: &dyn SyntaxGroup) -> TerminalModule {
12843 TerminalModule::from_syntax_node(db, self.children[2].clone())
12844 }
12845 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
12846 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
12847 }
12848 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeModuleBody {
12849 MaybeModuleBody::from_syntax_node(db, self.children[4].clone())
12850 }
12851}
12852#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12853pub struct ItemModulePtr(pub SyntaxStablePtrId);
12854impl ItemModulePtr {
12855 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
12856 let ptr = self.0.lookup_intern(db);
12857 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
12858 TerminalIdentifierGreen(key_fields[0])
12859 } else {
12860 panic!("Unexpected key field query on root.");
12861 }
12862 }
12863}
12864impl TypedStablePtr for ItemModulePtr {
12865 type SyntaxNode = ItemModule;
12866 fn untyped(&self) -> SyntaxStablePtrId {
12867 self.0
12868 }
12869 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemModule {
12870 ItemModule::from_syntax_node(db, self.0.lookup(db))
12871 }
12872}
12873impl From<ItemModulePtr> for SyntaxStablePtrId {
12874 fn from(ptr: ItemModulePtr) -> Self {
12875 ptr.untyped()
12876 }
12877}
12878#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12879pub struct ItemModuleGreen(pub GreenId);
12880impl TypedSyntaxNode for ItemModule {
12881 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemModule);
12882 type StablePtr = ItemModulePtr;
12883 type Green = ItemModuleGreen;
12884 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12885 ItemModuleGreen(
12886 Arc::new(GreenNode {
12887 kind: SyntaxKind::ItemModule,
12888 details: GreenNodeDetails::Node {
12889 children: vec![
12890 AttributeList::missing(db).0,
12891 Visibility::missing(db).0,
12892 TerminalModule::missing(db).0,
12893 TerminalIdentifier::missing(db).0,
12894 MaybeModuleBody::missing(db).0,
12895 ],
12896 width: TextWidth::default(),
12897 },
12898 })
12899 .intern(db),
12900 )
12901 }
12902 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12903 let kind = node.kind(db);
12904 assert_eq!(
12905 kind,
12906 SyntaxKind::ItemModule,
12907 "Unexpected SyntaxKind {:?}. Expected {:?}.",
12908 kind,
12909 SyntaxKind::ItemModule
12910 );
12911 let children = db.get_children(node.clone());
12912 Self { node, children }
12913 }
12914 fn as_syntax_node(&self) -> SyntaxNode {
12915 self.node.clone()
12916 }
12917 fn stable_ptr(&self) -> Self::StablePtr {
12918 ItemModulePtr(self.node.0.stable_ptr)
12919 }
12920}
12921impl From<&ItemModule> for SyntaxStablePtrId {
12922 fn from(node: &ItemModule) -> Self {
12923 node.stable_ptr().untyped()
12924 }
12925}
12926#[derive(Clone, Debug, Eq, Hash, PartialEq)]
12927pub enum MaybeModuleBody {
12928 Some(ModuleBody),
12929 None(TerminalSemicolon),
12930}
12931#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12932pub struct MaybeModuleBodyPtr(pub SyntaxStablePtrId);
12933impl TypedStablePtr for MaybeModuleBodyPtr {
12934 type SyntaxNode = MaybeModuleBody;
12935 fn untyped(&self) -> SyntaxStablePtrId {
12936 self.0
12937 }
12938 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeModuleBody {
12939 MaybeModuleBody::from_syntax_node(db, self.0.lookup(db))
12940 }
12941}
12942impl From<MaybeModuleBodyPtr> for SyntaxStablePtrId {
12943 fn from(ptr: MaybeModuleBodyPtr) -> Self {
12944 ptr.untyped()
12945 }
12946}
12947impl From<ModuleBodyPtr> for MaybeModuleBodyPtr {
12948 fn from(value: ModuleBodyPtr) -> Self {
12949 Self(value.0)
12950 }
12951}
12952impl From<TerminalSemicolonPtr> for MaybeModuleBodyPtr {
12953 fn from(value: TerminalSemicolonPtr) -> Self {
12954 Self(value.0)
12955 }
12956}
12957impl From<ModuleBodyGreen> for MaybeModuleBodyGreen {
12958 fn from(value: ModuleBodyGreen) -> Self {
12959 Self(value.0)
12960 }
12961}
12962impl From<TerminalSemicolonGreen> for MaybeModuleBodyGreen {
12963 fn from(value: TerminalSemicolonGreen) -> Self {
12964 Self(value.0)
12965 }
12966}
12967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
12968pub struct MaybeModuleBodyGreen(pub GreenId);
12969impl TypedSyntaxNode for MaybeModuleBody {
12970 const OPTIONAL_KIND: Option<SyntaxKind> = None;
12971 type StablePtr = MaybeModuleBodyPtr;
12972 type Green = MaybeModuleBodyGreen;
12973 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
12974 panic!("No missing variant.");
12975 }
12976 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
12977 let kind = node.kind(db);
12978 match kind {
12979 SyntaxKind::ModuleBody => MaybeModuleBody::Some(ModuleBody::from_syntax_node(db, node)),
12980 SyntaxKind::TerminalSemicolon => {
12981 MaybeModuleBody::None(TerminalSemicolon::from_syntax_node(db, node))
12982 }
12983 _ => {
12984 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeModuleBody")
12985 }
12986 }
12987 }
12988 fn as_syntax_node(&self) -> SyntaxNode {
12989 match self {
12990 MaybeModuleBody::Some(x) => x.as_syntax_node(),
12991 MaybeModuleBody::None(x) => x.as_syntax_node(),
12992 }
12993 }
12994 fn stable_ptr(&self) -> Self::StablePtr {
12995 MaybeModuleBodyPtr(self.as_syntax_node().0.stable_ptr)
12996 }
12997}
12998impl From<&MaybeModuleBody> for SyntaxStablePtrId {
12999 fn from(node: &MaybeModuleBody) -> Self {
13000 node.stable_ptr().untyped()
13001 }
13002}
13003impl MaybeModuleBody {
13004 pub fn is_variant(kind: SyntaxKind) -> bool {
13006 matches!(kind, SyntaxKind::ModuleBody | SyntaxKind::TerminalSemicolon)
13007 }
13008}
13009#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13010pub struct ModuleBody {
13011 node: SyntaxNode,
13012 children: Arc<[SyntaxNode]>,
13013}
13014impl ModuleBody {
13015 pub const INDEX_LBRACE: usize = 0;
13016 pub const INDEX_ITEMS: usize = 1;
13017 pub const INDEX_RBRACE: usize = 2;
13018 pub fn new_green(
13019 db: &dyn SyntaxGroup,
13020 lbrace: TerminalLBraceGreen,
13021 items: ModuleItemListGreen,
13022 rbrace: TerminalRBraceGreen,
13023 ) -> ModuleBodyGreen {
13024 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
13025 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13026 ModuleBodyGreen(
13027 Arc::new(GreenNode {
13028 kind: SyntaxKind::ModuleBody,
13029 details: GreenNodeDetails::Node { children, width },
13030 })
13031 .intern(db),
13032 )
13033 }
13034}
13035impl ModuleBody {
13036 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
13037 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
13038 }
13039 pub fn items(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
13040 ModuleItemList::from_syntax_node(db, self.children[1].clone())
13041 }
13042 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
13043 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
13044 }
13045}
13046#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13047pub struct ModuleBodyPtr(pub SyntaxStablePtrId);
13048impl ModuleBodyPtr {}
13049impl TypedStablePtr for ModuleBodyPtr {
13050 type SyntaxNode = ModuleBody;
13051 fn untyped(&self) -> SyntaxStablePtrId {
13052 self.0
13053 }
13054 fn lookup(&self, db: &dyn SyntaxGroup) -> ModuleBody {
13055 ModuleBody::from_syntax_node(db, self.0.lookup(db))
13056 }
13057}
13058impl From<ModuleBodyPtr> for SyntaxStablePtrId {
13059 fn from(ptr: ModuleBodyPtr) -> Self {
13060 ptr.untyped()
13061 }
13062}
13063#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13064pub struct ModuleBodyGreen(pub GreenId);
13065impl TypedSyntaxNode for ModuleBody {
13066 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ModuleBody);
13067 type StablePtr = ModuleBodyPtr;
13068 type Green = ModuleBodyGreen;
13069 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13070 ModuleBodyGreen(
13071 Arc::new(GreenNode {
13072 kind: SyntaxKind::ModuleBody,
13073 details: GreenNodeDetails::Node {
13074 children: vec![
13075 TerminalLBrace::missing(db).0,
13076 ModuleItemList::missing(db).0,
13077 TerminalRBrace::missing(db).0,
13078 ],
13079 width: TextWidth::default(),
13080 },
13081 })
13082 .intern(db),
13083 )
13084 }
13085 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13086 let kind = node.kind(db);
13087 assert_eq!(
13088 kind,
13089 SyntaxKind::ModuleBody,
13090 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13091 kind,
13092 SyntaxKind::ModuleBody
13093 );
13094 let children = db.get_children(node.clone());
13095 Self { node, children }
13096 }
13097 fn as_syntax_node(&self) -> SyntaxNode {
13098 self.node.clone()
13099 }
13100 fn stable_ptr(&self) -> Self::StablePtr {
13101 ModuleBodyPtr(self.node.0.stable_ptr)
13102 }
13103}
13104impl From<&ModuleBody> for SyntaxStablePtrId {
13105 fn from(node: &ModuleBody) -> Self {
13106 node.stable_ptr().untyped()
13107 }
13108}
13109#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13110pub struct FunctionDeclaration {
13111 node: SyntaxNode,
13112 children: Arc<[SyntaxNode]>,
13113}
13114impl FunctionDeclaration {
13115 pub const INDEX_FUNCTION_KW: usize = 0;
13116 pub const INDEX_NAME: usize = 1;
13117 pub const INDEX_GENERIC_PARAMS: usize = 2;
13118 pub const INDEX_SIGNATURE: usize = 3;
13119 pub fn new_green(
13120 db: &dyn SyntaxGroup,
13121 function_kw: TerminalFunctionGreen,
13122 name: TerminalIdentifierGreen,
13123 generic_params: OptionWrappedGenericParamListGreen,
13124 signature: FunctionSignatureGreen,
13125 ) -> FunctionDeclarationGreen {
13126 let children: Vec<GreenId> = vec![function_kw.0, name.0, generic_params.0, signature.0];
13127 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13128 FunctionDeclarationGreen(
13129 Arc::new(GreenNode {
13130 kind: SyntaxKind::FunctionDeclaration,
13131 details: GreenNodeDetails::Node { children, width },
13132 })
13133 .intern(db),
13134 )
13135 }
13136}
13137impl FunctionDeclaration {
13138 pub fn function_kw(&self, db: &dyn SyntaxGroup) -> TerminalFunction {
13139 TerminalFunction::from_syntax_node(db, self.children[0].clone())
13140 }
13141 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
13142 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
13143 }
13144 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
13145 OptionWrappedGenericParamList::from_syntax_node(db, self.children[2].clone())
13146 }
13147 pub fn signature(&self, db: &dyn SyntaxGroup) -> FunctionSignature {
13148 FunctionSignature::from_syntax_node(db, self.children[3].clone())
13149 }
13150}
13151#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13152pub struct FunctionDeclarationPtr(pub SyntaxStablePtrId);
13153impl FunctionDeclarationPtr {
13154 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
13155 let ptr = self.0.lookup_intern(db);
13156 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13157 TerminalIdentifierGreen(key_fields[0])
13158 } else {
13159 panic!("Unexpected key field query on root.");
13160 }
13161 }
13162}
13163impl TypedStablePtr for FunctionDeclarationPtr {
13164 type SyntaxNode = FunctionDeclaration;
13165 fn untyped(&self) -> SyntaxStablePtrId {
13166 self.0
13167 }
13168 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
13169 FunctionDeclaration::from_syntax_node(db, self.0.lookup(db))
13170 }
13171}
13172impl From<FunctionDeclarationPtr> for SyntaxStablePtrId {
13173 fn from(ptr: FunctionDeclarationPtr) -> Self {
13174 ptr.untyped()
13175 }
13176}
13177#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13178pub struct FunctionDeclarationGreen(pub GreenId);
13179impl TypedSyntaxNode for FunctionDeclaration {
13180 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionDeclaration);
13181 type StablePtr = FunctionDeclarationPtr;
13182 type Green = FunctionDeclarationGreen;
13183 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13184 FunctionDeclarationGreen(
13185 Arc::new(GreenNode {
13186 kind: SyntaxKind::FunctionDeclaration,
13187 details: GreenNodeDetails::Node {
13188 children: vec![
13189 TerminalFunction::missing(db).0,
13190 TerminalIdentifier::missing(db).0,
13191 OptionWrappedGenericParamList::missing(db).0,
13192 FunctionSignature::missing(db).0,
13193 ],
13194 width: TextWidth::default(),
13195 },
13196 })
13197 .intern(db),
13198 )
13199 }
13200 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13201 let kind = node.kind(db);
13202 assert_eq!(
13203 kind,
13204 SyntaxKind::FunctionDeclaration,
13205 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13206 kind,
13207 SyntaxKind::FunctionDeclaration
13208 );
13209 let children = db.get_children(node.clone());
13210 Self { node, children }
13211 }
13212 fn as_syntax_node(&self) -> SyntaxNode {
13213 self.node.clone()
13214 }
13215 fn stable_ptr(&self) -> Self::StablePtr {
13216 FunctionDeclarationPtr(self.node.0.stable_ptr)
13217 }
13218}
13219impl From<&FunctionDeclaration> for SyntaxStablePtrId {
13220 fn from(node: &FunctionDeclaration) -> Self {
13221 node.stable_ptr().untyped()
13222 }
13223}
13224#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13225pub struct ItemConstant {
13226 node: SyntaxNode,
13227 children: Arc<[SyntaxNode]>,
13228}
13229impl ItemConstant {
13230 pub const INDEX_ATTRIBUTES: usize = 0;
13231 pub const INDEX_VISIBILITY: usize = 1;
13232 pub const INDEX_CONST_KW: usize = 2;
13233 pub const INDEX_NAME: usize = 3;
13234 pub const INDEX_TYPE_CLAUSE: usize = 4;
13235 pub const INDEX_EQ: usize = 5;
13236 pub const INDEX_VALUE: usize = 6;
13237 pub const INDEX_SEMICOLON: usize = 7;
13238 pub fn new_green(
13239 db: &dyn SyntaxGroup,
13240 attributes: AttributeListGreen,
13241 visibility: VisibilityGreen,
13242 const_kw: TerminalConstGreen,
13243 name: TerminalIdentifierGreen,
13244 type_clause: TypeClauseGreen,
13245 eq: TerminalEqGreen,
13246 value: ExprGreen,
13247 semicolon: TerminalSemicolonGreen,
13248 ) -> ItemConstantGreen {
13249 let children: Vec<GreenId> = vec![
13250 attributes.0,
13251 visibility.0,
13252 const_kw.0,
13253 name.0,
13254 type_clause.0,
13255 eq.0,
13256 value.0,
13257 semicolon.0,
13258 ];
13259 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13260 ItemConstantGreen(
13261 Arc::new(GreenNode {
13262 kind: SyntaxKind::ItemConstant,
13263 details: GreenNodeDetails::Node { children, width },
13264 })
13265 .intern(db),
13266 )
13267 }
13268}
13269impl ItemConstant {
13270 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
13271 AttributeList::from_syntax_node(db, self.children[0].clone())
13272 }
13273 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
13274 Visibility::from_syntax_node(db, self.children[1].clone())
13275 }
13276 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
13277 TerminalConst::from_syntax_node(db, self.children[2].clone())
13278 }
13279 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
13280 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
13281 }
13282 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
13283 TypeClause::from_syntax_node(db, self.children[4].clone())
13284 }
13285 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
13286 TerminalEq::from_syntax_node(db, self.children[5].clone())
13287 }
13288 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
13289 Expr::from_syntax_node(db, self.children[6].clone())
13290 }
13291 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
13292 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
13293 }
13294}
13295#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13296pub struct ItemConstantPtr(pub SyntaxStablePtrId);
13297impl ItemConstantPtr {
13298 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
13299 let ptr = self.0.lookup_intern(db);
13300 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13301 TerminalIdentifierGreen(key_fields[0])
13302 } else {
13303 panic!("Unexpected key field query on root.");
13304 }
13305 }
13306}
13307impl TypedStablePtr for ItemConstantPtr {
13308 type SyntaxNode = ItemConstant;
13309 fn untyped(&self) -> SyntaxStablePtrId {
13310 self.0
13311 }
13312 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemConstant {
13313 ItemConstant::from_syntax_node(db, self.0.lookup(db))
13314 }
13315}
13316impl From<ItemConstantPtr> for SyntaxStablePtrId {
13317 fn from(ptr: ItemConstantPtr) -> Self {
13318 ptr.untyped()
13319 }
13320}
13321#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13322pub struct ItemConstantGreen(pub GreenId);
13323impl TypedSyntaxNode for ItemConstant {
13324 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemConstant);
13325 type StablePtr = ItemConstantPtr;
13326 type Green = ItemConstantGreen;
13327 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13328 ItemConstantGreen(
13329 Arc::new(GreenNode {
13330 kind: SyntaxKind::ItemConstant,
13331 details: GreenNodeDetails::Node {
13332 children: vec![
13333 AttributeList::missing(db).0,
13334 Visibility::missing(db).0,
13335 TerminalConst::missing(db).0,
13336 TerminalIdentifier::missing(db).0,
13337 TypeClause::missing(db).0,
13338 TerminalEq::missing(db).0,
13339 Expr::missing(db).0,
13340 TerminalSemicolon::missing(db).0,
13341 ],
13342 width: TextWidth::default(),
13343 },
13344 })
13345 .intern(db),
13346 )
13347 }
13348 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13349 let kind = node.kind(db);
13350 assert_eq!(
13351 kind,
13352 SyntaxKind::ItemConstant,
13353 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13354 kind,
13355 SyntaxKind::ItemConstant
13356 );
13357 let children = db.get_children(node.clone());
13358 Self { node, children }
13359 }
13360 fn as_syntax_node(&self) -> SyntaxNode {
13361 self.node.clone()
13362 }
13363 fn stable_ptr(&self) -> Self::StablePtr {
13364 ItemConstantPtr(self.node.0.stable_ptr)
13365 }
13366}
13367impl From<&ItemConstant> for SyntaxStablePtrId {
13368 fn from(node: &ItemConstant) -> Self {
13369 node.stable_ptr().untyped()
13370 }
13371}
13372#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13373pub struct FunctionWithBody {
13374 node: SyntaxNode,
13375 children: Arc<[SyntaxNode]>,
13376}
13377impl FunctionWithBody {
13378 pub const INDEX_ATTRIBUTES: usize = 0;
13379 pub const INDEX_VISIBILITY: usize = 1;
13380 pub const INDEX_DECLARATION: usize = 2;
13381 pub const INDEX_BODY: usize = 3;
13382 pub fn new_green(
13383 db: &dyn SyntaxGroup,
13384 attributes: AttributeListGreen,
13385 visibility: VisibilityGreen,
13386 declaration: FunctionDeclarationGreen,
13387 body: ExprBlockGreen,
13388 ) -> FunctionWithBodyGreen {
13389 let children: Vec<GreenId> = vec![attributes.0, visibility.0, declaration.0, body.0];
13390 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13391 FunctionWithBodyGreen(
13392 Arc::new(GreenNode {
13393 kind: SyntaxKind::FunctionWithBody,
13394 details: GreenNodeDetails::Node { children, width },
13395 })
13396 .intern(db),
13397 )
13398 }
13399}
13400impl FunctionWithBody {
13401 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
13402 AttributeList::from_syntax_node(db, self.children[0].clone())
13403 }
13404 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
13405 Visibility::from_syntax_node(db, self.children[1].clone())
13406 }
13407 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
13408 FunctionDeclaration::from_syntax_node(db, self.children[2].clone())
13409 }
13410 pub fn body(&self, db: &dyn SyntaxGroup) -> ExprBlock {
13411 ExprBlock::from_syntax_node(db, self.children[3].clone())
13412 }
13413}
13414#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13415pub struct FunctionWithBodyPtr(pub SyntaxStablePtrId);
13416impl FunctionWithBodyPtr {
13417 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
13418 let ptr = self.0.lookup_intern(db);
13419 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13420 FunctionDeclarationGreen(key_fields[0])
13421 } else {
13422 panic!("Unexpected key field query on root.");
13423 }
13424 }
13425}
13426impl TypedStablePtr for FunctionWithBodyPtr {
13427 type SyntaxNode = FunctionWithBody;
13428 fn untyped(&self) -> SyntaxStablePtrId {
13429 self.0
13430 }
13431 fn lookup(&self, db: &dyn SyntaxGroup) -> FunctionWithBody {
13432 FunctionWithBody::from_syntax_node(db, self.0.lookup(db))
13433 }
13434}
13435impl From<FunctionWithBodyPtr> for SyntaxStablePtrId {
13436 fn from(ptr: FunctionWithBodyPtr) -> Self {
13437 ptr.untyped()
13438 }
13439}
13440#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13441pub struct FunctionWithBodyGreen(pub GreenId);
13442impl TypedSyntaxNode for FunctionWithBody {
13443 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::FunctionWithBody);
13444 type StablePtr = FunctionWithBodyPtr;
13445 type Green = FunctionWithBodyGreen;
13446 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13447 FunctionWithBodyGreen(
13448 Arc::new(GreenNode {
13449 kind: SyntaxKind::FunctionWithBody,
13450 details: GreenNodeDetails::Node {
13451 children: vec![
13452 AttributeList::missing(db).0,
13453 Visibility::missing(db).0,
13454 FunctionDeclaration::missing(db).0,
13455 ExprBlock::missing(db).0,
13456 ],
13457 width: TextWidth::default(),
13458 },
13459 })
13460 .intern(db),
13461 )
13462 }
13463 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13464 let kind = node.kind(db);
13465 assert_eq!(
13466 kind,
13467 SyntaxKind::FunctionWithBody,
13468 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13469 kind,
13470 SyntaxKind::FunctionWithBody
13471 );
13472 let children = db.get_children(node.clone());
13473 Self { node, children }
13474 }
13475 fn as_syntax_node(&self) -> SyntaxNode {
13476 self.node.clone()
13477 }
13478 fn stable_ptr(&self) -> Self::StablePtr {
13479 FunctionWithBodyPtr(self.node.0.stable_ptr)
13480 }
13481}
13482impl From<&FunctionWithBody> for SyntaxStablePtrId {
13483 fn from(node: &FunctionWithBody) -> Self {
13484 node.stable_ptr().untyped()
13485 }
13486}
13487#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13488pub struct ItemExternFunction {
13489 node: SyntaxNode,
13490 children: Arc<[SyntaxNode]>,
13491}
13492impl ItemExternFunction {
13493 pub const INDEX_ATTRIBUTES: usize = 0;
13494 pub const INDEX_VISIBILITY: usize = 1;
13495 pub const INDEX_EXTERN_KW: usize = 2;
13496 pub const INDEX_DECLARATION: usize = 3;
13497 pub const INDEX_SEMICOLON: usize = 4;
13498 pub fn new_green(
13499 db: &dyn SyntaxGroup,
13500 attributes: AttributeListGreen,
13501 visibility: VisibilityGreen,
13502 extern_kw: TerminalExternGreen,
13503 declaration: FunctionDeclarationGreen,
13504 semicolon: TerminalSemicolonGreen,
13505 ) -> ItemExternFunctionGreen {
13506 let children: Vec<GreenId> =
13507 vec![attributes.0, visibility.0, extern_kw.0, declaration.0, semicolon.0];
13508 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13509 ItemExternFunctionGreen(
13510 Arc::new(GreenNode {
13511 kind: SyntaxKind::ItemExternFunction,
13512 details: GreenNodeDetails::Node { children, width },
13513 })
13514 .intern(db),
13515 )
13516 }
13517}
13518impl ItemExternFunction {
13519 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
13520 AttributeList::from_syntax_node(db, self.children[0].clone())
13521 }
13522 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
13523 Visibility::from_syntax_node(db, self.children[1].clone())
13524 }
13525 pub fn extern_kw(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
13526 TerminalExtern::from_syntax_node(db, self.children[2].clone())
13527 }
13528 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
13529 FunctionDeclaration::from_syntax_node(db, self.children[3].clone())
13530 }
13531 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
13532 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
13533 }
13534}
13535#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13536pub struct ItemExternFunctionPtr(pub SyntaxStablePtrId);
13537impl ItemExternFunctionPtr {
13538 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
13539 let ptr = self.0.lookup_intern(db);
13540 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13541 FunctionDeclarationGreen(key_fields[0])
13542 } else {
13543 panic!("Unexpected key field query on root.");
13544 }
13545 }
13546}
13547impl TypedStablePtr for ItemExternFunctionPtr {
13548 type SyntaxNode = ItemExternFunction;
13549 fn untyped(&self) -> SyntaxStablePtrId {
13550 self.0
13551 }
13552 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemExternFunction {
13553 ItemExternFunction::from_syntax_node(db, self.0.lookup(db))
13554 }
13555}
13556impl From<ItemExternFunctionPtr> for SyntaxStablePtrId {
13557 fn from(ptr: ItemExternFunctionPtr) -> Self {
13558 ptr.untyped()
13559 }
13560}
13561#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13562pub struct ItemExternFunctionGreen(pub GreenId);
13563impl TypedSyntaxNode for ItemExternFunction {
13564 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemExternFunction);
13565 type StablePtr = ItemExternFunctionPtr;
13566 type Green = ItemExternFunctionGreen;
13567 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13568 ItemExternFunctionGreen(
13569 Arc::new(GreenNode {
13570 kind: SyntaxKind::ItemExternFunction,
13571 details: GreenNodeDetails::Node {
13572 children: vec![
13573 AttributeList::missing(db).0,
13574 Visibility::missing(db).0,
13575 TerminalExtern::missing(db).0,
13576 FunctionDeclaration::missing(db).0,
13577 TerminalSemicolon::missing(db).0,
13578 ],
13579 width: TextWidth::default(),
13580 },
13581 })
13582 .intern(db),
13583 )
13584 }
13585 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13586 let kind = node.kind(db);
13587 assert_eq!(
13588 kind,
13589 SyntaxKind::ItemExternFunction,
13590 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13591 kind,
13592 SyntaxKind::ItemExternFunction
13593 );
13594 let children = db.get_children(node.clone());
13595 Self { node, children }
13596 }
13597 fn as_syntax_node(&self) -> SyntaxNode {
13598 self.node.clone()
13599 }
13600 fn stable_ptr(&self) -> Self::StablePtr {
13601 ItemExternFunctionPtr(self.node.0.stable_ptr)
13602 }
13603}
13604impl From<&ItemExternFunction> for SyntaxStablePtrId {
13605 fn from(node: &ItemExternFunction) -> Self {
13606 node.stable_ptr().untyped()
13607 }
13608}
13609#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13610pub struct ItemExternType {
13611 node: SyntaxNode,
13612 children: Arc<[SyntaxNode]>,
13613}
13614impl ItemExternType {
13615 pub const INDEX_ATTRIBUTES: usize = 0;
13616 pub const INDEX_VISIBILITY: usize = 1;
13617 pub const INDEX_EXTERN_KW: usize = 2;
13618 pub const INDEX_TYPE_KW: usize = 3;
13619 pub const INDEX_NAME: usize = 4;
13620 pub const INDEX_GENERIC_PARAMS: usize = 5;
13621 pub const INDEX_SEMICOLON: usize = 6;
13622 pub fn new_green(
13623 db: &dyn SyntaxGroup,
13624 attributes: AttributeListGreen,
13625 visibility: VisibilityGreen,
13626 extern_kw: TerminalExternGreen,
13627 type_kw: TerminalTypeGreen,
13628 name: TerminalIdentifierGreen,
13629 generic_params: OptionWrappedGenericParamListGreen,
13630 semicolon: TerminalSemicolonGreen,
13631 ) -> ItemExternTypeGreen {
13632 let children: Vec<GreenId> = vec![
13633 attributes.0,
13634 visibility.0,
13635 extern_kw.0,
13636 type_kw.0,
13637 name.0,
13638 generic_params.0,
13639 semicolon.0,
13640 ];
13641 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13642 ItemExternTypeGreen(
13643 Arc::new(GreenNode {
13644 kind: SyntaxKind::ItemExternType,
13645 details: GreenNodeDetails::Node { children, width },
13646 })
13647 .intern(db),
13648 )
13649 }
13650}
13651impl ItemExternType {
13652 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
13653 AttributeList::from_syntax_node(db, self.children[0].clone())
13654 }
13655 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
13656 Visibility::from_syntax_node(db, self.children[1].clone())
13657 }
13658 pub fn extern_kw(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
13659 TerminalExtern::from_syntax_node(db, self.children[2].clone())
13660 }
13661 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
13662 TerminalType::from_syntax_node(db, self.children[3].clone())
13663 }
13664 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
13665 TerminalIdentifier::from_syntax_node(db, self.children[4].clone())
13666 }
13667 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
13668 OptionWrappedGenericParamList::from_syntax_node(db, self.children[5].clone())
13669 }
13670 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
13671 TerminalSemicolon::from_syntax_node(db, self.children[6].clone())
13672 }
13673}
13674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13675pub struct ItemExternTypePtr(pub SyntaxStablePtrId);
13676impl ItemExternTypePtr {
13677 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
13678 let ptr = self.0.lookup_intern(db);
13679 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13680 TerminalIdentifierGreen(key_fields[0])
13681 } else {
13682 panic!("Unexpected key field query on root.");
13683 }
13684 }
13685}
13686impl TypedStablePtr for ItemExternTypePtr {
13687 type SyntaxNode = ItemExternType;
13688 fn untyped(&self) -> SyntaxStablePtrId {
13689 self.0
13690 }
13691 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemExternType {
13692 ItemExternType::from_syntax_node(db, self.0.lookup(db))
13693 }
13694}
13695impl From<ItemExternTypePtr> for SyntaxStablePtrId {
13696 fn from(ptr: ItemExternTypePtr) -> Self {
13697 ptr.untyped()
13698 }
13699}
13700#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13701pub struct ItemExternTypeGreen(pub GreenId);
13702impl TypedSyntaxNode for ItemExternType {
13703 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemExternType);
13704 type StablePtr = ItemExternTypePtr;
13705 type Green = ItemExternTypeGreen;
13706 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13707 ItemExternTypeGreen(
13708 Arc::new(GreenNode {
13709 kind: SyntaxKind::ItemExternType,
13710 details: GreenNodeDetails::Node {
13711 children: vec![
13712 AttributeList::missing(db).0,
13713 Visibility::missing(db).0,
13714 TerminalExtern::missing(db).0,
13715 TerminalType::missing(db).0,
13716 TerminalIdentifier::missing(db).0,
13717 OptionWrappedGenericParamList::missing(db).0,
13718 TerminalSemicolon::missing(db).0,
13719 ],
13720 width: TextWidth::default(),
13721 },
13722 })
13723 .intern(db),
13724 )
13725 }
13726 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13727 let kind = node.kind(db);
13728 assert_eq!(
13729 kind,
13730 SyntaxKind::ItemExternType,
13731 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13732 kind,
13733 SyntaxKind::ItemExternType
13734 );
13735 let children = db.get_children(node.clone());
13736 Self { node, children }
13737 }
13738 fn as_syntax_node(&self) -> SyntaxNode {
13739 self.node.clone()
13740 }
13741 fn stable_ptr(&self) -> Self::StablePtr {
13742 ItemExternTypePtr(self.node.0.stable_ptr)
13743 }
13744}
13745impl From<&ItemExternType> for SyntaxStablePtrId {
13746 fn from(node: &ItemExternType) -> Self {
13747 node.stable_ptr().untyped()
13748 }
13749}
13750#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13751pub struct ItemTrait {
13752 node: SyntaxNode,
13753 children: Arc<[SyntaxNode]>,
13754}
13755impl ItemTrait {
13756 pub const INDEX_ATTRIBUTES: usize = 0;
13757 pub const INDEX_VISIBILITY: usize = 1;
13758 pub const INDEX_TRAIT_KW: usize = 2;
13759 pub const INDEX_NAME: usize = 3;
13760 pub const INDEX_GENERIC_PARAMS: usize = 4;
13761 pub const INDEX_BODY: usize = 5;
13762 pub fn new_green(
13763 db: &dyn SyntaxGroup,
13764 attributes: AttributeListGreen,
13765 visibility: VisibilityGreen,
13766 trait_kw: TerminalTraitGreen,
13767 name: TerminalIdentifierGreen,
13768 generic_params: OptionWrappedGenericParamListGreen,
13769 body: MaybeTraitBodyGreen,
13770 ) -> ItemTraitGreen {
13771 let children: Vec<GreenId> =
13772 vec![attributes.0, visibility.0, trait_kw.0, name.0, generic_params.0, body.0];
13773 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13774 ItemTraitGreen(
13775 Arc::new(GreenNode {
13776 kind: SyntaxKind::ItemTrait,
13777 details: GreenNodeDetails::Node { children, width },
13778 })
13779 .intern(db),
13780 )
13781 }
13782}
13783impl ItemTrait {
13784 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
13785 AttributeList::from_syntax_node(db, self.children[0].clone())
13786 }
13787 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
13788 Visibility::from_syntax_node(db, self.children[1].clone())
13789 }
13790 pub fn trait_kw(&self, db: &dyn SyntaxGroup) -> TerminalTrait {
13791 TerminalTrait::from_syntax_node(db, self.children[2].clone())
13792 }
13793 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
13794 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
13795 }
13796 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
13797 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
13798 }
13799 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeTraitBody {
13800 MaybeTraitBody::from_syntax_node(db, self.children[5].clone())
13801 }
13802}
13803#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13804pub struct ItemTraitPtr(pub SyntaxStablePtrId);
13805impl ItemTraitPtr {
13806 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
13807 let ptr = self.0.lookup_intern(db);
13808 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
13809 TerminalIdentifierGreen(key_fields[0])
13810 } else {
13811 panic!("Unexpected key field query on root.");
13812 }
13813 }
13814}
13815impl TypedStablePtr for ItemTraitPtr {
13816 type SyntaxNode = ItemTrait;
13817 fn untyped(&self) -> SyntaxStablePtrId {
13818 self.0
13819 }
13820 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemTrait {
13821 ItemTrait::from_syntax_node(db, self.0.lookup(db))
13822 }
13823}
13824impl From<ItemTraitPtr> for SyntaxStablePtrId {
13825 fn from(ptr: ItemTraitPtr) -> Self {
13826 ptr.untyped()
13827 }
13828}
13829#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13830pub struct ItemTraitGreen(pub GreenId);
13831impl TypedSyntaxNode for ItemTrait {
13832 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemTrait);
13833 type StablePtr = ItemTraitPtr;
13834 type Green = ItemTraitGreen;
13835 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13836 ItemTraitGreen(
13837 Arc::new(GreenNode {
13838 kind: SyntaxKind::ItemTrait,
13839 details: GreenNodeDetails::Node {
13840 children: vec![
13841 AttributeList::missing(db).0,
13842 Visibility::missing(db).0,
13843 TerminalTrait::missing(db).0,
13844 TerminalIdentifier::missing(db).0,
13845 OptionWrappedGenericParamList::missing(db).0,
13846 MaybeTraitBody::missing(db).0,
13847 ],
13848 width: TextWidth::default(),
13849 },
13850 })
13851 .intern(db),
13852 )
13853 }
13854 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13855 let kind = node.kind(db);
13856 assert_eq!(
13857 kind,
13858 SyntaxKind::ItemTrait,
13859 "Unexpected SyntaxKind {:?}. Expected {:?}.",
13860 kind,
13861 SyntaxKind::ItemTrait
13862 );
13863 let children = db.get_children(node.clone());
13864 Self { node, children }
13865 }
13866 fn as_syntax_node(&self) -> SyntaxNode {
13867 self.node.clone()
13868 }
13869 fn stable_ptr(&self) -> Self::StablePtr {
13870 ItemTraitPtr(self.node.0.stable_ptr)
13871 }
13872}
13873impl From<&ItemTrait> for SyntaxStablePtrId {
13874 fn from(node: &ItemTrait) -> Self {
13875 node.stable_ptr().untyped()
13876 }
13877}
13878#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13879pub enum MaybeTraitBody {
13880 Some(TraitBody),
13881 None(TerminalSemicolon),
13882}
13883#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13884pub struct MaybeTraitBodyPtr(pub SyntaxStablePtrId);
13885impl TypedStablePtr for MaybeTraitBodyPtr {
13886 type SyntaxNode = MaybeTraitBody;
13887 fn untyped(&self) -> SyntaxStablePtrId {
13888 self.0
13889 }
13890 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeTraitBody {
13891 MaybeTraitBody::from_syntax_node(db, self.0.lookup(db))
13892 }
13893}
13894impl From<MaybeTraitBodyPtr> for SyntaxStablePtrId {
13895 fn from(ptr: MaybeTraitBodyPtr) -> Self {
13896 ptr.untyped()
13897 }
13898}
13899impl From<TraitBodyPtr> for MaybeTraitBodyPtr {
13900 fn from(value: TraitBodyPtr) -> Self {
13901 Self(value.0)
13902 }
13903}
13904impl From<TerminalSemicolonPtr> for MaybeTraitBodyPtr {
13905 fn from(value: TerminalSemicolonPtr) -> Self {
13906 Self(value.0)
13907 }
13908}
13909impl From<TraitBodyGreen> for MaybeTraitBodyGreen {
13910 fn from(value: TraitBodyGreen) -> Self {
13911 Self(value.0)
13912 }
13913}
13914impl From<TerminalSemicolonGreen> for MaybeTraitBodyGreen {
13915 fn from(value: TerminalSemicolonGreen) -> Self {
13916 Self(value.0)
13917 }
13918}
13919#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13920pub struct MaybeTraitBodyGreen(pub GreenId);
13921impl TypedSyntaxNode for MaybeTraitBody {
13922 const OPTIONAL_KIND: Option<SyntaxKind> = None;
13923 type StablePtr = MaybeTraitBodyPtr;
13924 type Green = MaybeTraitBodyGreen;
13925 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
13926 panic!("No missing variant.");
13927 }
13928 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
13929 let kind = node.kind(db);
13930 match kind {
13931 SyntaxKind::TraitBody => MaybeTraitBody::Some(TraitBody::from_syntax_node(db, node)),
13932 SyntaxKind::TerminalSemicolon => {
13933 MaybeTraitBody::None(TerminalSemicolon::from_syntax_node(db, node))
13934 }
13935 _ => {
13936 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeTraitBody")
13937 }
13938 }
13939 }
13940 fn as_syntax_node(&self) -> SyntaxNode {
13941 match self {
13942 MaybeTraitBody::Some(x) => x.as_syntax_node(),
13943 MaybeTraitBody::None(x) => x.as_syntax_node(),
13944 }
13945 }
13946 fn stable_ptr(&self) -> Self::StablePtr {
13947 MaybeTraitBodyPtr(self.as_syntax_node().0.stable_ptr)
13948 }
13949}
13950impl From<&MaybeTraitBody> for SyntaxStablePtrId {
13951 fn from(node: &MaybeTraitBody) -> Self {
13952 node.stable_ptr().untyped()
13953 }
13954}
13955impl MaybeTraitBody {
13956 pub fn is_variant(kind: SyntaxKind) -> bool {
13958 matches!(kind, SyntaxKind::TraitBody | SyntaxKind::TerminalSemicolon)
13959 }
13960}
13961#[derive(Clone, Debug, Eq, Hash, PartialEq)]
13962pub struct TraitBody {
13963 node: SyntaxNode,
13964 children: Arc<[SyntaxNode]>,
13965}
13966impl TraitBody {
13967 pub const INDEX_LBRACE: usize = 0;
13968 pub const INDEX_ITEMS: usize = 1;
13969 pub const INDEX_RBRACE: usize = 2;
13970 pub fn new_green(
13971 db: &dyn SyntaxGroup,
13972 lbrace: TerminalLBraceGreen,
13973 items: TraitItemListGreen,
13974 rbrace: TerminalRBraceGreen,
13975 ) -> TraitBodyGreen {
13976 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
13977 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
13978 TraitBodyGreen(
13979 Arc::new(GreenNode {
13980 kind: SyntaxKind::TraitBody,
13981 details: GreenNodeDetails::Node { children, width },
13982 })
13983 .intern(db),
13984 )
13985 }
13986}
13987impl TraitBody {
13988 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
13989 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
13990 }
13991 pub fn items(&self, db: &dyn SyntaxGroup) -> TraitItemList {
13992 TraitItemList::from_syntax_node(db, self.children[1].clone())
13993 }
13994 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
13995 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
13996 }
13997}
13998#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
13999pub struct TraitBodyPtr(pub SyntaxStablePtrId);
14000impl TraitBodyPtr {}
14001impl TypedStablePtr for TraitBodyPtr {
14002 type SyntaxNode = TraitBody;
14003 fn untyped(&self) -> SyntaxStablePtrId {
14004 self.0
14005 }
14006 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitBody {
14007 TraitBody::from_syntax_node(db, self.0.lookup(db))
14008 }
14009}
14010impl From<TraitBodyPtr> for SyntaxStablePtrId {
14011 fn from(ptr: TraitBodyPtr) -> Self {
14012 ptr.untyped()
14013 }
14014}
14015#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14016pub struct TraitBodyGreen(pub GreenId);
14017impl TypedSyntaxNode for TraitBody {
14018 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitBody);
14019 type StablePtr = TraitBodyPtr;
14020 type Green = TraitBodyGreen;
14021 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14022 TraitBodyGreen(
14023 Arc::new(GreenNode {
14024 kind: SyntaxKind::TraitBody,
14025 details: GreenNodeDetails::Node {
14026 children: vec![
14027 TerminalLBrace::missing(db).0,
14028 TraitItemList::missing(db).0,
14029 TerminalRBrace::missing(db).0,
14030 ],
14031 width: TextWidth::default(),
14032 },
14033 })
14034 .intern(db),
14035 )
14036 }
14037 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14038 let kind = node.kind(db);
14039 assert_eq!(
14040 kind,
14041 SyntaxKind::TraitBody,
14042 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14043 kind,
14044 SyntaxKind::TraitBody
14045 );
14046 let children = db.get_children(node.clone());
14047 Self { node, children }
14048 }
14049 fn as_syntax_node(&self) -> SyntaxNode {
14050 self.node.clone()
14051 }
14052 fn stable_ptr(&self) -> Self::StablePtr {
14053 TraitBodyPtr(self.node.0.stable_ptr)
14054 }
14055}
14056impl From<&TraitBody> for SyntaxStablePtrId {
14057 fn from(node: &TraitBody) -> Self {
14058 node.stable_ptr().untyped()
14059 }
14060}
14061#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14062pub struct TraitItemList(ElementList<TraitItem, 1>);
14063impl Deref for TraitItemList {
14064 type Target = ElementList<TraitItem, 1>;
14065 fn deref(&self) -> &Self::Target {
14066 &self.0
14067 }
14068}
14069impl TraitItemList {
14070 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<TraitItemGreen>) -> TraitItemListGreen {
14071 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
14072 TraitItemListGreen(
14073 Arc::new(GreenNode {
14074 kind: SyntaxKind::TraitItemList,
14075 details: GreenNodeDetails::Node {
14076 children: children.iter().map(|x| x.0).collect(),
14077 width,
14078 },
14079 })
14080 .intern(db),
14081 )
14082 }
14083}
14084#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14085pub struct TraitItemListPtr(pub SyntaxStablePtrId);
14086impl TypedStablePtr for TraitItemListPtr {
14087 type SyntaxNode = TraitItemList;
14088 fn untyped(&self) -> SyntaxStablePtrId {
14089 self.0
14090 }
14091 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemList {
14092 TraitItemList::from_syntax_node(db, self.0.lookup(db))
14093 }
14094}
14095impl From<TraitItemListPtr> for SyntaxStablePtrId {
14096 fn from(ptr: TraitItemListPtr) -> Self {
14097 ptr.untyped()
14098 }
14099}
14100#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14101pub struct TraitItemListGreen(pub GreenId);
14102impl TypedSyntaxNode for TraitItemList {
14103 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemList);
14104 type StablePtr = TraitItemListPtr;
14105 type Green = TraitItemListGreen;
14106 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14107 TraitItemListGreen(
14108 Arc::new(GreenNode {
14109 kind: SyntaxKind::TraitItemList,
14110 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
14111 })
14112 .intern(db),
14113 )
14114 }
14115 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14116 Self(ElementList::new(node))
14117 }
14118 fn as_syntax_node(&self) -> SyntaxNode {
14119 self.node.clone()
14120 }
14121 fn stable_ptr(&self) -> Self::StablePtr {
14122 TraitItemListPtr(self.node.0.stable_ptr)
14123 }
14124}
14125impl From<&TraitItemList> for SyntaxStablePtrId {
14126 fn from(node: &TraitItemList) -> Self {
14127 node.stable_ptr().untyped()
14128 }
14129}
14130#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14131pub enum TraitItem {
14132 Function(TraitItemFunction),
14133 Type(TraitItemType),
14134 Constant(TraitItemConstant),
14135 Impl(TraitItemImpl),
14136 Missing(TraitItemMissing),
14137}
14138#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14139pub struct TraitItemPtr(pub SyntaxStablePtrId);
14140impl TypedStablePtr for TraitItemPtr {
14141 type SyntaxNode = TraitItem;
14142 fn untyped(&self) -> SyntaxStablePtrId {
14143 self.0
14144 }
14145 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItem {
14146 TraitItem::from_syntax_node(db, self.0.lookup(db))
14147 }
14148}
14149impl From<TraitItemPtr> for SyntaxStablePtrId {
14150 fn from(ptr: TraitItemPtr) -> Self {
14151 ptr.untyped()
14152 }
14153}
14154impl From<TraitItemFunctionPtr> for TraitItemPtr {
14155 fn from(value: TraitItemFunctionPtr) -> Self {
14156 Self(value.0)
14157 }
14158}
14159impl From<TraitItemTypePtr> for TraitItemPtr {
14160 fn from(value: TraitItemTypePtr) -> Self {
14161 Self(value.0)
14162 }
14163}
14164impl From<TraitItemConstantPtr> for TraitItemPtr {
14165 fn from(value: TraitItemConstantPtr) -> Self {
14166 Self(value.0)
14167 }
14168}
14169impl From<TraitItemImplPtr> for TraitItemPtr {
14170 fn from(value: TraitItemImplPtr) -> Self {
14171 Self(value.0)
14172 }
14173}
14174impl From<TraitItemMissingPtr> for TraitItemPtr {
14175 fn from(value: TraitItemMissingPtr) -> Self {
14176 Self(value.0)
14177 }
14178}
14179impl From<TraitItemFunctionGreen> for TraitItemGreen {
14180 fn from(value: TraitItemFunctionGreen) -> Self {
14181 Self(value.0)
14182 }
14183}
14184impl From<TraitItemTypeGreen> for TraitItemGreen {
14185 fn from(value: TraitItemTypeGreen) -> Self {
14186 Self(value.0)
14187 }
14188}
14189impl From<TraitItemConstantGreen> for TraitItemGreen {
14190 fn from(value: TraitItemConstantGreen) -> Self {
14191 Self(value.0)
14192 }
14193}
14194impl From<TraitItemImplGreen> for TraitItemGreen {
14195 fn from(value: TraitItemImplGreen) -> Self {
14196 Self(value.0)
14197 }
14198}
14199impl From<TraitItemMissingGreen> for TraitItemGreen {
14200 fn from(value: TraitItemMissingGreen) -> Self {
14201 Self(value.0)
14202 }
14203}
14204#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14205pub struct TraitItemGreen(pub GreenId);
14206impl TypedSyntaxNode for TraitItem {
14207 const OPTIONAL_KIND: Option<SyntaxKind> = None;
14208 type StablePtr = TraitItemPtr;
14209 type Green = TraitItemGreen;
14210 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14211 TraitItemGreen(TraitItemMissing::missing(db).0)
14212 }
14213 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14214 let kind = node.kind(db);
14215 match kind {
14216 SyntaxKind::TraitItemFunction => {
14217 TraitItem::Function(TraitItemFunction::from_syntax_node(db, node))
14218 }
14219 SyntaxKind::TraitItemType => TraitItem::Type(TraitItemType::from_syntax_node(db, node)),
14220 SyntaxKind::TraitItemConstant => {
14221 TraitItem::Constant(TraitItemConstant::from_syntax_node(db, node))
14222 }
14223 SyntaxKind::TraitItemImpl => TraitItem::Impl(TraitItemImpl::from_syntax_node(db, node)),
14224 SyntaxKind::TraitItemMissing => {
14225 TraitItem::Missing(TraitItemMissing::from_syntax_node(db, node))
14226 }
14227 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TraitItem"),
14228 }
14229 }
14230 fn as_syntax_node(&self) -> SyntaxNode {
14231 match self {
14232 TraitItem::Function(x) => x.as_syntax_node(),
14233 TraitItem::Type(x) => x.as_syntax_node(),
14234 TraitItem::Constant(x) => x.as_syntax_node(),
14235 TraitItem::Impl(x) => x.as_syntax_node(),
14236 TraitItem::Missing(x) => x.as_syntax_node(),
14237 }
14238 }
14239 fn stable_ptr(&self) -> Self::StablePtr {
14240 TraitItemPtr(self.as_syntax_node().0.stable_ptr)
14241 }
14242}
14243impl From<&TraitItem> for SyntaxStablePtrId {
14244 fn from(node: &TraitItem) -> Self {
14245 node.stable_ptr().untyped()
14246 }
14247}
14248impl TraitItem {
14249 pub fn is_variant(kind: SyntaxKind) -> bool {
14251 matches!(
14252 kind,
14253 SyntaxKind::TraitItemFunction
14254 | SyntaxKind::TraitItemType
14255 | SyntaxKind::TraitItemConstant
14256 | SyntaxKind::TraitItemImpl
14257 | SyntaxKind::TraitItemMissing
14258 )
14259 }
14260}
14261#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14262pub struct TraitItemMissing {
14263 node: SyntaxNode,
14264 children: Arc<[SyntaxNode]>,
14265}
14266impl TraitItemMissing {
14267 pub fn new_green(db: &dyn SyntaxGroup) -> TraitItemMissingGreen {
14268 let children: Vec<GreenId> = vec![];
14269 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14270 TraitItemMissingGreen(
14271 Arc::new(GreenNode {
14272 kind: SyntaxKind::TraitItemMissing,
14273 details: GreenNodeDetails::Node { children, width },
14274 })
14275 .intern(db),
14276 )
14277 }
14278}
14279impl TraitItemMissing {}
14280#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14281pub struct TraitItemMissingPtr(pub SyntaxStablePtrId);
14282impl TraitItemMissingPtr {}
14283impl TypedStablePtr for TraitItemMissingPtr {
14284 type SyntaxNode = TraitItemMissing;
14285 fn untyped(&self) -> SyntaxStablePtrId {
14286 self.0
14287 }
14288 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemMissing {
14289 TraitItemMissing::from_syntax_node(db, self.0.lookup(db))
14290 }
14291}
14292impl From<TraitItemMissingPtr> for SyntaxStablePtrId {
14293 fn from(ptr: TraitItemMissingPtr) -> Self {
14294 ptr.untyped()
14295 }
14296}
14297#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14298pub struct TraitItemMissingGreen(pub GreenId);
14299impl TypedSyntaxNode for TraitItemMissing {
14300 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemMissing);
14301 type StablePtr = TraitItemMissingPtr;
14302 type Green = TraitItemMissingGreen;
14303 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14304 TraitItemMissingGreen(
14305 Arc::new(GreenNode {
14306 kind: SyntaxKind::TraitItemMissing,
14307 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
14308 })
14309 .intern(db),
14310 )
14311 }
14312 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14313 let kind = node.kind(db);
14314 assert_eq!(
14315 kind,
14316 SyntaxKind::TraitItemMissing,
14317 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14318 kind,
14319 SyntaxKind::TraitItemMissing
14320 );
14321 let children = db.get_children(node.clone());
14322 Self { node, children }
14323 }
14324 fn as_syntax_node(&self) -> SyntaxNode {
14325 self.node.clone()
14326 }
14327 fn stable_ptr(&self) -> Self::StablePtr {
14328 TraitItemMissingPtr(self.node.0.stable_ptr)
14329 }
14330}
14331impl From<&TraitItemMissing> for SyntaxStablePtrId {
14332 fn from(node: &TraitItemMissing) -> Self {
14333 node.stable_ptr().untyped()
14334 }
14335}
14336#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14337pub struct TraitItemFunction {
14338 node: SyntaxNode,
14339 children: Arc<[SyntaxNode]>,
14340}
14341impl TraitItemFunction {
14342 pub const INDEX_ATTRIBUTES: usize = 0;
14343 pub const INDEX_DECLARATION: usize = 1;
14344 pub const INDEX_BODY: usize = 2;
14345 pub fn new_green(
14346 db: &dyn SyntaxGroup,
14347 attributes: AttributeListGreen,
14348 declaration: FunctionDeclarationGreen,
14349 body: MaybeTraitFunctionBodyGreen,
14350 ) -> TraitItemFunctionGreen {
14351 let children: Vec<GreenId> = vec![attributes.0, declaration.0, body.0];
14352 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14353 TraitItemFunctionGreen(
14354 Arc::new(GreenNode {
14355 kind: SyntaxKind::TraitItemFunction,
14356 details: GreenNodeDetails::Node { children, width },
14357 })
14358 .intern(db),
14359 )
14360 }
14361}
14362impl TraitItemFunction {
14363 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14364 AttributeList::from_syntax_node(db, self.children[0].clone())
14365 }
14366 pub fn declaration(&self, db: &dyn SyntaxGroup) -> FunctionDeclaration {
14367 FunctionDeclaration::from_syntax_node(db, self.children[1].clone())
14368 }
14369 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeTraitFunctionBody {
14370 MaybeTraitFunctionBody::from_syntax_node(db, self.children[2].clone())
14371 }
14372}
14373#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14374pub struct TraitItemFunctionPtr(pub SyntaxStablePtrId);
14375impl TraitItemFunctionPtr {
14376 pub fn declaration_green(self, db: &dyn SyntaxGroup) -> FunctionDeclarationGreen {
14377 let ptr = self.0.lookup_intern(db);
14378 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14379 FunctionDeclarationGreen(key_fields[0])
14380 } else {
14381 panic!("Unexpected key field query on root.");
14382 }
14383 }
14384}
14385impl TypedStablePtr for TraitItemFunctionPtr {
14386 type SyntaxNode = TraitItemFunction;
14387 fn untyped(&self) -> SyntaxStablePtrId {
14388 self.0
14389 }
14390 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemFunction {
14391 TraitItemFunction::from_syntax_node(db, self.0.lookup(db))
14392 }
14393}
14394impl From<TraitItemFunctionPtr> for SyntaxStablePtrId {
14395 fn from(ptr: TraitItemFunctionPtr) -> Self {
14396 ptr.untyped()
14397 }
14398}
14399#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14400pub struct TraitItemFunctionGreen(pub GreenId);
14401impl TypedSyntaxNode for TraitItemFunction {
14402 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemFunction);
14403 type StablePtr = TraitItemFunctionPtr;
14404 type Green = TraitItemFunctionGreen;
14405 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14406 TraitItemFunctionGreen(
14407 Arc::new(GreenNode {
14408 kind: SyntaxKind::TraitItemFunction,
14409 details: GreenNodeDetails::Node {
14410 children: vec![
14411 AttributeList::missing(db).0,
14412 FunctionDeclaration::missing(db).0,
14413 MaybeTraitFunctionBody::missing(db).0,
14414 ],
14415 width: TextWidth::default(),
14416 },
14417 })
14418 .intern(db),
14419 )
14420 }
14421 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14422 let kind = node.kind(db);
14423 assert_eq!(
14424 kind,
14425 SyntaxKind::TraitItemFunction,
14426 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14427 kind,
14428 SyntaxKind::TraitItemFunction
14429 );
14430 let children = db.get_children(node.clone());
14431 Self { node, children }
14432 }
14433 fn as_syntax_node(&self) -> SyntaxNode {
14434 self.node.clone()
14435 }
14436 fn stable_ptr(&self) -> Self::StablePtr {
14437 TraitItemFunctionPtr(self.node.0.stable_ptr)
14438 }
14439}
14440impl From<&TraitItemFunction> for SyntaxStablePtrId {
14441 fn from(node: &TraitItemFunction) -> Self {
14442 node.stable_ptr().untyped()
14443 }
14444}
14445#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14446pub struct TraitItemType {
14447 node: SyntaxNode,
14448 children: Arc<[SyntaxNode]>,
14449}
14450impl TraitItemType {
14451 pub const INDEX_ATTRIBUTES: usize = 0;
14452 pub const INDEX_TYPE_KW: usize = 1;
14453 pub const INDEX_NAME: usize = 2;
14454 pub const INDEX_GENERIC_PARAMS: usize = 3;
14455 pub const INDEX_SEMICOLON: usize = 4;
14456 pub fn new_green(
14457 db: &dyn SyntaxGroup,
14458 attributes: AttributeListGreen,
14459 type_kw: TerminalTypeGreen,
14460 name: TerminalIdentifierGreen,
14461 generic_params: OptionWrappedGenericParamListGreen,
14462 semicolon: TerminalSemicolonGreen,
14463 ) -> TraitItemTypeGreen {
14464 let children: Vec<GreenId> =
14465 vec![attributes.0, type_kw.0, name.0, generic_params.0, semicolon.0];
14466 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14467 TraitItemTypeGreen(
14468 Arc::new(GreenNode {
14469 kind: SyntaxKind::TraitItemType,
14470 details: GreenNodeDetails::Node { children, width },
14471 })
14472 .intern(db),
14473 )
14474 }
14475}
14476impl TraitItemType {
14477 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14478 AttributeList::from_syntax_node(db, self.children[0].clone())
14479 }
14480 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
14481 TerminalType::from_syntax_node(db, self.children[1].clone())
14482 }
14483 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14484 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
14485 }
14486 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
14487 OptionWrappedGenericParamList::from_syntax_node(db, self.children[3].clone())
14488 }
14489 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14490 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
14491 }
14492}
14493#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14494pub struct TraitItemTypePtr(pub SyntaxStablePtrId);
14495impl TraitItemTypePtr {
14496 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14497 let ptr = self.0.lookup_intern(db);
14498 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14499 TerminalIdentifierGreen(key_fields[0])
14500 } else {
14501 panic!("Unexpected key field query on root.");
14502 }
14503 }
14504}
14505impl TypedStablePtr for TraitItemTypePtr {
14506 type SyntaxNode = TraitItemType;
14507 fn untyped(&self) -> SyntaxStablePtrId {
14508 self.0
14509 }
14510 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemType {
14511 TraitItemType::from_syntax_node(db, self.0.lookup(db))
14512 }
14513}
14514impl From<TraitItemTypePtr> for SyntaxStablePtrId {
14515 fn from(ptr: TraitItemTypePtr) -> Self {
14516 ptr.untyped()
14517 }
14518}
14519#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14520pub struct TraitItemTypeGreen(pub GreenId);
14521impl TypedSyntaxNode for TraitItemType {
14522 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemType);
14523 type StablePtr = TraitItemTypePtr;
14524 type Green = TraitItemTypeGreen;
14525 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14526 TraitItemTypeGreen(
14527 Arc::new(GreenNode {
14528 kind: SyntaxKind::TraitItemType,
14529 details: GreenNodeDetails::Node {
14530 children: vec![
14531 AttributeList::missing(db).0,
14532 TerminalType::missing(db).0,
14533 TerminalIdentifier::missing(db).0,
14534 OptionWrappedGenericParamList::missing(db).0,
14535 TerminalSemicolon::missing(db).0,
14536 ],
14537 width: TextWidth::default(),
14538 },
14539 })
14540 .intern(db),
14541 )
14542 }
14543 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14544 let kind = node.kind(db);
14545 assert_eq!(
14546 kind,
14547 SyntaxKind::TraitItemType,
14548 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14549 kind,
14550 SyntaxKind::TraitItemType
14551 );
14552 let children = db.get_children(node.clone());
14553 Self { node, children }
14554 }
14555 fn as_syntax_node(&self) -> SyntaxNode {
14556 self.node.clone()
14557 }
14558 fn stable_ptr(&self) -> Self::StablePtr {
14559 TraitItemTypePtr(self.node.0.stable_ptr)
14560 }
14561}
14562impl From<&TraitItemType> for SyntaxStablePtrId {
14563 fn from(node: &TraitItemType) -> Self {
14564 node.stable_ptr().untyped()
14565 }
14566}
14567#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14568pub struct TraitItemConstant {
14569 node: SyntaxNode,
14570 children: Arc<[SyntaxNode]>,
14571}
14572impl TraitItemConstant {
14573 pub const INDEX_ATTRIBUTES: usize = 0;
14574 pub const INDEX_CONST_KW: usize = 1;
14575 pub const INDEX_NAME: usize = 2;
14576 pub const INDEX_TYPE_CLAUSE: usize = 3;
14577 pub const INDEX_SEMICOLON: usize = 4;
14578 pub fn new_green(
14579 db: &dyn SyntaxGroup,
14580 attributes: AttributeListGreen,
14581 const_kw: TerminalConstGreen,
14582 name: TerminalIdentifierGreen,
14583 type_clause: TypeClauseGreen,
14584 semicolon: TerminalSemicolonGreen,
14585 ) -> TraitItemConstantGreen {
14586 let children: Vec<GreenId> =
14587 vec![attributes.0, const_kw.0, name.0, type_clause.0, semicolon.0];
14588 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14589 TraitItemConstantGreen(
14590 Arc::new(GreenNode {
14591 kind: SyntaxKind::TraitItemConstant,
14592 details: GreenNodeDetails::Node { children, width },
14593 })
14594 .intern(db),
14595 )
14596 }
14597}
14598impl TraitItemConstant {
14599 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14600 AttributeList::from_syntax_node(db, self.children[0].clone())
14601 }
14602 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
14603 TerminalConst::from_syntax_node(db, self.children[1].clone())
14604 }
14605 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14606 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
14607 }
14608 pub fn type_clause(&self, db: &dyn SyntaxGroup) -> TypeClause {
14609 TypeClause::from_syntax_node(db, self.children[3].clone())
14610 }
14611 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14612 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
14613 }
14614}
14615#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14616pub struct TraitItemConstantPtr(pub SyntaxStablePtrId);
14617impl TraitItemConstantPtr {
14618 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14619 let ptr = self.0.lookup_intern(db);
14620 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14621 TerminalIdentifierGreen(key_fields[0])
14622 } else {
14623 panic!("Unexpected key field query on root.");
14624 }
14625 }
14626}
14627impl TypedStablePtr for TraitItemConstantPtr {
14628 type SyntaxNode = TraitItemConstant;
14629 fn untyped(&self) -> SyntaxStablePtrId {
14630 self.0
14631 }
14632 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemConstant {
14633 TraitItemConstant::from_syntax_node(db, self.0.lookup(db))
14634 }
14635}
14636impl From<TraitItemConstantPtr> for SyntaxStablePtrId {
14637 fn from(ptr: TraitItemConstantPtr) -> Self {
14638 ptr.untyped()
14639 }
14640}
14641#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14642pub struct TraitItemConstantGreen(pub GreenId);
14643impl TypedSyntaxNode for TraitItemConstant {
14644 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemConstant);
14645 type StablePtr = TraitItemConstantPtr;
14646 type Green = TraitItemConstantGreen;
14647 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14648 TraitItemConstantGreen(
14649 Arc::new(GreenNode {
14650 kind: SyntaxKind::TraitItemConstant,
14651 details: GreenNodeDetails::Node {
14652 children: vec![
14653 AttributeList::missing(db).0,
14654 TerminalConst::missing(db).0,
14655 TerminalIdentifier::missing(db).0,
14656 TypeClause::missing(db).0,
14657 TerminalSemicolon::missing(db).0,
14658 ],
14659 width: TextWidth::default(),
14660 },
14661 })
14662 .intern(db),
14663 )
14664 }
14665 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14666 let kind = node.kind(db);
14667 assert_eq!(
14668 kind,
14669 SyntaxKind::TraitItemConstant,
14670 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14671 kind,
14672 SyntaxKind::TraitItemConstant
14673 );
14674 let children = db.get_children(node.clone());
14675 Self { node, children }
14676 }
14677 fn as_syntax_node(&self) -> SyntaxNode {
14678 self.node.clone()
14679 }
14680 fn stable_ptr(&self) -> Self::StablePtr {
14681 TraitItemConstantPtr(self.node.0.stable_ptr)
14682 }
14683}
14684impl From<&TraitItemConstant> for SyntaxStablePtrId {
14685 fn from(node: &TraitItemConstant) -> Self {
14686 node.stable_ptr().untyped()
14687 }
14688}
14689#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14690pub struct TraitItemImpl {
14691 node: SyntaxNode,
14692 children: Arc<[SyntaxNode]>,
14693}
14694impl TraitItemImpl {
14695 pub const INDEX_ATTRIBUTES: usize = 0;
14696 pub const INDEX_IMPL_KW: usize = 1;
14697 pub const INDEX_NAME: usize = 2;
14698 pub const INDEX_COLON: usize = 3;
14699 pub const INDEX_TRAIT_PATH: usize = 4;
14700 pub const INDEX_SEMICOLON: usize = 5;
14701 pub fn new_green(
14702 db: &dyn SyntaxGroup,
14703 attributes: AttributeListGreen,
14704 impl_kw: TerminalImplGreen,
14705 name: TerminalIdentifierGreen,
14706 colon: TerminalColonGreen,
14707 trait_path: ExprPathGreen,
14708 semicolon: TerminalSemicolonGreen,
14709 ) -> TraitItemImplGreen {
14710 let children: Vec<GreenId> =
14711 vec![attributes.0, impl_kw.0, name.0, colon.0, trait_path.0, semicolon.0];
14712 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14713 TraitItemImplGreen(
14714 Arc::new(GreenNode {
14715 kind: SyntaxKind::TraitItemImpl,
14716 details: GreenNodeDetails::Node { children, width },
14717 })
14718 .intern(db),
14719 )
14720 }
14721}
14722impl TraitItemImpl {
14723 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14724 AttributeList::from_syntax_node(db, self.children[0].clone())
14725 }
14726 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
14727 TerminalImpl::from_syntax_node(db, self.children[1].clone())
14728 }
14729 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14730 TerminalIdentifier::from_syntax_node(db, self.children[2].clone())
14731 }
14732 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
14733 TerminalColon::from_syntax_node(db, self.children[3].clone())
14734 }
14735 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
14736 ExprPath::from_syntax_node(db, self.children[4].clone())
14737 }
14738 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
14739 TerminalSemicolon::from_syntax_node(db, self.children[5].clone())
14740 }
14741}
14742#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14743pub struct TraitItemImplPtr(pub SyntaxStablePtrId);
14744impl TraitItemImplPtr {
14745 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14746 let ptr = self.0.lookup_intern(db);
14747 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14748 TerminalIdentifierGreen(key_fields[0])
14749 } else {
14750 panic!("Unexpected key field query on root.");
14751 }
14752 }
14753}
14754impl TypedStablePtr for TraitItemImplPtr {
14755 type SyntaxNode = TraitItemImpl;
14756 fn untyped(&self) -> SyntaxStablePtrId {
14757 self.0
14758 }
14759 fn lookup(&self, db: &dyn SyntaxGroup) -> TraitItemImpl {
14760 TraitItemImpl::from_syntax_node(db, self.0.lookup(db))
14761 }
14762}
14763impl From<TraitItemImplPtr> for SyntaxStablePtrId {
14764 fn from(ptr: TraitItemImplPtr) -> Self {
14765 ptr.untyped()
14766 }
14767}
14768#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14769pub struct TraitItemImplGreen(pub GreenId);
14770impl TypedSyntaxNode for TraitItemImpl {
14771 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TraitItemImpl);
14772 type StablePtr = TraitItemImplPtr;
14773 type Green = TraitItemImplGreen;
14774 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14775 TraitItemImplGreen(
14776 Arc::new(GreenNode {
14777 kind: SyntaxKind::TraitItemImpl,
14778 details: GreenNodeDetails::Node {
14779 children: vec![
14780 AttributeList::missing(db).0,
14781 TerminalImpl::missing(db).0,
14782 TerminalIdentifier::missing(db).0,
14783 TerminalColon::missing(db).0,
14784 ExprPath::missing(db).0,
14785 TerminalSemicolon::missing(db).0,
14786 ],
14787 width: TextWidth::default(),
14788 },
14789 })
14790 .intern(db),
14791 )
14792 }
14793 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14794 let kind = node.kind(db);
14795 assert_eq!(
14796 kind,
14797 SyntaxKind::TraitItemImpl,
14798 "Unexpected SyntaxKind {:?}. Expected {:?}.",
14799 kind,
14800 SyntaxKind::TraitItemImpl
14801 );
14802 let children = db.get_children(node.clone());
14803 Self { node, children }
14804 }
14805 fn as_syntax_node(&self) -> SyntaxNode {
14806 self.node.clone()
14807 }
14808 fn stable_ptr(&self) -> Self::StablePtr {
14809 TraitItemImplPtr(self.node.0.stable_ptr)
14810 }
14811}
14812impl From<&TraitItemImpl> for SyntaxStablePtrId {
14813 fn from(node: &TraitItemImpl) -> Self {
14814 node.stable_ptr().untyped()
14815 }
14816}
14817#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14818pub enum MaybeTraitFunctionBody {
14819 Some(ExprBlock),
14820 None(TerminalSemicolon),
14821}
14822#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14823pub struct MaybeTraitFunctionBodyPtr(pub SyntaxStablePtrId);
14824impl TypedStablePtr for MaybeTraitFunctionBodyPtr {
14825 type SyntaxNode = MaybeTraitFunctionBody;
14826 fn untyped(&self) -> SyntaxStablePtrId {
14827 self.0
14828 }
14829 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeTraitFunctionBody {
14830 MaybeTraitFunctionBody::from_syntax_node(db, self.0.lookup(db))
14831 }
14832}
14833impl From<MaybeTraitFunctionBodyPtr> for SyntaxStablePtrId {
14834 fn from(ptr: MaybeTraitFunctionBodyPtr) -> Self {
14835 ptr.untyped()
14836 }
14837}
14838impl From<ExprBlockPtr> for MaybeTraitFunctionBodyPtr {
14839 fn from(value: ExprBlockPtr) -> Self {
14840 Self(value.0)
14841 }
14842}
14843impl From<TerminalSemicolonPtr> for MaybeTraitFunctionBodyPtr {
14844 fn from(value: TerminalSemicolonPtr) -> Self {
14845 Self(value.0)
14846 }
14847}
14848impl From<ExprBlockGreen> for MaybeTraitFunctionBodyGreen {
14849 fn from(value: ExprBlockGreen) -> Self {
14850 Self(value.0)
14851 }
14852}
14853impl From<TerminalSemicolonGreen> for MaybeTraitFunctionBodyGreen {
14854 fn from(value: TerminalSemicolonGreen) -> Self {
14855 Self(value.0)
14856 }
14857}
14858#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14859pub struct MaybeTraitFunctionBodyGreen(pub GreenId);
14860impl TypedSyntaxNode for MaybeTraitFunctionBody {
14861 const OPTIONAL_KIND: Option<SyntaxKind> = None;
14862 type StablePtr = MaybeTraitFunctionBodyPtr;
14863 type Green = MaybeTraitFunctionBodyGreen;
14864 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
14865 panic!("No missing variant.");
14866 }
14867 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
14868 let kind = node.kind(db);
14869 match kind {
14870 SyntaxKind::ExprBlock => {
14871 MaybeTraitFunctionBody::Some(ExprBlock::from_syntax_node(db, node))
14872 }
14873 SyntaxKind::TerminalSemicolon => {
14874 MaybeTraitFunctionBody::None(TerminalSemicolon::from_syntax_node(db, node))
14875 }
14876 _ => panic!(
14877 "Unexpected syntax kind {:?} when constructing {}.",
14878 kind, "MaybeTraitFunctionBody"
14879 ),
14880 }
14881 }
14882 fn as_syntax_node(&self) -> SyntaxNode {
14883 match self {
14884 MaybeTraitFunctionBody::Some(x) => x.as_syntax_node(),
14885 MaybeTraitFunctionBody::None(x) => x.as_syntax_node(),
14886 }
14887 }
14888 fn stable_ptr(&self) -> Self::StablePtr {
14889 MaybeTraitFunctionBodyPtr(self.as_syntax_node().0.stable_ptr)
14890 }
14891}
14892impl From<&MaybeTraitFunctionBody> for SyntaxStablePtrId {
14893 fn from(node: &MaybeTraitFunctionBody) -> Self {
14894 node.stable_ptr().untyped()
14895 }
14896}
14897impl MaybeTraitFunctionBody {
14898 pub fn is_variant(kind: SyntaxKind) -> bool {
14900 matches!(kind, SyntaxKind::ExprBlock | SyntaxKind::TerminalSemicolon)
14901 }
14902}
14903#[derive(Clone, Debug, Eq, Hash, PartialEq)]
14904pub struct ItemImpl {
14905 node: SyntaxNode,
14906 children: Arc<[SyntaxNode]>,
14907}
14908impl ItemImpl {
14909 pub const INDEX_ATTRIBUTES: usize = 0;
14910 pub const INDEX_VISIBILITY: usize = 1;
14911 pub const INDEX_IMPL_KW: usize = 2;
14912 pub const INDEX_NAME: usize = 3;
14913 pub const INDEX_GENERIC_PARAMS: usize = 4;
14914 pub const INDEX_OF_KW: usize = 5;
14915 pub const INDEX_TRAIT_PATH: usize = 6;
14916 pub const INDEX_BODY: usize = 7;
14917 pub fn new_green(
14918 db: &dyn SyntaxGroup,
14919 attributes: AttributeListGreen,
14920 visibility: VisibilityGreen,
14921 impl_kw: TerminalImplGreen,
14922 name: TerminalIdentifierGreen,
14923 generic_params: OptionWrappedGenericParamListGreen,
14924 of_kw: TerminalOfGreen,
14925 trait_path: ExprPathGreen,
14926 body: MaybeImplBodyGreen,
14927 ) -> ItemImplGreen {
14928 let children: Vec<GreenId> = vec![
14929 attributes.0,
14930 visibility.0,
14931 impl_kw.0,
14932 name.0,
14933 generic_params.0,
14934 of_kw.0,
14935 trait_path.0,
14936 body.0,
14937 ];
14938 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
14939 ItemImplGreen(
14940 Arc::new(GreenNode {
14941 kind: SyntaxKind::ItemImpl,
14942 details: GreenNodeDetails::Node { children, width },
14943 })
14944 .intern(db),
14945 )
14946 }
14947}
14948impl ItemImpl {
14949 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
14950 AttributeList::from_syntax_node(db, self.children[0].clone())
14951 }
14952 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
14953 Visibility::from_syntax_node(db, self.children[1].clone())
14954 }
14955 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
14956 TerminalImpl::from_syntax_node(db, self.children[2].clone())
14957 }
14958 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
14959 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
14960 }
14961 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
14962 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
14963 }
14964 pub fn of_kw(&self, db: &dyn SyntaxGroup) -> TerminalOf {
14965 TerminalOf::from_syntax_node(db, self.children[5].clone())
14966 }
14967 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
14968 ExprPath::from_syntax_node(db, self.children[6].clone())
14969 }
14970 pub fn body(&self, db: &dyn SyntaxGroup) -> MaybeImplBody {
14971 MaybeImplBody::from_syntax_node(db, self.children[7].clone())
14972 }
14973}
14974#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
14975pub struct ItemImplPtr(pub SyntaxStablePtrId);
14976impl ItemImplPtr {
14977 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
14978 let ptr = self.0.lookup_intern(db);
14979 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
14980 TerminalIdentifierGreen(key_fields[0])
14981 } else {
14982 panic!("Unexpected key field query on root.");
14983 }
14984 }
14985}
14986impl TypedStablePtr for ItemImplPtr {
14987 type SyntaxNode = ItemImpl;
14988 fn untyped(&self) -> SyntaxStablePtrId {
14989 self.0
14990 }
14991 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemImpl {
14992 ItemImpl::from_syntax_node(db, self.0.lookup(db))
14993 }
14994}
14995impl From<ItemImplPtr> for SyntaxStablePtrId {
14996 fn from(ptr: ItemImplPtr) -> Self {
14997 ptr.untyped()
14998 }
14999}
15000#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15001pub struct ItemImplGreen(pub GreenId);
15002impl TypedSyntaxNode for ItemImpl {
15003 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemImpl);
15004 type StablePtr = ItemImplPtr;
15005 type Green = ItemImplGreen;
15006 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15007 ItemImplGreen(
15008 Arc::new(GreenNode {
15009 kind: SyntaxKind::ItemImpl,
15010 details: GreenNodeDetails::Node {
15011 children: vec![
15012 AttributeList::missing(db).0,
15013 Visibility::missing(db).0,
15014 TerminalImpl::missing(db).0,
15015 TerminalIdentifier::missing(db).0,
15016 OptionWrappedGenericParamList::missing(db).0,
15017 TerminalOf::missing(db).0,
15018 ExprPath::missing(db).0,
15019 MaybeImplBody::missing(db).0,
15020 ],
15021 width: TextWidth::default(),
15022 },
15023 })
15024 .intern(db),
15025 )
15026 }
15027 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15028 let kind = node.kind(db);
15029 assert_eq!(
15030 kind,
15031 SyntaxKind::ItemImpl,
15032 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15033 kind,
15034 SyntaxKind::ItemImpl
15035 );
15036 let children = db.get_children(node.clone());
15037 Self { node, children }
15038 }
15039 fn as_syntax_node(&self) -> SyntaxNode {
15040 self.node.clone()
15041 }
15042 fn stable_ptr(&self) -> Self::StablePtr {
15043 ItemImplPtr(self.node.0.stable_ptr)
15044 }
15045}
15046impl From<&ItemImpl> for SyntaxStablePtrId {
15047 fn from(node: &ItemImpl) -> Self {
15048 node.stable_ptr().untyped()
15049 }
15050}
15051#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15052pub struct ItemInlineMacro {
15053 node: SyntaxNode,
15054 children: Arc<[SyntaxNode]>,
15055}
15056impl ItemInlineMacro {
15057 pub const INDEX_ATTRIBUTES: usize = 0;
15058 pub const INDEX_NAME: usize = 1;
15059 pub const INDEX_BANG: usize = 2;
15060 pub const INDEX_ARGUMENTS: usize = 3;
15061 pub const INDEX_SEMICOLON: usize = 4;
15062 pub fn new_green(
15063 db: &dyn SyntaxGroup,
15064 attributes: AttributeListGreen,
15065 name: TerminalIdentifierGreen,
15066 bang: TerminalNotGreen,
15067 arguments: WrappedArgListGreen,
15068 semicolon: TerminalSemicolonGreen,
15069 ) -> ItemInlineMacroGreen {
15070 let children: Vec<GreenId> = vec![attributes.0, name.0, bang.0, arguments.0, semicolon.0];
15071 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15072 ItemInlineMacroGreen(
15073 Arc::new(GreenNode {
15074 kind: SyntaxKind::ItemInlineMacro,
15075 details: GreenNodeDetails::Node { children, width },
15076 })
15077 .intern(db),
15078 )
15079 }
15080}
15081impl ItemInlineMacro {
15082 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15083 AttributeList::from_syntax_node(db, self.children[0].clone())
15084 }
15085 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
15086 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
15087 }
15088 pub fn bang(&self, db: &dyn SyntaxGroup) -> TerminalNot {
15089 TerminalNot::from_syntax_node(db, self.children[2].clone())
15090 }
15091 pub fn arguments(&self, db: &dyn SyntaxGroup) -> WrappedArgList {
15092 WrappedArgList::from_syntax_node(db, self.children[3].clone())
15093 }
15094 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
15095 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
15096 }
15097}
15098#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15099pub struct ItemInlineMacroPtr(pub SyntaxStablePtrId);
15100impl ItemInlineMacroPtr {}
15101impl TypedStablePtr for ItemInlineMacroPtr {
15102 type SyntaxNode = ItemInlineMacro;
15103 fn untyped(&self) -> SyntaxStablePtrId {
15104 self.0
15105 }
15106 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemInlineMacro {
15107 ItemInlineMacro::from_syntax_node(db, self.0.lookup(db))
15108 }
15109}
15110impl From<ItemInlineMacroPtr> for SyntaxStablePtrId {
15111 fn from(ptr: ItemInlineMacroPtr) -> Self {
15112 ptr.untyped()
15113 }
15114}
15115#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15116pub struct ItemInlineMacroGreen(pub GreenId);
15117impl TypedSyntaxNode for ItemInlineMacro {
15118 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemInlineMacro);
15119 type StablePtr = ItemInlineMacroPtr;
15120 type Green = ItemInlineMacroGreen;
15121 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15122 ItemInlineMacroGreen(
15123 Arc::new(GreenNode {
15124 kind: SyntaxKind::ItemInlineMacro,
15125 details: GreenNodeDetails::Node {
15126 children: vec![
15127 AttributeList::missing(db).0,
15128 TerminalIdentifier::missing(db).0,
15129 TerminalNot::missing(db).0,
15130 WrappedArgList::missing(db).0,
15131 TerminalSemicolon::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::ItemInlineMacro,
15144 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15145 kind,
15146 SyntaxKind::ItemInlineMacro
15147 );
15148 let children = db.get_children(node.clone());
15149 Self { node, children }
15150 }
15151 fn as_syntax_node(&self) -> SyntaxNode {
15152 self.node.clone()
15153 }
15154 fn stable_ptr(&self) -> Self::StablePtr {
15155 ItemInlineMacroPtr(self.node.0.stable_ptr)
15156 }
15157}
15158impl From<&ItemInlineMacro> for SyntaxStablePtrId {
15159 fn from(node: &ItemInlineMacro) -> Self {
15160 node.stable_ptr().untyped()
15161 }
15162}
15163#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15164pub struct ItemHeaderDoc {
15165 node: SyntaxNode,
15166 children: Arc<[SyntaxNode]>,
15167}
15168impl ItemHeaderDoc {
15169 pub const INDEX_EMPTY: usize = 0;
15170 pub fn new_green(db: &dyn SyntaxGroup, empty: TerminalEmptyGreen) -> ItemHeaderDocGreen {
15171 let children: Vec<GreenId> = vec![empty.0];
15172 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15173 ItemHeaderDocGreen(
15174 Arc::new(GreenNode {
15175 kind: SyntaxKind::ItemHeaderDoc,
15176 details: GreenNodeDetails::Node { children, width },
15177 })
15178 .intern(db),
15179 )
15180 }
15181}
15182impl ItemHeaderDoc {
15183 pub fn empty(&self, db: &dyn SyntaxGroup) -> TerminalEmpty {
15184 TerminalEmpty::from_syntax_node(db, self.children[0].clone())
15185 }
15186}
15187#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15188pub struct ItemHeaderDocPtr(pub SyntaxStablePtrId);
15189impl ItemHeaderDocPtr {}
15190impl TypedStablePtr for ItemHeaderDocPtr {
15191 type SyntaxNode = ItemHeaderDoc;
15192 fn untyped(&self) -> SyntaxStablePtrId {
15193 self.0
15194 }
15195 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemHeaderDoc {
15196 ItemHeaderDoc::from_syntax_node(db, self.0.lookup(db))
15197 }
15198}
15199impl From<ItemHeaderDocPtr> for SyntaxStablePtrId {
15200 fn from(ptr: ItemHeaderDocPtr) -> Self {
15201 ptr.untyped()
15202 }
15203}
15204#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15205pub struct ItemHeaderDocGreen(pub GreenId);
15206impl TypedSyntaxNode for ItemHeaderDoc {
15207 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemHeaderDoc);
15208 type StablePtr = ItemHeaderDocPtr;
15209 type Green = ItemHeaderDocGreen;
15210 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15211 ItemHeaderDocGreen(
15212 Arc::new(GreenNode {
15213 kind: SyntaxKind::ItemHeaderDoc,
15214 details: GreenNodeDetails::Node {
15215 children: vec![TerminalEmpty::missing(db).0],
15216 width: TextWidth::default(),
15217 },
15218 })
15219 .intern(db),
15220 )
15221 }
15222 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15223 let kind = node.kind(db);
15224 assert_eq!(
15225 kind,
15226 SyntaxKind::ItemHeaderDoc,
15227 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15228 kind,
15229 SyntaxKind::ItemHeaderDoc
15230 );
15231 let children = db.get_children(node.clone());
15232 Self { node, children }
15233 }
15234 fn as_syntax_node(&self) -> SyntaxNode {
15235 self.node.clone()
15236 }
15237 fn stable_ptr(&self) -> Self::StablePtr {
15238 ItemHeaderDocPtr(self.node.0.stable_ptr)
15239 }
15240}
15241impl From<&ItemHeaderDoc> for SyntaxStablePtrId {
15242 fn from(node: &ItemHeaderDoc) -> Self {
15243 node.stable_ptr().untyped()
15244 }
15245}
15246#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15247pub enum MaybeImplBody {
15248 Some(ImplBody),
15249 None(TerminalSemicolon),
15250}
15251#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15252pub struct MaybeImplBodyPtr(pub SyntaxStablePtrId);
15253impl TypedStablePtr for MaybeImplBodyPtr {
15254 type SyntaxNode = MaybeImplBody;
15255 fn untyped(&self) -> SyntaxStablePtrId {
15256 self.0
15257 }
15258 fn lookup(&self, db: &dyn SyntaxGroup) -> MaybeImplBody {
15259 MaybeImplBody::from_syntax_node(db, self.0.lookup(db))
15260 }
15261}
15262impl From<MaybeImplBodyPtr> for SyntaxStablePtrId {
15263 fn from(ptr: MaybeImplBodyPtr) -> Self {
15264 ptr.untyped()
15265 }
15266}
15267impl From<ImplBodyPtr> for MaybeImplBodyPtr {
15268 fn from(value: ImplBodyPtr) -> Self {
15269 Self(value.0)
15270 }
15271}
15272impl From<TerminalSemicolonPtr> for MaybeImplBodyPtr {
15273 fn from(value: TerminalSemicolonPtr) -> Self {
15274 Self(value.0)
15275 }
15276}
15277impl From<ImplBodyGreen> for MaybeImplBodyGreen {
15278 fn from(value: ImplBodyGreen) -> Self {
15279 Self(value.0)
15280 }
15281}
15282impl From<TerminalSemicolonGreen> for MaybeImplBodyGreen {
15283 fn from(value: TerminalSemicolonGreen) -> Self {
15284 Self(value.0)
15285 }
15286}
15287#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15288pub struct MaybeImplBodyGreen(pub GreenId);
15289impl TypedSyntaxNode for MaybeImplBody {
15290 const OPTIONAL_KIND: Option<SyntaxKind> = None;
15291 type StablePtr = MaybeImplBodyPtr;
15292 type Green = MaybeImplBodyGreen;
15293 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15294 panic!("No missing variant.");
15295 }
15296 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15297 let kind = node.kind(db);
15298 match kind {
15299 SyntaxKind::ImplBody => MaybeImplBody::Some(ImplBody::from_syntax_node(db, node)),
15300 SyntaxKind::TerminalSemicolon => {
15301 MaybeImplBody::None(TerminalSemicolon::from_syntax_node(db, node))
15302 }
15303 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "MaybeImplBody"),
15304 }
15305 }
15306 fn as_syntax_node(&self) -> SyntaxNode {
15307 match self {
15308 MaybeImplBody::Some(x) => x.as_syntax_node(),
15309 MaybeImplBody::None(x) => x.as_syntax_node(),
15310 }
15311 }
15312 fn stable_ptr(&self) -> Self::StablePtr {
15313 MaybeImplBodyPtr(self.as_syntax_node().0.stable_ptr)
15314 }
15315}
15316impl From<&MaybeImplBody> for SyntaxStablePtrId {
15317 fn from(node: &MaybeImplBody) -> Self {
15318 node.stable_ptr().untyped()
15319 }
15320}
15321impl MaybeImplBody {
15322 pub fn is_variant(kind: SyntaxKind) -> bool {
15324 matches!(kind, SyntaxKind::ImplBody | SyntaxKind::TerminalSemicolon)
15325 }
15326}
15327#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15328pub struct ImplBody {
15329 node: SyntaxNode,
15330 children: Arc<[SyntaxNode]>,
15331}
15332impl ImplBody {
15333 pub const INDEX_LBRACE: usize = 0;
15334 pub const INDEX_ITEMS: usize = 1;
15335 pub const INDEX_RBRACE: usize = 2;
15336 pub fn new_green(
15337 db: &dyn SyntaxGroup,
15338 lbrace: TerminalLBraceGreen,
15339 items: ImplItemListGreen,
15340 rbrace: TerminalRBraceGreen,
15341 ) -> ImplBodyGreen {
15342 let children: Vec<GreenId> = vec![lbrace.0, items.0, rbrace.0];
15343 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15344 ImplBodyGreen(
15345 Arc::new(GreenNode {
15346 kind: SyntaxKind::ImplBody,
15347 details: GreenNodeDetails::Node { children, width },
15348 })
15349 .intern(db),
15350 )
15351 }
15352}
15353impl ImplBody {
15354 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
15355 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
15356 }
15357 pub fn items(&self, db: &dyn SyntaxGroup) -> ImplItemList {
15358 ImplItemList::from_syntax_node(db, self.children[1].clone())
15359 }
15360 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
15361 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
15362 }
15363}
15364#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15365pub struct ImplBodyPtr(pub SyntaxStablePtrId);
15366impl ImplBodyPtr {}
15367impl TypedStablePtr for ImplBodyPtr {
15368 type SyntaxNode = ImplBody;
15369 fn untyped(&self) -> SyntaxStablePtrId {
15370 self.0
15371 }
15372 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplBody {
15373 ImplBody::from_syntax_node(db, self.0.lookup(db))
15374 }
15375}
15376impl From<ImplBodyPtr> for SyntaxStablePtrId {
15377 fn from(ptr: ImplBodyPtr) -> Self {
15378 ptr.untyped()
15379 }
15380}
15381#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15382pub struct ImplBodyGreen(pub GreenId);
15383impl TypedSyntaxNode for ImplBody {
15384 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplBody);
15385 type StablePtr = ImplBodyPtr;
15386 type Green = ImplBodyGreen;
15387 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15388 ImplBodyGreen(
15389 Arc::new(GreenNode {
15390 kind: SyntaxKind::ImplBody,
15391 details: GreenNodeDetails::Node {
15392 children: vec![
15393 TerminalLBrace::missing(db).0,
15394 ImplItemList::missing(db).0,
15395 TerminalRBrace::missing(db).0,
15396 ],
15397 width: TextWidth::default(),
15398 },
15399 })
15400 .intern(db),
15401 )
15402 }
15403 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15404 let kind = node.kind(db);
15405 assert_eq!(
15406 kind,
15407 SyntaxKind::ImplBody,
15408 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15409 kind,
15410 SyntaxKind::ImplBody
15411 );
15412 let children = db.get_children(node.clone());
15413 Self { node, children }
15414 }
15415 fn as_syntax_node(&self) -> SyntaxNode {
15416 self.node.clone()
15417 }
15418 fn stable_ptr(&self) -> Self::StablePtr {
15419 ImplBodyPtr(self.node.0.stable_ptr)
15420 }
15421}
15422impl From<&ImplBody> for SyntaxStablePtrId {
15423 fn from(node: &ImplBody) -> Self {
15424 node.stable_ptr().untyped()
15425 }
15426}
15427#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15428pub struct ImplItemList(ElementList<ImplItem, 1>);
15429impl Deref for ImplItemList {
15430 type Target = ElementList<ImplItem, 1>;
15431 fn deref(&self) -> &Self::Target {
15432 &self.0
15433 }
15434}
15435impl ImplItemList {
15436 pub fn new_green(db: &dyn SyntaxGroup, children: Vec<ImplItemGreen>) -> ImplItemListGreen {
15437 let width = children.iter().map(|id| id.0.lookup_intern(db).width()).sum();
15438 ImplItemListGreen(
15439 Arc::new(GreenNode {
15440 kind: SyntaxKind::ImplItemList,
15441 details: GreenNodeDetails::Node {
15442 children: children.iter().map(|x| x.0).collect(),
15443 width,
15444 },
15445 })
15446 .intern(db),
15447 )
15448 }
15449}
15450#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15451pub struct ImplItemListPtr(pub SyntaxStablePtrId);
15452impl TypedStablePtr for ImplItemListPtr {
15453 type SyntaxNode = ImplItemList;
15454 fn untyped(&self) -> SyntaxStablePtrId {
15455 self.0
15456 }
15457 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItemList {
15458 ImplItemList::from_syntax_node(db, self.0.lookup(db))
15459 }
15460}
15461impl From<ImplItemListPtr> for SyntaxStablePtrId {
15462 fn from(ptr: ImplItemListPtr) -> Self {
15463 ptr.untyped()
15464 }
15465}
15466#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15467pub struct ImplItemListGreen(pub GreenId);
15468impl TypedSyntaxNode for ImplItemList {
15469 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplItemList);
15470 type StablePtr = ImplItemListPtr;
15471 type Green = ImplItemListGreen;
15472 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15473 ImplItemListGreen(
15474 Arc::new(GreenNode {
15475 kind: SyntaxKind::ImplItemList,
15476 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
15477 })
15478 .intern(db),
15479 )
15480 }
15481 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15482 Self(ElementList::new(node))
15483 }
15484 fn as_syntax_node(&self) -> SyntaxNode {
15485 self.node.clone()
15486 }
15487 fn stable_ptr(&self) -> Self::StablePtr {
15488 ImplItemListPtr(self.node.0.stable_ptr)
15489 }
15490}
15491impl From<&ImplItemList> for SyntaxStablePtrId {
15492 fn from(node: &ImplItemList) -> Self {
15493 node.stable_ptr().untyped()
15494 }
15495}
15496#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15497pub enum ImplItem {
15498 Function(FunctionWithBody),
15499 Type(ItemTypeAlias),
15500 Constant(ItemConstant),
15501 Impl(ItemImplAlias),
15502 Module(ItemModule),
15503 Use(ItemUse),
15504 ExternFunction(ItemExternFunction),
15505 ExternType(ItemExternType),
15506 Trait(ItemTrait),
15507 Struct(ItemStruct),
15508 Enum(ItemEnum),
15509 Missing(ImplItemMissing),
15510}
15511#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15512pub struct ImplItemPtr(pub SyntaxStablePtrId);
15513impl TypedStablePtr for ImplItemPtr {
15514 type SyntaxNode = ImplItem;
15515 fn untyped(&self) -> SyntaxStablePtrId {
15516 self.0
15517 }
15518 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItem {
15519 ImplItem::from_syntax_node(db, self.0.lookup(db))
15520 }
15521}
15522impl From<ImplItemPtr> for SyntaxStablePtrId {
15523 fn from(ptr: ImplItemPtr) -> Self {
15524 ptr.untyped()
15525 }
15526}
15527impl From<FunctionWithBodyPtr> for ImplItemPtr {
15528 fn from(value: FunctionWithBodyPtr) -> Self {
15529 Self(value.0)
15530 }
15531}
15532impl From<ItemTypeAliasPtr> for ImplItemPtr {
15533 fn from(value: ItemTypeAliasPtr) -> Self {
15534 Self(value.0)
15535 }
15536}
15537impl From<ItemConstantPtr> for ImplItemPtr {
15538 fn from(value: ItemConstantPtr) -> Self {
15539 Self(value.0)
15540 }
15541}
15542impl From<ItemImplAliasPtr> for ImplItemPtr {
15543 fn from(value: ItemImplAliasPtr) -> Self {
15544 Self(value.0)
15545 }
15546}
15547impl From<ItemModulePtr> for ImplItemPtr {
15548 fn from(value: ItemModulePtr) -> Self {
15549 Self(value.0)
15550 }
15551}
15552impl From<ItemUsePtr> for ImplItemPtr {
15553 fn from(value: ItemUsePtr) -> Self {
15554 Self(value.0)
15555 }
15556}
15557impl From<ItemExternFunctionPtr> for ImplItemPtr {
15558 fn from(value: ItemExternFunctionPtr) -> Self {
15559 Self(value.0)
15560 }
15561}
15562impl From<ItemExternTypePtr> for ImplItemPtr {
15563 fn from(value: ItemExternTypePtr) -> Self {
15564 Self(value.0)
15565 }
15566}
15567impl From<ItemTraitPtr> for ImplItemPtr {
15568 fn from(value: ItemTraitPtr) -> Self {
15569 Self(value.0)
15570 }
15571}
15572impl From<ItemStructPtr> for ImplItemPtr {
15573 fn from(value: ItemStructPtr) -> Self {
15574 Self(value.0)
15575 }
15576}
15577impl From<ItemEnumPtr> for ImplItemPtr {
15578 fn from(value: ItemEnumPtr) -> Self {
15579 Self(value.0)
15580 }
15581}
15582impl From<ImplItemMissingPtr> for ImplItemPtr {
15583 fn from(value: ImplItemMissingPtr) -> Self {
15584 Self(value.0)
15585 }
15586}
15587impl From<FunctionWithBodyGreen> for ImplItemGreen {
15588 fn from(value: FunctionWithBodyGreen) -> Self {
15589 Self(value.0)
15590 }
15591}
15592impl From<ItemTypeAliasGreen> for ImplItemGreen {
15593 fn from(value: ItemTypeAliasGreen) -> Self {
15594 Self(value.0)
15595 }
15596}
15597impl From<ItemConstantGreen> for ImplItemGreen {
15598 fn from(value: ItemConstantGreen) -> Self {
15599 Self(value.0)
15600 }
15601}
15602impl From<ItemImplAliasGreen> for ImplItemGreen {
15603 fn from(value: ItemImplAliasGreen) -> Self {
15604 Self(value.0)
15605 }
15606}
15607impl From<ItemModuleGreen> for ImplItemGreen {
15608 fn from(value: ItemModuleGreen) -> Self {
15609 Self(value.0)
15610 }
15611}
15612impl From<ItemUseGreen> for ImplItemGreen {
15613 fn from(value: ItemUseGreen) -> Self {
15614 Self(value.0)
15615 }
15616}
15617impl From<ItemExternFunctionGreen> for ImplItemGreen {
15618 fn from(value: ItemExternFunctionGreen) -> Self {
15619 Self(value.0)
15620 }
15621}
15622impl From<ItemExternTypeGreen> for ImplItemGreen {
15623 fn from(value: ItemExternTypeGreen) -> Self {
15624 Self(value.0)
15625 }
15626}
15627impl From<ItemTraitGreen> for ImplItemGreen {
15628 fn from(value: ItemTraitGreen) -> Self {
15629 Self(value.0)
15630 }
15631}
15632impl From<ItemStructGreen> for ImplItemGreen {
15633 fn from(value: ItemStructGreen) -> Self {
15634 Self(value.0)
15635 }
15636}
15637impl From<ItemEnumGreen> for ImplItemGreen {
15638 fn from(value: ItemEnumGreen) -> Self {
15639 Self(value.0)
15640 }
15641}
15642impl From<ImplItemMissingGreen> for ImplItemGreen {
15643 fn from(value: ImplItemMissingGreen) -> Self {
15644 Self(value.0)
15645 }
15646}
15647#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15648pub struct ImplItemGreen(pub GreenId);
15649impl TypedSyntaxNode for ImplItem {
15650 const OPTIONAL_KIND: Option<SyntaxKind> = None;
15651 type StablePtr = ImplItemPtr;
15652 type Green = ImplItemGreen;
15653 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15654 ImplItemGreen(ImplItemMissing::missing(db).0)
15655 }
15656 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15657 let kind = node.kind(db);
15658 match kind {
15659 SyntaxKind::FunctionWithBody => {
15660 ImplItem::Function(FunctionWithBody::from_syntax_node(db, node))
15661 }
15662 SyntaxKind::ItemTypeAlias => ImplItem::Type(ItemTypeAlias::from_syntax_node(db, node)),
15663 SyntaxKind::ItemConstant => {
15664 ImplItem::Constant(ItemConstant::from_syntax_node(db, node))
15665 }
15666 SyntaxKind::ItemImplAlias => ImplItem::Impl(ItemImplAlias::from_syntax_node(db, node)),
15667 SyntaxKind::ItemModule => ImplItem::Module(ItemModule::from_syntax_node(db, node)),
15668 SyntaxKind::ItemUse => ImplItem::Use(ItemUse::from_syntax_node(db, node)),
15669 SyntaxKind::ItemExternFunction => {
15670 ImplItem::ExternFunction(ItemExternFunction::from_syntax_node(db, node))
15671 }
15672 SyntaxKind::ItemExternType => {
15673 ImplItem::ExternType(ItemExternType::from_syntax_node(db, node))
15674 }
15675 SyntaxKind::ItemTrait => ImplItem::Trait(ItemTrait::from_syntax_node(db, node)),
15676 SyntaxKind::ItemStruct => ImplItem::Struct(ItemStruct::from_syntax_node(db, node)),
15677 SyntaxKind::ItemEnum => ImplItem::Enum(ItemEnum::from_syntax_node(db, node)),
15678 SyntaxKind::ImplItemMissing => {
15679 ImplItem::Missing(ImplItemMissing::from_syntax_node(db, node))
15680 }
15681 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "ImplItem"),
15682 }
15683 }
15684 fn as_syntax_node(&self) -> SyntaxNode {
15685 match self {
15686 ImplItem::Function(x) => x.as_syntax_node(),
15687 ImplItem::Type(x) => x.as_syntax_node(),
15688 ImplItem::Constant(x) => x.as_syntax_node(),
15689 ImplItem::Impl(x) => x.as_syntax_node(),
15690 ImplItem::Module(x) => x.as_syntax_node(),
15691 ImplItem::Use(x) => x.as_syntax_node(),
15692 ImplItem::ExternFunction(x) => x.as_syntax_node(),
15693 ImplItem::ExternType(x) => x.as_syntax_node(),
15694 ImplItem::Trait(x) => x.as_syntax_node(),
15695 ImplItem::Struct(x) => x.as_syntax_node(),
15696 ImplItem::Enum(x) => x.as_syntax_node(),
15697 ImplItem::Missing(x) => x.as_syntax_node(),
15698 }
15699 }
15700 fn stable_ptr(&self) -> Self::StablePtr {
15701 ImplItemPtr(self.as_syntax_node().0.stable_ptr)
15702 }
15703}
15704impl From<&ImplItem> for SyntaxStablePtrId {
15705 fn from(node: &ImplItem) -> Self {
15706 node.stable_ptr().untyped()
15707 }
15708}
15709impl ImplItem {
15710 pub fn is_variant(kind: SyntaxKind) -> bool {
15712 matches!(
15713 kind,
15714 SyntaxKind::FunctionWithBody
15715 | SyntaxKind::ItemTypeAlias
15716 | SyntaxKind::ItemConstant
15717 | SyntaxKind::ItemImplAlias
15718 | SyntaxKind::ItemModule
15719 | SyntaxKind::ItemUse
15720 | SyntaxKind::ItemExternFunction
15721 | SyntaxKind::ItemExternType
15722 | SyntaxKind::ItemTrait
15723 | SyntaxKind::ItemStruct
15724 | SyntaxKind::ItemEnum
15725 | SyntaxKind::ImplItemMissing
15726 )
15727 }
15728}
15729#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15730pub struct ImplItemMissing {
15731 node: SyntaxNode,
15732 children: Arc<[SyntaxNode]>,
15733}
15734impl ImplItemMissing {
15735 pub fn new_green(db: &dyn SyntaxGroup) -> ImplItemMissingGreen {
15736 let children: Vec<GreenId> = vec![];
15737 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15738 ImplItemMissingGreen(
15739 Arc::new(GreenNode {
15740 kind: SyntaxKind::ImplItemMissing,
15741 details: GreenNodeDetails::Node { children, width },
15742 })
15743 .intern(db),
15744 )
15745 }
15746}
15747impl ImplItemMissing {}
15748#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15749pub struct ImplItemMissingPtr(pub SyntaxStablePtrId);
15750impl ImplItemMissingPtr {}
15751impl TypedStablePtr for ImplItemMissingPtr {
15752 type SyntaxNode = ImplItemMissing;
15753 fn untyped(&self) -> SyntaxStablePtrId {
15754 self.0
15755 }
15756 fn lookup(&self, db: &dyn SyntaxGroup) -> ImplItemMissing {
15757 ImplItemMissing::from_syntax_node(db, self.0.lookup(db))
15758 }
15759}
15760impl From<ImplItemMissingPtr> for SyntaxStablePtrId {
15761 fn from(ptr: ImplItemMissingPtr) -> Self {
15762 ptr.untyped()
15763 }
15764}
15765#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15766pub struct ImplItemMissingGreen(pub GreenId);
15767impl TypedSyntaxNode for ImplItemMissing {
15768 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ImplItemMissing);
15769 type StablePtr = ImplItemMissingPtr;
15770 type Green = ImplItemMissingGreen;
15771 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15772 ImplItemMissingGreen(
15773 Arc::new(GreenNode {
15774 kind: SyntaxKind::ImplItemMissing,
15775 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
15776 })
15777 .intern(db),
15778 )
15779 }
15780 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15781 let kind = node.kind(db);
15782 assert_eq!(
15783 kind,
15784 SyntaxKind::ImplItemMissing,
15785 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15786 kind,
15787 SyntaxKind::ImplItemMissing
15788 );
15789 let children = db.get_children(node.clone());
15790 Self { node, children }
15791 }
15792 fn as_syntax_node(&self) -> SyntaxNode {
15793 self.node.clone()
15794 }
15795 fn stable_ptr(&self) -> Self::StablePtr {
15796 ImplItemMissingPtr(self.node.0.stable_ptr)
15797 }
15798}
15799impl From<&ImplItemMissing> for SyntaxStablePtrId {
15800 fn from(node: &ImplItemMissing) -> Self {
15801 node.stable_ptr().untyped()
15802 }
15803}
15804#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15805pub struct ItemImplAlias {
15806 node: SyntaxNode,
15807 children: Arc<[SyntaxNode]>,
15808}
15809impl ItemImplAlias {
15810 pub const INDEX_ATTRIBUTES: usize = 0;
15811 pub const INDEX_VISIBILITY: usize = 1;
15812 pub const INDEX_IMPL_KW: usize = 2;
15813 pub const INDEX_NAME: usize = 3;
15814 pub const INDEX_GENERIC_PARAMS: usize = 4;
15815 pub const INDEX_EQ: usize = 5;
15816 pub const INDEX_IMPL_PATH: usize = 6;
15817 pub const INDEX_SEMICOLON: usize = 7;
15818 pub fn new_green(
15819 db: &dyn SyntaxGroup,
15820 attributes: AttributeListGreen,
15821 visibility: VisibilityGreen,
15822 impl_kw: TerminalImplGreen,
15823 name: TerminalIdentifierGreen,
15824 generic_params: OptionWrappedGenericParamListGreen,
15825 eq: TerminalEqGreen,
15826 impl_path: ExprPathGreen,
15827 semicolon: TerminalSemicolonGreen,
15828 ) -> ItemImplAliasGreen {
15829 let children: Vec<GreenId> = vec![
15830 attributes.0,
15831 visibility.0,
15832 impl_kw.0,
15833 name.0,
15834 generic_params.0,
15835 eq.0,
15836 impl_path.0,
15837 semicolon.0,
15838 ];
15839 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15840 ItemImplAliasGreen(
15841 Arc::new(GreenNode {
15842 kind: SyntaxKind::ItemImplAlias,
15843 details: GreenNodeDetails::Node { children, width },
15844 })
15845 .intern(db),
15846 )
15847 }
15848}
15849impl ItemImplAlias {
15850 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15851 AttributeList::from_syntax_node(db, self.children[0].clone())
15852 }
15853 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
15854 Visibility::from_syntax_node(db, self.children[1].clone())
15855 }
15856 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
15857 TerminalImpl::from_syntax_node(db, self.children[2].clone())
15858 }
15859 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
15860 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
15861 }
15862 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
15863 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
15864 }
15865 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
15866 TerminalEq::from_syntax_node(db, self.children[5].clone())
15867 }
15868 pub fn impl_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
15869 ExprPath::from_syntax_node(db, self.children[6].clone())
15870 }
15871 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
15872 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
15873 }
15874}
15875#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15876pub struct ItemImplAliasPtr(pub SyntaxStablePtrId);
15877impl ItemImplAliasPtr {
15878 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
15879 let ptr = self.0.lookup_intern(db);
15880 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
15881 TerminalIdentifierGreen(key_fields[0])
15882 } else {
15883 panic!("Unexpected key field query on root.");
15884 }
15885 }
15886}
15887impl TypedStablePtr for ItemImplAliasPtr {
15888 type SyntaxNode = ItemImplAlias;
15889 fn untyped(&self) -> SyntaxStablePtrId {
15890 self.0
15891 }
15892 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemImplAlias {
15893 ItemImplAlias::from_syntax_node(db, self.0.lookup(db))
15894 }
15895}
15896impl From<ItemImplAliasPtr> for SyntaxStablePtrId {
15897 fn from(ptr: ItemImplAliasPtr) -> Self {
15898 ptr.untyped()
15899 }
15900}
15901#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
15902pub struct ItemImplAliasGreen(pub GreenId);
15903impl TypedSyntaxNode for ItemImplAlias {
15904 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemImplAlias);
15905 type StablePtr = ItemImplAliasPtr;
15906 type Green = ItemImplAliasGreen;
15907 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
15908 ItemImplAliasGreen(
15909 Arc::new(GreenNode {
15910 kind: SyntaxKind::ItemImplAlias,
15911 details: GreenNodeDetails::Node {
15912 children: vec![
15913 AttributeList::missing(db).0,
15914 Visibility::missing(db).0,
15915 TerminalImpl::missing(db).0,
15916 TerminalIdentifier::missing(db).0,
15917 OptionWrappedGenericParamList::missing(db).0,
15918 TerminalEq::missing(db).0,
15919 ExprPath::missing(db).0,
15920 TerminalSemicolon::missing(db).0,
15921 ],
15922 width: TextWidth::default(),
15923 },
15924 })
15925 .intern(db),
15926 )
15927 }
15928 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
15929 let kind = node.kind(db);
15930 assert_eq!(
15931 kind,
15932 SyntaxKind::ItemImplAlias,
15933 "Unexpected SyntaxKind {:?}. Expected {:?}.",
15934 kind,
15935 SyntaxKind::ItemImplAlias
15936 );
15937 let children = db.get_children(node.clone());
15938 Self { node, children }
15939 }
15940 fn as_syntax_node(&self) -> SyntaxNode {
15941 self.node.clone()
15942 }
15943 fn stable_ptr(&self) -> Self::StablePtr {
15944 ItemImplAliasPtr(self.node.0.stable_ptr)
15945 }
15946}
15947impl From<&ItemImplAlias> for SyntaxStablePtrId {
15948 fn from(node: &ItemImplAlias) -> Self {
15949 node.stable_ptr().untyped()
15950 }
15951}
15952#[derive(Clone, Debug, Eq, Hash, PartialEq)]
15953pub struct ItemStruct {
15954 node: SyntaxNode,
15955 children: Arc<[SyntaxNode]>,
15956}
15957impl ItemStruct {
15958 pub const INDEX_ATTRIBUTES: usize = 0;
15959 pub const INDEX_VISIBILITY: usize = 1;
15960 pub const INDEX_STRUCT_KW: usize = 2;
15961 pub const INDEX_NAME: usize = 3;
15962 pub const INDEX_GENERIC_PARAMS: usize = 4;
15963 pub const INDEX_LBRACE: usize = 5;
15964 pub const INDEX_MEMBERS: usize = 6;
15965 pub const INDEX_RBRACE: usize = 7;
15966 pub fn new_green(
15967 db: &dyn SyntaxGroup,
15968 attributes: AttributeListGreen,
15969 visibility: VisibilityGreen,
15970 struct_kw: TerminalStructGreen,
15971 name: TerminalIdentifierGreen,
15972 generic_params: OptionWrappedGenericParamListGreen,
15973 lbrace: TerminalLBraceGreen,
15974 members: MemberListGreen,
15975 rbrace: TerminalRBraceGreen,
15976 ) -> ItemStructGreen {
15977 let children: Vec<GreenId> = vec![
15978 attributes.0,
15979 visibility.0,
15980 struct_kw.0,
15981 name.0,
15982 generic_params.0,
15983 lbrace.0,
15984 members.0,
15985 rbrace.0,
15986 ];
15987 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
15988 ItemStructGreen(
15989 Arc::new(GreenNode {
15990 kind: SyntaxKind::ItemStruct,
15991 details: GreenNodeDetails::Node { children, width },
15992 })
15993 .intern(db),
15994 )
15995 }
15996}
15997impl ItemStruct {
15998 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
15999 AttributeList::from_syntax_node(db, self.children[0].clone())
16000 }
16001 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
16002 Visibility::from_syntax_node(db, self.children[1].clone())
16003 }
16004 pub fn struct_kw(&self, db: &dyn SyntaxGroup) -> TerminalStruct {
16005 TerminalStruct::from_syntax_node(db, self.children[2].clone())
16006 }
16007 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16008 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
16009 }
16010 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
16011 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
16012 }
16013 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
16014 TerminalLBrace::from_syntax_node(db, self.children[5].clone())
16015 }
16016 pub fn members(&self, db: &dyn SyntaxGroup) -> MemberList {
16017 MemberList::from_syntax_node(db, self.children[6].clone())
16018 }
16019 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
16020 TerminalRBrace::from_syntax_node(db, self.children[7].clone())
16021 }
16022}
16023#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16024pub struct ItemStructPtr(pub SyntaxStablePtrId);
16025impl ItemStructPtr {
16026 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
16027 let ptr = self.0.lookup_intern(db);
16028 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16029 TerminalIdentifierGreen(key_fields[0])
16030 } else {
16031 panic!("Unexpected key field query on root.");
16032 }
16033 }
16034}
16035impl TypedStablePtr for ItemStructPtr {
16036 type SyntaxNode = ItemStruct;
16037 fn untyped(&self) -> SyntaxStablePtrId {
16038 self.0
16039 }
16040 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemStruct {
16041 ItemStruct::from_syntax_node(db, self.0.lookup(db))
16042 }
16043}
16044impl From<ItemStructPtr> for SyntaxStablePtrId {
16045 fn from(ptr: ItemStructPtr) -> Self {
16046 ptr.untyped()
16047 }
16048}
16049#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16050pub struct ItemStructGreen(pub GreenId);
16051impl TypedSyntaxNode for ItemStruct {
16052 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemStruct);
16053 type StablePtr = ItemStructPtr;
16054 type Green = ItemStructGreen;
16055 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16056 ItemStructGreen(
16057 Arc::new(GreenNode {
16058 kind: SyntaxKind::ItemStruct,
16059 details: GreenNodeDetails::Node {
16060 children: vec![
16061 AttributeList::missing(db).0,
16062 Visibility::missing(db).0,
16063 TerminalStruct::missing(db).0,
16064 TerminalIdentifier::missing(db).0,
16065 OptionWrappedGenericParamList::missing(db).0,
16066 TerminalLBrace::missing(db).0,
16067 MemberList::missing(db).0,
16068 TerminalRBrace::missing(db).0,
16069 ],
16070 width: TextWidth::default(),
16071 },
16072 })
16073 .intern(db),
16074 )
16075 }
16076 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16077 let kind = node.kind(db);
16078 assert_eq!(
16079 kind,
16080 SyntaxKind::ItemStruct,
16081 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16082 kind,
16083 SyntaxKind::ItemStruct
16084 );
16085 let children = db.get_children(node.clone());
16086 Self { node, children }
16087 }
16088 fn as_syntax_node(&self) -> SyntaxNode {
16089 self.node.clone()
16090 }
16091 fn stable_ptr(&self) -> Self::StablePtr {
16092 ItemStructPtr(self.node.0.stable_ptr)
16093 }
16094}
16095impl From<&ItemStruct> for SyntaxStablePtrId {
16096 fn from(node: &ItemStruct) -> Self {
16097 node.stable_ptr().untyped()
16098 }
16099}
16100#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16101pub struct ItemEnum {
16102 node: SyntaxNode,
16103 children: Arc<[SyntaxNode]>,
16104}
16105impl ItemEnum {
16106 pub const INDEX_ATTRIBUTES: usize = 0;
16107 pub const INDEX_VISIBILITY: usize = 1;
16108 pub const INDEX_ENUM_KW: usize = 2;
16109 pub const INDEX_NAME: usize = 3;
16110 pub const INDEX_GENERIC_PARAMS: usize = 4;
16111 pub const INDEX_LBRACE: usize = 5;
16112 pub const INDEX_VARIANTS: usize = 6;
16113 pub const INDEX_RBRACE: usize = 7;
16114 pub fn new_green(
16115 db: &dyn SyntaxGroup,
16116 attributes: AttributeListGreen,
16117 visibility: VisibilityGreen,
16118 enum_kw: TerminalEnumGreen,
16119 name: TerminalIdentifierGreen,
16120 generic_params: OptionWrappedGenericParamListGreen,
16121 lbrace: TerminalLBraceGreen,
16122 variants: VariantListGreen,
16123 rbrace: TerminalRBraceGreen,
16124 ) -> ItemEnumGreen {
16125 let children: Vec<GreenId> = vec![
16126 attributes.0,
16127 visibility.0,
16128 enum_kw.0,
16129 name.0,
16130 generic_params.0,
16131 lbrace.0,
16132 variants.0,
16133 rbrace.0,
16134 ];
16135 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16136 ItemEnumGreen(
16137 Arc::new(GreenNode {
16138 kind: SyntaxKind::ItemEnum,
16139 details: GreenNodeDetails::Node { children, width },
16140 })
16141 .intern(db),
16142 )
16143 }
16144}
16145impl ItemEnum {
16146 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16147 AttributeList::from_syntax_node(db, self.children[0].clone())
16148 }
16149 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
16150 Visibility::from_syntax_node(db, self.children[1].clone())
16151 }
16152 pub fn enum_kw(&self, db: &dyn SyntaxGroup) -> TerminalEnum {
16153 TerminalEnum::from_syntax_node(db, self.children[2].clone())
16154 }
16155 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16156 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
16157 }
16158 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
16159 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
16160 }
16161 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
16162 TerminalLBrace::from_syntax_node(db, self.children[5].clone())
16163 }
16164 pub fn variants(&self, db: &dyn SyntaxGroup) -> VariantList {
16165 VariantList::from_syntax_node(db, self.children[6].clone())
16166 }
16167 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
16168 TerminalRBrace::from_syntax_node(db, self.children[7].clone())
16169 }
16170}
16171#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16172pub struct ItemEnumPtr(pub SyntaxStablePtrId);
16173impl ItemEnumPtr {
16174 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
16175 let ptr = self.0.lookup_intern(db);
16176 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16177 TerminalIdentifierGreen(key_fields[0])
16178 } else {
16179 panic!("Unexpected key field query on root.");
16180 }
16181 }
16182}
16183impl TypedStablePtr for ItemEnumPtr {
16184 type SyntaxNode = ItemEnum;
16185 fn untyped(&self) -> SyntaxStablePtrId {
16186 self.0
16187 }
16188 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemEnum {
16189 ItemEnum::from_syntax_node(db, self.0.lookup(db))
16190 }
16191}
16192impl From<ItemEnumPtr> for SyntaxStablePtrId {
16193 fn from(ptr: ItemEnumPtr) -> Self {
16194 ptr.untyped()
16195 }
16196}
16197#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16198pub struct ItemEnumGreen(pub GreenId);
16199impl TypedSyntaxNode for ItemEnum {
16200 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemEnum);
16201 type StablePtr = ItemEnumPtr;
16202 type Green = ItemEnumGreen;
16203 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16204 ItemEnumGreen(
16205 Arc::new(GreenNode {
16206 kind: SyntaxKind::ItemEnum,
16207 details: GreenNodeDetails::Node {
16208 children: vec![
16209 AttributeList::missing(db).0,
16210 Visibility::missing(db).0,
16211 TerminalEnum::missing(db).0,
16212 TerminalIdentifier::missing(db).0,
16213 OptionWrappedGenericParamList::missing(db).0,
16214 TerminalLBrace::missing(db).0,
16215 VariantList::missing(db).0,
16216 TerminalRBrace::missing(db).0,
16217 ],
16218 width: TextWidth::default(),
16219 },
16220 })
16221 .intern(db),
16222 )
16223 }
16224 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16225 let kind = node.kind(db);
16226 assert_eq!(
16227 kind,
16228 SyntaxKind::ItemEnum,
16229 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16230 kind,
16231 SyntaxKind::ItemEnum
16232 );
16233 let children = db.get_children(node.clone());
16234 Self { node, children }
16235 }
16236 fn as_syntax_node(&self) -> SyntaxNode {
16237 self.node.clone()
16238 }
16239 fn stable_ptr(&self) -> Self::StablePtr {
16240 ItemEnumPtr(self.node.0.stable_ptr)
16241 }
16242}
16243impl From<&ItemEnum> for SyntaxStablePtrId {
16244 fn from(node: &ItemEnum) -> Self {
16245 node.stable_ptr().untyped()
16246 }
16247}
16248#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16249pub struct ItemTypeAlias {
16250 node: SyntaxNode,
16251 children: Arc<[SyntaxNode]>,
16252}
16253impl ItemTypeAlias {
16254 pub const INDEX_ATTRIBUTES: usize = 0;
16255 pub const INDEX_VISIBILITY: usize = 1;
16256 pub const INDEX_TYPE_KW: usize = 2;
16257 pub const INDEX_NAME: usize = 3;
16258 pub const INDEX_GENERIC_PARAMS: usize = 4;
16259 pub const INDEX_EQ: usize = 5;
16260 pub const INDEX_TY: usize = 6;
16261 pub const INDEX_SEMICOLON: usize = 7;
16262 pub fn new_green(
16263 db: &dyn SyntaxGroup,
16264 attributes: AttributeListGreen,
16265 visibility: VisibilityGreen,
16266 type_kw: TerminalTypeGreen,
16267 name: TerminalIdentifierGreen,
16268 generic_params: OptionWrappedGenericParamListGreen,
16269 eq: TerminalEqGreen,
16270 ty: ExprGreen,
16271 semicolon: TerminalSemicolonGreen,
16272 ) -> ItemTypeAliasGreen {
16273 let children: Vec<GreenId> = vec![
16274 attributes.0,
16275 visibility.0,
16276 type_kw.0,
16277 name.0,
16278 generic_params.0,
16279 eq.0,
16280 ty.0,
16281 semicolon.0,
16282 ];
16283 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16284 ItemTypeAliasGreen(
16285 Arc::new(GreenNode {
16286 kind: SyntaxKind::ItemTypeAlias,
16287 details: GreenNodeDetails::Node { children, width },
16288 })
16289 .intern(db),
16290 )
16291 }
16292}
16293impl ItemTypeAlias {
16294 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16295 AttributeList::from_syntax_node(db, self.children[0].clone())
16296 }
16297 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
16298 Visibility::from_syntax_node(db, self.children[1].clone())
16299 }
16300 pub fn type_kw(&self, db: &dyn SyntaxGroup) -> TerminalType {
16301 TerminalType::from_syntax_node(db, self.children[2].clone())
16302 }
16303 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
16304 TerminalIdentifier::from_syntax_node(db, self.children[3].clone())
16305 }
16306 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
16307 OptionWrappedGenericParamList::from_syntax_node(db, self.children[4].clone())
16308 }
16309 pub fn eq(&self, db: &dyn SyntaxGroup) -> TerminalEq {
16310 TerminalEq::from_syntax_node(db, self.children[5].clone())
16311 }
16312 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
16313 Expr::from_syntax_node(db, self.children[6].clone())
16314 }
16315 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
16316 TerminalSemicolon::from_syntax_node(db, self.children[7].clone())
16317 }
16318}
16319#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16320pub struct ItemTypeAliasPtr(pub SyntaxStablePtrId);
16321impl ItemTypeAliasPtr {
16322 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
16323 let ptr = self.0.lookup_intern(db);
16324 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16325 TerminalIdentifierGreen(key_fields[0])
16326 } else {
16327 panic!("Unexpected key field query on root.");
16328 }
16329 }
16330}
16331impl TypedStablePtr for ItemTypeAliasPtr {
16332 type SyntaxNode = ItemTypeAlias;
16333 fn untyped(&self) -> SyntaxStablePtrId {
16334 self.0
16335 }
16336 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemTypeAlias {
16337 ItemTypeAlias::from_syntax_node(db, self.0.lookup(db))
16338 }
16339}
16340impl From<ItemTypeAliasPtr> for SyntaxStablePtrId {
16341 fn from(ptr: ItemTypeAliasPtr) -> Self {
16342 ptr.untyped()
16343 }
16344}
16345#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16346pub struct ItemTypeAliasGreen(pub GreenId);
16347impl TypedSyntaxNode for ItemTypeAlias {
16348 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemTypeAlias);
16349 type StablePtr = ItemTypeAliasPtr;
16350 type Green = ItemTypeAliasGreen;
16351 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16352 ItemTypeAliasGreen(
16353 Arc::new(GreenNode {
16354 kind: SyntaxKind::ItemTypeAlias,
16355 details: GreenNodeDetails::Node {
16356 children: vec![
16357 AttributeList::missing(db).0,
16358 Visibility::missing(db).0,
16359 TerminalType::missing(db).0,
16360 TerminalIdentifier::missing(db).0,
16361 OptionWrappedGenericParamList::missing(db).0,
16362 TerminalEq::missing(db).0,
16363 Expr::missing(db).0,
16364 TerminalSemicolon::missing(db).0,
16365 ],
16366 width: TextWidth::default(),
16367 },
16368 })
16369 .intern(db),
16370 )
16371 }
16372 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16373 let kind = node.kind(db);
16374 assert_eq!(
16375 kind,
16376 SyntaxKind::ItemTypeAlias,
16377 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16378 kind,
16379 SyntaxKind::ItemTypeAlias
16380 );
16381 let children = db.get_children(node.clone());
16382 Self { node, children }
16383 }
16384 fn as_syntax_node(&self) -> SyntaxNode {
16385 self.node.clone()
16386 }
16387 fn stable_ptr(&self) -> Self::StablePtr {
16388 ItemTypeAliasPtr(self.node.0.stable_ptr)
16389 }
16390}
16391impl From<&ItemTypeAlias> for SyntaxStablePtrId {
16392 fn from(node: &ItemTypeAlias) -> Self {
16393 node.stable_ptr().untyped()
16394 }
16395}
16396#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16397pub struct ItemUse {
16398 node: SyntaxNode,
16399 children: Arc<[SyntaxNode]>,
16400}
16401impl ItemUse {
16402 pub const INDEX_ATTRIBUTES: usize = 0;
16403 pub const INDEX_VISIBILITY: usize = 1;
16404 pub const INDEX_USE_KW: usize = 2;
16405 pub const INDEX_USE_PATH: usize = 3;
16406 pub const INDEX_SEMICOLON: usize = 4;
16407 pub fn new_green(
16408 db: &dyn SyntaxGroup,
16409 attributes: AttributeListGreen,
16410 visibility: VisibilityGreen,
16411 use_kw: TerminalUseGreen,
16412 use_path: UsePathGreen,
16413 semicolon: TerminalSemicolonGreen,
16414 ) -> ItemUseGreen {
16415 let children: Vec<GreenId> =
16416 vec![attributes.0, visibility.0, use_kw.0, use_path.0, semicolon.0];
16417 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16418 ItemUseGreen(
16419 Arc::new(GreenNode {
16420 kind: SyntaxKind::ItemUse,
16421 details: GreenNodeDetails::Node { children, width },
16422 })
16423 .intern(db),
16424 )
16425 }
16426}
16427impl ItemUse {
16428 pub fn attributes(&self, db: &dyn SyntaxGroup) -> AttributeList {
16429 AttributeList::from_syntax_node(db, self.children[0].clone())
16430 }
16431 pub fn visibility(&self, db: &dyn SyntaxGroup) -> Visibility {
16432 Visibility::from_syntax_node(db, self.children[1].clone())
16433 }
16434 pub fn use_kw(&self, db: &dyn SyntaxGroup) -> TerminalUse {
16435 TerminalUse::from_syntax_node(db, self.children[2].clone())
16436 }
16437 pub fn use_path(&self, db: &dyn SyntaxGroup) -> UsePath {
16438 UsePath::from_syntax_node(db, self.children[3].clone())
16439 }
16440 pub fn semicolon(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
16441 TerminalSemicolon::from_syntax_node(db, self.children[4].clone())
16442 }
16443}
16444#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16445pub struct ItemUsePtr(pub SyntaxStablePtrId);
16446impl ItemUsePtr {
16447 pub fn use_path_green(self, db: &dyn SyntaxGroup) -> UsePathGreen {
16448 let ptr = self.0.lookup_intern(db);
16449 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16450 UsePathGreen(key_fields[0])
16451 } else {
16452 panic!("Unexpected key field query on root.");
16453 }
16454 }
16455}
16456impl TypedStablePtr for ItemUsePtr {
16457 type SyntaxNode = ItemUse;
16458 fn untyped(&self) -> SyntaxStablePtrId {
16459 self.0
16460 }
16461 fn lookup(&self, db: &dyn SyntaxGroup) -> ItemUse {
16462 ItemUse::from_syntax_node(db, self.0.lookup(db))
16463 }
16464}
16465impl From<ItemUsePtr> for SyntaxStablePtrId {
16466 fn from(ptr: ItemUsePtr) -> Self {
16467 ptr.untyped()
16468 }
16469}
16470#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16471pub struct ItemUseGreen(pub GreenId);
16472impl TypedSyntaxNode for ItemUse {
16473 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::ItemUse);
16474 type StablePtr = ItemUsePtr;
16475 type Green = ItemUseGreen;
16476 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16477 ItemUseGreen(
16478 Arc::new(GreenNode {
16479 kind: SyntaxKind::ItemUse,
16480 details: GreenNodeDetails::Node {
16481 children: vec![
16482 AttributeList::missing(db).0,
16483 Visibility::missing(db).0,
16484 TerminalUse::missing(db).0,
16485 UsePath::missing(db).0,
16486 TerminalSemicolon::missing(db).0,
16487 ],
16488 width: TextWidth::default(),
16489 },
16490 })
16491 .intern(db),
16492 )
16493 }
16494 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16495 let kind = node.kind(db);
16496 assert_eq!(
16497 kind,
16498 SyntaxKind::ItemUse,
16499 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16500 kind,
16501 SyntaxKind::ItemUse
16502 );
16503 let children = db.get_children(node.clone());
16504 Self { node, children }
16505 }
16506 fn as_syntax_node(&self) -> SyntaxNode {
16507 self.node.clone()
16508 }
16509 fn stable_ptr(&self) -> Self::StablePtr {
16510 ItemUsePtr(self.node.0.stable_ptr)
16511 }
16512}
16513impl From<&ItemUse> for SyntaxStablePtrId {
16514 fn from(node: &ItemUse) -> Self {
16515 node.stable_ptr().untyped()
16516 }
16517}
16518#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16519pub enum UsePath {
16520 Leaf(UsePathLeaf),
16521 Single(UsePathSingle),
16522 Multi(UsePathMulti),
16523 Star(UsePathStar),
16524}
16525#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16526pub struct UsePathPtr(pub SyntaxStablePtrId);
16527impl TypedStablePtr for UsePathPtr {
16528 type SyntaxNode = UsePath;
16529 fn untyped(&self) -> SyntaxStablePtrId {
16530 self.0
16531 }
16532 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePath {
16533 UsePath::from_syntax_node(db, self.0.lookup(db))
16534 }
16535}
16536impl From<UsePathPtr> for SyntaxStablePtrId {
16537 fn from(ptr: UsePathPtr) -> Self {
16538 ptr.untyped()
16539 }
16540}
16541impl From<UsePathLeafPtr> for UsePathPtr {
16542 fn from(value: UsePathLeafPtr) -> Self {
16543 Self(value.0)
16544 }
16545}
16546impl From<UsePathSinglePtr> for UsePathPtr {
16547 fn from(value: UsePathSinglePtr) -> Self {
16548 Self(value.0)
16549 }
16550}
16551impl From<UsePathMultiPtr> for UsePathPtr {
16552 fn from(value: UsePathMultiPtr) -> Self {
16553 Self(value.0)
16554 }
16555}
16556impl From<UsePathStarPtr> for UsePathPtr {
16557 fn from(value: UsePathStarPtr) -> Self {
16558 Self(value.0)
16559 }
16560}
16561impl From<UsePathLeafGreen> for UsePathGreen {
16562 fn from(value: UsePathLeafGreen) -> Self {
16563 Self(value.0)
16564 }
16565}
16566impl From<UsePathSingleGreen> for UsePathGreen {
16567 fn from(value: UsePathSingleGreen) -> Self {
16568 Self(value.0)
16569 }
16570}
16571impl From<UsePathMultiGreen> for UsePathGreen {
16572 fn from(value: UsePathMultiGreen) -> Self {
16573 Self(value.0)
16574 }
16575}
16576impl From<UsePathStarGreen> for UsePathGreen {
16577 fn from(value: UsePathStarGreen) -> Self {
16578 Self(value.0)
16579 }
16580}
16581#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16582pub struct UsePathGreen(pub GreenId);
16583impl TypedSyntaxNode for UsePath {
16584 const OPTIONAL_KIND: Option<SyntaxKind> = None;
16585 type StablePtr = UsePathPtr;
16586 type Green = UsePathGreen;
16587 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16588 panic!("No missing variant.");
16589 }
16590 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16591 let kind = node.kind(db);
16592 match kind {
16593 SyntaxKind::UsePathLeaf => UsePath::Leaf(UsePathLeaf::from_syntax_node(db, node)),
16594 SyntaxKind::UsePathSingle => UsePath::Single(UsePathSingle::from_syntax_node(db, node)),
16595 SyntaxKind::UsePathMulti => UsePath::Multi(UsePathMulti::from_syntax_node(db, node)),
16596 SyntaxKind::UsePathStar => UsePath::Star(UsePathStar::from_syntax_node(db, node)),
16597 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "UsePath"),
16598 }
16599 }
16600 fn as_syntax_node(&self) -> SyntaxNode {
16601 match self {
16602 UsePath::Leaf(x) => x.as_syntax_node(),
16603 UsePath::Single(x) => x.as_syntax_node(),
16604 UsePath::Multi(x) => x.as_syntax_node(),
16605 UsePath::Star(x) => x.as_syntax_node(),
16606 }
16607 }
16608 fn stable_ptr(&self) -> Self::StablePtr {
16609 UsePathPtr(self.as_syntax_node().0.stable_ptr)
16610 }
16611}
16612impl From<&UsePath> for SyntaxStablePtrId {
16613 fn from(node: &UsePath) -> Self {
16614 node.stable_ptr().untyped()
16615 }
16616}
16617impl UsePath {
16618 pub fn is_variant(kind: SyntaxKind) -> bool {
16620 matches!(
16621 kind,
16622 SyntaxKind::UsePathLeaf
16623 | SyntaxKind::UsePathSingle
16624 | SyntaxKind::UsePathMulti
16625 | SyntaxKind::UsePathStar
16626 )
16627 }
16628}
16629#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16630pub struct UsePathLeaf {
16631 node: SyntaxNode,
16632 children: Arc<[SyntaxNode]>,
16633}
16634impl UsePathLeaf {
16635 pub const INDEX_IDENT: usize = 0;
16636 pub const INDEX_ALIAS_CLAUSE: usize = 1;
16637 pub fn new_green(
16638 db: &dyn SyntaxGroup,
16639 ident: PathSegmentGreen,
16640 alias_clause: OptionAliasClauseGreen,
16641 ) -> UsePathLeafGreen {
16642 let children: Vec<GreenId> = vec![ident.0, alias_clause.0];
16643 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16644 UsePathLeafGreen(
16645 Arc::new(GreenNode {
16646 kind: SyntaxKind::UsePathLeaf,
16647 details: GreenNodeDetails::Node { children, width },
16648 })
16649 .intern(db),
16650 )
16651 }
16652}
16653impl UsePathLeaf {
16654 pub fn ident(&self, db: &dyn SyntaxGroup) -> PathSegment {
16655 PathSegment::from_syntax_node(db, self.children[0].clone())
16656 }
16657 pub fn alias_clause(&self, db: &dyn SyntaxGroup) -> OptionAliasClause {
16658 OptionAliasClause::from_syntax_node(db, self.children[1].clone())
16659 }
16660}
16661#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16662pub struct UsePathLeafPtr(pub SyntaxStablePtrId);
16663impl UsePathLeafPtr {
16664 pub fn ident_green(self, db: &dyn SyntaxGroup) -> PathSegmentGreen {
16665 let ptr = self.0.lookup_intern(db);
16666 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16667 PathSegmentGreen(key_fields[0])
16668 } else {
16669 panic!("Unexpected key field query on root.");
16670 }
16671 }
16672 pub fn alias_clause_green(self, db: &dyn SyntaxGroup) -> OptionAliasClauseGreen {
16673 let ptr = self.0.lookup_intern(db);
16674 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
16675 OptionAliasClauseGreen(key_fields[1])
16676 } else {
16677 panic!("Unexpected key field query on root.");
16678 }
16679 }
16680}
16681impl TypedStablePtr for UsePathLeafPtr {
16682 type SyntaxNode = UsePathLeaf;
16683 fn untyped(&self) -> SyntaxStablePtrId {
16684 self.0
16685 }
16686 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathLeaf {
16687 UsePathLeaf::from_syntax_node(db, self.0.lookup(db))
16688 }
16689}
16690impl From<UsePathLeafPtr> for SyntaxStablePtrId {
16691 fn from(ptr: UsePathLeafPtr) -> Self {
16692 ptr.untyped()
16693 }
16694}
16695#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16696pub struct UsePathLeafGreen(pub GreenId);
16697impl TypedSyntaxNode for UsePathLeaf {
16698 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathLeaf);
16699 type StablePtr = UsePathLeafPtr;
16700 type Green = UsePathLeafGreen;
16701 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16702 UsePathLeafGreen(
16703 Arc::new(GreenNode {
16704 kind: SyntaxKind::UsePathLeaf,
16705 details: GreenNodeDetails::Node {
16706 children: vec![PathSegment::missing(db).0, OptionAliasClause::missing(db).0],
16707 width: TextWidth::default(),
16708 },
16709 })
16710 .intern(db),
16711 )
16712 }
16713 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16714 let kind = node.kind(db);
16715 assert_eq!(
16716 kind,
16717 SyntaxKind::UsePathLeaf,
16718 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16719 kind,
16720 SyntaxKind::UsePathLeaf
16721 );
16722 let children = db.get_children(node.clone());
16723 Self { node, children }
16724 }
16725 fn as_syntax_node(&self) -> SyntaxNode {
16726 self.node.clone()
16727 }
16728 fn stable_ptr(&self) -> Self::StablePtr {
16729 UsePathLeafPtr(self.node.0.stable_ptr)
16730 }
16731}
16732impl From<&UsePathLeaf> for SyntaxStablePtrId {
16733 fn from(node: &UsePathLeaf) -> Self {
16734 node.stable_ptr().untyped()
16735 }
16736}
16737#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16738pub struct UsePathSingle {
16739 node: SyntaxNode,
16740 children: Arc<[SyntaxNode]>,
16741}
16742impl UsePathSingle {
16743 pub const INDEX_IDENT: usize = 0;
16744 pub const INDEX_COLON_COLON: usize = 1;
16745 pub const INDEX_USE_PATH: usize = 2;
16746 pub fn new_green(
16747 db: &dyn SyntaxGroup,
16748 ident: PathSegmentGreen,
16749 colon_colon: TerminalColonColonGreen,
16750 use_path: UsePathGreen,
16751 ) -> UsePathSingleGreen {
16752 let children: Vec<GreenId> = vec![ident.0, colon_colon.0, use_path.0];
16753 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16754 UsePathSingleGreen(
16755 Arc::new(GreenNode {
16756 kind: SyntaxKind::UsePathSingle,
16757 details: GreenNodeDetails::Node { children, width },
16758 })
16759 .intern(db),
16760 )
16761 }
16762}
16763impl UsePathSingle {
16764 pub fn ident(&self, db: &dyn SyntaxGroup) -> PathSegment {
16765 PathSegment::from_syntax_node(db, self.children[0].clone())
16766 }
16767 pub fn colon_colon(&self, db: &dyn SyntaxGroup) -> TerminalColonColon {
16768 TerminalColonColon::from_syntax_node(db, self.children[1].clone())
16769 }
16770 pub fn use_path(&self, db: &dyn SyntaxGroup) -> UsePath {
16771 UsePath::from_syntax_node(db, self.children[2].clone())
16772 }
16773}
16774#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16775pub struct UsePathSinglePtr(pub SyntaxStablePtrId);
16776impl UsePathSinglePtr {}
16777impl TypedStablePtr for UsePathSinglePtr {
16778 type SyntaxNode = UsePathSingle;
16779 fn untyped(&self) -> SyntaxStablePtrId {
16780 self.0
16781 }
16782 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathSingle {
16783 UsePathSingle::from_syntax_node(db, self.0.lookup(db))
16784 }
16785}
16786impl From<UsePathSinglePtr> for SyntaxStablePtrId {
16787 fn from(ptr: UsePathSinglePtr) -> Self {
16788 ptr.untyped()
16789 }
16790}
16791#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16792pub struct UsePathSingleGreen(pub GreenId);
16793impl TypedSyntaxNode for UsePathSingle {
16794 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathSingle);
16795 type StablePtr = UsePathSinglePtr;
16796 type Green = UsePathSingleGreen;
16797 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16798 UsePathSingleGreen(
16799 Arc::new(GreenNode {
16800 kind: SyntaxKind::UsePathSingle,
16801 details: GreenNodeDetails::Node {
16802 children: vec![
16803 PathSegment::missing(db).0,
16804 TerminalColonColon::missing(db).0,
16805 UsePath::missing(db).0,
16806 ],
16807 width: TextWidth::default(),
16808 },
16809 })
16810 .intern(db),
16811 )
16812 }
16813 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16814 let kind = node.kind(db);
16815 assert_eq!(
16816 kind,
16817 SyntaxKind::UsePathSingle,
16818 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16819 kind,
16820 SyntaxKind::UsePathSingle
16821 );
16822 let children = db.get_children(node.clone());
16823 Self { node, children }
16824 }
16825 fn as_syntax_node(&self) -> SyntaxNode {
16826 self.node.clone()
16827 }
16828 fn stable_ptr(&self) -> Self::StablePtr {
16829 UsePathSinglePtr(self.node.0.stable_ptr)
16830 }
16831}
16832impl From<&UsePathSingle> for SyntaxStablePtrId {
16833 fn from(node: &UsePathSingle) -> Self {
16834 node.stable_ptr().untyped()
16835 }
16836}
16837#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16838pub struct UsePathMulti {
16839 node: SyntaxNode,
16840 children: Arc<[SyntaxNode]>,
16841}
16842impl UsePathMulti {
16843 pub const INDEX_LBRACE: usize = 0;
16844 pub const INDEX_USE_PATHS: usize = 1;
16845 pub const INDEX_RBRACE: usize = 2;
16846 pub fn new_green(
16847 db: &dyn SyntaxGroup,
16848 lbrace: TerminalLBraceGreen,
16849 use_paths: UsePathListGreen,
16850 rbrace: TerminalRBraceGreen,
16851 ) -> UsePathMultiGreen {
16852 let children: Vec<GreenId> = vec![lbrace.0, use_paths.0, rbrace.0];
16853 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16854 UsePathMultiGreen(
16855 Arc::new(GreenNode {
16856 kind: SyntaxKind::UsePathMulti,
16857 details: GreenNodeDetails::Node { children, width },
16858 })
16859 .intern(db),
16860 )
16861 }
16862}
16863impl UsePathMulti {
16864 pub fn lbrace(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
16865 TerminalLBrace::from_syntax_node(db, self.children[0].clone())
16866 }
16867 pub fn use_paths(&self, db: &dyn SyntaxGroup) -> UsePathList {
16868 UsePathList::from_syntax_node(db, self.children[1].clone())
16869 }
16870 pub fn rbrace(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
16871 TerminalRBrace::from_syntax_node(db, self.children[2].clone())
16872 }
16873}
16874#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16875pub struct UsePathMultiPtr(pub SyntaxStablePtrId);
16876impl UsePathMultiPtr {}
16877impl TypedStablePtr for UsePathMultiPtr {
16878 type SyntaxNode = UsePathMulti;
16879 fn untyped(&self) -> SyntaxStablePtrId {
16880 self.0
16881 }
16882 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathMulti {
16883 UsePathMulti::from_syntax_node(db, self.0.lookup(db))
16884 }
16885}
16886impl From<UsePathMultiPtr> for SyntaxStablePtrId {
16887 fn from(ptr: UsePathMultiPtr) -> Self {
16888 ptr.untyped()
16889 }
16890}
16891#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16892pub struct UsePathMultiGreen(pub GreenId);
16893impl TypedSyntaxNode for UsePathMulti {
16894 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathMulti);
16895 type StablePtr = UsePathMultiPtr;
16896 type Green = UsePathMultiGreen;
16897 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16898 UsePathMultiGreen(
16899 Arc::new(GreenNode {
16900 kind: SyntaxKind::UsePathMulti,
16901 details: GreenNodeDetails::Node {
16902 children: vec![
16903 TerminalLBrace::missing(db).0,
16904 UsePathList::missing(db).0,
16905 TerminalRBrace::missing(db).0,
16906 ],
16907 width: TextWidth::default(),
16908 },
16909 })
16910 .intern(db),
16911 )
16912 }
16913 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16914 let kind = node.kind(db);
16915 assert_eq!(
16916 kind,
16917 SyntaxKind::UsePathMulti,
16918 "Unexpected SyntaxKind {:?}. Expected {:?}.",
16919 kind,
16920 SyntaxKind::UsePathMulti
16921 );
16922 let children = db.get_children(node.clone());
16923 Self { node, children }
16924 }
16925 fn as_syntax_node(&self) -> SyntaxNode {
16926 self.node.clone()
16927 }
16928 fn stable_ptr(&self) -> Self::StablePtr {
16929 UsePathMultiPtr(self.node.0.stable_ptr)
16930 }
16931}
16932impl From<&UsePathMulti> for SyntaxStablePtrId {
16933 fn from(node: &UsePathMulti) -> Self {
16934 node.stable_ptr().untyped()
16935 }
16936}
16937#[derive(Clone, Debug, Eq, Hash, PartialEq)]
16938pub struct UsePathStar {
16939 node: SyntaxNode,
16940 children: Arc<[SyntaxNode]>,
16941}
16942impl UsePathStar {
16943 pub const INDEX_STAR: usize = 0;
16944 pub fn new_green(db: &dyn SyntaxGroup, star: TerminalMulGreen) -> UsePathStarGreen {
16945 let children: Vec<GreenId> = vec![star.0];
16946 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
16947 UsePathStarGreen(
16948 Arc::new(GreenNode {
16949 kind: SyntaxKind::UsePathStar,
16950 details: GreenNodeDetails::Node { children, width },
16951 })
16952 .intern(db),
16953 )
16954 }
16955}
16956impl UsePathStar {
16957 pub fn star(&self, db: &dyn SyntaxGroup) -> TerminalMul {
16958 TerminalMul::from_syntax_node(db, self.children[0].clone())
16959 }
16960}
16961#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16962pub struct UsePathStarPtr(pub SyntaxStablePtrId);
16963impl UsePathStarPtr {}
16964impl TypedStablePtr for UsePathStarPtr {
16965 type SyntaxNode = UsePathStar;
16966 fn untyped(&self) -> SyntaxStablePtrId {
16967 self.0
16968 }
16969 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathStar {
16970 UsePathStar::from_syntax_node(db, self.0.lookup(db))
16971 }
16972}
16973impl From<UsePathStarPtr> for SyntaxStablePtrId {
16974 fn from(ptr: UsePathStarPtr) -> Self {
16975 ptr.untyped()
16976 }
16977}
16978#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
16979pub struct UsePathStarGreen(pub GreenId);
16980impl TypedSyntaxNode for UsePathStar {
16981 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathStar);
16982 type StablePtr = UsePathStarPtr;
16983 type Green = UsePathStarGreen;
16984 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
16985 UsePathStarGreen(
16986 Arc::new(GreenNode {
16987 kind: SyntaxKind::UsePathStar,
16988 details: GreenNodeDetails::Node {
16989 children: vec![TerminalMul::missing(db).0],
16990 width: TextWidth::default(),
16991 },
16992 })
16993 .intern(db),
16994 )
16995 }
16996 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
16997 let kind = node.kind(db);
16998 assert_eq!(
16999 kind,
17000 SyntaxKind::UsePathStar,
17001 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17002 kind,
17003 SyntaxKind::UsePathStar
17004 );
17005 let children = db.get_children(node.clone());
17006 Self { node, children }
17007 }
17008 fn as_syntax_node(&self) -> SyntaxNode {
17009 self.node.clone()
17010 }
17011 fn stable_ptr(&self) -> Self::StablePtr {
17012 UsePathStarPtr(self.node.0.stable_ptr)
17013 }
17014}
17015impl From<&UsePathStar> for SyntaxStablePtrId {
17016 fn from(node: &UsePathStar) -> Self {
17017 node.stable_ptr().untyped()
17018 }
17019}
17020#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17021pub struct UsePathList(ElementList<UsePath, 2>);
17022impl Deref for UsePathList {
17023 type Target = ElementList<UsePath, 2>;
17024 fn deref(&self) -> &Self::Target {
17025 &self.0
17026 }
17027}
17028impl UsePathList {
17029 pub fn new_green(
17030 db: &dyn SyntaxGroup,
17031 children: Vec<UsePathListElementOrSeparatorGreen>,
17032 ) -> UsePathListGreen {
17033 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
17034 UsePathListGreen(
17035 Arc::new(GreenNode {
17036 kind: SyntaxKind::UsePathList,
17037 details: GreenNodeDetails::Node {
17038 children: children.iter().map(|x| x.id()).collect(),
17039 width,
17040 },
17041 })
17042 .intern(db),
17043 )
17044 }
17045}
17046#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17047pub struct UsePathListPtr(pub SyntaxStablePtrId);
17048impl TypedStablePtr for UsePathListPtr {
17049 type SyntaxNode = UsePathList;
17050 fn untyped(&self) -> SyntaxStablePtrId {
17051 self.0
17052 }
17053 fn lookup(&self, db: &dyn SyntaxGroup) -> UsePathList {
17054 UsePathList::from_syntax_node(db, self.0.lookup(db))
17055 }
17056}
17057impl From<UsePathListPtr> for SyntaxStablePtrId {
17058 fn from(ptr: UsePathListPtr) -> Self {
17059 ptr.untyped()
17060 }
17061}
17062#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17063pub enum UsePathListElementOrSeparatorGreen {
17064 Separator(TerminalCommaGreen),
17065 Element(UsePathGreen),
17066}
17067impl From<TerminalCommaGreen> for UsePathListElementOrSeparatorGreen {
17068 fn from(value: TerminalCommaGreen) -> Self {
17069 UsePathListElementOrSeparatorGreen::Separator(value)
17070 }
17071}
17072impl From<UsePathGreen> for UsePathListElementOrSeparatorGreen {
17073 fn from(value: UsePathGreen) -> Self {
17074 UsePathListElementOrSeparatorGreen::Element(value)
17075 }
17076}
17077impl UsePathListElementOrSeparatorGreen {
17078 fn id(&self) -> GreenId {
17079 match self {
17080 UsePathListElementOrSeparatorGreen::Separator(green) => green.0,
17081 UsePathListElementOrSeparatorGreen::Element(green) => green.0,
17082 }
17083 }
17084}
17085#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17086pub struct UsePathListGreen(pub GreenId);
17087impl TypedSyntaxNode for UsePathList {
17088 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::UsePathList);
17089 type StablePtr = UsePathListPtr;
17090 type Green = UsePathListGreen;
17091 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17092 UsePathListGreen(
17093 Arc::new(GreenNode {
17094 kind: SyntaxKind::UsePathList,
17095 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
17096 })
17097 .intern(db),
17098 )
17099 }
17100 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17101 Self(ElementList::new(node))
17102 }
17103 fn as_syntax_node(&self) -> SyntaxNode {
17104 self.node.clone()
17105 }
17106 fn stable_ptr(&self) -> Self::StablePtr {
17107 UsePathListPtr(self.node.0.stable_ptr)
17108 }
17109}
17110impl From<&UsePathList> for SyntaxStablePtrId {
17111 fn from(node: &UsePathList) -> Self {
17112 node.stable_ptr().untyped()
17113 }
17114}
17115#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17116pub struct AliasClause {
17117 node: SyntaxNode,
17118 children: Arc<[SyntaxNode]>,
17119}
17120impl AliasClause {
17121 pub const INDEX_AS_KW: usize = 0;
17122 pub const INDEX_ALIAS: usize = 1;
17123 pub fn new_green(
17124 db: &dyn SyntaxGroup,
17125 as_kw: TerminalAsGreen,
17126 alias: TerminalIdentifierGreen,
17127 ) -> AliasClauseGreen {
17128 let children: Vec<GreenId> = vec![as_kw.0, alias.0];
17129 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17130 AliasClauseGreen(
17131 Arc::new(GreenNode {
17132 kind: SyntaxKind::AliasClause,
17133 details: GreenNodeDetails::Node { children, width },
17134 })
17135 .intern(db),
17136 )
17137 }
17138}
17139impl AliasClause {
17140 pub fn as_kw(&self, db: &dyn SyntaxGroup) -> TerminalAs {
17141 TerminalAs::from_syntax_node(db, self.children[0].clone())
17142 }
17143 pub fn alias(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17144 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
17145 }
17146}
17147#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17148pub struct AliasClausePtr(pub SyntaxStablePtrId);
17149impl AliasClausePtr {
17150 pub fn alias_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
17151 let ptr = self.0.lookup_intern(db);
17152 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
17153 TerminalIdentifierGreen(key_fields[0])
17154 } else {
17155 panic!("Unexpected key field query on root.");
17156 }
17157 }
17158}
17159impl TypedStablePtr for AliasClausePtr {
17160 type SyntaxNode = AliasClause;
17161 fn untyped(&self) -> SyntaxStablePtrId {
17162 self.0
17163 }
17164 fn lookup(&self, db: &dyn SyntaxGroup) -> AliasClause {
17165 AliasClause::from_syntax_node(db, self.0.lookup(db))
17166 }
17167}
17168impl From<AliasClausePtr> for SyntaxStablePtrId {
17169 fn from(ptr: AliasClausePtr) -> Self {
17170 ptr.untyped()
17171 }
17172}
17173#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17174pub struct AliasClauseGreen(pub GreenId);
17175impl TypedSyntaxNode for AliasClause {
17176 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AliasClause);
17177 type StablePtr = AliasClausePtr;
17178 type Green = AliasClauseGreen;
17179 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17180 AliasClauseGreen(
17181 Arc::new(GreenNode {
17182 kind: SyntaxKind::AliasClause,
17183 details: GreenNodeDetails::Node {
17184 children: vec![TerminalAs::missing(db).0, TerminalIdentifier::missing(db).0],
17185 width: TextWidth::default(),
17186 },
17187 })
17188 .intern(db),
17189 )
17190 }
17191 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17192 let kind = node.kind(db);
17193 assert_eq!(
17194 kind,
17195 SyntaxKind::AliasClause,
17196 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17197 kind,
17198 SyntaxKind::AliasClause
17199 );
17200 let children = db.get_children(node.clone());
17201 Self { node, children }
17202 }
17203 fn as_syntax_node(&self) -> SyntaxNode {
17204 self.node.clone()
17205 }
17206 fn stable_ptr(&self) -> Self::StablePtr {
17207 AliasClausePtr(self.node.0.stable_ptr)
17208 }
17209}
17210impl From<&AliasClause> for SyntaxStablePtrId {
17211 fn from(node: &AliasClause) -> Self {
17212 node.stable_ptr().untyped()
17213 }
17214}
17215#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17216pub enum OptionAliasClause {
17217 Empty(OptionAliasClauseEmpty),
17218 AliasClause(AliasClause),
17219}
17220#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17221pub struct OptionAliasClausePtr(pub SyntaxStablePtrId);
17222impl TypedStablePtr for OptionAliasClausePtr {
17223 type SyntaxNode = OptionAliasClause;
17224 fn untyped(&self) -> SyntaxStablePtrId {
17225 self.0
17226 }
17227 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAliasClause {
17228 OptionAliasClause::from_syntax_node(db, self.0.lookup(db))
17229 }
17230}
17231impl From<OptionAliasClausePtr> for SyntaxStablePtrId {
17232 fn from(ptr: OptionAliasClausePtr) -> Self {
17233 ptr.untyped()
17234 }
17235}
17236impl From<OptionAliasClauseEmptyPtr> for OptionAliasClausePtr {
17237 fn from(value: OptionAliasClauseEmptyPtr) -> Self {
17238 Self(value.0)
17239 }
17240}
17241impl From<AliasClausePtr> for OptionAliasClausePtr {
17242 fn from(value: AliasClausePtr) -> Self {
17243 Self(value.0)
17244 }
17245}
17246impl From<OptionAliasClauseEmptyGreen> for OptionAliasClauseGreen {
17247 fn from(value: OptionAliasClauseEmptyGreen) -> Self {
17248 Self(value.0)
17249 }
17250}
17251impl From<AliasClauseGreen> for OptionAliasClauseGreen {
17252 fn from(value: AliasClauseGreen) -> Self {
17253 Self(value.0)
17254 }
17255}
17256#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17257pub struct OptionAliasClauseGreen(pub GreenId);
17258impl TypedSyntaxNode for OptionAliasClause {
17259 const OPTIONAL_KIND: Option<SyntaxKind> = None;
17260 type StablePtr = OptionAliasClausePtr;
17261 type Green = OptionAliasClauseGreen;
17262 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17263 panic!("No missing variant.");
17264 }
17265 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17266 let kind = node.kind(db);
17267 match kind {
17268 SyntaxKind::OptionAliasClauseEmpty => {
17269 OptionAliasClause::Empty(OptionAliasClauseEmpty::from_syntax_node(db, node))
17270 }
17271 SyntaxKind::AliasClause => {
17272 OptionAliasClause::AliasClause(AliasClause::from_syntax_node(db, node))
17273 }
17274 _ => panic!(
17275 "Unexpected syntax kind {:?} when constructing {}.",
17276 kind, "OptionAliasClause"
17277 ),
17278 }
17279 }
17280 fn as_syntax_node(&self) -> SyntaxNode {
17281 match self {
17282 OptionAliasClause::Empty(x) => x.as_syntax_node(),
17283 OptionAliasClause::AliasClause(x) => x.as_syntax_node(),
17284 }
17285 }
17286 fn stable_ptr(&self) -> Self::StablePtr {
17287 OptionAliasClausePtr(self.as_syntax_node().0.stable_ptr)
17288 }
17289}
17290impl From<&OptionAliasClause> for SyntaxStablePtrId {
17291 fn from(node: &OptionAliasClause) -> Self {
17292 node.stable_ptr().untyped()
17293 }
17294}
17295impl OptionAliasClause {
17296 pub fn is_variant(kind: SyntaxKind) -> bool {
17298 matches!(kind, SyntaxKind::OptionAliasClauseEmpty | SyntaxKind::AliasClause)
17299 }
17300}
17301#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17302pub struct OptionAliasClauseEmpty {
17303 node: SyntaxNode,
17304 children: Arc<[SyntaxNode]>,
17305}
17306impl OptionAliasClauseEmpty {
17307 pub fn new_green(db: &dyn SyntaxGroup) -> OptionAliasClauseEmptyGreen {
17308 let children: Vec<GreenId> = vec![];
17309 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17310 OptionAliasClauseEmptyGreen(
17311 Arc::new(GreenNode {
17312 kind: SyntaxKind::OptionAliasClauseEmpty,
17313 details: GreenNodeDetails::Node { children, width },
17314 })
17315 .intern(db),
17316 )
17317 }
17318}
17319impl OptionAliasClauseEmpty {}
17320#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17321pub struct OptionAliasClauseEmptyPtr(pub SyntaxStablePtrId);
17322impl OptionAliasClauseEmptyPtr {}
17323impl TypedStablePtr for OptionAliasClauseEmptyPtr {
17324 type SyntaxNode = OptionAliasClauseEmpty;
17325 fn untyped(&self) -> SyntaxStablePtrId {
17326 self.0
17327 }
17328 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAliasClauseEmpty {
17329 OptionAliasClauseEmpty::from_syntax_node(db, self.0.lookup(db))
17330 }
17331}
17332impl From<OptionAliasClauseEmptyPtr> for SyntaxStablePtrId {
17333 fn from(ptr: OptionAliasClauseEmptyPtr) -> Self {
17334 ptr.untyped()
17335 }
17336}
17337#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17338pub struct OptionAliasClauseEmptyGreen(pub GreenId);
17339impl TypedSyntaxNode for OptionAliasClauseEmpty {
17340 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionAliasClauseEmpty);
17341 type StablePtr = OptionAliasClauseEmptyPtr;
17342 type Green = OptionAliasClauseEmptyGreen;
17343 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17344 OptionAliasClauseEmptyGreen(
17345 Arc::new(GreenNode {
17346 kind: SyntaxKind::OptionAliasClauseEmpty,
17347 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
17348 })
17349 .intern(db),
17350 )
17351 }
17352 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17353 let kind = node.kind(db);
17354 assert_eq!(
17355 kind,
17356 SyntaxKind::OptionAliasClauseEmpty,
17357 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17358 kind,
17359 SyntaxKind::OptionAliasClauseEmpty
17360 );
17361 let children = db.get_children(node.clone());
17362 Self { node, children }
17363 }
17364 fn as_syntax_node(&self) -> SyntaxNode {
17365 self.node.clone()
17366 }
17367 fn stable_ptr(&self) -> Self::StablePtr {
17368 OptionAliasClauseEmptyPtr(self.node.0.stable_ptr)
17369 }
17370}
17371impl From<&OptionAliasClauseEmpty> for SyntaxStablePtrId {
17372 fn from(node: &OptionAliasClauseEmpty) -> Self {
17373 node.stable_ptr().untyped()
17374 }
17375}
17376#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17377pub enum GenericArg {
17378 Unnamed(GenericArgUnnamed),
17379 Named(GenericArgNamed),
17380}
17381#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17382pub struct GenericArgPtr(pub SyntaxStablePtrId);
17383impl TypedStablePtr for GenericArgPtr {
17384 type SyntaxNode = GenericArg;
17385 fn untyped(&self) -> SyntaxStablePtrId {
17386 self.0
17387 }
17388 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArg {
17389 GenericArg::from_syntax_node(db, self.0.lookup(db))
17390 }
17391}
17392impl From<GenericArgPtr> for SyntaxStablePtrId {
17393 fn from(ptr: GenericArgPtr) -> Self {
17394 ptr.untyped()
17395 }
17396}
17397impl From<GenericArgUnnamedPtr> for GenericArgPtr {
17398 fn from(value: GenericArgUnnamedPtr) -> Self {
17399 Self(value.0)
17400 }
17401}
17402impl From<GenericArgNamedPtr> for GenericArgPtr {
17403 fn from(value: GenericArgNamedPtr) -> Self {
17404 Self(value.0)
17405 }
17406}
17407impl From<GenericArgUnnamedGreen> for GenericArgGreen {
17408 fn from(value: GenericArgUnnamedGreen) -> Self {
17409 Self(value.0)
17410 }
17411}
17412impl From<GenericArgNamedGreen> for GenericArgGreen {
17413 fn from(value: GenericArgNamedGreen) -> Self {
17414 Self(value.0)
17415 }
17416}
17417#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17418pub struct GenericArgGreen(pub GreenId);
17419impl TypedSyntaxNode for GenericArg {
17420 const OPTIONAL_KIND: Option<SyntaxKind> = None;
17421 type StablePtr = GenericArgPtr;
17422 type Green = GenericArgGreen;
17423 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17424 panic!("No missing variant.");
17425 }
17426 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17427 let kind = node.kind(db);
17428 match kind {
17429 SyntaxKind::GenericArgUnnamed => {
17430 GenericArg::Unnamed(GenericArgUnnamed::from_syntax_node(db, node))
17431 }
17432 SyntaxKind::GenericArgNamed => {
17433 GenericArg::Named(GenericArgNamed::from_syntax_node(db, node))
17434 }
17435 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericArg"),
17436 }
17437 }
17438 fn as_syntax_node(&self) -> SyntaxNode {
17439 match self {
17440 GenericArg::Unnamed(x) => x.as_syntax_node(),
17441 GenericArg::Named(x) => x.as_syntax_node(),
17442 }
17443 }
17444 fn stable_ptr(&self) -> Self::StablePtr {
17445 GenericArgPtr(self.as_syntax_node().0.stable_ptr)
17446 }
17447}
17448impl From<&GenericArg> for SyntaxStablePtrId {
17449 fn from(node: &GenericArg) -> Self {
17450 node.stable_ptr().untyped()
17451 }
17452}
17453impl GenericArg {
17454 pub fn is_variant(kind: SyntaxKind) -> bool {
17456 matches!(kind, SyntaxKind::GenericArgUnnamed | SyntaxKind::GenericArgNamed)
17457 }
17458}
17459#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17460pub struct GenericArgNamed {
17461 node: SyntaxNode,
17462 children: Arc<[SyntaxNode]>,
17463}
17464impl GenericArgNamed {
17465 pub const INDEX_NAME: usize = 0;
17466 pub const INDEX_COLON: usize = 1;
17467 pub const INDEX_VALUE: usize = 2;
17468 pub fn new_green(
17469 db: &dyn SyntaxGroup,
17470 name: TerminalIdentifierGreen,
17471 colon: TerminalColonGreen,
17472 value: GenericArgValueGreen,
17473 ) -> GenericArgNamedGreen {
17474 let children: Vec<GreenId> = vec![name.0, colon.0, value.0];
17475 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17476 GenericArgNamedGreen(
17477 Arc::new(GreenNode {
17478 kind: SyntaxKind::GenericArgNamed,
17479 details: GreenNodeDetails::Node { children, width },
17480 })
17481 .intern(db),
17482 )
17483 }
17484}
17485impl GenericArgNamed {
17486 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
17487 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
17488 }
17489 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
17490 TerminalColon::from_syntax_node(db, self.children[1].clone())
17491 }
17492 pub fn value(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
17493 GenericArgValue::from_syntax_node(db, self.children[2].clone())
17494 }
17495}
17496#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17497pub struct GenericArgNamedPtr(pub SyntaxStablePtrId);
17498impl GenericArgNamedPtr {}
17499impl TypedStablePtr for GenericArgNamedPtr {
17500 type SyntaxNode = GenericArgNamed;
17501 fn untyped(&self) -> SyntaxStablePtrId {
17502 self.0
17503 }
17504 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgNamed {
17505 GenericArgNamed::from_syntax_node(db, self.0.lookup(db))
17506 }
17507}
17508impl From<GenericArgNamedPtr> for SyntaxStablePtrId {
17509 fn from(ptr: GenericArgNamedPtr) -> Self {
17510 ptr.untyped()
17511 }
17512}
17513#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17514pub struct GenericArgNamedGreen(pub GreenId);
17515impl TypedSyntaxNode for GenericArgNamed {
17516 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgNamed);
17517 type StablePtr = GenericArgNamedPtr;
17518 type Green = GenericArgNamedGreen;
17519 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17520 GenericArgNamedGreen(
17521 Arc::new(GreenNode {
17522 kind: SyntaxKind::GenericArgNamed,
17523 details: GreenNodeDetails::Node {
17524 children: vec![
17525 TerminalIdentifier::missing(db).0,
17526 TerminalColon::missing(db).0,
17527 GenericArgValue::missing(db).0,
17528 ],
17529 width: TextWidth::default(),
17530 },
17531 })
17532 .intern(db),
17533 )
17534 }
17535 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17536 let kind = node.kind(db);
17537 assert_eq!(
17538 kind,
17539 SyntaxKind::GenericArgNamed,
17540 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17541 kind,
17542 SyntaxKind::GenericArgNamed
17543 );
17544 let children = db.get_children(node.clone());
17545 Self { node, children }
17546 }
17547 fn as_syntax_node(&self) -> SyntaxNode {
17548 self.node.clone()
17549 }
17550 fn stable_ptr(&self) -> Self::StablePtr {
17551 GenericArgNamedPtr(self.node.0.stable_ptr)
17552 }
17553}
17554impl From<&GenericArgNamed> for SyntaxStablePtrId {
17555 fn from(node: &GenericArgNamed) -> Self {
17556 node.stable_ptr().untyped()
17557 }
17558}
17559#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17560pub struct GenericArgUnnamed {
17561 node: SyntaxNode,
17562 children: Arc<[SyntaxNode]>,
17563}
17564impl GenericArgUnnamed {
17565 pub const INDEX_VALUE: usize = 0;
17566 pub fn new_green(db: &dyn SyntaxGroup, value: GenericArgValueGreen) -> GenericArgUnnamedGreen {
17567 let children: Vec<GreenId> = vec![value.0];
17568 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17569 GenericArgUnnamedGreen(
17570 Arc::new(GreenNode {
17571 kind: SyntaxKind::GenericArgUnnamed,
17572 details: GreenNodeDetails::Node { children, width },
17573 })
17574 .intern(db),
17575 )
17576 }
17577}
17578impl GenericArgUnnamed {
17579 pub fn value(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
17580 GenericArgValue::from_syntax_node(db, self.children[0].clone())
17581 }
17582}
17583#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17584pub struct GenericArgUnnamedPtr(pub SyntaxStablePtrId);
17585impl GenericArgUnnamedPtr {}
17586impl TypedStablePtr for GenericArgUnnamedPtr {
17587 type SyntaxNode = GenericArgUnnamed;
17588 fn untyped(&self) -> SyntaxStablePtrId {
17589 self.0
17590 }
17591 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgUnnamed {
17592 GenericArgUnnamed::from_syntax_node(db, self.0.lookup(db))
17593 }
17594}
17595impl From<GenericArgUnnamedPtr> for SyntaxStablePtrId {
17596 fn from(ptr: GenericArgUnnamedPtr) -> Self {
17597 ptr.untyped()
17598 }
17599}
17600#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17601pub struct GenericArgUnnamedGreen(pub GreenId);
17602impl TypedSyntaxNode for GenericArgUnnamed {
17603 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgUnnamed);
17604 type StablePtr = GenericArgUnnamedPtr;
17605 type Green = GenericArgUnnamedGreen;
17606 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17607 GenericArgUnnamedGreen(
17608 Arc::new(GreenNode {
17609 kind: SyntaxKind::GenericArgUnnamed,
17610 details: GreenNodeDetails::Node {
17611 children: vec![GenericArgValue::missing(db).0],
17612 width: TextWidth::default(),
17613 },
17614 })
17615 .intern(db),
17616 )
17617 }
17618 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17619 let kind = node.kind(db);
17620 assert_eq!(
17621 kind,
17622 SyntaxKind::GenericArgUnnamed,
17623 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17624 kind,
17625 SyntaxKind::GenericArgUnnamed
17626 );
17627 let children = db.get_children(node.clone());
17628 Self { node, children }
17629 }
17630 fn as_syntax_node(&self) -> SyntaxNode {
17631 self.node.clone()
17632 }
17633 fn stable_ptr(&self) -> Self::StablePtr {
17634 GenericArgUnnamedPtr(self.node.0.stable_ptr)
17635 }
17636}
17637impl From<&GenericArgUnnamed> for SyntaxStablePtrId {
17638 fn from(node: &GenericArgUnnamed) -> Self {
17639 node.stable_ptr().untyped()
17640 }
17641}
17642#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17643pub enum GenericArgValue {
17644 Expr(GenericArgValueExpr),
17645 Underscore(TerminalUnderscore),
17646}
17647#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17648pub struct GenericArgValuePtr(pub SyntaxStablePtrId);
17649impl TypedStablePtr for GenericArgValuePtr {
17650 type SyntaxNode = GenericArgValue;
17651 fn untyped(&self) -> SyntaxStablePtrId {
17652 self.0
17653 }
17654 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgValue {
17655 GenericArgValue::from_syntax_node(db, self.0.lookup(db))
17656 }
17657}
17658impl From<GenericArgValuePtr> for SyntaxStablePtrId {
17659 fn from(ptr: GenericArgValuePtr) -> Self {
17660 ptr.untyped()
17661 }
17662}
17663impl From<GenericArgValueExprPtr> for GenericArgValuePtr {
17664 fn from(value: GenericArgValueExprPtr) -> Self {
17665 Self(value.0)
17666 }
17667}
17668impl From<TerminalUnderscorePtr> for GenericArgValuePtr {
17669 fn from(value: TerminalUnderscorePtr) -> Self {
17670 Self(value.0)
17671 }
17672}
17673impl From<GenericArgValueExprGreen> for GenericArgValueGreen {
17674 fn from(value: GenericArgValueExprGreen) -> Self {
17675 Self(value.0)
17676 }
17677}
17678impl From<TerminalUnderscoreGreen> for GenericArgValueGreen {
17679 fn from(value: TerminalUnderscoreGreen) -> Self {
17680 Self(value.0)
17681 }
17682}
17683#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17684pub struct GenericArgValueGreen(pub GreenId);
17685impl TypedSyntaxNode for GenericArgValue {
17686 const OPTIONAL_KIND: Option<SyntaxKind> = None;
17687 type StablePtr = GenericArgValuePtr;
17688 type Green = GenericArgValueGreen;
17689 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17690 panic!("No missing variant.");
17691 }
17692 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17693 let kind = node.kind(db);
17694 match kind {
17695 SyntaxKind::GenericArgValueExpr => {
17696 GenericArgValue::Expr(GenericArgValueExpr::from_syntax_node(db, node))
17697 }
17698 SyntaxKind::TerminalUnderscore => {
17699 GenericArgValue::Underscore(TerminalUnderscore::from_syntax_node(db, node))
17700 }
17701 _ => {
17702 panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericArgValue")
17703 }
17704 }
17705 }
17706 fn as_syntax_node(&self) -> SyntaxNode {
17707 match self {
17708 GenericArgValue::Expr(x) => x.as_syntax_node(),
17709 GenericArgValue::Underscore(x) => x.as_syntax_node(),
17710 }
17711 }
17712 fn stable_ptr(&self) -> Self::StablePtr {
17713 GenericArgValuePtr(self.as_syntax_node().0.stable_ptr)
17714 }
17715}
17716impl From<&GenericArgValue> for SyntaxStablePtrId {
17717 fn from(node: &GenericArgValue) -> Self {
17718 node.stable_ptr().untyped()
17719 }
17720}
17721impl GenericArgValue {
17722 pub fn is_variant(kind: SyntaxKind) -> bool {
17724 matches!(kind, SyntaxKind::GenericArgValueExpr | SyntaxKind::TerminalUnderscore)
17725 }
17726}
17727#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17728pub struct GenericArgValueExpr {
17729 node: SyntaxNode,
17730 children: Arc<[SyntaxNode]>,
17731}
17732impl GenericArgValueExpr {
17733 pub const INDEX_EXPR: usize = 0;
17734 pub fn new_green(db: &dyn SyntaxGroup, expr: ExprGreen) -> GenericArgValueExprGreen {
17735 let children: Vec<GreenId> = vec![expr.0];
17736 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17737 GenericArgValueExprGreen(
17738 Arc::new(GreenNode {
17739 kind: SyntaxKind::GenericArgValueExpr,
17740 details: GreenNodeDetails::Node { children, width },
17741 })
17742 .intern(db),
17743 )
17744 }
17745}
17746impl GenericArgValueExpr {
17747 pub fn expr(&self, db: &dyn SyntaxGroup) -> Expr {
17748 Expr::from_syntax_node(db, self.children[0].clone())
17749 }
17750}
17751#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17752pub struct GenericArgValueExprPtr(pub SyntaxStablePtrId);
17753impl GenericArgValueExprPtr {}
17754impl TypedStablePtr for GenericArgValueExprPtr {
17755 type SyntaxNode = GenericArgValueExpr;
17756 fn untyped(&self) -> SyntaxStablePtrId {
17757 self.0
17758 }
17759 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgValueExpr {
17760 GenericArgValueExpr::from_syntax_node(db, self.0.lookup(db))
17761 }
17762}
17763impl From<GenericArgValueExprPtr> for SyntaxStablePtrId {
17764 fn from(ptr: GenericArgValueExprPtr) -> Self {
17765 ptr.untyped()
17766 }
17767}
17768#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17769pub struct GenericArgValueExprGreen(pub GreenId);
17770impl TypedSyntaxNode for GenericArgValueExpr {
17771 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgValueExpr);
17772 type StablePtr = GenericArgValueExprPtr;
17773 type Green = GenericArgValueExprGreen;
17774 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17775 GenericArgValueExprGreen(
17776 Arc::new(GreenNode {
17777 kind: SyntaxKind::GenericArgValueExpr,
17778 details: GreenNodeDetails::Node {
17779 children: vec![Expr::missing(db).0],
17780 width: TextWidth::default(),
17781 },
17782 })
17783 .intern(db),
17784 )
17785 }
17786 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17787 let kind = node.kind(db);
17788 assert_eq!(
17789 kind,
17790 SyntaxKind::GenericArgValueExpr,
17791 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17792 kind,
17793 SyntaxKind::GenericArgValueExpr
17794 );
17795 let children = db.get_children(node.clone());
17796 Self { node, children }
17797 }
17798 fn as_syntax_node(&self) -> SyntaxNode {
17799 self.node.clone()
17800 }
17801 fn stable_ptr(&self) -> Self::StablePtr {
17802 GenericArgValueExprPtr(self.node.0.stable_ptr)
17803 }
17804}
17805impl From<&GenericArgValueExpr> for SyntaxStablePtrId {
17806 fn from(node: &GenericArgValueExpr) -> Self {
17807 node.stable_ptr().untyped()
17808 }
17809}
17810#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17811pub struct GenericArgs {
17812 node: SyntaxNode,
17813 children: Arc<[SyntaxNode]>,
17814}
17815impl GenericArgs {
17816 pub const INDEX_LANGLE: usize = 0;
17817 pub const INDEX_GENERIC_ARGS: usize = 1;
17818 pub const INDEX_RANGLE: usize = 2;
17819 pub fn new_green(
17820 db: &dyn SyntaxGroup,
17821 langle: TerminalLTGreen,
17822 generic_args: GenericArgListGreen,
17823 rangle: TerminalGTGreen,
17824 ) -> GenericArgsGreen {
17825 let children: Vec<GreenId> = vec![langle.0, generic_args.0, rangle.0];
17826 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
17827 GenericArgsGreen(
17828 Arc::new(GreenNode {
17829 kind: SyntaxKind::GenericArgs,
17830 details: GreenNodeDetails::Node { children, width },
17831 })
17832 .intern(db),
17833 )
17834 }
17835}
17836impl GenericArgs {
17837 pub fn langle(&self, db: &dyn SyntaxGroup) -> TerminalLT {
17838 TerminalLT::from_syntax_node(db, self.children[0].clone())
17839 }
17840 pub fn generic_args(&self, db: &dyn SyntaxGroup) -> GenericArgList {
17841 GenericArgList::from_syntax_node(db, self.children[1].clone())
17842 }
17843 pub fn rangle(&self, db: &dyn SyntaxGroup) -> TerminalGT {
17844 TerminalGT::from_syntax_node(db, self.children[2].clone())
17845 }
17846}
17847#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17848pub struct GenericArgsPtr(pub SyntaxStablePtrId);
17849impl GenericArgsPtr {}
17850impl TypedStablePtr for GenericArgsPtr {
17851 type SyntaxNode = GenericArgs;
17852 fn untyped(&self) -> SyntaxStablePtrId {
17853 self.0
17854 }
17855 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgs {
17856 GenericArgs::from_syntax_node(db, self.0.lookup(db))
17857 }
17858}
17859impl From<GenericArgsPtr> for SyntaxStablePtrId {
17860 fn from(ptr: GenericArgsPtr) -> Self {
17861 ptr.untyped()
17862 }
17863}
17864#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17865pub struct GenericArgsGreen(pub GreenId);
17866impl TypedSyntaxNode for GenericArgs {
17867 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgs);
17868 type StablePtr = GenericArgsPtr;
17869 type Green = GenericArgsGreen;
17870 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17871 GenericArgsGreen(
17872 Arc::new(GreenNode {
17873 kind: SyntaxKind::GenericArgs,
17874 details: GreenNodeDetails::Node {
17875 children: vec![
17876 TerminalLT::missing(db).0,
17877 GenericArgList::missing(db).0,
17878 TerminalGT::missing(db).0,
17879 ],
17880 width: TextWidth::default(),
17881 },
17882 })
17883 .intern(db),
17884 )
17885 }
17886 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17887 let kind = node.kind(db);
17888 assert_eq!(
17889 kind,
17890 SyntaxKind::GenericArgs,
17891 "Unexpected SyntaxKind {:?}. Expected {:?}.",
17892 kind,
17893 SyntaxKind::GenericArgs
17894 );
17895 let children = db.get_children(node.clone());
17896 Self { node, children }
17897 }
17898 fn as_syntax_node(&self) -> SyntaxNode {
17899 self.node.clone()
17900 }
17901 fn stable_ptr(&self) -> Self::StablePtr {
17902 GenericArgsPtr(self.node.0.stable_ptr)
17903 }
17904}
17905impl From<&GenericArgs> for SyntaxStablePtrId {
17906 fn from(node: &GenericArgs) -> Self {
17907 node.stable_ptr().untyped()
17908 }
17909}
17910#[derive(Clone, Debug, Eq, Hash, PartialEq)]
17911pub struct GenericArgList(ElementList<GenericArg, 2>);
17912impl Deref for GenericArgList {
17913 type Target = ElementList<GenericArg, 2>;
17914 fn deref(&self) -> &Self::Target {
17915 &self.0
17916 }
17917}
17918impl GenericArgList {
17919 pub fn new_green(
17920 db: &dyn SyntaxGroup,
17921 children: Vec<GenericArgListElementOrSeparatorGreen>,
17922 ) -> GenericArgListGreen {
17923 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
17924 GenericArgListGreen(
17925 Arc::new(GreenNode {
17926 kind: SyntaxKind::GenericArgList,
17927 details: GreenNodeDetails::Node {
17928 children: children.iter().map(|x| x.id()).collect(),
17929 width,
17930 },
17931 })
17932 .intern(db),
17933 )
17934 }
17935}
17936#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17937pub struct GenericArgListPtr(pub SyntaxStablePtrId);
17938impl TypedStablePtr for GenericArgListPtr {
17939 type SyntaxNode = GenericArgList;
17940 fn untyped(&self) -> SyntaxStablePtrId {
17941 self.0
17942 }
17943 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericArgList {
17944 GenericArgList::from_syntax_node(db, self.0.lookup(db))
17945 }
17946}
17947impl From<GenericArgListPtr> for SyntaxStablePtrId {
17948 fn from(ptr: GenericArgListPtr) -> Self {
17949 ptr.untyped()
17950 }
17951}
17952#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17953pub enum GenericArgListElementOrSeparatorGreen {
17954 Separator(TerminalCommaGreen),
17955 Element(GenericArgGreen),
17956}
17957impl From<TerminalCommaGreen> for GenericArgListElementOrSeparatorGreen {
17958 fn from(value: TerminalCommaGreen) -> Self {
17959 GenericArgListElementOrSeparatorGreen::Separator(value)
17960 }
17961}
17962impl From<GenericArgGreen> for GenericArgListElementOrSeparatorGreen {
17963 fn from(value: GenericArgGreen) -> Self {
17964 GenericArgListElementOrSeparatorGreen::Element(value)
17965 }
17966}
17967impl GenericArgListElementOrSeparatorGreen {
17968 fn id(&self) -> GreenId {
17969 match self {
17970 GenericArgListElementOrSeparatorGreen::Separator(green) => green.0,
17971 GenericArgListElementOrSeparatorGreen::Element(green) => green.0,
17972 }
17973 }
17974}
17975#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
17976pub struct GenericArgListGreen(pub GreenId);
17977impl TypedSyntaxNode for GenericArgList {
17978 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericArgList);
17979 type StablePtr = GenericArgListPtr;
17980 type Green = GenericArgListGreen;
17981 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
17982 GenericArgListGreen(
17983 Arc::new(GreenNode {
17984 kind: SyntaxKind::GenericArgList,
17985 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
17986 })
17987 .intern(db),
17988 )
17989 }
17990 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
17991 Self(ElementList::new(node))
17992 }
17993 fn as_syntax_node(&self) -> SyntaxNode {
17994 self.node.clone()
17995 }
17996 fn stable_ptr(&self) -> Self::StablePtr {
17997 GenericArgListPtr(self.node.0.stable_ptr)
17998 }
17999}
18000impl From<&GenericArgList> for SyntaxStablePtrId {
18001 fn from(node: &GenericArgList) -> Self {
18002 node.stable_ptr().untyped()
18003 }
18004}
18005#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18006pub struct AssociatedItemConstraint {
18007 node: SyntaxNode,
18008 children: Arc<[SyntaxNode]>,
18009}
18010impl AssociatedItemConstraint {
18011 pub const INDEX_ITEM: usize = 0;
18012 pub const INDEX_COLON: usize = 1;
18013 pub const INDEX_VALUE: usize = 2;
18014 pub fn new_green(
18015 db: &dyn SyntaxGroup,
18016 item: TerminalIdentifierGreen,
18017 colon: TerminalColonGreen,
18018 value: ExprGreen,
18019 ) -> AssociatedItemConstraintGreen {
18020 let children: Vec<GreenId> = vec![item.0, colon.0, value.0];
18021 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18022 AssociatedItemConstraintGreen(
18023 Arc::new(GreenNode {
18024 kind: SyntaxKind::AssociatedItemConstraint,
18025 details: GreenNodeDetails::Node { children, width },
18026 })
18027 .intern(db),
18028 )
18029 }
18030}
18031impl AssociatedItemConstraint {
18032 pub fn item(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
18033 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
18034 }
18035 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
18036 TerminalColon::from_syntax_node(db, self.children[1].clone())
18037 }
18038 pub fn value(&self, db: &dyn SyntaxGroup) -> Expr {
18039 Expr::from_syntax_node(db, self.children[2].clone())
18040 }
18041}
18042#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18043pub struct AssociatedItemConstraintPtr(pub SyntaxStablePtrId);
18044impl AssociatedItemConstraintPtr {}
18045impl TypedStablePtr for AssociatedItemConstraintPtr {
18046 type SyntaxNode = AssociatedItemConstraint;
18047 fn untyped(&self) -> SyntaxStablePtrId {
18048 self.0
18049 }
18050 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraint {
18051 AssociatedItemConstraint::from_syntax_node(db, self.0.lookup(db))
18052 }
18053}
18054impl From<AssociatedItemConstraintPtr> for SyntaxStablePtrId {
18055 fn from(ptr: AssociatedItemConstraintPtr) -> Self {
18056 ptr.untyped()
18057 }
18058}
18059#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18060pub struct AssociatedItemConstraintGreen(pub GreenId);
18061impl TypedSyntaxNode for AssociatedItemConstraint {
18062 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraint);
18063 type StablePtr = AssociatedItemConstraintPtr;
18064 type Green = AssociatedItemConstraintGreen;
18065 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18066 AssociatedItemConstraintGreen(
18067 Arc::new(GreenNode {
18068 kind: SyntaxKind::AssociatedItemConstraint,
18069 details: GreenNodeDetails::Node {
18070 children: vec![
18071 TerminalIdentifier::missing(db).0,
18072 TerminalColon::missing(db).0,
18073 Expr::missing(db).0,
18074 ],
18075 width: TextWidth::default(),
18076 },
18077 })
18078 .intern(db),
18079 )
18080 }
18081 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18082 let kind = node.kind(db);
18083 assert_eq!(
18084 kind,
18085 SyntaxKind::AssociatedItemConstraint,
18086 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18087 kind,
18088 SyntaxKind::AssociatedItemConstraint
18089 );
18090 let children = db.get_children(node.clone());
18091 Self { node, children }
18092 }
18093 fn as_syntax_node(&self) -> SyntaxNode {
18094 self.node.clone()
18095 }
18096 fn stable_ptr(&self) -> Self::StablePtr {
18097 AssociatedItemConstraintPtr(self.node.0.stable_ptr)
18098 }
18099}
18100impl From<&AssociatedItemConstraint> for SyntaxStablePtrId {
18101 fn from(node: &AssociatedItemConstraint) -> Self {
18102 node.stable_ptr().untyped()
18103 }
18104}
18105#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18106pub struct AssociatedItemConstraints {
18107 node: SyntaxNode,
18108 children: Arc<[SyntaxNode]>,
18109}
18110impl AssociatedItemConstraints {
18111 pub const INDEX_LBRACK: usize = 0;
18112 pub const INDEX_ASSOCIATED_ITEM_CONSTRAINTS: usize = 1;
18113 pub const INDEX_RBRACK: usize = 2;
18114 pub fn new_green(
18115 db: &dyn SyntaxGroup,
18116 lbrack: TerminalLBrackGreen,
18117 associated_item_constraints: AssociatedItemConstraintListGreen,
18118 rbrack: TerminalRBrackGreen,
18119 ) -> AssociatedItemConstraintsGreen {
18120 let children: Vec<GreenId> = vec![lbrack.0, associated_item_constraints.0, rbrack.0];
18121 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18122 AssociatedItemConstraintsGreen(
18123 Arc::new(GreenNode {
18124 kind: SyntaxKind::AssociatedItemConstraints,
18125 details: GreenNodeDetails::Node { children, width },
18126 })
18127 .intern(db),
18128 )
18129 }
18130}
18131impl AssociatedItemConstraints {
18132 pub fn lbrack(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
18133 TerminalLBrack::from_syntax_node(db, self.children[0].clone())
18134 }
18135 pub fn associated_item_constraints(
18136 &self,
18137 db: &dyn SyntaxGroup,
18138 ) -> AssociatedItemConstraintList {
18139 AssociatedItemConstraintList::from_syntax_node(db, self.children[1].clone())
18140 }
18141 pub fn rbrack(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
18142 TerminalRBrack::from_syntax_node(db, self.children[2].clone())
18143 }
18144}
18145#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18146pub struct AssociatedItemConstraintsPtr(pub SyntaxStablePtrId);
18147impl AssociatedItemConstraintsPtr {}
18148impl TypedStablePtr for AssociatedItemConstraintsPtr {
18149 type SyntaxNode = AssociatedItemConstraints;
18150 fn untyped(&self) -> SyntaxStablePtrId {
18151 self.0
18152 }
18153 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraints {
18154 AssociatedItemConstraints::from_syntax_node(db, self.0.lookup(db))
18155 }
18156}
18157impl From<AssociatedItemConstraintsPtr> for SyntaxStablePtrId {
18158 fn from(ptr: AssociatedItemConstraintsPtr) -> Self {
18159 ptr.untyped()
18160 }
18161}
18162#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18163pub struct AssociatedItemConstraintsGreen(pub GreenId);
18164impl TypedSyntaxNode for AssociatedItemConstraints {
18165 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraints);
18166 type StablePtr = AssociatedItemConstraintsPtr;
18167 type Green = AssociatedItemConstraintsGreen;
18168 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18169 AssociatedItemConstraintsGreen(
18170 Arc::new(GreenNode {
18171 kind: SyntaxKind::AssociatedItemConstraints,
18172 details: GreenNodeDetails::Node {
18173 children: vec![
18174 TerminalLBrack::missing(db).0,
18175 AssociatedItemConstraintList::missing(db).0,
18176 TerminalRBrack::missing(db).0,
18177 ],
18178 width: TextWidth::default(),
18179 },
18180 })
18181 .intern(db),
18182 )
18183 }
18184 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18185 let kind = node.kind(db);
18186 assert_eq!(
18187 kind,
18188 SyntaxKind::AssociatedItemConstraints,
18189 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18190 kind,
18191 SyntaxKind::AssociatedItemConstraints
18192 );
18193 let children = db.get_children(node.clone());
18194 Self { node, children }
18195 }
18196 fn as_syntax_node(&self) -> SyntaxNode {
18197 self.node.clone()
18198 }
18199 fn stable_ptr(&self) -> Self::StablePtr {
18200 AssociatedItemConstraintsPtr(self.node.0.stable_ptr)
18201 }
18202}
18203impl From<&AssociatedItemConstraints> for SyntaxStablePtrId {
18204 fn from(node: &AssociatedItemConstraints) -> Self {
18205 node.stable_ptr().untyped()
18206 }
18207}
18208#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18209pub struct AssociatedItemConstraintList(ElementList<AssociatedItemConstraint, 2>);
18210impl Deref for AssociatedItemConstraintList {
18211 type Target = ElementList<AssociatedItemConstraint, 2>;
18212 fn deref(&self) -> &Self::Target {
18213 &self.0
18214 }
18215}
18216impl AssociatedItemConstraintList {
18217 pub fn new_green(
18218 db: &dyn SyntaxGroup,
18219 children: Vec<AssociatedItemConstraintListElementOrSeparatorGreen>,
18220 ) -> AssociatedItemConstraintListGreen {
18221 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
18222 AssociatedItemConstraintListGreen(
18223 Arc::new(GreenNode {
18224 kind: SyntaxKind::AssociatedItemConstraintList,
18225 details: GreenNodeDetails::Node {
18226 children: children.iter().map(|x| x.id()).collect(),
18227 width,
18228 },
18229 })
18230 .intern(db),
18231 )
18232 }
18233}
18234#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18235pub struct AssociatedItemConstraintListPtr(pub SyntaxStablePtrId);
18236impl TypedStablePtr for AssociatedItemConstraintListPtr {
18237 type SyntaxNode = AssociatedItemConstraintList;
18238 fn untyped(&self) -> SyntaxStablePtrId {
18239 self.0
18240 }
18241 fn lookup(&self, db: &dyn SyntaxGroup) -> AssociatedItemConstraintList {
18242 AssociatedItemConstraintList::from_syntax_node(db, self.0.lookup(db))
18243 }
18244}
18245impl From<AssociatedItemConstraintListPtr> for SyntaxStablePtrId {
18246 fn from(ptr: AssociatedItemConstraintListPtr) -> Self {
18247 ptr.untyped()
18248 }
18249}
18250#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18251pub enum AssociatedItemConstraintListElementOrSeparatorGreen {
18252 Separator(TerminalCommaGreen),
18253 Element(AssociatedItemConstraintGreen),
18254}
18255impl From<TerminalCommaGreen> for AssociatedItemConstraintListElementOrSeparatorGreen {
18256 fn from(value: TerminalCommaGreen) -> Self {
18257 AssociatedItemConstraintListElementOrSeparatorGreen::Separator(value)
18258 }
18259}
18260impl From<AssociatedItemConstraintGreen> for AssociatedItemConstraintListElementOrSeparatorGreen {
18261 fn from(value: AssociatedItemConstraintGreen) -> Self {
18262 AssociatedItemConstraintListElementOrSeparatorGreen::Element(value)
18263 }
18264}
18265impl AssociatedItemConstraintListElementOrSeparatorGreen {
18266 fn id(&self) -> GreenId {
18267 match self {
18268 AssociatedItemConstraintListElementOrSeparatorGreen::Separator(green) => green.0,
18269 AssociatedItemConstraintListElementOrSeparatorGreen::Element(green) => green.0,
18270 }
18271 }
18272}
18273#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18274pub struct AssociatedItemConstraintListGreen(pub GreenId);
18275impl TypedSyntaxNode for AssociatedItemConstraintList {
18276 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::AssociatedItemConstraintList);
18277 type StablePtr = AssociatedItemConstraintListPtr;
18278 type Green = AssociatedItemConstraintListGreen;
18279 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18280 AssociatedItemConstraintListGreen(
18281 Arc::new(GreenNode {
18282 kind: SyntaxKind::AssociatedItemConstraintList,
18283 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18284 })
18285 .intern(db),
18286 )
18287 }
18288 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18289 Self(ElementList::new(node))
18290 }
18291 fn as_syntax_node(&self) -> SyntaxNode {
18292 self.node.clone()
18293 }
18294 fn stable_ptr(&self) -> Self::StablePtr {
18295 AssociatedItemConstraintListPtr(self.node.0.stable_ptr)
18296 }
18297}
18298impl From<&AssociatedItemConstraintList> for SyntaxStablePtrId {
18299 fn from(node: &AssociatedItemConstraintList) -> Self {
18300 node.stable_ptr().untyped()
18301 }
18302}
18303#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18304pub enum OptionAssociatedItemConstraints {
18305 Empty(OptionAssociatedItemConstraintsEmpty),
18306 AssociatedItemConstraints(AssociatedItemConstraints),
18307}
18308#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18309pub struct OptionAssociatedItemConstraintsPtr(pub SyntaxStablePtrId);
18310impl TypedStablePtr for OptionAssociatedItemConstraintsPtr {
18311 type SyntaxNode = OptionAssociatedItemConstraints;
18312 fn untyped(&self) -> SyntaxStablePtrId {
18313 self.0
18314 }
18315 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
18316 OptionAssociatedItemConstraints::from_syntax_node(db, self.0.lookup(db))
18317 }
18318}
18319impl From<OptionAssociatedItemConstraintsPtr> for SyntaxStablePtrId {
18320 fn from(ptr: OptionAssociatedItemConstraintsPtr) -> Self {
18321 ptr.untyped()
18322 }
18323}
18324impl From<OptionAssociatedItemConstraintsEmptyPtr> for OptionAssociatedItemConstraintsPtr {
18325 fn from(value: OptionAssociatedItemConstraintsEmptyPtr) -> Self {
18326 Self(value.0)
18327 }
18328}
18329impl From<AssociatedItemConstraintsPtr> for OptionAssociatedItemConstraintsPtr {
18330 fn from(value: AssociatedItemConstraintsPtr) -> Self {
18331 Self(value.0)
18332 }
18333}
18334impl From<OptionAssociatedItemConstraintsEmptyGreen> for OptionAssociatedItemConstraintsGreen {
18335 fn from(value: OptionAssociatedItemConstraintsEmptyGreen) -> Self {
18336 Self(value.0)
18337 }
18338}
18339impl From<AssociatedItemConstraintsGreen> for OptionAssociatedItemConstraintsGreen {
18340 fn from(value: AssociatedItemConstraintsGreen) -> Self {
18341 Self(value.0)
18342 }
18343}
18344#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18345pub struct OptionAssociatedItemConstraintsGreen(pub GreenId);
18346impl TypedSyntaxNode for OptionAssociatedItemConstraints {
18347 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18348 type StablePtr = OptionAssociatedItemConstraintsPtr;
18349 type Green = OptionAssociatedItemConstraintsGreen;
18350 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18351 panic!("No missing variant.");
18352 }
18353 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18354 let kind = node.kind(db);
18355 match kind {
18356 SyntaxKind::OptionAssociatedItemConstraintsEmpty => {
18357 OptionAssociatedItemConstraints::Empty(
18358 OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, node),
18359 )
18360 }
18361 SyntaxKind::AssociatedItemConstraints => {
18362 OptionAssociatedItemConstraints::AssociatedItemConstraints(
18363 AssociatedItemConstraints::from_syntax_node(db, node),
18364 )
18365 }
18366 _ => panic!(
18367 "Unexpected syntax kind {:?} when constructing {}.",
18368 kind, "OptionAssociatedItemConstraints"
18369 ),
18370 }
18371 }
18372 fn as_syntax_node(&self) -> SyntaxNode {
18373 match self {
18374 OptionAssociatedItemConstraints::Empty(x) => x.as_syntax_node(),
18375 OptionAssociatedItemConstraints::AssociatedItemConstraints(x) => x.as_syntax_node(),
18376 }
18377 }
18378 fn stable_ptr(&self) -> Self::StablePtr {
18379 OptionAssociatedItemConstraintsPtr(self.as_syntax_node().0.stable_ptr)
18380 }
18381}
18382impl From<&OptionAssociatedItemConstraints> for SyntaxStablePtrId {
18383 fn from(node: &OptionAssociatedItemConstraints) -> Self {
18384 node.stable_ptr().untyped()
18385 }
18386}
18387impl OptionAssociatedItemConstraints {
18388 pub fn is_variant(kind: SyntaxKind) -> bool {
18390 matches!(
18391 kind,
18392 SyntaxKind::OptionAssociatedItemConstraintsEmpty
18393 | SyntaxKind::AssociatedItemConstraints
18394 )
18395 }
18396}
18397#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18398pub struct OptionAssociatedItemConstraintsEmpty {
18399 node: SyntaxNode,
18400 children: Arc<[SyntaxNode]>,
18401}
18402impl OptionAssociatedItemConstraintsEmpty {
18403 pub fn new_green(db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraintsEmptyGreen {
18404 let children: Vec<GreenId> = vec![];
18405 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18406 OptionAssociatedItemConstraintsEmptyGreen(
18407 Arc::new(GreenNode {
18408 kind: SyntaxKind::OptionAssociatedItemConstraintsEmpty,
18409 details: GreenNodeDetails::Node { children, width },
18410 })
18411 .intern(db),
18412 )
18413 }
18414}
18415impl OptionAssociatedItemConstraintsEmpty {}
18416#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18417pub struct OptionAssociatedItemConstraintsEmptyPtr(pub SyntaxStablePtrId);
18418impl OptionAssociatedItemConstraintsEmptyPtr {}
18419impl TypedStablePtr for OptionAssociatedItemConstraintsEmptyPtr {
18420 type SyntaxNode = OptionAssociatedItemConstraintsEmpty;
18421 fn untyped(&self) -> SyntaxStablePtrId {
18422 self.0
18423 }
18424 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraintsEmpty {
18425 OptionAssociatedItemConstraintsEmpty::from_syntax_node(db, self.0.lookup(db))
18426 }
18427}
18428impl From<OptionAssociatedItemConstraintsEmptyPtr> for SyntaxStablePtrId {
18429 fn from(ptr: OptionAssociatedItemConstraintsEmptyPtr) -> Self {
18430 ptr.untyped()
18431 }
18432}
18433#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18434pub struct OptionAssociatedItemConstraintsEmptyGreen(pub GreenId);
18435impl TypedSyntaxNode for OptionAssociatedItemConstraintsEmpty {
18436 const OPTIONAL_KIND: Option<SyntaxKind> =
18437 Some(SyntaxKind::OptionAssociatedItemConstraintsEmpty);
18438 type StablePtr = OptionAssociatedItemConstraintsEmptyPtr;
18439 type Green = OptionAssociatedItemConstraintsEmptyGreen;
18440 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18441 OptionAssociatedItemConstraintsEmptyGreen(
18442 Arc::new(GreenNode {
18443 kind: SyntaxKind::OptionAssociatedItemConstraintsEmpty,
18444 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18445 })
18446 .intern(db),
18447 )
18448 }
18449 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18450 let kind = node.kind(db);
18451 assert_eq!(
18452 kind,
18453 SyntaxKind::OptionAssociatedItemConstraintsEmpty,
18454 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18455 kind,
18456 SyntaxKind::OptionAssociatedItemConstraintsEmpty
18457 );
18458 let children = db.get_children(node.clone());
18459 Self { node, children }
18460 }
18461 fn as_syntax_node(&self) -> SyntaxNode {
18462 self.node.clone()
18463 }
18464 fn stable_ptr(&self) -> Self::StablePtr {
18465 OptionAssociatedItemConstraintsEmptyPtr(self.node.0.stable_ptr)
18466 }
18467}
18468impl From<&OptionAssociatedItemConstraintsEmpty> for SyntaxStablePtrId {
18469 fn from(node: &OptionAssociatedItemConstraintsEmpty) -> Self {
18470 node.stable_ptr().untyped()
18471 }
18472}
18473#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18474pub enum OptionWrappedGenericParamList {
18475 Empty(OptionWrappedGenericParamListEmpty),
18476 WrappedGenericParamList(WrappedGenericParamList),
18477}
18478#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18479pub struct OptionWrappedGenericParamListPtr(pub SyntaxStablePtrId);
18480impl TypedStablePtr for OptionWrappedGenericParamListPtr {
18481 type SyntaxNode = OptionWrappedGenericParamList;
18482 fn untyped(&self) -> SyntaxStablePtrId {
18483 self.0
18484 }
18485 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamList {
18486 OptionWrappedGenericParamList::from_syntax_node(db, self.0.lookup(db))
18487 }
18488}
18489impl From<OptionWrappedGenericParamListPtr> for SyntaxStablePtrId {
18490 fn from(ptr: OptionWrappedGenericParamListPtr) -> Self {
18491 ptr.untyped()
18492 }
18493}
18494impl From<OptionWrappedGenericParamListEmptyPtr> for OptionWrappedGenericParamListPtr {
18495 fn from(value: OptionWrappedGenericParamListEmptyPtr) -> Self {
18496 Self(value.0)
18497 }
18498}
18499impl From<WrappedGenericParamListPtr> for OptionWrappedGenericParamListPtr {
18500 fn from(value: WrappedGenericParamListPtr) -> Self {
18501 Self(value.0)
18502 }
18503}
18504impl From<OptionWrappedGenericParamListEmptyGreen> for OptionWrappedGenericParamListGreen {
18505 fn from(value: OptionWrappedGenericParamListEmptyGreen) -> Self {
18506 Self(value.0)
18507 }
18508}
18509impl From<WrappedGenericParamListGreen> for OptionWrappedGenericParamListGreen {
18510 fn from(value: WrappedGenericParamListGreen) -> Self {
18511 Self(value.0)
18512 }
18513}
18514#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18515pub struct OptionWrappedGenericParamListGreen(pub GreenId);
18516impl TypedSyntaxNode for OptionWrappedGenericParamList {
18517 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18518 type StablePtr = OptionWrappedGenericParamListPtr;
18519 type Green = OptionWrappedGenericParamListGreen;
18520 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18521 panic!("No missing variant.");
18522 }
18523 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18524 let kind = node.kind(db);
18525 match kind {
18526 SyntaxKind::OptionWrappedGenericParamListEmpty => OptionWrappedGenericParamList::Empty(
18527 OptionWrappedGenericParamListEmpty::from_syntax_node(db, node),
18528 ),
18529 SyntaxKind::WrappedGenericParamList => {
18530 OptionWrappedGenericParamList::WrappedGenericParamList(
18531 WrappedGenericParamList::from_syntax_node(db, node),
18532 )
18533 }
18534 _ => panic!(
18535 "Unexpected syntax kind {:?} when constructing {}.",
18536 kind, "OptionWrappedGenericParamList"
18537 ),
18538 }
18539 }
18540 fn as_syntax_node(&self) -> SyntaxNode {
18541 match self {
18542 OptionWrappedGenericParamList::Empty(x) => x.as_syntax_node(),
18543 OptionWrappedGenericParamList::WrappedGenericParamList(x) => x.as_syntax_node(),
18544 }
18545 }
18546 fn stable_ptr(&self) -> Self::StablePtr {
18547 OptionWrappedGenericParamListPtr(self.as_syntax_node().0.stable_ptr)
18548 }
18549}
18550impl From<&OptionWrappedGenericParamList> for SyntaxStablePtrId {
18551 fn from(node: &OptionWrappedGenericParamList) -> Self {
18552 node.stable_ptr().untyped()
18553 }
18554}
18555impl OptionWrappedGenericParamList {
18556 pub fn is_variant(kind: SyntaxKind) -> bool {
18558 matches!(
18559 kind,
18560 SyntaxKind::OptionWrappedGenericParamListEmpty | SyntaxKind::WrappedGenericParamList
18561 )
18562 }
18563}
18564#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18565pub struct OptionWrappedGenericParamListEmpty {
18566 node: SyntaxNode,
18567 children: Arc<[SyntaxNode]>,
18568}
18569impl OptionWrappedGenericParamListEmpty {
18570 pub fn new_green(db: &dyn SyntaxGroup) -> OptionWrappedGenericParamListEmptyGreen {
18571 let children: Vec<GreenId> = vec![];
18572 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18573 OptionWrappedGenericParamListEmptyGreen(
18574 Arc::new(GreenNode {
18575 kind: SyntaxKind::OptionWrappedGenericParamListEmpty,
18576 details: GreenNodeDetails::Node { children, width },
18577 })
18578 .intern(db),
18579 )
18580 }
18581}
18582impl OptionWrappedGenericParamListEmpty {}
18583#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18584pub struct OptionWrappedGenericParamListEmptyPtr(pub SyntaxStablePtrId);
18585impl OptionWrappedGenericParamListEmptyPtr {}
18586impl TypedStablePtr for OptionWrappedGenericParamListEmptyPtr {
18587 type SyntaxNode = OptionWrappedGenericParamListEmpty;
18588 fn untyped(&self) -> SyntaxStablePtrId {
18589 self.0
18590 }
18591 fn lookup(&self, db: &dyn SyntaxGroup) -> OptionWrappedGenericParamListEmpty {
18592 OptionWrappedGenericParamListEmpty::from_syntax_node(db, self.0.lookup(db))
18593 }
18594}
18595impl From<OptionWrappedGenericParamListEmptyPtr> for SyntaxStablePtrId {
18596 fn from(ptr: OptionWrappedGenericParamListEmptyPtr) -> Self {
18597 ptr.untyped()
18598 }
18599}
18600#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18601pub struct OptionWrappedGenericParamListEmptyGreen(pub GreenId);
18602impl TypedSyntaxNode for OptionWrappedGenericParamListEmpty {
18603 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::OptionWrappedGenericParamListEmpty);
18604 type StablePtr = OptionWrappedGenericParamListEmptyPtr;
18605 type Green = OptionWrappedGenericParamListEmptyGreen;
18606 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18607 OptionWrappedGenericParamListEmptyGreen(
18608 Arc::new(GreenNode {
18609 kind: SyntaxKind::OptionWrappedGenericParamListEmpty,
18610 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18611 })
18612 .intern(db),
18613 )
18614 }
18615 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18616 let kind = node.kind(db);
18617 assert_eq!(
18618 kind,
18619 SyntaxKind::OptionWrappedGenericParamListEmpty,
18620 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18621 kind,
18622 SyntaxKind::OptionWrappedGenericParamListEmpty
18623 );
18624 let children = db.get_children(node.clone());
18625 Self { node, children }
18626 }
18627 fn as_syntax_node(&self) -> SyntaxNode {
18628 self.node.clone()
18629 }
18630 fn stable_ptr(&self) -> Self::StablePtr {
18631 OptionWrappedGenericParamListEmptyPtr(self.node.0.stable_ptr)
18632 }
18633}
18634impl From<&OptionWrappedGenericParamListEmpty> for SyntaxStablePtrId {
18635 fn from(node: &OptionWrappedGenericParamListEmpty) -> Self {
18636 node.stable_ptr().untyped()
18637 }
18638}
18639#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18640pub struct WrappedGenericParamList {
18641 node: SyntaxNode,
18642 children: Arc<[SyntaxNode]>,
18643}
18644impl WrappedGenericParamList {
18645 pub const INDEX_LANGLE: usize = 0;
18646 pub const INDEX_GENERIC_PARAMS: usize = 1;
18647 pub const INDEX_RANGLE: usize = 2;
18648 pub fn new_green(
18649 db: &dyn SyntaxGroup,
18650 langle: TerminalLTGreen,
18651 generic_params: GenericParamListGreen,
18652 rangle: TerminalGTGreen,
18653 ) -> WrappedGenericParamListGreen {
18654 let children: Vec<GreenId> = vec![langle.0, generic_params.0, rangle.0];
18655 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18656 WrappedGenericParamListGreen(
18657 Arc::new(GreenNode {
18658 kind: SyntaxKind::WrappedGenericParamList,
18659 details: GreenNodeDetails::Node { children, width },
18660 })
18661 .intern(db),
18662 )
18663 }
18664}
18665impl WrappedGenericParamList {
18666 pub fn langle(&self, db: &dyn SyntaxGroup) -> TerminalLT {
18667 TerminalLT::from_syntax_node(db, self.children[0].clone())
18668 }
18669 pub fn generic_params(&self, db: &dyn SyntaxGroup) -> GenericParamList {
18670 GenericParamList::from_syntax_node(db, self.children[1].clone())
18671 }
18672 pub fn rangle(&self, db: &dyn SyntaxGroup) -> TerminalGT {
18673 TerminalGT::from_syntax_node(db, self.children[2].clone())
18674 }
18675}
18676#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18677pub struct WrappedGenericParamListPtr(pub SyntaxStablePtrId);
18678impl WrappedGenericParamListPtr {}
18679impl TypedStablePtr for WrappedGenericParamListPtr {
18680 type SyntaxNode = WrappedGenericParamList;
18681 fn untyped(&self) -> SyntaxStablePtrId {
18682 self.0
18683 }
18684 fn lookup(&self, db: &dyn SyntaxGroup) -> WrappedGenericParamList {
18685 WrappedGenericParamList::from_syntax_node(db, self.0.lookup(db))
18686 }
18687}
18688impl From<WrappedGenericParamListPtr> for SyntaxStablePtrId {
18689 fn from(ptr: WrappedGenericParamListPtr) -> Self {
18690 ptr.untyped()
18691 }
18692}
18693#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18694pub struct WrappedGenericParamListGreen(pub GreenId);
18695impl TypedSyntaxNode for WrappedGenericParamList {
18696 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::WrappedGenericParamList);
18697 type StablePtr = WrappedGenericParamListPtr;
18698 type Green = WrappedGenericParamListGreen;
18699 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18700 WrappedGenericParamListGreen(
18701 Arc::new(GreenNode {
18702 kind: SyntaxKind::WrappedGenericParamList,
18703 details: GreenNodeDetails::Node {
18704 children: vec![
18705 TerminalLT::missing(db).0,
18706 GenericParamList::missing(db).0,
18707 TerminalGT::missing(db).0,
18708 ],
18709 width: TextWidth::default(),
18710 },
18711 })
18712 .intern(db),
18713 )
18714 }
18715 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18716 let kind = node.kind(db);
18717 assert_eq!(
18718 kind,
18719 SyntaxKind::WrappedGenericParamList,
18720 "Unexpected SyntaxKind {:?}. Expected {:?}.",
18721 kind,
18722 SyntaxKind::WrappedGenericParamList
18723 );
18724 let children = db.get_children(node.clone());
18725 Self { node, children }
18726 }
18727 fn as_syntax_node(&self) -> SyntaxNode {
18728 self.node.clone()
18729 }
18730 fn stable_ptr(&self) -> Self::StablePtr {
18731 WrappedGenericParamListPtr(self.node.0.stable_ptr)
18732 }
18733}
18734impl From<&WrappedGenericParamList> for SyntaxStablePtrId {
18735 fn from(node: &WrappedGenericParamList) -> Self {
18736 node.stable_ptr().untyped()
18737 }
18738}
18739#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18740pub struct GenericParamList(ElementList<GenericParam, 2>);
18741impl Deref for GenericParamList {
18742 type Target = ElementList<GenericParam, 2>;
18743 fn deref(&self) -> &Self::Target {
18744 &self.0
18745 }
18746}
18747impl GenericParamList {
18748 pub fn new_green(
18749 db: &dyn SyntaxGroup,
18750 children: Vec<GenericParamListElementOrSeparatorGreen>,
18751 ) -> GenericParamListGreen {
18752 let width = children.iter().map(|id| id.id().lookup_intern(db).width()).sum();
18753 GenericParamListGreen(
18754 Arc::new(GreenNode {
18755 kind: SyntaxKind::GenericParamList,
18756 details: GreenNodeDetails::Node {
18757 children: children.iter().map(|x| x.id()).collect(),
18758 width,
18759 },
18760 })
18761 .intern(db),
18762 )
18763 }
18764}
18765#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18766pub struct GenericParamListPtr(pub SyntaxStablePtrId);
18767impl TypedStablePtr for GenericParamListPtr {
18768 type SyntaxNode = GenericParamList;
18769 fn untyped(&self) -> SyntaxStablePtrId {
18770 self.0
18771 }
18772 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamList {
18773 GenericParamList::from_syntax_node(db, self.0.lookup(db))
18774 }
18775}
18776impl From<GenericParamListPtr> for SyntaxStablePtrId {
18777 fn from(ptr: GenericParamListPtr) -> Self {
18778 ptr.untyped()
18779 }
18780}
18781#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18782pub enum GenericParamListElementOrSeparatorGreen {
18783 Separator(TerminalCommaGreen),
18784 Element(GenericParamGreen),
18785}
18786impl From<TerminalCommaGreen> for GenericParamListElementOrSeparatorGreen {
18787 fn from(value: TerminalCommaGreen) -> Self {
18788 GenericParamListElementOrSeparatorGreen::Separator(value)
18789 }
18790}
18791impl From<GenericParamGreen> for GenericParamListElementOrSeparatorGreen {
18792 fn from(value: GenericParamGreen) -> Self {
18793 GenericParamListElementOrSeparatorGreen::Element(value)
18794 }
18795}
18796impl GenericParamListElementOrSeparatorGreen {
18797 fn id(&self) -> GreenId {
18798 match self {
18799 GenericParamListElementOrSeparatorGreen::Separator(green) => green.0,
18800 GenericParamListElementOrSeparatorGreen::Element(green) => green.0,
18801 }
18802 }
18803}
18804#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18805pub struct GenericParamListGreen(pub GreenId);
18806impl TypedSyntaxNode for GenericParamList {
18807 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamList);
18808 type StablePtr = GenericParamListPtr;
18809 type Green = GenericParamListGreen;
18810 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18811 GenericParamListGreen(
18812 Arc::new(GreenNode {
18813 kind: SyntaxKind::GenericParamList,
18814 details: GreenNodeDetails::Node { children: vec![], width: TextWidth::default() },
18815 })
18816 .intern(db),
18817 )
18818 }
18819 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18820 Self(ElementList::new(node))
18821 }
18822 fn as_syntax_node(&self) -> SyntaxNode {
18823 self.node.clone()
18824 }
18825 fn stable_ptr(&self) -> Self::StablePtr {
18826 GenericParamListPtr(self.node.0.stable_ptr)
18827 }
18828}
18829impl From<&GenericParamList> for SyntaxStablePtrId {
18830 fn from(node: &GenericParamList) -> Self {
18831 node.stable_ptr().untyped()
18832 }
18833}
18834#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18835pub enum GenericParam {
18836 Type(GenericParamType),
18837 Const(GenericParamConst),
18838 ImplNamed(GenericParamImplNamed),
18839 ImplAnonymous(GenericParamImplAnonymous),
18840 NegativeImpl(GenericParamNegativeImpl),
18841}
18842#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18843pub struct GenericParamPtr(pub SyntaxStablePtrId);
18844impl TypedStablePtr for GenericParamPtr {
18845 type SyntaxNode = GenericParam;
18846 fn untyped(&self) -> SyntaxStablePtrId {
18847 self.0
18848 }
18849 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParam {
18850 GenericParam::from_syntax_node(db, self.0.lookup(db))
18851 }
18852}
18853impl From<GenericParamPtr> for SyntaxStablePtrId {
18854 fn from(ptr: GenericParamPtr) -> Self {
18855 ptr.untyped()
18856 }
18857}
18858impl From<GenericParamTypePtr> for GenericParamPtr {
18859 fn from(value: GenericParamTypePtr) -> Self {
18860 Self(value.0)
18861 }
18862}
18863impl From<GenericParamConstPtr> for GenericParamPtr {
18864 fn from(value: GenericParamConstPtr) -> Self {
18865 Self(value.0)
18866 }
18867}
18868impl From<GenericParamImplNamedPtr> for GenericParamPtr {
18869 fn from(value: GenericParamImplNamedPtr) -> Self {
18870 Self(value.0)
18871 }
18872}
18873impl From<GenericParamImplAnonymousPtr> for GenericParamPtr {
18874 fn from(value: GenericParamImplAnonymousPtr) -> Self {
18875 Self(value.0)
18876 }
18877}
18878impl From<GenericParamNegativeImplPtr> for GenericParamPtr {
18879 fn from(value: GenericParamNegativeImplPtr) -> Self {
18880 Self(value.0)
18881 }
18882}
18883impl From<GenericParamTypeGreen> for GenericParamGreen {
18884 fn from(value: GenericParamTypeGreen) -> Self {
18885 Self(value.0)
18886 }
18887}
18888impl From<GenericParamConstGreen> for GenericParamGreen {
18889 fn from(value: GenericParamConstGreen) -> Self {
18890 Self(value.0)
18891 }
18892}
18893impl From<GenericParamImplNamedGreen> for GenericParamGreen {
18894 fn from(value: GenericParamImplNamedGreen) -> Self {
18895 Self(value.0)
18896 }
18897}
18898impl From<GenericParamImplAnonymousGreen> for GenericParamGreen {
18899 fn from(value: GenericParamImplAnonymousGreen) -> Self {
18900 Self(value.0)
18901 }
18902}
18903impl From<GenericParamNegativeImplGreen> for GenericParamGreen {
18904 fn from(value: GenericParamNegativeImplGreen) -> Self {
18905 Self(value.0)
18906 }
18907}
18908#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18909pub struct GenericParamGreen(pub GreenId);
18910impl TypedSyntaxNode for GenericParam {
18911 const OPTIONAL_KIND: Option<SyntaxKind> = None;
18912 type StablePtr = GenericParamPtr;
18913 type Green = GenericParamGreen;
18914 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
18915 panic!("No missing variant.");
18916 }
18917 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
18918 let kind = node.kind(db);
18919 match kind {
18920 SyntaxKind::GenericParamType => {
18921 GenericParam::Type(GenericParamType::from_syntax_node(db, node))
18922 }
18923 SyntaxKind::GenericParamConst => {
18924 GenericParam::Const(GenericParamConst::from_syntax_node(db, node))
18925 }
18926 SyntaxKind::GenericParamImplNamed => {
18927 GenericParam::ImplNamed(GenericParamImplNamed::from_syntax_node(db, node))
18928 }
18929 SyntaxKind::GenericParamImplAnonymous => {
18930 GenericParam::ImplAnonymous(GenericParamImplAnonymous::from_syntax_node(db, node))
18931 }
18932 SyntaxKind::GenericParamNegativeImpl => {
18933 GenericParam::NegativeImpl(GenericParamNegativeImpl::from_syntax_node(db, node))
18934 }
18935 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "GenericParam"),
18936 }
18937 }
18938 fn as_syntax_node(&self) -> SyntaxNode {
18939 match self {
18940 GenericParam::Type(x) => x.as_syntax_node(),
18941 GenericParam::Const(x) => x.as_syntax_node(),
18942 GenericParam::ImplNamed(x) => x.as_syntax_node(),
18943 GenericParam::ImplAnonymous(x) => x.as_syntax_node(),
18944 GenericParam::NegativeImpl(x) => x.as_syntax_node(),
18945 }
18946 }
18947 fn stable_ptr(&self) -> Self::StablePtr {
18948 GenericParamPtr(self.as_syntax_node().0.stable_ptr)
18949 }
18950}
18951impl From<&GenericParam> for SyntaxStablePtrId {
18952 fn from(node: &GenericParam) -> Self {
18953 node.stable_ptr().untyped()
18954 }
18955}
18956impl GenericParam {
18957 pub fn is_variant(kind: SyntaxKind) -> bool {
18959 matches!(
18960 kind,
18961 SyntaxKind::GenericParamType
18962 | SyntaxKind::GenericParamConst
18963 | SyntaxKind::GenericParamImplNamed
18964 | SyntaxKind::GenericParamImplAnonymous
18965 | SyntaxKind::GenericParamNegativeImpl
18966 )
18967 }
18968}
18969#[derive(Clone, Debug, Eq, Hash, PartialEq)]
18970pub struct GenericParamType {
18971 node: SyntaxNode,
18972 children: Arc<[SyntaxNode]>,
18973}
18974impl GenericParamType {
18975 pub const INDEX_NAME: usize = 0;
18976 pub fn new_green(db: &dyn SyntaxGroup, name: TerminalIdentifierGreen) -> GenericParamTypeGreen {
18977 let children: Vec<GreenId> = vec![name.0];
18978 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
18979 GenericParamTypeGreen(
18980 Arc::new(GreenNode {
18981 kind: SyntaxKind::GenericParamType,
18982 details: GreenNodeDetails::Node { children, width },
18983 })
18984 .intern(db),
18985 )
18986 }
18987}
18988impl GenericParamType {
18989 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
18990 TerminalIdentifier::from_syntax_node(db, self.children[0].clone())
18991 }
18992}
18993#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
18994pub struct GenericParamTypePtr(pub SyntaxStablePtrId);
18995impl GenericParamTypePtr {
18996 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
18997 let ptr = self.0.lookup_intern(db);
18998 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
18999 TerminalIdentifierGreen(key_fields[0])
19000 } else {
19001 panic!("Unexpected key field query on root.");
19002 }
19003 }
19004}
19005impl TypedStablePtr for GenericParamTypePtr {
19006 type SyntaxNode = GenericParamType;
19007 fn untyped(&self) -> SyntaxStablePtrId {
19008 self.0
19009 }
19010 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamType {
19011 GenericParamType::from_syntax_node(db, self.0.lookup(db))
19012 }
19013}
19014impl From<GenericParamTypePtr> for SyntaxStablePtrId {
19015 fn from(ptr: GenericParamTypePtr) -> Self {
19016 ptr.untyped()
19017 }
19018}
19019#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19020pub struct GenericParamTypeGreen(pub GreenId);
19021impl TypedSyntaxNode for GenericParamType {
19022 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamType);
19023 type StablePtr = GenericParamTypePtr;
19024 type Green = GenericParamTypeGreen;
19025 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19026 GenericParamTypeGreen(
19027 Arc::new(GreenNode {
19028 kind: SyntaxKind::GenericParamType,
19029 details: GreenNodeDetails::Node {
19030 children: vec![TerminalIdentifier::missing(db).0],
19031 width: TextWidth::default(),
19032 },
19033 })
19034 .intern(db),
19035 )
19036 }
19037 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19038 let kind = node.kind(db);
19039 assert_eq!(
19040 kind,
19041 SyntaxKind::GenericParamType,
19042 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19043 kind,
19044 SyntaxKind::GenericParamType
19045 );
19046 let children = db.get_children(node.clone());
19047 Self { node, children }
19048 }
19049 fn as_syntax_node(&self) -> SyntaxNode {
19050 self.node.clone()
19051 }
19052 fn stable_ptr(&self) -> Self::StablePtr {
19053 GenericParamTypePtr(self.node.0.stable_ptr)
19054 }
19055}
19056impl From<&GenericParamType> for SyntaxStablePtrId {
19057 fn from(node: &GenericParamType) -> Self {
19058 node.stable_ptr().untyped()
19059 }
19060}
19061#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19062pub struct GenericParamConst {
19063 node: SyntaxNode,
19064 children: Arc<[SyntaxNode]>,
19065}
19066impl GenericParamConst {
19067 pub const INDEX_CONST_KW: usize = 0;
19068 pub const INDEX_NAME: usize = 1;
19069 pub const INDEX_COLON: usize = 2;
19070 pub const INDEX_TY: usize = 3;
19071 pub fn new_green(
19072 db: &dyn SyntaxGroup,
19073 const_kw: TerminalConstGreen,
19074 name: TerminalIdentifierGreen,
19075 colon: TerminalColonGreen,
19076 ty: ExprGreen,
19077 ) -> GenericParamConstGreen {
19078 let children: Vec<GreenId> = vec![const_kw.0, name.0, colon.0, ty.0];
19079 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19080 GenericParamConstGreen(
19081 Arc::new(GreenNode {
19082 kind: SyntaxKind::GenericParamConst,
19083 details: GreenNodeDetails::Node { children, width },
19084 })
19085 .intern(db),
19086 )
19087 }
19088}
19089impl GenericParamConst {
19090 pub fn const_kw(&self, db: &dyn SyntaxGroup) -> TerminalConst {
19091 TerminalConst::from_syntax_node(db, self.children[0].clone())
19092 }
19093 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
19094 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
19095 }
19096 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
19097 TerminalColon::from_syntax_node(db, self.children[2].clone())
19098 }
19099 pub fn ty(&self, db: &dyn SyntaxGroup) -> Expr {
19100 Expr::from_syntax_node(db, self.children[3].clone())
19101 }
19102}
19103#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19104pub struct GenericParamConstPtr(pub SyntaxStablePtrId);
19105impl GenericParamConstPtr {
19106 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
19107 let ptr = self.0.lookup_intern(db);
19108 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
19109 TerminalIdentifierGreen(key_fields[0])
19110 } else {
19111 panic!("Unexpected key field query on root.");
19112 }
19113 }
19114}
19115impl TypedStablePtr for GenericParamConstPtr {
19116 type SyntaxNode = GenericParamConst;
19117 fn untyped(&self) -> SyntaxStablePtrId {
19118 self.0
19119 }
19120 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamConst {
19121 GenericParamConst::from_syntax_node(db, self.0.lookup(db))
19122 }
19123}
19124impl From<GenericParamConstPtr> for SyntaxStablePtrId {
19125 fn from(ptr: GenericParamConstPtr) -> Self {
19126 ptr.untyped()
19127 }
19128}
19129#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19130pub struct GenericParamConstGreen(pub GreenId);
19131impl TypedSyntaxNode for GenericParamConst {
19132 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamConst);
19133 type StablePtr = GenericParamConstPtr;
19134 type Green = GenericParamConstGreen;
19135 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19136 GenericParamConstGreen(
19137 Arc::new(GreenNode {
19138 kind: SyntaxKind::GenericParamConst,
19139 details: GreenNodeDetails::Node {
19140 children: vec![
19141 TerminalConst::missing(db).0,
19142 TerminalIdentifier::missing(db).0,
19143 TerminalColon::missing(db).0,
19144 Expr::missing(db).0,
19145 ],
19146 width: TextWidth::default(),
19147 },
19148 })
19149 .intern(db),
19150 )
19151 }
19152 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19153 let kind = node.kind(db);
19154 assert_eq!(
19155 kind,
19156 SyntaxKind::GenericParamConst,
19157 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19158 kind,
19159 SyntaxKind::GenericParamConst
19160 );
19161 let children = db.get_children(node.clone());
19162 Self { node, children }
19163 }
19164 fn as_syntax_node(&self) -> SyntaxNode {
19165 self.node.clone()
19166 }
19167 fn stable_ptr(&self) -> Self::StablePtr {
19168 GenericParamConstPtr(self.node.0.stable_ptr)
19169 }
19170}
19171impl From<&GenericParamConst> for SyntaxStablePtrId {
19172 fn from(node: &GenericParamConst) -> Self {
19173 node.stable_ptr().untyped()
19174 }
19175}
19176#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19177pub struct GenericParamImplNamed {
19178 node: SyntaxNode,
19179 children: Arc<[SyntaxNode]>,
19180}
19181impl GenericParamImplNamed {
19182 pub const INDEX_IMPL_KW: usize = 0;
19183 pub const INDEX_NAME: usize = 1;
19184 pub const INDEX_COLON: usize = 2;
19185 pub const INDEX_TRAIT_PATH: usize = 3;
19186 pub const INDEX_TYPE_CONSTRAINS: usize = 4;
19187 pub fn new_green(
19188 db: &dyn SyntaxGroup,
19189 impl_kw: TerminalImplGreen,
19190 name: TerminalIdentifierGreen,
19191 colon: TerminalColonGreen,
19192 trait_path: ExprPathGreen,
19193 type_constrains: OptionAssociatedItemConstraintsGreen,
19194 ) -> GenericParamImplNamedGreen {
19195 let children: Vec<GreenId> =
19196 vec![impl_kw.0, name.0, colon.0, trait_path.0, type_constrains.0];
19197 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19198 GenericParamImplNamedGreen(
19199 Arc::new(GreenNode {
19200 kind: SyntaxKind::GenericParamImplNamed,
19201 details: GreenNodeDetails::Node { children, width },
19202 })
19203 .intern(db),
19204 )
19205 }
19206}
19207impl GenericParamImplNamed {
19208 pub fn impl_kw(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
19209 TerminalImpl::from_syntax_node(db, self.children[0].clone())
19210 }
19211 pub fn name(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
19212 TerminalIdentifier::from_syntax_node(db, self.children[1].clone())
19213 }
19214 pub fn colon(&self, db: &dyn SyntaxGroup) -> TerminalColon {
19215 TerminalColon::from_syntax_node(db, self.children[2].clone())
19216 }
19217 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
19218 ExprPath::from_syntax_node(db, self.children[3].clone())
19219 }
19220 pub fn type_constrains(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
19221 OptionAssociatedItemConstraints::from_syntax_node(db, self.children[4].clone())
19222 }
19223}
19224#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19225pub struct GenericParamImplNamedPtr(pub SyntaxStablePtrId);
19226impl GenericParamImplNamedPtr {
19227 pub fn name_green(self, db: &dyn SyntaxGroup) -> TerminalIdentifierGreen {
19228 let ptr = self.0.lookup_intern(db);
19229 if let SyntaxStablePtr::Child { key_fields, .. } = ptr {
19230 TerminalIdentifierGreen(key_fields[0])
19231 } else {
19232 panic!("Unexpected key field query on root.");
19233 }
19234 }
19235}
19236impl TypedStablePtr for GenericParamImplNamedPtr {
19237 type SyntaxNode = GenericParamImplNamed;
19238 fn untyped(&self) -> SyntaxStablePtrId {
19239 self.0
19240 }
19241 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamImplNamed {
19242 GenericParamImplNamed::from_syntax_node(db, self.0.lookup(db))
19243 }
19244}
19245impl From<GenericParamImplNamedPtr> for SyntaxStablePtrId {
19246 fn from(ptr: GenericParamImplNamedPtr) -> Self {
19247 ptr.untyped()
19248 }
19249}
19250#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19251pub struct GenericParamImplNamedGreen(pub GreenId);
19252impl TypedSyntaxNode for GenericParamImplNamed {
19253 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamImplNamed);
19254 type StablePtr = GenericParamImplNamedPtr;
19255 type Green = GenericParamImplNamedGreen;
19256 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19257 GenericParamImplNamedGreen(
19258 Arc::new(GreenNode {
19259 kind: SyntaxKind::GenericParamImplNamed,
19260 details: GreenNodeDetails::Node {
19261 children: vec![
19262 TerminalImpl::missing(db).0,
19263 TerminalIdentifier::missing(db).0,
19264 TerminalColon::missing(db).0,
19265 ExprPath::missing(db).0,
19266 OptionAssociatedItemConstraints::missing(db).0,
19267 ],
19268 width: TextWidth::default(),
19269 },
19270 })
19271 .intern(db),
19272 )
19273 }
19274 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19275 let kind = node.kind(db);
19276 assert_eq!(
19277 kind,
19278 SyntaxKind::GenericParamImplNamed,
19279 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19280 kind,
19281 SyntaxKind::GenericParamImplNamed
19282 );
19283 let children = db.get_children(node.clone());
19284 Self { node, children }
19285 }
19286 fn as_syntax_node(&self) -> SyntaxNode {
19287 self.node.clone()
19288 }
19289 fn stable_ptr(&self) -> Self::StablePtr {
19290 GenericParamImplNamedPtr(self.node.0.stable_ptr)
19291 }
19292}
19293impl From<&GenericParamImplNamed> for SyntaxStablePtrId {
19294 fn from(node: &GenericParamImplNamed) -> Self {
19295 node.stable_ptr().untyped()
19296 }
19297}
19298#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19299pub struct GenericParamImplAnonymous {
19300 node: SyntaxNode,
19301 children: Arc<[SyntaxNode]>,
19302}
19303impl GenericParamImplAnonymous {
19304 pub const INDEX_PLUS: usize = 0;
19305 pub const INDEX_TRAIT_PATH: usize = 1;
19306 pub const INDEX_TYPE_CONSTRAINS: usize = 2;
19307 pub fn new_green(
19308 db: &dyn SyntaxGroup,
19309 plus: TerminalPlusGreen,
19310 trait_path: ExprPathGreen,
19311 type_constrains: OptionAssociatedItemConstraintsGreen,
19312 ) -> GenericParamImplAnonymousGreen {
19313 let children: Vec<GreenId> = vec![plus.0, trait_path.0, type_constrains.0];
19314 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19315 GenericParamImplAnonymousGreen(
19316 Arc::new(GreenNode {
19317 kind: SyntaxKind::GenericParamImplAnonymous,
19318 details: GreenNodeDetails::Node { children, width },
19319 })
19320 .intern(db),
19321 )
19322 }
19323}
19324impl GenericParamImplAnonymous {
19325 pub fn plus(&self, db: &dyn SyntaxGroup) -> TerminalPlus {
19326 TerminalPlus::from_syntax_node(db, self.children[0].clone())
19327 }
19328 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
19329 ExprPath::from_syntax_node(db, self.children[1].clone())
19330 }
19331 pub fn type_constrains(&self, db: &dyn SyntaxGroup) -> OptionAssociatedItemConstraints {
19332 OptionAssociatedItemConstraints::from_syntax_node(db, self.children[2].clone())
19333 }
19334}
19335#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19336pub struct GenericParamImplAnonymousPtr(pub SyntaxStablePtrId);
19337impl GenericParamImplAnonymousPtr {}
19338impl TypedStablePtr for GenericParamImplAnonymousPtr {
19339 type SyntaxNode = GenericParamImplAnonymous;
19340 fn untyped(&self) -> SyntaxStablePtrId {
19341 self.0
19342 }
19343 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamImplAnonymous {
19344 GenericParamImplAnonymous::from_syntax_node(db, self.0.lookup(db))
19345 }
19346}
19347impl From<GenericParamImplAnonymousPtr> for SyntaxStablePtrId {
19348 fn from(ptr: GenericParamImplAnonymousPtr) -> Self {
19349 ptr.untyped()
19350 }
19351}
19352#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19353pub struct GenericParamImplAnonymousGreen(pub GreenId);
19354impl TypedSyntaxNode for GenericParamImplAnonymous {
19355 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamImplAnonymous);
19356 type StablePtr = GenericParamImplAnonymousPtr;
19357 type Green = GenericParamImplAnonymousGreen;
19358 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19359 GenericParamImplAnonymousGreen(
19360 Arc::new(GreenNode {
19361 kind: SyntaxKind::GenericParamImplAnonymous,
19362 details: GreenNodeDetails::Node {
19363 children: vec![
19364 TerminalPlus::missing(db).0,
19365 ExprPath::missing(db).0,
19366 OptionAssociatedItemConstraints::missing(db).0,
19367 ],
19368 width: TextWidth::default(),
19369 },
19370 })
19371 .intern(db),
19372 )
19373 }
19374 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19375 let kind = node.kind(db);
19376 assert_eq!(
19377 kind,
19378 SyntaxKind::GenericParamImplAnonymous,
19379 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19380 kind,
19381 SyntaxKind::GenericParamImplAnonymous
19382 );
19383 let children = db.get_children(node.clone());
19384 Self { node, children }
19385 }
19386 fn as_syntax_node(&self) -> SyntaxNode {
19387 self.node.clone()
19388 }
19389 fn stable_ptr(&self) -> Self::StablePtr {
19390 GenericParamImplAnonymousPtr(self.node.0.stable_ptr)
19391 }
19392}
19393impl From<&GenericParamImplAnonymous> for SyntaxStablePtrId {
19394 fn from(node: &GenericParamImplAnonymous) -> Self {
19395 node.stable_ptr().untyped()
19396 }
19397}
19398#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19399pub struct GenericParamNegativeImpl {
19400 node: SyntaxNode,
19401 children: Arc<[SyntaxNode]>,
19402}
19403impl GenericParamNegativeImpl {
19404 pub const INDEX_MINUS: usize = 0;
19405 pub const INDEX_TRAIT_PATH: usize = 1;
19406 pub fn new_green(
19407 db: &dyn SyntaxGroup,
19408 minus: TerminalMinusGreen,
19409 trait_path: ExprPathGreen,
19410 ) -> GenericParamNegativeImplGreen {
19411 let children: Vec<GreenId> = vec![minus.0, trait_path.0];
19412 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19413 GenericParamNegativeImplGreen(
19414 Arc::new(GreenNode {
19415 kind: SyntaxKind::GenericParamNegativeImpl,
19416 details: GreenNodeDetails::Node { children, width },
19417 })
19418 .intern(db),
19419 )
19420 }
19421}
19422impl GenericParamNegativeImpl {
19423 pub fn minus(&self, db: &dyn SyntaxGroup) -> TerminalMinus {
19424 TerminalMinus::from_syntax_node(db, self.children[0].clone())
19425 }
19426 pub fn trait_path(&self, db: &dyn SyntaxGroup) -> ExprPath {
19427 ExprPath::from_syntax_node(db, self.children[1].clone())
19428 }
19429}
19430#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19431pub struct GenericParamNegativeImplPtr(pub SyntaxStablePtrId);
19432impl GenericParamNegativeImplPtr {}
19433impl TypedStablePtr for GenericParamNegativeImplPtr {
19434 type SyntaxNode = GenericParamNegativeImpl;
19435 fn untyped(&self) -> SyntaxStablePtrId {
19436 self.0
19437 }
19438 fn lookup(&self, db: &dyn SyntaxGroup) -> GenericParamNegativeImpl {
19439 GenericParamNegativeImpl::from_syntax_node(db, self.0.lookup(db))
19440 }
19441}
19442impl From<GenericParamNegativeImplPtr> for SyntaxStablePtrId {
19443 fn from(ptr: GenericParamNegativeImplPtr) -> Self {
19444 ptr.untyped()
19445 }
19446}
19447#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19448pub struct GenericParamNegativeImplGreen(pub GreenId);
19449impl TypedSyntaxNode for GenericParamNegativeImpl {
19450 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::GenericParamNegativeImpl);
19451 type StablePtr = GenericParamNegativeImplPtr;
19452 type Green = GenericParamNegativeImplGreen;
19453 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19454 GenericParamNegativeImplGreen(
19455 Arc::new(GreenNode {
19456 kind: SyntaxKind::GenericParamNegativeImpl,
19457 details: GreenNodeDetails::Node {
19458 children: vec![TerminalMinus::missing(db).0, ExprPath::missing(db).0],
19459 width: TextWidth::default(),
19460 },
19461 })
19462 .intern(db),
19463 )
19464 }
19465 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19466 let kind = node.kind(db);
19467 assert_eq!(
19468 kind,
19469 SyntaxKind::GenericParamNegativeImpl,
19470 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19471 kind,
19472 SyntaxKind::GenericParamNegativeImpl
19473 );
19474 let children = db.get_children(node.clone());
19475 Self { node, children }
19476 }
19477 fn as_syntax_node(&self) -> SyntaxNode {
19478 self.node.clone()
19479 }
19480 fn stable_ptr(&self) -> Self::StablePtr {
19481 GenericParamNegativeImplPtr(self.node.0.stable_ptr)
19482 }
19483}
19484impl From<&GenericParamNegativeImpl> for SyntaxStablePtrId {
19485 fn from(node: &GenericParamNegativeImpl) -> Self {
19486 node.stable_ptr().untyped()
19487 }
19488}
19489#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19490pub struct TriviumSkippedNode {
19491 node: SyntaxNode,
19492 children: Arc<[SyntaxNode]>,
19493}
19494impl TriviumSkippedNode {
19495 pub const INDEX_NODE: usize = 0;
19496 pub fn new_green(db: &dyn SyntaxGroup, node: SkippedNodeGreen) -> TriviumSkippedNodeGreen {
19497 let children: Vec<GreenId> = vec![node.0];
19498 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19499 TriviumSkippedNodeGreen(
19500 Arc::new(GreenNode {
19501 kind: SyntaxKind::TriviumSkippedNode,
19502 details: GreenNodeDetails::Node { children, width },
19503 })
19504 .intern(db),
19505 )
19506 }
19507}
19508impl TriviumSkippedNode {
19509 pub fn node(&self, db: &dyn SyntaxGroup) -> SkippedNode {
19510 SkippedNode::from_syntax_node(db, self.children[0].clone())
19511 }
19512}
19513#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19514pub struct TriviumSkippedNodePtr(pub SyntaxStablePtrId);
19515impl TriviumSkippedNodePtr {}
19516impl TypedStablePtr for TriviumSkippedNodePtr {
19517 type SyntaxNode = TriviumSkippedNode;
19518 fn untyped(&self) -> SyntaxStablePtrId {
19519 self.0
19520 }
19521 fn lookup(&self, db: &dyn SyntaxGroup) -> TriviumSkippedNode {
19522 TriviumSkippedNode::from_syntax_node(db, self.0.lookup(db))
19523 }
19524}
19525impl From<TriviumSkippedNodePtr> for SyntaxStablePtrId {
19526 fn from(ptr: TriviumSkippedNodePtr) -> Self {
19527 ptr.untyped()
19528 }
19529}
19530#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19531pub struct TriviumSkippedNodeGreen(pub GreenId);
19532impl TypedSyntaxNode for TriviumSkippedNode {
19533 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TriviumSkippedNode);
19534 type StablePtr = TriviumSkippedNodePtr;
19535 type Green = TriviumSkippedNodeGreen;
19536 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19537 TriviumSkippedNodeGreen(
19538 Arc::new(GreenNode {
19539 kind: SyntaxKind::TriviumSkippedNode,
19540 details: GreenNodeDetails::Node {
19541 children: vec![SkippedNode::missing(db).0],
19542 width: TextWidth::default(),
19543 },
19544 })
19545 .intern(db),
19546 )
19547 }
19548 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19549 let kind = node.kind(db);
19550 assert_eq!(
19551 kind,
19552 SyntaxKind::TriviumSkippedNode,
19553 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19554 kind,
19555 SyntaxKind::TriviumSkippedNode
19556 );
19557 let children = db.get_children(node.clone());
19558 Self { node, children }
19559 }
19560 fn as_syntax_node(&self) -> SyntaxNode {
19561 self.node.clone()
19562 }
19563 fn stable_ptr(&self) -> Self::StablePtr {
19564 TriviumSkippedNodePtr(self.node.0.stable_ptr)
19565 }
19566}
19567impl From<&TriviumSkippedNode> for SyntaxStablePtrId {
19568 fn from(node: &TriviumSkippedNode) -> Self {
19569 node.stable_ptr().untyped()
19570 }
19571}
19572#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19573pub enum SkippedNode {
19574 AttributeList(AttributeList),
19575 VisibilityPub(VisibilityPub),
19576}
19577#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19578pub struct SkippedNodePtr(pub SyntaxStablePtrId);
19579impl TypedStablePtr for SkippedNodePtr {
19580 type SyntaxNode = SkippedNode;
19581 fn untyped(&self) -> SyntaxStablePtrId {
19582 self.0
19583 }
19584 fn lookup(&self, db: &dyn SyntaxGroup) -> SkippedNode {
19585 SkippedNode::from_syntax_node(db, self.0.lookup(db))
19586 }
19587}
19588impl From<SkippedNodePtr> for SyntaxStablePtrId {
19589 fn from(ptr: SkippedNodePtr) -> Self {
19590 ptr.untyped()
19591 }
19592}
19593impl From<AttributeListPtr> for SkippedNodePtr {
19594 fn from(value: AttributeListPtr) -> Self {
19595 Self(value.0)
19596 }
19597}
19598impl From<VisibilityPubPtr> for SkippedNodePtr {
19599 fn from(value: VisibilityPubPtr) -> Self {
19600 Self(value.0)
19601 }
19602}
19603impl From<AttributeListGreen> for SkippedNodeGreen {
19604 fn from(value: AttributeListGreen) -> Self {
19605 Self(value.0)
19606 }
19607}
19608impl From<VisibilityPubGreen> for SkippedNodeGreen {
19609 fn from(value: VisibilityPubGreen) -> Self {
19610 Self(value.0)
19611 }
19612}
19613#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19614pub struct SkippedNodeGreen(pub GreenId);
19615impl TypedSyntaxNode for SkippedNode {
19616 const OPTIONAL_KIND: Option<SyntaxKind> = None;
19617 type StablePtr = SkippedNodePtr;
19618 type Green = SkippedNodeGreen;
19619 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19620 panic!("No missing variant.");
19621 }
19622 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19623 let kind = node.kind(db);
19624 match kind {
19625 SyntaxKind::AttributeList => {
19626 SkippedNode::AttributeList(AttributeList::from_syntax_node(db, node))
19627 }
19628 SyntaxKind::VisibilityPub => {
19629 SkippedNode::VisibilityPub(VisibilityPub::from_syntax_node(db, node))
19630 }
19631 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "SkippedNode"),
19632 }
19633 }
19634 fn as_syntax_node(&self) -> SyntaxNode {
19635 match self {
19636 SkippedNode::AttributeList(x) => x.as_syntax_node(),
19637 SkippedNode::VisibilityPub(x) => x.as_syntax_node(),
19638 }
19639 }
19640 fn stable_ptr(&self) -> Self::StablePtr {
19641 SkippedNodePtr(self.as_syntax_node().0.stable_ptr)
19642 }
19643}
19644impl From<&SkippedNode> for SyntaxStablePtrId {
19645 fn from(node: &SkippedNode) -> Self {
19646 node.stable_ptr().untyped()
19647 }
19648}
19649impl SkippedNode {
19650 pub fn is_variant(kind: SyntaxKind) -> bool {
19652 matches!(kind, SyntaxKind::AttributeList | SyntaxKind::VisibilityPub)
19653 }
19654}
19655#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19656pub struct TokenIdentifier {
19657 node: SyntaxNode,
19658}
19659impl Token for TokenIdentifier {
19660 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
19661 TokenIdentifierGreen(
19662 Arc::new(GreenNode {
19663 kind: SyntaxKind::TokenIdentifier,
19664 details: GreenNodeDetails::Token(text),
19665 })
19666 .intern(db),
19667 )
19668 }
19669 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19670 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
19671 .clone()
19672 }
19673}
19674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19675pub struct TokenIdentifierPtr(pub SyntaxStablePtrId);
19676impl TypedStablePtr for TokenIdentifierPtr {
19677 type SyntaxNode = TokenIdentifier;
19678 fn untyped(&self) -> SyntaxStablePtrId {
19679 self.0
19680 }
19681 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenIdentifier {
19682 TokenIdentifier::from_syntax_node(db, self.0.lookup(db))
19683 }
19684}
19685impl From<TokenIdentifierPtr> for SyntaxStablePtrId {
19686 fn from(ptr: TokenIdentifierPtr) -> Self {
19687 ptr.untyped()
19688 }
19689}
19690#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19691pub struct TokenIdentifierGreen(pub GreenId);
19692impl TokenIdentifierGreen {
19693 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19694 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
19695 }
19696}
19697impl TypedSyntaxNode for TokenIdentifier {
19698 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenIdentifier);
19699 type StablePtr = TokenIdentifierPtr;
19700 type Green = TokenIdentifierGreen;
19701 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19702 TokenIdentifierGreen(
19703 Arc::new(GreenNode {
19704 kind: SyntaxKind::TokenMissing,
19705 details: GreenNodeDetails::Token("".into()),
19706 })
19707 .intern(db),
19708 )
19709 }
19710 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19711 match node.0.green.lookup_intern(db).details {
19712 GreenNodeDetails::Token(_) => Self { node },
19713 GreenNodeDetails::Node { .. } => {
19714 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenIdentifier)
19715 }
19716 }
19717 }
19718 fn as_syntax_node(&self) -> SyntaxNode {
19719 self.node.clone()
19720 }
19721 fn stable_ptr(&self) -> Self::StablePtr {
19722 TokenIdentifierPtr(self.node.0.stable_ptr)
19723 }
19724}
19725impl From<&TokenIdentifier> for SyntaxStablePtrId {
19726 fn from(node: &TokenIdentifier) -> Self {
19727 node.stable_ptr().untyped()
19728 }
19729}
19730#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19731pub struct TerminalIdentifier {
19732 node: SyntaxNode,
19733 children: Arc<[SyntaxNode]>,
19734}
19735impl Terminal for TerminalIdentifier {
19736 const KIND: SyntaxKind = SyntaxKind::TerminalIdentifier;
19737 type TokenType = TokenIdentifier;
19738 fn new_green(
19739 db: &dyn SyntaxGroup,
19740 leading_trivia: TriviaGreen,
19741 token: <<TerminalIdentifier as Terminal>::TokenType as TypedSyntaxNode>::Green,
19742 trailing_trivia: TriviaGreen,
19743 ) -> Self::Green {
19744 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
19745 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19746 TerminalIdentifierGreen(
19747 Arc::new(GreenNode {
19748 kind: SyntaxKind::TerminalIdentifier,
19749 details: GreenNodeDetails::Node { children, width },
19750 })
19751 .intern(db),
19752 )
19753 }
19754 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19755 self.token(db).text(db)
19756 }
19757}
19758impl TerminalIdentifier {
19759 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
19760 Trivia::from_syntax_node(db, self.children[0].clone())
19761 }
19762 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenIdentifier {
19763 TokenIdentifier::from_syntax_node(db, self.children[1].clone())
19764 }
19765 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
19766 Trivia::from_syntax_node(db, self.children[2].clone())
19767 }
19768}
19769#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19770pub struct TerminalIdentifierPtr(pub SyntaxStablePtrId);
19771impl TerminalIdentifierPtr {}
19772impl TypedStablePtr for TerminalIdentifierPtr {
19773 type SyntaxNode = TerminalIdentifier;
19774 fn untyped(&self) -> SyntaxStablePtrId {
19775 self.0
19776 }
19777 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalIdentifier {
19778 TerminalIdentifier::from_syntax_node(db, self.0.lookup(db))
19779 }
19780}
19781impl From<TerminalIdentifierPtr> for SyntaxStablePtrId {
19782 fn from(ptr: TerminalIdentifierPtr) -> Self {
19783 ptr.untyped()
19784 }
19785}
19786#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19787pub struct TerminalIdentifierGreen(pub GreenId);
19788impl TypedSyntaxNode for TerminalIdentifier {
19789 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalIdentifier);
19790 type StablePtr = TerminalIdentifierPtr;
19791 type Green = TerminalIdentifierGreen;
19792 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19793 TerminalIdentifierGreen(
19794 Arc::new(GreenNode {
19795 kind: SyntaxKind::TerminalIdentifier,
19796 details: GreenNodeDetails::Node {
19797 children: vec![
19798 Trivia::missing(db).0,
19799 TokenIdentifier::missing(db).0,
19800 Trivia::missing(db).0,
19801 ],
19802 width: TextWidth::default(),
19803 },
19804 })
19805 .intern(db),
19806 )
19807 }
19808 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19809 let kind = node.kind(db);
19810 assert_eq!(
19811 kind,
19812 SyntaxKind::TerminalIdentifier,
19813 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19814 kind,
19815 SyntaxKind::TerminalIdentifier
19816 );
19817 let children = db.get_children(node.clone());
19818 Self { node, children }
19819 }
19820 fn as_syntax_node(&self) -> SyntaxNode {
19821 self.node.clone()
19822 }
19823 fn stable_ptr(&self) -> Self::StablePtr {
19824 TerminalIdentifierPtr(self.node.0.stable_ptr)
19825 }
19826}
19827impl From<&TerminalIdentifier> for SyntaxStablePtrId {
19828 fn from(node: &TerminalIdentifier) -> Self {
19829 node.stable_ptr().untyped()
19830 }
19831}
19832#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19833pub struct TokenLiteralNumber {
19834 node: SyntaxNode,
19835}
19836impl Token for TokenLiteralNumber {
19837 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
19838 TokenLiteralNumberGreen(
19839 Arc::new(GreenNode {
19840 kind: SyntaxKind::TokenLiteralNumber,
19841 details: GreenNodeDetails::Token(text),
19842 })
19843 .intern(db),
19844 )
19845 }
19846 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19847 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
19848 .clone()
19849 }
19850}
19851#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19852pub struct TokenLiteralNumberPtr(pub SyntaxStablePtrId);
19853impl TypedStablePtr for TokenLiteralNumberPtr {
19854 type SyntaxNode = TokenLiteralNumber;
19855 fn untyped(&self) -> SyntaxStablePtrId {
19856 self.0
19857 }
19858 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLiteralNumber {
19859 TokenLiteralNumber::from_syntax_node(db, self.0.lookup(db))
19860 }
19861}
19862impl From<TokenLiteralNumberPtr> for SyntaxStablePtrId {
19863 fn from(ptr: TokenLiteralNumberPtr) -> Self {
19864 ptr.untyped()
19865 }
19866}
19867#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19868pub struct TokenLiteralNumberGreen(pub GreenId);
19869impl TokenLiteralNumberGreen {
19870 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19871 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
19872 }
19873}
19874impl TypedSyntaxNode for TokenLiteralNumber {
19875 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLiteralNumber);
19876 type StablePtr = TokenLiteralNumberPtr;
19877 type Green = TokenLiteralNumberGreen;
19878 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19879 TokenLiteralNumberGreen(
19880 Arc::new(GreenNode {
19881 kind: SyntaxKind::TokenMissing,
19882 details: GreenNodeDetails::Token("".into()),
19883 })
19884 .intern(db),
19885 )
19886 }
19887 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19888 match node.0.green.lookup_intern(db).details {
19889 GreenNodeDetails::Token(_) => Self { node },
19890 GreenNodeDetails::Node { .. } => panic!(
19891 "Expected a token {:?}, not an internal node",
19892 SyntaxKind::TokenLiteralNumber
19893 ),
19894 }
19895 }
19896 fn as_syntax_node(&self) -> SyntaxNode {
19897 self.node.clone()
19898 }
19899 fn stable_ptr(&self) -> Self::StablePtr {
19900 TokenLiteralNumberPtr(self.node.0.stable_ptr)
19901 }
19902}
19903impl From<&TokenLiteralNumber> for SyntaxStablePtrId {
19904 fn from(node: &TokenLiteralNumber) -> Self {
19905 node.stable_ptr().untyped()
19906 }
19907}
19908#[derive(Clone, Debug, Eq, Hash, PartialEq)]
19909pub struct TerminalLiteralNumber {
19910 node: SyntaxNode,
19911 children: Arc<[SyntaxNode]>,
19912}
19913impl Terminal for TerminalLiteralNumber {
19914 const KIND: SyntaxKind = SyntaxKind::TerminalLiteralNumber;
19915 type TokenType = TokenLiteralNumber;
19916 fn new_green(
19917 db: &dyn SyntaxGroup,
19918 leading_trivia: TriviaGreen,
19919 token: <<TerminalLiteralNumber as Terminal>::TokenType as TypedSyntaxNode>::Green,
19920 trailing_trivia: TriviaGreen,
19921 ) -> Self::Green {
19922 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
19923 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
19924 TerminalLiteralNumberGreen(
19925 Arc::new(GreenNode {
19926 kind: SyntaxKind::TerminalLiteralNumber,
19927 details: GreenNodeDetails::Node { children, width },
19928 })
19929 .intern(db),
19930 )
19931 }
19932 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
19933 self.token(db).text(db)
19934 }
19935}
19936impl TerminalLiteralNumber {
19937 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
19938 Trivia::from_syntax_node(db, self.children[0].clone())
19939 }
19940 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLiteralNumber {
19941 TokenLiteralNumber::from_syntax_node(db, self.children[1].clone())
19942 }
19943 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
19944 Trivia::from_syntax_node(db, self.children[2].clone())
19945 }
19946}
19947#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19948pub struct TerminalLiteralNumberPtr(pub SyntaxStablePtrId);
19949impl TerminalLiteralNumberPtr {}
19950impl TypedStablePtr for TerminalLiteralNumberPtr {
19951 type SyntaxNode = TerminalLiteralNumber;
19952 fn untyped(&self) -> SyntaxStablePtrId {
19953 self.0
19954 }
19955 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLiteralNumber {
19956 TerminalLiteralNumber::from_syntax_node(db, self.0.lookup(db))
19957 }
19958}
19959impl From<TerminalLiteralNumberPtr> for SyntaxStablePtrId {
19960 fn from(ptr: TerminalLiteralNumberPtr) -> Self {
19961 ptr.untyped()
19962 }
19963}
19964#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
19965pub struct TerminalLiteralNumberGreen(pub GreenId);
19966impl TypedSyntaxNode for TerminalLiteralNumber {
19967 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLiteralNumber);
19968 type StablePtr = TerminalLiteralNumberPtr;
19969 type Green = TerminalLiteralNumberGreen;
19970 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
19971 TerminalLiteralNumberGreen(
19972 Arc::new(GreenNode {
19973 kind: SyntaxKind::TerminalLiteralNumber,
19974 details: GreenNodeDetails::Node {
19975 children: vec![
19976 Trivia::missing(db).0,
19977 TokenLiteralNumber::missing(db).0,
19978 Trivia::missing(db).0,
19979 ],
19980 width: TextWidth::default(),
19981 },
19982 })
19983 .intern(db),
19984 )
19985 }
19986 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
19987 let kind = node.kind(db);
19988 assert_eq!(
19989 kind,
19990 SyntaxKind::TerminalLiteralNumber,
19991 "Unexpected SyntaxKind {:?}. Expected {:?}.",
19992 kind,
19993 SyntaxKind::TerminalLiteralNumber
19994 );
19995 let children = db.get_children(node.clone());
19996 Self { node, children }
19997 }
19998 fn as_syntax_node(&self) -> SyntaxNode {
19999 self.node.clone()
20000 }
20001 fn stable_ptr(&self) -> Self::StablePtr {
20002 TerminalLiteralNumberPtr(self.node.0.stable_ptr)
20003 }
20004}
20005impl From<&TerminalLiteralNumber> for SyntaxStablePtrId {
20006 fn from(node: &TerminalLiteralNumber) -> Self {
20007 node.stable_ptr().untyped()
20008 }
20009}
20010#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20011pub struct TokenShortString {
20012 node: SyntaxNode,
20013}
20014impl Token for TokenShortString {
20015 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20016 TokenShortStringGreen(
20017 Arc::new(GreenNode {
20018 kind: SyntaxKind::TokenShortString,
20019 details: GreenNodeDetails::Token(text),
20020 })
20021 .intern(db),
20022 )
20023 }
20024 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20025 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20026 .clone()
20027 }
20028}
20029#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20030pub struct TokenShortStringPtr(pub SyntaxStablePtrId);
20031impl TypedStablePtr for TokenShortStringPtr {
20032 type SyntaxNode = TokenShortString;
20033 fn untyped(&self) -> SyntaxStablePtrId {
20034 self.0
20035 }
20036 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenShortString {
20037 TokenShortString::from_syntax_node(db, self.0.lookup(db))
20038 }
20039}
20040impl From<TokenShortStringPtr> for SyntaxStablePtrId {
20041 fn from(ptr: TokenShortStringPtr) -> Self {
20042 ptr.untyped()
20043 }
20044}
20045#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20046pub struct TokenShortStringGreen(pub GreenId);
20047impl TokenShortStringGreen {
20048 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20049 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20050 }
20051}
20052impl TypedSyntaxNode for TokenShortString {
20053 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenShortString);
20054 type StablePtr = TokenShortStringPtr;
20055 type Green = TokenShortStringGreen;
20056 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20057 TokenShortStringGreen(
20058 Arc::new(GreenNode {
20059 kind: SyntaxKind::TokenMissing,
20060 details: GreenNodeDetails::Token("".into()),
20061 })
20062 .intern(db),
20063 )
20064 }
20065 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20066 match node.0.green.lookup_intern(db).details {
20067 GreenNodeDetails::Token(_) => Self { node },
20068 GreenNodeDetails::Node { .. } => {
20069 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenShortString)
20070 }
20071 }
20072 }
20073 fn as_syntax_node(&self) -> SyntaxNode {
20074 self.node.clone()
20075 }
20076 fn stable_ptr(&self) -> Self::StablePtr {
20077 TokenShortStringPtr(self.node.0.stable_ptr)
20078 }
20079}
20080impl From<&TokenShortString> for SyntaxStablePtrId {
20081 fn from(node: &TokenShortString) -> Self {
20082 node.stable_ptr().untyped()
20083 }
20084}
20085#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20086pub struct TerminalShortString {
20087 node: SyntaxNode,
20088 children: Arc<[SyntaxNode]>,
20089}
20090impl Terminal for TerminalShortString {
20091 const KIND: SyntaxKind = SyntaxKind::TerminalShortString;
20092 type TokenType = TokenShortString;
20093 fn new_green(
20094 db: &dyn SyntaxGroup,
20095 leading_trivia: TriviaGreen,
20096 token: <<TerminalShortString as Terminal>::TokenType as TypedSyntaxNode>::Green,
20097 trailing_trivia: TriviaGreen,
20098 ) -> Self::Green {
20099 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20100 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20101 TerminalShortStringGreen(
20102 Arc::new(GreenNode {
20103 kind: SyntaxKind::TerminalShortString,
20104 details: GreenNodeDetails::Node { children, width },
20105 })
20106 .intern(db),
20107 )
20108 }
20109 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20110 self.token(db).text(db)
20111 }
20112}
20113impl TerminalShortString {
20114 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20115 Trivia::from_syntax_node(db, self.children[0].clone())
20116 }
20117 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenShortString {
20118 TokenShortString::from_syntax_node(db, self.children[1].clone())
20119 }
20120 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20121 Trivia::from_syntax_node(db, self.children[2].clone())
20122 }
20123}
20124#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20125pub struct TerminalShortStringPtr(pub SyntaxStablePtrId);
20126impl TerminalShortStringPtr {}
20127impl TypedStablePtr for TerminalShortStringPtr {
20128 type SyntaxNode = TerminalShortString;
20129 fn untyped(&self) -> SyntaxStablePtrId {
20130 self.0
20131 }
20132 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalShortString {
20133 TerminalShortString::from_syntax_node(db, self.0.lookup(db))
20134 }
20135}
20136impl From<TerminalShortStringPtr> for SyntaxStablePtrId {
20137 fn from(ptr: TerminalShortStringPtr) -> Self {
20138 ptr.untyped()
20139 }
20140}
20141#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20142pub struct TerminalShortStringGreen(pub GreenId);
20143impl TypedSyntaxNode for TerminalShortString {
20144 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalShortString);
20145 type StablePtr = TerminalShortStringPtr;
20146 type Green = TerminalShortStringGreen;
20147 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20148 TerminalShortStringGreen(
20149 Arc::new(GreenNode {
20150 kind: SyntaxKind::TerminalShortString,
20151 details: GreenNodeDetails::Node {
20152 children: vec![
20153 Trivia::missing(db).0,
20154 TokenShortString::missing(db).0,
20155 Trivia::missing(db).0,
20156 ],
20157 width: TextWidth::default(),
20158 },
20159 })
20160 .intern(db),
20161 )
20162 }
20163 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20164 let kind = node.kind(db);
20165 assert_eq!(
20166 kind,
20167 SyntaxKind::TerminalShortString,
20168 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20169 kind,
20170 SyntaxKind::TerminalShortString
20171 );
20172 let children = db.get_children(node.clone());
20173 Self { node, children }
20174 }
20175 fn as_syntax_node(&self) -> SyntaxNode {
20176 self.node.clone()
20177 }
20178 fn stable_ptr(&self) -> Self::StablePtr {
20179 TerminalShortStringPtr(self.node.0.stable_ptr)
20180 }
20181}
20182impl From<&TerminalShortString> for SyntaxStablePtrId {
20183 fn from(node: &TerminalShortString) -> Self {
20184 node.stable_ptr().untyped()
20185 }
20186}
20187#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20188pub struct TokenString {
20189 node: SyntaxNode,
20190}
20191impl Token for TokenString {
20192 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20193 TokenStringGreen(
20194 Arc::new(GreenNode {
20195 kind: SyntaxKind::TokenString,
20196 details: GreenNodeDetails::Token(text),
20197 })
20198 .intern(db),
20199 )
20200 }
20201 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20202 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20203 .clone()
20204 }
20205}
20206#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20207pub struct TokenStringPtr(pub SyntaxStablePtrId);
20208impl TypedStablePtr for TokenStringPtr {
20209 type SyntaxNode = TokenString;
20210 fn untyped(&self) -> SyntaxStablePtrId {
20211 self.0
20212 }
20213 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenString {
20214 TokenString::from_syntax_node(db, self.0.lookup(db))
20215 }
20216}
20217impl From<TokenStringPtr> for SyntaxStablePtrId {
20218 fn from(ptr: TokenStringPtr) -> Self {
20219 ptr.untyped()
20220 }
20221}
20222#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20223pub struct TokenStringGreen(pub GreenId);
20224impl TokenStringGreen {
20225 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20226 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20227 }
20228}
20229impl TypedSyntaxNode for TokenString {
20230 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenString);
20231 type StablePtr = TokenStringPtr;
20232 type Green = TokenStringGreen;
20233 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20234 TokenStringGreen(
20235 Arc::new(GreenNode {
20236 kind: SyntaxKind::TokenMissing,
20237 details: GreenNodeDetails::Token("".into()),
20238 })
20239 .intern(db),
20240 )
20241 }
20242 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20243 match node.0.green.lookup_intern(db).details {
20244 GreenNodeDetails::Token(_) => Self { node },
20245 GreenNodeDetails::Node { .. } => {
20246 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenString)
20247 }
20248 }
20249 }
20250 fn as_syntax_node(&self) -> SyntaxNode {
20251 self.node.clone()
20252 }
20253 fn stable_ptr(&self) -> Self::StablePtr {
20254 TokenStringPtr(self.node.0.stable_ptr)
20255 }
20256}
20257impl From<&TokenString> for SyntaxStablePtrId {
20258 fn from(node: &TokenString) -> Self {
20259 node.stable_ptr().untyped()
20260 }
20261}
20262#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20263pub struct TerminalString {
20264 node: SyntaxNode,
20265 children: Arc<[SyntaxNode]>,
20266}
20267impl Terminal for TerminalString {
20268 const KIND: SyntaxKind = SyntaxKind::TerminalString;
20269 type TokenType = TokenString;
20270 fn new_green(
20271 db: &dyn SyntaxGroup,
20272 leading_trivia: TriviaGreen,
20273 token: <<TerminalString as Terminal>::TokenType as TypedSyntaxNode>::Green,
20274 trailing_trivia: TriviaGreen,
20275 ) -> Self::Green {
20276 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20277 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20278 TerminalStringGreen(
20279 Arc::new(GreenNode {
20280 kind: SyntaxKind::TerminalString,
20281 details: GreenNodeDetails::Node { children, width },
20282 })
20283 .intern(db),
20284 )
20285 }
20286 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20287 self.token(db).text(db)
20288 }
20289}
20290impl TerminalString {
20291 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20292 Trivia::from_syntax_node(db, self.children[0].clone())
20293 }
20294 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenString {
20295 TokenString::from_syntax_node(db, self.children[1].clone())
20296 }
20297 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20298 Trivia::from_syntax_node(db, self.children[2].clone())
20299 }
20300}
20301#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20302pub struct TerminalStringPtr(pub SyntaxStablePtrId);
20303impl TerminalStringPtr {}
20304impl TypedStablePtr for TerminalStringPtr {
20305 type SyntaxNode = TerminalString;
20306 fn untyped(&self) -> SyntaxStablePtrId {
20307 self.0
20308 }
20309 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalString {
20310 TerminalString::from_syntax_node(db, self.0.lookup(db))
20311 }
20312}
20313impl From<TerminalStringPtr> for SyntaxStablePtrId {
20314 fn from(ptr: TerminalStringPtr) -> Self {
20315 ptr.untyped()
20316 }
20317}
20318#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20319pub struct TerminalStringGreen(pub GreenId);
20320impl TypedSyntaxNode for TerminalString {
20321 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalString);
20322 type StablePtr = TerminalStringPtr;
20323 type Green = TerminalStringGreen;
20324 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20325 TerminalStringGreen(
20326 Arc::new(GreenNode {
20327 kind: SyntaxKind::TerminalString,
20328 details: GreenNodeDetails::Node {
20329 children: vec![
20330 Trivia::missing(db).0,
20331 TokenString::missing(db).0,
20332 Trivia::missing(db).0,
20333 ],
20334 width: TextWidth::default(),
20335 },
20336 })
20337 .intern(db),
20338 )
20339 }
20340 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20341 let kind = node.kind(db);
20342 assert_eq!(
20343 kind,
20344 SyntaxKind::TerminalString,
20345 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20346 kind,
20347 SyntaxKind::TerminalString
20348 );
20349 let children = db.get_children(node.clone());
20350 Self { node, children }
20351 }
20352 fn as_syntax_node(&self) -> SyntaxNode {
20353 self.node.clone()
20354 }
20355 fn stable_ptr(&self) -> Self::StablePtr {
20356 TerminalStringPtr(self.node.0.stable_ptr)
20357 }
20358}
20359impl From<&TerminalString> for SyntaxStablePtrId {
20360 fn from(node: &TerminalString) -> Self {
20361 node.stable_ptr().untyped()
20362 }
20363}
20364#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20365pub struct TokenAs {
20366 node: SyntaxNode,
20367}
20368impl Token for TokenAs {
20369 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20370 TokenAsGreen(
20371 Arc::new(GreenNode {
20372 kind: SyntaxKind::TokenAs,
20373 details: GreenNodeDetails::Token(text),
20374 })
20375 .intern(db),
20376 )
20377 }
20378 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20379 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20380 .clone()
20381 }
20382}
20383#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20384pub struct TokenAsPtr(pub SyntaxStablePtrId);
20385impl TypedStablePtr for TokenAsPtr {
20386 type SyntaxNode = TokenAs;
20387 fn untyped(&self) -> SyntaxStablePtrId {
20388 self.0
20389 }
20390 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAs {
20391 TokenAs::from_syntax_node(db, self.0.lookup(db))
20392 }
20393}
20394impl From<TokenAsPtr> for SyntaxStablePtrId {
20395 fn from(ptr: TokenAsPtr) -> Self {
20396 ptr.untyped()
20397 }
20398}
20399#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20400pub struct TokenAsGreen(pub GreenId);
20401impl TokenAsGreen {
20402 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20403 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20404 }
20405}
20406impl TypedSyntaxNode for TokenAs {
20407 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAs);
20408 type StablePtr = TokenAsPtr;
20409 type Green = TokenAsGreen;
20410 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20411 TokenAsGreen(
20412 Arc::new(GreenNode {
20413 kind: SyntaxKind::TokenMissing,
20414 details: GreenNodeDetails::Token("".into()),
20415 })
20416 .intern(db),
20417 )
20418 }
20419 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20420 match node.0.green.lookup_intern(db).details {
20421 GreenNodeDetails::Token(_) => Self { node },
20422 GreenNodeDetails::Node { .. } => {
20423 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAs)
20424 }
20425 }
20426 }
20427 fn as_syntax_node(&self) -> SyntaxNode {
20428 self.node.clone()
20429 }
20430 fn stable_ptr(&self) -> Self::StablePtr {
20431 TokenAsPtr(self.node.0.stable_ptr)
20432 }
20433}
20434impl From<&TokenAs> for SyntaxStablePtrId {
20435 fn from(node: &TokenAs) -> Self {
20436 node.stable_ptr().untyped()
20437 }
20438}
20439#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20440pub struct TerminalAs {
20441 node: SyntaxNode,
20442 children: Arc<[SyntaxNode]>,
20443}
20444impl Terminal for TerminalAs {
20445 const KIND: SyntaxKind = SyntaxKind::TerminalAs;
20446 type TokenType = TokenAs;
20447 fn new_green(
20448 db: &dyn SyntaxGroup,
20449 leading_trivia: TriviaGreen,
20450 token: <<TerminalAs as Terminal>::TokenType as TypedSyntaxNode>::Green,
20451 trailing_trivia: TriviaGreen,
20452 ) -> Self::Green {
20453 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20454 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20455 TerminalAsGreen(
20456 Arc::new(GreenNode {
20457 kind: SyntaxKind::TerminalAs,
20458 details: GreenNodeDetails::Node { children, width },
20459 })
20460 .intern(db),
20461 )
20462 }
20463 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20464 self.token(db).text(db)
20465 }
20466}
20467impl TerminalAs {
20468 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20469 Trivia::from_syntax_node(db, self.children[0].clone())
20470 }
20471 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAs {
20472 TokenAs::from_syntax_node(db, self.children[1].clone())
20473 }
20474 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20475 Trivia::from_syntax_node(db, self.children[2].clone())
20476 }
20477}
20478#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20479pub struct TerminalAsPtr(pub SyntaxStablePtrId);
20480impl TerminalAsPtr {}
20481impl TypedStablePtr for TerminalAsPtr {
20482 type SyntaxNode = TerminalAs;
20483 fn untyped(&self) -> SyntaxStablePtrId {
20484 self.0
20485 }
20486 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAs {
20487 TerminalAs::from_syntax_node(db, self.0.lookup(db))
20488 }
20489}
20490impl From<TerminalAsPtr> for SyntaxStablePtrId {
20491 fn from(ptr: TerminalAsPtr) -> Self {
20492 ptr.untyped()
20493 }
20494}
20495#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20496pub struct TerminalAsGreen(pub GreenId);
20497impl TypedSyntaxNode for TerminalAs {
20498 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAs);
20499 type StablePtr = TerminalAsPtr;
20500 type Green = TerminalAsGreen;
20501 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20502 TerminalAsGreen(
20503 Arc::new(GreenNode {
20504 kind: SyntaxKind::TerminalAs,
20505 details: GreenNodeDetails::Node {
20506 children: vec![
20507 Trivia::missing(db).0,
20508 TokenAs::missing(db).0,
20509 Trivia::missing(db).0,
20510 ],
20511 width: TextWidth::default(),
20512 },
20513 })
20514 .intern(db),
20515 )
20516 }
20517 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20518 let kind = node.kind(db);
20519 assert_eq!(
20520 kind,
20521 SyntaxKind::TerminalAs,
20522 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20523 kind,
20524 SyntaxKind::TerminalAs
20525 );
20526 let children = db.get_children(node.clone());
20527 Self { node, children }
20528 }
20529 fn as_syntax_node(&self) -> SyntaxNode {
20530 self.node.clone()
20531 }
20532 fn stable_ptr(&self) -> Self::StablePtr {
20533 TerminalAsPtr(self.node.0.stable_ptr)
20534 }
20535}
20536impl From<&TerminalAs> for SyntaxStablePtrId {
20537 fn from(node: &TerminalAs) -> Self {
20538 node.stable_ptr().untyped()
20539 }
20540}
20541#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20542pub struct TokenConst {
20543 node: SyntaxNode,
20544}
20545impl Token for TokenConst {
20546 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20547 TokenConstGreen(
20548 Arc::new(GreenNode {
20549 kind: SyntaxKind::TokenConst,
20550 details: GreenNodeDetails::Token(text),
20551 })
20552 .intern(db),
20553 )
20554 }
20555 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20556 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20557 .clone()
20558 }
20559}
20560#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20561pub struct TokenConstPtr(pub SyntaxStablePtrId);
20562impl TypedStablePtr for TokenConstPtr {
20563 type SyntaxNode = TokenConst;
20564 fn untyped(&self) -> SyntaxStablePtrId {
20565 self.0
20566 }
20567 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenConst {
20568 TokenConst::from_syntax_node(db, self.0.lookup(db))
20569 }
20570}
20571impl From<TokenConstPtr> for SyntaxStablePtrId {
20572 fn from(ptr: TokenConstPtr) -> Self {
20573 ptr.untyped()
20574 }
20575}
20576#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20577pub struct TokenConstGreen(pub GreenId);
20578impl TokenConstGreen {
20579 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20580 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20581 }
20582}
20583impl TypedSyntaxNode for TokenConst {
20584 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenConst);
20585 type StablePtr = TokenConstPtr;
20586 type Green = TokenConstGreen;
20587 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20588 TokenConstGreen(
20589 Arc::new(GreenNode {
20590 kind: SyntaxKind::TokenMissing,
20591 details: GreenNodeDetails::Token("".into()),
20592 })
20593 .intern(db),
20594 )
20595 }
20596 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20597 match node.0.green.lookup_intern(db).details {
20598 GreenNodeDetails::Token(_) => Self { node },
20599 GreenNodeDetails::Node { .. } => {
20600 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenConst)
20601 }
20602 }
20603 }
20604 fn as_syntax_node(&self) -> SyntaxNode {
20605 self.node.clone()
20606 }
20607 fn stable_ptr(&self) -> Self::StablePtr {
20608 TokenConstPtr(self.node.0.stable_ptr)
20609 }
20610}
20611impl From<&TokenConst> for SyntaxStablePtrId {
20612 fn from(node: &TokenConst) -> Self {
20613 node.stable_ptr().untyped()
20614 }
20615}
20616#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20617pub struct TerminalConst {
20618 node: SyntaxNode,
20619 children: Arc<[SyntaxNode]>,
20620}
20621impl Terminal for TerminalConst {
20622 const KIND: SyntaxKind = SyntaxKind::TerminalConst;
20623 type TokenType = TokenConst;
20624 fn new_green(
20625 db: &dyn SyntaxGroup,
20626 leading_trivia: TriviaGreen,
20627 token: <<TerminalConst as Terminal>::TokenType as TypedSyntaxNode>::Green,
20628 trailing_trivia: TriviaGreen,
20629 ) -> Self::Green {
20630 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20631 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20632 TerminalConstGreen(
20633 Arc::new(GreenNode {
20634 kind: SyntaxKind::TerminalConst,
20635 details: GreenNodeDetails::Node { children, width },
20636 })
20637 .intern(db),
20638 )
20639 }
20640 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20641 self.token(db).text(db)
20642 }
20643}
20644impl TerminalConst {
20645 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20646 Trivia::from_syntax_node(db, self.children[0].clone())
20647 }
20648 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenConst {
20649 TokenConst::from_syntax_node(db, self.children[1].clone())
20650 }
20651 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20652 Trivia::from_syntax_node(db, self.children[2].clone())
20653 }
20654}
20655#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20656pub struct TerminalConstPtr(pub SyntaxStablePtrId);
20657impl TerminalConstPtr {}
20658impl TypedStablePtr for TerminalConstPtr {
20659 type SyntaxNode = TerminalConst;
20660 fn untyped(&self) -> SyntaxStablePtrId {
20661 self.0
20662 }
20663 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalConst {
20664 TerminalConst::from_syntax_node(db, self.0.lookup(db))
20665 }
20666}
20667impl From<TerminalConstPtr> for SyntaxStablePtrId {
20668 fn from(ptr: TerminalConstPtr) -> Self {
20669 ptr.untyped()
20670 }
20671}
20672#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20673pub struct TerminalConstGreen(pub GreenId);
20674impl TypedSyntaxNode for TerminalConst {
20675 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalConst);
20676 type StablePtr = TerminalConstPtr;
20677 type Green = TerminalConstGreen;
20678 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20679 TerminalConstGreen(
20680 Arc::new(GreenNode {
20681 kind: SyntaxKind::TerminalConst,
20682 details: GreenNodeDetails::Node {
20683 children: vec![
20684 Trivia::missing(db).0,
20685 TokenConst::missing(db).0,
20686 Trivia::missing(db).0,
20687 ],
20688 width: TextWidth::default(),
20689 },
20690 })
20691 .intern(db),
20692 )
20693 }
20694 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20695 let kind = node.kind(db);
20696 assert_eq!(
20697 kind,
20698 SyntaxKind::TerminalConst,
20699 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20700 kind,
20701 SyntaxKind::TerminalConst
20702 );
20703 let children = db.get_children(node.clone());
20704 Self { node, children }
20705 }
20706 fn as_syntax_node(&self) -> SyntaxNode {
20707 self.node.clone()
20708 }
20709 fn stable_ptr(&self) -> Self::StablePtr {
20710 TerminalConstPtr(self.node.0.stable_ptr)
20711 }
20712}
20713impl From<&TerminalConst> for SyntaxStablePtrId {
20714 fn from(node: &TerminalConst) -> Self {
20715 node.stable_ptr().untyped()
20716 }
20717}
20718#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20719pub struct TokenElse {
20720 node: SyntaxNode,
20721}
20722impl Token for TokenElse {
20723 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20724 TokenElseGreen(
20725 Arc::new(GreenNode {
20726 kind: SyntaxKind::TokenElse,
20727 details: GreenNodeDetails::Token(text),
20728 })
20729 .intern(db),
20730 )
20731 }
20732 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20733 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20734 .clone()
20735 }
20736}
20737#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20738pub struct TokenElsePtr(pub SyntaxStablePtrId);
20739impl TypedStablePtr for TokenElsePtr {
20740 type SyntaxNode = TokenElse;
20741 fn untyped(&self) -> SyntaxStablePtrId {
20742 self.0
20743 }
20744 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenElse {
20745 TokenElse::from_syntax_node(db, self.0.lookup(db))
20746 }
20747}
20748impl From<TokenElsePtr> for SyntaxStablePtrId {
20749 fn from(ptr: TokenElsePtr) -> Self {
20750 ptr.untyped()
20751 }
20752}
20753#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20754pub struct TokenElseGreen(pub GreenId);
20755impl TokenElseGreen {
20756 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20757 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20758 }
20759}
20760impl TypedSyntaxNode for TokenElse {
20761 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenElse);
20762 type StablePtr = TokenElsePtr;
20763 type Green = TokenElseGreen;
20764 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20765 TokenElseGreen(
20766 Arc::new(GreenNode {
20767 kind: SyntaxKind::TokenMissing,
20768 details: GreenNodeDetails::Token("".into()),
20769 })
20770 .intern(db),
20771 )
20772 }
20773 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20774 match node.0.green.lookup_intern(db).details {
20775 GreenNodeDetails::Token(_) => Self { node },
20776 GreenNodeDetails::Node { .. } => {
20777 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenElse)
20778 }
20779 }
20780 }
20781 fn as_syntax_node(&self) -> SyntaxNode {
20782 self.node.clone()
20783 }
20784 fn stable_ptr(&self) -> Self::StablePtr {
20785 TokenElsePtr(self.node.0.stable_ptr)
20786 }
20787}
20788impl From<&TokenElse> for SyntaxStablePtrId {
20789 fn from(node: &TokenElse) -> Self {
20790 node.stable_ptr().untyped()
20791 }
20792}
20793#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20794pub struct TerminalElse {
20795 node: SyntaxNode,
20796 children: Arc<[SyntaxNode]>,
20797}
20798impl Terminal for TerminalElse {
20799 const KIND: SyntaxKind = SyntaxKind::TerminalElse;
20800 type TokenType = TokenElse;
20801 fn new_green(
20802 db: &dyn SyntaxGroup,
20803 leading_trivia: TriviaGreen,
20804 token: <<TerminalElse as Terminal>::TokenType as TypedSyntaxNode>::Green,
20805 trailing_trivia: TriviaGreen,
20806 ) -> Self::Green {
20807 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20808 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20809 TerminalElseGreen(
20810 Arc::new(GreenNode {
20811 kind: SyntaxKind::TerminalElse,
20812 details: GreenNodeDetails::Node { children, width },
20813 })
20814 .intern(db),
20815 )
20816 }
20817 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20818 self.token(db).text(db)
20819 }
20820}
20821impl TerminalElse {
20822 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20823 Trivia::from_syntax_node(db, self.children[0].clone())
20824 }
20825 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenElse {
20826 TokenElse::from_syntax_node(db, self.children[1].clone())
20827 }
20828 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
20829 Trivia::from_syntax_node(db, self.children[2].clone())
20830 }
20831}
20832#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20833pub struct TerminalElsePtr(pub SyntaxStablePtrId);
20834impl TerminalElsePtr {}
20835impl TypedStablePtr for TerminalElsePtr {
20836 type SyntaxNode = TerminalElse;
20837 fn untyped(&self) -> SyntaxStablePtrId {
20838 self.0
20839 }
20840 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalElse {
20841 TerminalElse::from_syntax_node(db, self.0.lookup(db))
20842 }
20843}
20844impl From<TerminalElsePtr> for SyntaxStablePtrId {
20845 fn from(ptr: TerminalElsePtr) -> Self {
20846 ptr.untyped()
20847 }
20848}
20849#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20850pub struct TerminalElseGreen(pub GreenId);
20851impl TypedSyntaxNode for TerminalElse {
20852 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalElse);
20853 type StablePtr = TerminalElsePtr;
20854 type Green = TerminalElseGreen;
20855 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20856 TerminalElseGreen(
20857 Arc::new(GreenNode {
20858 kind: SyntaxKind::TerminalElse,
20859 details: GreenNodeDetails::Node {
20860 children: vec![
20861 Trivia::missing(db).0,
20862 TokenElse::missing(db).0,
20863 Trivia::missing(db).0,
20864 ],
20865 width: TextWidth::default(),
20866 },
20867 })
20868 .intern(db),
20869 )
20870 }
20871 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20872 let kind = node.kind(db);
20873 assert_eq!(
20874 kind,
20875 SyntaxKind::TerminalElse,
20876 "Unexpected SyntaxKind {:?}. Expected {:?}.",
20877 kind,
20878 SyntaxKind::TerminalElse
20879 );
20880 let children = db.get_children(node.clone());
20881 Self { node, children }
20882 }
20883 fn as_syntax_node(&self) -> SyntaxNode {
20884 self.node.clone()
20885 }
20886 fn stable_ptr(&self) -> Self::StablePtr {
20887 TerminalElsePtr(self.node.0.stable_ptr)
20888 }
20889}
20890impl From<&TerminalElse> for SyntaxStablePtrId {
20891 fn from(node: &TerminalElse) -> Self {
20892 node.stable_ptr().untyped()
20893 }
20894}
20895#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20896pub struct TokenEnum {
20897 node: SyntaxNode,
20898}
20899impl Token for TokenEnum {
20900 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
20901 TokenEnumGreen(
20902 Arc::new(GreenNode {
20903 kind: SyntaxKind::TokenEnum,
20904 details: GreenNodeDetails::Token(text),
20905 })
20906 .intern(db),
20907 )
20908 }
20909 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20910 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
20911 .clone()
20912 }
20913}
20914#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20915pub struct TokenEnumPtr(pub SyntaxStablePtrId);
20916impl TypedStablePtr for TokenEnumPtr {
20917 type SyntaxNode = TokenEnum;
20918 fn untyped(&self) -> SyntaxStablePtrId {
20919 self.0
20920 }
20921 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEnum {
20922 TokenEnum::from_syntax_node(db, self.0.lookup(db))
20923 }
20924}
20925impl From<TokenEnumPtr> for SyntaxStablePtrId {
20926 fn from(ptr: TokenEnumPtr) -> Self {
20927 ptr.untyped()
20928 }
20929}
20930#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
20931pub struct TokenEnumGreen(pub GreenId);
20932impl TokenEnumGreen {
20933 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20934 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
20935 }
20936}
20937impl TypedSyntaxNode for TokenEnum {
20938 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEnum);
20939 type StablePtr = TokenEnumPtr;
20940 type Green = TokenEnumGreen;
20941 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
20942 TokenEnumGreen(
20943 Arc::new(GreenNode {
20944 kind: SyntaxKind::TokenMissing,
20945 details: GreenNodeDetails::Token("".into()),
20946 })
20947 .intern(db),
20948 )
20949 }
20950 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
20951 match node.0.green.lookup_intern(db).details {
20952 GreenNodeDetails::Token(_) => Self { node },
20953 GreenNodeDetails::Node { .. } => {
20954 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEnum)
20955 }
20956 }
20957 }
20958 fn as_syntax_node(&self) -> SyntaxNode {
20959 self.node.clone()
20960 }
20961 fn stable_ptr(&self) -> Self::StablePtr {
20962 TokenEnumPtr(self.node.0.stable_ptr)
20963 }
20964}
20965impl From<&TokenEnum> for SyntaxStablePtrId {
20966 fn from(node: &TokenEnum) -> Self {
20967 node.stable_ptr().untyped()
20968 }
20969}
20970#[derive(Clone, Debug, Eq, Hash, PartialEq)]
20971pub struct TerminalEnum {
20972 node: SyntaxNode,
20973 children: Arc<[SyntaxNode]>,
20974}
20975impl Terminal for TerminalEnum {
20976 const KIND: SyntaxKind = SyntaxKind::TerminalEnum;
20977 type TokenType = TokenEnum;
20978 fn new_green(
20979 db: &dyn SyntaxGroup,
20980 leading_trivia: TriviaGreen,
20981 token: <<TerminalEnum as Terminal>::TokenType as TypedSyntaxNode>::Green,
20982 trailing_trivia: TriviaGreen,
20983 ) -> Self::Green {
20984 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
20985 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
20986 TerminalEnumGreen(
20987 Arc::new(GreenNode {
20988 kind: SyntaxKind::TerminalEnum,
20989 details: GreenNodeDetails::Node { children, width },
20990 })
20991 .intern(db),
20992 )
20993 }
20994 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
20995 self.token(db).text(db)
20996 }
20997}
20998impl TerminalEnum {
20999 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21000 Trivia::from_syntax_node(db, self.children[0].clone())
21001 }
21002 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEnum {
21003 TokenEnum::from_syntax_node(db, self.children[1].clone())
21004 }
21005 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21006 Trivia::from_syntax_node(db, self.children[2].clone())
21007 }
21008}
21009#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21010pub struct TerminalEnumPtr(pub SyntaxStablePtrId);
21011impl TerminalEnumPtr {}
21012impl TypedStablePtr for TerminalEnumPtr {
21013 type SyntaxNode = TerminalEnum;
21014 fn untyped(&self) -> SyntaxStablePtrId {
21015 self.0
21016 }
21017 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEnum {
21018 TerminalEnum::from_syntax_node(db, self.0.lookup(db))
21019 }
21020}
21021impl From<TerminalEnumPtr> for SyntaxStablePtrId {
21022 fn from(ptr: TerminalEnumPtr) -> Self {
21023 ptr.untyped()
21024 }
21025}
21026#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21027pub struct TerminalEnumGreen(pub GreenId);
21028impl TypedSyntaxNode for TerminalEnum {
21029 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEnum);
21030 type StablePtr = TerminalEnumPtr;
21031 type Green = TerminalEnumGreen;
21032 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21033 TerminalEnumGreen(
21034 Arc::new(GreenNode {
21035 kind: SyntaxKind::TerminalEnum,
21036 details: GreenNodeDetails::Node {
21037 children: vec![
21038 Trivia::missing(db).0,
21039 TokenEnum::missing(db).0,
21040 Trivia::missing(db).0,
21041 ],
21042 width: TextWidth::default(),
21043 },
21044 })
21045 .intern(db),
21046 )
21047 }
21048 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21049 let kind = node.kind(db);
21050 assert_eq!(
21051 kind,
21052 SyntaxKind::TerminalEnum,
21053 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21054 kind,
21055 SyntaxKind::TerminalEnum
21056 );
21057 let children = db.get_children(node.clone());
21058 Self { node, children }
21059 }
21060 fn as_syntax_node(&self) -> SyntaxNode {
21061 self.node.clone()
21062 }
21063 fn stable_ptr(&self) -> Self::StablePtr {
21064 TerminalEnumPtr(self.node.0.stable_ptr)
21065 }
21066}
21067impl From<&TerminalEnum> for SyntaxStablePtrId {
21068 fn from(node: &TerminalEnum) -> Self {
21069 node.stable_ptr().untyped()
21070 }
21071}
21072#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21073pub struct TokenExtern {
21074 node: SyntaxNode,
21075}
21076impl Token for TokenExtern {
21077 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21078 TokenExternGreen(
21079 Arc::new(GreenNode {
21080 kind: SyntaxKind::TokenExtern,
21081 details: GreenNodeDetails::Token(text),
21082 })
21083 .intern(db),
21084 )
21085 }
21086 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21087 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21088 .clone()
21089 }
21090}
21091#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21092pub struct TokenExternPtr(pub SyntaxStablePtrId);
21093impl TypedStablePtr for TokenExternPtr {
21094 type SyntaxNode = TokenExtern;
21095 fn untyped(&self) -> SyntaxStablePtrId {
21096 self.0
21097 }
21098 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenExtern {
21099 TokenExtern::from_syntax_node(db, self.0.lookup(db))
21100 }
21101}
21102impl From<TokenExternPtr> for SyntaxStablePtrId {
21103 fn from(ptr: TokenExternPtr) -> Self {
21104 ptr.untyped()
21105 }
21106}
21107#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21108pub struct TokenExternGreen(pub GreenId);
21109impl TokenExternGreen {
21110 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21111 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21112 }
21113}
21114impl TypedSyntaxNode for TokenExtern {
21115 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenExtern);
21116 type StablePtr = TokenExternPtr;
21117 type Green = TokenExternGreen;
21118 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21119 TokenExternGreen(
21120 Arc::new(GreenNode {
21121 kind: SyntaxKind::TokenMissing,
21122 details: GreenNodeDetails::Token("".into()),
21123 })
21124 .intern(db),
21125 )
21126 }
21127 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21128 match node.0.green.lookup_intern(db).details {
21129 GreenNodeDetails::Token(_) => Self { node },
21130 GreenNodeDetails::Node { .. } => {
21131 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenExtern)
21132 }
21133 }
21134 }
21135 fn as_syntax_node(&self) -> SyntaxNode {
21136 self.node.clone()
21137 }
21138 fn stable_ptr(&self) -> Self::StablePtr {
21139 TokenExternPtr(self.node.0.stable_ptr)
21140 }
21141}
21142impl From<&TokenExtern> for SyntaxStablePtrId {
21143 fn from(node: &TokenExtern) -> Self {
21144 node.stable_ptr().untyped()
21145 }
21146}
21147#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21148pub struct TerminalExtern {
21149 node: SyntaxNode,
21150 children: Arc<[SyntaxNode]>,
21151}
21152impl Terminal for TerminalExtern {
21153 const KIND: SyntaxKind = SyntaxKind::TerminalExtern;
21154 type TokenType = TokenExtern;
21155 fn new_green(
21156 db: &dyn SyntaxGroup,
21157 leading_trivia: TriviaGreen,
21158 token: <<TerminalExtern as Terminal>::TokenType as TypedSyntaxNode>::Green,
21159 trailing_trivia: TriviaGreen,
21160 ) -> Self::Green {
21161 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21162 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21163 TerminalExternGreen(
21164 Arc::new(GreenNode {
21165 kind: SyntaxKind::TerminalExtern,
21166 details: GreenNodeDetails::Node { children, width },
21167 })
21168 .intern(db),
21169 )
21170 }
21171 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21172 self.token(db).text(db)
21173 }
21174}
21175impl TerminalExtern {
21176 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21177 Trivia::from_syntax_node(db, self.children[0].clone())
21178 }
21179 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenExtern {
21180 TokenExtern::from_syntax_node(db, self.children[1].clone())
21181 }
21182 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21183 Trivia::from_syntax_node(db, self.children[2].clone())
21184 }
21185}
21186#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21187pub struct TerminalExternPtr(pub SyntaxStablePtrId);
21188impl TerminalExternPtr {}
21189impl TypedStablePtr for TerminalExternPtr {
21190 type SyntaxNode = TerminalExtern;
21191 fn untyped(&self) -> SyntaxStablePtrId {
21192 self.0
21193 }
21194 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalExtern {
21195 TerminalExtern::from_syntax_node(db, self.0.lookup(db))
21196 }
21197}
21198impl From<TerminalExternPtr> for SyntaxStablePtrId {
21199 fn from(ptr: TerminalExternPtr) -> Self {
21200 ptr.untyped()
21201 }
21202}
21203#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21204pub struct TerminalExternGreen(pub GreenId);
21205impl TypedSyntaxNode for TerminalExtern {
21206 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalExtern);
21207 type StablePtr = TerminalExternPtr;
21208 type Green = TerminalExternGreen;
21209 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21210 TerminalExternGreen(
21211 Arc::new(GreenNode {
21212 kind: SyntaxKind::TerminalExtern,
21213 details: GreenNodeDetails::Node {
21214 children: vec![
21215 Trivia::missing(db).0,
21216 TokenExtern::missing(db).0,
21217 Trivia::missing(db).0,
21218 ],
21219 width: TextWidth::default(),
21220 },
21221 })
21222 .intern(db),
21223 )
21224 }
21225 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21226 let kind = node.kind(db);
21227 assert_eq!(
21228 kind,
21229 SyntaxKind::TerminalExtern,
21230 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21231 kind,
21232 SyntaxKind::TerminalExtern
21233 );
21234 let children = db.get_children(node.clone());
21235 Self { node, children }
21236 }
21237 fn as_syntax_node(&self) -> SyntaxNode {
21238 self.node.clone()
21239 }
21240 fn stable_ptr(&self) -> Self::StablePtr {
21241 TerminalExternPtr(self.node.0.stable_ptr)
21242 }
21243}
21244impl From<&TerminalExtern> for SyntaxStablePtrId {
21245 fn from(node: &TerminalExtern) -> Self {
21246 node.stable_ptr().untyped()
21247 }
21248}
21249#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21250pub struct TokenFalse {
21251 node: SyntaxNode,
21252}
21253impl Token for TokenFalse {
21254 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21255 TokenFalseGreen(
21256 Arc::new(GreenNode {
21257 kind: SyntaxKind::TokenFalse,
21258 details: GreenNodeDetails::Token(text),
21259 })
21260 .intern(db),
21261 )
21262 }
21263 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21264 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21265 .clone()
21266 }
21267}
21268#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21269pub struct TokenFalsePtr(pub SyntaxStablePtrId);
21270impl TypedStablePtr for TokenFalsePtr {
21271 type SyntaxNode = TokenFalse;
21272 fn untyped(&self) -> SyntaxStablePtrId {
21273 self.0
21274 }
21275 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFalse {
21276 TokenFalse::from_syntax_node(db, self.0.lookup(db))
21277 }
21278}
21279impl From<TokenFalsePtr> for SyntaxStablePtrId {
21280 fn from(ptr: TokenFalsePtr) -> Self {
21281 ptr.untyped()
21282 }
21283}
21284#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21285pub struct TokenFalseGreen(pub GreenId);
21286impl TokenFalseGreen {
21287 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21288 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21289 }
21290}
21291impl TypedSyntaxNode for TokenFalse {
21292 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFalse);
21293 type StablePtr = TokenFalsePtr;
21294 type Green = TokenFalseGreen;
21295 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21296 TokenFalseGreen(
21297 Arc::new(GreenNode {
21298 kind: SyntaxKind::TokenMissing,
21299 details: GreenNodeDetails::Token("".into()),
21300 })
21301 .intern(db),
21302 )
21303 }
21304 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21305 match node.0.green.lookup_intern(db).details {
21306 GreenNodeDetails::Token(_) => Self { node },
21307 GreenNodeDetails::Node { .. } => {
21308 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFalse)
21309 }
21310 }
21311 }
21312 fn as_syntax_node(&self) -> SyntaxNode {
21313 self.node.clone()
21314 }
21315 fn stable_ptr(&self) -> Self::StablePtr {
21316 TokenFalsePtr(self.node.0.stable_ptr)
21317 }
21318}
21319impl From<&TokenFalse> for SyntaxStablePtrId {
21320 fn from(node: &TokenFalse) -> Self {
21321 node.stable_ptr().untyped()
21322 }
21323}
21324#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21325pub struct TerminalFalse {
21326 node: SyntaxNode,
21327 children: Arc<[SyntaxNode]>,
21328}
21329impl Terminal for TerminalFalse {
21330 const KIND: SyntaxKind = SyntaxKind::TerminalFalse;
21331 type TokenType = TokenFalse;
21332 fn new_green(
21333 db: &dyn SyntaxGroup,
21334 leading_trivia: TriviaGreen,
21335 token: <<TerminalFalse as Terminal>::TokenType as TypedSyntaxNode>::Green,
21336 trailing_trivia: TriviaGreen,
21337 ) -> Self::Green {
21338 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21339 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21340 TerminalFalseGreen(
21341 Arc::new(GreenNode {
21342 kind: SyntaxKind::TerminalFalse,
21343 details: GreenNodeDetails::Node { children, width },
21344 })
21345 .intern(db),
21346 )
21347 }
21348 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21349 self.token(db).text(db)
21350 }
21351}
21352impl TerminalFalse {
21353 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21354 Trivia::from_syntax_node(db, self.children[0].clone())
21355 }
21356 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFalse {
21357 TokenFalse::from_syntax_node(db, self.children[1].clone())
21358 }
21359 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21360 Trivia::from_syntax_node(db, self.children[2].clone())
21361 }
21362}
21363#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21364pub struct TerminalFalsePtr(pub SyntaxStablePtrId);
21365impl TerminalFalsePtr {}
21366impl TypedStablePtr for TerminalFalsePtr {
21367 type SyntaxNode = TerminalFalse;
21368 fn untyped(&self) -> SyntaxStablePtrId {
21369 self.0
21370 }
21371 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFalse {
21372 TerminalFalse::from_syntax_node(db, self.0.lookup(db))
21373 }
21374}
21375impl From<TerminalFalsePtr> for SyntaxStablePtrId {
21376 fn from(ptr: TerminalFalsePtr) -> Self {
21377 ptr.untyped()
21378 }
21379}
21380#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21381pub struct TerminalFalseGreen(pub GreenId);
21382impl TypedSyntaxNode for TerminalFalse {
21383 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFalse);
21384 type StablePtr = TerminalFalsePtr;
21385 type Green = TerminalFalseGreen;
21386 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21387 TerminalFalseGreen(
21388 Arc::new(GreenNode {
21389 kind: SyntaxKind::TerminalFalse,
21390 details: GreenNodeDetails::Node {
21391 children: vec![
21392 Trivia::missing(db).0,
21393 TokenFalse::missing(db).0,
21394 Trivia::missing(db).0,
21395 ],
21396 width: TextWidth::default(),
21397 },
21398 })
21399 .intern(db),
21400 )
21401 }
21402 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21403 let kind = node.kind(db);
21404 assert_eq!(
21405 kind,
21406 SyntaxKind::TerminalFalse,
21407 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21408 kind,
21409 SyntaxKind::TerminalFalse
21410 );
21411 let children = db.get_children(node.clone());
21412 Self { node, children }
21413 }
21414 fn as_syntax_node(&self) -> SyntaxNode {
21415 self.node.clone()
21416 }
21417 fn stable_ptr(&self) -> Self::StablePtr {
21418 TerminalFalsePtr(self.node.0.stable_ptr)
21419 }
21420}
21421impl From<&TerminalFalse> for SyntaxStablePtrId {
21422 fn from(node: &TerminalFalse) -> Self {
21423 node.stable_ptr().untyped()
21424 }
21425}
21426#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21427pub struct TokenFunction {
21428 node: SyntaxNode,
21429}
21430impl Token for TokenFunction {
21431 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21432 TokenFunctionGreen(
21433 Arc::new(GreenNode {
21434 kind: SyntaxKind::TokenFunction,
21435 details: GreenNodeDetails::Token(text),
21436 })
21437 .intern(db),
21438 )
21439 }
21440 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21441 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21442 .clone()
21443 }
21444}
21445#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21446pub struct TokenFunctionPtr(pub SyntaxStablePtrId);
21447impl TypedStablePtr for TokenFunctionPtr {
21448 type SyntaxNode = TokenFunction;
21449 fn untyped(&self) -> SyntaxStablePtrId {
21450 self.0
21451 }
21452 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFunction {
21453 TokenFunction::from_syntax_node(db, self.0.lookup(db))
21454 }
21455}
21456impl From<TokenFunctionPtr> for SyntaxStablePtrId {
21457 fn from(ptr: TokenFunctionPtr) -> Self {
21458 ptr.untyped()
21459 }
21460}
21461#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21462pub struct TokenFunctionGreen(pub GreenId);
21463impl TokenFunctionGreen {
21464 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21465 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21466 }
21467}
21468impl TypedSyntaxNode for TokenFunction {
21469 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFunction);
21470 type StablePtr = TokenFunctionPtr;
21471 type Green = TokenFunctionGreen;
21472 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21473 TokenFunctionGreen(
21474 Arc::new(GreenNode {
21475 kind: SyntaxKind::TokenMissing,
21476 details: GreenNodeDetails::Token("".into()),
21477 })
21478 .intern(db),
21479 )
21480 }
21481 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21482 match node.0.green.lookup_intern(db).details {
21483 GreenNodeDetails::Token(_) => Self { node },
21484 GreenNodeDetails::Node { .. } => {
21485 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFunction)
21486 }
21487 }
21488 }
21489 fn as_syntax_node(&self) -> SyntaxNode {
21490 self.node.clone()
21491 }
21492 fn stable_ptr(&self) -> Self::StablePtr {
21493 TokenFunctionPtr(self.node.0.stable_ptr)
21494 }
21495}
21496impl From<&TokenFunction> for SyntaxStablePtrId {
21497 fn from(node: &TokenFunction) -> Self {
21498 node.stable_ptr().untyped()
21499 }
21500}
21501#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21502pub struct TerminalFunction {
21503 node: SyntaxNode,
21504 children: Arc<[SyntaxNode]>,
21505}
21506impl Terminal for TerminalFunction {
21507 const KIND: SyntaxKind = SyntaxKind::TerminalFunction;
21508 type TokenType = TokenFunction;
21509 fn new_green(
21510 db: &dyn SyntaxGroup,
21511 leading_trivia: TriviaGreen,
21512 token: <<TerminalFunction as Terminal>::TokenType as TypedSyntaxNode>::Green,
21513 trailing_trivia: TriviaGreen,
21514 ) -> Self::Green {
21515 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21516 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21517 TerminalFunctionGreen(
21518 Arc::new(GreenNode {
21519 kind: SyntaxKind::TerminalFunction,
21520 details: GreenNodeDetails::Node { children, width },
21521 })
21522 .intern(db),
21523 )
21524 }
21525 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21526 self.token(db).text(db)
21527 }
21528}
21529impl TerminalFunction {
21530 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21531 Trivia::from_syntax_node(db, self.children[0].clone())
21532 }
21533 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFunction {
21534 TokenFunction::from_syntax_node(db, self.children[1].clone())
21535 }
21536 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21537 Trivia::from_syntax_node(db, self.children[2].clone())
21538 }
21539}
21540#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21541pub struct TerminalFunctionPtr(pub SyntaxStablePtrId);
21542impl TerminalFunctionPtr {}
21543impl TypedStablePtr for TerminalFunctionPtr {
21544 type SyntaxNode = TerminalFunction;
21545 fn untyped(&self) -> SyntaxStablePtrId {
21546 self.0
21547 }
21548 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFunction {
21549 TerminalFunction::from_syntax_node(db, self.0.lookup(db))
21550 }
21551}
21552impl From<TerminalFunctionPtr> for SyntaxStablePtrId {
21553 fn from(ptr: TerminalFunctionPtr) -> Self {
21554 ptr.untyped()
21555 }
21556}
21557#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21558pub struct TerminalFunctionGreen(pub GreenId);
21559impl TypedSyntaxNode for TerminalFunction {
21560 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFunction);
21561 type StablePtr = TerminalFunctionPtr;
21562 type Green = TerminalFunctionGreen;
21563 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21564 TerminalFunctionGreen(
21565 Arc::new(GreenNode {
21566 kind: SyntaxKind::TerminalFunction,
21567 details: GreenNodeDetails::Node {
21568 children: vec![
21569 Trivia::missing(db).0,
21570 TokenFunction::missing(db).0,
21571 Trivia::missing(db).0,
21572 ],
21573 width: TextWidth::default(),
21574 },
21575 })
21576 .intern(db),
21577 )
21578 }
21579 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21580 let kind = node.kind(db);
21581 assert_eq!(
21582 kind,
21583 SyntaxKind::TerminalFunction,
21584 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21585 kind,
21586 SyntaxKind::TerminalFunction
21587 );
21588 let children = db.get_children(node.clone());
21589 Self { node, children }
21590 }
21591 fn as_syntax_node(&self) -> SyntaxNode {
21592 self.node.clone()
21593 }
21594 fn stable_ptr(&self) -> Self::StablePtr {
21595 TerminalFunctionPtr(self.node.0.stable_ptr)
21596 }
21597}
21598impl From<&TerminalFunction> for SyntaxStablePtrId {
21599 fn from(node: &TerminalFunction) -> Self {
21600 node.stable_ptr().untyped()
21601 }
21602}
21603#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21604pub struct TokenIf {
21605 node: SyntaxNode,
21606}
21607impl Token for TokenIf {
21608 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21609 TokenIfGreen(
21610 Arc::new(GreenNode {
21611 kind: SyntaxKind::TokenIf,
21612 details: GreenNodeDetails::Token(text),
21613 })
21614 .intern(db),
21615 )
21616 }
21617 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21618 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21619 .clone()
21620 }
21621}
21622#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21623pub struct TokenIfPtr(pub SyntaxStablePtrId);
21624impl TypedStablePtr for TokenIfPtr {
21625 type SyntaxNode = TokenIf;
21626 fn untyped(&self) -> SyntaxStablePtrId {
21627 self.0
21628 }
21629 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenIf {
21630 TokenIf::from_syntax_node(db, self.0.lookup(db))
21631 }
21632}
21633impl From<TokenIfPtr> for SyntaxStablePtrId {
21634 fn from(ptr: TokenIfPtr) -> Self {
21635 ptr.untyped()
21636 }
21637}
21638#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21639pub struct TokenIfGreen(pub GreenId);
21640impl TokenIfGreen {
21641 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21642 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21643 }
21644}
21645impl TypedSyntaxNode for TokenIf {
21646 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenIf);
21647 type StablePtr = TokenIfPtr;
21648 type Green = TokenIfGreen;
21649 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21650 TokenIfGreen(
21651 Arc::new(GreenNode {
21652 kind: SyntaxKind::TokenMissing,
21653 details: GreenNodeDetails::Token("".into()),
21654 })
21655 .intern(db),
21656 )
21657 }
21658 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21659 match node.0.green.lookup_intern(db).details {
21660 GreenNodeDetails::Token(_) => Self { node },
21661 GreenNodeDetails::Node { .. } => {
21662 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenIf)
21663 }
21664 }
21665 }
21666 fn as_syntax_node(&self) -> SyntaxNode {
21667 self.node.clone()
21668 }
21669 fn stable_ptr(&self) -> Self::StablePtr {
21670 TokenIfPtr(self.node.0.stable_ptr)
21671 }
21672}
21673impl From<&TokenIf> for SyntaxStablePtrId {
21674 fn from(node: &TokenIf) -> Self {
21675 node.stable_ptr().untyped()
21676 }
21677}
21678#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21679pub struct TerminalIf {
21680 node: SyntaxNode,
21681 children: Arc<[SyntaxNode]>,
21682}
21683impl Terminal for TerminalIf {
21684 const KIND: SyntaxKind = SyntaxKind::TerminalIf;
21685 type TokenType = TokenIf;
21686 fn new_green(
21687 db: &dyn SyntaxGroup,
21688 leading_trivia: TriviaGreen,
21689 token: <<TerminalIf as Terminal>::TokenType as TypedSyntaxNode>::Green,
21690 trailing_trivia: TriviaGreen,
21691 ) -> Self::Green {
21692 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21693 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21694 TerminalIfGreen(
21695 Arc::new(GreenNode {
21696 kind: SyntaxKind::TerminalIf,
21697 details: GreenNodeDetails::Node { children, width },
21698 })
21699 .intern(db),
21700 )
21701 }
21702 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21703 self.token(db).text(db)
21704 }
21705}
21706impl TerminalIf {
21707 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21708 Trivia::from_syntax_node(db, self.children[0].clone())
21709 }
21710 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenIf {
21711 TokenIf::from_syntax_node(db, self.children[1].clone())
21712 }
21713 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21714 Trivia::from_syntax_node(db, self.children[2].clone())
21715 }
21716}
21717#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21718pub struct TerminalIfPtr(pub SyntaxStablePtrId);
21719impl TerminalIfPtr {}
21720impl TypedStablePtr for TerminalIfPtr {
21721 type SyntaxNode = TerminalIf;
21722 fn untyped(&self) -> SyntaxStablePtrId {
21723 self.0
21724 }
21725 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalIf {
21726 TerminalIf::from_syntax_node(db, self.0.lookup(db))
21727 }
21728}
21729impl From<TerminalIfPtr> for SyntaxStablePtrId {
21730 fn from(ptr: TerminalIfPtr) -> Self {
21731 ptr.untyped()
21732 }
21733}
21734#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21735pub struct TerminalIfGreen(pub GreenId);
21736impl TypedSyntaxNode for TerminalIf {
21737 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalIf);
21738 type StablePtr = TerminalIfPtr;
21739 type Green = TerminalIfGreen;
21740 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21741 TerminalIfGreen(
21742 Arc::new(GreenNode {
21743 kind: SyntaxKind::TerminalIf,
21744 details: GreenNodeDetails::Node {
21745 children: vec![
21746 Trivia::missing(db).0,
21747 TokenIf::missing(db).0,
21748 Trivia::missing(db).0,
21749 ],
21750 width: TextWidth::default(),
21751 },
21752 })
21753 .intern(db),
21754 )
21755 }
21756 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21757 let kind = node.kind(db);
21758 assert_eq!(
21759 kind,
21760 SyntaxKind::TerminalIf,
21761 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21762 kind,
21763 SyntaxKind::TerminalIf
21764 );
21765 let children = db.get_children(node.clone());
21766 Self { node, children }
21767 }
21768 fn as_syntax_node(&self) -> SyntaxNode {
21769 self.node.clone()
21770 }
21771 fn stable_ptr(&self) -> Self::StablePtr {
21772 TerminalIfPtr(self.node.0.stable_ptr)
21773 }
21774}
21775impl From<&TerminalIf> for SyntaxStablePtrId {
21776 fn from(node: &TerminalIf) -> Self {
21777 node.stable_ptr().untyped()
21778 }
21779}
21780#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21781pub struct TokenWhile {
21782 node: SyntaxNode,
21783}
21784impl Token for TokenWhile {
21785 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21786 TokenWhileGreen(
21787 Arc::new(GreenNode {
21788 kind: SyntaxKind::TokenWhile,
21789 details: GreenNodeDetails::Token(text),
21790 })
21791 .intern(db),
21792 )
21793 }
21794 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21795 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21796 .clone()
21797 }
21798}
21799#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21800pub struct TokenWhilePtr(pub SyntaxStablePtrId);
21801impl TypedStablePtr for TokenWhilePtr {
21802 type SyntaxNode = TokenWhile;
21803 fn untyped(&self) -> SyntaxStablePtrId {
21804 self.0
21805 }
21806 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenWhile {
21807 TokenWhile::from_syntax_node(db, self.0.lookup(db))
21808 }
21809}
21810impl From<TokenWhilePtr> for SyntaxStablePtrId {
21811 fn from(ptr: TokenWhilePtr) -> Self {
21812 ptr.untyped()
21813 }
21814}
21815#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21816pub struct TokenWhileGreen(pub GreenId);
21817impl TokenWhileGreen {
21818 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21819 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21820 }
21821}
21822impl TypedSyntaxNode for TokenWhile {
21823 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenWhile);
21824 type StablePtr = TokenWhilePtr;
21825 type Green = TokenWhileGreen;
21826 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21827 TokenWhileGreen(
21828 Arc::new(GreenNode {
21829 kind: SyntaxKind::TokenMissing,
21830 details: GreenNodeDetails::Token("".into()),
21831 })
21832 .intern(db),
21833 )
21834 }
21835 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21836 match node.0.green.lookup_intern(db).details {
21837 GreenNodeDetails::Token(_) => Self { node },
21838 GreenNodeDetails::Node { .. } => {
21839 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenWhile)
21840 }
21841 }
21842 }
21843 fn as_syntax_node(&self) -> SyntaxNode {
21844 self.node.clone()
21845 }
21846 fn stable_ptr(&self) -> Self::StablePtr {
21847 TokenWhilePtr(self.node.0.stable_ptr)
21848 }
21849}
21850impl From<&TokenWhile> for SyntaxStablePtrId {
21851 fn from(node: &TokenWhile) -> Self {
21852 node.stable_ptr().untyped()
21853 }
21854}
21855#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21856pub struct TerminalWhile {
21857 node: SyntaxNode,
21858 children: Arc<[SyntaxNode]>,
21859}
21860impl Terminal for TerminalWhile {
21861 const KIND: SyntaxKind = SyntaxKind::TerminalWhile;
21862 type TokenType = TokenWhile;
21863 fn new_green(
21864 db: &dyn SyntaxGroup,
21865 leading_trivia: TriviaGreen,
21866 token: <<TerminalWhile as Terminal>::TokenType as TypedSyntaxNode>::Green,
21867 trailing_trivia: TriviaGreen,
21868 ) -> Self::Green {
21869 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
21870 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
21871 TerminalWhileGreen(
21872 Arc::new(GreenNode {
21873 kind: SyntaxKind::TerminalWhile,
21874 details: GreenNodeDetails::Node { children, width },
21875 })
21876 .intern(db),
21877 )
21878 }
21879 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21880 self.token(db).text(db)
21881 }
21882}
21883impl TerminalWhile {
21884 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21885 Trivia::from_syntax_node(db, self.children[0].clone())
21886 }
21887 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenWhile {
21888 TokenWhile::from_syntax_node(db, self.children[1].clone())
21889 }
21890 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
21891 Trivia::from_syntax_node(db, self.children[2].clone())
21892 }
21893}
21894#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21895pub struct TerminalWhilePtr(pub SyntaxStablePtrId);
21896impl TerminalWhilePtr {}
21897impl TypedStablePtr for TerminalWhilePtr {
21898 type SyntaxNode = TerminalWhile;
21899 fn untyped(&self) -> SyntaxStablePtrId {
21900 self.0
21901 }
21902 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalWhile {
21903 TerminalWhile::from_syntax_node(db, self.0.lookup(db))
21904 }
21905}
21906impl From<TerminalWhilePtr> for SyntaxStablePtrId {
21907 fn from(ptr: TerminalWhilePtr) -> Self {
21908 ptr.untyped()
21909 }
21910}
21911#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21912pub struct TerminalWhileGreen(pub GreenId);
21913impl TypedSyntaxNode for TerminalWhile {
21914 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalWhile);
21915 type StablePtr = TerminalWhilePtr;
21916 type Green = TerminalWhileGreen;
21917 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
21918 TerminalWhileGreen(
21919 Arc::new(GreenNode {
21920 kind: SyntaxKind::TerminalWhile,
21921 details: GreenNodeDetails::Node {
21922 children: vec![
21923 Trivia::missing(db).0,
21924 TokenWhile::missing(db).0,
21925 Trivia::missing(db).0,
21926 ],
21927 width: TextWidth::default(),
21928 },
21929 })
21930 .intern(db),
21931 )
21932 }
21933 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
21934 let kind = node.kind(db);
21935 assert_eq!(
21936 kind,
21937 SyntaxKind::TerminalWhile,
21938 "Unexpected SyntaxKind {:?}. Expected {:?}.",
21939 kind,
21940 SyntaxKind::TerminalWhile
21941 );
21942 let children = db.get_children(node.clone());
21943 Self { node, children }
21944 }
21945 fn as_syntax_node(&self) -> SyntaxNode {
21946 self.node.clone()
21947 }
21948 fn stable_ptr(&self) -> Self::StablePtr {
21949 TerminalWhilePtr(self.node.0.stable_ptr)
21950 }
21951}
21952impl From<&TerminalWhile> for SyntaxStablePtrId {
21953 fn from(node: &TerminalWhile) -> Self {
21954 node.stable_ptr().untyped()
21955 }
21956}
21957#[derive(Clone, Debug, Eq, Hash, PartialEq)]
21958pub struct TokenFor {
21959 node: SyntaxNode,
21960}
21961impl Token for TokenFor {
21962 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
21963 TokenForGreen(
21964 Arc::new(GreenNode {
21965 kind: SyntaxKind::TokenFor,
21966 details: GreenNodeDetails::Token(text),
21967 })
21968 .intern(db),
21969 )
21970 }
21971 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21972 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
21973 .clone()
21974 }
21975}
21976#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21977pub struct TokenForPtr(pub SyntaxStablePtrId);
21978impl TypedStablePtr for TokenForPtr {
21979 type SyntaxNode = TokenFor;
21980 fn untyped(&self) -> SyntaxStablePtrId {
21981 self.0
21982 }
21983 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenFor {
21984 TokenFor::from_syntax_node(db, self.0.lookup(db))
21985 }
21986}
21987impl From<TokenForPtr> for SyntaxStablePtrId {
21988 fn from(ptr: TokenForPtr) -> Self {
21989 ptr.untyped()
21990 }
21991}
21992#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
21993pub struct TokenForGreen(pub GreenId);
21994impl TokenForGreen {
21995 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
21996 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
21997 }
21998}
21999impl TypedSyntaxNode for TokenFor {
22000 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenFor);
22001 type StablePtr = TokenForPtr;
22002 type Green = TokenForGreen;
22003 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22004 TokenForGreen(
22005 Arc::new(GreenNode {
22006 kind: SyntaxKind::TokenMissing,
22007 details: GreenNodeDetails::Token("".into()),
22008 })
22009 .intern(db),
22010 )
22011 }
22012 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22013 match node.0.green.lookup_intern(db).details {
22014 GreenNodeDetails::Token(_) => Self { node },
22015 GreenNodeDetails::Node { .. } => {
22016 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenFor)
22017 }
22018 }
22019 }
22020 fn as_syntax_node(&self) -> SyntaxNode {
22021 self.node.clone()
22022 }
22023 fn stable_ptr(&self) -> Self::StablePtr {
22024 TokenForPtr(self.node.0.stable_ptr)
22025 }
22026}
22027impl From<&TokenFor> for SyntaxStablePtrId {
22028 fn from(node: &TokenFor) -> Self {
22029 node.stable_ptr().untyped()
22030 }
22031}
22032#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22033pub struct TerminalFor {
22034 node: SyntaxNode,
22035 children: Arc<[SyntaxNode]>,
22036}
22037impl Terminal for TerminalFor {
22038 const KIND: SyntaxKind = SyntaxKind::TerminalFor;
22039 type TokenType = TokenFor;
22040 fn new_green(
22041 db: &dyn SyntaxGroup,
22042 leading_trivia: TriviaGreen,
22043 token: <<TerminalFor as Terminal>::TokenType as TypedSyntaxNode>::Green,
22044 trailing_trivia: TriviaGreen,
22045 ) -> Self::Green {
22046 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22047 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22048 TerminalForGreen(
22049 Arc::new(GreenNode {
22050 kind: SyntaxKind::TerminalFor,
22051 details: GreenNodeDetails::Node { children, width },
22052 })
22053 .intern(db),
22054 )
22055 }
22056 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22057 self.token(db).text(db)
22058 }
22059}
22060impl TerminalFor {
22061 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22062 Trivia::from_syntax_node(db, self.children[0].clone())
22063 }
22064 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenFor {
22065 TokenFor::from_syntax_node(db, self.children[1].clone())
22066 }
22067 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22068 Trivia::from_syntax_node(db, self.children[2].clone())
22069 }
22070}
22071#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22072pub struct TerminalForPtr(pub SyntaxStablePtrId);
22073impl TerminalForPtr {}
22074impl TypedStablePtr for TerminalForPtr {
22075 type SyntaxNode = TerminalFor;
22076 fn untyped(&self) -> SyntaxStablePtrId {
22077 self.0
22078 }
22079 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalFor {
22080 TerminalFor::from_syntax_node(db, self.0.lookup(db))
22081 }
22082}
22083impl From<TerminalForPtr> for SyntaxStablePtrId {
22084 fn from(ptr: TerminalForPtr) -> Self {
22085 ptr.untyped()
22086 }
22087}
22088#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22089pub struct TerminalForGreen(pub GreenId);
22090impl TypedSyntaxNode for TerminalFor {
22091 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalFor);
22092 type StablePtr = TerminalForPtr;
22093 type Green = TerminalForGreen;
22094 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22095 TerminalForGreen(
22096 Arc::new(GreenNode {
22097 kind: SyntaxKind::TerminalFor,
22098 details: GreenNodeDetails::Node {
22099 children: vec![
22100 Trivia::missing(db).0,
22101 TokenFor::missing(db).0,
22102 Trivia::missing(db).0,
22103 ],
22104 width: TextWidth::default(),
22105 },
22106 })
22107 .intern(db),
22108 )
22109 }
22110 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22111 let kind = node.kind(db);
22112 assert_eq!(
22113 kind,
22114 SyntaxKind::TerminalFor,
22115 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22116 kind,
22117 SyntaxKind::TerminalFor
22118 );
22119 let children = db.get_children(node.clone());
22120 Self { node, children }
22121 }
22122 fn as_syntax_node(&self) -> SyntaxNode {
22123 self.node.clone()
22124 }
22125 fn stable_ptr(&self) -> Self::StablePtr {
22126 TerminalForPtr(self.node.0.stable_ptr)
22127 }
22128}
22129impl From<&TerminalFor> for SyntaxStablePtrId {
22130 fn from(node: &TerminalFor) -> Self {
22131 node.stable_ptr().untyped()
22132 }
22133}
22134#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22135pub struct TokenLoop {
22136 node: SyntaxNode,
22137}
22138impl Token for TokenLoop {
22139 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22140 TokenLoopGreen(
22141 Arc::new(GreenNode {
22142 kind: SyntaxKind::TokenLoop,
22143 details: GreenNodeDetails::Token(text),
22144 })
22145 .intern(db),
22146 )
22147 }
22148 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22149 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22150 .clone()
22151 }
22152}
22153#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22154pub struct TokenLoopPtr(pub SyntaxStablePtrId);
22155impl TypedStablePtr for TokenLoopPtr {
22156 type SyntaxNode = TokenLoop;
22157 fn untyped(&self) -> SyntaxStablePtrId {
22158 self.0
22159 }
22160 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLoop {
22161 TokenLoop::from_syntax_node(db, self.0.lookup(db))
22162 }
22163}
22164impl From<TokenLoopPtr> for SyntaxStablePtrId {
22165 fn from(ptr: TokenLoopPtr) -> Self {
22166 ptr.untyped()
22167 }
22168}
22169#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22170pub struct TokenLoopGreen(pub GreenId);
22171impl TokenLoopGreen {
22172 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22173 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22174 }
22175}
22176impl TypedSyntaxNode for TokenLoop {
22177 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLoop);
22178 type StablePtr = TokenLoopPtr;
22179 type Green = TokenLoopGreen;
22180 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22181 TokenLoopGreen(
22182 Arc::new(GreenNode {
22183 kind: SyntaxKind::TokenMissing,
22184 details: GreenNodeDetails::Token("".into()),
22185 })
22186 .intern(db),
22187 )
22188 }
22189 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22190 match node.0.green.lookup_intern(db).details {
22191 GreenNodeDetails::Token(_) => Self { node },
22192 GreenNodeDetails::Node { .. } => {
22193 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLoop)
22194 }
22195 }
22196 }
22197 fn as_syntax_node(&self) -> SyntaxNode {
22198 self.node.clone()
22199 }
22200 fn stable_ptr(&self) -> Self::StablePtr {
22201 TokenLoopPtr(self.node.0.stable_ptr)
22202 }
22203}
22204impl From<&TokenLoop> for SyntaxStablePtrId {
22205 fn from(node: &TokenLoop) -> Self {
22206 node.stable_ptr().untyped()
22207 }
22208}
22209#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22210pub struct TerminalLoop {
22211 node: SyntaxNode,
22212 children: Arc<[SyntaxNode]>,
22213}
22214impl Terminal for TerminalLoop {
22215 const KIND: SyntaxKind = SyntaxKind::TerminalLoop;
22216 type TokenType = TokenLoop;
22217 fn new_green(
22218 db: &dyn SyntaxGroup,
22219 leading_trivia: TriviaGreen,
22220 token: <<TerminalLoop as Terminal>::TokenType as TypedSyntaxNode>::Green,
22221 trailing_trivia: TriviaGreen,
22222 ) -> Self::Green {
22223 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22224 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22225 TerminalLoopGreen(
22226 Arc::new(GreenNode {
22227 kind: SyntaxKind::TerminalLoop,
22228 details: GreenNodeDetails::Node { children, width },
22229 })
22230 .intern(db),
22231 )
22232 }
22233 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22234 self.token(db).text(db)
22235 }
22236}
22237impl TerminalLoop {
22238 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22239 Trivia::from_syntax_node(db, self.children[0].clone())
22240 }
22241 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLoop {
22242 TokenLoop::from_syntax_node(db, self.children[1].clone())
22243 }
22244 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22245 Trivia::from_syntax_node(db, self.children[2].clone())
22246 }
22247}
22248#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22249pub struct TerminalLoopPtr(pub SyntaxStablePtrId);
22250impl TerminalLoopPtr {}
22251impl TypedStablePtr for TerminalLoopPtr {
22252 type SyntaxNode = TerminalLoop;
22253 fn untyped(&self) -> SyntaxStablePtrId {
22254 self.0
22255 }
22256 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLoop {
22257 TerminalLoop::from_syntax_node(db, self.0.lookup(db))
22258 }
22259}
22260impl From<TerminalLoopPtr> for SyntaxStablePtrId {
22261 fn from(ptr: TerminalLoopPtr) -> Self {
22262 ptr.untyped()
22263 }
22264}
22265#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22266pub struct TerminalLoopGreen(pub GreenId);
22267impl TypedSyntaxNode for TerminalLoop {
22268 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLoop);
22269 type StablePtr = TerminalLoopPtr;
22270 type Green = TerminalLoopGreen;
22271 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22272 TerminalLoopGreen(
22273 Arc::new(GreenNode {
22274 kind: SyntaxKind::TerminalLoop,
22275 details: GreenNodeDetails::Node {
22276 children: vec![
22277 Trivia::missing(db).0,
22278 TokenLoop::missing(db).0,
22279 Trivia::missing(db).0,
22280 ],
22281 width: TextWidth::default(),
22282 },
22283 })
22284 .intern(db),
22285 )
22286 }
22287 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22288 let kind = node.kind(db);
22289 assert_eq!(
22290 kind,
22291 SyntaxKind::TerminalLoop,
22292 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22293 kind,
22294 SyntaxKind::TerminalLoop
22295 );
22296 let children = db.get_children(node.clone());
22297 Self { node, children }
22298 }
22299 fn as_syntax_node(&self) -> SyntaxNode {
22300 self.node.clone()
22301 }
22302 fn stable_ptr(&self) -> Self::StablePtr {
22303 TerminalLoopPtr(self.node.0.stable_ptr)
22304 }
22305}
22306impl From<&TerminalLoop> for SyntaxStablePtrId {
22307 fn from(node: &TerminalLoop) -> Self {
22308 node.stable_ptr().untyped()
22309 }
22310}
22311#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22312pub struct TokenImpl {
22313 node: SyntaxNode,
22314}
22315impl Token for TokenImpl {
22316 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22317 TokenImplGreen(
22318 Arc::new(GreenNode {
22319 kind: SyntaxKind::TokenImpl,
22320 details: GreenNodeDetails::Token(text),
22321 })
22322 .intern(db),
22323 )
22324 }
22325 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22326 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22327 .clone()
22328 }
22329}
22330#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22331pub struct TokenImplPtr(pub SyntaxStablePtrId);
22332impl TypedStablePtr for TokenImplPtr {
22333 type SyntaxNode = TokenImpl;
22334 fn untyped(&self) -> SyntaxStablePtrId {
22335 self.0
22336 }
22337 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenImpl {
22338 TokenImpl::from_syntax_node(db, self.0.lookup(db))
22339 }
22340}
22341impl From<TokenImplPtr> for SyntaxStablePtrId {
22342 fn from(ptr: TokenImplPtr) -> Self {
22343 ptr.untyped()
22344 }
22345}
22346#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22347pub struct TokenImplGreen(pub GreenId);
22348impl TokenImplGreen {
22349 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22350 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22351 }
22352}
22353impl TypedSyntaxNode for TokenImpl {
22354 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenImpl);
22355 type StablePtr = TokenImplPtr;
22356 type Green = TokenImplGreen;
22357 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22358 TokenImplGreen(
22359 Arc::new(GreenNode {
22360 kind: SyntaxKind::TokenMissing,
22361 details: GreenNodeDetails::Token("".into()),
22362 })
22363 .intern(db),
22364 )
22365 }
22366 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22367 match node.0.green.lookup_intern(db).details {
22368 GreenNodeDetails::Token(_) => Self { node },
22369 GreenNodeDetails::Node { .. } => {
22370 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenImpl)
22371 }
22372 }
22373 }
22374 fn as_syntax_node(&self) -> SyntaxNode {
22375 self.node.clone()
22376 }
22377 fn stable_ptr(&self) -> Self::StablePtr {
22378 TokenImplPtr(self.node.0.stable_ptr)
22379 }
22380}
22381impl From<&TokenImpl> for SyntaxStablePtrId {
22382 fn from(node: &TokenImpl) -> Self {
22383 node.stable_ptr().untyped()
22384 }
22385}
22386#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22387pub struct TerminalImpl {
22388 node: SyntaxNode,
22389 children: Arc<[SyntaxNode]>,
22390}
22391impl Terminal for TerminalImpl {
22392 const KIND: SyntaxKind = SyntaxKind::TerminalImpl;
22393 type TokenType = TokenImpl;
22394 fn new_green(
22395 db: &dyn SyntaxGroup,
22396 leading_trivia: TriviaGreen,
22397 token: <<TerminalImpl as Terminal>::TokenType as TypedSyntaxNode>::Green,
22398 trailing_trivia: TriviaGreen,
22399 ) -> Self::Green {
22400 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22401 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22402 TerminalImplGreen(
22403 Arc::new(GreenNode {
22404 kind: SyntaxKind::TerminalImpl,
22405 details: GreenNodeDetails::Node { children, width },
22406 })
22407 .intern(db),
22408 )
22409 }
22410 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22411 self.token(db).text(db)
22412 }
22413}
22414impl TerminalImpl {
22415 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22416 Trivia::from_syntax_node(db, self.children[0].clone())
22417 }
22418 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenImpl {
22419 TokenImpl::from_syntax_node(db, self.children[1].clone())
22420 }
22421 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22422 Trivia::from_syntax_node(db, self.children[2].clone())
22423 }
22424}
22425#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22426pub struct TerminalImplPtr(pub SyntaxStablePtrId);
22427impl TerminalImplPtr {}
22428impl TypedStablePtr for TerminalImplPtr {
22429 type SyntaxNode = TerminalImpl;
22430 fn untyped(&self) -> SyntaxStablePtrId {
22431 self.0
22432 }
22433 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalImpl {
22434 TerminalImpl::from_syntax_node(db, self.0.lookup(db))
22435 }
22436}
22437impl From<TerminalImplPtr> for SyntaxStablePtrId {
22438 fn from(ptr: TerminalImplPtr) -> Self {
22439 ptr.untyped()
22440 }
22441}
22442#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22443pub struct TerminalImplGreen(pub GreenId);
22444impl TypedSyntaxNode for TerminalImpl {
22445 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalImpl);
22446 type StablePtr = TerminalImplPtr;
22447 type Green = TerminalImplGreen;
22448 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22449 TerminalImplGreen(
22450 Arc::new(GreenNode {
22451 kind: SyntaxKind::TerminalImpl,
22452 details: GreenNodeDetails::Node {
22453 children: vec![
22454 Trivia::missing(db).0,
22455 TokenImpl::missing(db).0,
22456 Trivia::missing(db).0,
22457 ],
22458 width: TextWidth::default(),
22459 },
22460 })
22461 .intern(db),
22462 )
22463 }
22464 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22465 let kind = node.kind(db);
22466 assert_eq!(
22467 kind,
22468 SyntaxKind::TerminalImpl,
22469 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22470 kind,
22471 SyntaxKind::TerminalImpl
22472 );
22473 let children = db.get_children(node.clone());
22474 Self { node, children }
22475 }
22476 fn as_syntax_node(&self) -> SyntaxNode {
22477 self.node.clone()
22478 }
22479 fn stable_ptr(&self) -> Self::StablePtr {
22480 TerminalImplPtr(self.node.0.stable_ptr)
22481 }
22482}
22483impl From<&TerminalImpl> for SyntaxStablePtrId {
22484 fn from(node: &TerminalImpl) -> Self {
22485 node.stable_ptr().untyped()
22486 }
22487}
22488#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22489pub struct TokenImplicits {
22490 node: SyntaxNode,
22491}
22492impl Token for TokenImplicits {
22493 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22494 TokenImplicitsGreen(
22495 Arc::new(GreenNode {
22496 kind: SyntaxKind::TokenImplicits,
22497 details: GreenNodeDetails::Token(text),
22498 })
22499 .intern(db),
22500 )
22501 }
22502 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22503 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22504 .clone()
22505 }
22506}
22507#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22508pub struct TokenImplicitsPtr(pub SyntaxStablePtrId);
22509impl TypedStablePtr for TokenImplicitsPtr {
22510 type SyntaxNode = TokenImplicits;
22511 fn untyped(&self) -> SyntaxStablePtrId {
22512 self.0
22513 }
22514 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenImplicits {
22515 TokenImplicits::from_syntax_node(db, self.0.lookup(db))
22516 }
22517}
22518impl From<TokenImplicitsPtr> for SyntaxStablePtrId {
22519 fn from(ptr: TokenImplicitsPtr) -> Self {
22520 ptr.untyped()
22521 }
22522}
22523#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22524pub struct TokenImplicitsGreen(pub GreenId);
22525impl TokenImplicitsGreen {
22526 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22527 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22528 }
22529}
22530impl TypedSyntaxNode for TokenImplicits {
22531 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenImplicits);
22532 type StablePtr = TokenImplicitsPtr;
22533 type Green = TokenImplicitsGreen;
22534 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22535 TokenImplicitsGreen(
22536 Arc::new(GreenNode {
22537 kind: SyntaxKind::TokenMissing,
22538 details: GreenNodeDetails::Token("".into()),
22539 })
22540 .intern(db),
22541 )
22542 }
22543 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22544 match node.0.green.lookup_intern(db).details {
22545 GreenNodeDetails::Token(_) => Self { node },
22546 GreenNodeDetails::Node { .. } => {
22547 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenImplicits)
22548 }
22549 }
22550 }
22551 fn as_syntax_node(&self) -> SyntaxNode {
22552 self.node.clone()
22553 }
22554 fn stable_ptr(&self) -> Self::StablePtr {
22555 TokenImplicitsPtr(self.node.0.stable_ptr)
22556 }
22557}
22558impl From<&TokenImplicits> for SyntaxStablePtrId {
22559 fn from(node: &TokenImplicits) -> Self {
22560 node.stable_ptr().untyped()
22561 }
22562}
22563#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22564pub struct TerminalImplicits {
22565 node: SyntaxNode,
22566 children: Arc<[SyntaxNode]>,
22567}
22568impl Terminal for TerminalImplicits {
22569 const KIND: SyntaxKind = SyntaxKind::TerminalImplicits;
22570 type TokenType = TokenImplicits;
22571 fn new_green(
22572 db: &dyn SyntaxGroup,
22573 leading_trivia: TriviaGreen,
22574 token: <<TerminalImplicits as Terminal>::TokenType as TypedSyntaxNode>::Green,
22575 trailing_trivia: TriviaGreen,
22576 ) -> Self::Green {
22577 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22578 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22579 TerminalImplicitsGreen(
22580 Arc::new(GreenNode {
22581 kind: SyntaxKind::TerminalImplicits,
22582 details: GreenNodeDetails::Node { children, width },
22583 })
22584 .intern(db),
22585 )
22586 }
22587 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22588 self.token(db).text(db)
22589 }
22590}
22591impl TerminalImplicits {
22592 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22593 Trivia::from_syntax_node(db, self.children[0].clone())
22594 }
22595 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenImplicits {
22596 TokenImplicits::from_syntax_node(db, self.children[1].clone())
22597 }
22598 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22599 Trivia::from_syntax_node(db, self.children[2].clone())
22600 }
22601}
22602#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22603pub struct TerminalImplicitsPtr(pub SyntaxStablePtrId);
22604impl TerminalImplicitsPtr {}
22605impl TypedStablePtr for TerminalImplicitsPtr {
22606 type SyntaxNode = TerminalImplicits;
22607 fn untyped(&self) -> SyntaxStablePtrId {
22608 self.0
22609 }
22610 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalImplicits {
22611 TerminalImplicits::from_syntax_node(db, self.0.lookup(db))
22612 }
22613}
22614impl From<TerminalImplicitsPtr> for SyntaxStablePtrId {
22615 fn from(ptr: TerminalImplicitsPtr) -> Self {
22616 ptr.untyped()
22617 }
22618}
22619#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22620pub struct TerminalImplicitsGreen(pub GreenId);
22621impl TypedSyntaxNode for TerminalImplicits {
22622 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalImplicits);
22623 type StablePtr = TerminalImplicitsPtr;
22624 type Green = TerminalImplicitsGreen;
22625 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22626 TerminalImplicitsGreen(
22627 Arc::new(GreenNode {
22628 kind: SyntaxKind::TerminalImplicits,
22629 details: GreenNodeDetails::Node {
22630 children: vec![
22631 Trivia::missing(db).0,
22632 TokenImplicits::missing(db).0,
22633 Trivia::missing(db).0,
22634 ],
22635 width: TextWidth::default(),
22636 },
22637 })
22638 .intern(db),
22639 )
22640 }
22641 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22642 let kind = node.kind(db);
22643 assert_eq!(
22644 kind,
22645 SyntaxKind::TerminalImplicits,
22646 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22647 kind,
22648 SyntaxKind::TerminalImplicits
22649 );
22650 let children = db.get_children(node.clone());
22651 Self { node, children }
22652 }
22653 fn as_syntax_node(&self) -> SyntaxNode {
22654 self.node.clone()
22655 }
22656 fn stable_ptr(&self) -> Self::StablePtr {
22657 TerminalImplicitsPtr(self.node.0.stable_ptr)
22658 }
22659}
22660impl From<&TerminalImplicits> for SyntaxStablePtrId {
22661 fn from(node: &TerminalImplicits) -> Self {
22662 node.stable_ptr().untyped()
22663 }
22664}
22665#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22666pub struct TokenLet {
22667 node: SyntaxNode,
22668}
22669impl Token for TokenLet {
22670 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22671 TokenLetGreen(
22672 Arc::new(GreenNode {
22673 kind: SyntaxKind::TokenLet,
22674 details: GreenNodeDetails::Token(text),
22675 })
22676 .intern(db),
22677 )
22678 }
22679 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22680 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22681 .clone()
22682 }
22683}
22684#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22685pub struct TokenLetPtr(pub SyntaxStablePtrId);
22686impl TypedStablePtr for TokenLetPtr {
22687 type SyntaxNode = TokenLet;
22688 fn untyped(&self) -> SyntaxStablePtrId {
22689 self.0
22690 }
22691 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLet {
22692 TokenLet::from_syntax_node(db, self.0.lookup(db))
22693 }
22694}
22695impl From<TokenLetPtr> for SyntaxStablePtrId {
22696 fn from(ptr: TokenLetPtr) -> Self {
22697 ptr.untyped()
22698 }
22699}
22700#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22701pub struct TokenLetGreen(pub GreenId);
22702impl TokenLetGreen {
22703 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22704 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22705 }
22706}
22707impl TypedSyntaxNode for TokenLet {
22708 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLet);
22709 type StablePtr = TokenLetPtr;
22710 type Green = TokenLetGreen;
22711 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22712 TokenLetGreen(
22713 Arc::new(GreenNode {
22714 kind: SyntaxKind::TokenMissing,
22715 details: GreenNodeDetails::Token("".into()),
22716 })
22717 .intern(db),
22718 )
22719 }
22720 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22721 match node.0.green.lookup_intern(db).details {
22722 GreenNodeDetails::Token(_) => Self { node },
22723 GreenNodeDetails::Node { .. } => {
22724 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLet)
22725 }
22726 }
22727 }
22728 fn as_syntax_node(&self) -> SyntaxNode {
22729 self.node.clone()
22730 }
22731 fn stable_ptr(&self) -> Self::StablePtr {
22732 TokenLetPtr(self.node.0.stable_ptr)
22733 }
22734}
22735impl From<&TokenLet> for SyntaxStablePtrId {
22736 fn from(node: &TokenLet) -> Self {
22737 node.stable_ptr().untyped()
22738 }
22739}
22740#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22741pub struct TerminalLet {
22742 node: SyntaxNode,
22743 children: Arc<[SyntaxNode]>,
22744}
22745impl Terminal for TerminalLet {
22746 const KIND: SyntaxKind = SyntaxKind::TerminalLet;
22747 type TokenType = TokenLet;
22748 fn new_green(
22749 db: &dyn SyntaxGroup,
22750 leading_trivia: TriviaGreen,
22751 token: <<TerminalLet as Terminal>::TokenType as TypedSyntaxNode>::Green,
22752 trailing_trivia: TriviaGreen,
22753 ) -> Self::Green {
22754 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22755 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22756 TerminalLetGreen(
22757 Arc::new(GreenNode {
22758 kind: SyntaxKind::TerminalLet,
22759 details: GreenNodeDetails::Node { children, width },
22760 })
22761 .intern(db),
22762 )
22763 }
22764 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22765 self.token(db).text(db)
22766 }
22767}
22768impl TerminalLet {
22769 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22770 Trivia::from_syntax_node(db, self.children[0].clone())
22771 }
22772 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLet {
22773 TokenLet::from_syntax_node(db, self.children[1].clone())
22774 }
22775 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22776 Trivia::from_syntax_node(db, self.children[2].clone())
22777 }
22778}
22779#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22780pub struct TerminalLetPtr(pub SyntaxStablePtrId);
22781impl TerminalLetPtr {}
22782impl TypedStablePtr for TerminalLetPtr {
22783 type SyntaxNode = TerminalLet;
22784 fn untyped(&self) -> SyntaxStablePtrId {
22785 self.0
22786 }
22787 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLet {
22788 TerminalLet::from_syntax_node(db, self.0.lookup(db))
22789 }
22790}
22791impl From<TerminalLetPtr> for SyntaxStablePtrId {
22792 fn from(ptr: TerminalLetPtr) -> Self {
22793 ptr.untyped()
22794 }
22795}
22796#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22797pub struct TerminalLetGreen(pub GreenId);
22798impl TypedSyntaxNode for TerminalLet {
22799 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLet);
22800 type StablePtr = TerminalLetPtr;
22801 type Green = TerminalLetGreen;
22802 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22803 TerminalLetGreen(
22804 Arc::new(GreenNode {
22805 kind: SyntaxKind::TerminalLet,
22806 details: GreenNodeDetails::Node {
22807 children: vec![
22808 Trivia::missing(db).0,
22809 TokenLet::missing(db).0,
22810 Trivia::missing(db).0,
22811 ],
22812 width: TextWidth::default(),
22813 },
22814 })
22815 .intern(db),
22816 )
22817 }
22818 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22819 let kind = node.kind(db);
22820 assert_eq!(
22821 kind,
22822 SyntaxKind::TerminalLet,
22823 "Unexpected SyntaxKind {:?}. Expected {:?}.",
22824 kind,
22825 SyntaxKind::TerminalLet
22826 );
22827 let children = db.get_children(node.clone());
22828 Self { node, children }
22829 }
22830 fn as_syntax_node(&self) -> SyntaxNode {
22831 self.node.clone()
22832 }
22833 fn stable_ptr(&self) -> Self::StablePtr {
22834 TerminalLetPtr(self.node.0.stable_ptr)
22835 }
22836}
22837impl From<&TerminalLet> for SyntaxStablePtrId {
22838 fn from(node: &TerminalLet) -> Self {
22839 node.stable_ptr().untyped()
22840 }
22841}
22842#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22843pub struct TokenMatch {
22844 node: SyntaxNode,
22845}
22846impl Token for TokenMatch {
22847 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
22848 TokenMatchGreen(
22849 Arc::new(GreenNode {
22850 kind: SyntaxKind::TokenMatch,
22851 details: GreenNodeDetails::Token(text),
22852 })
22853 .intern(db),
22854 )
22855 }
22856 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22857 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
22858 .clone()
22859 }
22860}
22861#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22862pub struct TokenMatchPtr(pub SyntaxStablePtrId);
22863impl TypedStablePtr for TokenMatchPtr {
22864 type SyntaxNode = TokenMatch;
22865 fn untyped(&self) -> SyntaxStablePtrId {
22866 self.0
22867 }
22868 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMatch {
22869 TokenMatch::from_syntax_node(db, self.0.lookup(db))
22870 }
22871}
22872impl From<TokenMatchPtr> for SyntaxStablePtrId {
22873 fn from(ptr: TokenMatchPtr) -> Self {
22874 ptr.untyped()
22875 }
22876}
22877#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22878pub struct TokenMatchGreen(pub GreenId);
22879impl TokenMatchGreen {
22880 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22881 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
22882 }
22883}
22884impl TypedSyntaxNode for TokenMatch {
22885 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMatch);
22886 type StablePtr = TokenMatchPtr;
22887 type Green = TokenMatchGreen;
22888 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22889 TokenMatchGreen(
22890 Arc::new(GreenNode {
22891 kind: SyntaxKind::TokenMissing,
22892 details: GreenNodeDetails::Token("".into()),
22893 })
22894 .intern(db),
22895 )
22896 }
22897 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22898 match node.0.green.lookup_intern(db).details {
22899 GreenNodeDetails::Token(_) => Self { node },
22900 GreenNodeDetails::Node { .. } => {
22901 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMatch)
22902 }
22903 }
22904 }
22905 fn as_syntax_node(&self) -> SyntaxNode {
22906 self.node.clone()
22907 }
22908 fn stable_ptr(&self) -> Self::StablePtr {
22909 TokenMatchPtr(self.node.0.stable_ptr)
22910 }
22911}
22912impl From<&TokenMatch> for SyntaxStablePtrId {
22913 fn from(node: &TokenMatch) -> Self {
22914 node.stable_ptr().untyped()
22915 }
22916}
22917#[derive(Clone, Debug, Eq, Hash, PartialEq)]
22918pub struct TerminalMatch {
22919 node: SyntaxNode,
22920 children: Arc<[SyntaxNode]>,
22921}
22922impl Terminal for TerminalMatch {
22923 const KIND: SyntaxKind = SyntaxKind::TerminalMatch;
22924 type TokenType = TokenMatch;
22925 fn new_green(
22926 db: &dyn SyntaxGroup,
22927 leading_trivia: TriviaGreen,
22928 token: <<TerminalMatch as Terminal>::TokenType as TypedSyntaxNode>::Green,
22929 trailing_trivia: TriviaGreen,
22930 ) -> Self::Green {
22931 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
22932 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
22933 TerminalMatchGreen(
22934 Arc::new(GreenNode {
22935 kind: SyntaxKind::TerminalMatch,
22936 details: GreenNodeDetails::Node { children, width },
22937 })
22938 .intern(db),
22939 )
22940 }
22941 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
22942 self.token(db).text(db)
22943 }
22944}
22945impl TerminalMatch {
22946 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22947 Trivia::from_syntax_node(db, self.children[0].clone())
22948 }
22949 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMatch {
22950 TokenMatch::from_syntax_node(db, self.children[1].clone())
22951 }
22952 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
22953 Trivia::from_syntax_node(db, self.children[2].clone())
22954 }
22955}
22956#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22957pub struct TerminalMatchPtr(pub SyntaxStablePtrId);
22958impl TerminalMatchPtr {}
22959impl TypedStablePtr for TerminalMatchPtr {
22960 type SyntaxNode = TerminalMatch;
22961 fn untyped(&self) -> SyntaxStablePtrId {
22962 self.0
22963 }
22964 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMatch {
22965 TerminalMatch::from_syntax_node(db, self.0.lookup(db))
22966 }
22967}
22968impl From<TerminalMatchPtr> for SyntaxStablePtrId {
22969 fn from(ptr: TerminalMatchPtr) -> Self {
22970 ptr.untyped()
22971 }
22972}
22973#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
22974pub struct TerminalMatchGreen(pub GreenId);
22975impl TypedSyntaxNode for TerminalMatch {
22976 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMatch);
22977 type StablePtr = TerminalMatchPtr;
22978 type Green = TerminalMatchGreen;
22979 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
22980 TerminalMatchGreen(
22981 Arc::new(GreenNode {
22982 kind: SyntaxKind::TerminalMatch,
22983 details: GreenNodeDetails::Node {
22984 children: vec![
22985 Trivia::missing(db).0,
22986 TokenMatch::missing(db).0,
22987 Trivia::missing(db).0,
22988 ],
22989 width: TextWidth::default(),
22990 },
22991 })
22992 .intern(db),
22993 )
22994 }
22995 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
22996 let kind = node.kind(db);
22997 assert_eq!(
22998 kind,
22999 SyntaxKind::TerminalMatch,
23000 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23001 kind,
23002 SyntaxKind::TerminalMatch
23003 );
23004 let children = db.get_children(node.clone());
23005 Self { node, children }
23006 }
23007 fn as_syntax_node(&self) -> SyntaxNode {
23008 self.node.clone()
23009 }
23010 fn stable_ptr(&self) -> Self::StablePtr {
23011 TerminalMatchPtr(self.node.0.stable_ptr)
23012 }
23013}
23014impl From<&TerminalMatch> for SyntaxStablePtrId {
23015 fn from(node: &TerminalMatch) -> Self {
23016 node.stable_ptr().untyped()
23017 }
23018}
23019#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23020pub struct TokenModule {
23021 node: SyntaxNode,
23022}
23023impl Token for TokenModule {
23024 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23025 TokenModuleGreen(
23026 Arc::new(GreenNode {
23027 kind: SyntaxKind::TokenModule,
23028 details: GreenNodeDetails::Token(text),
23029 })
23030 .intern(db),
23031 )
23032 }
23033 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23034 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23035 .clone()
23036 }
23037}
23038#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23039pub struct TokenModulePtr(pub SyntaxStablePtrId);
23040impl TypedStablePtr for TokenModulePtr {
23041 type SyntaxNode = TokenModule;
23042 fn untyped(&self) -> SyntaxStablePtrId {
23043 self.0
23044 }
23045 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenModule {
23046 TokenModule::from_syntax_node(db, self.0.lookup(db))
23047 }
23048}
23049impl From<TokenModulePtr> for SyntaxStablePtrId {
23050 fn from(ptr: TokenModulePtr) -> Self {
23051 ptr.untyped()
23052 }
23053}
23054#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23055pub struct TokenModuleGreen(pub GreenId);
23056impl TokenModuleGreen {
23057 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23058 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23059 }
23060}
23061impl TypedSyntaxNode for TokenModule {
23062 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenModule);
23063 type StablePtr = TokenModulePtr;
23064 type Green = TokenModuleGreen;
23065 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23066 TokenModuleGreen(
23067 Arc::new(GreenNode {
23068 kind: SyntaxKind::TokenMissing,
23069 details: GreenNodeDetails::Token("".into()),
23070 })
23071 .intern(db),
23072 )
23073 }
23074 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23075 match node.0.green.lookup_intern(db).details {
23076 GreenNodeDetails::Token(_) => Self { node },
23077 GreenNodeDetails::Node { .. } => {
23078 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenModule)
23079 }
23080 }
23081 }
23082 fn as_syntax_node(&self) -> SyntaxNode {
23083 self.node.clone()
23084 }
23085 fn stable_ptr(&self) -> Self::StablePtr {
23086 TokenModulePtr(self.node.0.stable_ptr)
23087 }
23088}
23089impl From<&TokenModule> for SyntaxStablePtrId {
23090 fn from(node: &TokenModule) -> Self {
23091 node.stable_ptr().untyped()
23092 }
23093}
23094#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23095pub struct TerminalModule {
23096 node: SyntaxNode,
23097 children: Arc<[SyntaxNode]>,
23098}
23099impl Terminal for TerminalModule {
23100 const KIND: SyntaxKind = SyntaxKind::TerminalModule;
23101 type TokenType = TokenModule;
23102 fn new_green(
23103 db: &dyn SyntaxGroup,
23104 leading_trivia: TriviaGreen,
23105 token: <<TerminalModule as Terminal>::TokenType as TypedSyntaxNode>::Green,
23106 trailing_trivia: TriviaGreen,
23107 ) -> Self::Green {
23108 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23109 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23110 TerminalModuleGreen(
23111 Arc::new(GreenNode {
23112 kind: SyntaxKind::TerminalModule,
23113 details: GreenNodeDetails::Node { children, width },
23114 })
23115 .intern(db),
23116 )
23117 }
23118 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23119 self.token(db).text(db)
23120 }
23121}
23122impl TerminalModule {
23123 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23124 Trivia::from_syntax_node(db, self.children[0].clone())
23125 }
23126 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenModule {
23127 TokenModule::from_syntax_node(db, self.children[1].clone())
23128 }
23129 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23130 Trivia::from_syntax_node(db, self.children[2].clone())
23131 }
23132}
23133#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23134pub struct TerminalModulePtr(pub SyntaxStablePtrId);
23135impl TerminalModulePtr {}
23136impl TypedStablePtr for TerminalModulePtr {
23137 type SyntaxNode = TerminalModule;
23138 fn untyped(&self) -> SyntaxStablePtrId {
23139 self.0
23140 }
23141 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalModule {
23142 TerminalModule::from_syntax_node(db, self.0.lookup(db))
23143 }
23144}
23145impl From<TerminalModulePtr> for SyntaxStablePtrId {
23146 fn from(ptr: TerminalModulePtr) -> Self {
23147 ptr.untyped()
23148 }
23149}
23150#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23151pub struct TerminalModuleGreen(pub GreenId);
23152impl TypedSyntaxNode for TerminalModule {
23153 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalModule);
23154 type StablePtr = TerminalModulePtr;
23155 type Green = TerminalModuleGreen;
23156 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23157 TerminalModuleGreen(
23158 Arc::new(GreenNode {
23159 kind: SyntaxKind::TerminalModule,
23160 details: GreenNodeDetails::Node {
23161 children: vec![
23162 Trivia::missing(db).0,
23163 TokenModule::missing(db).0,
23164 Trivia::missing(db).0,
23165 ],
23166 width: TextWidth::default(),
23167 },
23168 })
23169 .intern(db),
23170 )
23171 }
23172 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23173 let kind = node.kind(db);
23174 assert_eq!(
23175 kind,
23176 SyntaxKind::TerminalModule,
23177 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23178 kind,
23179 SyntaxKind::TerminalModule
23180 );
23181 let children = db.get_children(node.clone());
23182 Self { node, children }
23183 }
23184 fn as_syntax_node(&self) -> SyntaxNode {
23185 self.node.clone()
23186 }
23187 fn stable_ptr(&self) -> Self::StablePtr {
23188 TerminalModulePtr(self.node.0.stable_ptr)
23189 }
23190}
23191impl From<&TerminalModule> for SyntaxStablePtrId {
23192 fn from(node: &TerminalModule) -> Self {
23193 node.stable_ptr().untyped()
23194 }
23195}
23196#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23197pub struct TokenMut {
23198 node: SyntaxNode,
23199}
23200impl Token for TokenMut {
23201 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23202 TokenMutGreen(
23203 Arc::new(GreenNode {
23204 kind: SyntaxKind::TokenMut,
23205 details: GreenNodeDetails::Token(text),
23206 })
23207 .intern(db),
23208 )
23209 }
23210 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23211 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23212 .clone()
23213 }
23214}
23215#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23216pub struct TokenMutPtr(pub SyntaxStablePtrId);
23217impl TypedStablePtr for TokenMutPtr {
23218 type SyntaxNode = TokenMut;
23219 fn untyped(&self) -> SyntaxStablePtrId {
23220 self.0
23221 }
23222 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMut {
23223 TokenMut::from_syntax_node(db, self.0.lookup(db))
23224 }
23225}
23226impl From<TokenMutPtr> for SyntaxStablePtrId {
23227 fn from(ptr: TokenMutPtr) -> Self {
23228 ptr.untyped()
23229 }
23230}
23231#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23232pub struct TokenMutGreen(pub GreenId);
23233impl TokenMutGreen {
23234 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23235 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23236 }
23237}
23238impl TypedSyntaxNode for TokenMut {
23239 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMut);
23240 type StablePtr = TokenMutPtr;
23241 type Green = TokenMutGreen;
23242 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23243 TokenMutGreen(
23244 Arc::new(GreenNode {
23245 kind: SyntaxKind::TokenMissing,
23246 details: GreenNodeDetails::Token("".into()),
23247 })
23248 .intern(db),
23249 )
23250 }
23251 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23252 match node.0.green.lookup_intern(db).details {
23253 GreenNodeDetails::Token(_) => Self { node },
23254 GreenNodeDetails::Node { .. } => {
23255 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMut)
23256 }
23257 }
23258 }
23259 fn as_syntax_node(&self) -> SyntaxNode {
23260 self.node.clone()
23261 }
23262 fn stable_ptr(&self) -> Self::StablePtr {
23263 TokenMutPtr(self.node.0.stable_ptr)
23264 }
23265}
23266impl From<&TokenMut> for SyntaxStablePtrId {
23267 fn from(node: &TokenMut) -> Self {
23268 node.stable_ptr().untyped()
23269 }
23270}
23271#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23272pub struct TerminalMut {
23273 node: SyntaxNode,
23274 children: Arc<[SyntaxNode]>,
23275}
23276impl Terminal for TerminalMut {
23277 const KIND: SyntaxKind = SyntaxKind::TerminalMut;
23278 type TokenType = TokenMut;
23279 fn new_green(
23280 db: &dyn SyntaxGroup,
23281 leading_trivia: TriviaGreen,
23282 token: <<TerminalMut as Terminal>::TokenType as TypedSyntaxNode>::Green,
23283 trailing_trivia: TriviaGreen,
23284 ) -> Self::Green {
23285 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23286 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23287 TerminalMutGreen(
23288 Arc::new(GreenNode {
23289 kind: SyntaxKind::TerminalMut,
23290 details: GreenNodeDetails::Node { children, width },
23291 })
23292 .intern(db),
23293 )
23294 }
23295 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23296 self.token(db).text(db)
23297 }
23298}
23299impl TerminalMut {
23300 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23301 Trivia::from_syntax_node(db, self.children[0].clone())
23302 }
23303 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMut {
23304 TokenMut::from_syntax_node(db, self.children[1].clone())
23305 }
23306 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23307 Trivia::from_syntax_node(db, self.children[2].clone())
23308 }
23309}
23310#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23311pub struct TerminalMutPtr(pub SyntaxStablePtrId);
23312impl TerminalMutPtr {}
23313impl TypedStablePtr for TerminalMutPtr {
23314 type SyntaxNode = TerminalMut;
23315 fn untyped(&self) -> SyntaxStablePtrId {
23316 self.0
23317 }
23318 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMut {
23319 TerminalMut::from_syntax_node(db, self.0.lookup(db))
23320 }
23321}
23322impl From<TerminalMutPtr> for SyntaxStablePtrId {
23323 fn from(ptr: TerminalMutPtr) -> Self {
23324 ptr.untyped()
23325 }
23326}
23327#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23328pub struct TerminalMutGreen(pub GreenId);
23329impl TypedSyntaxNode for TerminalMut {
23330 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMut);
23331 type StablePtr = TerminalMutPtr;
23332 type Green = TerminalMutGreen;
23333 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23334 TerminalMutGreen(
23335 Arc::new(GreenNode {
23336 kind: SyntaxKind::TerminalMut,
23337 details: GreenNodeDetails::Node {
23338 children: vec![
23339 Trivia::missing(db).0,
23340 TokenMut::missing(db).0,
23341 Trivia::missing(db).0,
23342 ],
23343 width: TextWidth::default(),
23344 },
23345 })
23346 .intern(db),
23347 )
23348 }
23349 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23350 let kind = node.kind(db);
23351 assert_eq!(
23352 kind,
23353 SyntaxKind::TerminalMut,
23354 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23355 kind,
23356 SyntaxKind::TerminalMut
23357 );
23358 let children = db.get_children(node.clone());
23359 Self { node, children }
23360 }
23361 fn as_syntax_node(&self) -> SyntaxNode {
23362 self.node.clone()
23363 }
23364 fn stable_ptr(&self) -> Self::StablePtr {
23365 TerminalMutPtr(self.node.0.stable_ptr)
23366 }
23367}
23368impl From<&TerminalMut> for SyntaxStablePtrId {
23369 fn from(node: &TerminalMut) -> Self {
23370 node.stable_ptr().untyped()
23371 }
23372}
23373#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23374pub struct TokenNoPanic {
23375 node: SyntaxNode,
23376}
23377impl Token for TokenNoPanic {
23378 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23379 TokenNoPanicGreen(
23380 Arc::new(GreenNode {
23381 kind: SyntaxKind::TokenNoPanic,
23382 details: GreenNodeDetails::Token(text),
23383 })
23384 .intern(db),
23385 )
23386 }
23387 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23388 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23389 .clone()
23390 }
23391}
23392#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23393pub struct TokenNoPanicPtr(pub SyntaxStablePtrId);
23394impl TypedStablePtr for TokenNoPanicPtr {
23395 type SyntaxNode = TokenNoPanic;
23396 fn untyped(&self) -> SyntaxStablePtrId {
23397 self.0
23398 }
23399 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNoPanic {
23400 TokenNoPanic::from_syntax_node(db, self.0.lookup(db))
23401 }
23402}
23403impl From<TokenNoPanicPtr> for SyntaxStablePtrId {
23404 fn from(ptr: TokenNoPanicPtr) -> Self {
23405 ptr.untyped()
23406 }
23407}
23408#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23409pub struct TokenNoPanicGreen(pub GreenId);
23410impl TokenNoPanicGreen {
23411 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23412 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23413 }
23414}
23415impl TypedSyntaxNode for TokenNoPanic {
23416 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNoPanic);
23417 type StablePtr = TokenNoPanicPtr;
23418 type Green = TokenNoPanicGreen;
23419 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23420 TokenNoPanicGreen(
23421 Arc::new(GreenNode {
23422 kind: SyntaxKind::TokenMissing,
23423 details: GreenNodeDetails::Token("".into()),
23424 })
23425 .intern(db),
23426 )
23427 }
23428 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23429 match node.0.green.lookup_intern(db).details {
23430 GreenNodeDetails::Token(_) => Self { node },
23431 GreenNodeDetails::Node { .. } => {
23432 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNoPanic)
23433 }
23434 }
23435 }
23436 fn as_syntax_node(&self) -> SyntaxNode {
23437 self.node.clone()
23438 }
23439 fn stable_ptr(&self) -> Self::StablePtr {
23440 TokenNoPanicPtr(self.node.0.stable_ptr)
23441 }
23442}
23443impl From<&TokenNoPanic> for SyntaxStablePtrId {
23444 fn from(node: &TokenNoPanic) -> Self {
23445 node.stable_ptr().untyped()
23446 }
23447}
23448#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23449pub struct TerminalNoPanic {
23450 node: SyntaxNode,
23451 children: Arc<[SyntaxNode]>,
23452}
23453impl Terminal for TerminalNoPanic {
23454 const KIND: SyntaxKind = SyntaxKind::TerminalNoPanic;
23455 type TokenType = TokenNoPanic;
23456 fn new_green(
23457 db: &dyn SyntaxGroup,
23458 leading_trivia: TriviaGreen,
23459 token: <<TerminalNoPanic as Terminal>::TokenType as TypedSyntaxNode>::Green,
23460 trailing_trivia: TriviaGreen,
23461 ) -> Self::Green {
23462 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23463 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23464 TerminalNoPanicGreen(
23465 Arc::new(GreenNode {
23466 kind: SyntaxKind::TerminalNoPanic,
23467 details: GreenNodeDetails::Node { children, width },
23468 })
23469 .intern(db),
23470 )
23471 }
23472 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23473 self.token(db).text(db)
23474 }
23475}
23476impl TerminalNoPanic {
23477 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23478 Trivia::from_syntax_node(db, self.children[0].clone())
23479 }
23480 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNoPanic {
23481 TokenNoPanic::from_syntax_node(db, self.children[1].clone())
23482 }
23483 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23484 Trivia::from_syntax_node(db, self.children[2].clone())
23485 }
23486}
23487#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23488pub struct TerminalNoPanicPtr(pub SyntaxStablePtrId);
23489impl TerminalNoPanicPtr {}
23490impl TypedStablePtr for TerminalNoPanicPtr {
23491 type SyntaxNode = TerminalNoPanic;
23492 fn untyped(&self) -> SyntaxStablePtrId {
23493 self.0
23494 }
23495 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNoPanic {
23496 TerminalNoPanic::from_syntax_node(db, self.0.lookup(db))
23497 }
23498}
23499impl From<TerminalNoPanicPtr> for SyntaxStablePtrId {
23500 fn from(ptr: TerminalNoPanicPtr) -> Self {
23501 ptr.untyped()
23502 }
23503}
23504#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23505pub struct TerminalNoPanicGreen(pub GreenId);
23506impl TypedSyntaxNode for TerminalNoPanic {
23507 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNoPanic);
23508 type StablePtr = TerminalNoPanicPtr;
23509 type Green = TerminalNoPanicGreen;
23510 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23511 TerminalNoPanicGreen(
23512 Arc::new(GreenNode {
23513 kind: SyntaxKind::TerminalNoPanic,
23514 details: GreenNodeDetails::Node {
23515 children: vec![
23516 Trivia::missing(db).0,
23517 TokenNoPanic::missing(db).0,
23518 Trivia::missing(db).0,
23519 ],
23520 width: TextWidth::default(),
23521 },
23522 })
23523 .intern(db),
23524 )
23525 }
23526 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23527 let kind = node.kind(db);
23528 assert_eq!(
23529 kind,
23530 SyntaxKind::TerminalNoPanic,
23531 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23532 kind,
23533 SyntaxKind::TerminalNoPanic
23534 );
23535 let children = db.get_children(node.clone());
23536 Self { node, children }
23537 }
23538 fn as_syntax_node(&self) -> SyntaxNode {
23539 self.node.clone()
23540 }
23541 fn stable_ptr(&self) -> Self::StablePtr {
23542 TerminalNoPanicPtr(self.node.0.stable_ptr)
23543 }
23544}
23545impl From<&TerminalNoPanic> for SyntaxStablePtrId {
23546 fn from(node: &TerminalNoPanic) -> Self {
23547 node.stable_ptr().untyped()
23548 }
23549}
23550#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23551pub struct TokenOf {
23552 node: SyntaxNode,
23553}
23554impl Token for TokenOf {
23555 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23556 TokenOfGreen(
23557 Arc::new(GreenNode {
23558 kind: SyntaxKind::TokenOf,
23559 details: GreenNodeDetails::Token(text),
23560 })
23561 .intern(db),
23562 )
23563 }
23564 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23565 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23566 .clone()
23567 }
23568}
23569#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23570pub struct TokenOfPtr(pub SyntaxStablePtrId);
23571impl TypedStablePtr for TokenOfPtr {
23572 type SyntaxNode = TokenOf;
23573 fn untyped(&self) -> SyntaxStablePtrId {
23574 self.0
23575 }
23576 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOf {
23577 TokenOf::from_syntax_node(db, self.0.lookup(db))
23578 }
23579}
23580impl From<TokenOfPtr> for SyntaxStablePtrId {
23581 fn from(ptr: TokenOfPtr) -> Self {
23582 ptr.untyped()
23583 }
23584}
23585#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23586pub struct TokenOfGreen(pub GreenId);
23587impl TokenOfGreen {
23588 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23589 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23590 }
23591}
23592impl TypedSyntaxNode for TokenOf {
23593 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOf);
23594 type StablePtr = TokenOfPtr;
23595 type Green = TokenOfGreen;
23596 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23597 TokenOfGreen(
23598 Arc::new(GreenNode {
23599 kind: SyntaxKind::TokenMissing,
23600 details: GreenNodeDetails::Token("".into()),
23601 })
23602 .intern(db),
23603 )
23604 }
23605 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23606 match node.0.green.lookup_intern(db).details {
23607 GreenNodeDetails::Token(_) => Self { node },
23608 GreenNodeDetails::Node { .. } => {
23609 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOf)
23610 }
23611 }
23612 }
23613 fn as_syntax_node(&self) -> SyntaxNode {
23614 self.node.clone()
23615 }
23616 fn stable_ptr(&self) -> Self::StablePtr {
23617 TokenOfPtr(self.node.0.stable_ptr)
23618 }
23619}
23620impl From<&TokenOf> for SyntaxStablePtrId {
23621 fn from(node: &TokenOf) -> Self {
23622 node.stable_ptr().untyped()
23623 }
23624}
23625#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23626pub struct TerminalOf {
23627 node: SyntaxNode,
23628 children: Arc<[SyntaxNode]>,
23629}
23630impl Terminal for TerminalOf {
23631 const KIND: SyntaxKind = SyntaxKind::TerminalOf;
23632 type TokenType = TokenOf;
23633 fn new_green(
23634 db: &dyn SyntaxGroup,
23635 leading_trivia: TriviaGreen,
23636 token: <<TerminalOf as Terminal>::TokenType as TypedSyntaxNode>::Green,
23637 trailing_trivia: TriviaGreen,
23638 ) -> Self::Green {
23639 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23640 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23641 TerminalOfGreen(
23642 Arc::new(GreenNode {
23643 kind: SyntaxKind::TerminalOf,
23644 details: GreenNodeDetails::Node { children, width },
23645 })
23646 .intern(db),
23647 )
23648 }
23649 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23650 self.token(db).text(db)
23651 }
23652}
23653impl TerminalOf {
23654 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23655 Trivia::from_syntax_node(db, self.children[0].clone())
23656 }
23657 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOf {
23658 TokenOf::from_syntax_node(db, self.children[1].clone())
23659 }
23660 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
23661 Trivia::from_syntax_node(db, self.children[2].clone())
23662 }
23663}
23664#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23665pub struct TerminalOfPtr(pub SyntaxStablePtrId);
23666impl TerminalOfPtr {}
23667impl TypedStablePtr for TerminalOfPtr {
23668 type SyntaxNode = TerminalOf;
23669 fn untyped(&self) -> SyntaxStablePtrId {
23670 self.0
23671 }
23672 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOf {
23673 TerminalOf::from_syntax_node(db, self.0.lookup(db))
23674 }
23675}
23676impl From<TerminalOfPtr> for SyntaxStablePtrId {
23677 fn from(ptr: TerminalOfPtr) -> Self {
23678 ptr.untyped()
23679 }
23680}
23681#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23682pub struct TerminalOfGreen(pub GreenId);
23683impl TypedSyntaxNode for TerminalOf {
23684 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOf);
23685 type StablePtr = TerminalOfPtr;
23686 type Green = TerminalOfGreen;
23687 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23688 TerminalOfGreen(
23689 Arc::new(GreenNode {
23690 kind: SyntaxKind::TerminalOf,
23691 details: GreenNodeDetails::Node {
23692 children: vec![
23693 Trivia::missing(db).0,
23694 TokenOf::missing(db).0,
23695 Trivia::missing(db).0,
23696 ],
23697 width: TextWidth::default(),
23698 },
23699 })
23700 .intern(db),
23701 )
23702 }
23703 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23704 let kind = node.kind(db);
23705 assert_eq!(
23706 kind,
23707 SyntaxKind::TerminalOf,
23708 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23709 kind,
23710 SyntaxKind::TerminalOf
23711 );
23712 let children = db.get_children(node.clone());
23713 Self { node, children }
23714 }
23715 fn as_syntax_node(&self) -> SyntaxNode {
23716 self.node.clone()
23717 }
23718 fn stable_ptr(&self) -> Self::StablePtr {
23719 TerminalOfPtr(self.node.0.stable_ptr)
23720 }
23721}
23722impl From<&TerminalOf> for SyntaxStablePtrId {
23723 fn from(node: &TerminalOf) -> Self {
23724 node.stable_ptr().untyped()
23725 }
23726}
23727#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23728pub struct TokenRef {
23729 node: SyntaxNode,
23730}
23731impl Token for TokenRef {
23732 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23733 TokenRefGreen(
23734 Arc::new(GreenNode {
23735 kind: SyntaxKind::TokenRef,
23736 details: GreenNodeDetails::Token(text),
23737 })
23738 .intern(db),
23739 )
23740 }
23741 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23742 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23743 .clone()
23744 }
23745}
23746#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23747pub struct TokenRefPtr(pub SyntaxStablePtrId);
23748impl TypedStablePtr for TokenRefPtr {
23749 type SyntaxNode = TokenRef;
23750 fn untyped(&self) -> SyntaxStablePtrId {
23751 self.0
23752 }
23753 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRef {
23754 TokenRef::from_syntax_node(db, self.0.lookup(db))
23755 }
23756}
23757impl From<TokenRefPtr> for SyntaxStablePtrId {
23758 fn from(ptr: TokenRefPtr) -> Self {
23759 ptr.untyped()
23760 }
23761}
23762#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23763pub struct TokenRefGreen(pub GreenId);
23764impl TokenRefGreen {
23765 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23766 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23767 }
23768}
23769impl TypedSyntaxNode for TokenRef {
23770 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRef);
23771 type StablePtr = TokenRefPtr;
23772 type Green = TokenRefGreen;
23773 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23774 TokenRefGreen(
23775 Arc::new(GreenNode {
23776 kind: SyntaxKind::TokenMissing,
23777 details: GreenNodeDetails::Token("".into()),
23778 })
23779 .intern(db),
23780 )
23781 }
23782 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23783 match node.0.green.lookup_intern(db).details {
23784 GreenNodeDetails::Token(_) => Self { node },
23785 GreenNodeDetails::Node { .. } => {
23786 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRef)
23787 }
23788 }
23789 }
23790 fn as_syntax_node(&self) -> SyntaxNode {
23791 self.node.clone()
23792 }
23793 fn stable_ptr(&self) -> Self::StablePtr {
23794 TokenRefPtr(self.node.0.stable_ptr)
23795 }
23796}
23797impl From<&TokenRef> for SyntaxStablePtrId {
23798 fn from(node: &TokenRef) -> Self {
23799 node.stable_ptr().untyped()
23800 }
23801}
23802#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23803pub struct TerminalRef {
23804 node: SyntaxNode,
23805 children: Arc<[SyntaxNode]>,
23806}
23807impl Terminal for TerminalRef {
23808 const KIND: SyntaxKind = SyntaxKind::TerminalRef;
23809 type TokenType = TokenRef;
23810 fn new_green(
23811 db: &dyn SyntaxGroup,
23812 leading_trivia: TriviaGreen,
23813 token: <<TerminalRef 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 TerminalRefGreen(
23819 Arc::new(GreenNode {
23820 kind: SyntaxKind::TerminalRef,
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 TerminalRef {
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) -> TokenRef {
23835 TokenRef::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 TerminalRefPtr(pub SyntaxStablePtrId);
23843impl TerminalRefPtr {}
23844impl TypedStablePtr for TerminalRefPtr {
23845 type SyntaxNode = TerminalRef;
23846 fn untyped(&self) -> SyntaxStablePtrId {
23847 self.0
23848 }
23849 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRef {
23850 TerminalRef::from_syntax_node(db, self.0.lookup(db))
23851 }
23852}
23853impl From<TerminalRefPtr> for SyntaxStablePtrId {
23854 fn from(ptr: TerminalRefPtr) -> Self {
23855 ptr.untyped()
23856 }
23857}
23858#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23859pub struct TerminalRefGreen(pub GreenId);
23860impl TypedSyntaxNode for TerminalRef {
23861 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRef);
23862 type StablePtr = TerminalRefPtr;
23863 type Green = TerminalRefGreen;
23864 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23865 TerminalRefGreen(
23866 Arc::new(GreenNode {
23867 kind: SyntaxKind::TerminalRef,
23868 details: GreenNodeDetails::Node {
23869 children: vec![
23870 Trivia::missing(db).0,
23871 TokenRef::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::TerminalRef,
23885 "Unexpected SyntaxKind {:?}. Expected {:?}.",
23886 kind,
23887 SyntaxKind::TerminalRef
23888 );
23889 let children = db.get_children(node.clone());
23890 Self { node, children }
23891 }
23892 fn as_syntax_node(&self) -> SyntaxNode {
23893 self.node.clone()
23894 }
23895 fn stable_ptr(&self) -> Self::StablePtr {
23896 TerminalRefPtr(self.node.0.stable_ptr)
23897 }
23898}
23899impl From<&TerminalRef> for SyntaxStablePtrId {
23900 fn from(node: &TerminalRef) -> Self {
23901 node.stable_ptr().untyped()
23902 }
23903}
23904#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23905pub struct TokenContinue {
23906 node: SyntaxNode,
23907}
23908impl Token for TokenContinue {
23909 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
23910 TokenContinueGreen(
23911 Arc::new(GreenNode {
23912 kind: SyntaxKind::TokenContinue,
23913 details: GreenNodeDetails::Token(text),
23914 })
23915 .intern(db),
23916 )
23917 }
23918 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23919 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
23920 .clone()
23921 }
23922}
23923#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23924pub struct TokenContinuePtr(pub SyntaxStablePtrId);
23925impl TypedStablePtr for TokenContinuePtr {
23926 type SyntaxNode = TokenContinue;
23927 fn untyped(&self) -> SyntaxStablePtrId {
23928 self.0
23929 }
23930 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenContinue {
23931 TokenContinue::from_syntax_node(db, self.0.lookup(db))
23932 }
23933}
23934impl From<TokenContinuePtr> for SyntaxStablePtrId {
23935 fn from(ptr: TokenContinuePtr) -> Self {
23936 ptr.untyped()
23937 }
23938}
23939#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
23940pub struct TokenContinueGreen(pub GreenId);
23941impl TokenContinueGreen {
23942 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
23943 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
23944 }
23945}
23946impl TypedSyntaxNode for TokenContinue {
23947 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenContinue);
23948 type StablePtr = TokenContinuePtr;
23949 type Green = TokenContinueGreen;
23950 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
23951 TokenContinueGreen(
23952 Arc::new(GreenNode {
23953 kind: SyntaxKind::TokenMissing,
23954 details: GreenNodeDetails::Token("".into()),
23955 })
23956 .intern(db),
23957 )
23958 }
23959 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
23960 match node.0.green.lookup_intern(db).details {
23961 GreenNodeDetails::Token(_) => Self { node },
23962 GreenNodeDetails::Node { .. } => {
23963 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenContinue)
23964 }
23965 }
23966 }
23967 fn as_syntax_node(&self) -> SyntaxNode {
23968 self.node.clone()
23969 }
23970 fn stable_ptr(&self) -> Self::StablePtr {
23971 TokenContinuePtr(self.node.0.stable_ptr)
23972 }
23973}
23974impl From<&TokenContinue> for SyntaxStablePtrId {
23975 fn from(node: &TokenContinue) -> Self {
23976 node.stable_ptr().untyped()
23977 }
23978}
23979#[derive(Clone, Debug, Eq, Hash, PartialEq)]
23980pub struct TerminalContinue {
23981 node: SyntaxNode,
23982 children: Arc<[SyntaxNode]>,
23983}
23984impl Terminal for TerminalContinue {
23985 const KIND: SyntaxKind = SyntaxKind::TerminalContinue;
23986 type TokenType = TokenContinue;
23987 fn new_green(
23988 db: &dyn SyntaxGroup,
23989 leading_trivia: TriviaGreen,
23990 token: <<TerminalContinue as Terminal>::TokenType as TypedSyntaxNode>::Green,
23991 trailing_trivia: TriviaGreen,
23992 ) -> Self::Green {
23993 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
23994 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
23995 TerminalContinueGreen(
23996 Arc::new(GreenNode {
23997 kind: SyntaxKind::TerminalContinue,
23998 details: GreenNodeDetails::Node { children, width },
23999 })
24000 .intern(db),
24001 )
24002 }
24003 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24004 self.token(db).text(db)
24005 }
24006}
24007impl TerminalContinue {
24008 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24009 Trivia::from_syntax_node(db, self.children[0].clone())
24010 }
24011 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenContinue {
24012 TokenContinue::from_syntax_node(db, self.children[1].clone())
24013 }
24014 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24015 Trivia::from_syntax_node(db, self.children[2].clone())
24016 }
24017}
24018#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24019pub struct TerminalContinuePtr(pub SyntaxStablePtrId);
24020impl TerminalContinuePtr {}
24021impl TypedStablePtr for TerminalContinuePtr {
24022 type SyntaxNode = TerminalContinue;
24023 fn untyped(&self) -> SyntaxStablePtrId {
24024 self.0
24025 }
24026 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalContinue {
24027 TerminalContinue::from_syntax_node(db, self.0.lookup(db))
24028 }
24029}
24030impl From<TerminalContinuePtr> for SyntaxStablePtrId {
24031 fn from(ptr: TerminalContinuePtr) -> Self {
24032 ptr.untyped()
24033 }
24034}
24035#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24036pub struct TerminalContinueGreen(pub GreenId);
24037impl TypedSyntaxNode for TerminalContinue {
24038 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalContinue);
24039 type StablePtr = TerminalContinuePtr;
24040 type Green = TerminalContinueGreen;
24041 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24042 TerminalContinueGreen(
24043 Arc::new(GreenNode {
24044 kind: SyntaxKind::TerminalContinue,
24045 details: GreenNodeDetails::Node {
24046 children: vec![
24047 Trivia::missing(db).0,
24048 TokenContinue::missing(db).0,
24049 Trivia::missing(db).0,
24050 ],
24051 width: TextWidth::default(),
24052 },
24053 })
24054 .intern(db),
24055 )
24056 }
24057 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24058 let kind = node.kind(db);
24059 assert_eq!(
24060 kind,
24061 SyntaxKind::TerminalContinue,
24062 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24063 kind,
24064 SyntaxKind::TerminalContinue
24065 );
24066 let children = db.get_children(node.clone());
24067 Self { node, children }
24068 }
24069 fn as_syntax_node(&self) -> SyntaxNode {
24070 self.node.clone()
24071 }
24072 fn stable_ptr(&self) -> Self::StablePtr {
24073 TerminalContinuePtr(self.node.0.stable_ptr)
24074 }
24075}
24076impl From<&TerminalContinue> for SyntaxStablePtrId {
24077 fn from(node: &TerminalContinue) -> Self {
24078 node.stable_ptr().untyped()
24079 }
24080}
24081#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24082pub struct TokenReturn {
24083 node: SyntaxNode,
24084}
24085impl Token for TokenReturn {
24086 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24087 TokenReturnGreen(
24088 Arc::new(GreenNode {
24089 kind: SyntaxKind::TokenReturn,
24090 details: GreenNodeDetails::Token(text),
24091 })
24092 .intern(db),
24093 )
24094 }
24095 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24096 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24097 .clone()
24098 }
24099}
24100#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24101pub struct TokenReturnPtr(pub SyntaxStablePtrId);
24102impl TypedStablePtr for TokenReturnPtr {
24103 type SyntaxNode = TokenReturn;
24104 fn untyped(&self) -> SyntaxStablePtrId {
24105 self.0
24106 }
24107 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenReturn {
24108 TokenReturn::from_syntax_node(db, self.0.lookup(db))
24109 }
24110}
24111impl From<TokenReturnPtr> for SyntaxStablePtrId {
24112 fn from(ptr: TokenReturnPtr) -> Self {
24113 ptr.untyped()
24114 }
24115}
24116#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24117pub struct TokenReturnGreen(pub GreenId);
24118impl TokenReturnGreen {
24119 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24120 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24121 }
24122}
24123impl TypedSyntaxNode for TokenReturn {
24124 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenReturn);
24125 type StablePtr = TokenReturnPtr;
24126 type Green = TokenReturnGreen;
24127 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24128 TokenReturnGreen(
24129 Arc::new(GreenNode {
24130 kind: SyntaxKind::TokenMissing,
24131 details: GreenNodeDetails::Token("".into()),
24132 })
24133 .intern(db),
24134 )
24135 }
24136 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24137 match node.0.green.lookup_intern(db).details {
24138 GreenNodeDetails::Token(_) => Self { node },
24139 GreenNodeDetails::Node { .. } => {
24140 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenReturn)
24141 }
24142 }
24143 }
24144 fn as_syntax_node(&self) -> SyntaxNode {
24145 self.node.clone()
24146 }
24147 fn stable_ptr(&self) -> Self::StablePtr {
24148 TokenReturnPtr(self.node.0.stable_ptr)
24149 }
24150}
24151impl From<&TokenReturn> for SyntaxStablePtrId {
24152 fn from(node: &TokenReturn) -> Self {
24153 node.stable_ptr().untyped()
24154 }
24155}
24156#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24157pub struct TerminalReturn {
24158 node: SyntaxNode,
24159 children: Arc<[SyntaxNode]>,
24160}
24161impl Terminal for TerminalReturn {
24162 const KIND: SyntaxKind = SyntaxKind::TerminalReturn;
24163 type TokenType = TokenReturn;
24164 fn new_green(
24165 db: &dyn SyntaxGroup,
24166 leading_trivia: TriviaGreen,
24167 token: <<TerminalReturn as Terminal>::TokenType as TypedSyntaxNode>::Green,
24168 trailing_trivia: TriviaGreen,
24169 ) -> Self::Green {
24170 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24171 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24172 TerminalReturnGreen(
24173 Arc::new(GreenNode {
24174 kind: SyntaxKind::TerminalReturn,
24175 details: GreenNodeDetails::Node { children, width },
24176 })
24177 .intern(db),
24178 )
24179 }
24180 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24181 self.token(db).text(db)
24182 }
24183}
24184impl TerminalReturn {
24185 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24186 Trivia::from_syntax_node(db, self.children[0].clone())
24187 }
24188 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenReturn {
24189 TokenReturn::from_syntax_node(db, self.children[1].clone())
24190 }
24191 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24192 Trivia::from_syntax_node(db, self.children[2].clone())
24193 }
24194}
24195#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24196pub struct TerminalReturnPtr(pub SyntaxStablePtrId);
24197impl TerminalReturnPtr {}
24198impl TypedStablePtr for TerminalReturnPtr {
24199 type SyntaxNode = TerminalReturn;
24200 fn untyped(&self) -> SyntaxStablePtrId {
24201 self.0
24202 }
24203 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalReturn {
24204 TerminalReturn::from_syntax_node(db, self.0.lookup(db))
24205 }
24206}
24207impl From<TerminalReturnPtr> for SyntaxStablePtrId {
24208 fn from(ptr: TerminalReturnPtr) -> Self {
24209 ptr.untyped()
24210 }
24211}
24212#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24213pub struct TerminalReturnGreen(pub GreenId);
24214impl TypedSyntaxNode for TerminalReturn {
24215 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalReturn);
24216 type StablePtr = TerminalReturnPtr;
24217 type Green = TerminalReturnGreen;
24218 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24219 TerminalReturnGreen(
24220 Arc::new(GreenNode {
24221 kind: SyntaxKind::TerminalReturn,
24222 details: GreenNodeDetails::Node {
24223 children: vec![
24224 Trivia::missing(db).0,
24225 TokenReturn::missing(db).0,
24226 Trivia::missing(db).0,
24227 ],
24228 width: TextWidth::default(),
24229 },
24230 })
24231 .intern(db),
24232 )
24233 }
24234 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24235 let kind = node.kind(db);
24236 assert_eq!(
24237 kind,
24238 SyntaxKind::TerminalReturn,
24239 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24240 kind,
24241 SyntaxKind::TerminalReturn
24242 );
24243 let children = db.get_children(node.clone());
24244 Self { node, children }
24245 }
24246 fn as_syntax_node(&self) -> SyntaxNode {
24247 self.node.clone()
24248 }
24249 fn stable_ptr(&self) -> Self::StablePtr {
24250 TerminalReturnPtr(self.node.0.stable_ptr)
24251 }
24252}
24253impl From<&TerminalReturn> for SyntaxStablePtrId {
24254 fn from(node: &TerminalReturn) -> Self {
24255 node.stable_ptr().untyped()
24256 }
24257}
24258#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24259pub struct TokenBreak {
24260 node: SyntaxNode,
24261}
24262impl Token for TokenBreak {
24263 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24264 TokenBreakGreen(
24265 Arc::new(GreenNode {
24266 kind: SyntaxKind::TokenBreak,
24267 details: GreenNodeDetails::Token(text),
24268 })
24269 .intern(db),
24270 )
24271 }
24272 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24273 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24274 .clone()
24275 }
24276}
24277#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24278pub struct TokenBreakPtr(pub SyntaxStablePtrId);
24279impl TypedStablePtr for TokenBreakPtr {
24280 type SyntaxNode = TokenBreak;
24281 fn untyped(&self) -> SyntaxStablePtrId {
24282 self.0
24283 }
24284 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBreak {
24285 TokenBreak::from_syntax_node(db, self.0.lookup(db))
24286 }
24287}
24288impl From<TokenBreakPtr> for SyntaxStablePtrId {
24289 fn from(ptr: TokenBreakPtr) -> Self {
24290 ptr.untyped()
24291 }
24292}
24293#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24294pub struct TokenBreakGreen(pub GreenId);
24295impl TokenBreakGreen {
24296 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24297 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24298 }
24299}
24300impl TypedSyntaxNode for TokenBreak {
24301 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBreak);
24302 type StablePtr = TokenBreakPtr;
24303 type Green = TokenBreakGreen;
24304 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24305 TokenBreakGreen(
24306 Arc::new(GreenNode {
24307 kind: SyntaxKind::TokenMissing,
24308 details: GreenNodeDetails::Token("".into()),
24309 })
24310 .intern(db),
24311 )
24312 }
24313 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24314 match node.0.green.lookup_intern(db).details {
24315 GreenNodeDetails::Token(_) => Self { node },
24316 GreenNodeDetails::Node { .. } => {
24317 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenBreak)
24318 }
24319 }
24320 }
24321 fn as_syntax_node(&self) -> SyntaxNode {
24322 self.node.clone()
24323 }
24324 fn stable_ptr(&self) -> Self::StablePtr {
24325 TokenBreakPtr(self.node.0.stable_ptr)
24326 }
24327}
24328impl From<&TokenBreak> for SyntaxStablePtrId {
24329 fn from(node: &TokenBreak) -> Self {
24330 node.stable_ptr().untyped()
24331 }
24332}
24333#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24334pub struct TerminalBreak {
24335 node: SyntaxNode,
24336 children: Arc<[SyntaxNode]>,
24337}
24338impl Terminal for TerminalBreak {
24339 const KIND: SyntaxKind = SyntaxKind::TerminalBreak;
24340 type TokenType = TokenBreak;
24341 fn new_green(
24342 db: &dyn SyntaxGroup,
24343 leading_trivia: TriviaGreen,
24344 token: <<TerminalBreak as Terminal>::TokenType as TypedSyntaxNode>::Green,
24345 trailing_trivia: TriviaGreen,
24346 ) -> Self::Green {
24347 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24348 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24349 TerminalBreakGreen(
24350 Arc::new(GreenNode {
24351 kind: SyntaxKind::TerminalBreak,
24352 details: GreenNodeDetails::Node { children, width },
24353 })
24354 .intern(db),
24355 )
24356 }
24357 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24358 self.token(db).text(db)
24359 }
24360}
24361impl TerminalBreak {
24362 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24363 Trivia::from_syntax_node(db, self.children[0].clone())
24364 }
24365 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBreak {
24366 TokenBreak::from_syntax_node(db, self.children[1].clone())
24367 }
24368 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24369 Trivia::from_syntax_node(db, self.children[2].clone())
24370 }
24371}
24372#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24373pub struct TerminalBreakPtr(pub SyntaxStablePtrId);
24374impl TerminalBreakPtr {}
24375impl TypedStablePtr for TerminalBreakPtr {
24376 type SyntaxNode = TerminalBreak;
24377 fn untyped(&self) -> SyntaxStablePtrId {
24378 self.0
24379 }
24380 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBreak {
24381 TerminalBreak::from_syntax_node(db, self.0.lookup(db))
24382 }
24383}
24384impl From<TerminalBreakPtr> for SyntaxStablePtrId {
24385 fn from(ptr: TerminalBreakPtr) -> Self {
24386 ptr.untyped()
24387 }
24388}
24389#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24390pub struct TerminalBreakGreen(pub GreenId);
24391impl TypedSyntaxNode for TerminalBreak {
24392 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBreak);
24393 type StablePtr = TerminalBreakPtr;
24394 type Green = TerminalBreakGreen;
24395 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24396 TerminalBreakGreen(
24397 Arc::new(GreenNode {
24398 kind: SyntaxKind::TerminalBreak,
24399 details: GreenNodeDetails::Node {
24400 children: vec![
24401 Trivia::missing(db).0,
24402 TokenBreak::missing(db).0,
24403 Trivia::missing(db).0,
24404 ],
24405 width: TextWidth::default(),
24406 },
24407 })
24408 .intern(db),
24409 )
24410 }
24411 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24412 let kind = node.kind(db);
24413 assert_eq!(
24414 kind,
24415 SyntaxKind::TerminalBreak,
24416 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24417 kind,
24418 SyntaxKind::TerminalBreak
24419 );
24420 let children = db.get_children(node.clone());
24421 Self { node, children }
24422 }
24423 fn as_syntax_node(&self) -> SyntaxNode {
24424 self.node.clone()
24425 }
24426 fn stable_ptr(&self) -> Self::StablePtr {
24427 TerminalBreakPtr(self.node.0.stable_ptr)
24428 }
24429}
24430impl From<&TerminalBreak> for SyntaxStablePtrId {
24431 fn from(node: &TerminalBreak) -> Self {
24432 node.stable_ptr().untyped()
24433 }
24434}
24435#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24436pub struct TokenStruct {
24437 node: SyntaxNode,
24438}
24439impl Token for TokenStruct {
24440 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24441 TokenStructGreen(
24442 Arc::new(GreenNode {
24443 kind: SyntaxKind::TokenStruct,
24444 details: GreenNodeDetails::Token(text),
24445 })
24446 .intern(db),
24447 )
24448 }
24449 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24450 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24451 .clone()
24452 }
24453}
24454#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24455pub struct TokenStructPtr(pub SyntaxStablePtrId);
24456impl TypedStablePtr for TokenStructPtr {
24457 type SyntaxNode = TokenStruct;
24458 fn untyped(&self) -> SyntaxStablePtrId {
24459 self.0
24460 }
24461 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenStruct {
24462 TokenStruct::from_syntax_node(db, self.0.lookup(db))
24463 }
24464}
24465impl From<TokenStructPtr> for SyntaxStablePtrId {
24466 fn from(ptr: TokenStructPtr) -> Self {
24467 ptr.untyped()
24468 }
24469}
24470#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24471pub struct TokenStructGreen(pub GreenId);
24472impl TokenStructGreen {
24473 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24474 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24475 }
24476}
24477impl TypedSyntaxNode for TokenStruct {
24478 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenStruct);
24479 type StablePtr = TokenStructPtr;
24480 type Green = TokenStructGreen;
24481 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24482 TokenStructGreen(
24483 Arc::new(GreenNode {
24484 kind: SyntaxKind::TokenMissing,
24485 details: GreenNodeDetails::Token("".into()),
24486 })
24487 .intern(db),
24488 )
24489 }
24490 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24491 match node.0.green.lookup_intern(db).details {
24492 GreenNodeDetails::Token(_) => Self { node },
24493 GreenNodeDetails::Node { .. } => {
24494 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenStruct)
24495 }
24496 }
24497 }
24498 fn as_syntax_node(&self) -> SyntaxNode {
24499 self.node.clone()
24500 }
24501 fn stable_ptr(&self) -> Self::StablePtr {
24502 TokenStructPtr(self.node.0.stable_ptr)
24503 }
24504}
24505impl From<&TokenStruct> for SyntaxStablePtrId {
24506 fn from(node: &TokenStruct) -> Self {
24507 node.stable_ptr().untyped()
24508 }
24509}
24510#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24511pub struct TerminalStruct {
24512 node: SyntaxNode,
24513 children: Arc<[SyntaxNode]>,
24514}
24515impl Terminal for TerminalStruct {
24516 const KIND: SyntaxKind = SyntaxKind::TerminalStruct;
24517 type TokenType = TokenStruct;
24518 fn new_green(
24519 db: &dyn SyntaxGroup,
24520 leading_trivia: TriviaGreen,
24521 token: <<TerminalStruct as Terminal>::TokenType as TypedSyntaxNode>::Green,
24522 trailing_trivia: TriviaGreen,
24523 ) -> Self::Green {
24524 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24525 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24526 TerminalStructGreen(
24527 Arc::new(GreenNode {
24528 kind: SyntaxKind::TerminalStruct,
24529 details: GreenNodeDetails::Node { children, width },
24530 })
24531 .intern(db),
24532 )
24533 }
24534 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24535 self.token(db).text(db)
24536 }
24537}
24538impl TerminalStruct {
24539 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24540 Trivia::from_syntax_node(db, self.children[0].clone())
24541 }
24542 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenStruct {
24543 TokenStruct::from_syntax_node(db, self.children[1].clone())
24544 }
24545 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24546 Trivia::from_syntax_node(db, self.children[2].clone())
24547 }
24548}
24549#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24550pub struct TerminalStructPtr(pub SyntaxStablePtrId);
24551impl TerminalStructPtr {}
24552impl TypedStablePtr for TerminalStructPtr {
24553 type SyntaxNode = TerminalStruct;
24554 fn untyped(&self) -> SyntaxStablePtrId {
24555 self.0
24556 }
24557 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalStruct {
24558 TerminalStruct::from_syntax_node(db, self.0.lookup(db))
24559 }
24560}
24561impl From<TerminalStructPtr> for SyntaxStablePtrId {
24562 fn from(ptr: TerminalStructPtr) -> Self {
24563 ptr.untyped()
24564 }
24565}
24566#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24567pub struct TerminalStructGreen(pub GreenId);
24568impl TypedSyntaxNode for TerminalStruct {
24569 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalStruct);
24570 type StablePtr = TerminalStructPtr;
24571 type Green = TerminalStructGreen;
24572 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24573 TerminalStructGreen(
24574 Arc::new(GreenNode {
24575 kind: SyntaxKind::TerminalStruct,
24576 details: GreenNodeDetails::Node {
24577 children: vec![
24578 Trivia::missing(db).0,
24579 TokenStruct::missing(db).0,
24580 Trivia::missing(db).0,
24581 ],
24582 width: TextWidth::default(),
24583 },
24584 })
24585 .intern(db),
24586 )
24587 }
24588 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24589 let kind = node.kind(db);
24590 assert_eq!(
24591 kind,
24592 SyntaxKind::TerminalStruct,
24593 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24594 kind,
24595 SyntaxKind::TerminalStruct
24596 );
24597 let children = db.get_children(node.clone());
24598 Self { node, children }
24599 }
24600 fn as_syntax_node(&self) -> SyntaxNode {
24601 self.node.clone()
24602 }
24603 fn stable_ptr(&self) -> Self::StablePtr {
24604 TerminalStructPtr(self.node.0.stable_ptr)
24605 }
24606}
24607impl From<&TerminalStruct> for SyntaxStablePtrId {
24608 fn from(node: &TerminalStruct) -> Self {
24609 node.stable_ptr().untyped()
24610 }
24611}
24612#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24613pub struct TokenTrait {
24614 node: SyntaxNode,
24615}
24616impl Token for TokenTrait {
24617 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24618 TokenTraitGreen(
24619 Arc::new(GreenNode {
24620 kind: SyntaxKind::TokenTrait,
24621 details: GreenNodeDetails::Token(text),
24622 })
24623 .intern(db),
24624 )
24625 }
24626 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24627 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24628 .clone()
24629 }
24630}
24631#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24632pub struct TokenTraitPtr(pub SyntaxStablePtrId);
24633impl TypedStablePtr for TokenTraitPtr {
24634 type SyntaxNode = TokenTrait;
24635 fn untyped(&self) -> SyntaxStablePtrId {
24636 self.0
24637 }
24638 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenTrait {
24639 TokenTrait::from_syntax_node(db, self.0.lookup(db))
24640 }
24641}
24642impl From<TokenTraitPtr> for SyntaxStablePtrId {
24643 fn from(ptr: TokenTraitPtr) -> Self {
24644 ptr.untyped()
24645 }
24646}
24647#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24648pub struct TokenTraitGreen(pub GreenId);
24649impl TokenTraitGreen {
24650 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24651 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24652 }
24653}
24654impl TypedSyntaxNode for TokenTrait {
24655 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenTrait);
24656 type StablePtr = TokenTraitPtr;
24657 type Green = TokenTraitGreen;
24658 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24659 TokenTraitGreen(
24660 Arc::new(GreenNode {
24661 kind: SyntaxKind::TokenMissing,
24662 details: GreenNodeDetails::Token("".into()),
24663 })
24664 .intern(db),
24665 )
24666 }
24667 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24668 match node.0.green.lookup_intern(db).details {
24669 GreenNodeDetails::Token(_) => Self { node },
24670 GreenNodeDetails::Node { .. } => {
24671 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenTrait)
24672 }
24673 }
24674 }
24675 fn as_syntax_node(&self) -> SyntaxNode {
24676 self.node.clone()
24677 }
24678 fn stable_ptr(&self) -> Self::StablePtr {
24679 TokenTraitPtr(self.node.0.stable_ptr)
24680 }
24681}
24682impl From<&TokenTrait> for SyntaxStablePtrId {
24683 fn from(node: &TokenTrait) -> Self {
24684 node.stable_ptr().untyped()
24685 }
24686}
24687#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24688pub struct TerminalTrait {
24689 node: SyntaxNode,
24690 children: Arc<[SyntaxNode]>,
24691}
24692impl Terminal for TerminalTrait {
24693 const KIND: SyntaxKind = SyntaxKind::TerminalTrait;
24694 type TokenType = TokenTrait;
24695 fn new_green(
24696 db: &dyn SyntaxGroup,
24697 leading_trivia: TriviaGreen,
24698 token: <<TerminalTrait as Terminal>::TokenType as TypedSyntaxNode>::Green,
24699 trailing_trivia: TriviaGreen,
24700 ) -> Self::Green {
24701 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24702 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24703 TerminalTraitGreen(
24704 Arc::new(GreenNode {
24705 kind: SyntaxKind::TerminalTrait,
24706 details: GreenNodeDetails::Node { children, width },
24707 })
24708 .intern(db),
24709 )
24710 }
24711 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24712 self.token(db).text(db)
24713 }
24714}
24715impl TerminalTrait {
24716 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24717 Trivia::from_syntax_node(db, self.children[0].clone())
24718 }
24719 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenTrait {
24720 TokenTrait::from_syntax_node(db, self.children[1].clone())
24721 }
24722 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24723 Trivia::from_syntax_node(db, self.children[2].clone())
24724 }
24725}
24726#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24727pub struct TerminalTraitPtr(pub SyntaxStablePtrId);
24728impl TerminalTraitPtr {}
24729impl TypedStablePtr for TerminalTraitPtr {
24730 type SyntaxNode = TerminalTrait;
24731 fn untyped(&self) -> SyntaxStablePtrId {
24732 self.0
24733 }
24734 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalTrait {
24735 TerminalTrait::from_syntax_node(db, self.0.lookup(db))
24736 }
24737}
24738impl From<TerminalTraitPtr> for SyntaxStablePtrId {
24739 fn from(ptr: TerminalTraitPtr) -> Self {
24740 ptr.untyped()
24741 }
24742}
24743#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24744pub struct TerminalTraitGreen(pub GreenId);
24745impl TypedSyntaxNode for TerminalTrait {
24746 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalTrait);
24747 type StablePtr = TerminalTraitPtr;
24748 type Green = TerminalTraitGreen;
24749 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24750 TerminalTraitGreen(
24751 Arc::new(GreenNode {
24752 kind: SyntaxKind::TerminalTrait,
24753 details: GreenNodeDetails::Node {
24754 children: vec![
24755 Trivia::missing(db).0,
24756 TokenTrait::missing(db).0,
24757 Trivia::missing(db).0,
24758 ],
24759 width: TextWidth::default(),
24760 },
24761 })
24762 .intern(db),
24763 )
24764 }
24765 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24766 let kind = node.kind(db);
24767 assert_eq!(
24768 kind,
24769 SyntaxKind::TerminalTrait,
24770 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24771 kind,
24772 SyntaxKind::TerminalTrait
24773 );
24774 let children = db.get_children(node.clone());
24775 Self { node, children }
24776 }
24777 fn as_syntax_node(&self) -> SyntaxNode {
24778 self.node.clone()
24779 }
24780 fn stable_ptr(&self) -> Self::StablePtr {
24781 TerminalTraitPtr(self.node.0.stable_ptr)
24782 }
24783}
24784impl From<&TerminalTrait> for SyntaxStablePtrId {
24785 fn from(node: &TerminalTrait) -> Self {
24786 node.stable_ptr().untyped()
24787 }
24788}
24789#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24790pub struct TokenTrue {
24791 node: SyntaxNode,
24792}
24793impl Token for TokenTrue {
24794 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24795 TokenTrueGreen(
24796 Arc::new(GreenNode {
24797 kind: SyntaxKind::TokenTrue,
24798 details: GreenNodeDetails::Token(text),
24799 })
24800 .intern(db),
24801 )
24802 }
24803 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24804 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24805 .clone()
24806 }
24807}
24808#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24809pub struct TokenTruePtr(pub SyntaxStablePtrId);
24810impl TypedStablePtr for TokenTruePtr {
24811 type SyntaxNode = TokenTrue;
24812 fn untyped(&self) -> SyntaxStablePtrId {
24813 self.0
24814 }
24815 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenTrue {
24816 TokenTrue::from_syntax_node(db, self.0.lookup(db))
24817 }
24818}
24819impl From<TokenTruePtr> for SyntaxStablePtrId {
24820 fn from(ptr: TokenTruePtr) -> Self {
24821 ptr.untyped()
24822 }
24823}
24824#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24825pub struct TokenTrueGreen(pub GreenId);
24826impl TokenTrueGreen {
24827 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24828 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
24829 }
24830}
24831impl TypedSyntaxNode for TokenTrue {
24832 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenTrue);
24833 type StablePtr = TokenTruePtr;
24834 type Green = TokenTrueGreen;
24835 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24836 TokenTrueGreen(
24837 Arc::new(GreenNode {
24838 kind: SyntaxKind::TokenMissing,
24839 details: GreenNodeDetails::Token("".into()),
24840 })
24841 .intern(db),
24842 )
24843 }
24844 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24845 match node.0.green.lookup_intern(db).details {
24846 GreenNodeDetails::Token(_) => Self { node },
24847 GreenNodeDetails::Node { .. } => {
24848 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenTrue)
24849 }
24850 }
24851 }
24852 fn as_syntax_node(&self) -> SyntaxNode {
24853 self.node.clone()
24854 }
24855 fn stable_ptr(&self) -> Self::StablePtr {
24856 TokenTruePtr(self.node.0.stable_ptr)
24857 }
24858}
24859impl From<&TokenTrue> for SyntaxStablePtrId {
24860 fn from(node: &TokenTrue) -> Self {
24861 node.stable_ptr().untyped()
24862 }
24863}
24864#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24865pub struct TerminalTrue {
24866 node: SyntaxNode,
24867 children: Arc<[SyntaxNode]>,
24868}
24869impl Terminal for TerminalTrue {
24870 const KIND: SyntaxKind = SyntaxKind::TerminalTrue;
24871 type TokenType = TokenTrue;
24872 fn new_green(
24873 db: &dyn SyntaxGroup,
24874 leading_trivia: TriviaGreen,
24875 token: <<TerminalTrue as Terminal>::TokenType as TypedSyntaxNode>::Green,
24876 trailing_trivia: TriviaGreen,
24877 ) -> Self::Green {
24878 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
24879 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
24880 TerminalTrueGreen(
24881 Arc::new(GreenNode {
24882 kind: SyntaxKind::TerminalTrue,
24883 details: GreenNodeDetails::Node { children, width },
24884 })
24885 .intern(db),
24886 )
24887 }
24888 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24889 self.token(db).text(db)
24890 }
24891}
24892impl TerminalTrue {
24893 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24894 Trivia::from_syntax_node(db, self.children[0].clone())
24895 }
24896 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenTrue {
24897 TokenTrue::from_syntax_node(db, self.children[1].clone())
24898 }
24899 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
24900 Trivia::from_syntax_node(db, self.children[2].clone())
24901 }
24902}
24903#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24904pub struct TerminalTruePtr(pub SyntaxStablePtrId);
24905impl TerminalTruePtr {}
24906impl TypedStablePtr for TerminalTruePtr {
24907 type SyntaxNode = TerminalTrue;
24908 fn untyped(&self) -> SyntaxStablePtrId {
24909 self.0
24910 }
24911 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalTrue {
24912 TerminalTrue::from_syntax_node(db, self.0.lookup(db))
24913 }
24914}
24915impl From<TerminalTruePtr> for SyntaxStablePtrId {
24916 fn from(ptr: TerminalTruePtr) -> Self {
24917 ptr.untyped()
24918 }
24919}
24920#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24921pub struct TerminalTrueGreen(pub GreenId);
24922impl TypedSyntaxNode for TerminalTrue {
24923 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalTrue);
24924 type StablePtr = TerminalTruePtr;
24925 type Green = TerminalTrueGreen;
24926 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
24927 TerminalTrueGreen(
24928 Arc::new(GreenNode {
24929 kind: SyntaxKind::TerminalTrue,
24930 details: GreenNodeDetails::Node {
24931 children: vec![
24932 Trivia::missing(db).0,
24933 TokenTrue::missing(db).0,
24934 Trivia::missing(db).0,
24935 ],
24936 width: TextWidth::default(),
24937 },
24938 })
24939 .intern(db),
24940 )
24941 }
24942 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
24943 let kind = node.kind(db);
24944 assert_eq!(
24945 kind,
24946 SyntaxKind::TerminalTrue,
24947 "Unexpected SyntaxKind {:?}. Expected {:?}.",
24948 kind,
24949 SyntaxKind::TerminalTrue
24950 );
24951 let children = db.get_children(node.clone());
24952 Self { node, children }
24953 }
24954 fn as_syntax_node(&self) -> SyntaxNode {
24955 self.node.clone()
24956 }
24957 fn stable_ptr(&self) -> Self::StablePtr {
24958 TerminalTruePtr(self.node.0.stable_ptr)
24959 }
24960}
24961impl From<&TerminalTrue> for SyntaxStablePtrId {
24962 fn from(node: &TerminalTrue) -> Self {
24963 node.stable_ptr().untyped()
24964 }
24965}
24966#[derive(Clone, Debug, Eq, Hash, PartialEq)]
24967pub struct TokenType {
24968 node: SyntaxNode,
24969}
24970impl Token for TokenType {
24971 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
24972 TokenTypeGreen(
24973 Arc::new(GreenNode {
24974 kind: SyntaxKind::TokenType,
24975 details: GreenNodeDetails::Token(text),
24976 })
24977 .intern(db),
24978 )
24979 }
24980 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
24981 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
24982 .clone()
24983 }
24984}
24985#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
24986pub struct TokenTypePtr(pub SyntaxStablePtrId);
24987impl TypedStablePtr for TokenTypePtr {
24988 type SyntaxNode = TokenType;
24989 fn untyped(&self) -> SyntaxStablePtrId {
24990 self.0
24991 }
24992 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenType {
24993 TokenType::from_syntax_node(db, self.0.lookup(db))
24994 }
24995}
24996impl From<TokenTypePtr> for SyntaxStablePtrId {
24997 fn from(ptr: TokenTypePtr) -> Self {
24998 ptr.untyped()
24999 }
25000}
25001#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25002pub struct TokenTypeGreen(pub GreenId);
25003impl TokenTypeGreen {
25004 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25005 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25006 }
25007}
25008impl TypedSyntaxNode for TokenType {
25009 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenType);
25010 type StablePtr = TokenTypePtr;
25011 type Green = TokenTypeGreen;
25012 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25013 TokenTypeGreen(
25014 Arc::new(GreenNode {
25015 kind: SyntaxKind::TokenMissing,
25016 details: GreenNodeDetails::Token("".into()),
25017 })
25018 .intern(db),
25019 )
25020 }
25021 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25022 match node.0.green.lookup_intern(db).details {
25023 GreenNodeDetails::Token(_) => Self { node },
25024 GreenNodeDetails::Node { .. } => {
25025 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenType)
25026 }
25027 }
25028 }
25029 fn as_syntax_node(&self) -> SyntaxNode {
25030 self.node.clone()
25031 }
25032 fn stable_ptr(&self) -> Self::StablePtr {
25033 TokenTypePtr(self.node.0.stable_ptr)
25034 }
25035}
25036impl From<&TokenType> for SyntaxStablePtrId {
25037 fn from(node: &TokenType) -> Self {
25038 node.stable_ptr().untyped()
25039 }
25040}
25041#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25042pub struct TerminalType {
25043 node: SyntaxNode,
25044 children: Arc<[SyntaxNode]>,
25045}
25046impl Terminal for TerminalType {
25047 const KIND: SyntaxKind = SyntaxKind::TerminalType;
25048 type TokenType = TokenType;
25049 fn new_green(
25050 db: &dyn SyntaxGroup,
25051 leading_trivia: TriviaGreen,
25052 token: <<TerminalType as Terminal>::TokenType as TypedSyntaxNode>::Green,
25053 trailing_trivia: TriviaGreen,
25054 ) -> Self::Green {
25055 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25056 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25057 TerminalTypeGreen(
25058 Arc::new(GreenNode {
25059 kind: SyntaxKind::TerminalType,
25060 details: GreenNodeDetails::Node { children, width },
25061 })
25062 .intern(db),
25063 )
25064 }
25065 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25066 self.token(db).text(db)
25067 }
25068}
25069impl TerminalType {
25070 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25071 Trivia::from_syntax_node(db, self.children[0].clone())
25072 }
25073 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenType {
25074 TokenType::from_syntax_node(db, self.children[1].clone())
25075 }
25076 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25077 Trivia::from_syntax_node(db, self.children[2].clone())
25078 }
25079}
25080#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25081pub struct TerminalTypePtr(pub SyntaxStablePtrId);
25082impl TerminalTypePtr {}
25083impl TypedStablePtr for TerminalTypePtr {
25084 type SyntaxNode = TerminalType;
25085 fn untyped(&self) -> SyntaxStablePtrId {
25086 self.0
25087 }
25088 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalType {
25089 TerminalType::from_syntax_node(db, self.0.lookup(db))
25090 }
25091}
25092impl From<TerminalTypePtr> for SyntaxStablePtrId {
25093 fn from(ptr: TerminalTypePtr) -> Self {
25094 ptr.untyped()
25095 }
25096}
25097#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25098pub struct TerminalTypeGreen(pub GreenId);
25099impl TypedSyntaxNode for TerminalType {
25100 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalType);
25101 type StablePtr = TerminalTypePtr;
25102 type Green = TerminalTypeGreen;
25103 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25104 TerminalTypeGreen(
25105 Arc::new(GreenNode {
25106 kind: SyntaxKind::TerminalType,
25107 details: GreenNodeDetails::Node {
25108 children: vec![
25109 Trivia::missing(db).0,
25110 TokenType::missing(db).0,
25111 Trivia::missing(db).0,
25112 ],
25113 width: TextWidth::default(),
25114 },
25115 })
25116 .intern(db),
25117 )
25118 }
25119 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25120 let kind = node.kind(db);
25121 assert_eq!(
25122 kind,
25123 SyntaxKind::TerminalType,
25124 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25125 kind,
25126 SyntaxKind::TerminalType
25127 );
25128 let children = db.get_children(node.clone());
25129 Self { node, children }
25130 }
25131 fn as_syntax_node(&self) -> SyntaxNode {
25132 self.node.clone()
25133 }
25134 fn stable_ptr(&self) -> Self::StablePtr {
25135 TerminalTypePtr(self.node.0.stable_ptr)
25136 }
25137}
25138impl From<&TerminalType> for SyntaxStablePtrId {
25139 fn from(node: &TerminalType) -> Self {
25140 node.stable_ptr().untyped()
25141 }
25142}
25143#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25144pub struct TokenUse {
25145 node: SyntaxNode,
25146}
25147impl Token for TokenUse {
25148 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25149 TokenUseGreen(
25150 Arc::new(GreenNode {
25151 kind: SyntaxKind::TokenUse,
25152 details: GreenNodeDetails::Token(text),
25153 })
25154 .intern(db),
25155 )
25156 }
25157 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25158 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25159 .clone()
25160 }
25161}
25162#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25163pub struct TokenUsePtr(pub SyntaxStablePtrId);
25164impl TypedStablePtr for TokenUsePtr {
25165 type SyntaxNode = TokenUse;
25166 fn untyped(&self) -> SyntaxStablePtrId {
25167 self.0
25168 }
25169 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenUse {
25170 TokenUse::from_syntax_node(db, self.0.lookup(db))
25171 }
25172}
25173impl From<TokenUsePtr> for SyntaxStablePtrId {
25174 fn from(ptr: TokenUsePtr) -> Self {
25175 ptr.untyped()
25176 }
25177}
25178#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25179pub struct TokenUseGreen(pub GreenId);
25180impl TokenUseGreen {
25181 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25182 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25183 }
25184}
25185impl TypedSyntaxNode for TokenUse {
25186 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenUse);
25187 type StablePtr = TokenUsePtr;
25188 type Green = TokenUseGreen;
25189 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25190 TokenUseGreen(
25191 Arc::new(GreenNode {
25192 kind: SyntaxKind::TokenMissing,
25193 details: GreenNodeDetails::Token("".into()),
25194 })
25195 .intern(db),
25196 )
25197 }
25198 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25199 match node.0.green.lookup_intern(db).details {
25200 GreenNodeDetails::Token(_) => Self { node },
25201 GreenNodeDetails::Node { .. } => {
25202 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenUse)
25203 }
25204 }
25205 }
25206 fn as_syntax_node(&self) -> SyntaxNode {
25207 self.node.clone()
25208 }
25209 fn stable_ptr(&self) -> Self::StablePtr {
25210 TokenUsePtr(self.node.0.stable_ptr)
25211 }
25212}
25213impl From<&TokenUse> for SyntaxStablePtrId {
25214 fn from(node: &TokenUse) -> Self {
25215 node.stable_ptr().untyped()
25216 }
25217}
25218#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25219pub struct TerminalUse {
25220 node: SyntaxNode,
25221 children: Arc<[SyntaxNode]>,
25222}
25223impl Terminal for TerminalUse {
25224 const KIND: SyntaxKind = SyntaxKind::TerminalUse;
25225 type TokenType = TokenUse;
25226 fn new_green(
25227 db: &dyn SyntaxGroup,
25228 leading_trivia: TriviaGreen,
25229 token: <<TerminalUse as Terminal>::TokenType as TypedSyntaxNode>::Green,
25230 trailing_trivia: TriviaGreen,
25231 ) -> Self::Green {
25232 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25233 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25234 TerminalUseGreen(
25235 Arc::new(GreenNode {
25236 kind: SyntaxKind::TerminalUse,
25237 details: GreenNodeDetails::Node { children, width },
25238 })
25239 .intern(db),
25240 )
25241 }
25242 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25243 self.token(db).text(db)
25244 }
25245}
25246impl TerminalUse {
25247 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25248 Trivia::from_syntax_node(db, self.children[0].clone())
25249 }
25250 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenUse {
25251 TokenUse::from_syntax_node(db, self.children[1].clone())
25252 }
25253 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25254 Trivia::from_syntax_node(db, self.children[2].clone())
25255 }
25256}
25257#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25258pub struct TerminalUsePtr(pub SyntaxStablePtrId);
25259impl TerminalUsePtr {}
25260impl TypedStablePtr for TerminalUsePtr {
25261 type SyntaxNode = TerminalUse;
25262 fn untyped(&self) -> SyntaxStablePtrId {
25263 self.0
25264 }
25265 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalUse {
25266 TerminalUse::from_syntax_node(db, self.0.lookup(db))
25267 }
25268}
25269impl From<TerminalUsePtr> for SyntaxStablePtrId {
25270 fn from(ptr: TerminalUsePtr) -> Self {
25271 ptr.untyped()
25272 }
25273}
25274#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25275pub struct TerminalUseGreen(pub GreenId);
25276impl TypedSyntaxNode for TerminalUse {
25277 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalUse);
25278 type StablePtr = TerminalUsePtr;
25279 type Green = TerminalUseGreen;
25280 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25281 TerminalUseGreen(
25282 Arc::new(GreenNode {
25283 kind: SyntaxKind::TerminalUse,
25284 details: GreenNodeDetails::Node {
25285 children: vec![
25286 Trivia::missing(db).0,
25287 TokenUse::missing(db).0,
25288 Trivia::missing(db).0,
25289 ],
25290 width: TextWidth::default(),
25291 },
25292 })
25293 .intern(db),
25294 )
25295 }
25296 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25297 let kind = node.kind(db);
25298 assert_eq!(
25299 kind,
25300 SyntaxKind::TerminalUse,
25301 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25302 kind,
25303 SyntaxKind::TerminalUse
25304 );
25305 let children = db.get_children(node.clone());
25306 Self { node, children }
25307 }
25308 fn as_syntax_node(&self) -> SyntaxNode {
25309 self.node.clone()
25310 }
25311 fn stable_ptr(&self) -> Self::StablePtr {
25312 TerminalUsePtr(self.node.0.stable_ptr)
25313 }
25314}
25315impl From<&TerminalUse> for SyntaxStablePtrId {
25316 fn from(node: &TerminalUse) -> Self {
25317 node.stable_ptr().untyped()
25318 }
25319}
25320#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25321pub struct TokenPub {
25322 node: SyntaxNode,
25323}
25324impl Token for TokenPub {
25325 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25326 TokenPubGreen(
25327 Arc::new(GreenNode {
25328 kind: SyntaxKind::TokenPub,
25329 details: GreenNodeDetails::Token(text),
25330 })
25331 .intern(db),
25332 )
25333 }
25334 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25335 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25336 .clone()
25337 }
25338}
25339#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25340pub struct TokenPubPtr(pub SyntaxStablePtrId);
25341impl TypedStablePtr for TokenPubPtr {
25342 type SyntaxNode = TokenPub;
25343 fn untyped(&self) -> SyntaxStablePtrId {
25344 self.0
25345 }
25346 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPub {
25347 TokenPub::from_syntax_node(db, self.0.lookup(db))
25348 }
25349}
25350impl From<TokenPubPtr> for SyntaxStablePtrId {
25351 fn from(ptr: TokenPubPtr) -> Self {
25352 ptr.untyped()
25353 }
25354}
25355#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25356pub struct TokenPubGreen(pub GreenId);
25357impl TokenPubGreen {
25358 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25359 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25360 }
25361}
25362impl TypedSyntaxNode for TokenPub {
25363 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPub);
25364 type StablePtr = TokenPubPtr;
25365 type Green = TokenPubGreen;
25366 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25367 TokenPubGreen(
25368 Arc::new(GreenNode {
25369 kind: SyntaxKind::TokenMissing,
25370 details: GreenNodeDetails::Token("".into()),
25371 })
25372 .intern(db),
25373 )
25374 }
25375 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25376 match node.0.green.lookup_intern(db).details {
25377 GreenNodeDetails::Token(_) => Self { node },
25378 GreenNodeDetails::Node { .. } => {
25379 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPub)
25380 }
25381 }
25382 }
25383 fn as_syntax_node(&self) -> SyntaxNode {
25384 self.node.clone()
25385 }
25386 fn stable_ptr(&self) -> Self::StablePtr {
25387 TokenPubPtr(self.node.0.stable_ptr)
25388 }
25389}
25390impl From<&TokenPub> for SyntaxStablePtrId {
25391 fn from(node: &TokenPub) -> Self {
25392 node.stable_ptr().untyped()
25393 }
25394}
25395#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25396pub struct TerminalPub {
25397 node: SyntaxNode,
25398 children: Arc<[SyntaxNode]>,
25399}
25400impl Terminal for TerminalPub {
25401 const KIND: SyntaxKind = SyntaxKind::TerminalPub;
25402 type TokenType = TokenPub;
25403 fn new_green(
25404 db: &dyn SyntaxGroup,
25405 leading_trivia: TriviaGreen,
25406 token: <<TerminalPub as Terminal>::TokenType as TypedSyntaxNode>::Green,
25407 trailing_trivia: TriviaGreen,
25408 ) -> Self::Green {
25409 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25410 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25411 TerminalPubGreen(
25412 Arc::new(GreenNode {
25413 kind: SyntaxKind::TerminalPub,
25414 details: GreenNodeDetails::Node { children, width },
25415 })
25416 .intern(db),
25417 )
25418 }
25419 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25420 self.token(db).text(db)
25421 }
25422}
25423impl TerminalPub {
25424 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25425 Trivia::from_syntax_node(db, self.children[0].clone())
25426 }
25427 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPub {
25428 TokenPub::from_syntax_node(db, self.children[1].clone())
25429 }
25430 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25431 Trivia::from_syntax_node(db, self.children[2].clone())
25432 }
25433}
25434#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25435pub struct TerminalPubPtr(pub SyntaxStablePtrId);
25436impl TerminalPubPtr {}
25437impl TypedStablePtr for TerminalPubPtr {
25438 type SyntaxNode = TerminalPub;
25439 fn untyped(&self) -> SyntaxStablePtrId {
25440 self.0
25441 }
25442 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPub {
25443 TerminalPub::from_syntax_node(db, self.0.lookup(db))
25444 }
25445}
25446impl From<TerminalPubPtr> for SyntaxStablePtrId {
25447 fn from(ptr: TerminalPubPtr) -> Self {
25448 ptr.untyped()
25449 }
25450}
25451#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25452pub struct TerminalPubGreen(pub GreenId);
25453impl TypedSyntaxNode for TerminalPub {
25454 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPub);
25455 type StablePtr = TerminalPubPtr;
25456 type Green = TerminalPubGreen;
25457 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25458 TerminalPubGreen(
25459 Arc::new(GreenNode {
25460 kind: SyntaxKind::TerminalPub,
25461 details: GreenNodeDetails::Node {
25462 children: vec![
25463 Trivia::missing(db).0,
25464 TokenPub::missing(db).0,
25465 Trivia::missing(db).0,
25466 ],
25467 width: TextWidth::default(),
25468 },
25469 })
25470 .intern(db),
25471 )
25472 }
25473 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25474 let kind = node.kind(db);
25475 assert_eq!(
25476 kind,
25477 SyntaxKind::TerminalPub,
25478 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25479 kind,
25480 SyntaxKind::TerminalPub
25481 );
25482 let children = db.get_children(node.clone());
25483 Self { node, children }
25484 }
25485 fn as_syntax_node(&self) -> SyntaxNode {
25486 self.node.clone()
25487 }
25488 fn stable_ptr(&self) -> Self::StablePtr {
25489 TerminalPubPtr(self.node.0.stable_ptr)
25490 }
25491}
25492impl From<&TerminalPub> for SyntaxStablePtrId {
25493 fn from(node: &TerminalPub) -> Self {
25494 node.stable_ptr().untyped()
25495 }
25496}
25497#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25498pub struct TokenAnd {
25499 node: SyntaxNode,
25500}
25501impl Token for TokenAnd {
25502 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25503 TokenAndGreen(
25504 Arc::new(GreenNode {
25505 kind: SyntaxKind::TokenAnd,
25506 details: GreenNodeDetails::Token(text),
25507 })
25508 .intern(db),
25509 )
25510 }
25511 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25512 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25513 .clone()
25514 }
25515}
25516#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25517pub struct TokenAndPtr(pub SyntaxStablePtrId);
25518impl TypedStablePtr for TokenAndPtr {
25519 type SyntaxNode = TokenAnd;
25520 fn untyped(&self) -> SyntaxStablePtrId {
25521 self.0
25522 }
25523 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAnd {
25524 TokenAnd::from_syntax_node(db, self.0.lookup(db))
25525 }
25526}
25527impl From<TokenAndPtr> for SyntaxStablePtrId {
25528 fn from(ptr: TokenAndPtr) -> Self {
25529 ptr.untyped()
25530 }
25531}
25532#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25533pub struct TokenAndGreen(pub GreenId);
25534impl TokenAndGreen {
25535 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25536 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25537 }
25538}
25539impl TypedSyntaxNode for TokenAnd {
25540 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAnd);
25541 type StablePtr = TokenAndPtr;
25542 type Green = TokenAndGreen;
25543 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25544 TokenAndGreen(
25545 Arc::new(GreenNode {
25546 kind: SyntaxKind::TokenMissing,
25547 details: GreenNodeDetails::Token("".into()),
25548 })
25549 .intern(db),
25550 )
25551 }
25552 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25553 match node.0.green.lookup_intern(db).details {
25554 GreenNodeDetails::Token(_) => Self { node },
25555 GreenNodeDetails::Node { .. } => {
25556 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAnd)
25557 }
25558 }
25559 }
25560 fn as_syntax_node(&self) -> SyntaxNode {
25561 self.node.clone()
25562 }
25563 fn stable_ptr(&self) -> Self::StablePtr {
25564 TokenAndPtr(self.node.0.stable_ptr)
25565 }
25566}
25567impl From<&TokenAnd> for SyntaxStablePtrId {
25568 fn from(node: &TokenAnd) -> Self {
25569 node.stable_ptr().untyped()
25570 }
25571}
25572#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25573pub struct TerminalAnd {
25574 node: SyntaxNode,
25575 children: Arc<[SyntaxNode]>,
25576}
25577impl Terminal for TerminalAnd {
25578 const KIND: SyntaxKind = SyntaxKind::TerminalAnd;
25579 type TokenType = TokenAnd;
25580 fn new_green(
25581 db: &dyn SyntaxGroup,
25582 leading_trivia: TriviaGreen,
25583 token: <<TerminalAnd as Terminal>::TokenType as TypedSyntaxNode>::Green,
25584 trailing_trivia: TriviaGreen,
25585 ) -> Self::Green {
25586 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25587 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25588 TerminalAndGreen(
25589 Arc::new(GreenNode {
25590 kind: SyntaxKind::TerminalAnd,
25591 details: GreenNodeDetails::Node { children, width },
25592 })
25593 .intern(db),
25594 )
25595 }
25596 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25597 self.token(db).text(db)
25598 }
25599}
25600impl TerminalAnd {
25601 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25602 Trivia::from_syntax_node(db, self.children[0].clone())
25603 }
25604 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAnd {
25605 TokenAnd::from_syntax_node(db, self.children[1].clone())
25606 }
25607 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25608 Trivia::from_syntax_node(db, self.children[2].clone())
25609 }
25610}
25611#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25612pub struct TerminalAndPtr(pub SyntaxStablePtrId);
25613impl TerminalAndPtr {}
25614impl TypedStablePtr for TerminalAndPtr {
25615 type SyntaxNode = TerminalAnd;
25616 fn untyped(&self) -> SyntaxStablePtrId {
25617 self.0
25618 }
25619 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAnd {
25620 TerminalAnd::from_syntax_node(db, self.0.lookup(db))
25621 }
25622}
25623impl From<TerminalAndPtr> for SyntaxStablePtrId {
25624 fn from(ptr: TerminalAndPtr) -> Self {
25625 ptr.untyped()
25626 }
25627}
25628#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25629pub struct TerminalAndGreen(pub GreenId);
25630impl TypedSyntaxNode for TerminalAnd {
25631 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAnd);
25632 type StablePtr = TerminalAndPtr;
25633 type Green = TerminalAndGreen;
25634 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25635 TerminalAndGreen(
25636 Arc::new(GreenNode {
25637 kind: SyntaxKind::TerminalAnd,
25638 details: GreenNodeDetails::Node {
25639 children: vec![
25640 Trivia::missing(db).0,
25641 TokenAnd::missing(db).0,
25642 Trivia::missing(db).0,
25643 ],
25644 width: TextWidth::default(),
25645 },
25646 })
25647 .intern(db),
25648 )
25649 }
25650 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25651 let kind = node.kind(db);
25652 assert_eq!(
25653 kind,
25654 SyntaxKind::TerminalAnd,
25655 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25656 kind,
25657 SyntaxKind::TerminalAnd
25658 );
25659 let children = db.get_children(node.clone());
25660 Self { node, children }
25661 }
25662 fn as_syntax_node(&self) -> SyntaxNode {
25663 self.node.clone()
25664 }
25665 fn stable_ptr(&self) -> Self::StablePtr {
25666 TerminalAndPtr(self.node.0.stable_ptr)
25667 }
25668}
25669impl From<&TerminalAnd> for SyntaxStablePtrId {
25670 fn from(node: &TerminalAnd) -> Self {
25671 node.stable_ptr().untyped()
25672 }
25673}
25674#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25675pub struct TokenAndAnd {
25676 node: SyntaxNode,
25677}
25678impl Token for TokenAndAnd {
25679 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25680 TokenAndAndGreen(
25681 Arc::new(GreenNode {
25682 kind: SyntaxKind::TokenAndAnd,
25683 details: GreenNodeDetails::Token(text),
25684 })
25685 .intern(db),
25686 )
25687 }
25688 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25689 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25690 .clone()
25691 }
25692}
25693#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25694pub struct TokenAndAndPtr(pub SyntaxStablePtrId);
25695impl TypedStablePtr for TokenAndAndPtr {
25696 type SyntaxNode = TokenAndAnd;
25697 fn untyped(&self) -> SyntaxStablePtrId {
25698 self.0
25699 }
25700 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAndAnd {
25701 TokenAndAnd::from_syntax_node(db, self.0.lookup(db))
25702 }
25703}
25704impl From<TokenAndAndPtr> for SyntaxStablePtrId {
25705 fn from(ptr: TokenAndAndPtr) -> Self {
25706 ptr.untyped()
25707 }
25708}
25709#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25710pub struct TokenAndAndGreen(pub GreenId);
25711impl TokenAndAndGreen {
25712 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25713 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25714 }
25715}
25716impl TypedSyntaxNode for TokenAndAnd {
25717 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAndAnd);
25718 type StablePtr = TokenAndAndPtr;
25719 type Green = TokenAndAndGreen;
25720 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25721 TokenAndAndGreen(
25722 Arc::new(GreenNode {
25723 kind: SyntaxKind::TokenMissing,
25724 details: GreenNodeDetails::Token("".into()),
25725 })
25726 .intern(db),
25727 )
25728 }
25729 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25730 match node.0.green.lookup_intern(db).details {
25731 GreenNodeDetails::Token(_) => Self { node },
25732 GreenNodeDetails::Node { .. } => {
25733 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAndAnd)
25734 }
25735 }
25736 }
25737 fn as_syntax_node(&self) -> SyntaxNode {
25738 self.node.clone()
25739 }
25740 fn stable_ptr(&self) -> Self::StablePtr {
25741 TokenAndAndPtr(self.node.0.stable_ptr)
25742 }
25743}
25744impl From<&TokenAndAnd> for SyntaxStablePtrId {
25745 fn from(node: &TokenAndAnd) -> Self {
25746 node.stable_ptr().untyped()
25747 }
25748}
25749#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25750pub struct TerminalAndAnd {
25751 node: SyntaxNode,
25752 children: Arc<[SyntaxNode]>,
25753}
25754impl Terminal for TerminalAndAnd {
25755 const KIND: SyntaxKind = SyntaxKind::TerminalAndAnd;
25756 type TokenType = TokenAndAnd;
25757 fn new_green(
25758 db: &dyn SyntaxGroup,
25759 leading_trivia: TriviaGreen,
25760 token: <<TerminalAndAnd as Terminal>::TokenType as TypedSyntaxNode>::Green,
25761 trailing_trivia: TriviaGreen,
25762 ) -> Self::Green {
25763 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25764 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25765 TerminalAndAndGreen(
25766 Arc::new(GreenNode {
25767 kind: SyntaxKind::TerminalAndAnd,
25768 details: GreenNodeDetails::Node { children, width },
25769 })
25770 .intern(db),
25771 )
25772 }
25773 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25774 self.token(db).text(db)
25775 }
25776}
25777impl TerminalAndAnd {
25778 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25779 Trivia::from_syntax_node(db, self.children[0].clone())
25780 }
25781 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAndAnd {
25782 TokenAndAnd::from_syntax_node(db, self.children[1].clone())
25783 }
25784 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25785 Trivia::from_syntax_node(db, self.children[2].clone())
25786 }
25787}
25788#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25789pub struct TerminalAndAndPtr(pub SyntaxStablePtrId);
25790impl TerminalAndAndPtr {}
25791impl TypedStablePtr for TerminalAndAndPtr {
25792 type SyntaxNode = TerminalAndAnd;
25793 fn untyped(&self) -> SyntaxStablePtrId {
25794 self.0
25795 }
25796 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAndAnd {
25797 TerminalAndAnd::from_syntax_node(db, self.0.lookup(db))
25798 }
25799}
25800impl From<TerminalAndAndPtr> for SyntaxStablePtrId {
25801 fn from(ptr: TerminalAndAndPtr) -> Self {
25802 ptr.untyped()
25803 }
25804}
25805#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25806pub struct TerminalAndAndGreen(pub GreenId);
25807impl TypedSyntaxNode for TerminalAndAnd {
25808 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAndAnd);
25809 type StablePtr = TerminalAndAndPtr;
25810 type Green = TerminalAndAndGreen;
25811 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25812 TerminalAndAndGreen(
25813 Arc::new(GreenNode {
25814 kind: SyntaxKind::TerminalAndAnd,
25815 details: GreenNodeDetails::Node {
25816 children: vec![
25817 Trivia::missing(db).0,
25818 TokenAndAnd::missing(db).0,
25819 Trivia::missing(db).0,
25820 ],
25821 width: TextWidth::default(),
25822 },
25823 })
25824 .intern(db),
25825 )
25826 }
25827 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25828 let kind = node.kind(db);
25829 assert_eq!(
25830 kind,
25831 SyntaxKind::TerminalAndAnd,
25832 "Unexpected SyntaxKind {:?}. Expected {:?}.",
25833 kind,
25834 SyntaxKind::TerminalAndAnd
25835 );
25836 let children = db.get_children(node.clone());
25837 Self { node, children }
25838 }
25839 fn as_syntax_node(&self) -> SyntaxNode {
25840 self.node.clone()
25841 }
25842 fn stable_ptr(&self) -> Self::StablePtr {
25843 TerminalAndAndPtr(self.node.0.stable_ptr)
25844 }
25845}
25846impl From<&TerminalAndAnd> for SyntaxStablePtrId {
25847 fn from(node: &TerminalAndAnd) -> Self {
25848 node.stable_ptr().untyped()
25849 }
25850}
25851#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25852pub struct TokenArrow {
25853 node: SyntaxNode,
25854}
25855impl Token for TokenArrow {
25856 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
25857 TokenArrowGreen(
25858 Arc::new(GreenNode {
25859 kind: SyntaxKind::TokenArrow,
25860 details: GreenNodeDetails::Token(text),
25861 })
25862 .intern(db),
25863 )
25864 }
25865 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25866 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
25867 .clone()
25868 }
25869}
25870#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25871pub struct TokenArrowPtr(pub SyntaxStablePtrId);
25872impl TypedStablePtr for TokenArrowPtr {
25873 type SyntaxNode = TokenArrow;
25874 fn untyped(&self) -> SyntaxStablePtrId {
25875 self.0
25876 }
25877 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenArrow {
25878 TokenArrow::from_syntax_node(db, self.0.lookup(db))
25879 }
25880}
25881impl From<TokenArrowPtr> for SyntaxStablePtrId {
25882 fn from(ptr: TokenArrowPtr) -> Self {
25883 ptr.untyped()
25884 }
25885}
25886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25887pub struct TokenArrowGreen(pub GreenId);
25888impl TokenArrowGreen {
25889 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25890 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
25891 }
25892}
25893impl TypedSyntaxNode for TokenArrow {
25894 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenArrow);
25895 type StablePtr = TokenArrowPtr;
25896 type Green = TokenArrowGreen;
25897 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25898 TokenArrowGreen(
25899 Arc::new(GreenNode {
25900 kind: SyntaxKind::TokenMissing,
25901 details: GreenNodeDetails::Token("".into()),
25902 })
25903 .intern(db),
25904 )
25905 }
25906 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
25907 match node.0.green.lookup_intern(db).details {
25908 GreenNodeDetails::Token(_) => Self { node },
25909 GreenNodeDetails::Node { .. } => {
25910 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenArrow)
25911 }
25912 }
25913 }
25914 fn as_syntax_node(&self) -> SyntaxNode {
25915 self.node.clone()
25916 }
25917 fn stable_ptr(&self) -> Self::StablePtr {
25918 TokenArrowPtr(self.node.0.stable_ptr)
25919 }
25920}
25921impl From<&TokenArrow> for SyntaxStablePtrId {
25922 fn from(node: &TokenArrow) -> Self {
25923 node.stable_ptr().untyped()
25924 }
25925}
25926#[derive(Clone, Debug, Eq, Hash, PartialEq)]
25927pub struct TerminalArrow {
25928 node: SyntaxNode,
25929 children: Arc<[SyntaxNode]>,
25930}
25931impl Terminal for TerminalArrow {
25932 const KIND: SyntaxKind = SyntaxKind::TerminalArrow;
25933 type TokenType = TokenArrow;
25934 fn new_green(
25935 db: &dyn SyntaxGroup,
25936 leading_trivia: TriviaGreen,
25937 token: <<TerminalArrow as Terminal>::TokenType as TypedSyntaxNode>::Green,
25938 trailing_trivia: TriviaGreen,
25939 ) -> Self::Green {
25940 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
25941 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
25942 TerminalArrowGreen(
25943 Arc::new(GreenNode {
25944 kind: SyntaxKind::TerminalArrow,
25945 details: GreenNodeDetails::Node { children, width },
25946 })
25947 .intern(db),
25948 )
25949 }
25950 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
25951 self.token(db).text(db)
25952 }
25953}
25954impl TerminalArrow {
25955 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25956 Trivia::from_syntax_node(db, self.children[0].clone())
25957 }
25958 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenArrow {
25959 TokenArrow::from_syntax_node(db, self.children[1].clone())
25960 }
25961 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
25962 Trivia::from_syntax_node(db, self.children[2].clone())
25963 }
25964}
25965#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25966pub struct TerminalArrowPtr(pub SyntaxStablePtrId);
25967impl TerminalArrowPtr {}
25968impl TypedStablePtr for TerminalArrowPtr {
25969 type SyntaxNode = TerminalArrow;
25970 fn untyped(&self) -> SyntaxStablePtrId {
25971 self.0
25972 }
25973 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalArrow {
25974 TerminalArrow::from_syntax_node(db, self.0.lookup(db))
25975 }
25976}
25977impl From<TerminalArrowPtr> for SyntaxStablePtrId {
25978 fn from(ptr: TerminalArrowPtr) -> Self {
25979 ptr.untyped()
25980 }
25981}
25982#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
25983pub struct TerminalArrowGreen(pub GreenId);
25984impl TypedSyntaxNode for TerminalArrow {
25985 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalArrow);
25986 type StablePtr = TerminalArrowPtr;
25987 type Green = TerminalArrowGreen;
25988 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
25989 TerminalArrowGreen(
25990 Arc::new(GreenNode {
25991 kind: SyntaxKind::TerminalArrow,
25992 details: GreenNodeDetails::Node {
25993 children: vec![
25994 Trivia::missing(db).0,
25995 TokenArrow::missing(db).0,
25996 Trivia::missing(db).0,
25997 ],
25998 width: TextWidth::default(),
25999 },
26000 })
26001 .intern(db),
26002 )
26003 }
26004 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26005 let kind = node.kind(db);
26006 assert_eq!(
26007 kind,
26008 SyntaxKind::TerminalArrow,
26009 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26010 kind,
26011 SyntaxKind::TerminalArrow
26012 );
26013 let children = db.get_children(node.clone());
26014 Self { node, children }
26015 }
26016 fn as_syntax_node(&self) -> SyntaxNode {
26017 self.node.clone()
26018 }
26019 fn stable_ptr(&self) -> Self::StablePtr {
26020 TerminalArrowPtr(self.node.0.stable_ptr)
26021 }
26022}
26023impl From<&TerminalArrow> for SyntaxStablePtrId {
26024 fn from(node: &TerminalArrow) -> Self {
26025 node.stable_ptr().untyped()
26026 }
26027}
26028#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26029pub struct TokenAt {
26030 node: SyntaxNode,
26031}
26032impl Token for TokenAt {
26033 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26034 TokenAtGreen(
26035 Arc::new(GreenNode {
26036 kind: SyntaxKind::TokenAt,
26037 details: GreenNodeDetails::Token(text),
26038 })
26039 .intern(db),
26040 )
26041 }
26042 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26043 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26044 .clone()
26045 }
26046}
26047#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26048pub struct TokenAtPtr(pub SyntaxStablePtrId);
26049impl TypedStablePtr for TokenAtPtr {
26050 type SyntaxNode = TokenAt;
26051 fn untyped(&self) -> SyntaxStablePtrId {
26052 self.0
26053 }
26054 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenAt {
26055 TokenAt::from_syntax_node(db, self.0.lookup(db))
26056 }
26057}
26058impl From<TokenAtPtr> for SyntaxStablePtrId {
26059 fn from(ptr: TokenAtPtr) -> Self {
26060 ptr.untyped()
26061 }
26062}
26063#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26064pub struct TokenAtGreen(pub GreenId);
26065impl TokenAtGreen {
26066 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26067 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26068 }
26069}
26070impl TypedSyntaxNode for TokenAt {
26071 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenAt);
26072 type StablePtr = TokenAtPtr;
26073 type Green = TokenAtGreen;
26074 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26075 TokenAtGreen(
26076 Arc::new(GreenNode {
26077 kind: SyntaxKind::TokenMissing,
26078 details: GreenNodeDetails::Token("".into()),
26079 })
26080 .intern(db),
26081 )
26082 }
26083 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26084 match node.0.green.lookup_intern(db).details {
26085 GreenNodeDetails::Token(_) => Self { node },
26086 GreenNodeDetails::Node { .. } => {
26087 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenAt)
26088 }
26089 }
26090 }
26091 fn as_syntax_node(&self) -> SyntaxNode {
26092 self.node.clone()
26093 }
26094 fn stable_ptr(&self) -> Self::StablePtr {
26095 TokenAtPtr(self.node.0.stable_ptr)
26096 }
26097}
26098impl From<&TokenAt> for SyntaxStablePtrId {
26099 fn from(node: &TokenAt) -> Self {
26100 node.stable_ptr().untyped()
26101 }
26102}
26103#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26104pub struct TerminalAt {
26105 node: SyntaxNode,
26106 children: Arc<[SyntaxNode]>,
26107}
26108impl Terminal for TerminalAt {
26109 const KIND: SyntaxKind = SyntaxKind::TerminalAt;
26110 type TokenType = TokenAt;
26111 fn new_green(
26112 db: &dyn SyntaxGroup,
26113 leading_trivia: TriviaGreen,
26114 token: <<TerminalAt as Terminal>::TokenType as TypedSyntaxNode>::Green,
26115 trailing_trivia: TriviaGreen,
26116 ) -> Self::Green {
26117 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26118 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26119 TerminalAtGreen(
26120 Arc::new(GreenNode {
26121 kind: SyntaxKind::TerminalAt,
26122 details: GreenNodeDetails::Node { children, width },
26123 })
26124 .intern(db),
26125 )
26126 }
26127 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26128 self.token(db).text(db)
26129 }
26130}
26131impl TerminalAt {
26132 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26133 Trivia::from_syntax_node(db, self.children[0].clone())
26134 }
26135 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenAt {
26136 TokenAt::from_syntax_node(db, self.children[1].clone())
26137 }
26138 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26139 Trivia::from_syntax_node(db, self.children[2].clone())
26140 }
26141}
26142#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26143pub struct TerminalAtPtr(pub SyntaxStablePtrId);
26144impl TerminalAtPtr {}
26145impl TypedStablePtr for TerminalAtPtr {
26146 type SyntaxNode = TerminalAt;
26147 fn untyped(&self) -> SyntaxStablePtrId {
26148 self.0
26149 }
26150 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalAt {
26151 TerminalAt::from_syntax_node(db, self.0.lookup(db))
26152 }
26153}
26154impl From<TerminalAtPtr> for SyntaxStablePtrId {
26155 fn from(ptr: TerminalAtPtr) -> Self {
26156 ptr.untyped()
26157 }
26158}
26159#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26160pub struct TerminalAtGreen(pub GreenId);
26161impl TypedSyntaxNode for TerminalAt {
26162 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalAt);
26163 type StablePtr = TerminalAtPtr;
26164 type Green = TerminalAtGreen;
26165 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26166 TerminalAtGreen(
26167 Arc::new(GreenNode {
26168 kind: SyntaxKind::TerminalAt,
26169 details: GreenNodeDetails::Node {
26170 children: vec![
26171 Trivia::missing(db).0,
26172 TokenAt::missing(db).0,
26173 Trivia::missing(db).0,
26174 ],
26175 width: TextWidth::default(),
26176 },
26177 })
26178 .intern(db),
26179 )
26180 }
26181 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26182 let kind = node.kind(db);
26183 assert_eq!(
26184 kind,
26185 SyntaxKind::TerminalAt,
26186 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26187 kind,
26188 SyntaxKind::TerminalAt
26189 );
26190 let children = db.get_children(node.clone());
26191 Self { node, children }
26192 }
26193 fn as_syntax_node(&self) -> SyntaxNode {
26194 self.node.clone()
26195 }
26196 fn stable_ptr(&self) -> Self::StablePtr {
26197 TerminalAtPtr(self.node.0.stable_ptr)
26198 }
26199}
26200impl From<&TerminalAt> for SyntaxStablePtrId {
26201 fn from(node: &TerminalAt) -> Self {
26202 node.stable_ptr().untyped()
26203 }
26204}
26205#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26206pub struct TokenBadCharacters {
26207 node: SyntaxNode,
26208}
26209impl Token for TokenBadCharacters {
26210 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26211 TokenBadCharactersGreen(
26212 Arc::new(GreenNode {
26213 kind: SyntaxKind::TokenBadCharacters,
26214 details: GreenNodeDetails::Token(text),
26215 })
26216 .intern(db),
26217 )
26218 }
26219 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26220 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26221 .clone()
26222 }
26223}
26224#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26225pub struct TokenBadCharactersPtr(pub SyntaxStablePtrId);
26226impl TypedStablePtr for TokenBadCharactersPtr {
26227 type SyntaxNode = TokenBadCharacters;
26228 fn untyped(&self) -> SyntaxStablePtrId {
26229 self.0
26230 }
26231 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBadCharacters {
26232 TokenBadCharacters::from_syntax_node(db, self.0.lookup(db))
26233 }
26234}
26235impl From<TokenBadCharactersPtr> for SyntaxStablePtrId {
26236 fn from(ptr: TokenBadCharactersPtr) -> Self {
26237 ptr.untyped()
26238 }
26239}
26240#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26241pub struct TokenBadCharactersGreen(pub GreenId);
26242impl TokenBadCharactersGreen {
26243 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26244 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26245 }
26246}
26247impl TypedSyntaxNode for TokenBadCharacters {
26248 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBadCharacters);
26249 type StablePtr = TokenBadCharactersPtr;
26250 type Green = TokenBadCharactersGreen;
26251 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26252 TokenBadCharactersGreen(
26253 Arc::new(GreenNode {
26254 kind: SyntaxKind::TokenMissing,
26255 details: GreenNodeDetails::Token("".into()),
26256 })
26257 .intern(db),
26258 )
26259 }
26260 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26261 match node.0.green.lookup_intern(db).details {
26262 GreenNodeDetails::Token(_) => Self { node },
26263 GreenNodeDetails::Node { .. } => panic!(
26264 "Expected a token {:?}, not an internal node",
26265 SyntaxKind::TokenBadCharacters
26266 ),
26267 }
26268 }
26269 fn as_syntax_node(&self) -> SyntaxNode {
26270 self.node.clone()
26271 }
26272 fn stable_ptr(&self) -> Self::StablePtr {
26273 TokenBadCharactersPtr(self.node.0.stable_ptr)
26274 }
26275}
26276impl From<&TokenBadCharacters> for SyntaxStablePtrId {
26277 fn from(node: &TokenBadCharacters) -> Self {
26278 node.stable_ptr().untyped()
26279 }
26280}
26281#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26282pub struct TerminalBadCharacters {
26283 node: SyntaxNode,
26284 children: Arc<[SyntaxNode]>,
26285}
26286impl Terminal for TerminalBadCharacters {
26287 const KIND: SyntaxKind = SyntaxKind::TerminalBadCharacters;
26288 type TokenType = TokenBadCharacters;
26289 fn new_green(
26290 db: &dyn SyntaxGroup,
26291 leading_trivia: TriviaGreen,
26292 token: <<TerminalBadCharacters as Terminal>::TokenType as TypedSyntaxNode>::Green,
26293 trailing_trivia: TriviaGreen,
26294 ) -> Self::Green {
26295 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26296 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26297 TerminalBadCharactersGreen(
26298 Arc::new(GreenNode {
26299 kind: SyntaxKind::TerminalBadCharacters,
26300 details: GreenNodeDetails::Node { children, width },
26301 })
26302 .intern(db),
26303 )
26304 }
26305 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26306 self.token(db).text(db)
26307 }
26308}
26309impl TerminalBadCharacters {
26310 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26311 Trivia::from_syntax_node(db, self.children[0].clone())
26312 }
26313 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBadCharacters {
26314 TokenBadCharacters::from_syntax_node(db, self.children[1].clone())
26315 }
26316 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26317 Trivia::from_syntax_node(db, self.children[2].clone())
26318 }
26319}
26320#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26321pub struct TerminalBadCharactersPtr(pub SyntaxStablePtrId);
26322impl TerminalBadCharactersPtr {}
26323impl TypedStablePtr for TerminalBadCharactersPtr {
26324 type SyntaxNode = TerminalBadCharacters;
26325 fn untyped(&self) -> SyntaxStablePtrId {
26326 self.0
26327 }
26328 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBadCharacters {
26329 TerminalBadCharacters::from_syntax_node(db, self.0.lookup(db))
26330 }
26331}
26332impl From<TerminalBadCharactersPtr> for SyntaxStablePtrId {
26333 fn from(ptr: TerminalBadCharactersPtr) -> Self {
26334 ptr.untyped()
26335 }
26336}
26337#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26338pub struct TerminalBadCharactersGreen(pub GreenId);
26339impl TypedSyntaxNode for TerminalBadCharacters {
26340 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBadCharacters);
26341 type StablePtr = TerminalBadCharactersPtr;
26342 type Green = TerminalBadCharactersGreen;
26343 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26344 TerminalBadCharactersGreen(
26345 Arc::new(GreenNode {
26346 kind: SyntaxKind::TerminalBadCharacters,
26347 details: GreenNodeDetails::Node {
26348 children: vec![
26349 Trivia::missing(db).0,
26350 TokenBadCharacters::missing(db).0,
26351 Trivia::missing(db).0,
26352 ],
26353 width: TextWidth::default(),
26354 },
26355 })
26356 .intern(db),
26357 )
26358 }
26359 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26360 let kind = node.kind(db);
26361 assert_eq!(
26362 kind,
26363 SyntaxKind::TerminalBadCharacters,
26364 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26365 kind,
26366 SyntaxKind::TerminalBadCharacters
26367 );
26368 let children = db.get_children(node.clone());
26369 Self { node, children }
26370 }
26371 fn as_syntax_node(&self) -> SyntaxNode {
26372 self.node.clone()
26373 }
26374 fn stable_ptr(&self) -> Self::StablePtr {
26375 TerminalBadCharactersPtr(self.node.0.stable_ptr)
26376 }
26377}
26378impl From<&TerminalBadCharacters> for SyntaxStablePtrId {
26379 fn from(node: &TerminalBadCharacters) -> Self {
26380 node.stable_ptr().untyped()
26381 }
26382}
26383#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26384pub struct TokenColon {
26385 node: SyntaxNode,
26386}
26387impl Token for TokenColon {
26388 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26389 TokenColonGreen(
26390 Arc::new(GreenNode {
26391 kind: SyntaxKind::TokenColon,
26392 details: GreenNodeDetails::Token(text),
26393 })
26394 .intern(db),
26395 )
26396 }
26397 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26398 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26399 .clone()
26400 }
26401}
26402#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26403pub struct TokenColonPtr(pub SyntaxStablePtrId);
26404impl TypedStablePtr for TokenColonPtr {
26405 type SyntaxNode = TokenColon;
26406 fn untyped(&self) -> SyntaxStablePtrId {
26407 self.0
26408 }
26409 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenColon {
26410 TokenColon::from_syntax_node(db, self.0.lookup(db))
26411 }
26412}
26413impl From<TokenColonPtr> for SyntaxStablePtrId {
26414 fn from(ptr: TokenColonPtr) -> Self {
26415 ptr.untyped()
26416 }
26417}
26418#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26419pub struct TokenColonGreen(pub GreenId);
26420impl TokenColonGreen {
26421 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26422 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26423 }
26424}
26425impl TypedSyntaxNode for TokenColon {
26426 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenColon);
26427 type StablePtr = TokenColonPtr;
26428 type Green = TokenColonGreen;
26429 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26430 TokenColonGreen(
26431 Arc::new(GreenNode {
26432 kind: SyntaxKind::TokenMissing,
26433 details: GreenNodeDetails::Token("".into()),
26434 })
26435 .intern(db),
26436 )
26437 }
26438 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26439 match node.0.green.lookup_intern(db).details {
26440 GreenNodeDetails::Token(_) => Self { node },
26441 GreenNodeDetails::Node { .. } => {
26442 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenColon)
26443 }
26444 }
26445 }
26446 fn as_syntax_node(&self) -> SyntaxNode {
26447 self.node.clone()
26448 }
26449 fn stable_ptr(&self) -> Self::StablePtr {
26450 TokenColonPtr(self.node.0.stable_ptr)
26451 }
26452}
26453impl From<&TokenColon> for SyntaxStablePtrId {
26454 fn from(node: &TokenColon) -> Self {
26455 node.stable_ptr().untyped()
26456 }
26457}
26458#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26459pub struct TerminalColon {
26460 node: SyntaxNode,
26461 children: Arc<[SyntaxNode]>,
26462}
26463impl Terminal for TerminalColon {
26464 const KIND: SyntaxKind = SyntaxKind::TerminalColon;
26465 type TokenType = TokenColon;
26466 fn new_green(
26467 db: &dyn SyntaxGroup,
26468 leading_trivia: TriviaGreen,
26469 token: <<TerminalColon as Terminal>::TokenType as TypedSyntaxNode>::Green,
26470 trailing_trivia: TriviaGreen,
26471 ) -> Self::Green {
26472 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26473 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26474 TerminalColonGreen(
26475 Arc::new(GreenNode {
26476 kind: SyntaxKind::TerminalColon,
26477 details: GreenNodeDetails::Node { children, width },
26478 })
26479 .intern(db),
26480 )
26481 }
26482 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26483 self.token(db).text(db)
26484 }
26485}
26486impl TerminalColon {
26487 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26488 Trivia::from_syntax_node(db, self.children[0].clone())
26489 }
26490 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenColon {
26491 TokenColon::from_syntax_node(db, self.children[1].clone())
26492 }
26493 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26494 Trivia::from_syntax_node(db, self.children[2].clone())
26495 }
26496}
26497#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26498pub struct TerminalColonPtr(pub SyntaxStablePtrId);
26499impl TerminalColonPtr {}
26500impl TypedStablePtr for TerminalColonPtr {
26501 type SyntaxNode = TerminalColon;
26502 fn untyped(&self) -> SyntaxStablePtrId {
26503 self.0
26504 }
26505 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalColon {
26506 TerminalColon::from_syntax_node(db, self.0.lookup(db))
26507 }
26508}
26509impl From<TerminalColonPtr> for SyntaxStablePtrId {
26510 fn from(ptr: TerminalColonPtr) -> Self {
26511 ptr.untyped()
26512 }
26513}
26514#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26515pub struct TerminalColonGreen(pub GreenId);
26516impl TypedSyntaxNode for TerminalColon {
26517 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalColon);
26518 type StablePtr = TerminalColonPtr;
26519 type Green = TerminalColonGreen;
26520 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26521 TerminalColonGreen(
26522 Arc::new(GreenNode {
26523 kind: SyntaxKind::TerminalColon,
26524 details: GreenNodeDetails::Node {
26525 children: vec![
26526 Trivia::missing(db).0,
26527 TokenColon::missing(db).0,
26528 Trivia::missing(db).0,
26529 ],
26530 width: TextWidth::default(),
26531 },
26532 })
26533 .intern(db),
26534 )
26535 }
26536 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26537 let kind = node.kind(db);
26538 assert_eq!(
26539 kind,
26540 SyntaxKind::TerminalColon,
26541 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26542 kind,
26543 SyntaxKind::TerminalColon
26544 );
26545 let children = db.get_children(node.clone());
26546 Self { node, children }
26547 }
26548 fn as_syntax_node(&self) -> SyntaxNode {
26549 self.node.clone()
26550 }
26551 fn stable_ptr(&self) -> Self::StablePtr {
26552 TerminalColonPtr(self.node.0.stable_ptr)
26553 }
26554}
26555impl From<&TerminalColon> for SyntaxStablePtrId {
26556 fn from(node: &TerminalColon) -> Self {
26557 node.stable_ptr().untyped()
26558 }
26559}
26560#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26561pub struct TokenColonColon {
26562 node: SyntaxNode,
26563}
26564impl Token for TokenColonColon {
26565 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26566 TokenColonColonGreen(
26567 Arc::new(GreenNode {
26568 kind: SyntaxKind::TokenColonColon,
26569 details: GreenNodeDetails::Token(text),
26570 })
26571 .intern(db),
26572 )
26573 }
26574 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26575 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26576 .clone()
26577 }
26578}
26579#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26580pub struct TokenColonColonPtr(pub SyntaxStablePtrId);
26581impl TypedStablePtr for TokenColonColonPtr {
26582 type SyntaxNode = TokenColonColon;
26583 fn untyped(&self) -> SyntaxStablePtrId {
26584 self.0
26585 }
26586 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenColonColon {
26587 TokenColonColon::from_syntax_node(db, self.0.lookup(db))
26588 }
26589}
26590impl From<TokenColonColonPtr> for SyntaxStablePtrId {
26591 fn from(ptr: TokenColonColonPtr) -> Self {
26592 ptr.untyped()
26593 }
26594}
26595#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26596pub struct TokenColonColonGreen(pub GreenId);
26597impl TokenColonColonGreen {
26598 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26599 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26600 }
26601}
26602impl TypedSyntaxNode for TokenColonColon {
26603 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenColonColon);
26604 type StablePtr = TokenColonColonPtr;
26605 type Green = TokenColonColonGreen;
26606 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26607 TokenColonColonGreen(
26608 Arc::new(GreenNode {
26609 kind: SyntaxKind::TokenMissing,
26610 details: GreenNodeDetails::Token("".into()),
26611 })
26612 .intern(db),
26613 )
26614 }
26615 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26616 match node.0.green.lookup_intern(db).details {
26617 GreenNodeDetails::Token(_) => Self { node },
26618 GreenNodeDetails::Node { .. } => {
26619 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenColonColon)
26620 }
26621 }
26622 }
26623 fn as_syntax_node(&self) -> SyntaxNode {
26624 self.node.clone()
26625 }
26626 fn stable_ptr(&self) -> Self::StablePtr {
26627 TokenColonColonPtr(self.node.0.stable_ptr)
26628 }
26629}
26630impl From<&TokenColonColon> for SyntaxStablePtrId {
26631 fn from(node: &TokenColonColon) -> Self {
26632 node.stable_ptr().untyped()
26633 }
26634}
26635#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26636pub struct TerminalColonColon {
26637 node: SyntaxNode,
26638 children: Arc<[SyntaxNode]>,
26639}
26640impl Terminal for TerminalColonColon {
26641 const KIND: SyntaxKind = SyntaxKind::TerminalColonColon;
26642 type TokenType = TokenColonColon;
26643 fn new_green(
26644 db: &dyn SyntaxGroup,
26645 leading_trivia: TriviaGreen,
26646 token: <<TerminalColonColon as Terminal>::TokenType as TypedSyntaxNode>::Green,
26647 trailing_trivia: TriviaGreen,
26648 ) -> Self::Green {
26649 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26650 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26651 TerminalColonColonGreen(
26652 Arc::new(GreenNode {
26653 kind: SyntaxKind::TerminalColonColon,
26654 details: GreenNodeDetails::Node { children, width },
26655 })
26656 .intern(db),
26657 )
26658 }
26659 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26660 self.token(db).text(db)
26661 }
26662}
26663impl TerminalColonColon {
26664 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26665 Trivia::from_syntax_node(db, self.children[0].clone())
26666 }
26667 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenColonColon {
26668 TokenColonColon::from_syntax_node(db, self.children[1].clone())
26669 }
26670 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26671 Trivia::from_syntax_node(db, self.children[2].clone())
26672 }
26673}
26674#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26675pub struct TerminalColonColonPtr(pub SyntaxStablePtrId);
26676impl TerminalColonColonPtr {}
26677impl TypedStablePtr for TerminalColonColonPtr {
26678 type SyntaxNode = TerminalColonColon;
26679 fn untyped(&self) -> SyntaxStablePtrId {
26680 self.0
26681 }
26682 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalColonColon {
26683 TerminalColonColon::from_syntax_node(db, self.0.lookup(db))
26684 }
26685}
26686impl From<TerminalColonColonPtr> for SyntaxStablePtrId {
26687 fn from(ptr: TerminalColonColonPtr) -> Self {
26688 ptr.untyped()
26689 }
26690}
26691#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26692pub struct TerminalColonColonGreen(pub GreenId);
26693impl TypedSyntaxNode for TerminalColonColon {
26694 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalColonColon);
26695 type StablePtr = TerminalColonColonPtr;
26696 type Green = TerminalColonColonGreen;
26697 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26698 TerminalColonColonGreen(
26699 Arc::new(GreenNode {
26700 kind: SyntaxKind::TerminalColonColon,
26701 details: GreenNodeDetails::Node {
26702 children: vec![
26703 Trivia::missing(db).0,
26704 TokenColonColon::missing(db).0,
26705 Trivia::missing(db).0,
26706 ],
26707 width: TextWidth::default(),
26708 },
26709 })
26710 .intern(db),
26711 )
26712 }
26713 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26714 let kind = node.kind(db);
26715 assert_eq!(
26716 kind,
26717 SyntaxKind::TerminalColonColon,
26718 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26719 kind,
26720 SyntaxKind::TerminalColonColon
26721 );
26722 let children = db.get_children(node.clone());
26723 Self { node, children }
26724 }
26725 fn as_syntax_node(&self) -> SyntaxNode {
26726 self.node.clone()
26727 }
26728 fn stable_ptr(&self) -> Self::StablePtr {
26729 TerminalColonColonPtr(self.node.0.stable_ptr)
26730 }
26731}
26732impl From<&TerminalColonColon> for SyntaxStablePtrId {
26733 fn from(node: &TerminalColonColon) -> Self {
26734 node.stable_ptr().untyped()
26735 }
26736}
26737#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26738pub struct TokenComma {
26739 node: SyntaxNode,
26740}
26741impl Token for TokenComma {
26742 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26743 TokenCommaGreen(
26744 Arc::new(GreenNode {
26745 kind: SyntaxKind::TokenComma,
26746 details: GreenNodeDetails::Token(text),
26747 })
26748 .intern(db),
26749 )
26750 }
26751 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26752 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26753 .clone()
26754 }
26755}
26756#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26757pub struct TokenCommaPtr(pub SyntaxStablePtrId);
26758impl TypedStablePtr for TokenCommaPtr {
26759 type SyntaxNode = TokenComma;
26760 fn untyped(&self) -> SyntaxStablePtrId {
26761 self.0
26762 }
26763 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenComma {
26764 TokenComma::from_syntax_node(db, self.0.lookup(db))
26765 }
26766}
26767impl From<TokenCommaPtr> for SyntaxStablePtrId {
26768 fn from(ptr: TokenCommaPtr) -> Self {
26769 ptr.untyped()
26770 }
26771}
26772#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26773pub struct TokenCommaGreen(pub GreenId);
26774impl TokenCommaGreen {
26775 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26776 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26777 }
26778}
26779impl TypedSyntaxNode for TokenComma {
26780 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenComma);
26781 type StablePtr = TokenCommaPtr;
26782 type Green = TokenCommaGreen;
26783 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26784 TokenCommaGreen(
26785 Arc::new(GreenNode {
26786 kind: SyntaxKind::TokenMissing,
26787 details: GreenNodeDetails::Token("".into()),
26788 })
26789 .intern(db),
26790 )
26791 }
26792 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26793 match node.0.green.lookup_intern(db).details {
26794 GreenNodeDetails::Token(_) => Self { node },
26795 GreenNodeDetails::Node { .. } => {
26796 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenComma)
26797 }
26798 }
26799 }
26800 fn as_syntax_node(&self) -> SyntaxNode {
26801 self.node.clone()
26802 }
26803 fn stable_ptr(&self) -> Self::StablePtr {
26804 TokenCommaPtr(self.node.0.stable_ptr)
26805 }
26806}
26807impl From<&TokenComma> for SyntaxStablePtrId {
26808 fn from(node: &TokenComma) -> Self {
26809 node.stable_ptr().untyped()
26810 }
26811}
26812#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26813pub struct TerminalComma {
26814 node: SyntaxNode,
26815 children: Arc<[SyntaxNode]>,
26816}
26817impl Terminal for TerminalComma {
26818 const KIND: SyntaxKind = SyntaxKind::TerminalComma;
26819 type TokenType = TokenComma;
26820 fn new_green(
26821 db: &dyn SyntaxGroup,
26822 leading_trivia: TriviaGreen,
26823 token: <<TerminalComma as Terminal>::TokenType as TypedSyntaxNode>::Green,
26824 trailing_trivia: TriviaGreen,
26825 ) -> Self::Green {
26826 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
26827 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
26828 TerminalCommaGreen(
26829 Arc::new(GreenNode {
26830 kind: SyntaxKind::TerminalComma,
26831 details: GreenNodeDetails::Node { children, width },
26832 })
26833 .intern(db),
26834 )
26835 }
26836 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26837 self.token(db).text(db)
26838 }
26839}
26840impl TerminalComma {
26841 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26842 Trivia::from_syntax_node(db, self.children[0].clone())
26843 }
26844 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenComma {
26845 TokenComma::from_syntax_node(db, self.children[1].clone())
26846 }
26847 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
26848 Trivia::from_syntax_node(db, self.children[2].clone())
26849 }
26850}
26851#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26852pub struct TerminalCommaPtr(pub SyntaxStablePtrId);
26853impl TerminalCommaPtr {}
26854impl TypedStablePtr for TerminalCommaPtr {
26855 type SyntaxNode = TerminalComma;
26856 fn untyped(&self) -> SyntaxStablePtrId {
26857 self.0
26858 }
26859 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalComma {
26860 TerminalComma::from_syntax_node(db, self.0.lookup(db))
26861 }
26862}
26863impl From<TerminalCommaPtr> for SyntaxStablePtrId {
26864 fn from(ptr: TerminalCommaPtr) -> Self {
26865 ptr.untyped()
26866 }
26867}
26868#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26869pub struct TerminalCommaGreen(pub GreenId);
26870impl TypedSyntaxNode for TerminalComma {
26871 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalComma);
26872 type StablePtr = TerminalCommaPtr;
26873 type Green = TerminalCommaGreen;
26874 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26875 TerminalCommaGreen(
26876 Arc::new(GreenNode {
26877 kind: SyntaxKind::TerminalComma,
26878 details: GreenNodeDetails::Node {
26879 children: vec![
26880 Trivia::missing(db).0,
26881 TokenComma::missing(db).0,
26882 Trivia::missing(db).0,
26883 ],
26884 width: TextWidth::default(),
26885 },
26886 })
26887 .intern(db),
26888 )
26889 }
26890 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26891 let kind = node.kind(db);
26892 assert_eq!(
26893 kind,
26894 SyntaxKind::TerminalComma,
26895 "Unexpected SyntaxKind {:?}. Expected {:?}.",
26896 kind,
26897 SyntaxKind::TerminalComma
26898 );
26899 let children = db.get_children(node.clone());
26900 Self { node, children }
26901 }
26902 fn as_syntax_node(&self) -> SyntaxNode {
26903 self.node.clone()
26904 }
26905 fn stable_ptr(&self) -> Self::StablePtr {
26906 TerminalCommaPtr(self.node.0.stable_ptr)
26907 }
26908}
26909impl From<&TerminalComma> for SyntaxStablePtrId {
26910 fn from(node: &TerminalComma) -> Self {
26911 node.stable_ptr().untyped()
26912 }
26913}
26914#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26915pub struct TokenDiv {
26916 node: SyntaxNode,
26917}
26918impl Token for TokenDiv {
26919 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
26920 TokenDivGreen(
26921 Arc::new(GreenNode {
26922 kind: SyntaxKind::TokenDiv,
26923 details: GreenNodeDetails::Token(text),
26924 })
26925 .intern(db),
26926 )
26927 }
26928 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26929 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
26930 .clone()
26931 }
26932}
26933#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26934pub struct TokenDivPtr(pub SyntaxStablePtrId);
26935impl TypedStablePtr for TokenDivPtr {
26936 type SyntaxNode = TokenDiv;
26937 fn untyped(&self) -> SyntaxStablePtrId {
26938 self.0
26939 }
26940 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDiv {
26941 TokenDiv::from_syntax_node(db, self.0.lookup(db))
26942 }
26943}
26944impl From<TokenDivPtr> for SyntaxStablePtrId {
26945 fn from(ptr: TokenDivPtr) -> Self {
26946 ptr.untyped()
26947 }
26948}
26949#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
26950pub struct TokenDivGreen(pub GreenId);
26951impl TokenDivGreen {
26952 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
26953 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
26954 }
26955}
26956impl TypedSyntaxNode for TokenDiv {
26957 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDiv);
26958 type StablePtr = TokenDivPtr;
26959 type Green = TokenDivGreen;
26960 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
26961 TokenDivGreen(
26962 Arc::new(GreenNode {
26963 kind: SyntaxKind::TokenMissing,
26964 details: GreenNodeDetails::Token("".into()),
26965 })
26966 .intern(db),
26967 )
26968 }
26969 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
26970 match node.0.green.lookup_intern(db).details {
26971 GreenNodeDetails::Token(_) => Self { node },
26972 GreenNodeDetails::Node { .. } => {
26973 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDiv)
26974 }
26975 }
26976 }
26977 fn as_syntax_node(&self) -> SyntaxNode {
26978 self.node.clone()
26979 }
26980 fn stable_ptr(&self) -> Self::StablePtr {
26981 TokenDivPtr(self.node.0.stable_ptr)
26982 }
26983}
26984impl From<&TokenDiv> for SyntaxStablePtrId {
26985 fn from(node: &TokenDiv) -> Self {
26986 node.stable_ptr().untyped()
26987 }
26988}
26989#[derive(Clone, Debug, Eq, Hash, PartialEq)]
26990pub struct TerminalDiv {
26991 node: SyntaxNode,
26992 children: Arc<[SyntaxNode]>,
26993}
26994impl Terminal for TerminalDiv {
26995 const KIND: SyntaxKind = SyntaxKind::TerminalDiv;
26996 type TokenType = TokenDiv;
26997 fn new_green(
26998 db: &dyn SyntaxGroup,
26999 leading_trivia: TriviaGreen,
27000 token: <<TerminalDiv as Terminal>::TokenType as TypedSyntaxNode>::Green,
27001 trailing_trivia: TriviaGreen,
27002 ) -> Self::Green {
27003 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27004 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27005 TerminalDivGreen(
27006 Arc::new(GreenNode {
27007 kind: SyntaxKind::TerminalDiv,
27008 details: GreenNodeDetails::Node { children, width },
27009 })
27010 .intern(db),
27011 )
27012 }
27013 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27014 self.token(db).text(db)
27015 }
27016}
27017impl TerminalDiv {
27018 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27019 Trivia::from_syntax_node(db, self.children[0].clone())
27020 }
27021 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDiv {
27022 TokenDiv::from_syntax_node(db, self.children[1].clone())
27023 }
27024 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27025 Trivia::from_syntax_node(db, self.children[2].clone())
27026 }
27027}
27028#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27029pub struct TerminalDivPtr(pub SyntaxStablePtrId);
27030impl TerminalDivPtr {}
27031impl TypedStablePtr for TerminalDivPtr {
27032 type SyntaxNode = TerminalDiv;
27033 fn untyped(&self) -> SyntaxStablePtrId {
27034 self.0
27035 }
27036 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDiv {
27037 TerminalDiv::from_syntax_node(db, self.0.lookup(db))
27038 }
27039}
27040impl From<TerminalDivPtr> for SyntaxStablePtrId {
27041 fn from(ptr: TerminalDivPtr) -> Self {
27042 ptr.untyped()
27043 }
27044}
27045#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27046pub struct TerminalDivGreen(pub GreenId);
27047impl TypedSyntaxNode for TerminalDiv {
27048 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDiv);
27049 type StablePtr = TerminalDivPtr;
27050 type Green = TerminalDivGreen;
27051 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27052 TerminalDivGreen(
27053 Arc::new(GreenNode {
27054 kind: SyntaxKind::TerminalDiv,
27055 details: GreenNodeDetails::Node {
27056 children: vec![
27057 Trivia::missing(db).0,
27058 TokenDiv::missing(db).0,
27059 Trivia::missing(db).0,
27060 ],
27061 width: TextWidth::default(),
27062 },
27063 })
27064 .intern(db),
27065 )
27066 }
27067 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27068 let kind = node.kind(db);
27069 assert_eq!(
27070 kind,
27071 SyntaxKind::TerminalDiv,
27072 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27073 kind,
27074 SyntaxKind::TerminalDiv
27075 );
27076 let children = db.get_children(node.clone());
27077 Self { node, children }
27078 }
27079 fn as_syntax_node(&self) -> SyntaxNode {
27080 self.node.clone()
27081 }
27082 fn stable_ptr(&self) -> Self::StablePtr {
27083 TerminalDivPtr(self.node.0.stable_ptr)
27084 }
27085}
27086impl From<&TerminalDiv> for SyntaxStablePtrId {
27087 fn from(node: &TerminalDiv) -> Self {
27088 node.stable_ptr().untyped()
27089 }
27090}
27091#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27092pub struct TokenDivEq {
27093 node: SyntaxNode,
27094}
27095impl Token for TokenDivEq {
27096 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27097 TokenDivEqGreen(
27098 Arc::new(GreenNode {
27099 kind: SyntaxKind::TokenDivEq,
27100 details: GreenNodeDetails::Token(text),
27101 })
27102 .intern(db),
27103 )
27104 }
27105 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27106 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27107 .clone()
27108 }
27109}
27110#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27111pub struct TokenDivEqPtr(pub SyntaxStablePtrId);
27112impl TypedStablePtr for TokenDivEqPtr {
27113 type SyntaxNode = TokenDivEq;
27114 fn untyped(&self) -> SyntaxStablePtrId {
27115 self.0
27116 }
27117 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDivEq {
27118 TokenDivEq::from_syntax_node(db, self.0.lookup(db))
27119 }
27120}
27121impl From<TokenDivEqPtr> for SyntaxStablePtrId {
27122 fn from(ptr: TokenDivEqPtr) -> Self {
27123 ptr.untyped()
27124 }
27125}
27126#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27127pub struct TokenDivEqGreen(pub GreenId);
27128impl TokenDivEqGreen {
27129 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27130 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27131 }
27132}
27133impl TypedSyntaxNode for TokenDivEq {
27134 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDivEq);
27135 type StablePtr = TokenDivEqPtr;
27136 type Green = TokenDivEqGreen;
27137 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27138 TokenDivEqGreen(
27139 Arc::new(GreenNode {
27140 kind: SyntaxKind::TokenMissing,
27141 details: GreenNodeDetails::Token("".into()),
27142 })
27143 .intern(db),
27144 )
27145 }
27146 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27147 match node.0.green.lookup_intern(db).details {
27148 GreenNodeDetails::Token(_) => Self { node },
27149 GreenNodeDetails::Node { .. } => {
27150 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDivEq)
27151 }
27152 }
27153 }
27154 fn as_syntax_node(&self) -> SyntaxNode {
27155 self.node.clone()
27156 }
27157 fn stable_ptr(&self) -> Self::StablePtr {
27158 TokenDivEqPtr(self.node.0.stable_ptr)
27159 }
27160}
27161impl From<&TokenDivEq> for SyntaxStablePtrId {
27162 fn from(node: &TokenDivEq) -> Self {
27163 node.stable_ptr().untyped()
27164 }
27165}
27166#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27167pub struct TerminalDivEq {
27168 node: SyntaxNode,
27169 children: Arc<[SyntaxNode]>,
27170}
27171impl Terminal for TerminalDivEq {
27172 const KIND: SyntaxKind = SyntaxKind::TerminalDivEq;
27173 type TokenType = TokenDivEq;
27174 fn new_green(
27175 db: &dyn SyntaxGroup,
27176 leading_trivia: TriviaGreen,
27177 token: <<TerminalDivEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
27178 trailing_trivia: TriviaGreen,
27179 ) -> Self::Green {
27180 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27181 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27182 TerminalDivEqGreen(
27183 Arc::new(GreenNode {
27184 kind: SyntaxKind::TerminalDivEq,
27185 details: GreenNodeDetails::Node { children, width },
27186 })
27187 .intern(db),
27188 )
27189 }
27190 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27191 self.token(db).text(db)
27192 }
27193}
27194impl TerminalDivEq {
27195 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27196 Trivia::from_syntax_node(db, self.children[0].clone())
27197 }
27198 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDivEq {
27199 TokenDivEq::from_syntax_node(db, self.children[1].clone())
27200 }
27201 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27202 Trivia::from_syntax_node(db, self.children[2].clone())
27203 }
27204}
27205#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27206pub struct TerminalDivEqPtr(pub SyntaxStablePtrId);
27207impl TerminalDivEqPtr {}
27208impl TypedStablePtr for TerminalDivEqPtr {
27209 type SyntaxNode = TerminalDivEq;
27210 fn untyped(&self) -> SyntaxStablePtrId {
27211 self.0
27212 }
27213 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDivEq {
27214 TerminalDivEq::from_syntax_node(db, self.0.lookup(db))
27215 }
27216}
27217impl From<TerminalDivEqPtr> for SyntaxStablePtrId {
27218 fn from(ptr: TerminalDivEqPtr) -> Self {
27219 ptr.untyped()
27220 }
27221}
27222#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27223pub struct TerminalDivEqGreen(pub GreenId);
27224impl TypedSyntaxNode for TerminalDivEq {
27225 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDivEq);
27226 type StablePtr = TerminalDivEqPtr;
27227 type Green = TerminalDivEqGreen;
27228 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27229 TerminalDivEqGreen(
27230 Arc::new(GreenNode {
27231 kind: SyntaxKind::TerminalDivEq,
27232 details: GreenNodeDetails::Node {
27233 children: vec![
27234 Trivia::missing(db).0,
27235 TokenDivEq::missing(db).0,
27236 Trivia::missing(db).0,
27237 ],
27238 width: TextWidth::default(),
27239 },
27240 })
27241 .intern(db),
27242 )
27243 }
27244 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27245 let kind = node.kind(db);
27246 assert_eq!(
27247 kind,
27248 SyntaxKind::TerminalDivEq,
27249 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27250 kind,
27251 SyntaxKind::TerminalDivEq
27252 );
27253 let children = db.get_children(node.clone());
27254 Self { node, children }
27255 }
27256 fn as_syntax_node(&self) -> SyntaxNode {
27257 self.node.clone()
27258 }
27259 fn stable_ptr(&self) -> Self::StablePtr {
27260 TerminalDivEqPtr(self.node.0.stable_ptr)
27261 }
27262}
27263impl From<&TerminalDivEq> for SyntaxStablePtrId {
27264 fn from(node: &TerminalDivEq) -> Self {
27265 node.stable_ptr().untyped()
27266 }
27267}
27268#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27269pub struct TokenDot {
27270 node: SyntaxNode,
27271}
27272impl Token for TokenDot {
27273 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27274 TokenDotGreen(
27275 Arc::new(GreenNode {
27276 kind: SyntaxKind::TokenDot,
27277 details: GreenNodeDetails::Token(text),
27278 })
27279 .intern(db),
27280 )
27281 }
27282 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27283 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27284 .clone()
27285 }
27286}
27287#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27288pub struct TokenDotPtr(pub SyntaxStablePtrId);
27289impl TypedStablePtr for TokenDotPtr {
27290 type SyntaxNode = TokenDot;
27291 fn untyped(&self) -> SyntaxStablePtrId {
27292 self.0
27293 }
27294 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDot {
27295 TokenDot::from_syntax_node(db, self.0.lookup(db))
27296 }
27297}
27298impl From<TokenDotPtr> for SyntaxStablePtrId {
27299 fn from(ptr: TokenDotPtr) -> Self {
27300 ptr.untyped()
27301 }
27302}
27303#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27304pub struct TokenDotGreen(pub GreenId);
27305impl TokenDotGreen {
27306 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27307 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27308 }
27309}
27310impl TypedSyntaxNode for TokenDot {
27311 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDot);
27312 type StablePtr = TokenDotPtr;
27313 type Green = TokenDotGreen;
27314 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27315 TokenDotGreen(
27316 Arc::new(GreenNode {
27317 kind: SyntaxKind::TokenMissing,
27318 details: GreenNodeDetails::Token("".into()),
27319 })
27320 .intern(db),
27321 )
27322 }
27323 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27324 match node.0.green.lookup_intern(db).details {
27325 GreenNodeDetails::Token(_) => Self { node },
27326 GreenNodeDetails::Node { .. } => {
27327 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDot)
27328 }
27329 }
27330 }
27331 fn as_syntax_node(&self) -> SyntaxNode {
27332 self.node.clone()
27333 }
27334 fn stable_ptr(&self) -> Self::StablePtr {
27335 TokenDotPtr(self.node.0.stable_ptr)
27336 }
27337}
27338impl From<&TokenDot> for SyntaxStablePtrId {
27339 fn from(node: &TokenDot) -> Self {
27340 node.stable_ptr().untyped()
27341 }
27342}
27343#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27344pub struct TerminalDot {
27345 node: SyntaxNode,
27346 children: Arc<[SyntaxNode]>,
27347}
27348impl Terminal for TerminalDot {
27349 const KIND: SyntaxKind = SyntaxKind::TerminalDot;
27350 type TokenType = TokenDot;
27351 fn new_green(
27352 db: &dyn SyntaxGroup,
27353 leading_trivia: TriviaGreen,
27354 token: <<TerminalDot as Terminal>::TokenType as TypedSyntaxNode>::Green,
27355 trailing_trivia: TriviaGreen,
27356 ) -> Self::Green {
27357 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27358 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27359 TerminalDotGreen(
27360 Arc::new(GreenNode {
27361 kind: SyntaxKind::TerminalDot,
27362 details: GreenNodeDetails::Node { children, width },
27363 })
27364 .intern(db),
27365 )
27366 }
27367 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27368 self.token(db).text(db)
27369 }
27370}
27371impl TerminalDot {
27372 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27373 Trivia::from_syntax_node(db, self.children[0].clone())
27374 }
27375 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDot {
27376 TokenDot::from_syntax_node(db, self.children[1].clone())
27377 }
27378 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27379 Trivia::from_syntax_node(db, self.children[2].clone())
27380 }
27381}
27382#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27383pub struct TerminalDotPtr(pub SyntaxStablePtrId);
27384impl TerminalDotPtr {}
27385impl TypedStablePtr for TerminalDotPtr {
27386 type SyntaxNode = TerminalDot;
27387 fn untyped(&self) -> SyntaxStablePtrId {
27388 self.0
27389 }
27390 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDot {
27391 TerminalDot::from_syntax_node(db, self.0.lookup(db))
27392 }
27393}
27394impl From<TerminalDotPtr> for SyntaxStablePtrId {
27395 fn from(ptr: TerminalDotPtr) -> Self {
27396 ptr.untyped()
27397 }
27398}
27399#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27400pub struct TerminalDotGreen(pub GreenId);
27401impl TypedSyntaxNode for TerminalDot {
27402 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDot);
27403 type StablePtr = TerminalDotPtr;
27404 type Green = TerminalDotGreen;
27405 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27406 TerminalDotGreen(
27407 Arc::new(GreenNode {
27408 kind: SyntaxKind::TerminalDot,
27409 details: GreenNodeDetails::Node {
27410 children: vec![
27411 Trivia::missing(db).0,
27412 TokenDot::missing(db).0,
27413 Trivia::missing(db).0,
27414 ],
27415 width: TextWidth::default(),
27416 },
27417 })
27418 .intern(db),
27419 )
27420 }
27421 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27422 let kind = node.kind(db);
27423 assert_eq!(
27424 kind,
27425 SyntaxKind::TerminalDot,
27426 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27427 kind,
27428 SyntaxKind::TerminalDot
27429 );
27430 let children = db.get_children(node.clone());
27431 Self { node, children }
27432 }
27433 fn as_syntax_node(&self) -> SyntaxNode {
27434 self.node.clone()
27435 }
27436 fn stable_ptr(&self) -> Self::StablePtr {
27437 TerminalDotPtr(self.node.0.stable_ptr)
27438 }
27439}
27440impl From<&TerminalDot> for SyntaxStablePtrId {
27441 fn from(node: &TerminalDot) -> Self {
27442 node.stable_ptr().untyped()
27443 }
27444}
27445#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27446pub struct TokenDotDot {
27447 node: SyntaxNode,
27448}
27449impl Token for TokenDotDot {
27450 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27451 TokenDotDotGreen(
27452 Arc::new(GreenNode {
27453 kind: SyntaxKind::TokenDotDot,
27454 details: GreenNodeDetails::Token(text),
27455 })
27456 .intern(db),
27457 )
27458 }
27459 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27460 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27461 .clone()
27462 }
27463}
27464#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27465pub struct TokenDotDotPtr(pub SyntaxStablePtrId);
27466impl TypedStablePtr for TokenDotDotPtr {
27467 type SyntaxNode = TokenDotDot;
27468 fn untyped(&self) -> SyntaxStablePtrId {
27469 self.0
27470 }
27471 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenDotDot {
27472 TokenDotDot::from_syntax_node(db, self.0.lookup(db))
27473 }
27474}
27475impl From<TokenDotDotPtr> for SyntaxStablePtrId {
27476 fn from(ptr: TokenDotDotPtr) -> Self {
27477 ptr.untyped()
27478 }
27479}
27480#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27481pub struct TokenDotDotGreen(pub GreenId);
27482impl TokenDotDotGreen {
27483 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27484 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27485 }
27486}
27487impl TypedSyntaxNode for TokenDotDot {
27488 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenDotDot);
27489 type StablePtr = TokenDotDotPtr;
27490 type Green = TokenDotDotGreen;
27491 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27492 TokenDotDotGreen(
27493 Arc::new(GreenNode {
27494 kind: SyntaxKind::TokenMissing,
27495 details: GreenNodeDetails::Token("".into()),
27496 })
27497 .intern(db),
27498 )
27499 }
27500 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27501 match node.0.green.lookup_intern(db).details {
27502 GreenNodeDetails::Token(_) => Self { node },
27503 GreenNodeDetails::Node { .. } => {
27504 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenDotDot)
27505 }
27506 }
27507 }
27508 fn as_syntax_node(&self) -> SyntaxNode {
27509 self.node.clone()
27510 }
27511 fn stable_ptr(&self) -> Self::StablePtr {
27512 TokenDotDotPtr(self.node.0.stable_ptr)
27513 }
27514}
27515impl From<&TokenDotDot> for SyntaxStablePtrId {
27516 fn from(node: &TokenDotDot) -> Self {
27517 node.stable_ptr().untyped()
27518 }
27519}
27520#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27521pub struct TerminalDotDot {
27522 node: SyntaxNode,
27523 children: Arc<[SyntaxNode]>,
27524}
27525impl Terminal for TerminalDotDot {
27526 const KIND: SyntaxKind = SyntaxKind::TerminalDotDot;
27527 type TokenType = TokenDotDot;
27528 fn new_green(
27529 db: &dyn SyntaxGroup,
27530 leading_trivia: TriviaGreen,
27531 token: <<TerminalDotDot as Terminal>::TokenType as TypedSyntaxNode>::Green,
27532 trailing_trivia: TriviaGreen,
27533 ) -> Self::Green {
27534 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27535 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27536 TerminalDotDotGreen(
27537 Arc::new(GreenNode {
27538 kind: SyntaxKind::TerminalDotDot,
27539 details: GreenNodeDetails::Node { children, width },
27540 })
27541 .intern(db),
27542 )
27543 }
27544 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27545 self.token(db).text(db)
27546 }
27547}
27548impl TerminalDotDot {
27549 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27550 Trivia::from_syntax_node(db, self.children[0].clone())
27551 }
27552 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenDotDot {
27553 TokenDotDot::from_syntax_node(db, self.children[1].clone())
27554 }
27555 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27556 Trivia::from_syntax_node(db, self.children[2].clone())
27557 }
27558}
27559#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27560pub struct TerminalDotDotPtr(pub SyntaxStablePtrId);
27561impl TerminalDotDotPtr {}
27562impl TypedStablePtr for TerminalDotDotPtr {
27563 type SyntaxNode = TerminalDotDot;
27564 fn untyped(&self) -> SyntaxStablePtrId {
27565 self.0
27566 }
27567 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalDotDot {
27568 TerminalDotDot::from_syntax_node(db, self.0.lookup(db))
27569 }
27570}
27571impl From<TerminalDotDotPtr> for SyntaxStablePtrId {
27572 fn from(ptr: TerminalDotDotPtr) -> Self {
27573 ptr.untyped()
27574 }
27575}
27576#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27577pub struct TerminalDotDotGreen(pub GreenId);
27578impl TypedSyntaxNode for TerminalDotDot {
27579 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalDotDot);
27580 type StablePtr = TerminalDotDotPtr;
27581 type Green = TerminalDotDotGreen;
27582 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27583 TerminalDotDotGreen(
27584 Arc::new(GreenNode {
27585 kind: SyntaxKind::TerminalDotDot,
27586 details: GreenNodeDetails::Node {
27587 children: vec![
27588 Trivia::missing(db).0,
27589 TokenDotDot::missing(db).0,
27590 Trivia::missing(db).0,
27591 ],
27592 width: TextWidth::default(),
27593 },
27594 })
27595 .intern(db),
27596 )
27597 }
27598 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27599 let kind = node.kind(db);
27600 assert_eq!(
27601 kind,
27602 SyntaxKind::TerminalDotDot,
27603 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27604 kind,
27605 SyntaxKind::TerminalDotDot
27606 );
27607 let children = db.get_children(node.clone());
27608 Self { node, children }
27609 }
27610 fn as_syntax_node(&self) -> SyntaxNode {
27611 self.node.clone()
27612 }
27613 fn stable_ptr(&self) -> Self::StablePtr {
27614 TerminalDotDotPtr(self.node.0.stable_ptr)
27615 }
27616}
27617impl From<&TerminalDotDot> for SyntaxStablePtrId {
27618 fn from(node: &TerminalDotDot) -> Self {
27619 node.stable_ptr().untyped()
27620 }
27621}
27622#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27623pub struct TokenEndOfFile {
27624 node: SyntaxNode,
27625}
27626impl Token for TokenEndOfFile {
27627 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27628 TokenEndOfFileGreen(
27629 Arc::new(GreenNode {
27630 kind: SyntaxKind::TokenEndOfFile,
27631 details: GreenNodeDetails::Token(text),
27632 })
27633 .intern(db),
27634 )
27635 }
27636 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27637 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27638 .clone()
27639 }
27640}
27641#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27642pub struct TokenEndOfFilePtr(pub SyntaxStablePtrId);
27643impl TypedStablePtr for TokenEndOfFilePtr {
27644 type SyntaxNode = TokenEndOfFile;
27645 fn untyped(&self) -> SyntaxStablePtrId {
27646 self.0
27647 }
27648 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEndOfFile {
27649 TokenEndOfFile::from_syntax_node(db, self.0.lookup(db))
27650 }
27651}
27652impl From<TokenEndOfFilePtr> for SyntaxStablePtrId {
27653 fn from(ptr: TokenEndOfFilePtr) -> Self {
27654 ptr.untyped()
27655 }
27656}
27657#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27658pub struct TokenEndOfFileGreen(pub GreenId);
27659impl TokenEndOfFileGreen {
27660 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27661 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27662 }
27663}
27664impl TypedSyntaxNode for TokenEndOfFile {
27665 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEndOfFile);
27666 type StablePtr = TokenEndOfFilePtr;
27667 type Green = TokenEndOfFileGreen;
27668 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27669 TokenEndOfFileGreen(
27670 Arc::new(GreenNode {
27671 kind: SyntaxKind::TokenMissing,
27672 details: GreenNodeDetails::Token("".into()),
27673 })
27674 .intern(db),
27675 )
27676 }
27677 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27678 match node.0.green.lookup_intern(db).details {
27679 GreenNodeDetails::Token(_) => Self { node },
27680 GreenNodeDetails::Node { .. } => {
27681 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEndOfFile)
27682 }
27683 }
27684 }
27685 fn as_syntax_node(&self) -> SyntaxNode {
27686 self.node.clone()
27687 }
27688 fn stable_ptr(&self) -> Self::StablePtr {
27689 TokenEndOfFilePtr(self.node.0.stable_ptr)
27690 }
27691}
27692impl From<&TokenEndOfFile> for SyntaxStablePtrId {
27693 fn from(node: &TokenEndOfFile) -> Self {
27694 node.stable_ptr().untyped()
27695 }
27696}
27697#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27698pub struct TerminalEndOfFile {
27699 node: SyntaxNode,
27700 children: Arc<[SyntaxNode]>,
27701}
27702impl Terminal for TerminalEndOfFile {
27703 const KIND: SyntaxKind = SyntaxKind::TerminalEndOfFile;
27704 type TokenType = TokenEndOfFile;
27705 fn new_green(
27706 db: &dyn SyntaxGroup,
27707 leading_trivia: TriviaGreen,
27708 token: <<TerminalEndOfFile as Terminal>::TokenType as TypedSyntaxNode>::Green,
27709 trailing_trivia: TriviaGreen,
27710 ) -> Self::Green {
27711 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27712 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27713 TerminalEndOfFileGreen(
27714 Arc::new(GreenNode {
27715 kind: SyntaxKind::TerminalEndOfFile,
27716 details: GreenNodeDetails::Node { children, width },
27717 })
27718 .intern(db),
27719 )
27720 }
27721 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27722 self.token(db).text(db)
27723 }
27724}
27725impl TerminalEndOfFile {
27726 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27727 Trivia::from_syntax_node(db, self.children[0].clone())
27728 }
27729 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEndOfFile {
27730 TokenEndOfFile::from_syntax_node(db, self.children[1].clone())
27731 }
27732 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27733 Trivia::from_syntax_node(db, self.children[2].clone())
27734 }
27735}
27736#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27737pub struct TerminalEndOfFilePtr(pub SyntaxStablePtrId);
27738impl TerminalEndOfFilePtr {}
27739impl TypedStablePtr for TerminalEndOfFilePtr {
27740 type SyntaxNode = TerminalEndOfFile;
27741 fn untyped(&self) -> SyntaxStablePtrId {
27742 self.0
27743 }
27744 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEndOfFile {
27745 TerminalEndOfFile::from_syntax_node(db, self.0.lookup(db))
27746 }
27747}
27748impl From<TerminalEndOfFilePtr> for SyntaxStablePtrId {
27749 fn from(ptr: TerminalEndOfFilePtr) -> Self {
27750 ptr.untyped()
27751 }
27752}
27753#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27754pub struct TerminalEndOfFileGreen(pub GreenId);
27755impl TypedSyntaxNode for TerminalEndOfFile {
27756 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEndOfFile);
27757 type StablePtr = TerminalEndOfFilePtr;
27758 type Green = TerminalEndOfFileGreen;
27759 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27760 TerminalEndOfFileGreen(
27761 Arc::new(GreenNode {
27762 kind: SyntaxKind::TerminalEndOfFile,
27763 details: GreenNodeDetails::Node {
27764 children: vec![
27765 Trivia::missing(db).0,
27766 TokenEndOfFile::missing(db).0,
27767 Trivia::missing(db).0,
27768 ],
27769 width: TextWidth::default(),
27770 },
27771 })
27772 .intern(db),
27773 )
27774 }
27775 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27776 let kind = node.kind(db);
27777 assert_eq!(
27778 kind,
27779 SyntaxKind::TerminalEndOfFile,
27780 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27781 kind,
27782 SyntaxKind::TerminalEndOfFile
27783 );
27784 let children = db.get_children(node.clone());
27785 Self { node, children }
27786 }
27787 fn as_syntax_node(&self) -> SyntaxNode {
27788 self.node.clone()
27789 }
27790 fn stable_ptr(&self) -> Self::StablePtr {
27791 TerminalEndOfFilePtr(self.node.0.stable_ptr)
27792 }
27793}
27794impl From<&TerminalEndOfFile> for SyntaxStablePtrId {
27795 fn from(node: &TerminalEndOfFile) -> Self {
27796 node.stable_ptr().untyped()
27797 }
27798}
27799#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27800pub struct TokenEq {
27801 node: SyntaxNode,
27802}
27803impl Token for TokenEq {
27804 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27805 TokenEqGreen(
27806 Arc::new(GreenNode {
27807 kind: SyntaxKind::TokenEq,
27808 details: GreenNodeDetails::Token(text),
27809 })
27810 .intern(db),
27811 )
27812 }
27813 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27814 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27815 .clone()
27816 }
27817}
27818#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27819pub struct TokenEqPtr(pub SyntaxStablePtrId);
27820impl TypedStablePtr for TokenEqPtr {
27821 type SyntaxNode = TokenEq;
27822 fn untyped(&self) -> SyntaxStablePtrId {
27823 self.0
27824 }
27825 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEq {
27826 TokenEq::from_syntax_node(db, self.0.lookup(db))
27827 }
27828}
27829impl From<TokenEqPtr> for SyntaxStablePtrId {
27830 fn from(ptr: TokenEqPtr) -> Self {
27831 ptr.untyped()
27832 }
27833}
27834#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27835pub struct TokenEqGreen(pub GreenId);
27836impl TokenEqGreen {
27837 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27838 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
27839 }
27840}
27841impl TypedSyntaxNode for TokenEq {
27842 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEq);
27843 type StablePtr = TokenEqPtr;
27844 type Green = TokenEqGreen;
27845 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27846 TokenEqGreen(
27847 Arc::new(GreenNode {
27848 kind: SyntaxKind::TokenMissing,
27849 details: GreenNodeDetails::Token("".into()),
27850 })
27851 .intern(db),
27852 )
27853 }
27854 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27855 match node.0.green.lookup_intern(db).details {
27856 GreenNodeDetails::Token(_) => Self { node },
27857 GreenNodeDetails::Node { .. } => {
27858 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEq)
27859 }
27860 }
27861 }
27862 fn as_syntax_node(&self) -> SyntaxNode {
27863 self.node.clone()
27864 }
27865 fn stable_ptr(&self) -> Self::StablePtr {
27866 TokenEqPtr(self.node.0.stable_ptr)
27867 }
27868}
27869impl From<&TokenEq> for SyntaxStablePtrId {
27870 fn from(node: &TokenEq) -> Self {
27871 node.stable_ptr().untyped()
27872 }
27873}
27874#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27875pub struct TerminalEq {
27876 node: SyntaxNode,
27877 children: Arc<[SyntaxNode]>,
27878}
27879impl Terminal for TerminalEq {
27880 const KIND: SyntaxKind = SyntaxKind::TerminalEq;
27881 type TokenType = TokenEq;
27882 fn new_green(
27883 db: &dyn SyntaxGroup,
27884 leading_trivia: TriviaGreen,
27885 token: <<TerminalEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
27886 trailing_trivia: TriviaGreen,
27887 ) -> Self::Green {
27888 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
27889 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
27890 TerminalEqGreen(
27891 Arc::new(GreenNode {
27892 kind: SyntaxKind::TerminalEq,
27893 details: GreenNodeDetails::Node { children, width },
27894 })
27895 .intern(db),
27896 )
27897 }
27898 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27899 self.token(db).text(db)
27900 }
27901}
27902impl TerminalEq {
27903 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27904 Trivia::from_syntax_node(db, self.children[0].clone())
27905 }
27906 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEq {
27907 TokenEq::from_syntax_node(db, self.children[1].clone())
27908 }
27909 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
27910 Trivia::from_syntax_node(db, self.children[2].clone())
27911 }
27912}
27913#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27914pub struct TerminalEqPtr(pub SyntaxStablePtrId);
27915impl TerminalEqPtr {}
27916impl TypedStablePtr for TerminalEqPtr {
27917 type SyntaxNode = TerminalEq;
27918 fn untyped(&self) -> SyntaxStablePtrId {
27919 self.0
27920 }
27921 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEq {
27922 TerminalEq::from_syntax_node(db, self.0.lookup(db))
27923 }
27924}
27925impl From<TerminalEqPtr> for SyntaxStablePtrId {
27926 fn from(ptr: TerminalEqPtr) -> Self {
27927 ptr.untyped()
27928 }
27929}
27930#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27931pub struct TerminalEqGreen(pub GreenId);
27932impl TypedSyntaxNode for TerminalEq {
27933 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEq);
27934 type StablePtr = TerminalEqPtr;
27935 type Green = TerminalEqGreen;
27936 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
27937 TerminalEqGreen(
27938 Arc::new(GreenNode {
27939 kind: SyntaxKind::TerminalEq,
27940 details: GreenNodeDetails::Node {
27941 children: vec![
27942 Trivia::missing(db).0,
27943 TokenEq::missing(db).0,
27944 Trivia::missing(db).0,
27945 ],
27946 width: TextWidth::default(),
27947 },
27948 })
27949 .intern(db),
27950 )
27951 }
27952 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
27953 let kind = node.kind(db);
27954 assert_eq!(
27955 kind,
27956 SyntaxKind::TerminalEq,
27957 "Unexpected SyntaxKind {:?}. Expected {:?}.",
27958 kind,
27959 SyntaxKind::TerminalEq
27960 );
27961 let children = db.get_children(node.clone());
27962 Self { node, children }
27963 }
27964 fn as_syntax_node(&self) -> SyntaxNode {
27965 self.node.clone()
27966 }
27967 fn stable_ptr(&self) -> Self::StablePtr {
27968 TerminalEqPtr(self.node.0.stable_ptr)
27969 }
27970}
27971impl From<&TerminalEq> for SyntaxStablePtrId {
27972 fn from(node: &TerminalEq) -> Self {
27973 node.stable_ptr().untyped()
27974 }
27975}
27976#[derive(Clone, Debug, Eq, Hash, PartialEq)]
27977pub struct TokenEqEq {
27978 node: SyntaxNode,
27979}
27980impl Token for TokenEqEq {
27981 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
27982 TokenEqEqGreen(
27983 Arc::new(GreenNode {
27984 kind: SyntaxKind::TokenEqEq,
27985 details: GreenNodeDetails::Token(text),
27986 })
27987 .intern(db),
27988 )
27989 }
27990 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
27991 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
27992 .clone()
27993 }
27994}
27995#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
27996pub struct TokenEqEqPtr(pub SyntaxStablePtrId);
27997impl TypedStablePtr for TokenEqEqPtr {
27998 type SyntaxNode = TokenEqEq;
27999 fn untyped(&self) -> SyntaxStablePtrId {
28000 self.0
28001 }
28002 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEqEq {
28003 TokenEqEq::from_syntax_node(db, self.0.lookup(db))
28004 }
28005}
28006impl From<TokenEqEqPtr> for SyntaxStablePtrId {
28007 fn from(ptr: TokenEqEqPtr) -> Self {
28008 ptr.untyped()
28009 }
28010}
28011#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28012pub struct TokenEqEqGreen(pub GreenId);
28013impl TokenEqEqGreen {
28014 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28015 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28016 }
28017}
28018impl TypedSyntaxNode for TokenEqEq {
28019 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEqEq);
28020 type StablePtr = TokenEqEqPtr;
28021 type Green = TokenEqEqGreen;
28022 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28023 TokenEqEqGreen(
28024 Arc::new(GreenNode {
28025 kind: SyntaxKind::TokenMissing,
28026 details: GreenNodeDetails::Token("".into()),
28027 })
28028 .intern(db),
28029 )
28030 }
28031 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28032 match node.0.green.lookup_intern(db).details {
28033 GreenNodeDetails::Token(_) => Self { node },
28034 GreenNodeDetails::Node { .. } => {
28035 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEqEq)
28036 }
28037 }
28038 }
28039 fn as_syntax_node(&self) -> SyntaxNode {
28040 self.node.clone()
28041 }
28042 fn stable_ptr(&self) -> Self::StablePtr {
28043 TokenEqEqPtr(self.node.0.stable_ptr)
28044 }
28045}
28046impl From<&TokenEqEq> for SyntaxStablePtrId {
28047 fn from(node: &TokenEqEq) -> Self {
28048 node.stable_ptr().untyped()
28049 }
28050}
28051#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28052pub struct TerminalEqEq {
28053 node: SyntaxNode,
28054 children: Arc<[SyntaxNode]>,
28055}
28056impl Terminal for TerminalEqEq {
28057 const KIND: SyntaxKind = SyntaxKind::TerminalEqEq;
28058 type TokenType = TokenEqEq;
28059 fn new_green(
28060 db: &dyn SyntaxGroup,
28061 leading_trivia: TriviaGreen,
28062 token: <<TerminalEqEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
28063 trailing_trivia: TriviaGreen,
28064 ) -> Self::Green {
28065 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28066 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28067 TerminalEqEqGreen(
28068 Arc::new(GreenNode {
28069 kind: SyntaxKind::TerminalEqEq,
28070 details: GreenNodeDetails::Node { children, width },
28071 })
28072 .intern(db),
28073 )
28074 }
28075 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28076 self.token(db).text(db)
28077 }
28078}
28079impl TerminalEqEq {
28080 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28081 Trivia::from_syntax_node(db, self.children[0].clone())
28082 }
28083 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEqEq {
28084 TokenEqEq::from_syntax_node(db, self.children[1].clone())
28085 }
28086 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28087 Trivia::from_syntax_node(db, self.children[2].clone())
28088 }
28089}
28090#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28091pub struct TerminalEqEqPtr(pub SyntaxStablePtrId);
28092impl TerminalEqEqPtr {}
28093impl TypedStablePtr for TerminalEqEqPtr {
28094 type SyntaxNode = TerminalEqEq;
28095 fn untyped(&self) -> SyntaxStablePtrId {
28096 self.0
28097 }
28098 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEqEq {
28099 TerminalEqEq::from_syntax_node(db, self.0.lookup(db))
28100 }
28101}
28102impl From<TerminalEqEqPtr> for SyntaxStablePtrId {
28103 fn from(ptr: TerminalEqEqPtr) -> Self {
28104 ptr.untyped()
28105 }
28106}
28107#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28108pub struct TerminalEqEqGreen(pub GreenId);
28109impl TypedSyntaxNode for TerminalEqEq {
28110 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEqEq);
28111 type StablePtr = TerminalEqEqPtr;
28112 type Green = TerminalEqEqGreen;
28113 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28114 TerminalEqEqGreen(
28115 Arc::new(GreenNode {
28116 kind: SyntaxKind::TerminalEqEq,
28117 details: GreenNodeDetails::Node {
28118 children: vec![
28119 Trivia::missing(db).0,
28120 TokenEqEq::missing(db).0,
28121 Trivia::missing(db).0,
28122 ],
28123 width: TextWidth::default(),
28124 },
28125 })
28126 .intern(db),
28127 )
28128 }
28129 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28130 let kind = node.kind(db);
28131 assert_eq!(
28132 kind,
28133 SyntaxKind::TerminalEqEq,
28134 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28135 kind,
28136 SyntaxKind::TerminalEqEq
28137 );
28138 let children = db.get_children(node.clone());
28139 Self { node, children }
28140 }
28141 fn as_syntax_node(&self) -> SyntaxNode {
28142 self.node.clone()
28143 }
28144 fn stable_ptr(&self) -> Self::StablePtr {
28145 TerminalEqEqPtr(self.node.0.stable_ptr)
28146 }
28147}
28148impl From<&TerminalEqEq> for SyntaxStablePtrId {
28149 fn from(node: &TerminalEqEq) -> Self {
28150 node.stable_ptr().untyped()
28151 }
28152}
28153#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28154pub struct TokenGE {
28155 node: SyntaxNode,
28156}
28157impl Token for TokenGE {
28158 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28159 TokenGEGreen(
28160 Arc::new(GreenNode {
28161 kind: SyntaxKind::TokenGE,
28162 details: GreenNodeDetails::Token(text),
28163 })
28164 .intern(db),
28165 )
28166 }
28167 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28168 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28169 .clone()
28170 }
28171}
28172#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28173pub struct TokenGEPtr(pub SyntaxStablePtrId);
28174impl TypedStablePtr for TokenGEPtr {
28175 type SyntaxNode = TokenGE;
28176 fn untyped(&self) -> SyntaxStablePtrId {
28177 self.0
28178 }
28179 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenGE {
28180 TokenGE::from_syntax_node(db, self.0.lookup(db))
28181 }
28182}
28183impl From<TokenGEPtr> for SyntaxStablePtrId {
28184 fn from(ptr: TokenGEPtr) -> Self {
28185 ptr.untyped()
28186 }
28187}
28188#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28189pub struct TokenGEGreen(pub GreenId);
28190impl TokenGEGreen {
28191 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28192 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28193 }
28194}
28195impl TypedSyntaxNode for TokenGE {
28196 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenGE);
28197 type StablePtr = TokenGEPtr;
28198 type Green = TokenGEGreen;
28199 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28200 TokenGEGreen(
28201 Arc::new(GreenNode {
28202 kind: SyntaxKind::TokenMissing,
28203 details: GreenNodeDetails::Token("".into()),
28204 })
28205 .intern(db),
28206 )
28207 }
28208 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28209 match node.0.green.lookup_intern(db).details {
28210 GreenNodeDetails::Token(_) => Self { node },
28211 GreenNodeDetails::Node { .. } => {
28212 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenGE)
28213 }
28214 }
28215 }
28216 fn as_syntax_node(&self) -> SyntaxNode {
28217 self.node.clone()
28218 }
28219 fn stable_ptr(&self) -> Self::StablePtr {
28220 TokenGEPtr(self.node.0.stable_ptr)
28221 }
28222}
28223impl From<&TokenGE> for SyntaxStablePtrId {
28224 fn from(node: &TokenGE) -> Self {
28225 node.stable_ptr().untyped()
28226 }
28227}
28228#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28229pub struct TerminalGE {
28230 node: SyntaxNode,
28231 children: Arc<[SyntaxNode]>,
28232}
28233impl Terminal for TerminalGE {
28234 const KIND: SyntaxKind = SyntaxKind::TerminalGE;
28235 type TokenType = TokenGE;
28236 fn new_green(
28237 db: &dyn SyntaxGroup,
28238 leading_trivia: TriviaGreen,
28239 token: <<TerminalGE as Terminal>::TokenType as TypedSyntaxNode>::Green,
28240 trailing_trivia: TriviaGreen,
28241 ) -> Self::Green {
28242 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28243 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28244 TerminalGEGreen(
28245 Arc::new(GreenNode {
28246 kind: SyntaxKind::TerminalGE,
28247 details: GreenNodeDetails::Node { children, width },
28248 })
28249 .intern(db),
28250 )
28251 }
28252 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28253 self.token(db).text(db)
28254 }
28255}
28256impl TerminalGE {
28257 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28258 Trivia::from_syntax_node(db, self.children[0].clone())
28259 }
28260 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenGE {
28261 TokenGE::from_syntax_node(db, self.children[1].clone())
28262 }
28263 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28264 Trivia::from_syntax_node(db, self.children[2].clone())
28265 }
28266}
28267#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28268pub struct TerminalGEPtr(pub SyntaxStablePtrId);
28269impl TerminalGEPtr {}
28270impl TypedStablePtr for TerminalGEPtr {
28271 type SyntaxNode = TerminalGE;
28272 fn untyped(&self) -> SyntaxStablePtrId {
28273 self.0
28274 }
28275 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalGE {
28276 TerminalGE::from_syntax_node(db, self.0.lookup(db))
28277 }
28278}
28279impl From<TerminalGEPtr> for SyntaxStablePtrId {
28280 fn from(ptr: TerminalGEPtr) -> Self {
28281 ptr.untyped()
28282 }
28283}
28284#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28285pub struct TerminalGEGreen(pub GreenId);
28286impl TypedSyntaxNode for TerminalGE {
28287 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalGE);
28288 type StablePtr = TerminalGEPtr;
28289 type Green = TerminalGEGreen;
28290 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28291 TerminalGEGreen(
28292 Arc::new(GreenNode {
28293 kind: SyntaxKind::TerminalGE,
28294 details: GreenNodeDetails::Node {
28295 children: vec![
28296 Trivia::missing(db).0,
28297 TokenGE::missing(db).0,
28298 Trivia::missing(db).0,
28299 ],
28300 width: TextWidth::default(),
28301 },
28302 })
28303 .intern(db),
28304 )
28305 }
28306 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28307 let kind = node.kind(db);
28308 assert_eq!(
28309 kind,
28310 SyntaxKind::TerminalGE,
28311 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28312 kind,
28313 SyntaxKind::TerminalGE
28314 );
28315 let children = db.get_children(node.clone());
28316 Self { node, children }
28317 }
28318 fn as_syntax_node(&self) -> SyntaxNode {
28319 self.node.clone()
28320 }
28321 fn stable_ptr(&self) -> Self::StablePtr {
28322 TerminalGEPtr(self.node.0.stable_ptr)
28323 }
28324}
28325impl From<&TerminalGE> for SyntaxStablePtrId {
28326 fn from(node: &TerminalGE) -> Self {
28327 node.stable_ptr().untyped()
28328 }
28329}
28330#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28331pub struct TokenGT {
28332 node: SyntaxNode,
28333}
28334impl Token for TokenGT {
28335 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28336 TokenGTGreen(
28337 Arc::new(GreenNode {
28338 kind: SyntaxKind::TokenGT,
28339 details: GreenNodeDetails::Token(text),
28340 })
28341 .intern(db),
28342 )
28343 }
28344 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28345 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28346 .clone()
28347 }
28348}
28349#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28350pub struct TokenGTPtr(pub SyntaxStablePtrId);
28351impl TypedStablePtr for TokenGTPtr {
28352 type SyntaxNode = TokenGT;
28353 fn untyped(&self) -> SyntaxStablePtrId {
28354 self.0
28355 }
28356 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenGT {
28357 TokenGT::from_syntax_node(db, self.0.lookup(db))
28358 }
28359}
28360impl From<TokenGTPtr> for SyntaxStablePtrId {
28361 fn from(ptr: TokenGTPtr) -> Self {
28362 ptr.untyped()
28363 }
28364}
28365#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28366pub struct TokenGTGreen(pub GreenId);
28367impl TokenGTGreen {
28368 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28369 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28370 }
28371}
28372impl TypedSyntaxNode for TokenGT {
28373 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenGT);
28374 type StablePtr = TokenGTPtr;
28375 type Green = TokenGTGreen;
28376 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28377 TokenGTGreen(
28378 Arc::new(GreenNode {
28379 kind: SyntaxKind::TokenMissing,
28380 details: GreenNodeDetails::Token("".into()),
28381 })
28382 .intern(db),
28383 )
28384 }
28385 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28386 match node.0.green.lookup_intern(db).details {
28387 GreenNodeDetails::Token(_) => Self { node },
28388 GreenNodeDetails::Node { .. } => {
28389 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenGT)
28390 }
28391 }
28392 }
28393 fn as_syntax_node(&self) -> SyntaxNode {
28394 self.node.clone()
28395 }
28396 fn stable_ptr(&self) -> Self::StablePtr {
28397 TokenGTPtr(self.node.0.stable_ptr)
28398 }
28399}
28400impl From<&TokenGT> for SyntaxStablePtrId {
28401 fn from(node: &TokenGT) -> Self {
28402 node.stable_ptr().untyped()
28403 }
28404}
28405#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28406pub struct TerminalGT {
28407 node: SyntaxNode,
28408 children: Arc<[SyntaxNode]>,
28409}
28410impl Terminal for TerminalGT {
28411 const KIND: SyntaxKind = SyntaxKind::TerminalGT;
28412 type TokenType = TokenGT;
28413 fn new_green(
28414 db: &dyn SyntaxGroup,
28415 leading_trivia: TriviaGreen,
28416 token: <<TerminalGT as Terminal>::TokenType as TypedSyntaxNode>::Green,
28417 trailing_trivia: TriviaGreen,
28418 ) -> Self::Green {
28419 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28420 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28421 TerminalGTGreen(
28422 Arc::new(GreenNode {
28423 kind: SyntaxKind::TerminalGT,
28424 details: GreenNodeDetails::Node { children, width },
28425 })
28426 .intern(db),
28427 )
28428 }
28429 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28430 self.token(db).text(db)
28431 }
28432}
28433impl TerminalGT {
28434 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28435 Trivia::from_syntax_node(db, self.children[0].clone())
28436 }
28437 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenGT {
28438 TokenGT::from_syntax_node(db, self.children[1].clone())
28439 }
28440 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28441 Trivia::from_syntax_node(db, self.children[2].clone())
28442 }
28443}
28444#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28445pub struct TerminalGTPtr(pub SyntaxStablePtrId);
28446impl TerminalGTPtr {}
28447impl TypedStablePtr for TerminalGTPtr {
28448 type SyntaxNode = TerminalGT;
28449 fn untyped(&self) -> SyntaxStablePtrId {
28450 self.0
28451 }
28452 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalGT {
28453 TerminalGT::from_syntax_node(db, self.0.lookup(db))
28454 }
28455}
28456impl From<TerminalGTPtr> for SyntaxStablePtrId {
28457 fn from(ptr: TerminalGTPtr) -> Self {
28458 ptr.untyped()
28459 }
28460}
28461#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28462pub struct TerminalGTGreen(pub GreenId);
28463impl TypedSyntaxNode for TerminalGT {
28464 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalGT);
28465 type StablePtr = TerminalGTPtr;
28466 type Green = TerminalGTGreen;
28467 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28468 TerminalGTGreen(
28469 Arc::new(GreenNode {
28470 kind: SyntaxKind::TerminalGT,
28471 details: GreenNodeDetails::Node {
28472 children: vec![
28473 Trivia::missing(db).0,
28474 TokenGT::missing(db).0,
28475 Trivia::missing(db).0,
28476 ],
28477 width: TextWidth::default(),
28478 },
28479 })
28480 .intern(db),
28481 )
28482 }
28483 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28484 let kind = node.kind(db);
28485 assert_eq!(
28486 kind,
28487 SyntaxKind::TerminalGT,
28488 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28489 kind,
28490 SyntaxKind::TerminalGT
28491 );
28492 let children = db.get_children(node.clone());
28493 Self { node, children }
28494 }
28495 fn as_syntax_node(&self) -> SyntaxNode {
28496 self.node.clone()
28497 }
28498 fn stable_ptr(&self) -> Self::StablePtr {
28499 TerminalGTPtr(self.node.0.stable_ptr)
28500 }
28501}
28502impl From<&TerminalGT> for SyntaxStablePtrId {
28503 fn from(node: &TerminalGT) -> Self {
28504 node.stable_ptr().untyped()
28505 }
28506}
28507#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28508pub struct TokenHash {
28509 node: SyntaxNode,
28510}
28511impl Token for TokenHash {
28512 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28513 TokenHashGreen(
28514 Arc::new(GreenNode {
28515 kind: SyntaxKind::TokenHash,
28516 details: GreenNodeDetails::Token(text),
28517 })
28518 .intern(db),
28519 )
28520 }
28521 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28522 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28523 .clone()
28524 }
28525}
28526#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28527pub struct TokenHashPtr(pub SyntaxStablePtrId);
28528impl TypedStablePtr for TokenHashPtr {
28529 type SyntaxNode = TokenHash;
28530 fn untyped(&self) -> SyntaxStablePtrId {
28531 self.0
28532 }
28533 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenHash {
28534 TokenHash::from_syntax_node(db, self.0.lookup(db))
28535 }
28536}
28537impl From<TokenHashPtr> for SyntaxStablePtrId {
28538 fn from(ptr: TokenHashPtr) -> Self {
28539 ptr.untyped()
28540 }
28541}
28542#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28543pub struct TokenHashGreen(pub GreenId);
28544impl TokenHashGreen {
28545 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28546 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28547 }
28548}
28549impl TypedSyntaxNode for TokenHash {
28550 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenHash);
28551 type StablePtr = TokenHashPtr;
28552 type Green = TokenHashGreen;
28553 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28554 TokenHashGreen(
28555 Arc::new(GreenNode {
28556 kind: SyntaxKind::TokenMissing,
28557 details: GreenNodeDetails::Token("".into()),
28558 })
28559 .intern(db),
28560 )
28561 }
28562 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28563 match node.0.green.lookup_intern(db).details {
28564 GreenNodeDetails::Token(_) => Self { node },
28565 GreenNodeDetails::Node { .. } => {
28566 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenHash)
28567 }
28568 }
28569 }
28570 fn as_syntax_node(&self) -> SyntaxNode {
28571 self.node.clone()
28572 }
28573 fn stable_ptr(&self) -> Self::StablePtr {
28574 TokenHashPtr(self.node.0.stable_ptr)
28575 }
28576}
28577impl From<&TokenHash> for SyntaxStablePtrId {
28578 fn from(node: &TokenHash) -> Self {
28579 node.stable_ptr().untyped()
28580 }
28581}
28582#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28583pub struct TerminalHash {
28584 node: SyntaxNode,
28585 children: Arc<[SyntaxNode]>,
28586}
28587impl Terminal for TerminalHash {
28588 const KIND: SyntaxKind = SyntaxKind::TerminalHash;
28589 type TokenType = TokenHash;
28590 fn new_green(
28591 db: &dyn SyntaxGroup,
28592 leading_trivia: TriviaGreen,
28593 token: <<TerminalHash as Terminal>::TokenType as TypedSyntaxNode>::Green,
28594 trailing_trivia: TriviaGreen,
28595 ) -> Self::Green {
28596 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28597 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28598 TerminalHashGreen(
28599 Arc::new(GreenNode {
28600 kind: SyntaxKind::TerminalHash,
28601 details: GreenNodeDetails::Node { children, width },
28602 })
28603 .intern(db),
28604 )
28605 }
28606 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28607 self.token(db).text(db)
28608 }
28609}
28610impl TerminalHash {
28611 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28612 Trivia::from_syntax_node(db, self.children[0].clone())
28613 }
28614 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenHash {
28615 TokenHash::from_syntax_node(db, self.children[1].clone())
28616 }
28617 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28618 Trivia::from_syntax_node(db, self.children[2].clone())
28619 }
28620}
28621#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28622pub struct TerminalHashPtr(pub SyntaxStablePtrId);
28623impl TerminalHashPtr {}
28624impl TypedStablePtr for TerminalHashPtr {
28625 type SyntaxNode = TerminalHash;
28626 fn untyped(&self) -> SyntaxStablePtrId {
28627 self.0
28628 }
28629 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalHash {
28630 TerminalHash::from_syntax_node(db, self.0.lookup(db))
28631 }
28632}
28633impl From<TerminalHashPtr> for SyntaxStablePtrId {
28634 fn from(ptr: TerminalHashPtr) -> Self {
28635 ptr.untyped()
28636 }
28637}
28638#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28639pub struct TerminalHashGreen(pub GreenId);
28640impl TypedSyntaxNode for TerminalHash {
28641 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalHash);
28642 type StablePtr = TerminalHashPtr;
28643 type Green = TerminalHashGreen;
28644 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28645 TerminalHashGreen(
28646 Arc::new(GreenNode {
28647 kind: SyntaxKind::TerminalHash,
28648 details: GreenNodeDetails::Node {
28649 children: vec![
28650 Trivia::missing(db).0,
28651 TokenHash::missing(db).0,
28652 Trivia::missing(db).0,
28653 ],
28654 width: TextWidth::default(),
28655 },
28656 })
28657 .intern(db),
28658 )
28659 }
28660 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28661 let kind = node.kind(db);
28662 assert_eq!(
28663 kind,
28664 SyntaxKind::TerminalHash,
28665 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28666 kind,
28667 SyntaxKind::TerminalHash
28668 );
28669 let children = db.get_children(node.clone());
28670 Self { node, children }
28671 }
28672 fn as_syntax_node(&self) -> SyntaxNode {
28673 self.node.clone()
28674 }
28675 fn stable_ptr(&self) -> Self::StablePtr {
28676 TerminalHashPtr(self.node.0.stable_ptr)
28677 }
28678}
28679impl From<&TerminalHash> for SyntaxStablePtrId {
28680 fn from(node: &TerminalHash) -> Self {
28681 node.stable_ptr().untyped()
28682 }
28683}
28684#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28685pub struct TokenLBrace {
28686 node: SyntaxNode,
28687}
28688impl Token for TokenLBrace {
28689 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28690 TokenLBraceGreen(
28691 Arc::new(GreenNode {
28692 kind: SyntaxKind::TokenLBrace,
28693 details: GreenNodeDetails::Token(text),
28694 })
28695 .intern(db),
28696 )
28697 }
28698 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28699 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28700 .clone()
28701 }
28702}
28703#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28704pub struct TokenLBracePtr(pub SyntaxStablePtrId);
28705impl TypedStablePtr for TokenLBracePtr {
28706 type SyntaxNode = TokenLBrace;
28707 fn untyped(&self) -> SyntaxStablePtrId {
28708 self.0
28709 }
28710 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLBrace {
28711 TokenLBrace::from_syntax_node(db, self.0.lookup(db))
28712 }
28713}
28714impl From<TokenLBracePtr> for SyntaxStablePtrId {
28715 fn from(ptr: TokenLBracePtr) -> Self {
28716 ptr.untyped()
28717 }
28718}
28719#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28720pub struct TokenLBraceGreen(pub GreenId);
28721impl TokenLBraceGreen {
28722 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28723 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28724 }
28725}
28726impl TypedSyntaxNode for TokenLBrace {
28727 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLBrace);
28728 type StablePtr = TokenLBracePtr;
28729 type Green = TokenLBraceGreen;
28730 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28731 TokenLBraceGreen(
28732 Arc::new(GreenNode {
28733 kind: SyntaxKind::TokenMissing,
28734 details: GreenNodeDetails::Token("".into()),
28735 })
28736 .intern(db),
28737 )
28738 }
28739 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28740 match node.0.green.lookup_intern(db).details {
28741 GreenNodeDetails::Token(_) => Self { node },
28742 GreenNodeDetails::Node { .. } => {
28743 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLBrace)
28744 }
28745 }
28746 }
28747 fn as_syntax_node(&self) -> SyntaxNode {
28748 self.node.clone()
28749 }
28750 fn stable_ptr(&self) -> Self::StablePtr {
28751 TokenLBracePtr(self.node.0.stable_ptr)
28752 }
28753}
28754impl From<&TokenLBrace> for SyntaxStablePtrId {
28755 fn from(node: &TokenLBrace) -> Self {
28756 node.stable_ptr().untyped()
28757 }
28758}
28759#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28760pub struct TerminalLBrace {
28761 node: SyntaxNode,
28762 children: Arc<[SyntaxNode]>,
28763}
28764impl Terminal for TerminalLBrace {
28765 const KIND: SyntaxKind = SyntaxKind::TerminalLBrace;
28766 type TokenType = TokenLBrace;
28767 fn new_green(
28768 db: &dyn SyntaxGroup,
28769 leading_trivia: TriviaGreen,
28770 token: <<TerminalLBrace as Terminal>::TokenType as TypedSyntaxNode>::Green,
28771 trailing_trivia: TriviaGreen,
28772 ) -> Self::Green {
28773 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28774 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28775 TerminalLBraceGreen(
28776 Arc::new(GreenNode {
28777 kind: SyntaxKind::TerminalLBrace,
28778 details: GreenNodeDetails::Node { children, width },
28779 })
28780 .intern(db),
28781 )
28782 }
28783 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28784 self.token(db).text(db)
28785 }
28786}
28787impl TerminalLBrace {
28788 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28789 Trivia::from_syntax_node(db, self.children[0].clone())
28790 }
28791 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLBrace {
28792 TokenLBrace::from_syntax_node(db, self.children[1].clone())
28793 }
28794 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28795 Trivia::from_syntax_node(db, self.children[2].clone())
28796 }
28797}
28798#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28799pub struct TerminalLBracePtr(pub SyntaxStablePtrId);
28800impl TerminalLBracePtr {}
28801impl TypedStablePtr for TerminalLBracePtr {
28802 type SyntaxNode = TerminalLBrace;
28803 fn untyped(&self) -> SyntaxStablePtrId {
28804 self.0
28805 }
28806 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLBrace {
28807 TerminalLBrace::from_syntax_node(db, self.0.lookup(db))
28808 }
28809}
28810impl From<TerminalLBracePtr> for SyntaxStablePtrId {
28811 fn from(ptr: TerminalLBracePtr) -> Self {
28812 ptr.untyped()
28813 }
28814}
28815#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28816pub struct TerminalLBraceGreen(pub GreenId);
28817impl TypedSyntaxNode for TerminalLBrace {
28818 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLBrace);
28819 type StablePtr = TerminalLBracePtr;
28820 type Green = TerminalLBraceGreen;
28821 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28822 TerminalLBraceGreen(
28823 Arc::new(GreenNode {
28824 kind: SyntaxKind::TerminalLBrace,
28825 details: GreenNodeDetails::Node {
28826 children: vec![
28827 Trivia::missing(db).0,
28828 TokenLBrace::missing(db).0,
28829 Trivia::missing(db).0,
28830 ],
28831 width: TextWidth::default(),
28832 },
28833 })
28834 .intern(db),
28835 )
28836 }
28837 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28838 let kind = node.kind(db);
28839 assert_eq!(
28840 kind,
28841 SyntaxKind::TerminalLBrace,
28842 "Unexpected SyntaxKind {:?}. Expected {:?}.",
28843 kind,
28844 SyntaxKind::TerminalLBrace
28845 );
28846 let children = db.get_children(node.clone());
28847 Self { node, children }
28848 }
28849 fn as_syntax_node(&self) -> SyntaxNode {
28850 self.node.clone()
28851 }
28852 fn stable_ptr(&self) -> Self::StablePtr {
28853 TerminalLBracePtr(self.node.0.stable_ptr)
28854 }
28855}
28856impl From<&TerminalLBrace> for SyntaxStablePtrId {
28857 fn from(node: &TerminalLBrace) -> Self {
28858 node.stable_ptr().untyped()
28859 }
28860}
28861#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28862pub struct TokenLBrack {
28863 node: SyntaxNode,
28864}
28865impl Token for TokenLBrack {
28866 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
28867 TokenLBrackGreen(
28868 Arc::new(GreenNode {
28869 kind: SyntaxKind::TokenLBrack,
28870 details: GreenNodeDetails::Token(text),
28871 })
28872 .intern(db),
28873 )
28874 }
28875 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28876 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
28877 .clone()
28878 }
28879}
28880#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28881pub struct TokenLBrackPtr(pub SyntaxStablePtrId);
28882impl TypedStablePtr for TokenLBrackPtr {
28883 type SyntaxNode = TokenLBrack;
28884 fn untyped(&self) -> SyntaxStablePtrId {
28885 self.0
28886 }
28887 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLBrack {
28888 TokenLBrack::from_syntax_node(db, self.0.lookup(db))
28889 }
28890}
28891impl From<TokenLBrackPtr> for SyntaxStablePtrId {
28892 fn from(ptr: TokenLBrackPtr) -> Self {
28893 ptr.untyped()
28894 }
28895}
28896#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28897pub struct TokenLBrackGreen(pub GreenId);
28898impl TokenLBrackGreen {
28899 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28900 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
28901 }
28902}
28903impl TypedSyntaxNode for TokenLBrack {
28904 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLBrack);
28905 type StablePtr = TokenLBrackPtr;
28906 type Green = TokenLBrackGreen;
28907 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28908 TokenLBrackGreen(
28909 Arc::new(GreenNode {
28910 kind: SyntaxKind::TokenMissing,
28911 details: GreenNodeDetails::Token("".into()),
28912 })
28913 .intern(db),
28914 )
28915 }
28916 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
28917 match node.0.green.lookup_intern(db).details {
28918 GreenNodeDetails::Token(_) => Self { node },
28919 GreenNodeDetails::Node { .. } => {
28920 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLBrack)
28921 }
28922 }
28923 }
28924 fn as_syntax_node(&self) -> SyntaxNode {
28925 self.node.clone()
28926 }
28927 fn stable_ptr(&self) -> Self::StablePtr {
28928 TokenLBrackPtr(self.node.0.stable_ptr)
28929 }
28930}
28931impl From<&TokenLBrack> for SyntaxStablePtrId {
28932 fn from(node: &TokenLBrack) -> Self {
28933 node.stable_ptr().untyped()
28934 }
28935}
28936#[derive(Clone, Debug, Eq, Hash, PartialEq)]
28937pub struct TerminalLBrack {
28938 node: SyntaxNode,
28939 children: Arc<[SyntaxNode]>,
28940}
28941impl Terminal for TerminalLBrack {
28942 const KIND: SyntaxKind = SyntaxKind::TerminalLBrack;
28943 type TokenType = TokenLBrack;
28944 fn new_green(
28945 db: &dyn SyntaxGroup,
28946 leading_trivia: TriviaGreen,
28947 token: <<TerminalLBrack as Terminal>::TokenType as TypedSyntaxNode>::Green,
28948 trailing_trivia: TriviaGreen,
28949 ) -> Self::Green {
28950 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
28951 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
28952 TerminalLBrackGreen(
28953 Arc::new(GreenNode {
28954 kind: SyntaxKind::TerminalLBrack,
28955 details: GreenNodeDetails::Node { children, width },
28956 })
28957 .intern(db),
28958 )
28959 }
28960 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
28961 self.token(db).text(db)
28962 }
28963}
28964impl TerminalLBrack {
28965 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28966 Trivia::from_syntax_node(db, self.children[0].clone())
28967 }
28968 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLBrack {
28969 TokenLBrack::from_syntax_node(db, self.children[1].clone())
28970 }
28971 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
28972 Trivia::from_syntax_node(db, self.children[2].clone())
28973 }
28974}
28975#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28976pub struct TerminalLBrackPtr(pub SyntaxStablePtrId);
28977impl TerminalLBrackPtr {}
28978impl TypedStablePtr for TerminalLBrackPtr {
28979 type SyntaxNode = TerminalLBrack;
28980 fn untyped(&self) -> SyntaxStablePtrId {
28981 self.0
28982 }
28983 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLBrack {
28984 TerminalLBrack::from_syntax_node(db, self.0.lookup(db))
28985 }
28986}
28987impl From<TerminalLBrackPtr> for SyntaxStablePtrId {
28988 fn from(ptr: TerminalLBrackPtr) -> Self {
28989 ptr.untyped()
28990 }
28991}
28992#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
28993pub struct TerminalLBrackGreen(pub GreenId);
28994impl TypedSyntaxNode for TerminalLBrack {
28995 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLBrack);
28996 type StablePtr = TerminalLBrackPtr;
28997 type Green = TerminalLBrackGreen;
28998 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
28999 TerminalLBrackGreen(
29000 Arc::new(GreenNode {
29001 kind: SyntaxKind::TerminalLBrack,
29002 details: GreenNodeDetails::Node {
29003 children: vec![
29004 Trivia::missing(db).0,
29005 TokenLBrack::missing(db).0,
29006 Trivia::missing(db).0,
29007 ],
29008 width: TextWidth::default(),
29009 },
29010 })
29011 .intern(db),
29012 )
29013 }
29014 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29015 let kind = node.kind(db);
29016 assert_eq!(
29017 kind,
29018 SyntaxKind::TerminalLBrack,
29019 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29020 kind,
29021 SyntaxKind::TerminalLBrack
29022 );
29023 let children = db.get_children(node.clone());
29024 Self { node, children }
29025 }
29026 fn as_syntax_node(&self) -> SyntaxNode {
29027 self.node.clone()
29028 }
29029 fn stable_ptr(&self) -> Self::StablePtr {
29030 TerminalLBrackPtr(self.node.0.stable_ptr)
29031 }
29032}
29033impl From<&TerminalLBrack> for SyntaxStablePtrId {
29034 fn from(node: &TerminalLBrack) -> Self {
29035 node.stable_ptr().untyped()
29036 }
29037}
29038#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29039pub struct TokenLE {
29040 node: SyntaxNode,
29041}
29042impl Token for TokenLE {
29043 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29044 TokenLEGreen(
29045 Arc::new(GreenNode {
29046 kind: SyntaxKind::TokenLE,
29047 details: GreenNodeDetails::Token(text),
29048 })
29049 .intern(db),
29050 )
29051 }
29052 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29053 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29054 .clone()
29055 }
29056}
29057#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29058pub struct TokenLEPtr(pub SyntaxStablePtrId);
29059impl TypedStablePtr for TokenLEPtr {
29060 type SyntaxNode = TokenLE;
29061 fn untyped(&self) -> SyntaxStablePtrId {
29062 self.0
29063 }
29064 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLE {
29065 TokenLE::from_syntax_node(db, self.0.lookup(db))
29066 }
29067}
29068impl From<TokenLEPtr> for SyntaxStablePtrId {
29069 fn from(ptr: TokenLEPtr) -> Self {
29070 ptr.untyped()
29071 }
29072}
29073#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29074pub struct TokenLEGreen(pub GreenId);
29075impl TokenLEGreen {
29076 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29077 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29078 }
29079}
29080impl TypedSyntaxNode for TokenLE {
29081 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLE);
29082 type StablePtr = TokenLEPtr;
29083 type Green = TokenLEGreen;
29084 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29085 TokenLEGreen(
29086 Arc::new(GreenNode {
29087 kind: SyntaxKind::TokenMissing,
29088 details: GreenNodeDetails::Token("".into()),
29089 })
29090 .intern(db),
29091 )
29092 }
29093 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29094 match node.0.green.lookup_intern(db).details {
29095 GreenNodeDetails::Token(_) => Self { node },
29096 GreenNodeDetails::Node { .. } => {
29097 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLE)
29098 }
29099 }
29100 }
29101 fn as_syntax_node(&self) -> SyntaxNode {
29102 self.node.clone()
29103 }
29104 fn stable_ptr(&self) -> Self::StablePtr {
29105 TokenLEPtr(self.node.0.stable_ptr)
29106 }
29107}
29108impl From<&TokenLE> for SyntaxStablePtrId {
29109 fn from(node: &TokenLE) -> Self {
29110 node.stable_ptr().untyped()
29111 }
29112}
29113#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29114pub struct TerminalLE {
29115 node: SyntaxNode,
29116 children: Arc<[SyntaxNode]>,
29117}
29118impl Terminal for TerminalLE {
29119 const KIND: SyntaxKind = SyntaxKind::TerminalLE;
29120 type TokenType = TokenLE;
29121 fn new_green(
29122 db: &dyn SyntaxGroup,
29123 leading_trivia: TriviaGreen,
29124 token: <<TerminalLE as Terminal>::TokenType as TypedSyntaxNode>::Green,
29125 trailing_trivia: TriviaGreen,
29126 ) -> Self::Green {
29127 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29128 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29129 TerminalLEGreen(
29130 Arc::new(GreenNode {
29131 kind: SyntaxKind::TerminalLE,
29132 details: GreenNodeDetails::Node { children, width },
29133 })
29134 .intern(db),
29135 )
29136 }
29137 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29138 self.token(db).text(db)
29139 }
29140}
29141impl TerminalLE {
29142 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29143 Trivia::from_syntax_node(db, self.children[0].clone())
29144 }
29145 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLE {
29146 TokenLE::from_syntax_node(db, self.children[1].clone())
29147 }
29148 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29149 Trivia::from_syntax_node(db, self.children[2].clone())
29150 }
29151}
29152#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29153pub struct TerminalLEPtr(pub SyntaxStablePtrId);
29154impl TerminalLEPtr {}
29155impl TypedStablePtr for TerminalLEPtr {
29156 type SyntaxNode = TerminalLE;
29157 fn untyped(&self) -> SyntaxStablePtrId {
29158 self.0
29159 }
29160 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLE {
29161 TerminalLE::from_syntax_node(db, self.0.lookup(db))
29162 }
29163}
29164impl From<TerminalLEPtr> for SyntaxStablePtrId {
29165 fn from(ptr: TerminalLEPtr) -> Self {
29166 ptr.untyped()
29167 }
29168}
29169#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29170pub struct TerminalLEGreen(pub GreenId);
29171impl TypedSyntaxNode for TerminalLE {
29172 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLE);
29173 type StablePtr = TerminalLEPtr;
29174 type Green = TerminalLEGreen;
29175 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29176 TerminalLEGreen(
29177 Arc::new(GreenNode {
29178 kind: SyntaxKind::TerminalLE,
29179 details: GreenNodeDetails::Node {
29180 children: vec![
29181 Trivia::missing(db).0,
29182 TokenLE::missing(db).0,
29183 Trivia::missing(db).0,
29184 ],
29185 width: TextWidth::default(),
29186 },
29187 })
29188 .intern(db),
29189 )
29190 }
29191 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29192 let kind = node.kind(db);
29193 assert_eq!(
29194 kind,
29195 SyntaxKind::TerminalLE,
29196 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29197 kind,
29198 SyntaxKind::TerminalLE
29199 );
29200 let children = db.get_children(node.clone());
29201 Self { node, children }
29202 }
29203 fn as_syntax_node(&self) -> SyntaxNode {
29204 self.node.clone()
29205 }
29206 fn stable_ptr(&self) -> Self::StablePtr {
29207 TerminalLEPtr(self.node.0.stable_ptr)
29208 }
29209}
29210impl From<&TerminalLE> for SyntaxStablePtrId {
29211 fn from(node: &TerminalLE) -> Self {
29212 node.stable_ptr().untyped()
29213 }
29214}
29215#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29216pub struct TokenLParen {
29217 node: SyntaxNode,
29218}
29219impl Token for TokenLParen {
29220 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29221 TokenLParenGreen(
29222 Arc::new(GreenNode {
29223 kind: SyntaxKind::TokenLParen,
29224 details: GreenNodeDetails::Token(text),
29225 })
29226 .intern(db),
29227 )
29228 }
29229 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29230 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29231 .clone()
29232 }
29233}
29234#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29235pub struct TokenLParenPtr(pub SyntaxStablePtrId);
29236impl TypedStablePtr for TokenLParenPtr {
29237 type SyntaxNode = TokenLParen;
29238 fn untyped(&self) -> SyntaxStablePtrId {
29239 self.0
29240 }
29241 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLParen {
29242 TokenLParen::from_syntax_node(db, self.0.lookup(db))
29243 }
29244}
29245impl From<TokenLParenPtr> for SyntaxStablePtrId {
29246 fn from(ptr: TokenLParenPtr) -> Self {
29247 ptr.untyped()
29248 }
29249}
29250#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29251pub struct TokenLParenGreen(pub GreenId);
29252impl TokenLParenGreen {
29253 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29254 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29255 }
29256}
29257impl TypedSyntaxNode for TokenLParen {
29258 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLParen);
29259 type StablePtr = TokenLParenPtr;
29260 type Green = TokenLParenGreen;
29261 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29262 TokenLParenGreen(
29263 Arc::new(GreenNode {
29264 kind: SyntaxKind::TokenMissing,
29265 details: GreenNodeDetails::Token("".into()),
29266 })
29267 .intern(db),
29268 )
29269 }
29270 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29271 match node.0.green.lookup_intern(db).details {
29272 GreenNodeDetails::Token(_) => Self { node },
29273 GreenNodeDetails::Node { .. } => {
29274 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLParen)
29275 }
29276 }
29277 }
29278 fn as_syntax_node(&self) -> SyntaxNode {
29279 self.node.clone()
29280 }
29281 fn stable_ptr(&self) -> Self::StablePtr {
29282 TokenLParenPtr(self.node.0.stable_ptr)
29283 }
29284}
29285impl From<&TokenLParen> for SyntaxStablePtrId {
29286 fn from(node: &TokenLParen) -> Self {
29287 node.stable_ptr().untyped()
29288 }
29289}
29290#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29291pub struct TerminalLParen {
29292 node: SyntaxNode,
29293 children: Arc<[SyntaxNode]>,
29294}
29295impl Terminal for TerminalLParen {
29296 const KIND: SyntaxKind = SyntaxKind::TerminalLParen;
29297 type TokenType = TokenLParen;
29298 fn new_green(
29299 db: &dyn SyntaxGroup,
29300 leading_trivia: TriviaGreen,
29301 token: <<TerminalLParen 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 TerminalLParenGreen(
29307 Arc::new(GreenNode {
29308 kind: SyntaxKind::TerminalLParen,
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 TerminalLParen {
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) -> TokenLParen {
29323 TokenLParen::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 TerminalLParenPtr(pub SyntaxStablePtrId);
29331impl TerminalLParenPtr {}
29332impl TypedStablePtr for TerminalLParenPtr {
29333 type SyntaxNode = TerminalLParen;
29334 fn untyped(&self) -> SyntaxStablePtrId {
29335 self.0
29336 }
29337 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLParen {
29338 TerminalLParen::from_syntax_node(db, self.0.lookup(db))
29339 }
29340}
29341impl From<TerminalLParenPtr> for SyntaxStablePtrId {
29342 fn from(ptr: TerminalLParenPtr) -> Self {
29343 ptr.untyped()
29344 }
29345}
29346#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29347pub struct TerminalLParenGreen(pub GreenId);
29348impl TypedSyntaxNode for TerminalLParen {
29349 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLParen);
29350 type StablePtr = TerminalLParenPtr;
29351 type Green = TerminalLParenGreen;
29352 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29353 TerminalLParenGreen(
29354 Arc::new(GreenNode {
29355 kind: SyntaxKind::TerminalLParen,
29356 details: GreenNodeDetails::Node {
29357 children: vec![
29358 Trivia::missing(db).0,
29359 TokenLParen::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::TerminalLParen,
29373 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29374 kind,
29375 SyntaxKind::TerminalLParen
29376 );
29377 let children = db.get_children(node.clone());
29378 Self { node, children }
29379 }
29380 fn as_syntax_node(&self) -> SyntaxNode {
29381 self.node.clone()
29382 }
29383 fn stable_ptr(&self) -> Self::StablePtr {
29384 TerminalLParenPtr(self.node.0.stable_ptr)
29385 }
29386}
29387impl From<&TerminalLParen> for SyntaxStablePtrId {
29388 fn from(node: &TerminalLParen) -> Self {
29389 node.stable_ptr().untyped()
29390 }
29391}
29392#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29393pub struct TokenLT {
29394 node: SyntaxNode,
29395}
29396impl Token for TokenLT {
29397 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29398 TokenLTGreen(
29399 Arc::new(GreenNode {
29400 kind: SyntaxKind::TokenLT,
29401 details: GreenNodeDetails::Token(text),
29402 })
29403 .intern(db),
29404 )
29405 }
29406 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29407 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29408 .clone()
29409 }
29410}
29411#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29412pub struct TokenLTPtr(pub SyntaxStablePtrId);
29413impl TypedStablePtr for TokenLTPtr {
29414 type SyntaxNode = TokenLT;
29415 fn untyped(&self) -> SyntaxStablePtrId {
29416 self.0
29417 }
29418 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenLT {
29419 TokenLT::from_syntax_node(db, self.0.lookup(db))
29420 }
29421}
29422impl From<TokenLTPtr> for SyntaxStablePtrId {
29423 fn from(ptr: TokenLTPtr) -> Self {
29424 ptr.untyped()
29425 }
29426}
29427#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29428pub struct TokenLTGreen(pub GreenId);
29429impl TokenLTGreen {
29430 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29431 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29432 }
29433}
29434impl TypedSyntaxNode for TokenLT {
29435 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenLT);
29436 type StablePtr = TokenLTPtr;
29437 type Green = TokenLTGreen;
29438 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29439 TokenLTGreen(
29440 Arc::new(GreenNode {
29441 kind: SyntaxKind::TokenMissing,
29442 details: GreenNodeDetails::Token("".into()),
29443 })
29444 .intern(db),
29445 )
29446 }
29447 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29448 match node.0.green.lookup_intern(db).details {
29449 GreenNodeDetails::Token(_) => Self { node },
29450 GreenNodeDetails::Node { .. } => {
29451 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenLT)
29452 }
29453 }
29454 }
29455 fn as_syntax_node(&self) -> SyntaxNode {
29456 self.node.clone()
29457 }
29458 fn stable_ptr(&self) -> Self::StablePtr {
29459 TokenLTPtr(self.node.0.stable_ptr)
29460 }
29461}
29462impl From<&TokenLT> for SyntaxStablePtrId {
29463 fn from(node: &TokenLT) -> Self {
29464 node.stable_ptr().untyped()
29465 }
29466}
29467#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29468pub struct TerminalLT {
29469 node: SyntaxNode,
29470 children: Arc<[SyntaxNode]>,
29471}
29472impl Terminal for TerminalLT {
29473 const KIND: SyntaxKind = SyntaxKind::TerminalLT;
29474 type TokenType = TokenLT;
29475 fn new_green(
29476 db: &dyn SyntaxGroup,
29477 leading_trivia: TriviaGreen,
29478 token: <<TerminalLT as Terminal>::TokenType as TypedSyntaxNode>::Green,
29479 trailing_trivia: TriviaGreen,
29480 ) -> Self::Green {
29481 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29482 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29483 TerminalLTGreen(
29484 Arc::new(GreenNode {
29485 kind: SyntaxKind::TerminalLT,
29486 details: GreenNodeDetails::Node { children, width },
29487 })
29488 .intern(db),
29489 )
29490 }
29491 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29492 self.token(db).text(db)
29493 }
29494}
29495impl TerminalLT {
29496 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29497 Trivia::from_syntax_node(db, self.children[0].clone())
29498 }
29499 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenLT {
29500 TokenLT::from_syntax_node(db, self.children[1].clone())
29501 }
29502 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29503 Trivia::from_syntax_node(db, self.children[2].clone())
29504 }
29505}
29506#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29507pub struct TerminalLTPtr(pub SyntaxStablePtrId);
29508impl TerminalLTPtr {}
29509impl TypedStablePtr for TerminalLTPtr {
29510 type SyntaxNode = TerminalLT;
29511 fn untyped(&self) -> SyntaxStablePtrId {
29512 self.0
29513 }
29514 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalLT {
29515 TerminalLT::from_syntax_node(db, self.0.lookup(db))
29516 }
29517}
29518impl From<TerminalLTPtr> for SyntaxStablePtrId {
29519 fn from(ptr: TerminalLTPtr) -> Self {
29520 ptr.untyped()
29521 }
29522}
29523#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29524pub struct TerminalLTGreen(pub GreenId);
29525impl TypedSyntaxNode for TerminalLT {
29526 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalLT);
29527 type StablePtr = TerminalLTPtr;
29528 type Green = TerminalLTGreen;
29529 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29530 TerminalLTGreen(
29531 Arc::new(GreenNode {
29532 kind: SyntaxKind::TerminalLT,
29533 details: GreenNodeDetails::Node {
29534 children: vec![
29535 Trivia::missing(db).0,
29536 TokenLT::missing(db).0,
29537 Trivia::missing(db).0,
29538 ],
29539 width: TextWidth::default(),
29540 },
29541 })
29542 .intern(db),
29543 )
29544 }
29545 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29546 let kind = node.kind(db);
29547 assert_eq!(
29548 kind,
29549 SyntaxKind::TerminalLT,
29550 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29551 kind,
29552 SyntaxKind::TerminalLT
29553 );
29554 let children = db.get_children(node.clone());
29555 Self { node, children }
29556 }
29557 fn as_syntax_node(&self) -> SyntaxNode {
29558 self.node.clone()
29559 }
29560 fn stable_ptr(&self) -> Self::StablePtr {
29561 TerminalLTPtr(self.node.0.stable_ptr)
29562 }
29563}
29564impl From<&TerminalLT> for SyntaxStablePtrId {
29565 fn from(node: &TerminalLT) -> Self {
29566 node.stable_ptr().untyped()
29567 }
29568}
29569#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29570pub struct TokenMatchArrow {
29571 node: SyntaxNode,
29572}
29573impl Token for TokenMatchArrow {
29574 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29575 TokenMatchArrowGreen(
29576 Arc::new(GreenNode {
29577 kind: SyntaxKind::TokenMatchArrow,
29578 details: GreenNodeDetails::Token(text),
29579 })
29580 .intern(db),
29581 )
29582 }
29583 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29584 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29585 .clone()
29586 }
29587}
29588#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29589pub struct TokenMatchArrowPtr(pub SyntaxStablePtrId);
29590impl TypedStablePtr for TokenMatchArrowPtr {
29591 type SyntaxNode = TokenMatchArrow;
29592 fn untyped(&self) -> SyntaxStablePtrId {
29593 self.0
29594 }
29595 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMatchArrow {
29596 TokenMatchArrow::from_syntax_node(db, self.0.lookup(db))
29597 }
29598}
29599impl From<TokenMatchArrowPtr> for SyntaxStablePtrId {
29600 fn from(ptr: TokenMatchArrowPtr) -> Self {
29601 ptr.untyped()
29602 }
29603}
29604#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29605pub struct TokenMatchArrowGreen(pub GreenId);
29606impl TokenMatchArrowGreen {
29607 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29608 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29609 }
29610}
29611impl TypedSyntaxNode for TokenMatchArrow {
29612 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMatchArrow);
29613 type StablePtr = TokenMatchArrowPtr;
29614 type Green = TokenMatchArrowGreen;
29615 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29616 TokenMatchArrowGreen(
29617 Arc::new(GreenNode {
29618 kind: SyntaxKind::TokenMissing,
29619 details: GreenNodeDetails::Token("".into()),
29620 })
29621 .intern(db),
29622 )
29623 }
29624 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29625 match node.0.green.lookup_intern(db).details {
29626 GreenNodeDetails::Token(_) => Self { node },
29627 GreenNodeDetails::Node { .. } => {
29628 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMatchArrow)
29629 }
29630 }
29631 }
29632 fn as_syntax_node(&self) -> SyntaxNode {
29633 self.node.clone()
29634 }
29635 fn stable_ptr(&self) -> Self::StablePtr {
29636 TokenMatchArrowPtr(self.node.0.stable_ptr)
29637 }
29638}
29639impl From<&TokenMatchArrow> for SyntaxStablePtrId {
29640 fn from(node: &TokenMatchArrow) -> Self {
29641 node.stable_ptr().untyped()
29642 }
29643}
29644#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29645pub struct TerminalMatchArrow {
29646 node: SyntaxNode,
29647 children: Arc<[SyntaxNode]>,
29648}
29649impl Terminal for TerminalMatchArrow {
29650 const KIND: SyntaxKind = SyntaxKind::TerminalMatchArrow;
29651 type TokenType = TokenMatchArrow;
29652 fn new_green(
29653 db: &dyn SyntaxGroup,
29654 leading_trivia: TriviaGreen,
29655 token: <<TerminalMatchArrow as Terminal>::TokenType as TypedSyntaxNode>::Green,
29656 trailing_trivia: TriviaGreen,
29657 ) -> Self::Green {
29658 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29659 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29660 TerminalMatchArrowGreen(
29661 Arc::new(GreenNode {
29662 kind: SyntaxKind::TerminalMatchArrow,
29663 details: GreenNodeDetails::Node { children, width },
29664 })
29665 .intern(db),
29666 )
29667 }
29668 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29669 self.token(db).text(db)
29670 }
29671}
29672impl TerminalMatchArrow {
29673 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29674 Trivia::from_syntax_node(db, self.children[0].clone())
29675 }
29676 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMatchArrow {
29677 TokenMatchArrow::from_syntax_node(db, self.children[1].clone())
29678 }
29679 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29680 Trivia::from_syntax_node(db, self.children[2].clone())
29681 }
29682}
29683#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29684pub struct TerminalMatchArrowPtr(pub SyntaxStablePtrId);
29685impl TerminalMatchArrowPtr {}
29686impl TypedStablePtr for TerminalMatchArrowPtr {
29687 type SyntaxNode = TerminalMatchArrow;
29688 fn untyped(&self) -> SyntaxStablePtrId {
29689 self.0
29690 }
29691 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMatchArrow {
29692 TerminalMatchArrow::from_syntax_node(db, self.0.lookup(db))
29693 }
29694}
29695impl From<TerminalMatchArrowPtr> for SyntaxStablePtrId {
29696 fn from(ptr: TerminalMatchArrowPtr) -> Self {
29697 ptr.untyped()
29698 }
29699}
29700#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29701pub struct TerminalMatchArrowGreen(pub GreenId);
29702impl TypedSyntaxNode for TerminalMatchArrow {
29703 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMatchArrow);
29704 type StablePtr = TerminalMatchArrowPtr;
29705 type Green = TerminalMatchArrowGreen;
29706 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29707 TerminalMatchArrowGreen(
29708 Arc::new(GreenNode {
29709 kind: SyntaxKind::TerminalMatchArrow,
29710 details: GreenNodeDetails::Node {
29711 children: vec![
29712 Trivia::missing(db).0,
29713 TokenMatchArrow::missing(db).0,
29714 Trivia::missing(db).0,
29715 ],
29716 width: TextWidth::default(),
29717 },
29718 })
29719 .intern(db),
29720 )
29721 }
29722 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29723 let kind = node.kind(db);
29724 assert_eq!(
29725 kind,
29726 SyntaxKind::TerminalMatchArrow,
29727 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29728 kind,
29729 SyntaxKind::TerminalMatchArrow
29730 );
29731 let children = db.get_children(node.clone());
29732 Self { node, children }
29733 }
29734 fn as_syntax_node(&self) -> SyntaxNode {
29735 self.node.clone()
29736 }
29737 fn stable_ptr(&self) -> Self::StablePtr {
29738 TerminalMatchArrowPtr(self.node.0.stable_ptr)
29739 }
29740}
29741impl From<&TerminalMatchArrow> for SyntaxStablePtrId {
29742 fn from(node: &TerminalMatchArrow) -> Self {
29743 node.stable_ptr().untyped()
29744 }
29745}
29746#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29747pub struct TokenMinus {
29748 node: SyntaxNode,
29749}
29750impl Token for TokenMinus {
29751 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29752 TokenMinusGreen(
29753 Arc::new(GreenNode {
29754 kind: SyntaxKind::TokenMinus,
29755 details: GreenNodeDetails::Token(text),
29756 })
29757 .intern(db),
29758 )
29759 }
29760 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29761 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29762 .clone()
29763 }
29764}
29765#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29766pub struct TokenMinusPtr(pub SyntaxStablePtrId);
29767impl TypedStablePtr for TokenMinusPtr {
29768 type SyntaxNode = TokenMinus;
29769 fn untyped(&self) -> SyntaxStablePtrId {
29770 self.0
29771 }
29772 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMinus {
29773 TokenMinus::from_syntax_node(db, self.0.lookup(db))
29774 }
29775}
29776impl From<TokenMinusPtr> for SyntaxStablePtrId {
29777 fn from(ptr: TokenMinusPtr) -> Self {
29778 ptr.untyped()
29779 }
29780}
29781#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29782pub struct TokenMinusGreen(pub GreenId);
29783impl TokenMinusGreen {
29784 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29785 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29786 }
29787}
29788impl TypedSyntaxNode for TokenMinus {
29789 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMinus);
29790 type StablePtr = TokenMinusPtr;
29791 type Green = TokenMinusGreen;
29792 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29793 TokenMinusGreen(
29794 Arc::new(GreenNode {
29795 kind: SyntaxKind::TokenMissing,
29796 details: GreenNodeDetails::Token("".into()),
29797 })
29798 .intern(db),
29799 )
29800 }
29801 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29802 match node.0.green.lookup_intern(db).details {
29803 GreenNodeDetails::Token(_) => Self { node },
29804 GreenNodeDetails::Node { .. } => {
29805 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMinus)
29806 }
29807 }
29808 }
29809 fn as_syntax_node(&self) -> SyntaxNode {
29810 self.node.clone()
29811 }
29812 fn stable_ptr(&self) -> Self::StablePtr {
29813 TokenMinusPtr(self.node.0.stable_ptr)
29814 }
29815}
29816impl From<&TokenMinus> for SyntaxStablePtrId {
29817 fn from(node: &TokenMinus) -> Self {
29818 node.stable_ptr().untyped()
29819 }
29820}
29821#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29822pub struct TerminalMinus {
29823 node: SyntaxNode,
29824 children: Arc<[SyntaxNode]>,
29825}
29826impl Terminal for TerminalMinus {
29827 const KIND: SyntaxKind = SyntaxKind::TerminalMinus;
29828 type TokenType = TokenMinus;
29829 fn new_green(
29830 db: &dyn SyntaxGroup,
29831 leading_trivia: TriviaGreen,
29832 token: <<TerminalMinus as Terminal>::TokenType as TypedSyntaxNode>::Green,
29833 trailing_trivia: TriviaGreen,
29834 ) -> Self::Green {
29835 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
29836 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
29837 TerminalMinusGreen(
29838 Arc::new(GreenNode {
29839 kind: SyntaxKind::TerminalMinus,
29840 details: GreenNodeDetails::Node { children, width },
29841 })
29842 .intern(db),
29843 )
29844 }
29845 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29846 self.token(db).text(db)
29847 }
29848}
29849impl TerminalMinus {
29850 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29851 Trivia::from_syntax_node(db, self.children[0].clone())
29852 }
29853 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMinus {
29854 TokenMinus::from_syntax_node(db, self.children[1].clone())
29855 }
29856 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
29857 Trivia::from_syntax_node(db, self.children[2].clone())
29858 }
29859}
29860#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29861pub struct TerminalMinusPtr(pub SyntaxStablePtrId);
29862impl TerminalMinusPtr {}
29863impl TypedStablePtr for TerminalMinusPtr {
29864 type SyntaxNode = TerminalMinus;
29865 fn untyped(&self) -> SyntaxStablePtrId {
29866 self.0
29867 }
29868 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMinus {
29869 TerminalMinus::from_syntax_node(db, self.0.lookup(db))
29870 }
29871}
29872impl From<TerminalMinusPtr> for SyntaxStablePtrId {
29873 fn from(ptr: TerminalMinusPtr) -> Self {
29874 ptr.untyped()
29875 }
29876}
29877#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29878pub struct TerminalMinusGreen(pub GreenId);
29879impl TypedSyntaxNode for TerminalMinus {
29880 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMinus);
29881 type StablePtr = TerminalMinusPtr;
29882 type Green = TerminalMinusGreen;
29883 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29884 TerminalMinusGreen(
29885 Arc::new(GreenNode {
29886 kind: SyntaxKind::TerminalMinus,
29887 details: GreenNodeDetails::Node {
29888 children: vec![
29889 Trivia::missing(db).0,
29890 TokenMinus::missing(db).0,
29891 Trivia::missing(db).0,
29892 ],
29893 width: TextWidth::default(),
29894 },
29895 })
29896 .intern(db),
29897 )
29898 }
29899 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29900 let kind = node.kind(db);
29901 assert_eq!(
29902 kind,
29903 SyntaxKind::TerminalMinus,
29904 "Unexpected SyntaxKind {:?}. Expected {:?}.",
29905 kind,
29906 SyntaxKind::TerminalMinus
29907 );
29908 let children = db.get_children(node.clone());
29909 Self { node, children }
29910 }
29911 fn as_syntax_node(&self) -> SyntaxNode {
29912 self.node.clone()
29913 }
29914 fn stable_ptr(&self) -> Self::StablePtr {
29915 TerminalMinusPtr(self.node.0.stable_ptr)
29916 }
29917}
29918impl From<&TerminalMinus> for SyntaxStablePtrId {
29919 fn from(node: &TerminalMinus) -> Self {
29920 node.stable_ptr().untyped()
29921 }
29922}
29923#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29924pub struct TokenMinusEq {
29925 node: SyntaxNode,
29926}
29927impl Token for TokenMinusEq {
29928 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
29929 TokenMinusEqGreen(
29930 Arc::new(GreenNode {
29931 kind: SyntaxKind::TokenMinusEq,
29932 details: GreenNodeDetails::Token(text),
29933 })
29934 .intern(db),
29935 )
29936 }
29937 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29938 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
29939 .clone()
29940 }
29941}
29942#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29943pub struct TokenMinusEqPtr(pub SyntaxStablePtrId);
29944impl TypedStablePtr for TokenMinusEqPtr {
29945 type SyntaxNode = TokenMinusEq;
29946 fn untyped(&self) -> SyntaxStablePtrId {
29947 self.0
29948 }
29949 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMinusEq {
29950 TokenMinusEq::from_syntax_node(db, self.0.lookup(db))
29951 }
29952}
29953impl From<TokenMinusEqPtr> for SyntaxStablePtrId {
29954 fn from(ptr: TokenMinusEqPtr) -> Self {
29955 ptr.untyped()
29956 }
29957}
29958#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
29959pub struct TokenMinusEqGreen(pub GreenId);
29960impl TokenMinusEqGreen {
29961 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
29962 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
29963 }
29964}
29965impl TypedSyntaxNode for TokenMinusEq {
29966 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMinusEq);
29967 type StablePtr = TokenMinusEqPtr;
29968 type Green = TokenMinusEqGreen;
29969 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
29970 TokenMinusEqGreen(
29971 Arc::new(GreenNode {
29972 kind: SyntaxKind::TokenMissing,
29973 details: GreenNodeDetails::Token("".into()),
29974 })
29975 .intern(db),
29976 )
29977 }
29978 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
29979 match node.0.green.lookup_intern(db).details {
29980 GreenNodeDetails::Token(_) => Self { node },
29981 GreenNodeDetails::Node { .. } => {
29982 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMinusEq)
29983 }
29984 }
29985 }
29986 fn as_syntax_node(&self) -> SyntaxNode {
29987 self.node.clone()
29988 }
29989 fn stable_ptr(&self) -> Self::StablePtr {
29990 TokenMinusEqPtr(self.node.0.stable_ptr)
29991 }
29992}
29993impl From<&TokenMinusEq> for SyntaxStablePtrId {
29994 fn from(node: &TokenMinusEq) -> Self {
29995 node.stable_ptr().untyped()
29996 }
29997}
29998#[derive(Clone, Debug, Eq, Hash, PartialEq)]
29999pub struct TerminalMinusEq {
30000 node: SyntaxNode,
30001 children: Arc<[SyntaxNode]>,
30002}
30003impl Terminal for TerminalMinusEq {
30004 const KIND: SyntaxKind = SyntaxKind::TerminalMinusEq;
30005 type TokenType = TokenMinusEq;
30006 fn new_green(
30007 db: &dyn SyntaxGroup,
30008 leading_trivia: TriviaGreen,
30009 token: <<TerminalMinusEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30010 trailing_trivia: TriviaGreen,
30011 ) -> Self::Green {
30012 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30013 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30014 TerminalMinusEqGreen(
30015 Arc::new(GreenNode {
30016 kind: SyntaxKind::TerminalMinusEq,
30017 details: GreenNodeDetails::Node { children, width },
30018 })
30019 .intern(db),
30020 )
30021 }
30022 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30023 self.token(db).text(db)
30024 }
30025}
30026impl TerminalMinusEq {
30027 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30028 Trivia::from_syntax_node(db, self.children[0].clone())
30029 }
30030 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMinusEq {
30031 TokenMinusEq::from_syntax_node(db, self.children[1].clone())
30032 }
30033 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30034 Trivia::from_syntax_node(db, self.children[2].clone())
30035 }
30036}
30037#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30038pub struct TerminalMinusEqPtr(pub SyntaxStablePtrId);
30039impl TerminalMinusEqPtr {}
30040impl TypedStablePtr for TerminalMinusEqPtr {
30041 type SyntaxNode = TerminalMinusEq;
30042 fn untyped(&self) -> SyntaxStablePtrId {
30043 self.0
30044 }
30045 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMinusEq {
30046 TerminalMinusEq::from_syntax_node(db, self.0.lookup(db))
30047 }
30048}
30049impl From<TerminalMinusEqPtr> for SyntaxStablePtrId {
30050 fn from(ptr: TerminalMinusEqPtr) -> Self {
30051 ptr.untyped()
30052 }
30053}
30054#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30055pub struct TerminalMinusEqGreen(pub GreenId);
30056impl TypedSyntaxNode for TerminalMinusEq {
30057 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMinusEq);
30058 type StablePtr = TerminalMinusEqPtr;
30059 type Green = TerminalMinusEqGreen;
30060 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30061 TerminalMinusEqGreen(
30062 Arc::new(GreenNode {
30063 kind: SyntaxKind::TerminalMinusEq,
30064 details: GreenNodeDetails::Node {
30065 children: vec![
30066 Trivia::missing(db).0,
30067 TokenMinusEq::missing(db).0,
30068 Trivia::missing(db).0,
30069 ],
30070 width: TextWidth::default(),
30071 },
30072 })
30073 .intern(db),
30074 )
30075 }
30076 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30077 let kind = node.kind(db);
30078 assert_eq!(
30079 kind,
30080 SyntaxKind::TerminalMinusEq,
30081 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30082 kind,
30083 SyntaxKind::TerminalMinusEq
30084 );
30085 let children = db.get_children(node.clone());
30086 Self { node, children }
30087 }
30088 fn as_syntax_node(&self) -> SyntaxNode {
30089 self.node.clone()
30090 }
30091 fn stable_ptr(&self) -> Self::StablePtr {
30092 TerminalMinusEqPtr(self.node.0.stable_ptr)
30093 }
30094}
30095impl From<&TerminalMinusEq> for SyntaxStablePtrId {
30096 fn from(node: &TerminalMinusEq) -> Self {
30097 node.stable_ptr().untyped()
30098 }
30099}
30100#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30101pub struct TokenMod {
30102 node: SyntaxNode,
30103}
30104impl Token for TokenMod {
30105 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30106 TokenModGreen(
30107 Arc::new(GreenNode {
30108 kind: SyntaxKind::TokenMod,
30109 details: GreenNodeDetails::Token(text),
30110 })
30111 .intern(db),
30112 )
30113 }
30114 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30115 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30116 .clone()
30117 }
30118}
30119#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30120pub struct TokenModPtr(pub SyntaxStablePtrId);
30121impl TypedStablePtr for TokenModPtr {
30122 type SyntaxNode = TokenMod;
30123 fn untyped(&self) -> SyntaxStablePtrId {
30124 self.0
30125 }
30126 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMod {
30127 TokenMod::from_syntax_node(db, self.0.lookup(db))
30128 }
30129}
30130impl From<TokenModPtr> for SyntaxStablePtrId {
30131 fn from(ptr: TokenModPtr) -> Self {
30132 ptr.untyped()
30133 }
30134}
30135#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30136pub struct TokenModGreen(pub GreenId);
30137impl TokenModGreen {
30138 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30139 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30140 }
30141}
30142impl TypedSyntaxNode for TokenMod {
30143 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMod);
30144 type StablePtr = TokenModPtr;
30145 type Green = TokenModGreen;
30146 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30147 TokenModGreen(
30148 Arc::new(GreenNode {
30149 kind: SyntaxKind::TokenMissing,
30150 details: GreenNodeDetails::Token("".into()),
30151 })
30152 .intern(db),
30153 )
30154 }
30155 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30156 match node.0.green.lookup_intern(db).details {
30157 GreenNodeDetails::Token(_) => Self { node },
30158 GreenNodeDetails::Node { .. } => {
30159 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMod)
30160 }
30161 }
30162 }
30163 fn as_syntax_node(&self) -> SyntaxNode {
30164 self.node.clone()
30165 }
30166 fn stable_ptr(&self) -> Self::StablePtr {
30167 TokenModPtr(self.node.0.stable_ptr)
30168 }
30169}
30170impl From<&TokenMod> for SyntaxStablePtrId {
30171 fn from(node: &TokenMod) -> Self {
30172 node.stable_ptr().untyped()
30173 }
30174}
30175#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30176pub struct TerminalMod {
30177 node: SyntaxNode,
30178 children: Arc<[SyntaxNode]>,
30179}
30180impl Terminal for TerminalMod {
30181 const KIND: SyntaxKind = SyntaxKind::TerminalMod;
30182 type TokenType = TokenMod;
30183 fn new_green(
30184 db: &dyn SyntaxGroup,
30185 leading_trivia: TriviaGreen,
30186 token: <<TerminalMod as Terminal>::TokenType as TypedSyntaxNode>::Green,
30187 trailing_trivia: TriviaGreen,
30188 ) -> Self::Green {
30189 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30190 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30191 TerminalModGreen(
30192 Arc::new(GreenNode {
30193 kind: SyntaxKind::TerminalMod,
30194 details: GreenNodeDetails::Node { children, width },
30195 })
30196 .intern(db),
30197 )
30198 }
30199 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30200 self.token(db).text(db)
30201 }
30202}
30203impl TerminalMod {
30204 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30205 Trivia::from_syntax_node(db, self.children[0].clone())
30206 }
30207 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMod {
30208 TokenMod::from_syntax_node(db, self.children[1].clone())
30209 }
30210 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30211 Trivia::from_syntax_node(db, self.children[2].clone())
30212 }
30213}
30214#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30215pub struct TerminalModPtr(pub SyntaxStablePtrId);
30216impl TerminalModPtr {}
30217impl TypedStablePtr for TerminalModPtr {
30218 type SyntaxNode = TerminalMod;
30219 fn untyped(&self) -> SyntaxStablePtrId {
30220 self.0
30221 }
30222 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMod {
30223 TerminalMod::from_syntax_node(db, self.0.lookup(db))
30224 }
30225}
30226impl From<TerminalModPtr> for SyntaxStablePtrId {
30227 fn from(ptr: TerminalModPtr) -> Self {
30228 ptr.untyped()
30229 }
30230}
30231#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30232pub struct TerminalModGreen(pub GreenId);
30233impl TypedSyntaxNode for TerminalMod {
30234 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMod);
30235 type StablePtr = TerminalModPtr;
30236 type Green = TerminalModGreen;
30237 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30238 TerminalModGreen(
30239 Arc::new(GreenNode {
30240 kind: SyntaxKind::TerminalMod,
30241 details: GreenNodeDetails::Node {
30242 children: vec![
30243 Trivia::missing(db).0,
30244 TokenMod::missing(db).0,
30245 Trivia::missing(db).0,
30246 ],
30247 width: TextWidth::default(),
30248 },
30249 })
30250 .intern(db),
30251 )
30252 }
30253 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30254 let kind = node.kind(db);
30255 assert_eq!(
30256 kind,
30257 SyntaxKind::TerminalMod,
30258 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30259 kind,
30260 SyntaxKind::TerminalMod
30261 );
30262 let children = db.get_children(node.clone());
30263 Self { node, children }
30264 }
30265 fn as_syntax_node(&self) -> SyntaxNode {
30266 self.node.clone()
30267 }
30268 fn stable_ptr(&self) -> Self::StablePtr {
30269 TerminalModPtr(self.node.0.stable_ptr)
30270 }
30271}
30272impl From<&TerminalMod> for SyntaxStablePtrId {
30273 fn from(node: &TerminalMod) -> Self {
30274 node.stable_ptr().untyped()
30275 }
30276}
30277#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30278pub struct TokenModEq {
30279 node: SyntaxNode,
30280}
30281impl Token for TokenModEq {
30282 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30283 TokenModEqGreen(
30284 Arc::new(GreenNode {
30285 kind: SyntaxKind::TokenModEq,
30286 details: GreenNodeDetails::Token(text),
30287 })
30288 .intern(db),
30289 )
30290 }
30291 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30292 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30293 .clone()
30294 }
30295}
30296#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30297pub struct TokenModEqPtr(pub SyntaxStablePtrId);
30298impl TypedStablePtr for TokenModEqPtr {
30299 type SyntaxNode = TokenModEq;
30300 fn untyped(&self) -> SyntaxStablePtrId {
30301 self.0
30302 }
30303 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenModEq {
30304 TokenModEq::from_syntax_node(db, self.0.lookup(db))
30305 }
30306}
30307impl From<TokenModEqPtr> for SyntaxStablePtrId {
30308 fn from(ptr: TokenModEqPtr) -> Self {
30309 ptr.untyped()
30310 }
30311}
30312#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30313pub struct TokenModEqGreen(pub GreenId);
30314impl TokenModEqGreen {
30315 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30316 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30317 }
30318}
30319impl TypedSyntaxNode for TokenModEq {
30320 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenModEq);
30321 type StablePtr = TokenModEqPtr;
30322 type Green = TokenModEqGreen;
30323 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30324 TokenModEqGreen(
30325 Arc::new(GreenNode {
30326 kind: SyntaxKind::TokenMissing,
30327 details: GreenNodeDetails::Token("".into()),
30328 })
30329 .intern(db),
30330 )
30331 }
30332 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30333 match node.0.green.lookup_intern(db).details {
30334 GreenNodeDetails::Token(_) => Self { node },
30335 GreenNodeDetails::Node { .. } => {
30336 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenModEq)
30337 }
30338 }
30339 }
30340 fn as_syntax_node(&self) -> SyntaxNode {
30341 self.node.clone()
30342 }
30343 fn stable_ptr(&self) -> Self::StablePtr {
30344 TokenModEqPtr(self.node.0.stable_ptr)
30345 }
30346}
30347impl From<&TokenModEq> for SyntaxStablePtrId {
30348 fn from(node: &TokenModEq) -> Self {
30349 node.stable_ptr().untyped()
30350 }
30351}
30352#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30353pub struct TerminalModEq {
30354 node: SyntaxNode,
30355 children: Arc<[SyntaxNode]>,
30356}
30357impl Terminal for TerminalModEq {
30358 const KIND: SyntaxKind = SyntaxKind::TerminalModEq;
30359 type TokenType = TokenModEq;
30360 fn new_green(
30361 db: &dyn SyntaxGroup,
30362 leading_trivia: TriviaGreen,
30363 token: <<TerminalModEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30364 trailing_trivia: TriviaGreen,
30365 ) -> Self::Green {
30366 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30367 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30368 TerminalModEqGreen(
30369 Arc::new(GreenNode {
30370 kind: SyntaxKind::TerminalModEq,
30371 details: GreenNodeDetails::Node { children, width },
30372 })
30373 .intern(db),
30374 )
30375 }
30376 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30377 self.token(db).text(db)
30378 }
30379}
30380impl TerminalModEq {
30381 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30382 Trivia::from_syntax_node(db, self.children[0].clone())
30383 }
30384 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenModEq {
30385 TokenModEq::from_syntax_node(db, self.children[1].clone())
30386 }
30387 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30388 Trivia::from_syntax_node(db, self.children[2].clone())
30389 }
30390}
30391#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30392pub struct TerminalModEqPtr(pub SyntaxStablePtrId);
30393impl TerminalModEqPtr {}
30394impl TypedStablePtr for TerminalModEqPtr {
30395 type SyntaxNode = TerminalModEq;
30396 fn untyped(&self) -> SyntaxStablePtrId {
30397 self.0
30398 }
30399 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalModEq {
30400 TerminalModEq::from_syntax_node(db, self.0.lookup(db))
30401 }
30402}
30403impl From<TerminalModEqPtr> for SyntaxStablePtrId {
30404 fn from(ptr: TerminalModEqPtr) -> Self {
30405 ptr.untyped()
30406 }
30407}
30408#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30409pub struct TerminalModEqGreen(pub GreenId);
30410impl TypedSyntaxNode for TerminalModEq {
30411 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalModEq);
30412 type StablePtr = TerminalModEqPtr;
30413 type Green = TerminalModEqGreen;
30414 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30415 TerminalModEqGreen(
30416 Arc::new(GreenNode {
30417 kind: SyntaxKind::TerminalModEq,
30418 details: GreenNodeDetails::Node {
30419 children: vec![
30420 Trivia::missing(db).0,
30421 TokenModEq::missing(db).0,
30422 Trivia::missing(db).0,
30423 ],
30424 width: TextWidth::default(),
30425 },
30426 })
30427 .intern(db),
30428 )
30429 }
30430 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30431 let kind = node.kind(db);
30432 assert_eq!(
30433 kind,
30434 SyntaxKind::TerminalModEq,
30435 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30436 kind,
30437 SyntaxKind::TerminalModEq
30438 );
30439 let children = db.get_children(node.clone());
30440 Self { node, children }
30441 }
30442 fn as_syntax_node(&self) -> SyntaxNode {
30443 self.node.clone()
30444 }
30445 fn stable_ptr(&self) -> Self::StablePtr {
30446 TerminalModEqPtr(self.node.0.stable_ptr)
30447 }
30448}
30449impl From<&TerminalModEq> for SyntaxStablePtrId {
30450 fn from(node: &TerminalModEq) -> Self {
30451 node.stable_ptr().untyped()
30452 }
30453}
30454#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30455pub struct TokenMul {
30456 node: SyntaxNode,
30457}
30458impl Token for TokenMul {
30459 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30460 TokenMulGreen(
30461 Arc::new(GreenNode {
30462 kind: SyntaxKind::TokenMul,
30463 details: GreenNodeDetails::Token(text),
30464 })
30465 .intern(db),
30466 )
30467 }
30468 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30469 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30470 .clone()
30471 }
30472}
30473#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30474pub struct TokenMulPtr(pub SyntaxStablePtrId);
30475impl TypedStablePtr for TokenMulPtr {
30476 type SyntaxNode = TokenMul;
30477 fn untyped(&self) -> SyntaxStablePtrId {
30478 self.0
30479 }
30480 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMul {
30481 TokenMul::from_syntax_node(db, self.0.lookup(db))
30482 }
30483}
30484impl From<TokenMulPtr> for SyntaxStablePtrId {
30485 fn from(ptr: TokenMulPtr) -> Self {
30486 ptr.untyped()
30487 }
30488}
30489#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30490pub struct TokenMulGreen(pub GreenId);
30491impl TokenMulGreen {
30492 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30493 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30494 }
30495}
30496impl TypedSyntaxNode for TokenMul {
30497 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMul);
30498 type StablePtr = TokenMulPtr;
30499 type Green = TokenMulGreen;
30500 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30501 TokenMulGreen(
30502 Arc::new(GreenNode {
30503 kind: SyntaxKind::TokenMissing,
30504 details: GreenNodeDetails::Token("".into()),
30505 })
30506 .intern(db),
30507 )
30508 }
30509 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30510 match node.0.green.lookup_intern(db).details {
30511 GreenNodeDetails::Token(_) => Self { node },
30512 GreenNodeDetails::Node { .. } => {
30513 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMul)
30514 }
30515 }
30516 }
30517 fn as_syntax_node(&self) -> SyntaxNode {
30518 self.node.clone()
30519 }
30520 fn stable_ptr(&self) -> Self::StablePtr {
30521 TokenMulPtr(self.node.0.stable_ptr)
30522 }
30523}
30524impl From<&TokenMul> for SyntaxStablePtrId {
30525 fn from(node: &TokenMul) -> Self {
30526 node.stable_ptr().untyped()
30527 }
30528}
30529#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30530pub struct TerminalMul {
30531 node: SyntaxNode,
30532 children: Arc<[SyntaxNode]>,
30533}
30534impl Terminal for TerminalMul {
30535 const KIND: SyntaxKind = SyntaxKind::TerminalMul;
30536 type TokenType = TokenMul;
30537 fn new_green(
30538 db: &dyn SyntaxGroup,
30539 leading_trivia: TriviaGreen,
30540 token: <<TerminalMul as Terminal>::TokenType as TypedSyntaxNode>::Green,
30541 trailing_trivia: TriviaGreen,
30542 ) -> Self::Green {
30543 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30544 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30545 TerminalMulGreen(
30546 Arc::new(GreenNode {
30547 kind: SyntaxKind::TerminalMul,
30548 details: GreenNodeDetails::Node { children, width },
30549 })
30550 .intern(db),
30551 )
30552 }
30553 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30554 self.token(db).text(db)
30555 }
30556}
30557impl TerminalMul {
30558 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30559 Trivia::from_syntax_node(db, self.children[0].clone())
30560 }
30561 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMul {
30562 TokenMul::from_syntax_node(db, self.children[1].clone())
30563 }
30564 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30565 Trivia::from_syntax_node(db, self.children[2].clone())
30566 }
30567}
30568#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30569pub struct TerminalMulPtr(pub SyntaxStablePtrId);
30570impl TerminalMulPtr {}
30571impl TypedStablePtr for TerminalMulPtr {
30572 type SyntaxNode = TerminalMul;
30573 fn untyped(&self) -> SyntaxStablePtrId {
30574 self.0
30575 }
30576 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMul {
30577 TerminalMul::from_syntax_node(db, self.0.lookup(db))
30578 }
30579}
30580impl From<TerminalMulPtr> for SyntaxStablePtrId {
30581 fn from(ptr: TerminalMulPtr) -> Self {
30582 ptr.untyped()
30583 }
30584}
30585#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30586pub struct TerminalMulGreen(pub GreenId);
30587impl TypedSyntaxNode for TerminalMul {
30588 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMul);
30589 type StablePtr = TerminalMulPtr;
30590 type Green = TerminalMulGreen;
30591 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30592 TerminalMulGreen(
30593 Arc::new(GreenNode {
30594 kind: SyntaxKind::TerminalMul,
30595 details: GreenNodeDetails::Node {
30596 children: vec![
30597 Trivia::missing(db).0,
30598 TokenMul::missing(db).0,
30599 Trivia::missing(db).0,
30600 ],
30601 width: TextWidth::default(),
30602 },
30603 })
30604 .intern(db),
30605 )
30606 }
30607 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30608 let kind = node.kind(db);
30609 assert_eq!(
30610 kind,
30611 SyntaxKind::TerminalMul,
30612 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30613 kind,
30614 SyntaxKind::TerminalMul
30615 );
30616 let children = db.get_children(node.clone());
30617 Self { node, children }
30618 }
30619 fn as_syntax_node(&self) -> SyntaxNode {
30620 self.node.clone()
30621 }
30622 fn stable_ptr(&self) -> Self::StablePtr {
30623 TerminalMulPtr(self.node.0.stable_ptr)
30624 }
30625}
30626impl From<&TerminalMul> for SyntaxStablePtrId {
30627 fn from(node: &TerminalMul) -> Self {
30628 node.stable_ptr().untyped()
30629 }
30630}
30631#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30632pub struct TokenMulEq {
30633 node: SyntaxNode,
30634}
30635impl Token for TokenMulEq {
30636 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30637 TokenMulEqGreen(
30638 Arc::new(GreenNode {
30639 kind: SyntaxKind::TokenMulEq,
30640 details: GreenNodeDetails::Token(text),
30641 })
30642 .intern(db),
30643 )
30644 }
30645 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30646 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30647 .clone()
30648 }
30649}
30650#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30651pub struct TokenMulEqPtr(pub SyntaxStablePtrId);
30652impl TypedStablePtr for TokenMulEqPtr {
30653 type SyntaxNode = TokenMulEq;
30654 fn untyped(&self) -> SyntaxStablePtrId {
30655 self.0
30656 }
30657 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMulEq {
30658 TokenMulEq::from_syntax_node(db, self.0.lookup(db))
30659 }
30660}
30661impl From<TokenMulEqPtr> for SyntaxStablePtrId {
30662 fn from(ptr: TokenMulEqPtr) -> Self {
30663 ptr.untyped()
30664 }
30665}
30666#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30667pub struct TokenMulEqGreen(pub GreenId);
30668impl TokenMulEqGreen {
30669 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30670 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30671 }
30672}
30673impl TypedSyntaxNode for TokenMulEq {
30674 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMulEq);
30675 type StablePtr = TokenMulEqPtr;
30676 type Green = TokenMulEqGreen;
30677 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30678 TokenMulEqGreen(
30679 Arc::new(GreenNode {
30680 kind: SyntaxKind::TokenMissing,
30681 details: GreenNodeDetails::Token("".into()),
30682 })
30683 .intern(db),
30684 )
30685 }
30686 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30687 match node.0.green.lookup_intern(db).details {
30688 GreenNodeDetails::Token(_) => Self { node },
30689 GreenNodeDetails::Node { .. } => {
30690 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenMulEq)
30691 }
30692 }
30693 }
30694 fn as_syntax_node(&self) -> SyntaxNode {
30695 self.node.clone()
30696 }
30697 fn stable_ptr(&self) -> Self::StablePtr {
30698 TokenMulEqPtr(self.node.0.stable_ptr)
30699 }
30700}
30701impl From<&TokenMulEq> for SyntaxStablePtrId {
30702 fn from(node: &TokenMulEq) -> Self {
30703 node.stable_ptr().untyped()
30704 }
30705}
30706#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30707pub struct TerminalMulEq {
30708 node: SyntaxNode,
30709 children: Arc<[SyntaxNode]>,
30710}
30711impl Terminal for TerminalMulEq {
30712 const KIND: SyntaxKind = SyntaxKind::TerminalMulEq;
30713 type TokenType = TokenMulEq;
30714 fn new_green(
30715 db: &dyn SyntaxGroup,
30716 leading_trivia: TriviaGreen,
30717 token: <<TerminalMulEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30718 trailing_trivia: TriviaGreen,
30719 ) -> Self::Green {
30720 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30721 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30722 TerminalMulEqGreen(
30723 Arc::new(GreenNode {
30724 kind: SyntaxKind::TerminalMulEq,
30725 details: GreenNodeDetails::Node { children, width },
30726 })
30727 .intern(db),
30728 )
30729 }
30730 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30731 self.token(db).text(db)
30732 }
30733}
30734impl TerminalMulEq {
30735 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30736 Trivia::from_syntax_node(db, self.children[0].clone())
30737 }
30738 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenMulEq {
30739 TokenMulEq::from_syntax_node(db, self.children[1].clone())
30740 }
30741 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30742 Trivia::from_syntax_node(db, self.children[2].clone())
30743 }
30744}
30745#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30746pub struct TerminalMulEqPtr(pub SyntaxStablePtrId);
30747impl TerminalMulEqPtr {}
30748impl TypedStablePtr for TerminalMulEqPtr {
30749 type SyntaxNode = TerminalMulEq;
30750 fn untyped(&self) -> SyntaxStablePtrId {
30751 self.0
30752 }
30753 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalMulEq {
30754 TerminalMulEq::from_syntax_node(db, self.0.lookup(db))
30755 }
30756}
30757impl From<TerminalMulEqPtr> for SyntaxStablePtrId {
30758 fn from(ptr: TerminalMulEqPtr) -> Self {
30759 ptr.untyped()
30760 }
30761}
30762#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30763pub struct TerminalMulEqGreen(pub GreenId);
30764impl TypedSyntaxNode for TerminalMulEq {
30765 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalMulEq);
30766 type StablePtr = TerminalMulEqPtr;
30767 type Green = TerminalMulEqGreen;
30768 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30769 TerminalMulEqGreen(
30770 Arc::new(GreenNode {
30771 kind: SyntaxKind::TerminalMulEq,
30772 details: GreenNodeDetails::Node {
30773 children: vec![
30774 Trivia::missing(db).0,
30775 TokenMulEq::missing(db).0,
30776 Trivia::missing(db).0,
30777 ],
30778 width: TextWidth::default(),
30779 },
30780 })
30781 .intern(db),
30782 )
30783 }
30784 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30785 let kind = node.kind(db);
30786 assert_eq!(
30787 kind,
30788 SyntaxKind::TerminalMulEq,
30789 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30790 kind,
30791 SyntaxKind::TerminalMulEq
30792 );
30793 let children = db.get_children(node.clone());
30794 Self { node, children }
30795 }
30796 fn as_syntax_node(&self) -> SyntaxNode {
30797 self.node.clone()
30798 }
30799 fn stable_ptr(&self) -> Self::StablePtr {
30800 TerminalMulEqPtr(self.node.0.stable_ptr)
30801 }
30802}
30803impl From<&TerminalMulEq> for SyntaxStablePtrId {
30804 fn from(node: &TerminalMulEq) -> Self {
30805 node.stable_ptr().untyped()
30806 }
30807}
30808#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30809pub struct TokenNeq {
30810 node: SyntaxNode,
30811}
30812impl Token for TokenNeq {
30813 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30814 TokenNeqGreen(
30815 Arc::new(GreenNode {
30816 kind: SyntaxKind::TokenNeq,
30817 details: GreenNodeDetails::Token(text),
30818 })
30819 .intern(db),
30820 )
30821 }
30822 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30823 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
30824 .clone()
30825 }
30826}
30827#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30828pub struct TokenNeqPtr(pub SyntaxStablePtrId);
30829impl TypedStablePtr for TokenNeqPtr {
30830 type SyntaxNode = TokenNeq;
30831 fn untyped(&self) -> SyntaxStablePtrId {
30832 self.0
30833 }
30834 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNeq {
30835 TokenNeq::from_syntax_node(db, self.0.lookup(db))
30836 }
30837}
30838impl From<TokenNeqPtr> for SyntaxStablePtrId {
30839 fn from(ptr: TokenNeqPtr) -> Self {
30840 ptr.untyped()
30841 }
30842}
30843#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30844pub struct TokenNeqGreen(pub GreenId);
30845impl TokenNeqGreen {
30846 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30847 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
30848 }
30849}
30850impl TypedSyntaxNode for TokenNeq {
30851 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNeq);
30852 type StablePtr = TokenNeqPtr;
30853 type Green = TokenNeqGreen;
30854 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30855 TokenNeqGreen(
30856 Arc::new(GreenNode {
30857 kind: SyntaxKind::TokenMissing,
30858 details: GreenNodeDetails::Token("".into()),
30859 })
30860 .intern(db),
30861 )
30862 }
30863 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30864 match node.0.green.lookup_intern(db).details {
30865 GreenNodeDetails::Token(_) => Self { node },
30866 GreenNodeDetails::Node { .. } => {
30867 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNeq)
30868 }
30869 }
30870 }
30871 fn as_syntax_node(&self) -> SyntaxNode {
30872 self.node.clone()
30873 }
30874 fn stable_ptr(&self) -> Self::StablePtr {
30875 TokenNeqPtr(self.node.0.stable_ptr)
30876 }
30877}
30878impl From<&TokenNeq> for SyntaxStablePtrId {
30879 fn from(node: &TokenNeq) -> Self {
30880 node.stable_ptr().untyped()
30881 }
30882}
30883#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30884pub struct TerminalNeq {
30885 node: SyntaxNode,
30886 children: Arc<[SyntaxNode]>,
30887}
30888impl Terminal for TerminalNeq {
30889 const KIND: SyntaxKind = SyntaxKind::TerminalNeq;
30890 type TokenType = TokenNeq;
30891 fn new_green(
30892 db: &dyn SyntaxGroup,
30893 leading_trivia: TriviaGreen,
30894 token: <<TerminalNeq as Terminal>::TokenType as TypedSyntaxNode>::Green,
30895 trailing_trivia: TriviaGreen,
30896 ) -> Self::Green {
30897 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
30898 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
30899 TerminalNeqGreen(
30900 Arc::new(GreenNode {
30901 kind: SyntaxKind::TerminalNeq,
30902 details: GreenNodeDetails::Node { children, width },
30903 })
30904 .intern(db),
30905 )
30906 }
30907 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
30908 self.token(db).text(db)
30909 }
30910}
30911impl TerminalNeq {
30912 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30913 Trivia::from_syntax_node(db, self.children[0].clone())
30914 }
30915 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNeq {
30916 TokenNeq::from_syntax_node(db, self.children[1].clone())
30917 }
30918 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
30919 Trivia::from_syntax_node(db, self.children[2].clone())
30920 }
30921}
30922#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30923pub struct TerminalNeqPtr(pub SyntaxStablePtrId);
30924impl TerminalNeqPtr {}
30925impl TypedStablePtr for TerminalNeqPtr {
30926 type SyntaxNode = TerminalNeq;
30927 fn untyped(&self) -> SyntaxStablePtrId {
30928 self.0
30929 }
30930 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNeq {
30931 TerminalNeq::from_syntax_node(db, self.0.lookup(db))
30932 }
30933}
30934impl From<TerminalNeqPtr> for SyntaxStablePtrId {
30935 fn from(ptr: TerminalNeqPtr) -> Self {
30936 ptr.untyped()
30937 }
30938}
30939#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
30940pub struct TerminalNeqGreen(pub GreenId);
30941impl TypedSyntaxNode for TerminalNeq {
30942 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNeq);
30943 type StablePtr = TerminalNeqPtr;
30944 type Green = TerminalNeqGreen;
30945 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
30946 TerminalNeqGreen(
30947 Arc::new(GreenNode {
30948 kind: SyntaxKind::TerminalNeq,
30949 details: GreenNodeDetails::Node {
30950 children: vec![
30951 Trivia::missing(db).0,
30952 TokenNeq::missing(db).0,
30953 Trivia::missing(db).0,
30954 ],
30955 width: TextWidth::default(),
30956 },
30957 })
30958 .intern(db),
30959 )
30960 }
30961 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
30962 let kind = node.kind(db);
30963 assert_eq!(
30964 kind,
30965 SyntaxKind::TerminalNeq,
30966 "Unexpected SyntaxKind {:?}. Expected {:?}.",
30967 kind,
30968 SyntaxKind::TerminalNeq
30969 );
30970 let children = db.get_children(node.clone());
30971 Self { node, children }
30972 }
30973 fn as_syntax_node(&self) -> SyntaxNode {
30974 self.node.clone()
30975 }
30976 fn stable_ptr(&self) -> Self::StablePtr {
30977 TerminalNeqPtr(self.node.0.stable_ptr)
30978 }
30979}
30980impl From<&TerminalNeq> for SyntaxStablePtrId {
30981 fn from(node: &TerminalNeq) -> Self {
30982 node.stable_ptr().untyped()
30983 }
30984}
30985#[derive(Clone, Debug, Eq, Hash, PartialEq)]
30986pub struct TokenNot {
30987 node: SyntaxNode,
30988}
30989impl Token for TokenNot {
30990 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
30991 TokenNotGreen(
30992 Arc::new(GreenNode {
30993 kind: SyntaxKind::TokenNot,
30994 details: GreenNodeDetails::Token(text),
30995 })
30996 .intern(db),
30997 )
30998 }
30999 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31000 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31001 .clone()
31002 }
31003}
31004#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31005pub struct TokenNotPtr(pub SyntaxStablePtrId);
31006impl TypedStablePtr for TokenNotPtr {
31007 type SyntaxNode = TokenNot;
31008 fn untyped(&self) -> SyntaxStablePtrId {
31009 self.0
31010 }
31011 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNot {
31012 TokenNot::from_syntax_node(db, self.0.lookup(db))
31013 }
31014}
31015impl From<TokenNotPtr> for SyntaxStablePtrId {
31016 fn from(ptr: TokenNotPtr) -> Self {
31017 ptr.untyped()
31018 }
31019}
31020#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31021pub struct TokenNotGreen(pub GreenId);
31022impl TokenNotGreen {
31023 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31024 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31025 }
31026}
31027impl TypedSyntaxNode for TokenNot {
31028 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNot);
31029 type StablePtr = TokenNotPtr;
31030 type Green = TokenNotGreen;
31031 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31032 TokenNotGreen(
31033 Arc::new(GreenNode {
31034 kind: SyntaxKind::TokenMissing,
31035 details: GreenNodeDetails::Token("".into()),
31036 })
31037 .intern(db),
31038 )
31039 }
31040 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31041 match node.0.green.lookup_intern(db).details {
31042 GreenNodeDetails::Token(_) => Self { node },
31043 GreenNodeDetails::Node { .. } => {
31044 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNot)
31045 }
31046 }
31047 }
31048 fn as_syntax_node(&self) -> SyntaxNode {
31049 self.node.clone()
31050 }
31051 fn stable_ptr(&self) -> Self::StablePtr {
31052 TokenNotPtr(self.node.0.stable_ptr)
31053 }
31054}
31055impl From<&TokenNot> for SyntaxStablePtrId {
31056 fn from(node: &TokenNot) -> Self {
31057 node.stable_ptr().untyped()
31058 }
31059}
31060#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31061pub struct TerminalNot {
31062 node: SyntaxNode,
31063 children: Arc<[SyntaxNode]>,
31064}
31065impl Terminal for TerminalNot {
31066 const KIND: SyntaxKind = SyntaxKind::TerminalNot;
31067 type TokenType = TokenNot;
31068 fn new_green(
31069 db: &dyn SyntaxGroup,
31070 leading_trivia: TriviaGreen,
31071 token: <<TerminalNot as Terminal>::TokenType as TypedSyntaxNode>::Green,
31072 trailing_trivia: TriviaGreen,
31073 ) -> Self::Green {
31074 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31075 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31076 TerminalNotGreen(
31077 Arc::new(GreenNode {
31078 kind: SyntaxKind::TerminalNot,
31079 details: GreenNodeDetails::Node { children, width },
31080 })
31081 .intern(db),
31082 )
31083 }
31084 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31085 self.token(db).text(db)
31086 }
31087}
31088impl TerminalNot {
31089 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31090 Trivia::from_syntax_node(db, self.children[0].clone())
31091 }
31092 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenNot {
31093 TokenNot::from_syntax_node(db, self.children[1].clone())
31094 }
31095 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31096 Trivia::from_syntax_node(db, self.children[2].clone())
31097 }
31098}
31099#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31100pub struct TerminalNotPtr(pub SyntaxStablePtrId);
31101impl TerminalNotPtr {}
31102impl TypedStablePtr for TerminalNotPtr {
31103 type SyntaxNode = TerminalNot;
31104 fn untyped(&self) -> SyntaxStablePtrId {
31105 self.0
31106 }
31107 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalNot {
31108 TerminalNot::from_syntax_node(db, self.0.lookup(db))
31109 }
31110}
31111impl From<TerminalNotPtr> for SyntaxStablePtrId {
31112 fn from(ptr: TerminalNotPtr) -> Self {
31113 ptr.untyped()
31114 }
31115}
31116#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31117pub struct TerminalNotGreen(pub GreenId);
31118impl TypedSyntaxNode for TerminalNot {
31119 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalNot);
31120 type StablePtr = TerminalNotPtr;
31121 type Green = TerminalNotGreen;
31122 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31123 TerminalNotGreen(
31124 Arc::new(GreenNode {
31125 kind: SyntaxKind::TerminalNot,
31126 details: GreenNodeDetails::Node {
31127 children: vec![
31128 Trivia::missing(db).0,
31129 TokenNot::missing(db).0,
31130 Trivia::missing(db).0,
31131 ],
31132 width: TextWidth::default(),
31133 },
31134 })
31135 .intern(db),
31136 )
31137 }
31138 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31139 let kind = node.kind(db);
31140 assert_eq!(
31141 kind,
31142 SyntaxKind::TerminalNot,
31143 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31144 kind,
31145 SyntaxKind::TerminalNot
31146 );
31147 let children = db.get_children(node.clone());
31148 Self { node, children }
31149 }
31150 fn as_syntax_node(&self) -> SyntaxNode {
31151 self.node.clone()
31152 }
31153 fn stable_ptr(&self) -> Self::StablePtr {
31154 TerminalNotPtr(self.node.0.stable_ptr)
31155 }
31156}
31157impl From<&TerminalNot> for SyntaxStablePtrId {
31158 fn from(node: &TerminalNot) -> Self {
31159 node.stable_ptr().untyped()
31160 }
31161}
31162#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31163pub struct TokenBitNot {
31164 node: SyntaxNode,
31165}
31166impl Token for TokenBitNot {
31167 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31168 TokenBitNotGreen(
31169 Arc::new(GreenNode {
31170 kind: SyntaxKind::TokenBitNot,
31171 details: GreenNodeDetails::Token(text),
31172 })
31173 .intern(db),
31174 )
31175 }
31176 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31177 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31178 .clone()
31179 }
31180}
31181#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31182pub struct TokenBitNotPtr(pub SyntaxStablePtrId);
31183impl TypedStablePtr for TokenBitNotPtr {
31184 type SyntaxNode = TokenBitNot;
31185 fn untyped(&self) -> SyntaxStablePtrId {
31186 self.0
31187 }
31188 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenBitNot {
31189 TokenBitNot::from_syntax_node(db, self.0.lookup(db))
31190 }
31191}
31192impl From<TokenBitNotPtr> for SyntaxStablePtrId {
31193 fn from(ptr: TokenBitNotPtr) -> Self {
31194 ptr.untyped()
31195 }
31196}
31197#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31198pub struct TokenBitNotGreen(pub GreenId);
31199impl TokenBitNotGreen {
31200 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31201 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31202 }
31203}
31204impl TypedSyntaxNode for TokenBitNot {
31205 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenBitNot);
31206 type StablePtr = TokenBitNotPtr;
31207 type Green = TokenBitNotGreen;
31208 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31209 TokenBitNotGreen(
31210 Arc::new(GreenNode {
31211 kind: SyntaxKind::TokenMissing,
31212 details: GreenNodeDetails::Token("".into()),
31213 })
31214 .intern(db),
31215 )
31216 }
31217 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31218 match node.0.green.lookup_intern(db).details {
31219 GreenNodeDetails::Token(_) => Self { node },
31220 GreenNodeDetails::Node { .. } => {
31221 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenBitNot)
31222 }
31223 }
31224 }
31225 fn as_syntax_node(&self) -> SyntaxNode {
31226 self.node.clone()
31227 }
31228 fn stable_ptr(&self) -> Self::StablePtr {
31229 TokenBitNotPtr(self.node.0.stable_ptr)
31230 }
31231}
31232impl From<&TokenBitNot> for SyntaxStablePtrId {
31233 fn from(node: &TokenBitNot) -> Self {
31234 node.stable_ptr().untyped()
31235 }
31236}
31237#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31238pub struct TerminalBitNot {
31239 node: SyntaxNode,
31240 children: Arc<[SyntaxNode]>,
31241}
31242impl Terminal for TerminalBitNot {
31243 const KIND: SyntaxKind = SyntaxKind::TerminalBitNot;
31244 type TokenType = TokenBitNot;
31245 fn new_green(
31246 db: &dyn SyntaxGroup,
31247 leading_trivia: TriviaGreen,
31248 token: <<TerminalBitNot as Terminal>::TokenType as TypedSyntaxNode>::Green,
31249 trailing_trivia: TriviaGreen,
31250 ) -> Self::Green {
31251 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31252 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31253 TerminalBitNotGreen(
31254 Arc::new(GreenNode {
31255 kind: SyntaxKind::TerminalBitNot,
31256 details: GreenNodeDetails::Node { children, width },
31257 })
31258 .intern(db),
31259 )
31260 }
31261 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31262 self.token(db).text(db)
31263 }
31264}
31265impl TerminalBitNot {
31266 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31267 Trivia::from_syntax_node(db, self.children[0].clone())
31268 }
31269 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenBitNot {
31270 TokenBitNot::from_syntax_node(db, self.children[1].clone())
31271 }
31272 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31273 Trivia::from_syntax_node(db, self.children[2].clone())
31274 }
31275}
31276#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31277pub struct TerminalBitNotPtr(pub SyntaxStablePtrId);
31278impl TerminalBitNotPtr {}
31279impl TypedStablePtr for TerminalBitNotPtr {
31280 type SyntaxNode = TerminalBitNot;
31281 fn untyped(&self) -> SyntaxStablePtrId {
31282 self.0
31283 }
31284 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalBitNot {
31285 TerminalBitNot::from_syntax_node(db, self.0.lookup(db))
31286 }
31287}
31288impl From<TerminalBitNotPtr> for SyntaxStablePtrId {
31289 fn from(ptr: TerminalBitNotPtr) -> Self {
31290 ptr.untyped()
31291 }
31292}
31293#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31294pub struct TerminalBitNotGreen(pub GreenId);
31295impl TypedSyntaxNode for TerminalBitNot {
31296 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalBitNot);
31297 type StablePtr = TerminalBitNotPtr;
31298 type Green = TerminalBitNotGreen;
31299 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31300 TerminalBitNotGreen(
31301 Arc::new(GreenNode {
31302 kind: SyntaxKind::TerminalBitNot,
31303 details: GreenNodeDetails::Node {
31304 children: vec![
31305 Trivia::missing(db).0,
31306 TokenBitNot::missing(db).0,
31307 Trivia::missing(db).0,
31308 ],
31309 width: TextWidth::default(),
31310 },
31311 })
31312 .intern(db),
31313 )
31314 }
31315 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31316 let kind = node.kind(db);
31317 assert_eq!(
31318 kind,
31319 SyntaxKind::TerminalBitNot,
31320 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31321 kind,
31322 SyntaxKind::TerminalBitNot
31323 );
31324 let children = db.get_children(node.clone());
31325 Self { node, children }
31326 }
31327 fn as_syntax_node(&self) -> SyntaxNode {
31328 self.node.clone()
31329 }
31330 fn stable_ptr(&self) -> Self::StablePtr {
31331 TerminalBitNotPtr(self.node.0.stable_ptr)
31332 }
31333}
31334impl From<&TerminalBitNot> for SyntaxStablePtrId {
31335 fn from(node: &TerminalBitNot) -> Self {
31336 node.stable_ptr().untyped()
31337 }
31338}
31339#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31340pub struct TokenOr {
31341 node: SyntaxNode,
31342}
31343impl Token for TokenOr {
31344 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31345 TokenOrGreen(
31346 Arc::new(GreenNode {
31347 kind: SyntaxKind::TokenOr,
31348 details: GreenNodeDetails::Token(text),
31349 })
31350 .intern(db),
31351 )
31352 }
31353 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31354 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31355 .clone()
31356 }
31357}
31358#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31359pub struct TokenOrPtr(pub SyntaxStablePtrId);
31360impl TypedStablePtr for TokenOrPtr {
31361 type SyntaxNode = TokenOr;
31362 fn untyped(&self) -> SyntaxStablePtrId {
31363 self.0
31364 }
31365 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOr {
31366 TokenOr::from_syntax_node(db, self.0.lookup(db))
31367 }
31368}
31369impl From<TokenOrPtr> for SyntaxStablePtrId {
31370 fn from(ptr: TokenOrPtr) -> Self {
31371 ptr.untyped()
31372 }
31373}
31374#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31375pub struct TokenOrGreen(pub GreenId);
31376impl TokenOrGreen {
31377 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31378 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31379 }
31380}
31381impl TypedSyntaxNode for TokenOr {
31382 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOr);
31383 type StablePtr = TokenOrPtr;
31384 type Green = TokenOrGreen;
31385 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31386 TokenOrGreen(
31387 Arc::new(GreenNode {
31388 kind: SyntaxKind::TokenMissing,
31389 details: GreenNodeDetails::Token("".into()),
31390 })
31391 .intern(db),
31392 )
31393 }
31394 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31395 match node.0.green.lookup_intern(db).details {
31396 GreenNodeDetails::Token(_) => Self { node },
31397 GreenNodeDetails::Node { .. } => {
31398 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOr)
31399 }
31400 }
31401 }
31402 fn as_syntax_node(&self) -> SyntaxNode {
31403 self.node.clone()
31404 }
31405 fn stable_ptr(&self) -> Self::StablePtr {
31406 TokenOrPtr(self.node.0.stable_ptr)
31407 }
31408}
31409impl From<&TokenOr> for SyntaxStablePtrId {
31410 fn from(node: &TokenOr) -> Self {
31411 node.stable_ptr().untyped()
31412 }
31413}
31414#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31415pub struct TerminalOr {
31416 node: SyntaxNode,
31417 children: Arc<[SyntaxNode]>,
31418}
31419impl Terminal for TerminalOr {
31420 const KIND: SyntaxKind = SyntaxKind::TerminalOr;
31421 type TokenType = TokenOr;
31422 fn new_green(
31423 db: &dyn SyntaxGroup,
31424 leading_trivia: TriviaGreen,
31425 token: <<TerminalOr as Terminal>::TokenType as TypedSyntaxNode>::Green,
31426 trailing_trivia: TriviaGreen,
31427 ) -> Self::Green {
31428 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31429 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31430 TerminalOrGreen(
31431 Arc::new(GreenNode {
31432 kind: SyntaxKind::TerminalOr,
31433 details: GreenNodeDetails::Node { children, width },
31434 })
31435 .intern(db),
31436 )
31437 }
31438 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31439 self.token(db).text(db)
31440 }
31441}
31442impl TerminalOr {
31443 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31444 Trivia::from_syntax_node(db, self.children[0].clone())
31445 }
31446 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOr {
31447 TokenOr::from_syntax_node(db, self.children[1].clone())
31448 }
31449 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31450 Trivia::from_syntax_node(db, self.children[2].clone())
31451 }
31452}
31453#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31454pub struct TerminalOrPtr(pub SyntaxStablePtrId);
31455impl TerminalOrPtr {}
31456impl TypedStablePtr for TerminalOrPtr {
31457 type SyntaxNode = TerminalOr;
31458 fn untyped(&self) -> SyntaxStablePtrId {
31459 self.0
31460 }
31461 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOr {
31462 TerminalOr::from_syntax_node(db, self.0.lookup(db))
31463 }
31464}
31465impl From<TerminalOrPtr> for SyntaxStablePtrId {
31466 fn from(ptr: TerminalOrPtr) -> Self {
31467 ptr.untyped()
31468 }
31469}
31470#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31471pub struct TerminalOrGreen(pub GreenId);
31472impl TypedSyntaxNode for TerminalOr {
31473 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOr);
31474 type StablePtr = TerminalOrPtr;
31475 type Green = TerminalOrGreen;
31476 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31477 TerminalOrGreen(
31478 Arc::new(GreenNode {
31479 kind: SyntaxKind::TerminalOr,
31480 details: GreenNodeDetails::Node {
31481 children: vec![
31482 Trivia::missing(db).0,
31483 TokenOr::missing(db).0,
31484 Trivia::missing(db).0,
31485 ],
31486 width: TextWidth::default(),
31487 },
31488 })
31489 .intern(db),
31490 )
31491 }
31492 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31493 let kind = node.kind(db);
31494 assert_eq!(
31495 kind,
31496 SyntaxKind::TerminalOr,
31497 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31498 kind,
31499 SyntaxKind::TerminalOr
31500 );
31501 let children = db.get_children(node.clone());
31502 Self { node, children }
31503 }
31504 fn as_syntax_node(&self) -> SyntaxNode {
31505 self.node.clone()
31506 }
31507 fn stable_ptr(&self) -> Self::StablePtr {
31508 TerminalOrPtr(self.node.0.stable_ptr)
31509 }
31510}
31511impl From<&TerminalOr> for SyntaxStablePtrId {
31512 fn from(node: &TerminalOr) -> Self {
31513 node.stable_ptr().untyped()
31514 }
31515}
31516#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31517pub struct TokenOrOr {
31518 node: SyntaxNode,
31519}
31520impl Token for TokenOrOr {
31521 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31522 TokenOrOrGreen(
31523 Arc::new(GreenNode {
31524 kind: SyntaxKind::TokenOrOr,
31525 details: GreenNodeDetails::Token(text),
31526 })
31527 .intern(db),
31528 )
31529 }
31530 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31531 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31532 .clone()
31533 }
31534}
31535#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31536pub struct TokenOrOrPtr(pub SyntaxStablePtrId);
31537impl TypedStablePtr for TokenOrOrPtr {
31538 type SyntaxNode = TokenOrOr;
31539 fn untyped(&self) -> SyntaxStablePtrId {
31540 self.0
31541 }
31542 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenOrOr {
31543 TokenOrOr::from_syntax_node(db, self.0.lookup(db))
31544 }
31545}
31546impl From<TokenOrOrPtr> for SyntaxStablePtrId {
31547 fn from(ptr: TokenOrOrPtr) -> Self {
31548 ptr.untyped()
31549 }
31550}
31551#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31552pub struct TokenOrOrGreen(pub GreenId);
31553impl TokenOrOrGreen {
31554 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31555 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31556 }
31557}
31558impl TypedSyntaxNode for TokenOrOr {
31559 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenOrOr);
31560 type StablePtr = TokenOrOrPtr;
31561 type Green = TokenOrOrGreen;
31562 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31563 TokenOrOrGreen(
31564 Arc::new(GreenNode {
31565 kind: SyntaxKind::TokenMissing,
31566 details: GreenNodeDetails::Token("".into()),
31567 })
31568 .intern(db),
31569 )
31570 }
31571 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31572 match node.0.green.lookup_intern(db).details {
31573 GreenNodeDetails::Token(_) => Self { node },
31574 GreenNodeDetails::Node { .. } => {
31575 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenOrOr)
31576 }
31577 }
31578 }
31579 fn as_syntax_node(&self) -> SyntaxNode {
31580 self.node.clone()
31581 }
31582 fn stable_ptr(&self) -> Self::StablePtr {
31583 TokenOrOrPtr(self.node.0.stable_ptr)
31584 }
31585}
31586impl From<&TokenOrOr> for SyntaxStablePtrId {
31587 fn from(node: &TokenOrOr) -> Self {
31588 node.stable_ptr().untyped()
31589 }
31590}
31591#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31592pub struct TerminalOrOr {
31593 node: SyntaxNode,
31594 children: Arc<[SyntaxNode]>,
31595}
31596impl Terminal for TerminalOrOr {
31597 const KIND: SyntaxKind = SyntaxKind::TerminalOrOr;
31598 type TokenType = TokenOrOr;
31599 fn new_green(
31600 db: &dyn SyntaxGroup,
31601 leading_trivia: TriviaGreen,
31602 token: <<TerminalOrOr as Terminal>::TokenType as TypedSyntaxNode>::Green,
31603 trailing_trivia: TriviaGreen,
31604 ) -> Self::Green {
31605 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31606 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31607 TerminalOrOrGreen(
31608 Arc::new(GreenNode {
31609 kind: SyntaxKind::TerminalOrOr,
31610 details: GreenNodeDetails::Node { children, width },
31611 })
31612 .intern(db),
31613 )
31614 }
31615 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31616 self.token(db).text(db)
31617 }
31618}
31619impl TerminalOrOr {
31620 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31621 Trivia::from_syntax_node(db, self.children[0].clone())
31622 }
31623 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenOrOr {
31624 TokenOrOr::from_syntax_node(db, self.children[1].clone())
31625 }
31626 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31627 Trivia::from_syntax_node(db, self.children[2].clone())
31628 }
31629}
31630#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31631pub struct TerminalOrOrPtr(pub SyntaxStablePtrId);
31632impl TerminalOrOrPtr {}
31633impl TypedStablePtr for TerminalOrOrPtr {
31634 type SyntaxNode = TerminalOrOr;
31635 fn untyped(&self) -> SyntaxStablePtrId {
31636 self.0
31637 }
31638 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalOrOr {
31639 TerminalOrOr::from_syntax_node(db, self.0.lookup(db))
31640 }
31641}
31642impl From<TerminalOrOrPtr> for SyntaxStablePtrId {
31643 fn from(ptr: TerminalOrOrPtr) -> Self {
31644 ptr.untyped()
31645 }
31646}
31647#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31648pub struct TerminalOrOrGreen(pub GreenId);
31649impl TypedSyntaxNode for TerminalOrOr {
31650 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalOrOr);
31651 type StablePtr = TerminalOrOrPtr;
31652 type Green = TerminalOrOrGreen;
31653 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31654 TerminalOrOrGreen(
31655 Arc::new(GreenNode {
31656 kind: SyntaxKind::TerminalOrOr,
31657 details: GreenNodeDetails::Node {
31658 children: vec![
31659 Trivia::missing(db).0,
31660 TokenOrOr::missing(db).0,
31661 Trivia::missing(db).0,
31662 ],
31663 width: TextWidth::default(),
31664 },
31665 })
31666 .intern(db),
31667 )
31668 }
31669 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31670 let kind = node.kind(db);
31671 assert_eq!(
31672 kind,
31673 SyntaxKind::TerminalOrOr,
31674 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31675 kind,
31676 SyntaxKind::TerminalOrOr
31677 );
31678 let children = db.get_children(node.clone());
31679 Self { node, children }
31680 }
31681 fn as_syntax_node(&self) -> SyntaxNode {
31682 self.node.clone()
31683 }
31684 fn stable_ptr(&self) -> Self::StablePtr {
31685 TerminalOrOrPtr(self.node.0.stable_ptr)
31686 }
31687}
31688impl From<&TerminalOrOr> for SyntaxStablePtrId {
31689 fn from(node: &TerminalOrOr) -> Self {
31690 node.stable_ptr().untyped()
31691 }
31692}
31693#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31694pub struct TokenPlus {
31695 node: SyntaxNode,
31696}
31697impl Token for TokenPlus {
31698 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31699 TokenPlusGreen(
31700 Arc::new(GreenNode {
31701 kind: SyntaxKind::TokenPlus,
31702 details: GreenNodeDetails::Token(text),
31703 })
31704 .intern(db),
31705 )
31706 }
31707 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31708 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31709 .clone()
31710 }
31711}
31712#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31713pub struct TokenPlusPtr(pub SyntaxStablePtrId);
31714impl TypedStablePtr for TokenPlusPtr {
31715 type SyntaxNode = TokenPlus;
31716 fn untyped(&self) -> SyntaxStablePtrId {
31717 self.0
31718 }
31719 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPlus {
31720 TokenPlus::from_syntax_node(db, self.0.lookup(db))
31721 }
31722}
31723impl From<TokenPlusPtr> for SyntaxStablePtrId {
31724 fn from(ptr: TokenPlusPtr) -> Self {
31725 ptr.untyped()
31726 }
31727}
31728#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31729pub struct TokenPlusGreen(pub GreenId);
31730impl TokenPlusGreen {
31731 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31732 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31733 }
31734}
31735impl TypedSyntaxNode for TokenPlus {
31736 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPlus);
31737 type StablePtr = TokenPlusPtr;
31738 type Green = TokenPlusGreen;
31739 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31740 TokenPlusGreen(
31741 Arc::new(GreenNode {
31742 kind: SyntaxKind::TokenMissing,
31743 details: GreenNodeDetails::Token("".into()),
31744 })
31745 .intern(db),
31746 )
31747 }
31748 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31749 match node.0.green.lookup_intern(db).details {
31750 GreenNodeDetails::Token(_) => Self { node },
31751 GreenNodeDetails::Node { .. } => {
31752 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPlus)
31753 }
31754 }
31755 }
31756 fn as_syntax_node(&self) -> SyntaxNode {
31757 self.node.clone()
31758 }
31759 fn stable_ptr(&self) -> Self::StablePtr {
31760 TokenPlusPtr(self.node.0.stable_ptr)
31761 }
31762}
31763impl From<&TokenPlus> for SyntaxStablePtrId {
31764 fn from(node: &TokenPlus) -> Self {
31765 node.stable_ptr().untyped()
31766 }
31767}
31768#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31769pub struct TerminalPlus {
31770 node: SyntaxNode,
31771 children: Arc<[SyntaxNode]>,
31772}
31773impl Terminal for TerminalPlus {
31774 const KIND: SyntaxKind = SyntaxKind::TerminalPlus;
31775 type TokenType = TokenPlus;
31776 fn new_green(
31777 db: &dyn SyntaxGroup,
31778 leading_trivia: TriviaGreen,
31779 token: <<TerminalPlus as Terminal>::TokenType as TypedSyntaxNode>::Green,
31780 trailing_trivia: TriviaGreen,
31781 ) -> Self::Green {
31782 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31783 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31784 TerminalPlusGreen(
31785 Arc::new(GreenNode {
31786 kind: SyntaxKind::TerminalPlus,
31787 details: GreenNodeDetails::Node { children, width },
31788 })
31789 .intern(db),
31790 )
31791 }
31792 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31793 self.token(db).text(db)
31794 }
31795}
31796impl TerminalPlus {
31797 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31798 Trivia::from_syntax_node(db, self.children[0].clone())
31799 }
31800 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPlus {
31801 TokenPlus::from_syntax_node(db, self.children[1].clone())
31802 }
31803 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31804 Trivia::from_syntax_node(db, self.children[2].clone())
31805 }
31806}
31807#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31808pub struct TerminalPlusPtr(pub SyntaxStablePtrId);
31809impl TerminalPlusPtr {}
31810impl TypedStablePtr for TerminalPlusPtr {
31811 type SyntaxNode = TerminalPlus;
31812 fn untyped(&self) -> SyntaxStablePtrId {
31813 self.0
31814 }
31815 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPlus {
31816 TerminalPlus::from_syntax_node(db, self.0.lookup(db))
31817 }
31818}
31819impl From<TerminalPlusPtr> for SyntaxStablePtrId {
31820 fn from(ptr: TerminalPlusPtr) -> Self {
31821 ptr.untyped()
31822 }
31823}
31824#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31825pub struct TerminalPlusGreen(pub GreenId);
31826impl TypedSyntaxNode for TerminalPlus {
31827 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPlus);
31828 type StablePtr = TerminalPlusPtr;
31829 type Green = TerminalPlusGreen;
31830 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31831 TerminalPlusGreen(
31832 Arc::new(GreenNode {
31833 kind: SyntaxKind::TerminalPlus,
31834 details: GreenNodeDetails::Node {
31835 children: vec![
31836 Trivia::missing(db).0,
31837 TokenPlus::missing(db).0,
31838 Trivia::missing(db).0,
31839 ],
31840 width: TextWidth::default(),
31841 },
31842 })
31843 .intern(db),
31844 )
31845 }
31846 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31847 let kind = node.kind(db);
31848 assert_eq!(
31849 kind,
31850 SyntaxKind::TerminalPlus,
31851 "Unexpected SyntaxKind {:?}. Expected {:?}.",
31852 kind,
31853 SyntaxKind::TerminalPlus
31854 );
31855 let children = db.get_children(node.clone());
31856 Self { node, children }
31857 }
31858 fn as_syntax_node(&self) -> SyntaxNode {
31859 self.node.clone()
31860 }
31861 fn stable_ptr(&self) -> Self::StablePtr {
31862 TerminalPlusPtr(self.node.0.stable_ptr)
31863 }
31864}
31865impl From<&TerminalPlus> for SyntaxStablePtrId {
31866 fn from(node: &TerminalPlus) -> Self {
31867 node.stable_ptr().untyped()
31868 }
31869}
31870#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31871pub struct TokenPlusEq {
31872 node: SyntaxNode,
31873}
31874impl Token for TokenPlusEq {
31875 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
31876 TokenPlusEqGreen(
31877 Arc::new(GreenNode {
31878 kind: SyntaxKind::TokenPlusEq,
31879 details: GreenNodeDetails::Token(text),
31880 })
31881 .intern(db),
31882 )
31883 }
31884 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31885 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
31886 .clone()
31887 }
31888}
31889#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31890pub struct TokenPlusEqPtr(pub SyntaxStablePtrId);
31891impl TypedStablePtr for TokenPlusEqPtr {
31892 type SyntaxNode = TokenPlusEq;
31893 fn untyped(&self) -> SyntaxStablePtrId {
31894 self.0
31895 }
31896 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenPlusEq {
31897 TokenPlusEq::from_syntax_node(db, self.0.lookup(db))
31898 }
31899}
31900impl From<TokenPlusEqPtr> for SyntaxStablePtrId {
31901 fn from(ptr: TokenPlusEqPtr) -> Self {
31902 ptr.untyped()
31903 }
31904}
31905#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31906pub struct TokenPlusEqGreen(pub GreenId);
31907impl TokenPlusEqGreen {
31908 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31909 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
31910 }
31911}
31912impl TypedSyntaxNode for TokenPlusEq {
31913 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenPlusEq);
31914 type StablePtr = TokenPlusEqPtr;
31915 type Green = TokenPlusEqGreen;
31916 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
31917 TokenPlusEqGreen(
31918 Arc::new(GreenNode {
31919 kind: SyntaxKind::TokenMissing,
31920 details: GreenNodeDetails::Token("".into()),
31921 })
31922 .intern(db),
31923 )
31924 }
31925 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
31926 match node.0.green.lookup_intern(db).details {
31927 GreenNodeDetails::Token(_) => Self { node },
31928 GreenNodeDetails::Node { .. } => {
31929 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenPlusEq)
31930 }
31931 }
31932 }
31933 fn as_syntax_node(&self) -> SyntaxNode {
31934 self.node.clone()
31935 }
31936 fn stable_ptr(&self) -> Self::StablePtr {
31937 TokenPlusEqPtr(self.node.0.stable_ptr)
31938 }
31939}
31940impl From<&TokenPlusEq> for SyntaxStablePtrId {
31941 fn from(node: &TokenPlusEq) -> Self {
31942 node.stable_ptr().untyped()
31943 }
31944}
31945#[derive(Clone, Debug, Eq, Hash, PartialEq)]
31946pub struct TerminalPlusEq {
31947 node: SyntaxNode,
31948 children: Arc<[SyntaxNode]>,
31949}
31950impl Terminal for TerminalPlusEq {
31951 const KIND: SyntaxKind = SyntaxKind::TerminalPlusEq;
31952 type TokenType = TokenPlusEq;
31953 fn new_green(
31954 db: &dyn SyntaxGroup,
31955 leading_trivia: TriviaGreen,
31956 token: <<TerminalPlusEq as Terminal>::TokenType as TypedSyntaxNode>::Green,
31957 trailing_trivia: TriviaGreen,
31958 ) -> Self::Green {
31959 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
31960 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
31961 TerminalPlusEqGreen(
31962 Arc::new(GreenNode {
31963 kind: SyntaxKind::TerminalPlusEq,
31964 details: GreenNodeDetails::Node { children, width },
31965 })
31966 .intern(db),
31967 )
31968 }
31969 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
31970 self.token(db).text(db)
31971 }
31972}
31973impl TerminalPlusEq {
31974 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31975 Trivia::from_syntax_node(db, self.children[0].clone())
31976 }
31977 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenPlusEq {
31978 TokenPlusEq::from_syntax_node(db, self.children[1].clone())
31979 }
31980 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
31981 Trivia::from_syntax_node(db, self.children[2].clone())
31982 }
31983}
31984#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31985pub struct TerminalPlusEqPtr(pub SyntaxStablePtrId);
31986impl TerminalPlusEqPtr {}
31987impl TypedStablePtr for TerminalPlusEqPtr {
31988 type SyntaxNode = TerminalPlusEq;
31989 fn untyped(&self) -> SyntaxStablePtrId {
31990 self.0
31991 }
31992 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalPlusEq {
31993 TerminalPlusEq::from_syntax_node(db, self.0.lookup(db))
31994 }
31995}
31996impl From<TerminalPlusEqPtr> for SyntaxStablePtrId {
31997 fn from(ptr: TerminalPlusEqPtr) -> Self {
31998 ptr.untyped()
31999 }
32000}
32001#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32002pub struct TerminalPlusEqGreen(pub GreenId);
32003impl TypedSyntaxNode for TerminalPlusEq {
32004 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalPlusEq);
32005 type StablePtr = TerminalPlusEqPtr;
32006 type Green = TerminalPlusEqGreen;
32007 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32008 TerminalPlusEqGreen(
32009 Arc::new(GreenNode {
32010 kind: SyntaxKind::TerminalPlusEq,
32011 details: GreenNodeDetails::Node {
32012 children: vec![
32013 Trivia::missing(db).0,
32014 TokenPlusEq::missing(db).0,
32015 Trivia::missing(db).0,
32016 ],
32017 width: TextWidth::default(),
32018 },
32019 })
32020 .intern(db),
32021 )
32022 }
32023 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32024 let kind = node.kind(db);
32025 assert_eq!(
32026 kind,
32027 SyntaxKind::TerminalPlusEq,
32028 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32029 kind,
32030 SyntaxKind::TerminalPlusEq
32031 );
32032 let children = db.get_children(node.clone());
32033 Self { node, children }
32034 }
32035 fn as_syntax_node(&self) -> SyntaxNode {
32036 self.node.clone()
32037 }
32038 fn stable_ptr(&self) -> Self::StablePtr {
32039 TerminalPlusEqPtr(self.node.0.stable_ptr)
32040 }
32041}
32042impl From<&TerminalPlusEq> for SyntaxStablePtrId {
32043 fn from(node: &TerminalPlusEq) -> Self {
32044 node.stable_ptr().untyped()
32045 }
32046}
32047#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32048pub struct TokenQuestionMark {
32049 node: SyntaxNode,
32050}
32051impl Token for TokenQuestionMark {
32052 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32053 TokenQuestionMarkGreen(
32054 Arc::new(GreenNode {
32055 kind: SyntaxKind::TokenQuestionMark,
32056 details: GreenNodeDetails::Token(text),
32057 })
32058 .intern(db),
32059 )
32060 }
32061 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32062 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32063 .clone()
32064 }
32065}
32066#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32067pub struct TokenQuestionMarkPtr(pub SyntaxStablePtrId);
32068impl TypedStablePtr for TokenQuestionMarkPtr {
32069 type SyntaxNode = TokenQuestionMark;
32070 fn untyped(&self) -> SyntaxStablePtrId {
32071 self.0
32072 }
32073 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenQuestionMark {
32074 TokenQuestionMark::from_syntax_node(db, self.0.lookup(db))
32075 }
32076}
32077impl From<TokenQuestionMarkPtr> for SyntaxStablePtrId {
32078 fn from(ptr: TokenQuestionMarkPtr) -> Self {
32079 ptr.untyped()
32080 }
32081}
32082#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32083pub struct TokenQuestionMarkGreen(pub GreenId);
32084impl TokenQuestionMarkGreen {
32085 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32086 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32087 }
32088}
32089impl TypedSyntaxNode for TokenQuestionMark {
32090 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenQuestionMark);
32091 type StablePtr = TokenQuestionMarkPtr;
32092 type Green = TokenQuestionMarkGreen;
32093 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32094 TokenQuestionMarkGreen(
32095 Arc::new(GreenNode {
32096 kind: SyntaxKind::TokenMissing,
32097 details: GreenNodeDetails::Token("".into()),
32098 })
32099 .intern(db),
32100 )
32101 }
32102 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32103 match node.0.green.lookup_intern(db).details {
32104 GreenNodeDetails::Token(_) => Self { node },
32105 GreenNodeDetails::Node { .. } => {
32106 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenQuestionMark)
32107 }
32108 }
32109 }
32110 fn as_syntax_node(&self) -> SyntaxNode {
32111 self.node.clone()
32112 }
32113 fn stable_ptr(&self) -> Self::StablePtr {
32114 TokenQuestionMarkPtr(self.node.0.stable_ptr)
32115 }
32116}
32117impl From<&TokenQuestionMark> for SyntaxStablePtrId {
32118 fn from(node: &TokenQuestionMark) -> Self {
32119 node.stable_ptr().untyped()
32120 }
32121}
32122#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32123pub struct TerminalQuestionMark {
32124 node: SyntaxNode,
32125 children: Arc<[SyntaxNode]>,
32126}
32127impl Terminal for TerminalQuestionMark {
32128 const KIND: SyntaxKind = SyntaxKind::TerminalQuestionMark;
32129 type TokenType = TokenQuestionMark;
32130 fn new_green(
32131 db: &dyn SyntaxGroup,
32132 leading_trivia: TriviaGreen,
32133 token: <<TerminalQuestionMark as Terminal>::TokenType as TypedSyntaxNode>::Green,
32134 trailing_trivia: TriviaGreen,
32135 ) -> Self::Green {
32136 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32137 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32138 TerminalQuestionMarkGreen(
32139 Arc::new(GreenNode {
32140 kind: SyntaxKind::TerminalQuestionMark,
32141 details: GreenNodeDetails::Node { children, width },
32142 })
32143 .intern(db),
32144 )
32145 }
32146 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32147 self.token(db).text(db)
32148 }
32149}
32150impl TerminalQuestionMark {
32151 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32152 Trivia::from_syntax_node(db, self.children[0].clone())
32153 }
32154 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenQuestionMark {
32155 TokenQuestionMark::from_syntax_node(db, self.children[1].clone())
32156 }
32157 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32158 Trivia::from_syntax_node(db, self.children[2].clone())
32159 }
32160}
32161#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32162pub struct TerminalQuestionMarkPtr(pub SyntaxStablePtrId);
32163impl TerminalQuestionMarkPtr {}
32164impl TypedStablePtr for TerminalQuestionMarkPtr {
32165 type SyntaxNode = TerminalQuestionMark;
32166 fn untyped(&self) -> SyntaxStablePtrId {
32167 self.0
32168 }
32169 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalQuestionMark {
32170 TerminalQuestionMark::from_syntax_node(db, self.0.lookup(db))
32171 }
32172}
32173impl From<TerminalQuestionMarkPtr> for SyntaxStablePtrId {
32174 fn from(ptr: TerminalQuestionMarkPtr) -> Self {
32175 ptr.untyped()
32176 }
32177}
32178#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32179pub struct TerminalQuestionMarkGreen(pub GreenId);
32180impl TypedSyntaxNode for TerminalQuestionMark {
32181 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalQuestionMark);
32182 type StablePtr = TerminalQuestionMarkPtr;
32183 type Green = TerminalQuestionMarkGreen;
32184 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32185 TerminalQuestionMarkGreen(
32186 Arc::new(GreenNode {
32187 kind: SyntaxKind::TerminalQuestionMark,
32188 details: GreenNodeDetails::Node {
32189 children: vec![
32190 Trivia::missing(db).0,
32191 TokenQuestionMark::missing(db).0,
32192 Trivia::missing(db).0,
32193 ],
32194 width: TextWidth::default(),
32195 },
32196 })
32197 .intern(db),
32198 )
32199 }
32200 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32201 let kind = node.kind(db);
32202 assert_eq!(
32203 kind,
32204 SyntaxKind::TerminalQuestionMark,
32205 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32206 kind,
32207 SyntaxKind::TerminalQuestionMark
32208 );
32209 let children = db.get_children(node.clone());
32210 Self { node, children }
32211 }
32212 fn as_syntax_node(&self) -> SyntaxNode {
32213 self.node.clone()
32214 }
32215 fn stable_ptr(&self) -> Self::StablePtr {
32216 TerminalQuestionMarkPtr(self.node.0.stable_ptr)
32217 }
32218}
32219impl From<&TerminalQuestionMark> for SyntaxStablePtrId {
32220 fn from(node: &TerminalQuestionMark) -> Self {
32221 node.stable_ptr().untyped()
32222 }
32223}
32224#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32225pub struct TokenRBrace {
32226 node: SyntaxNode,
32227}
32228impl Token for TokenRBrace {
32229 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32230 TokenRBraceGreen(
32231 Arc::new(GreenNode {
32232 kind: SyntaxKind::TokenRBrace,
32233 details: GreenNodeDetails::Token(text),
32234 })
32235 .intern(db),
32236 )
32237 }
32238 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32239 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32240 .clone()
32241 }
32242}
32243#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32244pub struct TokenRBracePtr(pub SyntaxStablePtrId);
32245impl TypedStablePtr for TokenRBracePtr {
32246 type SyntaxNode = TokenRBrace;
32247 fn untyped(&self) -> SyntaxStablePtrId {
32248 self.0
32249 }
32250 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRBrace {
32251 TokenRBrace::from_syntax_node(db, self.0.lookup(db))
32252 }
32253}
32254impl From<TokenRBracePtr> for SyntaxStablePtrId {
32255 fn from(ptr: TokenRBracePtr) -> Self {
32256 ptr.untyped()
32257 }
32258}
32259#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32260pub struct TokenRBraceGreen(pub GreenId);
32261impl TokenRBraceGreen {
32262 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32263 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32264 }
32265}
32266impl TypedSyntaxNode for TokenRBrace {
32267 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRBrace);
32268 type StablePtr = TokenRBracePtr;
32269 type Green = TokenRBraceGreen;
32270 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32271 TokenRBraceGreen(
32272 Arc::new(GreenNode {
32273 kind: SyntaxKind::TokenMissing,
32274 details: GreenNodeDetails::Token("".into()),
32275 })
32276 .intern(db),
32277 )
32278 }
32279 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32280 match node.0.green.lookup_intern(db).details {
32281 GreenNodeDetails::Token(_) => Self { node },
32282 GreenNodeDetails::Node { .. } => {
32283 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRBrace)
32284 }
32285 }
32286 }
32287 fn as_syntax_node(&self) -> SyntaxNode {
32288 self.node.clone()
32289 }
32290 fn stable_ptr(&self) -> Self::StablePtr {
32291 TokenRBracePtr(self.node.0.stable_ptr)
32292 }
32293}
32294impl From<&TokenRBrace> for SyntaxStablePtrId {
32295 fn from(node: &TokenRBrace) -> Self {
32296 node.stable_ptr().untyped()
32297 }
32298}
32299#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32300pub struct TerminalRBrace {
32301 node: SyntaxNode,
32302 children: Arc<[SyntaxNode]>,
32303}
32304impl Terminal for TerminalRBrace {
32305 const KIND: SyntaxKind = SyntaxKind::TerminalRBrace;
32306 type TokenType = TokenRBrace;
32307 fn new_green(
32308 db: &dyn SyntaxGroup,
32309 leading_trivia: TriviaGreen,
32310 token: <<TerminalRBrace as Terminal>::TokenType as TypedSyntaxNode>::Green,
32311 trailing_trivia: TriviaGreen,
32312 ) -> Self::Green {
32313 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32314 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32315 TerminalRBraceGreen(
32316 Arc::new(GreenNode {
32317 kind: SyntaxKind::TerminalRBrace,
32318 details: GreenNodeDetails::Node { children, width },
32319 })
32320 .intern(db),
32321 )
32322 }
32323 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32324 self.token(db).text(db)
32325 }
32326}
32327impl TerminalRBrace {
32328 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32329 Trivia::from_syntax_node(db, self.children[0].clone())
32330 }
32331 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRBrace {
32332 TokenRBrace::from_syntax_node(db, self.children[1].clone())
32333 }
32334 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32335 Trivia::from_syntax_node(db, self.children[2].clone())
32336 }
32337}
32338#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32339pub struct TerminalRBracePtr(pub SyntaxStablePtrId);
32340impl TerminalRBracePtr {}
32341impl TypedStablePtr for TerminalRBracePtr {
32342 type SyntaxNode = TerminalRBrace;
32343 fn untyped(&self) -> SyntaxStablePtrId {
32344 self.0
32345 }
32346 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRBrace {
32347 TerminalRBrace::from_syntax_node(db, self.0.lookup(db))
32348 }
32349}
32350impl From<TerminalRBracePtr> for SyntaxStablePtrId {
32351 fn from(ptr: TerminalRBracePtr) -> Self {
32352 ptr.untyped()
32353 }
32354}
32355#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32356pub struct TerminalRBraceGreen(pub GreenId);
32357impl TypedSyntaxNode for TerminalRBrace {
32358 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRBrace);
32359 type StablePtr = TerminalRBracePtr;
32360 type Green = TerminalRBraceGreen;
32361 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32362 TerminalRBraceGreen(
32363 Arc::new(GreenNode {
32364 kind: SyntaxKind::TerminalRBrace,
32365 details: GreenNodeDetails::Node {
32366 children: vec![
32367 Trivia::missing(db).0,
32368 TokenRBrace::missing(db).0,
32369 Trivia::missing(db).0,
32370 ],
32371 width: TextWidth::default(),
32372 },
32373 })
32374 .intern(db),
32375 )
32376 }
32377 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32378 let kind = node.kind(db);
32379 assert_eq!(
32380 kind,
32381 SyntaxKind::TerminalRBrace,
32382 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32383 kind,
32384 SyntaxKind::TerminalRBrace
32385 );
32386 let children = db.get_children(node.clone());
32387 Self { node, children }
32388 }
32389 fn as_syntax_node(&self) -> SyntaxNode {
32390 self.node.clone()
32391 }
32392 fn stable_ptr(&self) -> Self::StablePtr {
32393 TerminalRBracePtr(self.node.0.stable_ptr)
32394 }
32395}
32396impl From<&TerminalRBrace> for SyntaxStablePtrId {
32397 fn from(node: &TerminalRBrace) -> Self {
32398 node.stable_ptr().untyped()
32399 }
32400}
32401#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32402pub struct TokenRBrack {
32403 node: SyntaxNode,
32404}
32405impl Token for TokenRBrack {
32406 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32407 TokenRBrackGreen(
32408 Arc::new(GreenNode {
32409 kind: SyntaxKind::TokenRBrack,
32410 details: GreenNodeDetails::Token(text),
32411 })
32412 .intern(db),
32413 )
32414 }
32415 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32416 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32417 .clone()
32418 }
32419}
32420#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32421pub struct TokenRBrackPtr(pub SyntaxStablePtrId);
32422impl TypedStablePtr for TokenRBrackPtr {
32423 type SyntaxNode = TokenRBrack;
32424 fn untyped(&self) -> SyntaxStablePtrId {
32425 self.0
32426 }
32427 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRBrack {
32428 TokenRBrack::from_syntax_node(db, self.0.lookup(db))
32429 }
32430}
32431impl From<TokenRBrackPtr> for SyntaxStablePtrId {
32432 fn from(ptr: TokenRBrackPtr) -> Self {
32433 ptr.untyped()
32434 }
32435}
32436#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32437pub struct TokenRBrackGreen(pub GreenId);
32438impl TokenRBrackGreen {
32439 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32440 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32441 }
32442}
32443impl TypedSyntaxNode for TokenRBrack {
32444 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRBrack);
32445 type StablePtr = TokenRBrackPtr;
32446 type Green = TokenRBrackGreen;
32447 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32448 TokenRBrackGreen(
32449 Arc::new(GreenNode {
32450 kind: SyntaxKind::TokenMissing,
32451 details: GreenNodeDetails::Token("".into()),
32452 })
32453 .intern(db),
32454 )
32455 }
32456 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32457 match node.0.green.lookup_intern(db).details {
32458 GreenNodeDetails::Token(_) => Self { node },
32459 GreenNodeDetails::Node { .. } => {
32460 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRBrack)
32461 }
32462 }
32463 }
32464 fn as_syntax_node(&self) -> SyntaxNode {
32465 self.node.clone()
32466 }
32467 fn stable_ptr(&self) -> Self::StablePtr {
32468 TokenRBrackPtr(self.node.0.stable_ptr)
32469 }
32470}
32471impl From<&TokenRBrack> for SyntaxStablePtrId {
32472 fn from(node: &TokenRBrack) -> Self {
32473 node.stable_ptr().untyped()
32474 }
32475}
32476#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32477pub struct TerminalRBrack {
32478 node: SyntaxNode,
32479 children: Arc<[SyntaxNode]>,
32480}
32481impl Terminal for TerminalRBrack {
32482 const KIND: SyntaxKind = SyntaxKind::TerminalRBrack;
32483 type TokenType = TokenRBrack;
32484 fn new_green(
32485 db: &dyn SyntaxGroup,
32486 leading_trivia: TriviaGreen,
32487 token: <<TerminalRBrack as Terminal>::TokenType as TypedSyntaxNode>::Green,
32488 trailing_trivia: TriviaGreen,
32489 ) -> Self::Green {
32490 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32491 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32492 TerminalRBrackGreen(
32493 Arc::new(GreenNode {
32494 kind: SyntaxKind::TerminalRBrack,
32495 details: GreenNodeDetails::Node { children, width },
32496 })
32497 .intern(db),
32498 )
32499 }
32500 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32501 self.token(db).text(db)
32502 }
32503}
32504impl TerminalRBrack {
32505 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32506 Trivia::from_syntax_node(db, self.children[0].clone())
32507 }
32508 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRBrack {
32509 TokenRBrack::from_syntax_node(db, self.children[1].clone())
32510 }
32511 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32512 Trivia::from_syntax_node(db, self.children[2].clone())
32513 }
32514}
32515#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32516pub struct TerminalRBrackPtr(pub SyntaxStablePtrId);
32517impl TerminalRBrackPtr {}
32518impl TypedStablePtr for TerminalRBrackPtr {
32519 type SyntaxNode = TerminalRBrack;
32520 fn untyped(&self) -> SyntaxStablePtrId {
32521 self.0
32522 }
32523 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRBrack {
32524 TerminalRBrack::from_syntax_node(db, self.0.lookup(db))
32525 }
32526}
32527impl From<TerminalRBrackPtr> for SyntaxStablePtrId {
32528 fn from(ptr: TerminalRBrackPtr) -> Self {
32529 ptr.untyped()
32530 }
32531}
32532#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32533pub struct TerminalRBrackGreen(pub GreenId);
32534impl TypedSyntaxNode for TerminalRBrack {
32535 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRBrack);
32536 type StablePtr = TerminalRBrackPtr;
32537 type Green = TerminalRBrackGreen;
32538 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32539 TerminalRBrackGreen(
32540 Arc::new(GreenNode {
32541 kind: SyntaxKind::TerminalRBrack,
32542 details: GreenNodeDetails::Node {
32543 children: vec![
32544 Trivia::missing(db).0,
32545 TokenRBrack::missing(db).0,
32546 Trivia::missing(db).0,
32547 ],
32548 width: TextWidth::default(),
32549 },
32550 })
32551 .intern(db),
32552 )
32553 }
32554 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32555 let kind = node.kind(db);
32556 assert_eq!(
32557 kind,
32558 SyntaxKind::TerminalRBrack,
32559 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32560 kind,
32561 SyntaxKind::TerminalRBrack
32562 );
32563 let children = db.get_children(node.clone());
32564 Self { node, children }
32565 }
32566 fn as_syntax_node(&self) -> SyntaxNode {
32567 self.node.clone()
32568 }
32569 fn stable_ptr(&self) -> Self::StablePtr {
32570 TerminalRBrackPtr(self.node.0.stable_ptr)
32571 }
32572}
32573impl From<&TerminalRBrack> for SyntaxStablePtrId {
32574 fn from(node: &TerminalRBrack) -> Self {
32575 node.stable_ptr().untyped()
32576 }
32577}
32578#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32579pub struct TokenRParen {
32580 node: SyntaxNode,
32581}
32582impl Token for TokenRParen {
32583 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32584 TokenRParenGreen(
32585 Arc::new(GreenNode {
32586 kind: SyntaxKind::TokenRParen,
32587 details: GreenNodeDetails::Token(text),
32588 })
32589 .intern(db),
32590 )
32591 }
32592 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32593 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32594 .clone()
32595 }
32596}
32597#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32598pub struct TokenRParenPtr(pub SyntaxStablePtrId);
32599impl TypedStablePtr for TokenRParenPtr {
32600 type SyntaxNode = TokenRParen;
32601 fn untyped(&self) -> SyntaxStablePtrId {
32602 self.0
32603 }
32604 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenRParen {
32605 TokenRParen::from_syntax_node(db, self.0.lookup(db))
32606 }
32607}
32608impl From<TokenRParenPtr> for SyntaxStablePtrId {
32609 fn from(ptr: TokenRParenPtr) -> Self {
32610 ptr.untyped()
32611 }
32612}
32613#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32614pub struct TokenRParenGreen(pub GreenId);
32615impl TokenRParenGreen {
32616 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32617 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32618 }
32619}
32620impl TypedSyntaxNode for TokenRParen {
32621 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenRParen);
32622 type StablePtr = TokenRParenPtr;
32623 type Green = TokenRParenGreen;
32624 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32625 TokenRParenGreen(
32626 Arc::new(GreenNode {
32627 kind: SyntaxKind::TokenMissing,
32628 details: GreenNodeDetails::Token("".into()),
32629 })
32630 .intern(db),
32631 )
32632 }
32633 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32634 match node.0.green.lookup_intern(db).details {
32635 GreenNodeDetails::Token(_) => Self { node },
32636 GreenNodeDetails::Node { .. } => {
32637 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenRParen)
32638 }
32639 }
32640 }
32641 fn as_syntax_node(&self) -> SyntaxNode {
32642 self.node.clone()
32643 }
32644 fn stable_ptr(&self) -> Self::StablePtr {
32645 TokenRParenPtr(self.node.0.stable_ptr)
32646 }
32647}
32648impl From<&TokenRParen> for SyntaxStablePtrId {
32649 fn from(node: &TokenRParen) -> Self {
32650 node.stable_ptr().untyped()
32651 }
32652}
32653#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32654pub struct TerminalRParen {
32655 node: SyntaxNode,
32656 children: Arc<[SyntaxNode]>,
32657}
32658impl Terminal for TerminalRParen {
32659 const KIND: SyntaxKind = SyntaxKind::TerminalRParen;
32660 type TokenType = TokenRParen;
32661 fn new_green(
32662 db: &dyn SyntaxGroup,
32663 leading_trivia: TriviaGreen,
32664 token: <<TerminalRParen as Terminal>::TokenType as TypedSyntaxNode>::Green,
32665 trailing_trivia: TriviaGreen,
32666 ) -> Self::Green {
32667 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32668 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32669 TerminalRParenGreen(
32670 Arc::new(GreenNode {
32671 kind: SyntaxKind::TerminalRParen,
32672 details: GreenNodeDetails::Node { children, width },
32673 })
32674 .intern(db),
32675 )
32676 }
32677 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32678 self.token(db).text(db)
32679 }
32680}
32681impl TerminalRParen {
32682 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32683 Trivia::from_syntax_node(db, self.children[0].clone())
32684 }
32685 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenRParen {
32686 TokenRParen::from_syntax_node(db, self.children[1].clone())
32687 }
32688 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32689 Trivia::from_syntax_node(db, self.children[2].clone())
32690 }
32691}
32692#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32693pub struct TerminalRParenPtr(pub SyntaxStablePtrId);
32694impl TerminalRParenPtr {}
32695impl TypedStablePtr for TerminalRParenPtr {
32696 type SyntaxNode = TerminalRParen;
32697 fn untyped(&self) -> SyntaxStablePtrId {
32698 self.0
32699 }
32700 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalRParen {
32701 TerminalRParen::from_syntax_node(db, self.0.lookup(db))
32702 }
32703}
32704impl From<TerminalRParenPtr> for SyntaxStablePtrId {
32705 fn from(ptr: TerminalRParenPtr) -> Self {
32706 ptr.untyped()
32707 }
32708}
32709#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32710pub struct TerminalRParenGreen(pub GreenId);
32711impl TypedSyntaxNode for TerminalRParen {
32712 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalRParen);
32713 type StablePtr = TerminalRParenPtr;
32714 type Green = TerminalRParenGreen;
32715 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32716 TerminalRParenGreen(
32717 Arc::new(GreenNode {
32718 kind: SyntaxKind::TerminalRParen,
32719 details: GreenNodeDetails::Node {
32720 children: vec![
32721 Trivia::missing(db).0,
32722 TokenRParen::missing(db).0,
32723 Trivia::missing(db).0,
32724 ],
32725 width: TextWidth::default(),
32726 },
32727 })
32728 .intern(db),
32729 )
32730 }
32731 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32732 let kind = node.kind(db);
32733 assert_eq!(
32734 kind,
32735 SyntaxKind::TerminalRParen,
32736 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32737 kind,
32738 SyntaxKind::TerminalRParen
32739 );
32740 let children = db.get_children(node.clone());
32741 Self { node, children }
32742 }
32743 fn as_syntax_node(&self) -> SyntaxNode {
32744 self.node.clone()
32745 }
32746 fn stable_ptr(&self) -> Self::StablePtr {
32747 TerminalRParenPtr(self.node.0.stable_ptr)
32748 }
32749}
32750impl From<&TerminalRParen> for SyntaxStablePtrId {
32751 fn from(node: &TerminalRParen) -> Self {
32752 node.stable_ptr().untyped()
32753 }
32754}
32755#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32756pub struct TokenSemicolon {
32757 node: SyntaxNode,
32758}
32759impl Token for TokenSemicolon {
32760 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32761 TokenSemicolonGreen(
32762 Arc::new(GreenNode {
32763 kind: SyntaxKind::TokenSemicolon,
32764 details: GreenNodeDetails::Token(text),
32765 })
32766 .intern(db),
32767 )
32768 }
32769 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32770 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32771 .clone()
32772 }
32773}
32774#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32775pub struct TokenSemicolonPtr(pub SyntaxStablePtrId);
32776impl TypedStablePtr for TokenSemicolonPtr {
32777 type SyntaxNode = TokenSemicolon;
32778 fn untyped(&self) -> SyntaxStablePtrId {
32779 self.0
32780 }
32781 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSemicolon {
32782 TokenSemicolon::from_syntax_node(db, self.0.lookup(db))
32783 }
32784}
32785impl From<TokenSemicolonPtr> for SyntaxStablePtrId {
32786 fn from(ptr: TokenSemicolonPtr) -> Self {
32787 ptr.untyped()
32788 }
32789}
32790#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32791pub struct TokenSemicolonGreen(pub GreenId);
32792impl TokenSemicolonGreen {
32793 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32794 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32795 }
32796}
32797impl TypedSyntaxNode for TokenSemicolon {
32798 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSemicolon);
32799 type StablePtr = TokenSemicolonPtr;
32800 type Green = TokenSemicolonGreen;
32801 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32802 TokenSemicolonGreen(
32803 Arc::new(GreenNode {
32804 kind: SyntaxKind::TokenMissing,
32805 details: GreenNodeDetails::Token("".into()),
32806 })
32807 .intern(db),
32808 )
32809 }
32810 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32811 match node.0.green.lookup_intern(db).details {
32812 GreenNodeDetails::Token(_) => Self { node },
32813 GreenNodeDetails::Node { .. } => {
32814 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenSemicolon)
32815 }
32816 }
32817 }
32818 fn as_syntax_node(&self) -> SyntaxNode {
32819 self.node.clone()
32820 }
32821 fn stable_ptr(&self) -> Self::StablePtr {
32822 TokenSemicolonPtr(self.node.0.stable_ptr)
32823 }
32824}
32825impl From<&TokenSemicolon> for SyntaxStablePtrId {
32826 fn from(node: &TokenSemicolon) -> Self {
32827 node.stable_ptr().untyped()
32828 }
32829}
32830#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32831pub struct TerminalSemicolon {
32832 node: SyntaxNode,
32833 children: Arc<[SyntaxNode]>,
32834}
32835impl Terminal for TerminalSemicolon {
32836 const KIND: SyntaxKind = SyntaxKind::TerminalSemicolon;
32837 type TokenType = TokenSemicolon;
32838 fn new_green(
32839 db: &dyn SyntaxGroup,
32840 leading_trivia: TriviaGreen,
32841 token: <<TerminalSemicolon as Terminal>::TokenType as TypedSyntaxNode>::Green,
32842 trailing_trivia: TriviaGreen,
32843 ) -> Self::Green {
32844 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
32845 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
32846 TerminalSemicolonGreen(
32847 Arc::new(GreenNode {
32848 kind: SyntaxKind::TerminalSemicolon,
32849 details: GreenNodeDetails::Node { children, width },
32850 })
32851 .intern(db),
32852 )
32853 }
32854 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32855 self.token(db).text(db)
32856 }
32857}
32858impl TerminalSemicolon {
32859 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32860 Trivia::from_syntax_node(db, self.children[0].clone())
32861 }
32862 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenSemicolon {
32863 TokenSemicolon::from_syntax_node(db, self.children[1].clone())
32864 }
32865 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
32866 Trivia::from_syntax_node(db, self.children[2].clone())
32867 }
32868}
32869#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32870pub struct TerminalSemicolonPtr(pub SyntaxStablePtrId);
32871impl TerminalSemicolonPtr {}
32872impl TypedStablePtr for TerminalSemicolonPtr {
32873 type SyntaxNode = TerminalSemicolon;
32874 fn untyped(&self) -> SyntaxStablePtrId {
32875 self.0
32876 }
32877 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalSemicolon {
32878 TerminalSemicolon::from_syntax_node(db, self.0.lookup(db))
32879 }
32880}
32881impl From<TerminalSemicolonPtr> for SyntaxStablePtrId {
32882 fn from(ptr: TerminalSemicolonPtr) -> Self {
32883 ptr.untyped()
32884 }
32885}
32886#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32887pub struct TerminalSemicolonGreen(pub GreenId);
32888impl TypedSyntaxNode for TerminalSemicolon {
32889 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalSemicolon);
32890 type StablePtr = TerminalSemicolonPtr;
32891 type Green = TerminalSemicolonGreen;
32892 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32893 TerminalSemicolonGreen(
32894 Arc::new(GreenNode {
32895 kind: SyntaxKind::TerminalSemicolon,
32896 details: GreenNodeDetails::Node {
32897 children: vec![
32898 Trivia::missing(db).0,
32899 TokenSemicolon::missing(db).0,
32900 Trivia::missing(db).0,
32901 ],
32902 width: TextWidth::default(),
32903 },
32904 })
32905 .intern(db),
32906 )
32907 }
32908 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32909 let kind = node.kind(db);
32910 assert_eq!(
32911 kind,
32912 SyntaxKind::TerminalSemicolon,
32913 "Unexpected SyntaxKind {:?}. Expected {:?}.",
32914 kind,
32915 SyntaxKind::TerminalSemicolon
32916 );
32917 let children = db.get_children(node.clone());
32918 Self { node, children }
32919 }
32920 fn as_syntax_node(&self) -> SyntaxNode {
32921 self.node.clone()
32922 }
32923 fn stable_ptr(&self) -> Self::StablePtr {
32924 TerminalSemicolonPtr(self.node.0.stable_ptr)
32925 }
32926}
32927impl From<&TerminalSemicolon> for SyntaxStablePtrId {
32928 fn from(node: &TerminalSemicolon) -> Self {
32929 node.stable_ptr().untyped()
32930 }
32931}
32932#[derive(Clone, Debug, Eq, Hash, PartialEq)]
32933pub struct TokenUnderscore {
32934 node: SyntaxNode,
32935}
32936impl Token for TokenUnderscore {
32937 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
32938 TokenUnderscoreGreen(
32939 Arc::new(GreenNode {
32940 kind: SyntaxKind::TokenUnderscore,
32941 details: GreenNodeDetails::Token(text),
32942 })
32943 .intern(db),
32944 )
32945 }
32946 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32947 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
32948 .clone()
32949 }
32950}
32951#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32952pub struct TokenUnderscorePtr(pub SyntaxStablePtrId);
32953impl TypedStablePtr for TokenUnderscorePtr {
32954 type SyntaxNode = TokenUnderscore;
32955 fn untyped(&self) -> SyntaxStablePtrId {
32956 self.0
32957 }
32958 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenUnderscore {
32959 TokenUnderscore::from_syntax_node(db, self.0.lookup(db))
32960 }
32961}
32962impl From<TokenUnderscorePtr> for SyntaxStablePtrId {
32963 fn from(ptr: TokenUnderscorePtr) -> Self {
32964 ptr.untyped()
32965 }
32966}
32967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
32968pub struct TokenUnderscoreGreen(pub GreenId);
32969impl TokenUnderscoreGreen {
32970 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
32971 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
32972 }
32973}
32974impl TypedSyntaxNode for TokenUnderscore {
32975 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenUnderscore);
32976 type StablePtr = TokenUnderscorePtr;
32977 type Green = TokenUnderscoreGreen;
32978 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
32979 TokenUnderscoreGreen(
32980 Arc::new(GreenNode {
32981 kind: SyntaxKind::TokenMissing,
32982 details: GreenNodeDetails::Token("".into()),
32983 })
32984 .intern(db),
32985 )
32986 }
32987 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
32988 match node.0.green.lookup_intern(db).details {
32989 GreenNodeDetails::Token(_) => Self { node },
32990 GreenNodeDetails::Node { .. } => {
32991 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenUnderscore)
32992 }
32993 }
32994 }
32995 fn as_syntax_node(&self) -> SyntaxNode {
32996 self.node.clone()
32997 }
32998 fn stable_ptr(&self) -> Self::StablePtr {
32999 TokenUnderscorePtr(self.node.0.stable_ptr)
33000 }
33001}
33002impl From<&TokenUnderscore> for SyntaxStablePtrId {
33003 fn from(node: &TokenUnderscore) -> Self {
33004 node.stable_ptr().untyped()
33005 }
33006}
33007#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33008pub struct TerminalUnderscore {
33009 node: SyntaxNode,
33010 children: Arc<[SyntaxNode]>,
33011}
33012impl Terminal for TerminalUnderscore {
33013 const KIND: SyntaxKind = SyntaxKind::TerminalUnderscore;
33014 type TokenType = TokenUnderscore;
33015 fn new_green(
33016 db: &dyn SyntaxGroup,
33017 leading_trivia: TriviaGreen,
33018 token: <<TerminalUnderscore as Terminal>::TokenType as TypedSyntaxNode>::Green,
33019 trailing_trivia: TriviaGreen,
33020 ) -> Self::Green {
33021 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33022 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33023 TerminalUnderscoreGreen(
33024 Arc::new(GreenNode {
33025 kind: SyntaxKind::TerminalUnderscore,
33026 details: GreenNodeDetails::Node { children, width },
33027 })
33028 .intern(db),
33029 )
33030 }
33031 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33032 self.token(db).text(db)
33033 }
33034}
33035impl TerminalUnderscore {
33036 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33037 Trivia::from_syntax_node(db, self.children[0].clone())
33038 }
33039 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenUnderscore {
33040 TokenUnderscore::from_syntax_node(db, self.children[1].clone())
33041 }
33042 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33043 Trivia::from_syntax_node(db, self.children[2].clone())
33044 }
33045}
33046#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33047pub struct TerminalUnderscorePtr(pub SyntaxStablePtrId);
33048impl TerminalUnderscorePtr {}
33049impl TypedStablePtr for TerminalUnderscorePtr {
33050 type SyntaxNode = TerminalUnderscore;
33051 fn untyped(&self) -> SyntaxStablePtrId {
33052 self.0
33053 }
33054 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalUnderscore {
33055 TerminalUnderscore::from_syntax_node(db, self.0.lookup(db))
33056 }
33057}
33058impl From<TerminalUnderscorePtr> for SyntaxStablePtrId {
33059 fn from(ptr: TerminalUnderscorePtr) -> Self {
33060 ptr.untyped()
33061 }
33062}
33063#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33064pub struct TerminalUnderscoreGreen(pub GreenId);
33065impl TypedSyntaxNode for TerminalUnderscore {
33066 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalUnderscore);
33067 type StablePtr = TerminalUnderscorePtr;
33068 type Green = TerminalUnderscoreGreen;
33069 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33070 TerminalUnderscoreGreen(
33071 Arc::new(GreenNode {
33072 kind: SyntaxKind::TerminalUnderscore,
33073 details: GreenNodeDetails::Node {
33074 children: vec![
33075 Trivia::missing(db).0,
33076 TokenUnderscore::missing(db).0,
33077 Trivia::missing(db).0,
33078 ],
33079 width: TextWidth::default(),
33080 },
33081 })
33082 .intern(db),
33083 )
33084 }
33085 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33086 let kind = node.kind(db);
33087 assert_eq!(
33088 kind,
33089 SyntaxKind::TerminalUnderscore,
33090 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33091 kind,
33092 SyntaxKind::TerminalUnderscore
33093 );
33094 let children = db.get_children(node.clone());
33095 Self { node, children }
33096 }
33097 fn as_syntax_node(&self) -> SyntaxNode {
33098 self.node.clone()
33099 }
33100 fn stable_ptr(&self) -> Self::StablePtr {
33101 TerminalUnderscorePtr(self.node.0.stable_ptr)
33102 }
33103}
33104impl From<&TerminalUnderscore> for SyntaxStablePtrId {
33105 fn from(node: &TerminalUnderscore) -> Self {
33106 node.stable_ptr().untyped()
33107 }
33108}
33109#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33110pub struct TokenXor {
33111 node: SyntaxNode,
33112}
33113impl Token for TokenXor {
33114 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33115 TokenXorGreen(
33116 Arc::new(GreenNode {
33117 kind: SyntaxKind::TokenXor,
33118 details: GreenNodeDetails::Token(text),
33119 })
33120 .intern(db),
33121 )
33122 }
33123 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33124 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33125 .clone()
33126 }
33127}
33128#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33129pub struct TokenXorPtr(pub SyntaxStablePtrId);
33130impl TypedStablePtr for TokenXorPtr {
33131 type SyntaxNode = TokenXor;
33132 fn untyped(&self) -> SyntaxStablePtrId {
33133 self.0
33134 }
33135 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenXor {
33136 TokenXor::from_syntax_node(db, self.0.lookup(db))
33137 }
33138}
33139impl From<TokenXorPtr> for SyntaxStablePtrId {
33140 fn from(ptr: TokenXorPtr) -> Self {
33141 ptr.untyped()
33142 }
33143}
33144#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33145pub struct TokenXorGreen(pub GreenId);
33146impl TokenXorGreen {
33147 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33148 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33149 }
33150}
33151impl TypedSyntaxNode for TokenXor {
33152 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenXor);
33153 type StablePtr = TokenXorPtr;
33154 type Green = TokenXorGreen;
33155 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33156 TokenXorGreen(
33157 Arc::new(GreenNode {
33158 kind: SyntaxKind::TokenMissing,
33159 details: GreenNodeDetails::Token("".into()),
33160 })
33161 .intern(db),
33162 )
33163 }
33164 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33165 match node.0.green.lookup_intern(db).details {
33166 GreenNodeDetails::Token(_) => Self { node },
33167 GreenNodeDetails::Node { .. } => {
33168 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenXor)
33169 }
33170 }
33171 }
33172 fn as_syntax_node(&self) -> SyntaxNode {
33173 self.node.clone()
33174 }
33175 fn stable_ptr(&self) -> Self::StablePtr {
33176 TokenXorPtr(self.node.0.stable_ptr)
33177 }
33178}
33179impl From<&TokenXor> for SyntaxStablePtrId {
33180 fn from(node: &TokenXor) -> Self {
33181 node.stable_ptr().untyped()
33182 }
33183}
33184#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33185pub struct TerminalXor {
33186 node: SyntaxNode,
33187 children: Arc<[SyntaxNode]>,
33188}
33189impl Terminal for TerminalXor {
33190 const KIND: SyntaxKind = SyntaxKind::TerminalXor;
33191 type TokenType = TokenXor;
33192 fn new_green(
33193 db: &dyn SyntaxGroup,
33194 leading_trivia: TriviaGreen,
33195 token: <<TerminalXor as Terminal>::TokenType as TypedSyntaxNode>::Green,
33196 trailing_trivia: TriviaGreen,
33197 ) -> Self::Green {
33198 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33199 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33200 TerminalXorGreen(
33201 Arc::new(GreenNode {
33202 kind: SyntaxKind::TerminalXor,
33203 details: GreenNodeDetails::Node { children, width },
33204 })
33205 .intern(db),
33206 )
33207 }
33208 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33209 self.token(db).text(db)
33210 }
33211}
33212impl TerminalXor {
33213 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33214 Trivia::from_syntax_node(db, self.children[0].clone())
33215 }
33216 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenXor {
33217 TokenXor::from_syntax_node(db, self.children[1].clone())
33218 }
33219 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33220 Trivia::from_syntax_node(db, self.children[2].clone())
33221 }
33222}
33223#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33224pub struct TerminalXorPtr(pub SyntaxStablePtrId);
33225impl TerminalXorPtr {}
33226impl TypedStablePtr for TerminalXorPtr {
33227 type SyntaxNode = TerminalXor;
33228 fn untyped(&self) -> SyntaxStablePtrId {
33229 self.0
33230 }
33231 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalXor {
33232 TerminalXor::from_syntax_node(db, self.0.lookup(db))
33233 }
33234}
33235impl From<TerminalXorPtr> for SyntaxStablePtrId {
33236 fn from(ptr: TerminalXorPtr) -> Self {
33237 ptr.untyped()
33238 }
33239}
33240#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33241pub struct TerminalXorGreen(pub GreenId);
33242impl TypedSyntaxNode for TerminalXor {
33243 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalXor);
33244 type StablePtr = TerminalXorPtr;
33245 type Green = TerminalXorGreen;
33246 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33247 TerminalXorGreen(
33248 Arc::new(GreenNode {
33249 kind: SyntaxKind::TerminalXor,
33250 details: GreenNodeDetails::Node {
33251 children: vec![
33252 Trivia::missing(db).0,
33253 TokenXor::missing(db).0,
33254 Trivia::missing(db).0,
33255 ],
33256 width: TextWidth::default(),
33257 },
33258 })
33259 .intern(db),
33260 )
33261 }
33262 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33263 let kind = node.kind(db);
33264 assert_eq!(
33265 kind,
33266 SyntaxKind::TerminalXor,
33267 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33268 kind,
33269 SyntaxKind::TerminalXor
33270 );
33271 let children = db.get_children(node.clone());
33272 Self { node, children }
33273 }
33274 fn as_syntax_node(&self) -> SyntaxNode {
33275 self.node.clone()
33276 }
33277 fn stable_ptr(&self) -> Self::StablePtr {
33278 TerminalXorPtr(self.node.0.stable_ptr)
33279 }
33280}
33281impl From<&TerminalXor> for SyntaxStablePtrId {
33282 fn from(node: &TerminalXor) -> Self {
33283 node.stable_ptr().untyped()
33284 }
33285}
33286#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33287pub struct SyntaxFile {
33288 node: SyntaxNode,
33289 children: Arc<[SyntaxNode]>,
33290}
33291impl SyntaxFile {
33292 pub const INDEX_ITEMS: usize = 0;
33293 pub const INDEX_EOF: usize = 1;
33294 pub fn new_green(
33295 db: &dyn SyntaxGroup,
33296 items: ModuleItemListGreen,
33297 eof: TerminalEndOfFileGreen,
33298 ) -> SyntaxFileGreen {
33299 let children: Vec<GreenId> = vec![items.0, eof.0];
33300 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33301 SyntaxFileGreen(
33302 Arc::new(GreenNode {
33303 kind: SyntaxKind::SyntaxFile,
33304 details: GreenNodeDetails::Node { children, width },
33305 })
33306 .intern(db),
33307 )
33308 }
33309}
33310impl SyntaxFile {
33311 pub fn items(&self, db: &dyn SyntaxGroup) -> ModuleItemList {
33312 ModuleItemList::from_syntax_node(db, self.children[0].clone())
33313 }
33314 pub fn eof(&self, db: &dyn SyntaxGroup) -> TerminalEndOfFile {
33315 TerminalEndOfFile::from_syntax_node(db, self.children[1].clone())
33316 }
33317}
33318#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33319pub struct SyntaxFilePtr(pub SyntaxStablePtrId);
33320impl SyntaxFilePtr {}
33321impl TypedStablePtr for SyntaxFilePtr {
33322 type SyntaxNode = SyntaxFile;
33323 fn untyped(&self) -> SyntaxStablePtrId {
33324 self.0
33325 }
33326 fn lookup(&self, db: &dyn SyntaxGroup) -> SyntaxFile {
33327 SyntaxFile::from_syntax_node(db, self.0.lookup(db))
33328 }
33329}
33330impl From<SyntaxFilePtr> for SyntaxStablePtrId {
33331 fn from(ptr: SyntaxFilePtr) -> Self {
33332 ptr.untyped()
33333 }
33334}
33335#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33336pub struct SyntaxFileGreen(pub GreenId);
33337impl TypedSyntaxNode for SyntaxFile {
33338 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::SyntaxFile);
33339 type StablePtr = SyntaxFilePtr;
33340 type Green = SyntaxFileGreen;
33341 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33342 SyntaxFileGreen(
33343 Arc::new(GreenNode {
33344 kind: SyntaxKind::SyntaxFile,
33345 details: GreenNodeDetails::Node {
33346 children: vec![ModuleItemList::missing(db).0, TerminalEndOfFile::missing(db).0],
33347 width: TextWidth::default(),
33348 },
33349 })
33350 .intern(db),
33351 )
33352 }
33353 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33354 let kind = node.kind(db);
33355 assert_eq!(
33356 kind,
33357 SyntaxKind::SyntaxFile,
33358 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33359 kind,
33360 SyntaxKind::SyntaxFile
33361 );
33362 let children = db.get_children(node.clone());
33363 Self { node, children }
33364 }
33365 fn as_syntax_node(&self) -> SyntaxNode {
33366 self.node.clone()
33367 }
33368 fn stable_ptr(&self) -> Self::StablePtr {
33369 SyntaxFilePtr(self.node.0.stable_ptr)
33370 }
33371}
33372impl From<&SyntaxFile> for SyntaxStablePtrId {
33373 fn from(node: &SyntaxFile) -> Self {
33374 node.stable_ptr().untyped()
33375 }
33376}
33377#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33378pub struct TokenEmpty {
33379 node: SyntaxNode,
33380}
33381impl Token for TokenEmpty {
33382 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33383 TokenEmptyGreen(
33384 Arc::new(GreenNode {
33385 kind: SyntaxKind::TokenEmpty,
33386 details: GreenNodeDetails::Token(text),
33387 })
33388 .intern(db),
33389 )
33390 }
33391 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33392 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33393 .clone()
33394 }
33395}
33396#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33397pub struct TokenEmptyPtr(pub SyntaxStablePtrId);
33398impl TypedStablePtr for TokenEmptyPtr {
33399 type SyntaxNode = TokenEmpty;
33400 fn untyped(&self) -> SyntaxStablePtrId {
33401 self.0
33402 }
33403 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenEmpty {
33404 TokenEmpty::from_syntax_node(db, self.0.lookup(db))
33405 }
33406}
33407impl From<TokenEmptyPtr> for SyntaxStablePtrId {
33408 fn from(ptr: TokenEmptyPtr) -> Self {
33409 ptr.untyped()
33410 }
33411}
33412#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33413pub struct TokenEmptyGreen(pub GreenId);
33414impl TokenEmptyGreen {
33415 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33416 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33417 }
33418}
33419impl TypedSyntaxNode for TokenEmpty {
33420 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenEmpty);
33421 type StablePtr = TokenEmptyPtr;
33422 type Green = TokenEmptyGreen;
33423 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33424 TokenEmptyGreen(
33425 Arc::new(GreenNode {
33426 kind: SyntaxKind::TokenMissing,
33427 details: GreenNodeDetails::Token("".into()),
33428 })
33429 .intern(db),
33430 )
33431 }
33432 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33433 match node.0.green.lookup_intern(db).details {
33434 GreenNodeDetails::Token(_) => Self { node },
33435 GreenNodeDetails::Node { .. } => {
33436 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenEmpty)
33437 }
33438 }
33439 }
33440 fn as_syntax_node(&self) -> SyntaxNode {
33441 self.node.clone()
33442 }
33443 fn stable_ptr(&self) -> Self::StablePtr {
33444 TokenEmptyPtr(self.node.0.stable_ptr)
33445 }
33446}
33447impl From<&TokenEmpty> for SyntaxStablePtrId {
33448 fn from(node: &TokenEmpty) -> Self {
33449 node.stable_ptr().untyped()
33450 }
33451}
33452#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33453pub struct TerminalEmpty {
33454 node: SyntaxNode,
33455 children: Arc<[SyntaxNode]>,
33456}
33457impl Terminal for TerminalEmpty {
33458 const KIND: SyntaxKind = SyntaxKind::TerminalEmpty;
33459 type TokenType = TokenEmpty;
33460 fn new_green(
33461 db: &dyn SyntaxGroup,
33462 leading_trivia: TriviaGreen,
33463 token: <<TerminalEmpty as Terminal>::TokenType as TypedSyntaxNode>::Green,
33464 trailing_trivia: TriviaGreen,
33465 ) -> Self::Green {
33466 let children: Vec<GreenId> = vec![leading_trivia.0, token.0, trailing_trivia.0];
33467 let width = children.iter().copied().map(|id| id.lookup_intern(db).width()).sum();
33468 TerminalEmptyGreen(
33469 Arc::new(GreenNode {
33470 kind: SyntaxKind::TerminalEmpty,
33471 details: GreenNodeDetails::Node { children, width },
33472 })
33473 .intern(db),
33474 )
33475 }
33476 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33477 self.token(db).text(db)
33478 }
33479}
33480impl TerminalEmpty {
33481 pub fn leading_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33482 Trivia::from_syntax_node(db, self.children[0].clone())
33483 }
33484 pub fn token(&self, db: &dyn SyntaxGroup) -> TokenEmpty {
33485 TokenEmpty::from_syntax_node(db, self.children[1].clone())
33486 }
33487 pub fn trailing_trivia(&self, db: &dyn SyntaxGroup) -> Trivia {
33488 Trivia::from_syntax_node(db, self.children[2].clone())
33489 }
33490}
33491#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33492pub struct TerminalEmptyPtr(pub SyntaxStablePtrId);
33493impl TerminalEmptyPtr {}
33494impl TypedStablePtr for TerminalEmptyPtr {
33495 type SyntaxNode = TerminalEmpty;
33496 fn untyped(&self) -> SyntaxStablePtrId {
33497 self.0
33498 }
33499 fn lookup(&self, db: &dyn SyntaxGroup) -> TerminalEmpty {
33500 TerminalEmpty::from_syntax_node(db, self.0.lookup(db))
33501 }
33502}
33503impl From<TerminalEmptyPtr> for SyntaxStablePtrId {
33504 fn from(ptr: TerminalEmptyPtr) -> Self {
33505 ptr.untyped()
33506 }
33507}
33508#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33509pub struct TerminalEmptyGreen(pub GreenId);
33510impl TypedSyntaxNode for TerminalEmpty {
33511 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TerminalEmpty);
33512 type StablePtr = TerminalEmptyPtr;
33513 type Green = TerminalEmptyGreen;
33514 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33515 TerminalEmptyGreen(
33516 Arc::new(GreenNode {
33517 kind: SyntaxKind::TerminalEmpty,
33518 details: GreenNodeDetails::Node {
33519 children: vec![
33520 Trivia::missing(db).0,
33521 TokenEmpty::missing(db).0,
33522 Trivia::missing(db).0,
33523 ],
33524 width: TextWidth::default(),
33525 },
33526 })
33527 .intern(db),
33528 )
33529 }
33530 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33531 let kind = node.kind(db);
33532 assert_eq!(
33533 kind,
33534 SyntaxKind::TerminalEmpty,
33535 "Unexpected SyntaxKind {:?}. Expected {:?}.",
33536 kind,
33537 SyntaxKind::TerminalEmpty
33538 );
33539 let children = db.get_children(node.clone());
33540 Self { node, children }
33541 }
33542 fn as_syntax_node(&self) -> SyntaxNode {
33543 self.node.clone()
33544 }
33545 fn stable_ptr(&self) -> Self::StablePtr {
33546 TerminalEmptyPtr(self.node.0.stable_ptr)
33547 }
33548}
33549impl From<&TerminalEmpty> for SyntaxStablePtrId {
33550 fn from(node: &TerminalEmpty) -> Self {
33551 node.stable_ptr().untyped()
33552 }
33553}
33554#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33555pub struct TokenSingleLineComment {
33556 node: SyntaxNode,
33557}
33558impl Token for TokenSingleLineComment {
33559 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33560 TokenSingleLineCommentGreen(
33561 Arc::new(GreenNode {
33562 kind: SyntaxKind::TokenSingleLineComment,
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 TokenSingleLineCommentPtr(pub SyntaxStablePtrId);
33575impl TypedStablePtr for TokenSingleLineCommentPtr {
33576 type SyntaxNode = TokenSingleLineComment;
33577 fn untyped(&self) -> SyntaxStablePtrId {
33578 self.0
33579 }
33580 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineComment {
33581 TokenSingleLineComment::from_syntax_node(db, self.0.lookup(db))
33582 }
33583}
33584impl From<TokenSingleLineCommentPtr> for SyntaxStablePtrId {
33585 fn from(ptr: TokenSingleLineCommentPtr) -> Self {
33586 ptr.untyped()
33587 }
33588}
33589#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33590pub struct TokenSingleLineCommentGreen(pub GreenId);
33591impl TokenSingleLineCommentGreen {
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 TokenSingleLineComment {
33597 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineComment);
33598 type StablePtr = TokenSingleLineCommentPtr;
33599 type Green = TokenSingleLineCommentGreen;
33600 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33601 TokenSingleLineCommentGreen(
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 { .. } => panic!(
33613 "Expected a token {:?}, not an internal node",
33614 SyntaxKind::TokenSingleLineComment
33615 ),
33616 }
33617 }
33618 fn as_syntax_node(&self) -> SyntaxNode {
33619 self.node.clone()
33620 }
33621 fn stable_ptr(&self) -> Self::StablePtr {
33622 TokenSingleLineCommentPtr(self.node.0.stable_ptr)
33623 }
33624}
33625impl From<&TokenSingleLineComment> for SyntaxStablePtrId {
33626 fn from(node: &TokenSingleLineComment) -> Self {
33627 node.stable_ptr().untyped()
33628 }
33629}
33630#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33631pub struct TokenSingleLineInnerComment {
33632 node: SyntaxNode,
33633}
33634impl Token for TokenSingleLineInnerComment {
33635 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33636 TokenSingleLineInnerCommentGreen(
33637 Arc::new(GreenNode {
33638 kind: SyntaxKind::TokenSingleLineInnerComment,
33639 details: GreenNodeDetails::Token(text),
33640 })
33641 .intern(db),
33642 )
33643 }
33644 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33645 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33646 .clone()
33647 }
33648}
33649#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33650pub struct TokenSingleLineInnerCommentPtr(pub SyntaxStablePtrId);
33651impl TypedStablePtr for TokenSingleLineInnerCommentPtr {
33652 type SyntaxNode = TokenSingleLineInnerComment;
33653 fn untyped(&self) -> SyntaxStablePtrId {
33654 self.0
33655 }
33656 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineInnerComment {
33657 TokenSingleLineInnerComment::from_syntax_node(db, self.0.lookup(db))
33658 }
33659}
33660impl From<TokenSingleLineInnerCommentPtr> for SyntaxStablePtrId {
33661 fn from(ptr: TokenSingleLineInnerCommentPtr) -> Self {
33662 ptr.untyped()
33663 }
33664}
33665#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33666pub struct TokenSingleLineInnerCommentGreen(pub GreenId);
33667impl TokenSingleLineInnerCommentGreen {
33668 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33669 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33670 }
33671}
33672impl TypedSyntaxNode for TokenSingleLineInnerComment {
33673 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineInnerComment);
33674 type StablePtr = TokenSingleLineInnerCommentPtr;
33675 type Green = TokenSingleLineInnerCommentGreen;
33676 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33677 TokenSingleLineInnerCommentGreen(
33678 Arc::new(GreenNode {
33679 kind: SyntaxKind::TokenMissing,
33680 details: GreenNodeDetails::Token("".into()),
33681 })
33682 .intern(db),
33683 )
33684 }
33685 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33686 match node.0.green.lookup_intern(db).details {
33687 GreenNodeDetails::Token(_) => Self { node },
33688 GreenNodeDetails::Node { .. } => panic!(
33689 "Expected a token {:?}, not an internal node",
33690 SyntaxKind::TokenSingleLineInnerComment
33691 ),
33692 }
33693 }
33694 fn as_syntax_node(&self) -> SyntaxNode {
33695 self.node.clone()
33696 }
33697 fn stable_ptr(&self) -> Self::StablePtr {
33698 TokenSingleLineInnerCommentPtr(self.node.0.stable_ptr)
33699 }
33700}
33701impl From<&TokenSingleLineInnerComment> for SyntaxStablePtrId {
33702 fn from(node: &TokenSingleLineInnerComment) -> Self {
33703 node.stable_ptr().untyped()
33704 }
33705}
33706#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33707pub struct TokenSingleLineDocComment {
33708 node: SyntaxNode,
33709}
33710impl Token for TokenSingleLineDocComment {
33711 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33712 TokenSingleLineDocCommentGreen(
33713 Arc::new(GreenNode {
33714 kind: SyntaxKind::TokenSingleLineDocComment,
33715 details: GreenNodeDetails::Token(text),
33716 })
33717 .intern(db),
33718 )
33719 }
33720 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33721 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33722 .clone()
33723 }
33724}
33725#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33726pub struct TokenSingleLineDocCommentPtr(pub SyntaxStablePtrId);
33727impl TypedStablePtr for TokenSingleLineDocCommentPtr {
33728 type SyntaxNode = TokenSingleLineDocComment;
33729 fn untyped(&self) -> SyntaxStablePtrId {
33730 self.0
33731 }
33732 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSingleLineDocComment {
33733 TokenSingleLineDocComment::from_syntax_node(db, self.0.lookup(db))
33734 }
33735}
33736impl From<TokenSingleLineDocCommentPtr> for SyntaxStablePtrId {
33737 fn from(ptr: TokenSingleLineDocCommentPtr) -> Self {
33738 ptr.untyped()
33739 }
33740}
33741#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33742pub struct TokenSingleLineDocCommentGreen(pub GreenId);
33743impl TokenSingleLineDocCommentGreen {
33744 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33745 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33746 }
33747}
33748impl TypedSyntaxNode for TokenSingleLineDocComment {
33749 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSingleLineDocComment);
33750 type StablePtr = TokenSingleLineDocCommentPtr;
33751 type Green = TokenSingleLineDocCommentGreen;
33752 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33753 TokenSingleLineDocCommentGreen(
33754 Arc::new(GreenNode {
33755 kind: SyntaxKind::TokenMissing,
33756 details: GreenNodeDetails::Token("".into()),
33757 })
33758 .intern(db),
33759 )
33760 }
33761 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33762 match node.0.green.lookup_intern(db).details {
33763 GreenNodeDetails::Token(_) => Self { node },
33764 GreenNodeDetails::Node { .. } => panic!(
33765 "Expected a token {:?}, not an internal node",
33766 SyntaxKind::TokenSingleLineDocComment
33767 ),
33768 }
33769 }
33770 fn as_syntax_node(&self) -> SyntaxNode {
33771 self.node.clone()
33772 }
33773 fn stable_ptr(&self) -> Self::StablePtr {
33774 TokenSingleLineDocCommentPtr(self.node.0.stable_ptr)
33775 }
33776}
33777impl From<&TokenSingleLineDocComment> for SyntaxStablePtrId {
33778 fn from(node: &TokenSingleLineDocComment) -> Self {
33779 node.stable_ptr().untyped()
33780 }
33781}
33782#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33783pub struct TokenWhitespace {
33784 node: SyntaxNode,
33785}
33786impl Token for TokenWhitespace {
33787 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33788 TokenWhitespaceGreen(
33789 Arc::new(GreenNode {
33790 kind: SyntaxKind::TokenWhitespace,
33791 details: GreenNodeDetails::Token(text),
33792 })
33793 .intern(db),
33794 )
33795 }
33796 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33797 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33798 .clone()
33799 }
33800}
33801#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33802pub struct TokenWhitespacePtr(pub SyntaxStablePtrId);
33803impl TypedStablePtr for TokenWhitespacePtr {
33804 type SyntaxNode = TokenWhitespace;
33805 fn untyped(&self) -> SyntaxStablePtrId {
33806 self.0
33807 }
33808 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenWhitespace {
33809 TokenWhitespace::from_syntax_node(db, self.0.lookup(db))
33810 }
33811}
33812impl From<TokenWhitespacePtr> for SyntaxStablePtrId {
33813 fn from(ptr: TokenWhitespacePtr) -> Self {
33814 ptr.untyped()
33815 }
33816}
33817#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33818pub struct TokenWhitespaceGreen(pub GreenId);
33819impl TokenWhitespaceGreen {
33820 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33821 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33822 }
33823}
33824impl TypedSyntaxNode for TokenWhitespace {
33825 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenWhitespace);
33826 type StablePtr = TokenWhitespacePtr;
33827 type Green = TokenWhitespaceGreen;
33828 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33829 TokenWhitespaceGreen(
33830 Arc::new(GreenNode {
33831 kind: SyntaxKind::TokenMissing,
33832 details: GreenNodeDetails::Token("".into()),
33833 })
33834 .intern(db),
33835 )
33836 }
33837 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33838 match node.0.green.lookup_intern(db).details {
33839 GreenNodeDetails::Token(_) => Self { node },
33840 GreenNodeDetails::Node { .. } => {
33841 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenWhitespace)
33842 }
33843 }
33844 }
33845 fn as_syntax_node(&self) -> SyntaxNode {
33846 self.node.clone()
33847 }
33848 fn stable_ptr(&self) -> Self::StablePtr {
33849 TokenWhitespacePtr(self.node.0.stable_ptr)
33850 }
33851}
33852impl From<&TokenWhitespace> for SyntaxStablePtrId {
33853 fn from(node: &TokenWhitespace) -> Self {
33854 node.stable_ptr().untyped()
33855 }
33856}
33857#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33858pub struct TokenNewline {
33859 node: SyntaxNode,
33860}
33861impl Token for TokenNewline {
33862 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33863 TokenNewlineGreen(
33864 Arc::new(GreenNode {
33865 kind: SyntaxKind::TokenNewline,
33866 details: GreenNodeDetails::Token(text),
33867 })
33868 .intern(db),
33869 )
33870 }
33871 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33872 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
33873 .clone()
33874 }
33875}
33876#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33877pub struct TokenNewlinePtr(pub SyntaxStablePtrId);
33878impl TypedStablePtr for TokenNewlinePtr {
33879 type SyntaxNode = TokenNewline;
33880 fn untyped(&self) -> SyntaxStablePtrId {
33881 self.0
33882 }
33883 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNewline {
33884 TokenNewline::from_syntax_node(db, self.0.lookup(db))
33885 }
33886}
33887impl From<TokenNewlinePtr> for SyntaxStablePtrId {
33888 fn from(ptr: TokenNewlinePtr) -> Self {
33889 ptr.untyped()
33890 }
33891}
33892#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33893pub struct TokenNewlineGreen(pub GreenId);
33894impl TokenNewlineGreen {
33895 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
33896 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
33897 }
33898}
33899impl TypedSyntaxNode for TokenNewline {
33900 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenNewline);
33901 type StablePtr = TokenNewlinePtr;
33902 type Green = TokenNewlineGreen;
33903 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33904 TokenNewlineGreen(
33905 Arc::new(GreenNode {
33906 kind: SyntaxKind::TokenMissing,
33907 details: GreenNodeDetails::Token("".into()),
33908 })
33909 .intern(db),
33910 )
33911 }
33912 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
33913 match node.0.green.lookup_intern(db).details {
33914 GreenNodeDetails::Token(_) => Self { node },
33915 GreenNodeDetails::Node { .. } => {
33916 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenNewline)
33917 }
33918 }
33919 }
33920 fn as_syntax_node(&self) -> SyntaxNode {
33921 self.node.clone()
33922 }
33923 fn stable_ptr(&self) -> Self::StablePtr {
33924 TokenNewlinePtr(self.node.0.stable_ptr)
33925 }
33926}
33927impl From<&TokenNewline> for SyntaxStablePtrId {
33928 fn from(node: &TokenNewline) -> Self {
33929 node.stable_ptr().untyped()
33930 }
33931}
33932#[derive(Clone, Debug, Eq, Hash, PartialEq)]
33933pub struct TokenMissing {
33934 node: SyntaxNode,
33935}
33936impl Token for TokenMissing {
33937 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
33938 TokenMissingGreen(
33939 Arc::new(GreenNode {
33940 kind: SyntaxKind::TokenMissing,
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 TokenMissingPtr(pub SyntaxStablePtrId);
33953impl TypedStablePtr for TokenMissingPtr {
33954 type SyntaxNode = TokenMissing;
33955 fn untyped(&self) -> SyntaxStablePtrId {
33956 self.0
33957 }
33958 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenMissing {
33959 TokenMissing::from_syntax_node(db, self.0.lookup(db))
33960 }
33961}
33962impl From<TokenMissingPtr> for SyntaxStablePtrId {
33963 fn from(ptr: TokenMissingPtr) -> Self {
33964 ptr.untyped()
33965 }
33966}
33967#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
33968pub struct TokenMissingGreen(pub GreenId);
33969impl TokenMissingGreen {
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 TokenMissing {
33975 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenMissing);
33976 type StablePtr = TokenMissingPtr;
33977 type Green = TokenMissingGreen;
33978 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
33979 TokenMissingGreen(
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::TokenMissing)
33992 }
33993 }
33994 }
33995 fn as_syntax_node(&self) -> SyntaxNode {
33996 self.node.clone()
33997 }
33998 fn stable_ptr(&self) -> Self::StablePtr {
33999 TokenMissingPtr(self.node.0.stable_ptr)
34000 }
34001}
34002impl From<&TokenMissing> for SyntaxStablePtrId {
34003 fn from(node: &TokenMissing) -> Self {
34004 node.stable_ptr().untyped()
34005 }
34006}
34007#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34008pub struct TokenSkipped {
34009 node: SyntaxNode,
34010}
34011impl Token for TokenSkipped {
34012 fn new_green(db: &dyn SyntaxGroup, text: SmolStr) -> Self::Green {
34013 TokenSkippedGreen(
34014 Arc::new(GreenNode {
34015 kind: SyntaxKind::TokenSkipped,
34016 details: GreenNodeDetails::Token(text),
34017 })
34018 .intern(db),
34019 )
34020 }
34021 fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34022 extract_matches!(&self.node.0.green.lookup_intern(db).details, GreenNodeDetails::Token)
34023 .clone()
34024 }
34025}
34026#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34027pub struct TokenSkippedPtr(pub SyntaxStablePtrId);
34028impl TypedStablePtr for TokenSkippedPtr {
34029 type SyntaxNode = TokenSkipped;
34030 fn untyped(&self) -> SyntaxStablePtrId {
34031 self.0
34032 }
34033 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenSkipped {
34034 TokenSkipped::from_syntax_node(db, self.0.lookup(db))
34035 }
34036}
34037impl From<TokenSkippedPtr> for SyntaxStablePtrId {
34038 fn from(ptr: TokenSkippedPtr) -> Self {
34039 ptr.untyped()
34040 }
34041}
34042#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34043pub struct TokenSkippedGreen(pub GreenId);
34044impl TokenSkippedGreen {
34045 pub fn text(&self, db: &dyn SyntaxGroup) -> SmolStr {
34046 extract_matches!(&self.0.lookup_intern(db).details, GreenNodeDetails::Token).clone()
34047 }
34048}
34049impl TypedSyntaxNode for TokenSkipped {
34050 const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::TokenSkipped);
34051 type StablePtr = TokenSkippedPtr;
34052 type Green = TokenSkippedGreen;
34053 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34054 TokenSkippedGreen(
34055 Arc::new(GreenNode {
34056 kind: SyntaxKind::TokenMissing,
34057 details: GreenNodeDetails::Token("".into()),
34058 })
34059 .intern(db),
34060 )
34061 }
34062 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34063 match node.0.green.lookup_intern(db).details {
34064 GreenNodeDetails::Token(_) => Self { node },
34065 GreenNodeDetails::Node { .. } => {
34066 panic!("Expected a token {:?}, not an internal node", SyntaxKind::TokenSkipped)
34067 }
34068 }
34069 }
34070 fn as_syntax_node(&self) -> SyntaxNode {
34071 self.node.clone()
34072 }
34073 fn stable_ptr(&self) -> Self::StablePtr {
34074 TokenSkippedPtr(self.node.0.stable_ptr)
34075 }
34076}
34077impl From<&TokenSkipped> for SyntaxStablePtrId {
34078 fn from(node: &TokenSkipped) -> Self {
34079 node.stable_ptr().untyped()
34080 }
34081}
34082#[derive(Clone, Debug, Eq, Hash, PartialEq)]
34083pub enum TokenNode {
34084 TerminalIdentifier(TerminalIdentifier),
34085 TerminalLiteralNumber(TerminalLiteralNumber),
34086 TerminalShortString(TerminalShortString),
34087 TerminalString(TerminalString),
34088 TerminalAs(TerminalAs),
34089 TerminalConst(TerminalConst),
34090 TerminalElse(TerminalElse),
34091 TerminalEnum(TerminalEnum),
34092 TerminalExtern(TerminalExtern),
34093 TerminalFalse(TerminalFalse),
34094 TerminalFunction(TerminalFunction),
34095 TerminalIf(TerminalIf),
34096 TerminalWhile(TerminalWhile),
34097 TerminalFor(TerminalFor),
34098 TerminalLoop(TerminalLoop),
34099 TerminalImpl(TerminalImpl),
34100 TerminalImplicits(TerminalImplicits),
34101 TerminalLet(TerminalLet),
34102 TerminalMatch(TerminalMatch),
34103 TerminalModule(TerminalModule),
34104 TerminalMut(TerminalMut),
34105 TerminalNoPanic(TerminalNoPanic),
34106 TerminalOf(TerminalOf),
34107 TerminalRef(TerminalRef),
34108 TerminalContinue(TerminalContinue),
34109 TerminalReturn(TerminalReturn),
34110 TerminalBreak(TerminalBreak),
34111 TerminalStruct(TerminalStruct),
34112 TerminalTrait(TerminalTrait),
34113 TerminalTrue(TerminalTrue),
34114 TerminalType(TerminalType),
34115 TerminalUse(TerminalUse),
34116 TerminalPub(TerminalPub),
34117 TerminalAnd(TerminalAnd),
34118 TerminalAndAnd(TerminalAndAnd),
34119 TerminalArrow(TerminalArrow),
34120 TerminalAt(TerminalAt),
34121 TerminalBadCharacters(TerminalBadCharacters),
34122 TerminalColon(TerminalColon),
34123 TerminalColonColon(TerminalColonColon),
34124 TerminalComma(TerminalComma),
34125 TerminalDiv(TerminalDiv),
34126 TerminalDivEq(TerminalDivEq),
34127 TerminalDot(TerminalDot),
34128 TerminalDotDot(TerminalDotDot),
34129 TerminalEndOfFile(TerminalEndOfFile),
34130 TerminalEq(TerminalEq),
34131 TerminalEqEq(TerminalEqEq),
34132 TerminalGE(TerminalGE),
34133 TerminalGT(TerminalGT),
34134 TerminalHash(TerminalHash),
34135 TerminalLBrace(TerminalLBrace),
34136 TerminalLBrack(TerminalLBrack),
34137 TerminalLE(TerminalLE),
34138 TerminalLParen(TerminalLParen),
34139 TerminalLT(TerminalLT),
34140 TerminalMatchArrow(TerminalMatchArrow),
34141 TerminalMinus(TerminalMinus),
34142 TerminalMinusEq(TerminalMinusEq),
34143 TerminalMod(TerminalMod),
34144 TerminalModEq(TerminalModEq),
34145 TerminalMul(TerminalMul),
34146 TerminalMulEq(TerminalMulEq),
34147 TerminalNeq(TerminalNeq),
34148 TerminalNot(TerminalNot),
34149 TerminalBitNot(TerminalBitNot),
34150 TerminalOr(TerminalOr),
34151 TerminalOrOr(TerminalOrOr),
34152 TerminalPlus(TerminalPlus),
34153 TerminalPlusEq(TerminalPlusEq),
34154 TerminalQuestionMark(TerminalQuestionMark),
34155 TerminalRBrace(TerminalRBrace),
34156 TerminalRBrack(TerminalRBrack),
34157 TerminalRParen(TerminalRParen),
34158 TerminalSemicolon(TerminalSemicolon),
34159 TerminalUnderscore(TerminalUnderscore),
34160 TerminalXor(TerminalXor),
34161 TerminalEmpty(TerminalEmpty),
34162}
34163#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34164pub struct TokenNodePtr(pub SyntaxStablePtrId);
34165impl TypedStablePtr for TokenNodePtr {
34166 type SyntaxNode = TokenNode;
34167 fn untyped(&self) -> SyntaxStablePtrId {
34168 self.0
34169 }
34170 fn lookup(&self, db: &dyn SyntaxGroup) -> TokenNode {
34171 TokenNode::from_syntax_node(db, self.0.lookup(db))
34172 }
34173}
34174impl From<TokenNodePtr> for SyntaxStablePtrId {
34175 fn from(ptr: TokenNodePtr) -> Self {
34176 ptr.untyped()
34177 }
34178}
34179impl From<TerminalIdentifierPtr> for TokenNodePtr {
34180 fn from(value: TerminalIdentifierPtr) -> Self {
34181 Self(value.0)
34182 }
34183}
34184impl From<TerminalLiteralNumberPtr> for TokenNodePtr {
34185 fn from(value: TerminalLiteralNumberPtr) -> Self {
34186 Self(value.0)
34187 }
34188}
34189impl From<TerminalShortStringPtr> for TokenNodePtr {
34190 fn from(value: TerminalShortStringPtr) -> Self {
34191 Self(value.0)
34192 }
34193}
34194impl From<TerminalStringPtr> for TokenNodePtr {
34195 fn from(value: TerminalStringPtr) -> Self {
34196 Self(value.0)
34197 }
34198}
34199impl From<TerminalAsPtr> for TokenNodePtr {
34200 fn from(value: TerminalAsPtr) -> Self {
34201 Self(value.0)
34202 }
34203}
34204impl From<TerminalConstPtr> for TokenNodePtr {
34205 fn from(value: TerminalConstPtr) -> Self {
34206 Self(value.0)
34207 }
34208}
34209impl From<TerminalElsePtr> for TokenNodePtr {
34210 fn from(value: TerminalElsePtr) -> Self {
34211 Self(value.0)
34212 }
34213}
34214impl From<TerminalEnumPtr> for TokenNodePtr {
34215 fn from(value: TerminalEnumPtr) -> Self {
34216 Self(value.0)
34217 }
34218}
34219impl From<TerminalExternPtr> for TokenNodePtr {
34220 fn from(value: TerminalExternPtr) -> Self {
34221 Self(value.0)
34222 }
34223}
34224impl From<TerminalFalsePtr> for TokenNodePtr {
34225 fn from(value: TerminalFalsePtr) -> Self {
34226 Self(value.0)
34227 }
34228}
34229impl From<TerminalFunctionPtr> for TokenNodePtr {
34230 fn from(value: TerminalFunctionPtr) -> Self {
34231 Self(value.0)
34232 }
34233}
34234impl From<TerminalIfPtr> for TokenNodePtr {
34235 fn from(value: TerminalIfPtr) -> Self {
34236 Self(value.0)
34237 }
34238}
34239impl From<TerminalWhilePtr> for TokenNodePtr {
34240 fn from(value: TerminalWhilePtr) -> Self {
34241 Self(value.0)
34242 }
34243}
34244impl From<TerminalForPtr> for TokenNodePtr {
34245 fn from(value: TerminalForPtr) -> Self {
34246 Self(value.0)
34247 }
34248}
34249impl From<TerminalLoopPtr> for TokenNodePtr {
34250 fn from(value: TerminalLoopPtr) -> Self {
34251 Self(value.0)
34252 }
34253}
34254impl From<TerminalImplPtr> for TokenNodePtr {
34255 fn from(value: TerminalImplPtr) -> Self {
34256 Self(value.0)
34257 }
34258}
34259impl From<TerminalImplicitsPtr> for TokenNodePtr {
34260 fn from(value: TerminalImplicitsPtr) -> Self {
34261 Self(value.0)
34262 }
34263}
34264impl From<TerminalLetPtr> for TokenNodePtr {
34265 fn from(value: TerminalLetPtr) -> Self {
34266 Self(value.0)
34267 }
34268}
34269impl From<TerminalMatchPtr> for TokenNodePtr {
34270 fn from(value: TerminalMatchPtr) -> Self {
34271 Self(value.0)
34272 }
34273}
34274impl From<TerminalModulePtr> for TokenNodePtr {
34275 fn from(value: TerminalModulePtr) -> Self {
34276 Self(value.0)
34277 }
34278}
34279impl From<TerminalMutPtr> for TokenNodePtr {
34280 fn from(value: TerminalMutPtr) -> Self {
34281 Self(value.0)
34282 }
34283}
34284impl From<TerminalNoPanicPtr> for TokenNodePtr {
34285 fn from(value: TerminalNoPanicPtr) -> Self {
34286 Self(value.0)
34287 }
34288}
34289impl From<TerminalOfPtr> for TokenNodePtr {
34290 fn from(value: TerminalOfPtr) -> Self {
34291 Self(value.0)
34292 }
34293}
34294impl From<TerminalRefPtr> for TokenNodePtr {
34295 fn from(value: TerminalRefPtr) -> Self {
34296 Self(value.0)
34297 }
34298}
34299impl From<TerminalContinuePtr> for TokenNodePtr {
34300 fn from(value: TerminalContinuePtr) -> Self {
34301 Self(value.0)
34302 }
34303}
34304impl From<TerminalReturnPtr> for TokenNodePtr {
34305 fn from(value: TerminalReturnPtr) -> Self {
34306 Self(value.0)
34307 }
34308}
34309impl From<TerminalBreakPtr> for TokenNodePtr {
34310 fn from(value: TerminalBreakPtr) -> Self {
34311 Self(value.0)
34312 }
34313}
34314impl From<TerminalStructPtr> for TokenNodePtr {
34315 fn from(value: TerminalStructPtr) -> Self {
34316 Self(value.0)
34317 }
34318}
34319impl From<TerminalTraitPtr> for TokenNodePtr {
34320 fn from(value: TerminalTraitPtr) -> Self {
34321 Self(value.0)
34322 }
34323}
34324impl From<TerminalTruePtr> for TokenNodePtr {
34325 fn from(value: TerminalTruePtr) -> Self {
34326 Self(value.0)
34327 }
34328}
34329impl From<TerminalTypePtr> for TokenNodePtr {
34330 fn from(value: TerminalTypePtr) -> Self {
34331 Self(value.0)
34332 }
34333}
34334impl From<TerminalUsePtr> for TokenNodePtr {
34335 fn from(value: TerminalUsePtr) -> Self {
34336 Self(value.0)
34337 }
34338}
34339impl From<TerminalPubPtr> for TokenNodePtr {
34340 fn from(value: TerminalPubPtr) -> Self {
34341 Self(value.0)
34342 }
34343}
34344impl From<TerminalAndPtr> for TokenNodePtr {
34345 fn from(value: TerminalAndPtr) -> Self {
34346 Self(value.0)
34347 }
34348}
34349impl From<TerminalAndAndPtr> for TokenNodePtr {
34350 fn from(value: TerminalAndAndPtr) -> Self {
34351 Self(value.0)
34352 }
34353}
34354impl From<TerminalArrowPtr> for TokenNodePtr {
34355 fn from(value: TerminalArrowPtr) -> Self {
34356 Self(value.0)
34357 }
34358}
34359impl From<TerminalAtPtr> for TokenNodePtr {
34360 fn from(value: TerminalAtPtr) -> Self {
34361 Self(value.0)
34362 }
34363}
34364impl From<TerminalBadCharactersPtr> for TokenNodePtr {
34365 fn from(value: TerminalBadCharactersPtr) -> Self {
34366 Self(value.0)
34367 }
34368}
34369impl From<TerminalColonPtr> for TokenNodePtr {
34370 fn from(value: TerminalColonPtr) -> Self {
34371 Self(value.0)
34372 }
34373}
34374impl From<TerminalColonColonPtr> for TokenNodePtr {
34375 fn from(value: TerminalColonColonPtr) -> Self {
34376 Self(value.0)
34377 }
34378}
34379impl From<TerminalCommaPtr> for TokenNodePtr {
34380 fn from(value: TerminalCommaPtr) -> Self {
34381 Self(value.0)
34382 }
34383}
34384impl From<TerminalDivPtr> for TokenNodePtr {
34385 fn from(value: TerminalDivPtr) -> Self {
34386 Self(value.0)
34387 }
34388}
34389impl From<TerminalDivEqPtr> for TokenNodePtr {
34390 fn from(value: TerminalDivEqPtr) -> Self {
34391 Self(value.0)
34392 }
34393}
34394impl From<TerminalDotPtr> for TokenNodePtr {
34395 fn from(value: TerminalDotPtr) -> Self {
34396 Self(value.0)
34397 }
34398}
34399impl From<TerminalDotDotPtr> for TokenNodePtr {
34400 fn from(value: TerminalDotDotPtr) -> Self {
34401 Self(value.0)
34402 }
34403}
34404impl From<TerminalEndOfFilePtr> for TokenNodePtr {
34405 fn from(value: TerminalEndOfFilePtr) -> Self {
34406 Self(value.0)
34407 }
34408}
34409impl From<TerminalEqPtr> for TokenNodePtr {
34410 fn from(value: TerminalEqPtr) -> Self {
34411 Self(value.0)
34412 }
34413}
34414impl From<TerminalEqEqPtr> for TokenNodePtr {
34415 fn from(value: TerminalEqEqPtr) -> Self {
34416 Self(value.0)
34417 }
34418}
34419impl From<TerminalGEPtr> for TokenNodePtr {
34420 fn from(value: TerminalGEPtr) -> Self {
34421 Self(value.0)
34422 }
34423}
34424impl From<TerminalGTPtr> for TokenNodePtr {
34425 fn from(value: TerminalGTPtr) -> Self {
34426 Self(value.0)
34427 }
34428}
34429impl From<TerminalHashPtr> for TokenNodePtr {
34430 fn from(value: TerminalHashPtr) -> Self {
34431 Self(value.0)
34432 }
34433}
34434impl From<TerminalLBracePtr> for TokenNodePtr {
34435 fn from(value: TerminalLBracePtr) -> Self {
34436 Self(value.0)
34437 }
34438}
34439impl From<TerminalLBrackPtr> for TokenNodePtr {
34440 fn from(value: TerminalLBrackPtr) -> Self {
34441 Self(value.0)
34442 }
34443}
34444impl From<TerminalLEPtr> for TokenNodePtr {
34445 fn from(value: TerminalLEPtr) -> Self {
34446 Self(value.0)
34447 }
34448}
34449impl From<TerminalLParenPtr> for TokenNodePtr {
34450 fn from(value: TerminalLParenPtr) -> Self {
34451 Self(value.0)
34452 }
34453}
34454impl From<TerminalLTPtr> for TokenNodePtr {
34455 fn from(value: TerminalLTPtr) -> Self {
34456 Self(value.0)
34457 }
34458}
34459impl From<TerminalMatchArrowPtr> for TokenNodePtr {
34460 fn from(value: TerminalMatchArrowPtr) -> Self {
34461 Self(value.0)
34462 }
34463}
34464impl From<TerminalMinusPtr> for TokenNodePtr {
34465 fn from(value: TerminalMinusPtr) -> Self {
34466 Self(value.0)
34467 }
34468}
34469impl From<TerminalMinusEqPtr> for TokenNodePtr {
34470 fn from(value: TerminalMinusEqPtr) -> Self {
34471 Self(value.0)
34472 }
34473}
34474impl From<TerminalModPtr> for TokenNodePtr {
34475 fn from(value: TerminalModPtr) -> Self {
34476 Self(value.0)
34477 }
34478}
34479impl From<TerminalModEqPtr> for TokenNodePtr {
34480 fn from(value: TerminalModEqPtr) -> Self {
34481 Self(value.0)
34482 }
34483}
34484impl From<TerminalMulPtr> for TokenNodePtr {
34485 fn from(value: TerminalMulPtr) -> Self {
34486 Self(value.0)
34487 }
34488}
34489impl From<TerminalMulEqPtr> for TokenNodePtr {
34490 fn from(value: TerminalMulEqPtr) -> Self {
34491 Self(value.0)
34492 }
34493}
34494impl From<TerminalNeqPtr> for TokenNodePtr {
34495 fn from(value: TerminalNeqPtr) -> Self {
34496 Self(value.0)
34497 }
34498}
34499impl From<TerminalNotPtr> for TokenNodePtr {
34500 fn from(value: TerminalNotPtr) -> Self {
34501 Self(value.0)
34502 }
34503}
34504impl From<TerminalBitNotPtr> for TokenNodePtr {
34505 fn from(value: TerminalBitNotPtr) -> Self {
34506 Self(value.0)
34507 }
34508}
34509impl From<TerminalOrPtr> for TokenNodePtr {
34510 fn from(value: TerminalOrPtr) -> Self {
34511 Self(value.0)
34512 }
34513}
34514impl From<TerminalOrOrPtr> for TokenNodePtr {
34515 fn from(value: TerminalOrOrPtr) -> Self {
34516 Self(value.0)
34517 }
34518}
34519impl From<TerminalPlusPtr> for TokenNodePtr {
34520 fn from(value: TerminalPlusPtr) -> Self {
34521 Self(value.0)
34522 }
34523}
34524impl From<TerminalPlusEqPtr> for TokenNodePtr {
34525 fn from(value: TerminalPlusEqPtr) -> Self {
34526 Self(value.0)
34527 }
34528}
34529impl From<TerminalQuestionMarkPtr> for TokenNodePtr {
34530 fn from(value: TerminalQuestionMarkPtr) -> Self {
34531 Self(value.0)
34532 }
34533}
34534impl From<TerminalRBracePtr> for TokenNodePtr {
34535 fn from(value: TerminalRBracePtr) -> Self {
34536 Self(value.0)
34537 }
34538}
34539impl From<TerminalRBrackPtr> for TokenNodePtr {
34540 fn from(value: TerminalRBrackPtr) -> Self {
34541 Self(value.0)
34542 }
34543}
34544impl From<TerminalRParenPtr> for TokenNodePtr {
34545 fn from(value: TerminalRParenPtr) -> Self {
34546 Self(value.0)
34547 }
34548}
34549impl From<TerminalSemicolonPtr> for TokenNodePtr {
34550 fn from(value: TerminalSemicolonPtr) -> Self {
34551 Self(value.0)
34552 }
34553}
34554impl From<TerminalUnderscorePtr> for TokenNodePtr {
34555 fn from(value: TerminalUnderscorePtr) -> Self {
34556 Self(value.0)
34557 }
34558}
34559impl From<TerminalXorPtr> for TokenNodePtr {
34560 fn from(value: TerminalXorPtr) -> Self {
34561 Self(value.0)
34562 }
34563}
34564impl From<TerminalEmptyPtr> for TokenNodePtr {
34565 fn from(value: TerminalEmptyPtr) -> Self {
34566 Self(value.0)
34567 }
34568}
34569impl From<TerminalIdentifierGreen> for TokenNodeGreen {
34570 fn from(value: TerminalIdentifierGreen) -> Self {
34571 Self(value.0)
34572 }
34573}
34574impl From<TerminalLiteralNumberGreen> for TokenNodeGreen {
34575 fn from(value: TerminalLiteralNumberGreen) -> Self {
34576 Self(value.0)
34577 }
34578}
34579impl From<TerminalShortStringGreen> for TokenNodeGreen {
34580 fn from(value: TerminalShortStringGreen) -> Self {
34581 Self(value.0)
34582 }
34583}
34584impl From<TerminalStringGreen> for TokenNodeGreen {
34585 fn from(value: TerminalStringGreen) -> Self {
34586 Self(value.0)
34587 }
34588}
34589impl From<TerminalAsGreen> for TokenNodeGreen {
34590 fn from(value: TerminalAsGreen) -> Self {
34591 Self(value.0)
34592 }
34593}
34594impl From<TerminalConstGreen> for TokenNodeGreen {
34595 fn from(value: TerminalConstGreen) -> Self {
34596 Self(value.0)
34597 }
34598}
34599impl From<TerminalElseGreen> for TokenNodeGreen {
34600 fn from(value: TerminalElseGreen) -> Self {
34601 Self(value.0)
34602 }
34603}
34604impl From<TerminalEnumGreen> for TokenNodeGreen {
34605 fn from(value: TerminalEnumGreen) -> Self {
34606 Self(value.0)
34607 }
34608}
34609impl From<TerminalExternGreen> for TokenNodeGreen {
34610 fn from(value: TerminalExternGreen) -> Self {
34611 Self(value.0)
34612 }
34613}
34614impl From<TerminalFalseGreen> for TokenNodeGreen {
34615 fn from(value: TerminalFalseGreen) -> Self {
34616 Self(value.0)
34617 }
34618}
34619impl From<TerminalFunctionGreen> for TokenNodeGreen {
34620 fn from(value: TerminalFunctionGreen) -> Self {
34621 Self(value.0)
34622 }
34623}
34624impl From<TerminalIfGreen> for TokenNodeGreen {
34625 fn from(value: TerminalIfGreen) -> Self {
34626 Self(value.0)
34627 }
34628}
34629impl From<TerminalWhileGreen> for TokenNodeGreen {
34630 fn from(value: TerminalWhileGreen) -> Self {
34631 Self(value.0)
34632 }
34633}
34634impl From<TerminalForGreen> for TokenNodeGreen {
34635 fn from(value: TerminalForGreen) -> Self {
34636 Self(value.0)
34637 }
34638}
34639impl From<TerminalLoopGreen> for TokenNodeGreen {
34640 fn from(value: TerminalLoopGreen) -> Self {
34641 Self(value.0)
34642 }
34643}
34644impl From<TerminalImplGreen> for TokenNodeGreen {
34645 fn from(value: TerminalImplGreen) -> Self {
34646 Self(value.0)
34647 }
34648}
34649impl From<TerminalImplicitsGreen> for TokenNodeGreen {
34650 fn from(value: TerminalImplicitsGreen) -> Self {
34651 Self(value.0)
34652 }
34653}
34654impl From<TerminalLetGreen> for TokenNodeGreen {
34655 fn from(value: TerminalLetGreen) -> Self {
34656 Self(value.0)
34657 }
34658}
34659impl From<TerminalMatchGreen> for TokenNodeGreen {
34660 fn from(value: TerminalMatchGreen) -> Self {
34661 Self(value.0)
34662 }
34663}
34664impl From<TerminalModuleGreen> for TokenNodeGreen {
34665 fn from(value: TerminalModuleGreen) -> Self {
34666 Self(value.0)
34667 }
34668}
34669impl From<TerminalMutGreen> for TokenNodeGreen {
34670 fn from(value: TerminalMutGreen) -> Self {
34671 Self(value.0)
34672 }
34673}
34674impl From<TerminalNoPanicGreen> for TokenNodeGreen {
34675 fn from(value: TerminalNoPanicGreen) -> Self {
34676 Self(value.0)
34677 }
34678}
34679impl From<TerminalOfGreen> for TokenNodeGreen {
34680 fn from(value: TerminalOfGreen) -> Self {
34681 Self(value.0)
34682 }
34683}
34684impl From<TerminalRefGreen> for TokenNodeGreen {
34685 fn from(value: TerminalRefGreen) -> Self {
34686 Self(value.0)
34687 }
34688}
34689impl From<TerminalContinueGreen> for TokenNodeGreen {
34690 fn from(value: TerminalContinueGreen) -> Self {
34691 Self(value.0)
34692 }
34693}
34694impl From<TerminalReturnGreen> for TokenNodeGreen {
34695 fn from(value: TerminalReturnGreen) -> Self {
34696 Self(value.0)
34697 }
34698}
34699impl From<TerminalBreakGreen> for TokenNodeGreen {
34700 fn from(value: TerminalBreakGreen) -> Self {
34701 Self(value.0)
34702 }
34703}
34704impl From<TerminalStructGreen> for TokenNodeGreen {
34705 fn from(value: TerminalStructGreen) -> Self {
34706 Self(value.0)
34707 }
34708}
34709impl From<TerminalTraitGreen> for TokenNodeGreen {
34710 fn from(value: TerminalTraitGreen) -> Self {
34711 Self(value.0)
34712 }
34713}
34714impl From<TerminalTrueGreen> for TokenNodeGreen {
34715 fn from(value: TerminalTrueGreen) -> Self {
34716 Self(value.0)
34717 }
34718}
34719impl From<TerminalTypeGreen> for TokenNodeGreen {
34720 fn from(value: TerminalTypeGreen) -> Self {
34721 Self(value.0)
34722 }
34723}
34724impl From<TerminalUseGreen> for TokenNodeGreen {
34725 fn from(value: TerminalUseGreen) -> Self {
34726 Self(value.0)
34727 }
34728}
34729impl From<TerminalPubGreen> for TokenNodeGreen {
34730 fn from(value: TerminalPubGreen) -> Self {
34731 Self(value.0)
34732 }
34733}
34734impl From<TerminalAndGreen> for TokenNodeGreen {
34735 fn from(value: TerminalAndGreen) -> Self {
34736 Self(value.0)
34737 }
34738}
34739impl From<TerminalAndAndGreen> for TokenNodeGreen {
34740 fn from(value: TerminalAndAndGreen) -> Self {
34741 Self(value.0)
34742 }
34743}
34744impl From<TerminalArrowGreen> for TokenNodeGreen {
34745 fn from(value: TerminalArrowGreen) -> Self {
34746 Self(value.0)
34747 }
34748}
34749impl From<TerminalAtGreen> for TokenNodeGreen {
34750 fn from(value: TerminalAtGreen) -> Self {
34751 Self(value.0)
34752 }
34753}
34754impl From<TerminalBadCharactersGreen> for TokenNodeGreen {
34755 fn from(value: TerminalBadCharactersGreen) -> Self {
34756 Self(value.0)
34757 }
34758}
34759impl From<TerminalColonGreen> for TokenNodeGreen {
34760 fn from(value: TerminalColonGreen) -> Self {
34761 Self(value.0)
34762 }
34763}
34764impl From<TerminalColonColonGreen> for TokenNodeGreen {
34765 fn from(value: TerminalColonColonGreen) -> Self {
34766 Self(value.0)
34767 }
34768}
34769impl From<TerminalCommaGreen> for TokenNodeGreen {
34770 fn from(value: TerminalCommaGreen) -> Self {
34771 Self(value.0)
34772 }
34773}
34774impl From<TerminalDivGreen> for TokenNodeGreen {
34775 fn from(value: TerminalDivGreen) -> Self {
34776 Self(value.0)
34777 }
34778}
34779impl From<TerminalDivEqGreen> for TokenNodeGreen {
34780 fn from(value: TerminalDivEqGreen) -> Self {
34781 Self(value.0)
34782 }
34783}
34784impl From<TerminalDotGreen> for TokenNodeGreen {
34785 fn from(value: TerminalDotGreen) -> Self {
34786 Self(value.0)
34787 }
34788}
34789impl From<TerminalDotDotGreen> for TokenNodeGreen {
34790 fn from(value: TerminalDotDotGreen) -> Self {
34791 Self(value.0)
34792 }
34793}
34794impl From<TerminalEndOfFileGreen> for TokenNodeGreen {
34795 fn from(value: TerminalEndOfFileGreen) -> Self {
34796 Self(value.0)
34797 }
34798}
34799impl From<TerminalEqGreen> for TokenNodeGreen {
34800 fn from(value: TerminalEqGreen) -> Self {
34801 Self(value.0)
34802 }
34803}
34804impl From<TerminalEqEqGreen> for TokenNodeGreen {
34805 fn from(value: TerminalEqEqGreen) -> Self {
34806 Self(value.0)
34807 }
34808}
34809impl From<TerminalGEGreen> for TokenNodeGreen {
34810 fn from(value: TerminalGEGreen) -> Self {
34811 Self(value.0)
34812 }
34813}
34814impl From<TerminalGTGreen> for TokenNodeGreen {
34815 fn from(value: TerminalGTGreen) -> Self {
34816 Self(value.0)
34817 }
34818}
34819impl From<TerminalHashGreen> for TokenNodeGreen {
34820 fn from(value: TerminalHashGreen) -> Self {
34821 Self(value.0)
34822 }
34823}
34824impl From<TerminalLBraceGreen> for TokenNodeGreen {
34825 fn from(value: TerminalLBraceGreen) -> Self {
34826 Self(value.0)
34827 }
34828}
34829impl From<TerminalLBrackGreen> for TokenNodeGreen {
34830 fn from(value: TerminalLBrackGreen) -> Self {
34831 Self(value.0)
34832 }
34833}
34834impl From<TerminalLEGreen> for TokenNodeGreen {
34835 fn from(value: TerminalLEGreen) -> Self {
34836 Self(value.0)
34837 }
34838}
34839impl From<TerminalLParenGreen> for TokenNodeGreen {
34840 fn from(value: TerminalLParenGreen) -> Self {
34841 Self(value.0)
34842 }
34843}
34844impl From<TerminalLTGreen> for TokenNodeGreen {
34845 fn from(value: TerminalLTGreen) -> Self {
34846 Self(value.0)
34847 }
34848}
34849impl From<TerminalMatchArrowGreen> for TokenNodeGreen {
34850 fn from(value: TerminalMatchArrowGreen) -> Self {
34851 Self(value.0)
34852 }
34853}
34854impl From<TerminalMinusGreen> for TokenNodeGreen {
34855 fn from(value: TerminalMinusGreen) -> Self {
34856 Self(value.0)
34857 }
34858}
34859impl From<TerminalMinusEqGreen> for TokenNodeGreen {
34860 fn from(value: TerminalMinusEqGreen) -> Self {
34861 Self(value.0)
34862 }
34863}
34864impl From<TerminalModGreen> for TokenNodeGreen {
34865 fn from(value: TerminalModGreen) -> Self {
34866 Self(value.0)
34867 }
34868}
34869impl From<TerminalModEqGreen> for TokenNodeGreen {
34870 fn from(value: TerminalModEqGreen) -> Self {
34871 Self(value.0)
34872 }
34873}
34874impl From<TerminalMulGreen> for TokenNodeGreen {
34875 fn from(value: TerminalMulGreen) -> Self {
34876 Self(value.0)
34877 }
34878}
34879impl From<TerminalMulEqGreen> for TokenNodeGreen {
34880 fn from(value: TerminalMulEqGreen) -> Self {
34881 Self(value.0)
34882 }
34883}
34884impl From<TerminalNeqGreen> for TokenNodeGreen {
34885 fn from(value: TerminalNeqGreen) -> Self {
34886 Self(value.0)
34887 }
34888}
34889impl From<TerminalNotGreen> for TokenNodeGreen {
34890 fn from(value: TerminalNotGreen) -> Self {
34891 Self(value.0)
34892 }
34893}
34894impl From<TerminalBitNotGreen> for TokenNodeGreen {
34895 fn from(value: TerminalBitNotGreen) -> Self {
34896 Self(value.0)
34897 }
34898}
34899impl From<TerminalOrGreen> for TokenNodeGreen {
34900 fn from(value: TerminalOrGreen) -> Self {
34901 Self(value.0)
34902 }
34903}
34904impl From<TerminalOrOrGreen> for TokenNodeGreen {
34905 fn from(value: TerminalOrOrGreen) -> Self {
34906 Self(value.0)
34907 }
34908}
34909impl From<TerminalPlusGreen> for TokenNodeGreen {
34910 fn from(value: TerminalPlusGreen) -> Self {
34911 Self(value.0)
34912 }
34913}
34914impl From<TerminalPlusEqGreen> for TokenNodeGreen {
34915 fn from(value: TerminalPlusEqGreen) -> Self {
34916 Self(value.0)
34917 }
34918}
34919impl From<TerminalQuestionMarkGreen> for TokenNodeGreen {
34920 fn from(value: TerminalQuestionMarkGreen) -> Self {
34921 Self(value.0)
34922 }
34923}
34924impl From<TerminalRBraceGreen> for TokenNodeGreen {
34925 fn from(value: TerminalRBraceGreen) -> Self {
34926 Self(value.0)
34927 }
34928}
34929impl From<TerminalRBrackGreen> for TokenNodeGreen {
34930 fn from(value: TerminalRBrackGreen) -> Self {
34931 Self(value.0)
34932 }
34933}
34934impl From<TerminalRParenGreen> for TokenNodeGreen {
34935 fn from(value: TerminalRParenGreen) -> Self {
34936 Self(value.0)
34937 }
34938}
34939impl From<TerminalSemicolonGreen> for TokenNodeGreen {
34940 fn from(value: TerminalSemicolonGreen) -> Self {
34941 Self(value.0)
34942 }
34943}
34944impl From<TerminalUnderscoreGreen> for TokenNodeGreen {
34945 fn from(value: TerminalUnderscoreGreen) -> Self {
34946 Self(value.0)
34947 }
34948}
34949impl From<TerminalXorGreen> for TokenNodeGreen {
34950 fn from(value: TerminalXorGreen) -> Self {
34951 Self(value.0)
34952 }
34953}
34954impl From<TerminalEmptyGreen> for TokenNodeGreen {
34955 fn from(value: TerminalEmptyGreen) -> Self {
34956 Self(value.0)
34957 }
34958}
34959#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
34960pub struct TokenNodeGreen(pub GreenId);
34961impl TypedSyntaxNode for TokenNode {
34962 const OPTIONAL_KIND: Option<SyntaxKind> = None;
34963 type StablePtr = TokenNodePtr;
34964 type Green = TokenNodeGreen;
34965 fn missing(db: &dyn SyntaxGroup) -> Self::Green {
34966 panic!("No missing variant.");
34967 }
34968 fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self {
34969 let kind = node.kind(db);
34970 match kind {
34971 SyntaxKind::TerminalIdentifier => {
34972 TokenNode::TerminalIdentifier(TerminalIdentifier::from_syntax_node(db, node))
34973 }
34974 SyntaxKind::TerminalLiteralNumber => {
34975 TokenNode::TerminalLiteralNumber(TerminalLiteralNumber::from_syntax_node(db, node))
34976 }
34977 SyntaxKind::TerminalShortString => {
34978 TokenNode::TerminalShortString(TerminalShortString::from_syntax_node(db, node))
34979 }
34980 SyntaxKind::TerminalString => {
34981 TokenNode::TerminalString(TerminalString::from_syntax_node(db, node))
34982 }
34983 SyntaxKind::TerminalAs => TokenNode::TerminalAs(TerminalAs::from_syntax_node(db, node)),
34984 SyntaxKind::TerminalConst => {
34985 TokenNode::TerminalConst(TerminalConst::from_syntax_node(db, node))
34986 }
34987 SyntaxKind::TerminalElse => {
34988 TokenNode::TerminalElse(TerminalElse::from_syntax_node(db, node))
34989 }
34990 SyntaxKind::TerminalEnum => {
34991 TokenNode::TerminalEnum(TerminalEnum::from_syntax_node(db, node))
34992 }
34993 SyntaxKind::TerminalExtern => {
34994 TokenNode::TerminalExtern(TerminalExtern::from_syntax_node(db, node))
34995 }
34996 SyntaxKind::TerminalFalse => {
34997 TokenNode::TerminalFalse(TerminalFalse::from_syntax_node(db, node))
34998 }
34999 SyntaxKind::TerminalFunction => {
35000 TokenNode::TerminalFunction(TerminalFunction::from_syntax_node(db, node))
35001 }
35002 SyntaxKind::TerminalIf => TokenNode::TerminalIf(TerminalIf::from_syntax_node(db, node)),
35003 SyntaxKind::TerminalWhile => {
35004 TokenNode::TerminalWhile(TerminalWhile::from_syntax_node(db, node))
35005 }
35006 SyntaxKind::TerminalFor => {
35007 TokenNode::TerminalFor(TerminalFor::from_syntax_node(db, node))
35008 }
35009 SyntaxKind::TerminalLoop => {
35010 TokenNode::TerminalLoop(TerminalLoop::from_syntax_node(db, node))
35011 }
35012 SyntaxKind::TerminalImpl => {
35013 TokenNode::TerminalImpl(TerminalImpl::from_syntax_node(db, node))
35014 }
35015 SyntaxKind::TerminalImplicits => {
35016 TokenNode::TerminalImplicits(TerminalImplicits::from_syntax_node(db, node))
35017 }
35018 SyntaxKind::TerminalLet => {
35019 TokenNode::TerminalLet(TerminalLet::from_syntax_node(db, node))
35020 }
35021 SyntaxKind::TerminalMatch => {
35022 TokenNode::TerminalMatch(TerminalMatch::from_syntax_node(db, node))
35023 }
35024 SyntaxKind::TerminalModule => {
35025 TokenNode::TerminalModule(TerminalModule::from_syntax_node(db, node))
35026 }
35027 SyntaxKind::TerminalMut => {
35028 TokenNode::TerminalMut(TerminalMut::from_syntax_node(db, node))
35029 }
35030 SyntaxKind::TerminalNoPanic => {
35031 TokenNode::TerminalNoPanic(TerminalNoPanic::from_syntax_node(db, node))
35032 }
35033 SyntaxKind::TerminalOf => TokenNode::TerminalOf(TerminalOf::from_syntax_node(db, node)),
35034 SyntaxKind::TerminalRef => {
35035 TokenNode::TerminalRef(TerminalRef::from_syntax_node(db, node))
35036 }
35037 SyntaxKind::TerminalContinue => {
35038 TokenNode::TerminalContinue(TerminalContinue::from_syntax_node(db, node))
35039 }
35040 SyntaxKind::TerminalReturn => {
35041 TokenNode::TerminalReturn(TerminalReturn::from_syntax_node(db, node))
35042 }
35043 SyntaxKind::TerminalBreak => {
35044 TokenNode::TerminalBreak(TerminalBreak::from_syntax_node(db, node))
35045 }
35046 SyntaxKind::TerminalStruct => {
35047 TokenNode::TerminalStruct(TerminalStruct::from_syntax_node(db, node))
35048 }
35049 SyntaxKind::TerminalTrait => {
35050 TokenNode::TerminalTrait(TerminalTrait::from_syntax_node(db, node))
35051 }
35052 SyntaxKind::TerminalTrue => {
35053 TokenNode::TerminalTrue(TerminalTrue::from_syntax_node(db, node))
35054 }
35055 SyntaxKind::TerminalType => {
35056 TokenNode::TerminalType(TerminalType::from_syntax_node(db, node))
35057 }
35058 SyntaxKind::TerminalUse => {
35059 TokenNode::TerminalUse(TerminalUse::from_syntax_node(db, node))
35060 }
35061 SyntaxKind::TerminalPub => {
35062 TokenNode::TerminalPub(TerminalPub::from_syntax_node(db, node))
35063 }
35064 SyntaxKind::TerminalAnd => {
35065 TokenNode::TerminalAnd(TerminalAnd::from_syntax_node(db, node))
35066 }
35067 SyntaxKind::TerminalAndAnd => {
35068 TokenNode::TerminalAndAnd(TerminalAndAnd::from_syntax_node(db, node))
35069 }
35070 SyntaxKind::TerminalArrow => {
35071 TokenNode::TerminalArrow(TerminalArrow::from_syntax_node(db, node))
35072 }
35073 SyntaxKind::TerminalAt => TokenNode::TerminalAt(TerminalAt::from_syntax_node(db, node)),
35074 SyntaxKind::TerminalBadCharacters => {
35075 TokenNode::TerminalBadCharacters(TerminalBadCharacters::from_syntax_node(db, node))
35076 }
35077 SyntaxKind::TerminalColon => {
35078 TokenNode::TerminalColon(TerminalColon::from_syntax_node(db, node))
35079 }
35080 SyntaxKind::TerminalColonColon => {
35081 TokenNode::TerminalColonColon(TerminalColonColon::from_syntax_node(db, node))
35082 }
35083 SyntaxKind::TerminalComma => {
35084 TokenNode::TerminalComma(TerminalComma::from_syntax_node(db, node))
35085 }
35086 SyntaxKind::TerminalDiv => {
35087 TokenNode::TerminalDiv(TerminalDiv::from_syntax_node(db, node))
35088 }
35089 SyntaxKind::TerminalDivEq => {
35090 TokenNode::TerminalDivEq(TerminalDivEq::from_syntax_node(db, node))
35091 }
35092 SyntaxKind::TerminalDot => {
35093 TokenNode::TerminalDot(TerminalDot::from_syntax_node(db, node))
35094 }
35095 SyntaxKind::TerminalDotDot => {
35096 TokenNode::TerminalDotDot(TerminalDotDot::from_syntax_node(db, node))
35097 }
35098 SyntaxKind::TerminalEndOfFile => {
35099 TokenNode::TerminalEndOfFile(TerminalEndOfFile::from_syntax_node(db, node))
35100 }
35101 SyntaxKind::TerminalEq => TokenNode::TerminalEq(TerminalEq::from_syntax_node(db, node)),
35102 SyntaxKind::TerminalEqEq => {
35103 TokenNode::TerminalEqEq(TerminalEqEq::from_syntax_node(db, node))
35104 }
35105 SyntaxKind::TerminalGE => TokenNode::TerminalGE(TerminalGE::from_syntax_node(db, node)),
35106 SyntaxKind::TerminalGT => TokenNode::TerminalGT(TerminalGT::from_syntax_node(db, node)),
35107 SyntaxKind::TerminalHash => {
35108 TokenNode::TerminalHash(TerminalHash::from_syntax_node(db, node))
35109 }
35110 SyntaxKind::TerminalLBrace => {
35111 TokenNode::TerminalLBrace(TerminalLBrace::from_syntax_node(db, node))
35112 }
35113 SyntaxKind::TerminalLBrack => {
35114 TokenNode::TerminalLBrack(TerminalLBrack::from_syntax_node(db, node))
35115 }
35116 SyntaxKind::TerminalLE => TokenNode::TerminalLE(TerminalLE::from_syntax_node(db, node)),
35117 SyntaxKind::TerminalLParen => {
35118 TokenNode::TerminalLParen(TerminalLParen::from_syntax_node(db, node))
35119 }
35120 SyntaxKind::TerminalLT => TokenNode::TerminalLT(TerminalLT::from_syntax_node(db, node)),
35121 SyntaxKind::TerminalMatchArrow => {
35122 TokenNode::TerminalMatchArrow(TerminalMatchArrow::from_syntax_node(db, node))
35123 }
35124 SyntaxKind::TerminalMinus => {
35125 TokenNode::TerminalMinus(TerminalMinus::from_syntax_node(db, node))
35126 }
35127 SyntaxKind::TerminalMinusEq => {
35128 TokenNode::TerminalMinusEq(TerminalMinusEq::from_syntax_node(db, node))
35129 }
35130 SyntaxKind::TerminalMod => {
35131 TokenNode::TerminalMod(TerminalMod::from_syntax_node(db, node))
35132 }
35133 SyntaxKind::TerminalModEq => {
35134 TokenNode::TerminalModEq(TerminalModEq::from_syntax_node(db, node))
35135 }
35136 SyntaxKind::TerminalMul => {
35137 TokenNode::TerminalMul(TerminalMul::from_syntax_node(db, node))
35138 }
35139 SyntaxKind::TerminalMulEq => {
35140 TokenNode::TerminalMulEq(TerminalMulEq::from_syntax_node(db, node))
35141 }
35142 SyntaxKind::TerminalNeq => {
35143 TokenNode::TerminalNeq(TerminalNeq::from_syntax_node(db, node))
35144 }
35145 SyntaxKind::TerminalNot => {
35146 TokenNode::TerminalNot(TerminalNot::from_syntax_node(db, node))
35147 }
35148 SyntaxKind::TerminalBitNot => {
35149 TokenNode::TerminalBitNot(TerminalBitNot::from_syntax_node(db, node))
35150 }
35151 SyntaxKind::TerminalOr => TokenNode::TerminalOr(TerminalOr::from_syntax_node(db, node)),
35152 SyntaxKind::TerminalOrOr => {
35153 TokenNode::TerminalOrOr(TerminalOrOr::from_syntax_node(db, node))
35154 }
35155 SyntaxKind::TerminalPlus => {
35156 TokenNode::TerminalPlus(TerminalPlus::from_syntax_node(db, node))
35157 }
35158 SyntaxKind::TerminalPlusEq => {
35159 TokenNode::TerminalPlusEq(TerminalPlusEq::from_syntax_node(db, node))
35160 }
35161 SyntaxKind::TerminalQuestionMark => {
35162 TokenNode::TerminalQuestionMark(TerminalQuestionMark::from_syntax_node(db, node))
35163 }
35164 SyntaxKind::TerminalRBrace => {
35165 TokenNode::TerminalRBrace(TerminalRBrace::from_syntax_node(db, node))
35166 }
35167 SyntaxKind::TerminalRBrack => {
35168 TokenNode::TerminalRBrack(TerminalRBrack::from_syntax_node(db, node))
35169 }
35170 SyntaxKind::TerminalRParen => {
35171 TokenNode::TerminalRParen(TerminalRParen::from_syntax_node(db, node))
35172 }
35173 SyntaxKind::TerminalSemicolon => {
35174 TokenNode::TerminalSemicolon(TerminalSemicolon::from_syntax_node(db, node))
35175 }
35176 SyntaxKind::TerminalUnderscore => {
35177 TokenNode::TerminalUnderscore(TerminalUnderscore::from_syntax_node(db, node))
35178 }
35179 SyntaxKind::TerminalXor => {
35180 TokenNode::TerminalXor(TerminalXor::from_syntax_node(db, node))
35181 }
35182 SyntaxKind::TerminalEmpty => {
35183 TokenNode::TerminalEmpty(TerminalEmpty::from_syntax_node(db, node))
35184 }
35185 _ => panic!("Unexpected syntax kind {:?} when constructing {}.", kind, "TokenNode"),
35186 }
35187 }
35188 fn as_syntax_node(&self) -> SyntaxNode {
35189 match self {
35190 TokenNode::TerminalIdentifier(x) => x.as_syntax_node(),
35191 TokenNode::TerminalLiteralNumber(x) => x.as_syntax_node(),
35192 TokenNode::TerminalShortString(x) => x.as_syntax_node(),
35193 TokenNode::TerminalString(x) => x.as_syntax_node(),
35194 TokenNode::TerminalAs(x) => x.as_syntax_node(),
35195 TokenNode::TerminalConst(x) => x.as_syntax_node(),
35196 TokenNode::TerminalElse(x) => x.as_syntax_node(),
35197 TokenNode::TerminalEnum(x) => x.as_syntax_node(),
35198 TokenNode::TerminalExtern(x) => x.as_syntax_node(),
35199 TokenNode::TerminalFalse(x) => x.as_syntax_node(),
35200 TokenNode::TerminalFunction(x) => x.as_syntax_node(),
35201 TokenNode::TerminalIf(x) => x.as_syntax_node(),
35202 TokenNode::TerminalWhile(x) => x.as_syntax_node(),
35203 TokenNode::TerminalFor(x) => x.as_syntax_node(),
35204 TokenNode::TerminalLoop(x) => x.as_syntax_node(),
35205 TokenNode::TerminalImpl(x) => x.as_syntax_node(),
35206 TokenNode::TerminalImplicits(x) => x.as_syntax_node(),
35207 TokenNode::TerminalLet(x) => x.as_syntax_node(),
35208 TokenNode::TerminalMatch(x) => x.as_syntax_node(),
35209 TokenNode::TerminalModule(x) => x.as_syntax_node(),
35210 TokenNode::TerminalMut(x) => x.as_syntax_node(),
35211 TokenNode::TerminalNoPanic(x) => x.as_syntax_node(),
35212 TokenNode::TerminalOf(x) => x.as_syntax_node(),
35213 TokenNode::TerminalRef(x) => x.as_syntax_node(),
35214 TokenNode::TerminalContinue(x) => x.as_syntax_node(),
35215 TokenNode::TerminalReturn(x) => x.as_syntax_node(),
35216 TokenNode::TerminalBreak(x) => x.as_syntax_node(),
35217 TokenNode::TerminalStruct(x) => x.as_syntax_node(),
35218 TokenNode::TerminalTrait(x) => x.as_syntax_node(),
35219 TokenNode::TerminalTrue(x) => x.as_syntax_node(),
35220 TokenNode::TerminalType(x) => x.as_syntax_node(),
35221 TokenNode::TerminalUse(x) => x.as_syntax_node(),
35222 TokenNode::TerminalPub(x) => x.as_syntax_node(),
35223 TokenNode::TerminalAnd(x) => x.as_syntax_node(),
35224 TokenNode::TerminalAndAnd(x) => x.as_syntax_node(),
35225 TokenNode::TerminalArrow(x) => x.as_syntax_node(),
35226 TokenNode::TerminalAt(x) => x.as_syntax_node(),
35227 TokenNode::TerminalBadCharacters(x) => x.as_syntax_node(),
35228 TokenNode::TerminalColon(x) => x.as_syntax_node(),
35229 TokenNode::TerminalColonColon(x) => x.as_syntax_node(),
35230 TokenNode::TerminalComma(x) => x.as_syntax_node(),
35231 TokenNode::TerminalDiv(x) => x.as_syntax_node(),
35232 TokenNode::TerminalDivEq(x) => x.as_syntax_node(),
35233 TokenNode::TerminalDot(x) => x.as_syntax_node(),
35234 TokenNode::TerminalDotDot(x) => x.as_syntax_node(),
35235 TokenNode::TerminalEndOfFile(x) => x.as_syntax_node(),
35236 TokenNode::TerminalEq(x) => x.as_syntax_node(),
35237 TokenNode::TerminalEqEq(x) => x.as_syntax_node(),
35238 TokenNode::TerminalGE(x) => x.as_syntax_node(),
35239 TokenNode::TerminalGT(x) => x.as_syntax_node(),
35240 TokenNode::TerminalHash(x) => x.as_syntax_node(),
35241 TokenNode::TerminalLBrace(x) => x.as_syntax_node(),
35242 TokenNode::TerminalLBrack(x) => x.as_syntax_node(),
35243 TokenNode::TerminalLE(x) => x.as_syntax_node(),
35244 TokenNode::TerminalLParen(x) => x.as_syntax_node(),
35245 TokenNode::TerminalLT(x) => x.as_syntax_node(),
35246 TokenNode::TerminalMatchArrow(x) => x.as_syntax_node(),
35247 TokenNode::TerminalMinus(x) => x.as_syntax_node(),
35248 TokenNode::TerminalMinusEq(x) => x.as_syntax_node(),
35249 TokenNode::TerminalMod(x) => x.as_syntax_node(),
35250 TokenNode::TerminalModEq(x) => x.as_syntax_node(),
35251 TokenNode::TerminalMul(x) => x.as_syntax_node(),
35252 TokenNode::TerminalMulEq(x) => x.as_syntax_node(),
35253 TokenNode::TerminalNeq(x) => x.as_syntax_node(),
35254 TokenNode::TerminalNot(x) => x.as_syntax_node(),
35255 TokenNode::TerminalBitNot(x) => x.as_syntax_node(),
35256 TokenNode::TerminalOr(x) => x.as_syntax_node(),
35257 TokenNode::TerminalOrOr(x) => x.as_syntax_node(),
35258 TokenNode::TerminalPlus(x) => x.as_syntax_node(),
35259 TokenNode::TerminalPlusEq(x) => x.as_syntax_node(),
35260 TokenNode::TerminalQuestionMark(x) => x.as_syntax_node(),
35261 TokenNode::TerminalRBrace(x) => x.as_syntax_node(),
35262 TokenNode::TerminalRBrack(x) => x.as_syntax_node(),
35263 TokenNode::TerminalRParen(x) => x.as_syntax_node(),
35264 TokenNode::TerminalSemicolon(x) => x.as_syntax_node(),
35265 TokenNode::TerminalUnderscore(x) => x.as_syntax_node(),
35266 TokenNode::TerminalXor(x) => x.as_syntax_node(),
35267 TokenNode::TerminalEmpty(x) => x.as_syntax_node(),
35268 }
35269 }
35270 fn stable_ptr(&self) -> Self::StablePtr {
35271 TokenNodePtr(self.as_syntax_node().0.stable_ptr)
35272 }
35273}
35274impl From<&TokenNode> for SyntaxStablePtrId {
35275 fn from(node: &TokenNode) -> Self {
35276 node.stable_ptr().untyped()
35277 }
35278}
35279impl TokenNode {
35280 pub fn is_variant(kind: SyntaxKind) -> bool {
35282 matches!(
35283 kind,
35284 SyntaxKind::TerminalIdentifier
35285 | SyntaxKind::TerminalLiteralNumber
35286 | SyntaxKind::TerminalShortString
35287 | SyntaxKind::TerminalString
35288 | SyntaxKind::TerminalAs
35289 | SyntaxKind::TerminalConst
35290 | SyntaxKind::TerminalElse
35291 | SyntaxKind::TerminalEnum
35292 | SyntaxKind::TerminalExtern
35293 | SyntaxKind::TerminalFalse
35294 | SyntaxKind::TerminalFunction
35295 | SyntaxKind::TerminalIf
35296 | SyntaxKind::TerminalWhile
35297 | SyntaxKind::TerminalFor
35298 | SyntaxKind::TerminalLoop
35299 | SyntaxKind::TerminalImpl
35300 | SyntaxKind::TerminalImplicits
35301 | SyntaxKind::TerminalLet
35302 | SyntaxKind::TerminalMatch
35303 | SyntaxKind::TerminalModule
35304 | SyntaxKind::TerminalMut
35305 | SyntaxKind::TerminalNoPanic
35306 | SyntaxKind::TerminalOf
35307 | SyntaxKind::TerminalRef
35308 | SyntaxKind::TerminalContinue
35309 | SyntaxKind::TerminalReturn
35310 | SyntaxKind::TerminalBreak
35311 | SyntaxKind::TerminalStruct
35312 | SyntaxKind::TerminalTrait
35313 | SyntaxKind::TerminalTrue
35314 | SyntaxKind::TerminalType
35315 | SyntaxKind::TerminalUse
35316 | SyntaxKind::TerminalPub
35317 | SyntaxKind::TerminalAnd
35318 | SyntaxKind::TerminalAndAnd
35319 | SyntaxKind::TerminalArrow
35320 | SyntaxKind::TerminalAt
35321 | SyntaxKind::TerminalBadCharacters
35322 | SyntaxKind::TerminalColon
35323 | SyntaxKind::TerminalColonColon
35324 | SyntaxKind::TerminalComma
35325 | SyntaxKind::TerminalDiv
35326 | SyntaxKind::TerminalDivEq
35327 | SyntaxKind::TerminalDot
35328 | SyntaxKind::TerminalDotDot
35329 | SyntaxKind::TerminalEndOfFile
35330 | SyntaxKind::TerminalEq
35331 | SyntaxKind::TerminalEqEq
35332 | SyntaxKind::TerminalGE
35333 | SyntaxKind::TerminalGT
35334 | SyntaxKind::TerminalHash
35335 | SyntaxKind::TerminalLBrace
35336 | SyntaxKind::TerminalLBrack
35337 | SyntaxKind::TerminalLE
35338 | SyntaxKind::TerminalLParen
35339 | SyntaxKind::TerminalLT
35340 | SyntaxKind::TerminalMatchArrow
35341 | SyntaxKind::TerminalMinus
35342 | SyntaxKind::TerminalMinusEq
35343 | SyntaxKind::TerminalMod
35344 | SyntaxKind::TerminalModEq
35345 | SyntaxKind::TerminalMul
35346 | SyntaxKind::TerminalMulEq
35347 | SyntaxKind::TerminalNeq
35348 | SyntaxKind::TerminalNot
35349 | SyntaxKind::TerminalBitNot
35350 | SyntaxKind::TerminalOr
35351 | SyntaxKind::TerminalOrOr
35352 | SyntaxKind::TerminalPlus
35353 | SyntaxKind::TerminalPlusEq
35354 | SyntaxKind::TerminalQuestionMark
35355 | SyntaxKind::TerminalRBrace
35356 | SyntaxKind::TerminalRBrack
35357 | SyntaxKind::TerminalRParen
35358 | SyntaxKind::TerminalSemicolon
35359 | SyntaxKind::TerminalUnderscore
35360 | SyntaxKind::TerminalXor
35361 | SyntaxKind::TerminalEmpty
35362 )
35363 }
35364}