1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum ClassDecl<'tree> {
3 DataFamily(::std::boxed::Box<DataFamily<'tree>>),
4 Decl(::std::boxed::Box<Decl<'tree>>),
5 DefaultSignature(::std::boxed::Box<DefaultSignature<'tree>>),
6 Fixity(::std::boxed::Box<Fixity<'tree>>),
7 TypeFamily(::std::boxed::Box<TypeFamily<'tree>>),
8 TypeInstance(::std::boxed::Box<TypeInstance<'tree>>),
9}
10impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDecl<'tree> {
11 #[allow(clippy::collapsible_else_if)]
12 fn from_node(
13 node: ::treesitter_types::tree_sitter::Node<'tree>,
14 src: &'tree [u8],
15 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16 match node.kind() {
17 "data_family" => Ok(Self::DataFamily(::std::boxed::Box::new(
18 ::treesitter_types::runtime::maybe_grow_stack(|| {
19 <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)
20 })?,
21 ))),
22 "default_signature" => Ok(Self::DefaultSignature(::std::boxed::Box::new(
23 ::treesitter_types::runtime::maybe_grow_stack(|| {
24 <DefaultSignature as ::treesitter_types::FromNode>::from_node(node, src)
25 })?,
26 ))),
27 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
28 ::treesitter_types::runtime::maybe_grow_stack(|| {
29 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)
30 })?,
31 ))),
32 "type_family" => Ok(Self::TypeFamily(::std::boxed::Box::new(
33 ::treesitter_types::runtime::maybe_grow_stack(|| {
34 <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)
35 })?,
36 ))),
37 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
38 ::treesitter_types::runtime::maybe_grow_stack(|| {
39 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)
40 })?,
41 ))),
42 _other => {
43 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
44 <Decl as ::treesitter_types::FromNode>::from_node(node, src)
45 }) {
46 Ok(Self::Decl(::std::boxed::Box::new(v)))
47 } else {
48 Err(::treesitter_types::ParseError::unexpected_kind(
49 _other, node,
50 ))
51 }
52 }
53 }
54 }
55}
56impl ::treesitter_types::Spanned for ClassDecl<'_> {
57 fn span(&self) -> ::treesitter_types::Span {
58 match self {
59 Self::DataFamily(inner) => inner.span(),
60 Self::Decl(inner) => inner.span(),
61 Self::DefaultSignature(inner) => inner.span(),
62 Self::Fixity(inner) => inner.span(),
63 Self::TypeFamily(inner) => inner.span(),
64 Self::TypeInstance(inner) => inner.span(),
65 }
66 }
67}
68#[derive(Debug, Clone, PartialEq, Eq)]
69pub enum Constraint<'tree> {
70 Apply(::std::boxed::Box<Apply<'tree>>),
71 Infix(::std::boxed::Box<Infix<'tree>>),
72 Literal(::std::boxed::Box<Literal<'tree>>),
73 Name(::std::boxed::Box<Name<'tree>>),
74 Parens(::std::boxed::Box<Parens<'tree>>),
75 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
76 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
77 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
78 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
79 Promoted(::std::boxed::Box<Promoted<'tree>>),
80 Qualified(::std::boxed::Box<Qualified<'tree>>),
81 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
82 Splice(::std::boxed::Box<Splice<'tree>>),
83 Tuple(::std::boxed::Box<Tuple<'tree>>),
84 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
85 Unit(::std::boxed::Box<Unit<'tree>>),
86 Variable(::std::boxed::Box<Variable<'tree>>),
87 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
88}
89impl<'tree> ::treesitter_types::FromNode<'tree> for Constraint<'tree> {
90 #[allow(clippy::collapsible_else_if)]
91 fn from_node(
92 node: ::treesitter_types::tree_sitter::Node<'tree>,
93 src: &'tree [u8],
94 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
95 match node.kind() {
96 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
97 ::treesitter_types::runtime::maybe_grow_stack(|| {
98 <Apply as ::treesitter_types::FromNode>::from_node(node, src)
99 })?,
100 ))),
101 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
102 ::treesitter_types::runtime::maybe_grow_stack(|| {
103 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
104 })?,
105 ))),
106 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
107 ::treesitter_types::runtime::maybe_grow_stack(|| {
108 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
109 })?,
110 ))),
111 "name" => Ok(Self::Name(::std::boxed::Box::new(
112 ::treesitter_types::runtime::maybe_grow_stack(|| {
113 <Name as ::treesitter_types::FromNode>::from_node(node, src)
114 })?,
115 ))),
116 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
117 ::treesitter_types::runtime::maybe_grow_stack(|| {
118 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
119 })?,
120 ))),
121 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
122 ::treesitter_types::runtime::maybe_grow_stack(|| {
123 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
124 })?,
125 ))),
126 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
127 ::treesitter_types::runtime::maybe_grow_stack(|| {
128 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
129 })?,
130 ))),
131 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
132 ::treesitter_types::runtime::maybe_grow_stack(|| {
133 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
134 })?,
135 ))),
136 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
137 ::treesitter_types::runtime::maybe_grow_stack(|| {
138 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
139 })?,
140 ))),
141 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
142 ::treesitter_types::runtime::maybe_grow_stack(|| {
143 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)
144 })?,
145 ))),
146 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
147 ::treesitter_types::runtime::maybe_grow_stack(|| {
148 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
149 })?,
150 ))),
151 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
152 ::treesitter_types::runtime::maybe_grow_stack(|| {
153 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
154 })?,
155 ))),
156 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
157 ::treesitter_types::runtime::maybe_grow_stack(|| {
158 <Splice as ::treesitter_types::FromNode>::from_node(node, src)
159 })?,
160 ))),
161 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
162 ::treesitter_types::runtime::maybe_grow_stack(|| {
163 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
164 })?,
165 ))),
166 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
167 ::treesitter_types::runtime::maybe_grow_stack(|| {
168 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
169 })?,
170 ))),
171 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
172 ::treesitter_types::runtime::maybe_grow_stack(|| {
173 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
174 })?,
175 ))),
176 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
177 ::treesitter_types::runtime::maybe_grow_stack(|| {
178 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
179 })?,
180 ))),
181 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
182 ::treesitter_types::runtime::maybe_grow_stack(|| {
183 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
184 })?,
185 ))),
186 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
187 }
188 }
189}
190impl ::treesitter_types::Spanned for Constraint<'_> {
191 fn span(&self) -> ::treesitter_types::Span {
192 match self {
193 Self::Apply(inner) => inner.span(),
194 Self::Infix(inner) => inner.span(),
195 Self::Literal(inner) => inner.span(),
196 Self::Name(inner) => inner.span(),
197 Self::Parens(inner) => inner.span(),
198 Self::PrefixId(inner) => inner.span(),
199 Self::PrefixTuple(inner) => inner.span(),
200 Self::PrefixUnboxedSum(inner) => inner.span(),
201 Self::PrefixUnboxedTuple(inner) => inner.span(),
202 Self::Promoted(inner) => inner.span(),
203 Self::Qualified(inner) => inner.span(),
204 Self::Quasiquote(inner) => inner.span(),
205 Self::Splice(inner) => inner.span(),
206 Self::Tuple(inner) => inner.span(),
207 Self::UnboxedUnit(inner) => inner.span(),
208 Self::Unit(inner) => inner.span(),
209 Self::Variable(inner) => inner.span(),
210 Self::Wildcard(inner) => inner.span(),
211 }
212 }
213}
214#[derive(Debug, Clone, PartialEq, Eq)]
215pub enum Constraints<'tree> {
216 Constraint(::std::boxed::Box<Constraint<'tree>>),
217 Context(::std::boxed::Box<Context<'tree>>),
218 Forall(::std::boxed::Box<Forall<'tree>>),
219 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
220 Signature(::std::boxed::Box<Signature<'tree>>),
221}
222impl<'tree> ::treesitter_types::FromNode<'tree> for Constraints<'tree> {
223 #[allow(clippy::collapsible_else_if)]
224 fn from_node(
225 node: ::treesitter_types::tree_sitter::Node<'tree>,
226 src: &'tree [u8],
227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
228 match node.kind() {
229 "context" => Ok(Self::Context(::std::boxed::Box::new(
230 ::treesitter_types::runtime::maybe_grow_stack(|| {
231 <Context as ::treesitter_types::FromNode>::from_node(node, src)
232 })?,
233 ))),
234 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
235 ::treesitter_types::runtime::maybe_grow_stack(|| {
236 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
237 })?,
238 ))),
239 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
240 ::treesitter_types::runtime::maybe_grow_stack(|| {
241 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
242 })?,
243 ))),
244 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
245 ::treesitter_types::runtime::maybe_grow_stack(|| {
246 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
247 })?,
248 ))),
249 _other => {
250 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
251 <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
252 }) {
253 Ok(Self::Constraint(::std::boxed::Box::new(v)))
254 } else {
255 Err(::treesitter_types::ParseError::unexpected_kind(
256 _other, node,
257 ))
258 }
259 }
260 }
261 }
262}
263impl ::treesitter_types::Spanned for Constraints<'_> {
264 fn span(&self) -> ::treesitter_types::Span {
265 match self {
266 Self::Constraint(inner) => inner.span(),
267 Self::Context(inner) => inner.span(),
268 Self::Forall(inner) => inner.span(),
269 Self::ImplicitParameter(inner) => inner.span(),
270 Self::Signature(inner) => inner.span(),
271 }
272 }
273}
274#[derive(Debug, Clone, PartialEq, Eq)]
275pub enum Decl<'tree> {
276 Bind(::std::boxed::Box<Bind<'tree>>),
277 Function(::std::boxed::Box<Function<'tree>>),
278 Signature(::std::boxed::Box<Signature<'tree>>),
279}
280impl<'tree> ::treesitter_types::FromNode<'tree> for Decl<'tree> {
281 #[allow(clippy::collapsible_else_if)]
282 fn from_node(
283 node: ::treesitter_types::tree_sitter::Node<'tree>,
284 src: &'tree [u8],
285 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
286 match node.kind() {
287 "bind" => Ok(Self::Bind(::std::boxed::Box::new(
288 ::treesitter_types::runtime::maybe_grow_stack(|| {
289 <Bind as ::treesitter_types::FromNode>::from_node(node, src)
290 })?,
291 ))),
292 "function" => Ok(Self::Function(::std::boxed::Box::new(
293 ::treesitter_types::runtime::maybe_grow_stack(|| {
294 <Function as ::treesitter_types::FromNode>::from_node(node, src)
295 })?,
296 ))),
297 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
298 ::treesitter_types::runtime::maybe_grow_stack(|| {
299 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
300 })?,
301 ))),
302 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
303 }
304 }
305}
306impl ::treesitter_types::Spanned for Decl<'_> {
307 fn span(&self) -> ::treesitter_types::Span {
308 match self {
309 Self::Bind(inner) => inner.span(),
310 Self::Function(inner) => inner.span(),
311 Self::Signature(inner) => inner.span(),
312 }
313 }
314}
315#[derive(Debug, Clone, PartialEq, Eq)]
316pub enum Declaration<'tree> {
317 Class(::std::boxed::Box<Class<'tree>>),
318 DataFamily(::std::boxed::Box<DataFamily<'tree>>),
319 DataInstance(::std::boxed::Box<DataInstance<'tree>>),
320 DataType(::std::boxed::Box<DataType<'tree>>),
321 Decl(::std::boxed::Box<Decl<'tree>>),
322 DefaultTypes(::std::boxed::Box<DefaultTypes<'tree>>),
323 DerivingInstance(::std::boxed::Box<DerivingInstance<'tree>>),
324 Fixity(::std::boxed::Box<Fixity<'tree>>),
325 ForeignExport(::std::boxed::Box<ForeignExport<'tree>>),
326 ForeignImport(::std::boxed::Box<ForeignImport<'tree>>),
327 Instance(::std::boxed::Box<Instance<'tree>>),
328 KindSignature(::std::boxed::Box<KindSignature<'tree>>),
329 Newtype(::std::boxed::Box<Newtype<'tree>>),
330 PatternSynonym(::std::boxed::Box<PatternSynonym<'tree>>),
331 RoleAnnotation(::std::boxed::Box<RoleAnnotation<'tree>>),
332 TopSplice(::std::boxed::Box<TopSplice<'tree>>),
333 TypeFamily(::std::boxed::Box<TypeFamily<'tree>>),
334 TypeInstance(::std::boxed::Box<TypeInstance<'tree>>),
335 TypeSynomym(::std::boxed::Box<TypeSynomym<'tree>>),
336}
337impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
338 #[allow(clippy::collapsible_else_if)]
339 fn from_node(
340 node: ::treesitter_types::tree_sitter::Node<'tree>,
341 src: &'tree [u8],
342 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
343 match node.kind() {
344 "class" => Ok(Self::Class(::std::boxed::Box::new(
345 ::treesitter_types::runtime::maybe_grow_stack(|| {
346 <Class as ::treesitter_types::FromNode>::from_node(node, src)
347 })?,
348 ))),
349 "data_family" => Ok(Self::DataFamily(::std::boxed::Box::new(
350 ::treesitter_types::runtime::maybe_grow_stack(|| {
351 <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)
352 })?,
353 ))),
354 "data_instance" => Ok(Self::DataInstance(::std::boxed::Box::new(
355 ::treesitter_types::runtime::maybe_grow_stack(|| {
356 <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)
357 })?,
358 ))),
359 "data_type" => Ok(Self::DataType(::std::boxed::Box::new(
360 ::treesitter_types::runtime::maybe_grow_stack(|| {
361 <DataType as ::treesitter_types::FromNode>::from_node(node, src)
362 })?,
363 ))),
364 "default_types" => Ok(Self::DefaultTypes(::std::boxed::Box::new(
365 ::treesitter_types::runtime::maybe_grow_stack(|| {
366 <DefaultTypes as ::treesitter_types::FromNode>::from_node(node, src)
367 })?,
368 ))),
369 "deriving_instance" => Ok(Self::DerivingInstance(::std::boxed::Box::new(
370 ::treesitter_types::runtime::maybe_grow_stack(|| {
371 <DerivingInstance as ::treesitter_types::FromNode>::from_node(node, src)
372 })?,
373 ))),
374 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
375 ::treesitter_types::runtime::maybe_grow_stack(|| {
376 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)
377 })?,
378 ))),
379 "foreign_export" => Ok(Self::ForeignExport(::std::boxed::Box::new(
380 ::treesitter_types::runtime::maybe_grow_stack(|| {
381 <ForeignExport as ::treesitter_types::FromNode>::from_node(node, src)
382 })?,
383 ))),
384 "foreign_import" => Ok(Self::ForeignImport(::std::boxed::Box::new(
385 ::treesitter_types::runtime::maybe_grow_stack(|| {
386 <ForeignImport as ::treesitter_types::FromNode>::from_node(node, src)
387 })?,
388 ))),
389 "instance" => Ok(Self::Instance(::std::boxed::Box::new(
390 ::treesitter_types::runtime::maybe_grow_stack(|| {
391 <Instance as ::treesitter_types::FromNode>::from_node(node, src)
392 })?,
393 ))),
394 "kind_signature" => Ok(Self::KindSignature(::std::boxed::Box::new(
395 ::treesitter_types::runtime::maybe_grow_stack(|| {
396 <KindSignature as ::treesitter_types::FromNode>::from_node(node, src)
397 })?,
398 ))),
399 "newtype" => Ok(Self::Newtype(::std::boxed::Box::new(
400 ::treesitter_types::runtime::maybe_grow_stack(|| {
401 <Newtype as ::treesitter_types::FromNode>::from_node(node, src)
402 })?,
403 ))),
404 "pattern_synonym" => Ok(Self::PatternSynonym(::std::boxed::Box::new(
405 ::treesitter_types::runtime::maybe_grow_stack(|| {
406 <PatternSynonym as ::treesitter_types::FromNode>::from_node(node, src)
407 })?,
408 ))),
409 "role_annotation" => Ok(Self::RoleAnnotation(::std::boxed::Box::new(
410 ::treesitter_types::runtime::maybe_grow_stack(|| {
411 <RoleAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
412 })?,
413 ))),
414 "top_splice" => Ok(Self::TopSplice(::std::boxed::Box::new(
415 ::treesitter_types::runtime::maybe_grow_stack(|| {
416 <TopSplice as ::treesitter_types::FromNode>::from_node(node, src)
417 })?,
418 ))),
419 "type_family" => Ok(Self::TypeFamily(::std::boxed::Box::new(
420 ::treesitter_types::runtime::maybe_grow_stack(|| {
421 <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)
422 })?,
423 ))),
424 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
425 ::treesitter_types::runtime::maybe_grow_stack(|| {
426 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)
427 })?,
428 ))),
429 "type_synomym" => Ok(Self::TypeSynomym(::std::boxed::Box::new(
430 ::treesitter_types::runtime::maybe_grow_stack(|| {
431 <TypeSynomym as ::treesitter_types::FromNode>::from_node(node, src)
432 })?,
433 ))),
434 _other => {
435 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
436 <Decl as ::treesitter_types::FromNode>::from_node(node, src)
437 }) {
438 Ok(Self::Decl(::std::boxed::Box::new(v)))
439 } else {
440 Err(::treesitter_types::ParseError::unexpected_kind(
441 _other, node,
442 ))
443 }
444 }
445 }
446 }
447}
448impl ::treesitter_types::Spanned for Declaration<'_> {
449 fn span(&self) -> ::treesitter_types::Span {
450 match self {
451 Self::Class(inner) => inner.span(),
452 Self::DataFamily(inner) => inner.span(),
453 Self::DataInstance(inner) => inner.span(),
454 Self::DataType(inner) => inner.span(),
455 Self::Decl(inner) => inner.span(),
456 Self::DefaultTypes(inner) => inner.span(),
457 Self::DerivingInstance(inner) => inner.span(),
458 Self::Fixity(inner) => inner.span(),
459 Self::ForeignExport(inner) => inner.span(),
460 Self::ForeignImport(inner) => inner.span(),
461 Self::Instance(inner) => inner.span(),
462 Self::KindSignature(inner) => inner.span(),
463 Self::Newtype(inner) => inner.span(),
464 Self::PatternSynonym(inner) => inner.span(),
465 Self::RoleAnnotation(inner) => inner.span(),
466 Self::TopSplice(inner) => inner.span(),
467 Self::TypeFamily(inner) => inner.span(),
468 Self::TypeInstance(inner) => inner.span(),
469 Self::TypeSynomym(inner) => inner.span(),
470 }
471 }
472}
473#[derive(Debug, Clone, PartialEq, Eq)]
474pub enum Expression<'tree> {
475 Apply(::std::boxed::Box<Apply<'tree>>),
476 ArithmeticSequence(::std::boxed::Box<ArithmeticSequence<'tree>>),
477 Case(::std::boxed::Box<Case<'tree>>),
478 Conditional(::std::boxed::Box<Conditional<'tree>>),
479 Constructor(::std::boxed::Box<Constructor<'tree>>),
480 Do(::std::boxed::Box<Do<'tree>>),
481 ImplicitVariable(::std::boxed::Box<ImplicitVariable<'tree>>),
482 Infix(::std::boxed::Box<Infix<'tree>>),
483 Label(::std::boxed::Box<Label<'tree>>),
484 Lambda(::std::boxed::Box<Lambda<'tree>>),
485 LambdaCase(::std::boxed::Box<LambdaCase<'tree>>),
486 LambdaCases(::std::boxed::Box<LambdaCases<'tree>>),
487 LeftSection(::std::boxed::Box<LeftSection<'tree>>),
488 LetIn(::std::boxed::Box<LetIn<'tree>>),
489 List(::std::boxed::Box<List<'tree>>),
490 ListComprehension(::std::boxed::Box<ListComprehension<'tree>>),
491 Literal(::std::boxed::Box<Literal<'tree>>),
492 MultiWayIf(::std::boxed::Box<MultiWayIf<'tree>>),
493 Negation(::std::boxed::Box<Negation<'tree>>),
494 Parens(::std::boxed::Box<Parens<'tree>>),
495 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
496 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
497 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
498 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
499 Projection(::std::boxed::Box<Projection<'tree>>),
500 ProjectionSelector(::std::boxed::Box<ProjectionSelector<'tree>>),
501 Qualified(::std::boxed::Box<Qualified<'tree>>),
502 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
503 Quote(::std::boxed::Box<Quote<'tree>>),
504 Record(::std::boxed::Box<Record<'tree>>),
505 RightSection(::std::boxed::Box<RightSection<'tree>>),
506 Splice(::std::boxed::Box<Splice<'tree>>),
507 ThQuotedName(::std::boxed::Box<ThQuotedName<'tree>>),
508 Tuple(::std::boxed::Box<Tuple<'tree>>),
509 TypedQuote(::std::boxed::Box<TypedQuote<'tree>>),
510 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
511 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
512 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
513 Unit(::std::boxed::Box<Unit<'tree>>),
514 Variable(::std::boxed::Box<Variable<'tree>>),
515}
516impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
517 #[allow(clippy::collapsible_else_if)]
518 fn from_node(
519 node: ::treesitter_types::tree_sitter::Node<'tree>,
520 src: &'tree [u8],
521 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
522 match node.kind() {
523 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
524 ::treesitter_types::runtime::maybe_grow_stack(|| {
525 <Apply as ::treesitter_types::FromNode>::from_node(node, src)
526 })?,
527 ))),
528 "arithmetic_sequence" => Ok(Self::ArithmeticSequence(::std::boxed::Box::new(
529 ::treesitter_types::runtime::maybe_grow_stack(|| {
530 <ArithmeticSequence as ::treesitter_types::FromNode>::from_node(node, src)
531 })?,
532 ))),
533 "case" => Ok(Self::Case(::std::boxed::Box::new(
534 ::treesitter_types::runtime::maybe_grow_stack(|| {
535 <Case as ::treesitter_types::FromNode>::from_node(node, src)
536 })?,
537 ))),
538 "conditional" => Ok(Self::Conditional(::std::boxed::Box::new(
539 ::treesitter_types::runtime::maybe_grow_stack(|| {
540 <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
541 })?,
542 ))),
543 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
544 ::treesitter_types::runtime::maybe_grow_stack(|| {
545 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
546 })?,
547 ))),
548 "do" => Ok(Self::Do(::std::boxed::Box::new(
549 ::treesitter_types::runtime::maybe_grow_stack(|| {
550 <Do as ::treesitter_types::FromNode>::from_node(node, src)
551 })?,
552 ))),
553 "implicit_variable" => Ok(Self::ImplicitVariable(::std::boxed::Box::new(
554 ::treesitter_types::runtime::maybe_grow_stack(|| {
555 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)
556 })?,
557 ))),
558 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
559 ::treesitter_types::runtime::maybe_grow_stack(|| {
560 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
561 })?,
562 ))),
563 "label" => Ok(Self::Label(::std::boxed::Box::new(
564 ::treesitter_types::runtime::maybe_grow_stack(|| {
565 <Label as ::treesitter_types::FromNode>::from_node(node, src)
566 })?,
567 ))),
568 "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
569 ::treesitter_types::runtime::maybe_grow_stack(|| {
570 <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
571 })?,
572 ))),
573 "lambda_case" => Ok(Self::LambdaCase(::std::boxed::Box::new(
574 ::treesitter_types::runtime::maybe_grow_stack(|| {
575 <LambdaCase as ::treesitter_types::FromNode>::from_node(node, src)
576 })?,
577 ))),
578 "lambda_cases" => Ok(Self::LambdaCases(::std::boxed::Box::new(
579 ::treesitter_types::runtime::maybe_grow_stack(|| {
580 <LambdaCases as ::treesitter_types::FromNode>::from_node(node, src)
581 })?,
582 ))),
583 "left_section" => Ok(Self::LeftSection(::std::boxed::Box::new(
584 ::treesitter_types::runtime::maybe_grow_stack(|| {
585 <LeftSection as ::treesitter_types::FromNode>::from_node(node, src)
586 })?,
587 ))),
588 "let_in" => Ok(Self::LetIn(::std::boxed::Box::new(
589 ::treesitter_types::runtime::maybe_grow_stack(|| {
590 <LetIn as ::treesitter_types::FromNode>::from_node(node, src)
591 })?,
592 ))),
593 "list" => Ok(Self::List(::std::boxed::Box::new(
594 ::treesitter_types::runtime::maybe_grow_stack(|| {
595 <List as ::treesitter_types::FromNode>::from_node(node, src)
596 })?,
597 ))),
598 "list_comprehension" => Ok(Self::ListComprehension(::std::boxed::Box::new(
599 ::treesitter_types::runtime::maybe_grow_stack(|| {
600 <ListComprehension as ::treesitter_types::FromNode>::from_node(node, src)
601 })?,
602 ))),
603 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
604 ::treesitter_types::runtime::maybe_grow_stack(|| {
605 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
606 })?,
607 ))),
608 "multi_way_if" => Ok(Self::MultiWayIf(::std::boxed::Box::new(
609 ::treesitter_types::runtime::maybe_grow_stack(|| {
610 <MultiWayIf as ::treesitter_types::FromNode>::from_node(node, src)
611 })?,
612 ))),
613 "negation" => Ok(Self::Negation(::std::boxed::Box::new(
614 ::treesitter_types::runtime::maybe_grow_stack(|| {
615 <Negation as ::treesitter_types::FromNode>::from_node(node, src)
616 })?,
617 ))),
618 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
619 ::treesitter_types::runtime::maybe_grow_stack(|| {
620 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
621 })?,
622 ))),
623 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
624 ::treesitter_types::runtime::maybe_grow_stack(|| {
625 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
626 })?,
627 ))),
628 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
629 ::treesitter_types::runtime::maybe_grow_stack(|| {
630 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
631 })?,
632 ))),
633 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
634 ::treesitter_types::runtime::maybe_grow_stack(|| {
635 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
636 })?,
637 ))),
638 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
639 ::treesitter_types::runtime::maybe_grow_stack(|| {
640 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
641 })?,
642 ))),
643 "projection" => Ok(Self::Projection(::std::boxed::Box::new(
644 ::treesitter_types::runtime::maybe_grow_stack(|| {
645 <Projection as ::treesitter_types::FromNode>::from_node(node, src)
646 })?,
647 ))),
648 "projection_selector" => Ok(Self::ProjectionSelector(::std::boxed::Box::new(
649 ::treesitter_types::runtime::maybe_grow_stack(|| {
650 <ProjectionSelector as ::treesitter_types::FromNode>::from_node(node, src)
651 })?,
652 ))),
653 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
654 ::treesitter_types::runtime::maybe_grow_stack(|| {
655 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
656 })?,
657 ))),
658 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
659 ::treesitter_types::runtime::maybe_grow_stack(|| {
660 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
661 })?,
662 ))),
663 "quote" => Ok(Self::Quote(::std::boxed::Box::new(
664 ::treesitter_types::runtime::maybe_grow_stack(|| {
665 <Quote as ::treesitter_types::FromNode>::from_node(node, src)
666 })?,
667 ))),
668 "record" => Ok(Self::Record(::std::boxed::Box::new(
669 ::treesitter_types::runtime::maybe_grow_stack(|| {
670 <Record as ::treesitter_types::FromNode>::from_node(node, src)
671 })?,
672 ))),
673 "right_section" => Ok(Self::RightSection(::std::boxed::Box::new(
674 ::treesitter_types::runtime::maybe_grow_stack(|| {
675 <RightSection as ::treesitter_types::FromNode>::from_node(node, src)
676 })?,
677 ))),
678 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
679 ::treesitter_types::runtime::maybe_grow_stack(|| {
680 <Splice as ::treesitter_types::FromNode>::from_node(node, src)
681 })?,
682 ))),
683 "th_quoted_name" => Ok(Self::ThQuotedName(::std::boxed::Box::new(
684 ::treesitter_types::runtime::maybe_grow_stack(|| {
685 <ThQuotedName as ::treesitter_types::FromNode>::from_node(node, src)
686 })?,
687 ))),
688 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
689 ::treesitter_types::runtime::maybe_grow_stack(|| {
690 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
691 })?,
692 ))),
693 "typed_quote" => Ok(Self::TypedQuote(::std::boxed::Box::new(
694 ::treesitter_types::runtime::maybe_grow_stack(|| {
695 <TypedQuote as ::treesitter_types::FromNode>::from_node(node, src)
696 })?,
697 ))),
698 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
699 ::treesitter_types::runtime::maybe_grow_stack(|| {
700 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
701 })?,
702 ))),
703 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
704 ::treesitter_types::runtime::maybe_grow_stack(|| {
705 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
706 })?,
707 ))),
708 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
709 ::treesitter_types::runtime::maybe_grow_stack(|| {
710 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
711 })?,
712 ))),
713 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
714 ::treesitter_types::runtime::maybe_grow_stack(|| {
715 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
716 })?,
717 ))),
718 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
719 ::treesitter_types::runtime::maybe_grow_stack(|| {
720 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
721 })?,
722 ))),
723 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
724 }
725 }
726}
727impl ::treesitter_types::Spanned for Expression<'_> {
728 fn span(&self) -> ::treesitter_types::Span {
729 match self {
730 Self::Apply(inner) => inner.span(),
731 Self::ArithmeticSequence(inner) => inner.span(),
732 Self::Case(inner) => inner.span(),
733 Self::Conditional(inner) => inner.span(),
734 Self::Constructor(inner) => inner.span(),
735 Self::Do(inner) => inner.span(),
736 Self::ImplicitVariable(inner) => inner.span(),
737 Self::Infix(inner) => inner.span(),
738 Self::Label(inner) => inner.span(),
739 Self::Lambda(inner) => inner.span(),
740 Self::LambdaCase(inner) => inner.span(),
741 Self::LambdaCases(inner) => inner.span(),
742 Self::LeftSection(inner) => inner.span(),
743 Self::LetIn(inner) => inner.span(),
744 Self::List(inner) => inner.span(),
745 Self::ListComprehension(inner) => inner.span(),
746 Self::Literal(inner) => inner.span(),
747 Self::MultiWayIf(inner) => inner.span(),
748 Self::Negation(inner) => inner.span(),
749 Self::Parens(inner) => inner.span(),
750 Self::PrefixId(inner) => inner.span(),
751 Self::PrefixTuple(inner) => inner.span(),
752 Self::PrefixUnboxedSum(inner) => inner.span(),
753 Self::PrefixUnboxedTuple(inner) => inner.span(),
754 Self::Projection(inner) => inner.span(),
755 Self::ProjectionSelector(inner) => inner.span(),
756 Self::Qualified(inner) => inner.span(),
757 Self::Quasiquote(inner) => inner.span(),
758 Self::Quote(inner) => inner.span(),
759 Self::Record(inner) => inner.span(),
760 Self::RightSection(inner) => inner.span(),
761 Self::Splice(inner) => inner.span(),
762 Self::ThQuotedName(inner) => inner.span(),
763 Self::Tuple(inner) => inner.span(),
764 Self::TypedQuote(inner) => inner.span(),
765 Self::UnboxedSum(inner) => inner.span(),
766 Self::UnboxedTuple(inner) => inner.span(),
767 Self::UnboxedUnit(inner) => inner.span(),
768 Self::Unit(inner) => inner.span(),
769 Self::Variable(inner) => inner.span(),
770 }
771 }
772}
773#[derive(Debug, Clone, PartialEq, Eq)]
774pub enum Guard<'tree> {
775 Boolean(::std::boxed::Box<Boolean<'tree>>),
776 Let(::std::boxed::Box<Let<'tree>>),
777 PatternGuard(::std::boxed::Box<PatternGuard<'tree>>),
778}
779impl<'tree> ::treesitter_types::FromNode<'tree> for Guard<'tree> {
780 #[allow(clippy::collapsible_else_if)]
781 fn from_node(
782 node: ::treesitter_types::tree_sitter::Node<'tree>,
783 src: &'tree [u8],
784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
785 match node.kind() {
786 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
787 ::treesitter_types::runtime::maybe_grow_stack(|| {
788 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
789 })?,
790 ))),
791 "let" => Ok(Self::Let(::std::boxed::Box::new(
792 ::treesitter_types::runtime::maybe_grow_stack(|| {
793 <Let as ::treesitter_types::FromNode>::from_node(node, src)
794 })?,
795 ))),
796 "pattern_guard" => Ok(Self::PatternGuard(::std::boxed::Box::new(
797 ::treesitter_types::runtime::maybe_grow_stack(|| {
798 <PatternGuard as ::treesitter_types::FromNode>::from_node(node, src)
799 })?,
800 ))),
801 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
802 }
803 }
804}
805impl ::treesitter_types::Spanned for Guard<'_> {
806 fn span(&self) -> ::treesitter_types::Span {
807 match self {
808 Self::Boolean(inner) => inner.span(),
809 Self::Let(inner) => inner.span(),
810 Self::PatternGuard(inner) => inner.span(),
811 }
812 }
813}
814#[derive(Debug, Clone, PartialEq, Eq)]
815pub enum InstanceDecl<'tree> {
816 DataInstance(::std::boxed::Box<DataInstance<'tree>>),
817 Decl(::std::boxed::Box<Decl<'tree>>),
818 TypeInstance(::std::boxed::Box<TypeInstance<'tree>>),
819}
820impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceDecl<'tree> {
821 #[allow(clippy::collapsible_else_if)]
822 fn from_node(
823 node: ::treesitter_types::tree_sitter::Node<'tree>,
824 src: &'tree [u8],
825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
826 match node.kind() {
827 "data_instance" => Ok(Self::DataInstance(::std::boxed::Box::new(
828 ::treesitter_types::runtime::maybe_grow_stack(|| {
829 <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)
830 })?,
831 ))),
832 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
833 ::treesitter_types::runtime::maybe_grow_stack(|| {
834 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)
835 })?,
836 ))),
837 _other => {
838 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
839 <Decl as ::treesitter_types::FromNode>::from_node(node, src)
840 }) {
841 Ok(Self::Decl(::std::boxed::Box::new(v)))
842 } else {
843 Err(::treesitter_types::ParseError::unexpected_kind(
844 _other, node,
845 ))
846 }
847 }
848 }
849 }
850}
851impl ::treesitter_types::Spanned for InstanceDecl<'_> {
852 fn span(&self) -> ::treesitter_types::Span {
853 match self {
854 Self::DataInstance(inner) => inner.span(),
855 Self::Decl(inner) => inner.span(),
856 Self::TypeInstance(inner) => inner.span(),
857 }
858 }
859}
860#[derive(Debug, Clone, PartialEq, Eq)]
861pub enum Pattern<'tree> {
862 Apply(::std::boxed::Box<Apply<'tree>>),
863 As(::std::boxed::Box<As<'tree>>),
864 Constructor(::std::boxed::Box<Constructor<'tree>>),
865 Infix(::std::boxed::Box<Infix<'tree>>),
866 Irrefutable(::std::boxed::Box<Irrefutable<'tree>>),
867 List(::std::boxed::Box<List<'tree>>),
868 Literal(::std::boxed::Box<Literal<'tree>>),
869 Negation(::std::boxed::Box<Negation<'tree>>),
870 Parens(::std::boxed::Box<Parens<'tree>>),
871 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
872 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
873 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
874 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
875 Qualified(::std::boxed::Box<Qualified<'tree>>),
876 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
877 Record(::std::boxed::Box<Record<'tree>>),
878 Splice(::std::boxed::Box<Splice<'tree>>),
879 Strict(::std::boxed::Box<Strict<'tree>>),
880 Tuple(::std::boxed::Box<Tuple<'tree>>),
881 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
882 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
883 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
884 Unit(::std::boxed::Box<Unit<'tree>>),
885 Variable(::std::boxed::Box<Variable<'tree>>),
886 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
887}
888impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
889 #[allow(clippy::collapsible_else_if)]
890 fn from_node(
891 node: ::treesitter_types::tree_sitter::Node<'tree>,
892 src: &'tree [u8],
893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
894 match node.kind() {
895 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
896 ::treesitter_types::runtime::maybe_grow_stack(|| {
897 <Apply as ::treesitter_types::FromNode>::from_node(node, src)
898 })?,
899 ))),
900 "as" => Ok(Self::As(::std::boxed::Box::new(
901 ::treesitter_types::runtime::maybe_grow_stack(|| {
902 <As as ::treesitter_types::FromNode>::from_node(node, src)
903 })?,
904 ))),
905 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
906 ::treesitter_types::runtime::maybe_grow_stack(|| {
907 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
908 })?,
909 ))),
910 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
911 ::treesitter_types::runtime::maybe_grow_stack(|| {
912 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
913 })?,
914 ))),
915 "irrefutable" => Ok(Self::Irrefutable(::std::boxed::Box::new(
916 ::treesitter_types::runtime::maybe_grow_stack(|| {
917 <Irrefutable as ::treesitter_types::FromNode>::from_node(node, src)
918 })?,
919 ))),
920 "list" => Ok(Self::List(::std::boxed::Box::new(
921 ::treesitter_types::runtime::maybe_grow_stack(|| {
922 <List as ::treesitter_types::FromNode>::from_node(node, src)
923 })?,
924 ))),
925 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
926 ::treesitter_types::runtime::maybe_grow_stack(|| {
927 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
928 })?,
929 ))),
930 "negation" => Ok(Self::Negation(::std::boxed::Box::new(
931 ::treesitter_types::runtime::maybe_grow_stack(|| {
932 <Negation as ::treesitter_types::FromNode>::from_node(node, src)
933 })?,
934 ))),
935 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
936 ::treesitter_types::runtime::maybe_grow_stack(|| {
937 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
938 })?,
939 ))),
940 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
941 ::treesitter_types::runtime::maybe_grow_stack(|| {
942 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
943 })?,
944 ))),
945 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
946 ::treesitter_types::runtime::maybe_grow_stack(|| {
947 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
948 })?,
949 ))),
950 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
951 ::treesitter_types::runtime::maybe_grow_stack(|| {
952 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
953 })?,
954 ))),
955 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
956 ::treesitter_types::runtime::maybe_grow_stack(|| {
957 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
958 })?,
959 ))),
960 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
961 ::treesitter_types::runtime::maybe_grow_stack(|| {
962 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
963 })?,
964 ))),
965 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
966 ::treesitter_types::runtime::maybe_grow_stack(|| {
967 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
968 })?,
969 ))),
970 "record" => Ok(Self::Record(::std::boxed::Box::new(
971 ::treesitter_types::runtime::maybe_grow_stack(|| {
972 <Record as ::treesitter_types::FromNode>::from_node(node, src)
973 })?,
974 ))),
975 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
976 ::treesitter_types::runtime::maybe_grow_stack(|| {
977 <Splice as ::treesitter_types::FromNode>::from_node(node, src)
978 })?,
979 ))),
980 "strict" => Ok(Self::Strict(::std::boxed::Box::new(
981 ::treesitter_types::runtime::maybe_grow_stack(|| {
982 <Strict as ::treesitter_types::FromNode>::from_node(node, src)
983 })?,
984 ))),
985 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
986 ::treesitter_types::runtime::maybe_grow_stack(|| {
987 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
988 })?,
989 ))),
990 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
991 ::treesitter_types::runtime::maybe_grow_stack(|| {
992 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
993 })?,
994 ))),
995 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
996 ::treesitter_types::runtime::maybe_grow_stack(|| {
997 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
998 })?,
999 ))),
1000 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
1001 ::treesitter_types::runtime::maybe_grow_stack(|| {
1002 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
1003 })?,
1004 ))),
1005 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
1006 ::treesitter_types::runtime::maybe_grow_stack(|| {
1007 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
1008 })?,
1009 ))),
1010 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
1011 ::treesitter_types::runtime::maybe_grow_stack(|| {
1012 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
1013 })?,
1014 ))),
1015 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
1016 ::treesitter_types::runtime::maybe_grow_stack(|| {
1017 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
1018 })?,
1019 ))),
1020 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1021 }
1022 }
1023}
1024impl ::treesitter_types::Spanned for Pattern<'_> {
1025 fn span(&self) -> ::treesitter_types::Span {
1026 match self {
1027 Self::Apply(inner) => inner.span(),
1028 Self::As(inner) => inner.span(),
1029 Self::Constructor(inner) => inner.span(),
1030 Self::Infix(inner) => inner.span(),
1031 Self::Irrefutable(inner) => inner.span(),
1032 Self::List(inner) => inner.span(),
1033 Self::Literal(inner) => inner.span(),
1034 Self::Negation(inner) => inner.span(),
1035 Self::Parens(inner) => inner.span(),
1036 Self::PrefixId(inner) => inner.span(),
1037 Self::PrefixTuple(inner) => inner.span(),
1038 Self::PrefixUnboxedSum(inner) => inner.span(),
1039 Self::PrefixUnboxedTuple(inner) => inner.span(),
1040 Self::Qualified(inner) => inner.span(),
1041 Self::Quasiquote(inner) => inner.span(),
1042 Self::Record(inner) => inner.span(),
1043 Self::Splice(inner) => inner.span(),
1044 Self::Strict(inner) => inner.span(),
1045 Self::Tuple(inner) => inner.span(),
1046 Self::UnboxedSum(inner) => inner.span(),
1047 Self::UnboxedTuple(inner) => inner.span(),
1048 Self::UnboxedUnit(inner) => inner.span(),
1049 Self::Unit(inner) => inner.span(),
1050 Self::Variable(inner) => inner.span(),
1051 Self::Wildcard(inner) => inner.span(),
1052 }
1053 }
1054}
1055#[derive(Debug, Clone, PartialEq, Eq)]
1056pub enum Qualifier<'tree> {
1057 Boolean(::std::boxed::Box<Boolean<'tree>>),
1058 Generator(::std::boxed::Box<Generator<'tree>>),
1059 Group(::std::boxed::Box<Group<'tree>>),
1060 Let(::std::boxed::Box<Let<'tree>>),
1061 Transform(::std::boxed::Box<Transform<'tree>>),
1062}
1063impl<'tree> ::treesitter_types::FromNode<'tree> for Qualifier<'tree> {
1064 #[allow(clippy::collapsible_else_if)]
1065 fn from_node(
1066 node: ::treesitter_types::tree_sitter::Node<'tree>,
1067 src: &'tree [u8],
1068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1069 match node.kind() {
1070 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
1071 ::treesitter_types::runtime::maybe_grow_stack(|| {
1072 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
1073 })?,
1074 ))),
1075 "generator" => Ok(Self::Generator(::std::boxed::Box::new(
1076 ::treesitter_types::runtime::maybe_grow_stack(|| {
1077 <Generator as ::treesitter_types::FromNode>::from_node(node, src)
1078 })?,
1079 ))),
1080 "group" => Ok(Self::Group(::std::boxed::Box::new(
1081 ::treesitter_types::runtime::maybe_grow_stack(|| {
1082 <Group as ::treesitter_types::FromNode>::from_node(node, src)
1083 })?,
1084 ))),
1085 "let" => Ok(Self::Let(::std::boxed::Box::new(
1086 ::treesitter_types::runtime::maybe_grow_stack(|| {
1087 <Let as ::treesitter_types::FromNode>::from_node(node, src)
1088 })?,
1089 ))),
1090 "transform" => Ok(Self::Transform(::std::boxed::Box::new(
1091 ::treesitter_types::runtime::maybe_grow_stack(|| {
1092 <Transform as ::treesitter_types::FromNode>::from_node(node, src)
1093 })?,
1094 ))),
1095 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1096 }
1097 }
1098}
1099impl ::treesitter_types::Spanned for Qualifier<'_> {
1100 fn span(&self) -> ::treesitter_types::Span {
1101 match self {
1102 Self::Boolean(inner) => inner.span(),
1103 Self::Generator(inner) => inner.span(),
1104 Self::Group(inner) => inner.span(),
1105 Self::Let(inner) => inner.span(),
1106 Self::Transform(inner) => inner.span(),
1107 }
1108 }
1109}
1110#[derive(Debug, Clone, PartialEq, Eq)]
1111pub enum QuantifiedType<'tree> {
1112 Context(::std::boxed::Box<Context<'tree>>),
1113 Forall(::std::boxed::Box<Forall<'tree>>),
1114 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
1115 Function(::std::boxed::Box<Function<'tree>>),
1116 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
1117 LinearFunction(::std::boxed::Box<LinearFunction<'tree>>),
1118 Type(::std::boxed::Box<Type<'tree>>),
1119}
1120impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedType<'tree> {
1121 #[allow(clippy::collapsible_else_if)]
1122 fn from_node(
1123 node: ::treesitter_types::tree_sitter::Node<'tree>,
1124 src: &'tree [u8],
1125 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1126 match node.kind() {
1127 "context" => Ok(Self::Context(::std::boxed::Box::new(
1128 ::treesitter_types::runtime::maybe_grow_stack(|| {
1129 <Context as ::treesitter_types::FromNode>::from_node(node, src)
1130 })?,
1131 ))),
1132 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
1133 ::treesitter_types::runtime::maybe_grow_stack(|| {
1134 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
1135 })?,
1136 ))),
1137 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
1138 ::treesitter_types::runtime::maybe_grow_stack(|| {
1139 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
1140 })?,
1141 ))),
1142 "function" => Ok(Self::Function(::std::boxed::Box::new(
1143 ::treesitter_types::runtime::maybe_grow_stack(|| {
1144 <Function as ::treesitter_types::FromNode>::from_node(node, src)
1145 })?,
1146 ))),
1147 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
1148 ::treesitter_types::runtime::maybe_grow_stack(|| {
1149 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
1150 })?,
1151 ))),
1152 "linear_function" => Ok(Self::LinearFunction(::std::boxed::Box::new(
1153 ::treesitter_types::runtime::maybe_grow_stack(|| {
1154 <LinearFunction as ::treesitter_types::FromNode>::from_node(node, src)
1155 })?,
1156 ))),
1157 _other => {
1158 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
1159 <Type as ::treesitter_types::FromNode>::from_node(node, src)
1160 }) {
1161 Ok(Self::Type(::std::boxed::Box::new(v)))
1162 } else {
1163 Err(::treesitter_types::ParseError::unexpected_kind(
1164 _other, node,
1165 ))
1166 }
1167 }
1168 }
1169 }
1170}
1171impl ::treesitter_types::Spanned for QuantifiedType<'_> {
1172 fn span(&self) -> ::treesitter_types::Span {
1173 match self {
1174 Self::Context(inner) => inner.span(),
1175 Self::Forall(inner) => inner.span(),
1176 Self::ForallRequired(inner) => inner.span(),
1177 Self::Function(inner) => inner.span(),
1178 Self::ImplicitParameter(inner) => inner.span(),
1179 Self::LinearFunction(inner) => inner.span(),
1180 Self::Type(inner) => inner.span(),
1181 }
1182 }
1183}
1184#[derive(Debug, Clone, PartialEq, Eq)]
1185pub enum Statement<'tree> {
1186 Bind(::std::boxed::Box<Bind<'tree>>),
1187 Exp(::std::boxed::Box<Exp<'tree>>),
1188 Let(::std::boxed::Box<Let<'tree>>),
1189 Rec(::std::boxed::Box<Rec<'tree>>),
1190}
1191impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
1192 #[allow(clippy::collapsible_else_if)]
1193 fn from_node(
1194 node: ::treesitter_types::tree_sitter::Node<'tree>,
1195 src: &'tree [u8],
1196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1197 match node.kind() {
1198 "bind" => Ok(Self::Bind(::std::boxed::Box::new(
1199 ::treesitter_types::runtime::maybe_grow_stack(|| {
1200 <Bind as ::treesitter_types::FromNode>::from_node(node, src)
1201 })?,
1202 ))),
1203 "exp" => Ok(Self::Exp(::std::boxed::Box::new(
1204 ::treesitter_types::runtime::maybe_grow_stack(|| {
1205 <Exp as ::treesitter_types::FromNode>::from_node(node, src)
1206 })?,
1207 ))),
1208 "let" => Ok(Self::Let(::std::boxed::Box::new(
1209 ::treesitter_types::runtime::maybe_grow_stack(|| {
1210 <Let as ::treesitter_types::FromNode>::from_node(node, src)
1211 })?,
1212 ))),
1213 "rec" => Ok(Self::Rec(::std::boxed::Box::new(
1214 ::treesitter_types::runtime::maybe_grow_stack(|| {
1215 <Rec as ::treesitter_types::FromNode>::from_node(node, src)
1216 })?,
1217 ))),
1218 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1219 }
1220 }
1221}
1222impl ::treesitter_types::Spanned for Statement<'_> {
1223 fn span(&self) -> ::treesitter_types::Span {
1224 match self {
1225 Self::Bind(inner) => inner.span(),
1226 Self::Exp(inner) => inner.span(),
1227 Self::Let(inner) => inner.span(),
1228 Self::Rec(inner) => inner.span(),
1229 }
1230 }
1231}
1232#[derive(Debug, Clone, PartialEq, Eq)]
1233pub enum Type<'tree> {
1234 Apply(::std::boxed::Box<Apply<'tree>>),
1235 Infix(::std::boxed::Box<Infix<'tree>>),
1236 List(::std::boxed::Box<List<'tree>>),
1237 Literal(::std::boxed::Box<Literal<'tree>>),
1238 Name(::std::boxed::Box<Name<'tree>>),
1239 Parens(::std::boxed::Box<Parens<'tree>>),
1240 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
1241 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
1242 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
1243 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
1244 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
1245 Promoted(::std::boxed::Box<Promoted<'tree>>),
1246 Qualified(::std::boxed::Box<Qualified<'tree>>),
1247 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
1248 Splice(::std::boxed::Box<Splice<'tree>>),
1249 Star(::std::boxed::Box<Star<'tree>>),
1250 Tuple(::std::boxed::Box<Tuple<'tree>>),
1251 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
1252 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
1253 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
1254 Unit(::std::boxed::Box<Unit<'tree>>),
1255 Variable(::std::boxed::Box<Variable<'tree>>),
1256 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
1257}
1258impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
1259 #[allow(clippy::collapsible_else_if)]
1260 fn from_node(
1261 node: ::treesitter_types::tree_sitter::Node<'tree>,
1262 src: &'tree [u8],
1263 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1264 match node.kind() {
1265 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
1266 ::treesitter_types::runtime::maybe_grow_stack(|| {
1267 <Apply as ::treesitter_types::FromNode>::from_node(node, src)
1268 })?,
1269 ))),
1270 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
1271 ::treesitter_types::runtime::maybe_grow_stack(|| {
1272 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
1273 })?,
1274 ))),
1275 "list" => Ok(Self::List(::std::boxed::Box::new(
1276 ::treesitter_types::runtime::maybe_grow_stack(|| {
1277 <List as ::treesitter_types::FromNode>::from_node(node, src)
1278 })?,
1279 ))),
1280 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
1281 ::treesitter_types::runtime::maybe_grow_stack(|| {
1282 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
1283 })?,
1284 ))),
1285 "name" => Ok(Self::Name(::std::boxed::Box::new(
1286 ::treesitter_types::runtime::maybe_grow_stack(|| {
1287 <Name as ::treesitter_types::FromNode>::from_node(node, src)
1288 })?,
1289 ))),
1290 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
1291 ::treesitter_types::runtime::maybe_grow_stack(|| {
1292 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
1293 })?,
1294 ))),
1295 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
1296 ::treesitter_types::runtime::maybe_grow_stack(|| {
1297 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
1298 })?,
1299 ))),
1300 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
1301 ::treesitter_types::runtime::maybe_grow_stack(|| {
1302 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
1303 })?,
1304 ))),
1305 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
1306 ::treesitter_types::runtime::maybe_grow_stack(|| {
1307 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
1308 })?,
1309 ))),
1310 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
1311 ::treesitter_types::runtime::maybe_grow_stack(|| {
1312 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
1313 })?,
1314 ))),
1315 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
1316 ::treesitter_types::runtime::maybe_grow_stack(|| {
1317 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
1318 })?,
1319 ))),
1320 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
1321 ::treesitter_types::runtime::maybe_grow_stack(|| {
1322 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)
1323 })?,
1324 ))),
1325 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
1326 ::treesitter_types::runtime::maybe_grow_stack(|| {
1327 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
1328 })?,
1329 ))),
1330 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
1331 ::treesitter_types::runtime::maybe_grow_stack(|| {
1332 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
1333 })?,
1334 ))),
1335 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
1336 ::treesitter_types::runtime::maybe_grow_stack(|| {
1337 <Splice as ::treesitter_types::FromNode>::from_node(node, src)
1338 })?,
1339 ))),
1340 "star" => Ok(Self::Star(::std::boxed::Box::new(
1341 ::treesitter_types::runtime::maybe_grow_stack(|| {
1342 <Star as ::treesitter_types::FromNode>::from_node(node, src)
1343 })?,
1344 ))),
1345 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
1346 ::treesitter_types::runtime::maybe_grow_stack(|| {
1347 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
1348 })?,
1349 ))),
1350 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
1351 ::treesitter_types::runtime::maybe_grow_stack(|| {
1352 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
1353 })?,
1354 ))),
1355 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
1356 ::treesitter_types::runtime::maybe_grow_stack(|| {
1357 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
1358 })?,
1359 ))),
1360 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
1361 ::treesitter_types::runtime::maybe_grow_stack(|| {
1362 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
1363 })?,
1364 ))),
1365 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
1366 ::treesitter_types::runtime::maybe_grow_stack(|| {
1367 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
1368 })?,
1369 ))),
1370 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
1371 ::treesitter_types::runtime::maybe_grow_stack(|| {
1372 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
1373 })?,
1374 ))),
1375 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
1376 ::treesitter_types::runtime::maybe_grow_stack(|| {
1377 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
1378 })?,
1379 ))),
1380 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1381 }
1382 }
1383}
1384impl ::treesitter_types::Spanned for Type<'_> {
1385 fn span(&self) -> ::treesitter_types::Span {
1386 match self {
1387 Self::Apply(inner) => inner.span(),
1388 Self::Infix(inner) => inner.span(),
1389 Self::List(inner) => inner.span(),
1390 Self::Literal(inner) => inner.span(),
1391 Self::Name(inner) => inner.span(),
1392 Self::Parens(inner) => inner.span(),
1393 Self::PrefixId(inner) => inner.span(),
1394 Self::PrefixList(inner) => inner.span(),
1395 Self::PrefixTuple(inner) => inner.span(),
1396 Self::PrefixUnboxedSum(inner) => inner.span(),
1397 Self::PrefixUnboxedTuple(inner) => inner.span(),
1398 Self::Promoted(inner) => inner.span(),
1399 Self::Qualified(inner) => inner.span(),
1400 Self::Quasiquote(inner) => inner.span(),
1401 Self::Splice(inner) => inner.span(),
1402 Self::Star(inner) => inner.span(),
1403 Self::Tuple(inner) => inner.span(),
1404 Self::UnboxedSum(inner) => inner.span(),
1405 Self::UnboxedTuple(inner) => inner.span(),
1406 Self::UnboxedUnit(inner) => inner.span(),
1407 Self::Unit(inner) => inner.span(),
1408 Self::Variable(inner) => inner.span(),
1409 Self::Wildcard(inner) => inner.span(),
1410 }
1411 }
1412}
1413#[derive(Debug, Clone, PartialEq, Eq)]
1414pub enum TypeParam<'tree> {
1415 Invisible(::std::boxed::Box<Invisible<'tree>>),
1416 Parens(::std::boxed::Box<Parens<'tree>>),
1417 Variable(::std::boxed::Box<Variable<'tree>>),
1418 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
1419}
1420impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParam<'tree> {
1421 #[allow(clippy::collapsible_else_if)]
1422 fn from_node(
1423 node: ::treesitter_types::tree_sitter::Node<'tree>,
1424 src: &'tree [u8],
1425 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1426 match node.kind() {
1427 "invisible" => Ok(Self::Invisible(::std::boxed::Box::new(
1428 ::treesitter_types::runtime::maybe_grow_stack(|| {
1429 <Invisible as ::treesitter_types::FromNode>::from_node(node, src)
1430 })?,
1431 ))),
1432 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
1433 ::treesitter_types::runtime::maybe_grow_stack(|| {
1434 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
1435 })?,
1436 ))),
1437 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
1438 ::treesitter_types::runtime::maybe_grow_stack(|| {
1439 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
1440 })?,
1441 ))),
1442 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
1443 ::treesitter_types::runtime::maybe_grow_stack(|| {
1444 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
1445 })?,
1446 ))),
1447 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1448 }
1449 }
1450}
1451impl ::treesitter_types::Spanned for TypeParam<'_> {
1452 fn span(&self) -> ::treesitter_types::Span {
1453 match self {
1454 Self::Invisible(inner) => inner.span(),
1455 Self::Parens(inner) => inner.span(),
1456 Self::Variable(inner) => inner.span(),
1457 Self::Wildcard(inner) => inner.span(),
1458 }
1459 }
1460}
1461#[derive(Debug, Clone, PartialEq, Eq)]
1462pub struct AbstractFamily<'tree> {
1463 pub span: ::treesitter_types::Span,
1464 text: &'tree str,
1465}
1466impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFamily<'tree> {
1467 fn from_node(
1468 node: ::treesitter_types::tree_sitter::Node<'tree>,
1469 src: &'tree [u8],
1470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1471 debug_assert_eq!(node.kind(), "abstract_family");
1472 Ok(Self {
1473 span: ::treesitter_types::Span::from(node),
1474 text: node.utf8_text(src)?,
1475 })
1476 }
1477}
1478impl<'tree> ::treesitter_types::LeafNode<'tree> for AbstractFamily<'tree> {
1479 fn text(&self) -> &'tree str {
1480 self.text
1481 }
1482}
1483impl ::treesitter_types::Spanned for AbstractFamily<'_> {
1484 fn span(&self) -> ::treesitter_types::Span {
1485 self.span
1486 }
1487}
1488#[derive(Debug, Clone, PartialEq, Eq)]
1489pub struct Alternative<'tree> {
1490 pub span: ::treesitter_types::Span,
1491 pub binds: ::core::option::Option<LocalBinds<'tree>>,
1492 pub r#match: ::std::vec::Vec<Match<'tree>>,
1493 pub pattern: ::core::option::Option<AlternativePattern<'tree>>,
1494 pub patterns: ::core::option::Option<Patterns<'tree>>,
1495}
1496impl<'tree> ::treesitter_types::FromNode<'tree> for Alternative<'tree> {
1497 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1498 fn from_node(
1499 node: ::treesitter_types::tree_sitter::Node<'tree>,
1500 src: &'tree [u8],
1501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1502 debug_assert_eq!(node.kind(), "alternative");
1503 Ok(Self {
1504 span: ::treesitter_types::Span::from(node),
1505 binds: match node.child_by_field_name("binds") {
1506 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1507 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
1508 })?),
1509 None => None,
1510 },
1511 r#match: {
1512 let mut cursor = node.walk();
1513 let mut items = ::std::vec::Vec::new();
1514 for child in node.children_by_field_name("match", &mut cursor) {
1515 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1516 <Match as ::treesitter_types::FromNode>::from_node(child, src)
1517 })?);
1518 }
1519 items
1520 },
1521 pattern: match node.child_by_field_name("pattern") {
1522 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1523 <AlternativePattern as ::treesitter_types::FromNode>::from_node(child, src)
1524 })?),
1525 None => None,
1526 },
1527 patterns: match node.child_by_field_name("patterns") {
1528 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1529 <Patterns as ::treesitter_types::FromNode>::from_node(child, src)
1530 })?),
1531 None => None,
1532 },
1533 })
1534 }
1535}
1536impl ::treesitter_types::Spanned for Alternative<'_> {
1537 fn span(&self) -> ::treesitter_types::Span {
1538 self.span
1539 }
1540}
1541#[derive(Debug, Clone, PartialEq, Eq)]
1542pub struct Alternatives<'tree> {
1543 pub span: ::treesitter_types::Span,
1544 pub alternative: ::std::vec::Vec<Alternative<'tree>>,
1545}
1546impl<'tree> ::treesitter_types::FromNode<'tree> for Alternatives<'tree> {
1547 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1548 fn from_node(
1549 node: ::treesitter_types::tree_sitter::Node<'tree>,
1550 src: &'tree [u8],
1551 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1552 debug_assert_eq!(node.kind(), "alternatives");
1553 Ok(Self {
1554 span: ::treesitter_types::Span::from(node),
1555 alternative: {
1556 let mut cursor = node.walk();
1557 let mut items = ::std::vec::Vec::new();
1558 for child in node.children_by_field_name("alternative", &mut cursor) {
1559 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1560 <Alternative as ::treesitter_types::FromNode>::from_node(child, src)
1561 })?);
1562 }
1563 items
1564 },
1565 })
1566 }
1567}
1568impl ::treesitter_types::Spanned for Alternatives<'_> {
1569 fn span(&self) -> ::treesitter_types::Span {
1570 self.span
1571 }
1572}
1573#[derive(Debug, Clone, PartialEq, Eq)]
1574pub struct Annotated<'tree> {
1575 pub span: ::treesitter_types::Span,
1576 pub kind: QuantifiedType<'tree>,
1577 pub children: TypeParam<'tree>,
1578}
1579impl<'tree> ::treesitter_types::FromNode<'tree> for Annotated<'tree> {
1580 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1581 fn from_node(
1582 node: ::treesitter_types::tree_sitter::Node<'tree>,
1583 src: &'tree [u8],
1584 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1585 debug_assert_eq!(node.kind(), "annotated");
1586 Ok(Self {
1587 span: ::treesitter_types::Span::from(node),
1588 kind: {
1589 let child = node
1590 .child_by_field_name("kind")
1591 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
1592 ::treesitter_types::runtime::maybe_grow_stack(|| {
1593 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
1594 })?
1595 },
1596 children: {
1597 #[allow(clippy::suspicious_else_formatting)]
1598 let non_field_children = {
1599 let mut cursor = node.walk();
1600 let mut result = ::std::vec::Vec::new();
1601 if cursor.goto_first_child() {
1602 loop {
1603 if cursor.field_name().is_none()
1604 && cursor.node().is_named()
1605 && !cursor.node().is_extra()
1606 {
1607 result.push(cursor.node());
1608 }
1609 if !cursor.goto_next_sibling() {
1610 break;
1611 }
1612 }
1613 }
1614 result
1615 };
1616 let child = if let Some(&c) = non_field_children.first() {
1617 c
1618 } else {
1619 let mut fallback_cursor = node.walk();
1620 let mut fallback_child = None;
1621 if fallback_cursor.goto_first_child() {
1622 loop {
1623 if fallback_cursor.field_name().is_none()
1624 && !fallback_cursor.node().is_extra()
1625 {
1626 let candidate = fallback_cursor.node();
1627 #[allow(clippy::needless_question_mark)]
1628 if (|| -> ::core::result::Result<
1629 _,
1630 ::treesitter_types::ParseError,
1631 > {
1632 let child = candidate;
1633 Ok(
1634 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeParam as ::treesitter_types::FromNode>::from_node(
1635 child,
1636 src,
1637 ))?,
1638 )
1639 })()
1640 .is_ok()
1641 {
1642 fallback_child = Some(candidate);
1643 break;
1644 }
1645 }
1646 if !fallback_cursor.goto_next_sibling() {
1647 break;
1648 }
1649 }
1650 }
1651 if fallback_child.is_none() {
1652 let mut cursor2 = node.walk();
1653 if cursor2.goto_first_child() {
1654 loop {
1655 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1656 let candidate = cursor2.node();
1657 #[allow(clippy::needless_question_mark)]
1658 if (|| -> ::core::result::Result<
1659 _,
1660 ::treesitter_types::ParseError,
1661 > {
1662 let child = candidate;
1663 Ok(
1664 ::treesitter_types::runtime::maybe_grow_stack(|| <TypeParam as ::treesitter_types::FromNode>::from_node(
1665 child,
1666 src,
1667 ))?,
1668 )
1669 })()
1670 .is_ok()
1671 {
1672 fallback_child = Some(candidate);
1673 break;
1674 }
1675 }
1676 if !cursor2.goto_next_sibling() {
1677 break;
1678 }
1679 }
1680 }
1681 }
1682 fallback_child.ok_or_else(|| {
1683 ::treesitter_types::ParseError::missing_field("children", node)
1684 })?
1685 };
1686 ::treesitter_types::runtime::maybe_grow_stack(|| {
1687 <TypeParam as ::treesitter_types::FromNode>::from_node(child, src)
1688 })?
1689 },
1690 })
1691 }
1692}
1693impl ::treesitter_types::Spanned for Annotated<'_> {
1694 fn span(&self) -> ::treesitter_types::Span {
1695 self.span
1696 }
1697}
1698#[derive(Debug, Clone, PartialEq, Eq)]
1699pub struct Apply<'tree> {
1700 pub span: ::treesitter_types::Span,
1701 pub argument: ApplyArgument<'tree>,
1702 pub constructor: ::core::option::Option<ApplyConstructor<'tree>>,
1703 pub function: ::core::option::Option<ApplyFunction<'tree>>,
1704}
1705impl<'tree> ::treesitter_types::FromNode<'tree> for Apply<'tree> {
1706 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1707 fn from_node(
1708 node: ::treesitter_types::tree_sitter::Node<'tree>,
1709 src: &'tree [u8],
1710 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1711 debug_assert_eq!(node.kind(), "apply");
1712 Ok(Self {
1713 span: ::treesitter_types::Span::from(node),
1714 argument: {
1715 let child = node.child_by_field_name("argument").ok_or_else(|| {
1716 ::treesitter_types::ParseError::missing_field("argument", node)
1717 })?;
1718 ::treesitter_types::runtime::maybe_grow_stack(|| {
1719 <ApplyArgument as ::treesitter_types::FromNode>::from_node(child, src)
1720 })?
1721 },
1722 constructor: match node.child_by_field_name("constructor") {
1723 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1724 <ApplyConstructor as ::treesitter_types::FromNode>::from_node(child, src)
1725 })?),
1726 None => None,
1727 },
1728 function: match node.child_by_field_name("function") {
1729 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1730 <ApplyFunction as ::treesitter_types::FromNode>::from_node(child, src)
1731 })?),
1732 None => None,
1733 },
1734 })
1735 }
1736}
1737impl ::treesitter_types::Spanned for Apply<'_> {
1738 fn span(&self) -> ::treesitter_types::Span {
1739 self.span
1740 }
1741}
1742#[derive(Debug, Clone, PartialEq, Eq)]
1743pub struct ArithmeticSequence<'tree> {
1744 pub span: ::treesitter_types::Span,
1745 pub from: ArithmeticSequenceFrom<'tree>,
1746 pub step: ::core::option::Option<ArithmeticSequenceStep<'tree>>,
1747 pub to: ::core::option::Option<ArithmeticSequenceTo<'tree>>,
1748}
1749impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequence<'tree> {
1750 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1751 fn from_node(
1752 node: ::treesitter_types::tree_sitter::Node<'tree>,
1753 src: &'tree [u8],
1754 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1755 debug_assert_eq!(node.kind(), "arithmetic_sequence");
1756 Ok(Self {
1757 span: ::treesitter_types::Span::from(node),
1758 from: {
1759 let child = node
1760 .child_by_field_name("from")
1761 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("from", node))?;
1762 ::treesitter_types::runtime::maybe_grow_stack(|| {
1763 <ArithmeticSequenceFrom as ::treesitter_types::FromNode>::from_node(child, src)
1764 })?
1765 },
1766 step: match node.child_by_field_name("step") {
1767 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1768 <ArithmeticSequenceStep as ::treesitter_types::FromNode>::from_node(child, src)
1769 })?),
1770 None => None,
1771 },
1772 to: match node.child_by_field_name("to") {
1773 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1774 <ArithmeticSequenceTo as ::treesitter_types::FromNode>::from_node(child, src)
1775 })?),
1776 None => None,
1777 },
1778 })
1779 }
1780}
1781impl ::treesitter_types::Spanned for ArithmeticSequence<'_> {
1782 fn span(&self) -> ::treesitter_types::Span {
1783 self.span
1784 }
1785}
1786#[derive(Debug, Clone, PartialEq, Eq)]
1787pub struct As<'tree> {
1788 pub span: ::treesitter_types::Span,
1789 pub bind: Variable<'tree>,
1790 pub pattern: Pattern<'tree>,
1791}
1792impl<'tree> ::treesitter_types::FromNode<'tree> for As<'tree> {
1793 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1794 fn from_node(
1795 node: ::treesitter_types::tree_sitter::Node<'tree>,
1796 src: &'tree [u8],
1797 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1798 debug_assert_eq!(node.kind(), "as");
1799 Ok(Self {
1800 span: ::treesitter_types::Span::from(node),
1801 bind: {
1802 let child = node
1803 .child_by_field_name("bind")
1804 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bind", node))?;
1805 ::treesitter_types::runtime::maybe_grow_stack(|| {
1806 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
1807 })?
1808 },
1809 pattern: {
1810 let child = node.child_by_field_name("pattern").ok_or_else(|| {
1811 ::treesitter_types::ParseError::missing_field("pattern", node)
1812 })?;
1813 ::treesitter_types::runtime::maybe_grow_stack(|| {
1814 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
1815 })?
1816 },
1817 })
1818 }
1819}
1820impl ::treesitter_types::Spanned for As<'_> {
1821 fn span(&self) -> ::treesitter_types::Span {
1822 self.span
1823 }
1824}
1825#[derive(Debug, Clone, PartialEq, Eq)]
1826pub struct AssociatedType<'tree> {
1827 pub span: ::treesitter_types::Span,
1828 pub namespace: AssociatedTypeNamespace,
1829 pub r#type: AssociatedTypeType<'tree>,
1830}
1831impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedType<'tree> {
1832 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1833 fn from_node(
1834 node: ::treesitter_types::tree_sitter::Node<'tree>,
1835 src: &'tree [u8],
1836 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1837 debug_assert_eq!(node.kind(), "associated_type");
1838 Ok(Self {
1839 span: ::treesitter_types::Span::from(node),
1840 namespace: {
1841 let child = node.child_by_field_name("namespace").ok_or_else(|| {
1842 ::treesitter_types::ParseError::missing_field("namespace", node)
1843 })?;
1844 ::treesitter_types::runtime::maybe_grow_stack(|| {
1845 <AssociatedTypeNamespace as ::treesitter_types::FromNode>::from_node(child, src)
1846 })?
1847 },
1848 r#type: {
1849 let child = node
1850 .child_by_field_name("type")
1851 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1852 ::treesitter_types::runtime::maybe_grow_stack(|| {
1853 <AssociatedTypeType as ::treesitter_types::FromNode>::from_node(child, src)
1854 })?
1855 },
1856 })
1857 }
1858}
1859impl ::treesitter_types::Spanned for AssociatedType<'_> {
1860 fn span(&self) -> ::treesitter_types::Span {
1861 self.span
1862 }
1863}
1864#[derive(Debug, Clone, PartialEq, Eq)]
1865pub struct Bind<'tree> {
1866 pub span: ::treesitter_types::Span,
1867 pub arrow: ::core::option::Option<BindArrow>,
1868 pub binds: ::core::option::Option<LocalBinds<'tree>>,
1869 pub expression: ::core::option::Option<BindExpression<'tree>>,
1870 pub implicit: ::core::option::Option<ImplicitVariable<'tree>>,
1871 pub r#match: ::std::vec::Vec<Match<'tree>>,
1872 pub name: ::core::option::Option<BindName<'tree>>,
1873 pub pattern: ::core::option::Option<BindPattern<'tree>>,
1874}
1875impl<'tree> ::treesitter_types::FromNode<'tree> for Bind<'tree> {
1876 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1877 fn from_node(
1878 node: ::treesitter_types::tree_sitter::Node<'tree>,
1879 src: &'tree [u8],
1880 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1881 debug_assert_eq!(node.kind(), "bind");
1882 Ok(Self {
1883 span: ::treesitter_types::Span::from(node),
1884 arrow: match node.child_by_field_name("arrow") {
1885 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1886 <BindArrow as ::treesitter_types::FromNode>::from_node(child, src)
1887 })?),
1888 None => None,
1889 },
1890 binds: match node.child_by_field_name("binds") {
1891 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1892 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
1893 })?),
1894 None => None,
1895 },
1896 expression: match node.child_by_field_name("expression") {
1897 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1898 <BindExpression as ::treesitter_types::FromNode>::from_node(child, src)
1899 })?),
1900 None => None,
1901 },
1902 implicit: match node.child_by_field_name("implicit") {
1903 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1904 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)
1905 })?),
1906 None => None,
1907 },
1908 r#match: {
1909 let mut cursor = node.walk();
1910 let mut items = ::std::vec::Vec::new();
1911 for child in node.children_by_field_name("match", &mut cursor) {
1912 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1913 <Match as ::treesitter_types::FromNode>::from_node(child, src)
1914 })?);
1915 }
1916 items
1917 },
1918 name: match node.child_by_field_name("name") {
1919 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1920 <BindName as ::treesitter_types::FromNode>::from_node(child, src)
1921 })?),
1922 None => None,
1923 },
1924 pattern: match node.child_by_field_name("pattern") {
1925 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
1926 <BindPattern as ::treesitter_types::FromNode>::from_node(child, src)
1927 })?),
1928 None => None,
1929 },
1930 })
1931 }
1932}
1933impl ::treesitter_types::Spanned for Bind<'_> {
1934 fn span(&self) -> ::treesitter_types::Span {
1935 self.span
1936 }
1937}
1938#[derive(Debug, Clone, PartialEq, Eq)]
1939pub struct BindingList<'tree> {
1940 pub span: ::treesitter_types::Span,
1941 pub name: ::std::vec::Vec<BindingListName<'tree>>,
1942}
1943impl<'tree> ::treesitter_types::FromNode<'tree> for BindingList<'tree> {
1944 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1945 fn from_node(
1946 node: ::treesitter_types::tree_sitter::Node<'tree>,
1947 src: &'tree [u8],
1948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1949 debug_assert_eq!(node.kind(), "binding_list");
1950 Ok(Self {
1951 span: ::treesitter_types::Span::from(node),
1952 name: {
1953 let mut cursor = node.walk();
1954 let mut items = ::std::vec::Vec::new();
1955 for child in node.children_by_field_name("name", &mut cursor) {
1956 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1957 <BindingListName as ::treesitter_types::FromNode>::from_node(child, src)
1958 })?);
1959 }
1960 items
1961 },
1962 })
1963 }
1964}
1965impl ::treesitter_types::Spanned for BindingList<'_> {
1966 fn span(&self) -> ::treesitter_types::Span {
1967 self.span
1968 }
1969}
1970#[derive(Debug, Clone, PartialEq, Eq)]
1971pub struct Boolean<'tree> {
1972 pub span: ::treesitter_types::Span,
1973 pub children: BooleanChildren<'tree>,
1974}
1975impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
1976 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1977 fn from_node(
1978 node: ::treesitter_types::tree_sitter::Node<'tree>,
1979 src: &'tree [u8],
1980 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1981 debug_assert_eq!(node.kind(), "boolean");
1982 Ok(Self {
1983 span: ::treesitter_types::Span::from(node),
1984 children: {
1985 #[allow(clippy::suspicious_else_formatting)]
1986 let non_field_children = {
1987 let mut cursor = node.walk();
1988 let mut result = ::std::vec::Vec::new();
1989 if cursor.goto_first_child() {
1990 loop {
1991 if cursor.field_name().is_none()
1992 && cursor.node().is_named()
1993 && !cursor.node().is_extra()
1994 {
1995 result.push(cursor.node());
1996 }
1997 if !cursor.goto_next_sibling() {
1998 break;
1999 }
2000 }
2001 }
2002 result
2003 };
2004 let child = if let Some(&c) = non_field_children.first() {
2005 c
2006 } else {
2007 let mut fallback_cursor = node.walk();
2008 let mut fallback_child = None;
2009 if fallback_cursor.goto_first_child() {
2010 loop {
2011 if fallback_cursor.field_name().is_none()
2012 && !fallback_cursor.node().is_extra()
2013 {
2014 let candidate = fallback_cursor.node();
2015 #[allow(clippy::needless_question_mark)]
2016 if (|| -> ::core::result::Result<
2017 _,
2018 ::treesitter_types::ParseError,
2019 > {
2020 let child = candidate;
2021 Ok(
2022 ::treesitter_types::runtime::maybe_grow_stack(|| <BooleanChildren as ::treesitter_types::FromNode>::from_node(
2023 child,
2024 src,
2025 ))?,
2026 )
2027 })()
2028 .is_ok()
2029 {
2030 fallback_child = Some(candidate);
2031 break;
2032 }
2033 }
2034 if !fallback_cursor.goto_next_sibling() {
2035 break;
2036 }
2037 }
2038 }
2039 if fallback_child.is_none() {
2040 let mut cursor2 = node.walk();
2041 if cursor2.goto_first_child() {
2042 loop {
2043 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2044 let candidate = cursor2.node();
2045 #[allow(clippy::needless_question_mark)]
2046 if (|| -> ::core::result::Result<
2047 _,
2048 ::treesitter_types::ParseError,
2049 > {
2050 let child = candidate;
2051 Ok(
2052 ::treesitter_types::runtime::maybe_grow_stack(|| <BooleanChildren as ::treesitter_types::FromNode>::from_node(
2053 child,
2054 src,
2055 ))?,
2056 )
2057 })()
2058 .is_ok()
2059 {
2060 fallback_child = Some(candidate);
2061 break;
2062 }
2063 }
2064 if !cursor2.goto_next_sibling() {
2065 break;
2066 }
2067 }
2068 }
2069 }
2070 fallback_child.ok_or_else(|| {
2071 ::treesitter_types::ParseError::missing_field("children", node)
2072 })?
2073 };
2074 ::treesitter_types::runtime::maybe_grow_stack(|| {
2075 <BooleanChildren as ::treesitter_types::FromNode>::from_node(child, src)
2076 })?
2077 },
2078 })
2079 }
2080}
2081impl ::treesitter_types::Spanned for Boolean<'_> {
2082 fn span(&self) -> ::treesitter_types::Span {
2083 self.span
2084 }
2085}
2086#[derive(Debug, Clone, PartialEq, Eq)]
2087pub struct Case<'tree> {
2088 pub span: ::treesitter_types::Span,
2089 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
2090 pub children: CaseChildren<'tree>,
2091}
2092impl<'tree> ::treesitter_types::FromNode<'tree> for Case<'tree> {
2093 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2094 fn from_node(
2095 node: ::treesitter_types::tree_sitter::Node<'tree>,
2096 src: &'tree [u8],
2097 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2098 debug_assert_eq!(node.kind(), "case");
2099 Ok(Self {
2100 span: ::treesitter_types::Span::from(node),
2101 alternatives: match node.child_by_field_name("alternatives") {
2102 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2103 <Alternatives as ::treesitter_types::FromNode>::from_node(child, src)
2104 })?),
2105 None => None,
2106 },
2107 children: {
2108 #[allow(clippy::suspicious_else_formatting)]
2109 let non_field_children = {
2110 let mut cursor = node.walk();
2111 let mut result = ::std::vec::Vec::new();
2112 if cursor.goto_first_child() {
2113 loop {
2114 if cursor.field_name().is_none()
2115 && cursor.node().is_named()
2116 && !cursor.node().is_extra()
2117 {
2118 result.push(cursor.node());
2119 }
2120 if !cursor.goto_next_sibling() {
2121 break;
2122 }
2123 }
2124 }
2125 result
2126 };
2127 let child = if let Some(&c) = non_field_children.first() {
2128 c
2129 } else {
2130 let mut fallback_cursor = node.walk();
2131 let mut fallback_child = None;
2132 if fallback_cursor.goto_first_child() {
2133 loop {
2134 if fallback_cursor.field_name().is_none()
2135 && !fallback_cursor.node().is_extra()
2136 {
2137 let candidate = fallback_cursor.node();
2138 #[allow(clippy::needless_question_mark)]
2139 if (|| -> ::core::result::Result<
2140 _,
2141 ::treesitter_types::ParseError,
2142 > {
2143 let child = candidate;
2144 Ok(
2145 ::treesitter_types::runtime::maybe_grow_stack(|| <CaseChildren as ::treesitter_types::FromNode>::from_node(
2146 child,
2147 src,
2148 ))?,
2149 )
2150 })()
2151 .is_ok()
2152 {
2153 fallback_child = Some(candidate);
2154 break;
2155 }
2156 }
2157 if !fallback_cursor.goto_next_sibling() {
2158 break;
2159 }
2160 }
2161 }
2162 if fallback_child.is_none() {
2163 let mut cursor2 = node.walk();
2164 if cursor2.goto_first_child() {
2165 loop {
2166 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2167 let candidate = cursor2.node();
2168 #[allow(clippy::needless_question_mark)]
2169 if (|| -> ::core::result::Result<
2170 _,
2171 ::treesitter_types::ParseError,
2172 > {
2173 let child = candidate;
2174 Ok(
2175 ::treesitter_types::runtime::maybe_grow_stack(|| <CaseChildren as ::treesitter_types::FromNode>::from_node(
2176 child,
2177 src,
2178 ))?,
2179 )
2180 })()
2181 .is_ok()
2182 {
2183 fallback_child = Some(candidate);
2184 break;
2185 }
2186 }
2187 if !cursor2.goto_next_sibling() {
2188 break;
2189 }
2190 }
2191 }
2192 }
2193 fallback_child.ok_or_else(|| {
2194 ::treesitter_types::ParseError::missing_field("children", node)
2195 })?
2196 };
2197 ::treesitter_types::runtime::maybe_grow_stack(|| {
2198 <CaseChildren as ::treesitter_types::FromNode>::from_node(child, src)
2199 })?
2200 },
2201 })
2202 }
2203}
2204impl ::treesitter_types::Spanned for Case<'_> {
2205 fn span(&self) -> ::treesitter_types::Span {
2206 self.span
2207 }
2208}
2209#[derive(Debug, Clone, PartialEq, Eq)]
2210pub struct Children<'tree> {
2211 pub span: ::treesitter_types::Span,
2212 pub element: ::std::vec::Vec<ChildrenElement<'tree>>,
2213}
2214impl<'tree> ::treesitter_types::FromNode<'tree> for Children<'tree> {
2215 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2216 fn from_node(
2217 node: ::treesitter_types::tree_sitter::Node<'tree>,
2218 src: &'tree [u8],
2219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2220 debug_assert_eq!(node.kind(), "children");
2221 Ok(Self {
2222 span: ::treesitter_types::Span::from(node),
2223 element: {
2224 let mut cursor = node.walk();
2225 let mut items = ::std::vec::Vec::new();
2226 for child in node.children_by_field_name("element", &mut cursor) {
2227 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2228 <ChildrenElement as ::treesitter_types::FromNode>::from_node(child, src)
2229 })?);
2230 }
2231 items
2232 },
2233 })
2234 }
2235}
2236impl ::treesitter_types::Spanned for Children<'_> {
2237 fn span(&self) -> ::treesitter_types::Span {
2238 self.span
2239 }
2240}
2241#[derive(Debug, Clone, PartialEq, Eq)]
2242pub struct Class<'tree> {
2243 pub span: ::treesitter_types::Span,
2244 pub context: ::core::option::Option<Context<'tree>>,
2245 pub declarations: ::core::option::Option<ClassDeclarations<'tree>>,
2246 pub fundeps: ::core::option::Option<Fundeps<'tree>>,
2247 pub name: ::core::option::Option<ClassName<'tree>>,
2248 pub patterns: ::core::option::Option<TypeParams<'tree>>,
2249 pub children: ::core::option::Option<ClassChildren<'tree>>,
2250}
2251impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
2252 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2253 fn from_node(
2254 node: ::treesitter_types::tree_sitter::Node<'tree>,
2255 src: &'tree [u8],
2256 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2257 debug_assert_eq!(node.kind(), "class");
2258 Ok(Self {
2259 span: ::treesitter_types::Span::from(node),
2260 context: match node.child_by_field_name("context") {
2261 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2262 <Context as ::treesitter_types::FromNode>::from_node(child, src)
2263 })?),
2264 None => None,
2265 },
2266 declarations: match node.child_by_field_name("declarations") {
2267 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2268 <ClassDeclarations as ::treesitter_types::FromNode>::from_node(child, src)
2269 })?),
2270 None => None,
2271 },
2272 fundeps: match node.child_by_field_name("fundeps") {
2273 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2274 <Fundeps as ::treesitter_types::FromNode>::from_node(child, src)
2275 })?),
2276 None => None,
2277 },
2278 name: match node.child_by_field_name("name") {
2279 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2280 <ClassName as ::treesitter_types::FromNode>::from_node(child, src)
2281 })?),
2282 None => None,
2283 },
2284 patterns: match node.child_by_field_name("patterns") {
2285 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2286 <TypeParams as ::treesitter_types::FromNode>::from_node(child, src)
2287 })?),
2288 None => None,
2289 },
2290 children: {
2291 #[allow(clippy::suspicious_else_formatting)]
2292 let non_field_children = {
2293 let mut cursor = node.walk();
2294 let mut result = ::std::vec::Vec::new();
2295 if cursor.goto_first_child() {
2296 loop {
2297 if cursor.field_name().is_none()
2298 && cursor.node().is_named()
2299 && !cursor.node().is_extra()
2300 {
2301 result.push(cursor.node());
2302 }
2303 if !cursor.goto_next_sibling() {
2304 break;
2305 }
2306 }
2307 }
2308 result
2309 };
2310 match non_field_children.first() {
2311 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2312 <ClassChildren as ::treesitter_types::FromNode>::from_node(child, src)
2313 })?),
2314 None => None,
2315 }
2316 },
2317 })
2318 }
2319}
2320impl ::treesitter_types::Spanned for Class<'_> {
2321 fn span(&self) -> ::treesitter_types::Span {
2322 self.span
2323 }
2324}
2325#[derive(Debug, Clone, PartialEq, Eq)]
2326pub struct ClassDeclarations<'tree> {
2327 pub span: ::treesitter_types::Span,
2328 pub declaration: ::std::vec::Vec<ClassDecl<'tree>>,
2329}
2330impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarations<'tree> {
2331 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2332 fn from_node(
2333 node: ::treesitter_types::tree_sitter::Node<'tree>,
2334 src: &'tree [u8],
2335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2336 debug_assert_eq!(node.kind(), "class_declarations");
2337 Ok(Self {
2338 span: ::treesitter_types::Span::from(node),
2339 declaration: {
2340 let mut cursor = node.walk();
2341 let mut items = ::std::vec::Vec::new();
2342 for child in node.children_by_field_name("declaration", &mut cursor) {
2343 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2344 <ClassDecl as ::treesitter_types::FromNode>::from_node(child, src)
2345 })?);
2346 }
2347 items
2348 },
2349 })
2350 }
2351}
2352impl ::treesitter_types::Spanned for ClassDeclarations<'_> {
2353 fn span(&self) -> ::treesitter_types::Span {
2354 self.span
2355 }
2356}
2357#[derive(Debug, Clone, PartialEq, Eq)]
2358pub struct Conditional<'tree> {
2359 pub span: ::treesitter_types::Span,
2360 pub r#else: ConditionalElse<'tree>,
2361 pub r#if: ConditionalIf<'tree>,
2362 pub then: ConditionalThen<'tree>,
2363}
2364impl<'tree> ::treesitter_types::FromNode<'tree> for Conditional<'tree> {
2365 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2366 fn from_node(
2367 node: ::treesitter_types::tree_sitter::Node<'tree>,
2368 src: &'tree [u8],
2369 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2370 debug_assert_eq!(node.kind(), "conditional");
2371 Ok(Self {
2372 span: ::treesitter_types::Span::from(node),
2373 r#else: {
2374 let child = node
2375 .child_by_field_name("else")
2376 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("else", node))?;
2377 ::treesitter_types::runtime::maybe_grow_stack(|| {
2378 <ConditionalElse as ::treesitter_types::FromNode>::from_node(child, src)
2379 })?
2380 },
2381 r#if: {
2382 let child = node
2383 .child_by_field_name("if")
2384 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("if", node))?;
2385 ::treesitter_types::runtime::maybe_grow_stack(|| {
2386 <ConditionalIf as ::treesitter_types::FromNode>::from_node(child, src)
2387 })?
2388 },
2389 then: {
2390 let child = node
2391 .child_by_field_name("then")
2392 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("then", node))?;
2393 ::treesitter_types::runtime::maybe_grow_stack(|| {
2394 <ConditionalThen as ::treesitter_types::FromNode>::from_node(child, src)
2395 })?
2396 },
2397 })
2398 }
2399}
2400impl ::treesitter_types::Spanned for Conditional<'_> {
2401 fn span(&self) -> ::treesitter_types::Span {
2402 self.span
2403 }
2404}
2405#[derive(Debug, Clone, PartialEq, Eq)]
2406pub struct ConstructorOperator<'tree> {
2407 pub span: ::treesitter_types::Span,
2408 text: &'tree str,
2409}
2410impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorOperator<'tree> {
2411 fn from_node(
2412 node: ::treesitter_types::tree_sitter::Node<'tree>,
2413 src: &'tree [u8],
2414 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2415 debug_assert_eq!(node.kind(), "constructor_operator");
2416 Ok(Self {
2417 span: ::treesitter_types::Span::from(node),
2418 text: node.utf8_text(src)?,
2419 })
2420 }
2421}
2422impl<'tree> ::treesitter_types::LeafNode<'tree> for ConstructorOperator<'tree> {
2423 fn text(&self) -> &'tree str {
2424 self.text
2425 }
2426}
2427impl ::treesitter_types::Spanned for ConstructorOperator<'_> {
2428 fn span(&self) -> ::treesitter_types::Span {
2429 self.span
2430 }
2431}
2432#[derive(Debug, Clone, PartialEq, Eq)]
2433pub struct ConstructorSynonym<'tree> {
2434 pub span: ::treesitter_types::Span,
2435 pub binds: ::core::option::Option<LocalBinds<'tree>>,
2436 pub implicit: ::core::option::Option<ImplicitVariable<'tree>>,
2437 pub r#match: ::std::vec::Vec<Match<'tree>>,
2438 pub name: ::core::option::Option<ConstructorSynonymName<'tree>>,
2439 pub pattern: ::core::option::Option<ConstructorSynonymPattern<'tree>>,
2440}
2441impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonym<'tree> {
2442 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2443 fn from_node(
2444 node: ::treesitter_types::tree_sitter::Node<'tree>,
2445 src: &'tree [u8],
2446 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2447 debug_assert_eq!(node.kind(), "constructor_synonym");
2448 Ok(Self {
2449 span: ::treesitter_types::Span::from(node),
2450 binds: match node.child_by_field_name("binds") {
2451 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2452 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
2453 })?),
2454 None => None,
2455 },
2456 implicit: match node.child_by_field_name("implicit") {
2457 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2458 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)
2459 })?),
2460 None => None,
2461 },
2462 r#match: {
2463 let mut cursor = node.walk();
2464 let mut items = ::std::vec::Vec::new();
2465 for child in node.children_by_field_name("match", &mut cursor) {
2466 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2467 <Match as ::treesitter_types::FromNode>::from_node(child, src)
2468 })?);
2469 }
2470 items
2471 },
2472 name: match node.child_by_field_name("name") {
2473 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2474 <ConstructorSynonymName as ::treesitter_types::FromNode>::from_node(child, src)
2475 })?),
2476 None => None,
2477 },
2478 pattern: match node.child_by_field_name("pattern") {
2479 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2480 <ConstructorSynonymPattern as ::treesitter_types::FromNode>::from_node(
2481 child, src,
2482 )
2483 })?),
2484 None => None,
2485 },
2486 })
2487 }
2488}
2489impl ::treesitter_types::Spanned for ConstructorSynonym<'_> {
2490 fn span(&self) -> ::treesitter_types::Span {
2491 self.span
2492 }
2493}
2494#[derive(Debug, Clone, PartialEq, Eq)]
2495pub struct ConstructorSynonyms<'tree> {
2496 pub span: ::treesitter_types::Span,
2497 pub children: ::std::vec::Vec<ConstructorSynonym<'tree>>,
2498}
2499impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonyms<'tree> {
2500 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2501 fn from_node(
2502 node: ::treesitter_types::tree_sitter::Node<'tree>,
2503 src: &'tree [u8],
2504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2505 debug_assert_eq!(node.kind(), "constructor_synonyms");
2506 Ok(Self {
2507 span: ::treesitter_types::Span::from(node),
2508 children: {
2509 #[allow(clippy::suspicious_else_formatting)]
2510 let non_field_children = {
2511 let mut cursor = node.walk();
2512 let mut result = ::std::vec::Vec::new();
2513 if cursor.goto_first_child() {
2514 loop {
2515 if cursor.field_name().is_none()
2516 && cursor.node().is_named()
2517 && !cursor.node().is_extra()
2518 {
2519 result.push(cursor.node());
2520 }
2521 if !cursor.goto_next_sibling() {
2522 break;
2523 }
2524 }
2525 }
2526 result
2527 };
2528 let mut items = ::std::vec::Vec::new();
2529 for child in non_field_children {
2530 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2531 <ConstructorSynonym as ::treesitter_types::FromNode>::from_node(child, src)
2532 })?);
2533 }
2534 items
2535 },
2536 })
2537 }
2538}
2539impl ::treesitter_types::Spanned for ConstructorSynonyms<'_> {
2540 fn span(&self) -> ::treesitter_types::Span {
2541 self.span
2542 }
2543}
2544#[derive(Debug, Clone, PartialEq, Eq)]
2545pub struct Context<'tree> {
2546 pub span: ::treesitter_types::Span,
2547 pub arrow: ContextArrow,
2548 pub constraint: ::core::option::Option<Constraints<'tree>>,
2549 pub context: Constraint<'tree>,
2550 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
2551}
2552impl<'tree> ::treesitter_types::FromNode<'tree> for Context<'tree> {
2553 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2554 fn from_node(
2555 node: ::treesitter_types::tree_sitter::Node<'tree>,
2556 src: &'tree [u8],
2557 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2558 debug_assert_eq!(node.kind(), "context");
2559 Ok(Self {
2560 span: ::treesitter_types::Span::from(node),
2561 arrow: {
2562 let child = node
2563 .child_by_field_name("arrow")
2564 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
2565 ::treesitter_types::runtime::maybe_grow_stack(|| {
2566 <ContextArrow as ::treesitter_types::FromNode>::from_node(child, src)
2567 })?
2568 },
2569 constraint: match node.child_by_field_name("constraint") {
2570 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2571 <Constraints as ::treesitter_types::FromNode>::from_node(child, src)
2572 })?),
2573 None => None,
2574 },
2575 context: {
2576 let child = node.child_by_field_name("context").ok_or_else(|| {
2577 ::treesitter_types::ParseError::missing_field("context", node)
2578 })?;
2579 ::treesitter_types::runtime::maybe_grow_stack(|| {
2580 <Constraint as ::treesitter_types::FromNode>::from_node(child, src)
2581 })?
2582 },
2583 r#type: match node.child_by_field_name("type") {
2584 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2585 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
2586 })?),
2587 None => None,
2588 },
2589 })
2590 }
2591}
2592impl ::treesitter_types::Spanned for Context<'_> {
2593 fn span(&self) -> ::treesitter_types::Span {
2594 self.span
2595 }
2596}
2597#[derive(Debug, Clone, PartialEq, Eq)]
2598pub struct DataConstructor<'tree> {
2599 pub span: ::treesitter_types::Span,
2600 pub constructor: DataConstructorConstructor<'tree>,
2601 pub context: ::core::option::Option<Context<'tree>>,
2602 pub forall: ::core::option::Option<DataConstructorForall<'tree>>,
2603}
2604impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructor<'tree> {
2605 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2606 fn from_node(
2607 node: ::treesitter_types::tree_sitter::Node<'tree>,
2608 src: &'tree [u8],
2609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2610 debug_assert_eq!(node.kind(), "data_constructor");
2611 Ok(Self {
2612 span: ::treesitter_types::Span::from(node),
2613 constructor: {
2614 let child = node.child_by_field_name("constructor").ok_or_else(|| {
2615 ::treesitter_types::ParseError::missing_field("constructor", node)
2616 })?;
2617 ::treesitter_types::runtime::maybe_grow_stack(|| {
2618 <DataConstructorConstructor as ::treesitter_types::FromNode>::from_node(
2619 child, src,
2620 )
2621 })?
2622 },
2623 context: match node.child_by_field_name("context") {
2624 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2625 <Context as ::treesitter_types::FromNode>::from_node(child, src)
2626 })?),
2627 None => None,
2628 },
2629 forall: match node.child_by_field_name("forall") {
2630 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2631 <DataConstructorForall as ::treesitter_types::FromNode>::from_node(child, src)
2632 })?),
2633 None => None,
2634 },
2635 })
2636 }
2637}
2638impl ::treesitter_types::Spanned for DataConstructor<'_> {
2639 fn span(&self) -> ::treesitter_types::Span {
2640 self.span
2641 }
2642}
2643#[derive(Debug, Clone, PartialEq, Eq)]
2644pub struct DataConstructors<'tree> {
2645 pub span: ::treesitter_types::Span,
2646 pub constructor: ::std::vec::Vec<DataConstructor<'tree>>,
2647}
2648impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructors<'tree> {
2649 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2650 fn from_node(
2651 node: ::treesitter_types::tree_sitter::Node<'tree>,
2652 src: &'tree [u8],
2653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2654 debug_assert_eq!(node.kind(), "data_constructors");
2655 Ok(Self {
2656 span: ::treesitter_types::Span::from(node),
2657 constructor: {
2658 let mut cursor = node.walk();
2659 let mut items = ::std::vec::Vec::new();
2660 for child in node.children_by_field_name("constructor", &mut cursor) {
2661 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2662 <DataConstructor as ::treesitter_types::FromNode>::from_node(child, src)
2663 })?);
2664 }
2665 items
2666 },
2667 })
2668 }
2669}
2670impl ::treesitter_types::Spanned for DataConstructors<'_> {
2671 fn span(&self) -> ::treesitter_types::Span {
2672 self.span
2673 }
2674}
2675#[derive(Debug, Clone, PartialEq, Eq)]
2676pub struct DataFamily<'tree> {
2677 pub span: ::treesitter_types::Span,
2678 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
2679 pub name: ::core::option::Option<DataFamilyName<'tree>>,
2680 pub patterns: ::core::option::Option<TypeParams<'tree>>,
2681 pub children: ::core::option::Option<DataFamilyChildren<'tree>>,
2682}
2683impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamily<'tree> {
2684 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2685 fn from_node(
2686 node: ::treesitter_types::tree_sitter::Node<'tree>,
2687 src: &'tree [u8],
2688 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2689 debug_assert_eq!(node.kind(), "data_family");
2690 Ok(Self {
2691 span: ::treesitter_types::Span::from(node),
2692 kind: match node.child_by_field_name("kind") {
2693 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2694 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
2695 })?),
2696 None => None,
2697 },
2698 name: match node.child_by_field_name("name") {
2699 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2700 <DataFamilyName as ::treesitter_types::FromNode>::from_node(child, src)
2701 })?),
2702 None => None,
2703 },
2704 patterns: match node.child_by_field_name("patterns") {
2705 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2706 <TypeParams as ::treesitter_types::FromNode>::from_node(child, src)
2707 })?),
2708 None => None,
2709 },
2710 children: {
2711 #[allow(clippy::suspicious_else_formatting)]
2712 let non_field_children = {
2713 let mut cursor = node.walk();
2714 let mut result = ::std::vec::Vec::new();
2715 if cursor.goto_first_child() {
2716 loop {
2717 if cursor.field_name().is_none()
2718 && cursor.node().is_named()
2719 && !cursor.node().is_extra()
2720 {
2721 result.push(cursor.node());
2722 }
2723 if !cursor.goto_next_sibling() {
2724 break;
2725 }
2726 }
2727 }
2728 result
2729 };
2730 match non_field_children.first() {
2731 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2732 <DataFamilyChildren as ::treesitter_types::FromNode>::from_node(child, src)
2733 })?),
2734 None => None,
2735 }
2736 },
2737 })
2738 }
2739}
2740impl ::treesitter_types::Spanned for DataFamily<'_> {
2741 fn span(&self) -> ::treesitter_types::Span {
2742 self.span
2743 }
2744}
2745#[derive(Debug, Clone, PartialEq, Eq)]
2746pub struct DataInstance<'tree> {
2747 pub span: ::treesitter_types::Span,
2748 pub children: DataInstanceChildren<'tree>,
2749}
2750impl<'tree> ::treesitter_types::FromNode<'tree> for DataInstance<'tree> {
2751 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2752 fn from_node(
2753 node: ::treesitter_types::tree_sitter::Node<'tree>,
2754 src: &'tree [u8],
2755 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2756 debug_assert_eq!(node.kind(), "data_instance");
2757 Ok(Self {
2758 span: ::treesitter_types::Span::from(node),
2759 children: {
2760 #[allow(clippy::suspicious_else_formatting)]
2761 let non_field_children = {
2762 let mut cursor = node.walk();
2763 let mut result = ::std::vec::Vec::new();
2764 if cursor.goto_first_child() {
2765 loop {
2766 if cursor.field_name().is_none()
2767 && cursor.node().is_named()
2768 && !cursor.node().is_extra()
2769 {
2770 result.push(cursor.node());
2771 }
2772 if !cursor.goto_next_sibling() {
2773 break;
2774 }
2775 }
2776 }
2777 result
2778 };
2779 let child = if let Some(&c) = non_field_children.first() {
2780 c
2781 } else {
2782 let mut fallback_cursor = node.walk();
2783 let mut fallback_child = None;
2784 if fallback_cursor.goto_first_child() {
2785 loop {
2786 if fallback_cursor.field_name().is_none()
2787 && !fallback_cursor.node().is_extra()
2788 {
2789 let candidate = fallback_cursor.node();
2790 #[allow(clippy::needless_question_mark)]
2791 if (|| -> ::core::result::Result<
2792 _,
2793 ::treesitter_types::ParseError,
2794 > {
2795 let child = candidate;
2796 Ok(
2797 ::treesitter_types::runtime::maybe_grow_stack(|| <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(
2798 child,
2799 src,
2800 ))?,
2801 )
2802 })()
2803 .is_ok()
2804 {
2805 fallback_child = Some(candidate);
2806 break;
2807 }
2808 }
2809 if !fallback_cursor.goto_next_sibling() {
2810 break;
2811 }
2812 }
2813 }
2814 if fallback_child.is_none() {
2815 let mut cursor2 = node.walk();
2816 if cursor2.goto_first_child() {
2817 loop {
2818 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2819 let candidate = cursor2.node();
2820 #[allow(clippy::needless_question_mark)]
2821 if (|| -> ::core::result::Result<
2822 _,
2823 ::treesitter_types::ParseError,
2824 > {
2825 let child = candidate;
2826 Ok(
2827 ::treesitter_types::runtime::maybe_grow_stack(|| <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(
2828 child,
2829 src,
2830 ))?,
2831 )
2832 })()
2833 .is_ok()
2834 {
2835 fallback_child = Some(candidate);
2836 break;
2837 }
2838 }
2839 if !cursor2.goto_next_sibling() {
2840 break;
2841 }
2842 }
2843 }
2844 }
2845 fallback_child.ok_or_else(|| {
2846 ::treesitter_types::ParseError::missing_field("children", node)
2847 })?
2848 };
2849 ::treesitter_types::runtime::maybe_grow_stack(|| {
2850 <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(child, src)
2851 })?
2852 },
2853 })
2854 }
2855}
2856impl ::treesitter_types::Spanned for DataInstance<'_> {
2857 fn span(&self) -> ::treesitter_types::Span {
2858 self.span
2859 }
2860}
2861#[derive(Debug, Clone, PartialEq, Eq)]
2862pub struct DataType<'tree> {
2863 pub span: ::treesitter_types::Span,
2864 pub constructors: ::core::option::Option<DataTypeConstructors<'tree>>,
2865 pub context: ::core::option::Option<Context<'tree>>,
2866 pub deriving: ::std::vec::Vec<Deriving<'tree>>,
2867 pub forall: ::core::option::Option<DataTypeForall<'tree>>,
2868 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
2869 pub name: ::core::option::Option<DataTypeName<'tree>>,
2870 pub patterns: ::core::option::Option<DataTypePatterns<'tree>>,
2871 pub children: ::core::option::Option<DataTypeChildren<'tree>>,
2872}
2873impl<'tree> ::treesitter_types::FromNode<'tree> for DataType<'tree> {
2874 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2875 fn from_node(
2876 node: ::treesitter_types::tree_sitter::Node<'tree>,
2877 src: &'tree [u8],
2878 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2879 debug_assert_eq!(node.kind(), "data_type");
2880 Ok(Self {
2881 span: ::treesitter_types::Span::from(node),
2882 constructors: match node.child_by_field_name("constructors") {
2883 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2884 <DataTypeConstructors as ::treesitter_types::FromNode>::from_node(child, src)
2885 })?),
2886 None => None,
2887 },
2888 context: match node.child_by_field_name("context") {
2889 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2890 <Context as ::treesitter_types::FromNode>::from_node(child, src)
2891 })?),
2892 None => None,
2893 },
2894 deriving: {
2895 let mut cursor = node.walk();
2896 let mut items = ::std::vec::Vec::new();
2897 for child in node.children_by_field_name("deriving", &mut cursor) {
2898 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
2899 <Deriving as ::treesitter_types::FromNode>::from_node(child, src)
2900 })?);
2901 }
2902 items
2903 },
2904 forall: match node.child_by_field_name("forall") {
2905 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2906 <DataTypeForall as ::treesitter_types::FromNode>::from_node(child, src)
2907 })?),
2908 None => None,
2909 },
2910 kind: match node.child_by_field_name("kind") {
2911 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2912 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
2913 })?),
2914 None => None,
2915 },
2916 name: match node.child_by_field_name("name") {
2917 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2918 <DataTypeName as ::treesitter_types::FromNode>::from_node(child, src)
2919 })?),
2920 None => None,
2921 },
2922 patterns: match node.child_by_field_name("patterns") {
2923 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2924 <DataTypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
2925 })?),
2926 None => None,
2927 },
2928 children: {
2929 #[allow(clippy::suspicious_else_formatting)]
2930 let non_field_children = {
2931 let mut cursor = node.walk();
2932 let mut result = ::std::vec::Vec::new();
2933 if cursor.goto_first_child() {
2934 loop {
2935 if cursor.field_name().is_none()
2936 && cursor.node().is_named()
2937 && !cursor.node().is_extra()
2938 {
2939 result.push(cursor.node());
2940 }
2941 if !cursor.goto_next_sibling() {
2942 break;
2943 }
2944 }
2945 }
2946 result
2947 };
2948 match non_field_children.first() {
2949 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
2950 <DataTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
2951 })?),
2952 None => None,
2953 }
2954 },
2955 })
2956 }
2957}
2958impl ::treesitter_types::Spanned for DataType<'_> {
2959 fn span(&self) -> ::treesitter_types::Span {
2960 self.span
2961 }
2962}
2963#[derive(Debug, Clone, PartialEq, Eq)]
2964pub struct Declarations<'tree> {
2965 pub span: ::treesitter_types::Span,
2966 pub children: ::std::vec::Vec<DeclarationsChildren<'tree>>,
2967}
2968impl<'tree> ::treesitter_types::FromNode<'tree> for Declarations<'tree> {
2969 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2970 fn from_node(
2971 node: ::treesitter_types::tree_sitter::Node<'tree>,
2972 src: &'tree [u8],
2973 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2974 debug_assert_eq!(node.kind(), "declarations");
2975 Ok(Self {
2976 span: ::treesitter_types::Span::from(node),
2977 children: {
2978 #[allow(clippy::suspicious_else_formatting)]
2979 let non_field_children = {
2980 let mut cursor = node.walk();
2981 let mut result = ::std::vec::Vec::new();
2982 if cursor.goto_first_child() {
2983 loop {
2984 if cursor.field_name().is_none()
2985 && cursor.node().is_named()
2986 && !cursor.node().is_extra()
2987 {
2988 result.push(cursor.node());
2989 }
2990 if !cursor.goto_next_sibling() {
2991 break;
2992 }
2993 }
2994 }
2995 result
2996 };
2997 let mut items = ::std::vec::Vec::new();
2998 for child in non_field_children {
2999 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3000 <DeclarationsChildren as ::treesitter_types::FromNode>::from_node(
3001 child, src,
3002 )
3003 })?);
3004 }
3005 items
3006 },
3007 })
3008 }
3009}
3010impl ::treesitter_types::Spanned for Declarations<'_> {
3011 fn span(&self) -> ::treesitter_types::Span {
3012 self.span
3013 }
3014}
3015#[derive(Debug, Clone, PartialEq, Eq)]
3016pub struct DefaultSignature<'tree> {
3017 pub span: ::treesitter_types::Span,
3018 pub signature: Signature<'tree>,
3019}
3020impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultSignature<'tree> {
3021 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3022 fn from_node(
3023 node: ::treesitter_types::tree_sitter::Node<'tree>,
3024 src: &'tree [u8],
3025 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3026 debug_assert_eq!(node.kind(), "default_signature");
3027 Ok(Self {
3028 span: ::treesitter_types::Span::from(node),
3029 signature: {
3030 let child = node.child_by_field_name("signature").ok_or_else(|| {
3031 ::treesitter_types::ParseError::missing_field("signature", node)
3032 })?;
3033 ::treesitter_types::runtime::maybe_grow_stack(|| {
3034 <Signature as ::treesitter_types::FromNode>::from_node(child, src)
3035 })?
3036 },
3037 })
3038 }
3039}
3040impl ::treesitter_types::Spanned for DefaultSignature<'_> {
3041 fn span(&self) -> ::treesitter_types::Span {
3042 self.span
3043 }
3044}
3045#[derive(Debug, Clone, PartialEq, Eq)]
3046pub struct DefaultTypes<'tree> {
3047 pub span: ::treesitter_types::Span,
3048 pub r#type: ::std::vec::Vec<DefaultTypesType<'tree>>,
3049}
3050impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultTypes<'tree> {
3051 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3052 fn from_node(
3053 node: ::treesitter_types::tree_sitter::Node<'tree>,
3054 src: &'tree [u8],
3055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3056 debug_assert_eq!(node.kind(), "default_types");
3057 Ok(Self {
3058 span: ::treesitter_types::Span::from(node),
3059 r#type: {
3060 let mut cursor = node.walk();
3061 let mut items = ::std::vec::Vec::new();
3062 for child in node.children_by_field_name("type", &mut cursor) {
3063 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3064 <DefaultTypesType as ::treesitter_types::FromNode>::from_node(child, src)
3065 })?);
3066 }
3067 items
3068 },
3069 })
3070 }
3071}
3072impl ::treesitter_types::Spanned for DefaultTypes<'_> {
3073 fn span(&self) -> ::treesitter_types::Span {
3074 self.span
3075 }
3076}
3077#[derive(Debug, Clone, PartialEq, Eq)]
3078pub struct Deriving<'tree> {
3079 pub span: ::treesitter_types::Span,
3080 pub classes: Constraint<'tree>,
3081 pub strategy: ::core::option::Option<DerivingStrategy<'tree>>,
3082 pub via: ::core::option::Option<Via<'tree>>,
3083}
3084impl<'tree> ::treesitter_types::FromNode<'tree> for Deriving<'tree> {
3085 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3086 fn from_node(
3087 node: ::treesitter_types::tree_sitter::Node<'tree>,
3088 src: &'tree [u8],
3089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3090 debug_assert_eq!(node.kind(), "deriving");
3091 Ok(Self {
3092 span: ::treesitter_types::Span::from(node),
3093 classes: {
3094 let child = node.child_by_field_name("classes").ok_or_else(|| {
3095 ::treesitter_types::ParseError::missing_field("classes", node)
3096 })?;
3097 ::treesitter_types::runtime::maybe_grow_stack(|| {
3098 <Constraint as ::treesitter_types::FromNode>::from_node(child, src)
3099 })?
3100 },
3101 strategy: match node.child_by_field_name("strategy") {
3102 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3103 <DerivingStrategy as ::treesitter_types::FromNode>::from_node(child, src)
3104 })?),
3105 None => None,
3106 },
3107 via: match node.child_by_field_name("via") {
3108 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3109 <Via as ::treesitter_types::FromNode>::from_node(child, src)
3110 })?),
3111 None => None,
3112 },
3113 })
3114 }
3115}
3116impl ::treesitter_types::Spanned for Deriving<'_> {
3117 fn span(&self) -> ::treesitter_types::Span {
3118 self.span
3119 }
3120}
3121#[derive(Debug, Clone, PartialEq, Eq)]
3122pub struct DerivingInstance<'tree> {
3123 pub span: ::treesitter_types::Span,
3124 pub context: ::core::option::Option<Context<'tree>>,
3125 pub forall: ::core::option::Option<DerivingInstanceForall<'tree>>,
3126 pub name: ::core::option::Option<DerivingInstanceName<'tree>>,
3127 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
3128 pub strategy: ::core::option::Option<DerivingStrategy<'tree>>,
3129 pub via: ::core::option::Option<Via<'tree>>,
3130 pub children: ::core::option::Option<DerivingInstanceChildren<'tree>>,
3131}
3132impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstance<'tree> {
3133 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3134 fn from_node(
3135 node: ::treesitter_types::tree_sitter::Node<'tree>,
3136 src: &'tree [u8],
3137 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3138 debug_assert_eq!(node.kind(), "deriving_instance");
3139 Ok(Self {
3140 span: ::treesitter_types::Span::from(node),
3141 context: match node.child_by_field_name("context") {
3142 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3143 <Context as ::treesitter_types::FromNode>::from_node(child, src)
3144 })?),
3145 None => None,
3146 },
3147 forall: match node.child_by_field_name("forall") {
3148 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3149 <DerivingInstanceForall as ::treesitter_types::FromNode>::from_node(child, src)
3150 })?),
3151 None => None,
3152 },
3153 name: match node.child_by_field_name("name") {
3154 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3155 <DerivingInstanceName as ::treesitter_types::FromNode>::from_node(child, src)
3156 })?),
3157 None => None,
3158 },
3159 patterns: match node.child_by_field_name("patterns") {
3160 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3161 <TypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
3162 })?),
3163 None => None,
3164 },
3165 strategy: match node.child_by_field_name("strategy") {
3166 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3167 <DerivingStrategy as ::treesitter_types::FromNode>::from_node(child, src)
3168 })?),
3169 None => None,
3170 },
3171 via: match node.child_by_field_name("via") {
3172 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3173 <Via as ::treesitter_types::FromNode>::from_node(child, src)
3174 })?),
3175 None => None,
3176 },
3177 children: {
3178 #[allow(clippy::suspicious_else_formatting)]
3179 let non_field_children = {
3180 let mut cursor = node.walk();
3181 let mut result = ::std::vec::Vec::new();
3182 if cursor.goto_first_child() {
3183 loop {
3184 if cursor.field_name().is_none()
3185 && cursor.node().is_named()
3186 && !cursor.node().is_extra()
3187 {
3188 result.push(cursor.node());
3189 }
3190 if !cursor.goto_next_sibling() {
3191 break;
3192 }
3193 }
3194 }
3195 result
3196 };
3197 match non_field_children.first() {
3198 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3199 <DerivingInstanceChildren as ::treesitter_types::FromNode>::from_node(
3200 child, src,
3201 )
3202 })?),
3203 None => None,
3204 }
3205 },
3206 })
3207 }
3208}
3209impl ::treesitter_types::Spanned for DerivingInstance<'_> {
3210 fn span(&self) -> ::treesitter_types::Span {
3211 self.span
3212 }
3213}
3214#[derive(Debug, Clone, PartialEq, Eq)]
3215pub struct DerivingStrategy<'tree> {
3216 pub span: ::treesitter_types::Span,
3217 text: &'tree str,
3218}
3219impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingStrategy<'tree> {
3220 fn from_node(
3221 node: ::treesitter_types::tree_sitter::Node<'tree>,
3222 src: &'tree [u8],
3223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3224 debug_assert_eq!(node.kind(), "deriving_strategy");
3225 Ok(Self {
3226 span: ::treesitter_types::Span::from(node),
3227 text: node.utf8_text(src)?,
3228 })
3229 }
3230}
3231impl<'tree> ::treesitter_types::LeafNode<'tree> for DerivingStrategy<'tree> {
3232 fn text(&self) -> &'tree str {
3233 self.text
3234 }
3235}
3236impl ::treesitter_types::Spanned for DerivingStrategy<'_> {
3237 fn span(&self) -> ::treesitter_types::Span {
3238 self.span
3239 }
3240}
3241#[derive(Debug, Clone, PartialEq, Eq)]
3242pub struct Do<'tree> {
3243 pub span: ::treesitter_types::Span,
3244 pub statement: ::std::vec::Vec<Statement<'tree>>,
3245 pub children: ::core::option::Option<DoModule<'tree>>,
3246}
3247impl<'tree> ::treesitter_types::FromNode<'tree> for Do<'tree> {
3248 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3249 fn from_node(
3250 node: ::treesitter_types::tree_sitter::Node<'tree>,
3251 src: &'tree [u8],
3252 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3253 debug_assert_eq!(node.kind(), "do");
3254 Ok(Self {
3255 span: ::treesitter_types::Span::from(node),
3256 statement: {
3257 let mut cursor = node.walk();
3258 let mut items = ::std::vec::Vec::new();
3259 for child in node.children_by_field_name("statement", &mut cursor) {
3260 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3261 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
3262 })?);
3263 }
3264 items
3265 },
3266 children: {
3267 #[allow(clippy::suspicious_else_formatting)]
3268 let non_field_children = {
3269 let mut cursor = node.walk();
3270 let mut result = ::std::vec::Vec::new();
3271 if cursor.goto_first_child() {
3272 loop {
3273 if cursor.field_name().is_none()
3274 && cursor.node().is_named()
3275 && !cursor.node().is_extra()
3276 {
3277 result.push(cursor.node());
3278 }
3279 if !cursor.goto_next_sibling() {
3280 break;
3281 }
3282 }
3283 }
3284 result
3285 };
3286 match non_field_children.first() {
3287 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3288 <DoModule as ::treesitter_types::FromNode>::from_node(child, src)
3289 })?),
3290 None => None,
3291 }
3292 },
3293 })
3294 }
3295}
3296impl ::treesitter_types::Spanned for Do<'_> {
3297 fn span(&self) -> ::treesitter_types::Span {
3298 self.span
3299 }
3300}
3301#[derive(Debug, Clone, PartialEq, Eq)]
3302pub struct DoModule<'tree> {
3303 pub span: ::treesitter_types::Span,
3304 pub id: DoModuleId,
3305 pub module: Module<'tree>,
3306}
3307impl<'tree> ::treesitter_types::FromNode<'tree> for DoModule<'tree> {
3308 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3309 fn from_node(
3310 node: ::treesitter_types::tree_sitter::Node<'tree>,
3311 src: &'tree [u8],
3312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3313 debug_assert_eq!(node.kind(), "do_module");
3314 Ok(Self {
3315 span: ::treesitter_types::Span::from(node),
3316 id: {
3317 let child = node
3318 .child_by_field_name("id")
3319 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("id", node))?;
3320 ::treesitter_types::runtime::maybe_grow_stack(|| {
3321 <DoModuleId as ::treesitter_types::FromNode>::from_node(child, src)
3322 })?
3323 },
3324 module: {
3325 let child = node
3326 .child_by_field_name("module")
3327 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
3328 ::treesitter_types::runtime::maybe_grow_stack(|| {
3329 <Module as ::treesitter_types::FromNode>::from_node(child, src)
3330 })?
3331 },
3332 })
3333 }
3334}
3335impl ::treesitter_types::Spanned for DoModule<'_> {
3336 fn span(&self) -> ::treesitter_types::Span {
3337 self.span
3338 }
3339}
3340#[derive(Debug, Clone, PartialEq, Eq)]
3341pub struct EmptyList<'tree> {
3342 pub span: ::treesitter_types::Span,
3343 text: &'tree str,
3344}
3345impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyList<'tree> {
3346 fn from_node(
3347 node: ::treesitter_types::tree_sitter::Node<'tree>,
3348 src: &'tree [u8],
3349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3350 debug_assert_eq!(node.kind(), "empty_list");
3351 Ok(Self {
3352 span: ::treesitter_types::Span::from(node),
3353 text: node.utf8_text(src)?,
3354 })
3355 }
3356}
3357impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyList<'tree> {
3358 fn text(&self) -> &'tree str {
3359 self.text
3360 }
3361}
3362impl ::treesitter_types::Spanned for EmptyList<'_> {
3363 fn span(&self) -> ::treesitter_types::Span {
3364 self.span
3365 }
3366}
3367#[derive(Debug, Clone, PartialEq, Eq)]
3368pub struct Entity<'tree> {
3369 pub span: ::treesitter_types::Span,
3370 pub children: String<'tree>,
3371}
3372impl<'tree> ::treesitter_types::FromNode<'tree> for Entity<'tree> {
3373 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3374 fn from_node(
3375 node: ::treesitter_types::tree_sitter::Node<'tree>,
3376 src: &'tree [u8],
3377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3378 debug_assert_eq!(node.kind(), "entity");
3379 Ok(Self {
3380 span: ::treesitter_types::Span::from(node),
3381 children: {
3382 #[allow(clippy::suspicious_else_formatting)]
3383 let non_field_children = {
3384 let mut cursor = node.walk();
3385 let mut result = ::std::vec::Vec::new();
3386 if cursor.goto_first_child() {
3387 loop {
3388 if cursor.field_name().is_none()
3389 && cursor.node().is_named()
3390 && !cursor.node().is_extra()
3391 {
3392 result.push(cursor.node());
3393 }
3394 if !cursor.goto_next_sibling() {
3395 break;
3396 }
3397 }
3398 }
3399 result
3400 };
3401 let child = if let Some(&c) = non_field_children.first() {
3402 c
3403 } else {
3404 let mut fallback_cursor = node.walk();
3405 let mut fallback_child = None;
3406 if fallback_cursor.goto_first_child() {
3407 loop {
3408 if fallback_cursor.field_name().is_none()
3409 && !fallback_cursor.node().is_extra()
3410 {
3411 let candidate = fallback_cursor.node();
3412 #[allow(clippy::needless_question_mark)]
3413 if (|| -> ::core::result::Result<
3414 _,
3415 ::treesitter_types::ParseError,
3416 > {
3417 let child = candidate;
3418 Ok(
3419 ::treesitter_types::runtime::maybe_grow_stack(|| <String as ::treesitter_types::FromNode>::from_node(
3420 child,
3421 src,
3422 ))?,
3423 )
3424 })()
3425 .is_ok()
3426 {
3427 fallback_child = Some(candidate);
3428 break;
3429 }
3430 }
3431 if !fallback_cursor.goto_next_sibling() {
3432 break;
3433 }
3434 }
3435 }
3436 if fallback_child.is_none() {
3437 let mut cursor2 = node.walk();
3438 if cursor2.goto_first_child() {
3439 loop {
3440 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3441 let candidate = cursor2.node();
3442 #[allow(clippy::needless_question_mark)]
3443 if (|| -> ::core::result::Result<
3444 _,
3445 ::treesitter_types::ParseError,
3446 > {
3447 let child = candidate;
3448 Ok(
3449 ::treesitter_types::runtime::maybe_grow_stack(|| <String as ::treesitter_types::FromNode>::from_node(
3450 child,
3451 src,
3452 ))?,
3453 )
3454 })()
3455 .is_ok()
3456 {
3457 fallback_child = Some(candidate);
3458 break;
3459 }
3460 }
3461 if !cursor2.goto_next_sibling() {
3462 break;
3463 }
3464 }
3465 }
3466 }
3467 fallback_child.ok_or_else(|| {
3468 ::treesitter_types::ParseError::missing_field("children", node)
3469 })?
3470 };
3471 ::treesitter_types::runtime::maybe_grow_stack(|| {
3472 <String as ::treesitter_types::FromNode>::from_node(child, src)
3473 })?
3474 },
3475 })
3476 }
3477}
3478impl ::treesitter_types::Spanned for Entity<'_> {
3479 fn span(&self) -> ::treesitter_types::Span {
3480 self.span
3481 }
3482}
3483#[derive(Debug, Clone, PartialEq, Eq)]
3484pub struct Equation<'tree> {
3485 pub span: ::treesitter_types::Span,
3486 pub constructors: ::core::option::Option<ConstructorSynonyms<'tree>>,
3487 pub forall: ::core::option::Option<EquationForall<'tree>>,
3488 pub name: ::core::option::Option<EquationName<'tree>>,
3489 pub pattern: ::core::option::Option<EquationPattern<'tree>>,
3490 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
3491 pub synonym: ::core::option::Option<Pattern<'tree>>,
3492 pub children: ::std::vec::Vec<EquationChildren<'tree>>,
3493}
3494impl<'tree> ::treesitter_types::FromNode<'tree> for Equation<'tree> {
3495 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3496 fn from_node(
3497 node: ::treesitter_types::tree_sitter::Node<'tree>,
3498 src: &'tree [u8],
3499 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3500 debug_assert_eq!(node.kind(), "equation");
3501 Ok(Self {
3502 span: ::treesitter_types::Span::from(node),
3503 constructors: match node.child_by_field_name("constructors") {
3504 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3505 <ConstructorSynonyms as ::treesitter_types::FromNode>::from_node(child, src)
3506 })?),
3507 None => None,
3508 },
3509 forall: match node.child_by_field_name("forall") {
3510 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3511 <EquationForall as ::treesitter_types::FromNode>::from_node(child, src)
3512 })?),
3513 None => None,
3514 },
3515 name: match node.child_by_field_name("name") {
3516 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3517 <EquationName as ::treesitter_types::FromNode>::from_node(child, src)
3518 })?),
3519 None => None,
3520 },
3521 pattern: match node.child_by_field_name("pattern") {
3522 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3523 <EquationPattern as ::treesitter_types::FromNode>::from_node(child, src)
3524 })?),
3525 None => None,
3526 },
3527 patterns: match node.child_by_field_name("patterns") {
3528 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3529 <TypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
3530 })?),
3531 None => None,
3532 },
3533 synonym: match node.child_by_field_name("synonym") {
3534 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3535 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
3536 })?),
3537 None => None,
3538 },
3539 children: {
3540 #[allow(clippy::suspicious_else_formatting)]
3541 let non_field_children = {
3542 let mut cursor = node.walk();
3543 let mut result = ::std::vec::Vec::new();
3544 if cursor.goto_first_child() {
3545 loop {
3546 if cursor.field_name().is_none()
3547 && cursor.node().is_named()
3548 && !cursor.node().is_extra()
3549 {
3550 result.push(cursor.node());
3551 }
3552 if !cursor.goto_next_sibling() {
3553 break;
3554 }
3555 }
3556 }
3557 result
3558 };
3559 let mut items = ::std::vec::Vec::new();
3560 for child in non_field_children {
3561 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3562 <EquationChildren as ::treesitter_types::FromNode>::from_node(child, src)
3563 })?);
3564 }
3565 items
3566 },
3567 })
3568 }
3569}
3570impl ::treesitter_types::Spanned for Equation<'_> {
3571 fn span(&self) -> ::treesitter_types::Span {
3572 self.span
3573 }
3574}
3575#[derive(Debug, Clone, PartialEq, Eq)]
3576pub struct Equations<'tree> {
3577 pub span: ::treesitter_types::Span,
3578 pub equation: ::std::vec::Vec<Equation<'tree>>,
3579}
3580impl<'tree> ::treesitter_types::FromNode<'tree> for Equations<'tree> {
3581 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3582 fn from_node(
3583 node: ::treesitter_types::tree_sitter::Node<'tree>,
3584 src: &'tree [u8],
3585 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3586 debug_assert_eq!(node.kind(), "equations");
3587 Ok(Self {
3588 span: ::treesitter_types::Span::from(node),
3589 equation: {
3590 let mut cursor = node.walk();
3591 let mut items = ::std::vec::Vec::new();
3592 for child in node.children_by_field_name("equation", &mut cursor) {
3593 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3594 <Equation as ::treesitter_types::FromNode>::from_node(child, src)
3595 })?);
3596 }
3597 items
3598 },
3599 })
3600 }
3601}
3602impl ::treesitter_types::Spanned for Equations<'_> {
3603 fn span(&self) -> ::treesitter_types::Span {
3604 self.span
3605 }
3606}
3607#[derive(Debug, Clone, PartialEq, Eq)]
3608pub struct Exp<'tree> {
3609 pub span: ::treesitter_types::Span,
3610 pub children: ExpChildren<'tree>,
3611}
3612impl<'tree> ::treesitter_types::FromNode<'tree> for Exp<'tree> {
3613 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3614 fn from_node(
3615 node: ::treesitter_types::tree_sitter::Node<'tree>,
3616 src: &'tree [u8],
3617 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3618 debug_assert_eq!(node.kind(), "exp");
3619 Ok(Self {
3620 span: ::treesitter_types::Span::from(node),
3621 children: {
3622 #[allow(clippy::suspicious_else_formatting)]
3623 let non_field_children = {
3624 let mut cursor = node.walk();
3625 let mut result = ::std::vec::Vec::new();
3626 if cursor.goto_first_child() {
3627 loop {
3628 if cursor.field_name().is_none()
3629 && cursor.node().is_named()
3630 && !cursor.node().is_extra()
3631 {
3632 result.push(cursor.node());
3633 }
3634 if !cursor.goto_next_sibling() {
3635 break;
3636 }
3637 }
3638 }
3639 result
3640 };
3641 let child = if let Some(&c) = non_field_children.first() {
3642 c
3643 } else {
3644 let mut fallback_cursor = node.walk();
3645 let mut fallback_child = None;
3646 if fallback_cursor.goto_first_child() {
3647 loop {
3648 if fallback_cursor.field_name().is_none()
3649 && !fallback_cursor.node().is_extra()
3650 {
3651 let candidate = fallback_cursor.node();
3652 #[allow(clippy::needless_question_mark)]
3653 if (|| -> ::core::result::Result<
3654 _,
3655 ::treesitter_types::ParseError,
3656 > {
3657 let child = candidate;
3658 Ok(
3659 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpChildren as ::treesitter_types::FromNode>::from_node(
3660 child,
3661 src,
3662 ))?,
3663 )
3664 })()
3665 .is_ok()
3666 {
3667 fallback_child = Some(candidate);
3668 break;
3669 }
3670 }
3671 if !fallback_cursor.goto_next_sibling() {
3672 break;
3673 }
3674 }
3675 }
3676 if fallback_child.is_none() {
3677 let mut cursor2 = node.walk();
3678 if cursor2.goto_first_child() {
3679 loop {
3680 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3681 let candidate = cursor2.node();
3682 #[allow(clippy::needless_question_mark)]
3683 if (|| -> ::core::result::Result<
3684 _,
3685 ::treesitter_types::ParseError,
3686 > {
3687 let child = candidate;
3688 Ok(
3689 ::treesitter_types::runtime::maybe_grow_stack(|| <ExpChildren as ::treesitter_types::FromNode>::from_node(
3690 child,
3691 src,
3692 ))?,
3693 )
3694 })()
3695 .is_ok()
3696 {
3697 fallback_child = Some(candidate);
3698 break;
3699 }
3700 }
3701 if !cursor2.goto_next_sibling() {
3702 break;
3703 }
3704 }
3705 }
3706 }
3707 fallback_child.ok_or_else(|| {
3708 ::treesitter_types::ParseError::missing_field("children", node)
3709 })?
3710 };
3711 ::treesitter_types::runtime::maybe_grow_stack(|| {
3712 <ExpChildren as ::treesitter_types::FromNode>::from_node(child, src)
3713 })?
3714 },
3715 })
3716 }
3717}
3718impl ::treesitter_types::Spanned for Exp<'_> {
3719 fn span(&self) -> ::treesitter_types::Span {
3720 self.span
3721 }
3722}
3723#[derive(Debug, Clone, PartialEq, Eq)]
3724pub struct ExplicitType<'tree> {
3725 pub span: ::treesitter_types::Span,
3726 pub r#type: Type<'tree>,
3727}
3728impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitType<'tree> {
3729 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3730 fn from_node(
3731 node: ::treesitter_types::tree_sitter::Node<'tree>,
3732 src: &'tree [u8],
3733 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3734 debug_assert_eq!(node.kind(), "explicit_type");
3735 Ok(Self {
3736 span: ::treesitter_types::Span::from(node),
3737 r#type: {
3738 let child = node
3739 .child_by_field_name("type")
3740 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3741 ::treesitter_types::runtime::maybe_grow_stack(|| {
3742 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3743 })?
3744 },
3745 })
3746 }
3747}
3748impl ::treesitter_types::Spanned for ExplicitType<'_> {
3749 fn span(&self) -> ::treesitter_types::Span {
3750 self.span
3751 }
3752}
3753#[derive(Debug, Clone, PartialEq, Eq)]
3754pub struct Export<'tree> {
3755 pub span: ::treesitter_types::Span,
3756 pub children: ::core::option::Option<Children<'tree>>,
3757 pub namespace: ::core::option::Option<Namespace<'tree>>,
3758 pub operator: ::core::option::Option<PrefixId<'tree>>,
3759 pub r#type: ::core::option::Option<ExportType<'tree>>,
3760 pub variable: ::core::option::Option<ExportVariable<'tree>>,
3761}
3762impl<'tree> ::treesitter_types::FromNode<'tree> for Export<'tree> {
3763 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3764 fn from_node(
3765 node: ::treesitter_types::tree_sitter::Node<'tree>,
3766 src: &'tree [u8],
3767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3768 debug_assert_eq!(node.kind(), "export");
3769 Ok(Self {
3770 span: ::treesitter_types::Span::from(node),
3771 children: match node.child_by_field_name("children") {
3772 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3773 <Children as ::treesitter_types::FromNode>::from_node(child, src)
3774 })?),
3775 None => None,
3776 },
3777 namespace: match node.child_by_field_name("namespace") {
3778 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3779 <Namespace as ::treesitter_types::FromNode>::from_node(child, src)
3780 })?),
3781 None => None,
3782 },
3783 operator: match node.child_by_field_name("operator") {
3784 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3785 <PrefixId as ::treesitter_types::FromNode>::from_node(child, src)
3786 })?),
3787 None => None,
3788 },
3789 r#type: match node.child_by_field_name("type") {
3790 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3791 <ExportType as ::treesitter_types::FromNode>::from_node(child, src)
3792 })?),
3793 None => None,
3794 },
3795 variable: match node.child_by_field_name("variable") {
3796 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3797 <ExportVariable as ::treesitter_types::FromNode>::from_node(child, src)
3798 })?),
3799 None => None,
3800 },
3801 })
3802 }
3803}
3804impl ::treesitter_types::Spanned for Export<'_> {
3805 fn span(&self) -> ::treesitter_types::Span {
3806 self.span
3807 }
3808}
3809#[derive(Debug, Clone, PartialEq, Eq)]
3810pub struct Exports<'tree> {
3811 pub span: ::treesitter_types::Span,
3812 pub export: ::std::vec::Vec<Export<'tree>>,
3813 pub children: ::std::vec::Vec<ModuleExport<'tree>>,
3814}
3815impl<'tree> ::treesitter_types::FromNode<'tree> for Exports<'tree> {
3816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3817 fn from_node(
3818 node: ::treesitter_types::tree_sitter::Node<'tree>,
3819 src: &'tree [u8],
3820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3821 debug_assert_eq!(node.kind(), "exports");
3822 Ok(Self {
3823 span: ::treesitter_types::Span::from(node),
3824 export: {
3825 let mut cursor = node.walk();
3826 let mut items = ::std::vec::Vec::new();
3827 for child in node.children_by_field_name("export", &mut cursor) {
3828 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3829 <Export as ::treesitter_types::FromNode>::from_node(child, src)
3830 })?);
3831 }
3832 items
3833 },
3834 children: {
3835 #[allow(clippy::suspicious_else_formatting)]
3836 let non_field_children = {
3837 let mut cursor = node.walk();
3838 let mut result = ::std::vec::Vec::new();
3839 if cursor.goto_first_child() {
3840 loop {
3841 if cursor.field_name().is_none()
3842 && cursor.node().is_named()
3843 && !cursor.node().is_extra()
3844 {
3845 result.push(cursor.node());
3846 }
3847 if !cursor.goto_next_sibling() {
3848 break;
3849 }
3850 }
3851 }
3852 result
3853 };
3854 let mut items = ::std::vec::Vec::new();
3855 for child in non_field_children {
3856 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3857 <ModuleExport as ::treesitter_types::FromNode>::from_node(child, src)
3858 })?);
3859 }
3860 items
3861 },
3862 })
3863 }
3864}
3865impl ::treesitter_types::Spanned for Exports<'_> {
3866 fn span(&self) -> ::treesitter_types::Span {
3867 self.span
3868 }
3869}
3870#[derive(Debug, Clone, PartialEq, Eq)]
3871pub struct Field<'tree> {
3872 pub span: ::treesitter_types::Span,
3873 pub name: ::std::vec::Vec<FieldName<'tree>>,
3874 pub parameter: ::core::option::Option<FieldParameter<'tree>>,
3875 pub r#type: ::core::option::Option<FieldType<'tree>>,
3876 pub children: ::core::option::Option<Type<'tree>>,
3877}
3878impl<'tree> ::treesitter_types::FromNode<'tree> for Field<'tree> {
3879 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3880 fn from_node(
3881 node: ::treesitter_types::tree_sitter::Node<'tree>,
3882 src: &'tree [u8],
3883 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3884 debug_assert_eq!(node.kind(), "field");
3885 Ok(Self {
3886 span: ::treesitter_types::Span::from(node),
3887 name: {
3888 let mut cursor = node.walk();
3889 let mut items = ::std::vec::Vec::new();
3890 for child in node.children_by_field_name("name", &mut cursor) {
3891 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
3892 <FieldName as ::treesitter_types::FromNode>::from_node(child, src)
3893 })?);
3894 }
3895 items
3896 },
3897 parameter: match node.child_by_field_name("parameter") {
3898 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3899 <FieldParameter as ::treesitter_types::FromNode>::from_node(child, src)
3900 })?),
3901 None => None,
3902 },
3903 r#type: match node.child_by_field_name("type") {
3904 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3905 <FieldType as ::treesitter_types::FromNode>::from_node(child, src)
3906 })?),
3907 None => None,
3908 },
3909 children: {
3910 #[allow(clippy::suspicious_else_formatting)]
3911 let non_field_children = {
3912 let mut cursor = node.walk();
3913 let mut result = ::std::vec::Vec::new();
3914 if cursor.goto_first_child() {
3915 loop {
3916 if cursor.field_name().is_none()
3917 && cursor.node().is_named()
3918 && !cursor.node().is_extra()
3919 {
3920 result.push(cursor.node());
3921 }
3922 if !cursor.goto_next_sibling() {
3923 break;
3924 }
3925 }
3926 }
3927 result
3928 };
3929 match non_field_children.first() {
3930 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
3931 <Type as ::treesitter_types::FromNode>::from_node(child, src)
3932 })?),
3933 None => None,
3934 }
3935 },
3936 })
3937 }
3938}
3939impl ::treesitter_types::Spanned for Field<'_> {
3940 fn span(&self) -> ::treesitter_types::Span {
3941 self.span
3942 }
3943}
3944#[derive(Debug, Clone, PartialEq, Eq)]
3945pub struct FieldName<'tree> {
3946 pub span: ::treesitter_types::Span,
3947 pub children: Variable<'tree>,
3948}
3949impl<'tree> ::treesitter_types::FromNode<'tree> for FieldName<'tree> {
3950 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3951 fn from_node(
3952 node: ::treesitter_types::tree_sitter::Node<'tree>,
3953 src: &'tree [u8],
3954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3955 debug_assert_eq!(node.kind(), "field_name");
3956 Ok(Self {
3957 span: ::treesitter_types::Span::from(node),
3958 children: {
3959 #[allow(clippy::suspicious_else_formatting)]
3960 let non_field_children = {
3961 let mut cursor = node.walk();
3962 let mut result = ::std::vec::Vec::new();
3963 if cursor.goto_first_child() {
3964 loop {
3965 if cursor.field_name().is_none()
3966 && cursor.node().is_named()
3967 && !cursor.node().is_extra()
3968 {
3969 result.push(cursor.node());
3970 }
3971 if !cursor.goto_next_sibling() {
3972 break;
3973 }
3974 }
3975 }
3976 result
3977 };
3978 let child = if let Some(&c) = non_field_children.first() {
3979 c
3980 } else {
3981 let mut fallback_cursor = node.walk();
3982 let mut fallback_child = None;
3983 if fallback_cursor.goto_first_child() {
3984 loop {
3985 if fallback_cursor.field_name().is_none()
3986 && !fallback_cursor.node().is_extra()
3987 {
3988 let candidate = fallback_cursor.node();
3989 #[allow(clippy::needless_question_mark)]
3990 if (|| -> ::core::result::Result<
3991 _,
3992 ::treesitter_types::ParseError,
3993 > {
3994 let child = candidate;
3995 Ok(
3996 ::treesitter_types::runtime::maybe_grow_stack(|| <Variable as ::treesitter_types::FromNode>::from_node(
3997 child,
3998 src,
3999 ))?,
4000 )
4001 })()
4002 .is_ok()
4003 {
4004 fallback_child = Some(candidate);
4005 break;
4006 }
4007 }
4008 if !fallback_cursor.goto_next_sibling() {
4009 break;
4010 }
4011 }
4012 }
4013 if fallback_child.is_none() {
4014 let mut cursor2 = node.walk();
4015 if cursor2.goto_first_child() {
4016 loop {
4017 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4018 let candidate = cursor2.node();
4019 #[allow(clippy::needless_question_mark)]
4020 if (|| -> ::core::result::Result<
4021 _,
4022 ::treesitter_types::ParseError,
4023 > {
4024 let child = candidate;
4025 Ok(
4026 ::treesitter_types::runtime::maybe_grow_stack(|| <Variable as ::treesitter_types::FromNode>::from_node(
4027 child,
4028 src,
4029 ))?,
4030 )
4031 })()
4032 .is_ok()
4033 {
4034 fallback_child = Some(candidate);
4035 break;
4036 }
4037 }
4038 if !cursor2.goto_next_sibling() {
4039 break;
4040 }
4041 }
4042 }
4043 }
4044 fallback_child.ok_or_else(|| {
4045 ::treesitter_types::ParseError::missing_field("children", node)
4046 })?
4047 };
4048 ::treesitter_types::runtime::maybe_grow_stack(|| {
4049 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
4050 })?
4051 },
4052 })
4053 }
4054}
4055impl ::treesitter_types::Spanned for FieldName<'_> {
4056 fn span(&self) -> ::treesitter_types::Span {
4057 self.span
4058 }
4059}
4060#[derive(Debug, Clone, PartialEq, Eq)]
4061pub struct FieldPath<'tree> {
4062 pub span: ::treesitter_types::Span,
4063 pub field: FieldPathField<'tree>,
4064 pub subfield: ::std::vec::Vec<FieldName<'tree>>,
4065}
4066impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPath<'tree> {
4067 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4068 fn from_node(
4069 node: ::treesitter_types::tree_sitter::Node<'tree>,
4070 src: &'tree [u8],
4071 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4072 debug_assert_eq!(node.kind(), "field_path");
4073 Ok(Self {
4074 span: ::treesitter_types::Span::from(node),
4075 field: {
4076 let child = node
4077 .child_by_field_name("field")
4078 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
4079 ::treesitter_types::runtime::maybe_grow_stack(|| {
4080 <FieldPathField as ::treesitter_types::FromNode>::from_node(child, src)
4081 })?
4082 },
4083 subfield: {
4084 let mut cursor = node.walk();
4085 let mut items = ::std::vec::Vec::new();
4086 for child in node.children_by_field_name("subfield", &mut cursor) {
4087 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4088 <FieldName as ::treesitter_types::FromNode>::from_node(child, src)
4089 })?);
4090 }
4091 items
4092 },
4093 })
4094 }
4095}
4096impl ::treesitter_types::Spanned for FieldPath<'_> {
4097 fn span(&self) -> ::treesitter_types::Span {
4098 self.span
4099 }
4100}
4101#[derive(Debug, Clone, PartialEq, Eq)]
4102pub struct FieldPattern<'tree> {
4103 pub span: ::treesitter_types::Span,
4104 pub field: ::core::option::Option<FieldPatternField<'tree>>,
4105 pub pattern: ::core::option::Option<FieldPatternPattern<'tree>>,
4106 pub children: ::core::option::Option<Wildcard<'tree>>,
4107}
4108impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPattern<'tree> {
4109 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4110 fn from_node(
4111 node: ::treesitter_types::tree_sitter::Node<'tree>,
4112 src: &'tree [u8],
4113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4114 debug_assert_eq!(node.kind(), "field_pattern");
4115 Ok(Self {
4116 span: ::treesitter_types::Span::from(node),
4117 field: match node.child_by_field_name("field") {
4118 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4119 <FieldPatternField as ::treesitter_types::FromNode>::from_node(child, src)
4120 })?),
4121 None => None,
4122 },
4123 pattern: match node.child_by_field_name("pattern") {
4124 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4125 <FieldPatternPattern as ::treesitter_types::FromNode>::from_node(child, src)
4126 })?),
4127 None => None,
4128 },
4129 children: {
4130 #[allow(clippy::suspicious_else_formatting)]
4131 let non_field_children = {
4132 let mut cursor = node.walk();
4133 let mut result = ::std::vec::Vec::new();
4134 if cursor.goto_first_child() {
4135 loop {
4136 if cursor.field_name().is_none()
4137 && cursor.node().is_named()
4138 && !cursor.node().is_extra()
4139 {
4140 result.push(cursor.node());
4141 }
4142 if !cursor.goto_next_sibling() {
4143 break;
4144 }
4145 }
4146 }
4147 result
4148 };
4149 match non_field_children.first() {
4150 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4151 <Wildcard as ::treesitter_types::FromNode>::from_node(child, src)
4152 })?),
4153 None => None,
4154 }
4155 },
4156 })
4157 }
4158}
4159impl ::treesitter_types::Spanned for FieldPattern<'_> {
4160 fn span(&self) -> ::treesitter_types::Span {
4161 self.span
4162 }
4163}
4164#[derive(Debug, Clone, PartialEq, Eq)]
4165pub struct FieldUpdate<'tree> {
4166 pub span: ::treesitter_types::Span,
4167 pub expression: ::core::option::Option<FieldUpdateExpression<'tree>>,
4168 pub field: ::core::option::Option<FieldUpdateField<'tree>>,
4169 pub children: ::core::option::Option<Wildcard<'tree>>,
4170}
4171impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdate<'tree> {
4172 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4173 fn from_node(
4174 node: ::treesitter_types::tree_sitter::Node<'tree>,
4175 src: &'tree [u8],
4176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4177 debug_assert_eq!(node.kind(), "field_update");
4178 Ok(Self {
4179 span: ::treesitter_types::Span::from(node),
4180 expression: match node.child_by_field_name("expression") {
4181 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4182 <FieldUpdateExpression as ::treesitter_types::FromNode>::from_node(child, src)
4183 })?),
4184 None => None,
4185 },
4186 field: match node.child_by_field_name("field") {
4187 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4188 <FieldUpdateField as ::treesitter_types::FromNode>::from_node(child, src)
4189 })?),
4190 None => None,
4191 },
4192 children: {
4193 #[allow(clippy::suspicious_else_formatting)]
4194 let non_field_children = {
4195 let mut cursor = node.walk();
4196 let mut result = ::std::vec::Vec::new();
4197 if cursor.goto_first_child() {
4198 loop {
4199 if cursor.field_name().is_none()
4200 && cursor.node().is_named()
4201 && !cursor.node().is_extra()
4202 {
4203 result.push(cursor.node());
4204 }
4205 if !cursor.goto_next_sibling() {
4206 break;
4207 }
4208 }
4209 }
4210 result
4211 };
4212 match non_field_children.first() {
4213 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4214 <Wildcard as ::treesitter_types::FromNode>::from_node(child, src)
4215 })?),
4216 None => None,
4217 }
4218 },
4219 })
4220 }
4221}
4222impl ::treesitter_types::Spanned for FieldUpdate<'_> {
4223 fn span(&self) -> ::treesitter_types::Span {
4224 self.span
4225 }
4226}
4227#[derive(Debug, Clone, PartialEq, Eq)]
4228pub struct Fields<'tree> {
4229 pub span: ::treesitter_types::Span,
4230 pub field: ::std::vec::Vec<Field<'tree>>,
4231}
4232impl<'tree> ::treesitter_types::FromNode<'tree> for Fields<'tree> {
4233 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4234 fn from_node(
4235 node: ::treesitter_types::tree_sitter::Node<'tree>,
4236 src: &'tree [u8],
4237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4238 debug_assert_eq!(node.kind(), "fields");
4239 Ok(Self {
4240 span: ::treesitter_types::Span::from(node),
4241 field: {
4242 let mut cursor = node.walk();
4243 let mut items = ::std::vec::Vec::new();
4244 for child in node.children_by_field_name("field", &mut cursor) {
4245 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4246 <Field as ::treesitter_types::FromNode>::from_node(child, src)
4247 })?);
4248 }
4249 items
4250 },
4251 })
4252 }
4253}
4254impl ::treesitter_types::Spanned for Fields<'_> {
4255 fn span(&self) -> ::treesitter_types::Span {
4256 self.span
4257 }
4258}
4259#[derive(Debug, Clone, PartialEq, Eq)]
4260pub struct Fixity<'tree> {
4261 pub span: ::treesitter_types::Span,
4262 pub associativity: FixityAssociativity,
4263 pub operator: ::std::vec::Vec<FixityOperator<'tree>>,
4264 pub precedence: ::core::option::Option<Integer<'tree>>,
4265}
4266impl<'tree> ::treesitter_types::FromNode<'tree> for Fixity<'tree> {
4267 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4268 fn from_node(
4269 node: ::treesitter_types::tree_sitter::Node<'tree>,
4270 src: &'tree [u8],
4271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4272 debug_assert_eq!(node.kind(), "fixity");
4273 Ok(Self {
4274 span: ::treesitter_types::Span::from(node),
4275 associativity: {
4276 let child = node.child_by_field_name("associativity").ok_or_else(|| {
4277 ::treesitter_types::ParseError::missing_field("associativity", node)
4278 })?;
4279 ::treesitter_types::runtime::maybe_grow_stack(|| {
4280 <FixityAssociativity as ::treesitter_types::FromNode>::from_node(child, src)
4281 })?
4282 },
4283 operator: {
4284 let mut cursor = node.walk();
4285 let mut items = ::std::vec::Vec::new();
4286 for child in node.children_by_field_name("operator", &mut cursor) {
4287 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4288 <FixityOperator as ::treesitter_types::FromNode>::from_node(child, src)
4289 })?);
4290 }
4291 items
4292 },
4293 precedence: match node.child_by_field_name("precedence") {
4294 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4295 <Integer as ::treesitter_types::FromNode>::from_node(child, src)
4296 })?),
4297 None => None,
4298 },
4299 })
4300 }
4301}
4302impl ::treesitter_types::Spanned for Fixity<'_> {
4303 fn span(&self) -> ::treesitter_types::Span {
4304 self.span
4305 }
4306}
4307#[derive(Debug, Clone, PartialEq, Eq)]
4308pub struct Forall<'tree> {
4309 pub span: ::treesitter_types::Span,
4310 pub constraint: ::core::option::Option<Constraints<'tree>>,
4311 pub quantifier: ForallQuantifier,
4312 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
4313 pub variables: ::core::option::Option<QuantifiedVariables<'tree>>,
4314}
4315impl<'tree> ::treesitter_types::FromNode<'tree> for Forall<'tree> {
4316 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4317 fn from_node(
4318 node: ::treesitter_types::tree_sitter::Node<'tree>,
4319 src: &'tree [u8],
4320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4321 debug_assert_eq!(node.kind(), "forall");
4322 Ok(Self {
4323 span: ::treesitter_types::Span::from(node),
4324 constraint: match node.child_by_field_name("constraint") {
4325 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4326 <Constraints as ::treesitter_types::FromNode>::from_node(child, src)
4327 })?),
4328 None => None,
4329 },
4330 quantifier: {
4331 let child = node.child_by_field_name("quantifier").ok_or_else(|| {
4332 ::treesitter_types::ParseError::missing_field("quantifier", node)
4333 })?;
4334 ::treesitter_types::runtime::maybe_grow_stack(|| {
4335 <ForallQuantifier as ::treesitter_types::FromNode>::from_node(child, src)
4336 })?
4337 },
4338 r#type: match node.child_by_field_name("type") {
4339 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4340 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
4341 })?),
4342 None => None,
4343 },
4344 variables: match node.child_by_field_name("variables") {
4345 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4346 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(child, src)
4347 })?),
4348 None => None,
4349 },
4350 })
4351 }
4352}
4353impl ::treesitter_types::Spanned for Forall<'_> {
4354 fn span(&self) -> ::treesitter_types::Span {
4355 self.span
4356 }
4357}
4358#[derive(Debug, Clone, PartialEq, Eq)]
4359pub struct ForallRequired<'tree> {
4360 pub span: ::treesitter_types::Span,
4361 pub quantifier: ForallRequiredQuantifier,
4362 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
4363 pub variables: ::core::option::Option<QuantifiedVariables<'tree>>,
4364}
4365impl<'tree> ::treesitter_types::FromNode<'tree> for ForallRequired<'tree> {
4366 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4367 fn from_node(
4368 node: ::treesitter_types::tree_sitter::Node<'tree>,
4369 src: &'tree [u8],
4370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4371 debug_assert_eq!(node.kind(), "forall_required");
4372 Ok(Self {
4373 span: ::treesitter_types::Span::from(node),
4374 quantifier: {
4375 let child = node.child_by_field_name("quantifier").ok_or_else(|| {
4376 ::treesitter_types::ParseError::missing_field("quantifier", node)
4377 })?;
4378 ::treesitter_types::runtime::maybe_grow_stack(|| {
4379 <ForallRequiredQuantifier as ::treesitter_types::FromNode>::from_node(
4380 child, src,
4381 )
4382 })?
4383 },
4384 r#type: match node.child_by_field_name("type") {
4385 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4386 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
4387 })?),
4388 None => None,
4389 },
4390 variables: match node.child_by_field_name("variables") {
4391 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4392 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(child, src)
4393 })?),
4394 None => None,
4395 },
4396 })
4397 }
4398}
4399impl ::treesitter_types::Spanned for ForallRequired<'_> {
4400 fn span(&self) -> ::treesitter_types::Span {
4401 self.span
4402 }
4403}
4404#[derive(Debug, Clone, PartialEq, Eq)]
4405pub struct ForeignExport<'tree> {
4406 pub span: ::treesitter_types::Span,
4407 pub calling_convention: CallingConvention<'tree>,
4408 pub entity: ::core::option::Option<Entity<'tree>>,
4409 pub signature: Signature<'tree>,
4410}
4411impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignExport<'tree> {
4412 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4413 fn from_node(
4414 node: ::treesitter_types::tree_sitter::Node<'tree>,
4415 src: &'tree [u8],
4416 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4417 debug_assert_eq!(node.kind(), "foreign_export");
4418 Ok(Self {
4419 span: ::treesitter_types::Span::from(node),
4420 calling_convention: {
4421 let child = node
4422 .child_by_field_name("calling_convention")
4423 .ok_or_else(|| {
4424 ::treesitter_types::ParseError::missing_field("calling_convention", node)
4425 })?;
4426 ::treesitter_types::runtime::maybe_grow_stack(|| {
4427 <CallingConvention as ::treesitter_types::FromNode>::from_node(child, src)
4428 })?
4429 },
4430 entity: match node.child_by_field_name("entity") {
4431 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4432 <Entity as ::treesitter_types::FromNode>::from_node(child, src)
4433 })?),
4434 None => None,
4435 },
4436 signature: {
4437 let child = node.child_by_field_name("signature").ok_or_else(|| {
4438 ::treesitter_types::ParseError::missing_field("signature", node)
4439 })?;
4440 ::treesitter_types::runtime::maybe_grow_stack(|| {
4441 <Signature as ::treesitter_types::FromNode>::from_node(child, src)
4442 })?
4443 },
4444 })
4445 }
4446}
4447impl ::treesitter_types::Spanned for ForeignExport<'_> {
4448 fn span(&self) -> ::treesitter_types::Span {
4449 self.span
4450 }
4451}
4452#[derive(Debug, Clone, PartialEq, Eq)]
4453pub struct ForeignImport<'tree> {
4454 pub span: ::treesitter_types::Span,
4455 pub calling_convention: CallingConvention<'tree>,
4456 pub entity: ::core::option::Option<Entity<'tree>>,
4457 pub safety: ::core::option::Option<Safety<'tree>>,
4458 pub signature: Signature<'tree>,
4459}
4460impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignImport<'tree> {
4461 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4462 fn from_node(
4463 node: ::treesitter_types::tree_sitter::Node<'tree>,
4464 src: &'tree [u8],
4465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4466 debug_assert_eq!(node.kind(), "foreign_import");
4467 Ok(Self {
4468 span: ::treesitter_types::Span::from(node),
4469 calling_convention: {
4470 let child = node
4471 .child_by_field_name("calling_convention")
4472 .ok_or_else(|| {
4473 ::treesitter_types::ParseError::missing_field("calling_convention", node)
4474 })?;
4475 ::treesitter_types::runtime::maybe_grow_stack(|| {
4476 <CallingConvention as ::treesitter_types::FromNode>::from_node(child, src)
4477 })?
4478 },
4479 entity: match node.child_by_field_name("entity") {
4480 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4481 <Entity as ::treesitter_types::FromNode>::from_node(child, src)
4482 })?),
4483 None => None,
4484 },
4485 safety: match node.child_by_field_name("safety") {
4486 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4487 <Safety as ::treesitter_types::FromNode>::from_node(child, src)
4488 })?),
4489 None => None,
4490 },
4491 signature: {
4492 let child = node.child_by_field_name("signature").ok_or_else(|| {
4493 ::treesitter_types::ParseError::missing_field("signature", node)
4494 })?;
4495 ::treesitter_types::runtime::maybe_grow_stack(|| {
4496 <Signature as ::treesitter_types::FromNode>::from_node(child, src)
4497 })?
4498 },
4499 })
4500 }
4501}
4502impl ::treesitter_types::Spanned for ForeignImport<'_> {
4503 fn span(&self) -> ::treesitter_types::Span {
4504 self.span
4505 }
4506}
4507#[derive(Debug, Clone, PartialEq, Eq)]
4508pub struct Function<'tree> {
4509 pub span: ::treesitter_types::Span,
4510 pub arrow: ::core::option::Option<FunctionArrow>,
4511 pub binds: ::core::option::Option<LocalBinds<'tree>>,
4512 pub r#match: ::std::vec::Vec<Match<'tree>>,
4513 pub name: ::core::option::Option<FunctionName<'tree>>,
4514 pub parameter: ::core::option::Option<FunctionParameter<'tree>>,
4515 pub parens: ::core::option::Option<FunctionHeadParens<'tree>>,
4516 pub patterns: ::core::option::Option<Patterns<'tree>>,
4517 pub result: ::core::option::Option<QuantifiedType<'tree>>,
4518 pub children: ::core::option::Option<Infix<'tree>>,
4519}
4520impl<'tree> ::treesitter_types::FromNode<'tree> for Function<'tree> {
4521 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4522 fn from_node(
4523 node: ::treesitter_types::tree_sitter::Node<'tree>,
4524 src: &'tree [u8],
4525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4526 debug_assert_eq!(node.kind(), "function");
4527 Ok(Self {
4528 span: ::treesitter_types::Span::from(node),
4529 arrow: match node.child_by_field_name("arrow") {
4530 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4531 <FunctionArrow as ::treesitter_types::FromNode>::from_node(child, src)
4532 })?),
4533 None => None,
4534 },
4535 binds: match node.child_by_field_name("binds") {
4536 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4537 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
4538 })?),
4539 None => None,
4540 },
4541 r#match: {
4542 let mut cursor = node.walk();
4543 let mut items = ::std::vec::Vec::new();
4544 for child in node.children_by_field_name("match", &mut cursor) {
4545 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4546 <Match as ::treesitter_types::FromNode>::from_node(child, src)
4547 })?);
4548 }
4549 items
4550 },
4551 name: match node.child_by_field_name("name") {
4552 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4553 <FunctionName as ::treesitter_types::FromNode>::from_node(child, src)
4554 })?),
4555 None => None,
4556 },
4557 parameter: match node.child_by_field_name("parameter") {
4558 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4559 <FunctionParameter as ::treesitter_types::FromNode>::from_node(child, src)
4560 })?),
4561 None => None,
4562 },
4563 parens: match node.child_by_field_name("parens") {
4564 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4565 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(child, src)
4566 })?),
4567 None => None,
4568 },
4569 patterns: match node.child_by_field_name("patterns") {
4570 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4571 <Patterns as ::treesitter_types::FromNode>::from_node(child, src)
4572 })?),
4573 None => None,
4574 },
4575 result: match node.child_by_field_name("result") {
4576 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4577 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
4578 })?),
4579 None => None,
4580 },
4581 children: {
4582 #[allow(clippy::suspicious_else_formatting)]
4583 let non_field_children = {
4584 let mut cursor = node.walk();
4585 let mut result = ::std::vec::Vec::new();
4586 if cursor.goto_first_child() {
4587 loop {
4588 if cursor.field_name().is_none()
4589 && cursor.node().is_named()
4590 && !cursor.node().is_extra()
4591 {
4592 result.push(cursor.node());
4593 }
4594 if !cursor.goto_next_sibling() {
4595 break;
4596 }
4597 }
4598 }
4599 result
4600 };
4601 match non_field_children.first() {
4602 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4603 <Infix as ::treesitter_types::FromNode>::from_node(child, src)
4604 })?),
4605 None => None,
4606 }
4607 },
4608 })
4609 }
4610}
4611impl ::treesitter_types::Spanned for Function<'_> {
4612 fn span(&self) -> ::treesitter_types::Span {
4613 self.span
4614 }
4615}
4616#[derive(Debug, Clone, PartialEq, Eq)]
4617pub struct FunctionHeadParens<'tree> {
4618 pub span: ::treesitter_types::Span,
4619 pub name: ::core::option::Option<FunctionHeadParensName<'tree>>,
4620 pub parens: ::core::option::Option<::std::boxed::Box<FunctionHeadParens<'tree>>>,
4621 pub patterns: ::core::option::Option<Patterns<'tree>>,
4622 pub children: ::core::option::Option<Infix<'tree>>,
4623}
4624impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionHeadParens<'tree> {
4625 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4626 fn from_node(
4627 node: ::treesitter_types::tree_sitter::Node<'tree>,
4628 src: &'tree [u8],
4629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4630 debug_assert_eq!(node.kind(), "function_head_parens");
4631 Ok(Self {
4632 span: ::treesitter_types::Span::from(node),
4633 name: match node.child_by_field_name("name") {
4634 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4635 <FunctionHeadParensName as ::treesitter_types::FromNode>::from_node(child, src)
4636 })?),
4637 None => None,
4638 },
4639 parens: match node.child_by_field_name("parens") {
4640 Some(child) => Some(::std::boxed::Box::new(
4641 ::treesitter_types::runtime::maybe_grow_stack(|| {
4642 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(child, src)
4643 })?,
4644 )),
4645 None => None,
4646 },
4647 patterns: match node.child_by_field_name("patterns") {
4648 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4649 <Patterns as ::treesitter_types::FromNode>::from_node(child, src)
4650 })?),
4651 None => None,
4652 },
4653 children: {
4654 #[allow(clippy::suspicious_else_formatting)]
4655 let non_field_children = {
4656 let mut cursor = node.walk();
4657 let mut result = ::std::vec::Vec::new();
4658 if cursor.goto_first_child() {
4659 loop {
4660 if cursor.field_name().is_none()
4661 && cursor.node().is_named()
4662 && !cursor.node().is_extra()
4663 {
4664 result.push(cursor.node());
4665 }
4666 if !cursor.goto_next_sibling() {
4667 break;
4668 }
4669 }
4670 }
4671 result
4672 };
4673 match non_field_children.first() {
4674 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4675 <Infix as ::treesitter_types::FromNode>::from_node(child, src)
4676 })?),
4677 None => None,
4678 }
4679 },
4680 })
4681 }
4682}
4683impl ::treesitter_types::Spanned for FunctionHeadParens<'_> {
4684 fn span(&self) -> ::treesitter_types::Span {
4685 self.span
4686 }
4687}
4688#[derive(Debug, Clone, PartialEq, Eq)]
4689pub struct Fundep<'tree> {
4690 pub span: ::treesitter_types::Span,
4691 pub determined: ::std::vec::Vec<Variable<'tree>>,
4692 pub matched: ::std::vec::Vec<Variable<'tree>>,
4693}
4694impl<'tree> ::treesitter_types::FromNode<'tree> for Fundep<'tree> {
4695 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4696 fn from_node(
4697 node: ::treesitter_types::tree_sitter::Node<'tree>,
4698 src: &'tree [u8],
4699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4700 debug_assert_eq!(node.kind(), "fundep");
4701 Ok(Self {
4702 span: ::treesitter_types::Span::from(node),
4703 determined: {
4704 let mut cursor = node.walk();
4705 let mut items = ::std::vec::Vec::new();
4706 for child in node.children_by_field_name("determined", &mut cursor) {
4707 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4708 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
4709 })?);
4710 }
4711 items
4712 },
4713 matched: {
4714 let mut cursor = node.walk();
4715 let mut items = ::std::vec::Vec::new();
4716 for child in node.children_by_field_name("matched", &mut cursor) {
4717 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4718 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
4719 })?);
4720 }
4721 items
4722 },
4723 })
4724 }
4725}
4726impl ::treesitter_types::Spanned for Fundep<'_> {
4727 fn span(&self) -> ::treesitter_types::Span {
4728 self.span
4729 }
4730}
4731#[derive(Debug, Clone, PartialEq, Eq)]
4732pub struct Fundeps<'tree> {
4733 pub span: ::treesitter_types::Span,
4734 pub fundep: ::std::vec::Vec<Fundep<'tree>>,
4735}
4736impl<'tree> ::treesitter_types::FromNode<'tree> for Fundeps<'tree> {
4737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4738 fn from_node(
4739 node: ::treesitter_types::tree_sitter::Node<'tree>,
4740 src: &'tree [u8],
4741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4742 debug_assert_eq!(node.kind(), "fundeps");
4743 Ok(Self {
4744 span: ::treesitter_types::Span::from(node),
4745 fundep: {
4746 let mut cursor = node.walk();
4747 let mut items = ::std::vec::Vec::new();
4748 for child in node.children_by_field_name("fundep", &mut cursor) {
4749 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4750 <Fundep as ::treesitter_types::FromNode>::from_node(child, src)
4751 })?);
4752 }
4753 items
4754 },
4755 })
4756 }
4757}
4758impl ::treesitter_types::Spanned for Fundeps<'_> {
4759 fn span(&self) -> ::treesitter_types::Span {
4760 self.span
4761 }
4762}
4763#[derive(Debug, Clone, PartialEq, Eq)]
4764pub struct GadtConstructor<'tree> {
4765 pub span: ::treesitter_types::Span,
4766 pub context: ::core::option::Option<Context<'tree>>,
4767 pub forall: ::core::option::Option<GadtConstructorForall<'tree>>,
4768 pub name: ::core::option::Option<GadtConstructorName<'tree>>,
4769 pub names: ::core::option::Option<BindingList<'tree>>,
4770 pub r#type: GadtConstructorType<'tree>,
4771}
4772impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructor<'tree> {
4773 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4774 fn from_node(
4775 node: ::treesitter_types::tree_sitter::Node<'tree>,
4776 src: &'tree [u8],
4777 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4778 debug_assert_eq!(node.kind(), "gadt_constructor");
4779 Ok(Self {
4780 span: ::treesitter_types::Span::from(node),
4781 context: match node.child_by_field_name("context") {
4782 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4783 <Context as ::treesitter_types::FromNode>::from_node(child, src)
4784 })?),
4785 None => None,
4786 },
4787 forall: match node.child_by_field_name("forall") {
4788 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4789 <GadtConstructorForall as ::treesitter_types::FromNode>::from_node(child, src)
4790 })?),
4791 None => None,
4792 },
4793 name: match node.child_by_field_name("name") {
4794 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4795 <GadtConstructorName as ::treesitter_types::FromNode>::from_node(child, src)
4796 })?),
4797 None => None,
4798 },
4799 names: match node.child_by_field_name("names") {
4800 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4801 <BindingList as ::treesitter_types::FromNode>::from_node(child, src)
4802 })?),
4803 None => None,
4804 },
4805 r#type: {
4806 let child = node
4807 .child_by_field_name("type")
4808 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4809 ::treesitter_types::runtime::maybe_grow_stack(|| {
4810 <GadtConstructorType as ::treesitter_types::FromNode>::from_node(child, src)
4811 })?
4812 },
4813 })
4814 }
4815}
4816impl ::treesitter_types::Spanned for GadtConstructor<'_> {
4817 fn span(&self) -> ::treesitter_types::Span {
4818 self.span
4819 }
4820}
4821#[derive(Debug, Clone, PartialEq, Eq)]
4822pub struct GadtConstructors<'tree> {
4823 pub span: ::treesitter_types::Span,
4824 pub constructor: ::std::vec::Vec<GadtConstructor<'tree>>,
4825}
4826impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructors<'tree> {
4827 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4828 fn from_node(
4829 node: ::treesitter_types::tree_sitter::Node<'tree>,
4830 src: &'tree [u8],
4831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4832 debug_assert_eq!(node.kind(), "gadt_constructors");
4833 Ok(Self {
4834 span: ::treesitter_types::Span::from(node),
4835 constructor: {
4836 let mut cursor = node.walk();
4837 let mut items = ::std::vec::Vec::new();
4838 for child in node.children_by_field_name("constructor", &mut cursor) {
4839 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4840 <GadtConstructor as ::treesitter_types::FromNode>::from_node(child, src)
4841 })?);
4842 }
4843 items
4844 },
4845 })
4846 }
4847}
4848impl ::treesitter_types::Spanned for GadtConstructors<'_> {
4849 fn span(&self) -> ::treesitter_types::Span {
4850 self.span
4851 }
4852}
4853#[derive(Debug, Clone, PartialEq, Eq)]
4854pub struct Generator<'tree> {
4855 pub span: ::treesitter_types::Span,
4856 pub arrow: GeneratorArrow,
4857 pub expression: GeneratorExpression<'tree>,
4858 pub pattern: GeneratorPattern<'tree>,
4859}
4860impl<'tree> ::treesitter_types::FromNode<'tree> for Generator<'tree> {
4861 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4862 fn from_node(
4863 node: ::treesitter_types::tree_sitter::Node<'tree>,
4864 src: &'tree [u8],
4865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4866 debug_assert_eq!(node.kind(), "generator");
4867 Ok(Self {
4868 span: ::treesitter_types::Span::from(node),
4869 arrow: {
4870 let child = node
4871 .child_by_field_name("arrow")
4872 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
4873 ::treesitter_types::runtime::maybe_grow_stack(|| {
4874 <GeneratorArrow as ::treesitter_types::FromNode>::from_node(child, src)
4875 })?
4876 },
4877 expression: {
4878 let child = node.child_by_field_name("expression").ok_or_else(|| {
4879 ::treesitter_types::ParseError::missing_field("expression", node)
4880 })?;
4881 ::treesitter_types::runtime::maybe_grow_stack(|| {
4882 <GeneratorExpression as ::treesitter_types::FromNode>::from_node(child, src)
4883 })?
4884 },
4885 pattern: {
4886 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4887 ::treesitter_types::ParseError::missing_field("pattern", node)
4888 })?;
4889 ::treesitter_types::runtime::maybe_grow_stack(|| {
4890 <GeneratorPattern as ::treesitter_types::FromNode>::from_node(child, src)
4891 })?
4892 },
4893 })
4894 }
4895}
4896impl ::treesitter_types::Spanned for Generator<'_> {
4897 fn span(&self) -> ::treesitter_types::Span {
4898 self.span
4899 }
4900}
4901#[derive(Debug, Clone, PartialEq, Eq)]
4902pub struct Group<'tree> {
4903 pub span: ::treesitter_types::Span,
4904 pub classifier: GroupClassifier<'tree>,
4905 pub key: ::core::option::Option<GroupKey<'tree>>,
4906}
4907impl<'tree> ::treesitter_types::FromNode<'tree> for Group<'tree> {
4908 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4909 fn from_node(
4910 node: ::treesitter_types::tree_sitter::Node<'tree>,
4911 src: &'tree [u8],
4912 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4913 debug_assert_eq!(node.kind(), "group");
4914 Ok(Self {
4915 span: ::treesitter_types::Span::from(node),
4916 classifier: {
4917 let child = node.child_by_field_name("classifier").ok_or_else(|| {
4918 ::treesitter_types::ParseError::missing_field("classifier", node)
4919 })?;
4920 ::treesitter_types::runtime::maybe_grow_stack(|| {
4921 <GroupClassifier as ::treesitter_types::FromNode>::from_node(child, src)
4922 })?
4923 },
4924 key: match node.child_by_field_name("key") {
4925 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4926 <GroupKey as ::treesitter_types::FromNode>::from_node(child, src)
4927 })?),
4928 None => None,
4929 },
4930 })
4931 }
4932}
4933impl ::treesitter_types::Spanned for Group<'_> {
4934 fn span(&self) -> ::treesitter_types::Span {
4935 self.span
4936 }
4937}
4938#[derive(Debug, Clone, PartialEq, Eq)]
4939pub struct Guards<'tree> {
4940 pub span: ::treesitter_types::Span,
4941 pub guard: ::std::vec::Vec<Guard<'tree>>,
4942}
4943impl<'tree> ::treesitter_types::FromNode<'tree> for Guards<'tree> {
4944 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4945 fn from_node(
4946 node: ::treesitter_types::tree_sitter::Node<'tree>,
4947 src: &'tree [u8],
4948 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4949 debug_assert_eq!(node.kind(), "guards");
4950 Ok(Self {
4951 span: ::treesitter_types::Span::from(node),
4952 guard: {
4953 let mut cursor = node.walk();
4954 let mut items = ::std::vec::Vec::new();
4955 for child in node.children_by_field_name("guard", &mut cursor) {
4956 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
4957 <Guard as ::treesitter_types::FromNode>::from_node(child, src)
4958 })?);
4959 }
4960 items
4961 },
4962 })
4963 }
4964}
4965impl ::treesitter_types::Spanned for Guards<'_> {
4966 fn span(&self) -> ::treesitter_types::Span {
4967 self.span
4968 }
4969}
4970#[derive(Debug, Clone, PartialEq, Eq)]
4971pub struct Haskell<'tree> {
4972 pub span: ::treesitter_types::Span,
4973 pub declarations: ::core::option::Option<Declarations<'tree>>,
4974 pub imports: ::core::option::Option<Imports<'tree>>,
4975 pub children: ::core::option::Option<Header<'tree>>,
4976}
4977impl<'tree> ::treesitter_types::FromNode<'tree> for Haskell<'tree> {
4978 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4979 fn from_node(
4980 node: ::treesitter_types::tree_sitter::Node<'tree>,
4981 src: &'tree [u8],
4982 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4983 debug_assert_eq!(node.kind(), "haskell");
4984 Ok(Self {
4985 span: ::treesitter_types::Span::from(node),
4986 declarations: match node.child_by_field_name("declarations") {
4987 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4988 <Declarations as ::treesitter_types::FromNode>::from_node(child, src)
4989 })?),
4990 None => None,
4991 },
4992 imports: match node.child_by_field_name("imports") {
4993 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
4994 <Imports as ::treesitter_types::FromNode>::from_node(child, src)
4995 })?),
4996 None => None,
4997 },
4998 children: {
4999 #[allow(clippy::suspicious_else_formatting)]
5000 let non_field_children = {
5001 let mut cursor = node.walk();
5002 let mut result = ::std::vec::Vec::new();
5003 if cursor.goto_first_child() {
5004 loop {
5005 if cursor.field_name().is_none()
5006 && cursor.node().is_named()
5007 && !cursor.node().is_extra()
5008 {
5009 result.push(cursor.node());
5010 }
5011 if !cursor.goto_next_sibling() {
5012 break;
5013 }
5014 }
5015 }
5016 result
5017 };
5018 match non_field_children.first() {
5019 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5020 <Header as ::treesitter_types::FromNode>::from_node(child, src)
5021 })?),
5022 None => None,
5023 }
5024 },
5025 })
5026 }
5027}
5028impl ::treesitter_types::Spanned for Haskell<'_> {
5029 fn span(&self) -> ::treesitter_types::Span {
5030 self.span
5031 }
5032}
5033#[derive(Debug, Clone, PartialEq, Eq)]
5034pub struct Header<'tree> {
5035 pub span: ::treesitter_types::Span,
5036 pub exports: ::core::option::Option<Exports<'tree>>,
5037 pub module: Module<'tree>,
5038}
5039impl<'tree> ::treesitter_types::FromNode<'tree> for Header<'tree> {
5040 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5041 fn from_node(
5042 node: ::treesitter_types::tree_sitter::Node<'tree>,
5043 src: &'tree [u8],
5044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5045 debug_assert_eq!(node.kind(), "header");
5046 Ok(Self {
5047 span: ::treesitter_types::Span::from(node),
5048 exports: match node.child_by_field_name("exports") {
5049 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5050 <Exports as ::treesitter_types::FromNode>::from_node(child, src)
5051 })?),
5052 None => None,
5053 },
5054 module: {
5055 let child = node
5056 .child_by_field_name("module")
5057 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
5058 ::treesitter_types::runtime::maybe_grow_stack(|| {
5059 <Module as ::treesitter_types::FromNode>::from_node(child, src)
5060 })?
5061 },
5062 })
5063 }
5064}
5065impl ::treesitter_types::Spanned for Header<'_> {
5066 fn span(&self) -> ::treesitter_types::Span {
5067 self.span
5068 }
5069}
5070#[derive(Debug, Clone, PartialEq, Eq)]
5071pub struct ImplicitParameter<'tree> {
5072 pub span: ::treesitter_types::Span,
5073 pub name: ImplicitVariable<'tree>,
5074 pub r#type: QuantifiedType<'tree>,
5075}
5076impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitParameter<'tree> {
5077 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5078 fn from_node(
5079 node: ::treesitter_types::tree_sitter::Node<'tree>,
5080 src: &'tree [u8],
5081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5082 debug_assert_eq!(node.kind(), "implicit_parameter");
5083 Ok(Self {
5084 span: ::treesitter_types::Span::from(node),
5085 name: {
5086 let child = node
5087 .child_by_field_name("name")
5088 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5089 ::treesitter_types::runtime::maybe_grow_stack(|| {
5090 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)
5091 })?
5092 },
5093 r#type: {
5094 let child = node
5095 .child_by_field_name("type")
5096 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5097 ::treesitter_types::runtime::maybe_grow_stack(|| {
5098 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
5099 })?
5100 },
5101 })
5102 }
5103}
5104impl ::treesitter_types::Spanned for ImplicitParameter<'_> {
5105 fn span(&self) -> ::treesitter_types::Span {
5106 self.span
5107 }
5108}
5109#[derive(Debug, Clone, PartialEq, Eq)]
5110pub struct Import<'tree> {
5111 pub span: ::treesitter_types::Span,
5112 pub alias: ::core::option::Option<Module<'tree>>,
5113 pub module: Module<'tree>,
5114 pub names: ::core::option::Option<ImportList<'tree>>,
5115 pub package: ::core::option::Option<ImportPackage<'tree>>,
5116}
5117impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
5118 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5119 fn from_node(
5120 node: ::treesitter_types::tree_sitter::Node<'tree>,
5121 src: &'tree [u8],
5122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5123 debug_assert_eq!(node.kind(), "import");
5124 Ok(Self {
5125 span: ::treesitter_types::Span::from(node),
5126 alias: match node.child_by_field_name("alias") {
5127 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5128 <Module as ::treesitter_types::FromNode>::from_node(child, src)
5129 })?),
5130 None => None,
5131 },
5132 module: {
5133 let child = node
5134 .child_by_field_name("module")
5135 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
5136 ::treesitter_types::runtime::maybe_grow_stack(|| {
5137 <Module as ::treesitter_types::FromNode>::from_node(child, src)
5138 })?
5139 },
5140 names: match node.child_by_field_name("names") {
5141 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5142 <ImportList as ::treesitter_types::FromNode>::from_node(child, src)
5143 })?),
5144 None => None,
5145 },
5146 package: match node.child_by_field_name("package") {
5147 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5148 <ImportPackage as ::treesitter_types::FromNode>::from_node(child, src)
5149 })?),
5150 None => None,
5151 },
5152 })
5153 }
5154}
5155impl ::treesitter_types::Spanned for Import<'_> {
5156 fn span(&self) -> ::treesitter_types::Span {
5157 self.span
5158 }
5159}
5160#[derive(Debug, Clone, PartialEq, Eq)]
5161pub struct ImportList<'tree> {
5162 pub span: ::treesitter_types::Span,
5163 pub name: ::std::vec::Vec<ImportName<'tree>>,
5164}
5165impl<'tree> ::treesitter_types::FromNode<'tree> for ImportList<'tree> {
5166 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5167 fn from_node(
5168 node: ::treesitter_types::tree_sitter::Node<'tree>,
5169 src: &'tree [u8],
5170 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5171 debug_assert_eq!(node.kind(), "import_list");
5172 Ok(Self {
5173 span: ::treesitter_types::Span::from(node),
5174 name: {
5175 let mut cursor = node.walk();
5176 let mut items = ::std::vec::Vec::new();
5177 for child in node.children_by_field_name("name", &mut cursor) {
5178 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5179 <ImportName as ::treesitter_types::FromNode>::from_node(child, src)
5180 })?);
5181 }
5182 items
5183 },
5184 })
5185 }
5186}
5187impl ::treesitter_types::Spanned for ImportList<'_> {
5188 fn span(&self) -> ::treesitter_types::Span {
5189 self.span
5190 }
5191}
5192#[derive(Debug, Clone, PartialEq, Eq)]
5193pub struct ImportName<'tree> {
5194 pub span: ::treesitter_types::Span,
5195 pub children: ::core::option::Option<Children<'tree>>,
5196 pub namespace: ::core::option::Option<Namespace<'tree>>,
5197 pub operator: ::core::option::Option<PrefixId<'tree>>,
5198 pub r#type: ::core::option::Option<ImportNameType<'tree>>,
5199 pub variable: ::core::option::Option<ImportNameVariable<'tree>>,
5200}
5201impl<'tree> ::treesitter_types::FromNode<'tree> for ImportName<'tree> {
5202 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5203 fn from_node(
5204 node: ::treesitter_types::tree_sitter::Node<'tree>,
5205 src: &'tree [u8],
5206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5207 debug_assert_eq!(node.kind(), "import_name");
5208 Ok(Self {
5209 span: ::treesitter_types::Span::from(node),
5210 children: match node.child_by_field_name("children") {
5211 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5212 <Children as ::treesitter_types::FromNode>::from_node(child, src)
5213 })?),
5214 None => None,
5215 },
5216 namespace: match node.child_by_field_name("namespace") {
5217 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5218 <Namespace as ::treesitter_types::FromNode>::from_node(child, src)
5219 })?),
5220 None => None,
5221 },
5222 operator: match node.child_by_field_name("operator") {
5223 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5224 <PrefixId as ::treesitter_types::FromNode>::from_node(child, src)
5225 })?),
5226 None => None,
5227 },
5228 r#type: match node.child_by_field_name("type") {
5229 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5230 <ImportNameType as ::treesitter_types::FromNode>::from_node(child, src)
5231 })?),
5232 None => None,
5233 },
5234 variable: match node.child_by_field_name("variable") {
5235 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5236 <ImportNameVariable as ::treesitter_types::FromNode>::from_node(child, src)
5237 })?),
5238 None => None,
5239 },
5240 })
5241 }
5242}
5243impl ::treesitter_types::Spanned for ImportName<'_> {
5244 fn span(&self) -> ::treesitter_types::Span {
5245 self.span
5246 }
5247}
5248#[derive(Debug, Clone, PartialEq, Eq)]
5249pub struct Imports<'tree> {
5250 pub span: ::treesitter_types::Span,
5251 pub import: ::std::vec::Vec<Import<'tree>>,
5252}
5253impl<'tree> ::treesitter_types::FromNode<'tree> for Imports<'tree> {
5254 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5255 fn from_node(
5256 node: ::treesitter_types::tree_sitter::Node<'tree>,
5257 src: &'tree [u8],
5258 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5259 debug_assert_eq!(node.kind(), "imports");
5260 Ok(Self {
5261 span: ::treesitter_types::Span::from(node),
5262 import: {
5263 let mut cursor = node.walk();
5264 let mut items = ::std::vec::Vec::new();
5265 for child in node.children_by_field_name("import", &mut cursor) {
5266 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5267 <Import as ::treesitter_types::FromNode>::from_node(child, src)
5268 })?);
5269 }
5270 items
5271 },
5272 })
5273 }
5274}
5275impl ::treesitter_types::Spanned for Imports<'_> {
5276 fn span(&self) -> ::treesitter_types::Span {
5277 self.span
5278 }
5279}
5280#[derive(Debug, Clone, PartialEq, Eq)]
5281pub struct Inferred<'tree> {
5282 pub span: ::treesitter_types::Span,
5283 pub children: InferredChildren<'tree>,
5284}
5285impl<'tree> ::treesitter_types::FromNode<'tree> for Inferred<'tree> {
5286 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5287 fn from_node(
5288 node: ::treesitter_types::tree_sitter::Node<'tree>,
5289 src: &'tree [u8],
5290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5291 debug_assert_eq!(node.kind(), "inferred");
5292 Ok(Self {
5293 span: ::treesitter_types::Span::from(node),
5294 children: {
5295 #[allow(clippy::suspicious_else_formatting)]
5296 let non_field_children = {
5297 let mut cursor = node.walk();
5298 let mut result = ::std::vec::Vec::new();
5299 if cursor.goto_first_child() {
5300 loop {
5301 if cursor.field_name().is_none()
5302 && cursor.node().is_named()
5303 && !cursor.node().is_extra()
5304 {
5305 result.push(cursor.node());
5306 }
5307 if !cursor.goto_next_sibling() {
5308 break;
5309 }
5310 }
5311 }
5312 result
5313 };
5314 let child = if let Some(&c) = non_field_children.first() {
5315 c
5316 } else {
5317 let mut fallback_cursor = node.walk();
5318 let mut fallback_child = None;
5319 if fallback_cursor.goto_first_child() {
5320 loop {
5321 if fallback_cursor.field_name().is_none()
5322 && !fallback_cursor.node().is_extra()
5323 {
5324 let candidate = fallback_cursor.node();
5325 #[allow(clippy::needless_question_mark)]
5326 if (|| -> ::core::result::Result<
5327 _,
5328 ::treesitter_types::ParseError,
5329 > {
5330 let child = candidate;
5331 Ok(
5332 ::treesitter_types::runtime::maybe_grow_stack(|| <InferredChildren as ::treesitter_types::FromNode>::from_node(
5333 child,
5334 src,
5335 ))?,
5336 )
5337 })()
5338 .is_ok()
5339 {
5340 fallback_child = Some(candidate);
5341 break;
5342 }
5343 }
5344 if !fallback_cursor.goto_next_sibling() {
5345 break;
5346 }
5347 }
5348 }
5349 if fallback_child.is_none() {
5350 let mut cursor2 = node.walk();
5351 if cursor2.goto_first_child() {
5352 loop {
5353 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5354 let candidate = cursor2.node();
5355 #[allow(clippy::needless_question_mark)]
5356 if (|| -> ::core::result::Result<
5357 _,
5358 ::treesitter_types::ParseError,
5359 > {
5360 let child = candidate;
5361 Ok(
5362 ::treesitter_types::runtime::maybe_grow_stack(|| <InferredChildren as ::treesitter_types::FromNode>::from_node(
5363 child,
5364 src,
5365 ))?,
5366 )
5367 })()
5368 .is_ok()
5369 {
5370 fallback_child = Some(candidate);
5371 break;
5372 }
5373 }
5374 if !cursor2.goto_next_sibling() {
5375 break;
5376 }
5377 }
5378 }
5379 }
5380 fallback_child.ok_or_else(|| {
5381 ::treesitter_types::ParseError::missing_field("children", node)
5382 })?
5383 };
5384 ::treesitter_types::runtime::maybe_grow_stack(|| {
5385 <InferredChildren as ::treesitter_types::FromNode>::from_node(child, src)
5386 })?
5387 },
5388 })
5389 }
5390}
5391impl ::treesitter_types::Spanned for Inferred<'_> {
5392 fn span(&self) -> ::treesitter_types::Span {
5393 self.span
5394 }
5395}
5396#[derive(Debug, Clone, PartialEq, Eq)]
5397pub struct Infix<'tree> {
5398 pub span: ::treesitter_types::Span,
5399 pub left_operand: InfixLeftOperand<'tree>,
5400 pub operator: ::std::vec::Vec<InfixOperator<'tree>>,
5401 pub right_operand: InfixRightOperand<'tree>,
5402}
5403impl<'tree> ::treesitter_types::FromNode<'tree> for Infix<'tree> {
5404 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5405 fn from_node(
5406 node: ::treesitter_types::tree_sitter::Node<'tree>,
5407 src: &'tree [u8],
5408 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5409 debug_assert_eq!(node.kind(), "infix");
5410 Ok(Self {
5411 span: ::treesitter_types::Span::from(node),
5412 left_operand: {
5413 let child = node.child_by_field_name("left_operand").ok_or_else(|| {
5414 ::treesitter_types::ParseError::missing_field("left_operand", node)
5415 })?;
5416 ::treesitter_types::runtime::maybe_grow_stack(|| {
5417 <InfixLeftOperand as ::treesitter_types::FromNode>::from_node(child, src)
5418 })?
5419 },
5420 operator: {
5421 let mut cursor = node.walk();
5422 let mut items = ::std::vec::Vec::new();
5423 for child in node.children_by_field_name("operator", &mut cursor) {
5424 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5425 <InfixOperator as ::treesitter_types::FromNode>::from_node(child, src)
5426 })?);
5427 }
5428 items
5429 },
5430 right_operand: {
5431 let child = node.child_by_field_name("right_operand").ok_or_else(|| {
5432 ::treesitter_types::ParseError::missing_field("right_operand", node)
5433 })?;
5434 ::treesitter_types::runtime::maybe_grow_stack(|| {
5435 <InfixRightOperand as ::treesitter_types::FromNode>::from_node(child, src)
5436 })?
5437 },
5438 })
5439 }
5440}
5441impl ::treesitter_types::Spanned for Infix<'_> {
5442 fn span(&self) -> ::treesitter_types::Span {
5443 self.span
5444 }
5445}
5446#[derive(Debug, Clone, PartialEq, Eq)]
5447pub struct InfixId<'tree> {
5448 pub span: ::treesitter_types::Span,
5449 pub children: InfixIdChildren<'tree>,
5450}
5451impl<'tree> ::treesitter_types::FromNode<'tree> for InfixId<'tree> {
5452 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5453 fn from_node(
5454 node: ::treesitter_types::tree_sitter::Node<'tree>,
5455 src: &'tree [u8],
5456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5457 debug_assert_eq!(node.kind(), "infix_id");
5458 Ok(Self {
5459 span: ::treesitter_types::Span::from(node),
5460 children: {
5461 #[allow(clippy::suspicious_else_formatting)]
5462 let non_field_children = {
5463 let mut cursor = node.walk();
5464 let mut result = ::std::vec::Vec::new();
5465 if cursor.goto_first_child() {
5466 loop {
5467 if cursor.field_name().is_none()
5468 && cursor.node().is_named()
5469 && !cursor.node().is_extra()
5470 {
5471 result.push(cursor.node());
5472 }
5473 if !cursor.goto_next_sibling() {
5474 break;
5475 }
5476 }
5477 }
5478 result
5479 };
5480 let child = if let Some(&c) = non_field_children.first() {
5481 c
5482 } else {
5483 let mut fallback_cursor = node.walk();
5484 let mut fallback_child = None;
5485 if fallback_cursor.goto_first_child() {
5486 loop {
5487 if fallback_cursor.field_name().is_none()
5488 && !fallback_cursor.node().is_extra()
5489 {
5490 let candidate = fallback_cursor.node();
5491 #[allow(clippy::needless_question_mark)]
5492 if (|| -> ::core::result::Result<
5493 _,
5494 ::treesitter_types::ParseError,
5495 > {
5496 let child = candidate;
5497 Ok(
5498 ::treesitter_types::runtime::maybe_grow_stack(|| <InfixIdChildren as ::treesitter_types::FromNode>::from_node(
5499 child,
5500 src,
5501 ))?,
5502 )
5503 })()
5504 .is_ok()
5505 {
5506 fallback_child = Some(candidate);
5507 break;
5508 }
5509 }
5510 if !fallback_cursor.goto_next_sibling() {
5511 break;
5512 }
5513 }
5514 }
5515 if fallback_child.is_none() {
5516 let mut cursor2 = node.walk();
5517 if cursor2.goto_first_child() {
5518 loop {
5519 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5520 let candidate = cursor2.node();
5521 #[allow(clippy::needless_question_mark)]
5522 if (|| -> ::core::result::Result<
5523 _,
5524 ::treesitter_types::ParseError,
5525 > {
5526 let child = candidate;
5527 Ok(
5528 ::treesitter_types::runtime::maybe_grow_stack(|| <InfixIdChildren as ::treesitter_types::FromNode>::from_node(
5529 child,
5530 src,
5531 ))?,
5532 )
5533 })()
5534 .is_ok()
5535 {
5536 fallback_child = Some(candidate);
5537 break;
5538 }
5539 }
5540 if !cursor2.goto_next_sibling() {
5541 break;
5542 }
5543 }
5544 }
5545 }
5546 fallback_child.ok_or_else(|| {
5547 ::treesitter_types::ParseError::missing_field("children", node)
5548 })?
5549 };
5550 ::treesitter_types::runtime::maybe_grow_stack(|| {
5551 <InfixIdChildren as ::treesitter_types::FromNode>::from_node(child, src)
5552 })?
5553 },
5554 })
5555 }
5556}
5557impl ::treesitter_types::Spanned for InfixId<'_> {
5558 fn span(&self) -> ::treesitter_types::Span {
5559 self.span
5560 }
5561}
5562#[derive(Debug, Clone, PartialEq, Eq)]
5563pub struct Instance<'tree> {
5564 pub span: ::treesitter_types::Span,
5565 pub context: ::core::option::Option<Context<'tree>>,
5566 pub declarations: ::core::option::Option<InstanceDeclarations<'tree>>,
5567 pub forall: ::core::option::Option<InstanceForall<'tree>>,
5568 pub name: ::core::option::Option<InstanceName<'tree>>,
5569 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
5570 pub children: ::core::option::Option<InstanceChildren<'tree>>,
5571}
5572impl<'tree> ::treesitter_types::FromNode<'tree> for Instance<'tree> {
5573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5574 fn from_node(
5575 node: ::treesitter_types::tree_sitter::Node<'tree>,
5576 src: &'tree [u8],
5577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5578 debug_assert_eq!(node.kind(), "instance");
5579 Ok(Self {
5580 span: ::treesitter_types::Span::from(node),
5581 context: match node.child_by_field_name("context") {
5582 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5583 <Context as ::treesitter_types::FromNode>::from_node(child, src)
5584 })?),
5585 None => None,
5586 },
5587 declarations: match node.child_by_field_name("declarations") {
5588 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5589 <InstanceDeclarations as ::treesitter_types::FromNode>::from_node(child, src)
5590 })?),
5591 None => None,
5592 },
5593 forall: match node.child_by_field_name("forall") {
5594 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5595 <InstanceForall as ::treesitter_types::FromNode>::from_node(child, src)
5596 })?),
5597 None => None,
5598 },
5599 name: match node.child_by_field_name("name") {
5600 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5601 <InstanceName as ::treesitter_types::FromNode>::from_node(child, src)
5602 })?),
5603 None => None,
5604 },
5605 patterns: match node.child_by_field_name("patterns") {
5606 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5607 <TypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
5608 })?),
5609 None => None,
5610 },
5611 children: {
5612 #[allow(clippy::suspicious_else_formatting)]
5613 let non_field_children = {
5614 let mut cursor = node.walk();
5615 let mut result = ::std::vec::Vec::new();
5616 if cursor.goto_first_child() {
5617 loop {
5618 if cursor.field_name().is_none()
5619 && cursor.node().is_named()
5620 && !cursor.node().is_extra()
5621 {
5622 result.push(cursor.node());
5623 }
5624 if !cursor.goto_next_sibling() {
5625 break;
5626 }
5627 }
5628 }
5629 result
5630 };
5631 match non_field_children.first() {
5632 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5633 <InstanceChildren as ::treesitter_types::FromNode>::from_node(child, src)
5634 })?),
5635 None => None,
5636 }
5637 },
5638 })
5639 }
5640}
5641impl ::treesitter_types::Spanned for Instance<'_> {
5642 fn span(&self) -> ::treesitter_types::Span {
5643 self.span
5644 }
5645}
5646#[derive(Debug, Clone, PartialEq, Eq)]
5647pub struct InstanceDeclarations<'tree> {
5648 pub span: ::treesitter_types::Span,
5649 pub declaration: ::std::vec::Vec<InstanceDecl<'tree>>,
5650}
5651impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceDeclarations<'tree> {
5652 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5653 fn from_node(
5654 node: ::treesitter_types::tree_sitter::Node<'tree>,
5655 src: &'tree [u8],
5656 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5657 debug_assert_eq!(node.kind(), "instance_declarations");
5658 Ok(Self {
5659 span: ::treesitter_types::Span::from(node),
5660 declaration: {
5661 let mut cursor = node.walk();
5662 let mut items = ::std::vec::Vec::new();
5663 for child in node.children_by_field_name("declaration", &mut cursor) {
5664 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
5665 <InstanceDecl as ::treesitter_types::FromNode>::from_node(child, src)
5666 })?);
5667 }
5668 items
5669 },
5670 })
5671 }
5672}
5673impl ::treesitter_types::Spanned for InstanceDeclarations<'_> {
5674 fn span(&self) -> ::treesitter_types::Span {
5675 self.span
5676 }
5677}
5678#[derive(Debug, Clone, PartialEq, Eq)]
5679pub struct Integer<'tree> {
5680 pub span: ::treesitter_types::Span,
5681 text: &'tree str,
5682}
5683impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
5684 fn from_node(
5685 node: ::treesitter_types::tree_sitter::Node<'tree>,
5686 src: &'tree [u8],
5687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5688 debug_assert_eq!(node.kind(), "integer");
5689 Ok(Self {
5690 span: ::treesitter_types::Span::from(node),
5691 text: node.utf8_text(src)?,
5692 })
5693 }
5694}
5695impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
5696 fn text(&self) -> &'tree str {
5697 self.text
5698 }
5699}
5700impl ::treesitter_types::Spanned for Integer<'_> {
5701 fn span(&self) -> ::treesitter_types::Span {
5702 self.span
5703 }
5704}
5705#[derive(Debug, Clone, PartialEq, Eq)]
5706pub struct Invisible<'tree> {
5707 pub span: ::treesitter_types::Span,
5708 pub bind: TypeParam<'tree>,
5709}
5710impl<'tree> ::treesitter_types::FromNode<'tree> for Invisible<'tree> {
5711 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5712 fn from_node(
5713 node: ::treesitter_types::tree_sitter::Node<'tree>,
5714 src: &'tree [u8],
5715 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5716 debug_assert_eq!(node.kind(), "invisible");
5717 Ok(Self {
5718 span: ::treesitter_types::Span::from(node),
5719 bind: {
5720 let child = node
5721 .child_by_field_name("bind")
5722 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bind", node))?;
5723 ::treesitter_types::runtime::maybe_grow_stack(|| {
5724 <TypeParam as ::treesitter_types::FromNode>::from_node(child, src)
5725 })?
5726 },
5727 })
5728 }
5729}
5730impl ::treesitter_types::Spanned for Invisible<'_> {
5731 fn span(&self) -> ::treesitter_types::Span {
5732 self.span
5733 }
5734}
5735#[derive(Debug, Clone, PartialEq, Eq)]
5736pub struct Irrefutable<'tree> {
5737 pub span: ::treesitter_types::Span,
5738 pub pattern: Pattern<'tree>,
5739}
5740impl<'tree> ::treesitter_types::FromNode<'tree> for Irrefutable<'tree> {
5741 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5742 fn from_node(
5743 node: ::treesitter_types::tree_sitter::Node<'tree>,
5744 src: &'tree [u8],
5745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5746 debug_assert_eq!(node.kind(), "irrefutable");
5747 Ok(Self {
5748 span: ::treesitter_types::Span::from(node),
5749 pattern: {
5750 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5751 ::treesitter_types::ParseError::missing_field("pattern", node)
5752 })?;
5753 ::treesitter_types::runtime::maybe_grow_stack(|| {
5754 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
5755 })?
5756 },
5757 })
5758 }
5759}
5760impl ::treesitter_types::Spanned for Irrefutable<'_> {
5761 fn span(&self) -> ::treesitter_types::Span {
5762 self.span
5763 }
5764}
5765#[derive(Debug, Clone, PartialEq, Eq)]
5766pub struct KindApplication<'tree> {
5767 pub span: ::treesitter_types::Span,
5768 pub r#type: Type<'tree>,
5769}
5770impl<'tree> ::treesitter_types::FromNode<'tree> for KindApplication<'tree> {
5771 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5772 fn from_node(
5773 node: ::treesitter_types::tree_sitter::Node<'tree>,
5774 src: &'tree [u8],
5775 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5776 debug_assert_eq!(node.kind(), "kind_application");
5777 Ok(Self {
5778 span: ::treesitter_types::Span::from(node),
5779 r#type: {
5780 let child = node
5781 .child_by_field_name("type")
5782 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5783 ::treesitter_types::runtime::maybe_grow_stack(|| {
5784 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5785 })?
5786 },
5787 })
5788 }
5789}
5790impl ::treesitter_types::Spanned for KindApplication<'_> {
5791 fn span(&self) -> ::treesitter_types::Span {
5792 self.span
5793 }
5794}
5795#[derive(Debug, Clone, PartialEq, Eq)]
5796pub struct KindSignature<'tree> {
5797 pub span: ::treesitter_types::Span,
5798 pub kind: QuantifiedType<'tree>,
5799 pub name: ::core::option::Option<KindSignatureName<'tree>>,
5800 pub patterns: ::core::option::Option<TypeParams<'tree>>,
5801 pub children: ::core::option::Option<KindSignatureChildren<'tree>>,
5802}
5803impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignature<'tree> {
5804 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5805 fn from_node(
5806 node: ::treesitter_types::tree_sitter::Node<'tree>,
5807 src: &'tree [u8],
5808 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5809 debug_assert_eq!(node.kind(), "kind_signature");
5810 Ok(Self {
5811 span: ::treesitter_types::Span::from(node),
5812 kind: {
5813 let child = node
5814 .child_by_field_name("kind")
5815 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
5816 ::treesitter_types::runtime::maybe_grow_stack(|| {
5817 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
5818 })?
5819 },
5820 name: match node.child_by_field_name("name") {
5821 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5822 <KindSignatureName as ::treesitter_types::FromNode>::from_node(child, src)
5823 })?),
5824 None => None,
5825 },
5826 patterns: match node.child_by_field_name("patterns") {
5827 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5828 <TypeParams as ::treesitter_types::FromNode>::from_node(child, src)
5829 })?),
5830 None => None,
5831 },
5832 children: {
5833 #[allow(clippy::suspicious_else_formatting)]
5834 let non_field_children = {
5835 let mut cursor = node.walk();
5836 let mut result = ::std::vec::Vec::new();
5837 if cursor.goto_first_child() {
5838 loop {
5839 if cursor.field_name().is_none()
5840 && cursor.node().is_named()
5841 && !cursor.node().is_extra()
5842 {
5843 result.push(cursor.node());
5844 }
5845 if !cursor.goto_next_sibling() {
5846 break;
5847 }
5848 }
5849 }
5850 result
5851 };
5852 match non_field_children.first() {
5853 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5854 <KindSignatureChildren as ::treesitter_types::FromNode>::from_node(
5855 child, src,
5856 )
5857 })?),
5858 None => None,
5859 }
5860 },
5861 })
5862 }
5863}
5864impl ::treesitter_types::Spanned for KindSignature<'_> {
5865 fn span(&self) -> ::treesitter_types::Span {
5866 self.span
5867 }
5868}
5869#[derive(Debug, Clone, PartialEq, Eq)]
5870pub struct Lambda<'tree> {
5871 pub span: ::treesitter_types::Span,
5872 pub expression: LambdaExpression<'tree>,
5873 pub patterns: Patterns<'tree>,
5874}
5875impl<'tree> ::treesitter_types::FromNode<'tree> for Lambda<'tree> {
5876 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5877 fn from_node(
5878 node: ::treesitter_types::tree_sitter::Node<'tree>,
5879 src: &'tree [u8],
5880 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5881 debug_assert_eq!(node.kind(), "lambda");
5882 Ok(Self {
5883 span: ::treesitter_types::Span::from(node),
5884 expression: {
5885 let child = node.child_by_field_name("expression").ok_or_else(|| {
5886 ::treesitter_types::ParseError::missing_field("expression", node)
5887 })?;
5888 ::treesitter_types::runtime::maybe_grow_stack(|| {
5889 <LambdaExpression as ::treesitter_types::FromNode>::from_node(child, src)
5890 })?
5891 },
5892 patterns: {
5893 let child = node.child_by_field_name("patterns").ok_or_else(|| {
5894 ::treesitter_types::ParseError::missing_field("patterns", node)
5895 })?;
5896 ::treesitter_types::runtime::maybe_grow_stack(|| {
5897 <Patterns as ::treesitter_types::FromNode>::from_node(child, src)
5898 })?
5899 },
5900 })
5901 }
5902}
5903impl ::treesitter_types::Spanned for Lambda<'_> {
5904 fn span(&self) -> ::treesitter_types::Span {
5905 self.span
5906 }
5907}
5908#[derive(Debug, Clone, PartialEq, Eq)]
5909pub struct LambdaCase<'tree> {
5910 pub span: ::treesitter_types::Span,
5911 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
5912}
5913impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCase<'tree> {
5914 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5915 fn from_node(
5916 node: ::treesitter_types::tree_sitter::Node<'tree>,
5917 src: &'tree [u8],
5918 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5919 debug_assert_eq!(node.kind(), "lambda_case");
5920 Ok(Self {
5921 span: ::treesitter_types::Span::from(node),
5922 alternatives: match node.child_by_field_name("alternatives") {
5923 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5924 <Alternatives as ::treesitter_types::FromNode>::from_node(child, src)
5925 })?),
5926 None => None,
5927 },
5928 })
5929 }
5930}
5931impl ::treesitter_types::Spanned for LambdaCase<'_> {
5932 fn span(&self) -> ::treesitter_types::Span {
5933 self.span
5934 }
5935}
5936#[derive(Debug, Clone, PartialEq, Eq)]
5937pub struct LambdaCases<'tree> {
5938 pub span: ::treesitter_types::Span,
5939 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
5940}
5941impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCases<'tree> {
5942 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5943 fn from_node(
5944 node: ::treesitter_types::tree_sitter::Node<'tree>,
5945 src: &'tree [u8],
5946 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5947 debug_assert_eq!(node.kind(), "lambda_cases");
5948 Ok(Self {
5949 span: ::treesitter_types::Span::from(node),
5950 alternatives: match node.child_by_field_name("alternatives") {
5951 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
5952 <Alternatives as ::treesitter_types::FromNode>::from_node(child, src)
5953 })?),
5954 None => None,
5955 },
5956 })
5957 }
5958}
5959impl ::treesitter_types::Spanned for LambdaCases<'_> {
5960 fn span(&self) -> ::treesitter_types::Span {
5961 self.span
5962 }
5963}
5964#[derive(Debug, Clone, PartialEq, Eq)]
5965pub struct LazyField<'tree> {
5966 pub span: ::treesitter_types::Span,
5967 pub r#type: Type<'tree>,
5968}
5969impl<'tree> ::treesitter_types::FromNode<'tree> for LazyField<'tree> {
5970 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5971 fn from_node(
5972 node: ::treesitter_types::tree_sitter::Node<'tree>,
5973 src: &'tree [u8],
5974 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5975 debug_assert_eq!(node.kind(), "lazy_field");
5976 Ok(Self {
5977 span: ::treesitter_types::Span::from(node),
5978 r#type: {
5979 let child = node
5980 .child_by_field_name("type")
5981 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5982 ::treesitter_types::runtime::maybe_grow_stack(|| {
5983 <Type as ::treesitter_types::FromNode>::from_node(child, src)
5984 })?
5985 },
5986 })
5987 }
5988}
5989impl ::treesitter_types::Spanned for LazyField<'_> {
5990 fn span(&self) -> ::treesitter_types::Span {
5991 self.span
5992 }
5993}
5994#[derive(Debug, Clone, PartialEq, Eq)]
5995pub struct LeftSection<'tree> {
5996 pub span: ::treesitter_types::Span,
5997 pub left_operand: Expression<'tree>,
5998 pub operator: LeftSectionOperator<'tree>,
5999}
6000impl<'tree> ::treesitter_types::FromNode<'tree> for LeftSection<'tree> {
6001 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6002 fn from_node(
6003 node: ::treesitter_types::tree_sitter::Node<'tree>,
6004 src: &'tree [u8],
6005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6006 debug_assert_eq!(node.kind(), "left_section");
6007 Ok(Self {
6008 span: ::treesitter_types::Span::from(node),
6009 left_operand: {
6010 let child = node.child_by_field_name("left_operand").ok_or_else(|| {
6011 ::treesitter_types::ParseError::missing_field("left_operand", node)
6012 })?;
6013 ::treesitter_types::runtime::maybe_grow_stack(|| {
6014 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6015 })?
6016 },
6017 operator: {
6018 let child = node.child_by_field_name("operator").ok_or_else(|| {
6019 ::treesitter_types::ParseError::missing_field("operator", node)
6020 })?;
6021 ::treesitter_types::runtime::maybe_grow_stack(|| {
6022 <LeftSectionOperator as ::treesitter_types::FromNode>::from_node(child, src)
6023 })?
6024 },
6025 })
6026 }
6027}
6028impl ::treesitter_types::Spanned for LeftSection<'_> {
6029 fn span(&self) -> ::treesitter_types::Span {
6030 self.span
6031 }
6032}
6033#[derive(Debug, Clone, PartialEq, Eq)]
6034pub struct Let<'tree> {
6035 pub span: ::treesitter_types::Span,
6036 pub binds: ::core::option::Option<LocalBinds<'tree>>,
6037}
6038impl<'tree> ::treesitter_types::FromNode<'tree> for Let<'tree> {
6039 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6040 fn from_node(
6041 node: ::treesitter_types::tree_sitter::Node<'tree>,
6042 src: &'tree [u8],
6043 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6044 debug_assert_eq!(node.kind(), "let");
6045 Ok(Self {
6046 span: ::treesitter_types::Span::from(node),
6047 binds: match node.child_by_field_name("binds") {
6048 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6049 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
6050 })?),
6051 None => None,
6052 },
6053 })
6054 }
6055}
6056impl ::treesitter_types::Spanned for Let<'_> {
6057 fn span(&self) -> ::treesitter_types::Span {
6058 self.span
6059 }
6060}
6061#[derive(Debug, Clone, PartialEq, Eq)]
6062pub struct LetIn<'tree> {
6063 pub span: ::treesitter_types::Span,
6064 pub binds: ::core::option::Option<LocalBinds<'tree>>,
6065 pub expression: LetInExpression<'tree>,
6066}
6067impl<'tree> ::treesitter_types::FromNode<'tree> for LetIn<'tree> {
6068 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6069 fn from_node(
6070 node: ::treesitter_types::tree_sitter::Node<'tree>,
6071 src: &'tree [u8],
6072 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6073 debug_assert_eq!(node.kind(), "let_in");
6074 Ok(Self {
6075 span: ::treesitter_types::Span::from(node),
6076 binds: match node.child_by_field_name("binds") {
6077 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6078 <LocalBinds as ::treesitter_types::FromNode>::from_node(child, src)
6079 })?),
6080 None => None,
6081 },
6082 expression: {
6083 let child = node.child_by_field_name("expression").ok_or_else(|| {
6084 ::treesitter_types::ParseError::missing_field("expression", node)
6085 })?;
6086 ::treesitter_types::runtime::maybe_grow_stack(|| {
6087 <LetInExpression as ::treesitter_types::FromNode>::from_node(child, src)
6088 })?
6089 },
6090 })
6091 }
6092}
6093impl ::treesitter_types::Spanned for LetIn<'_> {
6094 fn span(&self) -> ::treesitter_types::Span {
6095 self.span
6096 }
6097}
6098#[derive(Debug, Clone, PartialEq, Eq)]
6099pub struct LinearFunction<'tree> {
6100 pub span: ::treesitter_types::Span,
6101 pub arrow: LinearFunctionArrow,
6102 pub multiplicity: ::core::option::Option<Modifier<'tree>>,
6103 pub parameter: LinearFunctionParameter<'tree>,
6104 pub result: QuantifiedType<'tree>,
6105}
6106impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunction<'tree> {
6107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6108 fn from_node(
6109 node: ::treesitter_types::tree_sitter::Node<'tree>,
6110 src: &'tree [u8],
6111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6112 debug_assert_eq!(node.kind(), "linear_function");
6113 Ok(Self {
6114 span: ::treesitter_types::Span::from(node),
6115 arrow: {
6116 let child = node
6117 .child_by_field_name("arrow")
6118 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
6119 ::treesitter_types::runtime::maybe_grow_stack(|| {
6120 <LinearFunctionArrow as ::treesitter_types::FromNode>::from_node(child, src)
6121 })?
6122 },
6123 multiplicity: match node.child_by_field_name("multiplicity") {
6124 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6125 <Modifier as ::treesitter_types::FromNode>::from_node(child, src)
6126 })?),
6127 None => None,
6128 },
6129 parameter: {
6130 let child = node.child_by_field_name("parameter").ok_or_else(|| {
6131 ::treesitter_types::ParseError::missing_field("parameter", node)
6132 })?;
6133 ::treesitter_types::runtime::maybe_grow_stack(|| {
6134 <LinearFunctionParameter as ::treesitter_types::FromNode>::from_node(child, src)
6135 })?
6136 },
6137 result: {
6138 let child = node
6139 .child_by_field_name("result")
6140 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
6141 ::treesitter_types::runtime::maybe_grow_stack(|| {
6142 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
6143 })?
6144 },
6145 })
6146 }
6147}
6148impl ::treesitter_types::Spanned for LinearFunction<'_> {
6149 fn span(&self) -> ::treesitter_types::Span {
6150 self.span
6151 }
6152}
6153#[derive(Debug, Clone, PartialEq, Eq)]
6154pub struct List<'tree> {
6155 pub span: ::treesitter_types::Span,
6156 pub element: ::std::vec::Vec<ListElement<'tree>>,
6157}
6158impl<'tree> ::treesitter_types::FromNode<'tree> for List<'tree> {
6159 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6160 fn from_node(
6161 node: ::treesitter_types::tree_sitter::Node<'tree>,
6162 src: &'tree [u8],
6163 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6164 debug_assert_eq!(node.kind(), "list");
6165 Ok(Self {
6166 span: ::treesitter_types::Span::from(node),
6167 element: {
6168 let mut cursor = node.walk();
6169 let mut items = ::std::vec::Vec::new();
6170 for child in node.children_by_field_name("element", &mut cursor) {
6171 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6172 <ListElement as ::treesitter_types::FromNode>::from_node(child, src)
6173 })?);
6174 }
6175 items
6176 },
6177 })
6178 }
6179}
6180impl ::treesitter_types::Spanned for List<'_> {
6181 fn span(&self) -> ::treesitter_types::Span {
6182 self.span
6183 }
6184}
6185#[derive(Debug, Clone, PartialEq, Eq)]
6186pub struct ListComprehension<'tree> {
6187 pub span: ::treesitter_types::Span,
6188 pub expression: ListComprehensionExpression<'tree>,
6189 pub qualifiers: ::std::vec::Vec<Qualifiers<'tree>>,
6190}
6191impl<'tree> ::treesitter_types::FromNode<'tree> for ListComprehension<'tree> {
6192 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6193 fn from_node(
6194 node: ::treesitter_types::tree_sitter::Node<'tree>,
6195 src: &'tree [u8],
6196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6197 debug_assert_eq!(node.kind(), "list_comprehension");
6198 Ok(Self {
6199 span: ::treesitter_types::Span::from(node),
6200 expression: {
6201 let child = node.child_by_field_name("expression").ok_or_else(|| {
6202 ::treesitter_types::ParseError::missing_field("expression", node)
6203 })?;
6204 ::treesitter_types::runtime::maybe_grow_stack(|| {
6205 <ListComprehensionExpression as ::treesitter_types::FromNode>::from_node(
6206 child, src,
6207 )
6208 })?
6209 },
6210 qualifiers: {
6211 let mut cursor = node.walk();
6212 let mut items = ::std::vec::Vec::new();
6213 for child in node.children_by_field_name("qualifiers", &mut cursor) {
6214 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6215 <Qualifiers as ::treesitter_types::FromNode>::from_node(child, src)
6216 })?);
6217 }
6218 items
6219 },
6220 })
6221 }
6222}
6223impl ::treesitter_types::Spanned for ListComprehension<'_> {
6224 fn span(&self) -> ::treesitter_types::Span {
6225 self.span
6226 }
6227}
6228#[derive(Debug, Clone, PartialEq, Eq)]
6229pub struct Literal<'tree> {
6230 pub span: ::treesitter_types::Span,
6231 pub children: LiteralChildren<'tree>,
6232}
6233impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
6234 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6235 fn from_node(
6236 node: ::treesitter_types::tree_sitter::Node<'tree>,
6237 src: &'tree [u8],
6238 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6239 debug_assert_eq!(node.kind(), "literal");
6240 Ok(Self {
6241 span: ::treesitter_types::Span::from(node),
6242 children: {
6243 #[allow(clippy::suspicious_else_formatting)]
6244 let non_field_children = {
6245 let mut cursor = node.walk();
6246 let mut result = ::std::vec::Vec::new();
6247 if cursor.goto_first_child() {
6248 loop {
6249 if cursor.field_name().is_none()
6250 && cursor.node().is_named()
6251 && !cursor.node().is_extra()
6252 {
6253 result.push(cursor.node());
6254 }
6255 if !cursor.goto_next_sibling() {
6256 break;
6257 }
6258 }
6259 }
6260 result
6261 };
6262 let child = if let Some(&c) = non_field_children.first() {
6263 c
6264 } else {
6265 let mut fallback_cursor = node.walk();
6266 let mut fallback_child = None;
6267 if fallback_cursor.goto_first_child() {
6268 loop {
6269 if fallback_cursor.field_name().is_none()
6270 && !fallback_cursor.node().is_extra()
6271 {
6272 let candidate = fallback_cursor.node();
6273 #[allow(clippy::needless_question_mark)]
6274 if (|| -> ::core::result::Result<
6275 _,
6276 ::treesitter_types::ParseError,
6277 > {
6278 let child = candidate;
6279 Ok(
6280 ::treesitter_types::runtime::maybe_grow_stack(|| <LiteralChildren as ::treesitter_types::FromNode>::from_node(
6281 child,
6282 src,
6283 ))?,
6284 )
6285 })()
6286 .is_ok()
6287 {
6288 fallback_child = Some(candidate);
6289 break;
6290 }
6291 }
6292 if !fallback_cursor.goto_next_sibling() {
6293 break;
6294 }
6295 }
6296 }
6297 if fallback_child.is_none() {
6298 let mut cursor2 = node.walk();
6299 if cursor2.goto_first_child() {
6300 loop {
6301 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6302 let candidate = cursor2.node();
6303 #[allow(clippy::needless_question_mark)]
6304 if (|| -> ::core::result::Result<
6305 _,
6306 ::treesitter_types::ParseError,
6307 > {
6308 let child = candidate;
6309 Ok(
6310 ::treesitter_types::runtime::maybe_grow_stack(|| <LiteralChildren as ::treesitter_types::FromNode>::from_node(
6311 child,
6312 src,
6313 ))?,
6314 )
6315 })()
6316 .is_ok()
6317 {
6318 fallback_child = Some(candidate);
6319 break;
6320 }
6321 }
6322 if !cursor2.goto_next_sibling() {
6323 break;
6324 }
6325 }
6326 }
6327 }
6328 fallback_child.ok_or_else(|| {
6329 ::treesitter_types::ParseError::missing_field("children", node)
6330 })?
6331 };
6332 ::treesitter_types::runtime::maybe_grow_stack(|| {
6333 <LiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)
6334 })?
6335 },
6336 })
6337 }
6338}
6339impl ::treesitter_types::Spanned for Literal<'_> {
6340 fn span(&self) -> ::treesitter_types::Span {
6341 self.span
6342 }
6343}
6344#[derive(Debug, Clone, PartialEq, Eq)]
6345pub struct LocalBinds<'tree> {
6346 pub span: ::treesitter_types::Span,
6347 pub decl: ::std::vec::Vec<LocalBindsDecl<'tree>>,
6348}
6349impl<'tree> ::treesitter_types::FromNode<'tree> for LocalBinds<'tree> {
6350 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6351 fn from_node(
6352 node: ::treesitter_types::tree_sitter::Node<'tree>,
6353 src: &'tree [u8],
6354 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6355 debug_assert_eq!(node.kind(), "local_binds");
6356 Ok(Self {
6357 span: ::treesitter_types::Span::from(node),
6358 decl: {
6359 let mut cursor = node.walk();
6360 let mut items = ::std::vec::Vec::new();
6361 for child in node.children_by_field_name("decl", &mut cursor) {
6362 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6363 <LocalBindsDecl as ::treesitter_types::FromNode>::from_node(child, src)
6364 })?);
6365 }
6366 items
6367 },
6368 })
6369 }
6370}
6371impl ::treesitter_types::Spanned for LocalBinds<'_> {
6372 fn span(&self) -> ::treesitter_types::Span {
6373 self.span
6374 }
6375}
6376#[derive(Debug, Clone, PartialEq, Eq)]
6377pub struct Match<'tree> {
6378 pub span: ::treesitter_types::Span,
6379 pub expression: MatchExpression<'tree>,
6380 pub guards: ::core::option::Option<Guards<'tree>>,
6381}
6382impl<'tree> ::treesitter_types::FromNode<'tree> for Match<'tree> {
6383 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6384 fn from_node(
6385 node: ::treesitter_types::tree_sitter::Node<'tree>,
6386 src: &'tree [u8],
6387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6388 debug_assert_eq!(node.kind(), "match");
6389 Ok(Self {
6390 span: ::treesitter_types::Span::from(node),
6391 expression: {
6392 let child = node.child_by_field_name("expression").ok_or_else(|| {
6393 ::treesitter_types::ParseError::missing_field("expression", node)
6394 })?;
6395 ::treesitter_types::runtime::maybe_grow_stack(|| {
6396 <MatchExpression as ::treesitter_types::FromNode>::from_node(child, src)
6397 })?
6398 },
6399 guards: match node.child_by_field_name("guards") {
6400 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6401 <Guards as ::treesitter_types::FromNode>::from_node(child, src)
6402 })?),
6403 None => None,
6404 },
6405 })
6406 }
6407}
6408impl ::treesitter_types::Spanned for Match<'_> {
6409 fn span(&self) -> ::treesitter_types::Span {
6410 self.span
6411 }
6412}
6413#[derive(Debug, Clone, PartialEq, Eq)]
6414pub struct Modifier<'tree> {
6415 pub span: ::treesitter_types::Span,
6416 pub children: Type<'tree>,
6417}
6418impl<'tree> ::treesitter_types::FromNode<'tree> for Modifier<'tree> {
6419 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6420 fn from_node(
6421 node: ::treesitter_types::tree_sitter::Node<'tree>,
6422 src: &'tree [u8],
6423 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6424 debug_assert_eq!(node.kind(), "modifier");
6425 Ok(Self {
6426 span: ::treesitter_types::Span::from(node),
6427 children: {
6428 #[allow(clippy::suspicious_else_formatting)]
6429 let non_field_children = {
6430 let mut cursor = node.walk();
6431 let mut result = ::std::vec::Vec::new();
6432 if cursor.goto_first_child() {
6433 loop {
6434 if cursor.field_name().is_none()
6435 && cursor.node().is_named()
6436 && !cursor.node().is_extra()
6437 {
6438 result.push(cursor.node());
6439 }
6440 if !cursor.goto_next_sibling() {
6441 break;
6442 }
6443 }
6444 }
6445 result
6446 };
6447 let child = if let Some(&c) = non_field_children.first() {
6448 c
6449 } else {
6450 let mut fallback_cursor = node.walk();
6451 let mut fallback_child = None;
6452 if fallback_cursor.goto_first_child() {
6453 loop {
6454 if fallback_cursor.field_name().is_none()
6455 && !fallback_cursor.node().is_extra()
6456 {
6457 let candidate = fallback_cursor.node();
6458 #[allow(clippy::needless_question_mark)]
6459 if (|| -> ::core::result::Result<
6460 _,
6461 ::treesitter_types::ParseError,
6462 > {
6463 let child = candidate;
6464 Ok(
6465 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
6466 child,
6467 src,
6468 ))?,
6469 )
6470 })()
6471 .is_ok()
6472 {
6473 fallback_child = Some(candidate);
6474 break;
6475 }
6476 }
6477 if !fallback_cursor.goto_next_sibling() {
6478 break;
6479 }
6480 }
6481 }
6482 if fallback_child.is_none() {
6483 let mut cursor2 = node.walk();
6484 if cursor2.goto_first_child() {
6485 loop {
6486 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6487 let candidate = cursor2.node();
6488 #[allow(clippy::needless_question_mark)]
6489 if (|| -> ::core::result::Result<
6490 _,
6491 ::treesitter_types::ParseError,
6492 > {
6493 let child = candidate;
6494 Ok(
6495 ::treesitter_types::runtime::maybe_grow_stack(|| <Type as ::treesitter_types::FromNode>::from_node(
6496 child,
6497 src,
6498 ))?,
6499 )
6500 })()
6501 .is_ok()
6502 {
6503 fallback_child = Some(candidate);
6504 break;
6505 }
6506 }
6507 if !cursor2.goto_next_sibling() {
6508 break;
6509 }
6510 }
6511 }
6512 }
6513 fallback_child.ok_or_else(|| {
6514 ::treesitter_types::ParseError::missing_field("children", node)
6515 })?
6516 };
6517 ::treesitter_types::runtime::maybe_grow_stack(|| {
6518 <Type as ::treesitter_types::FromNode>::from_node(child, src)
6519 })?
6520 },
6521 })
6522 }
6523}
6524impl ::treesitter_types::Spanned for Modifier<'_> {
6525 fn span(&self) -> ::treesitter_types::Span {
6526 self.span
6527 }
6528}
6529#[derive(Debug, Clone, PartialEq, Eq)]
6530pub struct Module<'tree> {
6531 pub span: ::treesitter_types::Span,
6532 pub children: ::std::vec::Vec<ModuleId<'tree>>,
6533}
6534impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
6535 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6536 fn from_node(
6537 node: ::treesitter_types::tree_sitter::Node<'tree>,
6538 src: &'tree [u8],
6539 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6540 debug_assert_eq!(node.kind(), "module");
6541 Ok(Self {
6542 span: ::treesitter_types::Span::from(node),
6543 children: {
6544 #[allow(clippy::suspicious_else_formatting)]
6545 let non_field_children = {
6546 let mut cursor = node.walk();
6547 let mut result = ::std::vec::Vec::new();
6548 if cursor.goto_first_child() {
6549 loop {
6550 if cursor.field_name().is_none()
6551 && cursor.node().is_named()
6552 && !cursor.node().is_extra()
6553 {
6554 result.push(cursor.node());
6555 }
6556 if !cursor.goto_next_sibling() {
6557 break;
6558 }
6559 }
6560 }
6561 result
6562 };
6563 let mut items = ::std::vec::Vec::new();
6564 for child in non_field_children {
6565 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6566 <ModuleId as ::treesitter_types::FromNode>::from_node(child, src)
6567 })?);
6568 }
6569 items
6570 },
6571 })
6572 }
6573}
6574impl ::treesitter_types::Spanned for Module<'_> {
6575 fn span(&self) -> ::treesitter_types::Span {
6576 self.span
6577 }
6578}
6579#[derive(Debug, Clone, PartialEq, Eq)]
6580pub struct ModuleExport<'tree> {
6581 pub span: ::treesitter_types::Span,
6582 pub module: Module<'tree>,
6583}
6584impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleExport<'tree> {
6585 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6586 fn from_node(
6587 node: ::treesitter_types::tree_sitter::Node<'tree>,
6588 src: &'tree [u8],
6589 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6590 debug_assert_eq!(node.kind(), "module_export");
6591 Ok(Self {
6592 span: ::treesitter_types::Span::from(node),
6593 module: {
6594 let child = node
6595 .child_by_field_name("module")
6596 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
6597 ::treesitter_types::runtime::maybe_grow_stack(|| {
6598 <Module as ::treesitter_types::FromNode>::from_node(child, src)
6599 })?
6600 },
6601 })
6602 }
6603}
6604impl ::treesitter_types::Spanned for ModuleExport<'_> {
6605 fn span(&self) -> ::treesitter_types::Span {
6606 self.span
6607 }
6608}
6609#[derive(Debug, Clone, PartialEq, Eq)]
6610pub struct MultiWayIf<'tree> {
6611 pub span: ::treesitter_types::Span,
6612 pub r#match: ::std::vec::Vec<Match<'tree>>,
6613}
6614impl<'tree> ::treesitter_types::FromNode<'tree> for MultiWayIf<'tree> {
6615 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6616 fn from_node(
6617 node: ::treesitter_types::tree_sitter::Node<'tree>,
6618 src: &'tree [u8],
6619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6620 debug_assert_eq!(node.kind(), "multi_way_if");
6621 Ok(Self {
6622 span: ::treesitter_types::Span::from(node),
6623 r#match: {
6624 let mut cursor = node.walk();
6625 let mut items = ::std::vec::Vec::new();
6626 for child in node.children_by_field_name("match", &mut cursor) {
6627 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6628 <Match as ::treesitter_types::FromNode>::from_node(child, src)
6629 })?);
6630 }
6631 items
6632 },
6633 })
6634 }
6635}
6636impl ::treesitter_types::Spanned for MultiWayIf<'_> {
6637 fn span(&self) -> ::treesitter_types::Span {
6638 self.span
6639 }
6640}
6641#[derive(Debug, Clone, PartialEq, Eq)]
6642pub struct Namespace<'tree> {
6643 pub span: ::treesitter_types::Span,
6644 text: &'tree str,
6645}
6646impl<'tree> ::treesitter_types::FromNode<'tree> for Namespace<'tree> {
6647 fn from_node(
6648 node: ::treesitter_types::tree_sitter::Node<'tree>,
6649 src: &'tree [u8],
6650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6651 debug_assert_eq!(node.kind(), "namespace");
6652 Ok(Self {
6653 span: ::treesitter_types::Span::from(node),
6654 text: node.utf8_text(src)?,
6655 })
6656 }
6657}
6658impl<'tree> ::treesitter_types::LeafNode<'tree> for Namespace<'tree> {
6659 fn text(&self) -> &'tree str {
6660 self.text
6661 }
6662}
6663impl ::treesitter_types::Spanned for Namespace<'_> {
6664 fn span(&self) -> ::treesitter_types::Span {
6665 self.span
6666 }
6667}
6668#[derive(Debug, Clone, PartialEq, Eq)]
6669pub struct Negation<'tree> {
6670 pub span: ::treesitter_types::Span,
6671 pub expression: ::core::option::Option<Expression<'tree>>,
6672 pub minus: ::core::option::Option<NegationMinus>,
6673 pub number: ::core::option::Option<NegationNumber<'tree>>,
6674}
6675impl<'tree> ::treesitter_types::FromNode<'tree> for Negation<'tree> {
6676 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6677 fn from_node(
6678 node: ::treesitter_types::tree_sitter::Node<'tree>,
6679 src: &'tree [u8],
6680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6681 debug_assert_eq!(node.kind(), "negation");
6682 Ok(Self {
6683 span: ::treesitter_types::Span::from(node),
6684 expression: match node.child_by_field_name("expression") {
6685 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6686 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
6687 })?),
6688 None => None,
6689 },
6690 minus: match node.child_by_field_name("minus") {
6691 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6692 <NegationMinus as ::treesitter_types::FromNode>::from_node(child, src)
6693 })?),
6694 None => None,
6695 },
6696 number: match node.child_by_field_name("number") {
6697 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6698 <NegationNumber as ::treesitter_types::FromNode>::from_node(child, src)
6699 })?),
6700 None => None,
6701 },
6702 })
6703 }
6704}
6705impl ::treesitter_types::Spanned for Negation<'_> {
6706 fn span(&self) -> ::treesitter_types::Span {
6707 self.span
6708 }
6709}
6710#[derive(Debug, Clone, PartialEq, Eq)]
6711pub struct Newtype<'tree> {
6712 pub span: ::treesitter_types::Span,
6713 pub constructor: ::core::option::Option<NewtypeConstructor<'tree>>,
6714 pub constructors: ::core::option::Option<GadtConstructors<'tree>>,
6715 pub context: ::core::option::Option<Context<'tree>>,
6716 pub deriving: ::std::vec::Vec<Deriving<'tree>>,
6717 pub forall: ::core::option::Option<NewtypeForall<'tree>>,
6718 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
6719 pub name: ::core::option::Option<NewtypeName<'tree>>,
6720 pub patterns: ::core::option::Option<NewtypePatterns<'tree>>,
6721 pub children: ::core::option::Option<NewtypeChildren<'tree>>,
6722}
6723impl<'tree> ::treesitter_types::FromNode<'tree> for Newtype<'tree> {
6724 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6725 fn from_node(
6726 node: ::treesitter_types::tree_sitter::Node<'tree>,
6727 src: &'tree [u8],
6728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6729 debug_assert_eq!(node.kind(), "newtype");
6730 Ok(Self {
6731 span: ::treesitter_types::Span::from(node),
6732 constructor: match node.child_by_field_name("constructor") {
6733 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6734 <NewtypeConstructor as ::treesitter_types::FromNode>::from_node(child, src)
6735 })?),
6736 None => None,
6737 },
6738 constructors: match node.child_by_field_name("constructors") {
6739 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6740 <GadtConstructors as ::treesitter_types::FromNode>::from_node(child, src)
6741 })?),
6742 None => None,
6743 },
6744 context: match node.child_by_field_name("context") {
6745 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6746 <Context as ::treesitter_types::FromNode>::from_node(child, src)
6747 })?),
6748 None => None,
6749 },
6750 deriving: {
6751 let mut cursor = node.walk();
6752 let mut items = ::std::vec::Vec::new();
6753 for child in node.children_by_field_name("deriving", &mut cursor) {
6754 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
6755 <Deriving as ::treesitter_types::FromNode>::from_node(child, src)
6756 })?);
6757 }
6758 items
6759 },
6760 forall: match node.child_by_field_name("forall") {
6761 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6762 <NewtypeForall as ::treesitter_types::FromNode>::from_node(child, src)
6763 })?),
6764 None => None,
6765 },
6766 kind: match node.child_by_field_name("kind") {
6767 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6768 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
6769 })?),
6770 None => None,
6771 },
6772 name: match node.child_by_field_name("name") {
6773 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6774 <NewtypeName as ::treesitter_types::FromNode>::from_node(child, src)
6775 })?),
6776 None => None,
6777 },
6778 patterns: match node.child_by_field_name("patterns") {
6779 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6780 <NewtypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
6781 })?),
6782 None => None,
6783 },
6784 children: {
6785 #[allow(clippy::suspicious_else_formatting)]
6786 let non_field_children = {
6787 let mut cursor = node.walk();
6788 let mut result = ::std::vec::Vec::new();
6789 if cursor.goto_first_child() {
6790 loop {
6791 if cursor.field_name().is_none()
6792 && cursor.node().is_named()
6793 && !cursor.node().is_extra()
6794 {
6795 result.push(cursor.node());
6796 }
6797 if !cursor.goto_next_sibling() {
6798 break;
6799 }
6800 }
6801 }
6802 result
6803 };
6804 match non_field_children.first() {
6805 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6806 <NewtypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
6807 })?),
6808 None => None,
6809 }
6810 },
6811 })
6812 }
6813}
6814impl ::treesitter_types::Spanned for Newtype<'_> {
6815 fn span(&self) -> ::treesitter_types::Span {
6816 self.span
6817 }
6818}
6819#[derive(Debug, Clone, PartialEq, Eq)]
6820pub struct NewtypeConstructor<'tree> {
6821 pub span: ::treesitter_types::Span,
6822 pub field: NewtypeConstructorField<'tree>,
6823 pub name: NewtypeConstructorName<'tree>,
6824}
6825impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructor<'tree> {
6826 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6827 fn from_node(
6828 node: ::treesitter_types::tree_sitter::Node<'tree>,
6829 src: &'tree [u8],
6830 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6831 debug_assert_eq!(node.kind(), "newtype_constructor");
6832 Ok(Self {
6833 span: ::treesitter_types::Span::from(node),
6834 field: {
6835 let child = node
6836 .child_by_field_name("field")
6837 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
6838 ::treesitter_types::runtime::maybe_grow_stack(|| {
6839 <NewtypeConstructorField as ::treesitter_types::FromNode>::from_node(child, src)
6840 })?
6841 },
6842 name: {
6843 let child = node
6844 .child_by_field_name("name")
6845 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6846 ::treesitter_types::runtime::maybe_grow_stack(|| {
6847 <NewtypeConstructorName as ::treesitter_types::FromNode>::from_node(child, src)
6848 })?
6849 },
6850 })
6851 }
6852}
6853impl ::treesitter_types::Spanned for NewtypeConstructor<'_> {
6854 fn span(&self) -> ::treesitter_types::Span {
6855 self.span
6856 }
6857}
6858#[derive(Debug, Clone, PartialEq, Eq)]
6859pub struct Operator<'tree> {
6860 pub span: ::treesitter_types::Span,
6861 text: &'tree str,
6862}
6863impl<'tree> ::treesitter_types::FromNode<'tree> for Operator<'tree> {
6864 fn from_node(
6865 node: ::treesitter_types::tree_sitter::Node<'tree>,
6866 src: &'tree [u8],
6867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6868 debug_assert_eq!(node.kind(), "operator");
6869 Ok(Self {
6870 span: ::treesitter_types::Span::from(node),
6871 text: node.utf8_text(src)?,
6872 })
6873 }
6874}
6875impl<'tree> ::treesitter_types::LeafNode<'tree> for Operator<'tree> {
6876 fn text(&self) -> &'tree str {
6877 self.text
6878 }
6879}
6880impl ::treesitter_types::Spanned for Operator<'_> {
6881 fn span(&self) -> ::treesitter_types::Span {
6882 self.span
6883 }
6884}
6885#[derive(Debug, Clone, PartialEq, Eq)]
6886pub struct Parens<'tree> {
6887 pub span: ::treesitter_types::Span,
6888 pub expression: ::core::option::Option<ParensExpression<'tree>>,
6889 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
6890 pub name: ::core::option::Option<ParensName<'tree>>,
6891 pub pattern: ::core::option::Option<ParensPattern<'tree>>,
6892 pub patterns: ::core::option::Option<ParensPatterns<'tree>>,
6893 pub r#type: ::core::option::Option<ParensType<'tree>>,
6894 pub children: ::core::option::Option<ParensChildren<'tree>>,
6895}
6896impl<'tree> ::treesitter_types::FromNode<'tree> for Parens<'tree> {
6897 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6898 fn from_node(
6899 node: ::treesitter_types::tree_sitter::Node<'tree>,
6900 src: &'tree [u8],
6901 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6902 debug_assert_eq!(node.kind(), "parens");
6903 Ok(Self {
6904 span: ::treesitter_types::Span::from(node),
6905 expression: match node.child_by_field_name("expression") {
6906 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6907 <ParensExpression as ::treesitter_types::FromNode>::from_node(child, src)
6908 })?),
6909 None => None,
6910 },
6911 kind: match node.child_by_field_name("kind") {
6912 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6913 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
6914 })?),
6915 None => None,
6916 },
6917 name: match node.child_by_field_name("name") {
6918 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6919 <ParensName as ::treesitter_types::FromNode>::from_node(child, src)
6920 })?),
6921 None => None,
6922 },
6923 pattern: match node.child_by_field_name("pattern") {
6924 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6925 <ParensPattern as ::treesitter_types::FromNode>::from_node(child, src)
6926 })?),
6927 None => None,
6928 },
6929 patterns: match node.child_by_field_name("patterns") {
6930 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6931 <ParensPatterns as ::treesitter_types::FromNode>::from_node(child, src)
6932 })?),
6933 None => None,
6934 },
6935 r#type: match node.child_by_field_name("type") {
6936 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6937 <ParensType as ::treesitter_types::FromNode>::from_node(child, src)
6938 })?),
6939 None => None,
6940 },
6941 children: {
6942 #[allow(clippy::suspicious_else_formatting)]
6943 let non_field_children = {
6944 let mut cursor = node.walk();
6945 let mut result = ::std::vec::Vec::new();
6946 if cursor.goto_first_child() {
6947 loop {
6948 if cursor.field_name().is_none()
6949 && cursor.node().is_named()
6950 && !cursor.node().is_extra()
6951 {
6952 result.push(cursor.node());
6953 }
6954 if !cursor.goto_next_sibling() {
6955 break;
6956 }
6957 }
6958 }
6959 result
6960 };
6961 match non_field_children.first() {
6962 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
6963 <ParensChildren as ::treesitter_types::FromNode>::from_node(child, src)
6964 })?),
6965 None => None,
6966 }
6967 },
6968 })
6969 }
6970}
6971impl ::treesitter_types::Spanned for Parens<'_> {
6972 fn span(&self) -> ::treesitter_types::Span {
6973 self.span
6974 }
6975}
6976#[derive(Debug, Clone, PartialEq, Eq)]
6977pub struct PatternGuard<'tree> {
6978 pub span: ::treesitter_types::Span,
6979 pub arrow: PatternGuardArrow,
6980 pub expression: PatternGuardExpression<'tree>,
6981 pub pattern: PatternGuardPattern<'tree>,
6982}
6983impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuard<'tree> {
6984 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6985 fn from_node(
6986 node: ::treesitter_types::tree_sitter::Node<'tree>,
6987 src: &'tree [u8],
6988 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6989 debug_assert_eq!(node.kind(), "pattern_guard");
6990 Ok(Self {
6991 span: ::treesitter_types::Span::from(node),
6992 arrow: {
6993 let child = node
6994 .child_by_field_name("arrow")
6995 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
6996 ::treesitter_types::runtime::maybe_grow_stack(|| {
6997 <PatternGuardArrow as ::treesitter_types::FromNode>::from_node(child, src)
6998 })?
6999 },
7000 expression: {
7001 let child = node.child_by_field_name("expression").ok_or_else(|| {
7002 ::treesitter_types::ParseError::missing_field("expression", node)
7003 })?;
7004 ::treesitter_types::runtime::maybe_grow_stack(|| {
7005 <PatternGuardExpression as ::treesitter_types::FromNode>::from_node(child, src)
7006 })?
7007 },
7008 pattern: {
7009 let child = node.child_by_field_name("pattern").ok_or_else(|| {
7010 ::treesitter_types::ParseError::missing_field("pattern", node)
7011 })?;
7012 ::treesitter_types::runtime::maybe_grow_stack(|| {
7013 <PatternGuardPattern as ::treesitter_types::FromNode>::from_node(child, src)
7014 })?
7015 },
7016 })
7017 }
7018}
7019impl ::treesitter_types::Spanned for PatternGuard<'_> {
7020 fn span(&self) -> ::treesitter_types::Span {
7021 self.span
7022 }
7023}
7024#[derive(Debug, Clone, PartialEq, Eq)]
7025pub struct PatternSynonym<'tree> {
7026 pub span: ::treesitter_types::Span,
7027 pub children: PatternSynonymChildren<'tree>,
7028}
7029impl<'tree> ::treesitter_types::FromNode<'tree> for PatternSynonym<'tree> {
7030 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7031 fn from_node(
7032 node: ::treesitter_types::tree_sitter::Node<'tree>,
7033 src: &'tree [u8],
7034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7035 debug_assert_eq!(node.kind(), "pattern_synonym");
7036 Ok(Self {
7037 span: ::treesitter_types::Span::from(node),
7038 children: {
7039 #[allow(clippy::suspicious_else_formatting)]
7040 let non_field_children = {
7041 let mut cursor = node.walk();
7042 let mut result = ::std::vec::Vec::new();
7043 if cursor.goto_first_child() {
7044 loop {
7045 if cursor.field_name().is_none()
7046 && cursor.node().is_named()
7047 && !cursor.node().is_extra()
7048 {
7049 result.push(cursor.node());
7050 }
7051 if !cursor.goto_next_sibling() {
7052 break;
7053 }
7054 }
7055 }
7056 result
7057 };
7058 let child = if let Some(&c) = non_field_children.first() {
7059 c
7060 } else {
7061 let mut fallback_cursor = node.walk();
7062 let mut fallback_child = None;
7063 if fallback_cursor.goto_first_child() {
7064 loop {
7065 if fallback_cursor.field_name().is_none()
7066 && !fallback_cursor.node().is_extra()
7067 {
7068 let candidate = fallback_cursor.node();
7069 #[allow(clippy::needless_question_mark)]
7070 if (|| -> ::core::result::Result<
7071 _,
7072 ::treesitter_types::ParseError,
7073 > {
7074 let child = candidate;
7075 Ok(
7076 ::treesitter_types::runtime::maybe_grow_stack(|| <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(
7077 child,
7078 src,
7079 ))?,
7080 )
7081 })()
7082 .is_ok()
7083 {
7084 fallback_child = Some(candidate);
7085 break;
7086 }
7087 }
7088 if !fallback_cursor.goto_next_sibling() {
7089 break;
7090 }
7091 }
7092 }
7093 if fallback_child.is_none() {
7094 let mut cursor2 = node.walk();
7095 if cursor2.goto_first_child() {
7096 loop {
7097 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7098 let candidate = cursor2.node();
7099 #[allow(clippy::needless_question_mark)]
7100 if (|| -> ::core::result::Result<
7101 _,
7102 ::treesitter_types::ParseError,
7103 > {
7104 let child = candidate;
7105 Ok(
7106 ::treesitter_types::runtime::maybe_grow_stack(|| <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(
7107 child,
7108 src,
7109 ))?,
7110 )
7111 })()
7112 .is_ok()
7113 {
7114 fallback_child = Some(candidate);
7115 break;
7116 }
7117 }
7118 if !cursor2.goto_next_sibling() {
7119 break;
7120 }
7121 }
7122 }
7123 }
7124 fallback_child.ok_or_else(|| {
7125 ::treesitter_types::ParseError::missing_field("children", node)
7126 })?
7127 };
7128 ::treesitter_types::runtime::maybe_grow_stack(|| {
7129 <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(child, src)
7130 })?
7131 },
7132 })
7133 }
7134}
7135impl ::treesitter_types::Spanned for PatternSynonym<'_> {
7136 fn span(&self) -> ::treesitter_types::Span {
7137 self.span
7138 }
7139}
7140#[derive(Debug, Clone, PartialEq, Eq)]
7141pub struct Patterns<'tree> {
7142 pub span: ::treesitter_types::Span,
7143 pub children: ::std::vec::Vec<PatternsChildren<'tree>>,
7144}
7145impl<'tree> ::treesitter_types::FromNode<'tree> for Patterns<'tree> {
7146 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7147 fn from_node(
7148 node: ::treesitter_types::tree_sitter::Node<'tree>,
7149 src: &'tree [u8],
7150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7151 debug_assert_eq!(node.kind(), "patterns");
7152 Ok(Self {
7153 span: ::treesitter_types::Span::from(node),
7154 children: {
7155 #[allow(clippy::suspicious_else_formatting)]
7156 let non_field_children = {
7157 let mut cursor = node.walk();
7158 let mut result = ::std::vec::Vec::new();
7159 if cursor.goto_first_child() {
7160 loop {
7161 if cursor.field_name().is_none()
7162 && cursor.node().is_named()
7163 && !cursor.node().is_extra()
7164 {
7165 result.push(cursor.node());
7166 }
7167 if !cursor.goto_next_sibling() {
7168 break;
7169 }
7170 }
7171 }
7172 result
7173 };
7174 let mut items = ::std::vec::Vec::new();
7175 for child in non_field_children {
7176 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7177 <PatternsChildren as ::treesitter_types::FromNode>::from_node(child, src)
7178 })?);
7179 }
7180 items
7181 },
7182 })
7183 }
7184}
7185impl ::treesitter_types::Spanned for Patterns<'_> {
7186 fn span(&self) -> ::treesitter_types::Span {
7187 self.span
7188 }
7189}
7190#[derive(Debug, Clone, PartialEq, Eq)]
7191pub struct Prefix<'tree> {
7192 pub span: ::treesitter_types::Span,
7193 pub field: ::std::vec::Vec<PrefixField<'tree>>,
7194 pub name: ::core::option::Option<PrefixName<'tree>>,
7195 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
7196}
7197impl<'tree> ::treesitter_types::FromNode<'tree> for Prefix<'tree> {
7198 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7199 fn from_node(
7200 node: ::treesitter_types::tree_sitter::Node<'tree>,
7201 src: &'tree [u8],
7202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7203 debug_assert_eq!(node.kind(), "prefix");
7204 Ok(Self {
7205 span: ::treesitter_types::Span::from(node),
7206 field: {
7207 let mut cursor = node.walk();
7208 let mut items = ::std::vec::Vec::new();
7209 for child in node.children_by_field_name("field", &mut cursor) {
7210 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7211 <PrefixField as ::treesitter_types::FromNode>::from_node(child, src)
7212 })?);
7213 }
7214 items
7215 },
7216 name: match node.child_by_field_name("name") {
7217 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7218 <PrefixName as ::treesitter_types::FromNode>::from_node(child, src)
7219 })?),
7220 None => None,
7221 },
7222 r#type: match node.child_by_field_name("type") {
7223 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7224 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
7225 })?),
7226 None => None,
7227 },
7228 })
7229 }
7230}
7231impl ::treesitter_types::Spanned for Prefix<'_> {
7232 fn span(&self) -> ::treesitter_types::Span {
7233 self.span
7234 }
7235}
7236#[derive(Debug, Clone, PartialEq, Eq)]
7237pub struct PrefixId<'tree> {
7238 pub span: ::treesitter_types::Span,
7239 pub children: PrefixIdChildren<'tree>,
7240}
7241impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixId<'tree> {
7242 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7243 fn from_node(
7244 node: ::treesitter_types::tree_sitter::Node<'tree>,
7245 src: &'tree [u8],
7246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7247 debug_assert_eq!(node.kind(), "prefix_id");
7248 Ok(Self {
7249 span: ::treesitter_types::Span::from(node),
7250 children: {
7251 #[allow(clippy::suspicious_else_formatting)]
7252 let non_field_children = {
7253 let mut cursor = node.walk();
7254 let mut result = ::std::vec::Vec::new();
7255 if cursor.goto_first_child() {
7256 loop {
7257 if cursor.field_name().is_none()
7258 && cursor.node().is_named()
7259 && !cursor.node().is_extra()
7260 {
7261 result.push(cursor.node());
7262 }
7263 if !cursor.goto_next_sibling() {
7264 break;
7265 }
7266 }
7267 }
7268 result
7269 };
7270 let child = if let Some(&c) = non_field_children.first() {
7271 c
7272 } else {
7273 let mut fallback_cursor = node.walk();
7274 let mut fallback_child = None;
7275 if fallback_cursor.goto_first_child() {
7276 loop {
7277 if fallback_cursor.field_name().is_none()
7278 && !fallback_cursor.node().is_extra()
7279 {
7280 let candidate = fallback_cursor.node();
7281 #[allow(clippy::needless_question_mark)]
7282 if (|| -> ::core::result::Result<
7283 _,
7284 ::treesitter_types::ParseError,
7285 > {
7286 let child = candidate;
7287 Ok(
7288 ::treesitter_types::runtime::maybe_grow_stack(|| <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(
7289 child,
7290 src,
7291 ))?,
7292 )
7293 })()
7294 .is_ok()
7295 {
7296 fallback_child = Some(candidate);
7297 break;
7298 }
7299 }
7300 if !fallback_cursor.goto_next_sibling() {
7301 break;
7302 }
7303 }
7304 }
7305 if fallback_child.is_none() {
7306 let mut cursor2 = node.walk();
7307 if cursor2.goto_first_child() {
7308 loop {
7309 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7310 let candidate = cursor2.node();
7311 #[allow(clippy::needless_question_mark)]
7312 if (|| -> ::core::result::Result<
7313 _,
7314 ::treesitter_types::ParseError,
7315 > {
7316 let child = candidate;
7317 Ok(
7318 ::treesitter_types::runtime::maybe_grow_stack(|| <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(
7319 child,
7320 src,
7321 ))?,
7322 )
7323 })()
7324 .is_ok()
7325 {
7326 fallback_child = Some(candidate);
7327 break;
7328 }
7329 }
7330 if !cursor2.goto_next_sibling() {
7331 break;
7332 }
7333 }
7334 }
7335 }
7336 fallback_child.ok_or_else(|| {
7337 ::treesitter_types::ParseError::missing_field("children", node)
7338 })?
7339 };
7340 ::treesitter_types::runtime::maybe_grow_stack(|| {
7341 <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(child, src)
7342 })?
7343 },
7344 })
7345 }
7346}
7347impl ::treesitter_types::Spanned for PrefixId<'_> {
7348 fn span(&self) -> ::treesitter_types::Span {
7349 self.span
7350 }
7351}
7352#[derive(Debug, Clone, PartialEq, Eq)]
7353pub struct PrefixList<'tree> {
7354 pub span: ::treesitter_types::Span,
7355 text: &'tree str,
7356}
7357impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixList<'tree> {
7358 fn from_node(
7359 node: ::treesitter_types::tree_sitter::Node<'tree>,
7360 src: &'tree [u8],
7361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7362 debug_assert_eq!(node.kind(), "prefix_list");
7363 Ok(Self {
7364 span: ::treesitter_types::Span::from(node),
7365 text: node.utf8_text(src)?,
7366 })
7367 }
7368}
7369impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixList<'tree> {
7370 fn text(&self) -> &'tree str {
7371 self.text
7372 }
7373}
7374impl ::treesitter_types::Spanned for PrefixList<'_> {
7375 fn span(&self) -> ::treesitter_types::Span {
7376 self.span
7377 }
7378}
7379#[derive(Debug, Clone, PartialEq, Eq)]
7380pub struct PrefixTuple<'tree> {
7381 pub span: ::treesitter_types::Span,
7382 text: &'tree str,
7383}
7384impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixTuple<'tree> {
7385 fn from_node(
7386 node: ::treesitter_types::tree_sitter::Node<'tree>,
7387 src: &'tree [u8],
7388 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7389 debug_assert_eq!(node.kind(), "prefix_tuple");
7390 Ok(Self {
7391 span: ::treesitter_types::Span::from(node),
7392 text: node.utf8_text(src)?,
7393 })
7394 }
7395}
7396impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixTuple<'tree> {
7397 fn text(&self) -> &'tree str {
7398 self.text
7399 }
7400}
7401impl ::treesitter_types::Spanned for PrefixTuple<'_> {
7402 fn span(&self) -> ::treesitter_types::Span {
7403 self.span
7404 }
7405}
7406#[derive(Debug, Clone, PartialEq, Eq)]
7407pub struct PrefixUnboxedSum<'tree> {
7408 pub span: ::treesitter_types::Span,
7409 text: &'tree str,
7410}
7411impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnboxedSum<'tree> {
7412 fn from_node(
7413 node: ::treesitter_types::tree_sitter::Node<'tree>,
7414 src: &'tree [u8],
7415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7416 debug_assert_eq!(node.kind(), "prefix_unboxed_sum");
7417 Ok(Self {
7418 span: ::treesitter_types::Span::from(node),
7419 text: node.utf8_text(src)?,
7420 })
7421 }
7422}
7423impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixUnboxedSum<'tree> {
7424 fn text(&self) -> &'tree str {
7425 self.text
7426 }
7427}
7428impl ::treesitter_types::Spanned for PrefixUnboxedSum<'_> {
7429 fn span(&self) -> ::treesitter_types::Span {
7430 self.span
7431 }
7432}
7433#[derive(Debug, Clone, PartialEq, Eq)]
7434pub struct PrefixUnboxedTuple<'tree> {
7435 pub span: ::treesitter_types::Span,
7436 text: &'tree str,
7437}
7438impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnboxedTuple<'tree> {
7439 fn from_node(
7440 node: ::treesitter_types::tree_sitter::Node<'tree>,
7441 src: &'tree [u8],
7442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7443 debug_assert_eq!(node.kind(), "prefix_unboxed_tuple");
7444 Ok(Self {
7445 span: ::treesitter_types::Span::from(node),
7446 text: node.utf8_text(src)?,
7447 })
7448 }
7449}
7450impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixUnboxedTuple<'tree> {
7451 fn text(&self) -> &'tree str {
7452 self.text
7453 }
7454}
7455impl ::treesitter_types::Spanned for PrefixUnboxedTuple<'_> {
7456 fn span(&self) -> ::treesitter_types::Span {
7457 self.span
7458 }
7459}
7460#[derive(Debug, Clone, PartialEq, Eq)]
7461pub struct Projection<'tree> {
7462 pub span: ::treesitter_types::Span,
7463 pub expression: Expression<'tree>,
7464 pub field: FieldName<'tree>,
7465}
7466impl<'tree> ::treesitter_types::FromNode<'tree> for Projection<'tree> {
7467 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7468 fn from_node(
7469 node: ::treesitter_types::tree_sitter::Node<'tree>,
7470 src: &'tree [u8],
7471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7472 debug_assert_eq!(node.kind(), "projection");
7473 Ok(Self {
7474 span: ::treesitter_types::Span::from(node),
7475 expression: {
7476 let child = node.child_by_field_name("expression").ok_or_else(|| {
7477 ::treesitter_types::ParseError::missing_field("expression", node)
7478 })?;
7479 ::treesitter_types::runtime::maybe_grow_stack(|| {
7480 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
7481 })?
7482 },
7483 field: {
7484 let child = node
7485 .child_by_field_name("field")
7486 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
7487 ::treesitter_types::runtime::maybe_grow_stack(|| {
7488 <FieldName as ::treesitter_types::FromNode>::from_node(child, src)
7489 })?
7490 },
7491 })
7492 }
7493}
7494impl ::treesitter_types::Spanned for Projection<'_> {
7495 fn span(&self) -> ::treesitter_types::Span {
7496 self.span
7497 }
7498}
7499#[derive(Debug, Clone, PartialEq, Eq)]
7500pub struct ProjectionSelector<'tree> {
7501 pub span: ::treesitter_types::Span,
7502 pub field: ::std::vec::Vec<Variable<'tree>>,
7503}
7504impl<'tree> ::treesitter_types::FromNode<'tree> for ProjectionSelector<'tree> {
7505 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7506 fn from_node(
7507 node: ::treesitter_types::tree_sitter::Node<'tree>,
7508 src: &'tree [u8],
7509 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7510 debug_assert_eq!(node.kind(), "projection_selector");
7511 Ok(Self {
7512 span: ::treesitter_types::Span::from(node),
7513 field: {
7514 let mut cursor = node.walk();
7515 let mut items = ::std::vec::Vec::new();
7516 for child in node.children_by_field_name("field", &mut cursor) {
7517 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7518 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
7519 })?);
7520 }
7521 items
7522 },
7523 })
7524 }
7525}
7526impl ::treesitter_types::Spanned for ProjectionSelector<'_> {
7527 fn span(&self) -> ::treesitter_types::Span {
7528 self.span
7529 }
7530}
7531#[derive(Debug, Clone, PartialEq, Eq)]
7532pub struct Promoted<'tree> {
7533 pub span: ::treesitter_types::Span,
7534 pub children: PromotedChildren<'tree>,
7535}
7536impl<'tree> ::treesitter_types::FromNode<'tree> for Promoted<'tree> {
7537 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7538 fn from_node(
7539 node: ::treesitter_types::tree_sitter::Node<'tree>,
7540 src: &'tree [u8],
7541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7542 debug_assert_eq!(node.kind(), "promoted");
7543 Ok(Self {
7544 span: ::treesitter_types::Span::from(node),
7545 children: {
7546 #[allow(clippy::suspicious_else_formatting)]
7547 let non_field_children = {
7548 let mut cursor = node.walk();
7549 let mut result = ::std::vec::Vec::new();
7550 if cursor.goto_first_child() {
7551 loop {
7552 if cursor.field_name().is_none()
7553 && cursor.node().is_named()
7554 && !cursor.node().is_extra()
7555 {
7556 result.push(cursor.node());
7557 }
7558 if !cursor.goto_next_sibling() {
7559 break;
7560 }
7561 }
7562 }
7563 result
7564 };
7565 let child = if let Some(&c) = non_field_children.first() {
7566 c
7567 } else {
7568 let mut fallback_cursor = node.walk();
7569 let mut fallback_child = None;
7570 if fallback_cursor.goto_first_child() {
7571 loop {
7572 if fallback_cursor.field_name().is_none()
7573 && !fallback_cursor.node().is_extra()
7574 {
7575 let candidate = fallback_cursor.node();
7576 #[allow(clippy::needless_question_mark)]
7577 if (|| -> ::core::result::Result<
7578 _,
7579 ::treesitter_types::ParseError,
7580 > {
7581 let child = candidate;
7582 Ok(
7583 ::treesitter_types::runtime::maybe_grow_stack(|| <PromotedChildren as ::treesitter_types::FromNode>::from_node(
7584 child,
7585 src,
7586 ))?,
7587 )
7588 })()
7589 .is_ok()
7590 {
7591 fallback_child = Some(candidate);
7592 break;
7593 }
7594 }
7595 if !fallback_cursor.goto_next_sibling() {
7596 break;
7597 }
7598 }
7599 }
7600 if fallback_child.is_none() {
7601 let mut cursor2 = node.walk();
7602 if cursor2.goto_first_child() {
7603 loop {
7604 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7605 let candidate = cursor2.node();
7606 #[allow(clippy::needless_question_mark)]
7607 if (|| -> ::core::result::Result<
7608 _,
7609 ::treesitter_types::ParseError,
7610 > {
7611 let child = candidate;
7612 Ok(
7613 ::treesitter_types::runtime::maybe_grow_stack(|| <PromotedChildren as ::treesitter_types::FromNode>::from_node(
7614 child,
7615 src,
7616 ))?,
7617 )
7618 })()
7619 .is_ok()
7620 {
7621 fallback_child = Some(candidate);
7622 break;
7623 }
7624 }
7625 if !cursor2.goto_next_sibling() {
7626 break;
7627 }
7628 }
7629 }
7630 }
7631 fallback_child.ok_or_else(|| {
7632 ::treesitter_types::ParseError::missing_field("children", node)
7633 })?
7634 };
7635 ::treesitter_types::runtime::maybe_grow_stack(|| {
7636 <PromotedChildren as ::treesitter_types::FromNode>::from_node(child, src)
7637 })?
7638 },
7639 })
7640 }
7641}
7642impl ::treesitter_types::Spanned for Promoted<'_> {
7643 fn span(&self) -> ::treesitter_types::Span {
7644 self.span
7645 }
7646}
7647#[derive(Debug, Clone, PartialEq, Eq)]
7648pub struct Qualified<'tree> {
7649 pub span: ::treesitter_types::Span,
7650 pub id: QualifiedId<'tree>,
7651 pub module: Module<'tree>,
7652}
7653impl<'tree> ::treesitter_types::FromNode<'tree> for Qualified<'tree> {
7654 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7655 fn from_node(
7656 node: ::treesitter_types::tree_sitter::Node<'tree>,
7657 src: &'tree [u8],
7658 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7659 debug_assert_eq!(node.kind(), "qualified");
7660 Ok(Self {
7661 span: ::treesitter_types::Span::from(node),
7662 id: {
7663 let child = node
7664 .child_by_field_name("id")
7665 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("id", node))?;
7666 ::treesitter_types::runtime::maybe_grow_stack(|| {
7667 <QualifiedId as ::treesitter_types::FromNode>::from_node(child, src)
7668 })?
7669 },
7670 module: {
7671 let child = node
7672 .child_by_field_name("module")
7673 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
7674 ::treesitter_types::runtime::maybe_grow_stack(|| {
7675 <Module as ::treesitter_types::FromNode>::from_node(child, src)
7676 })?
7677 },
7678 })
7679 }
7680}
7681impl ::treesitter_types::Spanned for Qualified<'_> {
7682 fn span(&self) -> ::treesitter_types::Span {
7683 self.span
7684 }
7685}
7686#[derive(Debug, Clone, PartialEq, Eq)]
7687pub struct Qualifiers<'tree> {
7688 pub span: ::treesitter_types::Span,
7689 pub qualifier: ::std::vec::Vec<Qualifier<'tree>>,
7690}
7691impl<'tree> ::treesitter_types::FromNode<'tree> for Qualifiers<'tree> {
7692 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7693 fn from_node(
7694 node: ::treesitter_types::tree_sitter::Node<'tree>,
7695 src: &'tree [u8],
7696 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7697 debug_assert_eq!(node.kind(), "qualifiers");
7698 Ok(Self {
7699 span: ::treesitter_types::Span::from(node),
7700 qualifier: {
7701 let mut cursor = node.walk();
7702 let mut items = ::std::vec::Vec::new();
7703 for child in node.children_by_field_name("qualifier", &mut cursor) {
7704 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7705 <Qualifier as ::treesitter_types::FromNode>::from_node(child, src)
7706 })?);
7707 }
7708 items
7709 },
7710 })
7711 }
7712}
7713impl ::treesitter_types::Spanned for Qualifiers<'_> {
7714 fn span(&self) -> ::treesitter_types::Span {
7715 self.span
7716 }
7717}
7718#[derive(Debug, Clone, PartialEq, Eq)]
7719pub struct QuantifiedVariables<'tree> {
7720 pub span: ::treesitter_types::Span,
7721 pub children: ::std::vec::Vec<QuantifiedVariablesChildren<'tree>>,
7722}
7723impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedVariables<'tree> {
7724 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7725 fn from_node(
7726 node: ::treesitter_types::tree_sitter::Node<'tree>,
7727 src: &'tree [u8],
7728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7729 debug_assert_eq!(node.kind(), "quantified_variables");
7730 Ok(Self {
7731 span: ::treesitter_types::Span::from(node),
7732 children: {
7733 #[allow(clippy::suspicious_else_formatting)]
7734 let non_field_children = {
7735 let mut cursor = node.walk();
7736 let mut result = ::std::vec::Vec::new();
7737 if cursor.goto_first_child() {
7738 loop {
7739 if cursor.field_name().is_none()
7740 && cursor.node().is_named()
7741 && !cursor.node().is_extra()
7742 {
7743 result.push(cursor.node());
7744 }
7745 if !cursor.goto_next_sibling() {
7746 break;
7747 }
7748 }
7749 }
7750 result
7751 };
7752 let mut items = ::std::vec::Vec::new();
7753 for child in non_field_children {
7754 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7755 <QuantifiedVariablesChildren as ::treesitter_types::FromNode>::from_node(
7756 child, src,
7757 )
7758 })?);
7759 }
7760 items
7761 },
7762 })
7763 }
7764}
7765impl ::treesitter_types::Spanned for QuantifiedVariables<'_> {
7766 fn span(&self) -> ::treesitter_types::Span {
7767 self.span
7768 }
7769}
7770#[derive(Debug, Clone, PartialEq, Eq)]
7771pub struct Quasiquote<'tree> {
7772 pub span: ::treesitter_types::Span,
7773 pub body: ::core::option::Option<QuasiquoteBody<'tree>>,
7774 pub quoter: Quoter<'tree>,
7775}
7776impl<'tree> ::treesitter_types::FromNode<'tree> for Quasiquote<'tree> {
7777 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7778 fn from_node(
7779 node: ::treesitter_types::tree_sitter::Node<'tree>,
7780 src: &'tree [u8],
7781 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7782 debug_assert_eq!(node.kind(), "quasiquote");
7783 Ok(Self {
7784 span: ::treesitter_types::Span::from(node),
7785 body: match node.child_by_field_name("body") {
7786 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7787 <QuasiquoteBody as ::treesitter_types::FromNode>::from_node(child, src)
7788 })?),
7789 None => None,
7790 },
7791 quoter: {
7792 let child = node
7793 .child_by_field_name("quoter")
7794 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("quoter", node))?;
7795 ::treesitter_types::runtime::maybe_grow_stack(|| {
7796 <Quoter as ::treesitter_types::FromNode>::from_node(child, src)
7797 })?
7798 },
7799 })
7800 }
7801}
7802impl ::treesitter_types::Spanned for Quasiquote<'_> {
7803 fn span(&self) -> ::treesitter_types::Span {
7804 self.span
7805 }
7806}
7807#[derive(Debug, Clone, PartialEq, Eq)]
7808pub struct Quote<'tree> {
7809 pub span: ::treesitter_types::Span,
7810 pub quoter: ::core::option::Option<QuoteQuoter>,
7811 pub children: ::core::option::Option<QuoteChildren<'tree>>,
7812}
7813impl<'tree> ::treesitter_types::FromNode<'tree> for Quote<'tree> {
7814 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7815 fn from_node(
7816 node: ::treesitter_types::tree_sitter::Node<'tree>,
7817 src: &'tree [u8],
7818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7819 debug_assert_eq!(node.kind(), "quote");
7820 Ok(Self {
7821 span: ::treesitter_types::Span::from(node),
7822 quoter: match node.child_by_field_name("quoter") {
7823 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7824 <QuoteQuoter as ::treesitter_types::FromNode>::from_node(child, src)
7825 })?),
7826 None => None,
7827 },
7828 children: {
7829 #[allow(clippy::suspicious_else_formatting)]
7830 let non_field_children = {
7831 let mut cursor = node.walk();
7832 let mut result = ::std::vec::Vec::new();
7833 if cursor.goto_first_child() {
7834 loop {
7835 if cursor.field_name().is_none()
7836 && cursor.node().is_named()
7837 && !cursor.node().is_extra()
7838 {
7839 result.push(cursor.node());
7840 }
7841 if !cursor.goto_next_sibling() {
7842 break;
7843 }
7844 }
7845 }
7846 result
7847 };
7848 match non_field_children.first() {
7849 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
7850 <QuoteChildren as ::treesitter_types::FromNode>::from_node(child, src)
7851 })?),
7852 None => None,
7853 }
7854 },
7855 })
7856 }
7857}
7858impl ::treesitter_types::Spanned for Quote<'_> {
7859 fn span(&self) -> ::treesitter_types::Span {
7860 self.span
7861 }
7862}
7863#[derive(Debug, Clone, PartialEq, Eq)]
7864pub struct QuotedDecls<'tree> {
7865 pub span: ::treesitter_types::Span,
7866 pub declaration: ::std::vec::Vec<Declaration<'tree>>,
7867}
7868impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedDecls<'tree> {
7869 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7870 fn from_node(
7871 node: ::treesitter_types::tree_sitter::Node<'tree>,
7872 src: &'tree [u8],
7873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7874 debug_assert_eq!(node.kind(), "quoted_decls");
7875 Ok(Self {
7876 span: ::treesitter_types::Span::from(node),
7877 declaration: {
7878 let mut cursor = node.walk();
7879 let mut items = ::std::vec::Vec::new();
7880 for child in node.children_by_field_name("declaration", &mut cursor) {
7881 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
7882 <Declaration as ::treesitter_types::FromNode>::from_node(child, src)
7883 })?);
7884 }
7885 items
7886 },
7887 })
7888 }
7889}
7890impl ::treesitter_types::Spanned for QuotedDecls<'_> {
7891 fn span(&self) -> ::treesitter_types::Span {
7892 self.span
7893 }
7894}
7895#[derive(Debug, Clone, PartialEq, Eq)]
7896pub struct QuotedExpression<'tree> {
7897 pub span: ::treesitter_types::Span,
7898 pub children: QuotedExpressionChildren<'tree>,
7899}
7900impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedExpression<'tree> {
7901 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7902 fn from_node(
7903 node: ::treesitter_types::tree_sitter::Node<'tree>,
7904 src: &'tree [u8],
7905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7906 debug_assert_eq!(node.kind(), "quoted_expression");
7907 Ok(Self {
7908 span: ::treesitter_types::Span::from(node),
7909 children: {
7910 #[allow(clippy::suspicious_else_formatting)]
7911 let non_field_children = {
7912 let mut cursor = node.walk();
7913 let mut result = ::std::vec::Vec::new();
7914 if cursor.goto_first_child() {
7915 loop {
7916 if cursor.field_name().is_none()
7917 && cursor.node().is_named()
7918 && !cursor.node().is_extra()
7919 {
7920 result.push(cursor.node());
7921 }
7922 if !cursor.goto_next_sibling() {
7923 break;
7924 }
7925 }
7926 }
7927 result
7928 };
7929 let child = if let Some(&c) = non_field_children.first() {
7930 c
7931 } else {
7932 let mut fallback_cursor = node.walk();
7933 let mut fallback_child = None;
7934 if fallback_cursor.goto_first_child() {
7935 loop {
7936 if fallback_cursor.field_name().is_none()
7937 && !fallback_cursor.node().is_extra()
7938 {
7939 let candidate = fallback_cursor.node();
7940 #[allow(clippy::needless_question_mark)]
7941 if (|| -> ::core::result::Result<
7942 _,
7943 ::treesitter_types::ParseError,
7944 > {
7945 let child = candidate;
7946 Ok(
7947 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7948 child,
7949 src,
7950 ))?,
7951 )
7952 })()
7953 .is_ok()
7954 {
7955 fallback_child = Some(candidate);
7956 break;
7957 }
7958 }
7959 if !fallback_cursor.goto_next_sibling() {
7960 break;
7961 }
7962 }
7963 }
7964 if fallback_child.is_none() {
7965 let mut cursor2 = node.walk();
7966 if cursor2.goto_first_child() {
7967 loop {
7968 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7969 let candidate = cursor2.node();
7970 #[allow(clippy::needless_question_mark)]
7971 if (|| -> ::core::result::Result<
7972 _,
7973 ::treesitter_types::ParseError,
7974 > {
7975 let child = candidate;
7976 Ok(
7977 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7978 child,
7979 src,
7980 ))?,
7981 )
7982 })()
7983 .is_ok()
7984 {
7985 fallback_child = Some(candidate);
7986 break;
7987 }
7988 }
7989 if !cursor2.goto_next_sibling() {
7990 break;
7991 }
7992 }
7993 }
7994 }
7995 fallback_child.ok_or_else(|| {
7996 ::treesitter_types::ParseError::missing_field("children", node)
7997 })?
7998 };
7999 ::treesitter_types::runtime::maybe_grow_stack(|| {
8000 <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(
8001 child, src,
8002 )
8003 })?
8004 },
8005 })
8006 }
8007}
8008impl ::treesitter_types::Spanned for QuotedExpression<'_> {
8009 fn span(&self) -> ::treesitter_types::Span {
8010 self.span
8011 }
8012}
8013#[derive(Debug, Clone, PartialEq, Eq)]
8014pub struct QuotedPattern<'tree> {
8015 pub span: ::treesitter_types::Span,
8016 pub children: QuotedPatternChildren<'tree>,
8017}
8018impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedPattern<'tree> {
8019 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8020 fn from_node(
8021 node: ::treesitter_types::tree_sitter::Node<'tree>,
8022 src: &'tree [u8],
8023 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8024 debug_assert_eq!(node.kind(), "quoted_pattern");
8025 Ok(Self {
8026 span: ::treesitter_types::Span::from(node),
8027 children: {
8028 #[allow(clippy::suspicious_else_formatting)]
8029 let non_field_children = {
8030 let mut cursor = node.walk();
8031 let mut result = ::std::vec::Vec::new();
8032 if cursor.goto_first_child() {
8033 loop {
8034 if cursor.field_name().is_none()
8035 && cursor.node().is_named()
8036 && !cursor.node().is_extra()
8037 {
8038 result.push(cursor.node());
8039 }
8040 if !cursor.goto_next_sibling() {
8041 break;
8042 }
8043 }
8044 }
8045 result
8046 };
8047 let child = if let Some(&c) = non_field_children.first() {
8048 c
8049 } else {
8050 let mut fallback_cursor = node.walk();
8051 let mut fallback_child = None;
8052 if fallback_cursor.goto_first_child() {
8053 loop {
8054 if fallback_cursor.field_name().is_none()
8055 && !fallback_cursor.node().is_extra()
8056 {
8057 let candidate = fallback_cursor.node();
8058 #[allow(clippy::needless_question_mark)]
8059 if (|| -> ::core::result::Result<
8060 _,
8061 ::treesitter_types::ParseError,
8062 > {
8063 let child = candidate;
8064 Ok(
8065 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedPatternChildren as ::treesitter_types::FromNode>::from_node(
8066 child,
8067 src,
8068 ))?,
8069 )
8070 })()
8071 .is_ok()
8072 {
8073 fallback_child = Some(candidate);
8074 break;
8075 }
8076 }
8077 if !fallback_cursor.goto_next_sibling() {
8078 break;
8079 }
8080 }
8081 }
8082 if fallback_child.is_none() {
8083 let mut cursor2 = node.walk();
8084 if cursor2.goto_first_child() {
8085 loop {
8086 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8087 let candidate = cursor2.node();
8088 #[allow(clippy::needless_question_mark)]
8089 if (|| -> ::core::result::Result<
8090 _,
8091 ::treesitter_types::ParseError,
8092 > {
8093 let child = candidate;
8094 Ok(
8095 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedPatternChildren as ::treesitter_types::FromNode>::from_node(
8096 child,
8097 src,
8098 ))?,
8099 )
8100 })()
8101 .is_ok()
8102 {
8103 fallback_child = Some(candidate);
8104 break;
8105 }
8106 }
8107 if !cursor2.goto_next_sibling() {
8108 break;
8109 }
8110 }
8111 }
8112 }
8113 fallback_child.ok_or_else(|| {
8114 ::treesitter_types::ParseError::missing_field("children", node)
8115 })?
8116 };
8117 ::treesitter_types::runtime::maybe_grow_stack(|| {
8118 <QuotedPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)
8119 })?
8120 },
8121 })
8122 }
8123}
8124impl ::treesitter_types::Spanned for QuotedPattern<'_> {
8125 fn span(&self) -> ::treesitter_types::Span {
8126 self.span
8127 }
8128}
8129#[derive(Debug, Clone, PartialEq, Eq)]
8130pub struct QuotedType<'tree> {
8131 pub span: ::treesitter_types::Span,
8132 pub children: QuotedTypeChildren<'tree>,
8133}
8134impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedType<'tree> {
8135 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8136 fn from_node(
8137 node: ::treesitter_types::tree_sitter::Node<'tree>,
8138 src: &'tree [u8],
8139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8140 debug_assert_eq!(node.kind(), "quoted_type");
8141 Ok(Self {
8142 span: ::treesitter_types::Span::from(node),
8143 children: {
8144 #[allow(clippy::suspicious_else_formatting)]
8145 let non_field_children = {
8146 let mut cursor = node.walk();
8147 let mut result = ::std::vec::Vec::new();
8148 if cursor.goto_first_child() {
8149 loop {
8150 if cursor.field_name().is_none()
8151 && cursor.node().is_named()
8152 && !cursor.node().is_extra()
8153 {
8154 result.push(cursor.node());
8155 }
8156 if !cursor.goto_next_sibling() {
8157 break;
8158 }
8159 }
8160 }
8161 result
8162 };
8163 let child = if let Some(&c) = non_field_children.first() {
8164 c
8165 } else {
8166 let mut fallback_cursor = node.walk();
8167 let mut fallback_child = None;
8168 if fallback_cursor.goto_first_child() {
8169 loop {
8170 if fallback_cursor.field_name().is_none()
8171 && !fallback_cursor.node().is_extra()
8172 {
8173 let candidate = fallback_cursor.node();
8174 #[allow(clippy::needless_question_mark)]
8175 if (|| -> ::core::result::Result<
8176 _,
8177 ::treesitter_types::ParseError,
8178 > {
8179 let child = candidate;
8180 Ok(
8181 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(
8182 child,
8183 src,
8184 ))?,
8185 )
8186 })()
8187 .is_ok()
8188 {
8189 fallback_child = Some(candidate);
8190 break;
8191 }
8192 }
8193 if !fallback_cursor.goto_next_sibling() {
8194 break;
8195 }
8196 }
8197 }
8198 if fallback_child.is_none() {
8199 let mut cursor2 = node.walk();
8200 if cursor2.goto_first_child() {
8201 loop {
8202 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8203 let candidate = cursor2.node();
8204 #[allow(clippy::needless_question_mark)]
8205 if (|| -> ::core::result::Result<
8206 _,
8207 ::treesitter_types::ParseError,
8208 > {
8209 let child = candidate;
8210 Ok(
8211 ::treesitter_types::runtime::maybe_grow_stack(|| <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(
8212 child,
8213 src,
8214 ))?,
8215 )
8216 })()
8217 .is_ok()
8218 {
8219 fallback_child = Some(candidate);
8220 break;
8221 }
8222 }
8223 if !cursor2.goto_next_sibling() {
8224 break;
8225 }
8226 }
8227 }
8228 }
8229 fallback_child.ok_or_else(|| {
8230 ::treesitter_types::ParseError::missing_field("children", node)
8231 })?
8232 };
8233 ::treesitter_types::runtime::maybe_grow_stack(|| {
8234 <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)
8235 })?
8236 },
8237 })
8238 }
8239}
8240impl ::treesitter_types::Spanned for QuotedType<'_> {
8241 fn span(&self) -> ::treesitter_types::Span {
8242 self.span
8243 }
8244}
8245#[derive(Debug, Clone, PartialEq, Eq)]
8246pub struct Quoter<'tree> {
8247 pub span: ::treesitter_types::Span,
8248 pub children: QuoterChildren<'tree>,
8249}
8250impl<'tree> ::treesitter_types::FromNode<'tree> for Quoter<'tree> {
8251 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8252 fn from_node(
8253 node: ::treesitter_types::tree_sitter::Node<'tree>,
8254 src: &'tree [u8],
8255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8256 debug_assert_eq!(node.kind(), "quoter");
8257 Ok(Self {
8258 span: ::treesitter_types::Span::from(node),
8259 children: {
8260 #[allow(clippy::suspicious_else_formatting)]
8261 let non_field_children = {
8262 let mut cursor = node.walk();
8263 let mut result = ::std::vec::Vec::new();
8264 if cursor.goto_first_child() {
8265 loop {
8266 if cursor.field_name().is_none()
8267 && cursor.node().is_named()
8268 && !cursor.node().is_extra()
8269 {
8270 result.push(cursor.node());
8271 }
8272 if !cursor.goto_next_sibling() {
8273 break;
8274 }
8275 }
8276 }
8277 result
8278 };
8279 let child = if let Some(&c) = non_field_children.first() {
8280 c
8281 } else {
8282 let mut fallback_cursor = node.walk();
8283 let mut fallback_child = None;
8284 if fallback_cursor.goto_first_child() {
8285 loop {
8286 if fallback_cursor.field_name().is_none()
8287 && !fallback_cursor.node().is_extra()
8288 {
8289 let candidate = fallback_cursor.node();
8290 #[allow(clippy::needless_question_mark)]
8291 if (|| -> ::core::result::Result<
8292 _,
8293 ::treesitter_types::ParseError,
8294 > {
8295 let child = candidate;
8296 Ok(
8297 ::treesitter_types::runtime::maybe_grow_stack(|| <QuoterChildren as ::treesitter_types::FromNode>::from_node(
8298 child,
8299 src,
8300 ))?,
8301 )
8302 })()
8303 .is_ok()
8304 {
8305 fallback_child = Some(candidate);
8306 break;
8307 }
8308 }
8309 if !fallback_cursor.goto_next_sibling() {
8310 break;
8311 }
8312 }
8313 }
8314 if fallback_child.is_none() {
8315 let mut cursor2 = node.walk();
8316 if cursor2.goto_first_child() {
8317 loop {
8318 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8319 let candidate = cursor2.node();
8320 #[allow(clippy::needless_question_mark)]
8321 if (|| -> ::core::result::Result<
8322 _,
8323 ::treesitter_types::ParseError,
8324 > {
8325 let child = candidate;
8326 Ok(
8327 ::treesitter_types::runtime::maybe_grow_stack(|| <QuoterChildren as ::treesitter_types::FromNode>::from_node(
8328 child,
8329 src,
8330 ))?,
8331 )
8332 })()
8333 .is_ok()
8334 {
8335 fallback_child = Some(candidate);
8336 break;
8337 }
8338 }
8339 if !cursor2.goto_next_sibling() {
8340 break;
8341 }
8342 }
8343 }
8344 }
8345 fallback_child.ok_or_else(|| {
8346 ::treesitter_types::ParseError::missing_field("children", node)
8347 })?
8348 };
8349 ::treesitter_types::runtime::maybe_grow_stack(|| {
8350 <QuoterChildren as ::treesitter_types::FromNode>::from_node(child, src)
8351 })?
8352 },
8353 })
8354 }
8355}
8356impl ::treesitter_types::Spanned for Quoter<'_> {
8357 fn span(&self) -> ::treesitter_types::Span {
8358 self.span
8359 }
8360}
8361#[derive(Debug, Clone, PartialEq, Eq)]
8362pub struct Rec<'tree> {
8363 pub span: ::treesitter_types::Span,
8364 pub statement: ::std::vec::Vec<Statement<'tree>>,
8365}
8366impl<'tree> ::treesitter_types::FromNode<'tree> for Rec<'tree> {
8367 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8368 fn from_node(
8369 node: ::treesitter_types::tree_sitter::Node<'tree>,
8370 src: &'tree [u8],
8371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8372 debug_assert_eq!(node.kind(), "rec");
8373 Ok(Self {
8374 span: ::treesitter_types::Span::from(node),
8375 statement: {
8376 let mut cursor = node.walk();
8377 let mut items = ::std::vec::Vec::new();
8378 for child in node.children_by_field_name("statement", &mut cursor) {
8379 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8380 <Statement as ::treesitter_types::FromNode>::from_node(child, src)
8381 })?);
8382 }
8383 items
8384 },
8385 })
8386 }
8387}
8388impl ::treesitter_types::Spanned for Rec<'_> {
8389 fn span(&self) -> ::treesitter_types::Span {
8390 self.span
8391 }
8392}
8393#[derive(Debug, Clone, PartialEq, Eq)]
8394pub struct Record<'tree> {
8395 pub span: ::treesitter_types::Span,
8396 pub arrow: ::std::vec::Vec<RecordArrow>,
8397 pub constructor: ::core::option::Option<Pattern<'tree>>,
8398 pub expression: ::core::option::Option<Expression<'tree>>,
8399 pub field: ::std::vec::Vec<RecordField<'tree>>,
8400 pub fields: ::core::option::Option<Fields<'tree>>,
8401 pub name: ::core::option::Option<Constructor<'tree>>,
8402 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
8403}
8404impl<'tree> ::treesitter_types::FromNode<'tree> for Record<'tree> {
8405 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8406 fn from_node(
8407 node: ::treesitter_types::tree_sitter::Node<'tree>,
8408 src: &'tree [u8],
8409 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8410 debug_assert_eq!(node.kind(), "record");
8411 Ok(Self {
8412 span: ::treesitter_types::Span::from(node),
8413 arrow: {
8414 let mut cursor = node.walk();
8415 let mut items = ::std::vec::Vec::new();
8416 for child in node.children_by_field_name("arrow", &mut cursor) {
8417 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8418 <RecordArrow as ::treesitter_types::FromNode>::from_node(child, src)
8419 })?);
8420 }
8421 items
8422 },
8423 constructor: match node.child_by_field_name("constructor") {
8424 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8425 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8426 })?),
8427 None => None,
8428 },
8429 expression: match node.child_by_field_name("expression") {
8430 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8431 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8432 })?),
8433 None => None,
8434 },
8435 field: {
8436 let mut cursor = node.walk();
8437 let mut items = ::std::vec::Vec::new();
8438 for child in node.children_by_field_name("field", &mut cursor) {
8439 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8440 <RecordField as ::treesitter_types::FromNode>::from_node(child, src)
8441 })?);
8442 }
8443 items
8444 },
8445 fields: match node.child_by_field_name("fields") {
8446 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8447 <Fields as ::treesitter_types::FromNode>::from_node(child, src)
8448 })?),
8449 None => None,
8450 },
8451 name: match node.child_by_field_name("name") {
8452 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8453 <Constructor as ::treesitter_types::FromNode>::from_node(child, src)
8454 })?),
8455 None => None,
8456 },
8457 r#type: match node.child_by_field_name("type") {
8458 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8459 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
8460 })?),
8461 None => None,
8462 },
8463 })
8464 }
8465}
8466impl ::treesitter_types::Spanned for Record<'_> {
8467 fn span(&self) -> ::treesitter_types::Span {
8468 self.span
8469 }
8470}
8471#[derive(Debug, Clone, PartialEq, Eq)]
8472pub struct RightSection<'tree> {
8473 pub span: ::treesitter_types::Span,
8474 pub right_operand: Expression<'tree>,
8475 pub children: RightSectionChildren<'tree>,
8476}
8477impl<'tree> ::treesitter_types::FromNode<'tree> for RightSection<'tree> {
8478 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8479 fn from_node(
8480 node: ::treesitter_types::tree_sitter::Node<'tree>,
8481 src: &'tree [u8],
8482 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8483 debug_assert_eq!(node.kind(), "right_section");
8484 Ok(Self {
8485 span: ::treesitter_types::Span::from(node),
8486 right_operand: {
8487 let child = node.child_by_field_name("right_operand").ok_or_else(|| {
8488 ::treesitter_types::ParseError::missing_field("right_operand", node)
8489 })?;
8490 ::treesitter_types::runtime::maybe_grow_stack(|| {
8491 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8492 })?
8493 },
8494 children: {
8495 #[allow(clippy::suspicious_else_formatting)]
8496 let non_field_children = {
8497 let mut cursor = node.walk();
8498 let mut result = ::std::vec::Vec::new();
8499 if cursor.goto_first_child() {
8500 loop {
8501 if cursor.field_name().is_none()
8502 && cursor.node().is_named()
8503 && !cursor.node().is_extra()
8504 {
8505 result.push(cursor.node());
8506 }
8507 if !cursor.goto_next_sibling() {
8508 break;
8509 }
8510 }
8511 }
8512 result
8513 };
8514 let child = if let Some(&c) = non_field_children.first() {
8515 c
8516 } else {
8517 let mut fallback_cursor = node.walk();
8518 let mut fallback_child = None;
8519 if fallback_cursor.goto_first_child() {
8520 loop {
8521 if fallback_cursor.field_name().is_none()
8522 && !fallback_cursor.node().is_extra()
8523 {
8524 let candidate = fallback_cursor.node();
8525 #[allow(clippy::needless_question_mark)]
8526 if (|| -> ::core::result::Result<
8527 _,
8528 ::treesitter_types::ParseError,
8529 > {
8530 let child = candidate;
8531 Ok(
8532 ::treesitter_types::runtime::maybe_grow_stack(|| <RightSectionChildren as ::treesitter_types::FromNode>::from_node(
8533 child,
8534 src,
8535 ))?,
8536 )
8537 })()
8538 .is_ok()
8539 {
8540 fallback_child = Some(candidate);
8541 break;
8542 }
8543 }
8544 if !fallback_cursor.goto_next_sibling() {
8545 break;
8546 }
8547 }
8548 }
8549 if fallback_child.is_none() {
8550 let mut cursor2 = node.walk();
8551 if cursor2.goto_first_child() {
8552 loop {
8553 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8554 let candidate = cursor2.node();
8555 #[allow(clippy::needless_question_mark)]
8556 if (|| -> ::core::result::Result<
8557 _,
8558 ::treesitter_types::ParseError,
8559 > {
8560 let child = candidate;
8561 Ok(
8562 ::treesitter_types::runtime::maybe_grow_stack(|| <RightSectionChildren as ::treesitter_types::FromNode>::from_node(
8563 child,
8564 src,
8565 ))?,
8566 )
8567 })()
8568 .is_ok()
8569 {
8570 fallback_child = Some(candidate);
8571 break;
8572 }
8573 }
8574 if !cursor2.goto_next_sibling() {
8575 break;
8576 }
8577 }
8578 }
8579 }
8580 fallback_child.ok_or_else(|| {
8581 ::treesitter_types::ParseError::missing_field("children", node)
8582 })?
8583 };
8584 ::treesitter_types::runtime::maybe_grow_stack(|| {
8585 <RightSectionChildren as ::treesitter_types::FromNode>::from_node(child, src)
8586 })?
8587 },
8588 })
8589 }
8590}
8591impl ::treesitter_types::Spanned for RightSection<'_> {
8592 fn span(&self) -> ::treesitter_types::Span {
8593 self.span
8594 }
8595}
8596#[derive(Debug, Clone, PartialEq, Eq)]
8597pub struct RoleAnnotation<'tree> {
8598 pub span: ::treesitter_types::Span,
8599 pub role: ::std::vec::Vec<TypeRole<'tree>>,
8600 pub r#type: RoleAnnotationType<'tree>,
8601}
8602impl<'tree> ::treesitter_types::FromNode<'tree> for RoleAnnotation<'tree> {
8603 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8604 fn from_node(
8605 node: ::treesitter_types::tree_sitter::Node<'tree>,
8606 src: &'tree [u8],
8607 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8608 debug_assert_eq!(node.kind(), "role_annotation");
8609 Ok(Self {
8610 span: ::treesitter_types::Span::from(node),
8611 role: {
8612 let mut cursor = node.walk();
8613 let mut items = ::std::vec::Vec::new();
8614 for child in node.children_by_field_name("role", &mut cursor) {
8615 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
8616 <TypeRole as ::treesitter_types::FromNode>::from_node(child, src)
8617 })?);
8618 }
8619 items
8620 },
8621 r#type: {
8622 let child = node
8623 .child_by_field_name("type")
8624 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8625 ::treesitter_types::runtime::maybe_grow_stack(|| {
8626 <RoleAnnotationType as ::treesitter_types::FromNode>::from_node(child, src)
8627 })?
8628 },
8629 })
8630 }
8631}
8632impl ::treesitter_types::Spanned for RoleAnnotation<'_> {
8633 fn span(&self) -> ::treesitter_types::Span {
8634 self.span
8635 }
8636}
8637#[derive(Debug, Clone, PartialEq, Eq)]
8638pub struct Signature<'tree> {
8639 pub span: ::treesitter_types::Span,
8640 pub constraint: ::core::option::Option<Constraints<'tree>>,
8641 pub expression: ::core::option::Option<Expression<'tree>>,
8642 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
8643 pub name: ::core::option::Option<SignatureName<'tree>>,
8644 pub names: ::core::option::Option<BindingList<'tree>>,
8645 pub pattern: ::core::option::Option<Pattern<'tree>>,
8646 pub synonym: ::core::option::Option<SignatureSynonym<'tree>>,
8647 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
8648}
8649impl<'tree> ::treesitter_types::FromNode<'tree> for Signature<'tree> {
8650 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8651 fn from_node(
8652 node: ::treesitter_types::tree_sitter::Node<'tree>,
8653 src: &'tree [u8],
8654 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8655 debug_assert_eq!(node.kind(), "signature");
8656 Ok(Self {
8657 span: ::treesitter_types::Span::from(node),
8658 constraint: match node.child_by_field_name("constraint") {
8659 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8660 <Constraints as ::treesitter_types::FromNode>::from_node(child, src)
8661 })?),
8662 None => None,
8663 },
8664 expression: match node.child_by_field_name("expression") {
8665 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8666 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
8667 })?),
8668 None => None,
8669 },
8670 kind: match node.child_by_field_name("kind") {
8671 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8672 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
8673 })?),
8674 None => None,
8675 },
8676 name: match node.child_by_field_name("name") {
8677 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8678 <SignatureName as ::treesitter_types::FromNode>::from_node(child, src)
8679 })?),
8680 None => None,
8681 },
8682 names: match node.child_by_field_name("names") {
8683 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8684 <BindingList as ::treesitter_types::FromNode>::from_node(child, src)
8685 })?),
8686 None => None,
8687 },
8688 pattern: match node.child_by_field_name("pattern") {
8689 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8690 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8691 })?),
8692 None => None,
8693 },
8694 synonym: match node.child_by_field_name("synonym") {
8695 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8696 <SignatureSynonym as ::treesitter_types::FromNode>::from_node(child, src)
8697 })?),
8698 None => None,
8699 },
8700 r#type: match node.child_by_field_name("type") {
8701 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8702 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
8703 })?),
8704 None => None,
8705 },
8706 })
8707 }
8708}
8709impl ::treesitter_types::Spanned for Signature<'_> {
8710 fn span(&self) -> ::treesitter_types::Span {
8711 self.span
8712 }
8713}
8714#[derive(Debug, Clone, PartialEq, Eq)]
8715pub struct Special<'tree> {
8716 pub span: ::treesitter_types::Span,
8717 pub children: SpecialChildren<'tree>,
8718}
8719impl<'tree> ::treesitter_types::FromNode<'tree> for Special<'tree> {
8720 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8721 fn from_node(
8722 node: ::treesitter_types::tree_sitter::Node<'tree>,
8723 src: &'tree [u8],
8724 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8725 debug_assert_eq!(node.kind(), "special");
8726 Ok(Self {
8727 span: ::treesitter_types::Span::from(node),
8728 children: {
8729 #[allow(clippy::suspicious_else_formatting)]
8730 let non_field_children = {
8731 let mut cursor = node.walk();
8732 let mut result = ::std::vec::Vec::new();
8733 if cursor.goto_first_child() {
8734 loop {
8735 if cursor.field_name().is_none()
8736 && cursor.node().is_named()
8737 && !cursor.node().is_extra()
8738 {
8739 result.push(cursor.node());
8740 }
8741 if !cursor.goto_next_sibling() {
8742 break;
8743 }
8744 }
8745 }
8746 result
8747 };
8748 let child = if let Some(&c) = non_field_children.first() {
8749 c
8750 } else {
8751 let mut fallback_cursor = node.walk();
8752 let mut fallback_child = None;
8753 if fallback_cursor.goto_first_child() {
8754 loop {
8755 if fallback_cursor.field_name().is_none()
8756 && !fallback_cursor.node().is_extra()
8757 {
8758 let candidate = fallback_cursor.node();
8759 #[allow(clippy::needless_question_mark)]
8760 if (|| -> ::core::result::Result<
8761 _,
8762 ::treesitter_types::ParseError,
8763 > {
8764 let child = candidate;
8765 Ok(
8766 ::treesitter_types::runtime::maybe_grow_stack(|| <SpecialChildren as ::treesitter_types::FromNode>::from_node(
8767 child,
8768 src,
8769 ))?,
8770 )
8771 })()
8772 .is_ok()
8773 {
8774 fallback_child = Some(candidate);
8775 break;
8776 }
8777 }
8778 if !fallback_cursor.goto_next_sibling() {
8779 break;
8780 }
8781 }
8782 }
8783 if fallback_child.is_none() {
8784 let mut cursor2 = node.walk();
8785 if cursor2.goto_first_child() {
8786 loop {
8787 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8788 let candidate = cursor2.node();
8789 #[allow(clippy::needless_question_mark)]
8790 if (|| -> ::core::result::Result<
8791 _,
8792 ::treesitter_types::ParseError,
8793 > {
8794 let child = candidate;
8795 Ok(
8796 ::treesitter_types::runtime::maybe_grow_stack(|| <SpecialChildren as ::treesitter_types::FromNode>::from_node(
8797 child,
8798 src,
8799 ))?,
8800 )
8801 })()
8802 .is_ok()
8803 {
8804 fallback_child = Some(candidate);
8805 break;
8806 }
8807 }
8808 if !cursor2.goto_next_sibling() {
8809 break;
8810 }
8811 }
8812 }
8813 }
8814 fallback_child.ok_or_else(|| {
8815 ::treesitter_types::ParseError::missing_field("children", node)
8816 })?
8817 };
8818 ::treesitter_types::runtime::maybe_grow_stack(|| {
8819 <SpecialChildren as ::treesitter_types::FromNode>::from_node(child, src)
8820 })?
8821 },
8822 })
8823 }
8824}
8825impl ::treesitter_types::Spanned for Special<'_> {
8826 fn span(&self) -> ::treesitter_types::Span {
8827 self.span
8828 }
8829}
8830#[derive(Debug, Clone, PartialEq, Eq)]
8831pub struct Splice<'tree> {
8832 pub span: ::treesitter_types::Span,
8833 pub expression: SpliceExpression<'tree>,
8834}
8835impl<'tree> ::treesitter_types::FromNode<'tree> for Splice<'tree> {
8836 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8837 fn from_node(
8838 node: ::treesitter_types::tree_sitter::Node<'tree>,
8839 src: &'tree [u8],
8840 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8841 debug_assert_eq!(node.kind(), "splice");
8842 Ok(Self {
8843 span: ::treesitter_types::Span::from(node),
8844 expression: {
8845 let child = node.child_by_field_name("expression").ok_or_else(|| {
8846 ::treesitter_types::ParseError::missing_field("expression", node)
8847 })?;
8848 ::treesitter_types::runtime::maybe_grow_stack(|| {
8849 <SpliceExpression as ::treesitter_types::FromNode>::from_node(child, src)
8850 })?
8851 },
8852 })
8853 }
8854}
8855impl ::treesitter_types::Spanned for Splice<'_> {
8856 fn span(&self) -> ::treesitter_types::Span {
8857 self.span
8858 }
8859}
8860#[derive(Debug, Clone, PartialEq, Eq)]
8861pub struct Star<'tree> {
8862 pub span: ::treesitter_types::Span,
8863 text: &'tree str,
8864}
8865impl<'tree> ::treesitter_types::FromNode<'tree> for Star<'tree> {
8866 fn from_node(
8867 node: ::treesitter_types::tree_sitter::Node<'tree>,
8868 src: &'tree [u8],
8869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8870 debug_assert_eq!(node.kind(), "star");
8871 Ok(Self {
8872 span: ::treesitter_types::Span::from(node),
8873 text: node.utf8_text(src)?,
8874 })
8875 }
8876}
8877impl<'tree> ::treesitter_types::LeafNode<'tree> for Star<'tree> {
8878 fn text(&self) -> &'tree str {
8879 self.text
8880 }
8881}
8882impl ::treesitter_types::Spanned for Star<'_> {
8883 fn span(&self) -> ::treesitter_types::Span {
8884 self.span
8885 }
8886}
8887#[derive(Debug, Clone, PartialEq, Eq)]
8888pub struct Strict<'tree> {
8889 pub span: ::treesitter_types::Span,
8890 pub pattern: Pattern<'tree>,
8891}
8892impl<'tree> ::treesitter_types::FromNode<'tree> for Strict<'tree> {
8893 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8894 fn from_node(
8895 node: ::treesitter_types::tree_sitter::Node<'tree>,
8896 src: &'tree [u8],
8897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8898 debug_assert_eq!(node.kind(), "strict");
8899 Ok(Self {
8900 span: ::treesitter_types::Span::from(node),
8901 pattern: {
8902 let child = node.child_by_field_name("pattern").ok_or_else(|| {
8903 ::treesitter_types::ParseError::missing_field("pattern", node)
8904 })?;
8905 ::treesitter_types::runtime::maybe_grow_stack(|| {
8906 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)
8907 })?
8908 },
8909 })
8910 }
8911}
8912impl ::treesitter_types::Spanned for Strict<'_> {
8913 fn span(&self) -> ::treesitter_types::Span {
8914 self.span
8915 }
8916}
8917#[derive(Debug, Clone, PartialEq, Eq)]
8918pub struct StrictField<'tree> {
8919 pub span: ::treesitter_types::Span,
8920 pub r#type: Type<'tree>,
8921}
8922impl<'tree> ::treesitter_types::FromNode<'tree> for StrictField<'tree> {
8923 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8924 fn from_node(
8925 node: ::treesitter_types::tree_sitter::Node<'tree>,
8926 src: &'tree [u8],
8927 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8928 debug_assert_eq!(node.kind(), "strict_field");
8929 Ok(Self {
8930 span: ::treesitter_types::Span::from(node),
8931 r#type: {
8932 let child = node
8933 .child_by_field_name("type")
8934 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8935 ::treesitter_types::runtime::maybe_grow_stack(|| {
8936 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8937 })?
8938 },
8939 })
8940 }
8941}
8942impl ::treesitter_types::Spanned for StrictField<'_> {
8943 fn span(&self) -> ::treesitter_types::Span {
8944 self.span
8945 }
8946}
8947#[derive(Debug, Clone, PartialEq, Eq)]
8948pub struct ThQuotedName<'tree> {
8949 pub span: ::treesitter_types::Span,
8950 pub name: ::core::option::Option<ThQuotedNameName<'tree>>,
8951 pub r#type: ::core::option::Option<Type<'tree>>,
8952}
8953impl<'tree> ::treesitter_types::FromNode<'tree> for ThQuotedName<'tree> {
8954 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8955 fn from_node(
8956 node: ::treesitter_types::tree_sitter::Node<'tree>,
8957 src: &'tree [u8],
8958 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8959 debug_assert_eq!(node.kind(), "th_quoted_name");
8960 Ok(Self {
8961 span: ::treesitter_types::Span::from(node),
8962 name: match node.child_by_field_name("name") {
8963 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8964 <ThQuotedNameName as ::treesitter_types::FromNode>::from_node(child, src)
8965 })?),
8966 None => None,
8967 },
8968 r#type: match node.child_by_field_name("type") {
8969 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
8970 <Type as ::treesitter_types::FromNode>::from_node(child, src)
8971 })?),
8972 None => None,
8973 },
8974 })
8975 }
8976}
8977impl ::treesitter_types::Spanned for ThQuotedName<'_> {
8978 fn span(&self) -> ::treesitter_types::Span {
8979 self.span
8980 }
8981}
8982#[derive(Debug, Clone, PartialEq, Eq)]
8983pub struct TopSplice<'tree> {
8984 pub span: ::treesitter_types::Span,
8985 pub children: Expression<'tree>,
8986}
8987impl<'tree> ::treesitter_types::FromNode<'tree> for TopSplice<'tree> {
8988 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8989 fn from_node(
8990 node: ::treesitter_types::tree_sitter::Node<'tree>,
8991 src: &'tree [u8],
8992 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8993 debug_assert_eq!(node.kind(), "top_splice");
8994 Ok(Self {
8995 span: ::treesitter_types::Span::from(node),
8996 children: {
8997 #[allow(clippy::suspicious_else_formatting)]
8998 let non_field_children = {
8999 let mut cursor = node.walk();
9000 let mut result = ::std::vec::Vec::new();
9001 if cursor.goto_first_child() {
9002 loop {
9003 if cursor.field_name().is_none()
9004 && cursor.node().is_named()
9005 && !cursor.node().is_extra()
9006 {
9007 result.push(cursor.node());
9008 }
9009 if !cursor.goto_next_sibling() {
9010 break;
9011 }
9012 }
9013 }
9014 result
9015 };
9016 let child = if let Some(&c) = non_field_children.first() {
9017 c
9018 } else {
9019 let mut fallback_cursor = node.walk();
9020 let mut fallback_child = None;
9021 if fallback_cursor.goto_first_child() {
9022 loop {
9023 if fallback_cursor.field_name().is_none()
9024 && !fallback_cursor.node().is_extra()
9025 {
9026 let candidate = fallback_cursor.node();
9027 #[allow(clippy::needless_question_mark)]
9028 if (|| -> ::core::result::Result<
9029 _,
9030 ::treesitter_types::ParseError,
9031 > {
9032 let child = candidate;
9033 Ok(
9034 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9035 child,
9036 src,
9037 ))?,
9038 )
9039 })()
9040 .is_ok()
9041 {
9042 fallback_child = Some(candidate);
9043 break;
9044 }
9045 }
9046 if !fallback_cursor.goto_next_sibling() {
9047 break;
9048 }
9049 }
9050 }
9051 if fallback_child.is_none() {
9052 let mut cursor2 = node.walk();
9053 if cursor2.goto_first_child() {
9054 loop {
9055 if cursor2.node().is_named() && !cursor2.node().is_extra() {
9056 let candidate = cursor2.node();
9057 #[allow(clippy::needless_question_mark)]
9058 if (|| -> ::core::result::Result<
9059 _,
9060 ::treesitter_types::ParseError,
9061 > {
9062 let child = candidate;
9063 Ok(
9064 ::treesitter_types::runtime::maybe_grow_stack(|| <Expression as ::treesitter_types::FromNode>::from_node(
9065 child,
9066 src,
9067 ))?,
9068 )
9069 })()
9070 .is_ok()
9071 {
9072 fallback_child = Some(candidate);
9073 break;
9074 }
9075 }
9076 if !cursor2.goto_next_sibling() {
9077 break;
9078 }
9079 }
9080 }
9081 }
9082 fallback_child.ok_or_else(|| {
9083 ::treesitter_types::ParseError::missing_field("children", node)
9084 })?
9085 };
9086 ::treesitter_types::runtime::maybe_grow_stack(|| {
9087 <Expression as ::treesitter_types::FromNode>::from_node(child, src)
9088 })?
9089 },
9090 })
9091 }
9092}
9093impl ::treesitter_types::Spanned for TopSplice<'_> {
9094 fn span(&self) -> ::treesitter_types::Span {
9095 self.span
9096 }
9097}
9098#[derive(Debug, Clone, PartialEq, Eq)]
9099pub struct Transform<'tree> {
9100 pub span: ::treesitter_types::Span,
9101 pub key: ::core::option::Option<TransformKey<'tree>>,
9102 pub transformation: TransformTransformation<'tree>,
9103}
9104impl<'tree> ::treesitter_types::FromNode<'tree> for Transform<'tree> {
9105 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9106 fn from_node(
9107 node: ::treesitter_types::tree_sitter::Node<'tree>,
9108 src: &'tree [u8],
9109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9110 debug_assert_eq!(node.kind(), "transform");
9111 Ok(Self {
9112 span: ::treesitter_types::Span::from(node),
9113 key: match node.child_by_field_name("key") {
9114 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9115 <TransformKey as ::treesitter_types::FromNode>::from_node(child, src)
9116 })?),
9117 None => None,
9118 },
9119 transformation: {
9120 let child = node.child_by_field_name("transformation").ok_or_else(|| {
9121 ::treesitter_types::ParseError::missing_field("transformation", node)
9122 })?;
9123 ::treesitter_types::runtime::maybe_grow_stack(|| {
9124 <TransformTransformation as ::treesitter_types::FromNode>::from_node(child, src)
9125 })?
9126 },
9127 })
9128 }
9129}
9130impl ::treesitter_types::Spanned for Transform<'_> {
9131 fn span(&self) -> ::treesitter_types::Span {
9132 self.span
9133 }
9134}
9135#[derive(Debug, Clone, PartialEq, Eq)]
9136pub struct Tuple<'tree> {
9137 pub span: ::treesitter_types::Span,
9138 pub element: ::std::vec::Vec<TupleElement<'tree>>,
9139 pub children: ::std::vec::Vec<Constraints<'tree>>,
9140}
9141impl<'tree> ::treesitter_types::FromNode<'tree> for Tuple<'tree> {
9142 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9143 fn from_node(
9144 node: ::treesitter_types::tree_sitter::Node<'tree>,
9145 src: &'tree [u8],
9146 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9147 debug_assert_eq!(node.kind(), "tuple");
9148 Ok(Self {
9149 span: ::treesitter_types::Span::from(node),
9150 element: {
9151 let mut cursor = node.walk();
9152 let mut items = ::std::vec::Vec::new();
9153 for child in node.children_by_field_name("element", &mut cursor) {
9154 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9155 <TupleElement as ::treesitter_types::FromNode>::from_node(child, src)
9156 })?);
9157 }
9158 items
9159 },
9160 children: {
9161 #[allow(clippy::suspicious_else_formatting)]
9162 let non_field_children = {
9163 let mut cursor = node.walk();
9164 let mut result = ::std::vec::Vec::new();
9165 if cursor.goto_first_child() {
9166 loop {
9167 if cursor.field_name().is_none()
9168 && cursor.node().is_named()
9169 && !cursor.node().is_extra()
9170 {
9171 result.push(cursor.node());
9172 }
9173 if !cursor.goto_next_sibling() {
9174 break;
9175 }
9176 }
9177 }
9178 result
9179 };
9180 let mut items = ::std::vec::Vec::new();
9181 for child in non_field_children {
9182 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9183 <Constraints as ::treesitter_types::FromNode>::from_node(child, src)
9184 })?);
9185 }
9186 items
9187 },
9188 })
9189 }
9190}
9191impl ::treesitter_types::Spanned for Tuple<'_> {
9192 fn span(&self) -> ::treesitter_types::Span {
9193 self.span
9194 }
9195}
9196#[derive(Debug, Clone, PartialEq, Eq)]
9197pub struct TypeApplication<'tree> {
9198 pub span: ::treesitter_types::Span,
9199 pub r#type: Type<'tree>,
9200}
9201impl<'tree> ::treesitter_types::FromNode<'tree> for TypeApplication<'tree> {
9202 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9203 fn from_node(
9204 node: ::treesitter_types::tree_sitter::Node<'tree>,
9205 src: &'tree [u8],
9206 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9207 debug_assert_eq!(node.kind(), "type_application");
9208 Ok(Self {
9209 span: ::treesitter_types::Span::from(node),
9210 r#type: {
9211 let child = node
9212 .child_by_field_name("type")
9213 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9214 ::treesitter_types::runtime::maybe_grow_stack(|| {
9215 <Type as ::treesitter_types::FromNode>::from_node(child, src)
9216 })?
9217 },
9218 })
9219 }
9220}
9221impl ::treesitter_types::Spanned for TypeApplication<'_> {
9222 fn span(&self) -> ::treesitter_types::Span {
9223 self.span
9224 }
9225}
9226#[derive(Debug, Clone, PartialEq, Eq)]
9227pub struct TypeBinder<'tree> {
9228 pub span: ::treesitter_types::Span,
9229 pub r#type: Type<'tree>,
9230}
9231impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBinder<'tree> {
9232 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9233 fn from_node(
9234 node: ::treesitter_types::tree_sitter::Node<'tree>,
9235 src: &'tree [u8],
9236 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9237 debug_assert_eq!(node.kind(), "type_binder");
9238 Ok(Self {
9239 span: ::treesitter_types::Span::from(node),
9240 r#type: {
9241 let child = node
9242 .child_by_field_name("type")
9243 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9244 ::treesitter_types::runtime::maybe_grow_stack(|| {
9245 <Type as ::treesitter_types::FromNode>::from_node(child, src)
9246 })?
9247 },
9248 })
9249 }
9250}
9251impl ::treesitter_types::Spanned for TypeBinder<'_> {
9252 fn span(&self) -> ::treesitter_types::Span {
9253 self.span
9254 }
9255}
9256#[derive(Debug, Clone, PartialEq, Eq)]
9257pub struct TypeFamily<'tree> {
9258 pub span: ::treesitter_types::Span,
9259 pub closed_family: ::core::option::Option<TypeFamilyClosedFamily<'tree>>,
9260 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
9261 pub name: ::core::option::Option<TypeFamilyName<'tree>>,
9262 pub patterns: ::core::option::Option<TypeParams<'tree>>,
9263 pub children: ::std::vec::Vec<TypeFamilyChildren<'tree>>,
9264}
9265impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamily<'tree> {
9266 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9267 fn from_node(
9268 node: ::treesitter_types::tree_sitter::Node<'tree>,
9269 src: &'tree [u8],
9270 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9271 debug_assert_eq!(node.kind(), "type_family");
9272 Ok(Self {
9273 span: ::treesitter_types::Span::from(node),
9274 closed_family: match node.child_by_field_name("closed_family") {
9275 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9276 <TypeFamilyClosedFamily as ::treesitter_types::FromNode>::from_node(child, src)
9277 })?),
9278 None => None,
9279 },
9280 kind: match node.child_by_field_name("kind") {
9281 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9282 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
9283 })?),
9284 None => None,
9285 },
9286 name: match node.child_by_field_name("name") {
9287 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9288 <TypeFamilyName as ::treesitter_types::FromNode>::from_node(child, src)
9289 })?),
9290 None => None,
9291 },
9292 patterns: match node.child_by_field_name("patterns") {
9293 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9294 <TypeParams as ::treesitter_types::FromNode>::from_node(child, src)
9295 })?),
9296 None => None,
9297 },
9298 children: {
9299 #[allow(clippy::suspicious_else_formatting)]
9300 let non_field_children = {
9301 let mut cursor = node.walk();
9302 let mut result = ::std::vec::Vec::new();
9303 if cursor.goto_first_child() {
9304 loop {
9305 if cursor.field_name().is_none()
9306 && cursor.node().is_named()
9307 && !cursor.node().is_extra()
9308 {
9309 result.push(cursor.node());
9310 }
9311 if !cursor.goto_next_sibling() {
9312 break;
9313 }
9314 }
9315 }
9316 result
9317 };
9318 let mut items = ::std::vec::Vec::new();
9319 for child in non_field_children {
9320 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9321 <TypeFamilyChildren as ::treesitter_types::FromNode>::from_node(child, src)
9322 })?);
9323 }
9324 items
9325 },
9326 })
9327 }
9328}
9329impl ::treesitter_types::Spanned for TypeFamily<'_> {
9330 fn span(&self) -> ::treesitter_types::Span {
9331 self.span
9332 }
9333}
9334#[derive(Debug, Clone, PartialEq, Eq)]
9335pub struct TypeFamilyInjectivity<'tree> {
9336 pub span: ::treesitter_types::Span,
9337 pub determined: ::std::vec::Vec<Variable<'tree>>,
9338 pub result: Variable<'tree>,
9339}
9340impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyInjectivity<'tree> {
9341 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9342 fn from_node(
9343 node: ::treesitter_types::tree_sitter::Node<'tree>,
9344 src: &'tree [u8],
9345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9346 debug_assert_eq!(node.kind(), "type_family_injectivity");
9347 Ok(Self {
9348 span: ::treesitter_types::Span::from(node),
9349 determined: {
9350 let mut cursor = node.walk();
9351 let mut items = ::std::vec::Vec::new();
9352 for child in node.children_by_field_name("determined", &mut cursor) {
9353 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9354 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
9355 })?);
9356 }
9357 items
9358 },
9359 result: {
9360 let child = node
9361 .child_by_field_name("result")
9362 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
9363 ::treesitter_types::runtime::maybe_grow_stack(|| {
9364 <Variable as ::treesitter_types::FromNode>::from_node(child, src)
9365 })?
9366 },
9367 })
9368 }
9369}
9370impl ::treesitter_types::Spanned for TypeFamilyInjectivity<'_> {
9371 fn span(&self) -> ::treesitter_types::Span {
9372 self.span
9373 }
9374}
9375#[derive(Debug, Clone, PartialEq, Eq)]
9376pub struct TypeFamilyResult<'tree> {
9377 pub span: ::treesitter_types::Span,
9378 pub result: QuantifiedType<'tree>,
9379}
9380impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyResult<'tree> {
9381 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9382 fn from_node(
9383 node: ::treesitter_types::tree_sitter::Node<'tree>,
9384 src: &'tree [u8],
9385 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9386 debug_assert_eq!(node.kind(), "type_family_result");
9387 Ok(Self {
9388 span: ::treesitter_types::Span::from(node),
9389 result: {
9390 let child = node
9391 .child_by_field_name("result")
9392 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
9393 ::treesitter_types::runtime::maybe_grow_stack(|| {
9394 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
9395 })?
9396 },
9397 })
9398 }
9399}
9400impl ::treesitter_types::Spanned for TypeFamilyResult<'_> {
9401 fn span(&self) -> ::treesitter_types::Span {
9402 self.span
9403 }
9404}
9405#[derive(Debug, Clone, PartialEq, Eq)]
9406pub struct TypeInstance<'tree> {
9407 pub span: ::treesitter_types::Span,
9408 pub forall: ::core::option::Option<TypeInstanceForall<'tree>>,
9409 pub name: ::core::option::Option<TypeInstanceName<'tree>>,
9410 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
9411 pub children: ::std::vec::Vec<TypeInstanceChildren<'tree>>,
9412}
9413impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstance<'tree> {
9414 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9415 fn from_node(
9416 node: ::treesitter_types::tree_sitter::Node<'tree>,
9417 src: &'tree [u8],
9418 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9419 debug_assert_eq!(node.kind(), "type_instance");
9420 Ok(Self {
9421 span: ::treesitter_types::Span::from(node),
9422 forall: match node.child_by_field_name("forall") {
9423 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9424 <TypeInstanceForall as ::treesitter_types::FromNode>::from_node(child, src)
9425 })?),
9426 None => None,
9427 },
9428 name: match node.child_by_field_name("name") {
9429 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9430 <TypeInstanceName as ::treesitter_types::FromNode>::from_node(child, src)
9431 })?),
9432 None => None,
9433 },
9434 patterns: match node.child_by_field_name("patterns") {
9435 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9436 <TypePatterns as ::treesitter_types::FromNode>::from_node(child, src)
9437 })?),
9438 None => None,
9439 },
9440 children: {
9441 #[allow(clippy::suspicious_else_formatting)]
9442 let non_field_children = {
9443 let mut cursor = node.walk();
9444 let mut result = ::std::vec::Vec::new();
9445 if cursor.goto_first_child() {
9446 loop {
9447 if cursor.field_name().is_none()
9448 && cursor.node().is_named()
9449 && !cursor.node().is_extra()
9450 {
9451 result.push(cursor.node());
9452 }
9453 if !cursor.goto_next_sibling() {
9454 break;
9455 }
9456 }
9457 }
9458 result
9459 };
9460 let mut items = ::std::vec::Vec::new();
9461 for child in non_field_children {
9462 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9463 <TypeInstanceChildren as ::treesitter_types::FromNode>::from_node(
9464 child, src,
9465 )
9466 })?);
9467 }
9468 items
9469 },
9470 })
9471 }
9472}
9473impl ::treesitter_types::Spanned for TypeInstance<'_> {
9474 fn span(&self) -> ::treesitter_types::Span {
9475 self.span
9476 }
9477}
9478#[derive(Debug, Clone, PartialEq, Eq)]
9479pub struct TypeParams<'tree> {
9480 pub span: ::treesitter_types::Span,
9481 pub children: ::std::vec::Vec<TypeParam<'tree>>,
9482}
9483impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParams<'tree> {
9484 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9485 fn from_node(
9486 node: ::treesitter_types::tree_sitter::Node<'tree>,
9487 src: &'tree [u8],
9488 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9489 debug_assert_eq!(node.kind(), "type_params");
9490 Ok(Self {
9491 span: ::treesitter_types::Span::from(node),
9492 children: {
9493 #[allow(clippy::suspicious_else_formatting)]
9494 let non_field_children = {
9495 let mut cursor = node.walk();
9496 let mut result = ::std::vec::Vec::new();
9497 if cursor.goto_first_child() {
9498 loop {
9499 if cursor.field_name().is_none()
9500 && cursor.node().is_named()
9501 && !cursor.node().is_extra()
9502 {
9503 result.push(cursor.node());
9504 }
9505 if !cursor.goto_next_sibling() {
9506 break;
9507 }
9508 }
9509 }
9510 result
9511 };
9512 let mut items = ::std::vec::Vec::new();
9513 for child in non_field_children {
9514 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9515 <TypeParam as ::treesitter_types::FromNode>::from_node(child, src)
9516 })?);
9517 }
9518 items
9519 },
9520 })
9521 }
9522}
9523impl ::treesitter_types::Spanned for TypeParams<'_> {
9524 fn span(&self) -> ::treesitter_types::Span {
9525 self.span
9526 }
9527}
9528#[derive(Debug, Clone, PartialEq, Eq)]
9529pub struct TypePatterns<'tree> {
9530 pub span: ::treesitter_types::Span,
9531 pub children: ::std::vec::Vec<TypePatternsChildren<'tree>>,
9532}
9533impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatterns<'tree> {
9534 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9535 fn from_node(
9536 node: ::treesitter_types::tree_sitter::Node<'tree>,
9537 src: &'tree [u8],
9538 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9539 debug_assert_eq!(node.kind(), "type_patterns");
9540 Ok(Self {
9541 span: ::treesitter_types::Span::from(node),
9542 children: {
9543 #[allow(clippy::suspicious_else_formatting)]
9544 let non_field_children = {
9545 let mut cursor = node.walk();
9546 let mut result = ::std::vec::Vec::new();
9547 if cursor.goto_first_child() {
9548 loop {
9549 if cursor.field_name().is_none()
9550 && cursor.node().is_named()
9551 && !cursor.node().is_extra()
9552 {
9553 result.push(cursor.node());
9554 }
9555 if !cursor.goto_next_sibling() {
9556 break;
9557 }
9558 }
9559 }
9560 result
9561 };
9562 let mut items = ::std::vec::Vec::new();
9563 for child in non_field_children {
9564 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9565 <TypePatternsChildren as ::treesitter_types::FromNode>::from_node(
9566 child, src,
9567 )
9568 })?);
9569 }
9570 items
9571 },
9572 })
9573 }
9574}
9575impl ::treesitter_types::Spanned for TypePatterns<'_> {
9576 fn span(&self) -> ::treesitter_types::Span {
9577 self.span
9578 }
9579}
9580#[derive(Debug, Clone, PartialEq, Eq)]
9581pub struct TypeRole<'tree> {
9582 pub span: ::treesitter_types::Span,
9583 text: &'tree str,
9584}
9585impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRole<'tree> {
9586 fn from_node(
9587 node: ::treesitter_types::tree_sitter::Node<'tree>,
9588 src: &'tree [u8],
9589 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9590 debug_assert_eq!(node.kind(), "type_role");
9591 Ok(Self {
9592 span: ::treesitter_types::Span::from(node),
9593 text: node.utf8_text(src)?,
9594 })
9595 }
9596}
9597impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeRole<'tree> {
9598 fn text(&self) -> &'tree str {
9599 self.text
9600 }
9601}
9602impl ::treesitter_types::Spanned for TypeRole<'_> {
9603 fn span(&self) -> ::treesitter_types::Span {
9604 self.span
9605 }
9606}
9607#[derive(Debug, Clone, PartialEq, Eq)]
9608pub struct TypeSynomym<'tree> {
9609 pub span: ::treesitter_types::Span,
9610 pub name: ::core::option::Option<TypeSynomymName<'tree>>,
9611 pub patterns: ::core::option::Option<TypeParams<'tree>>,
9612 pub r#type: TypeSynomymType<'tree>,
9613 pub children: ::core::option::Option<TypeSynomymChildren<'tree>>,
9614}
9615impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomym<'tree> {
9616 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9617 fn from_node(
9618 node: ::treesitter_types::tree_sitter::Node<'tree>,
9619 src: &'tree [u8],
9620 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9621 debug_assert_eq!(node.kind(), "type_synomym");
9622 Ok(Self {
9623 span: ::treesitter_types::Span::from(node),
9624 name: match node.child_by_field_name("name") {
9625 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9626 <TypeSynomymName as ::treesitter_types::FromNode>::from_node(child, src)
9627 })?),
9628 None => None,
9629 },
9630 patterns: match node.child_by_field_name("patterns") {
9631 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9632 <TypeParams as ::treesitter_types::FromNode>::from_node(child, src)
9633 })?),
9634 None => None,
9635 },
9636 r#type: {
9637 let child = node
9638 .child_by_field_name("type")
9639 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9640 ::treesitter_types::runtime::maybe_grow_stack(|| {
9641 <TypeSynomymType as ::treesitter_types::FromNode>::from_node(child, src)
9642 })?
9643 },
9644 children: {
9645 #[allow(clippy::suspicious_else_formatting)]
9646 let non_field_children = {
9647 let mut cursor = node.walk();
9648 let mut result = ::std::vec::Vec::new();
9649 if cursor.goto_first_child() {
9650 loop {
9651 if cursor.field_name().is_none()
9652 && cursor.node().is_named()
9653 && !cursor.node().is_extra()
9654 {
9655 result.push(cursor.node());
9656 }
9657 if !cursor.goto_next_sibling() {
9658 break;
9659 }
9660 }
9661 }
9662 result
9663 };
9664 match non_field_children.first() {
9665 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9666 <TypeSynomymChildren as ::treesitter_types::FromNode>::from_node(child, src)
9667 })?),
9668 None => None,
9669 }
9670 },
9671 })
9672 }
9673}
9674impl ::treesitter_types::Spanned for TypeSynomym<'_> {
9675 fn span(&self) -> ::treesitter_types::Span {
9676 self.span
9677 }
9678}
9679#[derive(Debug, Clone, PartialEq, Eq)]
9680pub struct TypedQuote<'tree> {
9681 pub span: ::treesitter_types::Span,
9682 pub children: ::core::option::Option<QuotedExpression<'tree>>,
9683}
9684impl<'tree> ::treesitter_types::FromNode<'tree> for TypedQuote<'tree> {
9685 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9686 fn from_node(
9687 node: ::treesitter_types::tree_sitter::Node<'tree>,
9688 src: &'tree [u8],
9689 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9690 debug_assert_eq!(node.kind(), "typed_quote");
9691 Ok(Self {
9692 span: ::treesitter_types::Span::from(node),
9693 children: {
9694 #[allow(clippy::suspicious_else_formatting)]
9695 let non_field_children = {
9696 let mut cursor = node.walk();
9697 let mut result = ::std::vec::Vec::new();
9698 if cursor.goto_first_child() {
9699 loop {
9700 if cursor.field_name().is_none()
9701 && cursor.node().is_named()
9702 && !cursor.node().is_extra()
9703 {
9704 result.push(cursor.node());
9705 }
9706 if !cursor.goto_next_sibling() {
9707 break;
9708 }
9709 }
9710 }
9711 result
9712 };
9713 match non_field_children.first() {
9714 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
9715 <QuotedExpression as ::treesitter_types::FromNode>::from_node(child, src)
9716 })?),
9717 None => None,
9718 }
9719 },
9720 })
9721 }
9722}
9723impl ::treesitter_types::Spanned for TypedQuote<'_> {
9724 fn span(&self) -> ::treesitter_types::Span {
9725 self.span
9726 }
9727}
9728#[derive(Debug, Clone, PartialEq, Eq)]
9729pub struct UnboxedSum<'tree> {
9730 pub span: ::treesitter_types::Span,
9731 pub element: ::std::vec::Vec<UnboxedSumElement<'tree>>,
9732}
9733impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedSum<'tree> {
9734 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9735 fn from_node(
9736 node: ::treesitter_types::tree_sitter::Node<'tree>,
9737 src: &'tree [u8],
9738 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9739 debug_assert_eq!(node.kind(), "unboxed_sum");
9740 Ok(Self {
9741 span: ::treesitter_types::Span::from(node),
9742 element: {
9743 let mut cursor = node.walk();
9744 let mut items = ::std::vec::Vec::new();
9745 for child in node.children_by_field_name("element", &mut cursor) {
9746 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9747 <UnboxedSumElement as ::treesitter_types::FromNode>::from_node(child, src)
9748 })?);
9749 }
9750 items
9751 },
9752 })
9753 }
9754}
9755impl ::treesitter_types::Spanned for UnboxedSum<'_> {
9756 fn span(&self) -> ::treesitter_types::Span {
9757 self.span
9758 }
9759}
9760#[derive(Debug, Clone, PartialEq, Eq)]
9761pub struct UnboxedTuple<'tree> {
9762 pub span: ::treesitter_types::Span,
9763 pub element: ::std::vec::Vec<UnboxedTupleElement<'tree>>,
9764}
9765impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedTuple<'tree> {
9766 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9767 fn from_node(
9768 node: ::treesitter_types::tree_sitter::Node<'tree>,
9769 src: &'tree [u8],
9770 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9771 debug_assert_eq!(node.kind(), "unboxed_tuple");
9772 Ok(Self {
9773 span: ::treesitter_types::Span::from(node),
9774 element: {
9775 let mut cursor = node.walk();
9776 let mut items = ::std::vec::Vec::new();
9777 for child in node.children_by_field_name("element", &mut cursor) {
9778 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
9779 <UnboxedTupleElement as ::treesitter_types::FromNode>::from_node(child, src)
9780 })?);
9781 }
9782 items
9783 },
9784 })
9785 }
9786}
9787impl ::treesitter_types::Spanned for UnboxedTuple<'_> {
9788 fn span(&self) -> ::treesitter_types::Span {
9789 self.span
9790 }
9791}
9792#[derive(Debug, Clone, PartialEq, Eq)]
9793pub struct UnboxedUnit<'tree> {
9794 pub span: ::treesitter_types::Span,
9795 text: &'tree str,
9796}
9797impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedUnit<'tree> {
9798 fn from_node(
9799 node: ::treesitter_types::tree_sitter::Node<'tree>,
9800 src: &'tree [u8],
9801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9802 debug_assert_eq!(node.kind(), "unboxed_unit");
9803 Ok(Self {
9804 span: ::treesitter_types::Span::from(node),
9805 text: node.utf8_text(src)?,
9806 })
9807 }
9808}
9809impl<'tree> ::treesitter_types::LeafNode<'tree> for UnboxedUnit<'tree> {
9810 fn text(&self) -> &'tree str {
9811 self.text
9812 }
9813}
9814impl ::treesitter_types::Spanned for UnboxedUnit<'_> {
9815 fn span(&self) -> ::treesitter_types::Span {
9816 self.span
9817 }
9818}
9819#[derive(Debug, Clone, PartialEq, Eq)]
9820pub struct Unit<'tree> {
9821 pub span: ::treesitter_types::Span,
9822 text: &'tree str,
9823}
9824impl<'tree> ::treesitter_types::FromNode<'tree> for Unit<'tree> {
9825 fn from_node(
9826 node: ::treesitter_types::tree_sitter::Node<'tree>,
9827 src: &'tree [u8],
9828 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9829 debug_assert_eq!(node.kind(), "unit");
9830 Ok(Self {
9831 span: ::treesitter_types::Span::from(node),
9832 text: node.utf8_text(src)?,
9833 })
9834 }
9835}
9836impl<'tree> ::treesitter_types::LeafNode<'tree> for Unit<'tree> {
9837 fn text(&self) -> &'tree str {
9838 self.text
9839 }
9840}
9841impl ::treesitter_types::Spanned for Unit<'_> {
9842 fn span(&self) -> ::treesitter_types::Span {
9843 self.span
9844 }
9845}
9846#[derive(Debug, Clone, PartialEq, Eq)]
9847pub struct Via<'tree> {
9848 pub span: ::treesitter_types::Span,
9849 pub r#type: QuantifiedType<'tree>,
9850}
9851impl<'tree> ::treesitter_types::FromNode<'tree> for Via<'tree> {
9852 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9853 fn from_node(
9854 node: ::treesitter_types::tree_sitter::Node<'tree>,
9855 src: &'tree [u8],
9856 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9857 debug_assert_eq!(node.kind(), "via");
9858 Ok(Self {
9859 span: ::treesitter_types::Span::from(node),
9860 r#type: {
9861 let child = node
9862 .child_by_field_name("type")
9863 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9864 ::treesitter_types::runtime::maybe_grow_stack(|| {
9865 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)
9866 })?
9867 },
9868 })
9869 }
9870}
9871impl ::treesitter_types::Spanned for Via<'_> {
9872 fn span(&self) -> ::treesitter_types::Span {
9873 self.span
9874 }
9875}
9876#[derive(Debug, Clone, PartialEq, Eq)]
9877pub struct ViewPattern<'tree> {
9878 pub span: ::treesitter_types::Span,
9879 pub expression: ViewPatternExpression<'tree>,
9880 pub pattern: ViewPatternPattern<'tree>,
9881}
9882impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPattern<'tree> {
9883 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9884 fn from_node(
9885 node: ::treesitter_types::tree_sitter::Node<'tree>,
9886 src: &'tree [u8],
9887 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9888 debug_assert_eq!(node.kind(), "view_pattern");
9889 Ok(Self {
9890 span: ::treesitter_types::Span::from(node),
9891 expression: {
9892 let child = node.child_by_field_name("expression").ok_or_else(|| {
9893 ::treesitter_types::ParseError::missing_field("expression", node)
9894 })?;
9895 ::treesitter_types::runtime::maybe_grow_stack(|| {
9896 <ViewPatternExpression as ::treesitter_types::FromNode>::from_node(child, src)
9897 })?
9898 },
9899 pattern: {
9900 let child = node.child_by_field_name("pattern").ok_or_else(|| {
9901 ::treesitter_types::ParseError::missing_field("pattern", node)
9902 })?;
9903 ::treesitter_types::runtime::maybe_grow_stack(|| {
9904 <ViewPatternPattern as ::treesitter_types::FromNode>::from_node(child, src)
9905 })?
9906 },
9907 })
9908 }
9909}
9910impl ::treesitter_types::Spanned for ViewPattern<'_> {
9911 fn span(&self) -> ::treesitter_types::Span {
9912 self.span
9913 }
9914}
9915#[derive(Debug, Clone, PartialEq, Eq)]
9916pub struct Wildcard<'tree> {
9917 pub span: ::treesitter_types::Span,
9918 text: &'tree str,
9919}
9920impl<'tree> ::treesitter_types::FromNode<'tree> for Wildcard<'tree> {
9921 fn from_node(
9922 node: ::treesitter_types::tree_sitter::Node<'tree>,
9923 src: &'tree [u8],
9924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9925 debug_assert_eq!(node.kind(), "wildcard");
9926 Ok(Self {
9927 span: ::treesitter_types::Span::from(node),
9928 text: node.utf8_text(src)?,
9929 })
9930 }
9931}
9932impl<'tree> ::treesitter_types::LeafNode<'tree> for Wildcard<'tree> {
9933 fn text(&self) -> &'tree str {
9934 self.text
9935 }
9936}
9937impl ::treesitter_types::Spanned for Wildcard<'_> {
9938 fn span(&self) -> ::treesitter_types::Span {
9939 self.span
9940 }
9941}
9942#[derive(Debug, Clone, PartialEq, Eq)]
9943pub struct AllNames<'tree> {
9944 pub span: ::treesitter_types::Span,
9945 text: &'tree str,
9946}
9947impl<'tree> ::treesitter_types::FromNode<'tree> for AllNames<'tree> {
9948 fn from_node(
9949 node: ::treesitter_types::tree_sitter::Node<'tree>,
9950 src: &'tree [u8],
9951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9952 debug_assert_eq!(node.kind(), "all_names");
9953 Ok(Self {
9954 span: ::treesitter_types::Span::from(node),
9955 text: node.utf8_text(src)?,
9956 })
9957 }
9958}
9959impl<'tree> ::treesitter_types::LeafNode<'tree> for AllNames<'tree> {
9960 fn text(&self) -> &'tree str {
9961 self.text
9962 }
9963}
9964impl ::treesitter_types::Spanned for AllNames<'_> {
9965 fn span(&self) -> ::treesitter_types::Span {
9966 self.span
9967 }
9968}
9969#[derive(Debug, Clone, PartialEq, Eq)]
9970pub struct CallingConvention<'tree> {
9971 pub span: ::treesitter_types::Span,
9972 text: &'tree str,
9973}
9974impl<'tree> ::treesitter_types::FromNode<'tree> for CallingConvention<'tree> {
9975 fn from_node(
9976 node: ::treesitter_types::tree_sitter::Node<'tree>,
9977 src: &'tree [u8],
9978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9979 debug_assert_eq!(node.kind(), "calling_convention");
9980 Ok(Self {
9981 span: ::treesitter_types::Span::from(node),
9982 text: node.utf8_text(src)?,
9983 })
9984 }
9985}
9986impl<'tree> ::treesitter_types::LeafNode<'tree> for CallingConvention<'tree> {
9987 fn text(&self) -> &'tree str {
9988 self.text
9989 }
9990}
9991impl ::treesitter_types::Spanned for CallingConvention<'_> {
9992 fn span(&self) -> ::treesitter_types::Span {
9993 self.span
9994 }
9995}
9996#[derive(Debug, Clone, PartialEq, Eq)]
9997pub struct Char<'tree> {
9998 pub span: ::treesitter_types::Span,
9999 text: &'tree str,
10000}
10001impl<'tree> ::treesitter_types::FromNode<'tree> for Char<'tree> {
10002 fn from_node(
10003 node: ::treesitter_types::tree_sitter::Node<'tree>,
10004 src: &'tree [u8],
10005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10006 debug_assert_eq!(node.kind(), "char");
10007 Ok(Self {
10008 span: ::treesitter_types::Span::from(node),
10009 text: node.utf8_text(src)?,
10010 })
10011 }
10012}
10013impl<'tree> ::treesitter_types::LeafNode<'tree> for Char<'tree> {
10014 fn text(&self) -> &'tree str {
10015 self.text
10016 }
10017}
10018impl ::treesitter_types::Spanned for Char<'_> {
10019 fn span(&self) -> ::treesitter_types::Span {
10020 self.span
10021 }
10022}
10023#[derive(Debug, Clone, PartialEq, Eq)]
10024pub struct Comment<'tree> {
10025 pub span: ::treesitter_types::Span,
10026 text: &'tree str,
10027}
10028impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
10029 fn from_node(
10030 node: ::treesitter_types::tree_sitter::Node<'tree>,
10031 src: &'tree [u8],
10032 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10033 debug_assert_eq!(node.kind(), "comment");
10034 Ok(Self {
10035 span: ::treesitter_types::Span::from(node),
10036 text: node.utf8_text(src)?,
10037 })
10038 }
10039}
10040impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
10041 fn text(&self) -> &'tree str {
10042 self.text
10043 }
10044}
10045impl ::treesitter_types::Spanned for Comment<'_> {
10046 fn span(&self) -> ::treesitter_types::Span {
10047 self.span
10048 }
10049}
10050#[derive(Debug, Clone, PartialEq, Eq)]
10051pub struct Constructor<'tree> {
10052 pub span: ::treesitter_types::Span,
10053 text: &'tree str,
10054}
10055impl<'tree> ::treesitter_types::FromNode<'tree> for Constructor<'tree> {
10056 fn from_node(
10057 node: ::treesitter_types::tree_sitter::Node<'tree>,
10058 src: &'tree [u8],
10059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10060 debug_assert_eq!(node.kind(), "constructor");
10061 Ok(Self {
10062 span: ::treesitter_types::Span::from(node),
10063 text: node.utf8_text(src)?,
10064 })
10065 }
10066}
10067impl<'tree> ::treesitter_types::LeafNode<'tree> for Constructor<'tree> {
10068 fn text(&self) -> &'tree str {
10069 self.text
10070 }
10071}
10072impl ::treesitter_types::Spanned for Constructor<'_> {
10073 fn span(&self) -> ::treesitter_types::Span {
10074 self.span
10075 }
10076}
10077#[derive(Debug, Clone, PartialEq, Eq)]
10078pub struct Cpp<'tree> {
10079 pub span: ::treesitter_types::Span,
10080 text: &'tree str,
10081}
10082impl<'tree> ::treesitter_types::FromNode<'tree> for Cpp<'tree> {
10083 fn from_node(
10084 node: ::treesitter_types::tree_sitter::Node<'tree>,
10085 src: &'tree [u8],
10086 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10087 debug_assert_eq!(node.kind(), "cpp");
10088 Ok(Self {
10089 span: ::treesitter_types::Span::from(node),
10090 text: node.utf8_text(src)?,
10091 })
10092 }
10093}
10094impl<'tree> ::treesitter_types::LeafNode<'tree> for Cpp<'tree> {
10095 fn text(&self) -> &'tree str {
10096 self.text
10097 }
10098}
10099impl ::treesitter_types::Spanned for Cpp<'_> {
10100 fn span(&self) -> ::treesitter_types::Span {
10101 self.span
10102 }
10103}
10104#[derive(Debug, Clone, PartialEq, Eq)]
10105pub struct Float<'tree> {
10106 pub span: ::treesitter_types::Span,
10107 text: &'tree str,
10108}
10109impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
10110 fn from_node(
10111 node: ::treesitter_types::tree_sitter::Node<'tree>,
10112 src: &'tree [u8],
10113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10114 debug_assert_eq!(node.kind(), "float");
10115 Ok(Self {
10116 span: ::treesitter_types::Span::from(node),
10117 text: node.utf8_text(src)?,
10118 })
10119 }
10120}
10121impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
10122 fn text(&self) -> &'tree str {
10123 self.text
10124 }
10125}
10126impl ::treesitter_types::Spanned for Float<'_> {
10127 fn span(&self) -> ::treesitter_types::Span {
10128 self.span
10129 }
10130}
10131#[derive(Debug, Clone, PartialEq, Eq)]
10132pub struct Haddock<'tree> {
10133 pub span: ::treesitter_types::Span,
10134 text: &'tree str,
10135}
10136impl<'tree> ::treesitter_types::FromNode<'tree> for Haddock<'tree> {
10137 fn from_node(
10138 node: ::treesitter_types::tree_sitter::Node<'tree>,
10139 src: &'tree [u8],
10140 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10141 debug_assert_eq!(node.kind(), "haddock");
10142 Ok(Self {
10143 span: ::treesitter_types::Span::from(node),
10144 text: node.utf8_text(src)?,
10145 })
10146 }
10147}
10148impl<'tree> ::treesitter_types::LeafNode<'tree> for Haddock<'tree> {
10149 fn text(&self) -> &'tree str {
10150 self.text
10151 }
10152}
10153impl ::treesitter_types::Spanned for Haddock<'_> {
10154 fn span(&self) -> ::treesitter_types::Span {
10155 self.span
10156 }
10157}
10158#[derive(Debug, Clone, PartialEq, Eq)]
10159pub struct ImplicitVariable<'tree> {
10160 pub span: ::treesitter_types::Span,
10161 text: &'tree str,
10162}
10163impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitVariable<'tree> {
10164 fn from_node(
10165 node: ::treesitter_types::tree_sitter::Node<'tree>,
10166 src: &'tree [u8],
10167 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10168 debug_assert_eq!(node.kind(), "implicit_variable");
10169 Ok(Self {
10170 span: ::treesitter_types::Span::from(node),
10171 text: node.utf8_text(src)?,
10172 })
10173 }
10174}
10175impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitVariable<'tree> {
10176 fn text(&self) -> &'tree str {
10177 self.text
10178 }
10179}
10180impl ::treesitter_types::Spanned for ImplicitVariable<'_> {
10181 fn span(&self) -> ::treesitter_types::Span {
10182 self.span
10183 }
10184}
10185#[derive(Debug, Clone, PartialEq, Eq)]
10186pub struct ImportPackage<'tree> {
10187 pub span: ::treesitter_types::Span,
10188 text: &'tree str,
10189}
10190impl<'tree> ::treesitter_types::FromNode<'tree> for ImportPackage<'tree> {
10191 fn from_node(
10192 node: ::treesitter_types::tree_sitter::Node<'tree>,
10193 src: &'tree [u8],
10194 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10195 debug_assert_eq!(node.kind(), "import_package");
10196 Ok(Self {
10197 span: ::treesitter_types::Span::from(node),
10198 text: node.utf8_text(src)?,
10199 })
10200 }
10201}
10202impl<'tree> ::treesitter_types::LeafNode<'tree> for ImportPackage<'tree> {
10203 fn text(&self) -> &'tree str {
10204 self.text
10205 }
10206}
10207impl ::treesitter_types::Spanned for ImportPackage<'_> {
10208 fn span(&self) -> ::treesitter_types::Span {
10209 self.span
10210 }
10211}
10212#[derive(Debug, Clone, PartialEq, Eq)]
10213pub struct Label<'tree> {
10214 pub span: ::treesitter_types::Span,
10215 text: &'tree str,
10216}
10217impl<'tree> ::treesitter_types::FromNode<'tree> for Label<'tree> {
10218 fn from_node(
10219 node: ::treesitter_types::tree_sitter::Node<'tree>,
10220 src: &'tree [u8],
10221 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10222 debug_assert_eq!(node.kind(), "label");
10223 Ok(Self {
10224 span: ::treesitter_types::Span::from(node),
10225 text: node.utf8_text(src)?,
10226 })
10227 }
10228}
10229impl<'tree> ::treesitter_types::LeafNode<'tree> for Label<'tree> {
10230 fn text(&self) -> &'tree str {
10231 self.text
10232 }
10233}
10234impl ::treesitter_types::Spanned for Label<'_> {
10235 fn span(&self) -> ::treesitter_types::Span {
10236 self.span
10237 }
10238}
10239#[derive(Debug, Clone, PartialEq, Eq)]
10240pub struct ModuleId<'tree> {
10241 pub span: ::treesitter_types::Span,
10242 text: &'tree str,
10243}
10244impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleId<'tree> {
10245 fn from_node(
10246 node: ::treesitter_types::tree_sitter::Node<'tree>,
10247 src: &'tree [u8],
10248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10249 debug_assert_eq!(node.kind(), "module_id");
10250 Ok(Self {
10251 span: ::treesitter_types::Span::from(node),
10252 text: node.utf8_text(src)?,
10253 })
10254 }
10255}
10256impl<'tree> ::treesitter_types::LeafNode<'tree> for ModuleId<'tree> {
10257 fn text(&self) -> &'tree str {
10258 self.text
10259 }
10260}
10261impl ::treesitter_types::Spanned for ModuleId<'_> {
10262 fn span(&self) -> ::treesitter_types::Span {
10263 self.span
10264 }
10265}
10266#[derive(Debug, Clone, PartialEq, Eq)]
10267pub struct Name<'tree> {
10268 pub span: ::treesitter_types::Span,
10269 text: &'tree str,
10270}
10271impl<'tree> ::treesitter_types::FromNode<'tree> for Name<'tree> {
10272 fn from_node(
10273 node: ::treesitter_types::tree_sitter::Node<'tree>,
10274 src: &'tree [u8],
10275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10276 debug_assert_eq!(node.kind(), "name");
10277 Ok(Self {
10278 span: ::treesitter_types::Span::from(node),
10279 text: node.utf8_text(src)?,
10280 })
10281 }
10282}
10283impl<'tree> ::treesitter_types::LeafNode<'tree> for Name<'tree> {
10284 fn text(&self) -> &'tree str {
10285 self.text
10286 }
10287}
10288impl ::treesitter_types::Spanned for Name<'_> {
10289 fn span(&self) -> ::treesitter_types::Span {
10290 self.span
10291 }
10292}
10293#[derive(Debug, Clone, PartialEq, Eq)]
10294pub struct Pragma<'tree> {
10295 pub span: ::treesitter_types::Span,
10296 text: &'tree str,
10297}
10298impl<'tree> ::treesitter_types::FromNode<'tree> for Pragma<'tree> {
10299 fn from_node(
10300 node: ::treesitter_types::tree_sitter::Node<'tree>,
10301 src: &'tree [u8],
10302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10303 debug_assert_eq!(node.kind(), "pragma");
10304 Ok(Self {
10305 span: ::treesitter_types::Span::from(node),
10306 text: node.utf8_text(src)?,
10307 })
10308 }
10309}
10310impl<'tree> ::treesitter_types::LeafNode<'tree> for Pragma<'tree> {
10311 fn text(&self) -> &'tree str {
10312 self.text
10313 }
10314}
10315impl ::treesitter_types::Spanned for Pragma<'_> {
10316 fn span(&self) -> ::treesitter_types::Span {
10317 self.span
10318 }
10319}
10320#[derive(Debug, Clone, PartialEq, Eq)]
10321pub struct QuasiquoteBody<'tree> {
10322 pub span: ::treesitter_types::Span,
10323 text: &'tree str,
10324}
10325impl<'tree> ::treesitter_types::FromNode<'tree> for QuasiquoteBody<'tree> {
10326 fn from_node(
10327 node: ::treesitter_types::tree_sitter::Node<'tree>,
10328 src: &'tree [u8],
10329 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10330 debug_assert_eq!(node.kind(), "quasiquote_body");
10331 Ok(Self {
10332 span: ::treesitter_types::Span::from(node),
10333 text: node.utf8_text(src)?,
10334 })
10335 }
10336}
10337impl<'tree> ::treesitter_types::LeafNode<'tree> for QuasiquoteBody<'tree> {
10338 fn text(&self) -> &'tree str {
10339 self.text
10340 }
10341}
10342impl ::treesitter_types::Spanned for QuasiquoteBody<'_> {
10343 fn span(&self) -> ::treesitter_types::Span {
10344 self.span
10345 }
10346}
10347#[derive(Debug, Clone, PartialEq, Eq)]
10348pub struct Safety<'tree> {
10349 pub span: ::treesitter_types::Span,
10350 text: &'tree str,
10351}
10352impl<'tree> ::treesitter_types::FromNode<'tree> for Safety<'tree> {
10353 fn from_node(
10354 node: ::treesitter_types::tree_sitter::Node<'tree>,
10355 src: &'tree [u8],
10356 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10357 debug_assert_eq!(node.kind(), "safety");
10358 Ok(Self {
10359 span: ::treesitter_types::Span::from(node),
10360 text: node.utf8_text(src)?,
10361 })
10362 }
10363}
10364impl<'tree> ::treesitter_types::LeafNode<'tree> for Safety<'tree> {
10365 fn text(&self) -> &'tree str {
10366 self.text
10367 }
10368}
10369impl ::treesitter_types::Spanned for Safety<'_> {
10370 fn span(&self) -> ::treesitter_types::Span {
10371 self.span
10372 }
10373}
10374#[derive(Debug, Clone, PartialEq, Eq)]
10375pub struct String<'tree> {
10376 pub span: ::treesitter_types::Span,
10377 text: &'tree str,
10378}
10379impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
10380 fn from_node(
10381 node: ::treesitter_types::tree_sitter::Node<'tree>,
10382 src: &'tree [u8],
10383 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10384 debug_assert_eq!(node.kind(), "string");
10385 Ok(Self {
10386 span: ::treesitter_types::Span::from(node),
10387 text: node.utf8_text(src)?,
10388 })
10389 }
10390}
10391impl<'tree> ::treesitter_types::LeafNode<'tree> for String<'tree> {
10392 fn text(&self) -> &'tree str {
10393 self.text
10394 }
10395}
10396impl ::treesitter_types::Spanned for String<'_> {
10397 fn span(&self) -> ::treesitter_types::Span {
10398 self.span
10399 }
10400}
10401#[derive(Debug, Clone, PartialEq, Eq)]
10402pub struct Variable<'tree> {
10403 pub span: ::treesitter_types::Span,
10404 text: &'tree str,
10405}
10406impl<'tree> ::treesitter_types::FromNode<'tree> for Variable<'tree> {
10407 fn from_node(
10408 node: ::treesitter_types::tree_sitter::Node<'tree>,
10409 src: &'tree [u8],
10410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10411 debug_assert_eq!(node.kind(), "variable");
10412 Ok(Self {
10413 span: ::treesitter_types::Span::from(node),
10414 text: node.utf8_text(src)?,
10415 })
10416 }
10417}
10418impl<'tree> ::treesitter_types::LeafNode<'tree> for Variable<'tree> {
10419 fn text(&self) -> &'tree str {
10420 self.text
10421 }
10422}
10423impl ::treesitter_types::Spanned for Variable<'_> {
10424 fn span(&self) -> ::treesitter_types::Span {
10425 self.span
10426 }
10427}
10428#[derive(Debug, Clone, PartialEq, Eq)]
10429pub enum AlternativePattern<'tree> {
10430 Pattern(::std::boxed::Box<Pattern<'tree>>),
10431 Signature(::std::boxed::Box<Signature<'tree>>),
10432}
10433impl<'tree> ::treesitter_types::FromNode<'tree> for AlternativePattern<'tree> {
10434 #[allow(clippy::collapsible_else_if)]
10435 fn from_node(
10436 node: ::treesitter_types::tree_sitter::Node<'tree>,
10437 src: &'tree [u8],
10438 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10439 match node.kind() {
10440 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10441 ::treesitter_types::runtime::maybe_grow_stack(|| {
10442 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10443 })?,
10444 ))),
10445 _other => {
10446 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10447 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10448 }) {
10449 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10450 } else {
10451 Err(::treesitter_types::ParseError::unexpected_kind(
10452 _other, node,
10453 ))
10454 }
10455 }
10456 }
10457 }
10458}
10459impl ::treesitter_types::Spanned for AlternativePattern<'_> {
10460 fn span(&self) -> ::treesitter_types::Span {
10461 match self {
10462 Self::Pattern(inner) => inner.span(),
10463 Self::Signature(inner) => inner.span(),
10464 }
10465 }
10466}
10467#[derive(Debug, Clone, PartialEq, Eq)]
10468pub enum ApplyArgument<'tree> {
10469 ExplicitType(::std::boxed::Box<ExplicitType<'tree>>),
10470 Expression(::std::boxed::Box<Expression<'tree>>),
10471 KindApplication(::std::boxed::Box<KindApplication<'tree>>),
10472 Pattern(::std::boxed::Box<Pattern<'tree>>),
10473 Type(::std::boxed::Box<Type<'tree>>),
10474 TypeApplication(::std::boxed::Box<TypeApplication<'tree>>),
10475 TypeBinder(::std::boxed::Box<TypeBinder<'tree>>),
10476}
10477impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyArgument<'tree> {
10478 #[allow(clippy::collapsible_else_if)]
10479 fn from_node(
10480 node: ::treesitter_types::tree_sitter::Node<'tree>,
10481 src: &'tree [u8],
10482 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10483 match node.kind() {
10484 "explicit_type" => Ok(Self::ExplicitType(::std::boxed::Box::new(
10485 ::treesitter_types::runtime::maybe_grow_stack(|| {
10486 <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)
10487 })?,
10488 ))),
10489 "kind_application" => Ok(Self::KindApplication(::std::boxed::Box::new(
10490 ::treesitter_types::runtime::maybe_grow_stack(|| {
10491 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)
10492 })?,
10493 ))),
10494 "type_application" => Ok(Self::TypeApplication(::std::boxed::Box::new(
10495 ::treesitter_types::runtime::maybe_grow_stack(|| {
10496 <TypeApplication as ::treesitter_types::FromNode>::from_node(node, src)
10497 })?,
10498 ))),
10499 "type_binder" => Ok(Self::TypeBinder(::std::boxed::Box::new(
10500 ::treesitter_types::runtime::maybe_grow_stack(|| {
10501 <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)
10502 })?,
10503 ))),
10504 _other => {
10505 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10506 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10507 }) {
10508 Ok(Self::Expression(::std::boxed::Box::new(v)))
10509 } else {
10510 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10511 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10512 }) {
10513 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10514 } else {
10515 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10516 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10517 }) {
10518 Ok(Self::Type(::std::boxed::Box::new(v)))
10519 } else {
10520 Err(::treesitter_types::ParseError::unexpected_kind(
10521 _other, node,
10522 ))
10523 }
10524 }
10525 }
10526 }
10527 }
10528 }
10529}
10530impl ::treesitter_types::Spanned for ApplyArgument<'_> {
10531 fn span(&self) -> ::treesitter_types::Span {
10532 match self {
10533 Self::ExplicitType(inner) => inner.span(),
10534 Self::Expression(inner) => inner.span(),
10535 Self::KindApplication(inner) => inner.span(),
10536 Self::Pattern(inner) => inner.span(),
10537 Self::Type(inner) => inner.span(),
10538 Self::TypeApplication(inner) => inner.span(),
10539 Self::TypeBinder(inner) => inner.span(),
10540 }
10541 }
10542}
10543#[derive(Debug, Clone, PartialEq, Eq)]
10544pub enum ApplyConstructor<'tree> {
10545 Constraint(::std::boxed::Box<Constraint<'tree>>),
10546 Type(::std::boxed::Box<Type<'tree>>),
10547}
10548impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyConstructor<'tree> {
10549 #[allow(clippy::collapsible_else_if)]
10550 fn from_node(
10551 node: ::treesitter_types::tree_sitter::Node<'tree>,
10552 src: &'tree [u8],
10553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10554 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10555 <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
10556 }) {
10557 Ok(Self::Constraint(::std::boxed::Box::new(v)))
10558 } else {
10559 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10560 <Type as ::treesitter_types::FromNode>::from_node(node, src)
10561 }) {
10562 Ok(Self::Type(::std::boxed::Box::new(v)))
10563 } else {
10564 Err(::treesitter_types::ParseError::unexpected_kind(
10565 node.kind(),
10566 node,
10567 ))
10568 }
10569 }
10570 }
10571}
10572impl ::treesitter_types::Spanned for ApplyConstructor<'_> {
10573 fn span(&self) -> ::treesitter_types::Span {
10574 match self {
10575 Self::Constraint(inner) => inner.span(),
10576 Self::Type(inner) => inner.span(),
10577 }
10578 }
10579}
10580#[derive(Debug, Clone, PartialEq, Eq)]
10581pub enum ApplyFunction<'tree> {
10582 Expression(::std::boxed::Box<Expression<'tree>>),
10583 Pattern(::std::boxed::Box<Pattern<'tree>>),
10584}
10585impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyFunction<'tree> {
10586 #[allow(clippy::collapsible_else_if)]
10587 fn from_node(
10588 node: ::treesitter_types::tree_sitter::Node<'tree>,
10589 src: &'tree [u8],
10590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10591 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10592 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10593 }) {
10594 Ok(Self::Expression(::std::boxed::Box::new(v)))
10595 } else {
10596 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10597 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10598 }) {
10599 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10600 } else {
10601 Err(::treesitter_types::ParseError::unexpected_kind(
10602 node.kind(),
10603 node,
10604 ))
10605 }
10606 }
10607 }
10608}
10609impl ::treesitter_types::Spanned for ApplyFunction<'_> {
10610 fn span(&self) -> ::treesitter_types::Span {
10611 match self {
10612 Self::Expression(inner) => inner.span(),
10613 Self::Pattern(inner) => inner.span(),
10614 }
10615 }
10616}
10617#[derive(Debug, Clone, PartialEq, Eq)]
10618pub enum ArithmeticSequenceFrom<'tree> {
10619 Expression(::std::boxed::Box<Expression<'tree>>),
10620 Signature(::std::boxed::Box<Signature<'tree>>),
10621}
10622impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceFrom<'tree> {
10623 #[allow(clippy::collapsible_else_if)]
10624 fn from_node(
10625 node: ::treesitter_types::tree_sitter::Node<'tree>,
10626 src: &'tree [u8],
10627 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10628 match node.kind() {
10629 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10630 ::treesitter_types::runtime::maybe_grow_stack(|| {
10631 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10632 })?,
10633 ))),
10634 _other => {
10635 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10636 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10637 }) {
10638 Ok(Self::Expression(::std::boxed::Box::new(v)))
10639 } else {
10640 Err(::treesitter_types::ParseError::unexpected_kind(
10641 _other, node,
10642 ))
10643 }
10644 }
10645 }
10646 }
10647}
10648impl ::treesitter_types::Spanned for ArithmeticSequenceFrom<'_> {
10649 fn span(&self) -> ::treesitter_types::Span {
10650 match self {
10651 Self::Expression(inner) => inner.span(),
10652 Self::Signature(inner) => inner.span(),
10653 }
10654 }
10655}
10656#[derive(Debug, Clone, PartialEq, Eq)]
10657pub enum ArithmeticSequenceStep<'tree> {
10658 Expression(::std::boxed::Box<Expression<'tree>>),
10659 Signature(::std::boxed::Box<Signature<'tree>>),
10660}
10661impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceStep<'tree> {
10662 #[allow(clippy::collapsible_else_if)]
10663 fn from_node(
10664 node: ::treesitter_types::tree_sitter::Node<'tree>,
10665 src: &'tree [u8],
10666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10667 match node.kind() {
10668 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10669 ::treesitter_types::runtime::maybe_grow_stack(|| {
10670 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10671 })?,
10672 ))),
10673 _other => {
10674 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10675 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10676 }) {
10677 Ok(Self::Expression(::std::boxed::Box::new(v)))
10678 } else {
10679 Err(::treesitter_types::ParseError::unexpected_kind(
10680 _other, node,
10681 ))
10682 }
10683 }
10684 }
10685 }
10686}
10687impl ::treesitter_types::Spanned for ArithmeticSequenceStep<'_> {
10688 fn span(&self) -> ::treesitter_types::Span {
10689 match self {
10690 Self::Expression(inner) => inner.span(),
10691 Self::Signature(inner) => inner.span(),
10692 }
10693 }
10694}
10695#[derive(Debug, Clone, PartialEq, Eq)]
10696pub enum ArithmeticSequenceTo<'tree> {
10697 Expression(::std::boxed::Box<Expression<'tree>>),
10698 Signature(::std::boxed::Box<Signature<'tree>>),
10699}
10700impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceTo<'tree> {
10701 #[allow(clippy::collapsible_else_if)]
10702 fn from_node(
10703 node: ::treesitter_types::tree_sitter::Node<'tree>,
10704 src: &'tree [u8],
10705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10706 match node.kind() {
10707 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10708 ::treesitter_types::runtime::maybe_grow_stack(|| {
10709 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10710 })?,
10711 ))),
10712 _other => {
10713 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10714 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10715 }) {
10716 Ok(Self::Expression(::std::boxed::Box::new(v)))
10717 } else {
10718 Err(::treesitter_types::ParseError::unexpected_kind(
10719 _other, node,
10720 ))
10721 }
10722 }
10723 }
10724 }
10725}
10726impl ::treesitter_types::Spanned for ArithmeticSequenceTo<'_> {
10727 fn span(&self) -> ::treesitter_types::Span {
10728 match self {
10729 Self::Expression(inner) => inner.span(),
10730 Self::Signature(inner) => inner.span(),
10731 }
10732 }
10733}
10734#[derive(Debug, Clone, PartialEq, Eq)]
10735pub enum AssociatedTypeNamespace {
10736 Type(::treesitter_types::Span),
10737}
10738impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedTypeNamespace {
10739 #[allow(clippy::collapsible_else_if)]
10740 fn from_node(
10741 node: ::treesitter_types::tree_sitter::Node<'tree>,
10742 _src: &'tree [u8],
10743 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10744 match node.kind() {
10745 "type" => Ok(Self::Type(::treesitter_types::Span::from(node))),
10746 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10747 }
10748 }
10749}
10750impl ::treesitter_types::Spanned for AssociatedTypeNamespace {
10751 fn span(&self) -> ::treesitter_types::Span {
10752 match self {
10753 Self::Type(span) => *span,
10754 }
10755 }
10756}
10757#[derive(Debug, Clone, PartialEq, Eq)]
10758pub enum AssociatedTypeType<'tree> {
10759 Name(::std::boxed::Box<Name<'tree>>),
10760 Qualified(::std::boxed::Box<Qualified<'tree>>),
10761}
10762impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedTypeType<'tree> {
10763 #[allow(clippy::collapsible_else_if)]
10764 fn from_node(
10765 node: ::treesitter_types::tree_sitter::Node<'tree>,
10766 src: &'tree [u8],
10767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10768 match node.kind() {
10769 "name" => Ok(Self::Name(::std::boxed::Box::new(
10770 ::treesitter_types::runtime::maybe_grow_stack(|| {
10771 <Name as ::treesitter_types::FromNode>::from_node(node, src)
10772 })?,
10773 ))),
10774 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
10775 ::treesitter_types::runtime::maybe_grow_stack(|| {
10776 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
10777 })?,
10778 ))),
10779 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10780 }
10781 }
10782}
10783impl ::treesitter_types::Spanned for AssociatedTypeType<'_> {
10784 fn span(&self) -> ::treesitter_types::Span {
10785 match self {
10786 Self::Name(inner) => inner.span(),
10787 Self::Qualified(inner) => inner.span(),
10788 }
10789 }
10790}
10791#[derive(Debug, Clone, PartialEq, Eq)]
10792pub enum BindArrow {
10793 LArrow(::treesitter_types::Span),
10794 X(::treesitter_types::Span),
10795}
10796impl<'tree> ::treesitter_types::FromNode<'tree> for BindArrow {
10797 #[allow(clippy::collapsible_else_if)]
10798 fn from_node(
10799 node: ::treesitter_types::tree_sitter::Node<'tree>,
10800 _src: &'tree [u8],
10801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10802 match node.kind() {
10803 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
10804 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
10805 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10806 }
10807 }
10808}
10809impl ::treesitter_types::Spanned for BindArrow {
10810 fn span(&self) -> ::treesitter_types::Span {
10811 match self {
10812 Self::LArrow(span) => *span,
10813 Self::X(span) => *span,
10814 }
10815 }
10816}
10817#[derive(Debug, Clone, PartialEq, Eq)]
10818pub enum BindExpression<'tree> {
10819 Expression(::std::boxed::Box<Expression<'tree>>),
10820 Signature(::std::boxed::Box<Signature<'tree>>),
10821}
10822impl<'tree> ::treesitter_types::FromNode<'tree> for BindExpression<'tree> {
10823 #[allow(clippy::collapsible_else_if)]
10824 fn from_node(
10825 node: ::treesitter_types::tree_sitter::Node<'tree>,
10826 src: &'tree [u8],
10827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10828 match node.kind() {
10829 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10830 ::treesitter_types::runtime::maybe_grow_stack(|| {
10831 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10832 })?,
10833 ))),
10834 _other => {
10835 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10836 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10837 }) {
10838 Ok(Self::Expression(::std::boxed::Box::new(v)))
10839 } else {
10840 Err(::treesitter_types::ParseError::unexpected_kind(
10841 _other, node,
10842 ))
10843 }
10844 }
10845 }
10846 }
10847}
10848impl ::treesitter_types::Spanned for BindExpression<'_> {
10849 fn span(&self) -> ::treesitter_types::Span {
10850 match self {
10851 Self::Expression(inner) => inner.span(),
10852 Self::Signature(inner) => inner.span(),
10853 }
10854 }
10855}
10856#[derive(Debug, Clone, PartialEq, Eq)]
10857pub enum BindName<'tree> {
10858 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10859 Variable(::std::boxed::Box<Variable<'tree>>),
10860}
10861impl<'tree> ::treesitter_types::FromNode<'tree> for BindName<'tree> {
10862 #[allow(clippy::collapsible_else_if)]
10863 fn from_node(
10864 node: ::treesitter_types::tree_sitter::Node<'tree>,
10865 src: &'tree [u8],
10866 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10867 match node.kind() {
10868 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10869 ::treesitter_types::runtime::maybe_grow_stack(|| {
10870 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
10871 })?,
10872 ))),
10873 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10874 ::treesitter_types::runtime::maybe_grow_stack(|| {
10875 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
10876 })?,
10877 ))),
10878 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10879 }
10880 }
10881}
10882impl ::treesitter_types::Spanned for BindName<'_> {
10883 fn span(&self) -> ::treesitter_types::Span {
10884 match self {
10885 Self::PrefixId(inner) => inner.span(),
10886 Self::Variable(inner) => inner.span(),
10887 }
10888 }
10889}
10890#[derive(Debug, Clone, PartialEq, Eq)]
10891pub enum BindPattern<'tree> {
10892 Pattern(::std::boxed::Box<Pattern<'tree>>),
10893 Signature(::std::boxed::Box<Signature<'tree>>),
10894}
10895impl<'tree> ::treesitter_types::FromNode<'tree> for BindPattern<'tree> {
10896 #[allow(clippy::collapsible_else_if)]
10897 fn from_node(
10898 node: ::treesitter_types::tree_sitter::Node<'tree>,
10899 src: &'tree [u8],
10900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10901 match node.kind() {
10902 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10903 ::treesitter_types::runtime::maybe_grow_stack(|| {
10904 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10905 })?,
10906 ))),
10907 _other => {
10908 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10909 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
10910 }) {
10911 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10912 } else {
10913 Err(::treesitter_types::ParseError::unexpected_kind(
10914 _other, node,
10915 ))
10916 }
10917 }
10918 }
10919 }
10920}
10921impl ::treesitter_types::Spanned for BindPattern<'_> {
10922 fn span(&self) -> ::treesitter_types::Span {
10923 match self {
10924 Self::Pattern(inner) => inner.span(),
10925 Self::Signature(inner) => inner.span(),
10926 }
10927 }
10928}
10929#[derive(Debug, Clone, PartialEq, Eq)]
10930pub enum BindingListName<'tree> {
10931 Constructor(::std::boxed::Box<Constructor<'tree>>),
10932 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10933 Variable(::std::boxed::Box<Variable<'tree>>),
10934}
10935impl<'tree> ::treesitter_types::FromNode<'tree> for BindingListName<'tree> {
10936 #[allow(clippy::collapsible_else_if)]
10937 fn from_node(
10938 node: ::treesitter_types::tree_sitter::Node<'tree>,
10939 src: &'tree [u8],
10940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10941 match node.kind() {
10942 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
10943 ::treesitter_types::runtime::maybe_grow_stack(|| {
10944 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
10945 })?,
10946 ))),
10947 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10948 ::treesitter_types::runtime::maybe_grow_stack(|| {
10949 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
10950 })?,
10951 ))),
10952 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10953 ::treesitter_types::runtime::maybe_grow_stack(|| {
10954 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
10955 })?,
10956 ))),
10957 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10958 }
10959 }
10960}
10961impl ::treesitter_types::Spanned for BindingListName<'_> {
10962 fn span(&self) -> ::treesitter_types::Span {
10963 match self {
10964 Self::Constructor(inner) => inner.span(),
10965 Self::PrefixId(inner) => inner.span(),
10966 Self::Variable(inner) => inner.span(),
10967 }
10968 }
10969}
10970#[derive(Debug, Clone, PartialEq, Eq)]
10971pub enum BooleanChildren<'tree> {
10972 Expression(::std::boxed::Box<Expression<'tree>>),
10973 Signature(::std::boxed::Box<Signature<'tree>>),
10974}
10975impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanChildren<'tree> {
10976 #[allow(clippy::collapsible_else_if)]
10977 fn from_node(
10978 node: ::treesitter_types::tree_sitter::Node<'tree>,
10979 src: &'tree [u8],
10980 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10981 match node.kind() {
10982 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10983 ::treesitter_types::runtime::maybe_grow_stack(|| {
10984 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
10985 })?,
10986 ))),
10987 _other => {
10988 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
10989 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
10990 }) {
10991 Ok(Self::Expression(::std::boxed::Box::new(v)))
10992 } else {
10993 Err(::treesitter_types::ParseError::unexpected_kind(
10994 _other, node,
10995 ))
10996 }
10997 }
10998 }
10999 }
11000}
11001impl ::treesitter_types::Spanned for BooleanChildren<'_> {
11002 fn span(&self) -> ::treesitter_types::Span {
11003 match self {
11004 Self::Expression(inner) => inner.span(),
11005 Self::Signature(inner) => inner.span(),
11006 }
11007 }
11008}
11009#[derive(Debug, Clone, PartialEq, Eq)]
11010pub enum CaseChildren<'tree> {
11011 Expression(::std::boxed::Box<Expression<'tree>>),
11012 Signature(::std::boxed::Box<Signature<'tree>>),
11013}
11014impl<'tree> ::treesitter_types::FromNode<'tree> for CaseChildren<'tree> {
11015 #[allow(clippy::collapsible_else_if)]
11016 fn from_node(
11017 node: ::treesitter_types::tree_sitter::Node<'tree>,
11018 src: &'tree [u8],
11019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11020 match node.kind() {
11021 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11022 ::treesitter_types::runtime::maybe_grow_stack(|| {
11023 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11024 })?,
11025 ))),
11026 _other => {
11027 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11028 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11029 }) {
11030 Ok(Self::Expression(::std::boxed::Box::new(v)))
11031 } else {
11032 Err(::treesitter_types::ParseError::unexpected_kind(
11033 _other, node,
11034 ))
11035 }
11036 }
11037 }
11038 }
11039}
11040impl ::treesitter_types::Spanned for CaseChildren<'_> {
11041 fn span(&self) -> ::treesitter_types::Span {
11042 match self {
11043 Self::Expression(inner) => inner.span(),
11044 Self::Signature(inner) => inner.span(),
11045 }
11046 }
11047}
11048#[derive(Debug, Clone, PartialEq, Eq)]
11049pub enum ChildrenElement<'tree> {
11050 AllNames(::std::boxed::Box<AllNames<'tree>>),
11051 AssociatedType(::std::boxed::Box<AssociatedType<'tree>>),
11052 Constructor(::std::boxed::Box<Constructor<'tree>>),
11053 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11054 Qualified(::std::boxed::Box<Qualified<'tree>>),
11055 Variable(::std::boxed::Box<Variable<'tree>>),
11056}
11057impl<'tree> ::treesitter_types::FromNode<'tree> for ChildrenElement<'tree> {
11058 #[allow(clippy::collapsible_else_if)]
11059 fn from_node(
11060 node: ::treesitter_types::tree_sitter::Node<'tree>,
11061 src: &'tree [u8],
11062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11063 match node.kind() {
11064 "all_names" => Ok(Self::AllNames(::std::boxed::Box::new(
11065 ::treesitter_types::runtime::maybe_grow_stack(|| {
11066 <AllNames as ::treesitter_types::FromNode>::from_node(node, src)
11067 })?,
11068 ))),
11069 "associated_type" => Ok(Self::AssociatedType(::std::boxed::Box::new(
11070 ::treesitter_types::runtime::maybe_grow_stack(|| {
11071 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
11072 })?,
11073 ))),
11074 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
11075 ::treesitter_types::runtime::maybe_grow_stack(|| {
11076 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
11077 })?,
11078 ))),
11079 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11080 ::treesitter_types::runtime::maybe_grow_stack(|| {
11081 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11082 })?,
11083 ))),
11084 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11085 ::treesitter_types::runtime::maybe_grow_stack(|| {
11086 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
11087 })?,
11088 ))),
11089 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
11090 ::treesitter_types::runtime::maybe_grow_stack(|| {
11091 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
11092 })?,
11093 ))),
11094 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11095 }
11096 }
11097}
11098impl ::treesitter_types::Spanned for ChildrenElement<'_> {
11099 fn span(&self) -> ::treesitter_types::Span {
11100 match self {
11101 Self::AllNames(inner) => inner.span(),
11102 Self::AssociatedType(inner) => inner.span(),
11103 Self::Constructor(inner) => inner.span(),
11104 Self::PrefixId(inner) => inner.span(),
11105 Self::Qualified(inner) => inner.span(),
11106 Self::Variable(inner) => inner.span(),
11107 }
11108 }
11109}
11110#[derive(Debug, Clone, PartialEq, Eq)]
11111pub enum ClassName<'tree> {
11112 Name(::std::boxed::Box<Name<'tree>>),
11113 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11114 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
11115 Unit(::std::boxed::Box<Unit<'tree>>),
11116}
11117impl<'tree> ::treesitter_types::FromNode<'tree> for ClassName<'tree> {
11118 #[allow(clippy::collapsible_else_if)]
11119 fn from_node(
11120 node: ::treesitter_types::tree_sitter::Node<'tree>,
11121 src: &'tree [u8],
11122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11123 match node.kind() {
11124 "name" => Ok(Self::Name(::std::boxed::Box::new(
11125 ::treesitter_types::runtime::maybe_grow_stack(|| {
11126 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11127 })?,
11128 ))),
11129 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11130 ::treesitter_types::runtime::maybe_grow_stack(|| {
11131 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11132 })?,
11133 ))),
11134 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
11135 ::treesitter_types::runtime::maybe_grow_stack(|| {
11136 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
11137 })?,
11138 ))),
11139 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
11140 ::treesitter_types::runtime::maybe_grow_stack(|| {
11141 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
11142 })?,
11143 ))),
11144 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11145 }
11146 }
11147}
11148impl ::treesitter_types::Spanned for ClassName<'_> {
11149 fn span(&self) -> ::treesitter_types::Span {
11150 match self {
11151 Self::Name(inner) => inner.span(),
11152 Self::PrefixId(inner) => inner.span(),
11153 Self::PrefixList(inner) => inner.span(),
11154 Self::Unit(inner) => inner.span(),
11155 }
11156 }
11157}
11158#[derive(Debug, Clone, PartialEq, Eq)]
11159pub enum ClassChildren<'tree> {
11160 Infix(::std::boxed::Box<Infix<'tree>>),
11161 Parens(::std::boxed::Box<Parens<'tree>>),
11162}
11163impl<'tree> ::treesitter_types::FromNode<'tree> for ClassChildren<'tree> {
11164 #[allow(clippy::collapsible_else_if)]
11165 fn from_node(
11166 node: ::treesitter_types::tree_sitter::Node<'tree>,
11167 src: &'tree [u8],
11168 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11169 match node.kind() {
11170 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11171 ::treesitter_types::runtime::maybe_grow_stack(|| {
11172 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
11173 })?,
11174 ))),
11175 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11176 ::treesitter_types::runtime::maybe_grow_stack(|| {
11177 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
11178 })?,
11179 ))),
11180 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11181 }
11182 }
11183}
11184impl ::treesitter_types::Spanned for ClassChildren<'_> {
11185 fn span(&self) -> ::treesitter_types::Span {
11186 match self {
11187 Self::Infix(inner) => inner.span(),
11188 Self::Parens(inner) => inner.span(),
11189 }
11190 }
11191}
11192#[derive(Debug, Clone, PartialEq, Eq)]
11193pub enum ConditionalElse<'tree> {
11194 Expression(::std::boxed::Box<Expression<'tree>>),
11195 Signature(::std::boxed::Box<Signature<'tree>>),
11196}
11197impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalElse<'tree> {
11198 #[allow(clippy::collapsible_else_if)]
11199 fn from_node(
11200 node: ::treesitter_types::tree_sitter::Node<'tree>,
11201 src: &'tree [u8],
11202 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11203 match node.kind() {
11204 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11205 ::treesitter_types::runtime::maybe_grow_stack(|| {
11206 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11207 })?,
11208 ))),
11209 _other => {
11210 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11211 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11212 }) {
11213 Ok(Self::Expression(::std::boxed::Box::new(v)))
11214 } else {
11215 Err(::treesitter_types::ParseError::unexpected_kind(
11216 _other, node,
11217 ))
11218 }
11219 }
11220 }
11221 }
11222}
11223impl ::treesitter_types::Spanned for ConditionalElse<'_> {
11224 fn span(&self) -> ::treesitter_types::Span {
11225 match self {
11226 Self::Expression(inner) => inner.span(),
11227 Self::Signature(inner) => inner.span(),
11228 }
11229 }
11230}
11231#[derive(Debug, Clone, PartialEq, Eq)]
11232pub enum ConditionalIf<'tree> {
11233 Expression(::std::boxed::Box<Expression<'tree>>),
11234 Signature(::std::boxed::Box<Signature<'tree>>),
11235}
11236impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalIf<'tree> {
11237 #[allow(clippy::collapsible_else_if)]
11238 fn from_node(
11239 node: ::treesitter_types::tree_sitter::Node<'tree>,
11240 src: &'tree [u8],
11241 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11242 match node.kind() {
11243 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11244 ::treesitter_types::runtime::maybe_grow_stack(|| {
11245 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11246 })?,
11247 ))),
11248 _other => {
11249 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11250 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11251 }) {
11252 Ok(Self::Expression(::std::boxed::Box::new(v)))
11253 } else {
11254 Err(::treesitter_types::ParseError::unexpected_kind(
11255 _other, node,
11256 ))
11257 }
11258 }
11259 }
11260 }
11261}
11262impl ::treesitter_types::Spanned for ConditionalIf<'_> {
11263 fn span(&self) -> ::treesitter_types::Span {
11264 match self {
11265 Self::Expression(inner) => inner.span(),
11266 Self::Signature(inner) => inner.span(),
11267 }
11268 }
11269}
11270#[derive(Debug, Clone, PartialEq, Eq)]
11271pub enum ConditionalThen<'tree> {
11272 Expression(::std::boxed::Box<Expression<'tree>>),
11273 Signature(::std::boxed::Box<Signature<'tree>>),
11274}
11275impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalThen<'tree> {
11276 #[allow(clippy::collapsible_else_if)]
11277 fn from_node(
11278 node: ::treesitter_types::tree_sitter::Node<'tree>,
11279 src: &'tree [u8],
11280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11281 match node.kind() {
11282 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11283 ::treesitter_types::runtime::maybe_grow_stack(|| {
11284 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11285 })?,
11286 ))),
11287 _other => {
11288 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11289 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
11290 }) {
11291 Ok(Self::Expression(::std::boxed::Box::new(v)))
11292 } else {
11293 Err(::treesitter_types::ParseError::unexpected_kind(
11294 _other, node,
11295 ))
11296 }
11297 }
11298 }
11299 }
11300}
11301impl ::treesitter_types::Spanned for ConditionalThen<'_> {
11302 fn span(&self) -> ::treesitter_types::Span {
11303 match self {
11304 Self::Expression(inner) => inner.span(),
11305 Self::Signature(inner) => inner.span(),
11306 }
11307 }
11308}
11309#[derive(Debug, Clone, PartialEq, Eq)]
11310pub enum ConstructorSynonymName<'tree> {
11311 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11312 Variable(::std::boxed::Box<Variable<'tree>>),
11313}
11314impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonymName<'tree> {
11315 #[allow(clippy::collapsible_else_if)]
11316 fn from_node(
11317 node: ::treesitter_types::tree_sitter::Node<'tree>,
11318 src: &'tree [u8],
11319 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11320 match node.kind() {
11321 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11322 ::treesitter_types::runtime::maybe_grow_stack(|| {
11323 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11324 })?,
11325 ))),
11326 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
11327 ::treesitter_types::runtime::maybe_grow_stack(|| {
11328 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
11329 })?,
11330 ))),
11331 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11332 }
11333 }
11334}
11335impl ::treesitter_types::Spanned for ConstructorSynonymName<'_> {
11336 fn span(&self) -> ::treesitter_types::Span {
11337 match self {
11338 Self::PrefixId(inner) => inner.span(),
11339 Self::Variable(inner) => inner.span(),
11340 }
11341 }
11342}
11343#[derive(Debug, Clone, PartialEq, Eq)]
11344pub enum ConstructorSynonymPattern<'tree> {
11345 Pattern(::std::boxed::Box<Pattern<'tree>>),
11346 Signature(::std::boxed::Box<Signature<'tree>>),
11347}
11348impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonymPattern<'tree> {
11349 #[allow(clippy::collapsible_else_if)]
11350 fn from_node(
11351 node: ::treesitter_types::tree_sitter::Node<'tree>,
11352 src: &'tree [u8],
11353 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11354 match node.kind() {
11355 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11356 ::treesitter_types::runtime::maybe_grow_stack(|| {
11357 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11358 })?,
11359 ))),
11360 _other => {
11361 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11362 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
11363 }) {
11364 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11365 } else {
11366 Err(::treesitter_types::ParseError::unexpected_kind(
11367 _other, node,
11368 ))
11369 }
11370 }
11371 }
11372 }
11373}
11374impl ::treesitter_types::Spanned for ConstructorSynonymPattern<'_> {
11375 fn span(&self) -> ::treesitter_types::Span {
11376 match self {
11377 Self::Pattern(inner) => inner.span(),
11378 Self::Signature(inner) => inner.span(),
11379 }
11380 }
11381}
11382#[derive(Debug, Clone, PartialEq, Eq)]
11383pub enum ContextArrow {
11384 FatArrow(::treesitter_types::Span),
11385 X(::treesitter_types::Span),
11386}
11387impl<'tree> ::treesitter_types::FromNode<'tree> for ContextArrow {
11388 #[allow(clippy::collapsible_else_if)]
11389 fn from_node(
11390 node: ::treesitter_types::tree_sitter::Node<'tree>,
11391 _src: &'tree [u8],
11392 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11393 match node.kind() {
11394 "=>" => Ok(Self::FatArrow(::treesitter_types::Span::from(node))),
11395 "⇒" => Ok(Self::X(::treesitter_types::Span::from(node))),
11396 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11397 }
11398 }
11399}
11400impl ::treesitter_types::Spanned for ContextArrow {
11401 fn span(&self) -> ::treesitter_types::Span {
11402 match self {
11403 Self::FatArrow(span) => *span,
11404 Self::X(span) => *span,
11405 }
11406 }
11407}
11408#[derive(Debug, Clone, PartialEq, Eq)]
11409pub enum DataConstructorConstructor<'tree> {
11410 Infix(::std::boxed::Box<Infix<'tree>>),
11411 Prefix(::std::boxed::Box<Prefix<'tree>>),
11412 Record(::std::boxed::Box<Record<'tree>>),
11413 Special(::std::boxed::Box<Special<'tree>>),
11414}
11415impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructorConstructor<'tree> {
11416 #[allow(clippy::collapsible_else_if)]
11417 fn from_node(
11418 node: ::treesitter_types::tree_sitter::Node<'tree>,
11419 src: &'tree [u8],
11420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11421 match node.kind() {
11422 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11423 ::treesitter_types::runtime::maybe_grow_stack(|| {
11424 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
11425 })?,
11426 ))),
11427 "prefix" => Ok(Self::Prefix(::std::boxed::Box::new(
11428 ::treesitter_types::runtime::maybe_grow_stack(|| {
11429 <Prefix as ::treesitter_types::FromNode>::from_node(node, src)
11430 })?,
11431 ))),
11432 "record" => Ok(Self::Record(::std::boxed::Box::new(
11433 ::treesitter_types::runtime::maybe_grow_stack(|| {
11434 <Record as ::treesitter_types::FromNode>::from_node(node, src)
11435 })?,
11436 ))),
11437 "special" => Ok(Self::Special(::std::boxed::Box::new(
11438 ::treesitter_types::runtime::maybe_grow_stack(|| {
11439 <Special as ::treesitter_types::FromNode>::from_node(node, src)
11440 })?,
11441 ))),
11442 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11443 }
11444 }
11445}
11446impl ::treesitter_types::Spanned for DataConstructorConstructor<'_> {
11447 fn span(&self) -> ::treesitter_types::Span {
11448 match self {
11449 Self::Infix(inner) => inner.span(),
11450 Self::Prefix(inner) => inner.span(),
11451 Self::Record(inner) => inner.span(),
11452 Self::Special(inner) => inner.span(),
11453 }
11454 }
11455}
11456#[derive(Debug, Clone, PartialEq, Eq)]
11457pub enum DataConstructorForall<'tree> {
11458 Forall(::std::boxed::Box<Forall<'tree>>),
11459 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
11460}
11461impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructorForall<'tree> {
11462 #[allow(clippy::collapsible_else_if)]
11463 fn from_node(
11464 node: ::treesitter_types::tree_sitter::Node<'tree>,
11465 src: &'tree [u8],
11466 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11467 match node.kind() {
11468 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
11469 ::treesitter_types::runtime::maybe_grow_stack(|| {
11470 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
11471 })?,
11472 ))),
11473 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
11474 ::treesitter_types::runtime::maybe_grow_stack(|| {
11475 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
11476 })?,
11477 ))),
11478 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11479 }
11480 }
11481}
11482impl ::treesitter_types::Spanned for DataConstructorForall<'_> {
11483 fn span(&self) -> ::treesitter_types::Span {
11484 match self {
11485 Self::Forall(inner) => inner.span(),
11486 Self::ForallRequired(inner) => inner.span(),
11487 }
11488 }
11489}
11490#[derive(Debug, Clone, PartialEq, Eq)]
11491pub enum DataFamilyName<'tree> {
11492 Name(::std::boxed::Box<Name<'tree>>),
11493 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11494 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
11495 Unit(::std::boxed::Box<Unit<'tree>>),
11496}
11497impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamilyName<'tree> {
11498 #[allow(clippy::collapsible_else_if)]
11499 fn from_node(
11500 node: ::treesitter_types::tree_sitter::Node<'tree>,
11501 src: &'tree [u8],
11502 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11503 match node.kind() {
11504 "name" => Ok(Self::Name(::std::boxed::Box::new(
11505 ::treesitter_types::runtime::maybe_grow_stack(|| {
11506 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11507 })?,
11508 ))),
11509 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11510 ::treesitter_types::runtime::maybe_grow_stack(|| {
11511 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11512 })?,
11513 ))),
11514 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
11515 ::treesitter_types::runtime::maybe_grow_stack(|| {
11516 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
11517 })?,
11518 ))),
11519 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
11520 ::treesitter_types::runtime::maybe_grow_stack(|| {
11521 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
11522 })?,
11523 ))),
11524 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11525 }
11526 }
11527}
11528impl ::treesitter_types::Spanned for DataFamilyName<'_> {
11529 fn span(&self) -> ::treesitter_types::Span {
11530 match self {
11531 Self::Name(inner) => inner.span(),
11532 Self::PrefixId(inner) => inner.span(),
11533 Self::PrefixList(inner) => inner.span(),
11534 Self::Unit(inner) => inner.span(),
11535 }
11536 }
11537}
11538#[derive(Debug, Clone, PartialEq, Eq)]
11539pub enum DataFamilyChildren<'tree> {
11540 Infix(::std::boxed::Box<Infix<'tree>>),
11541 Parens(::std::boxed::Box<Parens<'tree>>),
11542}
11543impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamilyChildren<'tree> {
11544 #[allow(clippy::collapsible_else_if)]
11545 fn from_node(
11546 node: ::treesitter_types::tree_sitter::Node<'tree>,
11547 src: &'tree [u8],
11548 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11549 match node.kind() {
11550 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11551 ::treesitter_types::runtime::maybe_grow_stack(|| {
11552 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
11553 })?,
11554 ))),
11555 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11556 ::treesitter_types::runtime::maybe_grow_stack(|| {
11557 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
11558 })?,
11559 ))),
11560 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11561 }
11562 }
11563}
11564impl ::treesitter_types::Spanned for DataFamilyChildren<'_> {
11565 fn span(&self) -> ::treesitter_types::Span {
11566 match self {
11567 Self::Infix(inner) => inner.span(),
11568 Self::Parens(inner) => inner.span(),
11569 }
11570 }
11571}
11572#[derive(Debug, Clone, PartialEq, Eq)]
11573pub enum DataInstanceChildren<'tree> {
11574 DataType(::std::boxed::Box<DataType<'tree>>),
11575 Newtype(::std::boxed::Box<Newtype<'tree>>),
11576}
11577impl<'tree> ::treesitter_types::FromNode<'tree> for DataInstanceChildren<'tree> {
11578 #[allow(clippy::collapsible_else_if)]
11579 fn from_node(
11580 node: ::treesitter_types::tree_sitter::Node<'tree>,
11581 src: &'tree [u8],
11582 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11583 match node.kind() {
11584 "data_type" => Ok(Self::DataType(::std::boxed::Box::new(
11585 ::treesitter_types::runtime::maybe_grow_stack(|| {
11586 <DataType as ::treesitter_types::FromNode>::from_node(node, src)
11587 })?,
11588 ))),
11589 "newtype" => Ok(Self::Newtype(::std::boxed::Box::new(
11590 ::treesitter_types::runtime::maybe_grow_stack(|| {
11591 <Newtype as ::treesitter_types::FromNode>::from_node(node, src)
11592 })?,
11593 ))),
11594 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11595 }
11596 }
11597}
11598impl ::treesitter_types::Spanned for DataInstanceChildren<'_> {
11599 fn span(&self) -> ::treesitter_types::Span {
11600 match self {
11601 Self::DataType(inner) => inner.span(),
11602 Self::Newtype(inner) => inner.span(),
11603 }
11604 }
11605}
11606#[derive(Debug, Clone, PartialEq, Eq)]
11607pub enum DataTypeConstructors<'tree> {
11608 DataConstructors(::std::boxed::Box<DataConstructors<'tree>>),
11609 GadtConstructors(::std::boxed::Box<GadtConstructors<'tree>>),
11610}
11611impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeConstructors<'tree> {
11612 #[allow(clippy::collapsible_else_if)]
11613 fn from_node(
11614 node: ::treesitter_types::tree_sitter::Node<'tree>,
11615 src: &'tree [u8],
11616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11617 match node.kind() {
11618 "data_constructors" => Ok(Self::DataConstructors(::std::boxed::Box::new(
11619 ::treesitter_types::runtime::maybe_grow_stack(|| {
11620 <DataConstructors as ::treesitter_types::FromNode>::from_node(node, src)
11621 })?,
11622 ))),
11623 "gadt_constructors" => Ok(Self::GadtConstructors(::std::boxed::Box::new(
11624 ::treesitter_types::runtime::maybe_grow_stack(|| {
11625 <GadtConstructors as ::treesitter_types::FromNode>::from_node(node, src)
11626 })?,
11627 ))),
11628 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11629 }
11630 }
11631}
11632impl ::treesitter_types::Spanned for DataTypeConstructors<'_> {
11633 fn span(&self) -> ::treesitter_types::Span {
11634 match self {
11635 Self::DataConstructors(inner) => inner.span(),
11636 Self::GadtConstructors(inner) => inner.span(),
11637 }
11638 }
11639}
11640#[derive(Debug, Clone, PartialEq, Eq)]
11641pub enum DataTypeForall<'tree> {
11642 Forall(::std::boxed::Box<Forall<'tree>>),
11643 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
11644}
11645impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeForall<'tree> {
11646 #[allow(clippy::collapsible_else_if)]
11647 fn from_node(
11648 node: ::treesitter_types::tree_sitter::Node<'tree>,
11649 src: &'tree [u8],
11650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11651 match node.kind() {
11652 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
11653 ::treesitter_types::runtime::maybe_grow_stack(|| {
11654 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
11655 })?,
11656 ))),
11657 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
11658 ::treesitter_types::runtime::maybe_grow_stack(|| {
11659 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
11660 })?,
11661 ))),
11662 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11663 }
11664 }
11665}
11666impl ::treesitter_types::Spanned for DataTypeForall<'_> {
11667 fn span(&self) -> ::treesitter_types::Span {
11668 match self {
11669 Self::Forall(inner) => inner.span(),
11670 Self::ForallRequired(inner) => inner.span(),
11671 }
11672 }
11673}
11674#[derive(Debug, Clone, PartialEq, Eq)]
11675pub enum DataTypeName<'tree> {
11676 Name(::std::boxed::Box<Name<'tree>>),
11677 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11678 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
11679 Qualified(::std::boxed::Box<Qualified<'tree>>),
11680 Unit(::std::boxed::Box<Unit<'tree>>),
11681}
11682impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeName<'tree> {
11683 #[allow(clippy::collapsible_else_if)]
11684 fn from_node(
11685 node: ::treesitter_types::tree_sitter::Node<'tree>,
11686 src: &'tree [u8],
11687 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11688 match node.kind() {
11689 "name" => Ok(Self::Name(::std::boxed::Box::new(
11690 ::treesitter_types::runtime::maybe_grow_stack(|| {
11691 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11692 })?,
11693 ))),
11694 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11695 ::treesitter_types::runtime::maybe_grow_stack(|| {
11696 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11697 })?,
11698 ))),
11699 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
11700 ::treesitter_types::runtime::maybe_grow_stack(|| {
11701 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
11702 })?,
11703 ))),
11704 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11705 ::treesitter_types::runtime::maybe_grow_stack(|| {
11706 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
11707 })?,
11708 ))),
11709 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
11710 ::treesitter_types::runtime::maybe_grow_stack(|| {
11711 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
11712 })?,
11713 ))),
11714 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11715 }
11716 }
11717}
11718impl ::treesitter_types::Spanned for DataTypeName<'_> {
11719 fn span(&self) -> ::treesitter_types::Span {
11720 match self {
11721 Self::Name(inner) => inner.span(),
11722 Self::PrefixId(inner) => inner.span(),
11723 Self::PrefixList(inner) => inner.span(),
11724 Self::Qualified(inner) => inner.span(),
11725 Self::Unit(inner) => inner.span(),
11726 }
11727 }
11728}
11729#[derive(Debug, Clone, PartialEq, Eq)]
11730pub enum DataTypePatterns<'tree> {
11731 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
11732 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
11733}
11734impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypePatterns<'tree> {
11735 #[allow(clippy::collapsible_else_if)]
11736 fn from_node(
11737 node: ::treesitter_types::tree_sitter::Node<'tree>,
11738 src: &'tree [u8],
11739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11740 match node.kind() {
11741 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
11742 ::treesitter_types::runtime::maybe_grow_stack(|| {
11743 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)
11744 })?,
11745 ))),
11746 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
11747 ::treesitter_types::runtime::maybe_grow_stack(|| {
11748 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)
11749 })?,
11750 ))),
11751 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11752 }
11753 }
11754}
11755impl ::treesitter_types::Spanned for DataTypePatterns<'_> {
11756 fn span(&self) -> ::treesitter_types::Span {
11757 match self {
11758 Self::TypeParams(inner) => inner.span(),
11759 Self::TypePatterns(inner) => inner.span(),
11760 }
11761 }
11762}
11763#[derive(Debug, Clone, PartialEq, Eq)]
11764pub enum DataTypeChildren<'tree> {
11765 Infix(::std::boxed::Box<Infix<'tree>>),
11766 Parens(::std::boxed::Box<Parens<'tree>>),
11767}
11768impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeChildren<'tree> {
11769 #[allow(clippy::collapsible_else_if)]
11770 fn from_node(
11771 node: ::treesitter_types::tree_sitter::Node<'tree>,
11772 src: &'tree [u8],
11773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11774 match node.kind() {
11775 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11776 ::treesitter_types::runtime::maybe_grow_stack(|| {
11777 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
11778 })?,
11779 ))),
11780 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11781 ::treesitter_types::runtime::maybe_grow_stack(|| {
11782 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
11783 })?,
11784 ))),
11785 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11786 }
11787 }
11788}
11789impl ::treesitter_types::Spanned for DataTypeChildren<'_> {
11790 fn span(&self) -> ::treesitter_types::Span {
11791 match self {
11792 Self::Infix(inner) => inner.span(),
11793 Self::Parens(inner) => inner.span(),
11794 }
11795 }
11796}
11797#[derive(Debug, Clone, PartialEq, Eq)]
11798pub enum DeclarationsChildren<'tree> {
11799 Declaration(::std::boxed::Box<Declaration<'tree>>),
11800 Import(::std::boxed::Box<Import<'tree>>),
11801}
11802impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationsChildren<'tree> {
11803 #[allow(clippy::collapsible_else_if)]
11804 fn from_node(
11805 node: ::treesitter_types::tree_sitter::Node<'tree>,
11806 src: &'tree [u8],
11807 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11808 match node.kind() {
11809 "import" => Ok(Self::Import(::std::boxed::Box::new(
11810 ::treesitter_types::runtime::maybe_grow_stack(|| {
11811 <Import as ::treesitter_types::FromNode>::from_node(node, src)
11812 })?,
11813 ))),
11814 _other => {
11815 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11816 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
11817 }) {
11818 Ok(Self::Declaration(::std::boxed::Box::new(v)))
11819 } else {
11820 Err(::treesitter_types::ParseError::unexpected_kind(
11821 _other, node,
11822 ))
11823 }
11824 }
11825 }
11826 }
11827}
11828impl ::treesitter_types::Spanned for DeclarationsChildren<'_> {
11829 fn span(&self) -> ::treesitter_types::Span {
11830 match self {
11831 Self::Declaration(inner) => inner.span(),
11832 Self::Import(inner) => inner.span(),
11833 }
11834 }
11835}
11836#[derive(Debug, Clone, PartialEq, Eq)]
11837pub enum DefaultTypesType<'tree> {
11838 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11839 Signature(::std::boxed::Box<Signature<'tree>>),
11840}
11841impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultTypesType<'tree> {
11842 #[allow(clippy::collapsible_else_if)]
11843 fn from_node(
11844 node: ::treesitter_types::tree_sitter::Node<'tree>,
11845 src: &'tree [u8],
11846 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11847 match node.kind() {
11848 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11849 ::treesitter_types::runtime::maybe_grow_stack(|| {
11850 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
11851 })?,
11852 ))),
11853 _other => {
11854 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
11855 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11856 }) {
11857 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
11858 } else {
11859 Err(::treesitter_types::ParseError::unexpected_kind(
11860 _other, node,
11861 ))
11862 }
11863 }
11864 }
11865 }
11866}
11867impl ::treesitter_types::Spanned for DefaultTypesType<'_> {
11868 fn span(&self) -> ::treesitter_types::Span {
11869 match self {
11870 Self::QuantifiedType(inner) => inner.span(),
11871 Self::Signature(inner) => inner.span(),
11872 }
11873 }
11874}
11875#[derive(Debug, Clone, PartialEq, Eq)]
11876pub enum DerivingInstanceForall<'tree> {
11877 Forall(::std::boxed::Box<Forall<'tree>>),
11878 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
11879}
11880impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceForall<'tree> {
11881 #[allow(clippy::collapsible_else_if)]
11882 fn from_node(
11883 node: ::treesitter_types::tree_sitter::Node<'tree>,
11884 src: &'tree [u8],
11885 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11886 match node.kind() {
11887 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
11888 ::treesitter_types::runtime::maybe_grow_stack(|| {
11889 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
11890 })?,
11891 ))),
11892 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
11893 ::treesitter_types::runtime::maybe_grow_stack(|| {
11894 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
11895 })?,
11896 ))),
11897 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11898 }
11899 }
11900}
11901impl ::treesitter_types::Spanned for DerivingInstanceForall<'_> {
11902 fn span(&self) -> ::treesitter_types::Span {
11903 match self {
11904 Self::Forall(inner) => inner.span(),
11905 Self::ForallRequired(inner) => inner.span(),
11906 }
11907 }
11908}
11909#[derive(Debug, Clone, PartialEq, Eq)]
11910pub enum DerivingInstanceName<'tree> {
11911 Name(::std::boxed::Box<Name<'tree>>),
11912 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11913 Qualified(::std::boxed::Box<Qualified<'tree>>),
11914}
11915impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceName<'tree> {
11916 #[allow(clippy::collapsible_else_if)]
11917 fn from_node(
11918 node: ::treesitter_types::tree_sitter::Node<'tree>,
11919 src: &'tree [u8],
11920 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11921 match node.kind() {
11922 "name" => Ok(Self::Name(::std::boxed::Box::new(
11923 ::treesitter_types::runtime::maybe_grow_stack(|| {
11924 <Name as ::treesitter_types::FromNode>::from_node(node, src)
11925 })?,
11926 ))),
11927 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11928 ::treesitter_types::runtime::maybe_grow_stack(|| {
11929 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
11930 })?,
11931 ))),
11932 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11933 ::treesitter_types::runtime::maybe_grow_stack(|| {
11934 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
11935 })?,
11936 ))),
11937 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11938 }
11939 }
11940}
11941impl ::treesitter_types::Spanned for DerivingInstanceName<'_> {
11942 fn span(&self) -> ::treesitter_types::Span {
11943 match self {
11944 Self::Name(inner) => inner.span(),
11945 Self::PrefixId(inner) => inner.span(),
11946 Self::Qualified(inner) => inner.span(),
11947 }
11948 }
11949}
11950#[derive(Debug, Clone, PartialEq, Eq)]
11951pub enum DerivingInstanceChildren<'tree> {
11952 Infix(::std::boxed::Box<Infix<'tree>>),
11953 Parens(::std::boxed::Box<Parens<'tree>>),
11954}
11955impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceChildren<'tree> {
11956 #[allow(clippy::collapsible_else_if)]
11957 fn from_node(
11958 node: ::treesitter_types::tree_sitter::Node<'tree>,
11959 src: &'tree [u8],
11960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11961 match node.kind() {
11962 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11963 ::treesitter_types::runtime::maybe_grow_stack(|| {
11964 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
11965 })?,
11966 ))),
11967 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11968 ::treesitter_types::runtime::maybe_grow_stack(|| {
11969 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
11970 })?,
11971 ))),
11972 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11973 }
11974 }
11975}
11976impl ::treesitter_types::Spanned for DerivingInstanceChildren<'_> {
11977 fn span(&self) -> ::treesitter_types::Span {
11978 match self {
11979 Self::Infix(inner) => inner.span(),
11980 Self::Parens(inner) => inner.span(),
11981 }
11982 }
11983}
11984#[derive(Debug, Clone, PartialEq, Eq)]
11985pub enum DoModuleId {
11986 Do(::treesitter_types::Span),
11987 Mdo(::treesitter_types::Span),
11988}
11989impl<'tree> ::treesitter_types::FromNode<'tree> for DoModuleId {
11990 #[allow(clippy::collapsible_else_if)]
11991 fn from_node(
11992 node: ::treesitter_types::tree_sitter::Node<'tree>,
11993 _src: &'tree [u8],
11994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11995 match node.kind() {
11996 "do" => Ok(Self::Do(::treesitter_types::Span::from(node))),
11997 "mdo" => Ok(Self::Mdo(::treesitter_types::Span::from(node))),
11998 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11999 }
12000 }
12001}
12002impl ::treesitter_types::Spanned for DoModuleId {
12003 fn span(&self) -> ::treesitter_types::Span {
12004 match self {
12005 Self::Do(span) => *span,
12006 Self::Mdo(span) => *span,
12007 }
12008 }
12009}
12010#[derive(Debug, Clone, PartialEq, Eq)]
12011pub enum EquationForall<'tree> {
12012 Forall(::std::boxed::Box<Forall<'tree>>),
12013 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
12014}
12015impl<'tree> ::treesitter_types::FromNode<'tree> for EquationForall<'tree> {
12016 #[allow(clippy::collapsible_else_if)]
12017 fn from_node(
12018 node: ::treesitter_types::tree_sitter::Node<'tree>,
12019 src: &'tree [u8],
12020 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12021 match node.kind() {
12022 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
12023 ::treesitter_types::runtime::maybe_grow_stack(|| {
12024 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
12025 })?,
12026 ))),
12027 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
12028 ::treesitter_types::runtime::maybe_grow_stack(|| {
12029 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
12030 })?,
12031 ))),
12032 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12033 }
12034 }
12035}
12036impl ::treesitter_types::Spanned for EquationForall<'_> {
12037 fn span(&self) -> ::treesitter_types::Span {
12038 match self {
12039 Self::Forall(inner) => inner.span(),
12040 Self::ForallRequired(inner) => inner.span(),
12041 }
12042 }
12043}
12044#[derive(Debug, Clone, PartialEq, Eq)]
12045pub enum EquationName<'tree> {
12046 Name(::std::boxed::Box<Name<'tree>>),
12047 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12048 Qualified(::std::boxed::Box<Qualified<'tree>>),
12049}
12050impl<'tree> ::treesitter_types::FromNode<'tree> for EquationName<'tree> {
12051 #[allow(clippy::collapsible_else_if)]
12052 fn from_node(
12053 node: ::treesitter_types::tree_sitter::Node<'tree>,
12054 src: &'tree [u8],
12055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12056 match node.kind() {
12057 "name" => Ok(Self::Name(::std::boxed::Box::new(
12058 ::treesitter_types::runtime::maybe_grow_stack(|| {
12059 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12060 })?,
12061 ))),
12062 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12063 ::treesitter_types::runtime::maybe_grow_stack(|| {
12064 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
12065 })?,
12066 ))),
12067 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12068 ::treesitter_types::runtime::maybe_grow_stack(|| {
12069 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12070 })?,
12071 ))),
12072 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12073 }
12074 }
12075}
12076impl ::treesitter_types::Spanned for EquationName<'_> {
12077 fn span(&self) -> ::treesitter_types::Span {
12078 match self {
12079 Self::Name(inner) => inner.span(),
12080 Self::PrefixId(inner) => inner.span(),
12081 Self::Qualified(inner) => inner.span(),
12082 }
12083 }
12084}
12085#[derive(Debug, Clone, PartialEq, Eq)]
12086pub enum EquationPattern<'tree> {
12087 Pattern(::std::boxed::Box<Pattern<'tree>>),
12088 Signature(::std::boxed::Box<Signature<'tree>>),
12089}
12090impl<'tree> ::treesitter_types::FromNode<'tree> for EquationPattern<'tree> {
12091 #[allow(clippy::collapsible_else_if)]
12092 fn from_node(
12093 node: ::treesitter_types::tree_sitter::Node<'tree>,
12094 src: &'tree [u8],
12095 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12096 match node.kind() {
12097 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12098 ::treesitter_types::runtime::maybe_grow_stack(|| {
12099 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
12100 })?,
12101 ))),
12102 _other => {
12103 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12104 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12105 }) {
12106 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12107 } else {
12108 Err(::treesitter_types::ParseError::unexpected_kind(
12109 _other, node,
12110 ))
12111 }
12112 }
12113 }
12114 }
12115}
12116impl ::treesitter_types::Spanned for EquationPattern<'_> {
12117 fn span(&self) -> ::treesitter_types::Span {
12118 match self {
12119 Self::Pattern(inner) => inner.span(),
12120 Self::Signature(inner) => inner.span(),
12121 }
12122 }
12123}
12124#[derive(Debug, Clone, PartialEq, Eq)]
12125pub enum EquationChildren<'tree> {
12126 Infix(::std::boxed::Box<Infix<'tree>>),
12127 Parens(::std::boxed::Box<Parens<'tree>>),
12128 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12129}
12130impl<'tree> ::treesitter_types::FromNode<'tree> for EquationChildren<'tree> {
12131 #[allow(clippy::collapsible_else_if)]
12132 fn from_node(
12133 node: ::treesitter_types::tree_sitter::Node<'tree>,
12134 src: &'tree [u8],
12135 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12136 match node.kind() {
12137 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
12138 ::treesitter_types::runtime::maybe_grow_stack(|| {
12139 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
12140 })?,
12141 ))),
12142 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
12143 ::treesitter_types::runtime::maybe_grow_stack(|| {
12144 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
12145 })?,
12146 ))),
12147 _other => {
12148 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12149 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12150 }) {
12151 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12152 } else {
12153 Err(::treesitter_types::ParseError::unexpected_kind(
12154 _other, node,
12155 ))
12156 }
12157 }
12158 }
12159 }
12160}
12161impl ::treesitter_types::Spanned for EquationChildren<'_> {
12162 fn span(&self) -> ::treesitter_types::Span {
12163 match self {
12164 Self::Infix(inner) => inner.span(),
12165 Self::Parens(inner) => inner.span(),
12166 Self::QuantifiedType(inner) => inner.span(),
12167 }
12168 }
12169}
12170#[derive(Debug, Clone, PartialEq, Eq)]
12171pub enum ExpChildren<'tree> {
12172 Expression(::std::boxed::Box<Expression<'tree>>),
12173 Signature(::std::boxed::Box<Signature<'tree>>),
12174}
12175impl<'tree> ::treesitter_types::FromNode<'tree> for ExpChildren<'tree> {
12176 #[allow(clippy::collapsible_else_if)]
12177 fn from_node(
12178 node: ::treesitter_types::tree_sitter::Node<'tree>,
12179 src: &'tree [u8],
12180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12181 match node.kind() {
12182 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12183 ::treesitter_types::runtime::maybe_grow_stack(|| {
12184 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
12185 })?,
12186 ))),
12187 _other => {
12188 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12189 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12190 }) {
12191 Ok(Self::Expression(::std::boxed::Box::new(v)))
12192 } else {
12193 Err(::treesitter_types::ParseError::unexpected_kind(
12194 _other, node,
12195 ))
12196 }
12197 }
12198 }
12199 }
12200}
12201impl ::treesitter_types::Spanned for ExpChildren<'_> {
12202 fn span(&self) -> ::treesitter_types::Span {
12203 match self {
12204 Self::Expression(inner) => inner.span(),
12205 Self::Signature(inner) => inner.span(),
12206 }
12207 }
12208}
12209#[derive(Debug, Clone, PartialEq, Eq)]
12210pub enum ExportType<'tree> {
12211 Name(::std::boxed::Box<Name<'tree>>),
12212 Qualified(::std::boxed::Box<Qualified<'tree>>),
12213}
12214impl<'tree> ::treesitter_types::FromNode<'tree> for ExportType<'tree> {
12215 #[allow(clippy::collapsible_else_if)]
12216 fn from_node(
12217 node: ::treesitter_types::tree_sitter::Node<'tree>,
12218 src: &'tree [u8],
12219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12220 match node.kind() {
12221 "name" => Ok(Self::Name(::std::boxed::Box::new(
12222 ::treesitter_types::runtime::maybe_grow_stack(|| {
12223 <Name as ::treesitter_types::FromNode>::from_node(node, src)
12224 })?,
12225 ))),
12226 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12227 ::treesitter_types::runtime::maybe_grow_stack(|| {
12228 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12229 })?,
12230 ))),
12231 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12232 }
12233 }
12234}
12235impl ::treesitter_types::Spanned for ExportType<'_> {
12236 fn span(&self) -> ::treesitter_types::Span {
12237 match self {
12238 Self::Name(inner) => inner.span(),
12239 Self::Qualified(inner) => inner.span(),
12240 }
12241 }
12242}
12243#[derive(Debug, Clone, PartialEq, Eq)]
12244pub enum ExportVariable<'tree> {
12245 Qualified(::std::boxed::Box<Qualified<'tree>>),
12246 Variable(::std::boxed::Box<Variable<'tree>>),
12247}
12248impl<'tree> ::treesitter_types::FromNode<'tree> for ExportVariable<'tree> {
12249 #[allow(clippy::collapsible_else_if)]
12250 fn from_node(
12251 node: ::treesitter_types::tree_sitter::Node<'tree>,
12252 src: &'tree [u8],
12253 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12254 match node.kind() {
12255 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12256 ::treesitter_types::runtime::maybe_grow_stack(|| {
12257 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12258 })?,
12259 ))),
12260 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12261 ::treesitter_types::runtime::maybe_grow_stack(|| {
12262 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
12263 })?,
12264 ))),
12265 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12266 }
12267 }
12268}
12269impl ::treesitter_types::Spanned for ExportVariable<'_> {
12270 fn span(&self) -> ::treesitter_types::Span {
12271 match self {
12272 Self::Qualified(inner) => inner.span(),
12273 Self::Variable(inner) => inner.span(),
12274 }
12275 }
12276}
12277#[derive(Debug, Clone, PartialEq, Eq)]
12278pub enum FieldParameter<'tree> {
12279 LazyField(::std::boxed::Box<LazyField<'tree>>),
12280 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12281 StrictField(::std::boxed::Box<StrictField<'tree>>),
12282}
12283impl<'tree> ::treesitter_types::FromNode<'tree> for FieldParameter<'tree> {
12284 #[allow(clippy::collapsible_else_if)]
12285 fn from_node(
12286 node: ::treesitter_types::tree_sitter::Node<'tree>,
12287 src: &'tree [u8],
12288 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12289 match node.kind() {
12290 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12291 ::treesitter_types::runtime::maybe_grow_stack(|| {
12292 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
12293 })?,
12294 ))),
12295 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12296 ::treesitter_types::runtime::maybe_grow_stack(|| {
12297 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
12298 })?,
12299 ))),
12300 _other => {
12301 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12302 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12303 }) {
12304 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12305 } else {
12306 Err(::treesitter_types::ParseError::unexpected_kind(
12307 _other, node,
12308 ))
12309 }
12310 }
12311 }
12312 }
12313}
12314impl ::treesitter_types::Spanned for FieldParameter<'_> {
12315 fn span(&self) -> ::treesitter_types::Span {
12316 match self {
12317 Self::LazyField(inner) => inner.span(),
12318 Self::QuantifiedType(inner) => inner.span(),
12319 Self::StrictField(inner) => inner.span(),
12320 }
12321 }
12322}
12323#[derive(Debug, Clone, PartialEq, Eq)]
12324pub enum FieldType<'tree> {
12325 LazyField(::std::boxed::Box<LazyField<'tree>>),
12326 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12327 StrictField(::std::boxed::Box<StrictField<'tree>>),
12328}
12329impl<'tree> ::treesitter_types::FromNode<'tree> for FieldType<'tree> {
12330 #[allow(clippy::collapsible_else_if)]
12331 fn from_node(
12332 node: ::treesitter_types::tree_sitter::Node<'tree>,
12333 src: &'tree [u8],
12334 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12335 match node.kind() {
12336 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12337 ::treesitter_types::runtime::maybe_grow_stack(|| {
12338 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
12339 })?,
12340 ))),
12341 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12342 ::treesitter_types::runtime::maybe_grow_stack(|| {
12343 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
12344 })?,
12345 ))),
12346 _other => {
12347 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12348 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12349 }) {
12350 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12351 } else {
12352 Err(::treesitter_types::ParseError::unexpected_kind(
12353 _other, node,
12354 ))
12355 }
12356 }
12357 }
12358 }
12359}
12360impl ::treesitter_types::Spanned for FieldType<'_> {
12361 fn span(&self) -> ::treesitter_types::Span {
12362 match self {
12363 Self::LazyField(inner) => inner.span(),
12364 Self::QuantifiedType(inner) => inner.span(),
12365 Self::StrictField(inner) => inner.span(),
12366 }
12367 }
12368}
12369#[derive(Debug, Clone, PartialEq, Eq)]
12370pub enum FieldPathField<'tree> {
12371 FieldName(::std::boxed::Box<FieldName<'tree>>),
12372 Qualified(::std::boxed::Box<Qualified<'tree>>),
12373}
12374impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPathField<'tree> {
12375 #[allow(clippy::collapsible_else_if)]
12376 fn from_node(
12377 node: ::treesitter_types::tree_sitter::Node<'tree>,
12378 src: &'tree [u8],
12379 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12380 match node.kind() {
12381 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
12382 ::treesitter_types::runtime::maybe_grow_stack(|| {
12383 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
12384 })?,
12385 ))),
12386 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12387 ::treesitter_types::runtime::maybe_grow_stack(|| {
12388 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12389 })?,
12390 ))),
12391 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12392 }
12393 }
12394}
12395impl ::treesitter_types::Spanned for FieldPathField<'_> {
12396 fn span(&self) -> ::treesitter_types::Span {
12397 match self {
12398 Self::FieldName(inner) => inner.span(),
12399 Self::Qualified(inner) => inner.span(),
12400 }
12401 }
12402}
12403#[derive(Debug, Clone, PartialEq, Eq)]
12404pub enum FieldPatternField<'tree> {
12405 FieldName(::std::boxed::Box<FieldName<'tree>>),
12406 Qualified(::std::boxed::Box<Qualified<'tree>>),
12407}
12408impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternField<'tree> {
12409 #[allow(clippy::collapsible_else_if)]
12410 fn from_node(
12411 node: ::treesitter_types::tree_sitter::Node<'tree>,
12412 src: &'tree [u8],
12413 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12414 match node.kind() {
12415 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
12416 ::treesitter_types::runtime::maybe_grow_stack(|| {
12417 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
12418 })?,
12419 ))),
12420 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12421 ::treesitter_types::runtime::maybe_grow_stack(|| {
12422 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12423 })?,
12424 ))),
12425 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12426 }
12427 }
12428}
12429impl ::treesitter_types::Spanned for FieldPatternField<'_> {
12430 fn span(&self) -> ::treesitter_types::Span {
12431 match self {
12432 Self::FieldName(inner) => inner.span(),
12433 Self::Qualified(inner) => inner.span(),
12434 }
12435 }
12436}
12437#[derive(Debug, Clone, PartialEq, Eq)]
12438pub enum FieldPatternPattern<'tree> {
12439 Pattern(::std::boxed::Box<Pattern<'tree>>),
12440 Signature(::std::boxed::Box<Signature<'tree>>),
12441 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
12442}
12443impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternPattern<'tree> {
12444 #[allow(clippy::collapsible_else_if)]
12445 fn from_node(
12446 node: ::treesitter_types::tree_sitter::Node<'tree>,
12447 src: &'tree [u8],
12448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12449 match node.kind() {
12450 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12451 ::treesitter_types::runtime::maybe_grow_stack(|| {
12452 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
12453 })?,
12454 ))),
12455 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
12456 ::treesitter_types::runtime::maybe_grow_stack(|| {
12457 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
12458 })?,
12459 ))),
12460 _other => {
12461 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12462 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
12463 }) {
12464 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12465 } else {
12466 Err(::treesitter_types::ParseError::unexpected_kind(
12467 _other, node,
12468 ))
12469 }
12470 }
12471 }
12472 }
12473}
12474impl ::treesitter_types::Spanned for FieldPatternPattern<'_> {
12475 fn span(&self) -> ::treesitter_types::Span {
12476 match self {
12477 Self::Pattern(inner) => inner.span(),
12478 Self::Signature(inner) => inner.span(),
12479 Self::ViewPattern(inner) => inner.span(),
12480 }
12481 }
12482}
12483#[derive(Debug, Clone, PartialEq, Eq)]
12484pub enum FieldUpdateExpression<'tree> {
12485 Expression(::std::boxed::Box<Expression<'tree>>),
12486 Signature(::std::boxed::Box<Signature<'tree>>),
12487}
12488impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdateExpression<'tree> {
12489 #[allow(clippy::collapsible_else_if)]
12490 fn from_node(
12491 node: ::treesitter_types::tree_sitter::Node<'tree>,
12492 src: &'tree [u8],
12493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12494 match node.kind() {
12495 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12496 ::treesitter_types::runtime::maybe_grow_stack(|| {
12497 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
12498 })?,
12499 ))),
12500 _other => {
12501 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12502 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12503 }) {
12504 Ok(Self::Expression(::std::boxed::Box::new(v)))
12505 } else {
12506 Err(::treesitter_types::ParseError::unexpected_kind(
12507 _other, node,
12508 ))
12509 }
12510 }
12511 }
12512 }
12513}
12514impl ::treesitter_types::Spanned for FieldUpdateExpression<'_> {
12515 fn span(&self) -> ::treesitter_types::Span {
12516 match self {
12517 Self::Expression(inner) => inner.span(),
12518 Self::Signature(inner) => inner.span(),
12519 }
12520 }
12521}
12522#[derive(Debug, Clone, PartialEq, Eq)]
12523pub enum FieldUpdateField<'tree> {
12524 FieldName(::std::boxed::Box<FieldName<'tree>>),
12525 FieldPath(::std::boxed::Box<FieldPath<'tree>>),
12526 Qualified(::std::boxed::Box<Qualified<'tree>>),
12527}
12528impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdateField<'tree> {
12529 #[allow(clippy::collapsible_else_if)]
12530 fn from_node(
12531 node: ::treesitter_types::tree_sitter::Node<'tree>,
12532 src: &'tree [u8],
12533 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12534 match node.kind() {
12535 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
12536 ::treesitter_types::runtime::maybe_grow_stack(|| {
12537 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
12538 })?,
12539 ))),
12540 "field_path" => Ok(Self::FieldPath(::std::boxed::Box::new(
12541 ::treesitter_types::runtime::maybe_grow_stack(|| {
12542 <FieldPath as ::treesitter_types::FromNode>::from_node(node, src)
12543 })?,
12544 ))),
12545 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12546 ::treesitter_types::runtime::maybe_grow_stack(|| {
12547 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
12548 })?,
12549 ))),
12550 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12551 }
12552 }
12553}
12554impl ::treesitter_types::Spanned for FieldUpdateField<'_> {
12555 fn span(&self) -> ::treesitter_types::Span {
12556 match self {
12557 Self::FieldName(inner) => inner.span(),
12558 Self::FieldPath(inner) => inner.span(),
12559 Self::Qualified(inner) => inner.span(),
12560 }
12561 }
12562}
12563#[derive(Debug, Clone, PartialEq, Eq)]
12564pub enum FixityAssociativity {
12565 Infix(::treesitter_types::Span),
12566 Infixl(::treesitter_types::Span),
12567 Infixr(::treesitter_types::Span),
12568}
12569impl<'tree> ::treesitter_types::FromNode<'tree> for FixityAssociativity {
12570 #[allow(clippy::collapsible_else_if)]
12571 fn from_node(
12572 node: ::treesitter_types::tree_sitter::Node<'tree>,
12573 _src: &'tree [u8],
12574 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12575 match node.kind() {
12576 "infix" => Ok(Self::Infix(::treesitter_types::Span::from(node))),
12577 "infixl" => Ok(Self::Infixl(::treesitter_types::Span::from(node))),
12578 "infixr" => Ok(Self::Infixr(::treesitter_types::Span::from(node))),
12579 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12580 }
12581 }
12582}
12583impl ::treesitter_types::Spanned for FixityAssociativity {
12584 fn span(&self) -> ::treesitter_types::Span {
12585 match self {
12586 Self::Infix(span) => *span,
12587 Self::Infixl(span) => *span,
12588 Self::Infixr(span) => *span,
12589 }
12590 }
12591}
12592#[derive(Debug, Clone, PartialEq, Eq)]
12593pub enum FixityOperator<'tree> {
12594 Comma(::treesitter_types::Span),
12595 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
12596 InfixId(::std::boxed::Box<InfixId<'tree>>),
12597 Operator(::std::boxed::Box<Operator<'tree>>),
12598}
12599impl<'tree> ::treesitter_types::FromNode<'tree> for FixityOperator<'tree> {
12600 #[allow(clippy::collapsible_else_if)]
12601 fn from_node(
12602 node: ::treesitter_types::tree_sitter::Node<'tree>,
12603 src: &'tree [u8],
12604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12605 match node.kind() {
12606 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
12607 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
12608 ::treesitter_types::runtime::maybe_grow_stack(|| {
12609 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
12610 })?,
12611 ))),
12612 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
12613 ::treesitter_types::runtime::maybe_grow_stack(|| {
12614 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
12615 })?,
12616 ))),
12617 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
12618 ::treesitter_types::runtime::maybe_grow_stack(|| {
12619 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
12620 })?,
12621 ))),
12622 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12623 }
12624 }
12625}
12626impl ::treesitter_types::Spanned for FixityOperator<'_> {
12627 fn span(&self) -> ::treesitter_types::Span {
12628 match self {
12629 Self::Comma(span) => *span,
12630 Self::ConstructorOperator(inner) => inner.span(),
12631 Self::InfixId(inner) => inner.span(),
12632 Self::Operator(inner) => inner.span(),
12633 }
12634 }
12635}
12636#[derive(Debug, Clone, PartialEq, Eq)]
12637pub enum ForallQuantifier {
12638 Forall(::treesitter_types::Span),
12639 X(::treesitter_types::Span),
12640}
12641impl<'tree> ::treesitter_types::FromNode<'tree> for ForallQuantifier {
12642 #[allow(clippy::collapsible_else_if)]
12643 fn from_node(
12644 node: ::treesitter_types::tree_sitter::Node<'tree>,
12645 _src: &'tree [u8],
12646 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12647 match node.kind() {
12648 "forall" => Ok(Self::Forall(::treesitter_types::Span::from(node))),
12649 "∀" => Ok(Self::X(::treesitter_types::Span::from(node))),
12650 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12651 }
12652 }
12653}
12654impl ::treesitter_types::Spanned for ForallQuantifier {
12655 fn span(&self) -> ::treesitter_types::Span {
12656 match self {
12657 Self::Forall(span) => *span,
12658 Self::X(span) => *span,
12659 }
12660 }
12661}
12662#[derive(Debug, Clone, PartialEq, Eq)]
12663pub enum ForallRequiredQuantifier {
12664 Forall(::treesitter_types::Span),
12665 X(::treesitter_types::Span),
12666}
12667impl<'tree> ::treesitter_types::FromNode<'tree> for ForallRequiredQuantifier {
12668 #[allow(clippy::collapsible_else_if)]
12669 fn from_node(
12670 node: ::treesitter_types::tree_sitter::Node<'tree>,
12671 _src: &'tree [u8],
12672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12673 match node.kind() {
12674 "forall" => Ok(Self::Forall(::treesitter_types::Span::from(node))),
12675 "∀" => Ok(Self::X(::treesitter_types::Span::from(node))),
12676 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12677 }
12678 }
12679}
12680impl ::treesitter_types::Spanned for ForallRequiredQuantifier {
12681 fn span(&self) -> ::treesitter_types::Span {
12682 match self {
12683 Self::Forall(span) => *span,
12684 Self::X(span) => *span,
12685 }
12686 }
12687}
12688#[derive(Debug, Clone, PartialEq, Eq)]
12689pub enum FunctionArrow {
12690 Arrow(::treesitter_types::Span),
12691 X(::treesitter_types::Span),
12692}
12693impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionArrow {
12694 #[allow(clippy::collapsible_else_if)]
12695 fn from_node(
12696 node: ::treesitter_types::tree_sitter::Node<'tree>,
12697 _src: &'tree [u8],
12698 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12699 match node.kind() {
12700 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
12701 "→" => Ok(Self::X(::treesitter_types::Span::from(node))),
12702 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12703 }
12704 }
12705}
12706impl ::treesitter_types::Spanned for FunctionArrow {
12707 fn span(&self) -> ::treesitter_types::Span {
12708 match self {
12709 Self::Arrow(span) => *span,
12710 Self::X(span) => *span,
12711 }
12712 }
12713}
12714#[derive(Debug, Clone, PartialEq, Eq)]
12715pub enum FunctionName<'tree> {
12716 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12717 Variable(::std::boxed::Box<Variable<'tree>>),
12718}
12719impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionName<'tree> {
12720 #[allow(clippy::collapsible_else_if)]
12721 fn from_node(
12722 node: ::treesitter_types::tree_sitter::Node<'tree>,
12723 src: &'tree [u8],
12724 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12725 match node.kind() {
12726 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12727 ::treesitter_types::runtime::maybe_grow_stack(|| {
12728 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
12729 })?,
12730 ))),
12731 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12732 ::treesitter_types::runtime::maybe_grow_stack(|| {
12733 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
12734 })?,
12735 ))),
12736 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12737 }
12738 }
12739}
12740impl ::treesitter_types::Spanned for FunctionName<'_> {
12741 fn span(&self) -> ::treesitter_types::Span {
12742 match self {
12743 Self::PrefixId(inner) => inner.span(),
12744 Self::Variable(inner) => inner.span(),
12745 }
12746 }
12747}
12748#[derive(Debug, Clone, PartialEq, Eq)]
12749pub enum FunctionParameter<'tree> {
12750 LazyField(::std::boxed::Box<LazyField<'tree>>),
12751 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12752 StrictField(::std::boxed::Box<StrictField<'tree>>),
12753}
12754impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionParameter<'tree> {
12755 #[allow(clippy::collapsible_else_if)]
12756 fn from_node(
12757 node: ::treesitter_types::tree_sitter::Node<'tree>,
12758 src: &'tree [u8],
12759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12760 match node.kind() {
12761 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12762 ::treesitter_types::runtime::maybe_grow_stack(|| {
12763 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
12764 })?,
12765 ))),
12766 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12767 ::treesitter_types::runtime::maybe_grow_stack(|| {
12768 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
12769 })?,
12770 ))),
12771 _other => {
12772 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12773 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12774 }) {
12775 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12776 } else {
12777 Err(::treesitter_types::ParseError::unexpected_kind(
12778 _other, node,
12779 ))
12780 }
12781 }
12782 }
12783 }
12784}
12785impl ::treesitter_types::Spanned for FunctionParameter<'_> {
12786 fn span(&self) -> ::treesitter_types::Span {
12787 match self {
12788 Self::LazyField(inner) => inner.span(),
12789 Self::QuantifiedType(inner) => inner.span(),
12790 Self::StrictField(inner) => inner.span(),
12791 }
12792 }
12793}
12794#[derive(Debug, Clone, PartialEq, Eq)]
12795pub enum FunctionHeadParensName<'tree> {
12796 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12797 Variable(::std::boxed::Box<Variable<'tree>>),
12798}
12799impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionHeadParensName<'tree> {
12800 #[allow(clippy::collapsible_else_if)]
12801 fn from_node(
12802 node: ::treesitter_types::tree_sitter::Node<'tree>,
12803 src: &'tree [u8],
12804 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12805 match node.kind() {
12806 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12807 ::treesitter_types::runtime::maybe_grow_stack(|| {
12808 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
12809 })?,
12810 ))),
12811 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12812 ::treesitter_types::runtime::maybe_grow_stack(|| {
12813 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
12814 })?,
12815 ))),
12816 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12817 }
12818 }
12819}
12820impl ::treesitter_types::Spanned for FunctionHeadParensName<'_> {
12821 fn span(&self) -> ::treesitter_types::Span {
12822 match self {
12823 Self::PrefixId(inner) => inner.span(),
12824 Self::Variable(inner) => inner.span(),
12825 }
12826 }
12827}
12828#[derive(Debug, Clone, PartialEq, Eq)]
12829pub enum GadtConstructorForall<'tree> {
12830 Forall(::std::boxed::Box<Forall<'tree>>),
12831 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
12832}
12833impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorForall<'tree> {
12834 #[allow(clippy::collapsible_else_if)]
12835 fn from_node(
12836 node: ::treesitter_types::tree_sitter::Node<'tree>,
12837 src: &'tree [u8],
12838 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12839 match node.kind() {
12840 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
12841 ::treesitter_types::runtime::maybe_grow_stack(|| {
12842 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
12843 })?,
12844 ))),
12845 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
12846 ::treesitter_types::runtime::maybe_grow_stack(|| {
12847 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
12848 })?,
12849 ))),
12850 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12851 }
12852 }
12853}
12854impl ::treesitter_types::Spanned for GadtConstructorForall<'_> {
12855 fn span(&self) -> ::treesitter_types::Span {
12856 match self {
12857 Self::Forall(inner) => inner.span(),
12858 Self::ForallRequired(inner) => inner.span(),
12859 }
12860 }
12861}
12862#[derive(Debug, Clone, PartialEq, Eq)]
12863pub enum GadtConstructorName<'tree> {
12864 Constructor(::std::boxed::Box<Constructor<'tree>>),
12865 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12866}
12867impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorName<'tree> {
12868 #[allow(clippy::collapsible_else_if)]
12869 fn from_node(
12870 node: ::treesitter_types::tree_sitter::Node<'tree>,
12871 src: &'tree [u8],
12872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12873 match node.kind() {
12874 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
12875 ::treesitter_types::runtime::maybe_grow_stack(|| {
12876 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
12877 })?,
12878 ))),
12879 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12880 ::treesitter_types::runtime::maybe_grow_stack(|| {
12881 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
12882 })?,
12883 ))),
12884 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12885 }
12886 }
12887}
12888impl ::treesitter_types::Spanned for GadtConstructorName<'_> {
12889 fn span(&self) -> ::treesitter_types::Span {
12890 match self {
12891 Self::Constructor(inner) => inner.span(),
12892 Self::PrefixId(inner) => inner.span(),
12893 }
12894 }
12895}
12896#[derive(Debug, Clone, PartialEq, Eq)]
12897pub enum GadtConstructorType<'tree> {
12898 Prefix(::std::boxed::Box<Prefix<'tree>>),
12899 Record(::std::boxed::Box<Record<'tree>>),
12900}
12901impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorType<'tree> {
12902 #[allow(clippy::collapsible_else_if)]
12903 fn from_node(
12904 node: ::treesitter_types::tree_sitter::Node<'tree>,
12905 src: &'tree [u8],
12906 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12907 match node.kind() {
12908 "prefix" => Ok(Self::Prefix(::std::boxed::Box::new(
12909 ::treesitter_types::runtime::maybe_grow_stack(|| {
12910 <Prefix as ::treesitter_types::FromNode>::from_node(node, src)
12911 })?,
12912 ))),
12913 "record" => Ok(Self::Record(::std::boxed::Box::new(
12914 ::treesitter_types::runtime::maybe_grow_stack(|| {
12915 <Record as ::treesitter_types::FromNode>::from_node(node, src)
12916 })?,
12917 ))),
12918 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12919 }
12920 }
12921}
12922impl ::treesitter_types::Spanned for GadtConstructorType<'_> {
12923 fn span(&self) -> ::treesitter_types::Span {
12924 match self {
12925 Self::Prefix(inner) => inner.span(),
12926 Self::Record(inner) => inner.span(),
12927 }
12928 }
12929}
12930#[derive(Debug, Clone, PartialEq, Eq)]
12931pub enum GeneratorArrow {
12932 LArrow(::treesitter_types::Span),
12933 X(::treesitter_types::Span),
12934}
12935impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorArrow {
12936 #[allow(clippy::collapsible_else_if)]
12937 fn from_node(
12938 node: ::treesitter_types::tree_sitter::Node<'tree>,
12939 _src: &'tree [u8],
12940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12941 match node.kind() {
12942 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
12943 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
12944 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12945 }
12946 }
12947}
12948impl ::treesitter_types::Spanned for GeneratorArrow {
12949 fn span(&self) -> ::treesitter_types::Span {
12950 match self {
12951 Self::LArrow(span) => *span,
12952 Self::X(span) => *span,
12953 }
12954 }
12955}
12956#[derive(Debug, Clone, PartialEq, Eq)]
12957pub enum GeneratorExpression<'tree> {
12958 Expression(::std::boxed::Box<Expression<'tree>>),
12959 Signature(::std::boxed::Box<Signature<'tree>>),
12960}
12961impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorExpression<'tree> {
12962 #[allow(clippy::collapsible_else_if)]
12963 fn from_node(
12964 node: ::treesitter_types::tree_sitter::Node<'tree>,
12965 src: &'tree [u8],
12966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12967 match node.kind() {
12968 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12969 ::treesitter_types::runtime::maybe_grow_stack(|| {
12970 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
12971 })?,
12972 ))),
12973 _other => {
12974 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
12975 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
12976 }) {
12977 Ok(Self::Expression(::std::boxed::Box::new(v)))
12978 } else {
12979 Err(::treesitter_types::ParseError::unexpected_kind(
12980 _other, node,
12981 ))
12982 }
12983 }
12984 }
12985 }
12986}
12987impl ::treesitter_types::Spanned for GeneratorExpression<'_> {
12988 fn span(&self) -> ::treesitter_types::Span {
12989 match self {
12990 Self::Expression(inner) => inner.span(),
12991 Self::Signature(inner) => inner.span(),
12992 }
12993 }
12994}
12995#[derive(Debug, Clone, PartialEq, Eq)]
12996pub enum GeneratorPattern<'tree> {
12997 Pattern(::std::boxed::Box<Pattern<'tree>>),
12998 Signature(::std::boxed::Box<Signature<'tree>>),
12999}
13000impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorPattern<'tree> {
13001 #[allow(clippy::collapsible_else_if)]
13002 fn from_node(
13003 node: ::treesitter_types::tree_sitter::Node<'tree>,
13004 src: &'tree [u8],
13005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13006 match node.kind() {
13007 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13008 ::treesitter_types::runtime::maybe_grow_stack(|| {
13009 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13010 })?,
13011 ))),
13012 _other => {
13013 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13014 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13015 }) {
13016 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13017 } else {
13018 Err(::treesitter_types::ParseError::unexpected_kind(
13019 _other, node,
13020 ))
13021 }
13022 }
13023 }
13024 }
13025}
13026impl ::treesitter_types::Spanned for GeneratorPattern<'_> {
13027 fn span(&self) -> ::treesitter_types::Span {
13028 match self {
13029 Self::Pattern(inner) => inner.span(),
13030 Self::Signature(inner) => inner.span(),
13031 }
13032 }
13033}
13034#[derive(Debug, Clone, PartialEq, Eq)]
13035pub enum GroupClassifier<'tree> {
13036 Expression(::std::boxed::Box<Expression<'tree>>),
13037 Signature(::std::boxed::Box<Signature<'tree>>),
13038}
13039impl<'tree> ::treesitter_types::FromNode<'tree> for GroupClassifier<'tree> {
13040 #[allow(clippy::collapsible_else_if)]
13041 fn from_node(
13042 node: ::treesitter_types::tree_sitter::Node<'tree>,
13043 src: &'tree [u8],
13044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13045 match node.kind() {
13046 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13047 ::treesitter_types::runtime::maybe_grow_stack(|| {
13048 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13049 })?,
13050 ))),
13051 _other => {
13052 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13053 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13054 }) {
13055 Ok(Self::Expression(::std::boxed::Box::new(v)))
13056 } else {
13057 Err(::treesitter_types::ParseError::unexpected_kind(
13058 _other, node,
13059 ))
13060 }
13061 }
13062 }
13063 }
13064}
13065impl ::treesitter_types::Spanned for GroupClassifier<'_> {
13066 fn span(&self) -> ::treesitter_types::Span {
13067 match self {
13068 Self::Expression(inner) => inner.span(),
13069 Self::Signature(inner) => inner.span(),
13070 }
13071 }
13072}
13073#[derive(Debug, Clone, PartialEq, Eq)]
13074pub enum GroupKey<'tree> {
13075 Expression(::std::boxed::Box<Expression<'tree>>),
13076 Signature(::std::boxed::Box<Signature<'tree>>),
13077}
13078impl<'tree> ::treesitter_types::FromNode<'tree> for GroupKey<'tree> {
13079 #[allow(clippy::collapsible_else_if)]
13080 fn from_node(
13081 node: ::treesitter_types::tree_sitter::Node<'tree>,
13082 src: &'tree [u8],
13083 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13084 match node.kind() {
13085 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13086 ::treesitter_types::runtime::maybe_grow_stack(|| {
13087 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13088 })?,
13089 ))),
13090 _other => {
13091 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13092 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13093 }) {
13094 Ok(Self::Expression(::std::boxed::Box::new(v)))
13095 } else {
13096 Err(::treesitter_types::ParseError::unexpected_kind(
13097 _other, node,
13098 ))
13099 }
13100 }
13101 }
13102 }
13103}
13104impl ::treesitter_types::Spanned for GroupKey<'_> {
13105 fn span(&self) -> ::treesitter_types::Span {
13106 match self {
13107 Self::Expression(inner) => inner.span(),
13108 Self::Signature(inner) => inner.span(),
13109 }
13110 }
13111}
13112#[derive(Debug, Clone, PartialEq, Eq)]
13113pub enum ImportNameType<'tree> {
13114 Name(::std::boxed::Box<Name<'tree>>),
13115 Qualified(::std::boxed::Box<Qualified<'tree>>),
13116}
13117impl<'tree> ::treesitter_types::FromNode<'tree> for ImportNameType<'tree> {
13118 #[allow(clippy::collapsible_else_if)]
13119 fn from_node(
13120 node: ::treesitter_types::tree_sitter::Node<'tree>,
13121 src: &'tree [u8],
13122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13123 match node.kind() {
13124 "name" => Ok(Self::Name(::std::boxed::Box::new(
13125 ::treesitter_types::runtime::maybe_grow_stack(|| {
13126 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13127 })?,
13128 ))),
13129 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13130 ::treesitter_types::runtime::maybe_grow_stack(|| {
13131 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13132 })?,
13133 ))),
13134 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13135 }
13136 }
13137}
13138impl ::treesitter_types::Spanned for ImportNameType<'_> {
13139 fn span(&self) -> ::treesitter_types::Span {
13140 match self {
13141 Self::Name(inner) => inner.span(),
13142 Self::Qualified(inner) => inner.span(),
13143 }
13144 }
13145}
13146#[derive(Debug, Clone, PartialEq, Eq)]
13147pub enum ImportNameVariable<'tree> {
13148 Qualified(::std::boxed::Box<Qualified<'tree>>),
13149 Variable(::std::boxed::Box<Variable<'tree>>),
13150}
13151impl<'tree> ::treesitter_types::FromNode<'tree> for ImportNameVariable<'tree> {
13152 #[allow(clippy::collapsible_else_if)]
13153 fn from_node(
13154 node: ::treesitter_types::tree_sitter::Node<'tree>,
13155 src: &'tree [u8],
13156 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13157 match node.kind() {
13158 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13159 ::treesitter_types::runtime::maybe_grow_stack(|| {
13160 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13161 })?,
13162 ))),
13163 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
13164 ::treesitter_types::runtime::maybe_grow_stack(|| {
13165 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
13166 })?,
13167 ))),
13168 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13169 }
13170 }
13171}
13172impl ::treesitter_types::Spanned for ImportNameVariable<'_> {
13173 fn span(&self) -> ::treesitter_types::Span {
13174 match self {
13175 Self::Qualified(inner) => inner.span(),
13176 Self::Variable(inner) => inner.span(),
13177 }
13178 }
13179}
13180#[derive(Debug, Clone, PartialEq, Eq)]
13181pub enum InferredChildren<'tree> {
13182 Annotated(::std::boxed::Box<Annotated<'tree>>),
13183 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
13184}
13185impl<'tree> ::treesitter_types::FromNode<'tree> for InferredChildren<'tree> {
13186 #[allow(clippy::collapsible_else_if)]
13187 fn from_node(
13188 node: ::treesitter_types::tree_sitter::Node<'tree>,
13189 src: &'tree [u8],
13190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13191 match node.kind() {
13192 "annotated" => Ok(Self::Annotated(::std::boxed::Box::new(
13193 ::treesitter_types::runtime::maybe_grow_stack(|| {
13194 <Annotated as ::treesitter_types::FromNode>::from_node(node, src)
13195 })?,
13196 ))),
13197 _other => {
13198 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13199 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
13200 }) {
13201 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
13202 } else {
13203 Err(::treesitter_types::ParseError::unexpected_kind(
13204 _other, node,
13205 ))
13206 }
13207 }
13208 }
13209 }
13210}
13211impl ::treesitter_types::Spanned for InferredChildren<'_> {
13212 fn span(&self) -> ::treesitter_types::Span {
13213 match self {
13214 Self::Annotated(inner) => inner.span(),
13215 Self::TypeParam(inner) => inner.span(),
13216 }
13217 }
13218}
13219#[derive(Debug, Clone, PartialEq, Eq)]
13220pub enum InfixLeftOperand<'tree> {
13221 Expression(::std::boxed::Box<Expression<'tree>>),
13222 LazyField(::std::boxed::Box<LazyField<'tree>>),
13223 Pattern(::std::boxed::Box<Pattern<'tree>>),
13224 StrictField(::std::boxed::Box<StrictField<'tree>>),
13225 Type(::std::boxed::Box<Type<'tree>>),
13226 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
13227}
13228impl<'tree> ::treesitter_types::FromNode<'tree> for InfixLeftOperand<'tree> {
13229 #[allow(clippy::collapsible_else_if)]
13230 fn from_node(
13231 node: ::treesitter_types::tree_sitter::Node<'tree>,
13232 src: &'tree [u8],
13233 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13234 match node.kind() {
13235 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
13236 ::treesitter_types::runtime::maybe_grow_stack(|| {
13237 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
13238 })?,
13239 ))),
13240 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
13241 ::treesitter_types::runtime::maybe_grow_stack(|| {
13242 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
13243 })?,
13244 ))),
13245 _other => {
13246 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13247 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13248 }) {
13249 Ok(Self::Expression(::std::boxed::Box::new(v)))
13250 } else {
13251 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13252 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13253 }) {
13254 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13255 } else {
13256 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13257 <Type as ::treesitter_types::FromNode>::from_node(node, src)
13258 }) {
13259 Ok(Self::Type(::std::boxed::Box::new(v)))
13260 } else {
13261 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13262 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
13263 }) {
13264 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
13265 } else {
13266 Err(::treesitter_types::ParseError::unexpected_kind(
13267 _other, node,
13268 ))
13269 }
13270 }
13271 }
13272 }
13273 }
13274 }
13275 }
13276}
13277impl ::treesitter_types::Spanned for InfixLeftOperand<'_> {
13278 fn span(&self) -> ::treesitter_types::Span {
13279 match self {
13280 Self::Expression(inner) => inner.span(),
13281 Self::LazyField(inner) => inner.span(),
13282 Self::Pattern(inner) => inner.span(),
13283 Self::StrictField(inner) => inner.span(),
13284 Self::Type(inner) => inner.span(),
13285 Self::TypeParam(inner) => inner.span(),
13286 }
13287 }
13288}
13289#[derive(Debug, Clone, PartialEq, Eq)]
13290pub enum InfixOperator<'tree> {
13291 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
13292 InfixId(::std::boxed::Box<InfixId<'tree>>),
13293 Operator(::std::boxed::Box<Operator<'tree>>),
13294 Promoted(::std::boxed::Box<Promoted<'tree>>),
13295 Qualified(::std::boxed::Box<Qualified<'tree>>),
13296}
13297impl<'tree> ::treesitter_types::FromNode<'tree> for InfixOperator<'tree> {
13298 #[allow(clippy::collapsible_else_if)]
13299 fn from_node(
13300 node: ::treesitter_types::tree_sitter::Node<'tree>,
13301 src: &'tree [u8],
13302 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13303 match node.kind() {
13304 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
13305 ::treesitter_types::runtime::maybe_grow_stack(|| {
13306 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
13307 })?,
13308 ))),
13309 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
13310 ::treesitter_types::runtime::maybe_grow_stack(|| {
13311 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
13312 })?,
13313 ))),
13314 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
13315 ::treesitter_types::runtime::maybe_grow_stack(|| {
13316 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
13317 })?,
13318 ))),
13319 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
13320 ::treesitter_types::runtime::maybe_grow_stack(|| {
13321 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)
13322 })?,
13323 ))),
13324 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13325 ::treesitter_types::runtime::maybe_grow_stack(|| {
13326 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13327 })?,
13328 ))),
13329 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13330 }
13331 }
13332}
13333impl ::treesitter_types::Spanned for InfixOperator<'_> {
13334 fn span(&self) -> ::treesitter_types::Span {
13335 match self {
13336 Self::ConstructorOperator(inner) => inner.span(),
13337 Self::InfixId(inner) => inner.span(),
13338 Self::Operator(inner) => inner.span(),
13339 Self::Promoted(inner) => inner.span(),
13340 Self::Qualified(inner) => inner.span(),
13341 }
13342 }
13343}
13344#[derive(Debug, Clone, PartialEq, Eq)]
13345pub enum InfixRightOperand<'tree> {
13346 Expression(::std::boxed::Box<Expression<'tree>>),
13347 LazyField(::std::boxed::Box<LazyField<'tree>>),
13348 Pattern(::std::boxed::Box<Pattern<'tree>>),
13349 StrictField(::std::boxed::Box<StrictField<'tree>>),
13350 Type(::std::boxed::Box<Type<'tree>>),
13351 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
13352}
13353impl<'tree> ::treesitter_types::FromNode<'tree> for InfixRightOperand<'tree> {
13354 #[allow(clippy::collapsible_else_if)]
13355 fn from_node(
13356 node: ::treesitter_types::tree_sitter::Node<'tree>,
13357 src: &'tree [u8],
13358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13359 match node.kind() {
13360 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
13361 ::treesitter_types::runtime::maybe_grow_stack(|| {
13362 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
13363 })?,
13364 ))),
13365 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
13366 ::treesitter_types::runtime::maybe_grow_stack(|| {
13367 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
13368 })?,
13369 ))),
13370 _other => {
13371 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13372 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13373 }) {
13374 Ok(Self::Expression(::std::boxed::Box::new(v)))
13375 } else {
13376 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13377 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13378 }) {
13379 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13380 } else {
13381 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13382 <Type as ::treesitter_types::FromNode>::from_node(node, src)
13383 }) {
13384 Ok(Self::Type(::std::boxed::Box::new(v)))
13385 } else {
13386 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13387 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
13388 }) {
13389 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
13390 } else {
13391 Err(::treesitter_types::ParseError::unexpected_kind(
13392 _other, node,
13393 ))
13394 }
13395 }
13396 }
13397 }
13398 }
13399 }
13400 }
13401}
13402impl ::treesitter_types::Spanned for InfixRightOperand<'_> {
13403 fn span(&self) -> ::treesitter_types::Span {
13404 match self {
13405 Self::Expression(inner) => inner.span(),
13406 Self::LazyField(inner) => inner.span(),
13407 Self::Pattern(inner) => inner.span(),
13408 Self::StrictField(inner) => inner.span(),
13409 Self::Type(inner) => inner.span(),
13410 Self::TypeParam(inner) => inner.span(),
13411 }
13412 }
13413}
13414#[derive(Debug, Clone, PartialEq, Eq)]
13415pub enum InfixIdChildren<'tree> {
13416 Constructor(::std::boxed::Box<Constructor<'tree>>),
13417 Name(::std::boxed::Box<Name<'tree>>),
13418 Qualified(::std::boxed::Box<Qualified<'tree>>),
13419 Variable(::std::boxed::Box<Variable<'tree>>),
13420}
13421impl<'tree> ::treesitter_types::FromNode<'tree> for InfixIdChildren<'tree> {
13422 #[allow(clippy::collapsible_else_if)]
13423 fn from_node(
13424 node: ::treesitter_types::tree_sitter::Node<'tree>,
13425 src: &'tree [u8],
13426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13427 match node.kind() {
13428 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
13429 ::treesitter_types::runtime::maybe_grow_stack(|| {
13430 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
13431 })?,
13432 ))),
13433 "name" => Ok(Self::Name(::std::boxed::Box::new(
13434 ::treesitter_types::runtime::maybe_grow_stack(|| {
13435 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13436 })?,
13437 ))),
13438 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13439 ::treesitter_types::runtime::maybe_grow_stack(|| {
13440 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13441 })?,
13442 ))),
13443 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
13444 ::treesitter_types::runtime::maybe_grow_stack(|| {
13445 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
13446 })?,
13447 ))),
13448 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13449 }
13450 }
13451}
13452impl ::treesitter_types::Spanned for InfixIdChildren<'_> {
13453 fn span(&self) -> ::treesitter_types::Span {
13454 match self {
13455 Self::Constructor(inner) => inner.span(),
13456 Self::Name(inner) => inner.span(),
13457 Self::Qualified(inner) => inner.span(),
13458 Self::Variable(inner) => inner.span(),
13459 }
13460 }
13461}
13462#[derive(Debug, Clone, PartialEq, Eq)]
13463pub enum InstanceForall<'tree> {
13464 Forall(::std::boxed::Box<Forall<'tree>>),
13465 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
13466}
13467impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceForall<'tree> {
13468 #[allow(clippy::collapsible_else_if)]
13469 fn from_node(
13470 node: ::treesitter_types::tree_sitter::Node<'tree>,
13471 src: &'tree [u8],
13472 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13473 match node.kind() {
13474 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
13475 ::treesitter_types::runtime::maybe_grow_stack(|| {
13476 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
13477 })?,
13478 ))),
13479 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
13480 ::treesitter_types::runtime::maybe_grow_stack(|| {
13481 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
13482 })?,
13483 ))),
13484 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13485 }
13486 }
13487}
13488impl ::treesitter_types::Spanned for InstanceForall<'_> {
13489 fn span(&self) -> ::treesitter_types::Span {
13490 match self {
13491 Self::Forall(inner) => inner.span(),
13492 Self::ForallRequired(inner) => inner.span(),
13493 }
13494 }
13495}
13496#[derive(Debug, Clone, PartialEq, Eq)]
13497pub enum InstanceName<'tree> {
13498 Name(::std::boxed::Box<Name<'tree>>),
13499 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13500 Qualified(::std::boxed::Box<Qualified<'tree>>),
13501}
13502impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceName<'tree> {
13503 #[allow(clippy::collapsible_else_if)]
13504 fn from_node(
13505 node: ::treesitter_types::tree_sitter::Node<'tree>,
13506 src: &'tree [u8],
13507 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13508 match node.kind() {
13509 "name" => Ok(Self::Name(::std::boxed::Box::new(
13510 ::treesitter_types::runtime::maybe_grow_stack(|| {
13511 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13512 })?,
13513 ))),
13514 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13515 ::treesitter_types::runtime::maybe_grow_stack(|| {
13516 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
13517 })?,
13518 ))),
13519 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13520 ::treesitter_types::runtime::maybe_grow_stack(|| {
13521 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13522 })?,
13523 ))),
13524 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13525 }
13526 }
13527}
13528impl ::treesitter_types::Spanned for InstanceName<'_> {
13529 fn span(&self) -> ::treesitter_types::Span {
13530 match self {
13531 Self::Name(inner) => inner.span(),
13532 Self::PrefixId(inner) => inner.span(),
13533 Self::Qualified(inner) => inner.span(),
13534 }
13535 }
13536}
13537#[derive(Debug, Clone, PartialEq, Eq)]
13538pub enum InstanceChildren<'tree> {
13539 Infix(::std::boxed::Box<Infix<'tree>>),
13540 Parens(::std::boxed::Box<Parens<'tree>>),
13541}
13542impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceChildren<'tree> {
13543 #[allow(clippy::collapsible_else_if)]
13544 fn from_node(
13545 node: ::treesitter_types::tree_sitter::Node<'tree>,
13546 src: &'tree [u8],
13547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13548 match node.kind() {
13549 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
13550 ::treesitter_types::runtime::maybe_grow_stack(|| {
13551 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
13552 })?,
13553 ))),
13554 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
13555 ::treesitter_types::runtime::maybe_grow_stack(|| {
13556 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
13557 })?,
13558 ))),
13559 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13560 }
13561 }
13562}
13563impl ::treesitter_types::Spanned for InstanceChildren<'_> {
13564 fn span(&self) -> ::treesitter_types::Span {
13565 match self {
13566 Self::Infix(inner) => inner.span(),
13567 Self::Parens(inner) => inner.span(),
13568 }
13569 }
13570}
13571#[derive(Debug, Clone, PartialEq, Eq)]
13572pub enum KindSignatureName<'tree> {
13573 Name(::std::boxed::Box<Name<'tree>>),
13574 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13575 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
13576 Unit(::std::boxed::Box<Unit<'tree>>),
13577}
13578impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignatureName<'tree> {
13579 #[allow(clippy::collapsible_else_if)]
13580 fn from_node(
13581 node: ::treesitter_types::tree_sitter::Node<'tree>,
13582 src: &'tree [u8],
13583 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13584 match node.kind() {
13585 "name" => Ok(Self::Name(::std::boxed::Box::new(
13586 ::treesitter_types::runtime::maybe_grow_stack(|| {
13587 <Name as ::treesitter_types::FromNode>::from_node(node, src)
13588 })?,
13589 ))),
13590 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13591 ::treesitter_types::runtime::maybe_grow_stack(|| {
13592 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
13593 })?,
13594 ))),
13595 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
13596 ::treesitter_types::runtime::maybe_grow_stack(|| {
13597 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
13598 })?,
13599 ))),
13600 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
13601 ::treesitter_types::runtime::maybe_grow_stack(|| {
13602 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
13603 })?,
13604 ))),
13605 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13606 }
13607 }
13608}
13609impl ::treesitter_types::Spanned for KindSignatureName<'_> {
13610 fn span(&self) -> ::treesitter_types::Span {
13611 match self {
13612 Self::Name(inner) => inner.span(),
13613 Self::PrefixId(inner) => inner.span(),
13614 Self::PrefixList(inner) => inner.span(),
13615 Self::Unit(inner) => inner.span(),
13616 }
13617 }
13618}
13619#[derive(Debug, Clone, PartialEq, Eq)]
13620pub enum KindSignatureChildren<'tree> {
13621 Infix(::std::boxed::Box<Infix<'tree>>),
13622 Parens(::std::boxed::Box<Parens<'tree>>),
13623}
13624impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignatureChildren<'tree> {
13625 #[allow(clippy::collapsible_else_if)]
13626 fn from_node(
13627 node: ::treesitter_types::tree_sitter::Node<'tree>,
13628 src: &'tree [u8],
13629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13630 match node.kind() {
13631 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
13632 ::treesitter_types::runtime::maybe_grow_stack(|| {
13633 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
13634 })?,
13635 ))),
13636 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
13637 ::treesitter_types::runtime::maybe_grow_stack(|| {
13638 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
13639 })?,
13640 ))),
13641 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13642 }
13643 }
13644}
13645impl ::treesitter_types::Spanned for KindSignatureChildren<'_> {
13646 fn span(&self) -> ::treesitter_types::Span {
13647 match self {
13648 Self::Infix(inner) => inner.span(),
13649 Self::Parens(inner) => inner.span(),
13650 }
13651 }
13652}
13653#[derive(Debug, Clone, PartialEq, Eq)]
13654pub enum LambdaExpression<'tree> {
13655 Expression(::std::boxed::Box<Expression<'tree>>),
13656 Signature(::std::boxed::Box<Signature<'tree>>),
13657}
13658impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
13659 #[allow(clippy::collapsible_else_if)]
13660 fn from_node(
13661 node: ::treesitter_types::tree_sitter::Node<'tree>,
13662 src: &'tree [u8],
13663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13664 match node.kind() {
13665 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13666 ::treesitter_types::runtime::maybe_grow_stack(|| {
13667 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13668 })?,
13669 ))),
13670 _other => {
13671 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13672 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13673 }) {
13674 Ok(Self::Expression(::std::boxed::Box::new(v)))
13675 } else {
13676 Err(::treesitter_types::ParseError::unexpected_kind(
13677 _other, node,
13678 ))
13679 }
13680 }
13681 }
13682 }
13683}
13684impl ::treesitter_types::Spanned for LambdaExpression<'_> {
13685 fn span(&self) -> ::treesitter_types::Span {
13686 match self {
13687 Self::Expression(inner) => inner.span(),
13688 Self::Signature(inner) => inner.span(),
13689 }
13690 }
13691}
13692#[derive(Debug, Clone, PartialEq, Eq)]
13693pub enum LeftSectionOperator<'tree> {
13694 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
13695 InfixId(::std::boxed::Box<InfixId<'tree>>),
13696 Operator(::std::boxed::Box<Operator<'tree>>),
13697 Qualified(::std::boxed::Box<Qualified<'tree>>),
13698}
13699impl<'tree> ::treesitter_types::FromNode<'tree> for LeftSectionOperator<'tree> {
13700 #[allow(clippy::collapsible_else_if)]
13701 fn from_node(
13702 node: ::treesitter_types::tree_sitter::Node<'tree>,
13703 src: &'tree [u8],
13704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13705 match node.kind() {
13706 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
13707 ::treesitter_types::runtime::maybe_grow_stack(|| {
13708 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
13709 })?,
13710 ))),
13711 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
13712 ::treesitter_types::runtime::maybe_grow_stack(|| {
13713 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
13714 })?,
13715 ))),
13716 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
13717 ::treesitter_types::runtime::maybe_grow_stack(|| {
13718 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
13719 })?,
13720 ))),
13721 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13722 ::treesitter_types::runtime::maybe_grow_stack(|| {
13723 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
13724 })?,
13725 ))),
13726 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13727 }
13728 }
13729}
13730impl ::treesitter_types::Spanned for LeftSectionOperator<'_> {
13731 fn span(&self) -> ::treesitter_types::Span {
13732 match self {
13733 Self::ConstructorOperator(inner) => inner.span(),
13734 Self::InfixId(inner) => inner.span(),
13735 Self::Operator(inner) => inner.span(),
13736 Self::Qualified(inner) => inner.span(),
13737 }
13738 }
13739}
13740#[derive(Debug, Clone, PartialEq, Eq)]
13741pub enum LetInExpression<'tree> {
13742 Expression(::std::boxed::Box<Expression<'tree>>),
13743 Signature(::std::boxed::Box<Signature<'tree>>),
13744}
13745impl<'tree> ::treesitter_types::FromNode<'tree> for LetInExpression<'tree> {
13746 #[allow(clippy::collapsible_else_if)]
13747 fn from_node(
13748 node: ::treesitter_types::tree_sitter::Node<'tree>,
13749 src: &'tree [u8],
13750 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13751 match node.kind() {
13752 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13753 ::treesitter_types::runtime::maybe_grow_stack(|| {
13754 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13755 })?,
13756 ))),
13757 _other => {
13758 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13759 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13760 }) {
13761 Ok(Self::Expression(::std::boxed::Box::new(v)))
13762 } else {
13763 Err(::treesitter_types::ParseError::unexpected_kind(
13764 _other, node,
13765 ))
13766 }
13767 }
13768 }
13769 }
13770}
13771impl ::treesitter_types::Spanned for LetInExpression<'_> {
13772 fn span(&self) -> ::treesitter_types::Span {
13773 match self {
13774 Self::Expression(inner) => inner.span(),
13775 Self::Signature(inner) => inner.span(),
13776 }
13777 }
13778}
13779#[derive(Debug, Clone, PartialEq, Eq)]
13780pub enum LinearFunctionArrow {
13781 Arrow(::treesitter_types::Span),
13782 MinusGtDot(::treesitter_types::Span),
13783 X(::treesitter_types::Span),
13784}
13785impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunctionArrow {
13786 #[allow(clippy::collapsible_else_if)]
13787 fn from_node(
13788 node: ::treesitter_types::tree_sitter::Node<'tree>,
13789 _src: &'tree [u8],
13790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13791 match node.kind() {
13792 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
13793 "->." => Ok(Self::MinusGtDot(::treesitter_types::Span::from(node))),
13794 "→" | "⊸" => Ok(Self::X(::treesitter_types::Span::from(node))),
13795 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13796 }
13797 }
13798}
13799impl ::treesitter_types::Spanned for LinearFunctionArrow {
13800 fn span(&self) -> ::treesitter_types::Span {
13801 match self {
13802 Self::Arrow(span) => *span,
13803 Self::MinusGtDot(span) => *span,
13804 Self::X(span) => *span,
13805 }
13806 }
13807}
13808#[derive(Debug, Clone, PartialEq, Eq)]
13809pub enum LinearFunctionParameter<'tree> {
13810 LazyField(::std::boxed::Box<LazyField<'tree>>),
13811 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
13812 StrictField(::std::boxed::Box<StrictField<'tree>>),
13813}
13814impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunctionParameter<'tree> {
13815 #[allow(clippy::collapsible_else_if)]
13816 fn from_node(
13817 node: ::treesitter_types::tree_sitter::Node<'tree>,
13818 src: &'tree [u8],
13819 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13820 match node.kind() {
13821 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
13822 ::treesitter_types::runtime::maybe_grow_stack(|| {
13823 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
13824 })?,
13825 ))),
13826 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
13827 ::treesitter_types::runtime::maybe_grow_stack(|| {
13828 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
13829 })?,
13830 ))),
13831 _other => {
13832 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13833 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
13834 }) {
13835 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
13836 } else {
13837 Err(::treesitter_types::ParseError::unexpected_kind(
13838 _other, node,
13839 ))
13840 }
13841 }
13842 }
13843 }
13844}
13845impl ::treesitter_types::Spanned for LinearFunctionParameter<'_> {
13846 fn span(&self) -> ::treesitter_types::Span {
13847 match self {
13848 Self::LazyField(inner) => inner.span(),
13849 Self::QuantifiedType(inner) => inner.span(),
13850 Self::StrictField(inner) => inner.span(),
13851 }
13852 }
13853}
13854#[derive(Debug, Clone, PartialEq, Eq)]
13855pub enum ListElement<'tree> {
13856 Expression(::std::boxed::Box<Expression<'tree>>),
13857 Pattern(::std::boxed::Box<Pattern<'tree>>),
13858 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
13859 Signature(::std::boxed::Box<Signature<'tree>>),
13860 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
13861}
13862impl<'tree> ::treesitter_types::FromNode<'tree> for ListElement<'tree> {
13863 #[allow(clippy::collapsible_else_if)]
13864 fn from_node(
13865 node: ::treesitter_types::tree_sitter::Node<'tree>,
13866 src: &'tree [u8],
13867 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13868 match node.kind() {
13869 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13870 ::treesitter_types::runtime::maybe_grow_stack(|| {
13871 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13872 })?,
13873 ))),
13874 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
13875 ::treesitter_types::runtime::maybe_grow_stack(|| {
13876 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
13877 })?,
13878 ))),
13879 _other => {
13880 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13881 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13882 }) {
13883 Ok(Self::Expression(::std::boxed::Box::new(v)))
13884 } else {
13885 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13886 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13887 }) {
13888 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13889 } else {
13890 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13891 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
13892 }) {
13893 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
13894 } else {
13895 Err(::treesitter_types::ParseError::unexpected_kind(
13896 _other, node,
13897 ))
13898 }
13899 }
13900 }
13901 }
13902 }
13903 }
13904}
13905impl ::treesitter_types::Spanned for ListElement<'_> {
13906 fn span(&self) -> ::treesitter_types::Span {
13907 match self {
13908 Self::Expression(inner) => inner.span(),
13909 Self::Pattern(inner) => inner.span(),
13910 Self::QuantifiedType(inner) => inner.span(),
13911 Self::Signature(inner) => inner.span(),
13912 Self::ViewPattern(inner) => inner.span(),
13913 }
13914 }
13915}
13916#[derive(Debug, Clone, PartialEq, Eq)]
13917pub enum ListComprehensionExpression<'tree> {
13918 Expression(::std::boxed::Box<Expression<'tree>>),
13919 Signature(::std::boxed::Box<Signature<'tree>>),
13920}
13921impl<'tree> ::treesitter_types::FromNode<'tree> for ListComprehensionExpression<'tree> {
13922 #[allow(clippy::collapsible_else_if)]
13923 fn from_node(
13924 node: ::treesitter_types::tree_sitter::Node<'tree>,
13925 src: &'tree [u8],
13926 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13927 match node.kind() {
13928 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13929 ::treesitter_types::runtime::maybe_grow_stack(|| {
13930 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
13931 })?,
13932 ))),
13933 _other => {
13934 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
13935 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13936 }) {
13937 Ok(Self::Expression(::std::boxed::Box::new(v)))
13938 } else {
13939 Err(::treesitter_types::ParseError::unexpected_kind(
13940 _other, node,
13941 ))
13942 }
13943 }
13944 }
13945 }
13946}
13947impl ::treesitter_types::Spanned for ListComprehensionExpression<'_> {
13948 fn span(&self) -> ::treesitter_types::Span {
13949 match self {
13950 Self::Expression(inner) => inner.span(),
13951 Self::Signature(inner) => inner.span(),
13952 }
13953 }
13954}
13955#[derive(Debug, Clone, PartialEq, Eq)]
13956pub enum LiteralChildren<'tree> {
13957 Char(::std::boxed::Box<Char<'tree>>),
13958 Float(::std::boxed::Box<Float<'tree>>),
13959 Integer(::std::boxed::Box<Integer<'tree>>),
13960 String(::std::boxed::Box<String<'tree>>),
13961}
13962impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralChildren<'tree> {
13963 #[allow(clippy::collapsible_else_if)]
13964 fn from_node(
13965 node: ::treesitter_types::tree_sitter::Node<'tree>,
13966 src: &'tree [u8],
13967 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13968 match node.kind() {
13969 "char" => Ok(Self::Char(::std::boxed::Box::new(
13970 ::treesitter_types::runtime::maybe_grow_stack(|| {
13971 <Char as ::treesitter_types::FromNode>::from_node(node, src)
13972 })?,
13973 ))),
13974 "float" => Ok(Self::Float(::std::boxed::Box::new(
13975 ::treesitter_types::runtime::maybe_grow_stack(|| {
13976 <Float as ::treesitter_types::FromNode>::from_node(node, src)
13977 })?,
13978 ))),
13979 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
13980 ::treesitter_types::runtime::maybe_grow_stack(|| {
13981 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
13982 })?,
13983 ))),
13984 "string" => Ok(Self::String(::std::boxed::Box::new(
13985 ::treesitter_types::runtime::maybe_grow_stack(|| {
13986 <String as ::treesitter_types::FromNode>::from_node(node, src)
13987 })?,
13988 ))),
13989 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13990 }
13991 }
13992}
13993impl ::treesitter_types::Spanned for LiteralChildren<'_> {
13994 fn span(&self) -> ::treesitter_types::Span {
13995 match self {
13996 Self::Char(inner) => inner.span(),
13997 Self::Float(inner) => inner.span(),
13998 Self::Integer(inner) => inner.span(),
13999 Self::String(inner) => inner.span(),
14000 }
14001 }
14002}
14003#[derive(Debug, Clone, PartialEq, Eq)]
14004pub enum LocalBindsDecl<'tree> {
14005 Decl(::std::boxed::Box<Decl<'tree>>),
14006 Fixity(::std::boxed::Box<Fixity<'tree>>),
14007}
14008impl<'tree> ::treesitter_types::FromNode<'tree> for LocalBindsDecl<'tree> {
14009 #[allow(clippy::collapsible_else_if)]
14010 fn from_node(
14011 node: ::treesitter_types::tree_sitter::Node<'tree>,
14012 src: &'tree [u8],
14013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14014 match node.kind() {
14015 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
14016 ::treesitter_types::runtime::maybe_grow_stack(|| {
14017 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)
14018 })?,
14019 ))),
14020 _other => {
14021 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14022 <Decl as ::treesitter_types::FromNode>::from_node(node, src)
14023 }) {
14024 Ok(Self::Decl(::std::boxed::Box::new(v)))
14025 } else {
14026 Err(::treesitter_types::ParseError::unexpected_kind(
14027 _other, node,
14028 ))
14029 }
14030 }
14031 }
14032 }
14033}
14034impl ::treesitter_types::Spanned for LocalBindsDecl<'_> {
14035 fn span(&self) -> ::treesitter_types::Span {
14036 match self {
14037 Self::Decl(inner) => inner.span(),
14038 Self::Fixity(inner) => inner.span(),
14039 }
14040 }
14041}
14042#[derive(Debug, Clone, PartialEq, Eq)]
14043pub enum MatchExpression<'tree> {
14044 Expression(::std::boxed::Box<Expression<'tree>>),
14045 Signature(::std::boxed::Box<Signature<'tree>>),
14046}
14047impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
14048 #[allow(clippy::collapsible_else_if)]
14049 fn from_node(
14050 node: ::treesitter_types::tree_sitter::Node<'tree>,
14051 src: &'tree [u8],
14052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14053 match node.kind() {
14054 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14055 ::treesitter_types::runtime::maybe_grow_stack(|| {
14056 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14057 })?,
14058 ))),
14059 _other => {
14060 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14061 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14062 }) {
14063 Ok(Self::Expression(::std::boxed::Box::new(v)))
14064 } else {
14065 Err(::treesitter_types::ParseError::unexpected_kind(
14066 _other, node,
14067 ))
14068 }
14069 }
14070 }
14071 }
14072}
14073impl ::treesitter_types::Spanned for MatchExpression<'_> {
14074 fn span(&self) -> ::treesitter_types::Span {
14075 match self {
14076 Self::Expression(inner) => inner.span(),
14077 Self::Signature(inner) => inner.span(),
14078 }
14079 }
14080}
14081#[derive(Debug, Clone, PartialEq, Eq)]
14082pub enum NegationMinus {
14083 Minus(::treesitter_types::Span),
14084}
14085impl<'tree> ::treesitter_types::FromNode<'tree> for NegationMinus {
14086 #[allow(clippy::collapsible_else_if)]
14087 fn from_node(
14088 node: ::treesitter_types::tree_sitter::Node<'tree>,
14089 _src: &'tree [u8],
14090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14091 match node.kind() {
14092 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
14093 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14094 }
14095 }
14096}
14097impl ::treesitter_types::Spanned for NegationMinus {
14098 fn span(&self) -> ::treesitter_types::Span {
14099 match self {
14100 Self::Minus(span) => *span,
14101 }
14102 }
14103}
14104#[derive(Debug, Clone, PartialEq, Eq)]
14105pub enum NegationNumber<'tree> {
14106 Float(::std::boxed::Box<Float<'tree>>),
14107 Integer(::std::boxed::Box<Integer<'tree>>),
14108}
14109impl<'tree> ::treesitter_types::FromNode<'tree> for NegationNumber<'tree> {
14110 #[allow(clippy::collapsible_else_if)]
14111 fn from_node(
14112 node: ::treesitter_types::tree_sitter::Node<'tree>,
14113 src: &'tree [u8],
14114 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14115 match node.kind() {
14116 "float" => Ok(Self::Float(::std::boxed::Box::new(
14117 ::treesitter_types::runtime::maybe_grow_stack(|| {
14118 <Float as ::treesitter_types::FromNode>::from_node(node, src)
14119 })?,
14120 ))),
14121 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
14122 ::treesitter_types::runtime::maybe_grow_stack(|| {
14123 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
14124 })?,
14125 ))),
14126 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14127 }
14128 }
14129}
14130impl ::treesitter_types::Spanned for NegationNumber<'_> {
14131 fn span(&self) -> ::treesitter_types::Span {
14132 match self {
14133 Self::Float(inner) => inner.span(),
14134 Self::Integer(inner) => inner.span(),
14135 }
14136 }
14137}
14138#[derive(Debug, Clone, PartialEq, Eq)]
14139pub enum NewtypeForall<'tree> {
14140 Forall(::std::boxed::Box<Forall<'tree>>),
14141 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
14142}
14143impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeForall<'tree> {
14144 #[allow(clippy::collapsible_else_if)]
14145 fn from_node(
14146 node: ::treesitter_types::tree_sitter::Node<'tree>,
14147 src: &'tree [u8],
14148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14149 match node.kind() {
14150 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
14151 ::treesitter_types::runtime::maybe_grow_stack(|| {
14152 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
14153 })?,
14154 ))),
14155 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
14156 ::treesitter_types::runtime::maybe_grow_stack(|| {
14157 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
14158 })?,
14159 ))),
14160 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14161 }
14162 }
14163}
14164impl ::treesitter_types::Spanned for NewtypeForall<'_> {
14165 fn span(&self) -> ::treesitter_types::Span {
14166 match self {
14167 Self::Forall(inner) => inner.span(),
14168 Self::ForallRequired(inner) => inner.span(),
14169 }
14170 }
14171}
14172#[derive(Debug, Clone, PartialEq, Eq)]
14173pub enum NewtypeName<'tree> {
14174 Name(::std::boxed::Box<Name<'tree>>),
14175 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14176 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
14177 Qualified(::std::boxed::Box<Qualified<'tree>>),
14178 Unit(::std::boxed::Box<Unit<'tree>>),
14179}
14180impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeName<'tree> {
14181 #[allow(clippy::collapsible_else_if)]
14182 fn from_node(
14183 node: ::treesitter_types::tree_sitter::Node<'tree>,
14184 src: &'tree [u8],
14185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14186 match node.kind() {
14187 "name" => Ok(Self::Name(::std::boxed::Box::new(
14188 ::treesitter_types::runtime::maybe_grow_stack(|| {
14189 <Name as ::treesitter_types::FromNode>::from_node(node, src)
14190 })?,
14191 ))),
14192 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14193 ::treesitter_types::runtime::maybe_grow_stack(|| {
14194 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
14195 })?,
14196 ))),
14197 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
14198 ::treesitter_types::runtime::maybe_grow_stack(|| {
14199 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
14200 })?,
14201 ))),
14202 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14203 ::treesitter_types::runtime::maybe_grow_stack(|| {
14204 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
14205 })?,
14206 ))),
14207 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
14208 ::treesitter_types::runtime::maybe_grow_stack(|| {
14209 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
14210 })?,
14211 ))),
14212 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14213 }
14214 }
14215}
14216impl ::treesitter_types::Spanned for NewtypeName<'_> {
14217 fn span(&self) -> ::treesitter_types::Span {
14218 match self {
14219 Self::Name(inner) => inner.span(),
14220 Self::PrefixId(inner) => inner.span(),
14221 Self::PrefixList(inner) => inner.span(),
14222 Self::Qualified(inner) => inner.span(),
14223 Self::Unit(inner) => inner.span(),
14224 }
14225 }
14226}
14227#[derive(Debug, Clone, PartialEq, Eq)]
14228pub enum NewtypePatterns<'tree> {
14229 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
14230 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
14231}
14232impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypePatterns<'tree> {
14233 #[allow(clippy::collapsible_else_if)]
14234 fn from_node(
14235 node: ::treesitter_types::tree_sitter::Node<'tree>,
14236 src: &'tree [u8],
14237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14238 match node.kind() {
14239 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
14240 ::treesitter_types::runtime::maybe_grow_stack(|| {
14241 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)
14242 })?,
14243 ))),
14244 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
14245 ::treesitter_types::runtime::maybe_grow_stack(|| {
14246 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)
14247 })?,
14248 ))),
14249 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14250 }
14251 }
14252}
14253impl ::treesitter_types::Spanned for NewtypePatterns<'_> {
14254 fn span(&self) -> ::treesitter_types::Span {
14255 match self {
14256 Self::TypeParams(inner) => inner.span(),
14257 Self::TypePatterns(inner) => inner.span(),
14258 }
14259 }
14260}
14261#[derive(Debug, Clone, PartialEq, Eq)]
14262pub enum NewtypeChildren<'tree> {
14263 Infix(::std::boxed::Box<Infix<'tree>>),
14264 Parens(::std::boxed::Box<Parens<'tree>>),
14265}
14266impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeChildren<'tree> {
14267 #[allow(clippy::collapsible_else_if)]
14268 fn from_node(
14269 node: ::treesitter_types::tree_sitter::Node<'tree>,
14270 src: &'tree [u8],
14271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14272 match node.kind() {
14273 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
14274 ::treesitter_types::runtime::maybe_grow_stack(|| {
14275 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
14276 })?,
14277 ))),
14278 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
14279 ::treesitter_types::runtime::maybe_grow_stack(|| {
14280 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
14281 })?,
14282 ))),
14283 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14284 }
14285 }
14286}
14287impl ::treesitter_types::Spanned for NewtypeChildren<'_> {
14288 fn span(&self) -> ::treesitter_types::Span {
14289 match self {
14290 Self::Infix(inner) => inner.span(),
14291 Self::Parens(inner) => inner.span(),
14292 }
14293 }
14294}
14295#[derive(Debug, Clone, PartialEq, Eq)]
14296pub enum NewtypeConstructorField<'tree> {
14297 Field(::std::boxed::Box<Field<'tree>>),
14298 Record(::std::boxed::Box<Record<'tree>>),
14299}
14300impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructorField<'tree> {
14301 #[allow(clippy::collapsible_else_if)]
14302 fn from_node(
14303 node: ::treesitter_types::tree_sitter::Node<'tree>,
14304 src: &'tree [u8],
14305 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14306 match node.kind() {
14307 "field" => Ok(Self::Field(::std::boxed::Box::new(
14308 ::treesitter_types::runtime::maybe_grow_stack(|| {
14309 <Field as ::treesitter_types::FromNode>::from_node(node, src)
14310 })?,
14311 ))),
14312 "record" => Ok(Self::Record(::std::boxed::Box::new(
14313 ::treesitter_types::runtime::maybe_grow_stack(|| {
14314 <Record as ::treesitter_types::FromNode>::from_node(node, src)
14315 })?,
14316 ))),
14317 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14318 }
14319 }
14320}
14321impl ::treesitter_types::Spanned for NewtypeConstructorField<'_> {
14322 fn span(&self) -> ::treesitter_types::Span {
14323 match self {
14324 Self::Field(inner) => inner.span(),
14325 Self::Record(inner) => inner.span(),
14326 }
14327 }
14328}
14329#[derive(Debug, Clone, PartialEq, Eq)]
14330pub enum NewtypeConstructorName<'tree> {
14331 Constructor(::std::boxed::Box<Constructor<'tree>>),
14332 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14333}
14334impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructorName<'tree> {
14335 #[allow(clippy::collapsible_else_if)]
14336 fn from_node(
14337 node: ::treesitter_types::tree_sitter::Node<'tree>,
14338 src: &'tree [u8],
14339 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14340 match node.kind() {
14341 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14342 ::treesitter_types::runtime::maybe_grow_stack(|| {
14343 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
14344 })?,
14345 ))),
14346 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14347 ::treesitter_types::runtime::maybe_grow_stack(|| {
14348 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
14349 })?,
14350 ))),
14351 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14352 }
14353 }
14354}
14355impl ::treesitter_types::Spanned for NewtypeConstructorName<'_> {
14356 fn span(&self) -> ::treesitter_types::Span {
14357 match self {
14358 Self::Constructor(inner) => inner.span(),
14359 Self::PrefixId(inner) => inner.span(),
14360 }
14361 }
14362}
14363#[derive(Debug, Clone, PartialEq, Eq)]
14364pub enum ParensExpression<'tree> {
14365 Expression(::std::boxed::Box<Expression<'tree>>),
14366 Signature(::std::boxed::Box<Signature<'tree>>),
14367}
14368impl<'tree> ::treesitter_types::FromNode<'tree> for ParensExpression<'tree> {
14369 #[allow(clippy::collapsible_else_if)]
14370 fn from_node(
14371 node: ::treesitter_types::tree_sitter::Node<'tree>,
14372 src: &'tree [u8],
14373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14374 match node.kind() {
14375 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14376 ::treesitter_types::runtime::maybe_grow_stack(|| {
14377 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14378 })?,
14379 ))),
14380 _other => {
14381 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14382 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14383 }) {
14384 Ok(Self::Expression(::std::boxed::Box::new(v)))
14385 } else {
14386 Err(::treesitter_types::ParseError::unexpected_kind(
14387 _other, node,
14388 ))
14389 }
14390 }
14391 }
14392 }
14393}
14394impl ::treesitter_types::Spanned for ParensExpression<'_> {
14395 fn span(&self) -> ::treesitter_types::Span {
14396 match self {
14397 Self::Expression(inner) => inner.span(),
14398 Self::Signature(inner) => inner.span(),
14399 }
14400 }
14401}
14402#[derive(Debug, Clone, PartialEq, Eq)]
14403pub enum ParensName<'tree> {
14404 Name(::std::boxed::Box<Name<'tree>>),
14405 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14406 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
14407 Qualified(::std::boxed::Box<Qualified<'tree>>),
14408 Unit(::std::boxed::Box<Unit<'tree>>),
14409}
14410impl<'tree> ::treesitter_types::FromNode<'tree> for ParensName<'tree> {
14411 #[allow(clippy::collapsible_else_if)]
14412 fn from_node(
14413 node: ::treesitter_types::tree_sitter::Node<'tree>,
14414 src: &'tree [u8],
14415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14416 match node.kind() {
14417 "name" => Ok(Self::Name(::std::boxed::Box::new(
14418 ::treesitter_types::runtime::maybe_grow_stack(|| {
14419 <Name as ::treesitter_types::FromNode>::from_node(node, src)
14420 })?,
14421 ))),
14422 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14423 ::treesitter_types::runtime::maybe_grow_stack(|| {
14424 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
14425 })?,
14426 ))),
14427 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
14428 ::treesitter_types::runtime::maybe_grow_stack(|| {
14429 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
14430 })?,
14431 ))),
14432 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14433 ::treesitter_types::runtime::maybe_grow_stack(|| {
14434 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
14435 })?,
14436 ))),
14437 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
14438 ::treesitter_types::runtime::maybe_grow_stack(|| {
14439 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
14440 })?,
14441 ))),
14442 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14443 }
14444 }
14445}
14446impl ::treesitter_types::Spanned for ParensName<'_> {
14447 fn span(&self) -> ::treesitter_types::Span {
14448 match self {
14449 Self::Name(inner) => inner.span(),
14450 Self::PrefixId(inner) => inner.span(),
14451 Self::PrefixList(inner) => inner.span(),
14452 Self::Qualified(inner) => inner.span(),
14453 Self::Unit(inner) => inner.span(),
14454 }
14455 }
14456}
14457#[derive(Debug, Clone, PartialEq, Eq)]
14458pub enum ParensPattern<'tree> {
14459 Pattern(::std::boxed::Box<Pattern<'tree>>),
14460 Signature(::std::boxed::Box<Signature<'tree>>),
14461 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
14462}
14463impl<'tree> ::treesitter_types::FromNode<'tree> for ParensPattern<'tree> {
14464 #[allow(clippy::collapsible_else_if)]
14465 fn from_node(
14466 node: ::treesitter_types::tree_sitter::Node<'tree>,
14467 src: &'tree [u8],
14468 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14469 match node.kind() {
14470 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14471 ::treesitter_types::runtime::maybe_grow_stack(|| {
14472 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14473 })?,
14474 ))),
14475 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
14476 ::treesitter_types::runtime::maybe_grow_stack(|| {
14477 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
14478 })?,
14479 ))),
14480 _other => {
14481 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14482 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
14483 }) {
14484 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14485 } else {
14486 Err(::treesitter_types::ParseError::unexpected_kind(
14487 _other, node,
14488 ))
14489 }
14490 }
14491 }
14492 }
14493}
14494impl ::treesitter_types::Spanned for ParensPattern<'_> {
14495 fn span(&self) -> ::treesitter_types::Span {
14496 match self {
14497 Self::Pattern(inner) => inner.span(),
14498 Self::Signature(inner) => inner.span(),
14499 Self::ViewPattern(inner) => inner.span(),
14500 }
14501 }
14502}
14503#[derive(Debug, Clone, PartialEq, Eq)]
14504pub enum ParensPatterns<'tree> {
14505 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
14506 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
14507}
14508impl<'tree> ::treesitter_types::FromNode<'tree> for ParensPatterns<'tree> {
14509 #[allow(clippy::collapsible_else_if)]
14510 fn from_node(
14511 node: ::treesitter_types::tree_sitter::Node<'tree>,
14512 src: &'tree [u8],
14513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14514 match node.kind() {
14515 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
14516 ::treesitter_types::runtime::maybe_grow_stack(|| {
14517 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)
14518 })?,
14519 ))),
14520 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
14521 ::treesitter_types::runtime::maybe_grow_stack(|| {
14522 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)
14523 })?,
14524 ))),
14525 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14526 }
14527 }
14528}
14529impl ::treesitter_types::Spanned for ParensPatterns<'_> {
14530 fn span(&self) -> ::treesitter_types::Span {
14531 match self {
14532 Self::TypeParams(inner) => inner.span(),
14533 Self::TypePatterns(inner) => inner.span(),
14534 }
14535 }
14536}
14537#[derive(Debug, Clone, PartialEq, Eq)]
14538pub enum ParensType<'tree> {
14539 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
14540 Signature(::std::boxed::Box<Signature<'tree>>),
14541}
14542impl<'tree> ::treesitter_types::FromNode<'tree> for ParensType<'tree> {
14543 #[allow(clippy::collapsible_else_if)]
14544 fn from_node(
14545 node: ::treesitter_types::tree_sitter::Node<'tree>,
14546 src: &'tree [u8],
14547 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14548 match node.kind() {
14549 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14550 ::treesitter_types::runtime::maybe_grow_stack(|| {
14551 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14552 })?,
14553 ))),
14554 _other => {
14555 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14556 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
14557 }) {
14558 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
14559 } else {
14560 Err(::treesitter_types::ParseError::unexpected_kind(
14561 _other, node,
14562 ))
14563 }
14564 }
14565 }
14566 }
14567}
14568impl ::treesitter_types::Spanned for ParensType<'_> {
14569 fn span(&self) -> ::treesitter_types::Span {
14570 match self {
14571 Self::QuantifiedType(inner) => inner.span(),
14572 Self::Signature(inner) => inner.span(),
14573 }
14574 }
14575}
14576#[derive(Debug, Clone, PartialEq, Eq)]
14577pub enum ParensChildren<'tree> {
14578 Annotated(::std::boxed::Box<Annotated<'tree>>),
14579 Constraints(::std::boxed::Box<Constraints<'tree>>),
14580 Infix(::std::boxed::Box<Infix<'tree>>),
14581 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
14582}
14583impl<'tree> ::treesitter_types::FromNode<'tree> for ParensChildren<'tree> {
14584 #[allow(clippy::collapsible_else_if)]
14585 fn from_node(
14586 node: ::treesitter_types::tree_sitter::Node<'tree>,
14587 src: &'tree [u8],
14588 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14589 match node.kind() {
14590 "annotated" => Ok(Self::Annotated(::std::boxed::Box::new(
14591 ::treesitter_types::runtime::maybe_grow_stack(|| {
14592 <Annotated as ::treesitter_types::FromNode>::from_node(node, src)
14593 })?,
14594 ))),
14595 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
14596 ::treesitter_types::runtime::maybe_grow_stack(|| {
14597 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
14598 })?,
14599 ))),
14600 _other => {
14601 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14602 <Constraints as ::treesitter_types::FromNode>::from_node(node, src)
14603 }) {
14604 Ok(Self::Constraints(::std::boxed::Box::new(v)))
14605 } else {
14606 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14607 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
14608 }) {
14609 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
14610 } else {
14611 Err(::treesitter_types::ParseError::unexpected_kind(
14612 _other, node,
14613 ))
14614 }
14615 }
14616 }
14617 }
14618 }
14619}
14620impl ::treesitter_types::Spanned for ParensChildren<'_> {
14621 fn span(&self) -> ::treesitter_types::Span {
14622 match self {
14623 Self::Annotated(inner) => inner.span(),
14624 Self::Constraints(inner) => inner.span(),
14625 Self::Infix(inner) => inner.span(),
14626 Self::TypeParam(inner) => inner.span(),
14627 }
14628 }
14629}
14630#[derive(Debug, Clone, PartialEq, Eq)]
14631pub enum PatternGuardArrow {
14632 LArrow(::treesitter_types::Span),
14633 X(::treesitter_types::Span),
14634}
14635impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardArrow {
14636 #[allow(clippy::collapsible_else_if)]
14637 fn from_node(
14638 node: ::treesitter_types::tree_sitter::Node<'tree>,
14639 _src: &'tree [u8],
14640 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14641 match node.kind() {
14642 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
14643 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
14644 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14645 }
14646 }
14647}
14648impl ::treesitter_types::Spanned for PatternGuardArrow {
14649 fn span(&self) -> ::treesitter_types::Span {
14650 match self {
14651 Self::LArrow(span) => *span,
14652 Self::X(span) => *span,
14653 }
14654 }
14655}
14656#[derive(Debug, Clone, PartialEq, Eq)]
14657pub enum PatternGuardExpression<'tree> {
14658 Expression(::std::boxed::Box<Expression<'tree>>),
14659 Signature(::std::boxed::Box<Signature<'tree>>),
14660}
14661impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardExpression<'tree> {
14662 #[allow(clippy::collapsible_else_if)]
14663 fn from_node(
14664 node: ::treesitter_types::tree_sitter::Node<'tree>,
14665 src: &'tree [u8],
14666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14667 match node.kind() {
14668 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14669 ::treesitter_types::runtime::maybe_grow_stack(|| {
14670 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14671 })?,
14672 ))),
14673 _other => {
14674 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14675 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
14676 }) {
14677 Ok(Self::Expression(::std::boxed::Box::new(v)))
14678 } else {
14679 Err(::treesitter_types::ParseError::unexpected_kind(
14680 _other, node,
14681 ))
14682 }
14683 }
14684 }
14685 }
14686}
14687impl ::treesitter_types::Spanned for PatternGuardExpression<'_> {
14688 fn span(&self) -> ::treesitter_types::Span {
14689 match self {
14690 Self::Expression(inner) => inner.span(),
14691 Self::Signature(inner) => inner.span(),
14692 }
14693 }
14694}
14695#[derive(Debug, Clone, PartialEq, Eq)]
14696pub enum PatternGuardPattern<'tree> {
14697 Pattern(::std::boxed::Box<Pattern<'tree>>),
14698 Signature(::std::boxed::Box<Signature<'tree>>),
14699}
14700impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardPattern<'tree> {
14701 #[allow(clippy::collapsible_else_if)]
14702 fn from_node(
14703 node: ::treesitter_types::tree_sitter::Node<'tree>,
14704 src: &'tree [u8],
14705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14706 match node.kind() {
14707 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14708 ::treesitter_types::runtime::maybe_grow_stack(|| {
14709 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14710 })?,
14711 ))),
14712 _other => {
14713 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14714 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
14715 }) {
14716 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14717 } else {
14718 Err(::treesitter_types::ParseError::unexpected_kind(
14719 _other, node,
14720 ))
14721 }
14722 }
14723 }
14724 }
14725}
14726impl ::treesitter_types::Spanned for PatternGuardPattern<'_> {
14727 fn span(&self) -> ::treesitter_types::Span {
14728 match self {
14729 Self::Pattern(inner) => inner.span(),
14730 Self::Signature(inner) => inner.span(),
14731 }
14732 }
14733}
14734#[derive(Debug, Clone, PartialEq, Eq)]
14735pub enum PatternSynonymChildren<'tree> {
14736 Equation(::std::boxed::Box<Equation<'tree>>),
14737 Signature(::std::boxed::Box<Signature<'tree>>),
14738}
14739impl<'tree> ::treesitter_types::FromNode<'tree> for PatternSynonymChildren<'tree> {
14740 #[allow(clippy::collapsible_else_if)]
14741 fn from_node(
14742 node: ::treesitter_types::tree_sitter::Node<'tree>,
14743 src: &'tree [u8],
14744 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14745 match node.kind() {
14746 "equation" => Ok(Self::Equation(::std::boxed::Box::new(
14747 ::treesitter_types::runtime::maybe_grow_stack(|| {
14748 <Equation as ::treesitter_types::FromNode>::from_node(node, src)
14749 })?,
14750 ))),
14751 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14752 ::treesitter_types::runtime::maybe_grow_stack(|| {
14753 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
14754 })?,
14755 ))),
14756 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14757 }
14758 }
14759}
14760impl ::treesitter_types::Spanned for PatternSynonymChildren<'_> {
14761 fn span(&self) -> ::treesitter_types::Span {
14762 match self {
14763 Self::Equation(inner) => inner.span(),
14764 Self::Signature(inner) => inner.span(),
14765 }
14766 }
14767}
14768#[derive(Debug, Clone, PartialEq, Eq)]
14769pub enum PatternsChildren<'tree> {
14770 ExplicitType(::std::boxed::Box<ExplicitType<'tree>>),
14771 Pattern(::std::boxed::Box<Pattern<'tree>>),
14772 TypeBinder(::std::boxed::Box<TypeBinder<'tree>>),
14773}
14774impl<'tree> ::treesitter_types::FromNode<'tree> for PatternsChildren<'tree> {
14775 #[allow(clippy::collapsible_else_if)]
14776 fn from_node(
14777 node: ::treesitter_types::tree_sitter::Node<'tree>,
14778 src: &'tree [u8],
14779 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14780 match node.kind() {
14781 "explicit_type" => Ok(Self::ExplicitType(::std::boxed::Box::new(
14782 ::treesitter_types::runtime::maybe_grow_stack(|| {
14783 <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)
14784 })?,
14785 ))),
14786 "type_binder" => Ok(Self::TypeBinder(::std::boxed::Box::new(
14787 ::treesitter_types::runtime::maybe_grow_stack(|| {
14788 <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)
14789 })?,
14790 ))),
14791 _other => {
14792 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14793 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
14794 }) {
14795 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14796 } else {
14797 Err(::treesitter_types::ParseError::unexpected_kind(
14798 _other, node,
14799 ))
14800 }
14801 }
14802 }
14803 }
14804}
14805impl ::treesitter_types::Spanned for PatternsChildren<'_> {
14806 fn span(&self) -> ::treesitter_types::Span {
14807 match self {
14808 Self::ExplicitType(inner) => inner.span(),
14809 Self::Pattern(inner) => inner.span(),
14810 Self::TypeBinder(inner) => inner.span(),
14811 }
14812 }
14813}
14814#[derive(Debug, Clone, PartialEq, Eq)]
14815pub enum PrefixField<'tree> {
14816 LazyField(::std::boxed::Box<LazyField<'tree>>),
14817 StrictField(::std::boxed::Box<StrictField<'tree>>),
14818 Type(::std::boxed::Box<Type<'tree>>),
14819}
14820impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixField<'tree> {
14821 #[allow(clippy::collapsible_else_if)]
14822 fn from_node(
14823 node: ::treesitter_types::tree_sitter::Node<'tree>,
14824 src: &'tree [u8],
14825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14826 match node.kind() {
14827 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
14828 ::treesitter_types::runtime::maybe_grow_stack(|| {
14829 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
14830 })?,
14831 ))),
14832 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
14833 ::treesitter_types::runtime::maybe_grow_stack(|| {
14834 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
14835 })?,
14836 ))),
14837 _other => {
14838 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
14839 <Type as ::treesitter_types::FromNode>::from_node(node, src)
14840 }) {
14841 Ok(Self::Type(::std::boxed::Box::new(v)))
14842 } else {
14843 Err(::treesitter_types::ParseError::unexpected_kind(
14844 _other, node,
14845 ))
14846 }
14847 }
14848 }
14849 }
14850}
14851impl ::treesitter_types::Spanned for PrefixField<'_> {
14852 fn span(&self) -> ::treesitter_types::Span {
14853 match self {
14854 Self::LazyField(inner) => inner.span(),
14855 Self::StrictField(inner) => inner.span(),
14856 Self::Type(inner) => inner.span(),
14857 }
14858 }
14859}
14860#[derive(Debug, Clone, PartialEq, Eq)]
14861pub enum PrefixName<'tree> {
14862 Constructor(::std::boxed::Box<Constructor<'tree>>),
14863 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14864}
14865impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixName<'tree> {
14866 #[allow(clippy::collapsible_else_if)]
14867 fn from_node(
14868 node: ::treesitter_types::tree_sitter::Node<'tree>,
14869 src: &'tree [u8],
14870 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14871 match node.kind() {
14872 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14873 ::treesitter_types::runtime::maybe_grow_stack(|| {
14874 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
14875 })?,
14876 ))),
14877 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14878 ::treesitter_types::runtime::maybe_grow_stack(|| {
14879 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
14880 })?,
14881 ))),
14882 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14883 }
14884 }
14885}
14886impl ::treesitter_types::Spanned for PrefixName<'_> {
14887 fn span(&self) -> ::treesitter_types::Span {
14888 match self {
14889 Self::Constructor(inner) => inner.span(),
14890 Self::PrefixId(inner) => inner.span(),
14891 }
14892 }
14893}
14894#[derive(Debug, Clone, PartialEq, Eq)]
14895pub enum PrefixIdChildren<'tree> {
14896 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
14897 Operator(::std::boxed::Box<Operator<'tree>>),
14898 Qualified(::std::boxed::Box<Qualified<'tree>>),
14899}
14900impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixIdChildren<'tree> {
14901 #[allow(clippy::collapsible_else_if)]
14902 fn from_node(
14903 node: ::treesitter_types::tree_sitter::Node<'tree>,
14904 src: &'tree [u8],
14905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14906 match node.kind() {
14907 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
14908 ::treesitter_types::runtime::maybe_grow_stack(|| {
14909 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
14910 })?,
14911 ))),
14912 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
14913 ::treesitter_types::runtime::maybe_grow_stack(|| {
14914 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
14915 })?,
14916 ))),
14917 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14918 ::treesitter_types::runtime::maybe_grow_stack(|| {
14919 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
14920 })?,
14921 ))),
14922 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14923 }
14924 }
14925}
14926impl ::treesitter_types::Spanned for PrefixIdChildren<'_> {
14927 fn span(&self) -> ::treesitter_types::Span {
14928 match self {
14929 Self::ConstructorOperator(inner) => inner.span(),
14930 Self::Operator(inner) => inner.span(),
14931 Self::Qualified(inner) => inner.span(),
14932 }
14933 }
14934}
14935#[derive(Debug, Clone, PartialEq, Eq)]
14936pub enum PromotedChildren<'tree> {
14937 Constructor(::std::boxed::Box<Constructor<'tree>>),
14938 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
14939 EmptyList(::std::boxed::Box<EmptyList<'tree>>),
14940 InfixId(::std::boxed::Box<InfixId<'tree>>),
14941 List(::std::boxed::Box<List<'tree>>),
14942 Operator(::std::boxed::Box<Operator<'tree>>),
14943 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14944 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
14945 Qualified(::std::boxed::Box<Qualified<'tree>>),
14946 Tuple(::std::boxed::Box<Tuple<'tree>>),
14947 Unit(::std::boxed::Box<Unit<'tree>>),
14948}
14949impl<'tree> ::treesitter_types::FromNode<'tree> for PromotedChildren<'tree> {
14950 #[allow(clippy::collapsible_else_if)]
14951 fn from_node(
14952 node: ::treesitter_types::tree_sitter::Node<'tree>,
14953 src: &'tree [u8],
14954 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14955 match node.kind() {
14956 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14957 ::treesitter_types::runtime::maybe_grow_stack(|| {
14958 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
14959 })?,
14960 ))),
14961 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
14962 ::treesitter_types::runtime::maybe_grow_stack(|| {
14963 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
14964 })?,
14965 ))),
14966 "empty_list" => Ok(Self::EmptyList(::std::boxed::Box::new(
14967 ::treesitter_types::runtime::maybe_grow_stack(|| {
14968 <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)
14969 })?,
14970 ))),
14971 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
14972 ::treesitter_types::runtime::maybe_grow_stack(|| {
14973 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
14974 })?,
14975 ))),
14976 "list" => Ok(Self::List(::std::boxed::Box::new(
14977 ::treesitter_types::runtime::maybe_grow_stack(|| {
14978 <List as ::treesitter_types::FromNode>::from_node(node, src)
14979 })?,
14980 ))),
14981 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
14982 ::treesitter_types::runtime::maybe_grow_stack(|| {
14983 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
14984 })?,
14985 ))),
14986 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14987 ::treesitter_types::runtime::maybe_grow_stack(|| {
14988 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
14989 })?,
14990 ))),
14991 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
14992 ::treesitter_types::runtime::maybe_grow_stack(|| {
14993 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
14994 })?,
14995 ))),
14996 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14997 ::treesitter_types::runtime::maybe_grow_stack(|| {
14998 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
14999 })?,
15000 ))),
15001 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
15002 ::treesitter_types::runtime::maybe_grow_stack(|| {
15003 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
15004 })?,
15005 ))),
15006 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
15007 ::treesitter_types::runtime::maybe_grow_stack(|| {
15008 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
15009 })?,
15010 ))),
15011 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15012 }
15013 }
15014}
15015impl ::treesitter_types::Spanned for PromotedChildren<'_> {
15016 fn span(&self) -> ::treesitter_types::Span {
15017 match self {
15018 Self::Constructor(inner) => inner.span(),
15019 Self::ConstructorOperator(inner) => inner.span(),
15020 Self::EmptyList(inner) => inner.span(),
15021 Self::InfixId(inner) => inner.span(),
15022 Self::List(inner) => inner.span(),
15023 Self::Operator(inner) => inner.span(),
15024 Self::PrefixId(inner) => inner.span(),
15025 Self::PrefixTuple(inner) => inner.span(),
15026 Self::Qualified(inner) => inner.span(),
15027 Self::Tuple(inner) => inner.span(),
15028 Self::Unit(inner) => inner.span(),
15029 }
15030 }
15031}
15032#[derive(Debug, Clone, PartialEq, Eq)]
15033pub enum QualifiedId<'tree> {
15034 Constructor(::std::boxed::Box<Constructor<'tree>>),
15035 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
15036 FieldName(::std::boxed::Box<FieldName<'tree>>),
15037 Name(::std::boxed::Box<Name<'tree>>),
15038 Operator(::std::boxed::Box<Operator<'tree>>),
15039 Variable(::std::boxed::Box<Variable<'tree>>),
15040}
15041impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedId<'tree> {
15042 #[allow(clippy::collapsible_else_if)]
15043 fn from_node(
15044 node: ::treesitter_types::tree_sitter::Node<'tree>,
15045 src: &'tree [u8],
15046 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15047 match node.kind() {
15048 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
15049 ::treesitter_types::runtime::maybe_grow_stack(|| {
15050 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
15051 })?,
15052 ))),
15053 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
15054 ::treesitter_types::runtime::maybe_grow_stack(|| {
15055 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
15056 })?,
15057 ))),
15058 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
15059 ::treesitter_types::runtime::maybe_grow_stack(|| {
15060 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
15061 })?,
15062 ))),
15063 "name" => Ok(Self::Name(::std::boxed::Box::new(
15064 ::treesitter_types::runtime::maybe_grow_stack(|| {
15065 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15066 })?,
15067 ))),
15068 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
15069 ::treesitter_types::runtime::maybe_grow_stack(|| {
15070 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
15071 })?,
15072 ))),
15073 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
15074 ::treesitter_types::runtime::maybe_grow_stack(|| {
15075 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
15076 })?,
15077 ))),
15078 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15079 }
15080 }
15081}
15082impl ::treesitter_types::Spanned for QualifiedId<'_> {
15083 fn span(&self) -> ::treesitter_types::Span {
15084 match self {
15085 Self::Constructor(inner) => inner.span(),
15086 Self::ConstructorOperator(inner) => inner.span(),
15087 Self::FieldName(inner) => inner.span(),
15088 Self::Name(inner) => inner.span(),
15089 Self::Operator(inner) => inner.span(),
15090 Self::Variable(inner) => inner.span(),
15091 }
15092 }
15093}
15094#[derive(Debug, Clone, PartialEq, Eq)]
15095pub enum QuantifiedVariablesChildren<'tree> {
15096 Inferred(::std::boxed::Box<Inferred<'tree>>),
15097 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
15098}
15099impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedVariablesChildren<'tree> {
15100 #[allow(clippy::collapsible_else_if)]
15101 fn from_node(
15102 node: ::treesitter_types::tree_sitter::Node<'tree>,
15103 src: &'tree [u8],
15104 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15105 match node.kind() {
15106 "inferred" => Ok(Self::Inferred(::std::boxed::Box::new(
15107 ::treesitter_types::runtime::maybe_grow_stack(|| {
15108 <Inferred as ::treesitter_types::FromNode>::from_node(node, src)
15109 })?,
15110 ))),
15111 _other => {
15112 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15113 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
15114 }) {
15115 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
15116 } else {
15117 Err(::treesitter_types::ParseError::unexpected_kind(
15118 _other, node,
15119 ))
15120 }
15121 }
15122 }
15123 }
15124}
15125impl ::treesitter_types::Spanned for QuantifiedVariablesChildren<'_> {
15126 fn span(&self) -> ::treesitter_types::Span {
15127 match self {
15128 Self::Inferred(inner) => inner.span(),
15129 Self::TypeParam(inner) => inner.span(),
15130 }
15131 }
15132}
15133#[derive(Debug, Clone, PartialEq, Eq)]
15134pub enum QuoteQuoter {
15135 D(::treesitter_types::Span),
15136 E(::treesitter_types::Span),
15137 P(::treesitter_types::Span),
15138 T(::treesitter_types::Span),
15139}
15140impl<'tree> ::treesitter_types::FromNode<'tree> for QuoteQuoter {
15141 #[allow(clippy::collapsible_else_if)]
15142 fn from_node(
15143 node: ::treesitter_types::tree_sitter::Node<'tree>,
15144 _src: &'tree [u8],
15145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15146 match node.kind() {
15147 "d" => Ok(Self::D(::treesitter_types::Span::from(node))),
15148 "e" => Ok(Self::E(::treesitter_types::Span::from(node))),
15149 "p" => Ok(Self::P(::treesitter_types::Span::from(node))),
15150 "t" => Ok(Self::T(::treesitter_types::Span::from(node))),
15151 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15152 }
15153 }
15154}
15155impl ::treesitter_types::Spanned for QuoteQuoter {
15156 fn span(&self) -> ::treesitter_types::Span {
15157 match self {
15158 Self::D(span) => *span,
15159 Self::E(span) => *span,
15160 Self::P(span) => *span,
15161 Self::T(span) => *span,
15162 }
15163 }
15164}
15165#[derive(Debug, Clone, PartialEq, Eq)]
15166pub enum QuoteChildren<'tree> {
15167 QuotedDecls(::std::boxed::Box<QuotedDecls<'tree>>),
15168 QuotedExpression(::std::boxed::Box<QuotedExpression<'tree>>),
15169 QuotedPattern(::std::boxed::Box<QuotedPattern<'tree>>),
15170 QuotedType(::std::boxed::Box<QuotedType<'tree>>),
15171}
15172impl<'tree> ::treesitter_types::FromNode<'tree> for QuoteChildren<'tree> {
15173 #[allow(clippy::collapsible_else_if)]
15174 fn from_node(
15175 node: ::treesitter_types::tree_sitter::Node<'tree>,
15176 src: &'tree [u8],
15177 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15178 match node.kind() {
15179 "quoted_decls" => Ok(Self::QuotedDecls(::std::boxed::Box::new(
15180 ::treesitter_types::runtime::maybe_grow_stack(|| {
15181 <QuotedDecls as ::treesitter_types::FromNode>::from_node(node, src)
15182 })?,
15183 ))),
15184 "quoted_expression" => Ok(Self::QuotedExpression(::std::boxed::Box::new(
15185 ::treesitter_types::runtime::maybe_grow_stack(|| {
15186 <QuotedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15187 })?,
15188 ))),
15189 "quoted_pattern" => Ok(Self::QuotedPattern(::std::boxed::Box::new(
15190 ::treesitter_types::runtime::maybe_grow_stack(|| {
15191 <QuotedPattern as ::treesitter_types::FromNode>::from_node(node, src)
15192 })?,
15193 ))),
15194 "quoted_type" => Ok(Self::QuotedType(::std::boxed::Box::new(
15195 ::treesitter_types::runtime::maybe_grow_stack(|| {
15196 <QuotedType as ::treesitter_types::FromNode>::from_node(node, src)
15197 })?,
15198 ))),
15199 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15200 }
15201 }
15202}
15203impl ::treesitter_types::Spanned for QuoteChildren<'_> {
15204 fn span(&self) -> ::treesitter_types::Span {
15205 match self {
15206 Self::QuotedDecls(inner) => inner.span(),
15207 Self::QuotedExpression(inner) => inner.span(),
15208 Self::QuotedPattern(inner) => inner.span(),
15209 Self::QuotedType(inner) => inner.span(),
15210 }
15211 }
15212}
15213#[derive(Debug, Clone, PartialEq, Eq)]
15214pub enum QuotedExpressionChildren<'tree> {
15215 Expression(::std::boxed::Box<Expression<'tree>>),
15216 Signature(::std::boxed::Box<Signature<'tree>>),
15217}
15218impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedExpressionChildren<'tree> {
15219 #[allow(clippy::collapsible_else_if)]
15220 fn from_node(
15221 node: ::treesitter_types::tree_sitter::Node<'tree>,
15222 src: &'tree [u8],
15223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15224 match node.kind() {
15225 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15226 ::treesitter_types::runtime::maybe_grow_stack(|| {
15227 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15228 })?,
15229 ))),
15230 _other => {
15231 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15232 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15233 }) {
15234 Ok(Self::Expression(::std::boxed::Box::new(v)))
15235 } else {
15236 Err(::treesitter_types::ParseError::unexpected_kind(
15237 _other, node,
15238 ))
15239 }
15240 }
15241 }
15242 }
15243}
15244impl ::treesitter_types::Spanned for QuotedExpressionChildren<'_> {
15245 fn span(&self) -> ::treesitter_types::Span {
15246 match self {
15247 Self::Expression(inner) => inner.span(),
15248 Self::Signature(inner) => inner.span(),
15249 }
15250 }
15251}
15252#[derive(Debug, Clone, PartialEq, Eq)]
15253pub enum QuotedPatternChildren<'tree> {
15254 Pattern(::std::boxed::Box<Pattern<'tree>>),
15255 Signature(::std::boxed::Box<Signature<'tree>>),
15256}
15257impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedPatternChildren<'tree> {
15258 #[allow(clippy::collapsible_else_if)]
15259 fn from_node(
15260 node: ::treesitter_types::tree_sitter::Node<'tree>,
15261 src: &'tree [u8],
15262 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15263 match node.kind() {
15264 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15265 ::treesitter_types::runtime::maybe_grow_stack(|| {
15266 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15267 })?,
15268 ))),
15269 _other => {
15270 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15271 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
15272 }) {
15273 Ok(Self::Pattern(::std::boxed::Box::new(v)))
15274 } else {
15275 Err(::treesitter_types::ParseError::unexpected_kind(
15276 _other, node,
15277 ))
15278 }
15279 }
15280 }
15281 }
15282}
15283impl ::treesitter_types::Spanned for QuotedPatternChildren<'_> {
15284 fn span(&self) -> ::treesitter_types::Span {
15285 match self {
15286 Self::Pattern(inner) => inner.span(),
15287 Self::Signature(inner) => inner.span(),
15288 }
15289 }
15290}
15291#[derive(Debug, Clone, PartialEq, Eq)]
15292pub enum QuotedTypeChildren<'tree> {
15293 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
15294 Signature(::std::boxed::Box<Signature<'tree>>),
15295}
15296impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedTypeChildren<'tree> {
15297 #[allow(clippy::collapsible_else_if)]
15298 fn from_node(
15299 node: ::treesitter_types::tree_sitter::Node<'tree>,
15300 src: &'tree [u8],
15301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15302 match node.kind() {
15303 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15304 ::treesitter_types::runtime::maybe_grow_stack(|| {
15305 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15306 })?,
15307 ))),
15308 _other => {
15309 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15310 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15311 }) {
15312 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
15313 } else {
15314 Err(::treesitter_types::ParseError::unexpected_kind(
15315 _other, node,
15316 ))
15317 }
15318 }
15319 }
15320 }
15321}
15322impl ::treesitter_types::Spanned for QuotedTypeChildren<'_> {
15323 fn span(&self) -> ::treesitter_types::Span {
15324 match self {
15325 Self::QuantifiedType(inner) => inner.span(),
15326 Self::Signature(inner) => inner.span(),
15327 }
15328 }
15329}
15330#[derive(Debug, Clone, PartialEq, Eq)]
15331pub enum QuoterChildren<'tree> {
15332 Qualified(::std::boxed::Box<Qualified<'tree>>),
15333 Variable(::std::boxed::Box<Variable<'tree>>),
15334}
15335impl<'tree> ::treesitter_types::FromNode<'tree> for QuoterChildren<'tree> {
15336 #[allow(clippy::collapsible_else_if)]
15337 fn from_node(
15338 node: ::treesitter_types::tree_sitter::Node<'tree>,
15339 src: &'tree [u8],
15340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15341 match node.kind() {
15342 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
15343 ::treesitter_types::runtime::maybe_grow_stack(|| {
15344 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15345 })?,
15346 ))),
15347 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
15348 ::treesitter_types::runtime::maybe_grow_stack(|| {
15349 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
15350 })?,
15351 ))),
15352 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15353 }
15354 }
15355}
15356impl ::treesitter_types::Spanned for QuoterChildren<'_> {
15357 fn span(&self) -> ::treesitter_types::Span {
15358 match self {
15359 Self::Qualified(inner) => inner.span(),
15360 Self::Variable(inner) => inner.span(),
15361 }
15362 }
15363}
15364#[derive(Debug, Clone, PartialEq, Eq)]
15365pub enum RecordArrow {
15366 Arrow(::treesitter_types::Span),
15367 X(::treesitter_types::Span),
15368}
15369impl<'tree> ::treesitter_types::FromNode<'tree> for RecordArrow {
15370 #[allow(clippy::collapsible_else_if)]
15371 fn from_node(
15372 node: ::treesitter_types::tree_sitter::Node<'tree>,
15373 _src: &'tree [u8],
15374 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15375 match node.kind() {
15376 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
15377 "→" => Ok(Self::X(::treesitter_types::Span::from(node))),
15378 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15379 }
15380 }
15381}
15382impl ::treesitter_types::Spanned for RecordArrow {
15383 fn span(&self) -> ::treesitter_types::Span {
15384 match self {
15385 Self::Arrow(span) => *span,
15386 Self::X(span) => *span,
15387 }
15388 }
15389}
15390#[derive(Debug, Clone, PartialEq, Eq)]
15391pub enum RecordField<'tree> {
15392 Field(::std::boxed::Box<Field<'tree>>),
15393 FieldPattern(::std::boxed::Box<FieldPattern<'tree>>),
15394 FieldUpdate(::std::boxed::Box<FieldUpdate<'tree>>),
15395}
15396impl<'tree> ::treesitter_types::FromNode<'tree> for RecordField<'tree> {
15397 #[allow(clippy::collapsible_else_if)]
15398 fn from_node(
15399 node: ::treesitter_types::tree_sitter::Node<'tree>,
15400 src: &'tree [u8],
15401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15402 match node.kind() {
15403 "field" => Ok(Self::Field(::std::boxed::Box::new(
15404 ::treesitter_types::runtime::maybe_grow_stack(|| {
15405 <Field as ::treesitter_types::FromNode>::from_node(node, src)
15406 })?,
15407 ))),
15408 "field_pattern" => Ok(Self::FieldPattern(::std::boxed::Box::new(
15409 ::treesitter_types::runtime::maybe_grow_stack(|| {
15410 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
15411 })?,
15412 ))),
15413 "field_update" => Ok(Self::FieldUpdate(::std::boxed::Box::new(
15414 ::treesitter_types::runtime::maybe_grow_stack(|| {
15415 <FieldUpdate as ::treesitter_types::FromNode>::from_node(node, src)
15416 })?,
15417 ))),
15418 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15419 }
15420 }
15421}
15422impl ::treesitter_types::Spanned for RecordField<'_> {
15423 fn span(&self) -> ::treesitter_types::Span {
15424 match self {
15425 Self::Field(inner) => inner.span(),
15426 Self::FieldPattern(inner) => inner.span(),
15427 Self::FieldUpdate(inner) => inner.span(),
15428 }
15429 }
15430}
15431#[derive(Debug, Clone, PartialEq, Eq)]
15432pub enum RightSectionChildren<'tree> {
15433 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
15434 InfixId(::std::boxed::Box<InfixId<'tree>>),
15435 Operator(::std::boxed::Box<Operator<'tree>>),
15436 Qualified(::std::boxed::Box<Qualified<'tree>>),
15437}
15438impl<'tree> ::treesitter_types::FromNode<'tree> for RightSectionChildren<'tree> {
15439 #[allow(clippy::collapsible_else_if)]
15440 fn from_node(
15441 node: ::treesitter_types::tree_sitter::Node<'tree>,
15442 src: &'tree [u8],
15443 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15444 match node.kind() {
15445 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
15446 ::treesitter_types::runtime::maybe_grow_stack(|| {
15447 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
15448 })?,
15449 ))),
15450 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
15451 ::treesitter_types::runtime::maybe_grow_stack(|| {
15452 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
15453 })?,
15454 ))),
15455 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
15456 ::treesitter_types::runtime::maybe_grow_stack(|| {
15457 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
15458 })?,
15459 ))),
15460 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
15461 ::treesitter_types::runtime::maybe_grow_stack(|| {
15462 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15463 })?,
15464 ))),
15465 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15466 }
15467 }
15468}
15469impl ::treesitter_types::Spanned for RightSectionChildren<'_> {
15470 fn span(&self) -> ::treesitter_types::Span {
15471 match self {
15472 Self::ConstructorOperator(inner) => inner.span(),
15473 Self::InfixId(inner) => inner.span(),
15474 Self::Operator(inner) => inner.span(),
15475 Self::Qualified(inner) => inner.span(),
15476 }
15477 }
15478}
15479#[derive(Debug, Clone, PartialEq, Eq)]
15480pub enum RoleAnnotationType<'tree> {
15481 Name(::std::boxed::Box<Name<'tree>>),
15482 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15483 Qualified(::std::boxed::Box<Qualified<'tree>>),
15484}
15485impl<'tree> ::treesitter_types::FromNode<'tree> for RoleAnnotationType<'tree> {
15486 #[allow(clippy::collapsible_else_if)]
15487 fn from_node(
15488 node: ::treesitter_types::tree_sitter::Node<'tree>,
15489 src: &'tree [u8],
15490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15491 match node.kind() {
15492 "name" => Ok(Self::Name(::std::boxed::Box::new(
15493 ::treesitter_types::runtime::maybe_grow_stack(|| {
15494 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15495 })?,
15496 ))),
15497 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15498 ::treesitter_types::runtime::maybe_grow_stack(|| {
15499 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15500 })?,
15501 ))),
15502 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
15503 ::treesitter_types::runtime::maybe_grow_stack(|| {
15504 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15505 })?,
15506 ))),
15507 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15508 }
15509 }
15510}
15511impl ::treesitter_types::Spanned for RoleAnnotationType<'_> {
15512 fn span(&self) -> ::treesitter_types::Span {
15513 match self {
15514 Self::Name(inner) => inner.span(),
15515 Self::PrefixId(inner) => inner.span(),
15516 Self::Qualified(inner) => inner.span(),
15517 }
15518 }
15519}
15520#[derive(Debug, Clone, PartialEq, Eq)]
15521pub enum SignatureName<'tree> {
15522 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15523 Variable(::std::boxed::Box<Variable<'tree>>),
15524}
15525impl<'tree> ::treesitter_types::FromNode<'tree> for SignatureName<'tree> {
15526 #[allow(clippy::collapsible_else_if)]
15527 fn from_node(
15528 node: ::treesitter_types::tree_sitter::Node<'tree>,
15529 src: &'tree [u8],
15530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15531 match node.kind() {
15532 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15533 ::treesitter_types::runtime::maybe_grow_stack(|| {
15534 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15535 })?,
15536 ))),
15537 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
15538 ::treesitter_types::runtime::maybe_grow_stack(|| {
15539 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
15540 })?,
15541 ))),
15542 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15543 }
15544 }
15545}
15546impl ::treesitter_types::Spanned for SignatureName<'_> {
15547 fn span(&self) -> ::treesitter_types::Span {
15548 match self {
15549 Self::PrefixId(inner) => inner.span(),
15550 Self::Variable(inner) => inner.span(),
15551 }
15552 }
15553}
15554#[derive(Debug, Clone, PartialEq, Eq)]
15555pub enum SignatureSynonym<'tree> {
15556 BindingList(::std::boxed::Box<BindingList<'tree>>),
15557 Constructor(::std::boxed::Box<Constructor<'tree>>),
15558 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15559}
15560impl<'tree> ::treesitter_types::FromNode<'tree> for SignatureSynonym<'tree> {
15561 #[allow(clippy::collapsible_else_if)]
15562 fn from_node(
15563 node: ::treesitter_types::tree_sitter::Node<'tree>,
15564 src: &'tree [u8],
15565 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15566 match node.kind() {
15567 "binding_list" => Ok(Self::BindingList(::std::boxed::Box::new(
15568 ::treesitter_types::runtime::maybe_grow_stack(|| {
15569 <BindingList as ::treesitter_types::FromNode>::from_node(node, src)
15570 })?,
15571 ))),
15572 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
15573 ::treesitter_types::runtime::maybe_grow_stack(|| {
15574 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
15575 })?,
15576 ))),
15577 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15578 ::treesitter_types::runtime::maybe_grow_stack(|| {
15579 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15580 })?,
15581 ))),
15582 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15583 }
15584 }
15585}
15586impl ::treesitter_types::Spanned for SignatureSynonym<'_> {
15587 fn span(&self) -> ::treesitter_types::Span {
15588 match self {
15589 Self::BindingList(inner) => inner.span(),
15590 Self::Constructor(inner) => inner.span(),
15591 Self::PrefixId(inner) => inner.span(),
15592 }
15593 }
15594}
15595#[derive(Debug, Clone, PartialEq, Eq)]
15596pub enum SpecialChildren<'tree> {
15597 EmptyList(::std::boxed::Box<EmptyList<'tree>>),
15598 Tuple(::std::boxed::Box<Tuple<'tree>>),
15599 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
15600 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
15601 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
15602 Unit(::std::boxed::Box<Unit<'tree>>),
15603}
15604impl<'tree> ::treesitter_types::FromNode<'tree> for SpecialChildren<'tree> {
15605 #[allow(clippy::collapsible_else_if)]
15606 fn from_node(
15607 node: ::treesitter_types::tree_sitter::Node<'tree>,
15608 src: &'tree [u8],
15609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15610 match node.kind() {
15611 "empty_list" => Ok(Self::EmptyList(::std::boxed::Box::new(
15612 ::treesitter_types::runtime::maybe_grow_stack(|| {
15613 <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)
15614 })?,
15615 ))),
15616 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
15617 ::treesitter_types::runtime::maybe_grow_stack(|| {
15618 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
15619 })?,
15620 ))),
15621 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
15622 ::treesitter_types::runtime::maybe_grow_stack(|| {
15623 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
15624 })?,
15625 ))),
15626 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
15627 ::treesitter_types::runtime::maybe_grow_stack(|| {
15628 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
15629 })?,
15630 ))),
15631 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
15632 ::treesitter_types::runtime::maybe_grow_stack(|| {
15633 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
15634 })?,
15635 ))),
15636 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
15637 ::treesitter_types::runtime::maybe_grow_stack(|| {
15638 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
15639 })?,
15640 ))),
15641 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15642 }
15643 }
15644}
15645impl ::treesitter_types::Spanned for SpecialChildren<'_> {
15646 fn span(&self) -> ::treesitter_types::Span {
15647 match self {
15648 Self::EmptyList(inner) => inner.span(),
15649 Self::Tuple(inner) => inner.span(),
15650 Self::UnboxedSum(inner) => inner.span(),
15651 Self::UnboxedTuple(inner) => inner.span(),
15652 Self::UnboxedUnit(inner) => inner.span(),
15653 Self::Unit(inner) => inner.span(),
15654 }
15655 }
15656}
15657#[derive(Debug, Clone, PartialEq, Eq)]
15658pub enum SpliceExpression<'tree> {
15659 Constructor(::std::boxed::Box<Constructor<'tree>>),
15660 ImplicitVariable(::std::boxed::Box<ImplicitVariable<'tree>>),
15661 Label(::std::boxed::Box<Label<'tree>>),
15662 Literal(::std::boxed::Box<Literal<'tree>>),
15663 Parens(::std::boxed::Box<Parens<'tree>>),
15664 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15665 Qualified(::std::boxed::Box<Qualified<'tree>>),
15666 Variable(::std::boxed::Box<Variable<'tree>>),
15667}
15668impl<'tree> ::treesitter_types::FromNode<'tree> for SpliceExpression<'tree> {
15669 #[allow(clippy::collapsible_else_if)]
15670 fn from_node(
15671 node: ::treesitter_types::tree_sitter::Node<'tree>,
15672 src: &'tree [u8],
15673 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15674 match node.kind() {
15675 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
15676 ::treesitter_types::runtime::maybe_grow_stack(|| {
15677 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
15678 })?,
15679 ))),
15680 "implicit_variable" => Ok(Self::ImplicitVariable(::std::boxed::Box::new(
15681 ::treesitter_types::runtime::maybe_grow_stack(|| {
15682 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)
15683 })?,
15684 ))),
15685 "label" => Ok(Self::Label(::std::boxed::Box::new(
15686 ::treesitter_types::runtime::maybe_grow_stack(|| {
15687 <Label as ::treesitter_types::FromNode>::from_node(node, src)
15688 })?,
15689 ))),
15690 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
15691 ::treesitter_types::runtime::maybe_grow_stack(|| {
15692 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
15693 })?,
15694 ))),
15695 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
15696 ::treesitter_types::runtime::maybe_grow_stack(|| {
15697 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
15698 })?,
15699 ))),
15700 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15701 ::treesitter_types::runtime::maybe_grow_stack(|| {
15702 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15703 })?,
15704 ))),
15705 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
15706 ::treesitter_types::runtime::maybe_grow_stack(|| {
15707 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15708 })?,
15709 ))),
15710 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
15711 ::treesitter_types::runtime::maybe_grow_stack(|| {
15712 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
15713 })?,
15714 ))),
15715 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15716 }
15717 }
15718}
15719impl ::treesitter_types::Spanned for SpliceExpression<'_> {
15720 fn span(&self) -> ::treesitter_types::Span {
15721 match self {
15722 Self::Constructor(inner) => inner.span(),
15723 Self::ImplicitVariable(inner) => inner.span(),
15724 Self::Label(inner) => inner.span(),
15725 Self::Literal(inner) => inner.span(),
15726 Self::Parens(inner) => inner.span(),
15727 Self::PrefixId(inner) => inner.span(),
15728 Self::Qualified(inner) => inner.span(),
15729 Self::Variable(inner) => inner.span(),
15730 }
15731 }
15732}
15733#[derive(Debug, Clone, PartialEq, Eq)]
15734pub enum ThQuotedNameName<'tree> {
15735 Constructor(::std::boxed::Box<Constructor<'tree>>),
15736 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15737 Qualified(::std::boxed::Box<Qualified<'tree>>),
15738 Variable(::std::boxed::Box<Variable<'tree>>),
15739}
15740impl<'tree> ::treesitter_types::FromNode<'tree> for ThQuotedNameName<'tree> {
15741 #[allow(clippy::collapsible_else_if)]
15742 fn from_node(
15743 node: ::treesitter_types::tree_sitter::Node<'tree>,
15744 src: &'tree [u8],
15745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15746 match node.kind() {
15747 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
15748 ::treesitter_types::runtime::maybe_grow_stack(|| {
15749 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
15750 })?,
15751 ))),
15752 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15753 ::treesitter_types::runtime::maybe_grow_stack(|| {
15754 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15755 })?,
15756 ))),
15757 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
15758 ::treesitter_types::runtime::maybe_grow_stack(|| {
15759 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15760 })?,
15761 ))),
15762 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
15763 ::treesitter_types::runtime::maybe_grow_stack(|| {
15764 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
15765 })?,
15766 ))),
15767 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15768 }
15769 }
15770}
15771impl ::treesitter_types::Spanned for ThQuotedNameName<'_> {
15772 fn span(&self) -> ::treesitter_types::Span {
15773 match self {
15774 Self::Constructor(inner) => inner.span(),
15775 Self::PrefixId(inner) => inner.span(),
15776 Self::Qualified(inner) => inner.span(),
15777 Self::Variable(inner) => inner.span(),
15778 }
15779 }
15780}
15781#[derive(Debug, Clone, PartialEq, Eq)]
15782pub enum TransformKey<'tree> {
15783 Expression(::std::boxed::Box<Expression<'tree>>),
15784 Signature(::std::boxed::Box<Signature<'tree>>),
15785}
15786impl<'tree> ::treesitter_types::FromNode<'tree> for TransformKey<'tree> {
15787 #[allow(clippy::collapsible_else_if)]
15788 fn from_node(
15789 node: ::treesitter_types::tree_sitter::Node<'tree>,
15790 src: &'tree [u8],
15791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15792 match node.kind() {
15793 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15794 ::treesitter_types::runtime::maybe_grow_stack(|| {
15795 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15796 })?,
15797 ))),
15798 _other => {
15799 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15800 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15801 }) {
15802 Ok(Self::Expression(::std::boxed::Box::new(v)))
15803 } else {
15804 Err(::treesitter_types::ParseError::unexpected_kind(
15805 _other, node,
15806 ))
15807 }
15808 }
15809 }
15810 }
15811}
15812impl ::treesitter_types::Spanned for TransformKey<'_> {
15813 fn span(&self) -> ::treesitter_types::Span {
15814 match self {
15815 Self::Expression(inner) => inner.span(),
15816 Self::Signature(inner) => inner.span(),
15817 }
15818 }
15819}
15820#[derive(Debug, Clone, PartialEq, Eq)]
15821pub enum TransformTransformation<'tree> {
15822 Expression(::std::boxed::Box<Expression<'tree>>),
15823 Signature(::std::boxed::Box<Signature<'tree>>),
15824}
15825impl<'tree> ::treesitter_types::FromNode<'tree> for TransformTransformation<'tree> {
15826 #[allow(clippy::collapsible_else_if)]
15827 fn from_node(
15828 node: ::treesitter_types::tree_sitter::Node<'tree>,
15829 src: &'tree [u8],
15830 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15831 match node.kind() {
15832 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15833 ::treesitter_types::runtime::maybe_grow_stack(|| {
15834 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15835 })?,
15836 ))),
15837 _other => {
15838 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15839 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15840 }) {
15841 Ok(Self::Expression(::std::boxed::Box::new(v)))
15842 } else {
15843 Err(::treesitter_types::ParseError::unexpected_kind(
15844 _other, node,
15845 ))
15846 }
15847 }
15848 }
15849 }
15850}
15851impl ::treesitter_types::Spanned for TransformTransformation<'_> {
15852 fn span(&self) -> ::treesitter_types::Span {
15853 match self {
15854 Self::Expression(inner) => inner.span(),
15855 Self::Signature(inner) => inner.span(),
15856 }
15857 }
15858}
15859#[derive(Debug, Clone, PartialEq, Eq)]
15860pub enum TupleElement<'tree> {
15861 Expression(::std::boxed::Box<Expression<'tree>>),
15862 Pattern(::std::boxed::Box<Pattern<'tree>>),
15863 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
15864 Signature(::std::boxed::Box<Signature<'tree>>),
15865 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
15866}
15867impl<'tree> ::treesitter_types::FromNode<'tree> for TupleElement<'tree> {
15868 #[allow(clippy::collapsible_else_if)]
15869 fn from_node(
15870 node: ::treesitter_types::tree_sitter::Node<'tree>,
15871 src: &'tree [u8],
15872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15873 match node.kind() {
15874 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15875 ::treesitter_types::runtime::maybe_grow_stack(|| {
15876 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15877 })?,
15878 ))),
15879 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
15880 ::treesitter_types::runtime::maybe_grow_stack(|| {
15881 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
15882 })?,
15883 ))),
15884 _other => {
15885 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15886 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15887 }) {
15888 Ok(Self::Expression(::std::boxed::Box::new(v)))
15889 } else {
15890 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15891 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
15892 }) {
15893 Ok(Self::Pattern(::std::boxed::Box::new(v)))
15894 } else {
15895 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
15896 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15897 }) {
15898 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
15899 } else {
15900 Err(::treesitter_types::ParseError::unexpected_kind(
15901 _other, node,
15902 ))
15903 }
15904 }
15905 }
15906 }
15907 }
15908 }
15909}
15910impl ::treesitter_types::Spanned for TupleElement<'_> {
15911 fn span(&self) -> ::treesitter_types::Span {
15912 match self {
15913 Self::Expression(inner) => inner.span(),
15914 Self::Pattern(inner) => inner.span(),
15915 Self::QuantifiedType(inner) => inner.span(),
15916 Self::Signature(inner) => inner.span(),
15917 Self::ViewPattern(inner) => inner.span(),
15918 }
15919 }
15920}
15921#[derive(Debug, Clone, PartialEq, Eq)]
15922pub enum TypeFamilyClosedFamily<'tree> {
15923 AbstractFamily(::std::boxed::Box<AbstractFamily<'tree>>),
15924 Equations(::std::boxed::Box<Equations<'tree>>),
15925}
15926impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyClosedFamily<'tree> {
15927 #[allow(clippy::collapsible_else_if)]
15928 fn from_node(
15929 node: ::treesitter_types::tree_sitter::Node<'tree>,
15930 src: &'tree [u8],
15931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15932 match node.kind() {
15933 "abstract_family" => Ok(Self::AbstractFamily(::std::boxed::Box::new(
15934 ::treesitter_types::runtime::maybe_grow_stack(|| {
15935 <AbstractFamily as ::treesitter_types::FromNode>::from_node(node, src)
15936 })?,
15937 ))),
15938 "equations" => Ok(Self::Equations(::std::boxed::Box::new(
15939 ::treesitter_types::runtime::maybe_grow_stack(|| {
15940 <Equations as ::treesitter_types::FromNode>::from_node(node, src)
15941 })?,
15942 ))),
15943 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15944 }
15945 }
15946}
15947impl ::treesitter_types::Spanned for TypeFamilyClosedFamily<'_> {
15948 fn span(&self) -> ::treesitter_types::Span {
15949 match self {
15950 Self::AbstractFamily(inner) => inner.span(),
15951 Self::Equations(inner) => inner.span(),
15952 }
15953 }
15954}
15955#[derive(Debug, Clone, PartialEq, Eq)]
15956pub enum TypeFamilyName<'tree> {
15957 Name(::std::boxed::Box<Name<'tree>>),
15958 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15959 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
15960 Unit(::std::boxed::Box<Unit<'tree>>),
15961}
15962impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyName<'tree> {
15963 #[allow(clippy::collapsible_else_if)]
15964 fn from_node(
15965 node: ::treesitter_types::tree_sitter::Node<'tree>,
15966 src: &'tree [u8],
15967 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15968 match node.kind() {
15969 "name" => Ok(Self::Name(::std::boxed::Box::new(
15970 ::treesitter_types::runtime::maybe_grow_stack(|| {
15971 <Name as ::treesitter_types::FromNode>::from_node(node, src)
15972 })?,
15973 ))),
15974 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15975 ::treesitter_types::runtime::maybe_grow_stack(|| {
15976 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15977 })?,
15978 ))),
15979 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
15980 ::treesitter_types::runtime::maybe_grow_stack(|| {
15981 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
15982 })?,
15983 ))),
15984 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
15985 ::treesitter_types::runtime::maybe_grow_stack(|| {
15986 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
15987 })?,
15988 ))),
15989 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15990 }
15991 }
15992}
15993impl ::treesitter_types::Spanned for TypeFamilyName<'_> {
15994 fn span(&self) -> ::treesitter_types::Span {
15995 match self {
15996 Self::Name(inner) => inner.span(),
15997 Self::PrefixId(inner) => inner.span(),
15998 Self::PrefixList(inner) => inner.span(),
15999 Self::Unit(inner) => inner.span(),
16000 }
16001 }
16002}
16003#[derive(Debug, Clone, PartialEq, Eq)]
16004pub enum TypeFamilyChildren<'tree> {
16005 Infix(::std::boxed::Box<Infix<'tree>>),
16006 Parens(::std::boxed::Box<Parens<'tree>>),
16007 TypeFamilyInjectivity(::std::boxed::Box<TypeFamilyInjectivity<'tree>>),
16008 TypeFamilyResult(::std::boxed::Box<TypeFamilyResult<'tree>>),
16009}
16010impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyChildren<'tree> {
16011 #[allow(clippy::collapsible_else_if)]
16012 fn from_node(
16013 node: ::treesitter_types::tree_sitter::Node<'tree>,
16014 src: &'tree [u8],
16015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16016 match node.kind() {
16017 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
16018 ::treesitter_types::runtime::maybe_grow_stack(|| {
16019 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
16020 })?,
16021 ))),
16022 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
16023 ::treesitter_types::runtime::maybe_grow_stack(|| {
16024 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
16025 })?,
16026 ))),
16027 "type_family_injectivity" => Ok(Self::TypeFamilyInjectivity(::std::boxed::Box::new(
16028 ::treesitter_types::runtime::maybe_grow_stack(|| {
16029 <TypeFamilyInjectivity as ::treesitter_types::FromNode>::from_node(node, src)
16030 })?,
16031 ))),
16032 "type_family_result" => Ok(Self::TypeFamilyResult(::std::boxed::Box::new(
16033 ::treesitter_types::runtime::maybe_grow_stack(|| {
16034 <TypeFamilyResult as ::treesitter_types::FromNode>::from_node(node, src)
16035 })?,
16036 ))),
16037 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16038 }
16039 }
16040}
16041impl ::treesitter_types::Spanned for TypeFamilyChildren<'_> {
16042 fn span(&self) -> ::treesitter_types::Span {
16043 match self {
16044 Self::Infix(inner) => inner.span(),
16045 Self::Parens(inner) => inner.span(),
16046 Self::TypeFamilyInjectivity(inner) => inner.span(),
16047 Self::TypeFamilyResult(inner) => inner.span(),
16048 }
16049 }
16050}
16051#[derive(Debug, Clone, PartialEq, Eq)]
16052pub enum TypeInstanceForall<'tree> {
16053 Forall(::std::boxed::Box<Forall<'tree>>),
16054 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
16055}
16056impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceForall<'tree> {
16057 #[allow(clippy::collapsible_else_if)]
16058 fn from_node(
16059 node: ::treesitter_types::tree_sitter::Node<'tree>,
16060 src: &'tree [u8],
16061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16062 match node.kind() {
16063 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
16064 ::treesitter_types::runtime::maybe_grow_stack(|| {
16065 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
16066 })?,
16067 ))),
16068 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
16069 ::treesitter_types::runtime::maybe_grow_stack(|| {
16070 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
16071 })?,
16072 ))),
16073 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16074 }
16075 }
16076}
16077impl ::treesitter_types::Spanned for TypeInstanceForall<'_> {
16078 fn span(&self) -> ::treesitter_types::Span {
16079 match self {
16080 Self::Forall(inner) => inner.span(),
16081 Self::ForallRequired(inner) => inner.span(),
16082 }
16083 }
16084}
16085#[derive(Debug, Clone, PartialEq, Eq)]
16086pub enum TypeInstanceName<'tree> {
16087 Name(::std::boxed::Box<Name<'tree>>),
16088 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
16089 Qualified(::std::boxed::Box<Qualified<'tree>>),
16090}
16091impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceName<'tree> {
16092 #[allow(clippy::collapsible_else_if)]
16093 fn from_node(
16094 node: ::treesitter_types::tree_sitter::Node<'tree>,
16095 src: &'tree [u8],
16096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16097 match node.kind() {
16098 "name" => Ok(Self::Name(::std::boxed::Box::new(
16099 ::treesitter_types::runtime::maybe_grow_stack(|| {
16100 <Name as ::treesitter_types::FromNode>::from_node(node, src)
16101 })?,
16102 ))),
16103 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
16104 ::treesitter_types::runtime::maybe_grow_stack(|| {
16105 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
16106 })?,
16107 ))),
16108 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
16109 ::treesitter_types::runtime::maybe_grow_stack(|| {
16110 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
16111 })?,
16112 ))),
16113 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16114 }
16115 }
16116}
16117impl ::treesitter_types::Spanned for TypeInstanceName<'_> {
16118 fn span(&self) -> ::treesitter_types::Span {
16119 match self {
16120 Self::Name(inner) => inner.span(),
16121 Self::PrefixId(inner) => inner.span(),
16122 Self::Qualified(inner) => inner.span(),
16123 }
16124 }
16125}
16126#[derive(Debug, Clone, PartialEq, Eq)]
16127pub enum TypeInstanceChildren<'tree> {
16128 Infix(::std::boxed::Box<Infix<'tree>>),
16129 Parens(::std::boxed::Box<Parens<'tree>>),
16130 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
16131}
16132impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceChildren<'tree> {
16133 #[allow(clippy::collapsible_else_if)]
16134 fn from_node(
16135 node: ::treesitter_types::tree_sitter::Node<'tree>,
16136 src: &'tree [u8],
16137 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16138 match node.kind() {
16139 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
16140 ::treesitter_types::runtime::maybe_grow_stack(|| {
16141 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
16142 })?,
16143 ))),
16144 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
16145 ::treesitter_types::runtime::maybe_grow_stack(|| {
16146 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
16147 })?,
16148 ))),
16149 _other => {
16150 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16151 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
16152 }) {
16153 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
16154 } else {
16155 Err(::treesitter_types::ParseError::unexpected_kind(
16156 _other, node,
16157 ))
16158 }
16159 }
16160 }
16161 }
16162}
16163impl ::treesitter_types::Spanned for TypeInstanceChildren<'_> {
16164 fn span(&self) -> ::treesitter_types::Span {
16165 match self {
16166 Self::Infix(inner) => inner.span(),
16167 Self::Parens(inner) => inner.span(),
16168 Self::QuantifiedType(inner) => inner.span(),
16169 }
16170 }
16171}
16172#[derive(Debug, Clone, PartialEq, Eq)]
16173pub enum TypePatternsChildren<'tree> {
16174 KindApplication(::std::boxed::Box<KindApplication<'tree>>),
16175 Type(::std::boxed::Box<Type<'tree>>),
16176}
16177impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatternsChildren<'tree> {
16178 #[allow(clippy::collapsible_else_if)]
16179 fn from_node(
16180 node: ::treesitter_types::tree_sitter::Node<'tree>,
16181 src: &'tree [u8],
16182 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16183 match node.kind() {
16184 "kind_application" => Ok(Self::KindApplication(::std::boxed::Box::new(
16185 ::treesitter_types::runtime::maybe_grow_stack(|| {
16186 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)
16187 })?,
16188 ))),
16189 _other => {
16190 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16191 <Type as ::treesitter_types::FromNode>::from_node(node, src)
16192 }) {
16193 Ok(Self::Type(::std::boxed::Box::new(v)))
16194 } else {
16195 Err(::treesitter_types::ParseError::unexpected_kind(
16196 _other, node,
16197 ))
16198 }
16199 }
16200 }
16201 }
16202}
16203impl ::treesitter_types::Spanned for TypePatternsChildren<'_> {
16204 fn span(&self) -> ::treesitter_types::Span {
16205 match self {
16206 Self::KindApplication(inner) => inner.span(),
16207 Self::Type(inner) => inner.span(),
16208 }
16209 }
16210}
16211#[derive(Debug, Clone, PartialEq, Eq)]
16212pub enum TypeSynomymName<'tree> {
16213 Name(::std::boxed::Box<Name<'tree>>),
16214 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
16215 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
16216 Unit(::std::boxed::Box<Unit<'tree>>),
16217}
16218impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymName<'tree> {
16219 #[allow(clippy::collapsible_else_if)]
16220 fn from_node(
16221 node: ::treesitter_types::tree_sitter::Node<'tree>,
16222 src: &'tree [u8],
16223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16224 match node.kind() {
16225 "name" => Ok(Self::Name(::std::boxed::Box::new(
16226 ::treesitter_types::runtime::maybe_grow_stack(|| {
16227 <Name as ::treesitter_types::FromNode>::from_node(node, src)
16228 })?,
16229 ))),
16230 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
16231 ::treesitter_types::runtime::maybe_grow_stack(|| {
16232 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
16233 })?,
16234 ))),
16235 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
16236 ::treesitter_types::runtime::maybe_grow_stack(|| {
16237 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
16238 })?,
16239 ))),
16240 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
16241 ::treesitter_types::runtime::maybe_grow_stack(|| {
16242 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
16243 })?,
16244 ))),
16245 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16246 }
16247 }
16248}
16249impl ::treesitter_types::Spanned for TypeSynomymName<'_> {
16250 fn span(&self) -> ::treesitter_types::Span {
16251 match self {
16252 Self::Name(inner) => inner.span(),
16253 Self::PrefixId(inner) => inner.span(),
16254 Self::PrefixList(inner) => inner.span(),
16255 Self::Unit(inner) => inner.span(),
16256 }
16257 }
16258}
16259#[derive(Debug, Clone, PartialEq, Eq)]
16260pub enum TypeSynomymType<'tree> {
16261 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
16262 Signature(::std::boxed::Box<Signature<'tree>>),
16263}
16264impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymType<'tree> {
16265 #[allow(clippy::collapsible_else_if)]
16266 fn from_node(
16267 node: ::treesitter_types::tree_sitter::Node<'tree>,
16268 src: &'tree [u8],
16269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16270 match node.kind() {
16271 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
16272 ::treesitter_types::runtime::maybe_grow_stack(|| {
16273 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
16274 })?,
16275 ))),
16276 _other => {
16277 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16278 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
16279 }) {
16280 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
16281 } else {
16282 Err(::treesitter_types::ParseError::unexpected_kind(
16283 _other, node,
16284 ))
16285 }
16286 }
16287 }
16288 }
16289}
16290impl ::treesitter_types::Spanned for TypeSynomymType<'_> {
16291 fn span(&self) -> ::treesitter_types::Span {
16292 match self {
16293 Self::QuantifiedType(inner) => inner.span(),
16294 Self::Signature(inner) => inner.span(),
16295 }
16296 }
16297}
16298#[derive(Debug, Clone, PartialEq, Eq)]
16299pub enum TypeSynomymChildren<'tree> {
16300 Infix(::std::boxed::Box<Infix<'tree>>),
16301 Parens(::std::boxed::Box<Parens<'tree>>),
16302}
16303impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymChildren<'tree> {
16304 #[allow(clippy::collapsible_else_if)]
16305 fn from_node(
16306 node: ::treesitter_types::tree_sitter::Node<'tree>,
16307 src: &'tree [u8],
16308 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16309 match node.kind() {
16310 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
16311 ::treesitter_types::runtime::maybe_grow_stack(|| {
16312 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
16313 })?,
16314 ))),
16315 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
16316 ::treesitter_types::runtime::maybe_grow_stack(|| {
16317 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
16318 })?,
16319 ))),
16320 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
16321 }
16322 }
16323}
16324impl ::treesitter_types::Spanned for TypeSynomymChildren<'_> {
16325 fn span(&self) -> ::treesitter_types::Span {
16326 match self {
16327 Self::Infix(inner) => inner.span(),
16328 Self::Parens(inner) => inner.span(),
16329 }
16330 }
16331}
16332#[derive(Debug, Clone, PartialEq, Eq)]
16333pub enum UnboxedSumElement<'tree> {
16334 Expression(::std::boxed::Box<Expression<'tree>>),
16335 Pattern(::std::boxed::Box<Pattern<'tree>>),
16336 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
16337 Signature(::std::boxed::Box<Signature<'tree>>),
16338 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
16339}
16340impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedSumElement<'tree> {
16341 #[allow(clippy::collapsible_else_if)]
16342 fn from_node(
16343 node: ::treesitter_types::tree_sitter::Node<'tree>,
16344 src: &'tree [u8],
16345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16346 match node.kind() {
16347 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
16348 ::treesitter_types::runtime::maybe_grow_stack(|| {
16349 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
16350 })?,
16351 ))),
16352 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
16353 ::treesitter_types::runtime::maybe_grow_stack(|| {
16354 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
16355 })?,
16356 ))),
16357 _other => {
16358 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16359 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16360 }) {
16361 Ok(Self::Expression(::std::boxed::Box::new(v)))
16362 } else {
16363 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16364 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
16365 }) {
16366 Ok(Self::Pattern(::std::boxed::Box::new(v)))
16367 } else {
16368 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16369 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
16370 }) {
16371 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
16372 } else {
16373 Err(::treesitter_types::ParseError::unexpected_kind(
16374 _other, node,
16375 ))
16376 }
16377 }
16378 }
16379 }
16380 }
16381 }
16382}
16383impl ::treesitter_types::Spanned for UnboxedSumElement<'_> {
16384 fn span(&self) -> ::treesitter_types::Span {
16385 match self {
16386 Self::Expression(inner) => inner.span(),
16387 Self::Pattern(inner) => inner.span(),
16388 Self::QuantifiedType(inner) => inner.span(),
16389 Self::Signature(inner) => inner.span(),
16390 Self::ViewPattern(inner) => inner.span(),
16391 }
16392 }
16393}
16394#[derive(Debug, Clone, PartialEq, Eq)]
16395pub enum UnboxedTupleElement<'tree> {
16396 Expression(::std::boxed::Box<Expression<'tree>>),
16397 Pattern(::std::boxed::Box<Pattern<'tree>>),
16398 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
16399 Signature(::std::boxed::Box<Signature<'tree>>),
16400 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
16401}
16402impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedTupleElement<'tree> {
16403 #[allow(clippy::collapsible_else_if)]
16404 fn from_node(
16405 node: ::treesitter_types::tree_sitter::Node<'tree>,
16406 src: &'tree [u8],
16407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16408 match node.kind() {
16409 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
16410 ::treesitter_types::runtime::maybe_grow_stack(|| {
16411 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
16412 })?,
16413 ))),
16414 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
16415 ::treesitter_types::runtime::maybe_grow_stack(|| {
16416 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
16417 })?,
16418 ))),
16419 _other => {
16420 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16421 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16422 }) {
16423 Ok(Self::Expression(::std::boxed::Box::new(v)))
16424 } else {
16425 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16426 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
16427 }) {
16428 Ok(Self::Pattern(::std::boxed::Box::new(v)))
16429 } else {
16430 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16431 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
16432 }) {
16433 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
16434 } else {
16435 Err(::treesitter_types::ParseError::unexpected_kind(
16436 _other, node,
16437 ))
16438 }
16439 }
16440 }
16441 }
16442 }
16443 }
16444}
16445impl ::treesitter_types::Spanned for UnboxedTupleElement<'_> {
16446 fn span(&self) -> ::treesitter_types::Span {
16447 match self {
16448 Self::Expression(inner) => inner.span(),
16449 Self::Pattern(inner) => inner.span(),
16450 Self::QuantifiedType(inner) => inner.span(),
16451 Self::Signature(inner) => inner.span(),
16452 Self::ViewPattern(inner) => inner.span(),
16453 }
16454 }
16455}
16456#[derive(Debug, Clone, PartialEq, Eq)]
16457pub enum ViewPatternExpression<'tree> {
16458 Expression(::std::boxed::Box<Expression<'tree>>),
16459 Signature(::std::boxed::Box<Signature<'tree>>),
16460}
16461impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPatternExpression<'tree> {
16462 #[allow(clippy::collapsible_else_if)]
16463 fn from_node(
16464 node: ::treesitter_types::tree_sitter::Node<'tree>,
16465 src: &'tree [u8],
16466 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16467 match node.kind() {
16468 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
16469 ::treesitter_types::runtime::maybe_grow_stack(|| {
16470 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
16471 })?,
16472 ))),
16473 _other => {
16474 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16475 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16476 }) {
16477 Ok(Self::Expression(::std::boxed::Box::new(v)))
16478 } else {
16479 Err(::treesitter_types::ParseError::unexpected_kind(
16480 _other, node,
16481 ))
16482 }
16483 }
16484 }
16485 }
16486}
16487impl ::treesitter_types::Spanned for ViewPatternExpression<'_> {
16488 fn span(&self) -> ::treesitter_types::Span {
16489 match self {
16490 Self::Expression(inner) => inner.span(),
16491 Self::Signature(inner) => inner.span(),
16492 }
16493 }
16494}
16495#[derive(Debug, Clone, PartialEq, Eq)]
16496pub enum ViewPatternPattern<'tree> {
16497 Pattern(::std::boxed::Box<Pattern<'tree>>),
16498 Signature(::std::boxed::Box<Signature<'tree>>),
16499 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
16500}
16501impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPatternPattern<'tree> {
16502 #[allow(clippy::collapsible_else_if)]
16503 fn from_node(
16504 node: ::treesitter_types::tree_sitter::Node<'tree>,
16505 src: &'tree [u8],
16506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16507 match node.kind() {
16508 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
16509 ::treesitter_types::runtime::maybe_grow_stack(|| {
16510 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
16511 })?,
16512 ))),
16513 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
16514 ::treesitter_types::runtime::maybe_grow_stack(|| {
16515 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
16516 })?,
16517 ))),
16518 _other => {
16519 if let Ok(v) = ::treesitter_types::runtime::maybe_grow_stack(|| {
16520 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
16521 }) {
16522 Ok(Self::Pattern(::std::boxed::Box::new(v)))
16523 } else {
16524 Err(::treesitter_types::ParseError::unexpected_kind(
16525 _other, node,
16526 ))
16527 }
16528 }
16529 }
16530 }
16531}
16532impl ::treesitter_types::Spanned for ViewPatternPattern<'_> {
16533 fn span(&self) -> ::treesitter_types::Span {
16534 match self {
16535 Self::Pattern(inner) => inner.span(),
16536 Self::Signature(inner) => inner.span(),
16537 Self::ViewPattern(inner) => inner.span(),
16538 }
16539 }
16540}
16541#[derive(Debug, Clone, PartialEq, Eq)]
16542pub enum AnyNode<'tree> {
16543 ClassDecl(ClassDecl<'tree>),
16544 Constraint(Constraint<'tree>),
16545 Constraints(Constraints<'tree>),
16546 Decl(Decl<'tree>),
16547 Declaration(Declaration<'tree>),
16548 Expression(Expression<'tree>),
16549 Guard(Guard<'tree>),
16550 InstanceDecl(InstanceDecl<'tree>),
16551 Pattern(Pattern<'tree>),
16552 Qualifier(Qualifier<'tree>),
16553 QuantifiedType(QuantifiedType<'tree>),
16554 Statement(Statement<'tree>),
16555 Type(Type<'tree>),
16556 TypeParam(TypeParam<'tree>),
16557 AbstractFamily(AbstractFamily<'tree>),
16558 Alternative(Alternative<'tree>),
16559 Alternatives(Alternatives<'tree>),
16560 Annotated(Annotated<'tree>),
16561 Apply(Apply<'tree>),
16562 ArithmeticSequence(ArithmeticSequence<'tree>),
16563 As(As<'tree>),
16564 AssociatedType(AssociatedType<'tree>),
16565 Bind(Bind<'tree>),
16566 BindingList(BindingList<'tree>),
16567 Boolean(Boolean<'tree>),
16568 Case(Case<'tree>),
16569 Children(Children<'tree>),
16570 Class(Class<'tree>),
16571 ClassDeclarations(ClassDeclarations<'tree>),
16572 Conditional(Conditional<'tree>),
16573 ConstructorOperator(ConstructorOperator<'tree>),
16574 ConstructorSynonym(ConstructorSynonym<'tree>),
16575 ConstructorSynonyms(ConstructorSynonyms<'tree>),
16576 Context(Context<'tree>),
16577 DataConstructor(DataConstructor<'tree>),
16578 DataConstructors(DataConstructors<'tree>),
16579 DataFamily(DataFamily<'tree>),
16580 DataInstance(DataInstance<'tree>),
16581 DataType(DataType<'tree>),
16582 Declarations(Declarations<'tree>),
16583 DefaultSignature(DefaultSignature<'tree>),
16584 DefaultTypes(DefaultTypes<'tree>),
16585 Deriving(Deriving<'tree>),
16586 DerivingInstance(DerivingInstance<'tree>),
16587 DerivingStrategy(DerivingStrategy<'tree>),
16588 Do(Do<'tree>),
16589 DoModule(DoModule<'tree>),
16590 EmptyList(EmptyList<'tree>),
16591 Entity(Entity<'tree>),
16592 Equation(Equation<'tree>),
16593 Equations(Equations<'tree>),
16594 Exp(Exp<'tree>),
16595 ExplicitType(ExplicitType<'tree>),
16596 Export(Export<'tree>),
16597 Exports(Exports<'tree>),
16598 Field(Field<'tree>),
16599 FieldName(FieldName<'tree>),
16600 FieldPath(FieldPath<'tree>),
16601 FieldPattern(FieldPattern<'tree>),
16602 FieldUpdate(FieldUpdate<'tree>),
16603 Fields(Fields<'tree>),
16604 Fixity(Fixity<'tree>),
16605 Forall(Forall<'tree>),
16606 ForallRequired(ForallRequired<'tree>),
16607 ForeignExport(ForeignExport<'tree>),
16608 ForeignImport(ForeignImport<'tree>),
16609 Function(Function<'tree>),
16610 FunctionHeadParens(FunctionHeadParens<'tree>),
16611 Fundep(Fundep<'tree>),
16612 Fundeps(Fundeps<'tree>),
16613 GadtConstructor(GadtConstructor<'tree>),
16614 GadtConstructors(GadtConstructors<'tree>),
16615 Generator(Generator<'tree>),
16616 Group(Group<'tree>),
16617 Guards(Guards<'tree>),
16618 Haskell(Haskell<'tree>),
16619 Header(Header<'tree>),
16620 ImplicitParameter(ImplicitParameter<'tree>),
16621 Import(Import<'tree>),
16622 ImportList(ImportList<'tree>),
16623 ImportName(ImportName<'tree>),
16624 Imports(Imports<'tree>),
16625 Inferred(Inferred<'tree>),
16626 Infix(Infix<'tree>),
16627 InfixId(InfixId<'tree>),
16628 Instance(Instance<'tree>),
16629 InstanceDeclarations(InstanceDeclarations<'tree>),
16630 Integer(Integer<'tree>),
16631 Invisible(Invisible<'tree>),
16632 Irrefutable(Irrefutable<'tree>),
16633 KindApplication(KindApplication<'tree>),
16634 KindSignature(KindSignature<'tree>),
16635 Lambda(Lambda<'tree>),
16636 LambdaCase(LambdaCase<'tree>),
16637 LambdaCases(LambdaCases<'tree>),
16638 LazyField(LazyField<'tree>),
16639 LeftSection(LeftSection<'tree>),
16640 Let(Let<'tree>),
16641 LetIn(LetIn<'tree>),
16642 LinearFunction(LinearFunction<'tree>),
16643 List(List<'tree>),
16644 ListComprehension(ListComprehension<'tree>),
16645 Literal(Literal<'tree>),
16646 LocalBinds(LocalBinds<'tree>),
16647 Match(Match<'tree>),
16648 Modifier(Modifier<'tree>),
16649 Module(Module<'tree>),
16650 ModuleExport(ModuleExport<'tree>),
16651 MultiWayIf(MultiWayIf<'tree>),
16652 Namespace(Namespace<'tree>),
16653 Negation(Negation<'tree>),
16654 Newtype(Newtype<'tree>),
16655 NewtypeConstructor(NewtypeConstructor<'tree>),
16656 Operator(Operator<'tree>),
16657 Parens(Parens<'tree>),
16658 PatternGuard(PatternGuard<'tree>),
16659 PatternSynonym(PatternSynonym<'tree>),
16660 Patterns(Patterns<'tree>),
16661 Prefix(Prefix<'tree>),
16662 PrefixId(PrefixId<'tree>),
16663 PrefixList(PrefixList<'tree>),
16664 PrefixTuple(PrefixTuple<'tree>),
16665 PrefixUnboxedSum(PrefixUnboxedSum<'tree>),
16666 PrefixUnboxedTuple(PrefixUnboxedTuple<'tree>),
16667 Projection(Projection<'tree>),
16668 ProjectionSelector(ProjectionSelector<'tree>),
16669 Promoted(Promoted<'tree>),
16670 Qualified(Qualified<'tree>),
16671 Qualifiers(Qualifiers<'tree>),
16672 QuantifiedVariables(QuantifiedVariables<'tree>),
16673 Quasiquote(Quasiquote<'tree>),
16674 Quote(Quote<'tree>),
16675 QuotedDecls(QuotedDecls<'tree>),
16676 QuotedExpression(QuotedExpression<'tree>),
16677 QuotedPattern(QuotedPattern<'tree>),
16678 QuotedType(QuotedType<'tree>),
16679 Quoter(Quoter<'tree>),
16680 Rec(Rec<'tree>),
16681 Record(Record<'tree>),
16682 RightSection(RightSection<'tree>),
16683 RoleAnnotation(RoleAnnotation<'tree>),
16684 Signature(Signature<'tree>),
16685 Special(Special<'tree>),
16686 Splice(Splice<'tree>),
16687 Star(Star<'tree>),
16688 Strict(Strict<'tree>),
16689 StrictField(StrictField<'tree>),
16690 ThQuotedName(ThQuotedName<'tree>),
16691 TopSplice(TopSplice<'tree>),
16692 Transform(Transform<'tree>),
16693 Tuple(Tuple<'tree>),
16694 TypeApplication(TypeApplication<'tree>),
16695 TypeBinder(TypeBinder<'tree>),
16696 TypeFamily(TypeFamily<'tree>),
16697 TypeFamilyInjectivity(TypeFamilyInjectivity<'tree>),
16698 TypeFamilyResult(TypeFamilyResult<'tree>),
16699 TypeInstance(TypeInstance<'tree>),
16700 TypeParams(TypeParams<'tree>),
16701 TypePatterns(TypePatterns<'tree>),
16702 TypeRole(TypeRole<'tree>),
16703 TypeSynomym(TypeSynomym<'tree>),
16704 TypedQuote(TypedQuote<'tree>),
16705 UnboxedSum(UnboxedSum<'tree>),
16706 UnboxedTuple(UnboxedTuple<'tree>),
16707 UnboxedUnit(UnboxedUnit<'tree>),
16708 Unit(Unit<'tree>),
16709 Via(Via<'tree>),
16710 ViewPattern(ViewPattern<'tree>),
16711 Wildcard(Wildcard<'tree>),
16712 AllNames(AllNames<'tree>),
16713 CallingConvention(CallingConvention<'tree>),
16714 Char(Char<'tree>),
16715 Comment(Comment<'tree>),
16716 Constructor(Constructor<'tree>),
16717 Cpp(Cpp<'tree>),
16718 Float(Float<'tree>),
16719 Haddock(Haddock<'tree>),
16720 ImplicitVariable(ImplicitVariable<'tree>),
16721 ImportPackage(ImportPackage<'tree>),
16722 Label(Label<'tree>),
16723 ModuleId(ModuleId<'tree>),
16724 Name(Name<'tree>),
16725 Pragma(Pragma<'tree>),
16726 QuasiquoteBody(QuasiquoteBody<'tree>),
16727 Safety(Safety<'tree>),
16728 String(String<'tree>),
16729 Variable(Variable<'tree>),
16730 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
16731}
16732impl<'tree> AnyNode<'tree> {
16733 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
16734 match node.kind() {
16735 "class_decl" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16736 <ClassDecl as ::treesitter_types::FromNode>::from_node(node, src)
16737 })
16738 .map(Self::ClassDecl)
16739 .unwrap_or(Self::Unknown(node)),
16740 "constraint" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16741 <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
16742 })
16743 .map(Self::Constraint)
16744 .unwrap_or(Self::Unknown(node)),
16745 "constraints" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16746 <Constraints as ::treesitter_types::FromNode>::from_node(node, src)
16747 })
16748 .map(Self::Constraints)
16749 .unwrap_or(Self::Unknown(node)),
16750 "decl" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16751 <Decl as ::treesitter_types::FromNode>::from_node(node, src)
16752 })
16753 .map(Self::Decl)
16754 .unwrap_or(Self::Unknown(node)),
16755 "declaration" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16756 <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
16757 })
16758 .map(Self::Declaration)
16759 .unwrap_or(Self::Unknown(node)),
16760 "expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16761 <Expression as ::treesitter_types::FromNode>::from_node(node, src)
16762 })
16763 .map(Self::Expression)
16764 .unwrap_or(Self::Unknown(node)),
16765 "guard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16766 <Guard as ::treesitter_types::FromNode>::from_node(node, src)
16767 })
16768 .map(Self::Guard)
16769 .unwrap_or(Self::Unknown(node)),
16770 "instance_decl" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16771 <InstanceDecl as ::treesitter_types::FromNode>::from_node(node, src)
16772 })
16773 .map(Self::InstanceDecl)
16774 .unwrap_or(Self::Unknown(node)),
16775 "pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16776 <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
16777 })
16778 .map(Self::Pattern)
16779 .unwrap_or(Self::Unknown(node)),
16780 "qualifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16781 <Qualifier as ::treesitter_types::FromNode>::from_node(node, src)
16782 })
16783 .map(Self::Qualifier)
16784 .unwrap_or(Self::Unknown(node)),
16785 "quantified_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16786 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
16787 })
16788 .map(Self::QuantifiedType)
16789 .unwrap_or(Self::Unknown(node)),
16790 "statement" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16791 <Statement as ::treesitter_types::FromNode>::from_node(node, src)
16792 })
16793 .map(Self::Statement)
16794 .unwrap_or(Self::Unknown(node)),
16795 "type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16796 <Type as ::treesitter_types::FromNode>::from_node(node, src)
16797 })
16798 .map(Self::Type)
16799 .unwrap_or(Self::Unknown(node)),
16800 "type_param" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16801 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
16802 })
16803 .map(Self::TypeParam)
16804 .unwrap_or(Self::Unknown(node)),
16805 "abstract_family" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16806 <AbstractFamily as ::treesitter_types::FromNode>::from_node(node, src)
16807 })
16808 .map(Self::AbstractFamily)
16809 .unwrap_or(Self::Unknown(node)),
16810 "alternative" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16811 <Alternative as ::treesitter_types::FromNode>::from_node(node, src)
16812 })
16813 .map(Self::Alternative)
16814 .unwrap_or(Self::Unknown(node)),
16815 "alternatives" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16816 <Alternatives as ::treesitter_types::FromNode>::from_node(node, src)
16817 })
16818 .map(Self::Alternatives)
16819 .unwrap_or(Self::Unknown(node)),
16820 "annotated" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16821 <Annotated as ::treesitter_types::FromNode>::from_node(node, src)
16822 })
16823 .map(Self::Annotated)
16824 .unwrap_or(Self::Unknown(node)),
16825 "apply" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16826 <Apply as ::treesitter_types::FromNode>::from_node(node, src)
16827 })
16828 .map(Self::Apply)
16829 .unwrap_or(Self::Unknown(node)),
16830 "arithmetic_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16831 <ArithmeticSequence as ::treesitter_types::FromNode>::from_node(node, src)
16832 })
16833 .map(Self::ArithmeticSequence)
16834 .unwrap_or(Self::Unknown(node)),
16835 "as" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16836 <As as ::treesitter_types::FromNode>::from_node(node, src)
16837 })
16838 .map(Self::As)
16839 .unwrap_or(Self::Unknown(node)),
16840 "associated_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16841 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
16842 })
16843 .map(Self::AssociatedType)
16844 .unwrap_or(Self::Unknown(node)),
16845 "bind" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16846 <Bind as ::treesitter_types::FromNode>::from_node(node, src)
16847 })
16848 .map(Self::Bind)
16849 .unwrap_or(Self::Unknown(node)),
16850 "binding_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16851 <BindingList as ::treesitter_types::FromNode>::from_node(node, src)
16852 })
16853 .map(Self::BindingList)
16854 .unwrap_or(Self::Unknown(node)),
16855 "boolean" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16856 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
16857 })
16858 .map(Self::Boolean)
16859 .unwrap_or(Self::Unknown(node)),
16860 "case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16861 <Case as ::treesitter_types::FromNode>::from_node(node, src)
16862 })
16863 .map(Self::Case)
16864 .unwrap_or(Self::Unknown(node)),
16865 "children" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16866 <Children as ::treesitter_types::FromNode>::from_node(node, src)
16867 })
16868 .map(Self::Children)
16869 .unwrap_or(Self::Unknown(node)),
16870 "class" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16871 <Class as ::treesitter_types::FromNode>::from_node(node, src)
16872 })
16873 .map(Self::Class)
16874 .unwrap_or(Self::Unknown(node)),
16875 "class_declarations" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16876 <ClassDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
16877 })
16878 .map(Self::ClassDeclarations)
16879 .unwrap_or(Self::Unknown(node)),
16880 "conditional" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16881 <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
16882 })
16883 .map(Self::Conditional)
16884 .unwrap_or(Self::Unknown(node)),
16885 "constructor_operator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16886 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
16887 })
16888 .map(Self::ConstructorOperator)
16889 .unwrap_or(Self::Unknown(node)),
16890 "constructor_synonym" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16891 <ConstructorSynonym as ::treesitter_types::FromNode>::from_node(node, src)
16892 })
16893 .map(Self::ConstructorSynonym)
16894 .unwrap_or(Self::Unknown(node)),
16895 "constructor_synonyms" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16896 <ConstructorSynonyms as ::treesitter_types::FromNode>::from_node(node, src)
16897 })
16898 .map(Self::ConstructorSynonyms)
16899 .unwrap_or(Self::Unknown(node)),
16900 "context" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16901 <Context as ::treesitter_types::FromNode>::from_node(node, src)
16902 })
16903 .map(Self::Context)
16904 .unwrap_or(Self::Unknown(node)),
16905 "data_constructor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16906 <DataConstructor as ::treesitter_types::FromNode>::from_node(node, src)
16907 })
16908 .map(Self::DataConstructor)
16909 .unwrap_or(Self::Unknown(node)),
16910 "data_constructors" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16911 <DataConstructors as ::treesitter_types::FromNode>::from_node(node, src)
16912 })
16913 .map(Self::DataConstructors)
16914 .unwrap_or(Self::Unknown(node)),
16915 "data_family" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16916 <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)
16917 })
16918 .map(Self::DataFamily)
16919 .unwrap_or(Self::Unknown(node)),
16920 "data_instance" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16921 <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)
16922 })
16923 .map(Self::DataInstance)
16924 .unwrap_or(Self::Unknown(node)),
16925 "data_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16926 <DataType as ::treesitter_types::FromNode>::from_node(node, src)
16927 })
16928 .map(Self::DataType)
16929 .unwrap_or(Self::Unknown(node)),
16930 "declarations" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16931 <Declarations as ::treesitter_types::FromNode>::from_node(node, src)
16932 })
16933 .map(Self::Declarations)
16934 .unwrap_or(Self::Unknown(node)),
16935 "default_signature" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16936 <DefaultSignature as ::treesitter_types::FromNode>::from_node(node, src)
16937 })
16938 .map(Self::DefaultSignature)
16939 .unwrap_or(Self::Unknown(node)),
16940 "default_types" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16941 <DefaultTypes as ::treesitter_types::FromNode>::from_node(node, src)
16942 })
16943 .map(Self::DefaultTypes)
16944 .unwrap_or(Self::Unknown(node)),
16945 "deriving" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16946 <Deriving as ::treesitter_types::FromNode>::from_node(node, src)
16947 })
16948 .map(Self::Deriving)
16949 .unwrap_or(Self::Unknown(node)),
16950 "deriving_instance" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16951 <DerivingInstance as ::treesitter_types::FromNode>::from_node(node, src)
16952 })
16953 .map(Self::DerivingInstance)
16954 .unwrap_or(Self::Unknown(node)),
16955 "deriving_strategy" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16956 <DerivingStrategy as ::treesitter_types::FromNode>::from_node(node, src)
16957 })
16958 .map(Self::DerivingStrategy)
16959 .unwrap_or(Self::Unknown(node)),
16960 "do" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16961 <Do as ::treesitter_types::FromNode>::from_node(node, src)
16962 })
16963 .map(Self::Do)
16964 .unwrap_or(Self::Unknown(node)),
16965 "do_module" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16966 <DoModule as ::treesitter_types::FromNode>::from_node(node, src)
16967 })
16968 .map(Self::DoModule)
16969 .unwrap_or(Self::Unknown(node)),
16970 "empty_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16971 <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)
16972 })
16973 .map(Self::EmptyList)
16974 .unwrap_or(Self::Unknown(node)),
16975 "entity" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16976 <Entity as ::treesitter_types::FromNode>::from_node(node, src)
16977 })
16978 .map(Self::Entity)
16979 .unwrap_or(Self::Unknown(node)),
16980 "equation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16981 <Equation as ::treesitter_types::FromNode>::from_node(node, src)
16982 })
16983 .map(Self::Equation)
16984 .unwrap_or(Self::Unknown(node)),
16985 "equations" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16986 <Equations as ::treesitter_types::FromNode>::from_node(node, src)
16987 })
16988 .map(Self::Equations)
16989 .unwrap_or(Self::Unknown(node)),
16990 "exp" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16991 <Exp as ::treesitter_types::FromNode>::from_node(node, src)
16992 })
16993 .map(Self::Exp)
16994 .unwrap_or(Self::Unknown(node)),
16995 "explicit_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
16996 <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)
16997 })
16998 .map(Self::ExplicitType)
16999 .unwrap_or(Self::Unknown(node)),
17000 "export" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17001 <Export as ::treesitter_types::FromNode>::from_node(node, src)
17002 })
17003 .map(Self::Export)
17004 .unwrap_or(Self::Unknown(node)),
17005 "exports" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17006 <Exports as ::treesitter_types::FromNode>::from_node(node, src)
17007 })
17008 .map(Self::Exports)
17009 .unwrap_or(Self::Unknown(node)),
17010 "field" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17011 <Field as ::treesitter_types::FromNode>::from_node(node, src)
17012 })
17013 .map(Self::Field)
17014 .unwrap_or(Self::Unknown(node)),
17015 "field_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17016 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
17017 })
17018 .map(Self::FieldName)
17019 .unwrap_or(Self::Unknown(node)),
17020 "field_path" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17021 <FieldPath as ::treesitter_types::FromNode>::from_node(node, src)
17022 })
17023 .map(Self::FieldPath)
17024 .unwrap_or(Self::Unknown(node)),
17025 "field_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17026 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
17027 })
17028 .map(Self::FieldPattern)
17029 .unwrap_or(Self::Unknown(node)),
17030 "field_update" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17031 <FieldUpdate as ::treesitter_types::FromNode>::from_node(node, src)
17032 })
17033 .map(Self::FieldUpdate)
17034 .unwrap_or(Self::Unknown(node)),
17035 "fields" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17036 <Fields as ::treesitter_types::FromNode>::from_node(node, src)
17037 })
17038 .map(Self::Fields)
17039 .unwrap_or(Self::Unknown(node)),
17040 "fixity" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17041 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)
17042 })
17043 .map(Self::Fixity)
17044 .unwrap_or(Self::Unknown(node)),
17045 "forall" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17046 <Forall as ::treesitter_types::FromNode>::from_node(node, src)
17047 })
17048 .map(Self::Forall)
17049 .unwrap_or(Self::Unknown(node)),
17050 "forall_required" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17051 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
17052 })
17053 .map(Self::ForallRequired)
17054 .unwrap_or(Self::Unknown(node)),
17055 "foreign_export" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17056 <ForeignExport as ::treesitter_types::FromNode>::from_node(node, src)
17057 })
17058 .map(Self::ForeignExport)
17059 .unwrap_or(Self::Unknown(node)),
17060 "foreign_import" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17061 <ForeignImport as ::treesitter_types::FromNode>::from_node(node, src)
17062 })
17063 .map(Self::ForeignImport)
17064 .unwrap_or(Self::Unknown(node)),
17065 "function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17066 <Function as ::treesitter_types::FromNode>::from_node(node, src)
17067 })
17068 .map(Self::Function)
17069 .unwrap_or(Self::Unknown(node)),
17070 "function_head_parens" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17071 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(node, src)
17072 })
17073 .map(Self::FunctionHeadParens)
17074 .unwrap_or(Self::Unknown(node)),
17075 "fundep" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17076 <Fundep as ::treesitter_types::FromNode>::from_node(node, src)
17077 })
17078 .map(Self::Fundep)
17079 .unwrap_or(Self::Unknown(node)),
17080 "fundeps" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17081 <Fundeps as ::treesitter_types::FromNode>::from_node(node, src)
17082 })
17083 .map(Self::Fundeps)
17084 .unwrap_or(Self::Unknown(node)),
17085 "gadt_constructor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17086 <GadtConstructor as ::treesitter_types::FromNode>::from_node(node, src)
17087 })
17088 .map(Self::GadtConstructor)
17089 .unwrap_or(Self::Unknown(node)),
17090 "gadt_constructors" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17091 <GadtConstructors as ::treesitter_types::FromNode>::from_node(node, src)
17092 })
17093 .map(Self::GadtConstructors)
17094 .unwrap_or(Self::Unknown(node)),
17095 "generator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17096 <Generator as ::treesitter_types::FromNode>::from_node(node, src)
17097 })
17098 .map(Self::Generator)
17099 .unwrap_or(Self::Unknown(node)),
17100 "group" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17101 <Group as ::treesitter_types::FromNode>::from_node(node, src)
17102 })
17103 .map(Self::Group)
17104 .unwrap_or(Self::Unknown(node)),
17105 "guards" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17106 <Guards as ::treesitter_types::FromNode>::from_node(node, src)
17107 })
17108 .map(Self::Guards)
17109 .unwrap_or(Self::Unknown(node)),
17110 "haskell" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17111 <Haskell as ::treesitter_types::FromNode>::from_node(node, src)
17112 })
17113 .map(Self::Haskell)
17114 .unwrap_or(Self::Unknown(node)),
17115 "header" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17116 <Header as ::treesitter_types::FromNode>::from_node(node, src)
17117 })
17118 .map(Self::Header)
17119 .unwrap_or(Self::Unknown(node)),
17120 "implicit_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17121 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
17122 })
17123 .map(Self::ImplicitParameter)
17124 .unwrap_or(Self::Unknown(node)),
17125 "import" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17126 <Import as ::treesitter_types::FromNode>::from_node(node, src)
17127 })
17128 .map(Self::Import)
17129 .unwrap_or(Self::Unknown(node)),
17130 "import_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17131 <ImportList as ::treesitter_types::FromNode>::from_node(node, src)
17132 })
17133 .map(Self::ImportList)
17134 .unwrap_or(Self::Unknown(node)),
17135 "import_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17136 <ImportName as ::treesitter_types::FromNode>::from_node(node, src)
17137 })
17138 .map(Self::ImportName)
17139 .unwrap_or(Self::Unknown(node)),
17140 "imports" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17141 <Imports as ::treesitter_types::FromNode>::from_node(node, src)
17142 })
17143 .map(Self::Imports)
17144 .unwrap_or(Self::Unknown(node)),
17145 "inferred" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17146 <Inferred as ::treesitter_types::FromNode>::from_node(node, src)
17147 })
17148 .map(Self::Inferred)
17149 .unwrap_or(Self::Unknown(node)),
17150 "infix" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17151 <Infix as ::treesitter_types::FromNode>::from_node(node, src)
17152 })
17153 .map(Self::Infix)
17154 .unwrap_or(Self::Unknown(node)),
17155 "infix_id" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17156 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
17157 })
17158 .map(Self::InfixId)
17159 .unwrap_or(Self::Unknown(node)),
17160 "instance" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17161 <Instance as ::treesitter_types::FromNode>::from_node(node, src)
17162 })
17163 .map(Self::Instance)
17164 .unwrap_or(Self::Unknown(node)),
17165 "instance_declarations" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17166 <InstanceDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
17167 })
17168 .map(Self::InstanceDeclarations)
17169 .unwrap_or(Self::Unknown(node)),
17170 "integer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17171 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
17172 })
17173 .map(Self::Integer)
17174 .unwrap_or(Self::Unknown(node)),
17175 "invisible" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17176 <Invisible as ::treesitter_types::FromNode>::from_node(node, src)
17177 })
17178 .map(Self::Invisible)
17179 .unwrap_or(Self::Unknown(node)),
17180 "irrefutable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17181 <Irrefutable as ::treesitter_types::FromNode>::from_node(node, src)
17182 })
17183 .map(Self::Irrefutable)
17184 .unwrap_or(Self::Unknown(node)),
17185 "kind_application" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17186 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)
17187 })
17188 .map(Self::KindApplication)
17189 .unwrap_or(Self::Unknown(node)),
17190 "kind_signature" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17191 <KindSignature as ::treesitter_types::FromNode>::from_node(node, src)
17192 })
17193 .map(Self::KindSignature)
17194 .unwrap_or(Self::Unknown(node)),
17195 "lambda" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17196 <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
17197 })
17198 .map(Self::Lambda)
17199 .unwrap_or(Self::Unknown(node)),
17200 "lambda_case" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17201 <LambdaCase as ::treesitter_types::FromNode>::from_node(node, src)
17202 })
17203 .map(Self::LambdaCase)
17204 .unwrap_or(Self::Unknown(node)),
17205 "lambda_cases" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17206 <LambdaCases as ::treesitter_types::FromNode>::from_node(node, src)
17207 })
17208 .map(Self::LambdaCases)
17209 .unwrap_or(Self::Unknown(node)),
17210 "lazy_field" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17211 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
17212 })
17213 .map(Self::LazyField)
17214 .unwrap_or(Self::Unknown(node)),
17215 "left_section" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17216 <LeftSection as ::treesitter_types::FromNode>::from_node(node, src)
17217 })
17218 .map(Self::LeftSection)
17219 .unwrap_or(Self::Unknown(node)),
17220 "let" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17221 <Let as ::treesitter_types::FromNode>::from_node(node, src)
17222 })
17223 .map(Self::Let)
17224 .unwrap_or(Self::Unknown(node)),
17225 "let_in" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17226 <LetIn as ::treesitter_types::FromNode>::from_node(node, src)
17227 })
17228 .map(Self::LetIn)
17229 .unwrap_or(Self::Unknown(node)),
17230 "linear_function" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17231 <LinearFunction as ::treesitter_types::FromNode>::from_node(node, src)
17232 })
17233 .map(Self::LinearFunction)
17234 .unwrap_or(Self::Unknown(node)),
17235 "list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17236 <List as ::treesitter_types::FromNode>::from_node(node, src)
17237 })
17238 .map(Self::List)
17239 .unwrap_or(Self::Unknown(node)),
17240 "list_comprehension" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17241 <ListComprehension as ::treesitter_types::FromNode>::from_node(node, src)
17242 })
17243 .map(Self::ListComprehension)
17244 .unwrap_or(Self::Unknown(node)),
17245 "literal" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17246 <Literal as ::treesitter_types::FromNode>::from_node(node, src)
17247 })
17248 .map(Self::Literal)
17249 .unwrap_or(Self::Unknown(node)),
17250 "local_binds" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17251 <LocalBinds as ::treesitter_types::FromNode>::from_node(node, src)
17252 })
17253 .map(Self::LocalBinds)
17254 .unwrap_or(Self::Unknown(node)),
17255 "match" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17256 <Match as ::treesitter_types::FromNode>::from_node(node, src)
17257 })
17258 .map(Self::Match)
17259 .unwrap_or(Self::Unknown(node)),
17260 "modifier" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17261 <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
17262 })
17263 .map(Self::Modifier)
17264 .unwrap_or(Self::Unknown(node)),
17265 "module" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17266 <Module as ::treesitter_types::FromNode>::from_node(node, src)
17267 })
17268 .map(Self::Module)
17269 .unwrap_or(Self::Unknown(node)),
17270 "module_export" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17271 <ModuleExport as ::treesitter_types::FromNode>::from_node(node, src)
17272 })
17273 .map(Self::ModuleExport)
17274 .unwrap_or(Self::Unknown(node)),
17275 "multi_way_if" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17276 <MultiWayIf as ::treesitter_types::FromNode>::from_node(node, src)
17277 })
17278 .map(Self::MultiWayIf)
17279 .unwrap_or(Self::Unknown(node)),
17280 "namespace" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17281 <Namespace as ::treesitter_types::FromNode>::from_node(node, src)
17282 })
17283 .map(Self::Namespace)
17284 .unwrap_or(Self::Unknown(node)),
17285 "negation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17286 <Negation as ::treesitter_types::FromNode>::from_node(node, src)
17287 })
17288 .map(Self::Negation)
17289 .unwrap_or(Self::Unknown(node)),
17290 "newtype" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17291 <Newtype as ::treesitter_types::FromNode>::from_node(node, src)
17292 })
17293 .map(Self::Newtype)
17294 .unwrap_or(Self::Unknown(node)),
17295 "newtype_constructor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17296 <NewtypeConstructor as ::treesitter_types::FromNode>::from_node(node, src)
17297 })
17298 .map(Self::NewtypeConstructor)
17299 .unwrap_or(Self::Unknown(node)),
17300 "operator" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17301 <Operator as ::treesitter_types::FromNode>::from_node(node, src)
17302 })
17303 .map(Self::Operator)
17304 .unwrap_or(Self::Unknown(node)),
17305 "parens" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17306 <Parens as ::treesitter_types::FromNode>::from_node(node, src)
17307 })
17308 .map(Self::Parens)
17309 .unwrap_or(Self::Unknown(node)),
17310 "pattern_guard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17311 <PatternGuard as ::treesitter_types::FromNode>::from_node(node, src)
17312 })
17313 .map(Self::PatternGuard)
17314 .unwrap_or(Self::Unknown(node)),
17315 "pattern_synonym" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17316 <PatternSynonym as ::treesitter_types::FromNode>::from_node(node, src)
17317 })
17318 .map(Self::PatternSynonym)
17319 .unwrap_or(Self::Unknown(node)),
17320 "patterns" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17321 <Patterns as ::treesitter_types::FromNode>::from_node(node, src)
17322 })
17323 .map(Self::Patterns)
17324 .unwrap_or(Self::Unknown(node)),
17325 "prefix" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17326 <Prefix as ::treesitter_types::FromNode>::from_node(node, src)
17327 })
17328 .map(Self::Prefix)
17329 .unwrap_or(Self::Unknown(node)),
17330 "prefix_id" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17331 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
17332 })
17333 .map(Self::PrefixId)
17334 .unwrap_or(Self::Unknown(node)),
17335 "prefix_list" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17336 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
17337 })
17338 .map(Self::PrefixList)
17339 .unwrap_or(Self::Unknown(node)),
17340 "prefix_tuple" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17341 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
17342 })
17343 .map(Self::PrefixTuple)
17344 .unwrap_or(Self::Unknown(node)),
17345 "prefix_unboxed_sum" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17346 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
17347 })
17348 .map(Self::PrefixUnboxedSum)
17349 .unwrap_or(Self::Unknown(node)),
17350 "prefix_unboxed_tuple" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17351 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
17352 })
17353 .map(Self::PrefixUnboxedTuple)
17354 .unwrap_or(Self::Unknown(node)),
17355 "projection" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17356 <Projection as ::treesitter_types::FromNode>::from_node(node, src)
17357 })
17358 .map(Self::Projection)
17359 .unwrap_or(Self::Unknown(node)),
17360 "projection_selector" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17361 <ProjectionSelector as ::treesitter_types::FromNode>::from_node(node, src)
17362 })
17363 .map(Self::ProjectionSelector)
17364 .unwrap_or(Self::Unknown(node)),
17365 "promoted" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17366 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)
17367 })
17368 .map(Self::Promoted)
17369 .unwrap_or(Self::Unknown(node)),
17370 "qualified" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17371 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
17372 })
17373 .map(Self::Qualified)
17374 .unwrap_or(Self::Unknown(node)),
17375 "qualifiers" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17376 <Qualifiers as ::treesitter_types::FromNode>::from_node(node, src)
17377 })
17378 .map(Self::Qualifiers)
17379 .unwrap_or(Self::Unknown(node)),
17380 "quantified_variables" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17381 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(node, src)
17382 })
17383 .map(Self::QuantifiedVariables)
17384 .unwrap_or(Self::Unknown(node)),
17385 "quasiquote" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17386 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
17387 })
17388 .map(Self::Quasiquote)
17389 .unwrap_or(Self::Unknown(node)),
17390 "quote" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17391 <Quote as ::treesitter_types::FromNode>::from_node(node, src)
17392 })
17393 .map(Self::Quote)
17394 .unwrap_or(Self::Unknown(node)),
17395 "quoted_decls" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17396 <QuotedDecls as ::treesitter_types::FromNode>::from_node(node, src)
17397 })
17398 .map(Self::QuotedDecls)
17399 .unwrap_or(Self::Unknown(node)),
17400 "quoted_expression" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17401 <QuotedExpression as ::treesitter_types::FromNode>::from_node(node, src)
17402 })
17403 .map(Self::QuotedExpression)
17404 .unwrap_or(Self::Unknown(node)),
17405 "quoted_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17406 <QuotedPattern as ::treesitter_types::FromNode>::from_node(node, src)
17407 })
17408 .map(Self::QuotedPattern)
17409 .unwrap_or(Self::Unknown(node)),
17410 "quoted_type" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17411 <QuotedType as ::treesitter_types::FromNode>::from_node(node, src)
17412 })
17413 .map(Self::QuotedType)
17414 .unwrap_or(Self::Unknown(node)),
17415 "quoter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17416 <Quoter as ::treesitter_types::FromNode>::from_node(node, src)
17417 })
17418 .map(Self::Quoter)
17419 .unwrap_or(Self::Unknown(node)),
17420 "rec" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17421 <Rec as ::treesitter_types::FromNode>::from_node(node, src)
17422 })
17423 .map(Self::Rec)
17424 .unwrap_or(Self::Unknown(node)),
17425 "record" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17426 <Record as ::treesitter_types::FromNode>::from_node(node, src)
17427 })
17428 .map(Self::Record)
17429 .unwrap_or(Self::Unknown(node)),
17430 "right_section" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17431 <RightSection as ::treesitter_types::FromNode>::from_node(node, src)
17432 })
17433 .map(Self::RightSection)
17434 .unwrap_or(Self::Unknown(node)),
17435 "role_annotation" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17436 <RoleAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
17437 })
17438 .map(Self::RoleAnnotation)
17439 .unwrap_or(Self::Unknown(node)),
17440 "signature" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17441 <Signature as ::treesitter_types::FromNode>::from_node(node, src)
17442 })
17443 .map(Self::Signature)
17444 .unwrap_or(Self::Unknown(node)),
17445 "special" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17446 <Special as ::treesitter_types::FromNode>::from_node(node, src)
17447 })
17448 .map(Self::Special)
17449 .unwrap_or(Self::Unknown(node)),
17450 "splice" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17451 <Splice as ::treesitter_types::FromNode>::from_node(node, src)
17452 })
17453 .map(Self::Splice)
17454 .unwrap_or(Self::Unknown(node)),
17455 "star" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17456 <Star as ::treesitter_types::FromNode>::from_node(node, src)
17457 })
17458 .map(Self::Star)
17459 .unwrap_or(Self::Unknown(node)),
17460 "strict" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17461 <Strict as ::treesitter_types::FromNode>::from_node(node, src)
17462 })
17463 .map(Self::Strict)
17464 .unwrap_or(Self::Unknown(node)),
17465 "strict_field" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17466 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
17467 })
17468 .map(Self::StrictField)
17469 .unwrap_or(Self::Unknown(node)),
17470 "th_quoted_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17471 <ThQuotedName as ::treesitter_types::FromNode>::from_node(node, src)
17472 })
17473 .map(Self::ThQuotedName)
17474 .unwrap_or(Self::Unknown(node)),
17475 "top_splice" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17476 <TopSplice as ::treesitter_types::FromNode>::from_node(node, src)
17477 })
17478 .map(Self::TopSplice)
17479 .unwrap_or(Self::Unknown(node)),
17480 "transform" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17481 <Transform as ::treesitter_types::FromNode>::from_node(node, src)
17482 })
17483 .map(Self::Transform)
17484 .unwrap_or(Self::Unknown(node)),
17485 "tuple" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17486 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
17487 })
17488 .map(Self::Tuple)
17489 .unwrap_or(Self::Unknown(node)),
17490 "type_application" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17491 <TypeApplication as ::treesitter_types::FromNode>::from_node(node, src)
17492 })
17493 .map(Self::TypeApplication)
17494 .unwrap_or(Self::Unknown(node)),
17495 "type_binder" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17496 <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)
17497 })
17498 .map(Self::TypeBinder)
17499 .unwrap_or(Self::Unknown(node)),
17500 "type_family" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17501 <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)
17502 })
17503 .map(Self::TypeFamily)
17504 .unwrap_or(Self::Unknown(node)),
17505 "type_family_injectivity" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17506 <TypeFamilyInjectivity as ::treesitter_types::FromNode>::from_node(node, src)
17507 })
17508 .map(Self::TypeFamilyInjectivity)
17509 .unwrap_or(Self::Unknown(node)),
17510 "type_family_result" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17511 <TypeFamilyResult as ::treesitter_types::FromNode>::from_node(node, src)
17512 })
17513 .map(Self::TypeFamilyResult)
17514 .unwrap_or(Self::Unknown(node)),
17515 "type_instance" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17516 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)
17517 })
17518 .map(Self::TypeInstance)
17519 .unwrap_or(Self::Unknown(node)),
17520 "type_params" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17521 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)
17522 })
17523 .map(Self::TypeParams)
17524 .unwrap_or(Self::Unknown(node)),
17525 "type_patterns" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17526 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)
17527 })
17528 .map(Self::TypePatterns)
17529 .unwrap_or(Self::Unknown(node)),
17530 "type_role" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17531 <TypeRole as ::treesitter_types::FromNode>::from_node(node, src)
17532 })
17533 .map(Self::TypeRole)
17534 .unwrap_or(Self::Unknown(node)),
17535 "type_synomym" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17536 <TypeSynomym as ::treesitter_types::FromNode>::from_node(node, src)
17537 })
17538 .map(Self::TypeSynomym)
17539 .unwrap_or(Self::Unknown(node)),
17540 "typed_quote" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17541 <TypedQuote as ::treesitter_types::FromNode>::from_node(node, src)
17542 })
17543 .map(Self::TypedQuote)
17544 .unwrap_or(Self::Unknown(node)),
17545 "unboxed_sum" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17546 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
17547 })
17548 .map(Self::UnboxedSum)
17549 .unwrap_or(Self::Unknown(node)),
17550 "unboxed_tuple" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17551 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
17552 })
17553 .map(Self::UnboxedTuple)
17554 .unwrap_or(Self::Unknown(node)),
17555 "unboxed_unit" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17556 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
17557 })
17558 .map(Self::UnboxedUnit)
17559 .unwrap_or(Self::Unknown(node)),
17560 "unit" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17561 <Unit as ::treesitter_types::FromNode>::from_node(node, src)
17562 })
17563 .map(Self::Unit)
17564 .unwrap_or(Self::Unknown(node)),
17565 "via" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17566 <Via as ::treesitter_types::FromNode>::from_node(node, src)
17567 })
17568 .map(Self::Via)
17569 .unwrap_or(Self::Unknown(node)),
17570 "view_pattern" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17571 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
17572 })
17573 .map(Self::ViewPattern)
17574 .unwrap_or(Self::Unknown(node)),
17575 "wildcard" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17576 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
17577 })
17578 .map(Self::Wildcard)
17579 .unwrap_or(Self::Unknown(node)),
17580 "all_names" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17581 <AllNames as ::treesitter_types::FromNode>::from_node(node, src)
17582 })
17583 .map(Self::AllNames)
17584 .unwrap_or(Self::Unknown(node)),
17585 "calling_convention" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17586 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
17587 })
17588 .map(Self::CallingConvention)
17589 .unwrap_or(Self::Unknown(node)),
17590 "char" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17591 <Char as ::treesitter_types::FromNode>::from_node(node, src)
17592 })
17593 .map(Self::Char)
17594 .unwrap_or(Self::Unknown(node)),
17595 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17596 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
17597 })
17598 .map(Self::Comment)
17599 .unwrap_or(Self::Unknown(node)),
17600 "constructor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17601 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
17602 })
17603 .map(Self::Constructor)
17604 .unwrap_or(Self::Unknown(node)),
17605 "cpp" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17606 <Cpp as ::treesitter_types::FromNode>::from_node(node, src)
17607 })
17608 .map(Self::Cpp)
17609 .unwrap_or(Self::Unknown(node)),
17610 "float" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17611 <Float as ::treesitter_types::FromNode>::from_node(node, src)
17612 })
17613 .map(Self::Float)
17614 .unwrap_or(Self::Unknown(node)),
17615 "haddock" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17616 <Haddock as ::treesitter_types::FromNode>::from_node(node, src)
17617 })
17618 .map(Self::Haddock)
17619 .unwrap_or(Self::Unknown(node)),
17620 "implicit_variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17621 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)
17622 })
17623 .map(Self::ImplicitVariable)
17624 .unwrap_or(Self::Unknown(node)),
17625 "import_package" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17626 <ImportPackage as ::treesitter_types::FromNode>::from_node(node, src)
17627 })
17628 .map(Self::ImportPackage)
17629 .unwrap_or(Self::Unknown(node)),
17630 "label" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17631 <Label as ::treesitter_types::FromNode>::from_node(node, src)
17632 })
17633 .map(Self::Label)
17634 .unwrap_or(Self::Unknown(node)),
17635 "module_id" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17636 <ModuleId as ::treesitter_types::FromNode>::from_node(node, src)
17637 })
17638 .map(Self::ModuleId)
17639 .unwrap_or(Self::Unknown(node)),
17640 "name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17641 <Name as ::treesitter_types::FromNode>::from_node(node, src)
17642 })
17643 .map(Self::Name)
17644 .unwrap_or(Self::Unknown(node)),
17645 "pragma" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17646 <Pragma as ::treesitter_types::FromNode>::from_node(node, src)
17647 })
17648 .map(Self::Pragma)
17649 .unwrap_or(Self::Unknown(node)),
17650 "quasiquote_body" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17651 <QuasiquoteBody as ::treesitter_types::FromNode>::from_node(node, src)
17652 })
17653 .map(Self::QuasiquoteBody)
17654 .unwrap_or(Self::Unknown(node)),
17655 "safety" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17656 <Safety as ::treesitter_types::FromNode>::from_node(node, src)
17657 })
17658 .map(Self::Safety)
17659 .unwrap_or(Self::Unknown(node)),
17660 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17661 <String as ::treesitter_types::FromNode>::from_node(node, src)
17662 })
17663 .map(Self::String)
17664 .unwrap_or(Self::Unknown(node)),
17665 "variable" => ::treesitter_types::runtime::maybe_grow_stack(|| {
17666 <Variable as ::treesitter_types::FromNode>::from_node(node, src)
17667 })
17668 .map(Self::Variable)
17669 .unwrap_or(Self::Unknown(node)),
17670 _ => Self::Unknown(node),
17671 }
17672 }
17673}
17674impl ::treesitter_types::Spanned for AnyNode<'_> {
17675 fn span(&self) -> ::treesitter_types::Span {
17676 match self {
17677 Self::ClassDecl(inner) => inner.span(),
17678 Self::Constraint(inner) => inner.span(),
17679 Self::Constraints(inner) => inner.span(),
17680 Self::Decl(inner) => inner.span(),
17681 Self::Declaration(inner) => inner.span(),
17682 Self::Expression(inner) => inner.span(),
17683 Self::Guard(inner) => inner.span(),
17684 Self::InstanceDecl(inner) => inner.span(),
17685 Self::Pattern(inner) => inner.span(),
17686 Self::Qualifier(inner) => inner.span(),
17687 Self::QuantifiedType(inner) => inner.span(),
17688 Self::Statement(inner) => inner.span(),
17689 Self::Type(inner) => inner.span(),
17690 Self::TypeParam(inner) => inner.span(),
17691 Self::AbstractFamily(inner) => inner.span(),
17692 Self::Alternative(inner) => inner.span(),
17693 Self::Alternatives(inner) => inner.span(),
17694 Self::Annotated(inner) => inner.span(),
17695 Self::Apply(inner) => inner.span(),
17696 Self::ArithmeticSequence(inner) => inner.span(),
17697 Self::As(inner) => inner.span(),
17698 Self::AssociatedType(inner) => inner.span(),
17699 Self::Bind(inner) => inner.span(),
17700 Self::BindingList(inner) => inner.span(),
17701 Self::Boolean(inner) => inner.span(),
17702 Self::Case(inner) => inner.span(),
17703 Self::Children(inner) => inner.span(),
17704 Self::Class(inner) => inner.span(),
17705 Self::ClassDeclarations(inner) => inner.span(),
17706 Self::Conditional(inner) => inner.span(),
17707 Self::ConstructorOperator(inner) => inner.span(),
17708 Self::ConstructorSynonym(inner) => inner.span(),
17709 Self::ConstructorSynonyms(inner) => inner.span(),
17710 Self::Context(inner) => inner.span(),
17711 Self::DataConstructor(inner) => inner.span(),
17712 Self::DataConstructors(inner) => inner.span(),
17713 Self::DataFamily(inner) => inner.span(),
17714 Self::DataInstance(inner) => inner.span(),
17715 Self::DataType(inner) => inner.span(),
17716 Self::Declarations(inner) => inner.span(),
17717 Self::DefaultSignature(inner) => inner.span(),
17718 Self::DefaultTypes(inner) => inner.span(),
17719 Self::Deriving(inner) => inner.span(),
17720 Self::DerivingInstance(inner) => inner.span(),
17721 Self::DerivingStrategy(inner) => inner.span(),
17722 Self::Do(inner) => inner.span(),
17723 Self::DoModule(inner) => inner.span(),
17724 Self::EmptyList(inner) => inner.span(),
17725 Self::Entity(inner) => inner.span(),
17726 Self::Equation(inner) => inner.span(),
17727 Self::Equations(inner) => inner.span(),
17728 Self::Exp(inner) => inner.span(),
17729 Self::ExplicitType(inner) => inner.span(),
17730 Self::Export(inner) => inner.span(),
17731 Self::Exports(inner) => inner.span(),
17732 Self::Field(inner) => inner.span(),
17733 Self::FieldName(inner) => inner.span(),
17734 Self::FieldPath(inner) => inner.span(),
17735 Self::FieldPattern(inner) => inner.span(),
17736 Self::FieldUpdate(inner) => inner.span(),
17737 Self::Fields(inner) => inner.span(),
17738 Self::Fixity(inner) => inner.span(),
17739 Self::Forall(inner) => inner.span(),
17740 Self::ForallRequired(inner) => inner.span(),
17741 Self::ForeignExport(inner) => inner.span(),
17742 Self::ForeignImport(inner) => inner.span(),
17743 Self::Function(inner) => inner.span(),
17744 Self::FunctionHeadParens(inner) => inner.span(),
17745 Self::Fundep(inner) => inner.span(),
17746 Self::Fundeps(inner) => inner.span(),
17747 Self::GadtConstructor(inner) => inner.span(),
17748 Self::GadtConstructors(inner) => inner.span(),
17749 Self::Generator(inner) => inner.span(),
17750 Self::Group(inner) => inner.span(),
17751 Self::Guards(inner) => inner.span(),
17752 Self::Haskell(inner) => inner.span(),
17753 Self::Header(inner) => inner.span(),
17754 Self::ImplicitParameter(inner) => inner.span(),
17755 Self::Import(inner) => inner.span(),
17756 Self::ImportList(inner) => inner.span(),
17757 Self::ImportName(inner) => inner.span(),
17758 Self::Imports(inner) => inner.span(),
17759 Self::Inferred(inner) => inner.span(),
17760 Self::Infix(inner) => inner.span(),
17761 Self::InfixId(inner) => inner.span(),
17762 Self::Instance(inner) => inner.span(),
17763 Self::InstanceDeclarations(inner) => inner.span(),
17764 Self::Integer(inner) => inner.span(),
17765 Self::Invisible(inner) => inner.span(),
17766 Self::Irrefutable(inner) => inner.span(),
17767 Self::KindApplication(inner) => inner.span(),
17768 Self::KindSignature(inner) => inner.span(),
17769 Self::Lambda(inner) => inner.span(),
17770 Self::LambdaCase(inner) => inner.span(),
17771 Self::LambdaCases(inner) => inner.span(),
17772 Self::LazyField(inner) => inner.span(),
17773 Self::LeftSection(inner) => inner.span(),
17774 Self::Let(inner) => inner.span(),
17775 Self::LetIn(inner) => inner.span(),
17776 Self::LinearFunction(inner) => inner.span(),
17777 Self::List(inner) => inner.span(),
17778 Self::ListComprehension(inner) => inner.span(),
17779 Self::Literal(inner) => inner.span(),
17780 Self::LocalBinds(inner) => inner.span(),
17781 Self::Match(inner) => inner.span(),
17782 Self::Modifier(inner) => inner.span(),
17783 Self::Module(inner) => inner.span(),
17784 Self::ModuleExport(inner) => inner.span(),
17785 Self::MultiWayIf(inner) => inner.span(),
17786 Self::Namespace(inner) => inner.span(),
17787 Self::Negation(inner) => inner.span(),
17788 Self::Newtype(inner) => inner.span(),
17789 Self::NewtypeConstructor(inner) => inner.span(),
17790 Self::Operator(inner) => inner.span(),
17791 Self::Parens(inner) => inner.span(),
17792 Self::PatternGuard(inner) => inner.span(),
17793 Self::PatternSynonym(inner) => inner.span(),
17794 Self::Patterns(inner) => inner.span(),
17795 Self::Prefix(inner) => inner.span(),
17796 Self::PrefixId(inner) => inner.span(),
17797 Self::PrefixList(inner) => inner.span(),
17798 Self::PrefixTuple(inner) => inner.span(),
17799 Self::PrefixUnboxedSum(inner) => inner.span(),
17800 Self::PrefixUnboxedTuple(inner) => inner.span(),
17801 Self::Projection(inner) => inner.span(),
17802 Self::ProjectionSelector(inner) => inner.span(),
17803 Self::Promoted(inner) => inner.span(),
17804 Self::Qualified(inner) => inner.span(),
17805 Self::Qualifiers(inner) => inner.span(),
17806 Self::QuantifiedVariables(inner) => inner.span(),
17807 Self::Quasiquote(inner) => inner.span(),
17808 Self::Quote(inner) => inner.span(),
17809 Self::QuotedDecls(inner) => inner.span(),
17810 Self::QuotedExpression(inner) => inner.span(),
17811 Self::QuotedPattern(inner) => inner.span(),
17812 Self::QuotedType(inner) => inner.span(),
17813 Self::Quoter(inner) => inner.span(),
17814 Self::Rec(inner) => inner.span(),
17815 Self::Record(inner) => inner.span(),
17816 Self::RightSection(inner) => inner.span(),
17817 Self::RoleAnnotation(inner) => inner.span(),
17818 Self::Signature(inner) => inner.span(),
17819 Self::Special(inner) => inner.span(),
17820 Self::Splice(inner) => inner.span(),
17821 Self::Star(inner) => inner.span(),
17822 Self::Strict(inner) => inner.span(),
17823 Self::StrictField(inner) => inner.span(),
17824 Self::ThQuotedName(inner) => inner.span(),
17825 Self::TopSplice(inner) => inner.span(),
17826 Self::Transform(inner) => inner.span(),
17827 Self::Tuple(inner) => inner.span(),
17828 Self::TypeApplication(inner) => inner.span(),
17829 Self::TypeBinder(inner) => inner.span(),
17830 Self::TypeFamily(inner) => inner.span(),
17831 Self::TypeFamilyInjectivity(inner) => inner.span(),
17832 Self::TypeFamilyResult(inner) => inner.span(),
17833 Self::TypeInstance(inner) => inner.span(),
17834 Self::TypeParams(inner) => inner.span(),
17835 Self::TypePatterns(inner) => inner.span(),
17836 Self::TypeRole(inner) => inner.span(),
17837 Self::TypeSynomym(inner) => inner.span(),
17838 Self::TypedQuote(inner) => inner.span(),
17839 Self::UnboxedSum(inner) => inner.span(),
17840 Self::UnboxedTuple(inner) => inner.span(),
17841 Self::UnboxedUnit(inner) => inner.span(),
17842 Self::Unit(inner) => inner.span(),
17843 Self::Via(inner) => inner.span(),
17844 Self::ViewPattern(inner) => inner.span(),
17845 Self::Wildcard(inner) => inner.span(),
17846 Self::AllNames(inner) => inner.span(),
17847 Self::CallingConvention(inner) => inner.span(),
17848 Self::Char(inner) => inner.span(),
17849 Self::Comment(inner) => inner.span(),
17850 Self::Constructor(inner) => inner.span(),
17851 Self::Cpp(inner) => inner.span(),
17852 Self::Float(inner) => inner.span(),
17853 Self::Haddock(inner) => inner.span(),
17854 Self::ImplicitVariable(inner) => inner.span(),
17855 Self::ImportPackage(inner) => inner.span(),
17856 Self::Label(inner) => inner.span(),
17857 Self::ModuleId(inner) => inner.span(),
17858 Self::Name(inner) => inner.span(),
17859 Self::Pragma(inner) => inner.span(),
17860 Self::QuasiquoteBody(inner) => inner.span(),
17861 Self::Safety(inner) => inner.span(),
17862 Self::String(inner) => inner.span(),
17863 Self::Variable(inner) => inner.span(),
17864 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
17865 }
17866 }
17867}