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: ::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 <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)?,
19 ))),
20 "default_signature" => Ok(Self::DefaultSignature(::std::boxed::Box::new(
21 <DefaultSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
22 ))),
23 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
24 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)?,
25 ))),
26 "type_family" => Ok(Self::TypeFamily(::std::boxed::Box::new(
27 <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)?,
28 ))),
29 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
30 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
31 ))),
32 _other => {
33 if let Ok(v) = <Decl as ::treesitter_types::FromNode>::from_node(node, src) {
34 Ok(Self::Decl(::std::boxed::Box::new(v)))
35 } else {
36 Err(::treesitter_types::ParseError::unexpected_kind(
37 _other, node,
38 ))
39 }
40 }
41 }
42 }
43}
44impl ::treesitter_types::Spanned for ClassDecl<'_> {
45 fn span(&self) -> ::treesitter_types::Span {
46 match self {
47 Self::DataFamily(inner) => inner.span(),
48 Self::Decl(inner) => inner.span(),
49 Self::DefaultSignature(inner) => inner.span(),
50 Self::Fixity(inner) => inner.span(),
51 Self::TypeFamily(inner) => inner.span(),
52 Self::TypeInstance(inner) => inner.span(),
53 }
54 }
55}
56#[derive(Debug, Clone, PartialEq, Eq)]
57pub enum Constraint<'tree> {
58 Apply(::std::boxed::Box<Apply<'tree>>),
59 Infix(::std::boxed::Box<Infix<'tree>>),
60 Literal(::std::boxed::Box<Literal<'tree>>),
61 Name(::std::boxed::Box<Name<'tree>>),
62 Parens(::std::boxed::Box<Parens<'tree>>),
63 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
64 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
65 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
66 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
67 Promoted(::std::boxed::Box<Promoted<'tree>>),
68 Qualified(::std::boxed::Box<Qualified<'tree>>),
69 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
70 Splice(::std::boxed::Box<Splice<'tree>>),
71 Tuple(::std::boxed::Box<Tuple<'tree>>),
72 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
73 Unit(::std::boxed::Box<Unit<'tree>>),
74 Variable(::std::boxed::Box<Variable<'tree>>),
75 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
76}
77impl<'tree> ::treesitter_types::FromNode<'tree> for Constraint<'tree> {
78 #[allow(clippy::collapsible_else_if)]
79 fn from_node(
80 node: ::tree_sitter::Node<'tree>,
81 src: &'tree [u8],
82 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
83 match node.kind() {
84 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
85 <Apply as ::treesitter_types::FromNode>::from_node(node, src)?,
86 ))),
87 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
88 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
89 ))),
90 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
91 <Literal as ::treesitter_types::FromNode>::from_node(node, src)?,
92 ))),
93 "name" => Ok(Self::Name(::std::boxed::Box::new(
94 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
95 ))),
96 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
97 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
98 ))),
99 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
100 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
101 ))),
102 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
103 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
104 ))),
105 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
106 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
107 ))),
108 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
109 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
110 ))),
111 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
112 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)?,
113 ))),
114 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
115 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
116 ))),
117 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
118 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)?,
119 ))),
120 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
121 <Splice as ::treesitter_types::FromNode>::from_node(node, src)?,
122 ))),
123 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
124 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
125 ))),
126 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
127 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)?,
128 ))),
129 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
130 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
131 ))),
132 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
133 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
134 ))),
135 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
136 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
137 ))),
138 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
139 }
140 }
141}
142impl ::treesitter_types::Spanned for Constraint<'_> {
143 fn span(&self) -> ::treesitter_types::Span {
144 match self {
145 Self::Apply(inner) => inner.span(),
146 Self::Infix(inner) => inner.span(),
147 Self::Literal(inner) => inner.span(),
148 Self::Name(inner) => inner.span(),
149 Self::Parens(inner) => inner.span(),
150 Self::PrefixId(inner) => inner.span(),
151 Self::PrefixTuple(inner) => inner.span(),
152 Self::PrefixUnboxedSum(inner) => inner.span(),
153 Self::PrefixUnboxedTuple(inner) => inner.span(),
154 Self::Promoted(inner) => inner.span(),
155 Self::Qualified(inner) => inner.span(),
156 Self::Quasiquote(inner) => inner.span(),
157 Self::Splice(inner) => inner.span(),
158 Self::Tuple(inner) => inner.span(),
159 Self::UnboxedUnit(inner) => inner.span(),
160 Self::Unit(inner) => inner.span(),
161 Self::Variable(inner) => inner.span(),
162 Self::Wildcard(inner) => inner.span(),
163 }
164 }
165}
166#[derive(Debug, Clone, PartialEq, Eq)]
167pub enum Constraints<'tree> {
168 Constraint(::std::boxed::Box<Constraint<'tree>>),
169 Context(::std::boxed::Box<Context<'tree>>),
170 Forall(::std::boxed::Box<Forall<'tree>>),
171 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
172 Signature(::std::boxed::Box<Signature<'tree>>),
173}
174impl<'tree> ::treesitter_types::FromNode<'tree> for Constraints<'tree> {
175 #[allow(clippy::collapsible_else_if)]
176 fn from_node(
177 node: ::tree_sitter::Node<'tree>,
178 src: &'tree [u8],
179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
180 match node.kind() {
181 "context" => Ok(Self::Context(::std::boxed::Box::new(
182 <Context as ::treesitter_types::FromNode>::from_node(node, src)?,
183 ))),
184 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
185 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
186 ))),
187 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
188 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
189 ))),
190 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
191 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
192 ))),
193 _other => {
194 if let Ok(v) = <Constraint as ::treesitter_types::FromNode>::from_node(node, src) {
195 Ok(Self::Constraint(::std::boxed::Box::new(v)))
196 } else {
197 Err(::treesitter_types::ParseError::unexpected_kind(
198 _other, node,
199 ))
200 }
201 }
202 }
203 }
204}
205impl ::treesitter_types::Spanned for Constraints<'_> {
206 fn span(&self) -> ::treesitter_types::Span {
207 match self {
208 Self::Constraint(inner) => inner.span(),
209 Self::Context(inner) => inner.span(),
210 Self::Forall(inner) => inner.span(),
211 Self::ImplicitParameter(inner) => inner.span(),
212 Self::Signature(inner) => inner.span(),
213 }
214 }
215}
216#[derive(Debug, Clone, PartialEq, Eq)]
217pub enum Decl<'tree> {
218 Bind(::std::boxed::Box<Bind<'tree>>),
219 Function(::std::boxed::Box<Function<'tree>>),
220 Signature(::std::boxed::Box<Signature<'tree>>),
221}
222impl<'tree> ::treesitter_types::FromNode<'tree> for Decl<'tree> {
223 #[allow(clippy::collapsible_else_if)]
224 fn from_node(
225 node: ::tree_sitter::Node<'tree>,
226 src: &'tree [u8],
227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
228 match node.kind() {
229 "bind" => Ok(Self::Bind(::std::boxed::Box::new(
230 <Bind as ::treesitter_types::FromNode>::from_node(node, src)?,
231 ))),
232 "function" => Ok(Self::Function(::std::boxed::Box::new(
233 <Function as ::treesitter_types::FromNode>::from_node(node, src)?,
234 ))),
235 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
236 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
237 ))),
238 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
239 }
240 }
241}
242impl ::treesitter_types::Spanned for Decl<'_> {
243 fn span(&self) -> ::treesitter_types::Span {
244 match self {
245 Self::Bind(inner) => inner.span(),
246 Self::Function(inner) => inner.span(),
247 Self::Signature(inner) => inner.span(),
248 }
249 }
250}
251#[derive(Debug, Clone, PartialEq, Eq)]
252pub enum Declaration<'tree> {
253 Class(::std::boxed::Box<Class<'tree>>),
254 DataFamily(::std::boxed::Box<DataFamily<'tree>>),
255 DataInstance(::std::boxed::Box<DataInstance<'tree>>),
256 DataType(::std::boxed::Box<DataType<'tree>>),
257 Decl(::std::boxed::Box<Decl<'tree>>),
258 DefaultTypes(::std::boxed::Box<DefaultTypes<'tree>>),
259 DerivingInstance(::std::boxed::Box<DerivingInstance<'tree>>),
260 Fixity(::std::boxed::Box<Fixity<'tree>>),
261 ForeignExport(::std::boxed::Box<ForeignExport<'tree>>),
262 ForeignImport(::std::boxed::Box<ForeignImport<'tree>>),
263 Instance(::std::boxed::Box<Instance<'tree>>),
264 KindSignature(::std::boxed::Box<KindSignature<'tree>>),
265 Newtype(::std::boxed::Box<Newtype<'tree>>),
266 PatternSynonym(::std::boxed::Box<PatternSynonym<'tree>>),
267 RoleAnnotation(::std::boxed::Box<RoleAnnotation<'tree>>),
268 TopSplice(::std::boxed::Box<TopSplice<'tree>>),
269 TypeFamily(::std::boxed::Box<TypeFamily<'tree>>),
270 TypeInstance(::std::boxed::Box<TypeInstance<'tree>>),
271 TypeSynomym(::std::boxed::Box<TypeSynomym<'tree>>),
272}
273impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
274 #[allow(clippy::collapsible_else_if)]
275 fn from_node(
276 node: ::tree_sitter::Node<'tree>,
277 src: &'tree [u8],
278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
279 match node.kind() {
280 "class" => Ok(Self::Class(::std::boxed::Box::new(
281 <Class as ::treesitter_types::FromNode>::from_node(node, src)?,
282 ))),
283 "data_family" => Ok(Self::DataFamily(::std::boxed::Box::new(
284 <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)?,
285 ))),
286 "data_instance" => Ok(Self::DataInstance(::std::boxed::Box::new(
287 <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
288 ))),
289 "data_type" => Ok(Self::DataType(::std::boxed::Box::new(
290 <DataType as ::treesitter_types::FromNode>::from_node(node, src)?,
291 ))),
292 "default_types" => Ok(Self::DefaultTypes(::std::boxed::Box::new(
293 <DefaultTypes as ::treesitter_types::FromNode>::from_node(node, src)?,
294 ))),
295 "deriving_instance" => Ok(Self::DerivingInstance(::std::boxed::Box::new(
296 <DerivingInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
297 ))),
298 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
299 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)?,
300 ))),
301 "foreign_export" => Ok(Self::ForeignExport(::std::boxed::Box::new(
302 <ForeignExport as ::treesitter_types::FromNode>::from_node(node, src)?,
303 ))),
304 "foreign_import" => Ok(Self::ForeignImport(::std::boxed::Box::new(
305 <ForeignImport as ::treesitter_types::FromNode>::from_node(node, src)?,
306 ))),
307 "instance" => Ok(Self::Instance(::std::boxed::Box::new(
308 <Instance as ::treesitter_types::FromNode>::from_node(node, src)?,
309 ))),
310 "kind_signature" => Ok(Self::KindSignature(::std::boxed::Box::new(
311 <KindSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
312 ))),
313 "newtype" => Ok(Self::Newtype(::std::boxed::Box::new(
314 <Newtype as ::treesitter_types::FromNode>::from_node(node, src)?,
315 ))),
316 "pattern_synonym" => Ok(Self::PatternSynonym(::std::boxed::Box::new(
317 <PatternSynonym as ::treesitter_types::FromNode>::from_node(node, src)?,
318 ))),
319 "role_annotation" => Ok(Self::RoleAnnotation(::std::boxed::Box::new(
320 <RoleAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
321 ))),
322 "top_splice" => Ok(Self::TopSplice(::std::boxed::Box::new(
323 <TopSplice as ::treesitter_types::FromNode>::from_node(node, src)?,
324 ))),
325 "type_family" => Ok(Self::TypeFamily(::std::boxed::Box::new(
326 <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)?,
327 ))),
328 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
329 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
330 ))),
331 "type_synomym" => Ok(Self::TypeSynomym(::std::boxed::Box::new(
332 <TypeSynomym as ::treesitter_types::FromNode>::from_node(node, src)?,
333 ))),
334 _other => {
335 if let Ok(v) = <Decl as ::treesitter_types::FromNode>::from_node(node, src) {
336 Ok(Self::Decl(::std::boxed::Box::new(v)))
337 } else {
338 Err(::treesitter_types::ParseError::unexpected_kind(
339 _other, node,
340 ))
341 }
342 }
343 }
344 }
345}
346impl ::treesitter_types::Spanned for Declaration<'_> {
347 fn span(&self) -> ::treesitter_types::Span {
348 match self {
349 Self::Class(inner) => inner.span(),
350 Self::DataFamily(inner) => inner.span(),
351 Self::DataInstance(inner) => inner.span(),
352 Self::DataType(inner) => inner.span(),
353 Self::Decl(inner) => inner.span(),
354 Self::DefaultTypes(inner) => inner.span(),
355 Self::DerivingInstance(inner) => inner.span(),
356 Self::Fixity(inner) => inner.span(),
357 Self::ForeignExport(inner) => inner.span(),
358 Self::ForeignImport(inner) => inner.span(),
359 Self::Instance(inner) => inner.span(),
360 Self::KindSignature(inner) => inner.span(),
361 Self::Newtype(inner) => inner.span(),
362 Self::PatternSynonym(inner) => inner.span(),
363 Self::RoleAnnotation(inner) => inner.span(),
364 Self::TopSplice(inner) => inner.span(),
365 Self::TypeFamily(inner) => inner.span(),
366 Self::TypeInstance(inner) => inner.span(),
367 Self::TypeSynomym(inner) => inner.span(),
368 }
369 }
370}
371#[derive(Debug, Clone, PartialEq, Eq)]
372pub enum Expression<'tree> {
373 Apply(::std::boxed::Box<Apply<'tree>>),
374 ArithmeticSequence(::std::boxed::Box<ArithmeticSequence<'tree>>),
375 Case(::std::boxed::Box<Case<'tree>>),
376 Conditional(::std::boxed::Box<Conditional<'tree>>),
377 Constructor(::std::boxed::Box<Constructor<'tree>>),
378 Do(::std::boxed::Box<Do<'tree>>),
379 ImplicitVariable(::std::boxed::Box<ImplicitVariable<'tree>>),
380 Infix(::std::boxed::Box<Infix<'tree>>),
381 Label(::std::boxed::Box<Label<'tree>>),
382 Lambda(::std::boxed::Box<Lambda<'tree>>),
383 LambdaCase(::std::boxed::Box<LambdaCase<'tree>>),
384 LambdaCases(::std::boxed::Box<LambdaCases<'tree>>),
385 LeftSection(::std::boxed::Box<LeftSection<'tree>>),
386 LetIn(::std::boxed::Box<LetIn<'tree>>),
387 List(::std::boxed::Box<List<'tree>>),
388 ListComprehension(::std::boxed::Box<ListComprehension<'tree>>),
389 Literal(::std::boxed::Box<Literal<'tree>>),
390 MultiWayIf(::std::boxed::Box<MultiWayIf<'tree>>),
391 Negation(::std::boxed::Box<Negation<'tree>>),
392 Parens(::std::boxed::Box<Parens<'tree>>),
393 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
394 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
395 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
396 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
397 Projection(::std::boxed::Box<Projection<'tree>>),
398 ProjectionSelector(::std::boxed::Box<ProjectionSelector<'tree>>),
399 Qualified(::std::boxed::Box<Qualified<'tree>>),
400 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
401 Quote(::std::boxed::Box<Quote<'tree>>),
402 Record(::std::boxed::Box<Record<'tree>>),
403 RightSection(::std::boxed::Box<RightSection<'tree>>),
404 Splice(::std::boxed::Box<Splice<'tree>>),
405 ThQuotedName(::std::boxed::Box<ThQuotedName<'tree>>),
406 Tuple(::std::boxed::Box<Tuple<'tree>>),
407 TypedQuote(::std::boxed::Box<TypedQuote<'tree>>),
408 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
409 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
410 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
411 Unit(::std::boxed::Box<Unit<'tree>>),
412 Variable(::std::boxed::Box<Variable<'tree>>),
413}
414impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
415 #[allow(clippy::collapsible_else_if)]
416 fn from_node(
417 node: ::tree_sitter::Node<'tree>,
418 src: &'tree [u8],
419 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
420 match node.kind() {
421 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
422 <Apply as ::treesitter_types::FromNode>::from_node(node, src)?,
423 ))),
424 "arithmetic_sequence" => Ok(Self::ArithmeticSequence(::std::boxed::Box::new(
425 <ArithmeticSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
426 ))),
427 "case" => Ok(Self::Case(::std::boxed::Box::new(
428 <Case as ::treesitter_types::FromNode>::from_node(node, src)?,
429 ))),
430 "conditional" => Ok(Self::Conditional(::std::boxed::Box::new(
431 <Conditional as ::treesitter_types::FromNode>::from_node(node, src)?,
432 ))),
433 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
434 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
435 ))),
436 "do" => Ok(Self::Do(::std::boxed::Box::new(
437 <Do as ::treesitter_types::FromNode>::from_node(node, src)?,
438 ))),
439 "implicit_variable" => Ok(Self::ImplicitVariable(::std::boxed::Box::new(
440 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)?,
441 ))),
442 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
443 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
444 ))),
445 "label" => Ok(Self::Label(::std::boxed::Box::new(
446 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
447 ))),
448 "lambda" => Ok(Self::Lambda(::std::boxed::Box::new(
449 <Lambda as ::treesitter_types::FromNode>::from_node(node, src)?,
450 ))),
451 "lambda_case" => Ok(Self::LambdaCase(::std::boxed::Box::new(
452 <LambdaCase as ::treesitter_types::FromNode>::from_node(node, src)?,
453 ))),
454 "lambda_cases" => Ok(Self::LambdaCases(::std::boxed::Box::new(
455 <LambdaCases as ::treesitter_types::FromNode>::from_node(node, src)?,
456 ))),
457 "left_section" => Ok(Self::LeftSection(::std::boxed::Box::new(
458 <LeftSection as ::treesitter_types::FromNode>::from_node(node, src)?,
459 ))),
460 "let_in" => Ok(Self::LetIn(::std::boxed::Box::new(
461 <LetIn as ::treesitter_types::FromNode>::from_node(node, src)?,
462 ))),
463 "list" => Ok(Self::List(::std::boxed::Box::new(
464 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
465 ))),
466 "list_comprehension" => Ok(Self::ListComprehension(::std::boxed::Box::new(
467 <ListComprehension as ::treesitter_types::FromNode>::from_node(node, src)?,
468 ))),
469 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
470 <Literal as ::treesitter_types::FromNode>::from_node(node, src)?,
471 ))),
472 "multi_way_if" => Ok(Self::MultiWayIf(::std::boxed::Box::new(
473 <MultiWayIf as ::treesitter_types::FromNode>::from_node(node, src)?,
474 ))),
475 "negation" => Ok(Self::Negation(::std::boxed::Box::new(
476 <Negation as ::treesitter_types::FromNode>::from_node(node, src)?,
477 ))),
478 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
479 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
480 ))),
481 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
482 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
483 ))),
484 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
485 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
486 ))),
487 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
488 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
489 ))),
490 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
491 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
492 ))),
493 "projection" => Ok(Self::Projection(::std::boxed::Box::new(
494 <Projection as ::treesitter_types::FromNode>::from_node(node, src)?,
495 ))),
496 "projection_selector" => Ok(Self::ProjectionSelector(::std::boxed::Box::new(
497 <ProjectionSelector as ::treesitter_types::FromNode>::from_node(node, src)?,
498 ))),
499 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
500 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
501 ))),
502 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
503 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)?,
504 ))),
505 "quote" => Ok(Self::Quote(::std::boxed::Box::new(
506 <Quote as ::treesitter_types::FromNode>::from_node(node, src)?,
507 ))),
508 "record" => Ok(Self::Record(::std::boxed::Box::new(
509 <Record as ::treesitter_types::FromNode>::from_node(node, src)?,
510 ))),
511 "right_section" => Ok(Self::RightSection(::std::boxed::Box::new(
512 <RightSection as ::treesitter_types::FromNode>::from_node(node, src)?,
513 ))),
514 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
515 <Splice as ::treesitter_types::FromNode>::from_node(node, src)?,
516 ))),
517 "th_quoted_name" => Ok(Self::ThQuotedName(::std::boxed::Box::new(
518 <ThQuotedName as ::treesitter_types::FromNode>::from_node(node, src)?,
519 ))),
520 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
521 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
522 ))),
523 "typed_quote" => Ok(Self::TypedQuote(::std::boxed::Box::new(
524 <TypedQuote as ::treesitter_types::FromNode>::from_node(node, src)?,
525 ))),
526 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
527 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
528 ))),
529 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
530 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
531 ))),
532 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
533 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)?,
534 ))),
535 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
536 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
537 ))),
538 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
539 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
540 ))),
541 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
542 }
543 }
544}
545impl ::treesitter_types::Spanned for Expression<'_> {
546 fn span(&self) -> ::treesitter_types::Span {
547 match self {
548 Self::Apply(inner) => inner.span(),
549 Self::ArithmeticSequence(inner) => inner.span(),
550 Self::Case(inner) => inner.span(),
551 Self::Conditional(inner) => inner.span(),
552 Self::Constructor(inner) => inner.span(),
553 Self::Do(inner) => inner.span(),
554 Self::ImplicitVariable(inner) => inner.span(),
555 Self::Infix(inner) => inner.span(),
556 Self::Label(inner) => inner.span(),
557 Self::Lambda(inner) => inner.span(),
558 Self::LambdaCase(inner) => inner.span(),
559 Self::LambdaCases(inner) => inner.span(),
560 Self::LeftSection(inner) => inner.span(),
561 Self::LetIn(inner) => inner.span(),
562 Self::List(inner) => inner.span(),
563 Self::ListComprehension(inner) => inner.span(),
564 Self::Literal(inner) => inner.span(),
565 Self::MultiWayIf(inner) => inner.span(),
566 Self::Negation(inner) => inner.span(),
567 Self::Parens(inner) => inner.span(),
568 Self::PrefixId(inner) => inner.span(),
569 Self::PrefixTuple(inner) => inner.span(),
570 Self::PrefixUnboxedSum(inner) => inner.span(),
571 Self::PrefixUnboxedTuple(inner) => inner.span(),
572 Self::Projection(inner) => inner.span(),
573 Self::ProjectionSelector(inner) => inner.span(),
574 Self::Qualified(inner) => inner.span(),
575 Self::Quasiquote(inner) => inner.span(),
576 Self::Quote(inner) => inner.span(),
577 Self::Record(inner) => inner.span(),
578 Self::RightSection(inner) => inner.span(),
579 Self::Splice(inner) => inner.span(),
580 Self::ThQuotedName(inner) => inner.span(),
581 Self::Tuple(inner) => inner.span(),
582 Self::TypedQuote(inner) => inner.span(),
583 Self::UnboxedSum(inner) => inner.span(),
584 Self::UnboxedTuple(inner) => inner.span(),
585 Self::UnboxedUnit(inner) => inner.span(),
586 Self::Unit(inner) => inner.span(),
587 Self::Variable(inner) => inner.span(),
588 }
589 }
590}
591#[derive(Debug, Clone, PartialEq, Eq)]
592pub enum Guard<'tree> {
593 Boolean(::std::boxed::Box<Boolean<'tree>>),
594 Let(::std::boxed::Box<Let<'tree>>),
595 PatternGuard(::std::boxed::Box<PatternGuard<'tree>>),
596}
597impl<'tree> ::treesitter_types::FromNode<'tree> for Guard<'tree> {
598 #[allow(clippy::collapsible_else_if)]
599 fn from_node(
600 node: ::tree_sitter::Node<'tree>,
601 src: &'tree [u8],
602 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
603 match node.kind() {
604 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
605 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
606 ))),
607 "let" => Ok(Self::Let(::std::boxed::Box::new(
608 <Let as ::treesitter_types::FromNode>::from_node(node, src)?,
609 ))),
610 "pattern_guard" => Ok(Self::PatternGuard(::std::boxed::Box::new(
611 <PatternGuard as ::treesitter_types::FromNode>::from_node(node, src)?,
612 ))),
613 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
614 }
615 }
616}
617impl ::treesitter_types::Spanned for Guard<'_> {
618 fn span(&self) -> ::treesitter_types::Span {
619 match self {
620 Self::Boolean(inner) => inner.span(),
621 Self::Let(inner) => inner.span(),
622 Self::PatternGuard(inner) => inner.span(),
623 }
624 }
625}
626#[derive(Debug, Clone, PartialEq, Eq)]
627pub enum InstanceDecl<'tree> {
628 DataInstance(::std::boxed::Box<DataInstance<'tree>>),
629 Decl(::std::boxed::Box<Decl<'tree>>),
630 TypeInstance(::std::boxed::Box<TypeInstance<'tree>>),
631}
632impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceDecl<'tree> {
633 #[allow(clippy::collapsible_else_if)]
634 fn from_node(
635 node: ::tree_sitter::Node<'tree>,
636 src: &'tree [u8],
637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
638 match node.kind() {
639 "data_instance" => Ok(Self::DataInstance(::std::boxed::Box::new(
640 <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
641 ))),
642 "type_instance" => Ok(Self::TypeInstance(::std::boxed::Box::new(
643 <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)?,
644 ))),
645 _other => {
646 if let Ok(v) = <Decl as ::treesitter_types::FromNode>::from_node(node, src) {
647 Ok(Self::Decl(::std::boxed::Box::new(v)))
648 } else {
649 Err(::treesitter_types::ParseError::unexpected_kind(
650 _other, node,
651 ))
652 }
653 }
654 }
655 }
656}
657impl ::treesitter_types::Spanned for InstanceDecl<'_> {
658 fn span(&self) -> ::treesitter_types::Span {
659 match self {
660 Self::DataInstance(inner) => inner.span(),
661 Self::Decl(inner) => inner.span(),
662 Self::TypeInstance(inner) => inner.span(),
663 }
664 }
665}
666#[derive(Debug, Clone, PartialEq, Eq)]
667pub enum Pattern<'tree> {
668 Apply(::std::boxed::Box<Apply<'tree>>),
669 As(::std::boxed::Box<As<'tree>>),
670 Constructor(::std::boxed::Box<Constructor<'tree>>),
671 Infix(::std::boxed::Box<Infix<'tree>>),
672 Irrefutable(::std::boxed::Box<Irrefutable<'tree>>),
673 List(::std::boxed::Box<List<'tree>>),
674 Literal(::std::boxed::Box<Literal<'tree>>),
675 Negation(::std::boxed::Box<Negation<'tree>>),
676 Parens(::std::boxed::Box<Parens<'tree>>),
677 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
678 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
679 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
680 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
681 Qualified(::std::boxed::Box<Qualified<'tree>>),
682 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
683 Record(::std::boxed::Box<Record<'tree>>),
684 Splice(::std::boxed::Box<Splice<'tree>>),
685 Strict(::std::boxed::Box<Strict<'tree>>),
686 Tuple(::std::boxed::Box<Tuple<'tree>>),
687 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
688 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
689 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
690 Unit(::std::boxed::Box<Unit<'tree>>),
691 Variable(::std::boxed::Box<Variable<'tree>>),
692 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
693}
694impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
695 #[allow(clippy::collapsible_else_if)]
696 fn from_node(
697 node: ::tree_sitter::Node<'tree>,
698 src: &'tree [u8],
699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
700 match node.kind() {
701 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
702 <Apply as ::treesitter_types::FromNode>::from_node(node, src)?,
703 ))),
704 "as" => Ok(Self::As(::std::boxed::Box::new(
705 <As as ::treesitter_types::FromNode>::from_node(node, src)?,
706 ))),
707 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
708 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
709 ))),
710 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
711 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
712 ))),
713 "irrefutable" => Ok(Self::Irrefutable(::std::boxed::Box::new(
714 <Irrefutable as ::treesitter_types::FromNode>::from_node(node, src)?,
715 ))),
716 "list" => Ok(Self::List(::std::boxed::Box::new(
717 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
718 ))),
719 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
720 <Literal as ::treesitter_types::FromNode>::from_node(node, src)?,
721 ))),
722 "negation" => Ok(Self::Negation(::std::boxed::Box::new(
723 <Negation as ::treesitter_types::FromNode>::from_node(node, src)?,
724 ))),
725 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
726 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
727 ))),
728 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
729 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
730 ))),
731 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
732 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
733 ))),
734 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
735 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
736 ))),
737 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
738 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
739 ))),
740 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
741 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
742 ))),
743 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
744 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)?,
745 ))),
746 "record" => Ok(Self::Record(::std::boxed::Box::new(
747 <Record as ::treesitter_types::FromNode>::from_node(node, src)?,
748 ))),
749 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
750 <Splice as ::treesitter_types::FromNode>::from_node(node, src)?,
751 ))),
752 "strict" => Ok(Self::Strict(::std::boxed::Box::new(
753 <Strict as ::treesitter_types::FromNode>::from_node(node, src)?,
754 ))),
755 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
756 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
757 ))),
758 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
759 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
760 ))),
761 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
762 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
763 ))),
764 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
765 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)?,
766 ))),
767 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
768 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
769 ))),
770 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
771 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
772 ))),
773 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
774 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
775 ))),
776 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
777 }
778 }
779}
780impl ::treesitter_types::Spanned for Pattern<'_> {
781 fn span(&self) -> ::treesitter_types::Span {
782 match self {
783 Self::Apply(inner) => inner.span(),
784 Self::As(inner) => inner.span(),
785 Self::Constructor(inner) => inner.span(),
786 Self::Infix(inner) => inner.span(),
787 Self::Irrefutable(inner) => inner.span(),
788 Self::List(inner) => inner.span(),
789 Self::Literal(inner) => inner.span(),
790 Self::Negation(inner) => inner.span(),
791 Self::Parens(inner) => inner.span(),
792 Self::PrefixId(inner) => inner.span(),
793 Self::PrefixTuple(inner) => inner.span(),
794 Self::PrefixUnboxedSum(inner) => inner.span(),
795 Self::PrefixUnboxedTuple(inner) => inner.span(),
796 Self::Qualified(inner) => inner.span(),
797 Self::Quasiquote(inner) => inner.span(),
798 Self::Record(inner) => inner.span(),
799 Self::Splice(inner) => inner.span(),
800 Self::Strict(inner) => inner.span(),
801 Self::Tuple(inner) => inner.span(),
802 Self::UnboxedSum(inner) => inner.span(),
803 Self::UnboxedTuple(inner) => inner.span(),
804 Self::UnboxedUnit(inner) => inner.span(),
805 Self::Unit(inner) => inner.span(),
806 Self::Variable(inner) => inner.span(),
807 Self::Wildcard(inner) => inner.span(),
808 }
809 }
810}
811#[derive(Debug, Clone, PartialEq, Eq)]
812pub enum Qualifier<'tree> {
813 Boolean(::std::boxed::Box<Boolean<'tree>>),
814 Generator(::std::boxed::Box<Generator<'tree>>),
815 Group(::std::boxed::Box<Group<'tree>>),
816 Let(::std::boxed::Box<Let<'tree>>),
817 Transform(::std::boxed::Box<Transform<'tree>>),
818}
819impl<'tree> ::treesitter_types::FromNode<'tree> for Qualifier<'tree> {
820 #[allow(clippy::collapsible_else_if)]
821 fn from_node(
822 node: ::tree_sitter::Node<'tree>,
823 src: &'tree [u8],
824 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
825 match node.kind() {
826 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
827 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
828 ))),
829 "generator" => Ok(Self::Generator(::std::boxed::Box::new(
830 <Generator as ::treesitter_types::FromNode>::from_node(node, src)?,
831 ))),
832 "group" => Ok(Self::Group(::std::boxed::Box::new(
833 <Group as ::treesitter_types::FromNode>::from_node(node, src)?,
834 ))),
835 "let" => Ok(Self::Let(::std::boxed::Box::new(
836 <Let as ::treesitter_types::FromNode>::from_node(node, src)?,
837 ))),
838 "transform" => Ok(Self::Transform(::std::boxed::Box::new(
839 <Transform as ::treesitter_types::FromNode>::from_node(node, src)?,
840 ))),
841 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
842 }
843 }
844}
845impl ::treesitter_types::Spanned for Qualifier<'_> {
846 fn span(&self) -> ::treesitter_types::Span {
847 match self {
848 Self::Boolean(inner) => inner.span(),
849 Self::Generator(inner) => inner.span(),
850 Self::Group(inner) => inner.span(),
851 Self::Let(inner) => inner.span(),
852 Self::Transform(inner) => inner.span(),
853 }
854 }
855}
856#[derive(Debug, Clone, PartialEq, Eq)]
857pub enum QuantifiedType<'tree> {
858 Context(::std::boxed::Box<Context<'tree>>),
859 Forall(::std::boxed::Box<Forall<'tree>>),
860 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
861 Function(::std::boxed::Box<Function<'tree>>),
862 ImplicitParameter(::std::boxed::Box<ImplicitParameter<'tree>>),
863 LinearFunction(::std::boxed::Box<LinearFunction<'tree>>),
864 Type(::std::boxed::Box<Type<'tree>>),
865}
866impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedType<'tree> {
867 #[allow(clippy::collapsible_else_if)]
868 fn from_node(
869 node: ::tree_sitter::Node<'tree>,
870 src: &'tree [u8],
871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
872 match node.kind() {
873 "context" => Ok(Self::Context(::std::boxed::Box::new(
874 <Context as ::treesitter_types::FromNode>::from_node(node, src)?,
875 ))),
876 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
877 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
878 ))),
879 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
880 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
881 ))),
882 "function" => Ok(Self::Function(::std::boxed::Box::new(
883 <Function as ::treesitter_types::FromNode>::from_node(node, src)?,
884 ))),
885 "implicit_parameter" => Ok(Self::ImplicitParameter(::std::boxed::Box::new(
886 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
887 ))),
888 "linear_function" => Ok(Self::LinearFunction(::std::boxed::Box::new(
889 <LinearFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
890 ))),
891 _other => {
892 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
893 Ok(Self::Type(::std::boxed::Box::new(v)))
894 } else {
895 Err(::treesitter_types::ParseError::unexpected_kind(
896 _other, node,
897 ))
898 }
899 }
900 }
901 }
902}
903impl ::treesitter_types::Spanned for QuantifiedType<'_> {
904 fn span(&self) -> ::treesitter_types::Span {
905 match self {
906 Self::Context(inner) => inner.span(),
907 Self::Forall(inner) => inner.span(),
908 Self::ForallRequired(inner) => inner.span(),
909 Self::Function(inner) => inner.span(),
910 Self::ImplicitParameter(inner) => inner.span(),
911 Self::LinearFunction(inner) => inner.span(),
912 Self::Type(inner) => inner.span(),
913 }
914 }
915}
916#[derive(Debug, Clone, PartialEq, Eq)]
917pub enum Statement<'tree> {
918 Bind(::std::boxed::Box<Bind<'tree>>),
919 Exp(::std::boxed::Box<Exp<'tree>>),
920 Let(::std::boxed::Box<Let<'tree>>),
921 Rec(::std::boxed::Box<Rec<'tree>>),
922}
923impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
924 #[allow(clippy::collapsible_else_if)]
925 fn from_node(
926 node: ::tree_sitter::Node<'tree>,
927 src: &'tree [u8],
928 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
929 match node.kind() {
930 "bind" => Ok(Self::Bind(::std::boxed::Box::new(
931 <Bind as ::treesitter_types::FromNode>::from_node(node, src)?,
932 ))),
933 "exp" => Ok(Self::Exp(::std::boxed::Box::new(
934 <Exp as ::treesitter_types::FromNode>::from_node(node, src)?,
935 ))),
936 "let" => Ok(Self::Let(::std::boxed::Box::new(
937 <Let as ::treesitter_types::FromNode>::from_node(node, src)?,
938 ))),
939 "rec" => Ok(Self::Rec(::std::boxed::Box::new(
940 <Rec as ::treesitter_types::FromNode>::from_node(node, src)?,
941 ))),
942 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
943 }
944 }
945}
946impl ::treesitter_types::Spanned for Statement<'_> {
947 fn span(&self) -> ::treesitter_types::Span {
948 match self {
949 Self::Bind(inner) => inner.span(),
950 Self::Exp(inner) => inner.span(),
951 Self::Let(inner) => inner.span(),
952 Self::Rec(inner) => inner.span(),
953 }
954 }
955}
956#[derive(Debug, Clone, PartialEq, Eq)]
957pub enum Type<'tree> {
958 Apply(::std::boxed::Box<Apply<'tree>>),
959 Infix(::std::boxed::Box<Infix<'tree>>),
960 List(::std::boxed::Box<List<'tree>>),
961 Literal(::std::boxed::Box<Literal<'tree>>),
962 Name(::std::boxed::Box<Name<'tree>>),
963 Parens(::std::boxed::Box<Parens<'tree>>),
964 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
965 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
966 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
967 PrefixUnboxedSum(::std::boxed::Box<PrefixUnboxedSum<'tree>>),
968 PrefixUnboxedTuple(::std::boxed::Box<PrefixUnboxedTuple<'tree>>),
969 Promoted(::std::boxed::Box<Promoted<'tree>>),
970 Qualified(::std::boxed::Box<Qualified<'tree>>),
971 Quasiquote(::std::boxed::Box<Quasiquote<'tree>>),
972 Splice(::std::boxed::Box<Splice<'tree>>),
973 Star(::std::boxed::Box<Star<'tree>>),
974 Tuple(::std::boxed::Box<Tuple<'tree>>),
975 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
976 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
977 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
978 Unit(::std::boxed::Box<Unit<'tree>>),
979 Variable(::std::boxed::Box<Variable<'tree>>),
980 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
981}
982impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
983 #[allow(clippy::collapsible_else_if)]
984 fn from_node(
985 node: ::tree_sitter::Node<'tree>,
986 src: &'tree [u8],
987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
988 match node.kind() {
989 "apply" => Ok(Self::Apply(::std::boxed::Box::new(
990 <Apply as ::treesitter_types::FromNode>::from_node(node, src)?,
991 ))),
992 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
993 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
994 ))),
995 "list" => Ok(Self::List(::std::boxed::Box::new(
996 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
997 ))),
998 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
999 <Literal as ::treesitter_types::FromNode>::from_node(node, src)?,
1000 ))),
1001 "name" => Ok(Self::Name(::std::boxed::Box::new(
1002 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
1003 ))),
1004 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
1005 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
1006 ))),
1007 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
1008 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
1009 ))),
1010 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
1011 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
1012 ))),
1013 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
1014 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
1015 ))),
1016 "prefix_unboxed_sum" => Ok(Self::PrefixUnboxedSum(::std::boxed::Box::new(
1017 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
1018 ))),
1019 "prefix_unboxed_tuple" => Ok(Self::PrefixUnboxedTuple(::std::boxed::Box::new(
1020 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
1021 ))),
1022 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
1023 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)?,
1024 ))),
1025 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
1026 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
1027 ))),
1028 "quasiquote" => Ok(Self::Quasiquote(::std::boxed::Box::new(
1029 <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)?,
1030 ))),
1031 "splice" => Ok(Self::Splice(::std::boxed::Box::new(
1032 <Splice as ::treesitter_types::FromNode>::from_node(node, src)?,
1033 ))),
1034 "star" => Ok(Self::Star(::std::boxed::Box::new(
1035 <Star as ::treesitter_types::FromNode>::from_node(node, src)?,
1036 ))),
1037 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
1038 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
1039 ))),
1040 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
1041 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
1042 ))),
1043 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
1044 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
1045 ))),
1046 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
1047 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)?,
1048 ))),
1049 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
1050 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
1051 ))),
1052 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
1053 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
1054 ))),
1055 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
1056 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
1057 ))),
1058 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1059 }
1060 }
1061}
1062impl ::treesitter_types::Spanned for Type<'_> {
1063 fn span(&self) -> ::treesitter_types::Span {
1064 match self {
1065 Self::Apply(inner) => inner.span(),
1066 Self::Infix(inner) => inner.span(),
1067 Self::List(inner) => inner.span(),
1068 Self::Literal(inner) => inner.span(),
1069 Self::Name(inner) => inner.span(),
1070 Self::Parens(inner) => inner.span(),
1071 Self::PrefixId(inner) => inner.span(),
1072 Self::PrefixList(inner) => inner.span(),
1073 Self::PrefixTuple(inner) => inner.span(),
1074 Self::PrefixUnboxedSum(inner) => inner.span(),
1075 Self::PrefixUnboxedTuple(inner) => inner.span(),
1076 Self::Promoted(inner) => inner.span(),
1077 Self::Qualified(inner) => inner.span(),
1078 Self::Quasiquote(inner) => inner.span(),
1079 Self::Splice(inner) => inner.span(),
1080 Self::Star(inner) => inner.span(),
1081 Self::Tuple(inner) => inner.span(),
1082 Self::UnboxedSum(inner) => inner.span(),
1083 Self::UnboxedTuple(inner) => inner.span(),
1084 Self::UnboxedUnit(inner) => inner.span(),
1085 Self::Unit(inner) => inner.span(),
1086 Self::Variable(inner) => inner.span(),
1087 Self::Wildcard(inner) => inner.span(),
1088 }
1089 }
1090}
1091#[derive(Debug, Clone, PartialEq, Eq)]
1092pub enum TypeParam<'tree> {
1093 Invisible(::std::boxed::Box<Invisible<'tree>>),
1094 Parens(::std::boxed::Box<Parens<'tree>>),
1095 Variable(::std::boxed::Box<Variable<'tree>>),
1096 Wildcard(::std::boxed::Box<Wildcard<'tree>>),
1097}
1098impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParam<'tree> {
1099 #[allow(clippy::collapsible_else_if)]
1100 fn from_node(
1101 node: ::tree_sitter::Node<'tree>,
1102 src: &'tree [u8],
1103 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1104 match node.kind() {
1105 "invisible" => Ok(Self::Invisible(::std::boxed::Box::new(
1106 <Invisible as ::treesitter_types::FromNode>::from_node(node, src)?,
1107 ))),
1108 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
1109 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
1110 ))),
1111 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
1112 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
1113 ))),
1114 "wildcard" => Ok(Self::Wildcard(::std::boxed::Box::new(
1115 <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)?,
1116 ))),
1117 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1118 }
1119 }
1120}
1121impl ::treesitter_types::Spanned for TypeParam<'_> {
1122 fn span(&self) -> ::treesitter_types::Span {
1123 match self {
1124 Self::Invisible(inner) => inner.span(),
1125 Self::Parens(inner) => inner.span(),
1126 Self::Variable(inner) => inner.span(),
1127 Self::Wildcard(inner) => inner.span(),
1128 }
1129 }
1130}
1131#[derive(Debug, Clone, PartialEq, Eq)]
1132pub struct AbstractFamily<'tree> {
1133 pub span: ::treesitter_types::Span,
1134 text: &'tree str,
1135}
1136impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractFamily<'tree> {
1137 fn from_node(
1138 node: ::tree_sitter::Node<'tree>,
1139 src: &'tree [u8],
1140 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1141 debug_assert_eq!(node.kind(), "abstract_family");
1142 Ok(Self {
1143 span: ::treesitter_types::Span::from(node),
1144 text: node.utf8_text(src)?,
1145 })
1146 }
1147}
1148impl<'tree> ::treesitter_types::LeafNode<'tree> for AbstractFamily<'tree> {
1149 fn text(&self) -> &'tree str {
1150 self.text
1151 }
1152}
1153impl ::treesitter_types::Spanned for AbstractFamily<'_> {
1154 fn span(&self) -> ::treesitter_types::Span {
1155 self.span
1156 }
1157}
1158#[derive(Debug, Clone, PartialEq, Eq)]
1159pub struct Alternative<'tree> {
1160 pub span: ::treesitter_types::Span,
1161 pub binds: ::core::option::Option<LocalBinds<'tree>>,
1162 pub r#match: ::std::vec::Vec<Match<'tree>>,
1163 pub pattern: ::core::option::Option<AlternativePattern<'tree>>,
1164 pub patterns: ::core::option::Option<Patterns<'tree>>,
1165}
1166impl<'tree> ::treesitter_types::FromNode<'tree> for Alternative<'tree> {
1167 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1168 fn from_node(
1169 node: ::tree_sitter::Node<'tree>,
1170 src: &'tree [u8],
1171 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1172 debug_assert_eq!(node.kind(), "alternative");
1173 Ok(Self {
1174 span: ::treesitter_types::Span::from(node),
1175 binds: match node.child_by_field_name("binds") {
1176 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
1177 child, src,
1178 )?),
1179 None => None,
1180 },
1181 r#match: {
1182 let mut cursor = node.walk();
1183 let mut items = ::std::vec::Vec::new();
1184 for child in node.children_by_field_name("match", &mut cursor) {
1185 items.push(<Match as ::treesitter_types::FromNode>::from_node(
1186 child, src,
1187 )?);
1188 }
1189 items
1190 },
1191 pattern: match node.child_by_field_name("pattern") {
1192 Some(child) => Some(
1193 <AlternativePattern as ::treesitter_types::FromNode>::from_node(child, src)?,
1194 ),
1195 None => None,
1196 },
1197 patterns: match node.child_by_field_name("patterns") {
1198 Some(child) => Some(<Patterns as ::treesitter_types::FromNode>::from_node(
1199 child, src,
1200 )?),
1201 None => None,
1202 },
1203 })
1204 }
1205}
1206impl ::treesitter_types::Spanned for Alternative<'_> {
1207 fn span(&self) -> ::treesitter_types::Span {
1208 self.span
1209 }
1210}
1211#[derive(Debug, Clone, PartialEq, Eq)]
1212pub struct Alternatives<'tree> {
1213 pub span: ::treesitter_types::Span,
1214 pub alternative: ::std::vec::Vec<Alternative<'tree>>,
1215}
1216impl<'tree> ::treesitter_types::FromNode<'tree> for Alternatives<'tree> {
1217 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1218 fn from_node(
1219 node: ::tree_sitter::Node<'tree>,
1220 src: &'tree [u8],
1221 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1222 debug_assert_eq!(node.kind(), "alternatives");
1223 Ok(Self {
1224 span: ::treesitter_types::Span::from(node),
1225 alternative: {
1226 let mut cursor = node.walk();
1227 let mut items = ::std::vec::Vec::new();
1228 for child in node.children_by_field_name("alternative", &mut cursor) {
1229 items.push(<Alternative as ::treesitter_types::FromNode>::from_node(
1230 child, src,
1231 )?);
1232 }
1233 items
1234 },
1235 })
1236 }
1237}
1238impl ::treesitter_types::Spanned for Alternatives<'_> {
1239 fn span(&self) -> ::treesitter_types::Span {
1240 self.span
1241 }
1242}
1243#[derive(Debug, Clone, PartialEq, Eq)]
1244pub struct Annotated<'tree> {
1245 pub span: ::treesitter_types::Span,
1246 pub kind: QuantifiedType<'tree>,
1247 pub children: TypeParam<'tree>,
1248}
1249impl<'tree> ::treesitter_types::FromNode<'tree> for Annotated<'tree> {
1250 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1251 fn from_node(
1252 node: ::tree_sitter::Node<'tree>,
1253 src: &'tree [u8],
1254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1255 debug_assert_eq!(node.kind(), "annotated");
1256 Ok(Self {
1257 span: ::treesitter_types::Span::from(node),
1258 kind: {
1259 let child = node
1260 .child_by_field_name("kind")
1261 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
1262 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
1263 },
1264 children: {
1265 #[allow(clippy::suspicious_else_formatting)]
1266 let non_field_children = {
1267 let mut cursor = node.walk();
1268 let mut result = ::std::vec::Vec::new();
1269 if cursor.goto_first_child() {
1270 loop {
1271 if cursor.field_name().is_none()
1272 && cursor.node().is_named()
1273 && !cursor.node().is_extra()
1274 {
1275 result.push(cursor.node());
1276 }
1277 if !cursor.goto_next_sibling() {
1278 break;
1279 }
1280 }
1281 }
1282 result
1283 };
1284 let child = if let Some(&c) = non_field_children.first() {
1285 c
1286 } else {
1287 let mut fallback_cursor = node.walk();
1288 let mut fallback_child = None;
1289 if fallback_cursor.goto_first_child() {
1290 loop {
1291 if fallback_cursor.field_name().is_none()
1292 && !fallback_cursor.node().is_extra()
1293 {
1294 let candidate = fallback_cursor.node();
1295 #[allow(clippy::needless_question_mark)]
1296 if (|| -> ::core::result::Result<
1297 _,
1298 ::treesitter_types::ParseError,
1299 > {
1300 let child = candidate;
1301 Ok(
1302 <TypeParam as ::treesitter_types::FromNode>::from_node(
1303 child,
1304 src,
1305 )?,
1306 )
1307 })()
1308 .is_ok()
1309 {
1310 fallback_child = Some(candidate);
1311 break;
1312 }
1313 }
1314 if !fallback_cursor.goto_next_sibling() {
1315 break;
1316 }
1317 }
1318 }
1319 if fallback_child.is_none() {
1320 let mut cursor2 = node.walk();
1321 if cursor2.goto_first_child() {
1322 loop {
1323 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1324 let candidate = cursor2.node();
1325 #[allow(clippy::needless_question_mark)]
1326 if (|| -> ::core::result::Result<
1327 _,
1328 ::treesitter_types::ParseError,
1329 > {
1330 let child = candidate;
1331 Ok(
1332 <TypeParam as ::treesitter_types::FromNode>::from_node(
1333 child,
1334 src,
1335 )?,
1336 )
1337 })()
1338 .is_ok()
1339 {
1340 fallback_child = Some(candidate);
1341 break;
1342 }
1343 }
1344 if !cursor2.goto_next_sibling() {
1345 break;
1346 }
1347 }
1348 }
1349 }
1350 fallback_child.ok_or_else(|| {
1351 ::treesitter_types::ParseError::missing_field("children", node)
1352 })?
1353 };
1354 <TypeParam as ::treesitter_types::FromNode>::from_node(child, src)?
1355 },
1356 })
1357 }
1358}
1359impl ::treesitter_types::Spanned for Annotated<'_> {
1360 fn span(&self) -> ::treesitter_types::Span {
1361 self.span
1362 }
1363}
1364#[derive(Debug, Clone, PartialEq, Eq)]
1365pub struct Apply<'tree> {
1366 pub span: ::treesitter_types::Span,
1367 pub argument: ApplyArgument<'tree>,
1368 pub constructor: ::core::option::Option<ApplyConstructor<'tree>>,
1369 pub function: ::core::option::Option<ApplyFunction<'tree>>,
1370}
1371impl<'tree> ::treesitter_types::FromNode<'tree> for Apply<'tree> {
1372 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1373 fn from_node(
1374 node: ::tree_sitter::Node<'tree>,
1375 src: &'tree [u8],
1376 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1377 debug_assert_eq!(node.kind(), "apply");
1378 Ok(Self {
1379 span: ::treesitter_types::Span::from(node),
1380 argument: {
1381 let child = node.child_by_field_name("argument").ok_or_else(|| {
1382 ::treesitter_types::ParseError::missing_field("argument", node)
1383 })?;
1384 <ApplyArgument as ::treesitter_types::FromNode>::from_node(child, src)?
1385 },
1386 constructor: match node.child_by_field_name("constructor") {
1387 Some(child) => {
1388 Some(<ApplyConstructor as ::treesitter_types::FromNode>::from_node(child, src)?)
1389 }
1390 None => None,
1391 },
1392 function: match node.child_by_field_name("function") {
1393 Some(child) => Some(<ApplyFunction as ::treesitter_types::FromNode>::from_node(
1394 child, src,
1395 )?),
1396 None => None,
1397 },
1398 })
1399 }
1400}
1401impl ::treesitter_types::Spanned for Apply<'_> {
1402 fn span(&self) -> ::treesitter_types::Span {
1403 self.span
1404 }
1405}
1406#[derive(Debug, Clone, PartialEq, Eq)]
1407pub struct ArithmeticSequence<'tree> {
1408 pub span: ::treesitter_types::Span,
1409 pub from: ArithmeticSequenceFrom<'tree>,
1410 pub step: ::core::option::Option<ArithmeticSequenceStep<'tree>>,
1411 pub to: ::core::option::Option<ArithmeticSequenceTo<'tree>>,
1412}
1413impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequence<'tree> {
1414 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1415 fn from_node(
1416 node: ::tree_sitter::Node<'tree>,
1417 src: &'tree [u8],
1418 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1419 debug_assert_eq!(node.kind(), "arithmetic_sequence");
1420 Ok(Self {
1421 span: ::treesitter_types::Span::from(node),
1422 from: {
1423 let child = node
1424 .child_by_field_name("from")
1425 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("from", node))?;
1426 <ArithmeticSequenceFrom as ::treesitter_types::FromNode>::from_node(child, src)?
1427 },
1428 step: match node.child_by_field_name("step") {
1429 Some(child) => Some(
1430 <ArithmeticSequenceStep as ::treesitter_types::FromNode>::from_node(
1431 child, src,
1432 )?,
1433 ),
1434 None => None,
1435 },
1436 to: match node.child_by_field_name("to") {
1437 Some(child) => Some(
1438 <ArithmeticSequenceTo as ::treesitter_types::FromNode>::from_node(child, src)?,
1439 ),
1440 None => None,
1441 },
1442 })
1443 }
1444}
1445impl ::treesitter_types::Spanned for ArithmeticSequence<'_> {
1446 fn span(&self) -> ::treesitter_types::Span {
1447 self.span
1448 }
1449}
1450#[derive(Debug, Clone, PartialEq, Eq)]
1451pub struct As<'tree> {
1452 pub span: ::treesitter_types::Span,
1453 pub bind: Variable<'tree>,
1454 pub pattern: Pattern<'tree>,
1455}
1456impl<'tree> ::treesitter_types::FromNode<'tree> for As<'tree> {
1457 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1458 fn from_node(
1459 node: ::tree_sitter::Node<'tree>,
1460 src: &'tree [u8],
1461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1462 debug_assert_eq!(node.kind(), "as");
1463 Ok(Self {
1464 span: ::treesitter_types::Span::from(node),
1465 bind: {
1466 let child = node
1467 .child_by_field_name("bind")
1468 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bind", node))?;
1469 <Variable as ::treesitter_types::FromNode>::from_node(child, src)?
1470 },
1471 pattern: {
1472 let child = node.child_by_field_name("pattern").ok_or_else(|| {
1473 ::treesitter_types::ParseError::missing_field("pattern", node)
1474 })?;
1475 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
1476 },
1477 })
1478 }
1479}
1480impl ::treesitter_types::Spanned for As<'_> {
1481 fn span(&self) -> ::treesitter_types::Span {
1482 self.span
1483 }
1484}
1485#[derive(Debug, Clone, PartialEq, Eq)]
1486pub struct AssociatedType<'tree> {
1487 pub span: ::treesitter_types::Span,
1488 pub namespace: AssociatedTypeNamespace,
1489 pub r#type: AssociatedTypeType<'tree>,
1490}
1491impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedType<'tree> {
1492 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1493 fn from_node(
1494 node: ::tree_sitter::Node<'tree>,
1495 src: &'tree [u8],
1496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1497 debug_assert_eq!(node.kind(), "associated_type");
1498 Ok(Self {
1499 span: ::treesitter_types::Span::from(node),
1500 namespace: {
1501 let child = node.child_by_field_name("namespace").ok_or_else(|| {
1502 ::treesitter_types::ParseError::missing_field("namespace", node)
1503 })?;
1504 <AssociatedTypeNamespace as ::treesitter_types::FromNode>::from_node(child, src)?
1505 },
1506 r#type: {
1507 let child = node
1508 .child_by_field_name("type")
1509 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
1510 <AssociatedTypeType as ::treesitter_types::FromNode>::from_node(child, src)?
1511 },
1512 })
1513 }
1514}
1515impl ::treesitter_types::Spanned for AssociatedType<'_> {
1516 fn span(&self) -> ::treesitter_types::Span {
1517 self.span
1518 }
1519}
1520#[derive(Debug, Clone, PartialEq, Eq)]
1521pub struct Bind<'tree> {
1522 pub span: ::treesitter_types::Span,
1523 pub arrow: ::core::option::Option<BindArrow>,
1524 pub binds: ::core::option::Option<LocalBinds<'tree>>,
1525 pub expression: ::core::option::Option<BindExpression<'tree>>,
1526 pub implicit: ::core::option::Option<ImplicitVariable<'tree>>,
1527 pub r#match: ::std::vec::Vec<Match<'tree>>,
1528 pub name: ::core::option::Option<BindName<'tree>>,
1529 pub pattern: ::core::option::Option<BindPattern<'tree>>,
1530}
1531impl<'tree> ::treesitter_types::FromNode<'tree> for Bind<'tree> {
1532 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1533 fn from_node(
1534 node: ::tree_sitter::Node<'tree>,
1535 src: &'tree [u8],
1536 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1537 debug_assert_eq!(node.kind(), "bind");
1538 Ok(Self {
1539 span: ::treesitter_types::Span::from(node),
1540 arrow: match node.child_by_field_name("arrow") {
1541 Some(child) => Some(<BindArrow as ::treesitter_types::FromNode>::from_node(
1542 child, src,
1543 )?),
1544 None => None,
1545 },
1546 binds: match node.child_by_field_name("binds") {
1547 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
1548 child, src,
1549 )?),
1550 None => None,
1551 },
1552 expression: match node.child_by_field_name("expression") {
1553 Some(child) => Some(<BindExpression as ::treesitter_types::FromNode>::from_node(
1554 child, src,
1555 )?),
1556 None => None,
1557 },
1558 implicit: match node.child_by_field_name("implicit") {
1559 Some(child) => {
1560 Some(<ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)?)
1561 }
1562 None => None,
1563 },
1564 r#match: {
1565 let mut cursor = node.walk();
1566 let mut items = ::std::vec::Vec::new();
1567 for child in node.children_by_field_name("match", &mut cursor) {
1568 items.push(<Match as ::treesitter_types::FromNode>::from_node(
1569 child, src,
1570 )?);
1571 }
1572 items
1573 },
1574 name: match node.child_by_field_name("name") {
1575 Some(child) => Some(<BindName as ::treesitter_types::FromNode>::from_node(
1576 child, src,
1577 )?),
1578 None => None,
1579 },
1580 pattern: match node.child_by_field_name("pattern") {
1581 Some(child) => Some(<BindPattern as ::treesitter_types::FromNode>::from_node(
1582 child, src,
1583 )?),
1584 None => None,
1585 },
1586 })
1587 }
1588}
1589impl ::treesitter_types::Spanned for Bind<'_> {
1590 fn span(&self) -> ::treesitter_types::Span {
1591 self.span
1592 }
1593}
1594#[derive(Debug, Clone, PartialEq, Eq)]
1595pub struct BindingList<'tree> {
1596 pub span: ::treesitter_types::Span,
1597 pub name: ::std::vec::Vec<BindingListName<'tree>>,
1598}
1599impl<'tree> ::treesitter_types::FromNode<'tree> for BindingList<'tree> {
1600 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1601 fn from_node(
1602 node: ::tree_sitter::Node<'tree>,
1603 src: &'tree [u8],
1604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1605 debug_assert_eq!(node.kind(), "binding_list");
1606 Ok(Self {
1607 span: ::treesitter_types::Span::from(node),
1608 name: {
1609 let mut cursor = node.walk();
1610 let mut items = ::std::vec::Vec::new();
1611 for child in node.children_by_field_name("name", &mut cursor) {
1612 items.push(
1613 <BindingListName as ::treesitter_types::FromNode>::from_node(child, src)?,
1614 );
1615 }
1616 items
1617 },
1618 })
1619 }
1620}
1621impl ::treesitter_types::Spanned for BindingList<'_> {
1622 fn span(&self) -> ::treesitter_types::Span {
1623 self.span
1624 }
1625}
1626#[derive(Debug, Clone, PartialEq, Eq)]
1627pub struct Boolean<'tree> {
1628 pub span: ::treesitter_types::Span,
1629 pub children: BooleanChildren<'tree>,
1630}
1631impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
1632 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1633 fn from_node(
1634 node: ::tree_sitter::Node<'tree>,
1635 src: &'tree [u8],
1636 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1637 debug_assert_eq!(node.kind(), "boolean");
1638 Ok(Self {
1639 span: ::treesitter_types::Span::from(node),
1640 children: {
1641 #[allow(clippy::suspicious_else_formatting)]
1642 let non_field_children = {
1643 let mut cursor = node.walk();
1644 let mut result = ::std::vec::Vec::new();
1645 if cursor.goto_first_child() {
1646 loop {
1647 if cursor.field_name().is_none()
1648 && cursor.node().is_named()
1649 && !cursor.node().is_extra()
1650 {
1651 result.push(cursor.node());
1652 }
1653 if !cursor.goto_next_sibling() {
1654 break;
1655 }
1656 }
1657 }
1658 result
1659 };
1660 let child = if let Some(&c) = non_field_children.first() {
1661 c
1662 } else {
1663 let mut fallback_cursor = node.walk();
1664 let mut fallback_child = None;
1665 if fallback_cursor.goto_first_child() {
1666 loop {
1667 if fallback_cursor.field_name().is_none()
1668 && !fallback_cursor.node().is_extra()
1669 {
1670 let candidate = fallback_cursor.node();
1671 #[allow(clippy::needless_question_mark)]
1672 if (|| -> ::core::result::Result<
1673 _,
1674 ::treesitter_types::ParseError,
1675 > {
1676 let child = candidate;
1677 Ok(
1678 <BooleanChildren as ::treesitter_types::FromNode>::from_node(
1679 child,
1680 src,
1681 )?,
1682 )
1683 })()
1684 .is_ok()
1685 {
1686 fallback_child = Some(candidate);
1687 break;
1688 }
1689 }
1690 if !fallback_cursor.goto_next_sibling() {
1691 break;
1692 }
1693 }
1694 }
1695 if fallback_child.is_none() {
1696 let mut cursor2 = node.walk();
1697 if cursor2.goto_first_child() {
1698 loop {
1699 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1700 let candidate = cursor2.node();
1701 #[allow(clippy::needless_question_mark)]
1702 if (|| -> ::core::result::Result<
1703 _,
1704 ::treesitter_types::ParseError,
1705 > {
1706 let child = candidate;
1707 Ok(
1708 <BooleanChildren as ::treesitter_types::FromNode>::from_node(
1709 child,
1710 src,
1711 )?,
1712 )
1713 })()
1714 .is_ok()
1715 {
1716 fallback_child = Some(candidate);
1717 break;
1718 }
1719 }
1720 if !cursor2.goto_next_sibling() {
1721 break;
1722 }
1723 }
1724 }
1725 }
1726 fallback_child.ok_or_else(|| {
1727 ::treesitter_types::ParseError::missing_field("children", node)
1728 })?
1729 };
1730 <BooleanChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1731 },
1732 })
1733 }
1734}
1735impl ::treesitter_types::Spanned for Boolean<'_> {
1736 fn span(&self) -> ::treesitter_types::Span {
1737 self.span
1738 }
1739}
1740#[derive(Debug, Clone, PartialEq, Eq)]
1741pub struct Case<'tree> {
1742 pub span: ::treesitter_types::Span,
1743 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
1744 pub children: CaseChildren<'tree>,
1745}
1746impl<'tree> ::treesitter_types::FromNode<'tree> for Case<'tree> {
1747 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1748 fn from_node(
1749 node: ::tree_sitter::Node<'tree>,
1750 src: &'tree [u8],
1751 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1752 debug_assert_eq!(node.kind(), "case");
1753 Ok(Self {
1754 span: ::treesitter_types::Span::from(node),
1755 alternatives: match node.child_by_field_name("alternatives") {
1756 Some(child) => Some(<Alternatives as ::treesitter_types::FromNode>::from_node(
1757 child, src,
1758 )?),
1759 None => None,
1760 },
1761 children: {
1762 #[allow(clippy::suspicious_else_formatting)]
1763 let non_field_children = {
1764 let mut cursor = node.walk();
1765 let mut result = ::std::vec::Vec::new();
1766 if cursor.goto_first_child() {
1767 loop {
1768 if cursor.field_name().is_none()
1769 && cursor.node().is_named()
1770 && !cursor.node().is_extra()
1771 {
1772 result.push(cursor.node());
1773 }
1774 if !cursor.goto_next_sibling() {
1775 break;
1776 }
1777 }
1778 }
1779 result
1780 };
1781 let child = if let Some(&c) = non_field_children.first() {
1782 c
1783 } else {
1784 let mut fallback_cursor = node.walk();
1785 let mut fallback_child = None;
1786 if fallback_cursor.goto_first_child() {
1787 loop {
1788 if fallback_cursor.field_name().is_none()
1789 && !fallback_cursor.node().is_extra()
1790 {
1791 let candidate = fallback_cursor.node();
1792 #[allow(clippy::needless_question_mark)]
1793 if (|| -> ::core::result::Result<
1794 _,
1795 ::treesitter_types::ParseError,
1796 > {
1797 let child = candidate;
1798 Ok(
1799 <CaseChildren as ::treesitter_types::FromNode>::from_node(
1800 child,
1801 src,
1802 )?,
1803 )
1804 })()
1805 .is_ok()
1806 {
1807 fallback_child = Some(candidate);
1808 break;
1809 }
1810 }
1811 if !fallback_cursor.goto_next_sibling() {
1812 break;
1813 }
1814 }
1815 }
1816 if fallback_child.is_none() {
1817 let mut cursor2 = node.walk();
1818 if cursor2.goto_first_child() {
1819 loop {
1820 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1821 let candidate = cursor2.node();
1822 #[allow(clippy::needless_question_mark)]
1823 if (|| -> ::core::result::Result<
1824 _,
1825 ::treesitter_types::ParseError,
1826 > {
1827 let child = candidate;
1828 Ok(
1829 <CaseChildren as ::treesitter_types::FromNode>::from_node(
1830 child,
1831 src,
1832 )?,
1833 )
1834 })()
1835 .is_ok()
1836 {
1837 fallback_child = Some(candidate);
1838 break;
1839 }
1840 }
1841 if !cursor2.goto_next_sibling() {
1842 break;
1843 }
1844 }
1845 }
1846 }
1847 fallback_child.ok_or_else(|| {
1848 ::treesitter_types::ParseError::missing_field("children", node)
1849 })?
1850 };
1851 <CaseChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1852 },
1853 })
1854 }
1855}
1856impl ::treesitter_types::Spanned for Case<'_> {
1857 fn span(&self) -> ::treesitter_types::Span {
1858 self.span
1859 }
1860}
1861#[derive(Debug, Clone, PartialEq, Eq)]
1862pub struct Children<'tree> {
1863 pub span: ::treesitter_types::Span,
1864 pub element: ::std::vec::Vec<ChildrenElement<'tree>>,
1865}
1866impl<'tree> ::treesitter_types::FromNode<'tree> for Children<'tree> {
1867 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1868 fn from_node(
1869 node: ::tree_sitter::Node<'tree>,
1870 src: &'tree [u8],
1871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1872 debug_assert_eq!(node.kind(), "children");
1873 Ok(Self {
1874 span: ::treesitter_types::Span::from(node),
1875 element: {
1876 let mut cursor = node.walk();
1877 let mut items = ::std::vec::Vec::new();
1878 for child in node.children_by_field_name("element", &mut cursor) {
1879 items.push(
1880 <ChildrenElement as ::treesitter_types::FromNode>::from_node(child, src)?,
1881 );
1882 }
1883 items
1884 },
1885 })
1886 }
1887}
1888impl ::treesitter_types::Spanned for Children<'_> {
1889 fn span(&self) -> ::treesitter_types::Span {
1890 self.span
1891 }
1892}
1893#[derive(Debug, Clone, PartialEq, Eq)]
1894pub struct Class<'tree> {
1895 pub span: ::treesitter_types::Span,
1896 pub context: ::core::option::Option<Context<'tree>>,
1897 pub declarations: ::core::option::Option<ClassDeclarations<'tree>>,
1898 pub fundeps: ::core::option::Option<Fundeps<'tree>>,
1899 pub name: ::core::option::Option<ClassName<'tree>>,
1900 pub patterns: ::core::option::Option<TypeParams<'tree>>,
1901 pub children: ::core::option::Option<ClassChildren<'tree>>,
1902}
1903impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
1904 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1905 fn from_node(
1906 node: ::tree_sitter::Node<'tree>,
1907 src: &'tree [u8],
1908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1909 debug_assert_eq!(node.kind(), "class");
1910 Ok(Self {
1911 span: ::treesitter_types::Span::from(node),
1912 context: match node.child_by_field_name("context") {
1913 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
1914 child, src,
1915 )?),
1916 None => None,
1917 },
1918 declarations: match node.child_by_field_name("declarations") {
1919 Some(child) => Some(
1920 <ClassDeclarations as ::treesitter_types::FromNode>::from_node(child, src)?,
1921 ),
1922 None => None,
1923 },
1924 fundeps: match node.child_by_field_name("fundeps") {
1925 Some(child) => Some(<Fundeps as ::treesitter_types::FromNode>::from_node(
1926 child, src,
1927 )?),
1928 None => None,
1929 },
1930 name: match node.child_by_field_name("name") {
1931 Some(child) => Some(<ClassName as ::treesitter_types::FromNode>::from_node(
1932 child, src,
1933 )?),
1934 None => None,
1935 },
1936 patterns: match node.child_by_field_name("patterns") {
1937 Some(child) => Some(<TypeParams as ::treesitter_types::FromNode>::from_node(
1938 child, src,
1939 )?),
1940 None => None,
1941 },
1942 children: {
1943 #[allow(clippy::suspicious_else_formatting)]
1944 let non_field_children = {
1945 let mut cursor = node.walk();
1946 let mut result = ::std::vec::Vec::new();
1947 if cursor.goto_first_child() {
1948 loop {
1949 if cursor.field_name().is_none()
1950 && cursor.node().is_named()
1951 && !cursor.node().is_extra()
1952 {
1953 result.push(cursor.node());
1954 }
1955 if !cursor.goto_next_sibling() {
1956 break;
1957 }
1958 }
1959 }
1960 result
1961 };
1962 match non_field_children.first() {
1963 Some(&child) => Some(
1964 <ClassChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1965 ),
1966 None => None,
1967 }
1968 },
1969 })
1970 }
1971}
1972impl ::treesitter_types::Spanned for Class<'_> {
1973 fn span(&self) -> ::treesitter_types::Span {
1974 self.span
1975 }
1976}
1977#[derive(Debug, Clone, PartialEq, Eq)]
1978pub struct ClassDeclarations<'tree> {
1979 pub span: ::treesitter_types::Span,
1980 pub declaration: ::std::vec::Vec<ClassDecl<'tree>>,
1981}
1982impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclarations<'tree> {
1983 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1984 fn from_node(
1985 node: ::tree_sitter::Node<'tree>,
1986 src: &'tree [u8],
1987 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1988 debug_assert_eq!(node.kind(), "class_declarations");
1989 Ok(Self {
1990 span: ::treesitter_types::Span::from(node),
1991 declaration: {
1992 let mut cursor = node.walk();
1993 let mut items = ::std::vec::Vec::new();
1994 for child in node.children_by_field_name("declaration", &mut cursor) {
1995 items.push(<ClassDecl as ::treesitter_types::FromNode>::from_node(
1996 child, src,
1997 )?);
1998 }
1999 items
2000 },
2001 })
2002 }
2003}
2004impl ::treesitter_types::Spanned for ClassDeclarations<'_> {
2005 fn span(&self) -> ::treesitter_types::Span {
2006 self.span
2007 }
2008}
2009#[derive(Debug, Clone, PartialEq, Eq)]
2010pub struct Conditional<'tree> {
2011 pub span: ::treesitter_types::Span,
2012 pub r#else: ConditionalElse<'tree>,
2013 pub r#if: ConditionalIf<'tree>,
2014 pub then: ConditionalThen<'tree>,
2015}
2016impl<'tree> ::treesitter_types::FromNode<'tree> for Conditional<'tree> {
2017 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2018 fn from_node(
2019 node: ::tree_sitter::Node<'tree>,
2020 src: &'tree [u8],
2021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2022 debug_assert_eq!(node.kind(), "conditional");
2023 Ok(Self {
2024 span: ::treesitter_types::Span::from(node),
2025 r#else: {
2026 let child = node
2027 .child_by_field_name("else")
2028 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("else", node))?;
2029 <ConditionalElse as ::treesitter_types::FromNode>::from_node(child, src)?
2030 },
2031 r#if: {
2032 let child = node
2033 .child_by_field_name("if")
2034 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("if", node))?;
2035 <ConditionalIf as ::treesitter_types::FromNode>::from_node(child, src)?
2036 },
2037 then: {
2038 let child = node
2039 .child_by_field_name("then")
2040 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("then", node))?;
2041 <ConditionalThen as ::treesitter_types::FromNode>::from_node(child, src)?
2042 },
2043 })
2044 }
2045}
2046impl ::treesitter_types::Spanned for Conditional<'_> {
2047 fn span(&self) -> ::treesitter_types::Span {
2048 self.span
2049 }
2050}
2051#[derive(Debug, Clone, PartialEq, Eq)]
2052pub struct ConstructorOperator<'tree> {
2053 pub span: ::treesitter_types::Span,
2054 text: &'tree str,
2055}
2056impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorOperator<'tree> {
2057 fn from_node(
2058 node: ::tree_sitter::Node<'tree>,
2059 src: &'tree [u8],
2060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2061 debug_assert_eq!(node.kind(), "constructor_operator");
2062 Ok(Self {
2063 span: ::treesitter_types::Span::from(node),
2064 text: node.utf8_text(src)?,
2065 })
2066 }
2067}
2068impl<'tree> ::treesitter_types::LeafNode<'tree> for ConstructorOperator<'tree> {
2069 fn text(&self) -> &'tree str {
2070 self.text
2071 }
2072}
2073impl ::treesitter_types::Spanned for ConstructorOperator<'_> {
2074 fn span(&self) -> ::treesitter_types::Span {
2075 self.span
2076 }
2077}
2078#[derive(Debug, Clone, PartialEq, Eq)]
2079pub struct ConstructorSynonym<'tree> {
2080 pub span: ::treesitter_types::Span,
2081 pub binds: ::core::option::Option<LocalBinds<'tree>>,
2082 pub implicit: ::core::option::Option<ImplicitVariable<'tree>>,
2083 pub r#match: ::std::vec::Vec<Match<'tree>>,
2084 pub name: ::core::option::Option<ConstructorSynonymName<'tree>>,
2085 pub pattern: ::core::option::Option<ConstructorSynonymPattern<'tree>>,
2086}
2087impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonym<'tree> {
2088 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2089 fn from_node(
2090 node: ::tree_sitter::Node<'tree>,
2091 src: &'tree [u8],
2092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2093 debug_assert_eq!(node.kind(), "constructor_synonym");
2094 Ok(Self {
2095 span: ::treesitter_types::Span::from(node),
2096 binds: match node.child_by_field_name("binds") {
2097 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
2098 child, src,
2099 )?),
2100 None => None,
2101 },
2102 implicit: match node.child_by_field_name("implicit") {
2103 Some(child) => {
2104 Some(<ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)?)
2105 }
2106 None => None,
2107 },
2108 r#match: {
2109 let mut cursor = node.walk();
2110 let mut items = ::std::vec::Vec::new();
2111 for child in node.children_by_field_name("match", &mut cursor) {
2112 items.push(<Match as ::treesitter_types::FromNode>::from_node(
2113 child, src,
2114 )?);
2115 }
2116 items
2117 },
2118 name: match node.child_by_field_name("name") {
2119 Some(child) => Some(
2120 <ConstructorSynonymName as ::treesitter_types::FromNode>::from_node(
2121 child, src,
2122 )?,
2123 ),
2124 None => None,
2125 },
2126 pattern: match node.child_by_field_name("pattern") {
2127 Some(child) => Some(
2128 <ConstructorSynonymPattern as ::treesitter_types::FromNode>::from_node(
2129 child, src,
2130 )?,
2131 ),
2132 None => None,
2133 },
2134 })
2135 }
2136}
2137impl ::treesitter_types::Spanned for ConstructorSynonym<'_> {
2138 fn span(&self) -> ::treesitter_types::Span {
2139 self.span
2140 }
2141}
2142#[derive(Debug, Clone, PartialEq, Eq)]
2143pub struct ConstructorSynonyms<'tree> {
2144 pub span: ::treesitter_types::Span,
2145 pub children: ::std::vec::Vec<ConstructorSynonym<'tree>>,
2146}
2147impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonyms<'tree> {
2148 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2149 fn from_node(
2150 node: ::tree_sitter::Node<'tree>,
2151 src: &'tree [u8],
2152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2153 debug_assert_eq!(node.kind(), "constructor_synonyms");
2154 Ok(Self {
2155 span: ::treesitter_types::Span::from(node),
2156 children: {
2157 #[allow(clippy::suspicious_else_formatting)]
2158 let non_field_children = {
2159 let mut cursor = node.walk();
2160 let mut result = ::std::vec::Vec::new();
2161 if cursor.goto_first_child() {
2162 loop {
2163 if cursor.field_name().is_none()
2164 && cursor.node().is_named()
2165 && !cursor.node().is_extra()
2166 {
2167 result.push(cursor.node());
2168 }
2169 if !cursor.goto_next_sibling() {
2170 break;
2171 }
2172 }
2173 }
2174 result
2175 };
2176 let mut items = ::std::vec::Vec::new();
2177 for child in non_field_children {
2178 items.push(
2179 <ConstructorSynonym as ::treesitter_types::FromNode>::from_node(
2180 child, src,
2181 )?,
2182 );
2183 }
2184 items
2185 },
2186 })
2187 }
2188}
2189impl ::treesitter_types::Spanned for ConstructorSynonyms<'_> {
2190 fn span(&self) -> ::treesitter_types::Span {
2191 self.span
2192 }
2193}
2194#[derive(Debug, Clone, PartialEq, Eq)]
2195pub struct Context<'tree> {
2196 pub span: ::treesitter_types::Span,
2197 pub arrow: ContextArrow,
2198 pub constraint: ::core::option::Option<Constraints<'tree>>,
2199 pub context: Constraint<'tree>,
2200 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
2201}
2202impl<'tree> ::treesitter_types::FromNode<'tree> for Context<'tree> {
2203 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2204 fn from_node(
2205 node: ::tree_sitter::Node<'tree>,
2206 src: &'tree [u8],
2207 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2208 debug_assert_eq!(node.kind(), "context");
2209 Ok(Self {
2210 span: ::treesitter_types::Span::from(node),
2211 arrow: {
2212 let child = node
2213 .child_by_field_name("arrow")
2214 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
2215 <ContextArrow as ::treesitter_types::FromNode>::from_node(child, src)?
2216 },
2217 constraint: match node.child_by_field_name("constraint") {
2218 Some(child) => Some(<Constraints as ::treesitter_types::FromNode>::from_node(
2219 child, src,
2220 )?),
2221 None => None,
2222 },
2223 context: {
2224 let child = node.child_by_field_name("context").ok_or_else(|| {
2225 ::treesitter_types::ParseError::missing_field("context", node)
2226 })?;
2227 <Constraint as ::treesitter_types::FromNode>::from_node(child, src)?
2228 },
2229 r#type: match node.child_by_field_name("type") {
2230 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
2231 child, src,
2232 )?),
2233 None => None,
2234 },
2235 })
2236 }
2237}
2238impl ::treesitter_types::Spanned for Context<'_> {
2239 fn span(&self) -> ::treesitter_types::Span {
2240 self.span
2241 }
2242}
2243#[derive(Debug, Clone, PartialEq, Eq)]
2244pub struct DataConstructor<'tree> {
2245 pub span: ::treesitter_types::Span,
2246 pub constructor: DataConstructorConstructor<'tree>,
2247 pub context: ::core::option::Option<Context<'tree>>,
2248 pub forall: ::core::option::Option<DataConstructorForall<'tree>>,
2249}
2250impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructor<'tree> {
2251 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2252 fn from_node(
2253 node: ::tree_sitter::Node<'tree>,
2254 src: &'tree [u8],
2255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2256 debug_assert_eq!(node.kind(), "data_constructor");
2257 Ok(Self {
2258 span: ::treesitter_types::Span::from(node),
2259 constructor: {
2260 let child = node.child_by_field_name("constructor").ok_or_else(|| {
2261 ::treesitter_types::ParseError::missing_field("constructor", node)
2262 })?;
2263 <DataConstructorConstructor as ::treesitter_types::FromNode>::from_node(child, src)?
2264 },
2265 context: match node.child_by_field_name("context") {
2266 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
2267 child, src,
2268 )?),
2269 None => None,
2270 },
2271 forall: match node.child_by_field_name("forall") {
2272 Some(child) => Some(
2273 <DataConstructorForall as ::treesitter_types::FromNode>::from_node(child, src)?,
2274 ),
2275 None => None,
2276 },
2277 })
2278 }
2279}
2280impl ::treesitter_types::Spanned for DataConstructor<'_> {
2281 fn span(&self) -> ::treesitter_types::Span {
2282 self.span
2283 }
2284}
2285#[derive(Debug, Clone, PartialEq, Eq)]
2286pub struct DataConstructors<'tree> {
2287 pub span: ::treesitter_types::Span,
2288 pub constructor: ::std::vec::Vec<DataConstructor<'tree>>,
2289}
2290impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructors<'tree> {
2291 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2292 fn from_node(
2293 node: ::tree_sitter::Node<'tree>,
2294 src: &'tree [u8],
2295 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2296 debug_assert_eq!(node.kind(), "data_constructors");
2297 Ok(Self {
2298 span: ::treesitter_types::Span::from(node),
2299 constructor: {
2300 let mut cursor = node.walk();
2301 let mut items = ::std::vec::Vec::new();
2302 for child in node.children_by_field_name("constructor", &mut cursor) {
2303 items.push(
2304 <DataConstructor as ::treesitter_types::FromNode>::from_node(child, src)?,
2305 );
2306 }
2307 items
2308 },
2309 })
2310 }
2311}
2312impl ::treesitter_types::Spanned for DataConstructors<'_> {
2313 fn span(&self) -> ::treesitter_types::Span {
2314 self.span
2315 }
2316}
2317#[derive(Debug, Clone, PartialEq, Eq)]
2318pub struct DataFamily<'tree> {
2319 pub span: ::treesitter_types::Span,
2320 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
2321 pub name: ::core::option::Option<DataFamilyName<'tree>>,
2322 pub patterns: ::core::option::Option<TypeParams<'tree>>,
2323 pub children: ::core::option::Option<DataFamilyChildren<'tree>>,
2324}
2325impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamily<'tree> {
2326 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2327 fn from_node(
2328 node: ::tree_sitter::Node<'tree>,
2329 src: &'tree [u8],
2330 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2331 debug_assert_eq!(node.kind(), "data_family");
2332 Ok(Self {
2333 span: ::treesitter_types::Span::from(node),
2334 kind: match node.child_by_field_name("kind") {
2335 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
2336 child, src,
2337 )?),
2338 None => None,
2339 },
2340 name: match node.child_by_field_name("name") {
2341 Some(child) => Some(<DataFamilyName as ::treesitter_types::FromNode>::from_node(
2342 child, src,
2343 )?),
2344 None => None,
2345 },
2346 patterns: match node.child_by_field_name("patterns") {
2347 Some(child) => Some(<TypeParams as ::treesitter_types::FromNode>::from_node(
2348 child, src,
2349 )?),
2350 None => None,
2351 },
2352 children: {
2353 #[allow(clippy::suspicious_else_formatting)]
2354 let non_field_children = {
2355 let mut cursor = node.walk();
2356 let mut result = ::std::vec::Vec::new();
2357 if cursor.goto_first_child() {
2358 loop {
2359 if cursor.field_name().is_none()
2360 && cursor.node().is_named()
2361 && !cursor.node().is_extra()
2362 {
2363 result.push(cursor.node());
2364 }
2365 if !cursor.goto_next_sibling() {
2366 break;
2367 }
2368 }
2369 }
2370 result
2371 };
2372 match non_field_children.first() {
2373 Some(&child) => Some(
2374 <DataFamilyChildren as ::treesitter_types::FromNode>::from_node(
2375 child, src,
2376 )?,
2377 ),
2378 None => None,
2379 }
2380 },
2381 })
2382 }
2383}
2384impl ::treesitter_types::Spanned for DataFamily<'_> {
2385 fn span(&self) -> ::treesitter_types::Span {
2386 self.span
2387 }
2388}
2389#[derive(Debug, Clone, PartialEq, Eq)]
2390pub struct DataInstance<'tree> {
2391 pub span: ::treesitter_types::Span,
2392 pub children: DataInstanceChildren<'tree>,
2393}
2394impl<'tree> ::treesitter_types::FromNode<'tree> for DataInstance<'tree> {
2395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2396 fn from_node(
2397 node: ::tree_sitter::Node<'tree>,
2398 src: &'tree [u8],
2399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2400 debug_assert_eq!(node.kind(), "data_instance");
2401 Ok(Self {
2402 span: ::treesitter_types::Span::from(node),
2403 children: {
2404 #[allow(clippy::suspicious_else_formatting)]
2405 let non_field_children = {
2406 let mut cursor = node.walk();
2407 let mut result = ::std::vec::Vec::new();
2408 if cursor.goto_first_child() {
2409 loop {
2410 if cursor.field_name().is_none()
2411 && cursor.node().is_named()
2412 && !cursor.node().is_extra()
2413 {
2414 result.push(cursor.node());
2415 }
2416 if !cursor.goto_next_sibling() {
2417 break;
2418 }
2419 }
2420 }
2421 result
2422 };
2423 let child = if let Some(&c) = non_field_children.first() {
2424 c
2425 } else {
2426 let mut fallback_cursor = node.walk();
2427 let mut fallback_child = None;
2428 if fallback_cursor.goto_first_child() {
2429 loop {
2430 if fallback_cursor.field_name().is_none()
2431 && !fallback_cursor.node().is_extra()
2432 {
2433 let candidate = fallback_cursor.node();
2434 #[allow(clippy::needless_question_mark)]
2435 if (|| -> ::core::result::Result<
2436 _,
2437 ::treesitter_types::ParseError,
2438 > {
2439 let child = candidate;
2440 Ok(
2441 <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(
2442 child,
2443 src,
2444 )?,
2445 )
2446 })()
2447 .is_ok()
2448 {
2449 fallback_child = Some(candidate);
2450 break;
2451 }
2452 }
2453 if !fallback_cursor.goto_next_sibling() {
2454 break;
2455 }
2456 }
2457 }
2458 if fallback_child.is_none() {
2459 let mut cursor2 = node.walk();
2460 if cursor2.goto_first_child() {
2461 loop {
2462 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2463 let candidate = cursor2.node();
2464 #[allow(clippy::needless_question_mark)]
2465 if (|| -> ::core::result::Result<
2466 _,
2467 ::treesitter_types::ParseError,
2468 > {
2469 let child = candidate;
2470 Ok(
2471 <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(
2472 child,
2473 src,
2474 )?,
2475 )
2476 })()
2477 .is_ok()
2478 {
2479 fallback_child = Some(candidate);
2480 break;
2481 }
2482 }
2483 if !cursor2.goto_next_sibling() {
2484 break;
2485 }
2486 }
2487 }
2488 }
2489 fallback_child.ok_or_else(|| {
2490 ::treesitter_types::ParseError::missing_field("children", node)
2491 })?
2492 };
2493 <DataInstanceChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2494 },
2495 })
2496 }
2497}
2498impl ::treesitter_types::Spanned for DataInstance<'_> {
2499 fn span(&self) -> ::treesitter_types::Span {
2500 self.span
2501 }
2502}
2503#[derive(Debug, Clone, PartialEq, Eq)]
2504pub struct DataType<'tree> {
2505 pub span: ::treesitter_types::Span,
2506 pub constructors: ::core::option::Option<DataTypeConstructors<'tree>>,
2507 pub context: ::core::option::Option<Context<'tree>>,
2508 pub deriving: ::std::vec::Vec<Deriving<'tree>>,
2509 pub forall: ::core::option::Option<DataTypeForall<'tree>>,
2510 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
2511 pub name: ::core::option::Option<DataTypeName<'tree>>,
2512 pub patterns: ::core::option::Option<DataTypePatterns<'tree>>,
2513 pub children: ::core::option::Option<DataTypeChildren<'tree>>,
2514}
2515impl<'tree> ::treesitter_types::FromNode<'tree> for DataType<'tree> {
2516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2517 fn from_node(
2518 node: ::tree_sitter::Node<'tree>,
2519 src: &'tree [u8],
2520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2521 debug_assert_eq!(node.kind(), "data_type");
2522 Ok(Self {
2523 span: ::treesitter_types::Span::from(node),
2524 constructors: match node.child_by_field_name("constructors") {
2525 Some(child) => Some(
2526 <DataTypeConstructors as ::treesitter_types::FromNode>::from_node(child, src)?,
2527 ),
2528 None => None,
2529 },
2530 context: match node.child_by_field_name("context") {
2531 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
2532 child, src,
2533 )?),
2534 None => None,
2535 },
2536 deriving: {
2537 let mut cursor = node.walk();
2538 let mut items = ::std::vec::Vec::new();
2539 for child in node.children_by_field_name("deriving", &mut cursor) {
2540 items.push(<Deriving as ::treesitter_types::FromNode>::from_node(
2541 child, src,
2542 )?);
2543 }
2544 items
2545 },
2546 forall: match node.child_by_field_name("forall") {
2547 Some(child) => Some(<DataTypeForall as ::treesitter_types::FromNode>::from_node(
2548 child, src,
2549 )?),
2550 None => None,
2551 },
2552 kind: match node.child_by_field_name("kind") {
2553 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
2554 child, src,
2555 )?),
2556 None => None,
2557 },
2558 name: match node.child_by_field_name("name") {
2559 Some(child) => Some(<DataTypeName as ::treesitter_types::FromNode>::from_node(
2560 child, src,
2561 )?),
2562 None => None,
2563 },
2564 patterns: match node.child_by_field_name("patterns") {
2565 Some(child) => {
2566 Some(<DataTypePatterns as ::treesitter_types::FromNode>::from_node(child, src)?)
2567 }
2568 None => None,
2569 },
2570 children: {
2571 #[allow(clippy::suspicious_else_formatting)]
2572 let non_field_children = {
2573 let mut cursor = node.walk();
2574 let mut result = ::std::vec::Vec::new();
2575 if cursor.goto_first_child() {
2576 loop {
2577 if cursor.field_name().is_none()
2578 && cursor.node().is_named()
2579 && !cursor.node().is_extra()
2580 {
2581 result.push(cursor.node());
2582 }
2583 if !cursor.goto_next_sibling() {
2584 break;
2585 }
2586 }
2587 }
2588 result
2589 };
2590 match non_field_children.first() {
2591 Some(&child) => Some(
2592 <DataTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
2593 ),
2594 None => None,
2595 }
2596 },
2597 })
2598 }
2599}
2600impl ::treesitter_types::Spanned for DataType<'_> {
2601 fn span(&self) -> ::treesitter_types::Span {
2602 self.span
2603 }
2604}
2605#[derive(Debug, Clone, PartialEq, Eq)]
2606pub struct Declarations<'tree> {
2607 pub span: ::treesitter_types::Span,
2608 pub children: ::std::vec::Vec<DeclarationsChildren<'tree>>,
2609}
2610impl<'tree> ::treesitter_types::FromNode<'tree> for Declarations<'tree> {
2611 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2612 fn from_node(
2613 node: ::tree_sitter::Node<'tree>,
2614 src: &'tree [u8],
2615 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2616 debug_assert_eq!(node.kind(), "declarations");
2617 Ok(Self {
2618 span: ::treesitter_types::Span::from(node),
2619 children: {
2620 #[allow(clippy::suspicious_else_formatting)]
2621 let non_field_children = {
2622 let mut cursor = node.walk();
2623 let mut result = ::std::vec::Vec::new();
2624 if cursor.goto_first_child() {
2625 loop {
2626 if cursor.field_name().is_none()
2627 && cursor.node().is_named()
2628 && !cursor.node().is_extra()
2629 {
2630 result.push(cursor.node());
2631 }
2632 if !cursor.goto_next_sibling() {
2633 break;
2634 }
2635 }
2636 }
2637 result
2638 };
2639 let mut items = ::std::vec::Vec::new();
2640 for child in non_field_children {
2641 items.push(
2642 <DeclarationsChildren as ::treesitter_types::FromNode>::from_node(
2643 child, src,
2644 )?,
2645 );
2646 }
2647 items
2648 },
2649 })
2650 }
2651}
2652impl ::treesitter_types::Spanned for Declarations<'_> {
2653 fn span(&self) -> ::treesitter_types::Span {
2654 self.span
2655 }
2656}
2657#[derive(Debug, Clone, PartialEq, Eq)]
2658pub struct DefaultSignature<'tree> {
2659 pub span: ::treesitter_types::Span,
2660 pub signature: Signature<'tree>,
2661}
2662impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultSignature<'tree> {
2663 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2664 fn from_node(
2665 node: ::tree_sitter::Node<'tree>,
2666 src: &'tree [u8],
2667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2668 debug_assert_eq!(node.kind(), "default_signature");
2669 Ok(Self {
2670 span: ::treesitter_types::Span::from(node),
2671 signature: {
2672 let child = node.child_by_field_name("signature").ok_or_else(|| {
2673 ::treesitter_types::ParseError::missing_field("signature", node)
2674 })?;
2675 <Signature as ::treesitter_types::FromNode>::from_node(child, src)?
2676 },
2677 })
2678 }
2679}
2680impl ::treesitter_types::Spanned for DefaultSignature<'_> {
2681 fn span(&self) -> ::treesitter_types::Span {
2682 self.span
2683 }
2684}
2685#[derive(Debug, Clone, PartialEq, Eq)]
2686pub struct DefaultTypes<'tree> {
2687 pub span: ::treesitter_types::Span,
2688 pub r#type: ::std::vec::Vec<DefaultTypesType<'tree>>,
2689}
2690impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultTypes<'tree> {
2691 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2692 fn from_node(
2693 node: ::tree_sitter::Node<'tree>,
2694 src: &'tree [u8],
2695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2696 debug_assert_eq!(node.kind(), "default_types");
2697 Ok(Self {
2698 span: ::treesitter_types::Span::from(node),
2699 r#type: {
2700 let mut cursor = node.walk();
2701 let mut items = ::std::vec::Vec::new();
2702 for child in node.children_by_field_name("type", &mut cursor) {
2703 items.push(
2704 <DefaultTypesType as ::treesitter_types::FromNode>::from_node(child, src)?,
2705 );
2706 }
2707 items
2708 },
2709 })
2710 }
2711}
2712impl ::treesitter_types::Spanned for DefaultTypes<'_> {
2713 fn span(&self) -> ::treesitter_types::Span {
2714 self.span
2715 }
2716}
2717#[derive(Debug, Clone, PartialEq, Eq)]
2718pub struct Deriving<'tree> {
2719 pub span: ::treesitter_types::Span,
2720 pub classes: Constraint<'tree>,
2721 pub strategy: ::core::option::Option<DerivingStrategy<'tree>>,
2722 pub via: ::core::option::Option<Via<'tree>>,
2723}
2724impl<'tree> ::treesitter_types::FromNode<'tree> for Deriving<'tree> {
2725 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2726 fn from_node(
2727 node: ::tree_sitter::Node<'tree>,
2728 src: &'tree [u8],
2729 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2730 debug_assert_eq!(node.kind(), "deriving");
2731 Ok(Self {
2732 span: ::treesitter_types::Span::from(node),
2733 classes: {
2734 let child = node.child_by_field_name("classes").ok_or_else(|| {
2735 ::treesitter_types::ParseError::missing_field("classes", node)
2736 })?;
2737 <Constraint as ::treesitter_types::FromNode>::from_node(child, src)?
2738 },
2739 strategy: match node.child_by_field_name("strategy") {
2740 Some(child) => {
2741 Some(<DerivingStrategy as ::treesitter_types::FromNode>::from_node(child, src)?)
2742 }
2743 None => None,
2744 },
2745 via: match node.child_by_field_name("via") {
2746 Some(child) => Some(<Via as ::treesitter_types::FromNode>::from_node(
2747 child, src,
2748 )?),
2749 None => None,
2750 },
2751 })
2752 }
2753}
2754impl ::treesitter_types::Spanned for Deriving<'_> {
2755 fn span(&self) -> ::treesitter_types::Span {
2756 self.span
2757 }
2758}
2759#[derive(Debug, Clone, PartialEq, Eq)]
2760pub struct DerivingInstance<'tree> {
2761 pub span: ::treesitter_types::Span,
2762 pub context: ::core::option::Option<Context<'tree>>,
2763 pub forall: ::core::option::Option<DerivingInstanceForall<'tree>>,
2764 pub name: ::core::option::Option<DerivingInstanceName<'tree>>,
2765 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
2766 pub strategy: ::core::option::Option<DerivingStrategy<'tree>>,
2767 pub via: ::core::option::Option<Via<'tree>>,
2768 pub children: ::core::option::Option<DerivingInstanceChildren<'tree>>,
2769}
2770impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstance<'tree> {
2771 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2772 fn from_node(
2773 node: ::tree_sitter::Node<'tree>,
2774 src: &'tree [u8],
2775 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2776 debug_assert_eq!(node.kind(), "deriving_instance");
2777 Ok(Self {
2778 span: ::treesitter_types::Span::from(node),
2779 context: match node.child_by_field_name("context") {
2780 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
2781 child, src,
2782 )?),
2783 None => None,
2784 },
2785 forall: match node.child_by_field_name("forall") {
2786 Some(child) => Some(
2787 <DerivingInstanceForall as ::treesitter_types::FromNode>::from_node(
2788 child, src,
2789 )?,
2790 ),
2791 None => None,
2792 },
2793 name: match node.child_by_field_name("name") {
2794 Some(child) => Some(
2795 <DerivingInstanceName as ::treesitter_types::FromNode>::from_node(child, src)?,
2796 ),
2797 None => None,
2798 },
2799 patterns: match node.child_by_field_name("patterns") {
2800 Some(child) => Some(<TypePatterns as ::treesitter_types::FromNode>::from_node(
2801 child, src,
2802 )?),
2803 None => None,
2804 },
2805 strategy: match node.child_by_field_name("strategy") {
2806 Some(child) => {
2807 Some(<DerivingStrategy as ::treesitter_types::FromNode>::from_node(child, src)?)
2808 }
2809 None => None,
2810 },
2811 via: match node.child_by_field_name("via") {
2812 Some(child) => Some(<Via as ::treesitter_types::FromNode>::from_node(
2813 child, src,
2814 )?),
2815 None => None,
2816 },
2817 children: {
2818 #[allow(clippy::suspicious_else_formatting)]
2819 let non_field_children = {
2820 let mut cursor = node.walk();
2821 let mut result = ::std::vec::Vec::new();
2822 if cursor.goto_first_child() {
2823 loop {
2824 if cursor.field_name().is_none()
2825 && cursor.node().is_named()
2826 && !cursor.node().is_extra()
2827 {
2828 result.push(cursor.node());
2829 }
2830 if !cursor.goto_next_sibling() {
2831 break;
2832 }
2833 }
2834 }
2835 result
2836 };
2837 match non_field_children.first() {
2838 Some(&child) => Some(
2839 <DerivingInstanceChildren as ::treesitter_types::FromNode>::from_node(
2840 child, src,
2841 )?,
2842 ),
2843 None => None,
2844 }
2845 },
2846 })
2847 }
2848}
2849impl ::treesitter_types::Spanned for DerivingInstance<'_> {
2850 fn span(&self) -> ::treesitter_types::Span {
2851 self.span
2852 }
2853}
2854#[derive(Debug, Clone, PartialEq, Eq)]
2855pub struct DerivingStrategy<'tree> {
2856 pub span: ::treesitter_types::Span,
2857 text: &'tree str,
2858}
2859impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingStrategy<'tree> {
2860 fn from_node(
2861 node: ::tree_sitter::Node<'tree>,
2862 src: &'tree [u8],
2863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2864 debug_assert_eq!(node.kind(), "deriving_strategy");
2865 Ok(Self {
2866 span: ::treesitter_types::Span::from(node),
2867 text: node.utf8_text(src)?,
2868 })
2869 }
2870}
2871impl<'tree> ::treesitter_types::LeafNode<'tree> for DerivingStrategy<'tree> {
2872 fn text(&self) -> &'tree str {
2873 self.text
2874 }
2875}
2876impl ::treesitter_types::Spanned for DerivingStrategy<'_> {
2877 fn span(&self) -> ::treesitter_types::Span {
2878 self.span
2879 }
2880}
2881#[derive(Debug, Clone, PartialEq, Eq)]
2882pub struct Do<'tree> {
2883 pub span: ::treesitter_types::Span,
2884 pub statement: ::std::vec::Vec<Statement<'tree>>,
2885 pub children: ::core::option::Option<DoModule<'tree>>,
2886}
2887impl<'tree> ::treesitter_types::FromNode<'tree> for Do<'tree> {
2888 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2889 fn from_node(
2890 node: ::tree_sitter::Node<'tree>,
2891 src: &'tree [u8],
2892 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2893 debug_assert_eq!(node.kind(), "do");
2894 Ok(Self {
2895 span: ::treesitter_types::Span::from(node),
2896 statement: {
2897 let mut cursor = node.walk();
2898 let mut items = ::std::vec::Vec::new();
2899 for child in node.children_by_field_name("statement", &mut cursor) {
2900 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
2901 child, src,
2902 )?);
2903 }
2904 items
2905 },
2906 children: {
2907 #[allow(clippy::suspicious_else_formatting)]
2908 let non_field_children = {
2909 let mut cursor = node.walk();
2910 let mut result = ::std::vec::Vec::new();
2911 if cursor.goto_first_child() {
2912 loop {
2913 if cursor.field_name().is_none()
2914 && cursor.node().is_named()
2915 && !cursor.node().is_extra()
2916 {
2917 result.push(cursor.node());
2918 }
2919 if !cursor.goto_next_sibling() {
2920 break;
2921 }
2922 }
2923 }
2924 result
2925 };
2926 match non_field_children.first() {
2927 Some(&child) => Some(<DoModule as ::treesitter_types::FromNode>::from_node(
2928 child, src,
2929 )?),
2930 None => None,
2931 }
2932 },
2933 })
2934 }
2935}
2936impl ::treesitter_types::Spanned for Do<'_> {
2937 fn span(&self) -> ::treesitter_types::Span {
2938 self.span
2939 }
2940}
2941#[derive(Debug, Clone, PartialEq, Eq)]
2942pub struct DoModule<'tree> {
2943 pub span: ::treesitter_types::Span,
2944 pub id: DoModuleId,
2945 pub module: Module<'tree>,
2946}
2947impl<'tree> ::treesitter_types::FromNode<'tree> for DoModule<'tree> {
2948 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2949 fn from_node(
2950 node: ::tree_sitter::Node<'tree>,
2951 src: &'tree [u8],
2952 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2953 debug_assert_eq!(node.kind(), "do_module");
2954 Ok(Self {
2955 span: ::treesitter_types::Span::from(node),
2956 id: {
2957 let child = node
2958 .child_by_field_name("id")
2959 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("id", node))?;
2960 <DoModuleId as ::treesitter_types::FromNode>::from_node(child, src)?
2961 },
2962 module: {
2963 let child = node
2964 .child_by_field_name("module")
2965 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
2966 <Module as ::treesitter_types::FromNode>::from_node(child, src)?
2967 },
2968 })
2969 }
2970}
2971impl ::treesitter_types::Spanned for DoModule<'_> {
2972 fn span(&self) -> ::treesitter_types::Span {
2973 self.span
2974 }
2975}
2976#[derive(Debug, Clone, PartialEq, Eq)]
2977pub struct EmptyList<'tree> {
2978 pub span: ::treesitter_types::Span,
2979 text: &'tree str,
2980}
2981impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyList<'tree> {
2982 fn from_node(
2983 node: ::tree_sitter::Node<'tree>,
2984 src: &'tree [u8],
2985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2986 debug_assert_eq!(node.kind(), "empty_list");
2987 Ok(Self {
2988 span: ::treesitter_types::Span::from(node),
2989 text: node.utf8_text(src)?,
2990 })
2991 }
2992}
2993impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyList<'tree> {
2994 fn text(&self) -> &'tree str {
2995 self.text
2996 }
2997}
2998impl ::treesitter_types::Spanned for EmptyList<'_> {
2999 fn span(&self) -> ::treesitter_types::Span {
3000 self.span
3001 }
3002}
3003#[derive(Debug, Clone, PartialEq, Eq)]
3004pub struct Entity<'tree> {
3005 pub span: ::treesitter_types::Span,
3006 pub children: String<'tree>,
3007}
3008impl<'tree> ::treesitter_types::FromNode<'tree> for Entity<'tree> {
3009 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3010 fn from_node(
3011 node: ::tree_sitter::Node<'tree>,
3012 src: &'tree [u8],
3013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3014 debug_assert_eq!(node.kind(), "entity");
3015 Ok(Self {
3016 span: ::treesitter_types::Span::from(node),
3017 children: {
3018 #[allow(clippy::suspicious_else_formatting)]
3019 let non_field_children = {
3020 let mut cursor = node.walk();
3021 let mut result = ::std::vec::Vec::new();
3022 if cursor.goto_first_child() {
3023 loop {
3024 if cursor.field_name().is_none()
3025 && cursor.node().is_named()
3026 && !cursor.node().is_extra()
3027 {
3028 result.push(cursor.node());
3029 }
3030 if !cursor.goto_next_sibling() {
3031 break;
3032 }
3033 }
3034 }
3035 result
3036 };
3037 let child = if let Some(&c) = non_field_children.first() {
3038 c
3039 } else {
3040 let mut fallback_cursor = node.walk();
3041 let mut fallback_child = None;
3042 if fallback_cursor.goto_first_child() {
3043 loop {
3044 if fallback_cursor.field_name().is_none()
3045 && !fallback_cursor.node().is_extra()
3046 {
3047 let candidate = fallback_cursor.node();
3048 #[allow(clippy::needless_question_mark)]
3049 if (|| -> ::core::result::Result<
3050 _,
3051 ::treesitter_types::ParseError,
3052 > {
3053 let child = candidate;
3054 Ok(
3055 <String as ::treesitter_types::FromNode>::from_node(
3056 child,
3057 src,
3058 )?,
3059 )
3060 })()
3061 .is_ok()
3062 {
3063 fallback_child = Some(candidate);
3064 break;
3065 }
3066 }
3067 if !fallback_cursor.goto_next_sibling() {
3068 break;
3069 }
3070 }
3071 }
3072 if fallback_child.is_none() {
3073 let mut cursor2 = node.walk();
3074 if cursor2.goto_first_child() {
3075 loop {
3076 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3077 let candidate = cursor2.node();
3078 #[allow(clippy::needless_question_mark)]
3079 if (|| -> ::core::result::Result<
3080 _,
3081 ::treesitter_types::ParseError,
3082 > {
3083 let child = candidate;
3084 Ok(
3085 <String as ::treesitter_types::FromNode>::from_node(
3086 child,
3087 src,
3088 )?,
3089 )
3090 })()
3091 .is_ok()
3092 {
3093 fallback_child = Some(candidate);
3094 break;
3095 }
3096 }
3097 if !cursor2.goto_next_sibling() {
3098 break;
3099 }
3100 }
3101 }
3102 }
3103 fallback_child.ok_or_else(|| {
3104 ::treesitter_types::ParseError::missing_field("children", node)
3105 })?
3106 };
3107 <String as ::treesitter_types::FromNode>::from_node(child, src)?
3108 },
3109 })
3110 }
3111}
3112impl ::treesitter_types::Spanned for Entity<'_> {
3113 fn span(&self) -> ::treesitter_types::Span {
3114 self.span
3115 }
3116}
3117#[derive(Debug, Clone, PartialEq, Eq)]
3118pub struct Equation<'tree> {
3119 pub span: ::treesitter_types::Span,
3120 pub constructors: ::core::option::Option<ConstructorSynonyms<'tree>>,
3121 pub forall: ::core::option::Option<EquationForall<'tree>>,
3122 pub name: ::core::option::Option<EquationName<'tree>>,
3123 pub pattern: ::core::option::Option<EquationPattern<'tree>>,
3124 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
3125 pub synonym: ::core::option::Option<Pattern<'tree>>,
3126 pub children: ::std::vec::Vec<EquationChildren<'tree>>,
3127}
3128impl<'tree> ::treesitter_types::FromNode<'tree> for Equation<'tree> {
3129 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3130 fn from_node(
3131 node: ::tree_sitter::Node<'tree>,
3132 src: &'tree [u8],
3133 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3134 debug_assert_eq!(node.kind(), "equation");
3135 Ok(Self {
3136 span: ::treesitter_types::Span::from(node),
3137 constructors: match node.child_by_field_name("constructors") {
3138 Some(child) => Some(
3139 <ConstructorSynonyms as ::treesitter_types::FromNode>::from_node(child, src)?,
3140 ),
3141 None => None,
3142 },
3143 forall: match node.child_by_field_name("forall") {
3144 Some(child) => Some(<EquationForall as ::treesitter_types::FromNode>::from_node(
3145 child, src,
3146 )?),
3147 None => None,
3148 },
3149 name: match node.child_by_field_name("name") {
3150 Some(child) => Some(<EquationName as ::treesitter_types::FromNode>::from_node(
3151 child, src,
3152 )?),
3153 None => None,
3154 },
3155 pattern: match node.child_by_field_name("pattern") {
3156 Some(child) => {
3157 Some(<EquationPattern as ::treesitter_types::FromNode>::from_node(child, src)?)
3158 }
3159 None => None,
3160 },
3161 patterns: match node.child_by_field_name("patterns") {
3162 Some(child) => Some(<TypePatterns as ::treesitter_types::FromNode>::from_node(
3163 child, src,
3164 )?),
3165 None => None,
3166 },
3167 synonym: match node.child_by_field_name("synonym") {
3168 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
3169 child, src,
3170 )?),
3171 None => None,
3172 },
3173 children: {
3174 #[allow(clippy::suspicious_else_formatting)]
3175 let non_field_children = {
3176 let mut cursor = node.walk();
3177 let mut result = ::std::vec::Vec::new();
3178 if cursor.goto_first_child() {
3179 loop {
3180 if cursor.field_name().is_none()
3181 && cursor.node().is_named()
3182 && !cursor.node().is_extra()
3183 {
3184 result.push(cursor.node());
3185 }
3186 if !cursor.goto_next_sibling() {
3187 break;
3188 }
3189 }
3190 }
3191 result
3192 };
3193 let mut items = ::std::vec::Vec::new();
3194 for child in non_field_children {
3195 items.push(
3196 <EquationChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
3197 );
3198 }
3199 items
3200 },
3201 })
3202 }
3203}
3204impl ::treesitter_types::Spanned for Equation<'_> {
3205 fn span(&self) -> ::treesitter_types::Span {
3206 self.span
3207 }
3208}
3209#[derive(Debug, Clone, PartialEq, Eq)]
3210pub struct Equations<'tree> {
3211 pub span: ::treesitter_types::Span,
3212 pub equation: ::std::vec::Vec<Equation<'tree>>,
3213}
3214impl<'tree> ::treesitter_types::FromNode<'tree> for Equations<'tree> {
3215 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3216 fn from_node(
3217 node: ::tree_sitter::Node<'tree>,
3218 src: &'tree [u8],
3219 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3220 debug_assert_eq!(node.kind(), "equations");
3221 Ok(Self {
3222 span: ::treesitter_types::Span::from(node),
3223 equation: {
3224 let mut cursor = node.walk();
3225 let mut items = ::std::vec::Vec::new();
3226 for child in node.children_by_field_name("equation", &mut cursor) {
3227 items.push(<Equation as ::treesitter_types::FromNode>::from_node(
3228 child, src,
3229 )?);
3230 }
3231 items
3232 },
3233 })
3234 }
3235}
3236impl ::treesitter_types::Spanned for Equations<'_> {
3237 fn span(&self) -> ::treesitter_types::Span {
3238 self.span
3239 }
3240}
3241#[derive(Debug, Clone, PartialEq, Eq)]
3242pub struct Exp<'tree> {
3243 pub span: ::treesitter_types::Span,
3244 pub children: ExpChildren<'tree>,
3245}
3246impl<'tree> ::treesitter_types::FromNode<'tree> for Exp<'tree> {
3247 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3248 fn from_node(
3249 node: ::tree_sitter::Node<'tree>,
3250 src: &'tree [u8],
3251 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3252 debug_assert_eq!(node.kind(), "exp");
3253 Ok(Self {
3254 span: ::treesitter_types::Span::from(node),
3255 children: {
3256 #[allow(clippy::suspicious_else_formatting)]
3257 let non_field_children = {
3258 let mut cursor = node.walk();
3259 let mut result = ::std::vec::Vec::new();
3260 if cursor.goto_first_child() {
3261 loop {
3262 if cursor.field_name().is_none()
3263 && cursor.node().is_named()
3264 && !cursor.node().is_extra()
3265 {
3266 result.push(cursor.node());
3267 }
3268 if !cursor.goto_next_sibling() {
3269 break;
3270 }
3271 }
3272 }
3273 result
3274 };
3275 let child = if let Some(&c) = non_field_children.first() {
3276 c
3277 } else {
3278 let mut fallback_cursor = node.walk();
3279 let mut fallback_child = None;
3280 if fallback_cursor.goto_first_child() {
3281 loop {
3282 if fallback_cursor.field_name().is_none()
3283 && !fallback_cursor.node().is_extra()
3284 {
3285 let candidate = fallback_cursor.node();
3286 #[allow(clippy::needless_question_mark)]
3287 if (|| -> ::core::result::Result<
3288 _,
3289 ::treesitter_types::ParseError,
3290 > {
3291 let child = candidate;
3292 Ok(
3293 <ExpChildren as ::treesitter_types::FromNode>::from_node(
3294 child,
3295 src,
3296 )?,
3297 )
3298 })()
3299 .is_ok()
3300 {
3301 fallback_child = Some(candidate);
3302 break;
3303 }
3304 }
3305 if !fallback_cursor.goto_next_sibling() {
3306 break;
3307 }
3308 }
3309 }
3310 if fallback_child.is_none() {
3311 let mut cursor2 = node.walk();
3312 if cursor2.goto_first_child() {
3313 loop {
3314 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3315 let candidate = cursor2.node();
3316 #[allow(clippy::needless_question_mark)]
3317 if (|| -> ::core::result::Result<
3318 _,
3319 ::treesitter_types::ParseError,
3320 > {
3321 let child = candidate;
3322 Ok(
3323 <ExpChildren as ::treesitter_types::FromNode>::from_node(
3324 child,
3325 src,
3326 )?,
3327 )
3328 })()
3329 .is_ok()
3330 {
3331 fallback_child = Some(candidate);
3332 break;
3333 }
3334 }
3335 if !cursor2.goto_next_sibling() {
3336 break;
3337 }
3338 }
3339 }
3340 }
3341 fallback_child.ok_or_else(|| {
3342 ::treesitter_types::ParseError::missing_field("children", node)
3343 })?
3344 };
3345 <ExpChildren as ::treesitter_types::FromNode>::from_node(child, src)?
3346 },
3347 })
3348 }
3349}
3350impl ::treesitter_types::Spanned for Exp<'_> {
3351 fn span(&self) -> ::treesitter_types::Span {
3352 self.span
3353 }
3354}
3355#[derive(Debug, Clone, PartialEq, Eq)]
3356pub struct ExplicitType<'tree> {
3357 pub span: ::treesitter_types::Span,
3358 pub r#type: Type<'tree>,
3359}
3360impl<'tree> ::treesitter_types::FromNode<'tree> for ExplicitType<'tree> {
3361 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3362 fn from_node(
3363 node: ::tree_sitter::Node<'tree>,
3364 src: &'tree [u8],
3365 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3366 debug_assert_eq!(node.kind(), "explicit_type");
3367 Ok(Self {
3368 span: ::treesitter_types::Span::from(node),
3369 r#type: {
3370 let child = node
3371 .child_by_field_name("type")
3372 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
3373 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
3374 },
3375 })
3376 }
3377}
3378impl ::treesitter_types::Spanned for ExplicitType<'_> {
3379 fn span(&self) -> ::treesitter_types::Span {
3380 self.span
3381 }
3382}
3383#[derive(Debug, Clone, PartialEq, Eq)]
3384pub struct Export<'tree> {
3385 pub span: ::treesitter_types::Span,
3386 pub children: ::core::option::Option<Children<'tree>>,
3387 pub namespace: ::core::option::Option<Namespace<'tree>>,
3388 pub operator: ::core::option::Option<PrefixId<'tree>>,
3389 pub r#type: ::core::option::Option<ExportType<'tree>>,
3390 pub variable: ::core::option::Option<ExportVariable<'tree>>,
3391}
3392impl<'tree> ::treesitter_types::FromNode<'tree> for Export<'tree> {
3393 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3394 fn from_node(
3395 node: ::tree_sitter::Node<'tree>,
3396 src: &'tree [u8],
3397 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3398 debug_assert_eq!(node.kind(), "export");
3399 Ok(Self {
3400 span: ::treesitter_types::Span::from(node),
3401 children: match node.child_by_field_name("children") {
3402 Some(child) => Some(<Children as ::treesitter_types::FromNode>::from_node(
3403 child, src,
3404 )?),
3405 None => None,
3406 },
3407 namespace: match node.child_by_field_name("namespace") {
3408 Some(child) => Some(<Namespace as ::treesitter_types::FromNode>::from_node(
3409 child, src,
3410 )?),
3411 None => None,
3412 },
3413 operator: match node.child_by_field_name("operator") {
3414 Some(child) => Some(<PrefixId as ::treesitter_types::FromNode>::from_node(
3415 child, src,
3416 )?),
3417 None => None,
3418 },
3419 r#type: match node.child_by_field_name("type") {
3420 Some(child) => Some(<ExportType as ::treesitter_types::FromNode>::from_node(
3421 child, src,
3422 )?),
3423 None => None,
3424 },
3425 variable: match node.child_by_field_name("variable") {
3426 Some(child) => Some(<ExportVariable as ::treesitter_types::FromNode>::from_node(
3427 child, src,
3428 )?),
3429 None => None,
3430 },
3431 })
3432 }
3433}
3434impl ::treesitter_types::Spanned for Export<'_> {
3435 fn span(&self) -> ::treesitter_types::Span {
3436 self.span
3437 }
3438}
3439#[derive(Debug, Clone, PartialEq, Eq)]
3440pub struct Exports<'tree> {
3441 pub span: ::treesitter_types::Span,
3442 pub export: ::std::vec::Vec<Export<'tree>>,
3443 pub children: ::std::vec::Vec<ModuleExport<'tree>>,
3444}
3445impl<'tree> ::treesitter_types::FromNode<'tree> for Exports<'tree> {
3446 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3447 fn from_node(
3448 node: ::tree_sitter::Node<'tree>,
3449 src: &'tree [u8],
3450 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3451 debug_assert_eq!(node.kind(), "exports");
3452 Ok(Self {
3453 span: ::treesitter_types::Span::from(node),
3454 export: {
3455 let mut cursor = node.walk();
3456 let mut items = ::std::vec::Vec::new();
3457 for child in node.children_by_field_name("export", &mut cursor) {
3458 items.push(<Export as ::treesitter_types::FromNode>::from_node(
3459 child, src,
3460 )?);
3461 }
3462 items
3463 },
3464 children: {
3465 #[allow(clippy::suspicious_else_formatting)]
3466 let non_field_children = {
3467 let mut cursor = node.walk();
3468 let mut result = ::std::vec::Vec::new();
3469 if cursor.goto_first_child() {
3470 loop {
3471 if cursor.field_name().is_none()
3472 && cursor.node().is_named()
3473 && !cursor.node().is_extra()
3474 {
3475 result.push(cursor.node());
3476 }
3477 if !cursor.goto_next_sibling() {
3478 break;
3479 }
3480 }
3481 }
3482 result
3483 };
3484 let mut items = ::std::vec::Vec::new();
3485 for child in non_field_children {
3486 items.push(<ModuleExport as ::treesitter_types::FromNode>::from_node(
3487 child, src,
3488 )?);
3489 }
3490 items
3491 },
3492 })
3493 }
3494}
3495impl ::treesitter_types::Spanned for Exports<'_> {
3496 fn span(&self) -> ::treesitter_types::Span {
3497 self.span
3498 }
3499}
3500#[derive(Debug, Clone, PartialEq, Eq)]
3501pub struct Field<'tree> {
3502 pub span: ::treesitter_types::Span,
3503 pub name: ::std::vec::Vec<FieldName<'tree>>,
3504 pub parameter: ::core::option::Option<FieldParameter<'tree>>,
3505 pub r#type: ::core::option::Option<FieldType<'tree>>,
3506 pub children: ::core::option::Option<Type<'tree>>,
3507}
3508impl<'tree> ::treesitter_types::FromNode<'tree> for Field<'tree> {
3509 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3510 fn from_node(
3511 node: ::tree_sitter::Node<'tree>,
3512 src: &'tree [u8],
3513 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3514 debug_assert_eq!(node.kind(), "field");
3515 Ok(Self {
3516 span: ::treesitter_types::Span::from(node),
3517 name: {
3518 let mut cursor = node.walk();
3519 let mut items = ::std::vec::Vec::new();
3520 for child in node.children_by_field_name("name", &mut cursor) {
3521 items.push(<FieldName as ::treesitter_types::FromNode>::from_node(
3522 child, src,
3523 )?);
3524 }
3525 items
3526 },
3527 parameter: match node.child_by_field_name("parameter") {
3528 Some(child) => Some(<FieldParameter as ::treesitter_types::FromNode>::from_node(
3529 child, src,
3530 )?),
3531 None => None,
3532 },
3533 r#type: match node.child_by_field_name("type") {
3534 Some(child) => Some(<FieldType as ::treesitter_types::FromNode>::from_node(
3535 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 match non_field_children.first() {
3560 Some(&child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
3561 child, src,
3562 )?),
3563 None => None,
3564 }
3565 },
3566 })
3567 }
3568}
3569impl ::treesitter_types::Spanned for Field<'_> {
3570 fn span(&self) -> ::treesitter_types::Span {
3571 self.span
3572 }
3573}
3574#[derive(Debug, Clone, PartialEq, Eq)]
3575pub struct FieldName<'tree> {
3576 pub span: ::treesitter_types::Span,
3577 pub children: Variable<'tree>,
3578}
3579impl<'tree> ::treesitter_types::FromNode<'tree> for FieldName<'tree> {
3580 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3581 fn from_node(
3582 node: ::tree_sitter::Node<'tree>,
3583 src: &'tree [u8],
3584 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3585 debug_assert_eq!(node.kind(), "field_name");
3586 Ok(Self {
3587 span: ::treesitter_types::Span::from(node),
3588 children: {
3589 #[allow(clippy::suspicious_else_formatting)]
3590 let non_field_children = {
3591 let mut cursor = node.walk();
3592 let mut result = ::std::vec::Vec::new();
3593 if cursor.goto_first_child() {
3594 loop {
3595 if cursor.field_name().is_none()
3596 && cursor.node().is_named()
3597 && !cursor.node().is_extra()
3598 {
3599 result.push(cursor.node());
3600 }
3601 if !cursor.goto_next_sibling() {
3602 break;
3603 }
3604 }
3605 }
3606 result
3607 };
3608 let child = if let Some(&c) = non_field_children.first() {
3609 c
3610 } else {
3611 let mut fallback_cursor = node.walk();
3612 let mut fallback_child = None;
3613 if fallback_cursor.goto_first_child() {
3614 loop {
3615 if fallback_cursor.field_name().is_none()
3616 && !fallback_cursor.node().is_extra()
3617 {
3618 let candidate = fallback_cursor.node();
3619 #[allow(clippy::needless_question_mark)]
3620 if (|| -> ::core::result::Result<
3621 _,
3622 ::treesitter_types::ParseError,
3623 > {
3624 let child = candidate;
3625 Ok(
3626 <Variable as ::treesitter_types::FromNode>::from_node(
3627 child,
3628 src,
3629 )?,
3630 )
3631 })()
3632 .is_ok()
3633 {
3634 fallback_child = Some(candidate);
3635 break;
3636 }
3637 }
3638 if !fallback_cursor.goto_next_sibling() {
3639 break;
3640 }
3641 }
3642 }
3643 if fallback_child.is_none() {
3644 let mut cursor2 = node.walk();
3645 if cursor2.goto_first_child() {
3646 loop {
3647 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3648 let candidate = cursor2.node();
3649 #[allow(clippy::needless_question_mark)]
3650 if (|| -> ::core::result::Result<
3651 _,
3652 ::treesitter_types::ParseError,
3653 > {
3654 let child = candidate;
3655 Ok(
3656 <Variable as ::treesitter_types::FromNode>::from_node(
3657 child,
3658 src,
3659 )?,
3660 )
3661 })()
3662 .is_ok()
3663 {
3664 fallback_child = Some(candidate);
3665 break;
3666 }
3667 }
3668 if !cursor2.goto_next_sibling() {
3669 break;
3670 }
3671 }
3672 }
3673 }
3674 fallback_child.ok_or_else(|| {
3675 ::treesitter_types::ParseError::missing_field("children", node)
3676 })?
3677 };
3678 <Variable as ::treesitter_types::FromNode>::from_node(child, src)?
3679 },
3680 })
3681 }
3682}
3683impl ::treesitter_types::Spanned for FieldName<'_> {
3684 fn span(&self) -> ::treesitter_types::Span {
3685 self.span
3686 }
3687}
3688#[derive(Debug, Clone, PartialEq, Eq)]
3689pub struct FieldPath<'tree> {
3690 pub span: ::treesitter_types::Span,
3691 pub field: FieldPathField<'tree>,
3692 pub subfield: ::std::vec::Vec<FieldName<'tree>>,
3693}
3694impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPath<'tree> {
3695 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3696 fn from_node(
3697 node: ::tree_sitter::Node<'tree>,
3698 src: &'tree [u8],
3699 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3700 debug_assert_eq!(node.kind(), "field_path");
3701 Ok(Self {
3702 span: ::treesitter_types::Span::from(node),
3703 field: {
3704 let child = node
3705 .child_by_field_name("field")
3706 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
3707 <FieldPathField as ::treesitter_types::FromNode>::from_node(child, src)?
3708 },
3709 subfield: {
3710 let mut cursor = node.walk();
3711 let mut items = ::std::vec::Vec::new();
3712 for child in node.children_by_field_name("subfield", &mut cursor) {
3713 items.push(<FieldName as ::treesitter_types::FromNode>::from_node(
3714 child, src,
3715 )?);
3716 }
3717 items
3718 },
3719 })
3720 }
3721}
3722impl ::treesitter_types::Spanned for FieldPath<'_> {
3723 fn span(&self) -> ::treesitter_types::Span {
3724 self.span
3725 }
3726}
3727#[derive(Debug, Clone, PartialEq, Eq)]
3728pub struct FieldPattern<'tree> {
3729 pub span: ::treesitter_types::Span,
3730 pub field: ::core::option::Option<FieldPatternField<'tree>>,
3731 pub pattern: ::core::option::Option<FieldPatternPattern<'tree>>,
3732 pub children: ::core::option::Option<Wildcard<'tree>>,
3733}
3734impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPattern<'tree> {
3735 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3736 fn from_node(
3737 node: ::tree_sitter::Node<'tree>,
3738 src: &'tree [u8],
3739 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3740 debug_assert_eq!(node.kind(), "field_pattern");
3741 Ok(Self {
3742 span: ::treesitter_types::Span::from(node),
3743 field: match node.child_by_field_name("field") {
3744 Some(child) => Some(
3745 <FieldPatternField as ::treesitter_types::FromNode>::from_node(child, src)?,
3746 ),
3747 None => None,
3748 },
3749 pattern: match node.child_by_field_name("pattern") {
3750 Some(child) => Some(
3751 <FieldPatternPattern as ::treesitter_types::FromNode>::from_node(child, src)?,
3752 ),
3753 None => None,
3754 },
3755 children: {
3756 #[allow(clippy::suspicious_else_formatting)]
3757 let non_field_children = {
3758 let mut cursor = node.walk();
3759 let mut result = ::std::vec::Vec::new();
3760 if cursor.goto_first_child() {
3761 loop {
3762 if cursor.field_name().is_none()
3763 && cursor.node().is_named()
3764 && !cursor.node().is_extra()
3765 {
3766 result.push(cursor.node());
3767 }
3768 if !cursor.goto_next_sibling() {
3769 break;
3770 }
3771 }
3772 }
3773 result
3774 };
3775 match non_field_children.first() {
3776 Some(&child) => Some(<Wildcard as ::treesitter_types::FromNode>::from_node(
3777 child, src,
3778 )?),
3779 None => None,
3780 }
3781 },
3782 })
3783 }
3784}
3785impl ::treesitter_types::Spanned for FieldPattern<'_> {
3786 fn span(&self) -> ::treesitter_types::Span {
3787 self.span
3788 }
3789}
3790#[derive(Debug, Clone, PartialEq, Eq)]
3791pub struct FieldUpdate<'tree> {
3792 pub span: ::treesitter_types::Span,
3793 pub expression: ::core::option::Option<FieldUpdateExpression<'tree>>,
3794 pub field: ::core::option::Option<FieldUpdateField<'tree>>,
3795 pub children: ::core::option::Option<Wildcard<'tree>>,
3796}
3797impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdate<'tree> {
3798 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3799 fn from_node(
3800 node: ::tree_sitter::Node<'tree>,
3801 src: &'tree [u8],
3802 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3803 debug_assert_eq!(node.kind(), "field_update");
3804 Ok(Self {
3805 span: ::treesitter_types::Span::from(node),
3806 expression: match node.child_by_field_name("expression") {
3807 Some(child) => Some(
3808 <FieldUpdateExpression as ::treesitter_types::FromNode>::from_node(child, src)?,
3809 ),
3810 None => None,
3811 },
3812 field: match node.child_by_field_name("field") {
3813 Some(child) => {
3814 Some(<FieldUpdateField as ::treesitter_types::FromNode>::from_node(child, src)?)
3815 }
3816 None => None,
3817 },
3818 children: {
3819 #[allow(clippy::suspicious_else_formatting)]
3820 let non_field_children = {
3821 let mut cursor = node.walk();
3822 let mut result = ::std::vec::Vec::new();
3823 if cursor.goto_first_child() {
3824 loop {
3825 if cursor.field_name().is_none()
3826 && cursor.node().is_named()
3827 && !cursor.node().is_extra()
3828 {
3829 result.push(cursor.node());
3830 }
3831 if !cursor.goto_next_sibling() {
3832 break;
3833 }
3834 }
3835 }
3836 result
3837 };
3838 match non_field_children.first() {
3839 Some(&child) => Some(<Wildcard as ::treesitter_types::FromNode>::from_node(
3840 child, src,
3841 )?),
3842 None => None,
3843 }
3844 },
3845 })
3846 }
3847}
3848impl ::treesitter_types::Spanned for FieldUpdate<'_> {
3849 fn span(&self) -> ::treesitter_types::Span {
3850 self.span
3851 }
3852}
3853#[derive(Debug, Clone, PartialEq, Eq)]
3854pub struct Fields<'tree> {
3855 pub span: ::treesitter_types::Span,
3856 pub field: ::std::vec::Vec<Field<'tree>>,
3857}
3858impl<'tree> ::treesitter_types::FromNode<'tree> for Fields<'tree> {
3859 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3860 fn from_node(
3861 node: ::tree_sitter::Node<'tree>,
3862 src: &'tree [u8],
3863 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3864 debug_assert_eq!(node.kind(), "fields");
3865 Ok(Self {
3866 span: ::treesitter_types::Span::from(node),
3867 field: {
3868 let mut cursor = node.walk();
3869 let mut items = ::std::vec::Vec::new();
3870 for child in node.children_by_field_name("field", &mut cursor) {
3871 items.push(<Field as ::treesitter_types::FromNode>::from_node(
3872 child, src,
3873 )?);
3874 }
3875 items
3876 },
3877 })
3878 }
3879}
3880impl ::treesitter_types::Spanned for Fields<'_> {
3881 fn span(&self) -> ::treesitter_types::Span {
3882 self.span
3883 }
3884}
3885#[derive(Debug, Clone, PartialEq, Eq)]
3886pub struct Fixity<'tree> {
3887 pub span: ::treesitter_types::Span,
3888 pub associativity: FixityAssociativity,
3889 pub operator: ::std::vec::Vec<FixityOperator<'tree>>,
3890 pub precedence: ::core::option::Option<Integer<'tree>>,
3891}
3892impl<'tree> ::treesitter_types::FromNode<'tree> for Fixity<'tree> {
3893 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3894 fn from_node(
3895 node: ::tree_sitter::Node<'tree>,
3896 src: &'tree [u8],
3897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3898 debug_assert_eq!(node.kind(), "fixity");
3899 Ok(Self {
3900 span: ::treesitter_types::Span::from(node),
3901 associativity: {
3902 let child = node.child_by_field_name("associativity").ok_or_else(|| {
3903 ::treesitter_types::ParseError::missing_field("associativity", node)
3904 })?;
3905 <FixityAssociativity as ::treesitter_types::FromNode>::from_node(child, src)?
3906 },
3907 operator: {
3908 let mut cursor = node.walk();
3909 let mut items = ::std::vec::Vec::new();
3910 for child in node.children_by_field_name("operator", &mut cursor) {
3911 items.push(<FixityOperator as ::treesitter_types::FromNode>::from_node(
3912 child, src,
3913 )?);
3914 }
3915 items
3916 },
3917 precedence: match node.child_by_field_name("precedence") {
3918 Some(child) => Some(<Integer as ::treesitter_types::FromNode>::from_node(
3919 child, src,
3920 )?),
3921 None => None,
3922 },
3923 })
3924 }
3925}
3926impl ::treesitter_types::Spanned for Fixity<'_> {
3927 fn span(&self) -> ::treesitter_types::Span {
3928 self.span
3929 }
3930}
3931#[derive(Debug, Clone, PartialEq, Eq)]
3932pub struct Forall<'tree> {
3933 pub span: ::treesitter_types::Span,
3934 pub constraint: ::core::option::Option<Constraints<'tree>>,
3935 pub quantifier: ForallQuantifier,
3936 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
3937 pub variables: ::core::option::Option<QuantifiedVariables<'tree>>,
3938}
3939impl<'tree> ::treesitter_types::FromNode<'tree> for Forall<'tree> {
3940 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3941 fn from_node(
3942 node: ::tree_sitter::Node<'tree>,
3943 src: &'tree [u8],
3944 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3945 debug_assert_eq!(node.kind(), "forall");
3946 Ok(Self {
3947 span: ::treesitter_types::Span::from(node),
3948 constraint: match node.child_by_field_name("constraint") {
3949 Some(child) => Some(<Constraints as ::treesitter_types::FromNode>::from_node(
3950 child, src,
3951 )?),
3952 None => None,
3953 },
3954 quantifier: {
3955 let child = node.child_by_field_name("quantifier").ok_or_else(|| {
3956 ::treesitter_types::ParseError::missing_field("quantifier", node)
3957 })?;
3958 <ForallQuantifier as ::treesitter_types::FromNode>::from_node(child, src)?
3959 },
3960 r#type: match node.child_by_field_name("type") {
3961 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
3962 child, src,
3963 )?),
3964 None => None,
3965 },
3966 variables: match node.child_by_field_name("variables") {
3967 Some(child) => Some(
3968 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(child, src)?,
3969 ),
3970 None => None,
3971 },
3972 })
3973 }
3974}
3975impl ::treesitter_types::Spanned for Forall<'_> {
3976 fn span(&self) -> ::treesitter_types::Span {
3977 self.span
3978 }
3979}
3980#[derive(Debug, Clone, PartialEq, Eq)]
3981pub struct ForallRequired<'tree> {
3982 pub span: ::treesitter_types::Span,
3983 pub quantifier: ForallRequiredQuantifier,
3984 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
3985 pub variables: ::core::option::Option<QuantifiedVariables<'tree>>,
3986}
3987impl<'tree> ::treesitter_types::FromNode<'tree> for ForallRequired<'tree> {
3988 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3989 fn from_node(
3990 node: ::tree_sitter::Node<'tree>,
3991 src: &'tree [u8],
3992 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3993 debug_assert_eq!(node.kind(), "forall_required");
3994 Ok(Self {
3995 span: ::treesitter_types::Span::from(node),
3996 quantifier: {
3997 let child = node.child_by_field_name("quantifier").ok_or_else(|| {
3998 ::treesitter_types::ParseError::missing_field("quantifier", node)
3999 })?;
4000 <ForallRequiredQuantifier as ::treesitter_types::FromNode>::from_node(child, src)?
4001 },
4002 r#type: match node.child_by_field_name("type") {
4003 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
4004 child, src,
4005 )?),
4006 None => None,
4007 },
4008 variables: match node.child_by_field_name("variables") {
4009 Some(child) => Some(
4010 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(child, src)?,
4011 ),
4012 None => None,
4013 },
4014 })
4015 }
4016}
4017impl ::treesitter_types::Spanned for ForallRequired<'_> {
4018 fn span(&self) -> ::treesitter_types::Span {
4019 self.span
4020 }
4021}
4022#[derive(Debug, Clone, PartialEq, Eq)]
4023pub struct ForeignExport<'tree> {
4024 pub span: ::treesitter_types::Span,
4025 pub calling_convention: CallingConvention<'tree>,
4026 pub entity: ::core::option::Option<Entity<'tree>>,
4027 pub signature: Signature<'tree>,
4028}
4029impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignExport<'tree> {
4030 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4031 fn from_node(
4032 node: ::tree_sitter::Node<'tree>,
4033 src: &'tree [u8],
4034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4035 debug_assert_eq!(node.kind(), "foreign_export");
4036 Ok(Self {
4037 span: ::treesitter_types::Span::from(node),
4038 calling_convention: {
4039 let child = node
4040 .child_by_field_name("calling_convention")
4041 .ok_or_else(|| {
4042 ::treesitter_types::ParseError::missing_field("calling_convention", node)
4043 })?;
4044 <CallingConvention as ::treesitter_types::FromNode>::from_node(child, src)?
4045 },
4046 entity: match node.child_by_field_name("entity") {
4047 Some(child) => Some(<Entity as ::treesitter_types::FromNode>::from_node(
4048 child, src,
4049 )?),
4050 None => None,
4051 },
4052 signature: {
4053 let child = node.child_by_field_name("signature").ok_or_else(|| {
4054 ::treesitter_types::ParseError::missing_field("signature", node)
4055 })?;
4056 <Signature as ::treesitter_types::FromNode>::from_node(child, src)?
4057 },
4058 })
4059 }
4060}
4061impl ::treesitter_types::Spanned for ForeignExport<'_> {
4062 fn span(&self) -> ::treesitter_types::Span {
4063 self.span
4064 }
4065}
4066#[derive(Debug, Clone, PartialEq, Eq)]
4067pub struct ForeignImport<'tree> {
4068 pub span: ::treesitter_types::Span,
4069 pub calling_convention: CallingConvention<'tree>,
4070 pub entity: ::core::option::Option<Entity<'tree>>,
4071 pub safety: ::core::option::Option<Safety<'tree>>,
4072 pub signature: Signature<'tree>,
4073}
4074impl<'tree> ::treesitter_types::FromNode<'tree> for ForeignImport<'tree> {
4075 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4076 fn from_node(
4077 node: ::tree_sitter::Node<'tree>,
4078 src: &'tree [u8],
4079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4080 debug_assert_eq!(node.kind(), "foreign_import");
4081 Ok(Self {
4082 span: ::treesitter_types::Span::from(node),
4083 calling_convention: {
4084 let child = node
4085 .child_by_field_name("calling_convention")
4086 .ok_or_else(|| {
4087 ::treesitter_types::ParseError::missing_field("calling_convention", node)
4088 })?;
4089 <CallingConvention as ::treesitter_types::FromNode>::from_node(child, src)?
4090 },
4091 entity: match node.child_by_field_name("entity") {
4092 Some(child) => Some(<Entity as ::treesitter_types::FromNode>::from_node(
4093 child, src,
4094 )?),
4095 None => None,
4096 },
4097 safety: match node.child_by_field_name("safety") {
4098 Some(child) => Some(<Safety as ::treesitter_types::FromNode>::from_node(
4099 child, src,
4100 )?),
4101 None => None,
4102 },
4103 signature: {
4104 let child = node.child_by_field_name("signature").ok_or_else(|| {
4105 ::treesitter_types::ParseError::missing_field("signature", node)
4106 })?;
4107 <Signature as ::treesitter_types::FromNode>::from_node(child, src)?
4108 },
4109 })
4110 }
4111}
4112impl ::treesitter_types::Spanned for ForeignImport<'_> {
4113 fn span(&self) -> ::treesitter_types::Span {
4114 self.span
4115 }
4116}
4117#[derive(Debug, Clone, PartialEq, Eq)]
4118pub struct Function<'tree> {
4119 pub span: ::treesitter_types::Span,
4120 pub arrow: ::core::option::Option<FunctionArrow>,
4121 pub binds: ::core::option::Option<LocalBinds<'tree>>,
4122 pub r#match: ::std::vec::Vec<Match<'tree>>,
4123 pub name: ::core::option::Option<FunctionName<'tree>>,
4124 pub parameter: ::core::option::Option<FunctionParameter<'tree>>,
4125 pub parens: ::core::option::Option<FunctionHeadParens<'tree>>,
4126 pub patterns: ::core::option::Option<Patterns<'tree>>,
4127 pub result: ::core::option::Option<QuantifiedType<'tree>>,
4128 pub children: ::core::option::Option<Infix<'tree>>,
4129}
4130impl<'tree> ::treesitter_types::FromNode<'tree> for Function<'tree> {
4131 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4132 fn from_node(
4133 node: ::tree_sitter::Node<'tree>,
4134 src: &'tree [u8],
4135 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4136 debug_assert_eq!(node.kind(), "function");
4137 Ok(Self {
4138 span: ::treesitter_types::Span::from(node),
4139 arrow: match node.child_by_field_name("arrow") {
4140 Some(child) => Some(<FunctionArrow as ::treesitter_types::FromNode>::from_node(
4141 child, src,
4142 )?),
4143 None => None,
4144 },
4145 binds: match node.child_by_field_name("binds") {
4146 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
4147 child, src,
4148 )?),
4149 None => None,
4150 },
4151 r#match: {
4152 let mut cursor = node.walk();
4153 let mut items = ::std::vec::Vec::new();
4154 for child in node.children_by_field_name("match", &mut cursor) {
4155 items.push(<Match as ::treesitter_types::FromNode>::from_node(
4156 child, src,
4157 )?);
4158 }
4159 items
4160 },
4161 name: match node.child_by_field_name("name") {
4162 Some(child) => Some(<FunctionName as ::treesitter_types::FromNode>::from_node(
4163 child, src,
4164 )?),
4165 None => None,
4166 },
4167 parameter: match node.child_by_field_name("parameter") {
4168 Some(child) => Some(
4169 <FunctionParameter as ::treesitter_types::FromNode>::from_node(child, src)?,
4170 ),
4171 None => None,
4172 },
4173 parens: match node.child_by_field_name("parens") {
4174 Some(child) => Some(
4175 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(child, src)?,
4176 ),
4177 None => None,
4178 },
4179 patterns: match node.child_by_field_name("patterns") {
4180 Some(child) => Some(<Patterns as ::treesitter_types::FromNode>::from_node(
4181 child, src,
4182 )?),
4183 None => None,
4184 },
4185 result: match node.child_by_field_name("result") {
4186 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
4187 child, src,
4188 )?),
4189 None => None,
4190 },
4191 children: {
4192 #[allow(clippy::suspicious_else_formatting)]
4193 let non_field_children = {
4194 let mut cursor = node.walk();
4195 let mut result = ::std::vec::Vec::new();
4196 if cursor.goto_first_child() {
4197 loop {
4198 if cursor.field_name().is_none()
4199 && cursor.node().is_named()
4200 && !cursor.node().is_extra()
4201 {
4202 result.push(cursor.node());
4203 }
4204 if !cursor.goto_next_sibling() {
4205 break;
4206 }
4207 }
4208 }
4209 result
4210 };
4211 match non_field_children.first() {
4212 Some(&child) => Some(<Infix as ::treesitter_types::FromNode>::from_node(
4213 child, src,
4214 )?),
4215 None => None,
4216 }
4217 },
4218 })
4219 }
4220}
4221impl ::treesitter_types::Spanned for Function<'_> {
4222 fn span(&self) -> ::treesitter_types::Span {
4223 self.span
4224 }
4225}
4226#[derive(Debug, Clone, PartialEq, Eq)]
4227pub struct FunctionHeadParens<'tree> {
4228 pub span: ::treesitter_types::Span,
4229 pub name: ::core::option::Option<FunctionHeadParensName<'tree>>,
4230 pub parens: ::core::option::Option<::std::boxed::Box<FunctionHeadParens<'tree>>>,
4231 pub patterns: ::core::option::Option<Patterns<'tree>>,
4232 pub children: ::core::option::Option<Infix<'tree>>,
4233}
4234impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionHeadParens<'tree> {
4235 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4236 fn from_node(
4237 node: ::tree_sitter::Node<'tree>,
4238 src: &'tree [u8],
4239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4240 debug_assert_eq!(node.kind(), "function_head_parens");
4241 Ok(Self {
4242 span: ::treesitter_types::Span::from(node),
4243 name: match node.child_by_field_name("name") {
4244 Some(child) => Some(
4245 <FunctionHeadParensName as ::treesitter_types::FromNode>::from_node(
4246 child, src,
4247 )?,
4248 ),
4249 None => None,
4250 },
4251 parens: match node.child_by_field_name("parens") {
4252 Some(child) => Some(::std::boxed::Box::new(
4253 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(child, src)?,
4254 )),
4255 None => None,
4256 },
4257 patterns: match node.child_by_field_name("patterns") {
4258 Some(child) => Some(<Patterns as ::treesitter_types::FromNode>::from_node(
4259 child, src,
4260 )?),
4261 None => None,
4262 },
4263 children: {
4264 #[allow(clippy::suspicious_else_formatting)]
4265 let non_field_children = {
4266 let mut cursor = node.walk();
4267 let mut result = ::std::vec::Vec::new();
4268 if cursor.goto_first_child() {
4269 loop {
4270 if cursor.field_name().is_none()
4271 && cursor.node().is_named()
4272 && !cursor.node().is_extra()
4273 {
4274 result.push(cursor.node());
4275 }
4276 if !cursor.goto_next_sibling() {
4277 break;
4278 }
4279 }
4280 }
4281 result
4282 };
4283 match non_field_children.first() {
4284 Some(&child) => Some(<Infix as ::treesitter_types::FromNode>::from_node(
4285 child, src,
4286 )?),
4287 None => None,
4288 }
4289 },
4290 })
4291 }
4292}
4293impl ::treesitter_types::Spanned for FunctionHeadParens<'_> {
4294 fn span(&self) -> ::treesitter_types::Span {
4295 self.span
4296 }
4297}
4298#[derive(Debug, Clone, PartialEq, Eq)]
4299pub struct Fundep<'tree> {
4300 pub span: ::treesitter_types::Span,
4301 pub determined: ::std::vec::Vec<Variable<'tree>>,
4302 pub matched: ::std::vec::Vec<Variable<'tree>>,
4303}
4304impl<'tree> ::treesitter_types::FromNode<'tree> for Fundep<'tree> {
4305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4306 fn from_node(
4307 node: ::tree_sitter::Node<'tree>,
4308 src: &'tree [u8],
4309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4310 debug_assert_eq!(node.kind(), "fundep");
4311 Ok(Self {
4312 span: ::treesitter_types::Span::from(node),
4313 determined: {
4314 let mut cursor = node.walk();
4315 let mut items = ::std::vec::Vec::new();
4316 for child in node.children_by_field_name("determined", &mut cursor) {
4317 items.push(<Variable as ::treesitter_types::FromNode>::from_node(
4318 child, src,
4319 )?);
4320 }
4321 items
4322 },
4323 matched: {
4324 let mut cursor = node.walk();
4325 let mut items = ::std::vec::Vec::new();
4326 for child in node.children_by_field_name("matched", &mut cursor) {
4327 items.push(<Variable as ::treesitter_types::FromNode>::from_node(
4328 child, src,
4329 )?);
4330 }
4331 items
4332 },
4333 })
4334 }
4335}
4336impl ::treesitter_types::Spanned for Fundep<'_> {
4337 fn span(&self) -> ::treesitter_types::Span {
4338 self.span
4339 }
4340}
4341#[derive(Debug, Clone, PartialEq, Eq)]
4342pub struct Fundeps<'tree> {
4343 pub span: ::treesitter_types::Span,
4344 pub fundep: ::std::vec::Vec<Fundep<'tree>>,
4345}
4346impl<'tree> ::treesitter_types::FromNode<'tree> for Fundeps<'tree> {
4347 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4348 fn from_node(
4349 node: ::tree_sitter::Node<'tree>,
4350 src: &'tree [u8],
4351 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4352 debug_assert_eq!(node.kind(), "fundeps");
4353 Ok(Self {
4354 span: ::treesitter_types::Span::from(node),
4355 fundep: {
4356 let mut cursor = node.walk();
4357 let mut items = ::std::vec::Vec::new();
4358 for child in node.children_by_field_name("fundep", &mut cursor) {
4359 items.push(<Fundep as ::treesitter_types::FromNode>::from_node(
4360 child, src,
4361 )?);
4362 }
4363 items
4364 },
4365 })
4366 }
4367}
4368impl ::treesitter_types::Spanned for Fundeps<'_> {
4369 fn span(&self) -> ::treesitter_types::Span {
4370 self.span
4371 }
4372}
4373#[derive(Debug, Clone, PartialEq, Eq)]
4374pub struct GadtConstructor<'tree> {
4375 pub span: ::treesitter_types::Span,
4376 pub context: ::core::option::Option<Context<'tree>>,
4377 pub forall: ::core::option::Option<GadtConstructorForall<'tree>>,
4378 pub name: ::core::option::Option<GadtConstructorName<'tree>>,
4379 pub names: ::core::option::Option<BindingList<'tree>>,
4380 pub r#type: GadtConstructorType<'tree>,
4381}
4382impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructor<'tree> {
4383 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4384 fn from_node(
4385 node: ::tree_sitter::Node<'tree>,
4386 src: &'tree [u8],
4387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4388 debug_assert_eq!(node.kind(), "gadt_constructor");
4389 Ok(Self {
4390 span: ::treesitter_types::Span::from(node),
4391 context: match node.child_by_field_name("context") {
4392 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
4393 child, src,
4394 )?),
4395 None => None,
4396 },
4397 forall: match node.child_by_field_name("forall") {
4398 Some(child) => Some(
4399 <GadtConstructorForall as ::treesitter_types::FromNode>::from_node(child, src)?,
4400 ),
4401 None => None,
4402 },
4403 name: match node.child_by_field_name("name") {
4404 Some(child) => Some(
4405 <GadtConstructorName as ::treesitter_types::FromNode>::from_node(child, src)?,
4406 ),
4407 None => None,
4408 },
4409 names: match node.child_by_field_name("names") {
4410 Some(child) => Some(<BindingList as ::treesitter_types::FromNode>::from_node(
4411 child, src,
4412 )?),
4413 None => None,
4414 },
4415 r#type: {
4416 let child = node
4417 .child_by_field_name("type")
4418 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4419 <GadtConstructorType as ::treesitter_types::FromNode>::from_node(child, src)?
4420 },
4421 })
4422 }
4423}
4424impl ::treesitter_types::Spanned for GadtConstructor<'_> {
4425 fn span(&self) -> ::treesitter_types::Span {
4426 self.span
4427 }
4428}
4429#[derive(Debug, Clone, PartialEq, Eq)]
4430pub struct GadtConstructors<'tree> {
4431 pub span: ::treesitter_types::Span,
4432 pub constructor: ::std::vec::Vec<GadtConstructor<'tree>>,
4433}
4434impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructors<'tree> {
4435 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4436 fn from_node(
4437 node: ::tree_sitter::Node<'tree>,
4438 src: &'tree [u8],
4439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4440 debug_assert_eq!(node.kind(), "gadt_constructors");
4441 Ok(Self {
4442 span: ::treesitter_types::Span::from(node),
4443 constructor: {
4444 let mut cursor = node.walk();
4445 let mut items = ::std::vec::Vec::new();
4446 for child in node.children_by_field_name("constructor", &mut cursor) {
4447 items.push(
4448 <GadtConstructor as ::treesitter_types::FromNode>::from_node(child, src)?,
4449 );
4450 }
4451 items
4452 },
4453 })
4454 }
4455}
4456impl ::treesitter_types::Spanned for GadtConstructors<'_> {
4457 fn span(&self) -> ::treesitter_types::Span {
4458 self.span
4459 }
4460}
4461#[derive(Debug, Clone, PartialEq, Eq)]
4462pub struct Generator<'tree> {
4463 pub span: ::treesitter_types::Span,
4464 pub arrow: GeneratorArrow,
4465 pub expression: GeneratorExpression<'tree>,
4466 pub pattern: GeneratorPattern<'tree>,
4467}
4468impl<'tree> ::treesitter_types::FromNode<'tree> for Generator<'tree> {
4469 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4470 fn from_node(
4471 node: ::tree_sitter::Node<'tree>,
4472 src: &'tree [u8],
4473 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4474 debug_assert_eq!(node.kind(), "generator");
4475 Ok(Self {
4476 span: ::treesitter_types::Span::from(node),
4477 arrow: {
4478 let child = node
4479 .child_by_field_name("arrow")
4480 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
4481 <GeneratorArrow as ::treesitter_types::FromNode>::from_node(child, src)?
4482 },
4483 expression: {
4484 let child = node.child_by_field_name("expression").ok_or_else(|| {
4485 ::treesitter_types::ParseError::missing_field("expression", node)
4486 })?;
4487 <GeneratorExpression as ::treesitter_types::FromNode>::from_node(child, src)?
4488 },
4489 pattern: {
4490 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4491 ::treesitter_types::ParseError::missing_field("pattern", node)
4492 })?;
4493 <GeneratorPattern as ::treesitter_types::FromNode>::from_node(child, src)?
4494 },
4495 })
4496 }
4497}
4498impl ::treesitter_types::Spanned for Generator<'_> {
4499 fn span(&self) -> ::treesitter_types::Span {
4500 self.span
4501 }
4502}
4503#[derive(Debug, Clone, PartialEq, Eq)]
4504pub struct Group<'tree> {
4505 pub span: ::treesitter_types::Span,
4506 pub classifier: GroupClassifier<'tree>,
4507 pub key: ::core::option::Option<GroupKey<'tree>>,
4508}
4509impl<'tree> ::treesitter_types::FromNode<'tree> for Group<'tree> {
4510 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4511 fn from_node(
4512 node: ::tree_sitter::Node<'tree>,
4513 src: &'tree [u8],
4514 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4515 debug_assert_eq!(node.kind(), "group");
4516 Ok(Self {
4517 span: ::treesitter_types::Span::from(node),
4518 classifier: {
4519 let child = node.child_by_field_name("classifier").ok_or_else(|| {
4520 ::treesitter_types::ParseError::missing_field("classifier", node)
4521 })?;
4522 <GroupClassifier as ::treesitter_types::FromNode>::from_node(child, src)?
4523 },
4524 key: match node.child_by_field_name("key") {
4525 Some(child) => Some(<GroupKey as ::treesitter_types::FromNode>::from_node(
4526 child, src,
4527 )?),
4528 None => None,
4529 },
4530 })
4531 }
4532}
4533impl ::treesitter_types::Spanned for Group<'_> {
4534 fn span(&self) -> ::treesitter_types::Span {
4535 self.span
4536 }
4537}
4538#[derive(Debug, Clone, PartialEq, Eq)]
4539pub struct Guards<'tree> {
4540 pub span: ::treesitter_types::Span,
4541 pub guard: ::std::vec::Vec<Guard<'tree>>,
4542}
4543impl<'tree> ::treesitter_types::FromNode<'tree> for Guards<'tree> {
4544 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4545 fn from_node(
4546 node: ::tree_sitter::Node<'tree>,
4547 src: &'tree [u8],
4548 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4549 debug_assert_eq!(node.kind(), "guards");
4550 Ok(Self {
4551 span: ::treesitter_types::Span::from(node),
4552 guard: {
4553 let mut cursor = node.walk();
4554 let mut items = ::std::vec::Vec::new();
4555 for child in node.children_by_field_name("guard", &mut cursor) {
4556 items.push(<Guard as ::treesitter_types::FromNode>::from_node(
4557 child, src,
4558 )?);
4559 }
4560 items
4561 },
4562 })
4563 }
4564}
4565impl ::treesitter_types::Spanned for Guards<'_> {
4566 fn span(&self) -> ::treesitter_types::Span {
4567 self.span
4568 }
4569}
4570#[derive(Debug, Clone, PartialEq, Eq)]
4571pub struct Haskell<'tree> {
4572 pub span: ::treesitter_types::Span,
4573 pub declarations: ::core::option::Option<Declarations<'tree>>,
4574 pub imports: ::core::option::Option<Imports<'tree>>,
4575 pub children: ::core::option::Option<Header<'tree>>,
4576}
4577impl<'tree> ::treesitter_types::FromNode<'tree> for Haskell<'tree> {
4578 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4579 fn from_node(
4580 node: ::tree_sitter::Node<'tree>,
4581 src: &'tree [u8],
4582 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4583 debug_assert_eq!(node.kind(), "haskell");
4584 Ok(Self {
4585 span: ::treesitter_types::Span::from(node),
4586 declarations: match node.child_by_field_name("declarations") {
4587 Some(child) => Some(<Declarations as ::treesitter_types::FromNode>::from_node(
4588 child, src,
4589 )?),
4590 None => None,
4591 },
4592 imports: match node.child_by_field_name("imports") {
4593 Some(child) => Some(<Imports as ::treesitter_types::FromNode>::from_node(
4594 child, src,
4595 )?),
4596 None => None,
4597 },
4598 children: {
4599 #[allow(clippy::suspicious_else_formatting)]
4600 let non_field_children = {
4601 let mut cursor = node.walk();
4602 let mut result = ::std::vec::Vec::new();
4603 if cursor.goto_first_child() {
4604 loop {
4605 if cursor.field_name().is_none()
4606 && cursor.node().is_named()
4607 && !cursor.node().is_extra()
4608 {
4609 result.push(cursor.node());
4610 }
4611 if !cursor.goto_next_sibling() {
4612 break;
4613 }
4614 }
4615 }
4616 result
4617 };
4618 match non_field_children.first() {
4619 Some(&child) => Some(<Header as ::treesitter_types::FromNode>::from_node(
4620 child, src,
4621 )?),
4622 None => None,
4623 }
4624 },
4625 })
4626 }
4627}
4628impl ::treesitter_types::Spanned for Haskell<'_> {
4629 fn span(&self) -> ::treesitter_types::Span {
4630 self.span
4631 }
4632}
4633#[derive(Debug, Clone, PartialEq, Eq)]
4634pub struct Header<'tree> {
4635 pub span: ::treesitter_types::Span,
4636 pub exports: ::core::option::Option<Exports<'tree>>,
4637 pub module: Module<'tree>,
4638}
4639impl<'tree> ::treesitter_types::FromNode<'tree> for Header<'tree> {
4640 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4641 fn from_node(
4642 node: ::tree_sitter::Node<'tree>,
4643 src: &'tree [u8],
4644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4645 debug_assert_eq!(node.kind(), "header");
4646 Ok(Self {
4647 span: ::treesitter_types::Span::from(node),
4648 exports: match node.child_by_field_name("exports") {
4649 Some(child) => Some(<Exports as ::treesitter_types::FromNode>::from_node(
4650 child, src,
4651 )?),
4652 None => None,
4653 },
4654 module: {
4655 let child = node
4656 .child_by_field_name("module")
4657 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
4658 <Module as ::treesitter_types::FromNode>::from_node(child, src)?
4659 },
4660 })
4661 }
4662}
4663impl ::treesitter_types::Spanned for Header<'_> {
4664 fn span(&self) -> ::treesitter_types::Span {
4665 self.span
4666 }
4667}
4668#[derive(Debug, Clone, PartialEq, Eq)]
4669pub struct ImplicitParameter<'tree> {
4670 pub span: ::treesitter_types::Span,
4671 pub name: ImplicitVariable<'tree>,
4672 pub r#type: QuantifiedType<'tree>,
4673}
4674impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitParameter<'tree> {
4675 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4676 fn from_node(
4677 node: ::tree_sitter::Node<'tree>,
4678 src: &'tree [u8],
4679 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4680 debug_assert_eq!(node.kind(), "implicit_parameter");
4681 Ok(Self {
4682 span: ::treesitter_types::Span::from(node),
4683 name: {
4684 let child = node
4685 .child_by_field_name("name")
4686 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4687 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(child, src)?
4688 },
4689 r#type: {
4690 let child = node
4691 .child_by_field_name("type")
4692 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4693 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
4694 },
4695 })
4696 }
4697}
4698impl ::treesitter_types::Spanned for ImplicitParameter<'_> {
4699 fn span(&self) -> ::treesitter_types::Span {
4700 self.span
4701 }
4702}
4703#[derive(Debug, Clone, PartialEq, Eq)]
4704pub struct Import<'tree> {
4705 pub span: ::treesitter_types::Span,
4706 pub alias: ::core::option::Option<Module<'tree>>,
4707 pub module: Module<'tree>,
4708 pub names: ::core::option::Option<ImportList<'tree>>,
4709 pub package: ::core::option::Option<ImportPackage<'tree>>,
4710}
4711impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
4712 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4713 fn from_node(
4714 node: ::tree_sitter::Node<'tree>,
4715 src: &'tree [u8],
4716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4717 debug_assert_eq!(node.kind(), "import");
4718 Ok(Self {
4719 span: ::treesitter_types::Span::from(node),
4720 alias: match node.child_by_field_name("alias") {
4721 Some(child) => Some(<Module as ::treesitter_types::FromNode>::from_node(
4722 child, src,
4723 )?),
4724 None => None,
4725 },
4726 module: {
4727 let child = node
4728 .child_by_field_name("module")
4729 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
4730 <Module as ::treesitter_types::FromNode>::from_node(child, src)?
4731 },
4732 names: match node.child_by_field_name("names") {
4733 Some(child) => Some(<ImportList as ::treesitter_types::FromNode>::from_node(
4734 child, src,
4735 )?),
4736 None => None,
4737 },
4738 package: match node.child_by_field_name("package") {
4739 Some(child) => Some(<ImportPackage as ::treesitter_types::FromNode>::from_node(
4740 child, src,
4741 )?),
4742 None => None,
4743 },
4744 })
4745 }
4746}
4747impl ::treesitter_types::Spanned for Import<'_> {
4748 fn span(&self) -> ::treesitter_types::Span {
4749 self.span
4750 }
4751}
4752#[derive(Debug, Clone, PartialEq, Eq)]
4753pub struct ImportList<'tree> {
4754 pub span: ::treesitter_types::Span,
4755 pub name: ::std::vec::Vec<ImportName<'tree>>,
4756}
4757impl<'tree> ::treesitter_types::FromNode<'tree> for ImportList<'tree> {
4758 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4759 fn from_node(
4760 node: ::tree_sitter::Node<'tree>,
4761 src: &'tree [u8],
4762 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4763 debug_assert_eq!(node.kind(), "import_list");
4764 Ok(Self {
4765 span: ::treesitter_types::Span::from(node),
4766 name: {
4767 let mut cursor = node.walk();
4768 let mut items = ::std::vec::Vec::new();
4769 for child in node.children_by_field_name("name", &mut cursor) {
4770 items.push(<ImportName as ::treesitter_types::FromNode>::from_node(
4771 child, src,
4772 )?);
4773 }
4774 items
4775 },
4776 })
4777 }
4778}
4779impl ::treesitter_types::Spanned for ImportList<'_> {
4780 fn span(&self) -> ::treesitter_types::Span {
4781 self.span
4782 }
4783}
4784#[derive(Debug, Clone, PartialEq, Eq)]
4785pub struct ImportName<'tree> {
4786 pub span: ::treesitter_types::Span,
4787 pub children: ::core::option::Option<Children<'tree>>,
4788 pub namespace: ::core::option::Option<Namespace<'tree>>,
4789 pub operator: ::core::option::Option<PrefixId<'tree>>,
4790 pub r#type: ::core::option::Option<ImportNameType<'tree>>,
4791 pub variable: ::core::option::Option<ImportNameVariable<'tree>>,
4792}
4793impl<'tree> ::treesitter_types::FromNode<'tree> for ImportName<'tree> {
4794 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4795 fn from_node(
4796 node: ::tree_sitter::Node<'tree>,
4797 src: &'tree [u8],
4798 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4799 debug_assert_eq!(node.kind(), "import_name");
4800 Ok(Self {
4801 span: ::treesitter_types::Span::from(node),
4802 children: match node.child_by_field_name("children") {
4803 Some(child) => Some(<Children as ::treesitter_types::FromNode>::from_node(
4804 child, src,
4805 )?),
4806 None => None,
4807 },
4808 namespace: match node.child_by_field_name("namespace") {
4809 Some(child) => Some(<Namespace as ::treesitter_types::FromNode>::from_node(
4810 child, src,
4811 )?),
4812 None => None,
4813 },
4814 operator: match node.child_by_field_name("operator") {
4815 Some(child) => Some(<PrefixId as ::treesitter_types::FromNode>::from_node(
4816 child, src,
4817 )?),
4818 None => None,
4819 },
4820 r#type: match node.child_by_field_name("type") {
4821 Some(child) => Some(<ImportNameType as ::treesitter_types::FromNode>::from_node(
4822 child, src,
4823 )?),
4824 None => None,
4825 },
4826 variable: match node.child_by_field_name("variable") {
4827 Some(child) => Some(
4828 <ImportNameVariable as ::treesitter_types::FromNode>::from_node(child, src)?,
4829 ),
4830 None => None,
4831 },
4832 })
4833 }
4834}
4835impl ::treesitter_types::Spanned for ImportName<'_> {
4836 fn span(&self) -> ::treesitter_types::Span {
4837 self.span
4838 }
4839}
4840#[derive(Debug, Clone, PartialEq, Eq)]
4841pub struct Imports<'tree> {
4842 pub span: ::treesitter_types::Span,
4843 pub import: ::std::vec::Vec<Import<'tree>>,
4844}
4845impl<'tree> ::treesitter_types::FromNode<'tree> for Imports<'tree> {
4846 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4847 fn from_node(
4848 node: ::tree_sitter::Node<'tree>,
4849 src: &'tree [u8],
4850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4851 debug_assert_eq!(node.kind(), "imports");
4852 Ok(Self {
4853 span: ::treesitter_types::Span::from(node),
4854 import: {
4855 let mut cursor = node.walk();
4856 let mut items = ::std::vec::Vec::new();
4857 for child in node.children_by_field_name("import", &mut cursor) {
4858 items.push(<Import as ::treesitter_types::FromNode>::from_node(
4859 child, src,
4860 )?);
4861 }
4862 items
4863 },
4864 })
4865 }
4866}
4867impl ::treesitter_types::Spanned for Imports<'_> {
4868 fn span(&self) -> ::treesitter_types::Span {
4869 self.span
4870 }
4871}
4872#[derive(Debug, Clone, PartialEq, Eq)]
4873pub struct Inferred<'tree> {
4874 pub span: ::treesitter_types::Span,
4875 pub children: InferredChildren<'tree>,
4876}
4877impl<'tree> ::treesitter_types::FromNode<'tree> for Inferred<'tree> {
4878 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4879 fn from_node(
4880 node: ::tree_sitter::Node<'tree>,
4881 src: &'tree [u8],
4882 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4883 debug_assert_eq!(node.kind(), "inferred");
4884 Ok(Self {
4885 span: ::treesitter_types::Span::from(node),
4886 children: {
4887 #[allow(clippy::suspicious_else_formatting)]
4888 let non_field_children = {
4889 let mut cursor = node.walk();
4890 let mut result = ::std::vec::Vec::new();
4891 if cursor.goto_first_child() {
4892 loop {
4893 if cursor.field_name().is_none()
4894 && cursor.node().is_named()
4895 && !cursor.node().is_extra()
4896 {
4897 result.push(cursor.node());
4898 }
4899 if !cursor.goto_next_sibling() {
4900 break;
4901 }
4902 }
4903 }
4904 result
4905 };
4906 let child = if let Some(&c) = non_field_children.first() {
4907 c
4908 } else {
4909 let mut fallback_cursor = node.walk();
4910 let mut fallback_child = None;
4911 if fallback_cursor.goto_first_child() {
4912 loop {
4913 if fallback_cursor.field_name().is_none()
4914 && !fallback_cursor.node().is_extra()
4915 {
4916 let candidate = fallback_cursor.node();
4917 #[allow(clippy::needless_question_mark)]
4918 if (|| -> ::core::result::Result<
4919 _,
4920 ::treesitter_types::ParseError,
4921 > {
4922 let child = candidate;
4923 Ok(
4924 <InferredChildren as ::treesitter_types::FromNode>::from_node(
4925 child,
4926 src,
4927 )?,
4928 )
4929 })()
4930 .is_ok()
4931 {
4932 fallback_child = Some(candidate);
4933 break;
4934 }
4935 }
4936 if !fallback_cursor.goto_next_sibling() {
4937 break;
4938 }
4939 }
4940 }
4941 if fallback_child.is_none() {
4942 let mut cursor2 = node.walk();
4943 if cursor2.goto_first_child() {
4944 loop {
4945 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4946 let candidate = cursor2.node();
4947 #[allow(clippy::needless_question_mark)]
4948 if (|| -> ::core::result::Result<
4949 _,
4950 ::treesitter_types::ParseError,
4951 > {
4952 let child = candidate;
4953 Ok(
4954 <InferredChildren as ::treesitter_types::FromNode>::from_node(
4955 child,
4956 src,
4957 )?,
4958 )
4959 })()
4960 .is_ok()
4961 {
4962 fallback_child = Some(candidate);
4963 break;
4964 }
4965 }
4966 if !cursor2.goto_next_sibling() {
4967 break;
4968 }
4969 }
4970 }
4971 }
4972 fallback_child.ok_or_else(|| {
4973 ::treesitter_types::ParseError::missing_field("children", node)
4974 })?
4975 };
4976 <InferredChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4977 },
4978 })
4979 }
4980}
4981impl ::treesitter_types::Spanned for Inferred<'_> {
4982 fn span(&self) -> ::treesitter_types::Span {
4983 self.span
4984 }
4985}
4986#[derive(Debug, Clone, PartialEq, Eq)]
4987pub struct Infix<'tree> {
4988 pub span: ::treesitter_types::Span,
4989 pub left_operand: InfixLeftOperand<'tree>,
4990 pub operator: ::std::vec::Vec<InfixOperator<'tree>>,
4991 pub right_operand: InfixRightOperand<'tree>,
4992}
4993impl<'tree> ::treesitter_types::FromNode<'tree> for Infix<'tree> {
4994 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4995 fn from_node(
4996 node: ::tree_sitter::Node<'tree>,
4997 src: &'tree [u8],
4998 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4999 debug_assert_eq!(node.kind(), "infix");
5000 Ok(Self {
5001 span: ::treesitter_types::Span::from(node),
5002 left_operand: {
5003 let child = node.child_by_field_name("left_operand").ok_or_else(|| {
5004 ::treesitter_types::ParseError::missing_field("left_operand", node)
5005 })?;
5006 <InfixLeftOperand as ::treesitter_types::FromNode>::from_node(child, src)?
5007 },
5008 operator: {
5009 let mut cursor = node.walk();
5010 let mut items = ::std::vec::Vec::new();
5011 for child in node.children_by_field_name("operator", &mut cursor) {
5012 items.push(<InfixOperator as ::treesitter_types::FromNode>::from_node(
5013 child, src,
5014 )?);
5015 }
5016 items
5017 },
5018 right_operand: {
5019 let child = node.child_by_field_name("right_operand").ok_or_else(|| {
5020 ::treesitter_types::ParseError::missing_field("right_operand", node)
5021 })?;
5022 <InfixRightOperand as ::treesitter_types::FromNode>::from_node(child, src)?
5023 },
5024 })
5025 }
5026}
5027impl ::treesitter_types::Spanned for Infix<'_> {
5028 fn span(&self) -> ::treesitter_types::Span {
5029 self.span
5030 }
5031}
5032#[derive(Debug, Clone, PartialEq, Eq)]
5033pub struct InfixId<'tree> {
5034 pub span: ::treesitter_types::Span,
5035 pub children: InfixIdChildren<'tree>,
5036}
5037impl<'tree> ::treesitter_types::FromNode<'tree> for InfixId<'tree> {
5038 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5039 fn from_node(
5040 node: ::tree_sitter::Node<'tree>,
5041 src: &'tree [u8],
5042 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5043 debug_assert_eq!(node.kind(), "infix_id");
5044 Ok(Self {
5045 span: ::treesitter_types::Span::from(node),
5046 children: {
5047 #[allow(clippy::suspicious_else_formatting)]
5048 let non_field_children = {
5049 let mut cursor = node.walk();
5050 let mut result = ::std::vec::Vec::new();
5051 if cursor.goto_first_child() {
5052 loop {
5053 if cursor.field_name().is_none()
5054 && cursor.node().is_named()
5055 && !cursor.node().is_extra()
5056 {
5057 result.push(cursor.node());
5058 }
5059 if !cursor.goto_next_sibling() {
5060 break;
5061 }
5062 }
5063 }
5064 result
5065 };
5066 let child = if let Some(&c) = non_field_children.first() {
5067 c
5068 } else {
5069 let mut fallback_cursor = node.walk();
5070 let mut fallback_child = None;
5071 if fallback_cursor.goto_first_child() {
5072 loop {
5073 if fallback_cursor.field_name().is_none()
5074 && !fallback_cursor.node().is_extra()
5075 {
5076 let candidate = fallback_cursor.node();
5077 #[allow(clippy::needless_question_mark)]
5078 if (|| -> ::core::result::Result<
5079 _,
5080 ::treesitter_types::ParseError,
5081 > {
5082 let child = candidate;
5083 Ok(
5084 <InfixIdChildren as ::treesitter_types::FromNode>::from_node(
5085 child,
5086 src,
5087 )?,
5088 )
5089 })()
5090 .is_ok()
5091 {
5092 fallback_child = Some(candidate);
5093 break;
5094 }
5095 }
5096 if !fallback_cursor.goto_next_sibling() {
5097 break;
5098 }
5099 }
5100 }
5101 if fallback_child.is_none() {
5102 let mut cursor2 = node.walk();
5103 if cursor2.goto_first_child() {
5104 loop {
5105 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5106 let candidate = cursor2.node();
5107 #[allow(clippy::needless_question_mark)]
5108 if (|| -> ::core::result::Result<
5109 _,
5110 ::treesitter_types::ParseError,
5111 > {
5112 let child = candidate;
5113 Ok(
5114 <InfixIdChildren as ::treesitter_types::FromNode>::from_node(
5115 child,
5116 src,
5117 )?,
5118 )
5119 })()
5120 .is_ok()
5121 {
5122 fallback_child = Some(candidate);
5123 break;
5124 }
5125 }
5126 if !cursor2.goto_next_sibling() {
5127 break;
5128 }
5129 }
5130 }
5131 }
5132 fallback_child.ok_or_else(|| {
5133 ::treesitter_types::ParseError::missing_field("children", node)
5134 })?
5135 };
5136 <InfixIdChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5137 },
5138 })
5139 }
5140}
5141impl ::treesitter_types::Spanned for InfixId<'_> {
5142 fn span(&self) -> ::treesitter_types::Span {
5143 self.span
5144 }
5145}
5146#[derive(Debug, Clone, PartialEq, Eq)]
5147pub struct Instance<'tree> {
5148 pub span: ::treesitter_types::Span,
5149 pub context: ::core::option::Option<Context<'tree>>,
5150 pub declarations: ::core::option::Option<InstanceDeclarations<'tree>>,
5151 pub forall: ::core::option::Option<InstanceForall<'tree>>,
5152 pub name: ::core::option::Option<InstanceName<'tree>>,
5153 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
5154 pub children: ::core::option::Option<InstanceChildren<'tree>>,
5155}
5156impl<'tree> ::treesitter_types::FromNode<'tree> for Instance<'tree> {
5157 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5158 fn from_node(
5159 node: ::tree_sitter::Node<'tree>,
5160 src: &'tree [u8],
5161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5162 debug_assert_eq!(node.kind(), "instance");
5163 Ok(Self {
5164 span: ::treesitter_types::Span::from(node),
5165 context: match node.child_by_field_name("context") {
5166 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
5167 child, src,
5168 )?),
5169 None => None,
5170 },
5171 declarations: match node.child_by_field_name("declarations") {
5172 Some(child) => Some(
5173 <InstanceDeclarations as ::treesitter_types::FromNode>::from_node(child, src)?,
5174 ),
5175 None => None,
5176 },
5177 forall: match node.child_by_field_name("forall") {
5178 Some(child) => Some(<InstanceForall as ::treesitter_types::FromNode>::from_node(
5179 child, src,
5180 )?),
5181 None => None,
5182 },
5183 name: match node.child_by_field_name("name") {
5184 Some(child) => Some(<InstanceName as ::treesitter_types::FromNode>::from_node(
5185 child, src,
5186 )?),
5187 None => None,
5188 },
5189 patterns: match node.child_by_field_name("patterns") {
5190 Some(child) => Some(<TypePatterns as ::treesitter_types::FromNode>::from_node(
5191 child, src,
5192 )?),
5193 None => None,
5194 },
5195 children: {
5196 #[allow(clippy::suspicious_else_formatting)]
5197 let non_field_children = {
5198 let mut cursor = node.walk();
5199 let mut result = ::std::vec::Vec::new();
5200 if cursor.goto_first_child() {
5201 loop {
5202 if cursor.field_name().is_none()
5203 && cursor.node().is_named()
5204 && !cursor.node().is_extra()
5205 {
5206 result.push(cursor.node());
5207 }
5208 if !cursor.goto_next_sibling() {
5209 break;
5210 }
5211 }
5212 }
5213 result
5214 };
5215 match non_field_children.first() {
5216 Some(&child) => Some(
5217 <InstanceChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
5218 ),
5219 None => None,
5220 }
5221 },
5222 })
5223 }
5224}
5225impl ::treesitter_types::Spanned for Instance<'_> {
5226 fn span(&self) -> ::treesitter_types::Span {
5227 self.span
5228 }
5229}
5230#[derive(Debug, Clone, PartialEq, Eq)]
5231pub struct InstanceDeclarations<'tree> {
5232 pub span: ::treesitter_types::Span,
5233 pub declaration: ::std::vec::Vec<InstanceDecl<'tree>>,
5234}
5235impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceDeclarations<'tree> {
5236 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5237 fn from_node(
5238 node: ::tree_sitter::Node<'tree>,
5239 src: &'tree [u8],
5240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5241 debug_assert_eq!(node.kind(), "instance_declarations");
5242 Ok(Self {
5243 span: ::treesitter_types::Span::from(node),
5244 declaration: {
5245 let mut cursor = node.walk();
5246 let mut items = ::std::vec::Vec::new();
5247 for child in node.children_by_field_name("declaration", &mut cursor) {
5248 items.push(<InstanceDecl as ::treesitter_types::FromNode>::from_node(
5249 child, src,
5250 )?);
5251 }
5252 items
5253 },
5254 })
5255 }
5256}
5257impl ::treesitter_types::Spanned for InstanceDeclarations<'_> {
5258 fn span(&self) -> ::treesitter_types::Span {
5259 self.span
5260 }
5261}
5262#[derive(Debug, Clone, PartialEq, Eq)]
5263pub struct Integer<'tree> {
5264 pub span: ::treesitter_types::Span,
5265 text: &'tree str,
5266}
5267impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
5268 fn from_node(
5269 node: ::tree_sitter::Node<'tree>,
5270 src: &'tree [u8],
5271 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5272 debug_assert_eq!(node.kind(), "integer");
5273 Ok(Self {
5274 span: ::treesitter_types::Span::from(node),
5275 text: node.utf8_text(src)?,
5276 })
5277 }
5278}
5279impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
5280 fn text(&self) -> &'tree str {
5281 self.text
5282 }
5283}
5284impl ::treesitter_types::Spanned for Integer<'_> {
5285 fn span(&self) -> ::treesitter_types::Span {
5286 self.span
5287 }
5288}
5289#[derive(Debug, Clone, PartialEq, Eq)]
5290pub struct Invisible<'tree> {
5291 pub span: ::treesitter_types::Span,
5292 pub bind: TypeParam<'tree>,
5293}
5294impl<'tree> ::treesitter_types::FromNode<'tree> for Invisible<'tree> {
5295 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5296 fn from_node(
5297 node: ::tree_sitter::Node<'tree>,
5298 src: &'tree [u8],
5299 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5300 debug_assert_eq!(node.kind(), "invisible");
5301 Ok(Self {
5302 span: ::treesitter_types::Span::from(node),
5303 bind: {
5304 let child = node
5305 .child_by_field_name("bind")
5306 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("bind", node))?;
5307 <TypeParam as ::treesitter_types::FromNode>::from_node(child, src)?
5308 },
5309 })
5310 }
5311}
5312impl ::treesitter_types::Spanned for Invisible<'_> {
5313 fn span(&self) -> ::treesitter_types::Span {
5314 self.span
5315 }
5316}
5317#[derive(Debug, Clone, PartialEq, Eq)]
5318pub struct Irrefutable<'tree> {
5319 pub span: ::treesitter_types::Span,
5320 pub pattern: Pattern<'tree>,
5321}
5322impl<'tree> ::treesitter_types::FromNode<'tree> for Irrefutable<'tree> {
5323 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5324 fn from_node(
5325 node: ::tree_sitter::Node<'tree>,
5326 src: &'tree [u8],
5327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5328 debug_assert_eq!(node.kind(), "irrefutable");
5329 Ok(Self {
5330 span: ::treesitter_types::Span::from(node),
5331 pattern: {
5332 let child = node.child_by_field_name("pattern").ok_or_else(|| {
5333 ::treesitter_types::ParseError::missing_field("pattern", node)
5334 })?;
5335 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
5336 },
5337 })
5338 }
5339}
5340impl ::treesitter_types::Spanned for Irrefutable<'_> {
5341 fn span(&self) -> ::treesitter_types::Span {
5342 self.span
5343 }
5344}
5345#[derive(Debug, Clone, PartialEq, Eq)]
5346pub struct KindApplication<'tree> {
5347 pub span: ::treesitter_types::Span,
5348 pub r#type: Type<'tree>,
5349}
5350impl<'tree> ::treesitter_types::FromNode<'tree> for KindApplication<'tree> {
5351 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5352 fn from_node(
5353 node: ::tree_sitter::Node<'tree>,
5354 src: &'tree [u8],
5355 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5356 debug_assert_eq!(node.kind(), "kind_application");
5357 Ok(Self {
5358 span: ::treesitter_types::Span::from(node),
5359 r#type: {
5360 let child = node
5361 .child_by_field_name("type")
5362 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5363 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5364 },
5365 })
5366 }
5367}
5368impl ::treesitter_types::Spanned for KindApplication<'_> {
5369 fn span(&self) -> ::treesitter_types::Span {
5370 self.span
5371 }
5372}
5373#[derive(Debug, Clone, PartialEq, Eq)]
5374pub struct KindSignature<'tree> {
5375 pub span: ::treesitter_types::Span,
5376 pub kind: QuantifiedType<'tree>,
5377 pub name: ::core::option::Option<KindSignatureName<'tree>>,
5378 pub patterns: ::core::option::Option<TypeParams<'tree>>,
5379 pub children: ::core::option::Option<KindSignatureChildren<'tree>>,
5380}
5381impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignature<'tree> {
5382 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5383 fn from_node(
5384 node: ::tree_sitter::Node<'tree>,
5385 src: &'tree [u8],
5386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5387 debug_assert_eq!(node.kind(), "kind_signature");
5388 Ok(Self {
5389 span: ::treesitter_types::Span::from(node),
5390 kind: {
5391 let child = node
5392 .child_by_field_name("kind")
5393 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
5394 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
5395 },
5396 name: match node.child_by_field_name("name") {
5397 Some(child) => Some(
5398 <KindSignatureName as ::treesitter_types::FromNode>::from_node(child, src)?,
5399 ),
5400 None => None,
5401 },
5402 patterns: match node.child_by_field_name("patterns") {
5403 Some(child) => Some(<TypeParams as ::treesitter_types::FromNode>::from_node(
5404 child, src,
5405 )?),
5406 None => None,
5407 },
5408 children: {
5409 #[allow(clippy::suspicious_else_formatting)]
5410 let non_field_children = {
5411 let mut cursor = node.walk();
5412 let mut result = ::std::vec::Vec::new();
5413 if cursor.goto_first_child() {
5414 loop {
5415 if cursor.field_name().is_none()
5416 && cursor.node().is_named()
5417 && !cursor.node().is_extra()
5418 {
5419 result.push(cursor.node());
5420 }
5421 if !cursor.goto_next_sibling() {
5422 break;
5423 }
5424 }
5425 }
5426 result
5427 };
5428 match non_field_children.first() {
5429 Some(&child) => Some(
5430 <KindSignatureChildren as ::treesitter_types::FromNode>::from_node(
5431 child, src,
5432 )?,
5433 ),
5434 None => None,
5435 }
5436 },
5437 })
5438 }
5439}
5440impl ::treesitter_types::Spanned for KindSignature<'_> {
5441 fn span(&self) -> ::treesitter_types::Span {
5442 self.span
5443 }
5444}
5445#[derive(Debug, Clone, PartialEq, Eq)]
5446pub struct Lambda<'tree> {
5447 pub span: ::treesitter_types::Span,
5448 pub expression: LambdaExpression<'tree>,
5449 pub patterns: Patterns<'tree>,
5450}
5451impl<'tree> ::treesitter_types::FromNode<'tree> for Lambda<'tree> {
5452 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5453 fn from_node(
5454 node: ::tree_sitter::Node<'tree>,
5455 src: &'tree [u8],
5456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5457 debug_assert_eq!(node.kind(), "lambda");
5458 Ok(Self {
5459 span: ::treesitter_types::Span::from(node),
5460 expression: {
5461 let child = node.child_by_field_name("expression").ok_or_else(|| {
5462 ::treesitter_types::ParseError::missing_field("expression", node)
5463 })?;
5464 <LambdaExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5465 },
5466 patterns: {
5467 let child = node.child_by_field_name("patterns").ok_or_else(|| {
5468 ::treesitter_types::ParseError::missing_field("patterns", node)
5469 })?;
5470 <Patterns as ::treesitter_types::FromNode>::from_node(child, src)?
5471 },
5472 })
5473 }
5474}
5475impl ::treesitter_types::Spanned for Lambda<'_> {
5476 fn span(&self) -> ::treesitter_types::Span {
5477 self.span
5478 }
5479}
5480#[derive(Debug, Clone, PartialEq, Eq)]
5481pub struct LambdaCase<'tree> {
5482 pub span: ::treesitter_types::Span,
5483 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
5484}
5485impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCase<'tree> {
5486 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5487 fn from_node(
5488 node: ::tree_sitter::Node<'tree>,
5489 src: &'tree [u8],
5490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5491 debug_assert_eq!(node.kind(), "lambda_case");
5492 Ok(Self {
5493 span: ::treesitter_types::Span::from(node),
5494 alternatives: match node.child_by_field_name("alternatives") {
5495 Some(child) => Some(<Alternatives as ::treesitter_types::FromNode>::from_node(
5496 child, src,
5497 )?),
5498 None => None,
5499 },
5500 })
5501 }
5502}
5503impl ::treesitter_types::Spanned for LambdaCase<'_> {
5504 fn span(&self) -> ::treesitter_types::Span {
5505 self.span
5506 }
5507}
5508#[derive(Debug, Clone, PartialEq, Eq)]
5509pub struct LambdaCases<'tree> {
5510 pub span: ::treesitter_types::Span,
5511 pub alternatives: ::core::option::Option<Alternatives<'tree>>,
5512}
5513impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaCases<'tree> {
5514 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5515 fn from_node(
5516 node: ::tree_sitter::Node<'tree>,
5517 src: &'tree [u8],
5518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5519 debug_assert_eq!(node.kind(), "lambda_cases");
5520 Ok(Self {
5521 span: ::treesitter_types::Span::from(node),
5522 alternatives: match node.child_by_field_name("alternatives") {
5523 Some(child) => Some(<Alternatives as ::treesitter_types::FromNode>::from_node(
5524 child, src,
5525 )?),
5526 None => None,
5527 },
5528 })
5529 }
5530}
5531impl ::treesitter_types::Spanned for LambdaCases<'_> {
5532 fn span(&self) -> ::treesitter_types::Span {
5533 self.span
5534 }
5535}
5536#[derive(Debug, Clone, PartialEq, Eq)]
5537pub struct LazyField<'tree> {
5538 pub span: ::treesitter_types::Span,
5539 pub r#type: Type<'tree>,
5540}
5541impl<'tree> ::treesitter_types::FromNode<'tree> for LazyField<'tree> {
5542 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5543 fn from_node(
5544 node: ::tree_sitter::Node<'tree>,
5545 src: &'tree [u8],
5546 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5547 debug_assert_eq!(node.kind(), "lazy_field");
5548 Ok(Self {
5549 span: ::treesitter_types::Span::from(node),
5550 r#type: {
5551 let child = node
5552 .child_by_field_name("type")
5553 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5554 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5555 },
5556 })
5557 }
5558}
5559impl ::treesitter_types::Spanned for LazyField<'_> {
5560 fn span(&self) -> ::treesitter_types::Span {
5561 self.span
5562 }
5563}
5564#[derive(Debug, Clone, PartialEq, Eq)]
5565pub struct LeftSection<'tree> {
5566 pub span: ::treesitter_types::Span,
5567 pub left_operand: Expression<'tree>,
5568 pub operator: LeftSectionOperator<'tree>,
5569}
5570impl<'tree> ::treesitter_types::FromNode<'tree> for LeftSection<'tree> {
5571 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5572 fn from_node(
5573 node: ::tree_sitter::Node<'tree>,
5574 src: &'tree [u8],
5575 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5576 debug_assert_eq!(node.kind(), "left_section");
5577 Ok(Self {
5578 span: ::treesitter_types::Span::from(node),
5579 left_operand: {
5580 let child = node.child_by_field_name("left_operand").ok_or_else(|| {
5581 ::treesitter_types::ParseError::missing_field("left_operand", node)
5582 })?;
5583 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5584 },
5585 operator: {
5586 let child = node.child_by_field_name("operator").ok_or_else(|| {
5587 ::treesitter_types::ParseError::missing_field("operator", node)
5588 })?;
5589 <LeftSectionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
5590 },
5591 })
5592 }
5593}
5594impl ::treesitter_types::Spanned for LeftSection<'_> {
5595 fn span(&self) -> ::treesitter_types::Span {
5596 self.span
5597 }
5598}
5599#[derive(Debug, Clone, PartialEq, Eq)]
5600pub struct Let<'tree> {
5601 pub span: ::treesitter_types::Span,
5602 pub binds: ::core::option::Option<LocalBinds<'tree>>,
5603}
5604impl<'tree> ::treesitter_types::FromNode<'tree> for Let<'tree> {
5605 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5606 fn from_node(
5607 node: ::tree_sitter::Node<'tree>,
5608 src: &'tree [u8],
5609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5610 debug_assert_eq!(node.kind(), "let");
5611 Ok(Self {
5612 span: ::treesitter_types::Span::from(node),
5613 binds: match node.child_by_field_name("binds") {
5614 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
5615 child, src,
5616 )?),
5617 None => None,
5618 },
5619 })
5620 }
5621}
5622impl ::treesitter_types::Spanned for Let<'_> {
5623 fn span(&self) -> ::treesitter_types::Span {
5624 self.span
5625 }
5626}
5627#[derive(Debug, Clone, PartialEq, Eq)]
5628pub struct LetIn<'tree> {
5629 pub span: ::treesitter_types::Span,
5630 pub binds: ::core::option::Option<LocalBinds<'tree>>,
5631 pub expression: LetInExpression<'tree>,
5632}
5633impl<'tree> ::treesitter_types::FromNode<'tree> for LetIn<'tree> {
5634 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5635 fn from_node(
5636 node: ::tree_sitter::Node<'tree>,
5637 src: &'tree [u8],
5638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5639 debug_assert_eq!(node.kind(), "let_in");
5640 Ok(Self {
5641 span: ::treesitter_types::Span::from(node),
5642 binds: match node.child_by_field_name("binds") {
5643 Some(child) => Some(<LocalBinds as ::treesitter_types::FromNode>::from_node(
5644 child, src,
5645 )?),
5646 None => None,
5647 },
5648 expression: {
5649 let child = node.child_by_field_name("expression").ok_or_else(|| {
5650 ::treesitter_types::ParseError::missing_field("expression", node)
5651 })?;
5652 <LetInExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5653 },
5654 })
5655 }
5656}
5657impl ::treesitter_types::Spanned for LetIn<'_> {
5658 fn span(&self) -> ::treesitter_types::Span {
5659 self.span
5660 }
5661}
5662#[derive(Debug, Clone, PartialEq, Eq)]
5663pub struct LinearFunction<'tree> {
5664 pub span: ::treesitter_types::Span,
5665 pub arrow: LinearFunctionArrow,
5666 pub multiplicity: ::core::option::Option<Modifier<'tree>>,
5667 pub parameter: LinearFunctionParameter<'tree>,
5668 pub result: QuantifiedType<'tree>,
5669}
5670impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunction<'tree> {
5671 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5672 fn from_node(
5673 node: ::tree_sitter::Node<'tree>,
5674 src: &'tree [u8],
5675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5676 debug_assert_eq!(node.kind(), "linear_function");
5677 Ok(Self {
5678 span: ::treesitter_types::Span::from(node),
5679 arrow: {
5680 let child = node
5681 .child_by_field_name("arrow")
5682 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
5683 <LinearFunctionArrow as ::treesitter_types::FromNode>::from_node(child, src)?
5684 },
5685 multiplicity: match node.child_by_field_name("multiplicity") {
5686 Some(child) => Some(<Modifier as ::treesitter_types::FromNode>::from_node(
5687 child, src,
5688 )?),
5689 None => None,
5690 },
5691 parameter: {
5692 let child = node.child_by_field_name("parameter").ok_or_else(|| {
5693 ::treesitter_types::ParseError::missing_field("parameter", node)
5694 })?;
5695 <LinearFunctionParameter as ::treesitter_types::FromNode>::from_node(child, src)?
5696 },
5697 result: {
5698 let child = node
5699 .child_by_field_name("result")
5700 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
5701 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
5702 },
5703 })
5704 }
5705}
5706impl ::treesitter_types::Spanned for LinearFunction<'_> {
5707 fn span(&self) -> ::treesitter_types::Span {
5708 self.span
5709 }
5710}
5711#[derive(Debug, Clone, PartialEq, Eq)]
5712pub struct List<'tree> {
5713 pub span: ::treesitter_types::Span,
5714 pub element: ::std::vec::Vec<ListElement<'tree>>,
5715}
5716impl<'tree> ::treesitter_types::FromNode<'tree> for List<'tree> {
5717 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5718 fn from_node(
5719 node: ::tree_sitter::Node<'tree>,
5720 src: &'tree [u8],
5721 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5722 debug_assert_eq!(node.kind(), "list");
5723 Ok(Self {
5724 span: ::treesitter_types::Span::from(node),
5725 element: {
5726 let mut cursor = node.walk();
5727 let mut items = ::std::vec::Vec::new();
5728 for child in node.children_by_field_name("element", &mut cursor) {
5729 items.push(<ListElement as ::treesitter_types::FromNode>::from_node(
5730 child, src,
5731 )?);
5732 }
5733 items
5734 },
5735 })
5736 }
5737}
5738impl ::treesitter_types::Spanned for List<'_> {
5739 fn span(&self) -> ::treesitter_types::Span {
5740 self.span
5741 }
5742}
5743#[derive(Debug, Clone, PartialEq, Eq)]
5744pub struct ListComprehension<'tree> {
5745 pub span: ::treesitter_types::Span,
5746 pub expression: ListComprehensionExpression<'tree>,
5747 pub qualifiers: ::std::vec::Vec<Qualifiers<'tree>>,
5748}
5749impl<'tree> ::treesitter_types::FromNode<'tree> for ListComprehension<'tree> {
5750 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5751 fn from_node(
5752 node: ::tree_sitter::Node<'tree>,
5753 src: &'tree [u8],
5754 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5755 debug_assert_eq!(node.kind(), "list_comprehension");
5756 Ok(Self {
5757 span: ::treesitter_types::Span::from(node),
5758 expression: {
5759 let child = node.child_by_field_name("expression").ok_or_else(|| {
5760 ::treesitter_types::ParseError::missing_field("expression", node)
5761 })?;
5762 <ListComprehensionExpression as ::treesitter_types::FromNode>::from_node(
5763 child, src,
5764 )?
5765 },
5766 qualifiers: {
5767 let mut cursor = node.walk();
5768 let mut items = ::std::vec::Vec::new();
5769 for child in node.children_by_field_name("qualifiers", &mut cursor) {
5770 items.push(<Qualifiers as ::treesitter_types::FromNode>::from_node(
5771 child, src,
5772 )?);
5773 }
5774 items
5775 },
5776 })
5777 }
5778}
5779impl ::treesitter_types::Spanned for ListComprehension<'_> {
5780 fn span(&self) -> ::treesitter_types::Span {
5781 self.span
5782 }
5783}
5784#[derive(Debug, Clone, PartialEq, Eq)]
5785pub struct Literal<'tree> {
5786 pub span: ::treesitter_types::Span,
5787 pub children: LiteralChildren<'tree>,
5788}
5789impl<'tree> ::treesitter_types::FromNode<'tree> for Literal<'tree> {
5790 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5791 fn from_node(
5792 node: ::tree_sitter::Node<'tree>,
5793 src: &'tree [u8],
5794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5795 debug_assert_eq!(node.kind(), "literal");
5796 Ok(Self {
5797 span: ::treesitter_types::Span::from(node),
5798 children: {
5799 #[allow(clippy::suspicious_else_formatting)]
5800 let non_field_children = {
5801 let mut cursor = node.walk();
5802 let mut result = ::std::vec::Vec::new();
5803 if cursor.goto_first_child() {
5804 loop {
5805 if cursor.field_name().is_none()
5806 && cursor.node().is_named()
5807 && !cursor.node().is_extra()
5808 {
5809 result.push(cursor.node());
5810 }
5811 if !cursor.goto_next_sibling() {
5812 break;
5813 }
5814 }
5815 }
5816 result
5817 };
5818 let child = if let Some(&c) = non_field_children.first() {
5819 c
5820 } else {
5821 let mut fallback_cursor = node.walk();
5822 let mut fallback_child = None;
5823 if fallback_cursor.goto_first_child() {
5824 loop {
5825 if fallback_cursor.field_name().is_none()
5826 && !fallback_cursor.node().is_extra()
5827 {
5828 let candidate = fallback_cursor.node();
5829 #[allow(clippy::needless_question_mark)]
5830 if (|| -> ::core::result::Result<
5831 _,
5832 ::treesitter_types::ParseError,
5833 > {
5834 let child = candidate;
5835 Ok(
5836 <LiteralChildren as ::treesitter_types::FromNode>::from_node(
5837 child,
5838 src,
5839 )?,
5840 )
5841 })()
5842 .is_ok()
5843 {
5844 fallback_child = Some(candidate);
5845 break;
5846 }
5847 }
5848 if !fallback_cursor.goto_next_sibling() {
5849 break;
5850 }
5851 }
5852 }
5853 if fallback_child.is_none() {
5854 let mut cursor2 = node.walk();
5855 if cursor2.goto_first_child() {
5856 loop {
5857 if cursor2.node().is_named() && !cursor2.node().is_extra() {
5858 let candidate = cursor2.node();
5859 #[allow(clippy::needless_question_mark)]
5860 if (|| -> ::core::result::Result<
5861 _,
5862 ::treesitter_types::ParseError,
5863 > {
5864 let child = candidate;
5865 Ok(
5866 <LiteralChildren as ::treesitter_types::FromNode>::from_node(
5867 child,
5868 src,
5869 )?,
5870 )
5871 })()
5872 .is_ok()
5873 {
5874 fallback_child = Some(candidate);
5875 break;
5876 }
5877 }
5878 if !cursor2.goto_next_sibling() {
5879 break;
5880 }
5881 }
5882 }
5883 }
5884 fallback_child.ok_or_else(|| {
5885 ::treesitter_types::ParseError::missing_field("children", node)
5886 })?
5887 };
5888 <LiteralChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5889 },
5890 })
5891 }
5892}
5893impl ::treesitter_types::Spanned for Literal<'_> {
5894 fn span(&self) -> ::treesitter_types::Span {
5895 self.span
5896 }
5897}
5898#[derive(Debug, Clone, PartialEq, Eq)]
5899pub struct LocalBinds<'tree> {
5900 pub span: ::treesitter_types::Span,
5901 pub decl: ::std::vec::Vec<LocalBindsDecl<'tree>>,
5902}
5903impl<'tree> ::treesitter_types::FromNode<'tree> for LocalBinds<'tree> {
5904 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5905 fn from_node(
5906 node: ::tree_sitter::Node<'tree>,
5907 src: &'tree [u8],
5908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5909 debug_assert_eq!(node.kind(), "local_binds");
5910 Ok(Self {
5911 span: ::treesitter_types::Span::from(node),
5912 decl: {
5913 let mut cursor = node.walk();
5914 let mut items = ::std::vec::Vec::new();
5915 for child in node.children_by_field_name("decl", &mut cursor) {
5916 items.push(<LocalBindsDecl as ::treesitter_types::FromNode>::from_node(
5917 child, src,
5918 )?);
5919 }
5920 items
5921 },
5922 })
5923 }
5924}
5925impl ::treesitter_types::Spanned for LocalBinds<'_> {
5926 fn span(&self) -> ::treesitter_types::Span {
5927 self.span
5928 }
5929}
5930#[derive(Debug, Clone, PartialEq, Eq)]
5931pub struct Match<'tree> {
5932 pub span: ::treesitter_types::Span,
5933 pub expression: MatchExpression<'tree>,
5934 pub guards: ::core::option::Option<Guards<'tree>>,
5935}
5936impl<'tree> ::treesitter_types::FromNode<'tree> for Match<'tree> {
5937 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5938 fn from_node(
5939 node: ::tree_sitter::Node<'tree>,
5940 src: &'tree [u8],
5941 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5942 debug_assert_eq!(node.kind(), "match");
5943 Ok(Self {
5944 span: ::treesitter_types::Span::from(node),
5945 expression: {
5946 let child = node.child_by_field_name("expression").ok_or_else(|| {
5947 ::treesitter_types::ParseError::missing_field("expression", node)
5948 })?;
5949 <MatchExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5950 },
5951 guards: match node.child_by_field_name("guards") {
5952 Some(child) => Some(<Guards as ::treesitter_types::FromNode>::from_node(
5953 child, src,
5954 )?),
5955 None => None,
5956 },
5957 })
5958 }
5959}
5960impl ::treesitter_types::Spanned for Match<'_> {
5961 fn span(&self) -> ::treesitter_types::Span {
5962 self.span
5963 }
5964}
5965#[derive(Debug, Clone, PartialEq, Eq)]
5966pub struct Modifier<'tree> {
5967 pub span: ::treesitter_types::Span,
5968 pub children: Type<'tree>,
5969}
5970impl<'tree> ::treesitter_types::FromNode<'tree> for Modifier<'tree> {
5971 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5972 fn from_node(
5973 node: ::tree_sitter::Node<'tree>,
5974 src: &'tree [u8],
5975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5976 debug_assert_eq!(node.kind(), "modifier");
5977 Ok(Self {
5978 span: ::treesitter_types::Span::from(node),
5979 children: {
5980 #[allow(clippy::suspicious_else_formatting)]
5981 let non_field_children = {
5982 let mut cursor = node.walk();
5983 let mut result = ::std::vec::Vec::new();
5984 if cursor.goto_first_child() {
5985 loop {
5986 if cursor.field_name().is_none()
5987 && cursor.node().is_named()
5988 && !cursor.node().is_extra()
5989 {
5990 result.push(cursor.node());
5991 }
5992 if !cursor.goto_next_sibling() {
5993 break;
5994 }
5995 }
5996 }
5997 result
5998 };
5999 let child = if let Some(&c) = non_field_children.first() {
6000 c
6001 } else {
6002 let mut fallback_cursor = node.walk();
6003 let mut fallback_child = None;
6004 if fallback_cursor.goto_first_child() {
6005 loop {
6006 if fallback_cursor.field_name().is_none()
6007 && !fallback_cursor.node().is_extra()
6008 {
6009 let candidate = fallback_cursor.node();
6010 #[allow(clippy::needless_question_mark)]
6011 if (|| -> ::core::result::Result<
6012 _,
6013 ::treesitter_types::ParseError,
6014 > {
6015 let child = candidate;
6016 Ok(
6017 <Type as ::treesitter_types::FromNode>::from_node(
6018 child,
6019 src,
6020 )?,
6021 )
6022 })()
6023 .is_ok()
6024 {
6025 fallback_child = Some(candidate);
6026 break;
6027 }
6028 }
6029 if !fallback_cursor.goto_next_sibling() {
6030 break;
6031 }
6032 }
6033 }
6034 if fallback_child.is_none() {
6035 let mut cursor2 = node.walk();
6036 if cursor2.goto_first_child() {
6037 loop {
6038 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6039 let candidate = cursor2.node();
6040 #[allow(clippy::needless_question_mark)]
6041 if (|| -> ::core::result::Result<
6042 _,
6043 ::treesitter_types::ParseError,
6044 > {
6045 let child = candidate;
6046 Ok(
6047 <Type as ::treesitter_types::FromNode>::from_node(
6048 child,
6049 src,
6050 )?,
6051 )
6052 })()
6053 .is_ok()
6054 {
6055 fallback_child = Some(candidate);
6056 break;
6057 }
6058 }
6059 if !cursor2.goto_next_sibling() {
6060 break;
6061 }
6062 }
6063 }
6064 }
6065 fallback_child.ok_or_else(|| {
6066 ::treesitter_types::ParseError::missing_field("children", node)
6067 })?
6068 };
6069 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6070 },
6071 })
6072 }
6073}
6074impl ::treesitter_types::Spanned for Modifier<'_> {
6075 fn span(&self) -> ::treesitter_types::Span {
6076 self.span
6077 }
6078}
6079#[derive(Debug, Clone, PartialEq, Eq)]
6080pub struct Module<'tree> {
6081 pub span: ::treesitter_types::Span,
6082 pub children: ::std::vec::Vec<ModuleId<'tree>>,
6083}
6084impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
6085 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6086 fn from_node(
6087 node: ::tree_sitter::Node<'tree>,
6088 src: &'tree [u8],
6089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6090 debug_assert_eq!(node.kind(), "module");
6091 Ok(Self {
6092 span: ::treesitter_types::Span::from(node),
6093 children: {
6094 #[allow(clippy::suspicious_else_formatting)]
6095 let non_field_children = {
6096 let mut cursor = node.walk();
6097 let mut result = ::std::vec::Vec::new();
6098 if cursor.goto_first_child() {
6099 loop {
6100 if cursor.field_name().is_none()
6101 && cursor.node().is_named()
6102 && !cursor.node().is_extra()
6103 {
6104 result.push(cursor.node());
6105 }
6106 if !cursor.goto_next_sibling() {
6107 break;
6108 }
6109 }
6110 }
6111 result
6112 };
6113 let mut items = ::std::vec::Vec::new();
6114 for child in non_field_children {
6115 items.push(<ModuleId as ::treesitter_types::FromNode>::from_node(
6116 child, src,
6117 )?);
6118 }
6119 items
6120 },
6121 })
6122 }
6123}
6124impl ::treesitter_types::Spanned for Module<'_> {
6125 fn span(&self) -> ::treesitter_types::Span {
6126 self.span
6127 }
6128}
6129#[derive(Debug, Clone, PartialEq, Eq)]
6130pub struct ModuleExport<'tree> {
6131 pub span: ::treesitter_types::Span,
6132 pub module: Module<'tree>,
6133}
6134impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleExport<'tree> {
6135 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6136 fn from_node(
6137 node: ::tree_sitter::Node<'tree>,
6138 src: &'tree [u8],
6139 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6140 debug_assert_eq!(node.kind(), "module_export");
6141 Ok(Self {
6142 span: ::treesitter_types::Span::from(node),
6143 module: {
6144 let child = node
6145 .child_by_field_name("module")
6146 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
6147 <Module as ::treesitter_types::FromNode>::from_node(child, src)?
6148 },
6149 })
6150 }
6151}
6152impl ::treesitter_types::Spanned for ModuleExport<'_> {
6153 fn span(&self) -> ::treesitter_types::Span {
6154 self.span
6155 }
6156}
6157#[derive(Debug, Clone, PartialEq, Eq)]
6158pub struct MultiWayIf<'tree> {
6159 pub span: ::treesitter_types::Span,
6160 pub r#match: ::std::vec::Vec<Match<'tree>>,
6161}
6162impl<'tree> ::treesitter_types::FromNode<'tree> for MultiWayIf<'tree> {
6163 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6164 fn from_node(
6165 node: ::tree_sitter::Node<'tree>,
6166 src: &'tree [u8],
6167 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6168 debug_assert_eq!(node.kind(), "multi_way_if");
6169 Ok(Self {
6170 span: ::treesitter_types::Span::from(node),
6171 r#match: {
6172 let mut cursor = node.walk();
6173 let mut items = ::std::vec::Vec::new();
6174 for child in node.children_by_field_name("match", &mut cursor) {
6175 items.push(<Match as ::treesitter_types::FromNode>::from_node(
6176 child, src,
6177 )?);
6178 }
6179 items
6180 },
6181 })
6182 }
6183}
6184impl ::treesitter_types::Spanned for MultiWayIf<'_> {
6185 fn span(&self) -> ::treesitter_types::Span {
6186 self.span
6187 }
6188}
6189#[derive(Debug, Clone, PartialEq, Eq)]
6190pub struct Namespace<'tree> {
6191 pub span: ::treesitter_types::Span,
6192 text: &'tree str,
6193}
6194impl<'tree> ::treesitter_types::FromNode<'tree> for Namespace<'tree> {
6195 fn from_node(
6196 node: ::tree_sitter::Node<'tree>,
6197 src: &'tree [u8],
6198 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6199 debug_assert_eq!(node.kind(), "namespace");
6200 Ok(Self {
6201 span: ::treesitter_types::Span::from(node),
6202 text: node.utf8_text(src)?,
6203 })
6204 }
6205}
6206impl<'tree> ::treesitter_types::LeafNode<'tree> for Namespace<'tree> {
6207 fn text(&self) -> &'tree str {
6208 self.text
6209 }
6210}
6211impl ::treesitter_types::Spanned for Namespace<'_> {
6212 fn span(&self) -> ::treesitter_types::Span {
6213 self.span
6214 }
6215}
6216#[derive(Debug, Clone, PartialEq, Eq)]
6217pub struct Negation<'tree> {
6218 pub span: ::treesitter_types::Span,
6219 pub expression: ::core::option::Option<Expression<'tree>>,
6220 pub minus: ::core::option::Option<NegationMinus>,
6221 pub number: ::core::option::Option<NegationNumber<'tree>>,
6222}
6223impl<'tree> ::treesitter_types::FromNode<'tree> for Negation<'tree> {
6224 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6225 fn from_node(
6226 node: ::tree_sitter::Node<'tree>,
6227 src: &'tree [u8],
6228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6229 debug_assert_eq!(node.kind(), "negation");
6230 Ok(Self {
6231 span: ::treesitter_types::Span::from(node),
6232 expression: match node.child_by_field_name("expression") {
6233 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6234 child, src,
6235 )?),
6236 None => None,
6237 },
6238 minus: match node.child_by_field_name("minus") {
6239 Some(child) => Some(<NegationMinus as ::treesitter_types::FromNode>::from_node(
6240 child, src,
6241 )?),
6242 None => None,
6243 },
6244 number: match node.child_by_field_name("number") {
6245 Some(child) => Some(<NegationNumber as ::treesitter_types::FromNode>::from_node(
6246 child, src,
6247 )?),
6248 None => None,
6249 },
6250 })
6251 }
6252}
6253impl ::treesitter_types::Spanned for Negation<'_> {
6254 fn span(&self) -> ::treesitter_types::Span {
6255 self.span
6256 }
6257}
6258#[derive(Debug, Clone, PartialEq, Eq)]
6259pub struct Newtype<'tree> {
6260 pub span: ::treesitter_types::Span,
6261 pub constructor: ::core::option::Option<NewtypeConstructor<'tree>>,
6262 pub constructors: ::core::option::Option<GadtConstructors<'tree>>,
6263 pub context: ::core::option::Option<Context<'tree>>,
6264 pub deriving: ::std::vec::Vec<Deriving<'tree>>,
6265 pub forall: ::core::option::Option<NewtypeForall<'tree>>,
6266 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
6267 pub name: ::core::option::Option<NewtypeName<'tree>>,
6268 pub patterns: ::core::option::Option<NewtypePatterns<'tree>>,
6269 pub children: ::core::option::Option<NewtypeChildren<'tree>>,
6270}
6271impl<'tree> ::treesitter_types::FromNode<'tree> for Newtype<'tree> {
6272 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6273 fn from_node(
6274 node: ::tree_sitter::Node<'tree>,
6275 src: &'tree [u8],
6276 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6277 debug_assert_eq!(node.kind(), "newtype");
6278 Ok(Self {
6279 span: ::treesitter_types::Span::from(node),
6280 constructor: match node.child_by_field_name("constructor") {
6281 Some(child) => Some(
6282 <NewtypeConstructor as ::treesitter_types::FromNode>::from_node(child, src)?,
6283 ),
6284 None => None,
6285 },
6286 constructors: match node.child_by_field_name("constructors") {
6287 Some(child) => {
6288 Some(<GadtConstructors as ::treesitter_types::FromNode>::from_node(child, src)?)
6289 }
6290 None => None,
6291 },
6292 context: match node.child_by_field_name("context") {
6293 Some(child) => Some(<Context as ::treesitter_types::FromNode>::from_node(
6294 child, src,
6295 )?),
6296 None => None,
6297 },
6298 deriving: {
6299 let mut cursor = node.walk();
6300 let mut items = ::std::vec::Vec::new();
6301 for child in node.children_by_field_name("deriving", &mut cursor) {
6302 items.push(<Deriving as ::treesitter_types::FromNode>::from_node(
6303 child, src,
6304 )?);
6305 }
6306 items
6307 },
6308 forall: match node.child_by_field_name("forall") {
6309 Some(child) => Some(<NewtypeForall as ::treesitter_types::FromNode>::from_node(
6310 child, src,
6311 )?),
6312 None => None,
6313 },
6314 kind: match node.child_by_field_name("kind") {
6315 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
6316 child, src,
6317 )?),
6318 None => None,
6319 },
6320 name: match node.child_by_field_name("name") {
6321 Some(child) => Some(<NewtypeName as ::treesitter_types::FromNode>::from_node(
6322 child, src,
6323 )?),
6324 None => None,
6325 },
6326 patterns: match node.child_by_field_name("patterns") {
6327 Some(child) => {
6328 Some(<NewtypePatterns as ::treesitter_types::FromNode>::from_node(child, src)?)
6329 }
6330 None => None,
6331 },
6332 children: {
6333 #[allow(clippy::suspicious_else_formatting)]
6334 let non_field_children = {
6335 let mut cursor = node.walk();
6336 let mut result = ::std::vec::Vec::new();
6337 if cursor.goto_first_child() {
6338 loop {
6339 if cursor.field_name().is_none()
6340 && cursor.node().is_named()
6341 && !cursor.node().is_extra()
6342 {
6343 result.push(cursor.node());
6344 }
6345 if !cursor.goto_next_sibling() {
6346 break;
6347 }
6348 }
6349 }
6350 result
6351 };
6352 match non_field_children.first() {
6353 Some(&child) => Some(
6354 <NewtypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6355 ),
6356 None => None,
6357 }
6358 },
6359 })
6360 }
6361}
6362impl ::treesitter_types::Spanned for Newtype<'_> {
6363 fn span(&self) -> ::treesitter_types::Span {
6364 self.span
6365 }
6366}
6367#[derive(Debug, Clone, PartialEq, Eq)]
6368pub struct NewtypeConstructor<'tree> {
6369 pub span: ::treesitter_types::Span,
6370 pub field: NewtypeConstructorField<'tree>,
6371 pub name: NewtypeConstructorName<'tree>,
6372}
6373impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructor<'tree> {
6374 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6375 fn from_node(
6376 node: ::tree_sitter::Node<'tree>,
6377 src: &'tree [u8],
6378 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6379 debug_assert_eq!(node.kind(), "newtype_constructor");
6380 Ok(Self {
6381 span: ::treesitter_types::Span::from(node),
6382 field: {
6383 let child = node
6384 .child_by_field_name("field")
6385 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
6386 <NewtypeConstructorField as ::treesitter_types::FromNode>::from_node(child, src)?
6387 },
6388 name: {
6389 let child = node
6390 .child_by_field_name("name")
6391 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6392 <NewtypeConstructorName as ::treesitter_types::FromNode>::from_node(child, src)?
6393 },
6394 })
6395 }
6396}
6397impl ::treesitter_types::Spanned for NewtypeConstructor<'_> {
6398 fn span(&self) -> ::treesitter_types::Span {
6399 self.span
6400 }
6401}
6402#[derive(Debug, Clone, PartialEq, Eq)]
6403pub struct Operator<'tree> {
6404 pub span: ::treesitter_types::Span,
6405 text: &'tree str,
6406}
6407impl<'tree> ::treesitter_types::FromNode<'tree> for Operator<'tree> {
6408 fn from_node(
6409 node: ::tree_sitter::Node<'tree>,
6410 src: &'tree [u8],
6411 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6412 debug_assert_eq!(node.kind(), "operator");
6413 Ok(Self {
6414 span: ::treesitter_types::Span::from(node),
6415 text: node.utf8_text(src)?,
6416 })
6417 }
6418}
6419impl<'tree> ::treesitter_types::LeafNode<'tree> for Operator<'tree> {
6420 fn text(&self) -> &'tree str {
6421 self.text
6422 }
6423}
6424impl ::treesitter_types::Spanned for Operator<'_> {
6425 fn span(&self) -> ::treesitter_types::Span {
6426 self.span
6427 }
6428}
6429#[derive(Debug, Clone, PartialEq, Eq)]
6430pub struct Parens<'tree> {
6431 pub span: ::treesitter_types::Span,
6432 pub expression: ::core::option::Option<ParensExpression<'tree>>,
6433 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
6434 pub name: ::core::option::Option<ParensName<'tree>>,
6435 pub pattern: ::core::option::Option<ParensPattern<'tree>>,
6436 pub patterns: ::core::option::Option<ParensPatterns<'tree>>,
6437 pub r#type: ::core::option::Option<ParensType<'tree>>,
6438 pub children: ::core::option::Option<ParensChildren<'tree>>,
6439}
6440impl<'tree> ::treesitter_types::FromNode<'tree> for Parens<'tree> {
6441 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6442 fn from_node(
6443 node: ::tree_sitter::Node<'tree>,
6444 src: &'tree [u8],
6445 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6446 debug_assert_eq!(node.kind(), "parens");
6447 Ok(Self {
6448 span: ::treesitter_types::Span::from(node),
6449 expression: match node.child_by_field_name("expression") {
6450 Some(child) => {
6451 Some(<ParensExpression as ::treesitter_types::FromNode>::from_node(child, src)?)
6452 }
6453 None => None,
6454 },
6455 kind: match node.child_by_field_name("kind") {
6456 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
6457 child, src,
6458 )?),
6459 None => None,
6460 },
6461 name: match node.child_by_field_name("name") {
6462 Some(child) => Some(<ParensName as ::treesitter_types::FromNode>::from_node(
6463 child, src,
6464 )?),
6465 None => None,
6466 },
6467 pattern: match node.child_by_field_name("pattern") {
6468 Some(child) => Some(<ParensPattern as ::treesitter_types::FromNode>::from_node(
6469 child, src,
6470 )?),
6471 None => None,
6472 },
6473 patterns: match node.child_by_field_name("patterns") {
6474 Some(child) => Some(<ParensPatterns as ::treesitter_types::FromNode>::from_node(
6475 child, src,
6476 )?),
6477 None => None,
6478 },
6479 r#type: match node.child_by_field_name("type") {
6480 Some(child) => Some(<ParensType as ::treesitter_types::FromNode>::from_node(
6481 child, src,
6482 )?),
6483 None => None,
6484 },
6485 children: {
6486 #[allow(clippy::suspicious_else_formatting)]
6487 let non_field_children = {
6488 let mut cursor = node.walk();
6489 let mut result = ::std::vec::Vec::new();
6490 if cursor.goto_first_child() {
6491 loop {
6492 if cursor.field_name().is_none()
6493 && cursor.node().is_named()
6494 && !cursor.node().is_extra()
6495 {
6496 result.push(cursor.node());
6497 }
6498 if !cursor.goto_next_sibling() {
6499 break;
6500 }
6501 }
6502 }
6503 result
6504 };
6505 match non_field_children.first() {
6506 Some(&child) => Some(
6507 <ParensChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6508 ),
6509 None => None,
6510 }
6511 },
6512 })
6513 }
6514}
6515impl ::treesitter_types::Spanned for Parens<'_> {
6516 fn span(&self) -> ::treesitter_types::Span {
6517 self.span
6518 }
6519}
6520#[derive(Debug, Clone, PartialEq, Eq)]
6521pub struct PatternGuard<'tree> {
6522 pub span: ::treesitter_types::Span,
6523 pub arrow: PatternGuardArrow,
6524 pub expression: PatternGuardExpression<'tree>,
6525 pub pattern: PatternGuardPattern<'tree>,
6526}
6527impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuard<'tree> {
6528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6529 fn from_node(
6530 node: ::tree_sitter::Node<'tree>,
6531 src: &'tree [u8],
6532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6533 debug_assert_eq!(node.kind(), "pattern_guard");
6534 Ok(Self {
6535 span: ::treesitter_types::Span::from(node),
6536 arrow: {
6537 let child = node
6538 .child_by_field_name("arrow")
6539 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("arrow", node))?;
6540 <PatternGuardArrow as ::treesitter_types::FromNode>::from_node(child, src)?
6541 },
6542 expression: {
6543 let child = node.child_by_field_name("expression").ok_or_else(|| {
6544 ::treesitter_types::ParseError::missing_field("expression", node)
6545 })?;
6546 <PatternGuardExpression as ::treesitter_types::FromNode>::from_node(child, src)?
6547 },
6548 pattern: {
6549 let child = node.child_by_field_name("pattern").ok_or_else(|| {
6550 ::treesitter_types::ParseError::missing_field("pattern", node)
6551 })?;
6552 <PatternGuardPattern as ::treesitter_types::FromNode>::from_node(child, src)?
6553 },
6554 })
6555 }
6556}
6557impl ::treesitter_types::Spanned for PatternGuard<'_> {
6558 fn span(&self) -> ::treesitter_types::Span {
6559 self.span
6560 }
6561}
6562#[derive(Debug, Clone, PartialEq, Eq)]
6563pub struct PatternSynonym<'tree> {
6564 pub span: ::treesitter_types::Span,
6565 pub children: PatternSynonymChildren<'tree>,
6566}
6567impl<'tree> ::treesitter_types::FromNode<'tree> for PatternSynonym<'tree> {
6568 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6569 fn from_node(
6570 node: ::tree_sitter::Node<'tree>,
6571 src: &'tree [u8],
6572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6573 debug_assert_eq!(node.kind(), "pattern_synonym");
6574 Ok(Self {
6575 span: ::treesitter_types::Span::from(node),
6576 children: {
6577 #[allow(clippy::suspicious_else_formatting)]
6578 let non_field_children = {
6579 let mut cursor = node.walk();
6580 let mut result = ::std::vec::Vec::new();
6581 if cursor.goto_first_child() {
6582 loop {
6583 if cursor.field_name().is_none()
6584 && cursor.node().is_named()
6585 && !cursor.node().is_extra()
6586 {
6587 result.push(cursor.node());
6588 }
6589 if !cursor.goto_next_sibling() {
6590 break;
6591 }
6592 }
6593 }
6594 result
6595 };
6596 let child = if let Some(&c) = non_field_children.first() {
6597 c
6598 } else {
6599 let mut fallback_cursor = node.walk();
6600 let mut fallback_child = None;
6601 if fallback_cursor.goto_first_child() {
6602 loop {
6603 if fallback_cursor.field_name().is_none()
6604 && !fallback_cursor.node().is_extra()
6605 {
6606 let candidate = fallback_cursor.node();
6607 #[allow(clippy::needless_question_mark)]
6608 if (|| -> ::core::result::Result<
6609 _,
6610 ::treesitter_types::ParseError,
6611 > {
6612 let child = candidate;
6613 Ok(
6614 <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(
6615 child,
6616 src,
6617 )?,
6618 )
6619 })()
6620 .is_ok()
6621 {
6622 fallback_child = Some(candidate);
6623 break;
6624 }
6625 }
6626 if !fallback_cursor.goto_next_sibling() {
6627 break;
6628 }
6629 }
6630 }
6631 if fallback_child.is_none() {
6632 let mut cursor2 = node.walk();
6633 if cursor2.goto_first_child() {
6634 loop {
6635 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6636 let candidate = cursor2.node();
6637 #[allow(clippy::needless_question_mark)]
6638 if (|| -> ::core::result::Result<
6639 _,
6640 ::treesitter_types::ParseError,
6641 > {
6642 let child = candidate;
6643 Ok(
6644 <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(
6645 child,
6646 src,
6647 )?,
6648 )
6649 })()
6650 .is_ok()
6651 {
6652 fallback_child = Some(candidate);
6653 break;
6654 }
6655 }
6656 if !cursor2.goto_next_sibling() {
6657 break;
6658 }
6659 }
6660 }
6661 }
6662 fallback_child.ok_or_else(|| {
6663 ::treesitter_types::ParseError::missing_field("children", node)
6664 })?
6665 };
6666 <PatternSynonymChildren as ::treesitter_types::FromNode>::from_node(child, src)?
6667 },
6668 })
6669 }
6670}
6671impl ::treesitter_types::Spanned for PatternSynonym<'_> {
6672 fn span(&self) -> ::treesitter_types::Span {
6673 self.span
6674 }
6675}
6676#[derive(Debug, Clone, PartialEq, Eq)]
6677pub struct Patterns<'tree> {
6678 pub span: ::treesitter_types::Span,
6679 pub children: ::std::vec::Vec<PatternsChildren<'tree>>,
6680}
6681impl<'tree> ::treesitter_types::FromNode<'tree> for Patterns<'tree> {
6682 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6683 fn from_node(
6684 node: ::tree_sitter::Node<'tree>,
6685 src: &'tree [u8],
6686 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6687 debug_assert_eq!(node.kind(), "patterns");
6688 Ok(Self {
6689 span: ::treesitter_types::Span::from(node),
6690 children: {
6691 #[allow(clippy::suspicious_else_formatting)]
6692 let non_field_children = {
6693 let mut cursor = node.walk();
6694 let mut result = ::std::vec::Vec::new();
6695 if cursor.goto_first_child() {
6696 loop {
6697 if cursor.field_name().is_none()
6698 && cursor.node().is_named()
6699 && !cursor.node().is_extra()
6700 {
6701 result.push(cursor.node());
6702 }
6703 if !cursor.goto_next_sibling() {
6704 break;
6705 }
6706 }
6707 }
6708 result
6709 };
6710 let mut items = ::std::vec::Vec::new();
6711 for child in non_field_children {
6712 items.push(
6713 <PatternsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6714 );
6715 }
6716 items
6717 },
6718 })
6719 }
6720}
6721impl ::treesitter_types::Spanned for Patterns<'_> {
6722 fn span(&self) -> ::treesitter_types::Span {
6723 self.span
6724 }
6725}
6726#[derive(Debug, Clone, PartialEq, Eq)]
6727pub struct Prefix<'tree> {
6728 pub span: ::treesitter_types::Span,
6729 pub field: ::std::vec::Vec<PrefixField<'tree>>,
6730 pub name: ::core::option::Option<PrefixName<'tree>>,
6731 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
6732}
6733impl<'tree> ::treesitter_types::FromNode<'tree> for Prefix<'tree> {
6734 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6735 fn from_node(
6736 node: ::tree_sitter::Node<'tree>,
6737 src: &'tree [u8],
6738 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6739 debug_assert_eq!(node.kind(), "prefix");
6740 Ok(Self {
6741 span: ::treesitter_types::Span::from(node),
6742 field: {
6743 let mut cursor = node.walk();
6744 let mut items = ::std::vec::Vec::new();
6745 for child in node.children_by_field_name("field", &mut cursor) {
6746 items.push(<PrefixField as ::treesitter_types::FromNode>::from_node(
6747 child, src,
6748 )?);
6749 }
6750 items
6751 },
6752 name: match node.child_by_field_name("name") {
6753 Some(child) => Some(<PrefixName as ::treesitter_types::FromNode>::from_node(
6754 child, src,
6755 )?),
6756 None => None,
6757 },
6758 r#type: match node.child_by_field_name("type") {
6759 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
6760 child, src,
6761 )?),
6762 None => None,
6763 },
6764 })
6765 }
6766}
6767impl ::treesitter_types::Spanned for Prefix<'_> {
6768 fn span(&self) -> ::treesitter_types::Span {
6769 self.span
6770 }
6771}
6772#[derive(Debug, Clone, PartialEq, Eq)]
6773pub struct PrefixId<'tree> {
6774 pub span: ::treesitter_types::Span,
6775 pub children: PrefixIdChildren<'tree>,
6776}
6777impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixId<'tree> {
6778 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6779 fn from_node(
6780 node: ::tree_sitter::Node<'tree>,
6781 src: &'tree [u8],
6782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6783 debug_assert_eq!(node.kind(), "prefix_id");
6784 Ok(Self {
6785 span: ::treesitter_types::Span::from(node),
6786 children: {
6787 #[allow(clippy::suspicious_else_formatting)]
6788 let non_field_children = {
6789 let mut cursor = node.walk();
6790 let mut result = ::std::vec::Vec::new();
6791 if cursor.goto_first_child() {
6792 loop {
6793 if cursor.field_name().is_none()
6794 && cursor.node().is_named()
6795 && !cursor.node().is_extra()
6796 {
6797 result.push(cursor.node());
6798 }
6799 if !cursor.goto_next_sibling() {
6800 break;
6801 }
6802 }
6803 }
6804 result
6805 };
6806 let child = if let Some(&c) = non_field_children.first() {
6807 c
6808 } else {
6809 let mut fallback_cursor = node.walk();
6810 let mut fallback_child = None;
6811 if fallback_cursor.goto_first_child() {
6812 loop {
6813 if fallback_cursor.field_name().is_none()
6814 && !fallback_cursor.node().is_extra()
6815 {
6816 let candidate = fallback_cursor.node();
6817 #[allow(clippy::needless_question_mark)]
6818 if (|| -> ::core::result::Result<
6819 _,
6820 ::treesitter_types::ParseError,
6821 > {
6822 let child = candidate;
6823 Ok(
6824 <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(
6825 child,
6826 src,
6827 )?,
6828 )
6829 })()
6830 .is_ok()
6831 {
6832 fallback_child = Some(candidate);
6833 break;
6834 }
6835 }
6836 if !fallback_cursor.goto_next_sibling() {
6837 break;
6838 }
6839 }
6840 }
6841 if fallback_child.is_none() {
6842 let mut cursor2 = node.walk();
6843 if cursor2.goto_first_child() {
6844 loop {
6845 if cursor2.node().is_named() && !cursor2.node().is_extra() {
6846 let candidate = cursor2.node();
6847 #[allow(clippy::needless_question_mark)]
6848 if (|| -> ::core::result::Result<
6849 _,
6850 ::treesitter_types::ParseError,
6851 > {
6852 let child = candidate;
6853 Ok(
6854 <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(
6855 child,
6856 src,
6857 )?,
6858 )
6859 })()
6860 .is_ok()
6861 {
6862 fallback_child = Some(candidate);
6863 break;
6864 }
6865 }
6866 if !cursor2.goto_next_sibling() {
6867 break;
6868 }
6869 }
6870 }
6871 }
6872 fallback_child.ok_or_else(|| {
6873 ::treesitter_types::ParseError::missing_field("children", node)
6874 })?
6875 };
6876 <PrefixIdChildren as ::treesitter_types::FromNode>::from_node(child, src)?
6877 },
6878 })
6879 }
6880}
6881impl ::treesitter_types::Spanned for PrefixId<'_> {
6882 fn span(&self) -> ::treesitter_types::Span {
6883 self.span
6884 }
6885}
6886#[derive(Debug, Clone, PartialEq, Eq)]
6887pub struct PrefixList<'tree> {
6888 pub span: ::treesitter_types::Span,
6889 text: &'tree str,
6890}
6891impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixList<'tree> {
6892 fn from_node(
6893 node: ::tree_sitter::Node<'tree>,
6894 src: &'tree [u8],
6895 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6896 debug_assert_eq!(node.kind(), "prefix_list");
6897 Ok(Self {
6898 span: ::treesitter_types::Span::from(node),
6899 text: node.utf8_text(src)?,
6900 })
6901 }
6902}
6903impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixList<'tree> {
6904 fn text(&self) -> &'tree str {
6905 self.text
6906 }
6907}
6908impl ::treesitter_types::Spanned for PrefixList<'_> {
6909 fn span(&self) -> ::treesitter_types::Span {
6910 self.span
6911 }
6912}
6913#[derive(Debug, Clone, PartialEq, Eq)]
6914pub struct PrefixTuple<'tree> {
6915 pub span: ::treesitter_types::Span,
6916 text: &'tree str,
6917}
6918impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixTuple<'tree> {
6919 fn from_node(
6920 node: ::tree_sitter::Node<'tree>,
6921 src: &'tree [u8],
6922 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6923 debug_assert_eq!(node.kind(), "prefix_tuple");
6924 Ok(Self {
6925 span: ::treesitter_types::Span::from(node),
6926 text: node.utf8_text(src)?,
6927 })
6928 }
6929}
6930impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixTuple<'tree> {
6931 fn text(&self) -> &'tree str {
6932 self.text
6933 }
6934}
6935impl ::treesitter_types::Spanned for PrefixTuple<'_> {
6936 fn span(&self) -> ::treesitter_types::Span {
6937 self.span
6938 }
6939}
6940#[derive(Debug, Clone, PartialEq, Eq)]
6941pub struct PrefixUnboxedSum<'tree> {
6942 pub span: ::treesitter_types::Span,
6943 text: &'tree str,
6944}
6945impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnboxedSum<'tree> {
6946 fn from_node(
6947 node: ::tree_sitter::Node<'tree>,
6948 src: &'tree [u8],
6949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6950 debug_assert_eq!(node.kind(), "prefix_unboxed_sum");
6951 Ok(Self {
6952 span: ::treesitter_types::Span::from(node),
6953 text: node.utf8_text(src)?,
6954 })
6955 }
6956}
6957impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixUnboxedSum<'tree> {
6958 fn text(&self) -> &'tree str {
6959 self.text
6960 }
6961}
6962impl ::treesitter_types::Spanned for PrefixUnboxedSum<'_> {
6963 fn span(&self) -> ::treesitter_types::Span {
6964 self.span
6965 }
6966}
6967#[derive(Debug, Clone, PartialEq, Eq)]
6968pub struct PrefixUnboxedTuple<'tree> {
6969 pub span: ::treesitter_types::Span,
6970 text: &'tree str,
6971}
6972impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixUnboxedTuple<'tree> {
6973 fn from_node(
6974 node: ::tree_sitter::Node<'tree>,
6975 src: &'tree [u8],
6976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6977 debug_assert_eq!(node.kind(), "prefix_unboxed_tuple");
6978 Ok(Self {
6979 span: ::treesitter_types::Span::from(node),
6980 text: node.utf8_text(src)?,
6981 })
6982 }
6983}
6984impl<'tree> ::treesitter_types::LeafNode<'tree> for PrefixUnboxedTuple<'tree> {
6985 fn text(&self) -> &'tree str {
6986 self.text
6987 }
6988}
6989impl ::treesitter_types::Spanned for PrefixUnboxedTuple<'_> {
6990 fn span(&self) -> ::treesitter_types::Span {
6991 self.span
6992 }
6993}
6994#[derive(Debug, Clone, PartialEq, Eq)]
6995pub struct Projection<'tree> {
6996 pub span: ::treesitter_types::Span,
6997 pub expression: Expression<'tree>,
6998 pub field: FieldName<'tree>,
6999}
7000impl<'tree> ::treesitter_types::FromNode<'tree> for Projection<'tree> {
7001 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7002 fn from_node(
7003 node: ::tree_sitter::Node<'tree>,
7004 src: &'tree [u8],
7005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7006 debug_assert_eq!(node.kind(), "projection");
7007 Ok(Self {
7008 span: ::treesitter_types::Span::from(node),
7009 expression: {
7010 let child = node.child_by_field_name("expression").ok_or_else(|| {
7011 ::treesitter_types::ParseError::missing_field("expression", node)
7012 })?;
7013 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7014 },
7015 field: {
7016 let child = node
7017 .child_by_field_name("field")
7018 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("field", node))?;
7019 <FieldName as ::treesitter_types::FromNode>::from_node(child, src)?
7020 },
7021 })
7022 }
7023}
7024impl ::treesitter_types::Spanned for Projection<'_> {
7025 fn span(&self) -> ::treesitter_types::Span {
7026 self.span
7027 }
7028}
7029#[derive(Debug, Clone, PartialEq, Eq)]
7030pub struct ProjectionSelector<'tree> {
7031 pub span: ::treesitter_types::Span,
7032 pub field: ::std::vec::Vec<Variable<'tree>>,
7033}
7034impl<'tree> ::treesitter_types::FromNode<'tree> for ProjectionSelector<'tree> {
7035 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7036 fn from_node(
7037 node: ::tree_sitter::Node<'tree>,
7038 src: &'tree [u8],
7039 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7040 debug_assert_eq!(node.kind(), "projection_selector");
7041 Ok(Self {
7042 span: ::treesitter_types::Span::from(node),
7043 field: {
7044 let mut cursor = node.walk();
7045 let mut items = ::std::vec::Vec::new();
7046 for child in node.children_by_field_name("field", &mut cursor) {
7047 items.push(<Variable as ::treesitter_types::FromNode>::from_node(
7048 child, src,
7049 )?);
7050 }
7051 items
7052 },
7053 })
7054 }
7055}
7056impl ::treesitter_types::Spanned for ProjectionSelector<'_> {
7057 fn span(&self) -> ::treesitter_types::Span {
7058 self.span
7059 }
7060}
7061#[derive(Debug, Clone, PartialEq, Eq)]
7062pub struct Promoted<'tree> {
7063 pub span: ::treesitter_types::Span,
7064 pub children: PromotedChildren<'tree>,
7065}
7066impl<'tree> ::treesitter_types::FromNode<'tree> for Promoted<'tree> {
7067 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7068 fn from_node(
7069 node: ::tree_sitter::Node<'tree>,
7070 src: &'tree [u8],
7071 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7072 debug_assert_eq!(node.kind(), "promoted");
7073 Ok(Self {
7074 span: ::treesitter_types::Span::from(node),
7075 children: {
7076 #[allow(clippy::suspicious_else_formatting)]
7077 let non_field_children = {
7078 let mut cursor = node.walk();
7079 let mut result = ::std::vec::Vec::new();
7080 if cursor.goto_first_child() {
7081 loop {
7082 if cursor.field_name().is_none()
7083 && cursor.node().is_named()
7084 && !cursor.node().is_extra()
7085 {
7086 result.push(cursor.node());
7087 }
7088 if !cursor.goto_next_sibling() {
7089 break;
7090 }
7091 }
7092 }
7093 result
7094 };
7095 let child = if let Some(&c) = non_field_children.first() {
7096 c
7097 } else {
7098 let mut fallback_cursor = node.walk();
7099 let mut fallback_child = None;
7100 if fallback_cursor.goto_first_child() {
7101 loop {
7102 if fallback_cursor.field_name().is_none()
7103 && !fallback_cursor.node().is_extra()
7104 {
7105 let candidate = fallback_cursor.node();
7106 #[allow(clippy::needless_question_mark)]
7107 if (|| -> ::core::result::Result<
7108 _,
7109 ::treesitter_types::ParseError,
7110 > {
7111 let child = candidate;
7112 Ok(
7113 <PromotedChildren as ::treesitter_types::FromNode>::from_node(
7114 child,
7115 src,
7116 )?,
7117 )
7118 })()
7119 .is_ok()
7120 {
7121 fallback_child = Some(candidate);
7122 break;
7123 }
7124 }
7125 if !fallback_cursor.goto_next_sibling() {
7126 break;
7127 }
7128 }
7129 }
7130 if fallback_child.is_none() {
7131 let mut cursor2 = node.walk();
7132 if cursor2.goto_first_child() {
7133 loop {
7134 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7135 let candidate = cursor2.node();
7136 #[allow(clippy::needless_question_mark)]
7137 if (|| -> ::core::result::Result<
7138 _,
7139 ::treesitter_types::ParseError,
7140 > {
7141 let child = candidate;
7142 Ok(
7143 <PromotedChildren as ::treesitter_types::FromNode>::from_node(
7144 child,
7145 src,
7146 )?,
7147 )
7148 })()
7149 .is_ok()
7150 {
7151 fallback_child = Some(candidate);
7152 break;
7153 }
7154 }
7155 if !cursor2.goto_next_sibling() {
7156 break;
7157 }
7158 }
7159 }
7160 }
7161 fallback_child.ok_or_else(|| {
7162 ::treesitter_types::ParseError::missing_field("children", node)
7163 })?
7164 };
7165 <PromotedChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7166 },
7167 })
7168 }
7169}
7170impl ::treesitter_types::Spanned for Promoted<'_> {
7171 fn span(&self) -> ::treesitter_types::Span {
7172 self.span
7173 }
7174}
7175#[derive(Debug, Clone, PartialEq, Eq)]
7176pub struct Qualified<'tree> {
7177 pub span: ::treesitter_types::Span,
7178 pub id: QualifiedId<'tree>,
7179 pub module: Module<'tree>,
7180}
7181impl<'tree> ::treesitter_types::FromNode<'tree> for Qualified<'tree> {
7182 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7183 fn from_node(
7184 node: ::tree_sitter::Node<'tree>,
7185 src: &'tree [u8],
7186 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7187 debug_assert_eq!(node.kind(), "qualified");
7188 Ok(Self {
7189 span: ::treesitter_types::Span::from(node),
7190 id: {
7191 let child = node
7192 .child_by_field_name("id")
7193 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("id", node))?;
7194 <QualifiedId as ::treesitter_types::FromNode>::from_node(child, src)?
7195 },
7196 module: {
7197 let child = node
7198 .child_by_field_name("module")
7199 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
7200 <Module as ::treesitter_types::FromNode>::from_node(child, src)?
7201 },
7202 })
7203 }
7204}
7205impl ::treesitter_types::Spanned for Qualified<'_> {
7206 fn span(&self) -> ::treesitter_types::Span {
7207 self.span
7208 }
7209}
7210#[derive(Debug, Clone, PartialEq, Eq)]
7211pub struct Qualifiers<'tree> {
7212 pub span: ::treesitter_types::Span,
7213 pub qualifier: ::std::vec::Vec<Qualifier<'tree>>,
7214}
7215impl<'tree> ::treesitter_types::FromNode<'tree> for Qualifiers<'tree> {
7216 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7217 fn from_node(
7218 node: ::tree_sitter::Node<'tree>,
7219 src: &'tree [u8],
7220 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7221 debug_assert_eq!(node.kind(), "qualifiers");
7222 Ok(Self {
7223 span: ::treesitter_types::Span::from(node),
7224 qualifier: {
7225 let mut cursor = node.walk();
7226 let mut items = ::std::vec::Vec::new();
7227 for child in node.children_by_field_name("qualifier", &mut cursor) {
7228 items.push(<Qualifier as ::treesitter_types::FromNode>::from_node(
7229 child, src,
7230 )?);
7231 }
7232 items
7233 },
7234 })
7235 }
7236}
7237impl ::treesitter_types::Spanned for Qualifiers<'_> {
7238 fn span(&self) -> ::treesitter_types::Span {
7239 self.span
7240 }
7241}
7242#[derive(Debug, Clone, PartialEq, Eq)]
7243pub struct QuantifiedVariables<'tree> {
7244 pub span: ::treesitter_types::Span,
7245 pub children: ::std::vec::Vec<QuantifiedVariablesChildren<'tree>>,
7246}
7247impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedVariables<'tree> {
7248 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7249 fn from_node(
7250 node: ::tree_sitter::Node<'tree>,
7251 src: &'tree [u8],
7252 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7253 debug_assert_eq!(node.kind(), "quantified_variables");
7254 Ok(Self {
7255 span: ::treesitter_types::Span::from(node),
7256 children: {
7257 #[allow(clippy::suspicious_else_formatting)]
7258 let non_field_children = {
7259 let mut cursor = node.walk();
7260 let mut result = ::std::vec::Vec::new();
7261 if cursor.goto_first_child() {
7262 loop {
7263 if cursor.field_name().is_none()
7264 && cursor.node().is_named()
7265 && !cursor.node().is_extra()
7266 {
7267 result.push(cursor.node());
7268 }
7269 if !cursor.goto_next_sibling() {
7270 break;
7271 }
7272 }
7273 }
7274 result
7275 };
7276 let mut items = ::std::vec::Vec::new();
7277 for child in non_field_children {
7278 items.push(
7279 <QuantifiedVariablesChildren as ::treesitter_types::FromNode>::from_node(
7280 child, src,
7281 )?,
7282 );
7283 }
7284 items
7285 },
7286 })
7287 }
7288}
7289impl ::treesitter_types::Spanned for QuantifiedVariables<'_> {
7290 fn span(&self) -> ::treesitter_types::Span {
7291 self.span
7292 }
7293}
7294#[derive(Debug, Clone, PartialEq, Eq)]
7295pub struct Quasiquote<'tree> {
7296 pub span: ::treesitter_types::Span,
7297 pub body: ::core::option::Option<QuasiquoteBody<'tree>>,
7298 pub quoter: Quoter<'tree>,
7299}
7300impl<'tree> ::treesitter_types::FromNode<'tree> for Quasiquote<'tree> {
7301 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7302 fn from_node(
7303 node: ::tree_sitter::Node<'tree>,
7304 src: &'tree [u8],
7305 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7306 debug_assert_eq!(node.kind(), "quasiquote");
7307 Ok(Self {
7308 span: ::treesitter_types::Span::from(node),
7309 body: match node.child_by_field_name("body") {
7310 Some(child) => Some(<QuasiquoteBody as ::treesitter_types::FromNode>::from_node(
7311 child, src,
7312 )?),
7313 None => None,
7314 },
7315 quoter: {
7316 let child = node
7317 .child_by_field_name("quoter")
7318 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("quoter", node))?;
7319 <Quoter as ::treesitter_types::FromNode>::from_node(child, src)?
7320 },
7321 })
7322 }
7323}
7324impl ::treesitter_types::Spanned for Quasiquote<'_> {
7325 fn span(&self) -> ::treesitter_types::Span {
7326 self.span
7327 }
7328}
7329#[derive(Debug, Clone, PartialEq, Eq)]
7330pub struct Quote<'tree> {
7331 pub span: ::treesitter_types::Span,
7332 pub quoter: ::core::option::Option<QuoteQuoter>,
7333 pub children: ::core::option::Option<QuoteChildren<'tree>>,
7334}
7335impl<'tree> ::treesitter_types::FromNode<'tree> for Quote<'tree> {
7336 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7337 fn from_node(
7338 node: ::tree_sitter::Node<'tree>,
7339 src: &'tree [u8],
7340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7341 debug_assert_eq!(node.kind(), "quote");
7342 Ok(Self {
7343 span: ::treesitter_types::Span::from(node),
7344 quoter: match node.child_by_field_name("quoter") {
7345 Some(child) => Some(<QuoteQuoter as ::treesitter_types::FromNode>::from_node(
7346 child, src,
7347 )?),
7348 None => None,
7349 },
7350 children: {
7351 #[allow(clippy::suspicious_else_formatting)]
7352 let non_field_children = {
7353 let mut cursor = node.walk();
7354 let mut result = ::std::vec::Vec::new();
7355 if cursor.goto_first_child() {
7356 loop {
7357 if cursor.field_name().is_none()
7358 && cursor.node().is_named()
7359 && !cursor.node().is_extra()
7360 {
7361 result.push(cursor.node());
7362 }
7363 if !cursor.goto_next_sibling() {
7364 break;
7365 }
7366 }
7367 }
7368 result
7369 };
7370 match non_field_children.first() {
7371 Some(&child) => Some(
7372 <QuoteChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7373 ),
7374 None => None,
7375 }
7376 },
7377 })
7378 }
7379}
7380impl ::treesitter_types::Spanned for Quote<'_> {
7381 fn span(&self) -> ::treesitter_types::Span {
7382 self.span
7383 }
7384}
7385#[derive(Debug, Clone, PartialEq, Eq)]
7386pub struct QuotedDecls<'tree> {
7387 pub span: ::treesitter_types::Span,
7388 pub declaration: ::std::vec::Vec<Declaration<'tree>>,
7389}
7390impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedDecls<'tree> {
7391 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7392 fn from_node(
7393 node: ::tree_sitter::Node<'tree>,
7394 src: &'tree [u8],
7395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7396 debug_assert_eq!(node.kind(), "quoted_decls");
7397 Ok(Self {
7398 span: ::treesitter_types::Span::from(node),
7399 declaration: {
7400 let mut cursor = node.walk();
7401 let mut items = ::std::vec::Vec::new();
7402 for child in node.children_by_field_name("declaration", &mut cursor) {
7403 items.push(<Declaration as ::treesitter_types::FromNode>::from_node(
7404 child, src,
7405 )?);
7406 }
7407 items
7408 },
7409 })
7410 }
7411}
7412impl ::treesitter_types::Spanned for QuotedDecls<'_> {
7413 fn span(&self) -> ::treesitter_types::Span {
7414 self.span
7415 }
7416}
7417#[derive(Debug, Clone, PartialEq, Eq)]
7418pub struct QuotedExpression<'tree> {
7419 pub span: ::treesitter_types::Span,
7420 pub children: QuotedExpressionChildren<'tree>,
7421}
7422impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedExpression<'tree> {
7423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7424 fn from_node(
7425 node: ::tree_sitter::Node<'tree>,
7426 src: &'tree [u8],
7427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7428 debug_assert_eq!(node.kind(), "quoted_expression");
7429 Ok(Self {
7430 span: ::treesitter_types::Span::from(node),
7431 children: {
7432 #[allow(clippy::suspicious_else_formatting)]
7433 let non_field_children = {
7434 let mut cursor = node.walk();
7435 let mut result = ::std::vec::Vec::new();
7436 if cursor.goto_first_child() {
7437 loop {
7438 if cursor.field_name().is_none()
7439 && cursor.node().is_named()
7440 && !cursor.node().is_extra()
7441 {
7442 result.push(cursor.node());
7443 }
7444 if !cursor.goto_next_sibling() {
7445 break;
7446 }
7447 }
7448 }
7449 result
7450 };
7451 let child = if let Some(&c) = non_field_children.first() {
7452 c
7453 } else {
7454 let mut fallback_cursor = node.walk();
7455 let mut fallback_child = None;
7456 if fallback_cursor.goto_first_child() {
7457 loop {
7458 if fallback_cursor.field_name().is_none()
7459 && !fallback_cursor.node().is_extra()
7460 {
7461 let candidate = fallback_cursor.node();
7462 #[allow(clippy::needless_question_mark)]
7463 if (|| -> ::core::result::Result<
7464 _,
7465 ::treesitter_types::ParseError,
7466 > {
7467 let child = candidate;
7468 Ok(
7469 <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7470 child,
7471 src,
7472 )?,
7473 )
7474 })()
7475 .is_ok()
7476 {
7477 fallback_child = Some(candidate);
7478 break;
7479 }
7480 }
7481 if !fallback_cursor.goto_next_sibling() {
7482 break;
7483 }
7484 }
7485 }
7486 if fallback_child.is_none() {
7487 let mut cursor2 = node.walk();
7488 if cursor2.goto_first_child() {
7489 loop {
7490 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7491 let candidate = cursor2.node();
7492 #[allow(clippy::needless_question_mark)]
7493 if (|| -> ::core::result::Result<
7494 _,
7495 ::treesitter_types::ParseError,
7496 > {
7497 let child = candidate;
7498 Ok(
7499 <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(
7500 child,
7501 src,
7502 )?,
7503 )
7504 })()
7505 .is_ok()
7506 {
7507 fallback_child = Some(candidate);
7508 break;
7509 }
7510 }
7511 if !cursor2.goto_next_sibling() {
7512 break;
7513 }
7514 }
7515 }
7516 }
7517 fallback_child.ok_or_else(|| {
7518 ::treesitter_types::ParseError::missing_field("children", node)
7519 })?
7520 };
7521 <QuotedExpressionChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7522 },
7523 })
7524 }
7525}
7526impl ::treesitter_types::Spanned for QuotedExpression<'_> {
7527 fn span(&self) -> ::treesitter_types::Span {
7528 self.span
7529 }
7530}
7531#[derive(Debug, Clone, PartialEq, Eq)]
7532pub struct QuotedPattern<'tree> {
7533 pub span: ::treesitter_types::Span,
7534 pub children: QuotedPatternChildren<'tree>,
7535}
7536impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedPattern<'tree> {
7537 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7538 fn from_node(
7539 node: ::tree_sitter::Node<'tree>,
7540 src: &'tree [u8],
7541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7542 debug_assert_eq!(node.kind(), "quoted_pattern");
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 <QuotedPatternChildren 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 <QuotedPatternChildren 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 <QuotedPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7636 },
7637 })
7638 }
7639}
7640impl ::treesitter_types::Spanned for QuotedPattern<'_> {
7641 fn span(&self) -> ::treesitter_types::Span {
7642 self.span
7643 }
7644}
7645#[derive(Debug, Clone, PartialEq, Eq)]
7646pub struct QuotedType<'tree> {
7647 pub span: ::treesitter_types::Span,
7648 pub children: QuotedTypeChildren<'tree>,
7649}
7650impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedType<'tree> {
7651 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7652 fn from_node(
7653 node: ::tree_sitter::Node<'tree>,
7654 src: &'tree [u8],
7655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7656 debug_assert_eq!(node.kind(), "quoted_type");
7657 Ok(Self {
7658 span: ::treesitter_types::Span::from(node),
7659 children: {
7660 #[allow(clippy::suspicious_else_formatting)]
7661 let non_field_children = {
7662 let mut cursor = node.walk();
7663 let mut result = ::std::vec::Vec::new();
7664 if cursor.goto_first_child() {
7665 loop {
7666 if cursor.field_name().is_none()
7667 && cursor.node().is_named()
7668 && !cursor.node().is_extra()
7669 {
7670 result.push(cursor.node());
7671 }
7672 if !cursor.goto_next_sibling() {
7673 break;
7674 }
7675 }
7676 }
7677 result
7678 };
7679 let child = if let Some(&c) = non_field_children.first() {
7680 c
7681 } else {
7682 let mut fallback_cursor = node.walk();
7683 let mut fallback_child = None;
7684 if fallback_cursor.goto_first_child() {
7685 loop {
7686 if fallback_cursor.field_name().is_none()
7687 && !fallback_cursor.node().is_extra()
7688 {
7689 let candidate = fallback_cursor.node();
7690 #[allow(clippy::needless_question_mark)]
7691 if (|| -> ::core::result::Result<
7692 _,
7693 ::treesitter_types::ParseError,
7694 > {
7695 let child = candidate;
7696 Ok(
7697 <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(
7698 child,
7699 src,
7700 )?,
7701 )
7702 })()
7703 .is_ok()
7704 {
7705 fallback_child = Some(candidate);
7706 break;
7707 }
7708 }
7709 if !fallback_cursor.goto_next_sibling() {
7710 break;
7711 }
7712 }
7713 }
7714 if fallback_child.is_none() {
7715 let mut cursor2 = node.walk();
7716 if cursor2.goto_first_child() {
7717 loop {
7718 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7719 let candidate = cursor2.node();
7720 #[allow(clippy::needless_question_mark)]
7721 if (|| -> ::core::result::Result<
7722 _,
7723 ::treesitter_types::ParseError,
7724 > {
7725 let child = candidate;
7726 Ok(
7727 <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(
7728 child,
7729 src,
7730 )?,
7731 )
7732 })()
7733 .is_ok()
7734 {
7735 fallback_child = Some(candidate);
7736 break;
7737 }
7738 }
7739 if !cursor2.goto_next_sibling() {
7740 break;
7741 }
7742 }
7743 }
7744 }
7745 fallback_child.ok_or_else(|| {
7746 ::treesitter_types::ParseError::missing_field("children", node)
7747 })?
7748 };
7749 <QuotedTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7750 },
7751 })
7752 }
7753}
7754impl ::treesitter_types::Spanned for QuotedType<'_> {
7755 fn span(&self) -> ::treesitter_types::Span {
7756 self.span
7757 }
7758}
7759#[derive(Debug, Clone, PartialEq, Eq)]
7760pub struct Quoter<'tree> {
7761 pub span: ::treesitter_types::Span,
7762 pub children: QuoterChildren<'tree>,
7763}
7764impl<'tree> ::treesitter_types::FromNode<'tree> for Quoter<'tree> {
7765 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7766 fn from_node(
7767 node: ::tree_sitter::Node<'tree>,
7768 src: &'tree [u8],
7769 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7770 debug_assert_eq!(node.kind(), "quoter");
7771 Ok(Self {
7772 span: ::treesitter_types::Span::from(node),
7773 children: {
7774 #[allow(clippy::suspicious_else_formatting)]
7775 let non_field_children = {
7776 let mut cursor = node.walk();
7777 let mut result = ::std::vec::Vec::new();
7778 if cursor.goto_first_child() {
7779 loop {
7780 if cursor.field_name().is_none()
7781 && cursor.node().is_named()
7782 && !cursor.node().is_extra()
7783 {
7784 result.push(cursor.node());
7785 }
7786 if !cursor.goto_next_sibling() {
7787 break;
7788 }
7789 }
7790 }
7791 result
7792 };
7793 let child = if let Some(&c) = non_field_children.first() {
7794 c
7795 } else {
7796 let mut fallback_cursor = node.walk();
7797 let mut fallback_child = None;
7798 if fallback_cursor.goto_first_child() {
7799 loop {
7800 if fallback_cursor.field_name().is_none()
7801 && !fallback_cursor.node().is_extra()
7802 {
7803 let candidate = fallback_cursor.node();
7804 #[allow(clippy::needless_question_mark)]
7805 if (|| -> ::core::result::Result<
7806 _,
7807 ::treesitter_types::ParseError,
7808 > {
7809 let child = candidate;
7810 Ok(
7811 <QuoterChildren as ::treesitter_types::FromNode>::from_node(
7812 child,
7813 src,
7814 )?,
7815 )
7816 })()
7817 .is_ok()
7818 {
7819 fallback_child = Some(candidate);
7820 break;
7821 }
7822 }
7823 if !fallback_cursor.goto_next_sibling() {
7824 break;
7825 }
7826 }
7827 }
7828 if fallback_child.is_none() {
7829 let mut cursor2 = node.walk();
7830 if cursor2.goto_first_child() {
7831 loop {
7832 if cursor2.node().is_named() && !cursor2.node().is_extra() {
7833 let candidate = cursor2.node();
7834 #[allow(clippy::needless_question_mark)]
7835 if (|| -> ::core::result::Result<
7836 _,
7837 ::treesitter_types::ParseError,
7838 > {
7839 let child = candidate;
7840 Ok(
7841 <QuoterChildren as ::treesitter_types::FromNode>::from_node(
7842 child,
7843 src,
7844 )?,
7845 )
7846 })()
7847 .is_ok()
7848 {
7849 fallback_child = Some(candidate);
7850 break;
7851 }
7852 }
7853 if !cursor2.goto_next_sibling() {
7854 break;
7855 }
7856 }
7857 }
7858 }
7859 fallback_child.ok_or_else(|| {
7860 ::treesitter_types::ParseError::missing_field("children", node)
7861 })?
7862 };
7863 <QuoterChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7864 },
7865 })
7866 }
7867}
7868impl ::treesitter_types::Spanned for Quoter<'_> {
7869 fn span(&self) -> ::treesitter_types::Span {
7870 self.span
7871 }
7872}
7873#[derive(Debug, Clone, PartialEq, Eq)]
7874pub struct Rec<'tree> {
7875 pub span: ::treesitter_types::Span,
7876 pub statement: ::std::vec::Vec<Statement<'tree>>,
7877}
7878impl<'tree> ::treesitter_types::FromNode<'tree> for Rec<'tree> {
7879 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7880 fn from_node(
7881 node: ::tree_sitter::Node<'tree>,
7882 src: &'tree [u8],
7883 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7884 debug_assert_eq!(node.kind(), "rec");
7885 Ok(Self {
7886 span: ::treesitter_types::Span::from(node),
7887 statement: {
7888 let mut cursor = node.walk();
7889 let mut items = ::std::vec::Vec::new();
7890 for child in node.children_by_field_name("statement", &mut cursor) {
7891 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
7892 child, src,
7893 )?);
7894 }
7895 items
7896 },
7897 })
7898 }
7899}
7900impl ::treesitter_types::Spanned for Rec<'_> {
7901 fn span(&self) -> ::treesitter_types::Span {
7902 self.span
7903 }
7904}
7905#[derive(Debug, Clone, PartialEq, Eq)]
7906pub struct Record<'tree> {
7907 pub span: ::treesitter_types::Span,
7908 pub arrow: ::std::vec::Vec<RecordArrow>,
7909 pub constructor: ::core::option::Option<Pattern<'tree>>,
7910 pub expression: ::core::option::Option<Expression<'tree>>,
7911 pub field: ::std::vec::Vec<RecordField<'tree>>,
7912 pub fields: ::core::option::Option<Fields<'tree>>,
7913 pub name: ::core::option::Option<Constructor<'tree>>,
7914 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
7915}
7916impl<'tree> ::treesitter_types::FromNode<'tree> for Record<'tree> {
7917 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7918 fn from_node(
7919 node: ::tree_sitter::Node<'tree>,
7920 src: &'tree [u8],
7921 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7922 debug_assert_eq!(node.kind(), "record");
7923 Ok(Self {
7924 span: ::treesitter_types::Span::from(node),
7925 arrow: {
7926 let mut cursor = node.walk();
7927 let mut items = ::std::vec::Vec::new();
7928 for child in node.children_by_field_name("arrow", &mut cursor) {
7929 items.push(<RecordArrow as ::treesitter_types::FromNode>::from_node(
7930 child, src,
7931 )?);
7932 }
7933 items
7934 },
7935 constructor: match node.child_by_field_name("constructor") {
7936 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
7937 child, src,
7938 )?),
7939 None => None,
7940 },
7941 expression: match node.child_by_field_name("expression") {
7942 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
7943 child, src,
7944 )?),
7945 None => None,
7946 },
7947 field: {
7948 let mut cursor = node.walk();
7949 let mut items = ::std::vec::Vec::new();
7950 for child in node.children_by_field_name("field", &mut cursor) {
7951 items.push(<RecordField as ::treesitter_types::FromNode>::from_node(
7952 child, src,
7953 )?);
7954 }
7955 items
7956 },
7957 fields: match node.child_by_field_name("fields") {
7958 Some(child) => Some(<Fields as ::treesitter_types::FromNode>::from_node(
7959 child, src,
7960 )?),
7961 None => None,
7962 },
7963 name: match node.child_by_field_name("name") {
7964 Some(child) => Some(<Constructor as ::treesitter_types::FromNode>::from_node(
7965 child, src,
7966 )?),
7967 None => None,
7968 },
7969 r#type: match node.child_by_field_name("type") {
7970 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
7971 child, src,
7972 )?),
7973 None => None,
7974 },
7975 })
7976 }
7977}
7978impl ::treesitter_types::Spanned for Record<'_> {
7979 fn span(&self) -> ::treesitter_types::Span {
7980 self.span
7981 }
7982}
7983#[derive(Debug, Clone, PartialEq, Eq)]
7984pub struct RightSection<'tree> {
7985 pub span: ::treesitter_types::Span,
7986 pub right_operand: Expression<'tree>,
7987 pub children: RightSectionChildren<'tree>,
7988}
7989impl<'tree> ::treesitter_types::FromNode<'tree> for RightSection<'tree> {
7990 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7991 fn from_node(
7992 node: ::tree_sitter::Node<'tree>,
7993 src: &'tree [u8],
7994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7995 debug_assert_eq!(node.kind(), "right_section");
7996 Ok(Self {
7997 span: ::treesitter_types::Span::from(node),
7998 right_operand: {
7999 let child = node.child_by_field_name("right_operand").ok_or_else(|| {
8000 ::treesitter_types::ParseError::missing_field("right_operand", node)
8001 })?;
8002 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8003 },
8004 children: {
8005 #[allow(clippy::suspicious_else_formatting)]
8006 let non_field_children = {
8007 let mut cursor = node.walk();
8008 let mut result = ::std::vec::Vec::new();
8009 if cursor.goto_first_child() {
8010 loop {
8011 if cursor.field_name().is_none()
8012 && cursor.node().is_named()
8013 && !cursor.node().is_extra()
8014 {
8015 result.push(cursor.node());
8016 }
8017 if !cursor.goto_next_sibling() {
8018 break;
8019 }
8020 }
8021 }
8022 result
8023 };
8024 let child = if let Some(&c) = non_field_children.first() {
8025 c
8026 } else {
8027 let mut fallback_cursor = node.walk();
8028 let mut fallback_child = None;
8029 if fallback_cursor.goto_first_child() {
8030 loop {
8031 if fallback_cursor.field_name().is_none()
8032 && !fallback_cursor.node().is_extra()
8033 {
8034 let candidate = fallback_cursor.node();
8035 #[allow(clippy::needless_question_mark)]
8036 if (|| -> ::core::result::Result<
8037 _,
8038 ::treesitter_types::ParseError,
8039 > {
8040 let child = candidate;
8041 Ok(
8042 <RightSectionChildren as ::treesitter_types::FromNode>::from_node(
8043 child,
8044 src,
8045 )?,
8046 )
8047 })()
8048 .is_ok()
8049 {
8050 fallback_child = Some(candidate);
8051 break;
8052 }
8053 }
8054 if !fallback_cursor.goto_next_sibling() {
8055 break;
8056 }
8057 }
8058 }
8059 if fallback_child.is_none() {
8060 let mut cursor2 = node.walk();
8061 if cursor2.goto_first_child() {
8062 loop {
8063 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8064 let candidate = cursor2.node();
8065 #[allow(clippy::needless_question_mark)]
8066 if (|| -> ::core::result::Result<
8067 _,
8068 ::treesitter_types::ParseError,
8069 > {
8070 let child = candidate;
8071 Ok(
8072 <RightSectionChildren as ::treesitter_types::FromNode>::from_node(
8073 child,
8074 src,
8075 )?,
8076 )
8077 })()
8078 .is_ok()
8079 {
8080 fallback_child = Some(candidate);
8081 break;
8082 }
8083 }
8084 if !cursor2.goto_next_sibling() {
8085 break;
8086 }
8087 }
8088 }
8089 }
8090 fallback_child.ok_or_else(|| {
8091 ::treesitter_types::ParseError::missing_field("children", node)
8092 })?
8093 };
8094 <RightSectionChildren as ::treesitter_types::FromNode>::from_node(child, src)?
8095 },
8096 })
8097 }
8098}
8099impl ::treesitter_types::Spanned for RightSection<'_> {
8100 fn span(&self) -> ::treesitter_types::Span {
8101 self.span
8102 }
8103}
8104#[derive(Debug, Clone, PartialEq, Eq)]
8105pub struct RoleAnnotation<'tree> {
8106 pub span: ::treesitter_types::Span,
8107 pub role: ::std::vec::Vec<TypeRole<'tree>>,
8108 pub r#type: RoleAnnotationType<'tree>,
8109}
8110impl<'tree> ::treesitter_types::FromNode<'tree> for RoleAnnotation<'tree> {
8111 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8112 fn from_node(
8113 node: ::tree_sitter::Node<'tree>,
8114 src: &'tree [u8],
8115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8116 debug_assert_eq!(node.kind(), "role_annotation");
8117 Ok(Self {
8118 span: ::treesitter_types::Span::from(node),
8119 role: {
8120 let mut cursor = node.walk();
8121 let mut items = ::std::vec::Vec::new();
8122 for child in node.children_by_field_name("role", &mut cursor) {
8123 items.push(<TypeRole as ::treesitter_types::FromNode>::from_node(
8124 child, src,
8125 )?);
8126 }
8127 items
8128 },
8129 r#type: {
8130 let child = node
8131 .child_by_field_name("type")
8132 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8133 <RoleAnnotationType as ::treesitter_types::FromNode>::from_node(child, src)?
8134 },
8135 })
8136 }
8137}
8138impl ::treesitter_types::Spanned for RoleAnnotation<'_> {
8139 fn span(&self) -> ::treesitter_types::Span {
8140 self.span
8141 }
8142}
8143#[derive(Debug, Clone, PartialEq, Eq)]
8144pub struct Signature<'tree> {
8145 pub span: ::treesitter_types::Span,
8146 pub constraint: ::core::option::Option<Constraints<'tree>>,
8147 pub expression: ::core::option::Option<Expression<'tree>>,
8148 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
8149 pub name: ::core::option::Option<SignatureName<'tree>>,
8150 pub names: ::core::option::Option<BindingList<'tree>>,
8151 pub pattern: ::core::option::Option<Pattern<'tree>>,
8152 pub synonym: ::core::option::Option<SignatureSynonym<'tree>>,
8153 pub r#type: ::core::option::Option<QuantifiedType<'tree>>,
8154}
8155impl<'tree> ::treesitter_types::FromNode<'tree> for Signature<'tree> {
8156 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8157 fn from_node(
8158 node: ::tree_sitter::Node<'tree>,
8159 src: &'tree [u8],
8160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8161 debug_assert_eq!(node.kind(), "signature");
8162 Ok(Self {
8163 span: ::treesitter_types::Span::from(node),
8164 constraint: match node.child_by_field_name("constraint") {
8165 Some(child) => Some(<Constraints as ::treesitter_types::FromNode>::from_node(
8166 child, src,
8167 )?),
8168 None => None,
8169 },
8170 expression: match node.child_by_field_name("expression") {
8171 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
8172 child, src,
8173 )?),
8174 None => None,
8175 },
8176 kind: match node.child_by_field_name("kind") {
8177 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
8178 child, src,
8179 )?),
8180 None => None,
8181 },
8182 name: match node.child_by_field_name("name") {
8183 Some(child) => Some(<SignatureName as ::treesitter_types::FromNode>::from_node(
8184 child, src,
8185 )?),
8186 None => None,
8187 },
8188 names: match node.child_by_field_name("names") {
8189 Some(child) => Some(<BindingList as ::treesitter_types::FromNode>::from_node(
8190 child, src,
8191 )?),
8192 None => None,
8193 },
8194 pattern: match node.child_by_field_name("pattern") {
8195 Some(child) => Some(<Pattern as ::treesitter_types::FromNode>::from_node(
8196 child, src,
8197 )?),
8198 None => None,
8199 },
8200 synonym: match node.child_by_field_name("synonym") {
8201 Some(child) => {
8202 Some(<SignatureSynonym as ::treesitter_types::FromNode>::from_node(child, src)?)
8203 }
8204 None => None,
8205 },
8206 r#type: match node.child_by_field_name("type") {
8207 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
8208 child, src,
8209 )?),
8210 None => None,
8211 },
8212 })
8213 }
8214}
8215impl ::treesitter_types::Spanned for Signature<'_> {
8216 fn span(&self) -> ::treesitter_types::Span {
8217 self.span
8218 }
8219}
8220#[derive(Debug, Clone, PartialEq, Eq)]
8221pub struct Special<'tree> {
8222 pub span: ::treesitter_types::Span,
8223 pub children: SpecialChildren<'tree>,
8224}
8225impl<'tree> ::treesitter_types::FromNode<'tree> for Special<'tree> {
8226 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8227 fn from_node(
8228 node: ::tree_sitter::Node<'tree>,
8229 src: &'tree [u8],
8230 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8231 debug_assert_eq!(node.kind(), "special");
8232 Ok(Self {
8233 span: ::treesitter_types::Span::from(node),
8234 children: {
8235 #[allow(clippy::suspicious_else_formatting)]
8236 let non_field_children = {
8237 let mut cursor = node.walk();
8238 let mut result = ::std::vec::Vec::new();
8239 if cursor.goto_first_child() {
8240 loop {
8241 if cursor.field_name().is_none()
8242 && cursor.node().is_named()
8243 && !cursor.node().is_extra()
8244 {
8245 result.push(cursor.node());
8246 }
8247 if !cursor.goto_next_sibling() {
8248 break;
8249 }
8250 }
8251 }
8252 result
8253 };
8254 let child = if let Some(&c) = non_field_children.first() {
8255 c
8256 } else {
8257 let mut fallback_cursor = node.walk();
8258 let mut fallback_child = None;
8259 if fallback_cursor.goto_first_child() {
8260 loop {
8261 if fallback_cursor.field_name().is_none()
8262 && !fallback_cursor.node().is_extra()
8263 {
8264 let candidate = fallback_cursor.node();
8265 #[allow(clippy::needless_question_mark)]
8266 if (|| -> ::core::result::Result<
8267 _,
8268 ::treesitter_types::ParseError,
8269 > {
8270 let child = candidate;
8271 Ok(
8272 <SpecialChildren as ::treesitter_types::FromNode>::from_node(
8273 child,
8274 src,
8275 )?,
8276 )
8277 })()
8278 .is_ok()
8279 {
8280 fallback_child = Some(candidate);
8281 break;
8282 }
8283 }
8284 if !fallback_cursor.goto_next_sibling() {
8285 break;
8286 }
8287 }
8288 }
8289 if fallback_child.is_none() {
8290 let mut cursor2 = node.walk();
8291 if cursor2.goto_first_child() {
8292 loop {
8293 if cursor2.node().is_named() && !cursor2.node().is_extra() {
8294 let candidate = cursor2.node();
8295 #[allow(clippy::needless_question_mark)]
8296 if (|| -> ::core::result::Result<
8297 _,
8298 ::treesitter_types::ParseError,
8299 > {
8300 let child = candidate;
8301 Ok(
8302 <SpecialChildren as ::treesitter_types::FromNode>::from_node(
8303 child,
8304 src,
8305 )?,
8306 )
8307 })()
8308 .is_ok()
8309 {
8310 fallback_child = Some(candidate);
8311 break;
8312 }
8313 }
8314 if !cursor2.goto_next_sibling() {
8315 break;
8316 }
8317 }
8318 }
8319 }
8320 fallback_child.ok_or_else(|| {
8321 ::treesitter_types::ParseError::missing_field("children", node)
8322 })?
8323 };
8324 <SpecialChildren as ::treesitter_types::FromNode>::from_node(child, src)?
8325 },
8326 })
8327 }
8328}
8329impl ::treesitter_types::Spanned for Special<'_> {
8330 fn span(&self) -> ::treesitter_types::Span {
8331 self.span
8332 }
8333}
8334#[derive(Debug, Clone, PartialEq, Eq)]
8335pub struct Splice<'tree> {
8336 pub span: ::treesitter_types::Span,
8337 pub expression: SpliceExpression<'tree>,
8338}
8339impl<'tree> ::treesitter_types::FromNode<'tree> for Splice<'tree> {
8340 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8341 fn from_node(
8342 node: ::tree_sitter::Node<'tree>,
8343 src: &'tree [u8],
8344 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8345 debug_assert_eq!(node.kind(), "splice");
8346 Ok(Self {
8347 span: ::treesitter_types::Span::from(node),
8348 expression: {
8349 let child = node.child_by_field_name("expression").ok_or_else(|| {
8350 ::treesitter_types::ParseError::missing_field("expression", node)
8351 })?;
8352 <SpliceExpression as ::treesitter_types::FromNode>::from_node(child, src)?
8353 },
8354 })
8355 }
8356}
8357impl ::treesitter_types::Spanned for Splice<'_> {
8358 fn span(&self) -> ::treesitter_types::Span {
8359 self.span
8360 }
8361}
8362#[derive(Debug, Clone, PartialEq, Eq)]
8363pub struct Star<'tree> {
8364 pub span: ::treesitter_types::Span,
8365 text: &'tree str,
8366}
8367impl<'tree> ::treesitter_types::FromNode<'tree> for Star<'tree> {
8368 fn from_node(
8369 node: ::tree_sitter::Node<'tree>,
8370 src: &'tree [u8],
8371 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8372 debug_assert_eq!(node.kind(), "star");
8373 Ok(Self {
8374 span: ::treesitter_types::Span::from(node),
8375 text: node.utf8_text(src)?,
8376 })
8377 }
8378}
8379impl<'tree> ::treesitter_types::LeafNode<'tree> for Star<'tree> {
8380 fn text(&self) -> &'tree str {
8381 self.text
8382 }
8383}
8384impl ::treesitter_types::Spanned for Star<'_> {
8385 fn span(&self) -> ::treesitter_types::Span {
8386 self.span
8387 }
8388}
8389#[derive(Debug, Clone, PartialEq, Eq)]
8390pub struct Strict<'tree> {
8391 pub span: ::treesitter_types::Span,
8392 pub pattern: Pattern<'tree>,
8393}
8394impl<'tree> ::treesitter_types::FromNode<'tree> for Strict<'tree> {
8395 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8396 fn from_node(
8397 node: ::tree_sitter::Node<'tree>,
8398 src: &'tree [u8],
8399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8400 debug_assert_eq!(node.kind(), "strict");
8401 Ok(Self {
8402 span: ::treesitter_types::Span::from(node),
8403 pattern: {
8404 let child = node.child_by_field_name("pattern").ok_or_else(|| {
8405 ::treesitter_types::ParseError::missing_field("pattern", node)
8406 })?;
8407 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
8408 },
8409 })
8410 }
8411}
8412impl ::treesitter_types::Spanned for Strict<'_> {
8413 fn span(&self) -> ::treesitter_types::Span {
8414 self.span
8415 }
8416}
8417#[derive(Debug, Clone, PartialEq, Eq)]
8418pub struct StrictField<'tree> {
8419 pub span: ::treesitter_types::Span,
8420 pub r#type: Type<'tree>,
8421}
8422impl<'tree> ::treesitter_types::FromNode<'tree> for StrictField<'tree> {
8423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8424 fn from_node(
8425 node: ::tree_sitter::Node<'tree>,
8426 src: &'tree [u8],
8427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8428 debug_assert_eq!(node.kind(), "strict_field");
8429 Ok(Self {
8430 span: ::treesitter_types::Span::from(node),
8431 r#type: {
8432 let child = node
8433 .child_by_field_name("type")
8434 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8435 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8436 },
8437 })
8438 }
8439}
8440impl ::treesitter_types::Spanned for StrictField<'_> {
8441 fn span(&self) -> ::treesitter_types::Span {
8442 self.span
8443 }
8444}
8445#[derive(Debug, Clone, PartialEq, Eq)]
8446pub struct ThQuotedName<'tree> {
8447 pub span: ::treesitter_types::Span,
8448 pub name: ::core::option::Option<ThQuotedNameName<'tree>>,
8449 pub r#type: ::core::option::Option<Type<'tree>>,
8450}
8451impl<'tree> ::treesitter_types::FromNode<'tree> for ThQuotedName<'tree> {
8452 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8453 fn from_node(
8454 node: ::tree_sitter::Node<'tree>,
8455 src: &'tree [u8],
8456 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8457 debug_assert_eq!(node.kind(), "th_quoted_name");
8458 Ok(Self {
8459 span: ::treesitter_types::Span::from(node),
8460 name: match node.child_by_field_name("name") {
8461 Some(child) => {
8462 Some(<ThQuotedNameName as ::treesitter_types::FromNode>::from_node(child, src)?)
8463 }
8464 None => None,
8465 },
8466 r#type: match node.child_by_field_name("type") {
8467 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
8468 child, src,
8469 )?),
8470 None => None,
8471 },
8472 })
8473 }
8474}
8475impl ::treesitter_types::Spanned for ThQuotedName<'_> {
8476 fn span(&self) -> ::treesitter_types::Span {
8477 self.span
8478 }
8479}
8480#[derive(Debug, Clone, PartialEq, Eq)]
8481pub struct TopSplice<'tree> {
8482 pub span: ::treesitter_types::Span,
8483 pub children: Expression<'tree>,
8484}
8485impl<'tree> ::treesitter_types::FromNode<'tree> for TopSplice<'tree> {
8486 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8487 fn from_node(
8488 node: ::tree_sitter::Node<'tree>,
8489 src: &'tree [u8],
8490 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8491 debug_assert_eq!(node.kind(), "top_splice");
8492 Ok(Self {
8493 span: ::treesitter_types::Span::from(node),
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 <Expression 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 <Expression 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 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8585 },
8586 })
8587 }
8588}
8589impl ::treesitter_types::Spanned for TopSplice<'_> {
8590 fn span(&self) -> ::treesitter_types::Span {
8591 self.span
8592 }
8593}
8594#[derive(Debug, Clone, PartialEq, Eq)]
8595pub struct Transform<'tree> {
8596 pub span: ::treesitter_types::Span,
8597 pub key: ::core::option::Option<TransformKey<'tree>>,
8598 pub transformation: TransformTransformation<'tree>,
8599}
8600impl<'tree> ::treesitter_types::FromNode<'tree> for Transform<'tree> {
8601 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8602 fn from_node(
8603 node: ::tree_sitter::Node<'tree>,
8604 src: &'tree [u8],
8605 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8606 debug_assert_eq!(node.kind(), "transform");
8607 Ok(Self {
8608 span: ::treesitter_types::Span::from(node),
8609 key: match node.child_by_field_name("key") {
8610 Some(child) => Some(<TransformKey as ::treesitter_types::FromNode>::from_node(
8611 child, src,
8612 )?),
8613 None => None,
8614 },
8615 transformation: {
8616 let child = node.child_by_field_name("transformation").ok_or_else(|| {
8617 ::treesitter_types::ParseError::missing_field("transformation", node)
8618 })?;
8619 <TransformTransformation as ::treesitter_types::FromNode>::from_node(child, src)?
8620 },
8621 })
8622 }
8623}
8624impl ::treesitter_types::Spanned for Transform<'_> {
8625 fn span(&self) -> ::treesitter_types::Span {
8626 self.span
8627 }
8628}
8629#[derive(Debug, Clone, PartialEq, Eq)]
8630pub struct Tuple<'tree> {
8631 pub span: ::treesitter_types::Span,
8632 pub element: ::std::vec::Vec<TupleElement<'tree>>,
8633 pub children: ::std::vec::Vec<Constraints<'tree>>,
8634}
8635impl<'tree> ::treesitter_types::FromNode<'tree> for Tuple<'tree> {
8636 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8637 fn from_node(
8638 node: ::tree_sitter::Node<'tree>,
8639 src: &'tree [u8],
8640 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8641 debug_assert_eq!(node.kind(), "tuple");
8642 Ok(Self {
8643 span: ::treesitter_types::Span::from(node),
8644 element: {
8645 let mut cursor = node.walk();
8646 let mut items = ::std::vec::Vec::new();
8647 for child in node.children_by_field_name("element", &mut cursor) {
8648 items.push(<TupleElement as ::treesitter_types::FromNode>::from_node(
8649 child, src,
8650 )?);
8651 }
8652 items
8653 },
8654 children: {
8655 #[allow(clippy::suspicious_else_formatting)]
8656 let non_field_children = {
8657 let mut cursor = node.walk();
8658 let mut result = ::std::vec::Vec::new();
8659 if cursor.goto_first_child() {
8660 loop {
8661 if cursor.field_name().is_none()
8662 && cursor.node().is_named()
8663 && !cursor.node().is_extra()
8664 {
8665 result.push(cursor.node());
8666 }
8667 if !cursor.goto_next_sibling() {
8668 break;
8669 }
8670 }
8671 }
8672 result
8673 };
8674 let mut items = ::std::vec::Vec::new();
8675 for child in non_field_children {
8676 items.push(<Constraints as ::treesitter_types::FromNode>::from_node(
8677 child, src,
8678 )?);
8679 }
8680 items
8681 },
8682 })
8683 }
8684}
8685impl ::treesitter_types::Spanned for Tuple<'_> {
8686 fn span(&self) -> ::treesitter_types::Span {
8687 self.span
8688 }
8689}
8690#[derive(Debug, Clone, PartialEq, Eq)]
8691pub struct TypeApplication<'tree> {
8692 pub span: ::treesitter_types::Span,
8693 pub r#type: Type<'tree>,
8694}
8695impl<'tree> ::treesitter_types::FromNode<'tree> for TypeApplication<'tree> {
8696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8697 fn from_node(
8698 node: ::tree_sitter::Node<'tree>,
8699 src: &'tree [u8],
8700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8701 debug_assert_eq!(node.kind(), "type_application");
8702 Ok(Self {
8703 span: ::treesitter_types::Span::from(node),
8704 r#type: {
8705 let child = node
8706 .child_by_field_name("type")
8707 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8708 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8709 },
8710 })
8711 }
8712}
8713impl ::treesitter_types::Spanned for TypeApplication<'_> {
8714 fn span(&self) -> ::treesitter_types::Span {
8715 self.span
8716 }
8717}
8718#[derive(Debug, Clone, PartialEq, Eq)]
8719pub struct TypeBinder<'tree> {
8720 pub span: ::treesitter_types::Span,
8721 pub r#type: Type<'tree>,
8722}
8723impl<'tree> ::treesitter_types::FromNode<'tree> for TypeBinder<'tree> {
8724 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8725 fn from_node(
8726 node: ::tree_sitter::Node<'tree>,
8727 src: &'tree [u8],
8728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8729 debug_assert_eq!(node.kind(), "type_binder");
8730 Ok(Self {
8731 span: ::treesitter_types::Span::from(node),
8732 r#type: {
8733 let child = node
8734 .child_by_field_name("type")
8735 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8736 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8737 },
8738 })
8739 }
8740}
8741impl ::treesitter_types::Spanned for TypeBinder<'_> {
8742 fn span(&self) -> ::treesitter_types::Span {
8743 self.span
8744 }
8745}
8746#[derive(Debug, Clone, PartialEq, Eq)]
8747pub struct TypeFamily<'tree> {
8748 pub span: ::treesitter_types::Span,
8749 pub closed_family: ::core::option::Option<TypeFamilyClosedFamily<'tree>>,
8750 pub kind: ::core::option::Option<QuantifiedType<'tree>>,
8751 pub name: ::core::option::Option<TypeFamilyName<'tree>>,
8752 pub patterns: ::core::option::Option<TypeParams<'tree>>,
8753 pub children: ::std::vec::Vec<TypeFamilyChildren<'tree>>,
8754}
8755impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamily<'tree> {
8756 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8757 fn from_node(
8758 node: ::tree_sitter::Node<'tree>,
8759 src: &'tree [u8],
8760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8761 debug_assert_eq!(node.kind(), "type_family");
8762 Ok(Self {
8763 span: ::treesitter_types::Span::from(node),
8764 closed_family: match node.child_by_field_name("closed_family") {
8765 Some(child) => Some(
8766 <TypeFamilyClosedFamily as ::treesitter_types::FromNode>::from_node(
8767 child, src,
8768 )?,
8769 ),
8770 None => None,
8771 },
8772 kind: match node.child_by_field_name("kind") {
8773 Some(child) => Some(<QuantifiedType as ::treesitter_types::FromNode>::from_node(
8774 child, src,
8775 )?),
8776 None => None,
8777 },
8778 name: match node.child_by_field_name("name") {
8779 Some(child) => Some(<TypeFamilyName as ::treesitter_types::FromNode>::from_node(
8780 child, src,
8781 )?),
8782 None => None,
8783 },
8784 patterns: match node.child_by_field_name("patterns") {
8785 Some(child) => Some(<TypeParams as ::treesitter_types::FromNode>::from_node(
8786 child, src,
8787 )?),
8788 None => None,
8789 },
8790 children: {
8791 #[allow(clippy::suspicious_else_formatting)]
8792 let non_field_children = {
8793 let mut cursor = node.walk();
8794 let mut result = ::std::vec::Vec::new();
8795 if cursor.goto_first_child() {
8796 loop {
8797 if cursor.field_name().is_none()
8798 && cursor.node().is_named()
8799 && !cursor.node().is_extra()
8800 {
8801 result.push(cursor.node());
8802 }
8803 if !cursor.goto_next_sibling() {
8804 break;
8805 }
8806 }
8807 }
8808 result
8809 };
8810 let mut items = ::std::vec::Vec::new();
8811 for child in non_field_children {
8812 items.push(
8813 <TypeFamilyChildren as ::treesitter_types::FromNode>::from_node(
8814 child, src,
8815 )?,
8816 );
8817 }
8818 items
8819 },
8820 })
8821 }
8822}
8823impl ::treesitter_types::Spanned for TypeFamily<'_> {
8824 fn span(&self) -> ::treesitter_types::Span {
8825 self.span
8826 }
8827}
8828#[derive(Debug, Clone, PartialEq, Eq)]
8829pub struct TypeFamilyInjectivity<'tree> {
8830 pub span: ::treesitter_types::Span,
8831 pub determined: ::std::vec::Vec<Variable<'tree>>,
8832 pub result: Variable<'tree>,
8833}
8834impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyInjectivity<'tree> {
8835 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8836 fn from_node(
8837 node: ::tree_sitter::Node<'tree>,
8838 src: &'tree [u8],
8839 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8840 debug_assert_eq!(node.kind(), "type_family_injectivity");
8841 Ok(Self {
8842 span: ::treesitter_types::Span::from(node),
8843 determined: {
8844 let mut cursor = node.walk();
8845 let mut items = ::std::vec::Vec::new();
8846 for child in node.children_by_field_name("determined", &mut cursor) {
8847 items.push(<Variable as ::treesitter_types::FromNode>::from_node(
8848 child, src,
8849 )?);
8850 }
8851 items
8852 },
8853 result: {
8854 let child = node
8855 .child_by_field_name("result")
8856 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
8857 <Variable as ::treesitter_types::FromNode>::from_node(child, src)?
8858 },
8859 })
8860 }
8861}
8862impl ::treesitter_types::Spanned for TypeFamilyInjectivity<'_> {
8863 fn span(&self) -> ::treesitter_types::Span {
8864 self.span
8865 }
8866}
8867#[derive(Debug, Clone, PartialEq, Eq)]
8868pub struct TypeFamilyResult<'tree> {
8869 pub span: ::treesitter_types::Span,
8870 pub result: QuantifiedType<'tree>,
8871}
8872impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyResult<'tree> {
8873 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8874 fn from_node(
8875 node: ::tree_sitter::Node<'tree>,
8876 src: &'tree [u8],
8877 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8878 debug_assert_eq!(node.kind(), "type_family_result");
8879 Ok(Self {
8880 span: ::treesitter_types::Span::from(node),
8881 result: {
8882 let child = node
8883 .child_by_field_name("result")
8884 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("result", node))?;
8885 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
8886 },
8887 })
8888 }
8889}
8890impl ::treesitter_types::Spanned for TypeFamilyResult<'_> {
8891 fn span(&self) -> ::treesitter_types::Span {
8892 self.span
8893 }
8894}
8895#[derive(Debug, Clone, PartialEq, Eq)]
8896pub struct TypeInstance<'tree> {
8897 pub span: ::treesitter_types::Span,
8898 pub forall: ::core::option::Option<TypeInstanceForall<'tree>>,
8899 pub name: ::core::option::Option<TypeInstanceName<'tree>>,
8900 pub patterns: ::core::option::Option<TypePatterns<'tree>>,
8901 pub children: ::std::vec::Vec<TypeInstanceChildren<'tree>>,
8902}
8903impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstance<'tree> {
8904 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8905 fn from_node(
8906 node: ::tree_sitter::Node<'tree>,
8907 src: &'tree [u8],
8908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8909 debug_assert_eq!(node.kind(), "type_instance");
8910 Ok(Self {
8911 span: ::treesitter_types::Span::from(node),
8912 forall: match node.child_by_field_name("forall") {
8913 Some(child) => Some(
8914 <TypeInstanceForall as ::treesitter_types::FromNode>::from_node(child, src)?,
8915 ),
8916 None => None,
8917 },
8918 name: match node.child_by_field_name("name") {
8919 Some(child) => {
8920 Some(<TypeInstanceName as ::treesitter_types::FromNode>::from_node(child, src)?)
8921 }
8922 None => None,
8923 },
8924 patterns: match node.child_by_field_name("patterns") {
8925 Some(child) => Some(<TypePatterns as ::treesitter_types::FromNode>::from_node(
8926 child, src,
8927 )?),
8928 None => None,
8929 },
8930 children: {
8931 #[allow(clippy::suspicious_else_formatting)]
8932 let non_field_children = {
8933 let mut cursor = node.walk();
8934 let mut result = ::std::vec::Vec::new();
8935 if cursor.goto_first_child() {
8936 loop {
8937 if cursor.field_name().is_none()
8938 && cursor.node().is_named()
8939 && !cursor.node().is_extra()
8940 {
8941 result.push(cursor.node());
8942 }
8943 if !cursor.goto_next_sibling() {
8944 break;
8945 }
8946 }
8947 }
8948 result
8949 };
8950 let mut items = ::std::vec::Vec::new();
8951 for child in non_field_children {
8952 items.push(
8953 <TypeInstanceChildren as ::treesitter_types::FromNode>::from_node(
8954 child, src,
8955 )?,
8956 );
8957 }
8958 items
8959 },
8960 })
8961 }
8962}
8963impl ::treesitter_types::Spanned for TypeInstance<'_> {
8964 fn span(&self) -> ::treesitter_types::Span {
8965 self.span
8966 }
8967}
8968#[derive(Debug, Clone, PartialEq, Eq)]
8969pub struct TypeParams<'tree> {
8970 pub span: ::treesitter_types::Span,
8971 pub children: ::std::vec::Vec<TypeParam<'tree>>,
8972}
8973impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParams<'tree> {
8974 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8975 fn from_node(
8976 node: ::tree_sitter::Node<'tree>,
8977 src: &'tree [u8],
8978 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8979 debug_assert_eq!(node.kind(), "type_params");
8980 Ok(Self {
8981 span: ::treesitter_types::Span::from(node),
8982 children: {
8983 #[allow(clippy::suspicious_else_formatting)]
8984 let non_field_children = {
8985 let mut cursor = node.walk();
8986 let mut result = ::std::vec::Vec::new();
8987 if cursor.goto_first_child() {
8988 loop {
8989 if cursor.field_name().is_none()
8990 && cursor.node().is_named()
8991 && !cursor.node().is_extra()
8992 {
8993 result.push(cursor.node());
8994 }
8995 if !cursor.goto_next_sibling() {
8996 break;
8997 }
8998 }
8999 }
9000 result
9001 };
9002 let mut items = ::std::vec::Vec::new();
9003 for child in non_field_children {
9004 items.push(<TypeParam as ::treesitter_types::FromNode>::from_node(
9005 child, src,
9006 )?);
9007 }
9008 items
9009 },
9010 })
9011 }
9012}
9013impl ::treesitter_types::Spanned for TypeParams<'_> {
9014 fn span(&self) -> ::treesitter_types::Span {
9015 self.span
9016 }
9017}
9018#[derive(Debug, Clone, PartialEq, Eq)]
9019pub struct TypePatterns<'tree> {
9020 pub span: ::treesitter_types::Span,
9021 pub children: ::std::vec::Vec<TypePatternsChildren<'tree>>,
9022}
9023impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatterns<'tree> {
9024 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9025 fn from_node(
9026 node: ::tree_sitter::Node<'tree>,
9027 src: &'tree [u8],
9028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9029 debug_assert_eq!(node.kind(), "type_patterns");
9030 Ok(Self {
9031 span: ::treesitter_types::Span::from(node),
9032 children: {
9033 #[allow(clippy::suspicious_else_formatting)]
9034 let non_field_children = {
9035 let mut cursor = node.walk();
9036 let mut result = ::std::vec::Vec::new();
9037 if cursor.goto_first_child() {
9038 loop {
9039 if cursor.field_name().is_none()
9040 && cursor.node().is_named()
9041 && !cursor.node().is_extra()
9042 {
9043 result.push(cursor.node());
9044 }
9045 if !cursor.goto_next_sibling() {
9046 break;
9047 }
9048 }
9049 }
9050 result
9051 };
9052 let mut items = ::std::vec::Vec::new();
9053 for child in non_field_children {
9054 items.push(
9055 <TypePatternsChildren as ::treesitter_types::FromNode>::from_node(
9056 child, src,
9057 )?,
9058 );
9059 }
9060 items
9061 },
9062 })
9063 }
9064}
9065impl ::treesitter_types::Spanned for TypePatterns<'_> {
9066 fn span(&self) -> ::treesitter_types::Span {
9067 self.span
9068 }
9069}
9070#[derive(Debug, Clone, PartialEq, Eq)]
9071pub struct TypeRole<'tree> {
9072 pub span: ::treesitter_types::Span,
9073 text: &'tree str,
9074}
9075impl<'tree> ::treesitter_types::FromNode<'tree> for TypeRole<'tree> {
9076 fn from_node(
9077 node: ::tree_sitter::Node<'tree>,
9078 src: &'tree [u8],
9079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9080 debug_assert_eq!(node.kind(), "type_role");
9081 Ok(Self {
9082 span: ::treesitter_types::Span::from(node),
9083 text: node.utf8_text(src)?,
9084 })
9085 }
9086}
9087impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeRole<'tree> {
9088 fn text(&self) -> &'tree str {
9089 self.text
9090 }
9091}
9092impl ::treesitter_types::Spanned for TypeRole<'_> {
9093 fn span(&self) -> ::treesitter_types::Span {
9094 self.span
9095 }
9096}
9097#[derive(Debug, Clone, PartialEq, Eq)]
9098pub struct TypeSynomym<'tree> {
9099 pub span: ::treesitter_types::Span,
9100 pub name: ::core::option::Option<TypeSynomymName<'tree>>,
9101 pub patterns: ::core::option::Option<TypeParams<'tree>>,
9102 pub r#type: TypeSynomymType<'tree>,
9103 pub children: ::core::option::Option<TypeSynomymChildren<'tree>>,
9104}
9105impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomym<'tree> {
9106 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9107 fn from_node(
9108 node: ::tree_sitter::Node<'tree>,
9109 src: &'tree [u8],
9110 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9111 debug_assert_eq!(node.kind(), "type_synomym");
9112 Ok(Self {
9113 span: ::treesitter_types::Span::from(node),
9114 name: match node.child_by_field_name("name") {
9115 Some(child) => {
9116 Some(<TypeSynomymName as ::treesitter_types::FromNode>::from_node(child, src)?)
9117 }
9118 None => None,
9119 },
9120 patterns: match node.child_by_field_name("patterns") {
9121 Some(child) => Some(<TypeParams as ::treesitter_types::FromNode>::from_node(
9122 child, src,
9123 )?),
9124 None => None,
9125 },
9126 r#type: {
9127 let child = node
9128 .child_by_field_name("type")
9129 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9130 <TypeSynomymType as ::treesitter_types::FromNode>::from_node(child, src)?
9131 },
9132 children: {
9133 #[allow(clippy::suspicious_else_formatting)]
9134 let non_field_children = {
9135 let mut cursor = node.walk();
9136 let mut result = ::std::vec::Vec::new();
9137 if cursor.goto_first_child() {
9138 loop {
9139 if cursor.field_name().is_none()
9140 && cursor.node().is_named()
9141 && !cursor.node().is_extra()
9142 {
9143 result.push(cursor.node());
9144 }
9145 if !cursor.goto_next_sibling() {
9146 break;
9147 }
9148 }
9149 }
9150 result
9151 };
9152 match non_field_children.first() {
9153 Some(&child) => Some(
9154 <TypeSynomymChildren as ::treesitter_types::FromNode>::from_node(
9155 child, src,
9156 )?,
9157 ),
9158 None => None,
9159 }
9160 },
9161 })
9162 }
9163}
9164impl ::treesitter_types::Spanned for TypeSynomym<'_> {
9165 fn span(&self) -> ::treesitter_types::Span {
9166 self.span
9167 }
9168}
9169#[derive(Debug, Clone, PartialEq, Eq)]
9170pub struct TypedQuote<'tree> {
9171 pub span: ::treesitter_types::Span,
9172 pub children: ::core::option::Option<QuotedExpression<'tree>>,
9173}
9174impl<'tree> ::treesitter_types::FromNode<'tree> for TypedQuote<'tree> {
9175 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9176 fn from_node(
9177 node: ::tree_sitter::Node<'tree>,
9178 src: &'tree [u8],
9179 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9180 debug_assert_eq!(node.kind(), "typed_quote");
9181 Ok(Self {
9182 span: ::treesitter_types::Span::from(node),
9183 children: {
9184 #[allow(clippy::suspicious_else_formatting)]
9185 let non_field_children = {
9186 let mut cursor = node.walk();
9187 let mut result = ::std::vec::Vec::new();
9188 if cursor.goto_first_child() {
9189 loop {
9190 if cursor.field_name().is_none()
9191 && cursor.node().is_named()
9192 && !cursor.node().is_extra()
9193 {
9194 result.push(cursor.node());
9195 }
9196 if !cursor.goto_next_sibling() {
9197 break;
9198 }
9199 }
9200 }
9201 result
9202 };
9203 match non_field_children.first() {
9204 Some(&child) => Some(
9205 <QuotedExpression as ::treesitter_types::FromNode>::from_node(child, src)?,
9206 ),
9207 None => None,
9208 }
9209 },
9210 })
9211 }
9212}
9213impl ::treesitter_types::Spanned for TypedQuote<'_> {
9214 fn span(&self) -> ::treesitter_types::Span {
9215 self.span
9216 }
9217}
9218#[derive(Debug, Clone, PartialEq, Eq)]
9219pub struct UnboxedSum<'tree> {
9220 pub span: ::treesitter_types::Span,
9221 pub element: ::std::vec::Vec<UnboxedSumElement<'tree>>,
9222}
9223impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedSum<'tree> {
9224 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9225 fn from_node(
9226 node: ::tree_sitter::Node<'tree>,
9227 src: &'tree [u8],
9228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9229 debug_assert_eq!(node.kind(), "unboxed_sum");
9230 Ok(Self {
9231 span: ::treesitter_types::Span::from(node),
9232 element: {
9233 let mut cursor = node.walk();
9234 let mut items = ::std::vec::Vec::new();
9235 for child in node.children_by_field_name("element", &mut cursor) {
9236 items.push(
9237 <UnboxedSumElement as ::treesitter_types::FromNode>::from_node(child, src)?,
9238 );
9239 }
9240 items
9241 },
9242 })
9243 }
9244}
9245impl ::treesitter_types::Spanned for UnboxedSum<'_> {
9246 fn span(&self) -> ::treesitter_types::Span {
9247 self.span
9248 }
9249}
9250#[derive(Debug, Clone, PartialEq, Eq)]
9251pub struct UnboxedTuple<'tree> {
9252 pub span: ::treesitter_types::Span,
9253 pub element: ::std::vec::Vec<UnboxedTupleElement<'tree>>,
9254}
9255impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedTuple<'tree> {
9256 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9257 fn from_node(
9258 node: ::tree_sitter::Node<'tree>,
9259 src: &'tree [u8],
9260 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9261 debug_assert_eq!(node.kind(), "unboxed_tuple");
9262 Ok(Self {
9263 span: ::treesitter_types::Span::from(node),
9264 element: {
9265 let mut cursor = node.walk();
9266 let mut items = ::std::vec::Vec::new();
9267 for child in node.children_by_field_name("element", &mut cursor) {
9268 items.push(
9269 <UnboxedTupleElement as ::treesitter_types::FromNode>::from_node(
9270 child, src,
9271 )?,
9272 );
9273 }
9274 items
9275 },
9276 })
9277 }
9278}
9279impl ::treesitter_types::Spanned for UnboxedTuple<'_> {
9280 fn span(&self) -> ::treesitter_types::Span {
9281 self.span
9282 }
9283}
9284#[derive(Debug, Clone, PartialEq, Eq)]
9285pub struct UnboxedUnit<'tree> {
9286 pub span: ::treesitter_types::Span,
9287 text: &'tree str,
9288}
9289impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedUnit<'tree> {
9290 fn from_node(
9291 node: ::tree_sitter::Node<'tree>,
9292 src: &'tree [u8],
9293 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9294 debug_assert_eq!(node.kind(), "unboxed_unit");
9295 Ok(Self {
9296 span: ::treesitter_types::Span::from(node),
9297 text: node.utf8_text(src)?,
9298 })
9299 }
9300}
9301impl<'tree> ::treesitter_types::LeafNode<'tree> for UnboxedUnit<'tree> {
9302 fn text(&self) -> &'tree str {
9303 self.text
9304 }
9305}
9306impl ::treesitter_types::Spanned for UnboxedUnit<'_> {
9307 fn span(&self) -> ::treesitter_types::Span {
9308 self.span
9309 }
9310}
9311#[derive(Debug, Clone, PartialEq, Eq)]
9312pub struct Unit<'tree> {
9313 pub span: ::treesitter_types::Span,
9314 text: &'tree str,
9315}
9316impl<'tree> ::treesitter_types::FromNode<'tree> for Unit<'tree> {
9317 fn from_node(
9318 node: ::tree_sitter::Node<'tree>,
9319 src: &'tree [u8],
9320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9321 debug_assert_eq!(node.kind(), "unit");
9322 Ok(Self {
9323 span: ::treesitter_types::Span::from(node),
9324 text: node.utf8_text(src)?,
9325 })
9326 }
9327}
9328impl<'tree> ::treesitter_types::LeafNode<'tree> for Unit<'tree> {
9329 fn text(&self) -> &'tree str {
9330 self.text
9331 }
9332}
9333impl ::treesitter_types::Spanned for Unit<'_> {
9334 fn span(&self) -> ::treesitter_types::Span {
9335 self.span
9336 }
9337}
9338#[derive(Debug, Clone, PartialEq, Eq)]
9339pub struct Via<'tree> {
9340 pub span: ::treesitter_types::Span,
9341 pub r#type: QuantifiedType<'tree>,
9342}
9343impl<'tree> ::treesitter_types::FromNode<'tree> for Via<'tree> {
9344 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9345 fn from_node(
9346 node: ::tree_sitter::Node<'tree>,
9347 src: &'tree [u8],
9348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9349 debug_assert_eq!(node.kind(), "via");
9350 Ok(Self {
9351 span: ::treesitter_types::Span::from(node),
9352 r#type: {
9353 let child = node
9354 .child_by_field_name("type")
9355 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
9356 <QuantifiedType as ::treesitter_types::FromNode>::from_node(child, src)?
9357 },
9358 })
9359 }
9360}
9361impl ::treesitter_types::Spanned for Via<'_> {
9362 fn span(&self) -> ::treesitter_types::Span {
9363 self.span
9364 }
9365}
9366#[derive(Debug, Clone, PartialEq, Eq)]
9367pub struct ViewPattern<'tree> {
9368 pub span: ::treesitter_types::Span,
9369 pub expression: ViewPatternExpression<'tree>,
9370 pub pattern: ViewPatternPattern<'tree>,
9371}
9372impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPattern<'tree> {
9373 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9374 fn from_node(
9375 node: ::tree_sitter::Node<'tree>,
9376 src: &'tree [u8],
9377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9378 debug_assert_eq!(node.kind(), "view_pattern");
9379 Ok(Self {
9380 span: ::treesitter_types::Span::from(node),
9381 expression: {
9382 let child = node.child_by_field_name("expression").ok_or_else(|| {
9383 ::treesitter_types::ParseError::missing_field("expression", node)
9384 })?;
9385 <ViewPatternExpression as ::treesitter_types::FromNode>::from_node(child, src)?
9386 },
9387 pattern: {
9388 let child = node.child_by_field_name("pattern").ok_or_else(|| {
9389 ::treesitter_types::ParseError::missing_field("pattern", node)
9390 })?;
9391 <ViewPatternPattern as ::treesitter_types::FromNode>::from_node(child, src)?
9392 },
9393 })
9394 }
9395}
9396impl ::treesitter_types::Spanned for ViewPattern<'_> {
9397 fn span(&self) -> ::treesitter_types::Span {
9398 self.span
9399 }
9400}
9401#[derive(Debug, Clone, PartialEq, Eq)]
9402pub struct Wildcard<'tree> {
9403 pub span: ::treesitter_types::Span,
9404 text: &'tree str,
9405}
9406impl<'tree> ::treesitter_types::FromNode<'tree> for Wildcard<'tree> {
9407 fn from_node(
9408 node: ::tree_sitter::Node<'tree>,
9409 src: &'tree [u8],
9410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9411 debug_assert_eq!(node.kind(), "wildcard");
9412 Ok(Self {
9413 span: ::treesitter_types::Span::from(node),
9414 text: node.utf8_text(src)?,
9415 })
9416 }
9417}
9418impl<'tree> ::treesitter_types::LeafNode<'tree> for Wildcard<'tree> {
9419 fn text(&self) -> &'tree str {
9420 self.text
9421 }
9422}
9423impl ::treesitter_types::Spanned for Wildcard<'_> {
9424 fn span(&self) -> ::treesitter_types::Span {
9425 self.span
9426 }
9427}
9428#[derive(Debug, Clone, PartialEq, Eq)]
9429pub struct AllNames<'tree> {
9430 pub span: ::treesitter_types::Span,
9431 text: &'tree str,
9432}
9433impl<'tree> ::treesitter_types::FromNode<'tree> for AllNames<'tree> {
9434 fn from_node(
9435 node: ::tree_sitter::Node<'tree>,
9436 src: &'tree [u8],
9437 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9438 debug_assert_eq!(node.kind(), "all_names");
9439 Ok(Self {
9440 span: ::treesitter_types::Span::from(node),
9441 text: node.utf8_text(src)?,
9442 })
9443 }
9444}
9445impl<'tree> ::treesitter_types::LeafNode<'tree> for AllNames<'tree> {
9446 fn text(&self) -> &'tree str {
9447 self.text
9448 }
9449}
9450impl ::treesitter_types::Spanned for AllNames<'_> {
9451 fn span(&self) -> ::treesitter_types::Span {
9452 self.span
9453 }
9454}
9455#[derive(Debug, Clone, PartialEq, Eq)]
9456pub struct CallingConvention<'tree> {
9457 pub span: ::treesitter_types::Span,
9458 text: &'tree str,
9459}
9460impl<'tree> ::treesitter_types::FromNode<'tree> for CallingConvention<'tree> {
9461 fn from_node(
9462 node: ::tree_sitter::Node<'tree>,
9463 src: &'tree [u8],
9464 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9465 debug_assert_eq!(node.kind(), "calling_convention");
9466 Ok(Self {
9467 span: ::treesitter_types::Span::from(node),
9468 text: node.utf8_text(src)?,
9469 })
9470 }
9471}
9472impl<'tree> ::treesitter_types::LeafNode<'tree> for CallingConvention<'tree> {
9473 fn text(&self) -> &'tree str {
9474 self.text
9475 }
9476}
9477impl ::treesitter_types::Spanned for CallingConvention<'_> {
9478 fn span(&self) -> ::treesitter_types::Span {
9479 self.span
9480 }
9481}
9482#[derive(Debug, Clone, PartialEq, Eq)]
9483pub struct Char<'tree> {
9484 pub span: ::treesitter_types::Span,
9485 text: &'tree str,
9486}
9487impl<'tree> ::treesitter_types::FromNode<'tree> for Char<'tree> {
9488 fn from_node(
9489 node: ::tree_sitter::Node<'tree>,
9490 src: &'tree [u8],
9491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9492 debug_assert_eq!(node.kind(), "char");
9493 Ok(Self {
9494 span: ::treesitter_types::Span::from(node),
9495 text: node.utf8_text(src)?,
9496 })
9497 }
9498}
9499impl<'tree> ::treesitter_types::LeafNode<'tree> for Char<'tree> {
9500 fn text(&self) -> &'tree str {
9501 self.text
9502 }
9503}
9504impl ::treesitter_types::Spanned for Char<'_> {
9505 fn span(&self) -> ::treesitter_types::Span {
9506 self.span
9507 }
9508}
9509#[derive(Debug, Clone, PartialEq, Eq)]
9510pub struct Comment<'tree> {
9511 pub span: ::treesitter_types::Span,
9512 text: &'tree str,
9513}
9514impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
9515 fn from_node(
9516 node: ::tree_sitter::Node<'tree>,
9517 src: &'tree [u8],
9518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9519 debug_assert_eq!(node.kind(), "comment");
9520 Ok(Self {
9521 span: ::treesitter_types::Span::from(node),
9522 text: node.utf8_text(src)?,
9523 })
9524 }
9525}
9526impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
9527 fn text(&self) -> &'tree str {
9528 self.text
9529 }
9530}
9531impl ::treesitter_types::Spanned for Comment<'_> {
9532 fn span(&self) -> ::treesitter_types::Span {
9533 self.span
9534 }
9535}
9536#[derive(Debug, Clone, PartialEq, Eq)]
9537pub struct Constructor<'tree> {
9538 pub span: ::treesitter_types::Span,
9539 text: &'tree str,
9540}
9541impl<'tree> ::treesitter_types::FromNode<'tree> for Constructor<'tree> {
9542 fn from_node(
9543 node: ::tree_sitter::Node<'tree>,
9544 src: &'tree [u8],
9545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9546 debug_assert_eq!(node.kind(), "constructor");
9547 Ok(Self {
9548 span: ::treesitter_types::Span::from(node),
9549 text: node.utf8_text(src)?,
9550 })
9551 }
9552}
9553impl<'tree> ::treesitter_types::LeafNode<'tree> for Constructor<'tree> {
9554 fn text(&self) -> &'tree str {
9555 self.text
9556 }
9557}
9558impl ::treesitter_types::Spanned for Constructor<'_> {
9559 fn span(&self) -> ::treesitter_types::Span {
9560 self.span
9561 }
9562}
9563#[derive(Debug, Clone, PartialEq, Eq)]
9564pub struct Cpp<'tree> {
9565 pub span: ::treesitter_types::Span,
9566 text: &'tree str,
9567}
9568impl<'tree> ::treesitter_types::FromNode<'tree> for Cpp<'tree> {
9569 fn from_node(
9570 node: ::tree_sitter::Node<'tree>,
9571 src: &'tree [u8],
9572 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9573 debug_assert_eq!(node.kind(), "cpp");
9574 Ok(Self {
9575 span: ::treesitter_types::Span::from(node),
9576 text: node.utf8_text(src)?,
9577 })
9578 }
9579}
9580impl<'tree> ::treesitter_types::LeafNode<'tree> for Cpp<'tree> {
9581 fn text(&self) -> &'tree str {
9582 self.text
9583 }
9584}
9585impl ::treesitter_types::Spanned for Cpp<'_> {
9586 fn span(&self) -> ::treesitter_types::Span {
9587 self.span
9588 }
9589}
9590#[derive(Debug, Clone, PartialEq, Eq)]
9591pub struct Float<'tree> {
9592 pub span: ::treesitter_types::Span,
9593 text: &'tree str,
9594}
9595impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
9596 fn from_node(
9597 node: ::tree_sitter::Node<'tree>,
9598 src: &'tree [u8],
9599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9600 debug_assert_eq!(node.kind(), "float");
9601 Ok(Self {
9602 span: ::treesitter_types::Span::from(node),
9603 text: node.utf8_text(src)?,
9604 })
9605 }
9606}
9607impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
9608 fn text(&self) -> &'tree str {
9609 self.text
9610 }
9611}
9612impl ::treesitter_types::Spanned for Float<'_> {
9613 fn span(&self) -> ::treesitter_types::Span {
9614 self.span
9615 }
9616}
9617#[derive(Debug, Clone, PartialEq, Eq)]
9618pub struct Haddock<'tree> {
9619 pub span: ::treesitter_types::Span,
9620 text: &'tree str,
9621}
9622impl<'tree> ::treesitter_types::FromNode<'tree> for Haddock<'tree> {
9623 fn from_node(
9624 node: ::tree_sitter::Node<'tree>,
9625 src: &'tree [u8],
9626 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9627 debug_assert_eq!(node.kind(), "haddock");
9628 Ok(Self {
9629 span: ::treesitter_types::Span::from(node),
9630 text: node.utf8_text(src)?,
9631 })
9632 }
9633}
9634impl<'tree> ::treesitter_types::LeafNode<'tree> for Haddock<'tree> {
9635 fn text(&self) -> &'tree str {
9636 self.text
9637 }
9638}
9639impl ::treesitter_types::Spanned for Haddock<'_> {
9640 fn span(&self) -> ::treesitter_types::Span {
9641 self.span
9642 }
9643}
9644#[derive(Debug, Clone, PartialEq, Eq)]
9645pub struct ImplicitVariable<'tree> {
9646 pub span: ::treesitter_types::Span,
9647 text: &'tree str,
9648}
9649impl<'tree> ::treesitter_types::FromNode<'tree> for ImplicitVariable<'tree> {
9650 fn from_node(
9651 node: ::tree_sitter::Node<'tree>,
9652 src: &'tree [u8],
9653 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9654 debug_assert_eq!(node.kind(), "implicit_variable");
9655 Ok(Self {
9656 span: ::treesitter_types::Span::from(node),
9657 text: node.utf8_text(src)?,
9658 })
9659 }
9660}
9661impl<'tree> ::treesitter_types::LeafNode<'tree> for ImplicitVariable<'tree> {
9662 fn text(&self) -> &'tree str {
9663 self.text
9664 }
9665}
9666impl ::treesitter_types::Spanned for ImplicitVariable<'_> {
9667 fn span(&self) -> ::treesitter_types::Span {
9668 self.span
9669 }
9670}
9671#[derive(Debug, Clone, PartialEq, Eq)]
9672pub struct ImportPackage<'tree> {
9673 pub span: ::treesitter_types::Span,
9674 text: &'tree str,
9675}
9676impl<'tree> ::treesitter_types::FromNode<'tree> for ImportPackage<'tree> {
9677 fn from_node(
9678 node: ::tree_sitter::Node<'tree>,
9679 src: &'tree [u8],
9680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9681 debug_assert_eq!(node.kind(), "import_package");
9682 Ok(Self {
9683 span: ::treesitter_types::Span::from(node),
9684 text: node.utf8_text(src)?,
9685 })
9686 }
9687}
9688impl<'tree> ::treesitter_types::LeafNode<'tree> for ImportPackage<'tree> {
9689 fn text(&self) -> &'tree str {
9690 self.text
9691 }
9692}
9693impl ::treesitter_types::Spanned for ImportPackage<'_> {
9694 fn span(&self) -> ::treesitter_types::Span {
9695 self.span
9696 }
9697}
9698#[derive(Debug, Clone, PartialEq, Eq)]
9699pub struct Label<'tree> {
9700 pub span: ::treesitter_types::Span,
9701 text: &'tree str,
9702}
9703impl<'tree> ::treesitter_types::FromNode<'tree> for Label<'tree> {
9704 fn from_node(
9705 node: ::tree_sitter::Node<'tree>,
9706 src: &'tree [u8],
9707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9708 debug_assert_eq!(node.kind(), "label");
9709 Ok(Self {
9710 span: ::treesitter_types::Span::from(node),
9711 text: node.utf8_text(src)?,
9712 })
9713 }
9714}
9715impl<'tree> ::treesitter_types::LeafNode<'tree> for Label<'tree> {
9716 fn text(&self) -> &'tree str {
9717 self.text
9718 }
9719}
9720impl ::treesitter_types::Spanned for Label<'_> {
9721 fn span(&self) -> ::treesitter_types::Span {
9722 self.span
9723 }
9724}
9725#[derive(Debug, Clone, PartialEq, Eq)]
9726pub struct ModuleId<'tree> {
9727 pub span: ::treesitter_types::Span,
9728 text: &'tree str,
9729}
9730impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleId<'tree> {
9731 fn from_node(
9732 node: ::tree_sitter::Node<'tree>,
9733 src: &'tree [u8],
9734 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9735 debug_assert_eq!(node.kind(), "module_id");
9736 Ok(Self {
9737 span: ::treesitter_types::Span::from(node),
9738 text: node.utf8_text(src)?,
9739 })
9740 }
9741}
9742impl<'tree> ::treesitter_types::LeafNode<'tree> for ModuleId<'tree> {
9743 fn text(&self) -> &'tree str {
9744 self.text
9745 }
9746}
9747impl ::treesitter_types::Spanned for ModuleId<'_> {
9748 fn span(&self) -> ::treesitter_types::Span {
9749 self.span
9750 }
9751}
9752#[derive(Debug, Clone, PartialEq, Eq)]
9753pub struct Name<'tree> {
9754 pub span: ::treesitter_types::Span,
9755 text: &'tree str,
9756}
9757impl<'tree> ::treesitter_types::FromNode<'tree> for Name<'tree> {
9758 fn from_node(
9759 node: ::tree_sitter::Node<'tree>,
9760 src: &'tree [u8],
9761 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9762 debug_assert_eq!(node.kind(), "name");
9763 Ok(Self {
9764 span: ::treesitter_types::Span::from(node),
9765 text: node.utf8_text(src)?,
9766 })
9767 }
9768}
9769impl<'tree> ::treesitter_types::LeafNode<'tree> for Name<'tree> {
9770 fn text(&self) -> &'tree str {
9771 self.text
9772 }
9773}
9774impl ::treesitter_types::Spanned for Name<'_> {
9775 fn span(&self) -> ::treesitter_types::Span {
9776 self.span
9777 }
9778}
9779#[derive(Debug, Clone, PartialEq, Eq)]
9780pub struct Pragma<'tree> {
9781 pub span: ::treesitter_types::Span,
9782 text: &'tree str,
9783}
9784impl<'tree> ::treesitter_types::FromNode<'tree> for Pragma<'tree> {
9785 fn from_node(
9786 node: ::tree_sitter::Node<'tree>,
9787 src: &'tree [u8],
9788 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9789 debug_assert_eq!(node.kind(), "pragma");
9790 Ok(Self {
9791 span: ::treesitter_types::Span::from(node),
9792 text: node.utf8_text(src)?,
9793 })
9794 }
9795}
9796impl<'tree> ::treesitter_types::LeafNode<'tree> for Pragma<'tree> {
9797 fn text(&self) -> &'tree str {
9798 self.text
9799 }
9800}
9801impl ::treesitter_types::Spanned for Pragma<'_> {
9802 fn span(&self) -> ::treesitter_types::Span {
9803 self.span
9804 }
9805}
9806#[derive(Debug, Clone, PartialEq, Eq)]
9807pub struct QuasiquoteBody<'tree> {
9808 pub span: ::treesitter_types::Span,
9809 text: &'tree str,
9810}
9811impl<'tree> ::treesitter_types::FromNode<'tree> for QuasiquoteBody<'tree> {
9812 fn from_node(
9813 node: ::tree_sitter::Node<'tree>,
9814 src: &'tree [u8],
9815 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9816 debug_assert_eq!(node.kind(), "quasiquote_body");
9817 Ok(Self {
9818 span: ::treesitter_types::Span::from(node),
9819 text: node.utf8_text(src)?,
9820 })
9821 }
9822}
9823impl<'tree> ::treesitter_types::LeafNode<'tree> for QuasiquoteBody<'tree> {
9824 fn text(&self) -> &'tree str {
9825 self.text
9826 }
9827}
9828impl ::treesitter_types::Spanned for QuasiquoteBody<'_> {
9829 fn span(&self) -> ::treesitter_types::Span {
9830 self.span
9831 }
9832}
9833#[derive(Debug, Clone, PartialEq, Eq)]
9834pub struct Safety<'tree> {
9835 pub span: ::treesitter_types::Span,
9836 text: &'tree str,
9837}
9838impl<'tree> ::treesitter_types::FromNode<'tree> for Safety<'tree> {
9839 fn from_node(
9840 node: ::tree_sitter::Node<'tree>,
9841 src: &'tree [u8],
9842 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9843 debug_assert_eq!(node.kind(), "safety");
9844 Ok(Self {
9845 span: ::treesitter_types::Span::from(node),
9846 text: node.utf8_text(src)?,
9847 })
9848 }
9849}
9850impl<'tree> ::treesitter_types::LeafNode<'tree> for Safety<'tree> {
9851 fn text(&self) -> &'tree str {
9852 self.text
9853 }
9854}
9855impl ::treesitter_types::Spanned for Safety<'_> {
9856 fn span(&self) -> ::treesitter_types::Span {
9857 self.span
9858 }
9859}
9860#[derive(Debug, Clone, PartialEq, Eq)]
9861pub struct String<'tree> {
9862 pub span: ::treesitter_types::Span,
9863 text: &'tree str,
9864}
9865impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
9866 fn from_node(
9867 node: ::tree_sitter::Node<'tree>,
9868 src: &'tree [u8],
9869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9870 debug_assert_eq!(node.kind(), "string");
9871 Ok(Self {
9872 span: ::treesitter_types::Span::from(node),
9873 text: node.utf8_text(src)?,
9874 })
9875 }
9876}
9877impl<'tree> ::treesitter_types::LeafNode<'tree> for String<'tree> {
9878 fn text(&self) -> &'tree str {
9879 self.text
9880 }
9881}
9882impl ::treesitter_types::Spanned for String<'_> {
9883 fn span(&self) -> ::treesitter_types::Span {
9884 self.span
9885 }
9886}
9887#[derive(Debug, Clone, PartialEq, Eq)]
9888pub struct Variable<'tree> {
9889 pub span: ::treesitter_types::Span,
9890 text: &'tree str,
9891}
9892impl<'tree> ::treesitter_types::FromNode<'tree> for Variable<'tree> {
9893 fn from_node(
9894 node: ::tree_sitter::Node<'tree>,
9895 src: &'tree [u8],
9896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9897 debug_assert_eq!(node.kind(), "variable");
9898 Ok(Self {
9899 span: ::treesitter_types::Span::from(node),
9900 text: node.utf8_text(src)?,
9901 })
9902 }
9903}
9904impl<'tree> ::treesitter_types::LeafNode<'tree> for Variable<'tree> {
9905 fn text(&self) -> &'tree str {
9906 self.text
9907 }
9908}
9909impl ::treesitter_types::Spanned for Variable<'_> {
9910 fn span(&self) -> ::treesitter_types::Span {
9911 self.span
9912 }
9913}
9914#[derive(Debug, Clone, PartialEq, Eq)]
9915pub enum AlternativePattern<'tree> {
9916 Pattern(::std::boxed::Box<Pattern<'tree>>),
9917 Signature(::std::boxed::Box<Signature<'tree>>),
9918}
9919impl<'tree> ::treesitter_types::FromNode<'tree> for AlternativePattern<'tree> {
9920 #[allow(clippy::collapsible_else_if)]
9921 fn from_node(
9922 node: ::tree_sitter::Node<'tree>,
9923 src: &'tree [u8],
9924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9925 match node.kind() {
9926 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
9927 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
9928 ))),
9929 _other => {
9930 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
9931 Ok(Self::Pattern(::std::boxed::Box::new(v)))
9932 } else {
9933 Err(::treesitter_types::ParseError::unexpected_kind(
9934 _other, node,
9935 ))
9936 }
9937 }
9938 }
9939 }
9940}
9941impl ::treesitter_types::Spanned for AlternativePattern<'_> {
9942 fn span(&self) -> ::treesitter_types::Span {
9943 match self {
9944 Self::Pattern(inner) => inner.span(),
9945 Self::Signature(inner) => inner.span(),
9946 }
9947 }
9948}
9949#[derive(Debug, Clone, PartialEq, Eq)]
9950pub enum ApplyArgument<'tree> {
9951 ExplicitType(::std::boxed::Box<ExplicitType<'tree>>),
9952 Expression(::std::boxed::Box<Expression<'tree>>),
9953 KindApplication(::std::boxed::Box<KindApplication<'tree>>),
9954 Pattern(::std::boxed::Box<Pattern<'tree>>),
9955 Type(::std::boxed::Box<Type<'tree>>),
9956 TypeApplication(::std::boxed::Box<TypeApplication<'tree>>),
9957 TypeBinder(::std::boxed::Box<TypeBinder<'tree>>),
9958}
9959impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyArgument<'tree> {
9960 #[allow(clippy::collapsible_else_if)]
9961 fn from_node(
9962 node: ::tree_sitter::Node<'tree>,
9963 src: &'tree [u8],
9964 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9965 match node.kind() {
9966 "explicit_type" => Ok(Self::ExplicitType(::std::boxed::Box::new(
9967 <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)?,
9968 ))),
9969 "kind_application" => Ok(Self::KindApplication(::std::boxed::Box::new(
9970 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)?,
9971 ))),
9972 "type_application" => Ok(Self::TypeApplication(::std::boxed::Box::new(
9973 <TypeApplication as ::treesitter_types::FromNode>::from_node(node, src)?,
9974 ))),
9975 "type_binder" => Ok(Self::TypeBinder(::std::boxed::Box::new(
9976 <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)?,
9977 ))),
9978 _other => {
9979 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9980 Ok(Self::Expression(::std::boxed::Box::new(v)))
9981 } else {
9982 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
9983 Ok(Self::Pattern(::std::boxed::Box::new(v)))
9984 } else {
9985 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src)
9986 {
9987 Ok(Self::Type(::std::boxed::Box::new(v)))
9988 } else {
9989 Err(::treesitter_types::ParseError::unexpected_kind(
9990 _other, node,
9991 ))
9992 }
9993 }
9994 }
9995 }
9996 }
9997 }
9998}
9999impl ::treesitter_types::Spanned for ApplyArgument<'_> {
10000 fn span(&self) -> ::treesitter_types::Span {
10001 match self {
10002 Self::ExplicitType(inner) => inner.span(),
10003 Self::Expression(inner) => inner.span(),
10004 Self::KindApplication(inner) => inner.span(),
10005 Self::Pattern(inner) => inner.span(),
10006 Self::Type(inner) => inner.span(),
10007 Self::TypeApplication(inner) => inner.span(),
10008 Self::TypeBinder(inner) => inner.span(),
10009 }
10010 }
10011}
10012#[derive(Debug, Clone, PartialEq, Eq)]
10013pub enum ApplyConstructor<'tree> {
10014 Constraint(::std::boxed::Box<Constraint<'tree>>),
10015 Type(::std::boxed::Box<Type<'tree>>),
10016}
10017impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyConstructor<'tree> {
10018 #[allow(clippy::collapsible_else_if)]
10019 fn from_node(
10020 node: ::tree_sitter::Node<'tree>,
10021 src: &'tree [u8],
10022 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10023 if let Ok(v) = <Constraint as ::treesitter_types::FromNode>::from_node(node, src) {
10024 Ok(Self::Constraint(::std::boxed::Box::new(v)))
10025 } else {
10026 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
10027 Ok(Self::Type(::std::boxed::Box::new(v)))
10028 } else {
10029 Err(::treesitter_types::ParseError::unexpected_kind(
10030 node.kind(),
10031 node,
10032 ))
10033 }
10034 }
10035 }
10036}
10037impl ::treesitter_types::Spanned for ApplyConstructor<'_> {
10038 fn span(&self) -> ::treesitter_types::Span {
10039 match self {
10040 Self::Constraint(inner) => inner.span(),
10041 Self::Type(inner) => inner.span(),
10042 }
10043 }
10044}
10045#[derive(Debug, Clone, PartialEq, Eq)]
10046pub enum ApplyFunction<'tree> {
10047 Expression(::std::boxed::Box<Expression<'tree>>),
10048 Pattern(::std::boxed::Box<Pattern<'tree>>),
10049}
10050impl<'tree> ::treesitter_types::FromNode<'tree> for ApplyFunction<'tree> {
10051 #[allow(clippy::collapsible_else_if)]
10052 fn from_node(
10053 node: ::tree_sitter::Node<'tree>,
10054 src: &'tree [u8],
10055 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10056 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10057 Ok(Self::Expression(::std::boxed::Box::new(v)))
10058 } else {
10059 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10060 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10061 } else {
10062 Err(::treesitter_types::ParseError::unexpected_kind(
10063 node.kind(),
10064 node,
10065 ))
10066 }
10067 }
10068 }
10069}
10070impl ::treesitter_types::Spanned for ApplyFunction<'_> {
10071 fn span(&self) -> ::treesitter_types::Span {
10072 match self {
10073 Self::Expression(inner) => inner.span(),
10074 Self::Pattern(inner) => inner.span(),
10075 }
10076 }
10077}
10078#[derive(Debug, Clone, PartialEq, Eq)]
10079pub enum ArithmeticSequenceFrom<'tree> {
10080 Expression(::std::boxed::Box<Expression<'tree>>),
10081 Signature(::std::boxed::Box<Signature<'tree>>),
10082}
10083impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceFrom<'tree> {
10084 #[allow(clippy::collapsible_else_if)]
10085 fn from_node(
10086 node: ::tree_sitter::Node<'tree>,
10087 src: &'tree [u8],
10088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10089 match node.kind() {
10090 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10091 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10092 ))),
10093 _other => {
10094 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10095 Ok(Self::Expression(::std::boxed::Box::new(v)))
10096 } else {
10097 Err(::treesitter_types::ParseError::unexpected_kind(
10098 _other, node,
10099 ))
10100 }
10101 }
10102 }
10103 }
10104}
10105impl ::treesitter_types::Spanned for ArithmeticSequenceFrom<'_> {
10106 fn span(&self) -> ::treesitter_types::Span {
10107 match self {
10108 Self::Expression(inner) => inner.span(),
10109 Self::Signature(inner) => inner.span(),
10110 }
10111 }
10112}
10113#[derive(Debug, Clone, PartialEq, Eq)]
10114pub enum ArithmeticSequenceStep<'tree> {
10115 Expression(::std::boxed::Box<Expression<'tree>>),
10116 Signature(::std::boxed::Box<Signature<'tree>>),
10117}
10118impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceStep<'tree> {
10119 #[allow(clippy::collapsible_else_if)]
10120 fn from_node(
10121 node: ::tree_sitter::Node<'tree>,
10122 src: &'tree [u8],
10123 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10124 match node.kind() {
10125 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10126 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10127 ))),
10128 _other => {
10129 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10130 Ok(Self::Expression(::std::boxed::Box::new(v)))
10131 } else {
10132 Err(::treesitter_types::ParseError::unexpected_kind(
10133 _other, node,
10134 ))
10135 }
10136 }
10137 }
10138 }
10139}
10140impl ::treesitter_types::Spanned for ArithmeticSequenceStep<'_> {
10141 fn span(&self) -> ::treesitter_types::Span {
10142 match self {
10143 Self::Expression(inner) => inner.span(),
10144 Self::Signature(inner) => inner.span(),
10145 }
10146 }
10147}
10148#[derive(Debug, Clone, PartialEq, Eq)]
10149pub enum ArithmeticSequenceTo<'tree> {
10150 Expression(::std::boxed::Box<Expression<'tree>>),
10151 Signature(::std::boxed::Box<Signature<'tree>>),
10152}
10153impl<'tree> ::treesitter_types::FromNode<'tree> for ArithmeticSequenceTo<'tree> {
10154 #[allow(clippy::collapsible_else_if)]
10155 fn from_node(
10156 node: ::tree_sitter::Node<'tree>,
10157 src: &'tree [u8],
10158 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10159 match node.kind() {
10160 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10161 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10162 ))),
10163 _other => {
10164 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10165 Ok(Self::Expression(::std::boxed::Box::new(v)))
10166 } else {
10167 Err(::treesitter_types::ParseError::unexpected_kind(
10168 _other, node,
10169 ))
10170 }
10171 }
10172 }
10173 }
10174}
10175impl ::treesitter_types::Spanned for ArithmeticSequenceTo<'_> {
10176 fn span(&self) -> ::treesitter_types::Span {
10177 match self {
10178 Self::Expression(inner) => inner.span(),
10179 Self::Signature(inner) => inner.span(),
10180 }
10181 }
10182}
10183#[derive(Debug, Clone, PartialEq, Eq)]
10184pub enum AssociatedTypeNamespace {
10185 Type(::treesitter_types::Span),
10186}
10187impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedTypeNamespace {
10188 #[allow(clippy::collapsible_else_if)]
10189 fn from_node(
10190 node: ::tree_sitter::Node<'tree>,
10191 _src: &'tree [u8],
10192 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10193 match node.kind() {
10194 "type" => Ok(Self::Type(::treesitter_types::Span::from(node))),
10195 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10196 }
10197 }
10198}
10199impl ::treesitter_types::Spanned for AssociatedTypeNamespace {
10200 fn span(&self) -> ::treesitter_types::Span {
10201 match self {
10202 Self::Type(span) => *span,
10203 }
10204 }
10205}
10206#[derive(Debug, Clone, PartialEq, Eq)]
10207pub enum AssociatedTypeType<'tree> {
10208 Name(::std::boxed::Box<Name<'tree>>),
10209 Qualified(::std::boxed::Box<Qualified<'tree>>),
10210}
10211impl<'tree> ::treesitter_types::FromNode<'tree> for AssociatedTypeType<'tree> {
10212 #[allow(clippy::collapsible_else_if)]
10213 fn from_node(
10214 node: ::tree_sitter::Node<'tree>,
10215 src: &'tree [u8],
10216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10217 match node.kind() {
10218 "name" => Ok(Self::Name(::std::boxed::Box::new(
10219 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10220 ))),
10221 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
10222 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
10223 ))),
10224 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10225 }
10226 }
10227}
10228impl ::treesitter_types::Spanned for AssociatedTypeType<'_> {
10229 fn span(&self) -> ::treesitter_types::Span {
10230 match self {
10231 Self::Name(inner) => inner.span(),
10232 Self::Qualified(inner) => inner.span(),
10233 }
10234 }
10235}
10236#[derive(Debug, Clone, PartialEq, Eq)]
10237pub enum BindArrow {
10238 LArrow(::treesitter_types::Span),
10239 X(::treesitter_types::Span),
10240}
10241impl<'tree> ::treesitter_types::FromNode<'tree> for BindArrow {
10242 #[allow(clippy::collapsible_else_if)]
10243 fn from_node(
10244 node: ::tree_sitter::Node<'tree>,
10245 _src: &'tree [u8],
10246 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10247 match node.kind() {
10248 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
10249 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
10250 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10251 }
10252 }
10253}
10254impl ::treesitter_types::Spanned for BindArrow {
10255 fn span(&self) -> ::treesitter_types::Span {
10256 match self {
10257 Self::LArrow(span) => *span,
10258 Self::X(span) => *span,
10259 }
10260 }
10261}
10262#[derive(Debug, Clone, PartialEq, Eq)]
10263pub enum BindExpression<'tree> {
10264 Expression(::std::boxed::Box<Expression<'tree>>),
10265 Signature(::std::boxed::Box<Signature<'tree>>),
10266}
10267impl<'tree> ::treesitter_types::FromNode<'tree> for BindExpression<'tree> {
10268 #[allow(clippy::collapsible_else_if)]
10269 fn from_node(
10270 node: ::tree_sitter::Node<'tree>,
10271 src: &'tree [u8],
10272 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10273 match node.kind() {
10274 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10275 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10276 ))),
10277 _other => {
10278 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10279 Ok(Self::Expression(::std::boxed::Box::new(v)))
10280 } else {
10281 Err(::treesitter_types::ParseError::unexpected_kind(
10282 _other, node,
10283 ))
10284 }
10285 }
10286 }
10287 }
10288}
10289impl ::treesitter_types::Spanned for BindExpression<'_> {
10290 fn span(&self) -> ::treesitter_types::Span {
10291 match self {
10292 Self::Expression(inner) => inner.span(),
10293 Self::Signature(inner) => inner.span(),
10294 }
10295 }
10296}
10297#[derive(Debug, Clone, PartialEq, Eq)]
10298pub enum BindName<'tree> {
10299 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10300 Variable(::std::boxed::Box<Variable<'tree>>),
10301}
10302impl<'tree> ::treesitter_types::FromNode<'tree> for BindName<'tree> {
10303 #[allow(clippy::collapsible_else_if)]
10304 fn from_node(
10305 node: ::tree_sitter::Node<'tree>,
10306 src: &'tree [u8],
10307 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10308 match node.kind() {
10309 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10310 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10311 ))),
10312 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10313 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
10314 ))),
10315 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10316 }
10317 }
10318}
10319impl ::treesitter_types::Spanned for BindName<'_> {
10320 fn span(&self) -> ::treesitter_types::Span {
10321 match self {
10322 Self::PrefixId(inner) => inner.span(),
10323 Self::Variable(inner) => inner.span(),
10324 }
10325 }
10326}
10327#[derive(Debug, Clone, PartialEq, Eq)]
10328pub enum BindPattern<'tree> {
10329 Pattern(::std::boxed::Box<Pattern<'tree>>),
10330 Signature(::std::boxed::Box<Signature<'tree>>),
10331}
10332impl<'tree> ::treesitter_types::FromNode<'tree> for BindPattern<'tree> {
10333 #[allow(clippy::collapsible_else_if)]
10334 fn from_node(
10335 node: ::tree_sitter::Node<'tree>,
10336 src: &'tree [u8],
10337 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10338 match node.kind() {
10339 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10340 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10341 ))),
10342 _other => {
10343 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10344 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10345 } else {
10346 Err(::treesitter_types::ParseError::unexpected_kind(
10347 _other, node,
10348 ))
10349 }
10350 }
10351 }
10352 }
10353}
10354impl ::treesitter_types::Spanned for BindPattern<'_> {
10355 fn span(&self) -> ::treesitter_types::Span {
10356 match self {
10357 Self::Pattern(inner) => inner.span(),
10358 Self::Signature(inner) => inner.span(),
10359 }
10360 }
10361}
10362#[derive(Debug, Clone, PartialEq, Eq)]
10363pub enum BindingListName<'tree> {
10364 Constructor(::std::boxed::Box<Constructor<'tree>>),
10365 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10366 Variable(::std::boxed::Box<Variable<'tree>>),
10367}
10368impl<'tree> ::treesitter_types::FromNode<'tree> for BindingListName<'tree> {
10369 #[allow(clippy::collapsible_else_if)]
10370 fn from_node(
10371 node: ::tree_sitter::Node<'tree>,
10372 src: &'tree [u8],
10373 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10374 match node.kind() {
10375 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
10376 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
10377 ))),
10378 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10379 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10380 ))),
10381 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10382 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
10383 ))),
10384 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10385 }
10386 }
10387}
10388impl ::treesitter_types::Spanned for BindingListName<'_> {
10389 fn span(&self) -> ::treesitter_types::Span {
10390 match self {
10391 Self::Constructor(inner) => inner.span(),
10392 Self::PrefixId(inner) => inner.span(),
10393 Self::Variable(inner) => inner.span(),
10394 }
10395 }
10396}
10397#[derive(Debug, Clone, PartialEq, Eq)]
10398pub enum BooleanChildren<'tree> {
10399 Expression(::std::boxed::Box<Expression<'tree>>),
10400 Signature(::std::boxed::Box<Signature<'tree>>),
10401}
10402impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanChildren<'tree> {
10403 #[allow(clippy::collapsible_else_if)]
10404 fn from_node(
10405 node: ::tree_sitter::Node<'tree>,
10406 src: &'tree [u8],
10407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10408 match node.kind() {
10409 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10410 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10411 ))),
10412 _other => {
10413 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10414 Ok(Self::Expression(::std::boxed::Box::new(v)))
10415 } else {
10416 Err(::treesitter_types::ParseError::unexpected_kind(
10417 _other, node,
10418 ))
10419 }
10420 }
10421 }
10422 }
10423}
10424impl ::treesitter_types::Spanned for BooleanChildren<'_> {
10425 fn span(&self) -> ::treesitter_types::Span {
10426 match self {
10427 Self::Expression(inner) => inner.span(),
10428 Self::Signature(inner) => inner.span(),
10429 }
10430 }
10431}
10432#[derive(Debug, Clone, PartialEq, Eq)]
10433pub enum CaseChildren<'tree> {
10434 Expression(::std::boxed::Box<Expression<'tree>>),
10435 Signature(::std::boxed::Box<Signature<'tree>>),
10436}
10437impl<'tree> ::treesitter_types::FromNode<'tree> for CaseChildren<'tree> {
10438 #[allow(clippy::collapsible_else_if)]
10439 fn from_node(
10440 node: ::tree_sitter::Node<'tree>,
10441 src: &'tree [u8],
10442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10443 match node.kind() {
10444 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10445 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10446 ))),
10447 _other => {
10448 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10449 Ok(Self::Expression(::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 CaseChildren<'_> {
10460 fn span(&self) -> ::treesitter_types::Span {
10461 match self {
10462 Self::Expression(inner) => inner.span(),
10463 Self::Signature(inner) => inner.span(),
10464 }
10465 }
10466}
10467#[derive(Debug, Clone, PartialEq, Eq)]
10468pub enum ChildrenElement<'tree> {
10469 AllNames(::std::boxed::Box<AllNames<'tree>>),
10470 AssociatedType(::std::boxed::Box<AssociatedType<'tree>>),
10471 Constructor(::std::boxed::Box<Constructor<'tree>>),
10472 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10473 Qualified(::std::boxed::Box<Qualified<'tree>>),
10474 Variable(::std::boxed::Box<Variable<'tree>>),
10475}
10476impl<'tree> ::treesitter_types::FromNode<'tree> for ChildrenElement<'tree> {
10477 #[allow(clippy::collapsible_else_if)]
10478 fn from_node(
10479 node: ::tree_sitter::Node<'tree>,
10480 src: &'tree [u8],
10481 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10482 match node.kind() {
10483 "all_names" => Ok(Self::AllNames(::std::boxed::Box::new(
10484 <AllNames as ::treesitter_types::FromNode>::from_node(node, src)?,
10485 ))),
10486 "associated_type" => Ok(Self::AssociatedType(::std::boxed::Box::new(
10487 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)?,
10488 ))),
10489 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
10490 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
10491 ))),
10492 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10493 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10494 ))),
10495 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
10496 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
10497 ))),
10498 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10499 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
10500 ))),
10501 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10502 }
10503 }
10504}
10505impl ::treesitter_types::Spanned for ChildrenElement<'_> {
10506 fn span(&self) -> ::treesitter_types::Span {
10507 match self {
10508 Self::AllNames(inner) => inner.span(),
10509 Self::AssociatedType(inner) => inner.span(),
10510 Self::Constructor(inner) => inner.span(),
10511 Self::PrefixId(inner) => inner.span(),
10512 Self::Qualified(inner) => inner.span(),
10513 Self::Variable(inner) => inner.span(),
10514 }
10515 }
10516}
10517#[derive(Debug, Clone, PartialEq, Eq)]
10518pub enum ClassName<'tree> {
10519 Name(::std::boxed::Box<Name<'tree>>),
10520 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10521 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
10522 Unit(::std::boxed::Box<Unit<'tree>>),
10523}
10524impl<'tree> ::treesitter_types::FromNode<'tree> for ClassName<'tree> {
10525 #[allow(clippy::collapsible_else_if)]
10526 fn from_node(
10527 node: ::tree_sitter::Node<'tree>,
10528 src: &'tree [u8],
10529 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10530 match node.kind() {
10531 "name" => Ok(Self::Name(::std::boxed::Box::new(
10532 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10533 ))),
10534 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10535 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10536 ))),
10537 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
10538 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
10539 ))),
10540 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
10541 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
10542 ))),
10543 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10544 }
10545 }
10546}
10547impl ::treesitter_types::Spanned for ClassName<'_> {
10548 fn span(&self) -> ::treesitter_types::Span {
10549 match self {
10550 Self::Name(inner) => inner.span(),
10551 Self::PrefixId(inner) => inner.span(),
10552 Self::PrefixList(inner) => inner.span(),
10553 Self::Unit(inner) => inner.span(),
10554 }
10555 }
10556}
10557#[derive(Debug, Clone, PartialEq, Eq)]
10558pub enum ClassChildren<'tree> {
10559 Infix(::std::boxed::Box<Infix<'tree>>),
10560 Parens(::std::boxed::Box<Parens<'tree>>),
10561}
10562impl<'tree> ::treesitter_types::FromNode<'tree> for ClassChildren<'tree> {
10563 #[allow(clippy::collapsible_else_if)]
10564 fn from_node(
10565 node: ::tree_sitter::Node<'tree>,
10566 src: &'tree [u8],
10567 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10568 match node.kind() {
10569 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
10570 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
10571 ))),
10572 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
10573 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
10574 ))),
10575 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10576 }
10577 }
10578}
10579impl ::treesitter_types::Spanned for ClassChildren<'_> {
10580 fn span(&self) -> ::treesitter_types::Span {
10581 match self {
10582 Self::Infix(inner) => inner.span(),
10583 Self::Parens(inner) => inner.span(),
10584 }
10585 }
10586}
10587#[derive(Debug, Clone, PartialEq, Eq)]
10588pub enum ConditionalElse<'tree> {
10589 Expression(::std::boxed::Box<Expression<'tree>>),
10590 Signature(::std::boxed::Box<Signature<'tree>>),
10591}
10592impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalElse<'tree> {
10593 #[allow(clippy::collapsible_else_if)]
10594 fn from_node(
10595 node: ::tree_sitter::Node<'tree>,
10596 src: &'tree [u8],
10597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10598 match node.kind() {
10599 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10600 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10601 ))),
10602 _other => {
10603 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10604 Ok(Self::Expression(::std::boxed::Box::new(v)))
10605 } else {
10606 Err(::treesitter_types::ParseError::unexpected_kind(
10607 _other, node,
10608 ))
10609 }
10610 }
10611 }
10612 }
10613}
10614impl ::treesitter_types::Spanned for ConditionalElse<'_> {
10615 fn span(&self) -> ::treesitter_types::Span {
10616 match self {
10617 Self::Expression(inner) => inner.span(),
10618 Self::Signature(inner) => inner.span(),
10619 }
10620 }
10621}
10622#[derive(Debug, Clone, PartialEq, Eq)]
10623pub enum ConditionalIf<'tree> {
10624 Expression(::std::boxed::Box<Expression<'tree>>),
10625 Signature(::std::boxed::Box<Signature<'tree>>),
10626}
10627impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalIf<'tree> {
10628 #[allow(clippy::collapsible_else_if)]
10629 fn from_node(
10630 node: ::tree_sitter::Node<'tree>,
10631 src: &'tree [u8],
10632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10633 match node.kind() {
10634 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10635 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10636 ))),
10637 _other => {
10638 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10639 Ok(Self::Expression(::std::boxed::Box::new(v)))
10640 } else {
10641 Err(::treesitter_types::ParseError::unexpected_kind(
10642 _other, node,
10643 ))
10644 }
10645 }
10646 }
10647 }
10648}
10649impl ::treesitter_types::Spanned for ConditionalIf<'_> {
10650 fn span(&self) -> ::treesitter_types::Span {
10651 match self {
10652 Self::Expression(inner) => inner.span(),
10653 Self::Signature(inner) => inner.span(),
10654 }
10655 }
10656}
10657#[derive(Debug, Clone, PartialEq, Eq)]
10658pub enum ConditionalThen<'tree> {
10659 Expression(::std::boxed::Box<Expression<'tree>>),
10660 Signature(::std::boxed::Box<Signature<'tree>>),
10661}
10662impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalThen<'tree> {
10663 #[allow(clippy::collapsible_else_if)]
10664 fn from_node(
10665 node: ::tree_sitter::Node<'tree>,
10666 src: &'tree [u8],
10667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10668 match node.kind() {
10669 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10670 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10671 ))),
10672 _other => {
10673 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10674 Ok(Self::Expression(::std::boxed::Box::new(v)))
10675 } else {
10676 Err(::treesitter_types::ParseError::unexpected_kind(
10677 _other, node,
10678 ))
10679 }
10680 }
10681 }
10682 }
10683}
10684impl ::treesitter_types::Spanned for ConditionalThen<'_> {
10685 fn span(&self) -> ::treesitter_types::Span {
10686 match self {
10687 Self::Expression(inner) => inner.span(),
10688 Self::Signature(inner) => inner.span(),
10689 }
10690 }
10691}
10692#[derive(Debug, Clone, PartialEq, Eq)]
10693pub enum ConstructorSynonymName<'tree> {
10694 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10695 Variable(::std::boxed::Box<Variable<'tree>>),
10696}
10697impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonymName<'tree> {
10698 #[allow(clippy::collapsible_else_if)]
10699 fn from_node(
10700 node: ::tree_sitter::Node<'tree>,
10701 src: &'tree [u8],
10702 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10703 match node.kind() {
10704 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10705 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10706 ))),
10707 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
10708 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
10709 ))),
10710 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10711 }
10712 }
10713}
10714impl ::treesitter_types::Spanned for ConstructorSynonymName<'_> {
10715 fn span(&self) -> ::treesitter_types::Span {
10716 match self {
10717 Self::PrefixId(inner) => inner.span(),
10718 Self::Variable(inner) => inner.span(),
10719 }
10720 }
10721}
10722#[derive(Debug, Clone, PartialEq, Eq)]
10723pub enum ConstructorSynonymPattern<'tree> {
10724 Pattern(::std::boxed::Box<Pattern<'tree>>),
10725 Signature(::std::boxed::Box<Signature<'tree>>),
10726}
10727impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorSynonymPattern<'tree> {
10728 #[allow(clippy::collapsible_else_if)]
10729 fn from_node(
10730 node: ::tree_sitter::Node<'tree>,
10731 src: &'tree [u8],
10732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10733 match node.kind() {
10734 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
10735 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
10736 ))),
10737 _other => {
10738 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
10739 Ok(Self::Pattern(::std::boxed::Box::new(v)))
10740 } else {
10741 Err(::treesitter_types::ParseError::unexpected_kind(
10742 _other, node,
10743 ))
10744 }
10745 }
10746 }
10747 }
10748}
10749impl ::treesitter_types::Spanned for ConstructorSynonymPattern<'_> {
10750 fn span(&self) -> ::treesitter_types::Span {
10751 match self {
10752 Self::Pattern(inner) => inner.span(),
10753 Self::Signature(inner) => inner.span(),
10754 }
10755 }
10756}
10757#[derive(Debug, Clone, PartialEq, Eq)]
10758pub enum ContextArrow {
10759 FatArrow(::treesitter_types::Span),
10760 X(::treesitter_types::Span),
10761}
10762impl<'tree> ::treesitter_types::FromNode<'tree> for ContextArrow {
10763 #[allow(clippy::collapsible_else_if)]
10764 fn from_node(
10765 node: ::tree_sitter::Node<'tree>,
10766 _src: &'tree [u8],
10767 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10768 match node.kind() {
10769 "=>" => Ok(Self::FatArrow(::treesitter_types::Span::from(node))),
10770 "⇒" => Ok(Self::X(::treesitter_types::Span::from(node))),
10771 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10772 }
10773 }
10774}
10775impl ::treesitter_types::Spanned for ContextArrow {
10776 fn span(&self) -> ::treesitter_types::Span {
10777 match self {
10778 Self::FatArrow(span) => *span,
10779 Self::X(span) => *span,
10780 }
10781 }
10782}
10783#[derive(Debug, Clone, PartialEq, Eq)]
10784pub enum DataConstructorConstructor<'tree> {
10785 Infix(::std::boxed::Box<Infix<'tree>>),
10786 Prefix(::std::boxed::Box<Prefix<'tree>>),
10787 Record(::std::boxed::Box<Record<'tree>>),
10788 Special(::std::boxed::Box<Special<'tree>>),
10789}
10790impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructorConstructor<'tree> {
10791 #[allow(clippy::collapsible_else_if)]
10792 fn from_node(
10793 node: ::tree_sitter::Node<'tree>,
10794 src: &'tree [u8],
10795 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10796 match node.kind() {
10797 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
10798 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
10799 ))),
10800 "prefix" => Ok(Self::Prefix(::std::boxed::Box::new(
10801 <Prefix as ::treesitter_types::FromNode>::from_node(node, src)?,
10802 ))),
10803 "record" => Ok(Self::Record(::std::boxed::Box::new(
10804 <Record as ::treesitter_types::FromNode>::from_node(node, src)?,
10805 ))),
10806 "special" => Ok(Self::Special(::std::boxed::Box::new(
10807 <Special as ::treesitter_types::FromNode>::from_node(node, src)?,
10808 ))),
10809 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10810 }
10811 }
10812}
10813impl ::treesitter_types::Spanned for DataConstructorConstructor<'_> {
10814 fn span(&self) -> ::treesitter_types::Span {
10815 match self {
10816 Self::Infix(inner) => inner.span(),
10817 Self::Prefix(inner) => inner.span(),
10818 Self::Record(inner) => inner.span(),
10819 Self::Special(inner) => inner.span(),
10820 }
10821 }
10822}
10823#[derive(Debug, Clone, PartialEq, Eq)]
10824pub enum DataConstructorForall<'tree> {
10825 Forall(::std::boxed::Box<Forall<'tree>>),
10826 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
10827}
10828impl<'tree> ::treesitter_types::FromNode<'tree> for DataConstructorForall<'tree> {
10829 #[allow(clippy::collapsible_else_if)]
10830 fn from_node(
10831 node: ::tree_sitter::Node<'tree>,
10832 src: &'tree [u8],
10833 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10834 match node.kind() {
10835 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
10836 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
10837 ))),
10838 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
10839 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
10840 ))),
10841 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10842 }
10843 }
10844}
10845impl ::treesitter_types::Spanned for DataConstructorForall<'_> {
10846 fn span(&self) -> ::treesitter_types::Span {
10847 match self {
10848 Self::Forall(inner) => inner.span(),
10849 Self::ForallRequired(inner) => inner.span(),
10850 }
10851 }
10852}
10853#[derive(Debug, Clone, PartialEq, Eq)]
10854pub enum DataFamilyName<'tree> {
10855 Name(::std::boxed::Box<Name<'tree>>),
10856 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
10857 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
10858 Unit(::std::boxed::Box<Unit<'tree>>),
10859}
10860impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamilyName<'tree> {
10861 #[allow(clippy::collapsible_else_if)]
10862 fn from_node(
10863 node: ::tree_sitter::Node<'tree>,
10864 src: &'tree [u8],
10865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10866 match node.kind() {
10867 "name" => Ok(Self::Name(::std::boxed::Box::new(
10868 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
10869 ))),
10870 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
10871 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
10872 ))),
10873 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
10874 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
10875 ))),
10876 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
10877 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
10878 ))),
10879 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10880 }
10881 }
10882}
10883impl ::treesitter_types::Spanned for DataFamilyName<'_> {
10884 fn span(&self) -> ::treesitter_types::Span {
10885 match self {
10886 Self::Name(inner) => inner.span(),
10887 Self::PrefixId(inner) => inner.span(),
10888 Self::PrefixList(inner) => inner.span(),
10889 Self::Unit(inner) => inner.span(),
10890 }
10891 }
10892}
10893#[derive(Debug, Clone, PartialEq, Eq)]
10894pub enum DataFamilyChildren<'tree> {
10895 Infix(::std::boxed::Box<Infix<'tree>>),
10896 Parens(::std::boxed::Box<Parens<'tree>>),
10897}
10898impl<'tree> ::treesitter_types::FromNode<'tree> for DataFamilyChildren<'tree> {
10899 #[allow(clippy::collapsible_else_if)]
10900 fn from_node(
10901 node: ::tree_sitter::Node<'tree>,
10902 src: &'tree [u8],
10903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10904 match node.kind() {
10905 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
10906 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
10907 ))),
10908 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
10909 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
10910 ))),
10911 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10912 }
10913 }
10914}
10915impl ::treesitter_types::Spanned for DataFamilyChildren<'_> {
10916 fn span(&self) -> ::treesitter_types::Span {
10917 match self {
10918 Self::Infix(inner) => inner.span(),
10919 Self::Parens(inner) => inner.span(),
10920 }
10921 }
10922}
10923#[derive(Debug, Clone, PartialEq, Eq)]
10924pub enum DataInstanceChildren<'tree> {
10925 DataType(::std::boxed::Box<DataType<'tree>>),
10926 Newtype(::std::boxed::Box<Newtype<'tree>>),
10927}
10928impl<'tree> ::treesitter_types::FromNode<'tree> for DataInstanceChildren<'tree> {
10929 #[allow(clippy::collapsible_else_if)]
10930 fn from_node(
10931 node: ::tree_sitter::Node<'tree>,
10932 src: &'tree [u8],
10933 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10934 match node.kind() {
10935 "data_type" => Ok(Self::DataType(::std::boxed::Box::new(
10936 <DataType as ::treesitter_types::FromNode>::from_node(node, src)?,
10937 ))),
10938 "newtype" => Ok(Self::Newtype(::std::boxed::Box::new(
10939 <Newtype as ::treesitter_types::FromNode>::from_node(node, src)?,
10940 ))),
10941 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10942 }
10943 }
10944}
10945impl ::treesitter_types::Spanned for DataInstanceChildren<'_> {
10946 fn span(&self) -> ::treesitter_types::Span {
10947 match self {
10948 Self::DataType(inner) => inner.span(),
10949 Self::Newtype(inner) => inner.span(),
10950 }
10951 }
10952}
10953#[derive(Debug, Clone, PartialEq, Eq)]
10954pub enum DataTypeConstructors<'tree> {
10955 DataConstructors(::std::boxed::Box<DataConstructors<'tree>>),
10956 GadtConstructors(::std::boxed::Box<GadtConstructors<'tree>>),
10957}
10958impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeConstructors<'tree> {
10959 #[allow(clippy::collapsible_else_if)]
10960 fn from_node(
10961 node: ::tree_sitter::Node<'tree>,
10962 src: &'tree [u8],
10963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10964 match node.kind() {
10965 "data_constructors" => Ok(Self::DataConstructors(::std::boxed::Box::new(
10966 <DataConstructors as ::treesitter_types::FromNode>::from_node(node, src)?,
10967 ))),
10968 "gadt_constructors" => Ok(Self::GadtConstructors(::std::boxed::Box::new(
10969 <GadtConstructors as ::treesitter_types::FromNode>::from_node(node, src)?,
10970 ))),
10971 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10972 }
10973 }
10974}
10975impl ::treesitter_types::Spanned for DataTypeConstructors<'_> {
10976 fn span(&self) -> ::treesitter_types::Span {
10977 match self {
10978 Self::DataConstructors(inner) => inner.span(),
10979 Self::GadtConstructors(inner) => inner.span(),
10980 }
10981 }
10982}
10983#[derive(Debug, Clone, PartialEq, Eq)]
10984pub enum DataTypeForall<'tree> {
10985 Forall(::std::boxed::Box<Forall<'tree>>),
10986 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
10987}
10988impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeForall<'tree> {
10989 #[allow(clippy::collapsible_else_if)]
10990 fn from_node(
10991 node: ::tree_sitter::Node<'tree>,
10992 src: &'tree [u8],
10993 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10994 match node.kind() {
10995 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
10996 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
10997 ))),
10998 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
10999 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
11000 ))),
11001 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11002 }
11003 }
11004}
11005impl ::treesitter_types::Spanned for DataTypeForall<'_> {
11006 fn span(&self) -> ::treesitter_types::Span {
11007 match self {
11008 Self::Forall(inner) => inner.span(),
11009 Self::ForallRequired(inner) => inner.span(),
11010 }
11011 }
11012}
11013#[derive(Debug, Clone, PartialEq, Eq)]
11014pub enum DataTypeName<'tree> {
11015 Name(::std::boxed::Box<Name<'tree>>),
11016 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11017 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
11018 Qualified(::std::boxed::Box<Qualified<'tree>>),
11019 Unit(::std::boxed::Box<Unit<'tree>>),
11020}
11021impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeName<'tree> {
11022 #[allow(clippy::collapsible_else_if)]
11023 fn from_node(
11024 node: ::tree_sitter::Node<'tree>,
11025 src: &'tree [u8],
11026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11027 match node.kind() {
11028 "name" => Ok(Self::Name(::std::boxed::Box::new(
11029 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11030 ))),
11031 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11032 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
11033 ))),
11034 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
11035 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
11036 ))),
11037 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11038 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11039 ))),
11040 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
11041 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
11042 ))),
11043 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11044 }
11045 }
11046}
11047impl ::treesitter_types::Spanned for DataTypeName<'_> {
11048 fn span(&self) -> ::treesitter_types::Span {
11049 match self {
11050 Self::Name(inner) => inner.span(),
11051 Self::PrefixId(inner) => inner.span(),
11052 Self::PrefixList(inner) => inner.span(),
11053 Self::Qualified(inner) => inner.span(),
11054 Self::Unit(inner) => inner.span(),
11055 }
11056 }
11057}
11058#[derive(Debug, Clone, PartialEq, Eq)]
11059pub enum DataTypePatterns<'tree> {
11060 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
11061 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
11062}
11063impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypePatterns<'tree> {
11064 #[allow(clippy::collapsible_else_if)]
11065 fn from_node(
11066 node: ::tree_sitter::Node<'tree>,
11067 src: &'tree [u8],
11068 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11069 match node.kind() {
11070 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
11071 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)?,
11072 ))),
11073 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
11074 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)?,
11075 ))),
11076 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11077 }
11078 }
11079}
11080impl ::treesitter_types::Spanned for DataTypePatterns<'_> {
11081 fn span(&self) -> ::treesitter_types::Span {
11082 match self {
11083 Self::TypeParams(inner) => inner.span(),
11084 Self::TypePatterns(inner) => inner.span(),
11085 }
11086 }
11087}
11088#[derive(Debug, Clone, PartialEq, Eq)]
11089pub enum DataTypeChildren<'tree> {
11090 Infix(::std::boxed::Box<Infix<'tree>>),
11091 Parens(::std::boxed::Box<Parens<'tree>>),
11092}
11093impl<'tree> ::treesitter_types::FromNode<'tree> for DataTypeChildren<'tree> {
11094 #[allow(clippy::collapsible_else_if)]
11095 fn from_node(
11096 node: ::tree_sitter::Node<'tree>,
11097 src: &'tree [u8],
11098 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11099 match node.kind() {
11100 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11101 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
11102 ))),
11103 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11104 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
11105 ))),
11106 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11107 }
11108 }
11109}
11110impl ::treesitter_types::Spanned for DataTypeChildren<'_> {
11111 fn span(&self) -> ::treesitter_types::Span {
11112 match self {
11113 Self::Infix(inner) => inner.span(),
11114 Self::Parens(inner) => inner.span(),
11115 }
11116 }
11117}
11118#[derive(Debug, Clone, PartialEq, Eq)]
11119pub enum DeclarationsChildren<'tree> {
11120 Declaration(::std::boxed::Box<Declaration<'tree>>),
11121 Import(::std::boxed::Box<Import<'tree>>),
11122}
11123impl<'tree> ::treesitter_types::FromNode<'tree> for DeclarationsChildren<'tree> {
11124 #[allow(clippy::collapsible_else_if)]
11125 fn from_node(
11126 node: ::tree_sitter::Node<'tree>,
11127 src: &'tree [u8],
11128 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11129 match node.kind() {
11130 "import" => Ok(Self::Import(::std::boxed::Box::new(
11131 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
11132 ))),
11133 _other => {
11134 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
11135 Ok(Self::Declaration(::std::boxed::Box::new(v)))
11136 } else {
11137 Err(::treesitter_types::ParseError::unexpected_kind(
11138 _other, node,
11139 ))
11140 }
11141 }
11142 }
11143 }
11144}
11145impl ::treesitter_types::Spanned for DeclarationsChildren<'_> {
11146 fn span(&self) -> ::treesitter_types::Span {
11147 match self {
11148 Self::Declaration(inner) => inner.span(),
11149 Self::Import(inner) => inner.span(),
11150 }
11151 }
11152}
11153#[derive(Debug, Clone, PartialEq, Eq)]
11154pub enum DefaultTypesType<'tree> {
11155 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11156 Signature(::std::boxed::Box<Signature<'tree>>),
11157}
11158impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultTypesType<'tree> {
11159 #[allow(clippy::collapsible_else_if)]
11160 fn from_node(
11161 node: ::tree_sitter::Node<'tree>,
11162 src: &'tree [u8],
11163 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11164 match node.kind() {
11165 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11166 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
11167 ))),
11168 _other => {
11169 if let Ok(v) =
11170 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11171 {
11172 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
11173 } else {
11174 Err(::treesitter_types::ParseError::unexpected_kind(
11175 _other, node,
11176 ))
11177 }
11178 }
11179 }
11180 }
11181}
11182impl ::treesitter_types::Spanned for DefaultTypesType<'_> {
11183 fn span(&self) -> ::treesitter_types::Span {
11184 match self {
11185 Self::QuantifiedType(inner) => inner.span(),
11186 Self::Signature(inner) => inner.span(),
11187 }
11188 }
11189}
11190#[derive(Debug, Clone, PartialEq, Eq)]
11191pub enum DerivingInstanceForall<'tree> {
11192 Forall(::std::boxed::Box<Forall<'tree>>),
11193 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
11194}
11195impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceForall<'tree> {
11196 #[allow(clippy::collapsible_else_if)]
11197 fn from_node(
11198 node: ::tree_sitter::Node<'tree>,
11199 src: &'tree [u8],
11200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11201 match node.kind() {
11202 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
11203 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
11204 ))),
11205 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
11206 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
11207 ))),
11208 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11209 }
11210 }
11211}
11212impl ::treesitter_types::Spanned for DerivingInstanceForall<'_> {
11213 fn span(&self) -> ::treesitter_types::Span {
11214 match self {
11215 Self::Forall(inner) => inner.span(),
11216 Self::ForallRequired(inner) => inner.span(),
11217 }
11218 }
11219}
11220#[derive(Debug, Clone, PartialEq, Eq)]
11221pub enum DerivingInstanceName<'tree> {
11222 Name(::std::boxed::Box<Name<'tree>>),
11223 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11224 Qualified(::std::boxed::Box<Qualified<'tree>>),
11225}
11226impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceName<'tree> {
11227 #[allow(clippy::collapsible_else_if)]
11228 fn from_node(
11229 node: ::tree_sitter::Node<'tree>,
11230 src: &'tree [u8],
11231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11232 match node.kind() {
11233 "name" => Ok(Self::Name(::std::boxed::Box::new(
11234 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11235 ))),
11236 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11237 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
11238 ))),
11239 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11240 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11241 ))),
11242 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11243 }
11244 }
11245}
11246impl ::treesitter_types::Spanned for DerivingInstanceName<'_> {
11247 fn span(&self) -> ::treesitter_types::Span {
11248 match self {
11249 Self::Name(inner) => inner.span(),
11250 Self::PrefixId(inner) => inner.span(),
11251 Self::Qualified(inner) => inner.span(),
11252 }
11253 }
11254}
11255#[derive(Debug, Clone, PartialEq, Eq)]
11256pub enum DerivingInstanceChildren<'tree> {
11257 Infix(::std::boxed::Box<Infix<'tree>>),
11258 Parens(::std::boxed::Box<Parens<'tree>>),
11259}
11260impl<'tree> ::treesitter_types::FromNode<'tree> for DerivingInstanceChildren<'tree> {
11261 #[allow(clippy::collapsible_else_if)]
11262 fn from_node(
11263 node: ::tree_sitter::Node<'tree>,
11264 src: &'tree [u8],
11265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11266 match node.kind() {
11267 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11268 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
11269 ))),
11270 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11271 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
11272 ))),
11273 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11274 }
11275 }
11276}
11277impl ::treesitter_types::Spanned for DerivingInstanceChildren<'_> {
11278 fn span(&self) -> ::treesitter_types::Span {
11279 match self {
11280 Self::Infix(inner) => inner.span(),
11281 Self::Parens(inner) => inner.span(),
11282 }
11283 }
11284}
11285#[derive(Debug, Clone, PartialEq, Eq)]
11286pub enum DoModuleId {
11287 Do(::treesitter_types::Span),
11288 Mdo(::treesitter_types::Span),
11289}
11290impl<'tree> ::treesitter_types::FromNode<'tree> for DoModuleId {
11291 #[allow(clippy::collapsible_else_if)]
11292 fn from_node(
11293 node: ::tree_sitter::Node<'tree>,
11294 _src: &'tree [u8],
11295 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11296 match node.kind() {
11297 "do" => Ok(Self::Do(::treesitter_types::Span::from(node))),
11298 "mdo" => Ok(Self::Mdo(::treesitter_types::Span::from(node))),
11299 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11300 }
11301 }
11302}
11303impl ::treesitter_types::Spanned for DoModuleId {
11304 fn span(&self) -> ::treesitter_types::Span {
11305 match self {
11306 Self::Do(span) => *span,
11307 Self::Mdo(span) => *span,
11308 }
11309 }
11310}
11311#[derive(Debug, Clone, PartialEq, Eq)]
11312pub enum EquationForall<'tree> {
11313 Forall(::std::boxed::Box<Forall<'tree>>),
11314 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
11315}
11316impl<'tree> ::treesitter_types::FromNode<'tree> for EquationForall<'tree> {
11317 #[allow(clippy::collapsible_else_if)]
11318 fn from_node(
11319 node: ::tree_sitter::Node<'tree>,
11320 src: &'tree [u8],
11321 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11322 match node.kind() {
11323 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
11324 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
11325 ))),
11326 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
11327 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
11328 ))),
11329 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11330 }
11331 }
11332}
11333impl ::treesitter_types::Spanned for EquationForall<'_> {
11334 fn span(&self) -> ::treesitter_types::Span {
11335 match self {
11336 Self::Forall(inner) => inner.span(),
11337 Self::ForallRequired(inner) => inner.span(),
11338 }
11339 }
11340}
11341#[derive(Debug, Clone, PartialEq, Eq)]
11342pub enum EquationName<'tree> {
11343 Name(::std::boxed::Box<Name<'tree>>),
11344 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11345 Qualified(::std::boxed::Box<Qualified<'tree>>),
11346}
11347impl<'tree> ::treesitter_types::FromNode<'tree> for EquationName<'tree> {
11348 #[allow(clippy::collapsible_else_if)]
11349 fn from_node(
11350 node: ::tree_sitter::Node<'tree>,
11351 src: &'tree [u8],
11352 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11353 match node.kind() {
11354 "name" => Ok(Self::Name(::std::boxed::Box::new(
11355 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11356 ))),
11357 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11358 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
11359 ))),
11360 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11361 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11362 ))),
11363 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11364 }
11365 }
11366}
11367impl ::treesitter_types::Spanned for EquationName<'_> {
11368 fn span(&self) -> ::treesitter_types::Span {
11369 match self {
11370 Self::Name(inner) => inner.span(),
11371 Self::PrefixId(inner) => inner.span(),
11372 Self::Qualified(inner) => inner.span(),
11373 }
11374 }
11375}
11376#[derive(Debug, Clone, PartialEq, Eq)]
11377pub enum EquationPattern<'tree> {
11378 Pattern(::std::boxed::Box<Pattern<'tree>>),
11379 Signature(::std::boxed::Box<Signature<'tree>>),
11380}
11381impl<'tree> ::treesitter_types::FromNode<'tree> for EquationPattern<'tree> {
11382 #[allow(clippy::collapsible_else_if)]
11383 fn from_node(
11384 node: ::tree_sitter::Node<'tree>,
11385 src: &'tree [u8],
11386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11387 match node.kind() {
11388 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11389 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
11390 ))),
11391 _other => {
11392 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
11393 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11394 } else {
11395 Err(::treesitter_types::ParseError::unexpected_kind(
11396 _other, node,
11397 ))
11398 }
11399 }
11400 }
11401 }
11402}
11403impl ::treesitter_types::Spanned for EquationPattern<'_> {
11404 fn span(&self) -> ::treesitter_types::Span {
11405 match self {
11406 Self::Pattern(inner) => inner.span(),
11407 Self::Signature(inner) => inner.span(),
11408 }
11409 }
11410}
11411#[derive(Debug, Clone, PartialEq, Eq)]
11412pub enum EquationChildren<'tree> {
11413 Infix(::std::boxed::Box<Infix<'tree>>),
11414 Parens(::std::boxed::Box<Parens<'tree>>),
11415 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11416}
11417impl<'tree> ::treesitter_types::FromNode<'tree> for EquationChildren<'tree> {
11418 #[allow(clippy::collapsible_else_if)]
11419 fn from_node(
11420 node: ::tree_sitter::Node<'tree>,
11421 src: &'tree [u8],
11422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11423 match node.kind() {
11424 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
11425 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
11426 ))),
11427 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
11428 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
11429 ))),
11430 _other => {
11431 if let Ok(v) =
11432 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11433 {
11434 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
11435 } else {
11436 Err(::treesitter_types::ParseError::unexpected_kind(
11437 _other, node,
11438 ))
11439 }
11440 }
11441 }
11442 }
11443}
11444impl ::treesitter_types::Spanned for EquationChildren<'_> {
11445 fn span(&self) -> ::treesitter_types::Span {
11446 match self {
11447 Self::Infix(inner) => inner.span(),
11448 Self::Parens(inner) => inner.span(),
11449 Self::QuantifiedType(inner) => inner.span(),
11450 }
11451 }
11452}
11453#[derive(Debug, Clone, PartialEq, Eq)]
11454pub enum ExpChildren<'tree> {
11455 Expression(::std::boxed::Box<Expression<'tree>>),
11456 Signature(::std::boxed::Box<Signature<'tree>>),
11457}
11458impl<'tree> ::treesitter_types::FromNode<'tree> for ExpChildren<'tree> {
11459 #[allow(clippy::collapsible_else_if)]
11460 fn from_node(
11461 node: ::tree_sitter::Node<'tree>,
11462 src: &'tree [u8],
11463 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11464 match node.kind() {
11465 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11466 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
11467 ))),
11468 _other => {
11469 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11470 Ok(Self::Expression(::std::boxed::Box::new(v)))
11471 } else {
11472 Err(::treesitter_types::ParseError::unexpected_kind(
11473 _other, node,
11474 ))
11475 }
11476 }
11477 }
11478 }
11479}
11480impl ::treesitter_types::Spanned for ExpChildren<'_> {
11481 fn span(&self) -> ::treesitter_types::Span {
11482 match self {
11483 Self::Expression(inner) => inner.span(),
11484 Self::Signature(inner) => inner.span(),
11485 }
11486 }
11487}
11488#[derive(Debug, Clone, PartialEq, Eq)]
11489pub enum ExportType<'tree> {
11490 Name(::std::boxed::Box<Name<'tree>>),
11491 Qualified(::std::boxed::Box<Qualified<'tree>>),
11492}
11493impl<'tree> ::treesitter_types::FromNode<'tree> for ExportType<'tree> {
11494 #[allow(clippy::collapsible_else_if)]
11495 fn from_node(
11496 node: ::tree_sitter::Node<'tree>,
11497 src: &'tree [u8],
11498 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11499 match node.kind() {
11500 "name" => Ok(Self::Name(::std::boxed::Box::new(
11501 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
11502 ))),
11503 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11504 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11505 ))),
11506 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11507 }
11508 }
11509}
11510impl ::treesitter_types::Spanned for ExportType<'_> {
11511 fn span(&self) -> ::treesitter_types::Span {
11512 match self {
11513 Self::Name(inner) => inner.span(),
11514 Self::Qualified(inner) => inner.span(),
11515 }
11516 }
11517}
11518#[derive(Debug, Clone, PartialEq, Eq)]
11519pub enum ExportVariable<'tree> {
11520 Qualified(::std::boxed::Box<Qualified<'tree>>),
11521 Variable(::std::boxed::Box<Variable<'tree>>),
11522}
11523impl<'tree> ::treesitter_types::FromNode<'tree> for ExportVariable<'tree> {
11524 #[allow(clippy::collapsible_else_if)]
11525 fn from_node(
11526 node: ::tree_sitter::Node<'tree>,
11527 src: &'tree [u8],
11528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11529 match node.kind() {
11530 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11531 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11532 ))),
11533 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
11534 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
11535 ))),
11536 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11537 }
11538 }
11539}
11540impl ::treesitter_types::Spanned for ExportVariable<'_> {
11541 fn span(&self) -> ::treesitter_types::Span {
11542 match self {
11543 Self::Qualified(inner) => inner.span(),
11544 Self::Variable(inner) => inner.span(),
11545 }
11546 }
11547}
11548#[derive(Debug, Clone, PartialEq, Eq)]
11549pub enum FieldParameter<'tree> {
11550 LazyField(::std::boxed::Box<LazyField<'tree>>),
11551 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11552 StrictField(::std::boxed::Box<StrictField<'tree>>),
11553}
11554impl<'tree> ::treesitter_types::FromNode<'tree> for FieldParameter<'tree> {
11555 #[allow(clippy::collapsible_else_if)]
11556 fn from_node(
11557 node: ::tree_sitter::Node<'tree>,
11558 src: &'tree [u8],
11559 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11560 match node.kind() {
11561 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
11562 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
11563 ))),
11564 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
11565 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
11566 ))),
11567 _other => {
11568 if let Ok(v) =
11569 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11570 {
11571 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
11572 } else {
11573 Err(::treesitter_types::ParseError::unexpected_kind(
11574 _other, node,
11575 ))
11576 }
11577 }
11578 }
11579 }
11580}
11581impl ::treesitter_types::Spanned for FieldParameter<'_> {
11582 fn span(&self) -> ::treesitter_types::Span {
11583 match self {
11584 Self::LazyField(inner) => inner.span(),
11585 Self::QuantifiedType(inner) => inner.span(),
11586 Self::StrictField(inner) => inner.span(),
11587 }
11588 }
11589}
11590#[derive(Debug, Clone, PartialEq, Eq)]
11591pub enum FieldType<'tree> {
11592 LazyField(::std::boxed::Box<LazyField<'tree>>),
11593 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11594 StrictField(::std::boxed::Box<StrictField<'tree>>),
11595}
11596impl<'tree> ::treesitter_types::FromNode<'tree> for FieldType<'tree> {
11597 #[allow(clippy::collapsible_else_if)]
11598 fn from_node(
11599 node: ::tree_sitter::Node<'tree>,
11600 src: &'tree [u8],
11601 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11602 match node.kind() {
11603 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
11604 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
11605 ))),
11606 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
11607 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
11608 ))),
11609 _other => {
11610 if let Ok(v) =
11611 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11612 {
11613 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
11614 } else {
11615 Err(::treesitter_types::ParseError::unexpected_kind(
11616 _other, node,
11617 ))
11618 }
11619 }
11620 }
11621 }
11622}
11623impl ::treesitter_types::Spanned for FieldType<'_> {
11624 fn span(&self) -> ::treesitter_types::Span {
11625 match self {
11626 Self::LazyField(inner) => inner.span(),
11627 Self::QuantifiedType(inner) => inner.span(),
11628 Self::StrictField(inner) => inner.span(),
11629 }
11630 }
11631}
11632#[derive(Debug, Clone, PartialEq, Eq)]
11633pub enum FieldPathField<'tree> {
11634 FieldName(::std::boxed::Box<FieldName<'tree>>),
11635 Qualified(::std::boxed::Box<Qualified<'tree>>),
11636}
11637impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPathField<'tree> {
11638 #[allow(clippy::collapsible_else_if)]
11639 fn from_node(
11640 node: ::tree_sitter::Node<'tree>,
11641 src: &'tree [u8],
11642 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11643 match node.kind() {
11644 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
11645 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)?,
11646 ))),
11647 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11648 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11649 ))),
11650 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11651 }
11652 }
11653}
11654impl ::treesitter_types::Spanned for FieldPathField<'_> {
11655 fn span(&self) -> ::treesitter_types::Span {
11656 match self {
11657 Self::FieldName(inner) => inner.span(),
11658 Self::Qualified(inner) => inner.span(),
11659 }
11660 }
11661}
11662#[derive(Debug, Clone, PartialEq, Eq)]
11663pub enum FieldPatternField<'tree> {
11664 FieldName(::std::boxed::Box<FieldName<'tree>>),
11665 Qualified(::std::boxed::Box<Qualified<'tree>>),
11666}
11667impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternField<'tree> {
11668 #[allow(clippy::collapsible_else_if)]
11669 fn from_node(
11670 node: ::tree_sitter::Node<'tree>,
11671 src: &'tree [u8],
11672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11673 match node.kind() {
11674 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
11675 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)?,
11676 ))),
11677 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11678 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11679 ))),
11680 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11681 }
11682 }
11683}
11684impl ::treesitter_types::Spanned for FieldPatternField<'_> {
11685 fn span(&self) -> ::treesitter_types::Span {
11686 match self {
11687 Self::FieldName(inner) => inner.span(),
11688 Self::Qualified(inner) => inner.span(),
11689 }
11690 }
11691}
11692#[derive(Debug, Clone, PartialEq, Eq)]
11693pub enum FieldPatternPattern<'tree> {
11694 Pattern(::std::boxed::Box<Pattern<'tree>>),
11695 Signature(::std::boxed::Box<Signature<'tree>>),
11696 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
11697}
11698impl<'tree> ::treesitter_types::FromNode<'tree> for FieldPatternPattern<'tree> {
11699 #[allow(clippy::collapsible_else_if)]
11700 fn from_node(
11701 node: ::tree_sitter::Node<'tree>,
11702 src: &'tree [u8],
11703 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11704 match node.kind() {
11705 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11706 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
11707 ))),
11708 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
11709 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
11710 ))),
11711 _other => {
11712 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
11713 Ok(Self::Pattern(::std::boxed::Box::new(v)))
11714 } else {
11715 Err(::treesitter_types::ParseError::unexpected_kind(
11716 _other, node,
11717 ))
11718 }
11719 }
11720 }
11721 }
11722}
11723impl ::treesitter_types::Spanned for FieldPatternPattern<'_> {
11724 fn span(&self) -> ::treesitter_types::Span {
11725 match self {
11726 Self::Pattern(inner) => inner.span(),
11727 Self::Signature(inner) => inner.span(),
11728 Self::ViewPattern(inner) => inner.span(),
11729 }
11730 }
11731}
11732#[derive(Debug, Clone, PartialEq, Eq)]
11733pub enum FieldUpdateExpression<'tree> {
11734 Expression(::std::boxed::Box<Expression<'tree>>),
11735 Signature(::std::boxed::Box<Signature<'tree>>),
11736}
11737impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdateExpression<'tree> {
11738 #[allow(clippy::collapsible_else_if)]
11739 fn from_node(
11740 node: ::tree_sitter::Node<'tree>,
11741 src: &'tree [u8],
11742 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11743 match node.kind() {
11744 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
11745 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
11746 ))),
11747 _other => {
11748 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11749 Ok(Self::Expression(::std::boxed::Box::new(v)))
11750 } else {
11751 Err(::treesitter_types::ParseError::unexpected_kind(
11752 _other, node,
11753 ))
11754 }
11755 }
11756 }
11757 }
11758}
11759impl ::treesitter_types::Spanned for FieldUpdateExpression<'_> {
11760 fn span(&self) -> ::treesitter_types::Span {
11761 match self {
11762 Self::Expression(inner) => inner.span(),
11763 Self::Signature(inner) => inner.span(),
11764 }
11765 }
11766}
11767#[derive(Debug, Clone, PartialEq, Eq)]
11768pub enum FieldUpdateField<'tree> {
11769 FieldName(::std::boxed::Box<FieldName<'tree>>),
11770 FieldPath(::std::boxed::Box<FieldPath<'tree>>),
11771 Qualified(::std::boxed::Box<Qualified<'tree>>),
11772}
11773impl<'tree> ::treesitter_types::FromNode<'tree> for FieldUpdateField<'tree> {
11774 #[allow(clippy::collapsible_else_if)]
11775 fn from_node(
11776 node: ::tree_sitter::Node<'tree>,
11777 src: &'tree [u8],
11778 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11779 match node.kind() {
11780 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
11781 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)?,
11782 ))),
11783 "field_path" => Ok(Self::FieldPath(::std::boxed::Box::new(
11784 <FieldPath as ::treesitter_types::FromNode>::from_node(node, src)?,
11785 ))),
11786 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
11787 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
11788 ))),
11789 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11790 }
11791 }
11792}
11793impl ::treesitter_types::Spanned for FieldUpdateField<'_> {
11794 fn span(&self) -> ::treesitter_types::Span {
11795 match self {
11796 Self::FieldName(inner) => inner.span(),
11797 Self::FieldPath(inner) => inner.span(),
11798 Self::Qualified(inner) => inner.span(),
11799 }
11800 }
11801}
11802#[derive(Debug, Clone, PartialEq, Eq)]
11803pub enum FixityAssociativity {
11804 Infix(::treesitter_types::Span),
11805 Infixl(::treesitter_types::Span),
11806 Infixr(::treesitter_types::Span),
11807}
11808impl<'tree> ::treesitter_types::FromNode<'tree> for FixityAssociativity {
11809 #[allow(clippy::collapsible_else_if)]
11810 fn from_node(
11811 node: ::tree_sitter::Node<'tree>,
11812 _src: &'tree [u8],
11813 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11814 match node.kind() {
11815 "infix" => Ok(Self::Infix(::treesitter_types::Span::from(node))),
11816 "infixl" => Ok(Self::Infixl(::treesitter_types::Span::from(node))),
11817 "infixr" => Ok(Self::Infixr(::treesitter_types::Span::from(node))),
11818 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11819 }
11820 }
11821}
11822impl ::treesitter_types::Spanned for FixityAssociativity {
11823 fn span(&self) -> ::treesitter_types::Span {
11824 match self {
11825 Self::Infix(span) => *span,
11826 Self::Infixl(span) => *span,
11827 Self::Infixr(span) => *span,
11828 }
11829 }
11830}
11831#[derive(Debug, Clone, PartialEq, Eq)]
11832pub enum FixityOperator<'tree> {
11833 Comma(::treesitter_types::Span),
11834 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
11835 InfixId(::std::boxed::Box<InfixId<'tree>>),
11836 Operator(::std::boxed::Box<Operator<'tree>>),
11837}
11838impl<'tree> ::treesitter_types::FromNode<'tree> for FixityOperator<'tree> {
11839 #[allow(clippy::collapsible_else_if)]
11840 fn from_node(
11841 node: ::tree_sitter::Node<'tree>,
11842 src: &'tree [u8],
11843 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11844 match node.kind() {
11845 "," => Ok(Self::Comma(::treesitter_types::Span::from(node))),
11846 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
11847 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
11848 ))),
11849 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
11850 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)?,
11851 ))),
11852 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
11853 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
11854 ))),
11855 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11856 }
11857 }
11858}
11859impl ::treesitter_types::Spanned for FixityOperator<'_> {
11860 fn span(&self) -> ::treesitter_types::Span {
11861 match self {
11862 Self::Comma(span) => *span,
11863 Self::ConstructorOperator(inner) => inner.span(),
11864 Self::InfixId(inner) => inner.span(),
11865 Self::Operator(inner) => inner.span(),
11866 }
11867 }
11868}
11869#[derive(Debug, Clone, PartialEq, Eq)]
11870pub enum ForallQuantifier {
11871 Forall(::treesitter_types::Span),
11872 X(::treesitter_types::Span),
11873}
11874impl<'tree> ::treesitter_types::FromNode<'tree> for ForallQuantifier {
11875 #[allow(clippy::collapsible_else_if)]
11876 fn from_node(
11877 node: ::tree_sitter::Node<'tree>,
11878 _src: &'tree [u8],
11879 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11880 match node.kind() {
11881 "forall" => Ok(Self::Forall(::treesitter_types::Span::from(node))),
11882 "∀" => Ok(Self::X(::treesitter_types::Span::from(node))),
11883 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11884 }
11885 }
11886}
11887impl ::treesitter_types::Spanned for ForallQuantifier {
11888 fn span(&self) -> ::treesitter_types::Span {
11889 match self {
11890 Self::Forall(span) => *span,
11891 Self::X(span) => *span,
11892 }
11893 }
11894}
11895#[derive(Debug, Clone, PartialEq, Eq)]
11896pub enum ForallRequiredQuantifier {
11897 Forall(::treesitter_types::Span),
11898 X(::treesitter_types::Span),
11899}
11900impl<'tree> ::treesitter_types::FromNode<'tree> for ForallRequiredQuantifier {
11901 #[allow(clippy::collapsible_else_if)]
11902 fn from_node(
11903 node: ::tree_sitter::Node<'tree>,
11904 _src: &'tree [u8],
11905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11906 match node.kind() {
11907 "forall" => Ok(Self::Forall(::treesitter_types::Span::from(node))),
11908 "∀" => Ok(Self::X(::treesitter_types::Span::from(node))),
11909 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11910 }
11911 }
11912}
11913impl ::treesitter_types::Spanned for ForallRequiredQuantifier {
11914 fn span(&self) -> ::treesitter_types::Span {
11915 match self {
11916 Self::Forall(span) => *span,
11917 Self::X(span) => *span,
11918 }
11919 }
11920}
11921#[derive(Debug, Clone, PartialEq, Eq)]
11922pub enum FunctionArrow {
11923 Arrow(::treesitter_types::Span),
11924 X(::treesitter_types::Span),
11925}
11926impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionArrow {
11927 #[allow(clippy::collapsible_else_if)]
11928 fn from_node(
11929 node: ::tree_sitter::Node<'tree>,
11930 _src: &'tree [u8],
11931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11932 match node.kind() {
11933 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
11934 "→" => Ok(Self::X(::treesitter_types::Span::from(node))),
11935 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11936 }
11937 }
11938}
11939impl ::treesitter_types::Spanned for FunctionArrow {
11940 fn span(&self) -> ::treesitter_types::Span {
11941 match self {
11942 Self::Arrow(span) => *span,
11943 Self::X(span) => *span,
11944 }
11945 }
11946}
11947#[derive(Debug, Clone, PartialEq, Eq)]
11948pub enum FunctionName<'tree> {
11949 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
11950 Variable(::std::boxed::Box<Variable<'tree>>),
11951}
11952impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionName<'tree> {
11953 #[allow(clippy::collapsible_else_if)]
11954 fn from_node(
11955 node: ::tree_sitter::Node<'tree>,
11956 src: &'tree [u8],
11957 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11958 match node.kind() {
11959 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
11960 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
11961 ))),
11962 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
11963 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
11964 ))),
11965 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11966 }
11967 }
11968}
11969impl ::treesitter_types::Spanned for FunctionName<'_> {
11970 fn span(&self) -> ::treesitter_types::Span {
11971 match self {
11972 Self::PrefixId(inner) => inner.span(),
11973 Self::Variable(inner) => inner.span(),
11974 }
11975 }
11976}
11977#[derive(Debug, Clone, PartialEq, Eq)]
11978pub enum FunctionParameter<'tree> {
11979 LazyField(::std::boxed::Box<LazyField<'tree>>),
11980 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
11981 StrictField(::std::boxed::Box<StrictField<'tree>>),
11982}
11983impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionParameter<'tree> {
11984 #[allow(clippy::collapsible_else_if)]
11985 fn from_node(
11986 node: ::tree_sitter::Node<'tree>,
11987 src: &'tree [u8],
11988 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11989 match node.kind() {
11990 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
11991 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
11992 ))),
11993 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
11994 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
11995 ))),
11996 _other => {
11997 if let Ok(v) =
11998 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
11999 {
12000 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12001 } else {
12002 Err(::treesitter_types::ParseError::unexpected_kind(
12003 _other, node,
12004 ))
12005 }
12006 }
12007 }
12008 }
12009}
12010impl ::treesitter_types::Spanned for FunctionParameter<'_> {
12011 fn span(&self) -> ::treesitter_types::Span {
12012 match self {
12013 Self::LazyField(inner) => inner.span(),
12014 Self::QuantifiedType(inner) => inner.span(),
12015 Self::StrictField(inner) => inner.span(),
12016 }
12017 }
12018}
12019#[derive(Debug, Clone, PartialEq, Eq)]
12020pub enum FunctionHeadParensName<'tree> {
12021 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12022 Variable(::std::boxed::Box<Variable<'tree>>),
12023}
12024impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionHeadParensName<'tree> {
12025 #[allow(clippy::collapsible_else_if)]
12026 fn from_node(
12027 node: ::tree_sitter::Node<'tree>,
12028 src: &'tree [u8],
12029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12030 match node.kind() {
12031 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12032 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12033 ))),
12034 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12035 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
12036 ))),
12037 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12038 }
12039 }
12040}
12041impl ::treesitter_types::Spanned for FunctionHeadParensName<'_> {
12042 fn span(&self) -> ::treesitter_types::Span {
12043 match self {
12044 Self::PrefixId(inner) => inner.span(),
12045 Self::Variable(inner) => inner.span(),
12046 }
12047 }
12048}
12049#[derive(Debug, Clone, PartialEq, Eq)]
12050pub enum GadtConstructorForall<'tree> {
12051 Forall(::std::boxed::Box<Forall<'tree>>),
12052 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
12053}
12054impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorForall<'tree> {
12055 #[allow(clippy::collapsible_else_if)]
12056 fn from_node(
12057 node: ::tree_sitter::Node<'tree>,
12058 src: &'tree [u8],
12059 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12060 match node.kind() {
12061 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
12062 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
12063 ))),
12064 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
12065 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
12066 ))),
12067 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12068 }
12069 }
12070}
12071impl ::treesitter_types::Spanned for GadtConstructorForall<'_> {
12072 fn span(&self) -> ::treesitter_types::Span {
12073 match self {
12074 Self::Forall(inner) => inner.span(),
12075 Self::ForallRequired(inner) => inner.span(),
12076 }
12077 }
12078}
12079#[derive(Debug, Clone, PartialEq, Eq)]
12080pub enum GadtConstructorName<'tree> {
12081 Constructor(::std::boxed::Box<Constructor<'tree>>),
12082 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12083}
12084impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorName<'tree> {
12085 #[allow(clippy::collapsible_else_if)]
12086 fn from_node(
12087 node: ::tree_sitter::Node<'tree>,
12088 src: &'tree [u8],
12089 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12090 match node.kind() {
12091 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
12092 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
12093 ))),
12094 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12095 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12096 ))),
12097 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12098 }
12099 }
12100}
12101impl ::treesitter_types::Spanned for GadtConstructorName<'_> {
12102 fn span(&self) -> ::treesitter_types::Span {
12103 match self {
12104 Self::Constructor(inner) => inner.span(),
12105 Self::PrefixId(inner) => inner.span(),
12106 }
12107 }
12108}
12109#[derive(Debug, Clone, PartialEq, Eq)]
12110pub enum GadtConstructorType<'tree> {
12111 Prefix(::std::boxed::Box<Prefix<'tree>>),
12112 Record(::std::boxed::Box<Record<'tree>>),
12113}
12114impl<'tree> ::treesitter_types::FromNode<'tree> for GadtConstructorType<'tree> {
12115 #[allow(clippy::collapsible_else_if)]
12116 fn from_node(
12117 node: ::tree_sitter::Node<'tree>,
12118 src: &'tree [u8],
12119 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12120 match node.kind() {
12121 "prefix" => Ok(Self::Prefix(::std::boxed::Box::new(
12122 <Prefix as ::treesitter_types::FromNode>::from_node(node, src)?,
12123 ))),
12124 "record" => Ok(Self::Record(::std::boxed::Box::new(
12125 <Record as ::treesitter_types::FromNode>::from_node(node, src)?,
12126 ))),
12127 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12128 }
12129 }
12130}
12131impl ::treesitter_types::Spanned for GadtConstructorType<'_> {
12132 fn span(&self) -> ::treesitter_types::Span {
12133 match self {
12134 Self::Prefix(inner) => inner.span(),
12135 Self::Record(inner) => inner.span(),
12136 }
12137 }
12138}
12139#[derive(Debug, Clone, PartialEq, Eq)]
12140pub enum GeneratorArrow {
12141 LArrow(::treesitter_types::Span),
12142 X(::treesitter_types::Span),
12143}
12144impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorArrow {
12145 #[allow(clippy::collapsible_else_if)]
12146 fn from_node(
12147 node: ::tree_sitter::Node<'tree>,
12148 _src: &'tree [u8],
12149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12150 match node.kind() {
12151 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
12152 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
12153 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12154 }
12155 }
12156}
12157impl ::treesitter_types::Spanned for GeneratorArrow {
12158 fn span(&self) -> ::treesitter_types::Span {
12159 match self {
12160 Self::LArrow(span) => *span,
12161 Self::X(span) => *span,
12162 }
12163 }
12164}
12165#[derive(Debug, Clone, PartialEq, Eq)]
12166pub enum GeneratorExpression<'tree> {
12167 Expression(::std::boxed::Box<Expression<'tree>>),
12168 Signature(::std::boxed::Box<Signature<'tree>>),
12169}
12170impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorExpression<'tree> {
12171 #[allow(clippy::collapsible_else_if)]
12172 fn from_node(
12173 node: ::tree_sitter::Node<'tree>,
12174 src: &'tree [u8],
12175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12176 match node.kind() {
12177 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12178 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12179 ))),
12180 _other => {
12181 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12182 Ok(Self::Expression(::std::boxed::Box::new(v)))
12183 } else {
12184 Err(::treesitter_types::ParseError::unexpected_kind(
12185 _other, node,
12186 ))
12187 }
12188 }
12189 }
12190 }
12191}
12192impl ::treesitter_types::Spanned for GeneratorExpression<'_> {
12193 fn span(&self) -> ::treesitter_types::Span {
12194 match self {
12195 Self::Expression(inner) => inner.span(),
12196 Self::Signature(inner) => inner.span(),
12197 }
12198 }
12199}
12200#[derive(Debug, Clone, PartialEq, Eq)]
12201pub enum GeneratorPattern<'tree> {
12202 Pattern(::std::boxed::Box<Pattern<'tree>>),
12203 Signature(::std::boxed::Box<Signature<'tree>>),
12204}
12205impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorPattern<'tree> {
12206 #[allow(clippy::collapsible_else_if)]
12207 fn from_node(
12208 node: ::tree_sitter::Node<'tree>,
12209 src: &'tree [u8],
12210 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12211 match node.kind() {
12212 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12213 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12214 ))),
12215 _other => {
12216 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12217 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12218 } else {
12219 Err(::treesitter_types::ParseError::unexpected_kind(
12220 _other, node,
12221 ))
12222 }
12223 }
12224 }
12225 }
12226}
12227impl ::treesitter_types::Spanned for GeneratorPattern<'_> {
12228 fn span(&self) -> ::treesitter_types::Span {
12229 match self {
12230 Self::Pattern(inner) => inner.span(),
12231 Self::Signature(inner) => inner.span(),
12232 }
12233 }
12234}
12235#[derive(Debug, Clone, PartialEq, Eq)]
12236pub enum GroupClassifier<'tree> {
12237 Expression(::std::boxed::Box<Expression<'tree>>),
12238 Signature(::std::boxed::Box<Signature<'tree>>),
12239}
12240impl<'tree> ::treesitter_types::FromNode<'tree> for GroupClassifier<'tree> {
12241 #[allow(clippy::collapsible_else_if)]
12242 fn from_node(
12243 node: ::tree_sitter::Node<'tree>,
12244 src: &'tree [u8],
12245 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12246 match node.kind() {
12247 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12248 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12249 ))),
12250 _other => {
12251 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12252 Ok(Self::Expression(::std::boxed::Box::new(v)))
12253 } else {
12254 Err(::treesitter_types::ParseError::unexpected_kind(
12255 _other, node,
12256 ))
12257 }
12258 }
12259 }
12260 }
12261}
12262impl ::treesitter_types::Spanned for GroupClassifier<'_> {
12263 fn span(&self) -> ::treesitter_types::Span {
12264 match self {
12265 Self::Expression(inner) => inner.span(),
12266 Self::Signature(inner) => inner.span(),
12267 }
12268 }
12269}
12270#[derive(Debug, Clone, PartialEq, Eq)]
12271pub enum GroupKey<'tree> {
12272 Expression(::std::boxed::Box<Expression<'tree>>),
12273 Signature(::std::boxed::Box<Signature<'tree>>),
12274}
12275impl<'tree> ::treesitter_types::FromNode<'tree> for GroupKey<'tree> {
12276 #[allow(clippy::collapsible_else_if)]
12277 fn from_node(
12278 node: ::tree_sitter::Node<'tree>,
12279 src: &'tree [u8],
12280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12281 match node.kind() {
12282 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12283 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12284 ))),
12285 _other => {
12286 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12287 Ok(Self::Expression(::std::boxed::Box::new(v)))
12288 } else {
12289 Err(::treesitter_types::ParseError::unexpected_kind(
12290 _other, node,
12291 ))
12292 }
12293 }
12294 }
12295 }
12296}
12297impl ::treesitter_types::Spanned for GroupKey<'_> {
12298 fn span(&self) -> ::treesitter_types::Span {
12299 match self {
12300 Self::Expression(inner) => inner.span(),
12301 Self::Signature(inner) => inner.span(),
12302 }
12303 }
12304}
12305#[derive(Debug, Clone, PartialEq, Eq)]
12306pub enum ImportNameType<'tree> {
12307 Name(::std::boxed::Box<Name<'tree>>),
12308 Qualified(::std::boxed::Box<Qualified<'tree>>),
12309}
12310impl<'tree> ::treesitter_types::FromNode<'tree> for ImportNameType<'tree> {
12311 #[allow(clippy::collapsible_else_if)]
12312 fn from_node(
12313 node: ::tree_sitter::Node<'tree>,
12314 src: &'tree [u8],
12315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12316 match node.kind() {
12317 "name" => Ok(Self::Name(::std::boxed::Box::new(
12318 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12319 ))),
12320 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12321 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12322 ))),
12323 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12324 }
12325 }
12326}
12327impl ::treesitter_types::Spanned for ImportNameType<'_> {
12328 fn span(&self) -> ::treesitter_types::Span {
12329 match self {
12330 Self::Name(inner) => inner.span(),
12331 Self::Qualified(inner) => inner.span(),
12332 }
12333 }
12334}
12335#[derive(Debug, Clone, PartialEq, Eq)]
12336pub enum ImportNameVariable<'tree> {
12337 Qualified(::std::boxed::Box<Qualified<'tree>>),
12338 Variable(::std::boxed::Box<Variable<'tree>>),
12339}
12340impl<'tree> ::treesitter_types::FromNode<'tree> for ImportNameVariable<'tree> {
12341 #[allow(clippy::collapsible_else_if)]
12342 fn from_node(
12343 node: ::tree_sitter::Node<'tree>,
12344 src: &'tree [u8],
12345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12346 match node.kind() {
12347 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12348 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12349 ))),
12350 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12351 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
12352 ))),
12353 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12354 }
12355 }
12356}
12357impl ::treesitter_types::Spanned for ImportNameVariable<'_> {
12358 fn span(&self) -> ::treesitter_types::Span {
12359 match self {
12360 Self::Qualified(inner) => inner.span(),
12361 Self::Variable(inner) => inner.span(),
12362 }
12363 }
12364}
12365#[derive(Debug, Clone, PartialEq, Eq)]
12366pub enum InferredChildren<'tree> {
12367 Annotated(::std::boxed::Box<Annotated<'tree>>),
12368 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
12369}
12370impl<'tree> ::treesitter_types::FromNode<'tree> for InferredChildren<'tree> {
12371 #[allow(clippy::collapsible_else_if)]
12372 fn from_node(
12373 node: ::tree_sitter::Node<'tree>,
12374 src: &'tree [u8],
12375 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12376 match node.kind() {
12377 "annotated" => Ok(Self::Annotated(::std::boxed::Box::new(
12378 <Annotated as ::treesitter_types::FromNode>::from_node(node, src)?,
12379 ))),
12380 _other => {
12381 if let Ok(v) = <TypeParam as ::treesitter_types::FromNode>::from_node(node, src) {
12382 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
12383 } else {
12384 Err(::treesitter_types::ParseError::unexpected_kind(
12385 _other, node,
12386 ))
12387 }
12388 }
12389 }
12390 }
12391}
12392impl ::treesitter_types::Spanned for InferredChildren<'_> {
12393 fn span(&self) -> ::treesitter_types::Span {
12394 match self {
12395 Self::Annotated(inner) => inner.span(),
12396 Self::TypeParam(inner) => inner.span(),
12397 }
12398 }
12399}
12400#[derive(Debug, Clone, PartialEq, Eq)]
12401pub enum InfixLeftOperand<'tree> {
12402 Expression(::std::boxed::Box<Expression<'tree>>),
12403 LazyField(::std::boxed::Box<LazyField<'tree>>),
12404 Pattern(::std::boxed::Box<Pattern<'tree>>),
12405 StrictField(::std::boxed::Box<StrictField<'tree>>),
12406 Type(::std::boxed::Box<Type<'tree>>),
12407 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
12408}
12409impl<'tree> ::treesitter_types::FromNode<'tree> for InfixLeftOperand<'tree> {
12410 #[allow(clippy::collapsible_else_if)]
12411 fn from_node(
12412 node: ::tree_sitter::Node<'tree>,
12413 src: &'tree [u8],
12414 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12415 match node.kind() {
12416 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12417 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
12418 ))),
12419 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12420 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
12421 ))),
12422 _other => {
12423 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12424 Ok(Self::Expression(::std::boxed::Box::new(v)))
12425 } else {
12426 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12427 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12428 } else {
12429 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src)
12430 {
12431 Ok(Self::Type(::std::boxed::Box::new(v)))
12432 } else {
12433 if let Ok(v) =
12434 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
12435 {
12436 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
12437 } else {
12438 Err(::treesitter_types::ParseError::unexpected_kind(
12439 _other, node,
12440 ))
12441 }
12442 }
12443 }
12444 }
12445 }
12446 }
12447 }
12448}
12449impl ::treesitter_types::Spanned for InfixLeftOperand<'_> {
12450 fn span(&self) -> ::treesitter_types::Span {
12451 match self {
12452 Self::Expression(inner) => inner.span(),
12453 Self::LazyField(inner) => inner.span(),
12454 Self::Pattern(inner) => inner.span(),
12455 Self::StrictField(inner) => inner.span(),
12456 Self::Type(inner) => inner.span(),
12457 Self::TypeParam(inner) => inner.span(),
12458 }
12459 }
12460}
12461#[derive(Debug, Clone, PartialEq, Eq)]
12462pub enum InfixOperator<'tree> {
12463 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
12464 InfixId(::std::boxed::Box<InfixId<'tree>>),
12465 Operator(::std::boxed::Box<Operator<'tree>>),
12466 Promoted(::std::boxed::Box<Promoted<'tree>>),
12467 Qualified(::std::boxed::Box<Qualified<'tree>>),
12468}
12469impl<'tree> ::treesitter_types::FromNode<'tree> for InfixOperator<'tree> {
12470 #[allow(clippy::collapsible_else_if)]
12471 fn from_node(
12472 node: ::tree_sitter::Node<'tree>,
12473 src: &'tree [u8],
12474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12475 match node.kind() {
12476 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
12477 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
12478 ))),
12479 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
12480 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12481 ))),
12482 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
12483 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
12484 ))),
12485 "promoted" => Ok(Self::Promoted(::std::boxed::Box::new(
12486 <Promoted as ::treesitter_types::FromNode>::from_node(node, src)?,
12487 ))),
12488 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12489 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12490 ))),
12491 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12492 }
12493 }
12494}
12495impl ::treesitter_types::Spanned for InfixOperator<'_> {
12496 fn span(&self) -> ::treesitter_types::Span {
12497 match self {
12498 Self::ConstructorOperator(inner) => inner.span(),
12499 Self::InfixId(inner) => inner.span(),
12500 Self::Operator(inner) => inner.span(),
12501 Self::Promoted(inner) => inner.span(),
12502 Self::Qualified(inner) => inner.span(),
12503 }
12504 }
12505}
12506#[derive(Debug, Clone, PartialEq, Eq)]
12507pub enum InfixRightOperand<'tree> {
12508 Expression(::std::boxed::Box<Expression<'tree>>),
12509 LazyField(::std::boxed::Box<LazyField<'tree>>),
12510 Pattern(::std::boxed::Box<Pattern<'tree>>),
12511 StrictField(::std::boxed::Box<StrictField<'tree>>),
12512 Type(::std::boxed::Box<Type<'tree>>),
12513 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
12514}
12515impl<'tree> ::treesitter_types::FromNode<'tree> for InfixRightOperand<'tree> {
12516 #[allow(clippy::collapsible_else_if)]
12517 fn from_node(
12518 node: ::tree_sitter::Node<'tree>,
12519 src: &'tree [u8],
12520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12521 match node.kind() {
12522 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12523 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
12524 ))),
12525 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12526 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
12527 ))),
12528 _other => {
12529 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12530 Ok(Self::Expression(::std::boxed::Box::new(v)))
12531 } else {
12532 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12533 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12534 } else {
12535 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src)
12536 {
12537 Ok(Self::Type(::std::boxed::Box::new(v)))
12538 } else {
12539 if let Ok(v) =
12540 <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
12541 {
12542 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
12543 } else {
12544 Err(::treesitter_types::ParseError::unexpected_kind(
12545 _other, node,
12546 ))
12547 }
12548 }
12549 }
12550 }
12551 }
12552 }
12553 }
12554}
12555impl ::treesitter_types::Spanned for InfixRightOperand<'_> {
12556 fn span(&self) -> ::treesitter_types::Span {
12557 match self {
12558 Self::Expression(inner) => inner.span(),
12559 Self::LazyField(inner) => inner.span(),
12560 Self::Pattern(inner) => inner.span(),
12561 Self::StrictField(inner) => inner.span(),
12562 Self::Type(inner) => inner.span(),
12563 Self::TypeParam(inner) => inner.span(),
12564 }
12565 }
12566}
12567#[derive(Debug, Clone, PartialEq, Eq)]
12568pub enum InfixIdChildren<'tree> {
12569 Constructor(::std::boxed::Box<Constructor<'tree>>),
12570 Name(::std::boxed::Box<Name<'tree>>),
12571 Qualified(::std::boxed::Box<Qualified<'tree>>),
12572 Variable(::std::boxed::Box<Variable<'tree>>),
12573}
12574impl<'tree> ::treesitter_types::FromNode<'tree> for InfixIdChildren<'tree> {
12575 #[allow(clippy::collapsible_else_if)]
12576 fn from_node(
12577 node: ::tree_sitter::Node<'tree>,
12578 src: &'tree [u8],
12579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12580 match node.kind() {
12581 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
12582 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
12583 ))),
12584 "name" => Ok(Self::Name(::std::boxed::Box::new(
12585 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12586 ))),
12587 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12588 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12589 ))),
12590 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
12591 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
12592 ))),
12593 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12594 }
12595 }
12596}
12597impl ::treesitter_types::Spanned for InfixIdChildren<'_> {
12598 fn span(&self) -> ::treesitter_types::Span {
12599 match self {
12600 Self::Constructor(inner) => inner.span(),
12601 Self::Name(inner) => inner.span(),
12602 Self::Qualified(inner) => inner.span(),
12603 Self::Variable(inner) => inner.span(),
12604 }
12605 }
12606}
12607#[derive(Debug, Clone, PartialEq, Eq)]
12608pub enum InstanceForall<'tree> {
12609 Forall(::std::boxed::Box<Forall<'tree>>),
12610 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
12611}
12612impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceForall<'tree> {
12613 #[allow(clippy::collapsible_else_if)]
12614 fn from_node(
12615 node: ::tree_sitter::Node<'tree>,
12616 src: &'tree [u8],
12617 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12618 match node.kind() {
12619 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
12620 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
12621 ))),
12622 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
12623 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
12624 ))),
12625 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12626 }
12627 }
12628}
12629impl ::treesitter_types::Spanned for InstanceForall<'_> {
12630 fn span(&self) -> ::treesitter_types::Span {
12631 match self {
12632 Self::Forall(inner) => inner.span(),
12633 Self::ForallRequired(inner) => inner.span(),
12634 }
12635 }
12636}
12637#[derive(Debug, Clone, PartialEq, Eq)]
12638pub enum InstanceName<'tree> {
12639 Name(::std::boxed::Box<Name<'tree>>),
12640 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12641 Qualified(::std::boxed::Box<Qualified<'tree>>),
12642}
12643impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceName<'tree> {
12644 #[allow(clippy::collapsible_else_if)]
12645 fn from_node(
12646 node: ::tree_sitter::Node<'tree>,
12647 src: &'tree [u8],
12648 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12649 match node.kind() {
12650 "name" => Ok(Self::Name(::std::boxed::Box::new(
12651 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12652 ))),
12653 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12654 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12655 ))),
12656 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12657 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12658 ))),
12659 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12660 }
12661 }
12662}
12663impl ::treesitter_types::Spanned for InstanceName<'_> {
12664 fn span(&self) -> ::treesitter_types::Span {
12665 match self {
12666 Self::Name(inner) => inner.span(),
12667 Self::PrefixId(inner) => inner.span(),
12668 Self::Qualified(inner) => inner.span(),
12669 }
12670 }
12671}
12672#[derive(Debug, Clone, PartialEq, Eq)]
12673pub enum InstanceChildren<'tree> {
12674 Infix(::std::boxed::Box<Infix<'tree>>),
12675 Parens(::std::boxed::Box<Parens<'tree>>),
12676}
12677impl<'tree> ::treesitter_types::FromNode<'tree> for InstanceChildren<'tree> {
12678 #[allow(clippy::collapsible_else_if)]
12679 fn from_node(
12680 node: ::tree_sitter::Node<'tree>,
12681 src: &'tree [u8],
12682 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12683 match node.kind() {
12684 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
12685 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
12686 ))),
12687 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
12688 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
12689 ))),
12690 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12691 }
12692 }
12693}
12694impl ::treesitter_types::Spanned for InstanceChildren<'_> {
12695 fn span(&self) -> ::treesitter_types::Span {
12696 match self {
12697 Self::Infix(inner) => inner.span(),
12698 Self::Parens(inner) => inner.span(),
12699 }
12700 }
12701}
12702#[derive(Debug, Clone, PartialEq, Eq)]
12703pub enum KindSignatureName<'tree> {
12704 Name(::std::boxed::Box<Name<'tree>>),
12705 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
12706 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
12707 Unit(::std::boxed::Box<Unit<'tree>>),
12708}
12709impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignatureName<'tree> {
12710 #[allow(clippy::collapsible_else_if)]
12711 fn from_node(
12712 node: ::tree_sitter::Node<'tree>,
12713 src: &'tree [u8],
12714 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12715 match node.kind() {
12716 "name" => Ok(Self::Name(::std::boxed::Box::new(
12717 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
12718 ))),
12719 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
12720 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12721 ))),
12722 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
12723 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
12724 ))),
12725 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
12726 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
12727 ))),
12728 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12729 }
12730 }
12731}
12732impl ::treesitter_types::Spanned for KindSignatureName<'_> {
12733 fn span(&self) -> ::treesitter_types::Span {
12734 match self {
12735 Self::Name(inner) => inner.span(),
12736 Self::PrefixId(inner) => inner.span(),
12737 Self::PrefixList(inner) => inner.span(),
12738 Self::Unit(inner) => inner.span(),
12739 }
12740 }
12741}
12742#[derive(Debug, Clone, PartialEq, Eq)]
12743pub enum KindSignatureChildren<'tree> {
12744 Infix(::std::boxed::Box<Infix<'tree>>),
12745 Parens(::std::boxed::Box<Parens<'tree>>),
12746}
12747impl<'tree> ::treesitter_types::FromNode<'tree> for KindSignatureChildren<'tree> {
12748 #[allow(clippy::collapsible_else_if)]
12749 fn from_node(
12750 node: ::tree_sitter::Node<'tree>,
12751 src: &'tree [u8],
12752 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12753 match node.kind() {
12754 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
12755 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
12756 ))),
12757 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
12758 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
12759 ))),
12760 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12761 }
12762 }
12763}
12764impl ::treesitter_types::Spanned for KindSignatureChildren<'_> {
12765 fn span(&self) -> ::treesitter_types::Span {
12766 match self {
12767 Self::Infix(inner) => inner.span(),
12768 Self::Parens(inner) => inner.span(),
12769 }
12770 }
12771}
12772#[derive(Debug, Clone, PartialEq, Eq)]
12773pub enum LambdaExpression<'tree> {
12774 Expression(::std::boxed::Box<Expression<'tree>>),
12775 Signature(::std::boxed::Box<Signature<'tree>>),
12776}
12777impl<'tree> ::treesitter_types::FromNode<'tree> for LambdaExpression<'tree> {
12778 #[allow(clippy::collapsible_else_if)]
12779 fn from_node(
12780 node: ::tree_sitter::Node<'tree>,
12781 src: &'tree [u8],
12782 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12783 match node.kind() {
12784 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12785 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12786 ))),
12787 _other => {
12788 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12789 Ok(Self::Expression(::std::boxed::Box::new(v)))
12790 } else {
12791 Err(::treesitter_types::ParseError::unexpected_kind(
12792 _other, node,
12793 ))
12794 }
12795 }
12796 }
12797 }
12798}
12799impl ::treesitter_types::Spanned for LambdaExpression<'_> {
12800 fn span(&self) -> ::treesitter_types::Span {
12801 match self {
12802 Self::Expression(inner) => inner.span(),
12803 Self::Signature(inner) => inner.span(),
12804 }
12805 }
12806}
12807#[derive(Debug, Clone, PartialEq, Eq)]
12808pub enum LeftSectionOperator<'tree> {
12809 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
12810 InfixId(::std::boxed::Box<InfixId<'tree>>),
12811 Operator(::std::boxed::Box<Operator<'tree>>),
12812 Qualified(::std::boxed::Box<Qualified<'tree>>),
12813}
12814impl<'tree> ::treesitter_types::FromNode<'tree> for LeftSectionOperator<'tree> {
12815 #[allow(clippy::collapsible_else_if)]
12816 fn from_node(
12817 node: ::tree_sitter::Node<'tree>,
12818 src: &'tree [u8],
12819 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12820 match node.kind() {
12821 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
12822 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
12823 ))),
12824 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
12825 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)?,
12826 ))),
12827 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
12828 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
12829 ))),
12830 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
12831 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
12832 ))),
12833 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12834 }
12835 }
12836}
12837impl ::treesitter_types::Spanned for LeftSectionOperator<'_> {
12838 fn span(&self) -> ::treesitter_types::Span {
12839 match self {
12840 Self::ConstructorOperator(inner) => inner.span(),
12841 Self::InfixId(inner) => inner.span(),
12842 Self::Operator(inner) => inner.span(),
12843 Self::Qualified(inner) => inner.span(),
12844 }
12845 }
12846}
12847#[derive(Debug, Clone, PartialEq, Eq)]
12848pub enum LetInExpression<'tree> {
12849 Expression(::std::boxed::Box<Expression<'tree>>),
12850 Signature(::std::boxed::Box<Signature<'tree>>),
12851}
12852impl<'tree> ::treesitter_types::FromNode<'tree> for LetInExpression<'tree> {
12853 #[allow(clippy::collapsible_else_if)]
12854 fn from_node(
12855 node: ::tree_sitter::Node<'tree>,
12856 src: &'tree [u8],
12857 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12858 match node.kind() {
12859 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
12860 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12861 ))),
12862 _other => {
12863 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12864 Ok(Self::Expression(::std::boxed::Box::new(v)))
12865 } else {
12866 Err(::treesitter_types::ParseError::unexpected_kind(
12867 _other, node,
12868 ))
12869 }
12870 }
12871 }
12872 }
12873}
12874impl ::treesitter_types::Spanned for LetInExpression<'_> {
12875 fn span(&self) -> ::treesitter_types::Span {
12876 match self {
12877 Self::Expression(inner) => inner.span(),
12878 Self::Signature(inner) => inner.span(),
12879 }
12880 }
12881}
12882#[derive(Debug, Clone, PartialEq, Eq)]
12883pub enum LinearFunctionArrow {
12884 Arrow(::treesitter_types::Span),
12885 MinusGtDot(::treesitter_types::Span),
12886 X(::treesitter_types::Span),
12887}
12888impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunctionArrow {
12889 #[allow(clippy::collapsible_else_if)]
12890 fn from_node(
12891 node: ::tree_sitter::Node<'tree>,
12892 _src: &'tree [u8],
12893 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12894 match node.kind() {
12895 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
12896 "->." => Ok(Self::MinusGtDot(::treesitter_types::Span::from(node))),
12897 "→" | "⊸" => Ok(Self::X(::treesitter_types::Span::from(node))),
12898 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12899 }
12900 }
12901}
12902impl ::treesitter_types::Spanned for LinearFunctionArrow {
12903 fn span(&self) -> ::treesitter_types::Span {
12904 match self {
12905 Self::Arrow(span) => *span,
12906 Self::MinusGtDot(span) => *span,
12907 Self::X(span) => *span,
12908 }
12909 }
12910}
12911#[derive(Debug, Clone, PartialEq, Eq)]
12912pub enum LinearFunctionParameter<'tree> {
12913 LazyField(::std::boxed::Box<LazyField<'tree>>),
12914 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12915 StrictField(::std::boxed::Box<StrictField<'tree>>),
12916}
12917impl<'tree> ::treesitter_types::FromNode<'tree> for LinearFunctionParameter<'tree> {
12918 #[allow(clippy::collapsible_else_if)]
12919 fn from_node(
12920 node: ::tree_sitter::Node<'tree>,
12921 src: &'tree [u8],
12922 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12923 match node.kind() {
12924 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
12925 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
12926 ))),
12927 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
12928 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
12929 ))),
12930 _other => {
12931 if let Ok(v) =
12932 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12933 {
12934 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12935 } else {
12936 Err(::treesitter_types::ParseError::unexpected_kind(
12937 _other, node,
12938 ))
12939 }
12940 }
12941 }
12942 }
12943}
12944impl ::treesitter_types::Spanned for LinearFunctionParameter<'_> {
12945 fn span(&self) -> ::treesitter_types::Span {
12946 match self {
12947 Self::LazyField(inner) => inner.span(),
12948 Self::QuantifiedType(inner) => inner.span(),
12949 Self::StrictField(inner) => inner.span(),
12950 }
12951 }
12952}
12953#[derive(Debug, Clone, PartialEq, Eq)]
12954pub enum ListElement<'tree> {
12955 Expression(::std::boxed::Box<Expression<'tree>>),
12956 Pattern(::std::boxed::Box<Pattern<'tree>>),
12957 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
12958 Signature(::std::boxed::Box<Signature<'tree>>),
12959 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
12960}
12961impl<'tree> ::treesitter_types::FromNode<'tree> for ListElement<'tree> {
12962 #[allow(clippy::collapsible_else_if)]
12963 fn from_node(
12964 node: ::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 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
12970 ))),
12971 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
12972 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12973 ))),
12974 _other => {
12975 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12976 Ok(Self::Expression(::std::boxed::Box::new(v)))
12977 } else {
12978 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12979 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12980 } else {
12981 if let Ok(v) =
12982 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
12983 {
12984 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
12985 } else {
12986 Err(::treesitter_types::ParseError::unexpected_kind(
12987 _other, node,
12988 ))
12989 }
12990 }
12991 }
12992 }
12993 }
12994 }
12995}
12996impl ::treesitter_types::Spanned for ListElement<'_> {
12997 fn span(&self) -> ::treesitter_types::Span {
12998 match self {
12999 Self::Expression(inner) => inner.span(),
13000 Self::Pattern(inner) => inner.span(),
13001 Self::QuantifiedType(inner) => inner.span(),
13002 Self::Signature(inner) => inner.span(),
13003 Self::ViewPattern(inner) => inner.span(),
13004 }
13005 }
13006}
13007#[derive(Debug, Clone, PartialEq, Eq)]
13008pub enum ListComprehensionExpression<'tree> {
13009 Expression(::std::boxed::Box<Expression<'tree>>),
13010 Signature(::std::boxed::Box<Signature<'tree>>),
13011}
13012impl<'tree> ::treesitter_types::FromNode<'tree> for ListComprehensionExpression<'tree> {
13013 #[allow(clippy::collapsible_else_if)]
13014 fn from_node(
13015 node: ::tree_sitter::Node<'tree>,
13016 src: &'tree [u8],
13017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13018 match node.kind() {
13019 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13020 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13021 ))),
13022 _other => {
13023 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13024 Ok(Self::Expression(::std::boxed::Box::new(v)))
13025 } else {
13026 Err(::treesitter_types::ParseError::unexpected_kind(
13027 _other, node,
13028 ))
13029 }
13030 }
13031 }
13032 }
13033}
13034impl ::treesitter_types::Spanned for ListComprehensionExpression<'_> {
13035 fn span(&self) -> ::treesitter_types::Span {
13036 match self {
13037 Self::Expression(inner) => inner.span(),
13038 Self::Signature(inner) => inner.span(),
13039 }
13040 }
13041}
13042#[derive(Debug, Clone, PartialEq, Eq)]
13043pub enum LiteralChildren<'tree> {
13044 Char(::std::boxed::Box<Char<'tree>>),
13045 Float(::std::boxed::Box<Float<'tree>>),
13046 Integer(::std::boxed::Box<Integer<'tree>>),
13047 String(::std::boxed::Box<String<'tree>>),
13048}
13049impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralChildren<'tree> {
13050 #[allow(clippy::collapsible_else_if)]
13051 fn from_node(
13052 node: ::tree_sitter::Node<'tree>,
13053 src: &'tree [u8],
13054 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13055 match node.kind() {
13056 "char" => Ok(Self::Char(::std::boxed::Box::new(
13057 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
13058 ))),
13059 "float" => Ok(Self::Float(::std::boxed::Box::new(
13060 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
13061 ))),
13062 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
13063 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
13064 ))),
13065 "string" => Ok(Self::String(::std::boxed::Box::new(
13066 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
13067 ))),
13068 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13069 }
13070 }
13071}
13072impl ::treesitter_types::Spanned for LiteralChildren<'_> {
13073 fn span(&self) -> ::treesitter_types::Span {
13074 match self {
13075 Self::Char(inner) => inner.span(),
13076 Self::Float(inner) => inner.span(),
13077 Self::Integer(inner) => inner.span(),
13078 Self::String(inner) => inner.span(),
13079 }
13080 }
13081}
13082#[derive(Debug, Clone, PartialEq, Eq)]
13083pub enum LocalBindsDecl<'tree> {
13084 Decl(::std::boxed::Box<Decl<'tree>>),
13085 Fixity(::std::boxed::Box<Fixity<'tree>>),
13086}
13087impl<'tree> ::treesitter_types::FromNode<'tree> for LocalBindsDecl<'tree> {
13088 #[allow(clippy::collapsible_else_if)]
13089 fn from_node(
13090 node: ::tree_sitter::Node<'tree>,
13091 src: &'tree [u8],
13092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13093 match node.kind() {
13094 "fixity" => Ok(Self::Fixity(::std::boxed::Box::new(
13095 <Fixity as ::treesitter_types::FromNode>::from_node(node, src)?,
13096 ))),
13097 _other => {
13098 if let Ok(v) = <Decl as ::treesitter_types::FromNode>::from_node(node, src) {
13099 Ok(Self::Decl(::std::boxed::Box::new(v)))
13100 } else {
13101 Err(::treesitter_types::ParseError::unexpected_kind(
13102 _other, node,
13103 ))
13104 }
13105 }
13106 }
13107 }
13108}
13109impl ::treesitter_types::Spanned for LocalBindsDecl<'_> {
13110 fn span(&self) -> ::treesitter_types::Span {
13111 match self {
13112 Self::Decl(inner) => inner.span(),
13113 Self::Fixity(inner) => inner.span(),
13114 }
13115 }
13116}
13117#[derive(Debug, Clone, PartialEq, Eq)]
13118pub enum MatchExpression<'tree> {
13119 Expression(::std::boxed::Box<Expression<'tree>>),
13120 Signature(::std::boxed::Box<Signature<'tree>>),
13121}
13122impl<'tree> ::treesitter_types::FromNode<'tree> for MatchExpression<'tree> {
13123 #[allow(clippy::collapsible_else_if)]
13124 fn from_node(
13125 node: ::tree_sitter::Node<'tree>,
13126 src: &'tree [u8],
13127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13128 match node.kind() {
13129 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13130 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13131 ))),
13132 _other => {
13133 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13134 Ok(Self::Expression(::std::boxed::Box::new(v)))
13135 } else {
13136 Err(::treesitter_types::ParseError::unexpected_kind(
13137 _other, node,
13138 ))
13139 }
13140 }
13141 }
13142 }
13143}
13144impl ::treesitter_types::Spanned for MatchExpression<'_> {
13145 fn span(&self) -> ::treesitter_types::Span {
13146 match self {
13147 Self::Expression(inner) => inner.span(),
13148 Self::Signature(inner) => inner.span(),
13149 }
13150 }
13151}
13152#[derive(Debug, Clone, PartialEq, Eq)]
13153pub enum NegationMinus {
13154 Minus(::treesitter_types::Span),
13155}
13156impl<'tree> ::treesitter_types::FromNode<'tree> for NegationMinus {
13157 #[allow(clippy::collapsible_else_if)]
13158 fn from_node(
13159 node: ::tree_sitter::Node<'tree>,
13160 _src: &'tree [u8],
13161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13162 match node.kind() {
13163 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
13164 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13165 }
13166 }
13167}
13168impl ::treesitter_types::Spanned for NegationMinus {
13169 fn span(&self) -> ::treesitter_types::Span {
13170 match self {
13171 Self::Minus(span) => *span,
13172 }
13173 }
13174}
13175#[derive(Debug, Clone, PartialEq, Eq)]
13176pub enum NegationNumber<'tree> {
13177 Float(::std::boxed::Box<Float<'tree>>),
13178 Integer(::std::boxed::Box<Integer<'tree>>),
13179}
13180impl<'tree> ::treesitter_types::FromNode<'tree> for NegationNumber<'tree> {
13181 #[allow(clippy::collapsible_else_if)]
13182 fn from_node(
13183 node: ::tree_sitter::Node<'tree>,
13184 src: &'tree [u8],
13185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13186 match node.kind() {
13187 "float" => Ok(Self::Float(::std::boxed::Box::new(
13188 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
13189 ))),
13190 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
13191 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
13192 ))),
13193 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13194 }
13195 }
13196}
13197impl ::treesitter_types::Spanned for NegationNumber<'_> {
13198 fn span(&self) -> ::treesitter_types::Span {
13199 match self {
13200 Self::Float(inner) => inner.span(),
13201 Self::Integer(inner) => inner.span(),
13202 }
13203 }
13204}
13205#[derive(Debug, Clone, PartialEq, Eq)]
13206pub enum NewtypeForall<'tree> {
13207 Forall(::std::boxed::Box<Forall<'tree>>),
13208 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
13209}
13210impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeForall<'tree> {
13211 #[allow(clippy::collapsible_else_if)]
13212 fn from_node(
13213 node: ::tree_sitter::Node<'tree>,
13214 src: &'tree [u8],
13215 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13216 match node.kind() {
13217 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
13218 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
13219 ))),
13220 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
13221 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
13222 ))),
13223 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13224 }
13225 }
13226}
13227impl ::treesitter_types::Spanned for NewtypeForall<'_> {
13228 fn span(&self) -> ::treesitter_types::Span {
13229 match self {
13230 Self::Forall(inner) => inner.span(),
13231 Self::ForallRequired(inner) => inner.span(),
13232 }
13233 }
13234}
13235#[derive(Debug, Clone, PartialEq, Eq)]
13236pub enum NewtypeName<'tree> {
13237 Name(::std::boxed::Box<Name<'tree>>),
13238 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13239 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
13240 Qualified(::std::boxed::Box<Qualified<'tree>>),
13241 Unit(::std::boxed::Box<Unit<'tree>>),
13242}
13243impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeName<'tree> {
13244 #[allow(clippy::collapsible_else_if)]
13245 fn from_node(
13246 node: ::tree_sitter::Node<'tree>,
13247 src: &'tree [u8],
13248 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13249 match node.kind() {
13250 "name" => Ok(Self::Name(::std::boxed::Box::new(
13251 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13252 ))),
13253 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13254 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13255 ))),
13256 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
13257 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
13258 ))),
13259 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13260 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
13261 ))),
13262 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
13263 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
13264 ))),
13265 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13266 }
13267 }
13268}
13269impl ::treesitter_types::Spanned for NewtypeName<'_> {
13270 fn span(&self) -> ::treesitter_types::Span {
13271 match self {
13272 Self::Name(inner) => inner.span(),
13273 Self::PrefixId(inner) => inner.span(),
13274 Self::PrefixList(inner) => inner.span(),
13275 Self::Qualified(inner) => inner.span(),
13276 Self::Unit(inner) => inner.span(),
13277 }
13278 }
13279}
13280#[derive(Debug, Clone, PartialEq, Eq)]
13281pub enum NewtypePatterns<'tree> {
13282 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
13283 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
13284}
13285impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypePatterns<'tree> {
13286 #[allow(clippy::collapsible_else_if)]
13287 fn from_node(
13288 node: ::tree_sitter::Node<'tree>,
13289 src: &'tree [u8],
13290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13291 match node.kind() {
13292 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
13293 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)?,
13294 ))),
13295 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
13296 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)?,
13297 ))),
13298 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13299 }
13300 }
13301}
13302impl ::treesitter_types::Spanned for NewtypePatterns<'_> {
13303 fn span(&self) -> ::treesitter_types::Span {
13304 match self {
13305 Self::TypeParams(inner) => inner.span(),
13306 Self::TypePatterns(inner) => inner.span(),
13307 }
13308 }
13309}
13310#[derive(Debug, Clone, PartialEq, Eq)]
13311pub enum NewtypeChildren<'tree> {
13312 Infix(::std::boxed::Box<Infix<'tree>>),
13313 Parens(::std::boxed::Box<Parens<'tree>>),
13314}
13315impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeChildren<'tree> {
13316 #[allow(clippy::collapsible_else_if)]
13317 fn from_node(
13318 node: ::tree_sitter::Node<'tree>,
13319 src: &'tree [u8],
13320 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13321 match node.kind() {
13322 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
13323 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
13324 ))),
13325 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
13326 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
13327 ))),
13328 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13329 }
13330 }
13331}
13332impl ::treesitter_types::Spanned for NewtypeChildren<'_> {
13333 fn span(&self) -> ::treesitter_types::Span {
13334 match self {
13335 Self::Infix(inner) => inner.span(),
13336 Self::Parens(inner) => inner.span(),
13337 }
13338 }
13339}
13340#[derive(Debug, Clone, PartialEq, Eq)]
13341pub enum NewtypeConstructorField<'tree> {
13342 Field(::std::boxed::Box<Field<'tree>>),
13343 Record(::std::boxed::Box<Record<'tree>>),
13344}
13345impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructorField<'tree> {
13346 #[allow(clippy::collapsible_else_if)]
13347 fn from_node(
13348 node: ::tree_sitter::Node<'tree>,
13349 src: &'tree [u8],
13350 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13351 match node.kind() {
13352 "field" => Ok(Self::Field(::std::boxed::Box::new(
13353 <Field as ::treesitter_types::FromNode>::from_node(node, src)?,
13354 ))),
13355 "record" => Ok(Self::Record(::std::boxed::Box::new(
13356 <Record as ::treesitter_types::FromNode>::from_node(node, src)?,
13357 ))),
13358 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13359 }
13360 }
13361}
13362impl ::treesitter_types::Spanned for NewtypeConstructorField<'_> {
13363 fn span(&self) -> ::treesitter_types::Span {
13364 match self {
13365 Self::Field(inner) => inner.span(),
13366 Self::Record(inner) => inner.span(),
13367 }
13368 }
13369}
13370#[derive(Debug, Clone, PartialEq, Eq)]
13371pub enum NewtypeConstructorName<'tree> {
13372 Constructor(::std::boxed::Box<Constructor<'tree>>),
13373 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13374}
13375impl<'tree> ::treesitter_types::FromNode<'tree> for NewtypeConstructorName<'tree> {
13376 #[allow(clippy::collapsible_else_if)]
13377 fn from_node(
13378 node: ::tree_sitter::Node<'tree>,
13379 src: &'tree [u8],
13380 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13381 match node.kind() {
13382 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
13383 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
13384 ))),
13385 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13386 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13387 ))),
13388 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13389 }
13390 }
13391}
13392impl ::treesitter_types::Spanned for NewtypeConstructorName<'_> {
13393 fn span(&self) -> ::treesitter_types::Span {
13394 match self {
13395 Self::Constructor(inner) => inner.span(),
13396 Self::PrefixId(inner) => inner.span(),
13397 }
13398 }
13399}
13400#[derive(Debug, Clone, PartialEq, Eq)]
13401pub enum ParensExpression<'tree> {
13402 Expression(::std::boxed::Box<Expression<'tree>>),
13403 Signature(::std::boxed::Box<Signature<'tree>>),
13404}
13405impl<'tree> ::treesitter_types::FromNode<'tree> for ParensExpression<'tree> {
13406 #[allow(clippy::collapsible_else_if)]
13407 fn from_node(
13408 node: ::tree_sitter::Node<'tree>,
13409 src: &'tree [u8],
13410 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13411 match node.kind() {
13412 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13413 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13414 ))),
13415 _other => {
13416 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13417 Ok(Self::Expression(::std::boxed::Box::new(v)))
13418 } else {
13419 Err(::treesitter_types::ParseError::unexpected_kind(
13420 _other, node,
13421 ))
13422 }
13423 }
13424 }
13425 }
13426}
13427impl ::treesitter_types::Spanned for ParensExpression<'_> {
13428 fn span(&self) -> ::treesitter_types::Span {
13429 match self {
13430 Self::Expression(inner) => inner.span(),
13431 Self::Signature(inner) => inner.span(),
13432 }
13433 }
13434}
13435#[derive(Debug, Clone, PartialEq, Eq)]
13436pub enum ParensName<'tree> {
13437 Name(::std::boxed::Box<Name<'tree>>),
13438 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13439 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
13440 Qualified(::std::boxed::Box<Qualified<'tree>>),
13441 Unit(::std::boxed::Box<Unit<'tree>>),
13442}
13443impl<'tree> ::treesitter_types::FromNode<'tree> for ParensName<'tree> {
13444 #[allow(clippy::collapsible_else_if)]
13445 fn from_node(
13446 node: ::tree_sitter::Node<'tree>,
13447 src: &'tree [u8],
13448 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13449 match node.kind() {
13450 "name" => Ok(Self::Name(::std::boxed::Box::new(
13451 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
13452 ))),
13453 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13454 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13455 ))),
13456 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
13457 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
13458 ))),
13459 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13460 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
13461 ))),
13462 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
13463 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
13464 ))),
13465 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13466 }
13467 }
13468}
13469impl ::treesitter_types::Spanned for ParensName<'_> {
13470 fn span(&self) -> ::treesitter_types::Span {
13471 match self {
13472 Self::Name(inner) => inner.span(),
13473 Self::PrefixId(inner) => inner.span(),
13474 Self::PrefixList(inner) => inner.span(),
13475 Self::Qualified(inner) => inner.span(),
13476 Self::Unit(inner) => inner.span(),
13477 }
13478 }
13479}
13480#[derive(Debug, Clone, PartialEq, Eq)]
13481pub enum ParensPattern<'tree> {
13482 Pattern(::std::boxed::Box<Pattern<'tree>>),
13483 Signature(::std::boxed::Box<Signature<'tree>>),
13484 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
13485}
13486impl<'tree> ::treesitter_types::FromNode<'tree> for ParensPattern<'tree> {
13487 #[allow(clippy::collapsible_else_if)]
13488 fn from_node(
13489 node: ::tree_sitter::Node<'tree>,
13490 src: &'tree [u8],
13491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13492 match node.kind() {
13493 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13494 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13495 ))),
13496 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
13497 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
13498 ))),
13499 _other => {
13500 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
13501 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13502 } else {
13503 Err(::treesitter_types::ParseError::unexpected_kind(
13504 _other, node,
13505 ))
13506 }
13507 }
13508 }
13509 }
13510}
13511impl ::treesitter_types::Spanned for ParensPattern<'_> {
13512 fn span(&self) -> ::treesitter_types::Span {
13513 match self {
13514 Self::Pattern(inner) => inner.span(),
13515 Self::Signature(inner) => inner.span(),
13516 Self::ViewPattern(inner) => inner.span(),
13517 }
13518 }
13519}
13520#[derive(Debug, Clone, PartialEq, Eq)]
13521pub enum ParensPatterns<'tree> {
13522 TypeParams(::std::boxed::Box<TypeParams<'tree>>),
13523 TypePatterns(::std::boxed::Box<TypePatterns<'tree>>),
13524}
13525impl<'tree> ::treesitter_types::FromNode<'tree> for ParensPatterns<'tree> {
13526 #[allow(clippy::collapsible_else_if)]
13527 fn from_node(
13528 node: ::tree_sitter::Node<'tree>,
13529 src: &'tree [u8],
13530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13531 match node.kind() {
13532 "type_params" => Ok(Self::TypeParams(::std::boxed::Box::new(
13533 <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)?,
13534 ))),
13535 "type_patterns" => Ok(Self::TypePatterns(::std::boxed::Box::new(
13536 <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)?,
13537 ))),
13538 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13539 }
13540 }
13541}
13542impl ::treesitter_types::Spanned for ParensPatterns<'_> {
13543 fn span(&self) -> ::treesitter_types::Span {
13544 match self {
13545 Self::TypeParams(inner) => inner.span(),
13546 Self::TypePatterns(inner) => inner.span(),
13547 }
13548 }
13549}
13550#[derive(Debug, Clone, PartialEq, Eq)]
13551pub enum ParensType<'tree> {
13552 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
13553 Signature(::std::boxed::Box<Signature<'tree>>),
13554}
13555impl<'tree> ::treesitter_types::FromNode<'tree> for ParensType<'tree> {
13556 #[allow(clippy::collapsible_else_if)]
13557 fn from_node(
13558 node: ::tree_sitter::Node<'tree>,
13559 src: &'tree [u8],
13560 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13561 match node.kind() {
13562 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13563 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13564 ))),
13565 _other => {
13566 if let Ok(v) =
13567 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
13568 {
13569 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
13570 } else {
13571 Err(::treesitter_types::ParseError::unexpected_kind(
13572 _other, node,
13573 ))
13574 }
13575 }
13576 }
13577 }
13578}
13579impl ::treesitter_types::Spanned for ParensType<'_> {
13580 fn span(&self) -> ::treesitter_types::Span {
13581 match self {
13582 Self::QuantifiedType(inner) => inner.span(),
13583 Self::Signature(inner) => inner.span(),
13584 }
13585 }
13586}
13587#[derive(Debug, Clone, PartialEq, Eq)]
13588pub enum ParensChildren<'tree> {
13589 Annotated(::std::boxed::Box<Annotated<'tree>>),
13590 Constraints(::std::boxed::Box<Constraints<'tree>>),
13591 Infix(::std::boxed::Box<Infix<'tree>>),
13592 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
13593}
13594impl<'tree> ::treesitter_types::FromNode<'tree> for ParensChildren<'tree> {
13595 #[allow(clippy::collapsible_else_if)]
13596 fn from_node(
13597 node: ::tree_sitter::Node<'tree>,
13598 src: &'tree [u8],
13599 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13600 match node.kind() {
13601 "annotated" => Ok(Self::Annotated(::std::boxed::Box::new(
13602 <Annotated as ::treesitter_types::FromNode>::from_node(node, src)?,
13603 ))),
13604 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
13605 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
13606 ))),
13607 _other => {
13608 if let Ok(v) = <Constraints as ::treesitter_types::FromNode>::from_node(node, src) {
13609 Ok(Self::Constraints(::std::boxed::Box::new(v)))
13610 } else {
13611 if let Ok(v) = <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
13612 {
13613 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
13614 } else {
13615 Err(::treesitter_types::ParseError::unexpected_kind(
13616 _other, node,
13617 ))
13618 }
13619 }
13620 }
13621 }
13622 }
13623}
13624impl ::treesitter_types::Spanned for ParensChildren<'_> {
13625 fn span(&self) -> ::treesitter_types::Span {
13626 match self {
13627 Self::Annotated(inner) => inner.span(),
13628 Self::Constraints(inner) => inner.span(),
13629 Self::Infix(inner) => inner.span(),
13630 Self::TypeParam(inner) => inner.span(),
13631 }
13632 }
13633}
13634#[derive(Debug, Clone, PartialEq, Eq)]
13635pub enum PatternGuardArrow {
13636 LArrow(::treesitter_types::Span),
13637 X(::treesitter_types::Span),
13638}
13639impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardArrow {
13640 #[allow(clippy::collapsible_else_if)]
13641 fn from_node(
13642 node: ::tree_sitter::Node<'tree>,
13643 _src: &'tree [u8],
13644 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13645 match node.kind() {
13646 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
13647 "←" => Ok(Self::X(::treesitter_types::Span::from(node))),
13648 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13649 }
13650 }
13651}
13652impl ::treesitter_types::Spanned for PatternGuardArrow {
13653 fn span(&self) -> ::treesitter_types::Span {
13654 match self {
13655 Self::LArrow(span) => *span,
13656 Self::X(span) => *span,
13657 }
13658 }
13659}
13660#[derive(Debug, Clone, PartialEq, Eq)]
13661pub enum PatternGuardExpression<'tree> {
13662 Expression(::std::boxed::Box<Expression<'tree>>),
13663 Signature(::std::boxed::Box<Signature<'tree>>),
13664}
13665impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardExpression<'tree> {
13666 #[allow(clippy::collapsible_else_if)]
13667 fn from_node(
13668 node: ::tree_sitter::Node<'tree>,
13669 src: &'tree [u8],
13670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13671 match node.kind() {
13672 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13673 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13674 ))),
13675 _other => {
13676 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13677 Ok(Self::Expression(::std::boxed::Box::new(v)))
13678 } else {
13679 Err(::treesitter_types::ParseError::unexpected_kind(
13680 _other, node,
13681 ))
13682 }
13683 }
13684 }
13685 }
13686}
13687impl ::treesitter_types::Spanned for PatternGuardExpression<'_> {
13688 fn span(&self) -> ::treesitter_types::Span {
13689 match self {
13690 Self::Expression(inner) => inner.span(),
13691 Self::Signature(inner) => inner.span(),
13692 }
13693 }
13694}
13695#[derive(Debug, Clone, PartialEq, Eq)]
13696pub enum PatternGuardPattern<'tree> {
13697 Pattern(::std::boxed::Box<Pattern<'tree>>),
13698 Signature(::std::boxed::Box<Signature<'tree>>),
13699}
13700impl<'tree> ::treesitter_types::FromNode<'tree> for PatternGuardPattern<'tree> {
13701 #[allow(clippy::collapsible_else_if)]
13702 fn from_node(
13703 node: ::tree_sitter::Node<'tree>,
13704 src: &'tree [u8],
13705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13706 match node.kind() {
13707 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13708 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13709 ))),
13710 _other => {
13711 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
13712 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13713 } else {
13714 Err(::treesitter_types::ParseError::unexpected_kind(
13715 _other, node,
13716 ))
13717 }
13718 }
13719 }
13720 }
13721}
13722impl ::treesitter_types::Spanned for PatternGuardPattern<'_> {
13723 fn span(&self) -> ::treesitter_types::Span {
13724 match self {
13725 Self::Pattern(inner) => inner.span(),
13726 Self::Signature(inner) => inner.span(),
13727 }
13728 }
13729}
13730#[derive(Debug, Clone, PartialEq, Eq)]
13731pub enum PatternSynonymChildren<'tree> {
13732 Equation(::std::boxed::Box<Equation<'tree>>),
13733 Signature(::std::boxed::Box<Signature<'tree>>),
13734}
13735impl<'tree> ::treesitter_types::FromNode<'tree> for PatternSynonymChildren<'tree> {
13736 #[allow(clippy::collapsible_else_if)]
13737 fn from_node(
13738 node: ::tree_sitter::Node<'tree>,
13739 src: &'tree [u8],
13740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13741 match node.kind() {
13742 "equation" => Ok(Self::Equation(::std::boxed::Box::new(
13743 <Equation as ::treesitter_types::FromNode>::from_node(node, src)?,
13744 ))),
13745 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
13746 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
13747 ))),
13748 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13749 }
13750 }
13751}
13752impl ::treesitter_types::Spanned for PatternSynonymChildren<'_> {
13753 fn span(&self) -> ::treesitter_types::Span {
13754 match self {
13755 Self::Equation(inner) => inner.span(),
13756 Self::Signature(inner) => inner.span(),
13757 }
13758 }
13759}
13760#[derive(Debug, Clone, PartialEq, Eq)]
13761pub enum PatternsChildren<'tree> {
13762 ExplicitType(::std::boxed::Box<ExplicitType<'tree>>),
13763 Pattern(::std::boxed::Box<Pattern<'tree>>),
13764 TypeBinder(::std::boxed::Box<TypeBinder<'tree>>),
13765}
13766impl<'tree> ::treesitter_types::FromNode<'tree> for PatternsChildren<'tree> {
13767 #[allow(clippy::collapsible_else_if)]
13768 fn from_node(
13769 node: ::tree_sitter::Node<'tree>,
13770 src: &'tree [u8],
13771 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13772 match node.kind() {
13773 "explicit_type" => Ok(Self::ExplicitType(::std::boxed::Box::new(
13774 <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)?,
13775 ))),
13776 "type_binder" => Ok(Self::TypeBinder(::std::boxed::Box::new(
13777 <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)?,
13778 ))),
13779 _other => {
13780 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
13781 Ok(Self::Pattern(::std::boxed::Box::new(v)))
13782 } else {
13783 Err(::treesitter_types::ParseError::unexpected_kind(
13784 _other, node,
13785 ))
13786 }
13787 }
13788 }
13789 }
13790}
13791impl ::treesitter_types::Spanned for PatternsChildren<'_> {
13792 fn span(&self) -> ::treesitter_types::Span {
13793 match self {
13794 Self::ExplicitType(inner) => inner.span(),
13795 Self::Pattern(inner) => inner.span(),
13796 Self::TypeBinder(inner) => inner.span(),
13797 }
13798 }
13799}
13800#[derive(Debug, Clone, PartialEq, Eq)]
13801pub enum PrefixField<'tree> {
13802 LazyField(::std::boxed::Box<LazyField<'tree>>),
13803 StrictField(::std::boxed::Box<StrictField<'tree>>),
13804 Type(::std::boxed::Box<Type<'tree>>),
13805}
13806impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixField<'tree> {
13807 #[allow(clippy::collapsible_else_if)]
13808 fn from_node(
13809 node: ::tree_sitter::Node<'tree>,
13810 src: &'tree [u8],
13811 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13812 match node.kind() {
13813 "lazy_field" => Ok(Self::LazyField(::std::boxed::Box::new(
13814 <LazyField as ::treesitter_types::FromNode>::from_node(node, src)?,
13815 ))),
13816 "strict_field" => Ok(Self::StrictField(::std::boxed::Box::new(
13817 <StrictField as ::treesitter_types::FromNode>::from_node(node, src)?,
13818 ))),
13819 _other => {
13820 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
13821 Ok(Self::Type(::std::boxed::Box::new(v)))
13822 } else {
13823 Err(::treesitter_types::ParseError::unexpected_kind(
13824 _other, node,
13825 ))
13826 }
13827 }
13828 }
13829 }
13830}
13831impl ::treesitter_types::Spanned for PrefixField<'_> {
13832 fn span(&self) -> ::treesitter_types::Span {
13833 match self {
13834 Self::LazyField(inner) => inner.span(),
13835 Self::StrictField(inner) => inner.span(),
13836 Self::Type(inner) => inner.span(),
13837 }
13838 }
13839}
13840#[derive(Debug, Clone, PartialEq, Eq)]
13841pub enum PrefixName<'tree> {
13842 Constructor(::std::boxed::Box<Constructor<'tree>>),
13843 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13844}
13845impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixName<'tree> {
13846 #[allow(clippy::collapsible_else_if)]
13847 fn from_node(
13848 node: ::tree_sitter::Node<'tree>,
13849 src: &'tree [u8],
13850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13851 match node.kind() {
13852 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
13853 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
13854 ))),
13855 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13856 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13857 ))),
13858 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13859 }
13860 }
13861}
13862impl ::treesitter_types::Spanned for PrefixName<'_> {
13863 fn span(&self) -> ::treesitter_types::Span {
13864 match self {
13865 Self::Constructor(inner) => inner.span(),
13866 Self::PrefixId(inner) => inner.span(),
13867 }
13868 }
13869}
13870#[derive(Debug, Clone, PartialEq, Eq)]
13871pub enum PrefixIdChildren<'tree> {
13872 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
13873 Operator(::std::boxed::Box<Operator<'tree>>),
13874 Qualified(::std::boxed::Box<Qualified<'tree>>),
13875}
13876impl<'tree> ::treesitter_types::FromNode<'tree> for PrefixIdChildren<'tree> {
13877 #[allow(clippy::collapsible_else_if)]
13878 fn from_node(
13879 node: ::tree_sitter::Node<'tree>,
13880 src: &'tree [u8],
13881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13882 match node.kind() {
13883 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
13884 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
13885 ))),
13886 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
13887 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
13888 ))),
13889 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13890 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
13891 ))),
13892 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13893 }
13894 }
13895}
13896impl ::treesitter_types::Spanned for PrefixIdChildren<'_> {
13897 fn span(&self) -> ::treesitter_types::Span {
13898 match self {
13899 Self::ConstructorOperator(inner) => inner.span(),
13900 Self::Operator(inner) => inner.span(),
13901 Self::Qualified(inner) => inner.span(),
13902 }
13903 }
13904}
13905#[derive(Debug, Clone, PartialEq, Eq)]
13906pub enum PromotedChildren<'tree> {
13907 Constructor(::std::boxed::Box<Constructor<'tree>>),
13908 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
13909 EmptyList(::std::boxed::Box<EmptyList<'tree>>),
13910 InfixId(::std::boxed::Box<InfixId<'tree>>),
13911 List(::std::boxed::Box<List<'tree>>),
13912 Operator(::std::boxed::Box<Operator<'tree>>),
13913 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
13914 PrefixTuple(::std::boxed::Box<PrefixTuple<'tree>>),
13915 Qualified(::std::boxed::Box<Qualified<'tree>>),
13916 Tuple(::std::boxed::Box<Tuple<'tree>>),
13917 Unit(::std::boxed::Box<Unit<'tree>>),
13918}
13919impl<'tree> ::treesitter_types::FromNode<'tree> for PromotedChildren<'tree> {
13920 #[allow(clippy::collapsible_else_if)]
13921 fn from_node(
13922 node: ::tree_sitter::Node<'tree>,
13923 src: &'tree [u8],
13924 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13925 match node.kind() {
13926 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
13927 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
13928 ))),
13929 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
13930 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
13931 ))),
13932 "empty_list" => Ok(Self::EmptyList(::std::boxed::Box::new(
13933 <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)?,
13934 ))),
13935 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
13936 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13937 ))),
13938 "list" => Ok(Self::List(::std::boxed::Box::new(
13939 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
13940 ))),
13941 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
13942 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
13943 ))),
13944 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
13945 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
13946 ))),
13947 "prefix_tuple" => Ok(Self::PrefixTuple(::std::boxed::Box::new(
13948 <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
13949 ))),
13950 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
13951 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
13952 ))),
13953 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
13954 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
13955 ))),
13956 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
13957 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
13958 ))),
13959 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13960 }
13961 }
13962}
13963impl ::treesitter_types::Spanned for PromotedChildren<'_> {
13964 fn span(&self) -> ::treesitter_types::Span {
13965 match self {
13966 Self::Constructor(inner) => inner.span(),
13967 Self::ConstructorOperator(inner) => inner.span(),
13968 Self::EmptyList(inner) => inner.span(),
13969 Self::InfixId(inner) => inner.span(),
13970 Self::List(inner) => inner.span(),
13971 Self::Operator(inner) => inner.span(),
13972 Self::PrefixId(inner) => inner.span(),
13973 Self::PrefixTuple(inner) => inner.span(),
13974 Self::Qualified(inner) => inner.span(),
13975 Self::Tuple(inner) => inner.span(),
13976 Self::Unit(inner) => inner.span(),
13977 }
13978 }
13979}
13980#[derive(Debug, Clone, PartialEq, Eq)]
13981pub enum QualifiedId<'tree> {
13982 Constructor(::std::boxed::Box<Constructor<'tree>>),
13983 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
13984 FieldName(::std::boxed::Box<FieldName<'tree>>),
13985 Name(::std::boxed::Box<Name<'tree>>),
13986 Operator(::std::boxed::Box<Operator<'tree>>),
13987 Variable(::std::boxed::Box<Variable<'tree>>),
13988}
13989impl<'tree> ::treesitter_types::FromNode<'tree> for QualifiedId<'tree> {
13990 #[allow(clippy::collapsible_else_if)]
13991 fn from_node(
13992 node: ::tree_sitter::Node<'tree>,
13993 src: &'tree [u8],
13994 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13995 match node.kind() {
13996 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
13997 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
13998 ))),
13999 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
14000 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
14001 ))),
14002 "field_name" => Ok(Self::FieldName(::std::boxed::Box::new(
14003 <FieldName as ::treesitter_types::FromNode>::from_node(node, src)?,
14004 ))),
14005 "name" => Ok(Self::Name(::std::boxed::Box::new(
14006 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14007 ))),
14008 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
14009 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
14010 ))),
14011 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
14012 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
14013 ))),
14014 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14015 }
14016 }
14017}
14018impl ::treesitter_types::Spanned for QualifiedId<'_> {
14019 fn span(&self) -> ::treesitter_types::Span {
14020 match self {
14021 Self::Constructor(inner) => inner.span(),
14022 Self::ConstructorOperator(inner) => inner.span(),
14023 Self::FieldName(inner) => inner.span(),
14024 Self::Name(inner) => inner.span(),
14025 Self::Operator(inner) => inner.span(),
14026 Self::Variable(inner) => inner.span(),
14027 }
14028 }
14029}
14030#[derive(Debug, Clone, PartialEq, Eq)]
14031pub enum QuantifiedVariablesChildren<'tree> {
14032 Inferred(::std::boxed::Box<Inferred<'tree>>),
14033 TypeParam(::std::boxed::Box<TypeParam<'tree>>),
14034}
14035impl<'tree> ::treesitter_types::FromNode<'tree> for QuantifiedVariablesChildren<'tree> {
14036 #[allow(clippy::collapsible_else_if)]
14037 fn from_node(
14038 node: ::tree_sitter::Node<'tree>,
14039 src: &'tree [u8],
14040 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14041 match node.kind() {
14042 "inferred" => Ok(Self::Inferred(::std::boxed::Box::new(
14043 <Inferred as ::treesitter_types::FromNode>::from_node(node, src)?,
14044 ))),
14045 _other => {
14046 if let Ok(v) = <TypeParam as ::treesitter_types::FromNode>::from_node(node, src) {
14047 Ok(Self::TypeParam(::std::boxed::Box::new(v)))
14048 } else {
14049 Err(::treesitter_types::ParseError::unexpected_kind(
14050 _other, node,
14051 ))
14052 }
14053 }
14054 }
14055 }
14056}
14057impl ::treesitter_types::Spanned for QuantifiedVariablesChildren<'_> {
14058 fn span(&self) -> ::treesitter_types::Span {
14059 match self {
14060 Self::Inferred(inner) => inner.span(),
14061 Self::TypeParam(inner) => inner.span(),
14062 }
14063 }
14064}
14065#[derive(Debug, Clone, PartialEq, Eq)]
14066pub enum QuoteQuoter {
14067 D(::treesitter_types::Span),
14068 E(::treesitter_types::Span),
14069 P(::treesitter_types::Span),
14070 T(::treesitter_types::Span),
14071}
14072impl<'tree> ::treesitter_types::FromNode<'tree> for QuoteQuoter {
14073 #[allow(clippy::collapsible_else_if)]
14074 fn from_node(
14075 node: ::tree_sitter::Node<'tree>,
14076 _src: &'tree [u8],
14077 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14078 match node.kind() {
14079 "d" => Ok(Self::D(::treesitter_types::Span::from(node))),
14080 "e" => Ok(Self::E(::treesitter_types::Span::from(node))),
14081 "p" => Ok(Self::P(::treesitter_types::Span::from(node))),
14082 "t" => Ok(Self::T(::treesitter_types::Span::from(node))),
14083 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14084 }
14085 }
14086}
14087impl ::treesitter_types::Spanned for QuoteQuoter {
14088 fn span(&self) -> ::treesitter_types::Span {
14089 match self {
14090 Self::D(span) => *span,
14091 Self::E(span) => *span,
14092 Self::P(span) => *span,
14093 Self::T(span) => *span,
14094 }
14095 }
14096}
14097#[derive(Debug, Clone, PartialEq, Eq)]
14098pub enum QuoteChildren<'tree> {
14099 QuotedDecls(::std::boxed::Box<QuotedDecls<'tree>>),
14100 QuotedExpression(::std::boxed::Box<QuotedExpression<'tree>>),
14101 QuotedPattern(::std::boxed::Box<QuotedPattern<'tree>>),
14102 QuotedType(::std::boxed::Box<QuotedType<'tree>>),
14103}
14104impl<'tree> ::treesitter_types::FromNode<'tree> for QuoteChildren<'tree> {
14105 #[allow(clippy::collapsible_else_if)]
14106 fn from_node(
14107 node: ::tree_sitter::Node<'tree>,
14108 src: &'tree [u8],
14109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14110 match node.kind() {
14111 "quoted_decls" => Ok(Self::QuotedDecls(::std::boxed::Box::new(
14112 <QuotedDecls as ::treesitter_types::FromNode>::from_node(node, src)?,
14113 ))),
14114 "quoted_expression" => Ok(Self::QuotedExpression(::std::boxed::Box::new(
14115 <QuotedExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
14116 ))),
14117 "quoted_pattern" => Ok(Self::QuotedPattern(::std::boxed::Box::new(
14118 <QuotedPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
14119 ))),
14120 "quoted_type" => Ok(Self::QuotedType(::std::boxed::Box::new(
14121 <QuotedType as ::treesitter_types::FromNode>::from_node(node, src)?,
14122 ))),
14123 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14124 }
14125 }
14126}
14127impl ::treesitter_types::Spanned for QuoteChildren<'_> {
14128 fn span(&self) -> ::treesitter_types::Span {
14129 match self {
14130 Self::QuotedDecls(inner) => inner.span(),
14131 Self::QuotedExpression(inner) => inner.span(),
14132 Self::QuotedPattern(inner) => inner.span(),
14133 Self::QuotedType(inner) => inner.span(),
14134 }
14135 }
14136}
14137#[derive(Debug, Clone, PartialEq, Eq)]
14138pub enum QuotedExpressionChildren<'tree> {
14139 Expression(::std::boxed::Box<Expression<'tree>>),
14140 Signature(::std::boxed::Box<Signature<'tree>>),
14141}
14142impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedExpressionChildren<'tree> {
14143 #[allow(clippy::collapsible_else_if)]
14144 fn from_node(
14145 node: ::tree_sitter::Node<'tree>,
14146 src: &'tree [u8],
14147 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14148 match node.kind() {
14149 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14150 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14151 ))),
14152 _other => {
14153 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14154 Ok(Self::Expression(::std::boxed::Box::new(v)))
14155 } else {
14156 Err(::treesitter_types::ParseError::unexpected_kind(
14157 _other, node,
14158 ))
14159 }
14160 }
14161 }
14162 }
14163}
14164impl ::treesitter_types::Spanned for QuotedExpressionChildren<'_> {
14165 fn span(&self) -> ::treesitter_types::Span {
14166 match self {
14167 Self::Expression(inner) => inner.span(),
14168 Self::Signature(inner) => inner.span(),
14169 }
14170 }
14171}
14172#[derive(Debug, Clone, PartialEq, Eq)]
14173pub enum QuotedPatternChildren<'tree> {
14174 Pattern(::std::boxed::Box<Pattern<'tree>>),
14175 Signature(::std::boxed::Box<Signature<'tree>>),
14176}
14177impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedPatternChildren<'tree> {
14178 #[allow(clippy::collapsible_else_if)]
14179 fn from_node(
14180 node: ::tree_sitter::Node<'tree>,
14181 src: &'tree [u8],
14182 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14183 match node.kind() {
14184 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14185 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14186 ))),
14187 _other => {
14188 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
14189 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14190 } else {
14191 Err(::treesitter_types::ParseError::unexpected_kind(
14192 _other, node,
14193 ))
14194 }
14195 }
14196 }
14197 }
14198}
14199impl ::treesitter_types::Spanned for QuotedPatternChildren<'_> {
14200 fn span(&self) -> ::treesitter_types::Span {
14201 match self {
14202 Self::Pattern(inner) => inner.span(),
14203 Self::Signature(inner) => inner.span(),
14204 }
14205 }
14206}
14207#[derive(Debug, Clone, PartialEq, Eq)]
14208pub enum QuotedTypeChildren<'tree> {
14209 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
14210 Signature(::std::boxed::Box<Signature<'tree>>),
14211}
14212impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedTypeChildren<'tree> {
14213 #[allow(clippy::collapsible_else_if)]
14214 fn from_node(
14215 node: ::tree_sitter::Node<'tree>,
14216 src: &'tree [u8],
14217 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14218 match node.kind() {
14219 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14220 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14221 ))),
14222 _other => {
14223 if let Ok(v) =
14224 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
14225 {
14226 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
14227 } else {
14228 Err(::treesitter_types::ParseError::unexpected_kind(
14229 _other, node,
14230 ))
14231 }
14232 }
14233 }
14234 }
14235}
14236impl ::treesitter_types::Spanned for QuotedTypeChildren<'_> {
14237 fn span(&self) -> ::treesitter_types::Span {
14238 match self {
14239 Self::QuantifiedType(inner) => inner.span(),
14240 Self::Signature(inner) => inner.span(),
14241 }
14242 }
14243}
14244#[derive(Debug, Clone, PartialEq, Eq)]
14245pub enum QuoterChildren<'tree> {
14246 Qualified(::std::boxed::Box<Qualified<'tree>>),
14247 Variable(::std::boxed::Box<Variable<'tree>>),
14248}
14249impl<'tree> ::treesitter_types::FromNode<'tree> for QuoterChildren<'tree> {
14250 #[allow(clippy::collapsible_else_if)]
14251 fn from_node(
14252 node: ::tree_sitter::Node<'tree>,
14253 src: &'tree [u8],
14254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14255 match node.kind() {
14256 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14257 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14258 ))),
14259 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
14260 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
14261 ))),
14262 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14263 }
14264 }
14265}
14266impl ::treesitter_types::Spanned for QuoterChildren<'_> {
14267 fn span(&self) -> ::treesitter_types::Span {
14268 match self {
14269 Self::Qualified(inner) => inner.span(),
14270 Self::Variable(inner) => inner.span(),
14271 }
14272 }
14273}
14274#[derive(Debug, Clone, PartialEq, Eq)]
14275pub enum RecordArrow {
14276 Arrow(::treesitter_types::Span),
14277 X(::treesitter_types::Span),
14278}
14279impl<'tree> ::treesitter_types::FromNode<'tree> for RecordArrow {
14280 #[allow(clippy::collapsible_else_if)]
14281 fn from_node(
14282 node: ::tree_sitter::Node<'tree>,
14283 _src: &'tree [u8],
14284 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14285 match node.kind() {
14286 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
14287 "→" => Ok(Self::X(::treesitter_types::Span::from(node))),
14288 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14289 }
14290 }
14291}
14292impl ::treesitter_types::Spanned for RecordArrow {
14293 fn span(&self) -> ::treesitter_types::Span {
14294 match self {
14295 Self::Arrow(span) => *span,
14296 Self::X(span) => *span,
14297 }
14298 }
14299}
14300#[derive(Debug, Clone, PartialEq, Eq)]
14301pub enum RecordField<'tree> {
14302 Field(::std::boxed::Box<Field<'tree>>),
14303 FieldPattern(::std::boxed::Box<FieldPattern<'tree>>),
14304 FieldUpdate(::std::boxed::Box<FieldUpdate<'tree>>),
14305}
14306impl<'tree> ::treesitter_types::FromNode<'tree> for RecordField<'tree> {
14307 #[allow(clippy::collapsible_else_if)]
14308 fn from_node(
14309 node: ::tree_sitter::Node<'tree>,
14310 src: &'tree [u8],
14311 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14312 match node.kind() {
14313 "field" => Ok(Self::Field(::std::boxed::Box::new(
14314 <Field as ::treesitter_types::FromNode>::from_node(node, src)?,
14315 ))),
14316 "field_pattern" => Ok(Self::FieldPattern(::std::boxed::Box::new(
14317 <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
14318 ))),
14319 "field_update" => Ok(Self::FieldUpdate(::std::boxed::Box::new(
14320 <FieldUpdate as ::treesitter_types::FromNode>::from_node(node, src)?,
14321 ))),
14322 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14323 }
14324 }
14325}
14326impl ::treesitter_types::Spanned for RecordField<'_> {
14327 fn span(&self) -> ::treesitter_types::Span {
14328 match self {
14329 Self::Field(inner) => inner.span(),
14330 Self::FieldPattern(inner) => inner.span(),
14331 Self::FieldUpdate(inner) => inner.span(),
14332 }
14333 }
14334}
14335#[derive(Debug, Clone, PartialEq, Eq)]
14336pub enum RightSectionChildren<'tree> {
14337 ConstructorOperator(::std::boxed::Box<ConstructorOperator<'tree>>),
14338 InfixId(::std::boxed::Box<InfixId<'tree>>),
14339 Operator(::std::boxed::Box<Operator<'tree>>),
14340 Qualified(::std::boxed::Box<Qualified<'tree>>),
14341}
14342impl<'tree> ::treesitter_types::FromNode<'tree> for RightSectionChildren<'tree> {
14343 #[allow(clippy::collapsible_else_if)]
14344 fn from_node(
14345 node: ::tree_sitter::Node<'tree>,
14346 src: &'tree [u8],
14347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14348 match node.kind() {
14349 "constructor_operator" => Ok(Self::ConstructorOperator(::std::boxed::Box::new(
14350 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
14351 ))),
14352 "infix_id" => Ok(Self::InfixId(::std::boxed::Box::new(
14353 <InfixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14354 ))),
14355 "operator" => Ok(Self::Operator(::std::boxed::Box::new(
14356 <Operator as ::treesitter_types::FromNode>::from_node(node, src)?,
14357 ))),
14358 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14359 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14360 ))),
14361 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14362 }
14363 }
14364}
14365impl ::treesitter_types::Spanned for RightSectionChildren<'_> {
14366 fn span(&self) -> ::treesitter_types::Span {
14367 match self {
14368 Self::ConstructorOperator(inner) => inner.span(),
14369 Self::InfixId(inner) => inner.span(),
14370 Self::Operator(inner) => inner.span(),
14371 Self::Qualified(inner) => inner.span(),
14372 }
14373 }
14374}
14375#[derive(Debug, Clone, PartialEq, Eq)]
14376pub enum RoleAnnotationType<'tree> {
14377 Name(::std::boxed::Box<Name<'tree>>),
14378 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14379 Qualified(::std::boxed::Box<Qualified<'tree>>),
14380}
14381impl<'tree> ::treesitter_types::FromNode<'tree> for RoleAnnotationType<'tree> {
14382 #[allow(clippy::collapsible_else_if)]
14383 fn from_node(
14384 node: ::tree_sitter::Node<'tree>,
14385 src: &'tree [u8],
14386 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14387 match node.kind() {
14388 "name" => Ok(Self::Name(::std::boxed::Box::new(
14389 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14390 ))),
14391 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14392 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14393 ))),
14394 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14395 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14396 ))),
14397 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14398 }
14399 }
14400}
14401impl ::treesitter_types::Spanned for RoleAnnotationType<'_> {
14402 fn span(&self) -> ::treesitter_types::Span {
14403 match self {
14404 Self::Name(inner) => inner.span(),
14405 Self::PrefixId(inner) => inner.span(),
14406 Self::Qualified(inner) => inner.span(),
14407 }
14408 }
14409}
14410#[derive(Debug, Clone, PartialEq, Eq)]
14411pub enum SignatureName<'tree> {
14412 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14413 Variable(::std::boxed::Box<Variable<'tree>>),
14414}
14415impl<'tree> ::treesitter_types::FromNode<'tree> for SignatureName<'tree> {
14416 #[allow(clippy::collapsible_else_if)]
14417 fn from_node(
14418 node: ::tree_sitter::Node<'tree>,
14419 src: &'tree [u8],
14420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14421 match node.kind() {
14422 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14423 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14424 ))),
14425 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
14426 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
14427 ))),
14428 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14429 }
14430 }
14431}
14432impl ::treesitter_types::Spanned for SignatureName<'_> {
14433 fn span(&self) -> ::treesitter_types::Span {
14434 match self {
14435 Self::PrefixId(inner) => inner.span(),
14436 Self::Variable(inner) => inner.span(),
14437 }
14438 }
14439}
14440#[derive(Debug, Clone, PartialEq, Eq)]
14441pub enum SignatureSynonym<'tree> {
14442 BindingList(::std::boxed::Box<BindingList<'tree>>),
14443 Constructor(::std::boxed::Box<Constructor<'tree>>),
14444 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14445}
14446impl<'tree> ::treesitter_types::FromNode<'tree> for SignatureSynonym<'tree> {
14447 #[allow(clippy::collapsible_else_if)]
14448 fn from_node(
14449 node: ::tree_sitter::Node<'tree>,
14450 src: &'tree [u8],
14451 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14452 match node.kind() {
14453 "binding_list" => Ok(Self::BindingList(::std::boxed::Box::new(
14454 <BindingList as ::treesitter_types::FromNode>::from_node(node, src)?,
14455 ))),
14456 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14457 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
14458 ))),
14459 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14460 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14461 ))),
14462 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14463 }
14464 }
14465}
14466impl ::treesitter_types::Spanned for SignatureSynonym<'_> {
14467 fn span(&self) -> ::treesitter_types::Span {
14468 match self {
14469 Self::BindingList(inner) => inner.span(),
14470 Self::Constructor(inner) => inner.span(),
14471 Self::PrefixId(inner) => inner.span(),
14472 }
14473 }
14474}
14475#[derive(Debug, Clone, PartialEq, Eq)]
14476pub enum SpecialChildren<'tree> {
14477 EmptyList(::std::boxed::Box<EmptyList<'tree>>),
14478 Tuple(::std::boxed::Box<Tuple<'tree>>),
14479 UnboxedSum(::std::boxed::Box<UnboxedSum<'tree>>),
14480 UnboxedTuple(::std::boxed::Box<UnboxedTuple<'tree>>),
14481 UnboxedUnit(::std::boxed::Box<UnboxedUnit<'tree>>),
14482 Unit(::std::boxed::Box<Unit<'tree>>),
14483}
14484impl<'tree> ::treesitter_types::FromNode<'tree> for SpecialChildren<'tree> {
14485 #[allow(clippy::collapsible_else_if)]
14486 fn from_node(
14487 node: ::tree_sitter::Node<'tree>,
14488 src: &'tree [u8],
14489 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14490 match node.kind() {
14491 "empty_list" => Ok(Self::EmptyList(::std::boxed::Box::new(
14492 <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)?,
14493 ))),
14494 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
14495 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
14496 ))),
14497 "unboxed_sum" => Ok(Self::UnboxedSum(::std::boxed::Box::new(
14498 <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)?,
14499 ))),
14500 "unboxed_tuple" => Ok(Self::UnboxedTuple(::std::boxed::Box::new(
14501 <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)?,
14502 ))),
14503 "unboxed_unit" => Ok(Self::UnboxedUnit(::std::boxed::Box::new(
14504 <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)?,
14505 ))),
14506 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
14507 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
14508 ))),
14509 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14510 }
14511 }
14512}
14513impl ::treesitter_types::Spanned for SpecialChildren<'_> {
14514 fn span(&self) -> ::treesitter_types::Span {
14515 match self {
14516 Self::EmptyList(inner) => inner.span(),
14517 Self::Tuple(inner) => inner.span(),
14518 Self::UnboxedSum(inner) => inner.span(),
14519 Self::UnboxedTuple(inner) => inner.span(),
14520 Self::UnboxedUnit(inner) => inner.span(),
14521 Self::Unit(inner) => inner.span(),
14522 }
14523 }
14524}
14525#[derive(Debug, Clone, PartialEq, Eq)]
14526pub enum SpliceExpression<'tree> {
14527 Constructor(::std::boxed::Box<Constructor<'tree>>),
14528 ImplicitVariable(::std::boxed::Box<ImplicitVariable<'tree>>),
14529 Label(::std::boxed::Box<Label<'tree>>),
14530 Literal(::std::boxed::Box<Literal<'tree>>),
14531 Parens(::std::boxed::Box<Parens<'tree>>),
14532 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14533 Qualified(::std::boxed::Box<Qualified<'tree>>),
14534 Variable(::std::boxed::Box<Variable<'tree>>),
14535}
14536impl<'tree> ::treesitter_types::FromNode<'tree> for SpliceExpression<'tree> {
14537 #[allow(clippy::collapsible_else_if)]
14538 fn from_node(
14539 node: ::tree_sitter::Node<'tree>,
14540 src: &'tree [u8],
14541 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14542 match node.kind() {
14543 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14544 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
14545 ))),
14546 "implicit_variable" => Ok(Self::ImplicitVariable(::std::boxed::Box::new(
14547 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)?,
14548 ))),
14549 "label" => Ok(Self::Label(::std::boxed::Box::new(
14550 <Label as ::treesitter_types::FromNode>::from_node(node, src)?,
14551 ))),
14552 "literal" => Ok(Self::Literal(::std::boxed::Box::new(
14553 <Literal as ::treesitter_types::FromNode>::from_node(node, src)?,
14554 ))),
14555 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
14556 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
14557 ))),
14558 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14559 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14560 ))),
14561 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14562 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14563 ))),
14564 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
14565 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
14566 ))),
14567 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14568 }
14569 }
14570}
14571impl ::treesitter_types::Spanned for SpliceExpression<'_> {
14572 fn span(&self) -> ::treesitter_types::Span {
14573 match self {
14574 Self::Constructor(inner) => inner.span(),
14575 Self::ImplicitVariable(inner) => inner.span(),
14576 Self::Label(inner) => inner.span(),
14577 Self::Literal(inner) => inner.span(),
14578 Self::Parens(inner) => inner.span(),
14579 Self::PrefixId(inner) => inner.span(),
14580 Self::Qualified(inner) => inner.span(),
14581 Self::Variable(inner) => inner.span(),
14582 }
14583 }
14584}
14585#[derive(Debug, Clone, PartialEq, Eq)]
14586pub enum ThQuotedNameName<'tree> {
14587 Constructor(::std::boxed::Box<Constructor<'tree>>),
14588 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14589 Qualified(::std::boxed::Box<Qualified<'tree>>),
14590 Variable(::std::boxed::Box<Variable<'tree>>),
14591}
14592impl<'tree> ::treesitter_types::FromNode<'tree> for ThQuotedNameName<'tree> {
14593 #[allow(clippy::collapsible_else_if)]
14594 fn from_node(
14595 node: ::tree_sitter::Node<'tree>,
14596 src: &'tree [u8],
14597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14598 match node.kind() {
14599 "constructor" => Ok(Self::Constructor(::std::boxed::Box::new(
14600 <Constructor as ::treesitter_types::FromNode>::from_node(node, src)?,
14601 ))),
14602 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14603 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14604 ))),
14605 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14606 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14607 ))),
14608 "variable" => Ok(Self::Variable(::std::boxed::Box::new(
14609 <Variable as ::treesitter_types::FromNode>::from_node(node, src)?,
14610 ))),
14611 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14612 }
14613 }
14614}
14615impl ::treesitter_types::Spanned for ThQuotedNameName<'_> {
14616 fn span(&self) -> ::treesitter_types::Span {
14617 match self {
14618 Self::Constructor(inner) => inner.span(),
14619 Self::PrefixId(inner) => inner.span(),
14620 Self::Qualified(inner) => inner.span(),
14621 Self::Variable(inner) => inner.span(),
14622 }
14623 }
14624}
14625#[derive(Debug, Clone, PartialEq, Eq)]
14626pub enum TransformKey<'tree> {
14627 Expression(::std::boxed::Box<Expression<'tree>>),
14628 Signature(::std::boxed::Box<Signature<'tree>>),
14629}
14630impl<'tree> ::treesitter_types::FromNode<'tree> for TransformKey<'tree> {
14631 #[allow(clippy::collapsible_else_if)]
14632 fn from_node(
14633 node: ::tree_sitter::Node<'tree>,
14634 src: &'tree [u8],
14635 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14636 match node.kind() {
14637 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14638 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14639 ))),
14640 _other => {
14641 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14642 Ok(Self::Expression(::std::boxed::Box::new(v)))
14643 } else {
14644 Err(::treesitter_types::ParseError::unexpected_kind(
14645 _other, node,
14646 ))
14647 }
14648 }
14649 }
14650 }
14651}
14652impl ::treesitter_types::Spanned for TransformKey<'_> {
14653 fn span(&self) -> ::treesitter_types::Span {
14654 match self {
14655 Self::Expression(inner) => inner.span(),
14656 Self::Signature(inner) => inner.span(),
14657 }
14658 }
14659}
14660#[derive(Debug, Clone, PartialEq, Eq)]
14661pub enum TransformTransformation<'tree> {
14662 Expression(::std::boxed::Box<Expression<'tree>>),
14663 Signature(::std::boxed::Box<Signature<'tree>>),
14664}
14665impl<'tree> ::treesitter_types::FromNode<'tree> for TransformTransformation<'tree> {
14666 #[allow(clippy::collapsible_else_if)]
14667 fn from_node(
14668 node: ::tree_sitter::Node<'tree>,
14669 src: &'tree [u8],
14670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14671 match node.kind() {
14672 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14673 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14674 ))),
14675 _other => {
14676 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
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 TransformTransformation<'_> {
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 TupleElement<'tree> {
14697 Expression(::std::boxed::Box<Expression<'tree>>),
14698 Pattern(::std::boxed::Box<Pattern<'tree>>),
14699 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
14700 Signature(::std::boxed::Box<Signature<'tree>>),
14701 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
14702}
14703impl<'tree> ::treesitter_types::FromNode<'tree> for TupleElement<'tree> {
14704 #[allow(clippy::collapsible_else_if)]
14705 fn from_node(
14706 node: ::tree_sitter::Node<'tree>,
14707 src: &'tree [u8],
14708 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14709 match node.kind() {
14710 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
14711 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
14712 ))),
14713 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
14714 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
14715 ))),
14716 _other => {
14717 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
14718 Ok(Self::Expression(::std::boxed::Box::new(v)))
14719 } else {
14720 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
14721 Ok(Self::Pattern(::std::boxed::Box::new(v)))
14722 } else {
14723 if let Ok(v) =
14724 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
14725 {
14726 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
14727 } else {
14728 Err(::treesitter_types::ParseError::unexpected_kind(
14729 _other, node,
14730 ))
14731 }
14732 }
14733 }
14734 }
14735 }
14736 }
14737}
14738impl ::treesitter_types::Spanned for TupleElement<'_> {
14739 fn span(&self) -> ::treesitter_types::Span {
14740 match self {
14741 Self::Expression(inner) => inner.span(),
14742 Self::Pattern(inner) => inner.span(),
14743 Self::QuantifiedType(inner) => inner.span(),
14744 Self::Signature(inner) => inner.span(),
14745 Self::ViewPattern(inner) => inner.span(),
14746 }
14747 }
14748}
14749#[derive(Debug, Clone, PartialEq, Eq)]
14750pub enum TypeFamilyClosedFamily<'tree> {
14751 AbstractFamily(::std::boxed::Box<AbstractFamily<'tree>>),
14752 Equations(::std::boxed::Box<Equations<'tree>>),
14753}
14754impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyClosedFamily<'tree> {
14755 #[allow(clippy::collapsible_else_if)]
14756 fn from_node(
14757 node: ::tree_sitter::Node<'tree>,
14758 src: &'tree [u8],
14759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14760 match node.kind() {
14761 "abstract_family" => Ok(Self::AbstractFamily(::std::boxed::Box::new(
14762 <AbstractFamily as ::treesitter_types::FromNode>::from_node(node, src)?,
14763 ))),
14764 "equations" => Ok(Self::Equations(::std::boxed::Box::new(
14765 <Equations as ::treesitter_types::FromNode>::from_node(node, src)?,
14766 ))),
14767 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14768 }
14769 }
14770}
14771impl ::treesitter_types::Spanned for TypeFamilyClosedFamily<'_> {
14772 fn span(&self) -> ::treesitter_types::Span {
14773 match self {
14774 Self::AbstractFamily(inner) => inner.span(),
14775 Self::Equations(inner) => inner.span(),
14776 }
14777 }
14778}
14779#[derive(Debug, Clone, PartialEq, Eq)]
14780pub enum TypeFamilyName<'tree> {
14781 Name(::std::boxed::Box<Name<'tree>>),
14782 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14783 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
14784 Unit(::std::boxed::Box<Unit<'tree>>),
14785}
14786impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyName<'tree> {
14787 #[allow(clippy::collapsible_else_if)]
14788 fn from_node(
14789 node: ::tree_sitter::Node<'tree>,
14790 src: &'tree [u8],
14791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14792 match node.kind() {
14793 "name" => Ok(Self::Name(::std::boxed::Box::new(
14794 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14795 ))),
14796 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14797 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14798 ))),
14799 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
14800 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
14801 ))),
14802 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
14803 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
14804 ))),
14805 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14806 }
14807 }
14808}
14809impl ::treesitter_types::Spanned for TypeFamilyName<'_> {
14810 fn span(&self) -> ::treesitter_types::Span {
14811 match self {
14812 Self::Name(inner) => inner.span(),
14813 Self::PrefixId(inner) => inner.span(),
14814 Self::PrefixList(inner) => inner.span(),
14815 Self::Unit(inner) => inner.span(),
14816 }
14817 }
14818}
14819#[derive(Debug, Clone, PartialEq, Eq)]
14820pub enum TypeFamilyChildren<'tree> {
14821 Infix(::std::boxed::Box<Infix<'tree>>),
14822 Parens(::std::boxed::Box<Parens<'tree>>),
14823 TypeFamilyInjectivity(::std::boxed::Box<TypeFamilyInjectivity<'tree>>),
14824 TypeFamilyResult(::std::boxed::Box<TypeFamilyResult<'tree>>),
14825}
14826impl<'tree> ::treesitter_types::FromNode<'tree> for TypeFamilyChildren<'tree> {
14827 #[allow(clippy::collapsible_else_if)]
14828 fn from_node(
14829 node: ::tree_sitter::Node<'tree>,
14830 src: &'tree [u8],
14831 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14832 match node.kind() {
14833 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
14834 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
14835 ))),
14836 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
14837 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
14838 ))),
14839 "type_family_injectivity" => Ok(Self::TypeFamilyInjectivity(::std::boxed::Box::new(
14840 <TypeFamilyInjectivity as ::treesitter_types::FromNode>::from_node(node, src)?,
14841 ))),
14842 "type_family_result" => Ok(Self::TypeFamilyResult(::std::boxed::Box::new(
14843 <TypeFamilyResult as ::treesitter_types::FromNode>::from_node(node, src)?,
14844 ))),
14845 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14846 }
14847 }
14848}
14849impl ::treesitter_types::Spanned for TypeFamilyChildren<'_> {
14850 fn span(&self) -> ::treesitter_types::Span {
14851 match self {
14852 Self::Infix(inner) => inner.span(),
14853 Self::Parens(inner) => inner.span(),
14854 Self::TypeFamilyInjectivity(inner) => inner.span(),
14855 Self::TypeFamilyResult(inner) => inner.span(),
14856 }
14857 }
14858}
14859#[derive(Debug, Clone, PartialEq, Eq)]
14860pub enum TypeInstanceForall<'tree> {
14861 Forall(::std::boxed::Box<Forall<'tree>>),
14862 ForallRequired(::std::boxed::Box<ForallRequired<'tree>>),
14863}
14864impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceForall<'tree> {
14865 #[allow(clippy::collapsible_else_if)]
14866 fn from_node(
14867 node: ::tree_sitter::Node<'tree>,
14868 src: &'tree [u8],
14869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14870 match node.kind() {
14871 "forall" => Ok(Self::Forall(::std::boxed::Box::new(
14872 <Forall as ::treesitter_types::FromNode>::from_node(node, src)?,
14873 ))),
14874 "forall_required" => Ok(Self::ForallRequired(::std::boxed::Box::new(
14875 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)?,
14876 ))),
14877 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14878 }
14879 }
14880}
14881impl ::treesitter_types::Spanned for TypeInstanceForall<'_> {
14882 fn span(&self) -> ::treesitter_types::Span {
14883 match self {
14884 Self::Forall(inner) => inner.span(),
14885 Self::ForallRequired(inner) => inner.span(),
14886 }
14887 }
14888}
14889#[derive(Debug, Clone, PartialEq, Eq)]
14890pub enum TypeInstanceName<'tree> {
14891 Name(::std::boxed::Box<Name<'tree>>),
14892 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
14893 Qualified(::std::boxed::Box<Qualified<'tree>>),
14894}
14895impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceName<'tree> {
14896 #[allow(clippy::collapsible_else_if)]
14897 fn from_node(
14898 node: ::tree_sitter::Node<'tree>,
14899 src: &'tree [u8],
14900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14901 match node.kind() {
14902 "name" => Ok(Self::Name(::std::boxed::Box::new(
14903 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
14904 ))),
14905 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
14906 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
14907 ))),
14908 "qualified" => Ok(Self::Qualified(::std::boxed::Box::new(
14909 <Qualified as ::treesitter_types::FromNode>::from_node(node, src)?,
14910 ))),
14911 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
14912 }
14913 }
14914}
14915impl ::treesitter_types::Spanned for TypeInstanceName<'_> {
14916 fn span(&self) -> ::treesitter_types::Span {
14917 match self {
14918 Self::Name(inner) => inner.span(),
14919 Self::PrefixId(inner) => inner.span(),
14920 Self::Qualified(inner) => inner.span(),
14921 }
14922 }
14923}
14924#[derive(Debug, Clone, PartialEq, Eq)]
14925pub enum TypeInstanceChildren<'tree> {
14926 Infix(::std::boxed::Box<Infix<'tree>>),
14927 Parens(::std::boxed::Box<Parens<'tree>>),
14928 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
14929}
14930impl<'tree> ::treesitter_types::FromNode<'tree> for TypeInstanceChildren<'tree> {
14931 #[allow(clippy::collapsible_else_if)]
14932 fn from_node(
14933 node: ::tree_sitter::Node<'tree>,
14934 src: &'tree [u8],
14935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14936 match node.kind() {
14937 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
14938 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
14939 ))),
14940 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
14941 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
14942 ))),
14943 _other => {
14944 if let Ok(v) =
14945 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
14946 {
14947 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
14948 } else {
14949 Err(::treesitter_types::ParseError::unexpected_kind(
14950 _other, node,
14951 ))
14952 }
14953 }
14954 }
14955 }
14956}
14957impl ::treesitter_types::Spanned for TypeInstanceChildren<'_> {
14958 fn span(&self) -> ::treesitter_types::Span {
14959 match self {
14960 Self::Infix(inner) => inner.span(),
14961 Self::Parens(inner) => inner.span(),
14962 Self::QuantifiedType(inner) => inner.span(),
14963 }
14964 }
14965}
14966#[derive(Debug, Clone, PartialEq, Eq)]
14967pub enum TypePatternsChildren<'tree> {
14968 KindApplication(::std::boxed::Box<KindApplication<'tree>>),
14969 Type(::std::boxed::Box<Type<'tree>>),
14970}
14971impl<'tree> ::treesitter_types::FromNode<'tree> for TypePatternsChildren<'tree> {
14972 #[allow(clippy::collapsible_else_if)]
14973 fn from_node(
14974 node: ::tree_sitter::Node<'tree>,
14975 src: &'tree [u8],
14976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
14977 match node.kind() {
14978 "kind_application" => Ok(Self::KindApplication(::std::boxed::Box::new(
14979 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)?,
14980 ))),
14981 _other => {
14982 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
14983 Ok(Self::Type(::std::boxed::Box::new(v)))
14984 } else {
14985 Err(::treesitter_types::ParseError::unexpected_kind(
14986 _other, node,
14987 ))
14988 }
14989 }
14990 }
14991 }
14992}
14993impl ::treesitter_types::Spanned for TypePatternsChildren<'_> {
14994 fn span(&self) -> ::treesitter_types::Span {
14995 match self {
14996 Self::KindApplication(inner) => inner.span(),
14997 Self::Type(inner) => inner.span(),
14998 }
14999 }
15000}
15001#[derive(Debug, Clone, PartialEq, Eq)]
15002pub enum TypeSynomymName<'tree> {
15003 Name(::std::boxed::Box<Name<'tree>>),
15004 PrefixId(::std::boxed::Box<PrefixId<'tree>>),
15005 PrefixList(::std::boxed::Box<PrefixList<'tree>>),
15006 Unit(::std::boxed::Box<Unit<'tree>>),
15007}
15008impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymName<'tree> {
15009 #[allow(clippy::collapsible_else_if)]
15010 fn from_node(
15011 node: ::tree_sitter::Node<'tree>,
15012 src: &'tree [u8],
15013 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15014 match node.kind() {
15015 "name" => Ok(Self::Name(::std::boxed::Box::new(
15016 <Name as ::treesitter_types::FromNode>::from_node(node, src)?,
15017 ))),
15018 "prefix_id" => Ok(Self::PrefixId(::std::boxed::Box::new(
15019 <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)?,
15020 ))),
15021 "prefix_list" => Ok(Self::PrefixList(::std::boxed::Box::new(
15022 <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)?,
15023 ))),
15024 "unit" => Ok(Self::Unit(::std::boxed::Box::new(
15025 <Unit as ::treesitter_types::FromNode>::from_node(node, src)?,
15026 ))),
15027 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15028 }
15029 }
15030}
15031impl ::treesitter_types::Spanned for TypeSynomymName<'_> {
15032 fn span(&self) -> ::treesitter_types::Span {
15033 match self {
15034 Self::Name(inner) => inner.span(),
15035 Self::PrefixId(inner) => inner.span(),
15036 Self::PrefixList(inner) => inner.span(),
15037 Self::Unit(inner) => inner.span(),
15038 }
15039 }
15040}
15041#[derive(Debug, Clone, PartialEq, Eq)]
15042pub enum TypeSynomymType<'tree> {
15043 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
15044 Signature(::std::boxed::Box<Signature<'tree>>),
15045}
15046impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymType<'tree> {
15047 #[allow(clippy::collapsible_else_if)]
15048 fn from_node(
15049 node: ::tree_sitter::Node<'tree>,
15050 src: &'tree [u8],
15051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15052 match node.kind() {
15053 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15054 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
15055 ))),
15056 _other => {
15057 if let Ok(v) =
15058 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15059 {
15060 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
15061 } else {
15062 Err(::treesitter_types::ParseError::unexpected_kind(
15063 _other, node,
15064 ))
15065 }
15066 }
15067 }
15068 }
15069}
15070impl ::treesitter_types::Spanned for TypeSynomymType<'_> {
15071 fn span(&self) -> ::treesitter_types::Span {
15072 match self {
15073 Self::QuantifiedType(inner) => inner.span(),
15074 Self::Signature(inner) => inner.span(),
15075 }
15076 }
15077}
15078#[derive(Debug, Clone, PartialEq, Eq)]
15079pub enum TypeSynomymChildren<'tree> {
15080 Infix(::std::boxed::Box<Infix<'tree>>),
15081 Parens(::std::boxed::Box<Parens<'tree>>),
15082}
15083impl<'tree> ::treesitter_types::FromNode<'tree> for TypeSynomymChildren<'tree> {
15084 #[allow(clippy::collapsible_else_if)]
15085 fn from_node(
15086 node: ::tree_sitter::Node<'tree>,
15087 src: &'tree [u8],
15088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15089 match node.kind() {
15090 "infix" => Ok(Self::Infix(::std::boxed::Box::new(
15091 <Infix as ::treesitter_types::FromNode>::from_node(node, src)?,
15092 ))),
15093 "parens" => Ok(Self::Parens(::std::boxed::Box::new(
15094 <Parens as ::treesitter_types::FromNode>::from_node(node, src)?,
15095 ))),
15096 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
15097 }
15098 }
15099}
15100impl ::treesitter_types::Spanned for TypeSynomymChildren<'_> {
15101 fn span(&self) -> ::treesitter_types::Span {
15102 match self {
15103 Self::Infix(inner) => inner.span(),
15104 Self::Parens(inner) => inner.span(),
15105 }
15106 }
15107}
15108#[derive(Debug, Clone, PartialEq, Eq)]
15109pub enum UnboxedSumElement<'tree> {
15110 Expression(::std::boxed::Box<Expression<'tree>>),
15111 Pattern(::std::boxed::Box<Pattern<'tree>>),
15112 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
15113 Signature(::std::boxed::Box<Signature<'tree>>),
15114 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
15115}
15116impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedSumElement<'tree> {
15117 #[allow(clippy::collapsible_else_if)]
15118 fn from_node(
15119 node: ::tree_sitter::Node<'tree>,
15120 src: &'tree [u8],
15121 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15122 match node.kind() {
15123 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15124 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
15125 ))),
15126 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
15127 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
15128 ))),
15129 _other => {
15130 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15131 Ok(Self::Expression(::std::boxed::Box::new(v)))
15132 } else {
15133 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
15134 Ok(Self::Pattern(::std::boxed::Box::new(v)))
15135 } else {
15136 if let Ok(v) =
15137 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15138 {
15139 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
15140 } else {
15141 Err(::treesitter_types::ParseError::unexpected_kind(
15142 _other, node,
15143 ))
15144 }
15145 }
15146 }
15147 }
15148 }
15149 }
15150}
15151impl ::treesitter_types::Spanned for UnboxedSumElement<'_> {
15152 fn span(&self) -> ::treesitter_types::Span {
15153 match self {
15154 Self::Expression(inner) => inner.span(),
15155 Self::Pattern(inner) => inner.span(),
15156 Self::QuantifiedType(inner) => inner.span(),
15157 Self::Signature(inner) => inner.span(),
15158 Self::ViewPattern(inner) => inner.span(),
15159 }
15160 }
15161}
15162#[derive(Debug, Clone, PartialEq, Eq)]
15163pub enum UnboxedTupleElement<'tree> {
15164 Expression(::std::boxed::Box<Expression<'tree>>),
15165 Pattern(::std::boxed::Box<Pattern<'tree>>),
15166 QuantifiedType(::std::boxed::Box<QuantifiedType<'tree>>),
15167 Signature(::std::boxed::Box<Signature<'tree>>),
15168 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
15169}
15170impl<'tree> ::treesitter_types::FromNode<'tree> for UnboxedTupleElement<'tree> {
15171 #[allow(clippy::collapsible_else_if)]
15172 fn from_node(
15173 node: ::tree_sitter::Node<'tree>,
15174 src: &'tree [u8],
15175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15176 match node.kind() {
15177 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15178 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
15179 ))),
15180 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
15181 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
15182 ))),
15183 _other => {
15184 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15185 Ok(Self::Expression(::std::boxed::Box::new(v)))
15186 } else {
15187 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
15188 Ok(Self::Pattern(::std::boxed::Box::new(v)))
15189 } else {
15190 if let Ok(v) =
15191 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15192 {
15193 Ok(Self::QuantifiedType(::std::boxed::Box::new(v)))
15194 } else {
15195 Err(::treesitter_types::ParseError::unexpected_kind(
15196 _other, node,
15197 ))
15198 }
15199 }
15200 }
15201 }
15202 }
15203 }
15204}
15205impl ::treesitter_types::Spanned for UnboxedTupleElement<'_> {
15206 fn span(&self) -> ::treesitter_types::Span {
15207 match self {
15208 Self::Expression(inner) => inner.span(),
15209 Self::Pattern(inner) => inner.span(),
15210 Self::QuantifiedType(inner) => inner.span(),
15211 Self::Signature(inner) => inner.span(),
15212 Self::ViewPattern(inner) => inner.span(),
15213 }
15214 }
15215}
15216#[derive(Debug, Clone, PartialEq, Eq)]
15217pub enum ViewPatternExpression<'tree> {
15218 Expression(::std::boxed::Box<Expression<'tree>>),
15219 Signature(::std::boxed::Box<Signature<'tree>>),
15220}
15221impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPatternExpression<'tree> {
15222 #[allow(clippy::collapsible_else_if)]
15223 fn from_node(
15224 node: ::tree_sitter::Node<'tree>,
15225 src: &'tree [u8],
15226 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
15227 match node.kind() {
15228 "signature" => Ok(Self::Signature(::std::boxed::Box::new(
15229 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
15230 ))),
15231 _other => {
15232 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
15233 Ok(Self::Expression(::std::boxed::Box::new(v)))
15234 } else {
15235 Err(::treesitter_types::ParseError::unexpected_kind(
15236 _other, node,
15237 ))
15238 }
15239 }
15240 }
15241 }
15242}
15243impl ::treesitter_types::Spanned for ViewPatternExpression<'_> {
15244 fn span(&self) -> ::treesitter_types::Span {
15245 match self {
15246 Self::Expression(inner) => inner.span(),
15247 Self::Signature(inner) => inner.span(),
15248 }
15249 }
15250}
15251#[derive(Debug, Clone, PartialEq, Eq)]
15252pub enum ViewPatternPattern<'tree> {
15253 Pattern(::std::boxed::Box<Pattern<'tree>>),
15254 Signature(::std::boxed::Box<Signature<'tree>>),
15255 ViewPattern(::std::boxed::Box<ViewPattern<'tree>>),
15256}
15257impl<'tree> ::treesitter_types::FromNode<'tree> for ViewPatternPattern<'tree> {
15258 #[allow(clippy::collapsible_else_if)]
15259 fn from_node(
15260 node: ::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 <Signature as ::treesitter_types::FromNode>::from_node(node, src)?,
15266 ))),
15267 "view_pattern" => Ok(Self::ViewPattern(::std::boxed::Box::new(
15268 <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
15269 ))),
15270 _other => {
15271 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
15272 Ok(Self::Pattern(::std::boxed::Box::new(v)))
15273 } else {
15274 Err(::treesitter_types::ParseError::unexpected_kind(
15275 _other, node,
15276 ))
15277 }
15278 }
15279 }
15280 }
15281}
15282impl ::treesitter_types::Spanned for ViewPatternPattern<'_> {
15283 fn span(&self) -> ::treesitter_types::Span {
15284 match self {
15285 Self::Pattern(inner) => inner.span(),
15286 Self::Signature(inner) => inner.span(),
15287 Self::ViewPattern(inner) => inner.span(),
15288 }
15289 }
15290}
15291#[derive(Debug, Clone, PartialEq, Eq)]
15292pub enum AnyNode<'tree> {
15293 ClassDecl(ClassDecl<'tree>),
15294 Constraint(Constraint<'tree>),
15295 Constraints(Constraints<'tree>),
15296 Decl(Decl<'tree>),
15297 Declaration(Declaration<'tree>),
15298 Expression(Expression<'tree>),
15299 Guard(Guard<'tree>),
15300 InstanceDecl(InstanceDecl<'tree>),
15301 Pattern(Pattern<'tree>),
15302 Qualifier(Qualifier<'tree>),
15303 QuantifiedType(QuantifiedType<'tree>),
15304 Statement(Statement<'tree>),
15305 Type(Type<'tree>),
15306 TypeParam(TypeParam<'tree>),
15307 AbstractFamily(AbstractFamily<'tree>),
15308 Alternative(Alternative<'tree>),
15309 Alternatives(Alternatives<'tree>),
15310 Annotated(Annotated<'tree>),
15311 Apply(Apply<'tree>),
15312 ArithmeticSequence(ArithmeticSequence<'tree>),
15313 As(As<'tree>),
15314 AssociatedType(AssociatedType<'tree>),
15315 Bind(Bind<'tree>),
15316 BindingList(BindingList<'tree>),
15317 Boolean(Boolean<'tree>),
15318 Case(Case<'tree>),
15319 Children(Children<'tree>),
15320 Class(Class<'tree>),
15321 ClassDeclarations(ClassDeclarations<'tree>),
15322 Conditional(Conditional<'tree>),
15323 ConstructorOperator(ConstructorOperator<'tree>),
15324 ConstructorSynonym(ConstructorSynonym<'tree>),
15325 ConstructorSynonyms(ConstructorSynonyms<'tree>),
15326 Context(Context<'tree>),
15327 DataConstructor(DataConstructor<'tree>),
15328 DataConstructors(DataConstructors<'tree>),
15329 DataFamily(DataFamily<'tree>),
15330 DataInstance(DataInstance<'tree>),
15331 DataType(DataType<'tree>),
15332 Declarations(Declarations<'tree>),
15333 DefaultSignature(DefaultSignature<'tree>),
15334 DefaultTypes(DefaultTypes<'tree>),
15335 Deriving(Deriving<'tree>),
15336 DerivingInstance(DerivingInstance<'tree>),
15337 DerivingStrategy(DerivingStrategy<'tree>),
15338 Do(Do<'tree>),
15339 DoModule(DoModule<'tree>),
15340 EmptyList(EmptyList<'tree>),
15341 Entity(Entity<'tree>),
15342 Equation(Equation<'tree>),
15343 Equations(Equations<'tree>),
15344 Exp(Exp<'tree>),
15345 ExplicitType(ExplicitType<'tree>),
15346 Export(Export<'tree>),
15347 Exports(Exports<'tree>),
15348 Field(Field<'tree>),
15349 FieldName(FieldName<'tree>),
15350 FieldPath(FieldPath<'tree>),
15351 FieldPattern(FieldPattern<'tree>),
15352 FieldUpdate(FieldUpdate<'tree>),
15353 Fields(Fields<'tree>),
15354 Fixity(Fixity<'tree>),
15355 Forall(Forall<'tree>),
15356 ForallRequired(ForallRequired<'tree>),
15357 ForeignExport(ForeignExport<'tree>),
15358 ForeignImport(ForeignImport<'tree>),
15359 Function(Function<'tree>),
15360 FunctionHeadParens(FunctionHeadParens<'tree>),
15361 Fundep(Fundep<'tree>),
15362 Fundeps(Fundeps<'tree>),
15363 GadtConstructor(GadtConstructor<'tree>),
15364 GadtConstructors(GadtConstructors<'tree>),
15365 Generator(Generator<'tree>),
15366 Group(Group<'tree>),
15367 Guards(Guards<'tree>),
15368 Haskell(Haskell<'tree>),
15369 Header(Header<'tree>),
15370 ImplicitParameter(ImplicitParameter<'tree>),
15371 Import(Import<'tree>),
15372 ImportList(ImportList<'tree>),
15373 ImportName(ImportName<'tree>),
15374 Imports(Imports<'tree>),
15375 Inferred(Inferred<'tree>),
15376 Infix(Infix<'tree>),
15377 InfixId(InfixId<'tree>),
15378 Instance(Instance<'tree>),
15379 InstanceDeclarations(InstanceDeclarations<'tree>),
15380 Integer(Integer<'tree>),
15381 Invisible(Invisible<'tree>),
15382 Irrefutable(Irrefutable<'tree>),
15383 KindApplication(KindApplication<'tree>),
15384 KindSignature(KindSignature<'tree>),
15385 Lambda(Lambda<'tree>),
15386 LambdaCase(LambdaCase<'tree>),
15387 LambdaCases(LambdaCases<'tree>),
15388 LazyField(LazyField<'tree>),
15389 LeftSection(LeftSection<'tree>),
15390 Let(Let<'tree>),
15391 LetIn(LetIn<'tree>),
15392 LinearFunction(LinearFunction<'tree>),
15393 List(List<'tree>),
15394 ListComprehension(ListComprehension<'tree>),
15395 Literal(Literal<'tree>),
15396 LocalBinds(LocalBinds<'tree>),
15397 Match(Match<'tree>),
15398 Modifier(Modifier<'tree>),
15399 Module(Module<'tree>),
15400 ModuleExport(ModuleExport<'tree>),
15401 MultiWayIf(MultiWayIf<'tree>),
15402 Namespace(Namespace<'tree>),
15403 Negation(Negation<'tree>),
15404 Newtype(Newtype<'tree>),
15405 NewtypeConstructor(NewtypeConstructor<'tree>),
15406 Operator(Operator<'tree>),
15407 Parens(Parens<'tree>),
15408 PatternGuard(PatternGuard<'tree>),
15409 PatternSynonym(PatternSynonym<'tree>),
15410 Patterns(Patterns<'tree>),
15411 Prefix(Prefix<'tree>),
15412 PrefixId(PrefixId<'tree>),
15413 PrefixList(PrefixList<'tree>),
15414 PrefixTuple(PrefixTuple<'tree>),
15415 PrefixUnboxedSum(PrefixUnboxedSum<'tree>),
15416 PrefixUnboxedTuple(PrefixUnboxedTuple<'tree>),
15417 Projection(Projection<'tree>),
15418 ProjectionSelector(ProjectionSelector<'tree>),
15419 Promoted(Promoted<'tree>),
15420 Qualified(Qualified<'tree>),
15421 Qualifiers(Qualifiers<'tree>),
15422 QuantifiedVariables(QuantifiedVariables<'tree>),
15423 Quasiquote(Quasiquote<'tree>),
15424 Quote(Quote<'tree>),
15425 QuotedDecls(QuotedDecls<'tree>),
15426 QuotedExpression(QuotedExpression<'tree>),
15427 QuotedPattern(QuotedPattern<'tree>),
15428 QuotedType(QuotedType<'tree>),
15429 Quoter(Quoter<'tree>),
15430 Rec(Rec<'tree>),
15431 Record(Record<'tree>),
15432 RightSection(RightSection<'tree>),
15433 RoleAnnotation(RoleAnnotation<'tree>),
15434 Signature(Signature<'tree>),
15435 Special(Special<'tree>),
15436 Splice(Splice<'tree>),
15437 Star(Star<'tree>),
15438 Strict(Strict<'tree>),
15439 StrictField(StrictField<'tree>),
15440 ThQuotedName(ThQuotedName<'tree>),
15441 TopSplice(TopSplice<'tree>),
15442 Transform(Transform<'tree>),
15443 Tuple(Tuple<'tree>),
15444 TypeApplication(TypeApplication<'tree>),
15445 TypeBinder(TypeBinder<'tree>),
15446 TypeFamily(TypeFamily<'tree>),
15447 TypeFamilyInjectivity(TypeFamilyInjectivity<'tree>),
15448 TypeFamilyResult(TypeFamilyResult<'tree>),
15449 TypeInstance(TypeInstance<'tree>),
15450 TypeParams(TypeParams<'tree>),
15451 TypePatterns(TypePatterns<'tree>),
15452 TypeRole(TypeRole<'tree>),
15453 TypeSynomym(TypeSynomym<'tree>),
15454 TypedQuote(TypedQuote<'tree>),
15455 UnboxedSum(UnboxedSum<'tree>),
15456 UnboxedTuple(UnboxedTuple<'tree>),
15457 UnboxedUnit(UnboxedUnit<'tree>),
15458 Unit(Unit<'tree>),
15459 Via(Via<'tree>),
15460 ViewPattern(ViewPattern<'tree>),
15461 Wildcard(Wildcard<'tree>),
15462 AllNames(AllNames<'tree>),
15463 CallingConvention(CallingConvention<'tree>),
15464 Char(Char<'tree>),
15465 Comment(Comment<'tree>),
15466 Constructor(Constructor<'tree>),
15467 Cpp(Cpp<'tree>),
15468 Float(Float<'tree>),
15469 Haddock(Haddock<'tree>),
15470 ImplicitVariable(ImplicitVariable<'tree>),
15471 ImportPackage(ImportPackage<'tree>),
15472 Label(Label<'tree>),
15473 ModuleId(ModuleId<'tree>),
15474 Name(Name<'tree>),
15475 Pragma(Pragma<'tree>),
15476 QuasiquoteBody(QuasiquoteBody<'tree>),
15477 Safety(Safety<'tree>),
15478 String(String<'tree>),
15479 Variable(Variable<'tree>),
15480 Unknown(::tree_sitter::Node<'tree>),
15481}
15482impl<'tree> AnyNode<'tree> {
15483 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
15484 match node.kind() {
15485 "class_decl" => <ClassDecl as ::treesitter_types::FromNode>::from_node(node, src)
15486 .map(Self::ClassDecl)
15487 .unwrap_or(Self::Unknown(node)),
15488 "constraint" => <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
15489 .map(Self::Constraint)
15490 .unwrap_or(Self::Unknown(node)),
15491 "constraints" => <Constraints as ::treesitter_types::FromNode>::from_node(node, src)
15492 .map(Self::Constraints)
15493 .unwrap_or(Self::Unknown(node)),
15494 "decl" => <Decl as ::treesitter_types::FromNode>::from_node(node, src)
15495 .map(Self::Decl)
15496 .unwrap_or(Self::Unknown(node)),
15497 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
15498 .map(Self::Declaration)
15499 .unwrap_or(Self::Unknown(node)),
15500 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
15501 .map(Self::Expression)
15502 .unwrap_or(Self::Unknown(node)),
15503 "guard" => <Guard as ::treesitter_types::FromNode>::from_node(node, src)
15504 .map(Self::Guard)
15505 .unwrap_or(Self::Unknown(node)),
15506 "instance_decl" => <InstanceDecl as ::treesitter_types::FromNode>::from_node(node, src)
15507 .map(Self::InstanceDecl)
15508 .unwrap_or(Self::Unknown(node)),
15509 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
15510 .map(Self::Pattern)
15511 .unwrap_or(Self::Unknown(node)),
15512 "qualifier" => <Qualifier as ::treesitter_types::FromNode>::from_node(node, src)
15513 .map(Self::Qualifier)
15514 .unwrap_or(Self::Unknown(node)),
15515 "quantified_type" => {
15516 <QuantifiedType as ::treesitter_types::FromNode>::from_node(node, src)
15517 .map(Self::QuantifiedType)
15518 .unwrap_or(Self::Unknown(node))
15519 }
15520 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
15521 .map(Self::Statement)
15522 .unwrap_or(Self::Unknown(node)),
15523 "type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
15524 .map(Self::Type)
15525 .unwrap_or(Self::Unknown(node)),
15526 "type_param" => <TypeParam as ::treesitter_types::FromNode>::from_node(node, src)
15527 .map(Self::TypeParam)
15528 .unwrap_or(Self::Unknown(node)),
15529 "abstract_family" => {
15530 <AbstractFamily as ::treesitter_types::FromNode>::from_node(node, src)
15531 .map(Self::AbstractFamily)
15532 .unwrap_or(Self::Unknown(node))
15533 }
15534 "alternative" => <Alternative as ::treesitter_types::FromNode>::from_node(node, src)
15535 .map(Self::Alternative)
15536 .unwrap_or(Self::Unknown(node)),
15537 "alternatives" => <Alternatives as ::treesitter_types::FromNode>::from_node(node, src)
15538 .map(Self::Alternatives)
15539 .unwrap_or(Self::Unknown(node)),
15540 "annotated" => <Annotated as ::treesitter_types::FromNode>::from_node(node, src)
15541 .map(Self::Annotated)
15542 .unwrap_or(Self::Unknown(node)),
15543 "apply" => <Apply as ::treesitter_types::FromNode>::from_node(node, src)
15544 .map(Self::Apply)
15545 .unwrap_or(Self::Unknown(node)),
15546 "arithmetic_sequence" => {
15547 <ArithmeticSequence as ::treesitter_types::FromNode>::from_node(node, src)
15548 .map(Self::ArithmeticSequence)
15549 .unwrap_or(Self::Unknown(node))
15550 }
15551 "as" => <As as ::treesitter_types::FromNode>::from_node(node, src)
15552 .map(Self::As)
15553 .unwrap_or(Self::Unknown(node)),
15554 "associated_type" => {
15555 <AssociatedType as ::treesitter_types::FromNode>::from_node(node, src)
15556 .map(Self::AssociatedType)
15557 .unwrap_or(Self::Unknown(node))
15558 }
15559 "bind" => <Bind as ::treesitter_types::FromNode>::from_node(node, src)
15560 .map(Self::Bind)
15561 .unwrap_or(Self::Unknown(node)),
15562 "binding_list" => <BindingList as ::treesitter_types::FromNode>::from_node(node, src)
15563 .map(Self::BindingList)
15564 .unwrap_or(Self::Unknown(node)),
15565 "boolean" => <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
15566 .map(Self::Boolean)
15567 .unwrap_or(Self::Unknown(node)),
15568 "case" => <Case as ::treesitter_types::FromNode>::from_node(node, src)
15569 .map(Self::Case)
15570 .unwrap_or(Self::Unknown(node)),
15571 "children" => <Children as ::treesitter_types::FromNode>::from_node(node, src)
15572 .map(Self::Children)
15573 .unwrap_or(Self::Unknown(node)),
15574 "class" => <Class as ::treesitter_types::FromNode>::from_node(node, src)
15575 .map(Self::Class)
15576 .unwrap_or(Self::Unknown(node)),
15577 "class_declarations" => {
15578 <ClassDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
15579 .map(Self::ClassDeclarations)
15580 .unwrap_or(Self::Unknown(node))
15581 }
15582 "conditional" => <Conditional as ::treesitter_types::FromNode>::from_node(node, src)
15583 .map(Self::Conditional)
15584 .unwrap_or(Self::Unknown(node)),
15585 "constructor_operator" => {
15586 <ConstructorOperator as ::treesitter_types::FromNode>::from_node(node, src)
15587 .map(Self::ConstructorOperator)
15588 .unwrap_or(Self::Unknown(node))
15589 }
15590 "constructor_synonym" => {
15591 <ConstructorSynonym as ::treesitter_types::FromNode>::from_node(node, src)
15592 .map(Self::ConstructorSynonym)
15593 .unwrap_or(Self::Unknown(node))
15594 }
15595 "constructor_synonyms" => {
15596 <ConstructorSynonyms as ::treesitter_types::FromNode>::from_node(node, src)
15597 .map(Self::ConstructorSynonyms)
15598 .unwrap_or(Self::Unknown(node))
15599 }
15600 "context" => <Context as ::treesitter_types::FromNode>::from_node(node, src)
15601 .map(Self::Context)
15602 .unwrap_or(Self::Unknown(node)),
15603 "data_constructor" => {
15604 <DataConstructor as ::treesitter_types::FromNode>::from_node(node, src)
15605 .map(Self::DataConstructor)
15606 .unwrap_or(Self::Unknown(node))
15607 }
15608 "data_constructors" => {
15609 <DataConstructors as ::treesitter_types::FromNode>::from_node(node, src)
15610 .map(Self::DataConstructors)
15611 .unwrap_or(Self::Unknown(node))
15612 }
15613 "data_family" => <DataFamily as ::treesitter_types::FromNode>::from_node(node, src)
15614 .map(Self::DataFamily)
15615 .unwrap_or(Self::Unknown(node)),
15616 "data_instance" => <DataInstance as ::treesitter_types::FromNode>::from_node(node, src)
15617 .map(Self::DataInstance)
15618 .unwrap_or(Self::Unknown(node)),
15619 "data_type" => <DataType as ::treesitter_types::FromNode>::from_node(node, src)
15620 .map(Self::DataType)
15621 .unwrap_or(Self::Unknown(node)),
15622 "declarations" => <Declarations as ::treesitter_types::FromNode>::from_node(node, src)
15623 .map(Self::Declarations)
15624 .unwrap_or(Self::Unknown(node)),
15625 "default_signature" => {
15626 <DefaultSignature as ::treesitter_types::FromNode>::from_node(node, src)
15627 .map(Self::DefaultSignature)
15628 .unwrap_or(Self::Unknown(node))
15629 }
15630 "default_types" => <DefaultTypes as ::treesitter_types::FromNode>::from_node(node, src)
15631 .map(Self::DefaultTypes)
15632 .unwrap_or(Self::Unknown(node)),
15633 "deriving" => <Deriving as ::treesitter_types::FromNode>::from_node(node, src)
15634 .map(Self::Deriving)
15635 .unwrap_or(Self::Unknown(node)),
15636 "deriving_instance" => {
15637 <DerivingInstance as ::treesitter_types::FromNode>::from_node(node, src)
15638 .map(Self::DerivingInstance)
15639 .unwrap_or(Self::Unknown(node))
15640 }
15641 "deriving_strategy" => {
15642 <DerivingStrategy as ::treesitter_types::FromNode>::from_node(node, src)
15643 .map(Self::DerivingStrategy)
15644 .unwrap_or(Self::Unknown(node))
15645 }
15646 "do" => <Do as ::treesitter_types::FromNode>::from_node(node, src)
15647 .map(Self::Do)
15648 .unwrap_or(Self::Unknown(node)),
15649 "do_module" => <DoModule as ::treesitter_types::FromNode>::from_node(node, src)
15650 .map(Self::DoModule)
15651 .unwrap_or(Self::Unknown(node)),
15652 "empty_list" => <EmptyList as ::treesitter_types::FromNode>::from_node(node, src)
15653 .map(Self::EmptyList)
15654 .unwrap_or(Self::Unknown(node)),
15655 "entity" => <Entity as ::treesitter_types::FromNode>::from_node(node, src)
15656 .map(Self::Entity)
15657 .unwrap_or(Self::Unknown(node)),
15658 "equation" => <Equation as ::treesitter_types::FromNode>::from_node(node, src)
15659 .map(Self::Equation)
15660 .unwrap_or(Self::Unknown(node)),
15661 "equations" => <Equations as ::treesitter_types::FromNode>::from_node(node, src)
15662 .map(Self::Equations)
15663 .unwrap_or(Self::Unknown(node)),
15664 "exp" => <Exp as ::treesitter_types::FromNode>::from_node(node, src)
15665 .map(Self::Exp)
15666 .unwrap_or(Self::Unknown(node)),
15667 "explicit_type" => <ExplicitType as ::treesitter_types::FromNode>::from_node(node, src)
15668 .map(Self::ExplicitType)
15669 .unwrap_or(Self::Unknown(node)),
15670 "export" => <Export as ::treesitter_types::FromNode>::from_node(node, src)
15671 .map(Self::Export)
15672 .unwrap_or(Self::Unknown(node)),
15673 "exports" => <Exports as ::treesitter_types::FromNode>::from_node(node, src)
15674 .map(Self::Exports)
15675 .unwrap_or(Self::Unknown(node)),
15676 "field" => <Field as ::treesitter_types::FromNode>::from_node(node, src)
15677 .map(Self::Field)
15678 .unwrap_or(Self::Unknown(node)),
15679 "field_name" => <FieldName as ::treesitter_types::FromNode>::from_node(node, src)
15680 .map(Self::FieldName)
15681 .unwrap_or(Self::Unknown(node)),
15682 "field_path" => <FieldPath as ::treesitter_types::FromNode>::from_node(node, src)
15683 .map(Self::FieldPath)
15684 .unwrap_or(Self::Unknown(node)),
15685 "field_pattern" => <FieldPattern as ::treesitter_types::FromNode>::from_node(node, src)
15686 .map(Self::FieldPattern)
15687 .unwrap_or(Self::Unknown(node)),
15688 "field_update" => <FieldUpdate as ::treesitter_types::FromNode>::from_node(node, src)
15689 .map(Self::FieldUpdate)
15690 .unwrap_or(Self::Unknown(node)),
15691 "fields" => <Fields as ::treesitter_types::FromNode>::from_node(node, src)
15692 .map(Self::Fields)
15693 .unwrap_or(Self::Unknown(node)),
15694 "fixity" => <Fixity as ::treesitter_types::FromNode>::from_node(node, src)
15695 .map(Self::Fixity)
15696 .unwrap_or(Self::Unknown(node)),
15697 "forall" => <Forall as ::treesitter_types::FromNode>::from_node(node, src)
15698 .map(Self::Forall)
15699 .unwrap_or(Self::Unknown(node)),
15700 "forall_required" => {
15701 <ForallRequired as ::treesitter_types::FromNode>::from_node(node, src)
15702 .map(Self::ForallRequired)
15703 .unwrap_or(Self::Unknown(node))
15704 }
15705 "foreign_export" => {
15706 <ForeignExport as ::treesitter_types::FromNode>::from_node(node, src)
15707 .map(Self::ForeignExport)
15708 .unwrap_or(Self::Unknown(node))
15709 }
15710 "foreign_import" => {
15711 <ForeignImport as ::treesitter_types::FromNode>::from_node(node, src)
15712 .map(Self::ForeignImport)
15713 .unwrap_or(Self::Unknown(node))
15714 }
15715 "function" => <Function as ::treesitter_types::FromNode>::from_node(node, src)
15716 .map(Self::Function)
15717 .unwrap_or(Self::Unknown(node)),
15718 "function_head_parens" => {
15719 <FunctionHeadParens as ::treesitter_types::FromNode>::from_node(node, src)
15720 .map(Self::FunctionHeadParens)
15721 .unwrap_or(Self::Unknown(node))
15722 }
15723 "fundep" => <Fundep as ::treesitter_types::FromNode>::from_node(node, src)
15724 .map(Self::Fundep)
15725 .unwrap_or(Self::Unknown(node)),
15726 "fundeps" => <Fundeps as ::treesitter_types::FromNode>::from_node(node, src)
15727 .map(Self::Fundeps)
15728 .unwrap_or(Self::Unknown(node)),
15729 "gadt_constructor" => {
15730 <GadtConstructor as ::treesitter_types::FromNode>::from_node(node, src)
15731 .map(Self::GadtConstructor)
15732 .unwrap_or(Self::Unknown(node))
15733 }
15734 "gadt_constructors" => {
15735 <GadtConstructors as ::treesitter_types::FromNode>::from_node(node, src)
15736 .map(Self::GadtConstructors)
15737 .unwrap_or(Self::Unknown(node))
15738 }
15739 "generator" => <Generator as ::treesitter_types::FromNode>::from_node(node, src)
15740 .map(Self::Generator)
15741 .unwrap_or(Self::Unknown(node)),
15742 "group" => <Group as ::treesitter_types::FromNode>::from_node(node, src)
15743 .map(Self::Group)
15744 .unwrap_or(Self::Unknown(node)),
15745 "guards" => <Guards as ::treesitter_types::FromNode>::from_node(node, src)
15746 .map(Self::Guards)
15747 .unwrap_or(Self::Unknown(node)),
15748 "haskell" => <Haskell as ::treesitter_types::FromNode>::from_node(node, src)
15749 .map(Self::Haskell)
15750 .unwrap_or(Self::Unknown(node)),
15751 "header" => <Header as ::treesitter_types::FromNode>::from_node(node, src)
15752 .map(Self::Header)
15753 .unwrap_or(Self::Unknown(node)),
15754 "implicit_parameter" => {
15755 <ImplicitParameter as ::treesitter_types::FromNode>::from_node(node, src)
15756 .map(Self::ImplicitParameter)
15757 .unwrap_or(Self::Unknown(node))
15758 }
15759 "import" => <Import as ::treesitter_types::FromNode>::from_node(node, src)
15760 .map(Self::Import)
15761 .unwrap_or(Self::Unknown(node)),
15762 "import_list" => <ImportList as ::treesitter_types::FromNode>::from_node(node, src)
15763 .map(Self::ImportList)
15764 .unwrap_or(Self::Unknown(node)),
15765 "import_name" => <ImportName as ::treesitter_types::FromNode>::from_node(node, src)
15766 .map(Self::ImportName)
15767 .unwrap_or(Self::Unknown(node)),
15768 "imports" => <Imports as ::treesitter_types::FromNode>::from_node(node, src)
15769 .map(Self::Imports)
15770 .unwrap_or(Self::Unknown(node)),
15771 "inferred" => <Inferred as ::treesitter_types::FromNode>::from_node(node, src)
15772 .map(Self::Inferred)
15773 .unwrap_or(Self::Unknown(node)),
15774 "infix" => <Infix as ::treesitter_types::FromNode>::from_node(node, src)
15775 .map(Self::Infix)
15776 .unwrap_or(Self::Unknown(node)),
15777 "infix_id" => <InfixId as ::treesitter_types::FromNode>::from_node(node, src)
15778 .map(Self::InfixId)
15779 .unwrap_or(Self::Unknown(node)),
15780 "instance" => <Instance as ::treesitter_types::FromNode>::from_node(node, src)
15781 .map(Self::Instance)
15782 .unwrap_or(Self::Unknown(node)),
15783 "instance_declarations" => {
15784 <InstanceDeclarations as ::treesitter_types::FromNode>::from_node(node, src)
15785 .map(Self::InstanceDeclarations)
15786 .unwrap_or(Self::Unknown(node))
15787 }
15788 "integer" => <Integer as ::treesitter_types::FromNode>::from_node(node, src)
15789 .map(Self::Integer)
15790 .unwrap_or(Self::Unknown(node)),
15791 "invisible" => <Invisible as ::treesitter_types::FromNode>::from_node(node, src)
15792 .map(Self::Invisible)
15793 .unwrap_or(Self::Unknown(node)),
15794 "irrefutable" => <Irrefutable as ::treesitter_types::FromNode>::from_node(node, src)
15795 .map(Self::Irrefutable)
15796 .unwrap_or(Self::Unknown(node)),
15797 "kind_application" => {
15798 <KindApplication as ::treesitter_types::FromNode>::from_node(node, src)
15799 .map(Self::KindApplication)
15800 .unwrap_or(Self::Unknown(node))
15801 }
15802 "kind_signature" => {
15803 <KindSignature as ::treesitter_types::FromNode>::from_node(node, src)
15804 .map(Self::KindSignature)
15805 .unwrap_or(Self::Unknown(node))
15806 }
15807 "lambda" => <Lambda as ::treesitter_types::FromNode>::from_node(node, src)
15808 .map(Self::Lambda)
15809 .unwrap_or(Self::Unknown(node)),
15810 "lambda_case" => <LambdaCase as ::treesitter_types::FromNode>::from_node(node, src)
15811 .map(Self::LambdaCase)
15812 .unwrap_or(Self::Unknown(node)),
15813 "lambda_cases" => <LambdaCases as ::treesitter_types::FromNode>::from_node(node, src)
15814 .map(Self::LambdaCases)
15815 .unwrap_or(Self::Unknown(node)),
15816 "lazy_field" => <LazyField as ::treesitter_types::FromNode>::from_node(node, src)
15817 .map(Self::LazyField)
15818 .unwrap_or(Self::Unknown(node)),
15819 "left_section" => <LeftSection as ::treesitter_types::FromNode>::from_node(node, src)
15820 .map(Self::LeftSection)
15821 .unwrap_or(Self::Unknown(node)),
15822 "let" => <Let as ::treesitter_types::FromNode>::from_node(node, src)
15823 .map(Self::Let)
15824 .unwrap_or(Self::Unknown(node)),
15825 "let_in" => <LetIn as ::treesitter_types::FromNode>::from_node(node, src)
15826 .map(Self::LetIn)
15827 .unwrap_or(Self::Unknown(node)),
15828 "linear_function" => {
15829 <LinearFunction as ::treesitter_types::FromNode>::from_node(node, src)
15830 .map(Self::LinearFunction)
15831 .unwrap_or(Self::Unknown(node))
15832 }
15833 "list" => <List as ::treesitter_types::FromNode>::from_node(node, src)
15834 .map(Self::List)
15835 .unwrap_or(Self::Unknown(node)),
15836 "list_comprehension" => {
15837 <ListComprehension as ::treesitter_types::FromNode>::from_node(node, src)
15838 .map(Self::ListComprehension)
15839 .unwrap_or(Self::Unknown(node))
15840 }
15841 "literal" => <Literal as ::treesitter_types::FromNode>::from_node(node, src)
15842 .map(Self::Literal)
15843 .unwrap_or(Self::Unknown(node)),
15844 "local_binds" => <LocalBinds as ::treesitter_types::FromNode>::from_node(node, src)
15845 .map(Self::LocalBinds)
15846 .unwrap_or(Self::Unknown(node)),
15847 "match" => <Match as ::treesitter_types::FromNode>::from_node(node, src)
15848 .map(Self::Match)
15849 .unwrap_or(Self::Unknown(node)),
15850 "modifier" => <Modifier as ::treesitter_types::FromNode>::from_node(node, src)
15851 .map(Self::Modifier)
15852 .unwrap_or(Self::Unknown(node)),
15853 "module" => <Module as ::treesitter_types::FromNode>::from_node(node, src)
15854 .map(Self::Module)
15855 .unwrap_or(Self::Unknown(node)),
15856 "module_export" => <ModuleExport as ::treesitter_types::FromNode>::from_node(node, src)
15857 .map(Self::ModuleExport)
15858 .unwrap_or(Self::Unknown(node)),
15859 "multi_way_if" => <MultiWayIf as ::treesitter_types::FromNode>::from_node(node, src)
15860 .map(Self::MultiWayIf)
15861 .unwrap_or(Self::Unknown(node)),
15862 "namespace" => <Namespace as ::treesitter_types::FromNode>::from_node(node, src)
15863 .map(Self::Namespace)
15864 .unwrap_or(Self::Unknown(node)),
15865 "negation" => <Negation as ::treesitter_types::FromNode>::from_node(node, src)
15866 .map(Self::Negation)
15867 .unwrap_or(Self::Unknown(node)),
15868 "newtype" => <Newtype as ::treesitter_types::FromNode>::from_node(node, src)
15869 .map(Self::Newtype)
15870 .unwrap_or(Self::Unknown(node)),
15871 "newtype_constructor" => {
15872 <NewtypeConstructor as ::treesitter_types::FromNode>::from_node(node, src)
15873 .map(Self::NewtypeConstructor)
15874 .unwrap_or(Self::Unknown(node))
15875 }
15876 "operator" => <Operator as ::treesitter_types::FromNode>::from_node(node, src)
15877 .map(Self::Operator)
15878 .unwrap_or(Self::Unknown(node)),
15879 "parens" => <Parens as ::treesitter_types::FromNode>::from_node(node, src)
15880 .map(Self::Parens)
15881 .unwrap_or(Self::Unknown(node)),
15882 "pattern_guard" => <PatternGuard as ::treesitter_types::FromNode>::from_node(node, src)
15883 .map(Self::PatternGuard)
15884 .unwrap_or(Self::Unknown(node)),
15885 "pattern_synonym" => {
15886 <PatternSynonym as ::treesitter_types::FromNode>::from_node(node, src)
15887 .map(Self::PatternSynonym)
15888 .unwrap_or(Self::Unknown(node))
15889 }
15890 "patterns" => <Patterns as ::treesitter_types::FromNode>::from_node(node, src)
15891 .map(Self::Patterns)
15892 .unwrap_or(Self::Unknown(node)),
15893 "prefix" => <Prefix as ::treesitter_types::FromNode>::from_node(node, src)
15894 .map(Self::Prefix)
15895 .unwrap_or(Self::Unknown(node)),
15896 "prefix_id" => <PrefixId as ::treesitter_types::FromNode>::from_node(node, src)
15897 .map(Self::PrefixId)
15898 .unwrap_or(Self::Unknown(node)),
15899 "prefix_list" => <PrefixList as ::treesitter_types::FromNode>::from_node(node, src)
15900 .map(Self::PrefixList)
15901 .unwrap_or(Self::Unknown(node)),
15902 "prefix_tuple" => <PrefixTuple as ::treesitter_types::FromNode>::from_node(node, src)
15903 .map(Self::PrefixTuple)
15904 .unwrap_or(Self::Unknown(node)),
15905 "prefix_unboxed_sum" => {
15906 <PrefixUnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
15907 .map(Self::PrefixUnboxedSum)
15908 .unwrap_or(Self::Unknown(node))
15909 }
15910 "prefix_unboxed_tuple" => {
15911 <PrefixUnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
15912 .map(Self::PrefixUnboxedTuple)
15913 .unwrap_or(Self::Unknown(node))
15914 }
15915 "projection" => <Projection as ::treesitter_types::FromNode>::from_node(node, src)
15916 .map(Self::Projection)
15917 .unwrap_or(Self::Unknown(node)),
15918 "projection_selector" => {
15919 <ProjectionSelector as ::treesitter_types::FromNode>::from_node(node, src)
15920 .map(Self::ProjectionSelector)
15921 .unwrap_or(Self::Unknown(node))
15922 }
15923 "promoted" => <Promoted as ::treesitter_types::FromNode>::from_node(node, src)
15924 .map(Self::Promoted)
15925 .unwrap_or(Self::Unknown(node)),
15926 "qualified" => <Qualified as ::treesitter_types::FromNode>::from_node(node, src)
15927 .map(Self::Qualified)
15928 .unwrap_or(Self::Unknown(node)),
15929 "qualifiers" => <Qualifiers as ::treesitter_types::FromNode>::from_node(node, src)
15930 .map(Self::Qualifiers)
15931 .unwrap_or(Self::Unknown(node)),
15932 "quantified_variables" => {
15933 <QuantifiedVariables as ::treesitter_types::FromNode>::from_node(node, src)
15934 .map(Self::QuantifiedVariables)
15935 .unwrap_or(Self::Unknown(node))
15936 }
15937 "quasiquote" => <Quasiquote as ::treesitter_types::FromNode>::from_node(node, src)
15938 .map(Self::Quasiquote)
15939 .unwrap_or(Self::Unknown(node)),
15940 "quote" => <Quote as ::treesitter_types::FromNode>::from_node(node, src)
15941 .map(Self::Quote)
15942 .unwrap_or(Self::Unknown(node)),
15943 "quoted_decls" => <QuotedDecls as ::treesitter_types::FromNode>::from_node(node, src)
15944 .map(Self::QuotedDecls)
15945 .unwrap_or(Self::Unknown(node)),
15946 "quoted_expression" => {
15947 <QuotedExpression as ::treesitter_types::FromNode>::from_node(node, src)
15948 .map(Self::QuotedExpression)
15949 .unwrap_or(Self::Unknown(node))
15950 }
15951 "quoted_pattern" => {
15952 <QuotedPattern as ::treesitter_types::FromNode>::from_node(node, src)
15953 .map(Self::QuotedPattern)
15954 .unwrap_or(Self::Unknown(node))
15955 }
15956 "quoted_type" => <QuotedType as ::treesitter_types::FromNode>::from_node(node, src)
15957 .map(Self::QuotedType)
15958 .unwrap_or(Self::Unknown(node)),
15959 "quoter" => <Quoter as ::treesitter_types::FromNode>::from_node(node, src)
15960 .map(Self::Quoter)
15961 .unwrap_or(Self::Unknown(node)),
15962 "rec" => <Rec as ::treesitter_types::FromNode>::from_node(node, src)
15963 .map(Self::Rec)
15964 .unwrap_or(Self::Unknown(node)),
15965 "record" => <Record as ::treesitter_types::FromNode>::from_node(node, src)
15966 .map(Self::Record)
15967 .unwrap_or(Self::Unknown(node)),
15968 "right_section" => <RightSection as ::treesitter_types::FromNode>::from_node(node, src)
15969 .map(Self::RightSection)
15970 .unwrap_or(Self::Unknown(node)),
15971 "role_annotation" => {
15972 <RoleAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
15973 .map(Self::RoleAnnotation)
15974 .unwrap_or(Self::Unknown(node))
15975 }
15976 "signature" => <Signature as ::treesitter_types::FromNode>::from_node(node, src)
15977 .map(Self::Signature)
15978 .unwrap_or(Self::Unknown(node)),
15979 "special" => <Special as ::treesitter_types::FromNode>::from_node(node, src)
15980 .map(Self::Special)
15981 .unwrap_or(Self::Unknown(node)),
15982 "splice" => <Splice as ::treesitter_types::FromNode>::from_node(node, src)
15983 .map(Self::Splice)
15984 .unwrap_or(Self::Unknown(node)),
15985 "star" => <Star as ::treesitter_types::FromNode>::from_node(node, src)
15986 .map(Self::Star)
15987 .unwrap_or(Self::Unknown(node)),
15988 "strict" => <Strict as ::treesitter_types::FromNode>::from_node(node, src)
15989 .map(Self::Strict)
15990 .unwrap_or(Self::Unknown(node)),
15991 "strict_field" => <StrictField as ::treesitter_types::FromNode>::from_node(node, src)
15992 .map(Self::StrictField)
15993 .unwrap_or(Self::Unknown(node)),
15994 "th_quoted_name" => {
15995 <ThQuotedName as ::treesitter_types::FromNode>::from_node(node, src)
15996 .map(Self::ThQuotedName)
15997 .unwrap_or(Self::Unknown(node))
15998 }
15999 "top_splice" => <TopSplice as ::treesitter_types::FromNode>::from_node(node, src)
16000 .map(Self::TopSplice)
16001 .unwrap_or(Self::Unknown(node)),
16002 "transform" => <Transform as ::treesitter_types::FromNode>::from_node(node, src)
16003 .map(Self::Transform)
16004 .unwrap_or(Self::Unknown(node)),
16005 "tuple" => <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
16006 .map(Self::Tuple)
16007 .unwrap_or(Self::Unknown(node)),
16008 "type_application" => {
16009 <TypeApplication as ::treesitter_types::FromNode>::from_node(node, src)
16010 .map(Self::TypeApplication)
16011 .unwrap_or(Self::Unknown(node))
16012 }
16013 "type_binder" => <TypeBinder as ::treesitter_types::FromNode>::from_node(node, src)
16014 .map(Self::TypeBinder)
16015 .unwrap_or(Self::Unknown(node)),
16016 "type_family" => <TypeFamily as ::treesitter_types::FromNode>::from_node(node, src)
16017 .map(Self::TypeFamily)
16018 .unwrap_or(Self::Unknown(node)),
16019 "type_family_injectivity" => {
16020 <TypeFamilyInjectivity as ::treesitter_types::FromNode>::from_node(node, src)
16021 .map(Self::TypeFamilyInjectivity)
16022 .unwrap_or(Self::Unknown(node))
16023 }
16024 "type_family_result" => {
16025 <TypeFamilyResult as ::treesitter_types::FromNode>::from_node(node, src)
16026 .map(Self::TypeFamilyResult)
16027 .unwrap_or(Self::Unknown(node))
16028 }
16029 "type_instance" => <TypeInstance as ::treesitter_types::FromNode>::from_node(node, src)
16030 .map(Self::TypeInstance)
16031 .unwrap_or(Self::Unknown(node)),
16032 "type_params" => <TypeParams as ::treesitter_types::FromNode>::from_node(node, src)
16033 .map(Self::TypeParams)
16034 .unwrap_or(Self::Unknown(node)),
16035 "type_patterns" => <TypePatterns as ::treesitter_types::FromNode>::from_node(node, src)
16036 .map(Self::TypePatterns)
16037 .unwrap_or(Self::Unknown(node)),
16038 "type_role" => <TypeRole as ::treesitter_types::FromNode>::from_node(node, src)
16039 .map(Self::TypeRole)
16040 .unwrap_or(Self::Unknown(node)),
16041 "type_synomym" => <TypeSynomym as ::treesitter_types::FromNode>::from_node(node, src)
16042 .map(Self::TypeSynomym)
16043 .unwrap_or(Self::Unknown(node)),
16044 "typed_quote" => <TypedQuote as ::treesitter_types::FromNode>::from_node(node, src)
16045 .map(Self::TypedQuote)
16046 .unwrap_or(Self::Unknown(node)),
16047 "unboxed_sum" => <UnboxedSum as ::treesitter_types::FromNode>::from_node(node, src)
16048 .map(Self::UnboxedSum)
16049 .unwrap_or(Self::Unknown(node)),
16050 "unboxed_tuple" => <UnboxedTuple as ::treesitter_types::FromNode>::from_node(node, src)
16051 .map(Self::UnboxedTuple)
16052 .unwrap_or(Self::Unknown(node)),
16053 "unboxed_unit" => <UnboxedUnit as ::treesitter_types::FromNode>::from_node(node, src)
16054 .map(Self::UnboxedUnit)
16055 .unwrap_or(Self::Unknown(node)),
16056 "unit" => <Unit as ::treesitter_types::FromNode>::from_node(node, src)
16057 .map(Self::Unit)
16058 .unwrap_or(Self::Unknown(node)),
16059 "via" => <Via as ::treesitter_types::FromNode>::from_node(node, src)
16060 .map(Self::Via)
16061 .unwrap_or(Self::Unknown(node)),
16062 "view_pattern" => <ViewPattern as ::treesitter_types::FromNode>::from_node(node, src)
16063 .map(Self::ViewPattern)
16064 .unwrap_or(Self::Unknown(node)),
16065 "wildcard" => <Wildcard as ::treesitter_types::FromNode>::from_node(node, src)
16066 .map(Self::Wildcard)
16067 .unwrap_or(Self::Unknown(node)),
16068 "all_names" => <AllNames as ::treesitter_types::FromNode>::from_node(node, src)
16069 .map(Self::AllNames)
16070 .unwrap_or(Self::Unknown(node)),
16071 "calling_convention" => {
16072 <CallingConvention as ::treesitter_types::FromNode>::from_node(node, src)
16073 .map(Self::CallingConvention)
16074 .unwrap_or(Self::Unknown(node))
16075 }
16076 "char" => <Char as ::treesitter_types::FromNode>::from_node(node, src)
16077 .map(Self::Char)
16078 .unwrap_or(Self::Unknown(node)),
16079 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
16080 .map(Self::Comment)
16081 .unwrap_or(Self::Unknown(node)),
16082 "constructor" => <Constructor as ::treesitter_types::FromNode>::from_node(node, src)
16083 .map(Self::Constructor)
16084 .unwrap_or(Self::Unknown(node)),
16085 "cpp" => <Cpp as ::treesitter_types::FromNode>::from_node(node, src)
16086 .map(Self::Cpp)
16087 .unwrap_or(Self::Unknown(node)),
16088 "float" => <Float as ::treesitter_types::FromNode>::from_node(node, src)
16089 .map(Self::Float)
16090 .unwrap_or(Self::Unknown(node)),
16091 "haddock" => <Haddock as ::treesitter_types::FromNode>::from_node(node, src)
16092 .map(Self::Haddock)
16093 .unwrap_or(Self::Unknown(node)),
16094 "implicit_variable" => {
16095 <ImplicitVariable as ::treesitter_types::FromNode>::from_node(node, src)
16096 .map(Self::ImplicitVariable)
16097 .unwrap_or(Self::Unknown(node))
16098 }
16099 "import_package" => {
16100 <ImportPackage as ::treesitter_types::FromNode>::from_node(node, src)
16101 .map(Self::ImportPackage)
16102 .unwrap_or(Self::Unknown(node))
16103 }
16104 "label" => <Label as ::treesitter_types::FromNode>::from_node(node, src)
16105 .map(Self::Label)
16106 .unwrap_or(Self::Unknown(node)),
16107 "module_id" => <ModuleId as ::treesitter_types::FromNode>::from_node(node, src)
16108 .map(Self::ModuleId)
16109 .unwrap_or(Self::Unknown(node)),
16110 "name" => <Name as ::treesitter_types::FromNode>::from_node(node, src)
16111 .map(Self::Name)
16112 .unwrap_or(Self::Unknown(node)),
16113 "pragma" => <Pragma as ::treesitter_types::FromNode>::from_node(node, src)
16114 .map(Self::Pragma)
16115 .unwrap_or(Self::Unknown(node)),
16116 "quasiquote_body" => {
16117 <QuasiquoteBody as ::treesitter_types::FromNode>::from_node(node, src)
16118 .map(Self::QuasiquoteBody)
16119 .unwrap_or(Self::Unknown(node))
16120 }
16121 "safety" => <Safety as ::treesitter_types::FromNode>::from_node(node, src)
16122 .map(Self::Safety)
16123 .unwrap_or(Self::Unknown(node)),
16124 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
16125 .map(Self::String)
16126 .unwrap_or(Self::Unknown(node)),
16127 "variable" => <Variable as ::treesitter_types::FromNode>::from_node(node, src)
16128 .map(Self::Variable)
16129 .unwrap_or(Self::Unknown(node)),
16130 _ => Self::Unknown(node),
16131 }
16132 }
16133}
16134impl ::treesitter_types::Spanned for AnyNode<'_> {
16135 fn span(&self) -> ::treesitter_types::Span {
16136 match self {
16137 Self::ClassDecl(inner) => inner.span(),
16138 Self::Constraint(inner) => inner.span(),
16139 Self::Constraints(inner) => inner.span(),
16140 Self::Decl(inner) => inner.span(),
16141 Self::Declaration(inner) => inner.span(),
16142 Self::Expression(inner) => inner.span(),
16143 Self::Guard(inner) => inner.span(),
16144 Self::InstanceDecl(inner) => inner.span(),
16145 Self::Pattern(inner) => inner.span(),
16146 Self::Qualifier(inner) => inner.span(),
16147 Self::QuantifiedType(inner) => inner.span(),
16148 Self::Statement(inner) => inner.span(),
16149 Self::Type(inner) => inner.span(),
16150 Self::TypeParam(inner) => inner.span(),
16151 Self::AbstractFamily(inner) => inner.span(),
16152 Self::Alternative(inner) => inner.span(),
16153 Self::Alternatives(inner) => inner.span(),
16154 Self::Annotated(inner) => inner.span(),
16155 Self::Apply(inner) => inner.span(),
16156 Self::ArithmeticSequence(inner) => inner.span(),
16157 Self::As(inner) => inner.span(),
16158 Self::AssociatedType(inner) => inner.span(),
16159 Self::Bind(inner) => inner.span(),
16160 Self::BindingList(inner) => inner.span(),
16161 Self::Boolean(inner) => inner.span(),
16162 Self::Case(inner) => inner.span(),
16163 Self::Children(inner) => inner.span(),
16164 Self::Class(inner) => inner.span(),
16165 Self::ClassDeclarations(inner) => inner.span(),
16166 Self::Conditional(inner) => inner.span(),
16167 Self::ConstructorOperator(inner) => inner.span(),
16168 Self::ConstructorSynonym(inner) => inner.span(),
16169 Self::ConstructorSynonyms(inner) => inner.span(),
16170 Self::Context(inner) => inner.span(),
16171 Self::DataConstructor(inner) => inner.span(),
16172 Self::DataConstructors(inner) => inner.span(),
16173 Self::DataFamily(inner) => inner.span(),
16174 Self::DataInstance(inner) => inner.span(),
16175 Self::DataType(inner) => inner.span(),
16176 Self::Declarations(inner) => inner.span(),
16177 Self::DefaultSignature(inner) => inner.span(),
16178 Self::DefaultTypes(inner) => inner.span(),
16179 Self::Deriving(inner) => inner.span(),
16180 Self::DerivingInstance(inner) => inner.span(),
16181 Self::DerivingStrategy(inner) => inner.span(),
16182 Self::Do(inner) => inner.span(),
16183 Self::DoModule(inner) => inner.span(),
16184 Self::EmptyList(inner) => inner.span(),
16185 Self::Entity(inner) => inner.span(),
16186 Self::Equation(inner) => inner.span(),
16187 Self::Equations(inner) => inner.span(),
16188 Self::Exp(inner) => inner.span(),
16189 Self::ExplicitType(inner) => inner.span(),
16190 Self::Export(inner) => inner.span(),
16191 Self::Exports(inner) => inner.span(),
16192 Self::Field(inner) => inner.span(),
16193 Self::FieldName(inner) => inner.span(),
16194 Self::FieldPath(inner) => inner.span(),
16195 Self::FieldPattern(inner) => inner.span(),
16196 Self::FieldUpdate(inner) => inner.span(),
16197 Self::Fields(inner) => inner.span(),
16198 Self::Fixity(inner) => inner.span(),
16199 Self::Forall(inner) => inner.span(),
16200 Self::ForallRequired(inner) => inner.span(),
16201 Self::ForeignExport(inner) => inner.span(),
16202 Self::ForeignImport(inner) => inner.span(),
16203 Self::Function(inner) => inner.span(),
16204 Self::FunctionHeadParens(inner) => inner.span(),
16205 Self::Fundep(inner) => inner.span(),
16206 Self::Fundeps(inner) => inner.span(),
16207 Self::GadtConstructor(inner) => inner.span(),
16208 Self::GadtConstructors(inner) => inner.span(),
16209 Self::Generator(inner) => inner.span(),
16210 Self::Group(inner) => inner.span(),
16211 Self::Guards(inner) => inner.span(),
16212 Self::Haskell(inner) => inner.span(),
16213 Self::Header(inner) => inner.span(),
16214 Self::ImplicitParameter(inner) => inner.span(),
16215 Self::Import(inner) => inner.span(),
16216 Self::ImportList(inner) => inner.span(),
16217 Self::ImportName(inner) => inner.span(),
16218 Self::Imports(inner) => inner.span(),
16219 Self::Inferred(inner) => inner.span(),
16220 Self::Infix(inner) => inner.span(),
16221 Self::InfixId(inner) => inner.span(),
16222 Self::Instance(inner) => inner.span(),
16223 Self::InstanceDeclarations(inner) => inner.span(),
16224 Self::Integer(inner) => inner.span(),
16225 Self::Invisible(inner) => inner.span(),
16226 Self::Irrefutable(inner) => inner.span(),
16227 Self::KindApplication(inner) => inner.span(),
16228 Self::KindSignature(inner) => inner.span(),
16229 Self::Lambda(inner) => inner.span(),
16230 Self::LambdaCase(inner) => inner.span(),
16231 Self::LambdaCases(inner) => inner.span(),
16232 Self::LazyField(inner) => inner.span(),
16233 Self::LeftSection(inner) => inner.span(),
16234 Self::Let(inner) => inner.span(),
16235 Self::LetIn(inner) => inner.span(),
16236 Self::LinearFunction(inner) => inner.span(),
16237 Self::List(inner) => inner.span(),
16238 Self::ListComprehension(inner) => inner.span(),
16239 Self::Literal(inner) => inner.span(),
16240 Self::LocalBinds(inner) => inner.span(),
16241 Self::Match(inner) => inner.span(),
16242 Self::Modifier(inner) => inner.span(),
16243 Self::Module(inner) => inner.span(),
16244 Self::ModuleExport(inner) => inner.span(),
16245 Self::MultiWayIf(inner) => inner.span(),
16246 Self::Namespace(inner) => inner.span(),
16247 Self::Negation(inner) => inner.span(),
16248 Self::Newtype(inner) => inner.span(),
16249 Self::NewtypeConstructor(inner) => inner.span(),
16250 Self::Operator(inner) => inner.span(),
16251 Self::Parens(inner) => inner.span(),
16252 Self::PatternGuard(inner) => inner.span(),
16253 Self::PatternSynonym(inner) => inner.span(),
16254 Self::Patterns(inner) => inner.span(),
16255 Self::Prefix(inner) => inner.span(),
16256 Self::PrefixId(inner) => inner.span(),
16257 Self::PrefixList(inner) => inner.span(),
16258 Self::PrefixTuple(inner) => inner.span(),
16259 Self::PrefixUnboxedSum(inner) => inner.span(),
16260 Self::PrefixUnboxedTuple(inner) => inner.span(),
16261 Self::Projection(inner) => inner.span(),
16262 Self::ProjectionSelector(inner) => inner.span(),
16263 Self::Promoted(inner) => inner.span(),
16264 Self::Qualified(inner) => inner.span(),
16265 Self::Qualifiers(inner) => inner.span(),
16266 Self::QuantifiedVariables(inner) => inner.span(),
16267 Self::Quasiquote(inner) => inner.span(),
16268 Self::Quote(inner) => inner.span(),
16269 Self::QuotedDecls(inner) => inner.span(),
16270 Self::QuotedExpression(inner) => inner.span(),
16271 Self::QuotedPattern(inner) => inner.span(),
16272 Self::QuotedType(inner) => inner.span(),
16273 Self::Quoter(inner) => inner.span(),
16274 Self::Rec(inner) => inner.span(),
16275 Self::Record(inner) => inner.span(),
16276 Self::RightSection(inner) => inner.span(),
16277 Self::RoleAnnotation(inner) => inner.span(),
16278 Self::Signature(inner) => inner.span(),
16279 Self::Special(inner) => inner.span(),
16280 Self::Splice(inner) => inner.span(),
16281 Self::Star(inner) => inner.span(),
16282 Self::Strict(inner) => inner.span(),
16283 Self::StrictField(inner) => inner.span(),
16284 Self::ThQuotedName(inner) => inner.span(),
16285 Self::TopSplice(inner) => inner.span(),
16286 Self::Transform(inner) => inner.span(),
16287 Self::Tuple(inner) => inner.span(),
16288 Self::TypeApplication(inner) => inner.span(),
16289 Self::TypeBinder(inner) => inner.span(),
16290 Self::TypeFamily(inner) => inner.span(),
16291 Self::TypeFamilyInjectivity(inner) => inner.span(),
16292 Self::TypeFamilyResult(inner) => inner.span(),
16293 Self::TypeInstance(inner) => inner.span(),
16294 Self::TypeParams(inner) => inner.span(),
16295 Self::TypePatterns(inner) => inner.span(),
16296 Self::TypeRole(inner) => inner.span(),
16297 Self::TypeSynomym(inner) => inner.span(),
16298 Self::TypedQuote(inner) => inner.span(),
16299 Self::UnboxedSum(inner) => inner.span(),
16300 Self::UnboxedTuple(inner) => inner.span(),
16301 Self::UnboxedUnit(inner) => inner.span(),
16302 Self::Unit(inner) => inner.span(),
16303 Self::Via(inner) => inner.span(),
16304 Self::ViewPattern(inner) => inner.span(),
16305 Self::Wildcard(inner) => inner.span(),
16306 Self::AllNames(inner) => inner.span(),
16307 Self::CallingConvention(inner) => inner.span(),
16308 Self::Char(inner) => inner.span(),
16309 Self::Comment(inner) => inner.span(),
16310 Self::Constructor(inner) => inner.span(),
16311 Self::Cpp(inner) => inner.span(),
16312 Self::Float(inner) => inner.span(),
16313 Self::Haddock(inner) => inner.span(),
16314 Self::ImplicitVariable(inner) => inner.span(),
16315 Self::ImportPackage(inner) => inner.span(),
16316 Self::Label(inner) => inner.span(),
16317 Self::ModuleId(inner) => inner.span(),
16318 Self::Name(inner) => inner.span(),
16319 Self::Pragma(inner) => inner.span(),
16320 Self::QuasiquoteBody(inner) => inner.span(),
16321 Self::Safety(inner) => inner.span(),
16322 Self::String(inner) => inner.span(),
16323 Self::Variable(inner) => inner.span(),
16324 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
16325 }
16326 }
16327}