1#[derive(Debug, Clone)]
2pub enum Declaration<'tree> {
3 AbstractClassDeclaration(::std::boxed::Box<AbstractClassDeclaration<'tree>>),
4 AmbientDeclaration(::std::boxed::Box<AmbientDeclaration<'tree>>),
5 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
6 EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
7 FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
8 FunctionSignature(::std::boxed::Box<FunctionSignature<'tree>>),
9 GeneratorFunctionDeclaration(::std::boxed::Box<GeneratorFunctionDeclaration<'tree>>),
10 ImportAlias(::std::boxed::Box<ImportAlias<'tree>>),
11 InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
12 InternalModule(::std::boxed::Box<InternalModule<'tree>>),
13 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
14 Module(::std::boxed::Box<Module<'tree>>),
15 TypeAliasDeclaration(::std::boxed::Box<TypeAliasDeclaration<'tree>>),
16 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
17}
18impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
19 #[allow(clippy::collapsible_else_if)]
20 fn from_node(
21 node: ::tree_sitter::Node<'tree>,
22 src: &'tree [u8],
23 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
24 match node.kind() {
25 "abstract_class_declaration" => {
26 Ok(Self::AbstractClassDeclaration(::std::boxed::Box::new(
27 <AbstractClassDeclaration as ::treesitter_types::FromNode>::from_node(
28 node, src,
29 )?,
30 )))
31 }
32 "ambient_declaration" => Ok(Self::AmbientDeclaration(::std::boxed::Box::new(
33 <AmbientDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
34 ))),
35 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
36 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
37 ))),
38 "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
39 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
40 ))),
41 "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
42 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
43 ))),
44 "function_signature" => Ok(Self::FunctionSignature(::std::boxed::Box::new(
45 <FunctionSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
46 ))),
47 "generator_function_declaration" => {
48 Ok(Self::GeneratorFunctionDeclaration(::std::boxed::Box::new(
49 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(
50 node, src,
51 )?,
52 )))
53 }
54 "import_alias" => Ok(Self::ImportAlias(::std::boxed::Box::new(
55 <ImportAlias as ::treesitter_types::FromNode>::from_node(node, src)?,
56 ))),
57 "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
58 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
59 ))),
60 "internal_module" => Ok(Self::InternalModule(::std::boxed::Box::new(
61 <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)?,
62 ))),
63 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
64 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
65 ))),
66 "module" => Ok(Self::Module(::std::boxed::Box::new(
67 <Module as ::treesitter_types::FromNode>::from_node(node, src)?,
68 ))),
69 "type_alias_declaration" => Ok(Self::TypeAliasDeclaration(::std::boxed::Box::new(
70 <TypeAliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
71 ))),
72 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
73 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
74 ))),
75 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
76 }
77 }
78}
79impl ::treesitter_types::Spanned for Declaration<'_> {
80 fn span(&self) -> ::treesitter_types::Span {
81 match self {
82 Self::AbstractClassDeclaration(inner) => inner.span(),
83 Self::AmbientDeclaration(inner) => inner.span(),
84 Self::ClassDeclaration(inner) => inner.span(),
85 Self::EnumDeclaration(inner) => inner.span(),
86 Self::FunctionDeclaration(inner) => inner.span(),
87 Self::FunctionSignature(inner) => inner.span(),
88 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
89 Self::ImportAlias(inner) => inner.span(),
90 Self::InterfaceDeclaration(inner) => inner.span(),
91 Self::InternalModule(inner) => inner.span(),
92 Self::LexicalDeclaration(inner) => inner.span(),
93 Self::Module(inner) => inner.span(),
94 Self::TypeAliasDeclaration(inner) => inner.span(),
95 Self::VariableDeclaration(inner) => inner.span(),
96 }
97 }
98}
99#[derive(Debug, Clone)]
100pub enum Expression<'tree> {
101 AsExpression(::std::boxed::Box<AsExpression<'tree>>),
102 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
103 AugmentedAssignmentExpression(::std::boxed::Box<AugmentedAssignmentExpression<'tree>>),
104 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
105 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
106 InstantiationExpression(::std::boxed::Box<InstantiationExpression<'tree>>),
107 InternalModule(::std::boxed::Box<InternalModule<'tree>>),
108 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
109 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
110 SatisfiesExpression(::std::boxed::Box<SatisfiesExpression<'tree>>),
111 TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
112 TypeAssertion(::std::boxed::Box<TypeAssertion<'tree>>),
113 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
114 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
115 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
116}
117impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
118 #[allow(clippy::collapsible_else_if)]
119 fn from_node(
120 node: ::tree_sitter::Node<'tree>,
121 src: &'tree [u8],
122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
123 match node.kind() {
124 "as_expression" => Ok(Self::AsExpression(::std::boxed::Box::new(
125 <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
126 ))),
127 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
128 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
129 ))),
130 "augmented_assignment_expression" => {
131 Ok(Self::AugmentedAssignmentExpression(::std::boxed::Box::new(
132 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
133 node, src,
134 )?,
135 )))
136 }
137 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
138 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
139 ))),
140 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
141 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
142 ))),
143 "instantiation_expression" => {
144 Ok(Self::InstantiationExpression(::std::boxed::Box::new(
145 <InstantiationExpression as ::treesitter_types::FromNode>::from_node(
146 node, src,
147 )?,
148 )))
149 }
150 "internal_module" => Ok(Self::InternalModule(::std::boxed::Box::new(
151 <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)?,
152 ))),
153 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
154 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
155 ))),
156 "satisfies_expression" => Ok(Self::SatisfiesExpression(::std::boxed::Box::new(
157 <SatisfiesExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
158 ))),
159 "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
160 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
161 ))),
162 "type_assertion" => Ok(Self::TypeAssertion(::std::boxed::Box::new(
163 <TypeAssertion as ::treesitter_types::FromNode>::from_node(node, src)?,
164 ))),
165 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
166 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
167 ))),
168 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
169 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
170 ))),
171 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
172 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
173 ))),
174 _other => {
175 if let Ok(v) =
176 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
177 {
178 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
179 } else {
180 Err(::treesitter_types::ParseError::unexpected_kind(
181 _other, node,
182 ))
183 }
184 }
185 }
186 }
187}
188impl ::treesitter_types::Spanned for Expression<'_> {
189 fn span(&self) -> ::treesitter_types::Span {
190 match self {
191 Self::AsExpression(inner) => inner.span(),
192 Self::AssignmentExpression(inner) => inner.span(),
193 Self::AugmentedAssignmentExpression(inner) => inner.span(),
194 Self::AwaitExpression(inner) => inner.span(),
195 Self::BinaryExpression(inner) => inner.span(),
196 Self::InstantiationExpression(inner) => inner.span(),
197 Self::InternalModule(inner) => inner.span(),
198 Self::NewExpression(inner) => inner.span(),
199 Self::PrimaryExpression(inner) => inner.span(),
200 Self::SatisfiesExpression(inner) => inner.span(),
201 Self::TernaryExpression(inner) => inner.span(),
202 Self::TypeAssertion(inner) => inner.span(),
203 Self::UnaryExpression(inner) => inner.span(),
204 Self::UpdateExpression(inner) => inner.span(),
205 Self::YieldExpression(inner) => inner.span(),
206 }
207 }
208}
209#[derive(Debug, Clone)]
210pub enum Pattern<'tree> {
211 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
212 Identifier(::std::boxed::Box<Identifier<'tree>>),
213 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
214 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
215 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
216 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
217 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
218 Undefined(::std::boxed::Box<Undefined<'tree>>),
219}
220impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
221 #[allow(clippy::collapsible_else_if)]
222 fn from_node(
223 node: ::tree_sitter::Node<'tree>,
224 src: &'tree [u8],
225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
226 match node.kind() {
227 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
228 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
229 ))),
230 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
231 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
232 ))),
233 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
234 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
235 ))),
236 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
237 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
238 ))),
239 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
240 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
241 ))),
242 "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
243 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
244 ))),
245 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
246 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
247 ))),
248 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
249 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
250 ))),
251 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
252 }
253 }
254}
255impl ::treesitter_types::Spanned for Pattern<'_> {
256 fn span(&self) -> ::treesitter_types::Span {
257 match self {
258 Self::ArrayPattern(inner) => inner.span(),
259 Self::Identifier(inner) => inner.span(),
260 Self::MemberExpression(inner) => inner.span(),
261 Self::NonNullExpression(inner) => inner.span(),
262 Self::ObjectPattern(inner) => inner.span(),
263 Self::RestPattern(inner) => inner.span(),
264 Self::SubscriptExpression(inner) => inner.span(),
265 Self::Undefined(inner) => inner.span(),
266 }
267 }
268}
269#[derive(Debug, Clone)]
270pub enum PrimaryExpression<'tree> {
271 Array(::std::boxed::Box<Array<'tree>>),
272 ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
273 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
274 Class(::std::boxed::Box<Class<'tree>>),
275 False(::std::boxed::Box<False<'tree>>),
276 FunctionExpression(::std::boxed::Box<FunctionExpression<'tree>>),
277 GeneratorFunction(::std::boxed::Box<GeneratorFunction<'tree>>),
278 Identifier(::std::boxed::Box<Identifier<'tree>>),
279 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
280 MetaProperty(::std::boxed::Box<MetaProperty<'tree>>),
281 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
282 Null(::std::boxed::Box<Null<'tree>>),
283 Number(::std::boxed::Box<Number<'tree>>),
284 Object(::std::boxed::Box<Object<'tree>>),
285 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
286 Regex(::std::boxed::Box<Regex<'tree>>),
287 String(::std::boxed::Box<String<'tree>>),
288 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
289 Super(::std::boxed::Box<Super<'tree>>),
290 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
291 This(::std::boxed::Box<This<'tree>>),
292 True(::std::boxed::Box<True<'tree>>),
293 Undefined(::std::boxed::Box<Undefined<'tree>>),
294}
295impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
296 #[allow(clippy::collapsible_else_if)]
297 fn from_node(
298 node: ::tree_sitter::Node<'tree>,
299 src: &'tree [u8],
300 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
301 match node.kind() {
302 "array" => Ok(Self::Array(::std::boxed::Box::new(
303 <Array as ::treesitter_types::FromNode>::from_node(node, src)?,
304 ))),
305 "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
306 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
307 ))),
308 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
309 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
310 ))),
311 "class" => Ok(Self::Class(::std::boxed::Box::new(
312 <Class as ::treesitter_types::FromNode>::from_node(node, src)?,
313 ))),
314 "false" => Ok(Self::False(::std::boxed::Box::new(
315 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
316 ))),
317 "function_expression" => Ok(Self::FunctionExpression(::std::boxed::Box::new(
318 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
319 ))),
320 "generator_function" => Ok(Self::GeneratorFunction(::std::boxed::Box::new(
321 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
322 ))),
323 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
324 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
325 ))),
326 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
327 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
328 ))),
329 "meta_property" => Ok(Self::MetaProperty(::std::boxed::Box::new(
330 <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)?,
331 ))),
332 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
333 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
334 ))),
335 "null" => Ok(Self::Null(::std::boxed::Box::new(
336 <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
337 ))),
338 "number" => Ok(Self::Number(::std::boxed::Box::new(
339 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
340 ))),
341 "object" => Ok(Self::Object(::std::boxed::Box::new(
342 <Object as ::treesitter_types::FromNode>::from_node(node, src)?,
343 ))),
344 "parenthesized_expression" => {
345 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
346 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
347 node, src,
348 )?,
349 )))
350 }
351 "regex" => Ok(Self::Regex(::std::boxed::Box::new(
352 <Regex as ::treesitter_types::FromNode>::from_node(node, src)?,
353 ))),
354 "string" => Ok(Self::String(::std::boxed::Box::new(
355 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
356 ))),
357 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
358 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
359 ))),
360 "super" => Ok(Self::Super(::std::boxed::Box::new(
361 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
362 ))),
363 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
364 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
365 ))),
366 "this" => Ok(Self::This(::std::boxed::Box::new(
367 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
368 ))),
369 "true" => Ok(Self::True(::std::boxed::Box::new(
370 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
371 ))),
372 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
373 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
374 ))),
375 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
376 }
377 }
378}
379impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
380 fn span(&self) -> ::treesitter_types::Span {
381 match self {
382 Self::Array(inner) => inner.span(),
383 Self::ArrowFunction(inner) => inner.span(),
384 Self::CallExpression(inner) => inner.span(),
385 Self::Class(inner) => inner.span(),
386 Self::False(inner) => inner.span(),
387 Self::FunctionExpression(inner) => inner.span(),
388 Self::GeneratorFunction(inner) => inner.span(),
389 Self::Identifier(inner) => inner.span(),
390 Self::MemberExpression(inner) => inner.span(),
391 Self::MetaProperty(inner) => inner.span(),
392 Self::NonNullExpression(inner) => inner.span(),
393 Self::Null(inner) => inner.span(),
394 Self::Number(inner) => inner.span(),
395 Self::Object(inner) => inner.span(),
396 Self::ParenthesizedExpression(inner) => inner.span(),
397 Self::Regex(inner) => inner.span(),
398 Self::String(inner) => inner.span(),
399 Self::SubscriptExpression(inner) => inner.span(),
400 Self::Super(inner) => inner.span(),
401 Self::TemplateString(inner) => inner.span(),
402 Self::This(inner) => inner.span(),
403 Self::True(inner) => inner.span(),
404 Self::Undefined(inner) => inner.span(),
405 }
406 }
407}
408#[derive(Debug, Clone)]
409pub enum PrimaryType<'tree> {
410 ArrayType(::std::boxed::Box<ArrayType<'tree>>),
411 ConditionalType(::std::boxed::Box<ConditionalType<'tree>>),
412 Const(::treesitter_types::Span),
413 ExistentialType(::std::boxed::Box<ExistentialType<'tree>>),
414 FlowMaybeType(::std::boxed::Box<FlowMaybeType<'tree>>),
415 GenericType(::std::boxed::Box<GenericType<'tree>>),
416 IndexTypeQuery(::std::boxed::Box<IndexTypeQuery<'tree>>),
417 IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
418 LiteralType(::std::boxed::Box<LiteralType<'tree>>),
419 LookupType(::std::boxed::Box<LookupType<'tree>>),
420 NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
421 ObjectType(::std::boxed::Box<ObjectType<'tree>>),
422 ParenthesizedType(::std::boxed::Box<ParenthesizedType<'tree>>),
423 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
424 TemplateLiteralType(::std::boxed::Box<TemplateLiteralType<'tree>>),
425 ThisType(::std::boxed::Box<ThisType<'tree>>),
426 TupleType(::std::boxed::Box<TupleType<'tree>>),
427 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
428 TypeQuery(::std::boxed::Box<TypeQuery<'tree>>),
429 UnionType(::std::boxed::Box<UnionType<'tree>>),
430}
431impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryType<'tree> {
432 #[allow(clippy::collapsible_else_if)]
433 fn from_node(
434 node: ::tree_sitter::Node<'tree>,
435 src: &'tree [u8],
436 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
437 match node.kind() {
438 "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
439 <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
440 ))),
441 "conditional_type" => Ok(Self::ConditionalType(::std::boxed::Box::new(
442 <ConditionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
443 ))),
444 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
445 "existential_type" => Ok(Self::ExistentialType(::std::boxed::Box::new(
446 <ExistentialType as ::treesitter_types::FromNode>::from_node(node, src)?,
447 ))),
448 "flow_maybe_type" => Ok(Self::FlowMaybeType(::std::boxed::Box::new(
449 <FlowMaybeType as ::treesitter_types::FromNode>::from_node(node, src)?,
450 ))),
451 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
452 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
453 ))),
454 "index_type_query" => Ok(Self::IndexTypeQuery(::std::boxed::Box::new(
455 <IndexTypeQuery as ::treesitter_types::FromNode>::from_node(node, src)?,
456 ))),
457 "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
458 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)?,
459 ))),
460 "literal_type" => Ok(Self::LiteralType(::std::boxed::Box::new(
461 <LiteralType as ::treesitter_types::FromNode>::from_node(node, src)?,
462 ))),
463 "lookup_type" => Ok(Self::LookupType(::std::boxed::Box::new(
464 <LookupType as ::treesitter_types::FromNode>::from_node(node, src)?,
465 ))),
466 "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
467 <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
468 ))),
469 "object_type" => Ok(Self::ObjectType(::std::boxed::Box::new(
470 <ObjectType as ::treesitter_types::FromNode>::from_node(node, src)?,
471 ))),
472 "parenthesized_type" => Ok(Self::ParenthesizedType(::std::boxed::Box::new(
473 <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)?,
474 ))),
475 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
476 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
477 ))),
478 "template_literal_type" => Ok(Self::TemplateLiteralType(::std::boxed::Box::new(
479 <TemplateLiteralType as ::treesitter_types::FromNode>::from_node(node, src)?,
480 ))),
481 "this_type" => Ok(Self::ThisType(::std::boxed::Box::new(
482 <ThisType as ::treesitter_types::FromNode>::from_node(node, src)?,
483 ))),
484 "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
485 <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
486 ))),
487 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
488 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
489 ))),
490 "type_query" => Ok(Self::TypeQuery(::std::boxed::Box::new(
491 <TypeQuery as ::treesitter_types::FromNode>::from_node(node, src)?,
492 ))),
493 "union_type" => Ok(Self::UnionType(::std::boxed::Box::new(
494 <UnionType as ::treesitter_types::FromNode>::from_node(node, src)?,
495 ))),
496 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
497 }
498 }
499}
500impl ::treesitter_types::Spanned for PrimaryType<'_> {
501 fn span(&self) -> ::treesitter_types::Span {
502 match self {
503 Self::ArrayType(inner) => inner.span(),
504 Self::ConditionalType(inner) => inner.span(),
505 Self::Const(span) => *span,
506 Self::ExistentialType(inner) => inner.span(),
507 Self::FlowMaybeType(inner) => inner.span(),
508 Self::GenericType(inner) => inner.span(),
509 Self::IndexTypeQuery(inner) => inner.span(),
510 Self::IntersectionType(inner) => inner.span(),
511 Self::LiteralType(inner) => inner.span(),
512 Self::LookupType(inner) => inner.span(),
513 Self::NestedTypeIdentifier(inner) => inner.span(),
514 Self::ObjectType(inner) => inner.span(),
515 Self::ParenthesizedType(inner) => inner.span(),
516 Self::PredefinedType(inner) => inner.span(),
517 Self::TemplateLiteralType(inner) => inner.span(),
518 Self::ThisType(inner) => inner.span(),
519 Self::TupleType(inner) => inner.span(),
520 Self::TypeIdentifier(inner) => inner.span(),
521 Self::TypeQuery(inner) => inner.span(),
522 Self::UnionType(inner) => inner.span(),
523 }
524 }
525}
526#[derive(Debug, Clone)]
527pub enum Statement<'tree> {
528 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
529 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
530 DebuggerStatement(::std::boxed::Box<DebuggerStatement<'tree>>),
531 Declaration(::std::boxed::Box<Declaration<'tree>>),
532 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
533 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
534 ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
535 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
536 ForInStatement(::std::boxed::Box<ForInStatement<'tree>>),
537 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
538 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
539 ImportStatement(::std::boxed::Box<ImportStatement<'tree>>),
540 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
541 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
542 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
543 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
544 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
545 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
546 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
547 WithStatement(::std::boxed::Box<WithStatement<'tree>>),
548}
549impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
550 #[allow(clippy::collapsible_else_if)]
551 fn from_node(
552 node: ::tree_sitter::Node<'tree>,
553 src: &'tree [u8],
554 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
555 match node.kind() {
556 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
557 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
558 ))),
559 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
560 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
561 ))),
562 "debugger_statement" => Ok(Self::DebuggerStatement(::std::boxed::Box::new(
563 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
564 ))),
565 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
566 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
567 ))),
568 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
569 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
570 ))),
571 "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
572 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
573 ))),
574 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
575 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
576 ))),
577 "for_in_statement" => Ok(Self::ForInStatement(::std::boxed::Box::new(
578 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
579 ))),
580 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
581 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
582 ))),
583 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
584 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
585 ))),
586 "import_statement" => Ok(Self::ImportStatement(::std::boxed::Box::new(
587 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
588 ))),
589 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
590 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
591 ))),
592 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
593 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
594 ))),
595 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
596 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
597 ))),
598 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
599 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
600 ))),
601 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
602 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
603 ))),
604 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
605 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
606 ))),
607 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
608 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
609 ))),
610 "with_statement" => Ok(Self::WithStatement(::std::boxed::Box::new(
611 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
612 ))),
613 _other => {
614 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
615 Ok(Self::Declaration(::std::boxed::Box::new(v)))
616 } else {
617 Err(::treesitter_types::ParseError::unexpected_kind(
618 _other, node,
619 ))
620 }
621 }
622 }
623 }
624}
625impl ::treesitter_types::Spanned for Statement<'_> {
626 fn span(&self) -> ::treesitter_types::Span {
627 match self {
628 Self::BreakStatement(inner) => inner.span(),
629 Self::ContinueStatement(inner) => inner.span(),
630 Self::DebuggerStatement(inner) => inner.span(),
631 Self::Declaration(inner) => inner.span(),
632 Self::DoStatement(inner) => inner.span(),
633 Self::EmptyStatement(inner) => inner.span(),
634 Self::ExportStatement(inner) => inner.span(),
635 Self::ExpressionStatement(inner) => inner.span(),
636 Self::ForInStatement(inner) => inner.span(),
637 Self::ForStatement(inner) => inner.span(),
638 Self::IfStatement(inner) => inner.span(),
639 Self::ImportStatement(inner) => inner.span(),
640 Self::LabeledStatement(inner) => inner.span(),
641 Self::ReturnStatement(inner) => inner.span(),
642 Self::StatementBlock(inner) => inner.span(),
643 Self::SwitchStatement(inner) => inner.span(),
644 Self::ThrowStatement(inner) => inner.span(),
645 Self::TryStatement(inner) => inner.span(),
646 Self::WhileStatement(inner) => inner.span(),
647 Self::WithStatement(inner) => inner.span(),
648 }
649 }
650}
651#[derive(Debug, Clone)]
652pub enum Type<'tree> {
653 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
654 ConstructorType(::std::boxed::Box<ConstructorType<'tree>>),
655 FunctionType(::std::boxed::Box<FunctionType<'tree>>),
656 InferType(::std::boxed::Box<InferType<'tree>>),
657 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
658 PrimaryType(::std::boxed::Box<PrimaryType<'tree>>),
659 ReadonlyType(::std::boxed::Box<ReadonlyType<'tree>>),
660}
661impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
662 #[allow(clippy::collapsible_else_if)]
663 fn from_node(
664 node: ::tree_sitter::Node<'tree>,
665 src: &'tree [u8],
666 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
667 match node.kind() {
668 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
669 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
670 ))),
671 "constructor_type" => Ok(Self::ConstructorType(::std::boxed::Box::new(
672 <ConstructorType as ::treesitter_types::FromNode>::from_node(node, src)?,
673 ))),
674 "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
675 <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
676 ))),
677 "infer_type" => Ok(Self::InferType(::std::boxed::Box::new(
678 <InferType as ::treesitter_types::FromNode>::from_node(node, src)?,
679 ))),
680 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
681 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
682 ))),
683 "readonly_type" => Ok(Self::ReadonlyType(::std::boxed::Box::new(
684 <ReadonlyType as ::treesitter_types::FromNode>::from_node(node, src)?,
685 ))),
686 _other => {
687 if let Ok(v) = <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src) {
688 Ok(Self::PrimaryType(::std::boxed::Box::new(v)))
689 } else {
690 Err(::treesitter_types::ParseError::unexpected_kind(
691 _other, node,
692 ))
693 }
694 }
695 }
696 }
697}
698impl ::treesitter_types::Spanned for Type<'_> {
699 fn span(&self) -> ::treesitter_types::Span {
700 match self {
701 Self::CallExpression(inner) => inner.span(),
702 Self::ConstructorType(inner) => inner.span(),
703 Self::FunctionType(inner) => inner.span(),
704 Self::InferType(inner) => inner.span(),
705 Self::MemberExpression(inner) => inner.span(),
706 Self::PrimaryType(inner) => inner.span(),
707 Self::ReadonlyType(inner) => inner.span(),
708 }
709 }
710}
711#[derive(Debug, Clone)]
712pub struct AbstractClassDeclaration<'tree> {
713 pub span: ::treesitter_types::Span,
714 pub body: ClassBody<'tree>,
715 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
716 pub name: TypeIdentifier<'tree>,
717 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
718 pub children: ::core::option::Option<ClassHeritage<'tree>>,
719}
720impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractClassDeclaration<'tree> {
721 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
722 fn from_node(
723 node: ::tree_sitter::Node<'tree>,
724 src: &'tree [u8],
725 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
726 debug_assert_eq!(node.kind(), "abstract_class_declaration");
727 Ok(Self {
728 span: ::treesitter_types::Span::from(node),
729 body: {
730 let child = node
731 .child_by_field_name("body")
732 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
733 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
734 },
735 decorator: {
736 let mut cursor = node.walk();
737 let mut items = ::std::vec::Vec::new();
738 for child in node.children_by_field_name("decorator", &mut cursor) {
739 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
740 child, src,
741 )?);
742 }
743 items
744 },
745 name: {
746 let child = node
747 .child_by_field_name("name")
748 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
749 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
750 },
751 type_parameters: match node.child_by_field_name("type_parameters") {
752 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
753 child, src,
754 )?),
755 None => None,
756 },
757 children: {
758 #[allow(clippy::suspicious_else_formatting)]
759 let non_field_children = {
760 let mut cursor = node.walk();
761 let mut result = ::std::vec::Vec::new();
762 if cursor.goto_first_child() {
763 loop {
764 if cursor.field_name().is_none()
765 && cursor.node().is_named()
766 && !cursor.node().is_extra()
767 {
768 result.push(cursor.node());
769 }
770 if !cursor.goto_next_sibling() {
771 break;
772 }
773 }
774 }
775 result
776 };
777 match non_field_children.first() {
778 Some(&child) => Some(
779 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
780 ),
781 None => None,
782 }
783 },
784 })
785 }
786}
787impl ::treesitter_types::Spanned for AbstractClassDeclaration<'_> {
788 fn span(&self) -> ::treesitter_types::Span {
789 self.span
790 }
791}
792#[derive(Debug, Clone)]
793pub struct AbstractMethodSignature<'tree> {
794 pub span: ::treesitter_types::Span,
795 pub name: AbstractMethodSignatureName<'tree>,
796 pub parameters: FormalParameters<'tree>,
797 pub return_type: ::core::option::Option<AbstractMethodSignatureReturnType<'tree>>,
798 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
799 pub children: ::std::vec::Vec<AbstractMethodSignatureChildren<'tree>>,
800}
801impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignature<'tree> {
802 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
803 fn from_node(
804 node: ::tree_sitter::Node<'tree>,
805 src: &'tree [u8],
806 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
807 debug_assert_eq!(node.kind(), "abstract_method_signature");
808 Ok(Self {
809 span: ::treesitter_types::Span::from(node),
810 name: {
811 let child = node
812 .child_by_field_name("name")
813 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
814 <AbstractMethodSignatureName as ::treesitter_types::FromNode>::from_node(
815 child, src,
816 )?
817 },
818 parameters: {
819 let child = node.child_by_field_name("parameters").ok_or_else(|| {
820 ::treesitter_types::ParseError::missing_field("parameters", node)
821 })?;
822 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
823 },
824 return_type: match node.child_by_field_name("return_type") {
825 Some(child) => Some(
826 <AbstractMethodSignatureReturnType as ::treesitter_types::FromNode>::from_node(
827 child, src,
828 )?,
829 ),
830 None => None,
831 },
832 type_parameters: match node.child_by_field_name("type_parameters") {
833 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
834 child, src,
835 )?),
836 None => None,
837 },
838 children: {
839 #[allow(clippy::suspicious_else_formatting)]
840 let non_field_children = {
841 let mut cursor = node.walk();
842 let mut result = ::std::vec::Vec::new();
843 if cursor.goto_first_child() {
844 loop {
845 if cursor.field_name().is_none()
846 && cursor.node().is_named()
847 && !cursor.node().is_extra()
848 {
849 result.push(cursor.node());
850 }
851 if !cursor.goto_next_sibling() {
852 break;
853 }
854 }
855 }
856 result
857 };
858 let mut items = ::std::vec::Vec::new();
859 for child in non_field_children {
860 items
861 .push(
862 <AbstractMethodSignatureChildren as ::treesitter_types::FromNode>::from_node(
863 child,
864 src,
865 )?,
866 );
867 }
868 items
869 },
870 })
871 }
872}
873impl ::treesitter_types::Spanned for AbstractMethodSignature<'_> {
874 fn span(&self) -> ::treesitter_types::Span {
875 self.span
876 }
877}
878#[derive(Debug, Clone)]
879pub struct AccessibilityModifier<'tree> {
880 pub span: ::treesitter_types::Span,
881 text: &'tree str,
882}
883impl<'tree> ::treesitter_types::FromNode<'tree> for AccessibilityModifier<'tree> {
884 fn from_node(
885 node: ::tree_sitter::Node<'tree>,
886 src: &'tree [u8],
887 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
888 debug_assert_eq!(node.kind(), "accessibility_modifier");
889 Ok(Self {
890 span: ::treesitter_types::Span::from(node),
891 text: node.utf8_text(src)?,
892 })
893 }
894}
895impl<'tree> ::treesitter_types::LeafNode<'tree> for AccessibilityModifier<'tree> {
896 fn text(&self) -> &'tree str {
897 self.text
898 }
899}
900impl ::treesitter_types::Spanned for AccessibilityModifier<'_> {
901 fn span(&self) -> ::treesitter_types::Span {
902 self.span
903 }
904}
905#[derive(Debug, Clone)]
906pub struct AddingTypeAnnotation<'tree> {
907 pub span: ::treesitter_types::Span,
908 pub children: Type<'tree>,
909}
910impl<'tree> ::treesitter_types::FromNode<'tree> for AddingTypeAnnotation<'tree> {
911 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
912 fn from_node(
913 node: ::tree_sitter::Node<'tree>,
914 src: &'tree [u8],
915 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
916 debug_assert_eq!(node.kind(), "adding_type_annotation");
917 Ok(Self {
918 span: ::treesitter_types::Span::from(node),
919 children: {
920 #[allow(clippy::suspicious_else_formatting)]
921 let non_field_children = {
922 let mut cursor = node.walk();
923 let mut result = ::std::vec::Vec::new();
924 if cursor.goto_first_child() {
925 loop {
926 if cursor.field_name().is_none()
927 && cursor.node().is_named()
928 && !cursor.node().is_extra()
929 {
930 result.push(cursor.node());
931 }
932 if !cursor.goto_next_sibling() {
933 break;
934 }
935 }
936 }
937 result
938 };
939 let child = if let Some(&c) = non_field_children.first() {
940 c
941 } else {
942 let mut fallback_cursor = node.walk();
943 let mut fallback_child = None;
944 if fallback_cursor.goto_first_child() {
945 loop {
946 if fallback_cursor.field_name().is_none()
947 && !fallback_cursor.node().is_extra()
948 {
949 fallback_child = Some(fallback_cursor.node());
950 break;
951 }
952 if !fallback_cursor.goto_next_sibling() {
953 break;
954 }
955 }
956 }
957 fallback_child.ok_or_else(|| {
958 ::treesitter_types::ParseError::missing_field("children", node)
959 })?
960 };
961 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
962 },
963 })
964 }
965}
966impl ::treesitter_types::Spanned for AddingTypeAnnotation<'_> {
967 fn span(&self) -> ::treesitter_types::Span {
968 self.span
969 }
970}
971#[derive(Debug, Clone)]
972pub struct AmbientDeclaration<'tree> {
973 pub span: ::treesitter_types::Span,
974 pub children: ::std::vec::Vec<AmbientDeclarationChildren<'tree>>,
975}
976impl<'tree> ::treesitter_types::FromNode<'tree> for AmbientDeclaration<'tree> {
977 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
978 fn from_node(
979 node: ::tree_sitter::Node<'tree>,
980 src: &'tree [u8],
981 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
982 debug_assert_eq!(node.kind(), "ambient_declaration");
983 Ok(Self {
984 span: ::treesitter_types::Span::from(node),
985 children: {
986 #[allow(clippy::suspicious_else_formatting)]
987 let non_field_children = {
988 let mut cursor = node.walk();
989 let mut result = ::std::vec::Vec::new();
990 if cursor.goto_first_child() {
991 loop {
992 if cursor.field_name().is_none()
993 && cursor.node().is_named()
994 && !cursor.node().is_extra()
995 {
996 result.push(cursor.node());
997 }
998 if !cursor.goto_next_sibling() {
999 break;
1000 }
1001 }
1002 }
1003 result
1004 };
1005 let mut items = ::std::vec::Vec::new();
1006 for child in non_field_children {
1007 items.push(
1008 <AmbientDeclarationChildren as ::treesitter_types::FromNode>::from_node(
1009 child, src,
1010 )?,
1011 );
1012 }
1013 items
1014 },
1015 })
1016 }
1017}
1018impl ::treesitter_types::Spanned for AmbientDeclaration<'_> {
1019 fn span(&self) -> ::treesitter_types::Span {
1020 self.span
1021 }
1022}
1023#[derive(Debug, Clone)]
1024pub struct Arguments<'tree> {
1025 pub span: ::treesitter_types::Span,
1026 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
1027}
1028impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
1029 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1030 fn from_node(
1031 node: ::tree_sitter::Node<'tree>,
1032 src: &'tree [u8],
1033 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1034 debug_assert_eq!(node.kind(), "arguments");
1035 Ok(Self {
1036 span: ::treesitter_types::Span::from(node),
1037 children: {
1038 #[allow(clippy::suspicious_else_formatting)]
1039 let non_field_children = {
1040 let mut cursor = node.walk();
1041 let mut result = ::std::vec::Vec::new();
1042 if cursor.goto_first_child() {
1043 loop {
1044 if cursor.field_name().is_none()
1045 && cursor.node().is_named()
1046 && !cursor.node().is_extra()
1047 {
1048 result.push(cursor.node());
1049 }
1050 if !cursor.goto_next_sibling() {
1051 break;
1052 }
1053 }
1054 }
1055 result
1056 };
1057 let mut items = ::std::vec::Vec::new();
1058 for child in non_field_children {
1059 items.push(
1060 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1061 );
1062 }
1063 items
1064 },
1065 })
1066 }
1067}
1068impl ::treesitter_types::Spanned for Arguments<'_> {
1069 fn span(&self) -> ::treesitter_types::Span {
1070 self.span
1071 }
1072}
1073#[derive(Debug, Clone)]
1074pub struct Array<'tree> {
1075 pub span: ::treesitter_types::Span,
1076 pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
1077}
1078impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
1079 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1080 fn from_node(
1081 node: ::tree_sitter::Node<'tree>,
1082 src: &'tree [u8],
1083 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1084 debug_assert_eq!(node.kind(), "array");
1085 Ok(Self {
1086 span: ::treesitter_types::Span::from(node),
1087 children: {
1088 #[allow(clippy::suspicious_else_formatting)]
1089 let non_field_children = {
1090 let mut cursor = node.walk();
1091 let mut result = ::std::vec::Vec::new();
1092 if cursor.goto_first_child() {
1093 loop {
1094 if cursor.field_name().is_none()
1095 && cursor.node().is_named()
1096 && !cursor.node().is_extra()
1097 {
1098 result.push(cursor.node());
1099 }
1100 if !cursor.goto_next_sibling() {
1101 break;
1102 }
1103 }
1104 }
1105 result
1106 };
1107 let mut items = ::std::vec::Vec::new();
1108 for child in non_field_children {
1109 items.push(<ArrayChildren as ::treesitter_types::FromNode>::from_node(
1110 child, src,
1111 )?);
1112 }
1113 items
1114 },
1115 })
1116 }
1117}
1118impl ::treesitter_types::Spanned for Array<'_> {
1119 fn span(&self) -> ::treesitter_types::Span {
1120 self.span
1121 }
1122}
1123#[derive(Debug, Clone)]
1124pub struct ArrayPattern<'tree> {
1125 pub span: ::treesitter_types::Span,
1126 pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
1127}
1128impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
1129 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1130 fn from_node(
1131 node: ::tree_sitter::Node<'tree>,
1132 src: &'tree [u8],
1133 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1134 debug_assert_eq!(node.kind(), "array_pattern");
1135 Ok(Self {
1136 span: ::treesitter_types::Span::from(node),
1137 children: {
1138 #[allow(clippy::suspicious_else_formatting)]
1139 let non_field_children = {
1140 let mut cursor = node.walk();
1141 let mut result = ::std::vec::Vec::new();
1142 if cursor.goto_first_child() {
1143 loop {
1144 if cursor.field_name().is_none()
1145 && cursor.node().is_named()
1146 && !cursor.node().is_extra()
1147 {
1148 result.push(cursor.node());
1149 }
1150 if !cursor.goto_next_sibling() {
1151 break;
1152 }
1153 }
1154 }
1155 result
1156 };
1157 let mut items = ::std::vec::Vec::new();
1158 for child in non_field_children {
1159 items.push(
1160 <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
1161 child, src,
1162 )?,
1163 );
1164 }
1165 items
1166 },
1167 })
1168 }
1169}
1170impl ::treesitter_types::Spanned for ArrayPattern<'_> {
1171 fn span(&self) -> ::treesitter_types::Span {
1172 self.span
1173 }
1174}
1175#[derive(Debug, Clone)]
1176pub struct ArrayType<'tree> {
1177 pub span: ::treesitter_types::Span,
1178 pub children: PrimaryType<'tree>,
1179}
1180impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
1181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1182 fn from_node(
1183 node: ::tree_sitter::Node<'tree>,
1184 src: &'tree [u8],
1185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1186 debug_assert_eq!(node.kind(), "array_type");
1187 Ok(Self {
1188 span: ::treesitter_types::Span::from(node),
1189 children: {
1190 #[allow(clippy::suspicious_else_formatting)]
1191 let non_field_children = {
1192 let mut cursor = node.walk();
1193 let mut result = ::std::vec::Vec::new();
1194 if cursor.goto_first_child() {
1195 loop {
1196 if cursor.field_name().is_none()
1197 && cursor.node().is_named()
1198 && !cursor.node().is_extra()
1199 {
1200 result.push(cursor.node());
1201 }
1202 if !cursor.goto_next_sibling() {
1203 break;
1204 }
1205 }
1206 }
1207 result
1208 };
1209 let child = if let Some(&c) = non_field_children.first() {
1210 c
1211 } else {
1212 let mut fallback_cursor = node.walk();
1213 let mut fallback_child = None;
1214 if fallback_cursor.goto_first_child() {
1215 loop {
1216 if fallback_cursor.field_name().is_none()
1217 && !fallback_cursor.node().is_extra()
1218 {
1219 fallback_child = Some(fallback_cursor.node());
1220 break;
1221 }
1222 if !fallback_cursor.goto_next_sibling() {
1223 break;
1224 }
1225 }
1226 }
1227 fallback_child.ok_or_else(|| {
1228 ::treesitter_types::ParseError::missing_field("children", node)
1229 })?
1230 };
1231 <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
1232 },
1233 })
1234 }
1235}
1236impl ::treesitter_types::Spanned for ArrayType<'_> {
1237 fn span(&self) -> ::treesitter_types::Span {
1238 self.span
1239 }
1240}
1241#[derive(Debug, Clone)]
1242pub struct ArrowFunction<'tree> {
1243 pub span: ::treesitter_types::Span,
1244 pub body: ArrowFunctionBody<'tree>,
1245 pub parameter: ::core::option::Option<Identifier<'tree>>,
1246 pub parameters: ::core::option::Option<FormalParameters<'tree>>,
1247 pub return_type: ::core::option::Option<ArrowFunctionReturnType<'tree>>,
1248 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1249}
1250impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
1251 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1252 fn from_node(
1253 node: ::tree_sitter::Node<'tree>,
1254 src: &'tree [u8],
1255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1256 debug_assert_eq!(node.kind(), "arrow_function");
1257 Ok(Self {
1258 span: ::treesitter_types::Span::from(node),
1259 body: {
1260 let child = node
1261 .child_by_field_name("body")
1262 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1263 <ArrowFunctionBody as ::treesitter_types::FromNode>::from_node(child, src)?
1264 },
1265 parameter: match node.child_by_field_name("parameter") {
1266 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1267 child, src,
1268 )?),
1269 None => None,
1270 },
1271 parameters: match node.child_by_field_name("parameters") {
1272 Some(child) => {
1273 Some(<FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
1274 }
1275 None => None,
1276 },
1277 return_type: match node.child_by_field_name("return_type") {
1278 Some(child) => Some(
1279 <ArrowFunctionReturnType as ::treesitter_types::FromNode>::from_node(
1280 child, src,
1281 )?,
1282 ),
1283 None => None,
1284 },
1285 type_parameters: match node.child_by_field_name("type_parameters") {
1286 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
1287 child, src,
1288 )?),
1289 None => None,
1290 },
1291 })
1292 }
1293}
1294impl ::treesitter_types::Spanned for ArrowFunction<'_> {
1295 fn span(&self) -> ::treesitter_types::Span {
1296 self.span
1297 }
1298}
1299#[derive(Debug, Clone)]
1300pub struct AsExpression<'tree> {
1301 pub span: ::treesitter_types::Span,
1302 pub children: ::std::vec::Vec<AsExpressionChildren<'tree>>,
1303}
1304impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpression<'tree> {
1305 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1306 fn from_node(
1307 node: ::tree_sitter::Node<'tree>,
1308 src: &'tree [u8],
1309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1310 debug_assert_eq!(node.kind(), "as_expression");
1311 Ok(Self {
1312 span: ::treesitter_types::Span::from(node),
1313 children: {
1314 #[allow(clippy::suspicious_else_formatting)]
1315 let non_field_children = {
1316 let mut cursor = node.walk();
1317 let mut result = ::std::vec::Vec::new();
1318 if cursor.goto_first_child() {
1319 loop {
1320 if cursor.field_name().is_none()
1321 && cursor.node().is_named()
1322 && !cursor.node().is_extra()
1323 {
1324 result.push(cursor.node());
1325 }
1326 if !cursor.goto_next_sibling() {
1327 break;
1328 }
1329 }
1330 }
1331 result
1332 };
1333 let mut items = ::std::vec::Vec::new();
1334 for child in non_field_children {
1335 items.push(
1336 <AsExpressionChildren as ::treesitter_types::FromNode>::from_node(
1337 child, src,
1338 )?,
1339 );
1340 }
1341 items
1342 },
1343 })
1344 }
1345}
1346impl ::treesitter_types::Spanned for AsExpression<'_> {
1347 fn span(&self) -> ::treesitter_types::Span {
1348 self.span
1349 }
1350}
1351#[derive(Debug, Clone)]
1352pub struct Asserts<'tree> {
1353 pub span: ::treesitter_types::Span,
1354 pub children: AssertsChildren<'tree>,
1355}
1356impl<'tree> ::treesitter_types::FromNode<'tree> for Asserts<'tree> {
1357 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1358 fn from_node(
1359 node: ::tree_sitter::Node<'tree>,
1360 src: &'tree [u8],
1361 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1362 debug_assert_eq!(node.kind(), "asserts");
1363 Ok(Self {
1364 span: ::treesitter_types::Span::from(node),
1365 children: {
1366 #[allow(clippy::suspicious_else_formatting)]
1367 let non_field_children = {
1368 let mut cursor = node.walk();
1369 let mut result = ::std::vec::Vec::new();
1370 if cursor.goto_first_child() {
1371 loop {
1372 if cursor.field_name().is_none()
1373 && cursor.node().is_named()
1374 && !cursor.node().is_extra()
1375 {
1376 result.push(cursor.node());
1377 }
1378 if !cursor.goto_next_sibling() {
1379 break;
1380 }
1381 }
1382 }
1383 result
1384 };
1385 let child = if let Some(&c) = non_field_children.first() {
1386 c
1387 } else {
1388 let mut fallback_cursor = node.walk();
1389 let mut fallback_child = None;
1390 if fallback_cursor.goto_first_child() {
1391 loop {
1392 if fallback_cursor.field_name().is_none()
1393 && !fallback_cursor.node().is_extra()
1394 {
1395 fallback_child = Some(fallback_cursor.node());
1396 break;
1397 }
1398 if !fallback_cursor.goto_next_sibling() {
1399 break;
1400 }
1401 }
1402 }
1403 fallback_child.ok_or_else(|| {
1404 ::treesitter_types::ParseError::missing_field("children", node)
1405 })?
1406 };
1407 <AssertsChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1408 },
1409 })
1410 }
1411}
1412impl ::treesitter_types::Spanned for Asserts<'_> {
1413 fn span(&self) -> ::treesitter_types::Span {
1414 self.span
1415 }
1416}
1417#[derive(Debug, Clone)]
1418pub struct AssertsAnnotation<'tree> {
1419 pub span: ::treesitter_types::Span,
1420 pub children: Asserts<'tree>,
1421}
1422impl<'tree> ::treesitter_types::FromNode<'tree> for AssertsAnnotation<'tree> {
1423 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1424 fn from_node(
1425 node: ::tree_sitter::Node<'tree>,
1426 src: &'tree [u8],
1427 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1428 debug_assert_eq!(node.kind(), "asserts_annotation");
1429 Ok(Self {
1430 span: ::treesitter_types::Span::from(node),
1431 children: {
1432 #[allow(clippy::suspicious_else_formatting)]
1433 let non_field_children = {
1434 let mut cursor = node.walk();
1435 let mut result = ::std::vec::Vec::new();
1436 if cursor.goto_first_child() {
1437 loop {
1438 if cursor.field_name().is_none()
1439 && cursor.node().is_named()
1440 && !cursor.node().is_extra()
1441 {
1442 result.push(cursor.node());
1443 }
1444 if !cursor.goto_next_sibling() {
1445 break;
1446 }
1447 }
1448 }
1449 result
1450 };
1451 let child = if let Some(&c) = non_field_children.first() {
1452 c
1453 } else {
1454 let mut fallback_cursor = node.walk();
1455 let mut fallback_child = None;
1456 if fallback_cursor.goto_first_child() {
1457 loop {
1458 if fallback_cursor.field_name().is_none()
1459 && !fallback_cursor.node().is_extra()
1460 {
1461 fallback_child = Some(fallback_cursor.node());
1462 break;
1463 }
1464 if !fallback_cursor.goto_next_sibling() {
1465 break;
1466 }
1467 }
1468 }
1469 fallback_child.ok_or_else(|| {
1470 ::treesitter_types::ParseError::missing_field("children", node)
1471 })?
1472 };
1473 <Asserts as ::treesitter_types::FromNode>::from_node(child, src)?
1474 },
1475 })
1476 }
1477}
1478impl ::treesitter_types::Spanned for AssertsAnnotation<'_> {
1479 fn span(&self) -> ::treesitter_types::Span {
1480 self.span
1481 }
1482}
1483#[derive(Debug, Clone)]
1484pub struct AssignmentExpression<'tree> {
1485 pub span: ::treesitter_types::Span,
1486 pub left: AssignmentExpressionLeft<'tree>,
1487 pub right: Expression<'tree>,
1488}
1489impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
1490 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1491 fn from_node(
1492 node: ::tree_sitter::Node<'tree>,
1493 src: &'tree [u8],
1494 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1495 debug_assert_eq!(node.kind(), "assignment_expression");
1496 Ok(Self {
1497 span: ::treesitter_types::Span::from(node),
1498 left: {
1499 let child = node
1500 .child_by_field_name("left")
1501 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1502 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1503 },
1504 right: {
1505 let child = node
1506 .child_by_field_name("right")
1507 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1508 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1509 },
1510 })
1511 }
1512}
1513impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
1514 fn span(&self) -> ::treesitter_types::Span {
1515 self.span
1516 }
1517}
1518#[derive(Debug, Clone)]
1519pub struct AssignmentPattern<'tree> {
1520 pub span: ::treesitter_types::Span,
1521 pub left: Pattern<'tree>,
1522 pub right: Expression<'tree>,
1523}
1524impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentPattern<'tree> {
1525 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1526 fn from_node(
1527 node: ::tree_sitter::Node<'tree>,
1528 src: &'tree [u8],
1529 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1530 debug_assert_eq!(node.kind(), "assignment_pattern");
1531 Ok(Self {
1532 span: ::treesitter_types::Span::from(node),
1533 left: {
1534 let child = node
1535 .child_by_field_name("left")
1536 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1537 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
1538 },
1539 right: {
1540 let child = node
1541 .child_by_field_name("right")
1542 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1543 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1544 },
1545 })
1546 }
1547}
1548impl ::treesitter_types::Spanned for AssignmentPattern<'_> {
1549 fn span(&self) -> ::treesitter_types::Span {
1550 self.span
1551 }
1552}
1553#[derive(Debug, Clone)]
1554pub struct AugmentedAssignmentExpression<'tree> {
1555 pub span: ::treesitter_types::Span,
1556 pub left: AugmentedAssignmentExpressionLeft<'tree>,
1557 pub operator: AugmentedAssignmentExpressionOperator,
1558 pub right: Expression<'tree>,
1559}
1560impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
1561 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1562 fn from_node(
1563 node: ::tree_sitter::Node<'tree>,
1564 src: &'tree [u8],
1565 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1566 debug_assert_eq!(node.kind(), "augmented_assignment_expression");
1567 Ok(Self {
1568 span: ::treesitter_types::Span::from(node),
1569 left: {
1570 let child = node
1571 .child_by_field_name("left")
1572 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1573 <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
1574 child, src,
1575 )?
1576 },
1577 operator: {
1578 let child = node.child_by_field_name("operator").ok_or_else(|| {
1579 ::treesitter_types::ParseError::missing_field("operator", node)
1580 })?;
1581 <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
1582 child, src,
1583 )?
1584 },
1585 right: {
1586 let child = node
1587 .child_by_field_name("right")
1588 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1589 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1590 },
1591 })
1592 }
1593}
1594impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
1595 fn span(&self) -> ::treesitter_types::Span {
1596 self.span
1597 }
1598}
1599#[derive(Debug, Clone)]
1600pub struct AwaitExpression<'tree> {
1601 pub span: ::treesitter_types::Span,
1602 pub children: Expression<'tree>,
1603}
1604impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
1605 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1606 fn from_node(
1607 node: ::tree_sitter::Node<'tree>,
1608 src: &'tree [u8],
1609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1610 debug_assert_eq!(node.kind(), "await_expression");
1611 Ok(Self {
1612 span: ::treesitter_types::Span::from(node),
1613 children: {
1614 #[allow(clippy::suspicious_else_formatting)]
1615 let non_field_children = {
1616 let mut cursor = node.walk();
1617 let mut result = ::std::vec::Vec::new();
1618 if cursor.goto_first_child() {
1619 loop {
1620 if cursor.field_name().is_none()
1621 && cursor.node().is_named()
1622 && !cursor.node().is_extra()
1623 {
1624 result.push(cursor.node());
1625 }
1626 if !cursor.goto_next_sibling() {
1627 break;
1628 }
1629 }
1630 }
1631 result
1632 };
1633 let child = if let Some(&c) = non_field_children.first() {
1634 c
1635 } else {
1636 let mut fallback_cursor = node.walk();
1637 let mut fallback_child = None;
1638 if fallback_cursor.goto_first_child() {
1639 loop {
1640 if fallback_cursor.field_name().is_none()
1641 && !fallback_cursor.node().is_extra()
1642 {
1643 fallback_child = Some(fallback_cursor.node());
1644 break;
1645 }
1646 if !fallback_cursor.goto_next_sibling() {
1647 break;
1648 }
1649 }
1650 }
1651 fallback_child.ok_or_else(|| {
1652 ::treesitter_types::ParseError::missing_field("children", node)
1653 })?
1654 };
1655 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1656 },
1657 })
1658 }
1659}
1660impl ::treesitter_types::Spanned for AwaitExpression<'_> {
1661 fn span(&self) -> ::treesitter_types::Span {
1662 self.span
1663 }
1664}
1665#[derive(Debug, Clone)]
1666pub struct BinaryExpression<'tree> {
1667 pub span: ::treesitter_types::Span,
1668 pub left: BinaryExpressionLeft<'tree>,
1669 pub operator: BinaryExpressionOperator,
1670 pub right: Expression<'tree>,
1671}
1672impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
1673 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1674 fn from_node(
1675 node: ::tree_sitter::Node<'tree>,
1676 src: &'tree [u8],
1677 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1678 debug_assert_eq!(node.kind(), "binary_expression");
1679 Ok(Self {
1680 span: ::treesitter_types::Span::from(node),
1681 left: {
1682 let child = node
1683 .child_by_field_name("left")
1684 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
1685 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
1686 },
1687 operator: {
1688 let child = node.child_by_field_name("operator").ok_or_else(|| {
1689 ::treesitter_types::ParseError::missing_field("operator", node)
1690 })?;
1691 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1692 },
1693 right: {
1694 let child = node
1695 .child_by_field_name("right")
1696 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
1697 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1698 },
1699 })
1700 }
1701}
1702impl ::treesitter_types::Spanned for BinaryExpression<'_> {
1703 fn span(&self) -> ::treesitter_types::Span {
1704 self.span
1705 }
1706}
1707#[derive(Debug, Clone)]
1708pub struct BreakStatement<'tree> {
1709 pub span: ::treesitter_types::Span,
1710 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
1711}
1712impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
1713 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1714 fn from_node(
1715 node: ::tree_sitter::Node<'tree>,
1716 src: &'tree [u8],
1717 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1718 debug_assert_eq!(node.kind(), "break_statement");
1719 Ok(Self {
1720 span: ::treesitter_types::Span::from(node),
1721 label: match node.child_by_field_name("label") {
1722 Some(child) => Some(
1723 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
1724 ),
1725 None => None,
1726 },
1727 })
1728 }
1729}
1730impl ::treesitter_types::Spanned for BreakStatement<'_> {
1731 fn span(&self) -> ::treesitter_types::Span {
1732 self.span
1733 }
1734}
1735#[derive(Debug, Clone)]
1736pub struct CallExpression<'tree> {
1737 pub span: ::treesitter_types::Span,
1738 pub arguments: CallExpressionArguments<'tree>,
1739 pub function: CallExpressionFunction<'tree>,
1740 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
1741}
1742impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
1743 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1744 fn from_node(
1745 node: ::tree_sitter::Node<'tree>,
1746 src: &'tree [u8],
1747 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1748 debug_assert_eq!(node.kind(), "call_expression");
1749 Ok(Self {
1750 span: ::treesitter_types::Span::from(node),
1751 arguments: {
1752 let child = node.child_by_field_name("arguments").ok_or_else(|| {
1753 ::treesitter_types::ParseError::missing_field("arguments", node)
1754 })?;
1755 <CallExpressionArguments as ::treesitter_types::FromNode>::from_node(child, src)?
1756 },
1757 function: {
1758 let child = node.child_by_field_name("function").ok_or_else(|| {
1759 ::treesitter_types::ParseError::missing_field("function", node)
1760 })?;
1761 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
1762 },
1763 type_arguments: match node.child_by_field_name("type_arguments") {
1764 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
1765 child, src,
1766 )?),
1767 None => None,
1768 },
1769 })
1770 }
1771}
1772impl ::treesitter_types::Spanned for CallExpression<'_> {
1773 fn span(&self) -> ::treesitter_types::Span {
1774 self.span
1775 }
1776}
1777#[derive(Debug, Clone)]
1778pub struct CallSignature<'tree> {
1779 pub span: ::treesitter_types::Span,
1780 pub parameters: FormalParameters<'tree>,
1781 pub return_type: ::core::option::Option<CallSignatureReturnType<'tree>>,
1782 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1783}
1784impl<'tree> ::treesitter_types::FromNode<'tree> for CallSignature<'tree> {
1785 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1786 fn from_node(
1787 node: ::tree_sitter::Node<'tree>,
1788 src: &'tree [u8],
1789 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1790 debug_assert_eq!(node.kind(), "call_signature");
1791 Ok(Self {
1792 span: ::treesitter_types::Span::from(node),
1793 parameters: {
1794 let child = node.child_by_field_name("parameters").ok_or_else(|| {
1795 ::treesitter_types::ParseError::missing_field("parameters", node)
1796 })?;
1797 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
1798 },
1799 return_type: match node.child_by_field_name("return_type") {
1800 Some(child) => Some(
1801 <CallSignatureReturnType as ::treesitter_types::FromNode>::from_node(
1802 child, src,
1803 )?,
1804 ),
1805 None => None,
1806 },
1807 type_parameters: match node.child_by_field_name("type_parameters") {
1808 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
1809 child, src,
1810 )?),
1811 None => None,
1812 },
1813 })
1814 }
1815}
1816impl ::treesitter_types::Spanned for CallSignature<'_> {
1817 fn span(&self) -> ::treesitter_types::Span {
1818 self.span
1819 }
1820}
1821#[derive(Debug, Clone)]
1822pub struct CatchClause<'tree> {
1823 pub span: ::treesitter_types::Span,
1824 pub body: StatementBlock<'tree>,
1825 pub parameter: ::core::option::Option<CatchClauseParameter<'tree>>,
1826 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
1827}
1828impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1829 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1830 fn from_node(
1831 node: ::tree_sitter::Node<'tree>,
1832 src: &'tree [u8],
1833 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1834 debug_assert_eq!(node.kind(), "catch_clause");
1835 Ok(Self {
1836 span: ::treesitter_types::Span::from(node),
1837 body: {
1838 let child = node
1839 .child_by_field_name("body")
1840 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1841 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
1842 },
1843 parameter: match node.child_by_field_name("parameter") {
1844 Some(child) => Some(
1845 <CatchClauseParameter as ::treesitter_types::FromNode>::from_node(child, src)?,
1846 ),
1847 None => None,
1848 },
1849 r#type: match node.child_by_field_name("type") {
1850 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
1851 child, src,
1852 )?),
1853 None => None,
1854 },
1855 })
1856 }
1857}
1858impl ::treesitter_types::Spanned for CatchClause<'_> {
1859 fn span(&self) -> ::treesitter_types::Span {
1860 self.span
1861 }
1862}
1863#[derive(Debug, Clone)]
1864pub struct Class<'tree> {
1865 pub span: ::treesitter_types::Span,
1866 pub body: ClassBody<'tree>,
1867 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1868 pub name: ::core::option::Option<TypeIdentifier<'tree>>,
1869 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
1870 pub children: ::core::option::Option<ClassHeritage<'tree>>,
1871}
1872impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
1873 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1874 fn from_node(
1875 node: ::tree_sitter::Node<'tree>,
1876 src: &'tree [u8],
1877 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1878 debug_assert_eq!(node.kind(), "class");
1879 Ok(Self {
1880 span: ::treesitter_types::Span::from(node),
1881 body: {
1882 let child = node
1883 .child_by_field_name("body")
1884 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1885 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
1886 },
1887 decorator: {
1888 let mut cursor = node.walk();
1889 let mut items = ::std::vec::Vec::new();
1890 for child in node.children_by_field_name("decorator", &mut cursor) {
1891 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
1892 child, src,
1893 )?);
1894 }
1895 items
1896 },
1897 name: match node.child_by_field_name("name") {
1898 Some(child) => Some(<TypeIdentifier as ::treesitter_types::FromNode>::from_node(
1899 child, src,
1900 )?),
1901 None => None,
1902 },
1903 type_parameters: match node.child_by_field_name("type_parameters") {
1904 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
1905 child, src,
1906 )?),
1907 None => None,
1908 },
1909 children: {
1910 #[allow(clippy::suspicious_else_formatting)]
1911 let non_field_children = {
1912 let mut cursor = node.walk();
1913 let mut result = ::std::vec::Vec::new();
1914 if cursor.goto_first_child() {
1915 loop {
1916 if cursor.field_name().is_none()
1917 && cursor.node().is_named()
1918 && !cursor.node().is_extra()
1919 {
1920 result.push(cursor.node());
1921 }
1922 if !cursor.goto_next_sibling() {
1923 break;
1924 }
1925 }
1926 }
1927 result
1928 };
1929 match non_field_children.first() {
1930 Some(&child) => Some(
1931 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
1932 ),
1933 None => None,
1934 }
1935 },
1936 })
1937 }
1938}
1939impl ::treesitter_types::Spanned for Class<'_> {
1940 fn span(&self) -> ::treesitter_types::Span {
1941 self.span
1942 }
1943}
1944#[derive(Debug, Clone)]
1945pub struct ClassBody<'tree> {
1946 pub span: ::treesitter_types::Span,
1947 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1948 pub children: ::std::vec::Vec<ClassBodyChildren<'tree>>,
1949}
1950impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1951 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1952 fn from_node(
1953 node: ::tree_sitter::Node<'tree>,
1954 src: &'tree [u8],
1955 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1956 debug_assert_eq!(node.kind(), "class_body");
1957 Ok(Self {
1958 span: ::treesitter_types::Span::from(node),
1959 decorator: {
1960 let mut cursor = node.walk();
1961 let mut items = ::std::vec::Vec::new();
1962 for child in node.children_by_field_name("decorator", &mut cursor) {
1963 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
1964 child, src,
1965 )?);
1966 }
1967 items
1968 },
1969 children: {
1970 #[allow(clippy::suspicious_else_formatting)]
1971 let non_field_children = {
1972 let mut cursor = node.walk();
1973 let mut result = ::std::vec::Vec::new();
1974 if cursor.goto_first_child() {
1975 loop {
1976 if cursor.field_name().is_none()
1977 && cursor.node().is_named()
1978 && !cursor.node().is_extra()
1979 {
1980 result.push(cursor.node());
1981 }
1982 if !cursor.goto_next_sibling() {
1983 break;
1984 }
1985 }
1986 }
1987 result
1988 };
1989 let mut items = ::std::vec::Vec::new();
1990 for child in non_field_children {
1991 items.push(
1992 <ClassBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
1993 );
1994 }
1995 items
1996 },
1997 })
1998 }
1999}
2000impl ::treesitter_types::Spanned for ClassBody<'_> {
2001 fn span(&self) -> ::treesitter_types::Span {
2002 self.span
2003 }
2004}
2005#[derive(Debug, Clone)]
2006pub struct ClassDeclaration<'tree> {
2007 pub span: ::treesitter_types::Span,
2008 pub body: ClassBody<'tree>,
2009 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
2010 pub name: TypeIdentifier<'tree>,
2011 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2012 pub children: ::core::option::Option<ClassHeritage<'tree>>,
2013}
2014impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
2015 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2016 fn from_node(
2017 node: ::tree_sitter::Node<'tree>,
2018 src: &'tree [u8],
2019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2020 debug_assert_eq!(node.kind(), "class_declaration");
2021 Ok(Self {
2022 span: ::treesitter_types::Span::from(node),
2023 body: {
2024 let child = node
2025 .child_by_field_name("body")
2026 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2027 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
2028 },
2029 decorator: {
2030 let mut cursor = node.walk();
2031 let mut items = ::std::vec::Vec::new();
2032 for child in node.children_by_field_name("decorator", &mut cursor) {
2033 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
2034 child, src,
2035 )?);
2036 }
2037 items
2038 },
2039 name: {
2040 let child = node
2041 .child_by_field_name("name")
2042 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2043 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
2044 },
2045 type_parameters: match node.child_by_field_name("type_parameters") {
2046 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2047 child, src,
2048 )?),
2049 None => None,
2050 },
2051 children: {
2052 #[allow(clippy::suspicious_else_formatting)]
2053 let non_field_children = {
2054 let mut cursor = node.walk();
2055 let mut result = ::std::vec::Vec::new();
2056 if cursor.goto_first_child() {
2057 loop {
2058 if cursor.field_name().is_none()
2059 && cursor.node().is_named()
2060 && !cursor.node().is_extra()
2061 {
2062 result.push(cursor.node());
2063 }
2064 if !cursor.goto_next_sibling() {
2065 break;
2066 }
2067 }
2068 }
2069 result
2070 };
2071 match non_field_children.first() {
2072 Some(&child) => Some(
2073 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
2074 ),
2075 None => None,
2076 }
2077 },
2078 })
2079 }
2080}
2081impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
2082 fn span(&self) -> ::treesitter_types::Span {
2083 self.span
2084 }
2085}
2086#[derive(Debug, Clone)]
2087pub struct ClassHeritage<'tree> {
2088 pub span: ::treesitter_types::Span,
2089 pub children: ::std::vec::Vec<ClassHeritageChildren<'tree>>,
2090}
2091impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritage<'tree> {
2092 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2093 fn from_node(
2094 node: ::tree_sitter::Node<'tree>,
2095 src: &'tree [u8],
2096 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2097 debug_assert_eq!(node.kind(), "class_heritage");
2098 Ok(Self {
2099 span: ::treesitter_types::Span::from(node),
2100 children: {
2101 #[allow(clippy::suspicious_else_formatting)]
2102 let non_field_children = {
2103 let mut cursor = node.walk();
2104 let mut result = ::std::vec::Vec::new();
2105 if cursor.goto_first_child() {
2106 loop {
2107 if cursor.field_name().is_none()
2108 && cursor.node().is_named()
2109 && !cursor.node().is_extra()
2110 {
2111 result.push(cursor.node());
2112 }
2113 if !cursor.goto_next_sibling() {
2114 break;
2115 }
2116 }
2117 }
2118 result
2119 };
2120 let mut items = ::std::vec::Vec::new();
2121 for child in non_field_children {
2122 items.push(
2123 <ClassHeritageChildren as ::treesitter_types::FromNode>::from_node(
2124 child, src,
2125 )?,
2126 );
2127 }
2128 items
2129 },
2130 })
2131 }
2132}
2133impl ::treesitter_types::Spanned for ClassHeritage<'_> {
2134 fn span(&self) -> ::treesitter_types::Span {
2135 self.span
2136 }
2137}
2138#[derive(Debug, Clone)]
2139pub struct ClassStaticBlock<'tree> {
2140 pub span: ::treesitter_types::Span,
2141 pub body: StatementBlock<'tree>,
2142}
2143impl<'tree> ::treesitter_types::FromNode<'tree> for ClassStaticBlock<'tree> {
2144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2145 fn from_node(
2146 node: ::tree_sitter::Node<'tree>,
2147 src: &'tree [u8],
2148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2149 debug_assert_eq!(node.kind(), "class_static_block");
2150 Ok(Self {
2151 span: ::treesitter_types::Span::from(node),
2152 body: {
2153 let child = node
2154 .child_by_field_name("body")
2155 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2156 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2157 },
2158 })
2159 }
2160}
2161impl ::treesitter_types::Spanned for ClassStaticBlock<'_> {
2162 fn span(&self) -> ::treesitter_types::Span {
2163 self.span
2164 }
2165}
2166#[derive(Debug, Clone)]
2167pub struct ComputedPropertyName<'tree> {
2168 pub span: ::treesitter_types::Span,
2169 pub children: Expression<'tree>,
2170}
2171impl<'tree> ::treesitter_types::FromNode<'tree> for ComputedPropertyName<'tree> {
2172 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2173 fn from_node(
2174 node: ::tree_sitter::Node<'tree>,
2175 src: &'tree [u8],
2176 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2177 debug_assert_eq!(node.kind(), "computed_property_name");
2178 Ok(Self {
2179 span: ::treesitter_types::Span::from(node),
2180 children: {
2181 #[allow(clippy::suspicious_else_formatting)]
2182 let non_field_children = {
2183 let mut cursor = node.walk();
2184 let mut result = ::std::vec::Vec::new();
2185 if cursor.goto_first_child() {
2186 loop {
2187 if cursor.field_name().is_none()
2188 && cursor.node().is_named()
2189 && !cursor.node().is_extra()
2190 {
2191 result.push(cursor.node());
2192 }
2193 if !cursor.goto_next_sibling() {
2194 break;
2195 }
2196 }
2197 }
2198 result
2199 };
2200 let child = if let Some(&c) = non_field_children.first() {
2201 c
2202 } else {
2203 let mut fallback_cursor = node.walk();
2204 let mut fallback_child = None;
2205 if fallback_cursor.goto_first_child() {
2206 loop {
2207 if fallback_cursor.field_name().is_none()
2208 && !fallback_cursor.node().is_extra()
2209 {
2210 fallback_child = Some(fallback_cursor.node());
2211 break;
2212 }
2213 if !fallback_cursor.goto_next_sibling() {
2214 break;
2215 }
2216 }
2217 }
2218 fallback_child.ok_or_else(|| {
2219 ::treesitter_types::ParseError::missing_field("children", node)
2220 })?
2221 };
2222 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2223 },
2224 })
2225 }
2226}
2227impl ::treesitter_types::Spanned for ComputedPropertyName<'_> {
2228 fn span(&self) -> ::treesitter_types::Span {
2229 self.span
2230 }
2231}
2232#[derive(Debug, Clone)]
2233pub struct ConditionalType<'tree> {
2234 pub span: ::treesitter_types::Span,
2235 pub alternative: Type<'tree>,
2236 pub consequence: Type<'tree>,
2237 pub left: Type<'tree>,
2238 pub right: Type<'tree>,
2239}
2240impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalType<'tree> {
2241 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2242 fn from_node(
2243 node: ::tree_sitter::Node<'tree>,
2244 src: &'tree [u8],
2245 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2246 debug_assert_eq!(node.kind(), "conditional_type");
2247 Ok(Self {
2248 span: ::treesitter_types::Span::from(node),
2249 alternative: {
2250 let child = node.child_by_field_name("alternative").ok_or_else(|| {
2251 ::treesitter_types::ParseError::missing_field("alternative", node)
2252 })?;
2253 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2254 },
2255 consequence: {
2256 let child = node.child_by_field_name("consequence").ok_or_else(|| {
2257 ::treesitter_types::ParseError::missing_field("consequence", node)
2258 })?;
2259 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2260 },
2261 left: {
2262 let child = node
2263 .child_by_field_name("left")
2264 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2265 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2266 },
2267 right: {
2268 let child = node
2269 .child_by_field_name("right")
2270 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2271 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2272 },
2273 })
2274 }
2275}
2276impl ::treesitter_types::Spanned for ConditionalType<'_> {
2277 fn span(&self) -> ::treesitter_types::Span {
2278 self.span
2279 }
2280}
2281#[derive(Debug, Clone)]
2282pub struct Constraint<'tree> {
2283 pub span: ::treesitter_types::Span,
2284 pub children: Type<'tree>,
2285}
2286impl<'tree> ::treesitter_types::FromNode<'tree> for Constraint<'tree> {
2287 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2288 fn from_node(
2289 node: ::tree_sitter::Node<'tree>,
2290 src: &'tree [u8],
2291 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2292 debug_assert_eq!(node.kind(), "constraint");
2293 Ok(Self {
2294 span: ::treesitter_types::Span::from(node),
2295 children: {
2296 #[allow(clippy::suspicious_else_formatting)]
2297 let non_field_children = {
2298 let mut cursor = node.walk();
2299 let mut result = ::std::vec::Vec::new();
2300 if cursor.goto_first_child() {
2301 loop {
2302 if cursor.field_name().is_none()
2303 && cursor.node().is_named()
2304 && !cursor.node().is_extra()
2305 {
2306 result.push(cursor.node());
2307 }
2308 if !cursor.goto_next_sibling() {
2309 break;
2310 }
2311 }
2312 }
2313 result
2314 };
2315 let child = if let Some(&c) = non_field_children.first() {
2316 c
2317 } else {
2318 let mut fallback_cursor = node.walk();
2319 let mut fallback_child = None;
2320 if fallback_cursor.goto_first_child() {
2321 loop {
2322 if fallback_cursor.field_name().is_none()
2323 && !fallback_cursor.node().is_extra()
2324 {
2325 fallback_child = Some(fallback_cursor.node());
2326 break;
2327 }
2328 if !fallback_cursor.goto_next_sibling() {
2329 break;
2330 }
2331 }
2332 }
2333 fallback_child.ok_or_else(|| {
2334 ::treesitter_types::ParseError::missing_field("children", node)
2335 })?
2336 };
2337 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2338 },
2339 })
2340 }
2341}
2342impl ::treesitter_types::Spanned for Constraint<'_> {
2343 fn span(&self) -> ::treesitter_types::Span {
2344 self.span
2345 }
2346}
2347#[derive(Debug, Clone)]
2348pub struct ConstructSignature<'tree> {
2349 pub span: ::treesitter_types::Span,
2350 pub parameters: FormalParameters<'tree>,
2351 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
2352 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2353}
2354impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructSignature<'tree> {
2355 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2356 fn from_node(
2357 node: ::tree_sitter::Node<'tree>,
2358 src: &'tree [u8],
2359 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2360 debug_assert_eq!(node.kind(), "construct_signature");
2361 Ok(Self {
2362 span: ::treesitter_types::Span::from(node),
2363 parameters: {
2364 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2365 ::treesitter_types::ParseError::missing_field("parameters", node)
2366 })?;
2367 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2368 },
2369 r#type: match node.child_by_field_name("type") {
2370 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
2371 child, src,
2372 )?),
2373 None => None,
2374 },
2375 type_parameters: match node.child_by_field_name("type_parameters") {
2376 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2377 child, src,
2378 )?),
2379 None => None,
2380 },
2381 })
2382 }
2383}
2384impl ::treesitter_types::Spanned for ConstructSignature<'_> {
2385 fn span(&self) -> ::treesitter_types::Span {
2386 self.span
2387 }
2388}
2389#[derive(Debug, Clone)]
2390pub struct ConstructorType<'tree> {
2391 pub span: ::treesitter_types::Span,
2392 pub parameters: FormalParameters<'tree>,
2393 pub r#type: Type<'tree>,
2394 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
2395}
2396impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorType<'tree> {
2397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2398 fn from_node(
2399 node: ::tree_sitter::Node<'tree>,
2400 src: &'tree [u8],
2401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2402 debug_assert_eq!(node.kind(), "constructor_type");
2403 Ok(Self {
2404 span: ::treesitter_types::Span::from(node),
2405 parameters: {
2406 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2407 ::treesitter_types::ParseError::missing_field("parameters", node)
2408 })?;
2409 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2410 },
2411 r#type: {
2412 let child = node
2413 .child_by_field_name("type")
2414 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
2415 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2416 },
2417 type_parameters: match node.child_by_field_name("type_parameters") {
2418 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
2419 child, src,
2420 )?),
2421 None => None,
2422 },
2423 })
2424 }
2425}
2426impl ::treesitter_types::Spanned for ConstructorType<'_> {
2427 fn span(&self) -> ::treesitter_types::Span {
2428 self.span
2429 }
2430}
2431#[derive(Debug, Clone)]
2432pub struct ContinueStatement<'tree> {
2433 pub span: ::treesitter_types::Span,
2434 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
2435}
2436impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
2437 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2438 fn from_node(
2439 node: ::tree_sitter::Node<'tree>,
2440 src: &'tree [u8],
2441 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2442 debug_assert_eq!(node.kind(), "continue_statement");
2443 Ok(Self {
2444 span: ::treesitter_types::Span::from(node),
2445 label: match node.child_by_field_name("label") {
2446 Some(child) => Some(
2447 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
2448 ),
2449 None => None,
2450 },
2451 })
2452 }
2453}
2454impl ::treesitter_types::Spanned for ContinueStatement<'_> {
2455 fn span(&self) -> ::treesitter_types::Span {
2456 self.span
2457 }
2458}
2459#[derive(Debug, Clone)]
2460pub struct DebuggerStatement<'tree> {
2461 pub span: ::treesitter_types::Span,
2462 text: &'tree str,
2463}
2464impl<'tree> ::treesitter_types::FromNode<'tree> for DebuggerStatement<'tree> {
2465 fn from_node(
2466 node: ::tree_sitter::Node<'tree>,
2467 src: &'tree [u8],
2468 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2469 debug_assert_eq!(node.kind(), "debugger_statement");
2470 Ok(Self {
2471 span: ::treesitter_types::Span::from(node),
2472 text: node.utf8_text(src)?,
2473 })
2474 }
2475}
2476impl<'tree> ::treesitter_types::LeafNode<'tree> for DebuggerStatement<'tree> {
2477 fn text(&self) -> &'tree str {
2478 self.text
2479 }
2480}
2481impl ::treesitter_types::Spanned for DebuggerStatement<'_> {
2482 fn span(&self) -> ::treesitter_types::Span {
2483 self.span
2484 }
2485}
2486#[derive(Debug, Clone)]
2487pub struct Decorator<'tree> {
2488 pub span: ::treesitter_types::Span,
2489 pub children: DecoratorChildren<'tree>,
2490}
2491impl<'tree> ::treesitter_types::FromNode<'tree> for Decorator<'tree> {
2492 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2493 fn from_node(
2494 node: ::tree_sitter::Node<'tree>,
2495 src: &'tree [u8],
2496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2497 debug_assert_eq!(node.kind(), "decorator");
2498 Ok(Self {
2499 span: ::treesitter_types::Span::from(node),
2500 children: {
2501 #[allow(clippy::suspicious_else_formatting)]
2502 let non_field_children = {
2503 let mut cursor = node.walk();
2504 let mut result = ::std::vec::Vec::new();
2505 if cursor.goto_first_child() {
2506 loop {
2507 if cursor.field_name().is_none()
2508 && cursor.node().is_named()
2509 && !cursor.node().is_extra()
2510 {
2511 result.push(cursor.node());
2512 }
2513 if !cursor.goto_next_sibling() {
2514 break;
2515 }
2516 }
2517 }
2518 result
2519 };
2520 let child = if let Some(&c) = non_field_children.first() {
2521 c
2522 } else {
2523 let mut fallback_cursor = node.walk();
2524 let mut fallback_child = None;
2525 if fallback_cursor.goto_first_child() {
2526 loop {
2527 if fallback_cursor.field_name().is_none()
2528 && !fallback_cursor.node().is_extra()
2529 {
2530 fallback_child = Some(fallback_cursor.node());
2531 break;
2532 }
2533 if !fallback_cursor.goto_next_sibling() {
2534 break;
2535 }
2536 }
2537 }
2538 fallback_child.ok_or_else(|| {
2539 ::treesitter_types::ParseError::missing_field("children", node)
2540 })?
2541 };
2542 <DecoratorChildren as ::treesitter_types::FromNode>::from_node(child, src)?
2543 },
2544 })
2545 }
2546}
2547impl ::treesitter_types::Spanned for Decorator<'_> {
2548 fn span(&self) -> ::treesitter_types::Span {
2549 self.span
2550 }
2551}
2552#[derive(Debug, Clone)]
2553pub struct DefaultType<'tree> {
2554 pub span: ::treesitter_types::Span,
2555 pub children: Type<'tree>,
2556}
2557impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultType<'tree> {
2558 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2559 fn from_node(
2560 node: ::tree_sitter::Node<'tree>,
2561 src: &'tree [u8],
2562 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2563 debug_assert_eq!(node.kind(), "default_type");
2564 Ok(Self {
2565 span: ::treesitter_types::Span::from(node),
2566 children: {
2567 #[allow(clippy::suspicious_else_formatting)]
2568 let non_field_children = {
2569 let mut cursor = node.walk();
2570 let mut result = ::std::vec::Vec::new();
2571 if cursor.goto_first_child() {
2572 loop {
2573 if cursor.field_name().is_none()
2574 && cursor.node().is_named()
2575 && !cursor.node().is_extra()
2576 {
2577 result.push(cursor.node());
2578 }
2579 if !cursor.goto_next_sibling() {
2580 break;
2581 }
2582 }
2583 }
2584 result
2585 };
2586 let child = if let Some(&c) = non_field_children.first() {
2587 c
2588 } else {
2589 let mut fallback_cursor = node.walk();
2590 let mut fallback_child = None;
2591 if fallback_cursor.goto_first_child() {
2592 loop {
2593 if fallback_cursor.field_name().is_none()
2594 && !fallback_cursor.node().is_extra()
2595 {
2596 fallback_child = Some(fallback_cursor.node());
2597 break;
2598 }
2599 if !fallback_cursor.goto_next_sibling() {
2600 break;
2601 }
2602 }
2603 }
2604 fallback_child.ok_or_else(|| {
2605 ::treesitter_types::ParseError::missing_field("children", node)
2606 })?
2607 };
2608 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
2609 },
2610 })
2611 }
2612}
2613impl ::treesitter_types::Spanned for DefaultType<'_> {
2614 fn span(&self) -> ::treesitter_types::Span {
2615 self.span
2616 }
2617}
2618#[derive(Debug, Clone)]
2619pub struct DoStatement<'tree> {
2620 pub span: ::treesitter_types::Span,
2621 pub body: Statement<'tree>,
2622 pub condition: ParenthesizedExpression<'tree>,
2623}
2624impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
2625 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2626 fn from_node(
2627 node: ::tree_sitter::Node<'tree>,
2628 src: &'tree [u8],
2629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2630 debug_assert_eq!(node.kind(), "do_statement");
2631 Ok(Self {
2632 span: ::treesitter_types::Span::from(node),
2633 body: {
2634 let child = node
2635 .child_by_field_name("body")
2636 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2637 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2638 },
2639 condition: {
2640 let child = node.child_by_field_name("condition").ok_or_else(|| {
2641 ::treesitter_types::ParseError::missing_field("condition", node)
2642 })?;
2643 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2644 },
2645 })
2646 }
2647}
2648impl ::treesitter_types::Spanned for DoStatement<'_> {
2649 fn span(&self) -> ::treesitter_types::Span {
2650 self.span
2651 }
2652}
2653#[derive(Debug, Clone)]
2654pub struct ElseClause<'tree> {
2655 pub span: ::treesitter_types::Span,
2656 pub children: Statement<'tree>,
2657}
2658impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
2659 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2660 fn from_node(
2661 node: ::tree_sitter::Node<'tree>,
2662 src: &'tree [u8],
2663 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2664 debug_assert_eq!(node.kind(), "else_clause");
2665 Ok(Self {
2666 span: ::treesitter_types::Span::from(node),
2667 children: {
2668 #[allow(clippy::suspicious_else_formatting)]
2669 let non_field_children = {
2670 let mut cursor = node.walk();
2671 let mut result = ::std::vec::Vec::new();
2672 if cursor.goto_first_child() {
2673 loop {
2674 if cursor.field_name().is_none()
2675 && cursor.node().is_named()
2676 && !cursor.node().is_extra()
2677 {
2678 result.push(cursor.node());
2679 }
2680 if !cursor.goto_next_sibling() {
2681 break;
2682 }
2683 }
2684 }
2685 result
2686 };
2687 let child = if let Some(&c) = non_field_children.first() {
2688 c
2689 } else {
2690 let mut fallback_cursor = node.walk();
2691 let mut fallback_child = None;
2692 if fallback_cursor.goto_first_child() {
2693 loop {
2694 if fallback_cursor.field_name().is_none()
2695 && !fallback_cursor.node().is_extra()
2696 {
2697 fallback_child = Some(fallback_cursor.node());
2698 break;
2699 }
2700 if !fallback_cursor.goto_next_sibling() {
2701 break;
2702 }
2703 }
2704 }
2705 fallback_child.ok_or_else(|| {
2706 ::treesitter_types::ParseError::missing_field("children", node)
2707 })?
2708 };
2709 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2710 },
2711 })
2712 }
2713}
2714impl ::treesitter_types::Spanned for ElseClause<'_> {
2715 fn span(&self) -> ::treesitter_types::Span {
2716 self.span
2717 }
2718}
2719#[derive(Debug, Clone)]
2720pub struct EmptyStatement<'tree> {
2721 pub span: ::treesitter_types::Span,
2722 text: &'tree str,
2723}
2724impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
2725 fn from_node(
2726 node: ::tree_sitter::Node<'tree>,
2727 src: &'tree [u8],
2728 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2729 debug_assert_eq!(node.kind(), "empty_statement");
2730 Ok(Self {
2731 span: ::treesitter_types::Span::from(node),
2732 text: node.utf8_text(src)?,
2733 })
2734 }
2735}
2736impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
2737 fn text(&self) -> &'tree str {
2738 self.text
2739 }
2740}
2741impl ::treesitter_types::Spanned for EmptyStatement<'_> {
2742 fn span(&self) -> ::treesitter_types::Span {
2743 self.span
2744 }
2745}
2746#[derive(Debug, Clone)]
2747pub struct EnumAssignment<'tree> {
2748 pub span: ::treesitter_types::Span,
2749 pub name: EnumAssignmentName<'tree>,
2750 pub value: Expression<'tree>,
2751}
2752impl<'tree> ::treesitter_types::FromNode<'tree> for EnumAssignment<'tree> {
2753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2754 fn from_node(
2755 node: ::tree_sitter::Node<'tree>,
2756 src: &'tree [u8],
2757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2758 debug_assert_eq!(node.kind(), "enum_assignment");
2759 Ok(Self {
2760 span: ::treesitter_types::Span::from(node),
2761 name: {
2762 let child = node
2763 .child_by_field_name("name")
2764 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2765 <EnumAssignmentName as ::treesitter_types::FromNode>::from_node(child, src)?
2766 },
2767 value: {
2768 let child = node
2769 .child_by_field_name("value")
2770 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
2771 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
2772 },
2773 })
2774 }
2775}
2776impl ::treesitter_types::Spanned for EnumAssignment<'_> {
2777 fn span(&self) -> ::treesitter_types::Span {
2778 self.span
2779 }
2780}
2781#[derive(Debug, Clone)]
2782pub struct EnumBody<'tree> {
2783 pub span: ::treesitter_types::Span,
2784 pub name: ::std::vec::Vec<EnumBodyName<'tree>>,
2785 pub children: ::std::vec::Vec<EnumAssignment<'tree>>,
2786}
2787impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBody<'tree> {
2788 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2789 fn from_node(
2790 node: ::tree_sitter::Node<'tree>,
2791 src: &'tree [u8],
2792 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2793 debug_assert_eq!(node.kind(), "enum_body");
2794 Ok(Self {
2795 span: ::treesitter_types::Span::from(node),
2796 name: {
2797 let mut cursor = node.walk();
2798 let mut items = ::std::vec::Vec::new();
2799 for child in node.children_by_field_name("name", &mut cursor) {
2800 items.push(<EnumBodyName as ::treesitter_types::FromNode>::from_node(
2801 child, src,
2802 )?);
2803 }
2804 items
2805 },
2806 children: {
2807 #[allow(clippy::suspicious_else_formatting)]
2808 let non_field_children = {
2809 let mut cursor = node.walk();
2810 let mut result = ::std::vec::Vec::new();
2811 if cursor.goto_first_child() {
2812 loop {
2813 if cursor.field_name().is_none()
2814 && cursor.node().is_named()
2815 && !cursor.node().is_extra()
2816 {
2817 result.push(cursor.node());
2818 }
2819 if !cursor.goto_next_sibling() {
2820 break;
2821 }
2822 }
2823 }
2824 result
2825 };
2826 let mut items = ::std::vec::Vec::new();
2827 for child in non_field_children {
2828 items.push(<EnumAssignment as ::treesitter_types::FromNode>::from_node(
2829 child, src,
2830 )?);
2831 }
2832 items
2833 },
2834 })
2835 }
2836}
2837impl ::treesitter_types::Spanned for EnumBody<'_> {
2838 fn span(&self) -> ::treesitter_types::Span {
2839 self.span
2840 }
2841}
2842#[derive(Debug, Clone)]
2843pub struct EnumDeclaration<'tree> {
2844 pub span: ::treesitter_types::Span,
2845 pub body: EnumBody<'tree>,
2846 pub name: Identifier<'tree>,
2847}
2848impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
2849 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2850 fn from_node(
2851 node: ::tree_sitter::Node<'tree>,
2852 src: &'tree [u8],
2853 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2854 debug_assert_eq!(node.kind(), "enum_declaration");
2855 Ok(Self {
2856 span: ::treesitter_types::Span::from(node),
2857 body: {
2858 let child = node
2859 .child_by_field_name("body")
2860 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2861 <EnumBody as ::treesitter_types::FromNode>::from_node(child, src)?
2862 },
2863 name: {
2864 let child = node
2865 .child_by_field_name("name")
2866 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2867 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2868 },
2869 })
2870 }
2871}
2872impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
2873 fn span(&self) -> ::treesitter_types::Span {
2874 self.span
2875 }
2876}
2877#[derive(Debug, Clone)]
2878pub struct ExistentialType<'tree> {
2879 pub span: ::treesitter_types::Span,
2880 text: &'tree str,
2881}
2882impl<'tree> ::treesitter_types::FromNode<'tree> for ExistentialType<'tree> {
2883 fn from_node(
2884 node: ::tree_sitter::Node<'tree>,
2885 src: &'tree [u8],
2886 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2887 debug_assert_eq!(node.kind(), "existential_type");
2888 Ok(Self {
2889 span: ::treesitter_types::Span::from(node),
2890 text: node.utf8_text(src)?,
2891 })
2892 }
2893}
2894impl<'tree> ::treesitter_types::LeafNode<'tree> for ExistentialType<'tree> {
2895 fn text(&self) -> &'tree str {
2896 self.text
2897 }
2898}
2899impl ::treesitter_types::Spanned for ExistentialType<'_> {
2900 fn span(&self) -> ::treesitter_types::Span {
2901 self.span
2902 }
2903}
2904#[derive(Debug, Clone)]
2905pub struct ExportClause<'tree> {
2906 pub span: ::treesitter_types::Span,
2907 pub children: ::std::vec::Vec<ExportSpecifier<'tree>>,
2908}
2909impl<'tree> ::treesitter_types::FromNode<'tree> for ExportClause<'tree> {
2910 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2911 fn from_node(
2912 node: ::tree_sitter::Node<'tree>,
2913 src: &'tree [u8],
2914 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2915 debug_assert_eq!(node.kind(), "export_clause");
2916 Ok(Self {
2917 span: ::treesitter_types::Span::from(node),
2918 children: {
2919 #[allow(clippy::suspicious_else_formatting)]
2920 let non_field_children = {
2921 let mut cursor = node.walk();
2922 let mut result = ::std::vec::Vec::new();
2923 if cursor.goto_first_child() {
2924 loop {
2925 if cursor.field_name().is_none()
2926 && cursor.node().is_named()
2927 && !cursor.node().is_extra()
2928 {
2929 result.push(cursor.node());
2930 }
2931 if !cursor.goto_next_sibling() {
2932 break;
2933 }
2934 }
2935 }
2936 result
2937 };
2938 let mut items = ::std::vec::Vec::new();
2939 for child in non_field_children {
2940 items.push(
2941 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
2942 );
2943 }
2944 items
2945 },
2946 })
2947 }
2948}
2949impl ::treesitter_types::Spanned for ExportClause<'_> {
2950 fn span(&self) -> ::treesitter_types::Span {
2951 self.span
2952 }
2953}
2954#[derive(Debug, Clone)]
2955pub struct ExportSpecifier<'tree> {
2956 pub span: ::treesitter_types::Span,
2957 pub alias: ::core::option::Option<ExportSpecifierAlias<'tree>>,
2958 pub name: ExportSpecifierName<'tree>,
2959}
2960impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifier<'tree> {
2961 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2962 fn from_node(
2963 node: ::tree_sitter::Node<'tree>,
2964 src: &'tree [u8],
2965 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2966 debug_assert_eq!(node.kind(), "export_specifier");
2967 Ok(Self {
2968 span: ::treesitter_types::Span::from(node),
2969 alias: match node.child_by_field_name("alias") {
2970 Some(child) => Some(
2971 <ExportSpecifierAlias as ::treesitter_types::FromNode>::from_node(child, src)?,
2972 ),
2973 None => None,
2974 },
2975 name: {
2976 let child = node
2977 .child_by_field_name("name")
2978 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2979 <ExportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
2980 },
2981 })
2982 }
2983}
2984impl ::treesitter_types::Spanned for ExportSpecifier<'_> {
2985 fn span(&self) -> ::treesitter_types::Span {
2986 self.span
2987 }
2988}
2989#[derive(Debug, Clone)]
2990pub struct ExportStatement<'tree> {
2991 pub span: ::treesitter_types::Span,
2992 pub declaration: ::core::option::Option<Declaration<'tree>>,
2993 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
2994 pub source: ::core::option::Option<String<'tree>>,
2995 pub value: ::core::option::Option<Expression<'tree>>,
2996 pub children: ::core::option::Option<ExportStatementChildren<'tree>>,
2997}
2998impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatement<'tree> {
2999 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3000 fn from_node(
3001 node: ::tree_sitter::Node<'tree>,
3002 src: &'tree [u8],
3003 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3004 debug_assert_eq!(node.kind(), "export_statement");
3005 Ok(Self {
3006 span: ::treesitter_types::Span::from(node),
3007 declaration: match node.child_by_field_name("declaration") {
3008 Some(child) => Some(<Declaration as ::treesitter_types::FromNode>::from_node(
3009 child, src,
3010 )?),
3011 None => None,
3012 },
3013 decorator: {
3014 let mut cursor = node.walk();
3015 let mut items = ::std::vec::Vec::new();
3016 for child in node.children_by_field_name("decorator", &mut cursor) {
3017 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
3018 child, src,
3019 )?);
3020 }
3021 items
3022 },
3023 source: match node.child_by_field_name("source") {
3024 Some(child) => Some(<String as ::treesitter_types::FromNode>::from_node(
3025 child, src,
3026 )?),
3027 None => None,
3028 },
3029 value: match node.child_by_field_name("value") {
3030 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3031 child, src,
3032 )?),
3033 None => None,
3034 },
3035 children: {
3036 #[allow(clippy::suspicious_else_formatting)]
3037 let non_field_children = {
3038 let mut cursor = node.walk();
3039 let mut result = ::std::vec::Vec::new();
3040 if cursor.goto_first_child() {
3041 loop {
3042 if cursor.field_name().is_none()
3043 && cursor.node().is_named()
3044 && !cursor.node().is_extra()
3045 {
3046 result.push(cursor.node());
3047 }
3048 if !cursor.goto_next_sibling() {
3049 break;
3050 }
3051 }
3052 }
3053 result
3054 };
3055 match non_field_children.first() {
3056 Some(&child) => Some(
3057 <ExportStatementChildren as ::treesitter_types::FromNode>::from_node(
3058 child, src,
3059 )?,
3060 ),
3061 None => None,
3062 }
3063 },
3064 })
3065 }
3066}
3067impl ::treesitter_types::Spanned for ExportStatement<'_> {
3068 fn span(&self) -> ::treesitter_types::Span {
3069 self.span
3070 }
3071}
3072#[derive(Debug, Clone)]
3073pub struct ExpressionStatement<'tree> {
3074 pub span: ::treesitter_types::Span,
3075 pub children: ExpressionStatementChildren<'tree>,
3076}
3077impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
3078 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3079 fn from_node(
3080 node: ::tree_sitter::Node<'tree>,
3081 src: &'tree [u8],
3082 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3083 debug_assert_eq!(node.kind(), "expression_statement");
3084 Ok(Self {
3085 span: ::treesitter_types::Span::from(node),
3086 children: {
3087 #[allow(clippy::suspicious_else_formatting)]
3088 let non_field_children = {
3089 let mut cursor = node.walk();
3090 let mut result = ::std::vec::Vec::new();
3091 if cursor.goto_first_child() {
3092 loop {
3093 if cursor.field_name().is_none()
3094 && cursor.node().is_named()
3095 && !cursor.node().is_extra()
3096 {
3097 result.push(cursor.node());
3098 }
3099 if !cursor.goto_next_sibling() {
3100 break;
3101 }
3102 }
3103 }
3104 result
3105 };
3106 let child = if let Some(&c) = non_field_children.first() {
3107 c
3108 } else {
3109 let mut fallback_cursor = node.walk();
3110 let mut fallback_child = None;
3111 if fallback_cursor.goto_first_child() {
3112 loop {
3113 if fallback_cursor.field_name().is_none()
3114 && !fallback_cursor.node().is_extra()
3115 {
3116 fallback_child = Some(fallback_cursor.node());
3117 break;
3118 }
3119 if !fallback_cursor.goto_next_sibling() {
3120 break;
3121 }
3122 }
3123 }
3124 fallback_child.ok_or_else(|| {
3125 ::treesitter_types::ParseError::missing_field("children", node)
3126 })?
3127 };
3128 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
3129 child, src,
3130 )?
3131 },
3132 })
3133 }
3134}
3135impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
3136 fn span(&self) -> ::treesitter_types::Span {
3137 self.span
3138 }
3139}
3140#[derive(Debug, Clone)]
3141pub struct ExtendsClause<'tree> {
3142 pub span: ::treesitter_types::Span,
3143 pub type_arguments: ::std::vec::Vec<TypeArguments<'tree>>,
3144 pub value: ::std::vec::Vec<Expression<'tree>>,
3145}
3146impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsClause<'tree> {
3147 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3148 fn from_node(
3149 node: ::tree_sitter::Node<'tree>,
3150 src: &'tree [u8],
3151 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3152 debug_assert_eq!(node.kind(), "extends_clause");
3153 Ok(Self {
3154 span: ::treesitter_types::Span::from(node),
3155 type_arguments: {
3156 let mut cursor = node.walk();
3157 let mut items = ::std::vec::Vec::new();
3158 for child in node.children_by_field_name("type_arguments", &mut cursor) {
3159 items.push(<TypeArguments as ::treesitter_types::FromNode>::from_node(
3160 child, src,
3161 )?);
3162 }
3163 items
3164 },
3165 value: {
3166 let mut cursor = node.walk();
3167 let mut items = ::std::vec::Vec::new();
3168 for child in node.children_by_field_name("value", &mut cursor) {
3169 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
3170 child, src,
3171 )?);
3172 }
3173 items
3174 },
3175 })
3176 }
3177}
3178impl ::treesitter_types::Spanned for ExtendsClause<'_> {
3179 fn span(&self) -> ::treesitter_types::Span {
3180 self.span
3181 }
3182}
3183#[derive(Debug, Clone)]
3184pub struct ExtendsTypeClause<'tree> {
3185 pub span: ::treesitter_types::Span,
3186 pub r#type: ::std::vec::Vec<ExtendsTypeClauseType<'tree>>,
3187}
3188impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsTypeClause<'tree> {
3189 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3190 fn from_node(
3191 node: ::tree_sitter::Node<'tree>,
3192 src: &'tree [u8],
3193 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3194 debug_assert_eq!(node.kind(), "extends_type_clause");
3195 Ok(Self {
3196 span: ::treesitter_types::Span::from(node),
3197 r#type: {
3198 let mut cursor = node.walk();
3199 let mut items = ::std::vec::Vec::new();
3200 for child in node.children_by_field_name("type", &mut cursor) {
3201 items.push(
3202 <ExtendsTypeClauseType as ::treesitter_types::FromNode>::from_node(
3203 child, src,
3204 )?,
3205 );
3206 }
3207 items
3208 },
3209 })
3210 }
3211}
3212impl ::treesitter_types::Spanned for ExtendsTypeClause<'_> {
3213 fn span(&self) -> ::treesitter_types::Span {
3214 self.span
3215 }
3216}
3217#[derive(Debug, Clone)]
3218pub struct FinallyClause<'tree> {
3219 pub span: ::treesitter_types::Span,
3220 pub body: StatementBlock<'tree>,
3221}
3222impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
3223 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3224 fn from_node(
3225 node: ::tree_sitter::Node<'tree>,
3226 src: &'tree [u8],
3227 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3228 debug_assert_eq!(node.kind(), "finally_clause");
3229 Ok(Self {
3230 span: ::treesitter_types::Span::from(node),
3231 body: {
3232 let child = node
3233 .child_by_field_name("body")
3234 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3235 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3236 },
3237 })
3238 }
3239}
3240impl ::treesitter_types::Spanned for FinallyClause<'_> {
3241 fn span(&self) -> ::treesitter_types::Span {
3242 self.span
3243 }
3244}
3245#[derive(Debug, Clone)]
3246pub struct FlowMaybeType<'tree> {
3247 pub span: ::treesitter_types::Span,
3248 pub children: PrimaryType<'tree>,
3249}
3250impl<'tree> ::treesitter_types::FromNode<'tree> for FlowMaybeType<'tree> {
3251 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3252 fn from_node(
3253 node: ::tree_sitter::Node<'tree>,
3254 src: &'tree [u8],
3255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3256 debug_assert_eq!(node.kind(), "flow_maybe_type");
3257 Ok(Self {
3258 span: ::treesitter_types::Span::from(node),
3259 children: {
3260 #[allow(clippy::suspicious_else_formatting)]
3261 let non_field_children = {
3262 let mut cursor = node.walk();
3263 let mut result = ::std::vec::Vec::new();
3264 if cursor.goto_first_child() {
3265 loop {
3266 if cursor.field_name().is_none()
3267 && cursor.node().is_named()
3268 && !cursor.node().is_extra()
3269 {
3270 result.push(cursor.node());
3271 }
3272 if !cursor.goto_next_sibling() {
3273 break;
3274 }
3275 }
3276 }
3277 result
3278 };
3279 let child = if let Some(&c) = non_field_children.first() {
3280 c
3281 } else {
3282 let mut fallback_cursor = node.walk();
3283 let mut fallback_child = None;
3284 if fallback_cursor.goto_first_child() {
3285 loop {
3286 if fallback_cursor.field_name().is_none()
3287 && !fallback_cursor.node().is_extra()
3288 {
3289 fallback_child = Some(fallback_cursor.node());
3290 break;
3291 }
3292 if !fallback_cursor.goto_next_sibling() {
3293 break;
3294 }
3295 }
3296 }
3297 fallback_child.ok_or_else(|| {
3298 ::treesitter_types::ParseError::missing_field("children", node)
3299 })?
3300 };
3301 <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
3302 },
3303 })
3304 }
3305}
3306impl ::treesitter_types::Spanned for FlowMaybeType<'_> {
3307 fn span(&self) -> ::treesitter_types::Span {
3308 self.span
3309 }
3310}
3311#[derive(Debug, Clone)]
3312pub struct ForInStatement<'tree> {
3313 pub span: ::treesitter_types::Span,
3314 pub body: Statement<'tree>,
3315 pub kind: ::core::option::Option<ForInStatementKind>,
3316 pub left: ForInStatementLeft<'tree>,
3317 pub operator: ForInStatementOperator,
3318 pub right: ForInStatementRight<'tree>,
3319 pub value: ::core::option::Option<Expression<'tree>>,
3320}
3321impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatement<'tree> {
3322 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3323 fn from_node(
3324 node: ::tree_sitter::Node<'tree>,
3325 src: &'tree [u8],
3326 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3327 debug_assert_eq!(node.kind(), "for_in_statement");
3328 Ok(Self {
3329 span: ::treesitter_types::Span::from(node),
3330 body: {
3331 let child = node
3332 .child_by_field_name("body")
3333 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3334 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3335 },
3336 kind: match node.child_by_field_name("kind") {
3337 Some(child) => Some(
3338 <ForInStatementKind as ::treesitter_types::FromNode>::from_node(child, src)?,
3339 ),
3340 None => None,
3341 },
3342 left: {
3343 let child = node
3344 .child_by_field_name("left")
3345 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
3346 <ForInStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)?
3347 },
3348 operator: {
3349 let child = node.child_by_field_name("operator").ok_or_else(|| {
3350 ::treesitter_types::ParseError::missing_field("operator", node)
3351 })?;
3352 <ForInStatementOperator as ::treesitter_types::FromNode>::from_node(child, src)?
3353 },
3354 right: {
3355 let child = node
3356 .child_by_field_name("right")
3357 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
3358 <ForInStatementRight as ::treesitter_types::FromNode>::from_node(child, src)?
3359 },
3360 value: match node.child_by_field_name("value") {
3361 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
3362 child, src,
3363 )?),
3364 None => None,
3365 },
3366 })
3367 }
3368}
3369impl ::treesitter_types::Spanned for ForInStatement<'_> {
3370 fn span(&self) -> ::treesitter_types::Span {
3371 self.span
3372 }
3373}
3374#[derive(Debug, Clone)]
3375pub struct ForStatement<'tree> {
3376 pub span: ::treesitter_types::Span,
3377 pub body: Statement<'tree>,
3378 pub condition: ::std::vec::Vec<ForStatementCondition<'tree>>,
3379 pub increment: ::core::option::Option<ForStatementIncrement<'tree>>,
3380 pub initializer: ForStatementInitializer<'tree>,
3381}
3382impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
3383 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3384 fn from_node(
3385 node: ::tree_sitter::Node<'tree>,
3386 src: &'tree [u8],
3387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3388 debug_assert_eq!(node.kind(), "for_statement");
3389 Ok(Self {
3390 span: ::treesitter_types::Span::from(node),
3391 body: {
3392 let child = node
3393 .child_by_field_name("body")
3394 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3395 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3396 },
3397 condition: {
3398 let mut cursor = node.walk();
3399 let mut items = ::std::vec::Vec::new();
3400 for child in node.children_by_field_name("condition", &mut cursor) {
3401 items.push(
3402 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(
3403 child, src,
3404 )?,
3405 );
3406 }
3407 items
3408 },
3409 increment: match node.child_by_field_name("increment") {
3410 Some(child) => Some(
3411 <ForStatementIncrement as ::treesitter_types::FromNode>::from_node(child, src)?,
3412 ),
3413 None => None,
3414 },
3415 initializer: {
3416 let child = node.child_by_field_name("initializer").ok_or_else(|| {
3417 ::treesitter_types::ParseError::missing_field("initializer", node)
3418 })?;
3419 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)?
3420 },
3421 })
3422 }
3423}
3424impl ::treesitter_types::Spanned for ForStatement<'_> {
3425 fn span(&self) -> ::treesitter_types::Span {
3426 self.span
3427 }
3428}
3429#[derive(Debug, Clone)]
3430pub struct FormalParameters<'tree> {
3431 pub span: ::treesitter_types::Span,
3432 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
3433}
3434impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
3435 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3436 fn from_node(
3437 node: ::tree_sitter::Node<'tree>,
3438 src: &'tree [u8],
3439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3440 debug_assert_eq!(node.kind(), "formal_parameters");
3441 Ok(Self {
3442 span: ::treesitter_types::Span::from(node),
3443 children: {
3444 #[allow(clippy::suspicious_else_formatting)]
3445 let non_field_children = {
3446 let mut cursor = node.walk();
3447 let mut result = ::std::vec::Vec::new();
3448 if cursor.goto_first_child() {
3449 loop {
3450 if cursor.field_name().is_none()
3451 && cursor.node().is_named()
3452 && !cursor.node().is_extra()
3453 {
3454 result.push(cursor.node());
3455 }
3456 if !cursor.goto_next_sibling() {
3457 break;
3458 }
3459 }
3460 }
3461 result
3462 };
3463 let mut items = ::std::vec::Vec::new();
3464 for child in non_field_children {
3465 items.push(
3466 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
3467 child, src,
3468 )?,
3469 );
3470 }
3471 items
3472 },
3473 })
3474 }
3475}
3476impl ::treesitter_types::Spanned for FormalParameters<'_> {
3477 fn span(&self) -> ::treesitter_types::Span {
3478 self.span
3479 }
3480}
3481#[derive(Debug, Clone)]
3482pub struct FunctionDeclaration<'tree> {
3483 pub span: ::treesitter_types::Span,
3484 pub body: StatementBlock<'tree>,
3485 pub name: Identifier<'tree>,
3486 pub parameters: FormalParameters<'tree>,
3487 pub return_type: ::core::option::Option<FunctionDeclarationReturnType<'tree>>,
3488 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3489}
3490impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
3491 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3492 fn from_node(
3493 node: ::tree_sitter::Node<'tree>,
3494 src: &'tree [u8],
3495 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3496 debug_assert_eq!(node.kind(), "function_declaration");
3497 Ok(Self {
3498 span: ::treesitter_types::Span::from(node),
3499 body: {
3500 let child = node
3501 .child_by_field_name("body")
3502 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3503 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3504 },
3505 name: {
3506 let child = node
3507 .child_by_field_name("name")
3508 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3509 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3510 },
3511 parameters: {
3512 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3513 ::treesitter_types::ParseError::missing_field("parameters", node)
3514 })?;
3515 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3516 },
3517 return_type: match node.child_by_field_name("return_type") {
3518 Some(child) => Some(
3519 <FunctionDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
3520 child, src,
3521 )?,
3522 ),
3523 None => None,
3524 },
3525 type_parameters: match node.child_by_field_name("type_parameters") {
3526 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3527 child, src,
3528 )?),
3529 None => None,
3530 },
3531 })
3532 }
3533}
3534impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
3535 fn span(&self) -> ::treesitter_types::Span {
3536 self.span
3537 }
3538}
3539#[derive(Debug, Clone)]
3540pub struct FunctionExpression<'tree> {
3541 pub span: ::treesitter_types::Span,
3542 pub body: StatementBlock<'tree>,
3543 pub name: ::core::option::Option<Identifier<'tree>>,
3544 pub parameters: FormalParameters<'tree>,
3545 pub return_type: ::core::option::Option<FunctionExpressionReturnType<'tree>>,
3546 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3547}
3548impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpression<'tree> {
3549 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3550 fn from_node(
3551 node: ::tree_sitter::Node<'tree>,
3552 src: &'tree [u8],
3553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3554 debug_assert_eq!(node.kind(), "function_expression");
3555 Ok(Self {
3556 span: ::treesitter_types::Span::from(node),
3557 body: {
3558 let child = node
3559 .child_by_field_name("body")
3560 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3561 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3562 },
3563 name: match node.child_by_field_name("name") {
3564 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
3565 child, src,
3566 )?),
3567 None => None,
3568 },
3569 parameters: {
3570 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3571 ::treesitter_types::ParseError::missing_field("parameters", node)
3572 })?;
3573 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3574 },
3575 return_type: match node.child_by_field_name("return_type") {
3576 Some(child) => Some(
3577 <FunctionExpressionReturnType as ::treesitter_types::FromNode>::from_node(
3578 child, src,
3579 )?,
3580 ),
3581 None => None,
3582 },
3583 type_parameters: match node.child_by_field_name("type_parameters") {
3584 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3585 child, src,
3586 )?),
3587 None => None,
3588 },
3589 })
3590 }
3591}
3592impl ::treesitter_types::Spanned for FunctionExpression<'_> {
3593 fn span(&self) -> ::treesitter_types::Span {
3594 self.span
3595 }
3596}
3597#[derive(Debug, Clone)]
3598pub struct FunctionSignature<'tree> {
3599 pub span: ::treesitter_types::Span,
3600 pub name: Identifier<'tree>,
3601 pub parameters: FormalParameters<'tree>,
3602 pub return_type: ::core::option::Option<FunctionSignatureReturnType<'tree>>,
3603 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3604}
3605impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignature<'tree> {
3606 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3607 fn from_node(
3608 node: ::tree_sitter::Node<'tree>,
3609 src: &'tree [u8],
3610 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3611 debug_assert_eq!(node.kind(), "function_signature");
3612 Ok(Self {
3613 span: ::treesitter_types::Span::from(node),
3614 name: {
3615 let child = node
3616 .child_by_field_name("name")
3617 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3618 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3619 },
3620 parameters: {
3621 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3622 ::treesitter_types::ParseError::missing_field("parameters", node)
3623 })?;
3624 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3625 },
3626 return_type: match node.child_by_field_name("return_type") {
3627 Some(child) => Some(
3628 <FunctionSignatureReturnType as ::treesitter_types::FromNode>::from_node(
3629 child, src,
3630 )?,
3631 ),
3632 None => None,
3633 },
3634 type_parameters: match node.child_by_field_name("type_parameters") {
3635 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3636 child, src,
3637 )?),
3638 None => None,
3639 },
3640 })
3641 }
3642}
3643impl ::treesitter_types::Spanned for FunctionSignature<'_> {
3644 fn span(&self) -> ::treesitter_types::Span {
3645 self.span
3646 }
3647}
3648#[derive(Debug, Clone)]
3649pub struct FunctionType<'tree> {
3650 pub span: ::treesitter_types::Span,
3651 pub parameters: FormalParameters<'tree>,
3652 pub return_type: FunctionTypeReturnType<'tree>,
3653 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3654}
3655impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
3656 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3657 fn from_node(
3658 node: ::tree_sitter::Node<'tree>,
3659 src: &'tree [u8],
3660 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3661 debug_assert_eq!(node.kind(), "function_type");
3662 Ok(Self {
3663 span: ::treesitter_types::Span::from(node),
3664 parameters: {
3665 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3666 ::treesitter_types::ParseError::missing_field("parameters", node)
3667 })?;
3668 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3669 },
3670 return_type: {
3671 let child = node.child_by_field_name("return_type").ok_or_else(|| {
3672 ::treesitter_types::ParseError::missing_field("return_type", node)
3673 })?;
3674 <FunctionTypeReturnType as ::treesitter_types::FromNode>::from_node(child, src)?
3675 },
3676 type_parameters: match node.child_by_field_name("type_parameters") {
3677 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3678 child, src,
3679 )?),
3680 None => None,
3681 },
3682 })
3683 }
3684}
3685impl ::treesitter_types::Spanned for FunctionType<'_> {
3686 fn span(&self) -> ::treesitter_types::Span {
3687 self.span
3688 }
3689}
3690#[derive(Debug, Clone)]
3691pub struct GeneratorFunction<'tree> {
3692 pub span: ::treesitter_types::Span,
3693 pub body: StatementBlock<'tree>,
3694 pub name: ::core::option::Option<Identifier<'tree>>,
3695 pub parameters: FormalParameters<'tree>,
3696 pub return_type: ::core::option::Option<GeneratorFunctionReturnType<'tree>>,
3697 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3698}
3699impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunction<'tree> {
3700 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3701 fn from_node(
3702 node: ::tree_sitter::Node<'tree>,
3703 src: &'tree [u8],
3704 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3705 debug_assert_eq!(node.kind(), "generator_function");
3706 Ok(Self {
3707 span: ::treesitter_types::Span::from(node),
3708 body: {
3709 let child = node
3710 .child_by_field_name("body")
3711 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3712 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3713 },
3714 name: match node.child_by_field_name("name") {
3715 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
3716 child, src,
3717 )?),
3718 None => None,
3719 },
3720 parameters: {
3721 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3722 ::treesitter_types::ParseError::missing_field("parameters", node)
3723 })?;
3724 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3725 },
3726 return_type: match node.child_by_field_name("return_type") {
3727 Some(child) => Some(
3728 <GeneratorFunctionReturnType as ::treesitter_types::FromNode>::from_node(
3729 child, src,
3730 )?,
3731 ),
3732 None => None,
3733 },
3734 type_parameters: match node.child_by_field_name("type_parameters") {
3735 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
3736 child, src,
3737 )?),
3738 None => None,
3739 },
3740 })
3741 }
3742}
3743impl ::treesitter_types::Spanned for GeneratorFunction<'_> {
3744 fn span(&self) -> ::treesitter_types::Span {
3745 self.span
3746 }
3747}
3748#[derive(Debug, Clone)]
3749pub struct GeneratorFunctionDeclaration<'tree> {
3750 pub span: ::treesitter_types::Span,
3751 pub body: StatementBlock<'tree>,
3752 pub name: Identifier<'tree>,
3753 pub parameters: FormalParameters<'tree>,
3754 pub return_type: ::core::option::Option<GeneratorFunctionDeclarationReturnType<'tree>>,
3755 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
3756}
3757impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclaration<'tree> {
3758 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3759 fn from_node(
3760 node: ::tree_sitter::Node<'tree>,
3761 src: &'tree [u8],
3762 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3763 debug_assert_eq!(node.kind(), "generator_function_declaration");
3764 Ok(Self {
3765 span: ::treesitter_types::Span::from(node),
3766 body: {
3767 let child = node
3768 .child_by_field_name("body")
3769 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
3770 "body",
3771 node,
3772 ))?;
3773 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3774 },
3775 name: {
3776 let child = node
3777 .child_by_field_name("name")
3778 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
3779 "name",
3780 node,
3781 ))?;
3782 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3783 },
3784 parameters: {
3785 let child = node
3786 .child_by_field_name("parameters")
3787 .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
3788 "parameters",
3789 node,
3790 ))?;
3791 <FormalParameters as ::treesitter_types::FromNode>::from_node(
3792 child,
3793 src,
3794 )?
3795 },
3796 return_type: match node.child_by_field_name("return_type") {
3797 Some(child) => {
3798 Some(
3799 <GeneratorFunctionDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
3800 child,
3801 src,
3802 )?,
3803 )
3804 }
3805 None => None,
3806 },
3807 type_parameters: match node.child_by_field_name("type_parameters") {
3808 Some(child) => {
3809 Some(
3810 <TypeParameters as ::treesitter_types::FromNode>::from_node(
3811 child,
3812 src,
3813 )?,
3814 )
3815 }
3816 None => None,
3817 },
3818 })
3819 }
3820}
3821impl ::treesitter_types::Spanned for GeneratorFunctionDeclaration<'_> {
3822 fn span(&self) -> ::treesitter_types::Span {
3823 self.span
3824 }
3825}
3826#[derive(Debug, Clone)]
3827pub struct GenericType<'tree> {
3828 pub span: ::treesitter_types::Span,
3829 pub name: GenericTypeName<'tree>,
3830 pub type_arguments: TypeArguments<'tree>,
3831}
3832impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
3833 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3834 fn from_node(
3835 node: ::tree_sitter::Node<'tree>,
3836 src: &'tree [u8],
3837 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3838 debug_assert_eq!(node.kind(), "generic_type");
3839 Ok(Self {
3840 span: ::treesitter_types::Span::from(node),
3841 name: {
3842 let child = node
3843 .child_by_field_name("name")
3844 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3845 <GenericTypeName as ::treesitter_types::FromNode>::from_node(child, src)?
3846 },
3847 type_arguments: {
3848 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
3849 ::treesitter_types::ParseError::missing_field("type_arguments", node)
3850 })?;
3851 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
3852 },
3853 })
3854 }
3855}
3856impl ::treesitter_types::Spanned for GenericType<'_> {
3857 fn span(&self) -> ::treesitter_types::Span {
3858 self.span
3859 }
3860}
3861#[derive(Debug, Clone)]
3862pub struct Identifier<'tree> {
3863 pub span: ::treesitter_types::Span,
3864 text: &'tree str,
3865}
3866impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
3867 fn from_node(
3868 node: ::tree_sitter::Node<'tree>,
3869 src: &'tree [u8],
3870 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3871 debug_assert_eq!(node.kind(), "identifier");
3872 Ok(Self {
3873 span: ::treesitter_types::Span::from(node),
3874 text: node.utf8_text(src)?,
3875 })
3876 }
3877}
3878impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
3879 fn text(&self) -> &'tree str {
3880 self.text
3881 }
3882}
3883impl ::treesitter_types::Spanned for Identifier<'_> {
3884 fn span(&self) -> ::treesitter_types::Span {
3885 self.span
3886 }
3887}
3888#[derive(Debug, Clone)]
3889pub struct IfStatement<'tree> {
3890 pub span: ::treesitter_types::Span,
3891 pub alternative: ::core::option::Option<ElseClause<'tree>>,
3892 pub condition: ParenthesizedExpression<'tree>,
3893 pub consequence: Statement<'tree>,
3894}
3895impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
3896 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3897 fn from_node(
3898 node: ::tree_sitter::Node<'tree>,
3899 src: &'tree [u8],
3900 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3901 debug_assert_eq!(node.kind(), "if_statement");
3902 Ok(Self {
3903 span: ::treesitter_types::Span::from(node),
3904 alternative: match node.child_by_field_name("alternative") {
3905 Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
3906 child, src,
3907 )?),
3908 None => None,
3909 },
3910 condition: {
3911 let child = node.child_by_field_name("condition").ok_or_else(|| {
3912 ::treesitter_types::ParseError::missing_field("condition", node)
3913 })?;
3914 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
3915 },
3916 consequence: {
3917 let child = node.child_by_field_name("consequence").ok_or_else(|| {
3918 ::treesitter_types::ParseError::missing_field("consequence", node)
3919 })?;
3920 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3921 },
3922 })
3923 }
3924}
3925impl ::treesitter_types::Spanned for IfStatement<'_> {
3926 fn span(&self) -> ::treesitter_types::Span {
3927 self.span
3928 }
3929}
3930#[derive(Debug, Clone)]
3931pub struct ImplementsClause<'tree> {
3932 pub span: ::treesitter_types::Span,
3933 pub children: ::std::vec::Vec<Type<'tree>>,
3934}
3935impl<'tree> ::treesitter_types::FromNode<'tree> for ImplementsClause<'tree> {
3936 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3937 fn from_node(
3938 node: ::tree_sitter::Node<'tree>,
3939 src: &'tree [u8],
3940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3941 debug_assert_eq!(node.kind(), "implements_clause");
3942 Ok(Self {
3943 span: ::treesitter_types::Span::from(node),
3944 children: {
3945 #[allow(clippy::suspicious_else_formatting)]
3946 let non_field_children = {
3947 let mut cursor = node.walk();
3948 let mut result = ::std::vec::Vec::new();
3949 if cursor.goto_first_child() {
3950 loop {
3951 if cursor.field_name().is_none()
3952 && cursor.node().is_named()
3953 && !cursor.node().is_extra()
3954 {
3955 result.push(cursor.node());
3956 }
3957 if !cursor.goto_next_sibling() {
3958 break;
3959 }
3960 }
3961 }
3962 result
3963 };
3964 let mut items = ::std::vec::Vec::new();
3965 for child in non_field_children {
3966 items.push(<Type as ::treesitter_types::FromNode>::from_node(
3967 child, src,
3968 )?);
3969 }
3970 items
3971 },
3972 })
3973 }
3974}
3975impl ::treesitter_types::Spanned for ImplementsClause<'_> {
3976 fn span(&self) -> ::treesitter_types::Span {
3977 self.span
3978 }
3979}
3980#[derive(Debug, Clone)]
3981pub struct Import<'tree> {
3982 pub span: ::treesitter_types::Span,
3983 text: &'tree str,
3984}
3985impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
3986 fn from_node(
3987 node: ::tree_sitter::Node<'tree>,
3988 src: &'tree [u8],
3989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3990 debug_assert_eq!(node.kind(), "import");
3991 Ok(Self {
3992 span: ::treesitter_types::Span::from(node),
3993 text: node.utf8_text(src)?,
3994 })
3995 }
3996}
3997impl<'tree> ::treesitter_types::LeafNode<'tree> for Import<'tree> {
3998 fn text(&self) -> &'tree str {
3999 self.text
4000 }
4001}
4002impl ::treesitter_types::Spanned for Import<'_> {
4003 fn span(&self) -> ::treesitter_types::Span {
4004 self.span
4005 }
4006}
4007#[derive(Debug, Clone)]
4008pub struct ImportAlias<'tree> {
4009 pub span: ::treesitter_types::Span,
4010 pub children: ::std::vec::Vec<ImportAliasChildren<'tree>>,
4011}
4012impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAlias<'tree> {
4013 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4014 fn from_node(
4015 node: ::tree_sitter::Node<'tree>,
4016 src: &'tree [u8],
4017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4018 debug_assert_eq!(node.kind(), "import_alias");
4019 Ok(Self {
4020 span: ::treesitter_types::Span::from(node),
4021 children: {
4022 #[allow(clippy::suspicious_else_formatting)]
4023 let non_field_children = {
4024 let mut cursor = node.walk();
4025 let mut result = ::std::vec::Vec::new();
4026 if cursor.goto_first_child() {
4027 loop {
4028 if cursor.field_name().is_none()
4029 && cursor.node().is_named()
4030 && !cursor.node().is_extra()
4031 {
4032 result.push(cursor.node());
4033 }
4034 if !cursor.goto_next_sibling() {
4035 break;
4036 }
4037 }
4038 }
4039 result
4040 };
4041 let mut items = ::std::vec::Vec::new();
4042 for child in non_field_children {
4043 items.push(
4044 <ImportAliasChildren as ::treesitter_types::FromNode>::from_node(
4045 child, src,
4046 )?,
4047 );
4048 }
4049 items
4050 },
4051 })
4052 }
4053}
4054impl ::treesitter_types::Spanned for ImportAlias<'_> {
4055 fn span(&self) -> ::treesitter_types::Span {
4056 self.span
4057 }
4058}
4059#[derive(Debug, Clone)]
4060pub struct ImportAttribute<'tree> {
4061 pub span: ::treesitter_types::Span,
4062 pub children: Object<'tree>,
4063}
4064impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAttribute<'tree> {
4065 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4066 fn from_node(
4067 node: ::tree_sitter::Node<'tree>,
4068 src: &'tree [u8],
4069 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4070 debug_assert_eq!(node.kind(), "import_attribute");
4071 Ok(Self {
4072 span: ::treesitter_types::Span::from(node),
4073 children: {
4074 #[allow(clippy::suspicious_else_formatting)]
4075 let non_field_children = {
4076 let mut cursor = node.walk();
4077 let mut result = ::std::vec::Vec::new();
4078 if cursor.goto_first_child() {
4079 loop {
4080 if cursor.field_name().is_none()
4081 && cursor.node().is_named()
4082 && !cursor.node().is_extra()
4083 {
4084 result.push(cursor.node());
4085 }
4086 if !cursor.goto_next_sibling() {
4087 break;
4088 }
4089 }
4090 }
4091 result
4092 };
4093 let child = if let Some(&c) = non_field_children.first() {
4094 c
4095 } else {
4096 let mut fallback_cursor = node.walk();
4097 let mut fallback_child = None;
4098 if fallback_cursor.goto_first_child() {
4099 loop {
4100 if fallback_cursor.field_name().is_none()
4101 && !fallback_cursor.node().is_extra()
4102 {
4103 fallback_child = Some(fallback_cursor.node());
4104 break;
4105 }
4106 if !fallback_cursor.goto_next_sibling() {
4107 break;
4108 }
4109 }
4110 }
4111 fallback_child.ok_or_else(|| {
4112 ::treesitter_types::ParseError::missing_field("children", node)
4113 })?
4114 };
4115 <Object as ::treesitter_types::FromNode>::from_node(child, src)?
4116 },
4117 })
4118 }
4119}
4120impl ::treesitter_types::Spanned for ImportAttribute<'_> {
4121 fn span(&self) -> ::treesitter_types::Span {
4122 self.span
4123 }
4124}
4125#[derive(Debug, Clone)]
4126pub struct ImportClause<'tree> {
4127 pub span: ::treesitter_types::Span,
4128 pub children: ::std::vec::Vec<ImportClauseChildren<'tree>>,
4129}
4130impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClause<'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(), "import_clause");
4137 Ok(Self {
4138 span: ::treesitter_types::Span::from(node),
4139 children: {
4140 #[allow(clippy::suspicious_else_formatting)]
4141 let non_field_children = {
4142 let mut cursor = node.walk();
4143 let mut result = ::std::vec::Vec::new();
4144 if cursor.goto_first_child() {
4145 loop {
4146 if cursor.field_name().is_none()
4147 && cursor.node().is_named()
4148 && !cursor.node().is_extra()
4149 {
4150 result.push(cursor.node());
4151 }
4152 if !cursor.goto_next_sibling() {
4153 break;
4154 }
4155 }
4156 }
4157 result
4158 };
4159 let mut items = ::std::vec::Vec::new();
4160 for child in non_field_children {
4161 items.push(
4162 <ImportClauseChildren as ::treesitter_types::FromNode>::from_node(
4163 child, src,
4164 )?,
4165 );
4166 }
4167 items
4168 },
4169 })
4170 }
4171}
4172impl ::treesitter_types::Spanned for ImportClause<'_> {
4173 fn span(&self) -> ::treesitter_types::Span {
4174 self.span
4175 }
4176}
4177#[derive(Debug, Clone)]
4178pub struct ImportRequireClause<'tree> {
4179 pub span: ::treesitter_types::Span,
4180 pub source: String<'tree>,
4181 pub children: Identifier<'tree>,
4182}
4183impl<'tree> ::treesitter_types::FromNode<'tree> for ImportRequireClause<'tree> {
4184 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4185 fn from_node(
4186 node: ::tree_sitter::Node<'tree>,
4187 src: &'tree [u8],
4188 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4189 debug_assert_eq!(node.kind(), "import_require_clause");
4190 Ok(Self {
4191 span: ::treesitter_types::Span::from(node),
4192 source: {
4193 let child = node
4194 .child_by_field_name("source")
4195 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("source", node))?;
4196 <String as ::treesitter_types::FromNode>::from_node(child, src)?
4197 },
4198 children: {
4199 #[allow(clippy::suspicious_else_formatting)]
4200 let non_field_children = {
4201 let mut cursor = node.walk();
4202 let mut result = ::std::vec::Vec::new();
4203 if cursor.goto_first_child() {
4204 loop {
4205 if cursor.field_name().is_none()
4206 && cursor.node().is_named()
4207 && !cursor.node().is_extra()
4208 {
4209 result.push(cursor.node());
4210 }
4211 if !cursor.goto_next_sibling() {
4212 break;
4213 }
4214 }
4215 }
4216 result
4217 };
4218 let child = if let Some(&c) = non_field_children.first() {
4219 c
4220 } else {
4221 let mut fallback_cursor = node.walk();
4222 let mut fallback_child = None;
4223 if fallback_cursor.goto_first_child() {
4224 loop {
4225 if fallback_cursor.field_name().is_none()
4226 && !fallback_cursor.node().is_extra()
4227 {
4228 fallback_child = Some(fallback_cursor.node());
4229 break;
4230 }
4231 if !fallback_cursor.goto_next_sibling() {
4232 break;
4233 }
4234 }
4235 }
4236 fallback_child.ok_or_else(|| {
4237 ::treesitter_types::ParseError::missing_field("children", node)
4238 })?
4239 };
4240 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
4241 },
4242 })
4243 }
4244}
4245impl ::treesitter_types::Spanned for ImportRequireClause<'_> {
4246 fn span(&self) -> ::treesitter_types::Span {
4247 self.span
4248 }
4249}
4250#[derive(Debug, Clone)]
4251pub struct ImportSpecifier<'tree> {
4252 pub span: ::treesitter_types::Span,
4253 pub alias: ::core::option::Option<Identifier<'tree>>,
4254 pub name: ImportSpecifierName<'tree>,
4255}
4256impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifier<'tree> {
4257 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4258 fn from_node(
4259 node: ::tree_sitter::Node<'tree>,
4260 src: &'tree [u8],
4261 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4262 debug_assert_eq!(node.kind(), "import_specifier");
4263 Ok(Self {
4264 span: ::treesitter_types::Span::from(node),
4265 alias: match node.child_by_field_name("alias") {
4266 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
4267 child, src,
4268 )?),
4269 None => None,
4270 },
4271 name: {
4272 let child = node
4273 .child_by_field_name("name")
4274 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4275 <ImportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
4276 },
4277 })
4278 }
4279}
4280impl ::treesitter_types::Spanned for ImportSpecifier<'_> {
4281 fn span(&self) -> ::treesitter_types::Span {
4282 self.span
4283 }
4284}
4285#[derive(Debug, Clone)]
4286pub struct ImportStatement<'tree> {
4287 pub span: ::treesitter_types::Span,
4288 pub source: ::core::option::Option<String<'tree>>,
4289 pub children: ::std::vec::Vec<ImportStatementChildren<'tree>>,
4290}
4291impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatement<'tree> {
4292 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4293 fn from_node(
4294 node: ::tree_sitter::Node<'tree>,
4295 src: &'tree [u8],
4296 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4297 debug_assert_eq!(node.kind(), "import_statement");
4298 Ok(Self {
4299 span: ::treesitter_types::Span::from(node),
4300 source: match node.child_by_field_name("source") {
4301 Some(child) => Some(<String as ::treesitter_types::FromNode>::from_node(
4302 child, src,
4303 )?),
4304 None => None,
4305 },
4306 children: {
4307 #[allow(clippy::suspicious_else_formatting)]
4308 let non_field_children = {
4309 let mut cursor = node.walk();
4310 let mut result = ::std::vec::Vec::new();
4311 if cursor.goto_first_child() {
4312 loop {
4313 if cursor.field_name().is_none()
4314 && cursor.node().is_named()
4315 && !cursor.node().is_extra()
4316 {
4317 result.push(cursor.node());
4318 }
4319 if !cursor.goto_next_sibling() {
4320 break;
4321 }
4322 }
4323 }
4324 result
4325 };
4326 let mut items = ::std::vec::Vec::new();
4327 for child in non_field_children {
4328 items.push(
4329 <ImportStatementChildren as ::treesitter_types::FromNode>::from_node(
4330 child, src,
4331 )?,
4332 );
4333 }
4334 items
4335 },
4336 })
4337 }
4338}
4339impl ::treesitter_types::Spanned for ImportStatement<'_> {
4340 fn span(&self) -> ::treesitter_types::Span {
4341 self.span
4342 }
4343}
4344#[derive(Debug, Clone)]
4345pub struct IndexSignature<'tree> {
4346 pub span: ::treesitter_types::Span,
4347 pub index_type: ::core::option::Option<Type<'tree>>,
4348 pub name: ::core::option::Option<Identifier<'tree>>,
4349 pub sign: ::core::option::Option<IndexSignatureSign>,
4350 pub r#type: IndexSignatureType<'tree>,
4351 pub children: ::core::option::Option<MappedTypeClause<'tree>>,
4352}
4353impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignature<'tree> {
4354 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4355 fn from_node(
4356 node: ::tree_sitter::Node<'tree>,
4357 src: &'tree [u8],
4358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4359 debug_assert_eq!(node.kind(), "index_signature");
4360 Ok(Self {
4361 span: ::treesitter_types::Span::from(node),
4362 index_type: match node.child_by_field_name("index_type") {
4363 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
4364 child, src,
4365 )?),
4366 None => None,
4367 },
4368 name: match node.child_by_field_name("name") {
4369 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
4370 child, src,
4371 )?),
4372 None => None,
4373 },
4374 sign: match node.child_by_field_name("sign") {
4375 Some(child) => Some(
4376 <IndexSignatureSign as ::treesitter_types::FromNode>::from_node(child, src)?,
4377 ),
4378 None => None,
4379 },
4380 r#type: {
4381 let child = node
4382 .child_by_field_name("type")
4383 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
4384 <IndexSignatureType as ::treesitter_types::FromNode>::from_node(child, src)?
4385 },
4386 children: {
4387 #[allow(clippy::suspicious_else_formatting)]
4388 let non_field_children = {
4389 let mut cursor = node.walk();
4390 let mut result = ::std::vec::Vec::new();
4391 if cursor.goto_first_child() {
4392 loop {
4393 if cursor.field_name().is_none()
4394 && cursor.node().is_named()
4395 && !cursor.node().is_extra()
4396 {
4397 result.push(cursor.node());
4398 }
4399 if !cursor.goto_next_sibling() {
4400 break;
4401 }
4402 }
4403 }
4404 result
4405 };
4406 match non_field_children.first() {
4407 Some(&child) => Some(
4408 <MappedTypeClause as ::treesitter_types::FromNode>::from_node(child, src)?,
4409 ),
4410 None => None,
4411 }
4412 },
4413 })
4414 }
4415}
4416impl ::treesitter_types::Spanned for IndexSignature<'_> {
4417 fn span(&self) -> ::treesitter_types::Span {
4418 self.span
4419 }
4420}
4421#[derive(Debug, Clone)]
4422pub struct IndexTypeQuery<'tree> {
4423 pub span: ::treesitter_types::Span,
4424 pub children: PrimaryType<'tree>,
4425}
4426impl<'tree> ::treesitter_types::FromNode<'tree> for IndexTypeQuery<'tree> {
4427 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4428 fn from_node(
4429 node: ::tree_sitter::Node<'tree>,
4430 src: &'tree [u8],
4431 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4432 debug_assert_eq!(node.kind(), "index_type_query");
4433 Ok(Self {
4434 span: ::treesitter_types::Span::from(node),
4435 children: {
4436 #[allow(clippy::suspicious_else_formatting)]
4437 let non_field_children = {
4438 let mut cursor = node.walk();
4439 let mut result = ::std::vec::Vec::new();
4440 if cursor.goto_first_child() {
4441 loop {
4442 if cursor.field_name().is_none()
4443 && cursor.node().is_named()
4444 && !cursor.node().is_extra()
4445 {
4446 result.push(cursor.node());
4447 }
4448 if !cursor.goto_next_sibling() {
4449 break;
4450 }
4451 }
4452 }
4453 result
4454 };
4455 let child = if let Some(&c) = non_field_children.first() {
4456 c
4457 } else {
4458 let mut fallback_cursor = node.walk();
4459 let mut fallback_child = None;
4460 if fallback_cursor.goto_first_child() {
4461 loop {
4462 if fallback_cursor.field_name().is_none()
4463 && !fallback_cursor.node().is_extra()
4464 {
4465 fallback_child = Some(fallback_cursor.node());
4466 break;
4467 }
4468 if !fallback_cursor.goto_next_sibling() {
4469 break;
4470 }
4471 }
4472 }
4473 fallback_child.ok_or_else(|| {
4474 ::treesitter_types::ParseError::missing_field("children", node)
4475 })?
4476 };
4477 <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
4478 },
4479 })
4480 }
4481}
4482impl ::treesitter_types::Spanned for IndexTypeQuery<'_> {
4483 fn span(&self) -> ::treesitter_types::Span {
4484 self.span
4485 }
4486}
4487#[derive(Debug, Clone)]
4488pub struct InferType<'tree> {
4489 pub span: ::treesitter_types::Span,
4490 pub children: ::std::vec::Vec<InferTypeChildren<'tree>>,
4491}
4492impl<'tree> ::treesitter_types::FromNode<'tree> for InferType<'tree> {
4493 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4494 fn from_node(
4495 node: ::tree_sitter::Node<'tree>,
4496 src: &'tree [u8],
4497 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4498 debug_assert_eq!(node.kind(), "infer_type");
4499 Ok(Self {
4500 span: ::treesitter_types::Span::from(node),
4501 children: {
4502 #[allow(clippy::suspicious_else_formatting)]
4503 let non_field_children = {
4504 let mut cursor = node.walk();
4505 let mut result = ::std::vec::Vec::new();
4506 if cursor.goto_first_child() {
4507 loop {
4508 if cursor.field_name().is_none()
4509 && cursor.node().is_named()
4510 && !cursor.node().is_extra()
4511 {
4512 result.push(cursor.node());
4513 }
4514 if !cursor.goto_next_sibling() {
4515 break;
4516 }
4517 }
4518 }
4519 result
4520 };
4521 let mut items = ::std::vec::Vec::new();
4522 for child in non_field_children {
4523 items.push(
4524 <InferTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4525 );
4526 }
4527 items
4528 },
4529 })
4530 }
4531}
4532impl ::treesitter_types::Spanned for InferType<'_> {
4533 fn span(&self) -> ::treesitter_types::Span {
4534 self.span
4535 }
4536}
4537#[derive(Debug, Clone)]
4538pub struct InstantiationExpression<'tree> {
4539 pub span: ::treesitter_types::Span,
4540 pub function: ::core::option::Option<InstantiationExpressionFunction<'tree>>,
4541 pub type_arguments: TypeArguments<'tree>,
4542 pub children: ::core::option::Option<Expression<'tree>>,
4543}
4544impl<'tree> ::treesitter_types::FromNode<'tree> for InstantiationExpression<'tree> {
4545 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4546 fn from_node(
4547 node: ::tree_sitter::Node<'tree>,
4548 src: &'tree [u8],
4549 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4550 debug_assert_eq!(node.kind(), "instantiation_expression");
4551 Ok(Self {
4552 span: ::treesitter_types::Span::from(node),
4553 function: match node.child_by_field_name("function") {
4554 Some(child) => Some(
4555 <InstantiationExpressionFunction as ::treesitter_types::FromNode>::from_node(
4556 child, src,
4557 )?,
4558 ),
4559 None => None,
4560 },
4561 type_arguments: {
4562 let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
4563 ::treesitter_types::ParseError::missing_field("type_arguments", node)
4564 })?;
4565 <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
4566 },
4567 children: {
4568 #[allow(clippy::suspicious_else_formatting)]
4569 let non_field_children = {
4570 let mut cursor = node.walk();
4571 let mut result = ::std::vec::Vec::new();
4572 if cursor.goto_first_child() {
4573 loop {
4574 if cursor.field_name().is_none()
4575 && cursor.node().is_named()
4576 && !cursor.node().is_extra()
4577 {
4578 result.push(cursor.node());
4579 }
4580 if !cursor.goto_next_sibling() {
4581 break;
4582 }
4583 }
4584 }
4585 result
4586 };
4587 match non_field_children.first() {
4588 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
4589 child, src,
4590 )?),
4591 None => None,
4592 }
4593 },
4594 })
4595 }
4596}
4597impl ::treesitter_types::Spanned for InstantiationExpression<'_> {
4598 fn span(&self) -> ::treesitter_types::Span {
4599 self.span
4600 }
4601}
4602#[derive(Debug, Clone)]
4603pub struct InterfaceBody<'tree> {
4604 pub span: ::treesitter_types::Span,
4605 pub children: ::std::vec::Vec<InterfaceBodyChildren<'tree>>,
4606}
4607impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBody<'tree> {
4608 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4609 fn from_node(
4610 node: ::tree_sitter::Node<'tree>,
4611 src: &'tree [u8],
4612 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4613 debug_assert_eq!(node.kind(), "interface_body");
4614 Ok(Self {
4615 span: ::treesitter_types::Span::from(node),
4616 children: {
4617 #[allow(clippy::suspicious_else_formatting)]
4618 let non_field_children = {
4619 let mut cursor = node.walk();
4620 let mut result = ::std::vec::Vec::new();
4621 if cursor.goto_first_child() {
4622 loop {
4623 if cursor.field_name().is_none()
4624 && cursor.node().is_named()
4625 && !cursor.node().is_extra()
4626 {
4627 result.push(cursor.node());
4628 }
4629 if !cursor.goto_next_sibling() {
4630 break;
4631 }
4632 }
4633 }
4634 result
4635 };
4636 let mut items = ::std::vec::Vec::new();
4637 for child in non_field_children {
4638 items.push(
4639 <InterfaceBodyChildren as ::treesitter_types::FromNode>::from_node(
4640 child, src,
4641 )?,
4642 );
4643 }
4644 items
4645 },
4646 })
4647 }
4648}
4649impl ::treesitter_types::Spanned for InterfaceBody<'_> {
4650 fn span(&self) -> ::treesitter_types::Span {
4651 self.span
4652 }
4653}
4654#[derive(Debug, Clone)]
4655pub struct InterfaceDeclaration<'tree> {
4656 pub span: ::treesitter_types::Span,
4657 pub body: InterfaceBody<'tree>,
4658 pub name: TypeIdentifier<'tree>,
4659 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
4660 pub children: ::core::option::Option<ExtendsTypeClause<'tree>>,
4661}
4662impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
4663 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4664 fn from_node(
4665 node: ::tree_sitter::Node<'tree>,
4666 src: &'tree [u8],
4667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4668 debug_assert_eq!(node.kind(), "interface_declaration");
4669 Ok(Self {
4670 span: ::treesitter_types::Span::from(node),
4671 body: {
4672 let child = node
4673 .child_by_field_name("body")
4674 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4675 <InterfaceBody as ::treesitter_types::FromNode>::from_node(child, src)?
4676 },
4677 name: {
4678 let child = node
4679 .child_by_field_name("name")
4680 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4681 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
4682 },
4683 type_parameters: match node.child_by_field_name("type_parameters") {
4684 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
4685 child, src,
4686 )?),
4687 None => None,
4688 },
4689 children: {
4690 #[allow(clippy::suspicious_else_formatting)]
4691 let non_field_children = {
4692 let mut cursor = node.walk();
4693 let mut result = ::std::vec::Vec::new();
4694 if cursor.goto_first_child() {
4695 loop {
4696 if cursor.field_name().is_none()
4697 && cursor.node().is_named()
4698 && !cursor.node().is_extra()
4699 {
4700 result.push(cursor.node());
4701 }
4702 if !cursor.goto_next_sibling() {
4703 break;
4704 }
4705 }
4706 }
4707 result
4708 };
4709 match non_field_children.first() {
4710 Some(&child) => Some(
4711 <ExtendsTypeClause as ::treesitter_types::FromNode>::from_node(child, src)?,
4712 ),
4713 None => None,
4714 }
4715 },
4716 })
4717 }
4718}
4719impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
4720 fn span(&self) -> ::treesitter_types::Span {
4721 self.span
4722 }
4723}
4724#[derive(Debug, Clone)]
4725pub struct InternalModule<'tree> {
4726 pub span: ::treesitter_types::Span,
4727 pub body: ::core::option::Option<StatementBlock<'tree>>,
4728 pub name: InternalModuleName<'tree>,
4729}
4730impl<'tree> ::treesitter_types::FromNode<'tree> for InternalModule<'tree> {
4731 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4732 fn from_node(
4733 node: ::tree_sitter::Node<'tree>,
4734 src: &'tree [u8],
4735 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4736 debug_assert_eq!(node.kind(), "internal_module");
4737 Ok(Self {
4738 span: ::treesitter_types::Span::from(node),
4739 body: match node.child_by_field_name("body") {
4740 Some(child) => Some(<StatementBlock as ::treesitter_types::FromNode>::from_node(
4741 child, src,
4742 )?),
4743 None => None,
4744 },
4745 name: {
4746 let child = node
4747 .child_by_field_name("name")
4748 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
4749 <InternalModuleName as ::treesitter_types::FromNode>::from_node(child, src)?
4750 },
4751 })
4752 }
4753}
4754impl ::treesitter_types::Spanned for InternalModule<'_> {
4755 fn span(&self) -> ::treesitter_types::Span {
4756 self.span
4757 }
4758}
4759#[derive(Debug, Clone)]
4760pub struct IntersectionType<'tree> {
4761 pub span: ::treesitter_types::Span,
4762 pub children: ::std::vec::Vec<Type<'tree>>,
4763}
4764impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionType<'tree> {
4765 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4766 fn from_node(
4767 node: ::tree_sitter::Node<'tree>,
4768 src: &'tree [u8],
4769 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4770 debug_assert_eq!(node.kind(), "intersection_type");
4771 Ok(Self {
4772 span: ::treesitter_types::Span::from(node),
4773 children: {
4774 #[allow(clippy::suspicious_else_formatting)]
4775 let non_field_children = {
4776 let mut cursor = node.walk();
4777 let mut result = ::std::vec::Vec::new();
4778 if cursor.goto_first_child() {
4779 loop {
4780 if cursor.field_name().is_none()
4781 && cursor.node().is_named()
4782 && !cursor.node().is_extra()
4783 {
4784 result.push(cursor.node());
4785 }
4786 if !cursor.goto_next_sibling() {
4787 break;
4788 }
4789 }
4790 }
4791 result
4792 };
4793 let mut items = ::std::vec::Vec::new();
4794 for child in non_field_children {
4795 items.push(<Type as ::treesitter_types::FromNode>::from_node(
4796 child, src,
4797 )?);
4798 }
4799 items
4800 },
4801 })
4802 }
4803}
4804impl ::treesitter_types::Spanned for IntersectionType<'_> {
4805 fn span(&self) -> ::treesitter_types::Span {
4806 self.span
4807 }
4808}
4809#[derive(Debug, Clone)]
4810pub struct LabeledStatement<'tree> {
4811 pub span: ::treesitter_types::Span,
4812 pub body: Statement<'tree>,
4813 pub label: StatementIdentifier<'tree>,
4814}
4815impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
4816 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4817 fn from_node(
4818 node: ::tree_sitter::Node<'tree>,
4819 src: &'tree [u8],
4820 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4821 debug_assert_eq!(node.kind(), "labeled_statement");
4822 Ok(Self {
4823 span: ::treesitter_types::Span::from(node),
4824 body: {
4825 let child = node
4826 .child_by_field_name("body")
4827 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4828 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
4829 },
4830 label: {
4831 let child = node
4832 .child_by_field_name("label")
4833 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
4834 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
4835 },
4836 })
4837 }
4838}
4839impl ::treesitter_types::Spanned for LabeledStatement<'_> {
4840 fn span(&self) -> ::treesitter_types::Span {
4841 self.span
4842 }
4843}
4844#[derive(Debug, Clone)]
4845pub struct LexicalDeclaration<'tree> {
4846 pub span: ::treesitter_types::Span,
4847 pub kind: LexicalDeclarationKind,
4848 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
4849}
4850impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclaration<'tree> {
4851 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4852 fn from_node(
4853 node: ::tree_sitter::Node<'tree>,
4854 src: &'tree [u8],
4855 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4856 debug_assert_eq!(node.kind(), "lexical_declaration");
4857 Ok(Self {
4858 span: ::treesitter_types::Span::from(node),
4859 kind: {
4860 let child = node
4861 .child_by_field_name("kind")
4862 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
4863 <LexicalDeclarationKind as ::treesitter_types::FromNode>::from_node(child, src)?
4864 },
4865 children: {
4866 #[allow(clippy::suspicious_else_formatting)]
4867 let non_field_children = {
4868 let mut cursor = node.walk();
4869 let mut result = ::std::vec::Vec::new();
4870 if cursor.goto_first_child() {
4871 loop {
4872 if cursor.field_name().is_none()
4873 && cursor.node().is_named()
4874 && !cursor.node().is_extra()
4875 {
4876 result.push(cursor.node());
4877 }
4878 if !cursor.goto_next_sibling() {
4879 break;
4880 }
4881 }
4882 }
4883 result
4884 };
4885 let mut items = ::std::vec::Vec::new();
4886 for child in non_field_children {
4887 items.push(
4888 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
4889 child, src,
4890 )?,
4891 );
4892 }
4893 items
4894 },
4895 })
4896 }
4897}
4898impl ::treesitter_types::Spanned for LexicalDeclaration<'_> {
4899 fn span(&self) -> ::treesitter_types::Span {
4900 self.span
4901 }
4902}
4903#[derive(Debug, Clone)]
4904pub struct LiteralType<'tree> {
4905 pub span: ::treesitter_types::Span,
4906 pub children: LiteralTypeChildren<'tree>,
4907}
4908impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralType<'tree> {
4909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4910 fn from_node(
4911 node: ::tree_sitter::Node<'tree>,
4912 src: &'tree [u8],
4913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4914 debug_assert_eq!(node.kind(), "literal_type");
4915 Ok(Self {
4916 span: ::treesitter_types::Span::from(node),
4917 children: {
4918 #[allow(clippy::suspicious_else_formatting)]
4919 let non_field_children = {
4920 let mut cursor = node.walk();
4921 let mut result = ::std::vec::Vec::new();
4922 if cursor.goto_first_child() {
4923 loop {
4924 if cursor.field_name().is_none()
4925 && cursor.node().is_named()
4926 && !cursor.node().is_extra()
4927 {
4928 result.push(cursor.node());
4929 }
4930 if !cursor.goto_next_sibling() {
4931 break;
4932 }
4933 }
4934 }
4935 result
4936 };
4937 let child = if let Some(&c) = non_field_children.first() {
4938 c
4939 } else {
4940 let mut fallback_cursor = node.walk();
4941 let mut fallback_child = None;
4942 if fallback_cursor.goto_first_child() {
4943 loop {
4944 if fallback_cursor.field_name().is_none()
4945 && !fallback_cursor.node().is_extra()
4946 {
4947 fallback_child = Some(fallback_cursor.node());
4948 break;
4949 }
4950 if !fallback_cursor.goto_next_sibling() {
4951 break;
4952 }
4953 }
4954 }
4955 fallback_child.ok_or_else(|| {
4956 ::treesitter_types::ParseError::missing_field("children", node)
4957 })?
4958 };
4959 <LiteralTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4960 },
4961 })
4962 }
4963}
4964impl ::treesitter_types::Spanned for LiteralType<'_> {
4965 fn span(&self) -> ::treesitter_types::Span {
4966 self.span
4967 }
4968}
4969#[derive(Debug, Clone)]
4970pub struct LookupType<'tree> {
4971 pub span: ::treesitter_types::Span,
4972 pub children: ::std::vec::Vec<Type<'tree>>,
4973}
4974impl<'tree> ::treesitter_types::FromNode<'tree> for LookupType<'tree> {
4975 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4976 fn from_node(
4977 node: ::tree_sitter::Node<'tree>,
4978 src: &'tree [u8],
4979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4980 debug_assert_eq!(node.kind(), "lookup_type");
4981 Ok(Self {
4982 span: ::treesitter_types::Span::from(node),
4983 children: {
4984 #[allow(clippy::suspicious_else_formatting)]
4985 let non_field_children = {
4986 let mut cursor = node.walk();
4987 let mut result = ::std::vec::Vec::new();
4988 if cursor.goto_first_child() {
4989 loop {
4990 if cursor.field_name().is_none()
4991 && cursor.node().is_named()
4992 && !cursor.node().is_extra()
4993 {
4994 result.push(cursor.node());
4995 }
4996 if !cursor.goto_next_sibling() {
4997 break;
4998 }
4999 }
5000 }
5001 result
5002 };
5003 let mut items = ::std::vec::Vec::new();
5004 for child in non_field_children {
5005 items.push(<Type as ::treesitter_types::FromNode>::from_node(
5006 child, src,
5007 )?);
5008 }
5009 items
5010 },
5011 })
5012 }
5013}
5014impl ::treesitter_types::Spanned for LookupType<'_> {
5015 fn span(&self) -> ::treesitter_types::Span {
5016 self.span
5017 }
5018}
5019#[derive(Debug, Clone)]
5020pub struct MappedTypeClause<'tree> {
5021 pub span: ::treesitter_types::Span,
5022 pub alias: ::core::option::Option<Type<'tree>>,
5023 pub name: TypeIdentifier<'tree>,
5024 pub r#type: Type<'tree>,
5025}
5026impl<'tree> ::treesitter_types::FromNode<'tree> for MappedTypeClause<'tree> {
5027 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5028 fn from_node(
5029 node: ::tree_sitter::Node<'tree>,
5030 src: &'tree [u8],
5031 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5032 debug_assert_eq!(node.kind(), "mapped_type_clause");
5033 Ok(Self {
5034 span: ::treesitter_types::Span::from(node),
5035 alias: match node.child_by_field_name("alias") {
5036 Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
5037 child, src,
5038 )?),
5039 None => None,
5040 },
5041 name: {
5042 let child = node
5043 .child_by_field_name("name")
5044 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5045 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
5046 },
5047 r#type: {
5048 let child = node
5049 .child_by_field_name("type")
5050 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
5051 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5052 },
5053 })
5054 }
5055}
5056impl ::treesitter_types::Spanned for MappedTypeClause<'_> {
5057 fn span(&self) -> ::treesitter_types::Span {
5058 self.span
5059 }
5060}
5061#[derive(Debug, Clone)]
5062pub struct MemberExpression<'tree> {
5063 pub span: ::treesitter_types::Span,
5064 pub object: MemberExpressionObject<'tree>,
5065 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
5066 pub property: MemberExpressionProperty<'tree>,
5067}
5068impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpression<'tree> {
5069 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5070 fn from_node(
5071 node: ::tree_sitter::Node<'tree>,
5072 src: &'tree [u8],
5073 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5074 debug_assert_eq!(node.kind(), "member_expression");
5075 Ok(Self {
5076 span: ::treesitter_types::Span::from(node),
5077 object: {
5078 let child = node
5079 .child_by_field_name("object")
5080 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5081 <MemberExpressionObject as ::treesitter_types::FromNode>::from_node(child, src)?
5082 },
5083 optional_chain: match node.child_by_field_name("optional_chain") {
5084 Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
5085 child, src,
5086 )?),
5087 None => None,
5088 },
5089 property: {
5090 let child = node.child_by_field_name("property").ok_or_else(|| {
5091 ::treesitter_types::ParseError::missing_field("property", node)
5092 })?;
5093 <MemberExpressionProperty as ::treesitter_types::FromNode>::from_node(child, src)?
5094 },
5095 })
5096 }
5097}
5098impl ::treesitter_types::Spanned for MemberExpression<'_> {
5099 fn span(&self) -> ::treesitter_types::Span {
5100 self.span
5101 }
5102}
5103#[derive(Debug, Clone)]
5104pub struct MetaProperty<'tree> {
5105 pub span: ::treesitter_types::Span,
5106 text: &'tree str,
5107}
5108impl<'tree> ::treesitter_types::FromNode<'tree> for MetaProperty<'tree> {
5109 fn from_node(
5110 node: ::tree_sitter::Node<'tree>,
5111 src: &'tree [u8],
5112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5113 debug_assert_eq!(node.kind(), "meta_property");
5114 Ok(Self {
5115 span: ::treesitter_types::Span::from(node),
5116 text: node.utf8_text(src)?,
5117 })
5118 }
5119}
5120impl<'tree> ::treesitter_types::LeafNode<'tree> for MetaProperty<'tree> {
5121 fn text(&self) -> &'tree str {
5122 self.text
5123 }
5124}
5125impl ::treesitter_types::Spanned for MetaProperty<'_> {
5126 fn span(&self) -> ::treesitter_types::Span {
5127 self.span
5128 }
5129}
5130#[derive(Debug, Clone)]
5131pub struct MethodDefinition<'tree> {
5132 pub span: ::treesitter_types::Span,
5133 pub body: StatementBlock<'tree>,
5134 pub name: MethodDefinitionName<'tree>,
5135 pub parameters: FormalParameters<'tree>,
5136 pub return_type: ::core::option::Option<MethodDefinitionReturnType<'tree>>,
5137 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
5138 pub children: ::std::vec::Vec<MethodDefinitionChildren<'tree>>,
5139}
5140impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinition<'tree> {
5141 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5142 fn from_node(
5143 node: ::tree_sitter::Node<'tree>,
5144 src: &'tree [u8],
5145 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5146 debug_assert_eq!(node.kind(), "method_definition");
5147 Ok(Self {
5148 span: ::treesitter_types::Span::from(node),
5149 body: {
5150 let child = node
5151 .child_by_field_name("body")
5152 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5153 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
5154 },
5155 name: {
5156 let child = node
5157 .child_by_field_name("name")
5158 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5159 <MethodDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)?
5160 },
5161 parameters: {
5162 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5163 ::treesitter_types::ParseError::missing_field("parameters", node)
5164 })?;
5165 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
5166 },
5167 return_type: match node.child_by_field_name("return_type") {
5168 Some(child) => Some(
5169 <MethodDefinitionReturnType as ::treesitter_types::FromNode>::from_node(
5170 child, src,
5171 )?,
5172 ),
5173 None => None,
5174 },
5175 type_parameters: match node.child_by_field_name("type_parameters") {
5176 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
5177 child, src,
5178 )?),
5179 None => None,
5180 },
5181 children: {
5182 #[allow(clippy::suspicious_else_formatting)]
5183 let non_field_children = {
5184 let mut cursor = node.walk();
5185 let mut result = ::std::vec::Vec::new();
5186 if cursor.goto_first_child() {
5187 loop {
5188 if cursor.field_name().is_none()
5189 && cursor.node().is_named()
5190 && !cursor.node().is_extra()
5191 {
5192 result.push(cursor.node());
5193 }
5194 if !cursor.goto_next_sibling() {
5195 break;
5196 }
5197 }
5198 }
5199 result
5200 };
5201 let mut items = ::std::vec::Vec::new();
5202 for child in non_field_children {
5203 items.push(
5204 <MethodDefinitionChildren as ::treesitter_types::FromNode>::from_node(
5205 child, src,
5206 )?,
5207 );
5208 }
5209 items
5210 },
5211 })
5212 }
5213}
5214impl ::treesitter_types::Spanned for MethodDefinition<'_> {
5215 fn span(&self) -> ::treesitter_types::Span {
5216 self.span
5217 }
5218}
5219#[derive(Debug, Clone)]
5220pub struct MethodSignature<'tree> {
5221 pub span: ::treesitter_types::Span,
5222 pub name: MethodSignatureName<'tree>,
5223 pub parameters: FormalParameters<'tree>,
5224 pub return_type: ::core::option::Option<MethodSignatureReturnType<'tree>>,
5225 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
5226 pub children: ::std::vec::Vec<MethodSignatureChildren<'tree>>,
5227}
5228impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignature<'tree> {
5229 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5230 fn from_node(
5231 node: ::tree_sitter::Node<'tree>,
5232 src: &'tree [u8],
5233 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5234 debug_assert_eq!(node.kind(), "method_signature");
5235 Ok(Self {
5236 span: ::treesitter_types::Span::from(node),
5237 name: {
5238 let child = node
5239 .child_by_field_name("name")
5240 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5241 <MethodSignatureName as ::treesitter_types::FromNode>::from_node(child, src)?
5242 },
5243 parameters: {
5244 let child = node.child_by_field_name("parameters").ok_or_else(|| {
5245 ::treesitter_types::ParseError::missing_field("parameters", node)
5246 })?;
5247 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
5248 },
5249 return_type: match node.child_by_field_name("return_type") {
5250 Some(child) => Some(
5251 <MethodSignatureReturnType as ::treesitter_types::FromNode>::from_node(
5252 child, src,
5253 )?,
5254 ),
5255 None => None,
5256 },
5257 type_parameters: match node.child_by_field_name("type_parameters") {
5258 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
5259 child, src,
5260 )?),
5261 None => None,
5262 },
5263 children: {
5264 #[allow(clippy::suspicious_else_formatting)]
5265 let non_field_children = {
5266 let mut cursor = node.walk();
5267 let mut result = ::std::vec::Vec::new();
5268 if cursor.goto_first_child() {
5269 loop {
5270 if cursor.field_name().is_none()
5271 && cursor.node().is_named()
5272 && !cursor.node().is_extra()
5273 {
5274 result.push(cursor.node());
5275 }
5276 if !cursor.goto_next_sibling() {
5277 break;
5278 }
5279 }
5280 }
5281 result
5282 };
5283 let mut items = ::std::vec::Vec::new();
5284 for child in non_field_children {
5285 items.push(
5286 <MethodSignatureChildren as ::treesitter_types::FromNode>::from_node(
5287 child, src,
5288 )?,
5289 );
5290 }
5291 items
5292 },
5293 })
5294 }
5295}
5296impl ::treesitter_types::Spanned for MethodSignature<'_> {
5297 fn span(&self) -> ::treesitter_types::Span {
5298 self.span
5299 }
5300}
5301#[derive(Debug, Clone)]
5302pub struct Module<'tree> {
5303 pub span: ::treesitter_types::Span,
5304 pub body: ::core::option::Option<StatementBlock<'tree>>,
5305 pub name: ModuleName<'tree>,
5306}
5307impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
5308 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5309 fn from_node(
5310 node: ::tree_sitter::Node<'tree>,
5311 src: &'tree [u8],
5312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5313 debug_assert_eq!(node.kind(), "module");
5314 Ok(Self {
5315 span: ::treesitter_types::Span::from(node),
5316 body: match node.child_by_field_name("body") {
5317 Some(child) => Some(<StatementBlock as ::treesitter_types::FromNode>::from_node(
5318 child, src,
5319 )?),
5320 None => None,
5321 },
5322 name: {
5323 let child = node
5324 .child_by_field_name("name")
5325 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5326 <ModuleName as ::treesitter_types::FromNode>::from_node(child, src)?
5327 },
5328 })
5329 }
5330}
5331impl ::treesitter_types::Spanned for Module<'_> {
5332 fn span(&self) -> ::treesitter_types::Span {
5333 self.span
5334 }
5335}
5336#[derive(Debug, Clone)]
5337pub struct NamedImports<'tree> {
5338 pub span: ::treesitter_types::Span,
5339 pub children: ::std::vec::Vec<ImportSpecifier<'tree>>,
5340}
5341impl<'tree> ::treesitter_types::FromNode<'tree> for NamedImports<'tree> {
5342 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5343 fn from_node(
5344 node: ::tree_sitter::Node<'tree>,
5345 src: &'tree [u8],
5346 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5347 debug_assert_eq!(node.kind(), "named_imports");
5348 Ok(Self {
5349 span: ::treesitter_types::Span::from(node),
5350 children: {
5351 #[allow(clippy::suspicious_else_formatting)]
5352 let non_field_children = {
5353 let mut cursor = node.walk();
5354 let mut result = ::std::vec::Vec::new();
5355 if cursor.goto_first_child() {
5356 loop {
5357 if cursor.field_name().is_none()
5358 && cursor.node().is_named()
5359 && !cursor.node().is_extra()
5360 {
5361 result.push(cursor.node());
5362 }
5363 if !cursor.goto_next_sibling() {
5364 break;
5365 }
5366 }
5367 }
5368 result
5369 };
5370 let mut items = ::std::vec::Vec::new();
5371 for child in non_field_children {
5372 items.push(
5373 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
5374 );
5375 }
5376 items
5377 },
5378 })
5379 }
5380}
5381impl ::treesitter_types::Spanned for NamedImports<'_> {
5382 fn span(&self) -> ::treesitter_types::Span {
5383 self.span
5384 }
5385}
5386#[derive(Debug, Clone)]
5387pub struct NamespaceExport<'tree> {
5388 pub span: ::treesitter_types::Span,
5389 pub children: NamespaceExportChildren<'tree>,
5390}
5391impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExport<'tree> {
5392 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5393 fn from_node(
5394 node: ::tree_sitter::Node<'tree>,
5395 src: &'tree [u8],
5396 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5397 debug_assert_eq!(node.kind(), "namespace_export");
5398 Ok(Self {
5399 span: ::treesitter_types::Span::from(node),
5400 children: {
5401 #[allow(clippy::suspicious_else_formatting)]
5402 let non_field_children = {
5403 let mut cursor = node.walk();
5404 let mut result = ::std::vec::Vec::new();
5405 if cursor.goto_first_child() {
5406 loop {
5407 if cursor.field_name().is_none()
5408 && cursor.node().is_named()
5409 && !cursor.node().is_extra()
5410 {
5411 result.push(cursor.node());
5412 }
5413 if !cursor.goto_next_sibling() {
5414 break;
5415 }
5416 }
5417 }
5418 result
5419 };
5420 let child = if let Some(&c) = non_field_children.first() {
5421 c
5422 } else {
5423 let mut fallback_cursor = node.walk();
5424 let mut fallback_child = None;
5425 if fallback_cursor.goto_first_child() {
5426 loop {
5427 if fallback_cursor.field_name().is_none()
5428 && !fallback_cursor.node().is_extra()
5429 {
5430 fallback_child = Some(fallback_cursor.node());
5431 break;
5432 }
5433 if !fallback_cursor.goto_next_sibling() {
5434 break;
5435 }
5436 }
5437 }
5438 fallback_child.ok_or_else(|| {
5439 ::treesitter_types::ParseError::missing_field("children", node)
5440 })?
5441 };
5442 <NamespaceExportChildren as ::treesitter_types::FromNode>::from_node(child, src)?
5443 },
5444 })
5445 }
5446}
5447impl ::treesitter_types::Spanned for NamespaceExport<'_> {
5448 fn span(&self) -> ::treesitter_types::Span {
5449 self.span
5450 }
5451}
5452#[derive(Debug, Clone)]
5453pub struct NamespaceImport<'tree> {
5454 pub span: ::treesitter_types::Span,
5455 pub children: Identifier<'tree>,
5456}
5457impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceImport<'tree> {
5458 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5459 fn from_node(
5460 node: ::tree_sitter::Node<'tree>,
5461 src: &'tree [u8],
5462 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5463 debug_assert_eq!(node.kind(), "namespace_import");
5464 Ok(Self {
5465 span: ::treesitter_types::Span::from(node),
5466 children: {
5467 #[allow(clippy::suspicious_else_formatting)]
5468 let non_field_children = {
5469 let mut cursor = node.walk();
5470 let mut result = ::std::vec::Vec::new();
5471 if cursor.goto_first_child() {
5472 loop {
5473 if cursor.field_name().is_none()
5474 && cursor.node().is_named()
5475 && !cursor.node().is_extra()
5476 {
5477 result.push(cursor.node());
5478 }
5479 if !cursor.goto_next_sibling() {
5480 break;
5481 }
5482 }
5483 }
5484 result
5485 };
5486 let child = if let Some(&c) = non_field_children.first() {
5487 c
5488 } else {
5489 let mut fallback_cursor = node.walk();
5490 let mut fallback_child = None;
5491 if fallback_cursor.goto_first_child() {
5492 loop {
5493 if fallback_cursor.field_name().is_none()
5494 && !fallback_cursor.node().is_extra()
5495 {
5496 fallback_child = Some(fallback_cursor.node());
5497 break;
5498 }
5499 if !fallback_cursor.goto_next_sibling() {
5500 break;
5501 }
5502 }
5503 }
5504 fallback_child.ok_or_else(|| {
5505 ::treesitter_types::ParseError::missing_field("children", node)
5506 })?
5507 };
5508 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
5509 },
5510 })
5511 }
5512}
5513impl ::treesitter_types::Spanned for NamespaceImport<'_> {
5514 fn span(&self) -> ::treesitter_types::Span {
5515 self.span
5516 }
5517}
5518#[derive(Debug, Clone)]
5519pub struct NestedIdentifier<'tree> {
5520 pub span: ::treesitter_types::Span,
5521 pub object: NestedIdentifierObject<'tree>,
5522 pub property: PropertyIdentifier<'tree>,
5523}
5524impl<'tree> ::treesitter_types::FromNode<'tree> for NestedIdentifier<'tree> {
5525 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5526 fn from_node(
5527 node: ::tree_sitter::Node<'tree>,
5528 src: &'tree [u8],
5529 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5530 debug_assert_eq!(node.kind(), "nested_identifier");
5531 Ok(Self {
5532 span: ::treesitter_types::Span::from(node),
5533 object: {
5534 let child = node
5535 .child_by_field_name("object")
5536 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5537 <NestedIdentifierObject as ::treesitter_types::FromNode>::from_node(child, src)?
5538 },
5539 property: {
5540 let child = node.child_by_field_name("property").ok_or_else(|| {
5541 ::treesitter_types::ParseError::missing_field("property", node)
5542 })?;
5543 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
5544 },
5545 })
5546 }
5547}
5548impl ::treesitter_types::Spanned for NestedIdentifier<'_> {
5549 fn span(&self) -> ::treesitter_types::Span {
5550 self.span
5551 }
5552}
5553#[derive(Debug, Clone)]
5554pub struct NestedTypeIdentifier<'tree> {
5555 pub span: ::treesitter_types::Span,
5556 pub module: NestedTypeIdentifierModule<'tree>,
5557 pub name: TypeIdentifier<'tree>,
5558}
5559impl<'tree> ::treesitter_types::FromNode<'tree> for NestedTypeIdentifier<'tree> {
5560 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5561 fn from_node(
5562 node: ::tree_sitter::Node<'tree>,
5563 src: &'tree [u8],
5564 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5565 debug_assert_eq!(node.kind(), "nested_type_identifier");
5566 Ok(Self {
5567 span: ::treesitter_types::Span::from(node),
5568 module: {
5569 let child = node
5570 .child_by_field_name("module")
5571 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
5572 <NestedTypeIdentifierModule as ::treesitter_types::FromNode>::from_node(child, src)?
5573 },
5574 name: {
5575 let child = node
5576 .child_by_field_name("name")
5577 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5578 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
5579 },
5580 })
5581 }
5582}
5583impl ::treesitter_types::Spanned for NestedTypeIdentifier<'_> {
5584 fn span(&self) -> ::treesitter_types::Span {
5585 self.span
5586 }
5587}
5588#[derive(Debug, Clone)]
5589pub struct NewExpression<'tree> {
5590 pub span: ::treesitter_types::Span,
5591 pub arguments: ::core::option::Option<Arguments<'tree>>,
5592 pub constructor: PrimaryExpression<'tree>,
5593 pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
5594}
5595impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
5596 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5597 fn from_node(
5598 node: ::tree_sitter::Node<'tree>,
5599 src: &'tree [u8],
5600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5601 debug_assert_eq!(node.kind(), "new_expression");
5602 Ok(Self {
5603 span: ::treesitter_types::Span::from(node),
5604 arguments: match node.child_by_field_name("arguments") {
5605 Some(child) => Some(<Arguments as ::treesitter_types::FromNode>::from_node(
5606 child, src,
5607 )?),
5608 None => None,
5609 },
5610 constructor: {
5611 let child = node.child_by_field_name("constructor").ok_or_else(|| {
5612 ::treesitter_types::ParseError::missing_field("constructor", node)
5613 })?;
5614 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5615 },
5616 type_arguments: match node.child_by_field_name("type_arguments") {
5617 Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
5618 child, src,
5619 )?),
5620 None => None,
5621 },
5622 })
5623 }
5624}
5625impl ::treesitter_types::Spanned for NewExpression<'_> {
5626 fn span(&self) -> ::treesitter_types::Span {
5627 self.span
5628 }
5629}
5630#[derive(Debug, Clone)]
5631pub struct NonNullExpression<'tree> {
5632 pub span: ::treesitter_types::Span,
5633 pub children: Expression<'tree>,
5634}
5635impl<'tree> ::treesitter_types::FromNode<'tree> for NonNullExpression<'tree> {
5636 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5637 fn from_node(
5638 node: ::tree_sitter::Node<'tree>,
5639 src: &'tree [u8],
5640 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5641 debug_assert_eq!(node.kind(), "non_null_expression");
5642 Ok(Self {
5643 span: ::treesitter_types::Span::from(node),
5644 children: {
5645 #[allow(clippy::suspicious_else_formatting)]
5646 let non_field_children = {
5647 let mut cursor = node.walk();
5648 let mut result = ::std::vec::Vec::new();
5649 if cursor.goto_first_child() {
5650 loop {
5651 if cursor.field_name().is_none()
5652 && cursor.node().is_named()
5653 && !cursor.node().is_extra()
5654 {
5655 result.push(cursor.node());
5656 }
5657 if !cursor.goto_next_sibling() {
5658 break;
5659 }
5660 }
5661 }
5662 result
5663 };
5664 let child = if let Some(&c) = non_field_children.first() {
5665 c
5666 } else {
5667 let mut fallback_cursor = node.walk();
5668 let mut fallback_child = None;
5669 if fallback_cursor.goto_first_child() {
5670 loop {
5671 if fallback_cursor.field_name().is_none()
5672 && !fallback_cursor.node().is_extra()
5673 {
5674 fallback_child = Some(fallback_cursor.node());
5675 break;
5676 }
5677 if !fallback_cursor.goto_next_sibling() {
5678 break;
5679 }
5680 }
5681 }
5682 fallback_child.ok_or_else(|| {
5683 ::treesitter_types::ParseError::missing_field("children", node)
5684 })?
5685 };
5686 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5687 },
5688 })
5689 }
5690}
5691impl ::treesitter_types::Spanned for NonNullExpression<'_> {
5692 fn span(&self) -> ::treesitter_types::Span {
5693 self.span
5694 }
5695}
5696#[derive(Debug, Clone)]
5697pub struct Object<'tree> {
5698 pub span: ::treesitter_types::Span,
5699 pub children: ::std::vec::Vec<ObjectChildren<'tree>>,
5700}
5701impl<'tree> ::treesitter_types::FromNode<'tree> for Object<'tree> {
5702 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5703 fn from_node(
5704 node: ::tree_sitter::Node<'tree>,
5705 src: &'tree [u8],
5706 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5707 debug_assert_eq!(node.kind(), "object");
5708 Ok(Self {
5709 span: ::treesitter_types::Span::from(node),
5710 children: {
5711 #[allow(clippy::suspicious_else_formatting)]
5712 let non_field_children = {
5713 let mut cursor = node.walk();
5714 let mut result = ::std::vec::Vec::new();
5715 if cursor.goto_first_child() {
5716 loop {
5717 if cursor.field_name().is_none()
5718 && cursor.node().is_named()
5719 && !cursor.node().is_extra()
5720 {
5721 result.push(cursor.node());
5722 }
5723 if !cursor.goto_next_sibling() {
5724 break;
5725 }
5726 }
5727 }
5728 result
5729 };
5730 let mut items = ::std::vec::Vec::new();
5731 for child in non_field_children {
5732 items.push(<ObjectChildren as ::treesitter_types::FromNode>::from_node(
5733 child, src,
5734 )?);
5735 }
5736 items
5737 },
5738 })
5739 }
5740}
5741impl ::treesitter_types::Spanned for Object<'_> {
5742 fn span(&self) -> ::treesitter_types::Span {
5743 self.span
5744 }
5745}
5746#[derive(Debug, Clone)]
5747pub struct ObjectAssignmentPattern<'tree> {
5748 pub span: ::treesitter_types::Span,
5749 pub left: ObjectAssignmentPatternLeft<'tree>,
5750 pub right: Expression<'tree>,
5751}
5752impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPattern<'tree> {
5753 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5754 fn from_node(
5755 node: ::tree_sitter::Node<'tree>,
5756 src: &'tree [u8],
5757 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5758 debug_assert_eq!(node.kind(), "object_assignment_pattern");
5759 Ok(Self {
5760 span: ::treesitter_types::Span::from(node),
5761 left: {
5762 let child = node
5763 .child_by_field_name("left")
5764 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
5765 <ObjectAssignmentPatternLeft as ::treesitter_types::FromNode>::from_node(
5766 child, src,
5767 )?
5768 },
5769 right: {
5770 let child = node
5771 .child_by_field_name("right")
5772 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
5773 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5774 },
5775 })
5776 }
5777}
5778impl ::treesitter_types::Spanned for ObjectAssignmentPattern<'_> {
5779 fn span(&self) -> ::treesitter_types::Span {
5780 self.span
5781 }
5782}
5783#[derive(Debug, Clone)]
5784pub struct ObjectPattern<'tree> {
5785 pub span: ::treesitter_types::Span,
5786 pub children: ::std::vec::Vec<ObjectPatternChildren<'tree>>,
5787}
5788impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPattern<'tree> {
5789 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5790 fn from_node(
5791 node: ::tree_sitter::Node<'tree>,
5792 src: &'tree [u8],
5793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5794 debug_assert_eq!(node.kind(), "object_pattern");
5795 Ok(Self {
5796 span: ::treesitter_types::Span::from(node),
5797 children: {
5798 #[allow(clippy::suspicious_else_formatting)]
5799 let non_field_children = {
5800 let mut cursor = node.walk();
5801 let mut result = ::std::vec::Vec::new();
5802 if cursor.goto_first_child() {
5803 loop {
5804 if cursor.field_name().is_none()
5805 && cursor.node().is_named()
5806 && !cursor.node().is_extra()
5807 {
5808 result.push(cursor.node());
5809 }
5810 if !cursor.goto_next_sibling() {
5811 break;
5812 }
5813 }
5814 }
5815 result
5816 };
5817 let mut items = ::std::vec::Vec::new();
5818 for child in non_field_children {
5819 items.push(
5820 <ObjectPatternChildren as ::treesitter_types::FromNode>::from_node(
5821 child, src,
5822 )?,
5823 );
5824 }
5825 items
5826 },
5827 })
5828 }
5829}
5830impl ::treesitter_types::Spanned for ObjectPattern<'_> {
5831 fn span(&self) -> ::treesitter_types::Span {
5832 self.span
5833 }
5834}
5835#[derive(Debug, Clone)]
5836pub struct ObjectType<'tree> {
5837 pub span: ::treesitter_types::Span,
5838 pub children: ::std::vec::Vec<ObjectTypeChildren<'tree>>,
5839}
5840impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectType<'tree> {
5841 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5842 fn from_node(
5843 node: ::tree_sitter::Node<'tree>,
5844 src: &'tree [u8],
5845 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5846 debug_assert_eq!(node.kind(), "object_type");
5847 Ok(Self {
5848 span: ::treesitter_types::Span::from(node),
5849 children: {
5850 #[allow(clippy::suspicious_else_formatting)]
5851 let non_field_children = {
5852 let mut cursor = node.walk();
5853 let mut result = ::std::vec::Vec::new();
5854 if cursor.goto_first_child() {
5855 loop {
5856 if cursor.field_name().is_none()
5857 && cursor.node().is_named()
5858 && !cursor.node().is_extra()
5859 {
5860 result.push(cursor.node());
5861 }
5862 if !cursor.goto_next_sibling() {
5863 break;
5864 }
5865 }
5866 }
5867 result
5868 };
5869 let mut items = ::std::vec::Vec::new();
5870 for child in non_field_children {
5871 items.push(
5872 <ObjectTypeChildren as ::treesitter_types::FromNode>::from_node(
5873 child, src,
5874 )?,
5875 );
5876 }
5877 items
5878 },
5879 })
5880 }
5881}
5882impl ::treesitter_types::Spanned for ObjectType<'_> {
5883 fn span(&self) -> ::treesitter_types::Span {
5884 self.span
5885 }
5886}
5887#[derive(Debug, Clone)]
5888pub struct OmittingTypeAnnotation<'tree> {
5889 pub span: ::treesitter_types::Span,
5890 pub children: Type<'tree>,
5891}
5892impl<'tree> ::treesitter_types::FromNode<'tree> for OmittingTypeAnnotation<'tree> {
5893 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5894 fn from_node(
5895 node: ::tree_sitter::Node<'tree>,
5896 src: &'tree [u8],
5897 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5898 debug_assert_eq!(node.kind(), "omitting_type_annotation");
5899 Ok(Self {
5900 span: ::treesitter_types::Span::from(node),
5901 children: {
5902 #[allow(clippy::suspicious_else_formatting)]
5903 let non_field_children = {
5904 let mut cursor = node.walk();
5905 let mut result = ::std::vec::Vec::new();
5906 if cursor.goto_first_child() {
5907 loop {
5908 if cursor.field_name().is_none()
5909 && cursor.node().is_named()
5910 && !cursor.node().is_extra()
5911 {
5912 result.push(cursor.node());
5913 }
5914 if !cursor.goto_next_sibling() {
5915 break;
5916 }
5917 }
5918 }
5919 result
5920 };
5921 let child = if let Some(&c) = non_field_children.first() {
5922 c
5923 } else {
5924 let mut fallback_cursor = node.walk();
5925 let mut fallback_child = None;
5926 if fallback_cursor.goto_first_child() {
5927 loop {
5928 if fallback_cursor.field_name().is_none()
5929 && !fallback_cursor.node().is_extra()
5930 {
5931 fallback_child = Some(fallback_cursor.node());
5932 break;
5933 }
5934 if !fallback_cursor.goto_next_sibling() {
5935 break;
5936 }
5937 }
5938 }
5939 fallback_child.ok_or_else(|| {
5940 ::treesitter_types::ParseError::missing_field("children", node)
5941 })?
5942 };
5943 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
5944 },
5945 })
5946 }
5947}
5948impl ::treesitter_types::Spanned for OmittingTypeAnnotation<'_> {
5949 fn span(&self) -> ::treesitter_types::Span {
5950 self.span
5951 }
5952}
5953#[derive(Debug, Clone)]
5954pub struct OptingTypeAnnotation<'tree> {
5955 pub span: ::treesitter_types::Span,
5956 pub children: Type<'tree>,
5957}
5958impl<'tree> ::treesitter_types::FromNode<'tree> for OptingTypeAnnotation<'tree> {
5959 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5960 fn from_node(
5961 node: ::tree_sitter::Node<'tree>,
5962 src: &'tree [u8],
5963 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5964 debug_assert_eq!(node.kind(), "opting_type_annotation");
5965 Ok(Self {
5966 span: ::treesitter_types::Span::from(node),
5967 children: {
5968 #[allow(clippy::suspicious_else_formatting)]
5969 let non_field_children = {
5970 let mut cursor = node.walk();
5971 let mut result = ::std::vec::Vec::new();
5972 if cursor.goto_first_child() {
5973 loop {
5974 if cursor.field_name().is_none()
5975 && cursor.node().is_named()
5976 && !cursor.node().is_extra()
5977 {
5978 result.push(cursor.node());
5979 }
5980 if !cursor.goto_next_sibling() {
5981 break;
5982 }
5983 }
5984 }
5985 result
5986 };
5987 let child = if let Some(&c) = non_field_children.first() {
5988 c
5989 } else {
5990 let mut fallback_cursor = node.walk();
5991 let mut fallback_child = None;
5992 if fallback_cursor.goto_first_child() {
5993 loop {
5994 if fallback_cursor.field_name().is_none()
5995 && !fallback_cursor.node().is_extra()
5996 {
5997 fallback_child = Some(fallback_cursor.node());
5998 break;
5999 }
6000 if !fallback_cursor.goto_next_sibling() {
6001 break;
6002 }
6003 }
6004 }
6005 fallback_child.ok_or_else(|| {
6006 ::treesitter_types::ParseError::missing_field("children", node)
6007 })?
6008 };
6009 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6010 },
6011 })
6012 }
6013}
6014impl ::treesitter_types::Spanned for OptingTypeAnnotation<'_> {
6015 fn span(&self) -> ::treesitter_types::Span {
6016 self.span
6017 }
6018}
6019#[derive(Debug, Clone)]
6020pub struct OptionalChain<'tree> {
6021 pub span: ::treesitter_types::Span,
6022 text: &'tree str,
6023}
6024impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalChain<'tree> {
6025 fn from_node(
6026 node: ::tree_sitter::Node<'tree>,
6027 src: &'tree [u8],
6028 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6029 debug_assert_eq!(node.kind(), "optional_chain");
6030 Ok(Self {
6031 span: ::treesitter_types::Span::from(node),
6032 text: node.utf8_text(src)?,
6033 })
6034 }
6035}
6036impl<'tree> ::treesitter_types::LeafNode<'tree> for OptionalChain<'tree> {
6037 fn text(&self) -> &'tree str {
6038 self.text
6039 }
6040}
6041impl ::treesitter_types::Spanned for OptionalChain<'_> {
6042 fn span(&self) -> ::treesitter_types::Span {
6043 self.span
6044 }
6045}
6046#[derive(Debug, Clone)]
6047pub struct OptionalParameter<'tree> {
6048 pub span: ::treesitter_types::Span,
6049 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
6050 pub name: ::core::option::Option<Identifier<'tree>>,
6051 pub pattern: ::core::option::Option<OptionalParameterPattern<'tree>>,
6052 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
6053 pub value: ::core::option::Option<Expression<'tree>>,
6054 pub children: ::std::vec::Vec<OptionalParameterChildren<'tree>>,
6055}
6056impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameter<'tree> {
6057 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6058 fn from_node(
6059 node: ::tree_sitter::Node<'tree>,
6060 src: &'tree [u8],
6061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6062 debug_assert_eq!(node.kind(), "optional_parameter");
6063 Ok(Self {
6064 span: ::treesitter_types::Span::from(node),
6065 decorator: {
6066 let mut cursor = node.walk();
6067 let mut items = ::std::vec::Vec::new();
6068 for child in node.children_by_field_name("decorator", &mut cursor) {
6069 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
6070 child, src,
6071 )?);
6072 }
6073 items
6074 },
6075 name: match node.child_by_field_name("name") {
6076 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
6077 child, src,
6078 )?),
6079 None => None,
6080 },
6081 pattern: match node.child_by_field_name("pattern") {
6082 Some(child) => Some(
6083 <OptionalParameterPattern as ::treesitter_types::FromNode>::from_node(
6084 child, src,
6085 )?,
6086 ),
6087 None => None,
6088 },
6089 r#type: match node.child_by_field_name("type") {
6090 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
6091 child, src,
6092 )?),
6093 None => None,
6094 },
6095 value: match node.child_by_field_name("value") {
6096 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6097 child, src,
6098 )?),
6099 None => None,
6100 },
6101 children: {
6102 #[allow(clippy::suspicious_else_formatting)]
6103 let non_field_children = {
6104 let mut cursor = node.walk();
6105 let mut result = ::std::vec::Vec::new();
6106 if cursor.goto_first_child() {
6107 loop {
6108 if cursor.field_name().is_none()
6109 && cursor.node().is_named()
6110 && !cursor.node().is_extra()
6111 {
6112 result.push(cursor.node());
6113 }
6114 if !cursor.goto_next_sibling() {
6115 break;
6116 }
6117 }
6118 }
6119 result
6120 };
6121 let mut items = ::std::vec::Vec::new();
6122 for child in non_field_children {
6123 items.push(
6124 <OptionalParameterChildren as ::treesitter_types::FromNode>::from_node(
6125 child, src,
6126 )?,
6127 );
6128 }
6129 items
6130 },
6131 })
6132 }
6133}
6134impl ::treesitter_types::Spanned for OptionalParameter<'_> {
6135 fn span(&self) -> ::treesitter_types::Span {
6136 self.span
6137 }
6138}
6139#[derive(Debug, Clone)]
6140pub struct OptionalType<'tree> {
6141 pub span: ::treesitter_types::Span,
6142 pub children: Type<'tree>,
6143}
6144impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalType<'tree> {
6145 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6146 fn from_node(
6147 node: ::tree_sitter::Node<'tree>,
6148 src: &'tree [u8],
6149 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6150 debug_assert_eq!(node.kind(), "optional_type");
6151 Ok(Self {
6152 span: ::treesitter_types::Span::from(node),
6153 children: {
6154 #[allow(clippy::suspicious_else_formatting)]
6155 let non_field_children = {
6156 let mut cursor = node.walk();
6157 let mut result = ::std::vec::Vec::new();
6158 if cursor.goto_first_child() {
6159 loop {
6160 if cursor.field_name().is_none()
6161 && cursor.node().is_named()
6162 && !cursor.node().is_extra()
6163 {
6164 result.push(cursor.node());
6165 }
6166 if !cursor.goto_next_sibling() {
6167 break;
6168 }
6169 }
6170 }
6171 result
6172 };
6173 let child = if let Some(&c) = non_field_children.first() {
6174 c
6175 } else {
6176 let mut fallback_cursor = node.walk();
6177 let mut fallback_child = None;
6178 if fallback_cursor.goto_first_child() {
6179 loop {
6180 if fallback_cursor.field_name().is_none()
6181 && !fallback_cursor.node().is_extra()
6182 {
6183 fallback_child = Some(fallback_cursor.node());
6184 break;
6185 }
6186 if !fallback_cursor.goto_next_sibling() {
6187 break;
6188 }
6189 }
6190 }
6191 fallback_child.ok_or_else(|| {
6192 ::treesitter_types::ParseError::missing_field("children", node)
6193 })?
6194 };
6195 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6196 },
6197 })
6198 }
6199}
6200impl ::treesitter_types::Spanned for OptionalType<'_> {
6201 fn span(&self) -> ::treesitter_types::Span {
6202 self.span
6203 }
6204}
6205#[derive(Debug, Clone)]
6206pub struct OverrideModifier<'tree> {
6207 pub span: ::treesitter_types::Span,
6208 text: &'tree str,
6209}
6210impl<'tree> ::treesitter_types::FromNode<'tree> for OverrideModifier<'tree> {
6211 fn from_node(
6212 node: ::tree_sitter::Node<'tree>,
6213 src: &'tree [u8],
6214 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6215 debug_assert_eq!(node.kind(), "override_modifier");
6216 Ok(Self {
6217 span: ::treesitter_types::Span::from(node),
6218 text: node.utf8_text(src)?,
6219 })
6220 }
6221}
6222impl<'tree> ::treesitter_types::LeafNode<'tree> for OverrideModifier<'tree> {
6223 fn text(&self) -> &'tree str {
6224 self.text
6225 }
6226}
6227impl ::treesitter_types::Spanned for OverrideModifier<'_> {
6228 fn span(&self) -> ::treesitter_types::Span {
6229 self.span
6230 }
6231}
6232#[derive(Debug, Clone)]
6233pub struct Pair<'tree> {
6234 pub span: ::treesitter_types::Span,
6235 pub key: PairKey<'tree>,
6236 pub value: Expression<'tree>,
6237}
6238impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
6239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6240 fn from_node(
6241 node: ::tree_sitter::Node<'tree>,
6242 src: &'tree [u8],
6243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6244 debug_assert_eq!(node.kind(), "pair");
6245 Ok(Self {
6246 span: ::treesitter_types::Span::from(node),
6247 key: {
6248 let child = node
6249 .child_by_field_name("key")
6250 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
6251 <PairKey as ::treesitter_types::FromNode>::from_node(child, src)?
6252 },
6253 value: {
6254 let child = node
6255 .child_by_field_name("value")
6256 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6257 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
6258 },
6259 })
6260 }
6261}
6262impl ::treesitter_types::Spanned for Pair<'_> {
6263 fn span(&self) -> ::treesitter_types::Span {
6264 self.span
6265 }
6266}
6267#[derive(Debug, Clone)]
6268pub struct PairPattern<'tree> {
6269 pub span: ::treesitter_types::Span,
6270 pub key: PairPatternKey<'tree>,
6271 pub value: PairPatternValue<'tree>,
6272}
6273impl<'tree> ::treesitter_types::FromNode<'tree> for PairPattern<'tree> {
6274 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6275 fn from_node(
6276 node: ::tree_sitter::Node<'tree>,
6277 src: &'tree [u8],
6278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6279 debug_assert_eq!(node.kind(), "pair_pattern");
6280 Ok(Self {
6281 span: ::treesitter_types::Span::from(node),
6282 key: {
6283 let child = node
6284 .child_by_field_name("key")
6285 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
6286 <PairPatternKey as ::treesitter_types::FromNode>::from_node(child, src)?
6287 },
6288 value: {
6289 let child = node
6290 .child_by_field_name("value")
6291 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
6292 <PairPatternValue as ::treesitter_types::FromNode>::from_node(child, src)?
6293 },
6294 })
6295 }
6296}
6297impl ::treesitter_types::Spanned for PairPattern<'_> {
6298 fn span(&self) -> ::treesitter_types::Span {
6299 self.span
6300 }
6301}
6302#[derive(Debug, Clone)]
6303pub struct ParenthesizedExpression<'tree> {
6304 pub span: ::treesitter_types::Span,
6305 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
6306 pub children: ParenthesizedExpressionChildren<'tree>,
6307}
6308impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
6309 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6310 fn from_node(
6311 node: ::tree_sitter::Node<'tree>,
6312 src: &'tree [u8],
6313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6314 debug_assert_eq!(node.kind(), "parenthesized_expression");
6315 Ok(Self {
6316 span: ::treesitter_types::Span::from(node),
6317 r#type: match node.child_by_field_name("type") {
6318 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
6319 child, src,
6320 )?),
6321 None => None,
6322 },
6323 children: {
6324 #[allow(clippy::suspicious_else_formatting)]
6325 let non_field_children = {
6326 let mut cursor = node.walk();
6327 let mut result = ::std::vec::Vec::new();
6328 if cursor.goto_first_child() {
6329 loop {
6330 if cursor.field_name().is_none()
6331 && cursor.node().is_named()
6332 && !cursor.node().is_extra()
6333 {
6334 result.push(cursor.node());
6335 }
6336 if !cursor.goto_next_sibling() {
6337 break;
6338 }
6339 }
6340 }
6341 result
6342 };
6343 let child = if let Some(&c) = non_field_children.first() {
6344 c
6345 } else {
6346 let mut fallback_cursor = node.walk();
6347 let mut fallback_child = None;
6348 if fallback_cursor.goto_first_child() {
6349 loop {
6350 if fallback_cursor.field_name().is_none()
6351 && !fallback_cursor.node().is_extra()
6352 {
6353 fallback_child = Some(fallback_cursor.node());
6354 break;
6355 }
6356 if !fallback_cursor.goto_next_sibling() {
6357 break;
6358 }
6359 }
6360 }
6361 fallback_child.ok_or_else(|| {
6362 ::treesitter_types::ParseError::missing_field("children", node)
6363 })?
6364 };
6365 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
6366 child, src,
6367 )?
6368 },
6369 })
6370 }
6371}
6372impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
6373 fn span(&self) -> ::treesitter_types::Span {
6374 self.span
6375 }
6376}
6377#[derive(Debug, Clone)]
6378pub struct ParenthesizedType<'tree> {
6379 pub span: ::treesitter_types::Span,
6380 pub children: Type<'tree>,
6381}
6382impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedType<'tree> {
6383 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6384 fn from_node(
6385 node: ::tree_sitter::Node<'tree>,
6386 src: &'tree [u8],
6387 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6388 debug_assert_eq!(node.kind(), "parenthesized_type");
6389 Ok(Self {
6390 span: ::treesitter_types::Span::from(node),
6391 children: {
6392 #[allow(clippy::suspicious_else_formatting)]
6393 let non_field_children = {
6394 let mut cursor = node.walk();
6395 let mut result = ::std::vec::Vec::new();
6396 if cursor.goto_first_child() {
6397 loop {
6398 if cursor.field_name().is_none()
6399 && cursor.node().is_named()
6400 && !cursor.node().is_extra()
6401 {
6402 result.push(cursor.node());
6403 }
6404 if !cursor.goto_next_sibling() {
6405 break;
6406 }
6407 }
6408 }
6409 result
6410 };
6411 let child = if let Some(&c) = non_field_children.first() {
6412 c
6413 } else {
6414 let mut fallback_cursor = node.walk();
6415 let mut fallback_child = None;
6416 if fallback_cursor.goto_first_child() {
6417 loop {
6418 if fallback_cursor.field_name().is_none()
6419 && !fallback_cursor.node().is_extra()
6420 {
6421 fallback_child = Some(fallback_cursor.node());
6422 break;
6423 }
6424 if !fallback_cursor.goto_next_sibling() {
6425 break;
6426 }
6427 }
6428 }
6429 fallback_child.ok_or_else(|| {
6430 ::treesitter_types::ParseError::missing_field("children", node)
6431 })?
6432 };
6433 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6434 },
6435 })
6436 }
6437}
6438impl ::treesitter_types::Spanned for ParenthesizedType<'_> {
6439 fn span(&self) -> ::treesitter_types::Span {
6440 self.span
6441 }
6442}
6443#[derive(Debug, Clone)]
6444pub struct PredefinedType<'tree> {
6445 pub span: ::treesitter_types::Span,
6446 text: &'tree str,
6447}
6448impl<'tree> ::treesitter_types::FromNode<'tree> for PredefinedType<'tree> {
6449 fn from_node(
6450 node: ::tree_sitter::Node<'tree>,
6451 src: &'tree [u8],
6452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6453 debug_assert_eq!(node.kind(), "predefined_type");
6454 Ok(Self {
6455 span: ::treesitter_types::Span::from(node),
6456 text: node.utf8_text(src)?,
6457 })
6458 }
6459}
6460impl<'tree> ::treesitter_types::LeafNode<'tree> for PredefinedType<'tree> {
6461 fn text(&self) -> &'tree str {
6462 self.text
6463 }
6464}
6465impl ::treesitter_types::Spanned for PredefinedType<'_> {
6466 fn span(&self) -> ::treesitter_types::Span {
6467 self.span
6468 }
6469}
6470#[derive(Debug, Clone)]
6471pub struct Program<'tree> {
6472 pub span: ::treesitter_types::Span,
6473 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
6474}
6475impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
6476 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6477 fn from_node(
6478 node: ::tree_sitter::Node<'tree>,
6479 src: &'tree [u8],
6480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6481 debug_assert_eq!(node.kind(), "program");
6482 Ok(Self {
6483 span: ::treesitter_types::Span::from(node),
6484 children: {
6485 #[allow(clippy::suspicious_else_formatting)]
6486 let non_field_children = {
6487 let mut cursor = node.walk();
6488 let mut result = ::std::vec::Vec::new();
6489 if cursor.goto_first_child() {
6490 loop {
6491 if cursor.field_name().is_none()
6492 && cursor.node().is_named()
6493 && !cursor.node().is_extra()
6494 {
6495 result.push(cursor.node());
6496 }
6497 if !cursor.goto_next_sibling() {
6498 break;
6499 }
6500 }
6501 }
6502 result
6503 };
6504 let mut items = ::std::vec::Vec::new();
6505 for child in non_field_children {
6506 items.push(
6507 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
6508 );
6509 }
6510 items
6511 },
6512 })
6513 }
6514}
6515impl ::treesitter_types::Spanned for Program<'_> {
6516 fn span(&self) -> ::treesitter_types::Span {
6517 self.span
6518 }
6519}
6520#[derive(Debug, Clone)]
6521pub struct PropertySignature<'tree> {
6522 pub span: ::treesitter_types::Span,
6523 pub name: PropertySignatureName<'tree>,
6524 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
6525 pub children: ::std::vec::Vec<PropertySignatureChildren<'tree>>,
6526}
6527impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignature<'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(), "property_signature");
6534 Ok(Self {
6535 span: ::treesitter_types::Span::from(node),
6536 name: {
6537 let child = node
6538 .child_by_field_name("name")
6539 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6540 <PropertySignatureName as ::treesitter_types::FromNode>::from_node(child, src)?
6541 },
6542 r#type: match node.child_by_field_name("type") {
6543 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
6544 child, src,
6545 )?),
6546 None => None,
6547 },
6548 children: {
6549 #[allow(clippy::suspicious_else_formatting)]
6550 let non_field_children = {
6551 let mut cursor = node.walk();
6552 let mut result = ::std::vec::Vec::new();
6553 if cursor.goto_first_child() {
6554 loop {
6555 if cursor.field_name().is_none()
6556 && cursor.node().is_named()
6557 && !cursor.node().is_extra()
6558 {
6559 result.push(cursor.node());
6560 }
6561 if !cursor.goto_next_sibling() {
6562 break;
6563 }
6564 }
6565 }
6566 result
6567 };
6568 let mut items = ::std::vec::Vec::new();
6569 for child in non_field_children {
6570 items.push(
6571 <PropertySignatureChildren as ::treesitter_types::FromNode>::from_node(
6572 child, src,
6573 )?,
6574 );
6575 }
6576 items
6577 },
6578 })
6579 }
6580}
6581impl ::treesitter_types::Spanned for PropertySignature<'_> {
6582 fn span(&self) -> ::treesitter_types::Span {
6583 self.span
6584 }
6585}
6586#[derive(Debug, Clone)]
6587pub struct PublicFieldDefinition<'tree> {
6588 pub span: ::treesitter_types::Span,
6589 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
6590 pub name: PublicFieldDefinitionName<'tree>,
6591 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
6592 pub value: ::core::option::Option<Expression<'tree>>,
6593 pub children: ::std::vec::Vec<PublicFieldDefinitionChildren<'tree>>,
6594}
6595impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinition<'tree> {
6596 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6597 fn from_node(
6598 node: ::tree_sitter::Node<'tree>,
6599 src: &'tree [u8],
6600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6601 debug_assert_eq!(node.kind(), "public_field_definition");
6602 Ok(Self {
6603 span: ::treesitter_types::Span::from(node),
6604 decorator: {
6605 let mut cursor = node.walk();
6606 let mut items = ::std::vec::Vec::new();
6607 for child in node.children_by_field_name("decorator", &mut cursor) {
6608 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
6609 child, src,
6610 )?);
6611 }
6612 items
6613 },
6614 name: {
6615 let child = node
6616 .child_by_field_name("name")
6617 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
6618 <PublicFieldDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)?
6619 },
6620 r#type: match node.child_by_field_name("type") {
6621 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
6622 child, src,
6623 )?),
6624 None => None,
6625 },
6626 value: match node.child_by_field_name("value") {
6627 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6628 child, src,
6629 )?),
6630 None => None,
6631 },
6632 children: {
6633 #[allow(clippy::suspicious_else_formatting)]
6634 let non_field_children = {
6635 let mut cursor = node.walk();
6636 let mut result = ::std::vec::Vec::new();
6637 if cursor.goto_first_child() {
6638 loop {
6639 if cursor.field_name().is_none()
6640 && cursor.node().is_named()
6641 && !cursor.node().is_extra()
6642 {
6643 result.push(cursor.node());
6644 }
6645 if !cursor.goto_next_sibling() {
6646 break;
6647 }
6648 }
6649 }
6650 result
6651 };
6652 let mut items = ::std::vec::Vec::new();
6653 for child in non_field_children {
6654 items.push(
6655 <PublicFieldDefinitionChildren as ::treesitter_types::FromNode>::from_node(
6656 child, src,
6657 )?,
6658 );
6659 }
6660 items
6661 },
6662 })
6663 }
6664}
6665impl ::treesitter_types::Spanned for PublicFieldDefinition<'_> {
6666 fn span(&self) -> ::treesitter_types::Span {
6667 self.span
6668 }
6669}
6670#[derive(Debug, Clone)]
6671pub struct ReadonlyType<'tree> {
6672 pub span: ::treesitter_types::Span,
6673 pub children: Type<'tree>,
6674}
6675impl<'tree> ::treesitter_types::FromNode<'tree> for ReadonlyType<'tree> {
6676 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6677 fn from_node(
6678 node: ::tree_sitter::Node<'tree>,
6679 src: &'tree [u8],
6680 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6681 debug_assert_eq!(node.kind(), "readonly_type");
6682 Ok(Self {
6683 span: ::treesitter_types::Span::from(node),
6684 children: {
6685 #[allow(clippy::suspicious_else_formatting)]
6686 let non_field_children = {
6687 let mut cursor = node.walk();
6688 let mut result = ::std::vec::Vec::new();
6689 if cursor.goto_first_child() {
6690 loop {
6691 if cursor.field_name().is_none()
6692 && cursor.node().is_named()
6693 && !cursor.node().is_extra()
6694 {
6695 result.push(cursor.node());
6696 }
6697 if !cursor.goto_next_sibling() {
6698 break;
6699 }
6700 }
6701 }
6702 result
6703 };
6704 let child = if let Some(&c) = non_field_children.first() {
6705 c
6706 } else {
6707 let mut fallback_cursor = node.walk();
6708 let mut fallback_child = None;
6709 if fallback_cursor.goto_first_child() {
6710 loop {
6711 if fallback_cursor.field_name().is_none()
6712 && !fallback_cursor.node().is_extra()
6713 {
6714 fallback_child = Some(fallback_cursor.node());
6715 break;
6716 }
6717 if !fallback_cursor.goto_next_sibling() {
6718 break;
6719 }
6720 }
6721 }
6722 fallback_child.ok_or_else(|| {
6723 ::treesitter_types::ParseError::missing_field("children", node)
6724 })?
6725 };
6726 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6727 },
6728 })
6729 }
6730}
6731impl ::treesitter_types::Spanned for ReadonlyType<'_> {
6732 fn span(&self) -> ::treesitter_types::Span {
6733 self.span
6734 }
6735}
6736#[derive(Debug, Clone)]
6737pub struct Regex<'tree> {
6738 pub span: ::treesitter_types::Span,
6739 pub flags: ::core::option::Option<RegexFlags<'tree>>,
6740 pub pattern: RegexPattern<'tree>,
6741}
6742impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
6743 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6744 fn from_node(
6745 node: ::tree_sitter::Node<'tree>,
6746 src: &'tree [u8],
6747 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6748 debug_assert_eq!(node.kind(), "regex");
6749 Ok(Self {
6750 span: ::treesitter_types::Span::from(node),
6751 flags: match node.child_by_field_name("flags") {
6752 Some(child) => Some(<RegexFlags as ::treesitter_types::FromNode>::from_node(
6753 child, src,
6754 )?),
6755 None => None,
6756 },
6757 pattern: {
6758 let child = node.child_by_field_name("pattern").ok_or_else(|| {
6759 ::treesitter_types::ParseError::missing_field("pattern", node)
6760 })?;
6761 <RegexPattern as ::treesitter_types::FromNode>::from_node(child, src)?
6762 },
6763 })
6764 }
6765}
6766impl ::treesitter_types::Spanned for Regex<'_> {
6767 fn span(&self) -> ::treesitter_types::Span {
6768 self.span
6769 }
6770}
6771#[derive(Debug, Clone)]
6772pub struct RequiredParameter<'tree> {
6773 pub span: ::treesitter_types::Span,
6774 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
6775 pub name: ::core::option::Option<RequiredParameterName<'tree>>,
6776 pub pattern: ::core::option::Option<RequiredParameterPattern<'tree>>,
6777 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
6778 pub value: ::core::option::Option<Expression<'tree>>,
6779 pub children: ::std::vec::Vec<RequiredParameterChildren<'tree>>,
6780}
6781impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameter<'tree> {
6782 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6783 fn from_node(
6784 node: ::tree_sitter::Node<'tree>,
6785 src: &'tree [u8],
6786 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6787 debug_assert_eq!(node.kind(), "required_parameter");
6788 Ok(Self {
6789 span: ::treesitter_types::Span::from(node),
6790 decorator: {
6791 let mut cursor = node.walk();
6792 let mut items = ::std::vec::Vec::new();
6793 for child in node.children_by_field_name("decorator", &mut cursor) {
6794 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
6795 child, src,
6796 )?);
6797 }
6798 items
6799 },
6800 name: match node.child_by_field_name("name") {
6801 Some(child) => Some(
6802 <RequiredParameterName as ::treesitter_types::FromNode>::from_node(child, src)?,
6803 ),
6804 None => None,
6805 },
6806 pattern: match node.child_by_field_name("pattern") {
6807 Some(child) => Some(
6808 <RequiredParameterPattern as ::treesitter_types::FromNode>::from_node(
6809 child, src,
6810 )?,
6811 ),
6812 None => None,
6813 },
6814 r#type: match node.child_by_field_name("type") {
6815 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
6816 child, src,
6817 )?),
6818 None => None,
6819 },
6820 value: match node.child_by_field_name("value") {
6821 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
6822 child, src,
6823 )?),
6824 None => None,
6825 },
6826 children: {
6827 #[allow(clippy::suspicious_else_formatting)]
6828 let non_field_children = {
6829 let mut cursor = node.walk();
6830 let mut result = ::std::vec::Vec::new();
6831 if cursor.goto_first_child() {
6832 loop {
6833 if cursor.field_name().is_none()
6834 && cursor.node().is_named()
6835 && !cursor.node().is_extra()
6836 {
6837 result.push(cursor.node());
6838 }
6839 if !cursor.goto_next_sibling() {
6840 break;
6841 }
6842 }
6843 }
6844 result
6845 };
6846 let mut items = ::std::vec::Vec::new();
6847 for child in non_field_children {
6848 items.push(
6849 <RequiredParameterChildren as ::treesitter_types::FromNode>::from_node(
6850 child, src,
6851 )?,
6852 );
6853 }
6854 items
6855 },
6856 })
6857 }
6858}
6859impl ::treesitter_types::Spanned for RequiredParameter<'_> {
6860 fn span(&self) -> ::treesitter_types::Span {
6861 self.span
6862 }
6863}
6864#[derive(Debug, Clone)]
6865pub struct RestPattern<'tree> {
6866 pub span: ::treesitter_types::Span,
6867 pub children: RestPatternChildren<'tree>,
6868}
6869impl<'tree> ::treesitter_types::FromNode<'tree> for RestPattern<'tree> {
6870 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6871 fn from_node(
6872 node: ::tree_sitter::Node<'tree>,
6873 src: &'tree [u8],
6874 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6875 debug_assert_eq!(node.kind(), "rest_pattern");
6876 Ok(Self {
6877 span: ::treesitter_types::Span::from(node),
6878 children: {
6879 #[allow(clippy::suspicious_else_formatting)]
6880 let non_field_children = {
6881 let mut cursor = node.walk();
6882 let mut result = ::std::vec::Vec::new();
6883 if cursor.goto_first_child() {
6884 loop {
6885 if cursor.field_name().is_none()
6886 && cursor.node().is_named()
6887 && !cursor.node().is_extra()
6888 {
6889 result.push(cursor.node());
6890 }
6891 if !cursor.goto_next_sibling() {
6892 break;
6893 }
6894 }
6895 }
6896 result
6897 };
6898 let child = if let Some(&c) = non_field_children.first() {
6899 c
6900 } else {
6901 let mut fallback_cursor = node.walk();
6902 let mut fallback_child = None;
6903 if fallback_cursor.goto_first_child() {
6904 loop {
6905 if fallback_cursor.field_name().is_none()
6906 && !fallback_cursor.node().is_extra()
6907 {
6908 fallback_child = Some(fallback_cursor.node());
6909 break;
6910 }
6911 if !fallback_cursor.goto_next_sibling() {
6912 break;
6913 }
6914 }
6915 }
6916 fallback_child.ok_or_else(|| {
6917 ::treesitter_types::ParseError::missing_field("children", node)
6918 })?
6919 };
6920 <RestPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
6921 },
6922 })
6923 }
6924}
6925impl ::treesitter_types::Spanned for RestPattern<'_> {
6926 fn span(&self) -> ::treesitter_types::Span {
6927 self.span
6928 }
6929}
6930#[derive(Debug, Clone)]
6931pub struct RestType<'tree> {
6932 pub span: ::treesitter_types::Span,
6933 pub children: Type<'tree>,
6934}
6935impl<'tree> ::treesitter_types::FromNode<'tree> for RestType<'tree> {
6936 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
6937 fn from_node(
6938 node: ::tree_sitter::Node<'tree>,
6939 src: &'tree [u8],
6940 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6941 debug_assert_eq!(node.kind(), "rest_type");
6942 Ok(Self {
6943 span: ::treesitter_types::Span::from(node),
6944 children: {
6945 #[allow(clippy::suspicious_else_formatting)]
6946 let non_field_children = {
6947 let mut cursor = node.walk();
6948 let mut result = ::std::vec::Vec::new();
6949 if cursor.goto_first_child() {
6950 loop {
6951 if cursor.field_name().is_none()
6952 && cursor.node().is_named()
6953 && !cursor.node().is_extra()
6954 {
6955 result.push(cursor.node());
6956 }
6957 if !cursor.goto_next_sibling() {
6958 break;
6959 }
6960 }
6961 }
6962 result
6963 };
6964 let child = if let Some(&c) = non_field_children.first() {
6965 c
6966 } else {
6967 let mut fallback_cursor = node.walk();
6968 let mut fallback_child = None;
6969 if fallback_cursor.goto_first_child() {
6970 loop {
6971 if fallback_cursor.field_name().is_none()
6972 && !fallback_cursor.node().is_extra()
6973 {
6974 fallback_child = Some(fallback_cursor.node());
6975 break;
6976 }
6977 if !fallback_cursor.goto_next_sibling() {
6978 break;
6979 }
6980 }
6981 }
6982 fallback_child.ok_or_else(|| {
6983 ::treesitter_types::ParseError::missing_field("children", node)
6984 })?
6985 };
6986 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
6987 },
6988 })
6989 }
6990}
6991impl ::treesitter_types::Spanned for RestType<'_> {
6992 fn span(&self) -> ::treesitter_types::Span {
6993 self.span
6994 }
6995}
6996#[derive(Debug, Clone)]
6997pub struct ReturnStatement<'tree> {
6998 pub span: ::treesitter_types::Span,
6999 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
7000}
7001impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
7002 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7003 fn from_node(
7004 node: ::tree_sitter::Node<'tree>,
7005 src: &'tree [u8],
7006 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7007 debug_assert_eq!(node.kind(), "return_statement");
7008 Ok(Self {
7009 span: ::treesitter_types::Span::from(node),
7010 children: {
7011 #[allow(clippy::suspicious_else_formatting)]
7012 let non_field_children = {
7013 let mut cursor = node.walk();
7014 let mut result = ::std::vec::Vec::new();
7015 if cursor.goto_first_child() {
7016 loop {
7017 if cursor.field_name().is_none()
7018 && cursor.node().is_named()
7019 && !cursor.node().is_extra()
7020 {
7021 result.push(cursor.node());
7022 }
7023 if !cursor.goto_next_sibling() {
7024 break;
7025 }
7026 }
7027 }
7028 result
7029 };
7030 match non_field_children.first() {
7031 Some(&child) => Some(
7032 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
7033 child, src,
7034 )?,
7035 ),
7036 None => None,
7037 }
7038 },
7039 })
7040 }
7041}
7042impl ::treesitter_types::Spanned for ReturnStatement<'_> {
7043 fn span(&self) -> ::treesitter_types::Span {
7044 self.span
7045 }
7046}
7047#[derive(Debug, Clone)]
7048pub struct SatisfiesExpression<'tree> {
7049 pub span: ::treesitter_types::Span,
7050 pub children: ::std::vec::Vec<SatisfiesExpressionChildren<'tree>>,
7051}
7052impl<'tree> ::treesitter_types::FromNode<'tree> for SatisfiesExpression<'tree> {
7053 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7054 fn from_node(
7055 node: ::tree_sitter::Node<'tree>,
7056 src: &'tree [u8],
7057 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7058 debug_assert_eq!(node.kind(), "satisfies_expression");
7059 Ok(Self {
7060 span: ::treesitter_types::Span::from(node),
7061 children: {
7062 #[allow(clippy::suspicious_else_formatting)]
7063 let non_field_children = {
7064 let mut cursor = node.walk();
7065 let mut result = ::std::vec::Vec::new();
7066 if cursor.goto_first_child() {
7067 loop {
7068 if cursor.field_name().is_none()
7069 && cursor.node().is_named()
7070 && !cursor.node().is_extra()
7071 {
7072 result.push(cursor.node());
7073 }
7074 if !cursor.goto_next_sibling() {
7075 break;
7076 }
7077 }
7078 }
7079 result
7080 };
7081 let mut items = ::std::vec::Vec::new();
7082 for child in non_field_children {
7083 items.push(
7084 <SatisfiesExpressionChildren as ::treesitter_types::FromNode>::from_node(
7085 child, src,
7086 )?,
7087 );
7088 }
7089 items
7090 },
7091 })
7092 }
7093}
7094impl ::treesitter_types::Spanned for SatisfiesExpression<'_> {
7095 fn span(&self) -> ::treesitter_types::Span {
7096 self.span
7097 }
7098}
7099#[derive(Debug, Clone)]
7100pub struct SequenceExpression<'tree> {
7101 pub span: ::treesitter_types::Span,
7102 pub children: ::std::vec::Vec<Expression<'tree>>,
7103}
7104impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
7105 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7106 fn from_node(
7107 node: ::tree_sitter::Node<'tree>,
7108 src: &'tree [u8],
7109 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7110 debug_assert_eq!(node.kind(), "sequence_expression");
7111 Ok(Self {
7112 span: ::treesitter_types::Span::from(node),
7113 children: {
7114 #[allow(clippy::suspicious_else_formatting)]
7115 let non_field_children = {
7116 let mut cursor = node.walk();
7117 let mut result = ::std::vec::Vec::new();
7118 if cursor.goto_first_child() {
7119 loop {
7120 if cursor.field_name().is_none()
7121 && cursor.node().is_named()
7122 && !cursor.node().is_extra()
7123 {
7124 result.push(cursor.node());
7125 }
7126 if !cursor.goto_next_sibling() {
7127 break;
7128 }
7129 }
7130 }
7131 result
7132 };
7133 let mut items = ::std::vec::Vec::new();
7134 for child in non_field_children {
7135 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
7136 child, src,
7137 )?);
7138 }
7139 items
7140 },
7141 })
7142 }
7143}
7144impl ::treesitter_types::Spanned for SequenceExpression<'_> {
7145 fn span(&self) -> ::treesitter_types::Span {
7146 self.span
7147 }
7148}
7149#[derive(Debug, Clone)]
7150pub struct SpreadElement<'tree> {
7151 pub span: ::treesitter_types::Span,
7152 pub children: Expression<'tree>,
7153}
7154impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadElement<'tree> {
7155 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7156 fn from_node(
7157 node: ::tree_sitter::Node<'tree>,
7158 src: &'tree [u8],
7159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7160 debug_assert_eq!(node.kind(), "spread_element");
7161 Ok(Self {
7162 span: ::treesitter_types::Span::from(node),
7163 children: {
7164 #[allow(clippy::suspicious_else_formatting)]
7165 let non_field_children = {
7166 let mut cursor = node.walk();
7167 let mut result = ::std::vec::Vec::new();
7168 if cursor.goto_first_child() {
7169 loop {
7170 if cursor.field_name().is_none()
7171 && cursor.node().is_named()
7172 && !cursor.node().is_extra()
7173 {
7174 result.push(cursor.node());
7175 }
7176 if !cursor.goto_next_sibling() {
7177 break;
7178 }
7179 }
7180 }
7181 result
7182 };
7183 let child = if let Some(&c) = non_field_children.first() {
7184 c
7185 } else {
7186 let mut fallback_cursor = node.walk();
7187 let mut fallback_child = None;
7188 if fallback_cursor.goto_first_child() {
7189 loop {
7190 if fallback_cursor.field_name().is_none()
7191 && !fallback_cursor.node().is_extra()
7192 {
7193 fallback_child = Some(fallback_cursor.node());
7194 break;
7195 }
7196 if !fallback_cursor.goto_next_sibling() {
7197 break;
7198 }
7199 }
7200 }
7201 fallback_child.ok_or_else(|| {
7202 ::treesitter_types::ParseError::missing_field("children", node)
7203 })?
7204 };
7205 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7206 },
7207 })
7208 }
7209}
7210impl ::treesitter_types::Spanned for SpreadElement<'_> {
7211 fn span(&self) -> ::treesitter_types::Span {
7212 self.span
7213 }
7214}
7215#[derive(Debug, Clone)]
7216pub struct StatementBlock<'tree> {
7217 pub span: ::treesitter_types::Span,
7218 pub children: ::std::vec::Vec<Statement<'tree>>,
7219}
7220impl<'tree> ::treesitter_types::FromNode<'tree> for StatementBlock<'tree> {
7221 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7222 fn from_node(
7223 node: ::tree_sitter::Node<'tree>,
7224 src: &'tree [u8],
7225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7226 debug_assert_eq!(node.kind(), "statement_block");
7227 Ok(Self {
7228 span: ::treesitter_types::Span::from(node),
7229 children: {
7230 #[allow(clippy::suspicious_else_formatting)]
7231 let non_field_children = {
7232 let mut cursor = node.walk();
7233 let mut result = ::std::vec::Vec::new();
7234 if cursor.goto_first_child() {
7235 loop {
7236 if cursor.field_name().is_none()
7237 && cursor.node().is_named()
7238 && !cursor.node().is_extra()
7239 {
7240 result.push(cursor.node());
7241 }
7242 if !cursor.goto_next_sibling() {
7243 break;
7244 }
7245 }
7246 }
7247 result
7248 };
7249 let mut items = ::std::vec::Vec::new();
7250 for child in non_field_children {
7251 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
7252 child, src,
7253 )?);
7254 }
7255 items
7256 },
7257 })
7258 }
7259}
7260impl ::treesitter_types::Spanned for StatementBlock<'_> {
7261 fn span(&self) -> ::treesitter_types::Span {
7262 self.span
7263 }
7264}
7265#[derive(Debug, Clone)]
7266pub struct String<'tree> {
7267 pub span: ::treesitter_types::Span,
7268 pub children: ::std::vec::Vec<StringChildren<'tree>>,
7269}
7270impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
7271 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7272 fn from_node(
7273 node: ::tree_sitter::Node<'tree>,
7274 src: &'tree [u8],
7275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7276 debug_assert_eq!(node.kind(), "string");
7277 Ok(Self {
7278 span: ::treesitter_types::Span::from(node),
7279 children: {
7280 #[allow(clippy::suspicious_else_formatting)]
7281 let non_field_children = {
7282 let mut cursor = node.walk();
7283 let mut result = ::std::vec::Vec::new();
7284 if cursor.goto_first_child() {
7285 loop {
7286 if cursor.field_name().is_none()
7287 && cursor.node().is_named()
7288 && !cursor.node().is_extra()
7289 {
7290 result.push(cursor.node());
7291 }
7292 if !cursor.goto_next_sibling() {
7293 break;
7294 }
7295 }
7296 }
7297 result
7298 };
7299 let mut items = ::std::vec::Vec::new();
7300 for child in non_field_children {
7301 items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
7302 child, src,
7303 )?);
7304 }
7305 items
7306 },
7307 })
7308 }
7309}
7310impl ::treesitter_types::Spanned for String<'_> {
7311 fn span(&self) -> ::treesitter_types::Span {
7312 self.span
7313 }
7314}
7315#[derive(Debug, Clone)]
7316pub struct SubscriptExpression<'tree> {
7317 pub span: ::treesitter_types::Span,
7318 pub index: SubscriptExpressionIndex<'tree>,
7319 pub object: Expression<'tree>,
7320 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
7321}
7322impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
7323 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7324 fn from_node(
7325 node: ::tree_sitter::Node<'tree>,
7326 src: &'tree [u8],
7327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7328 debug_assert_eq!(node.kind(), "subscript_expression");
7329 Ok(Self {
7330 span: ::treesitter_types::Span::from(node),
7331 index: {
7332 let child = node
7333 .child_by_field_name("index")
7334 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
7335 <SubscriptExpressionIndex as ::treesitter_types::FromNode>::from_node(child, src)?
7336 },
7337 object: {
7338 let child = node
7339 .child_by_field_name("object")
7340 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
7341 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7342 },
7343 optional_chain: match node.child_by_field_name("optional_chain") {
7344 Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
7345 child, src,
7346 )?),
7347 None => None,
7348 },
7349 })
7350 }
7351}
7352impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
7353 fn span(&self) -> ::treesitter_types::Span {
7354 self.span
7355 }
7356}
7357#[derive(Debug, Clone)]
7358pub struct SwitchBody<'tree> {
7359 pub span: ::treesitter_types::Span,
7360 pub children: ::std::vec::Vec<SwitchBodyChildren<'tree>>,
7361}
7362impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
7363 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7364 fn from_node(
7365 node: ::tree_sitter::Node<'tree>,
7366 src: &'tree [u8],
7367 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7368 debug_assert_eq!(node.kind(), "switch_body");
7369 Ok(Self {
7370 span: ::treesitter_types::Span::from(node),
7371 children: {
7372 #[allow(clippy::suspicious_else_formatting)]
7373 let non_field_children = {
7374 let mut cursor = node.walk();
7375 let mut result = ::std::vec::Vec::new();
7376 if cursor.goto_first_child() {
7377 loop {
7378 if cursor.field_name().is_none()
7379 && cursor.node().is_named()
7380 && !cursor.node().is_extra()
7381 {
7382 result.push(cursor.node());
7383 }
7384 if !cursor.goto_next_sibling() {
7385 break;
7386 }
7387 }
7388 }
7389 result
7390 };
7391 let mut items = ::std::vec::Vec::new();
7392 for child in non_field_children {
7393 items.push(
7394 <SwitchBodyChildren as ::treesitter_types::FromNode>::from_node(
7395 child, src,
7396 )?,
7397 );
7398 }
7399 items
7400 },
7401 })
7402 }
7403}
7404impl ::treesitter_types::Spanned for SwitchBody<'_> {
7405 fn span(&self) -> ::treesitter_types::Span {
7406 self.span
7407 }
7408}
7409#[derive(Debug, Clone)]
7410pub struct SwitchCase<'tree> {
7411 pub span: ::treesitter_types::Span,
7412 pub body: ::std::vec::Vec<Statement<'tree>>,
7413 pub value: SwitchCaseValue<'tree>,
7414}
7415impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCase<'tree> {
7416 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7417 fn from_node(
7418 node: ::tree_sitter::Node<'tree>,
7419 src: &'tree [u8],
7420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7421 debug_assert_eq!(node.kind(), "switch_case");
7422 Ok(Self {
7423 span: ::treesitter_types::Span::from(node),
7424 body: {
7425 let mut cursor = node.walk();
7426 let mut items = ::std::vec::Vec::new();
7427 for child in node.children_by_field_name("body", &mut cursor) {
7428 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
7429 child, src,
7430 )?);
7431 }
7432 items
7433 },
7434 value: {
7435 let child = node
7436 .child_by_field_name("value")
7437 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
7438 <SwitchCaseValue as ::treesitter_types::FromNode>::from_node(child, src)?
7439 },
7440 })
7441 }
7442}
7443impl ::treesitter_types::Spanned for SwitchCase<'_> {
7444 fn span(&self) -> ::treesitter_types::Span {
7445 self.span
7446 }
7447}
7448#[derive(Debug, Clone)]
7449pub struct SwitchDefault<'tree> {
7450 pub span: ::treesitter_types::Span,
7451 pub body: ::std::vec::Vec<Statement<'tree>>,
7452}
7453impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchDefault<'tree> {
7454 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7455 fn from_node(
7456 node: ::tree_sitter::Node<'tree>,
7457 src: &'tree [u8],
7458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7459 debug_assert_eq!(node.kind(), "switch_default");
7460 Ok(Self {
7461 span: ::treesitter_types::Span::from(node),
7462 body: {
7463 let mut cursor = node.walk();
7464 let mut items = ::std::vec::Vec::new();
7465 for child in node.children_by_field_name("body", &mut cursor) {
7466 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
7467 child, src,
7468 )?);
7469 }
7470 items
7471 },
7472 })
7473 }
7474}
7475impl ::treesitter_types::Spanned for SwitchDefault<'_> {
7476 fn span(&self) -> ::treesitter_types::Span {
7477 self.span
7478 }
7479}
7480#[derive(Debug, Clone)]
7481pub struct SwitchStatement<'tree> {
7482 pub span: ::treesitter_types::Span,
7483 pub body: SwitchBody<'tree>,
7484 pub value: ParenthesizedExpression<'tree>,
7485}
7486impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
7487 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7488 fn from_node(
7489 node: ::tree_sitter::Node<'tree>,
7490 src: &'tree [u8],
7491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7492 debug_assert_eq!(node.kind(), "switch_statement");
7493 Ok(Self {
7494 span: ::treesitter_types::Span::from(node),
7495 body: {
7496 let child = node
7497 .child_by_field_name("body")
7498 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7499 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)?
7500 },
7501 value: {
7502 let child = node
7503 .child_by_field_name("value")
7504 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
7505 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
7506 },
7507 })
7508 }
7509}
7510impl ::treesitter_types::Spanned for SwitchStatement<'_> {
7511 fn span(&self) -> ::treesitter_types::Span {
7512 self.span
7513 }
7514}
7515#[derive(Debug, Clone)]
7516pub struct TemplateLiteralType<'tree> {
7517 pub span: ::treesitter_types::Span,
7518 pub children: ::std::vec::Vec<TemplateLiteralTypeChildren<'tree>>,
7519}
7520impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateLiteralType<'tree> {
7521 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7522 fn from_node(
7523 node: ::tree_sitter::Node<'tree>,
7524 src: &'tree [u8],
7525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7526 debug_assert_eq!(node.kind(), "template_literal_type");
7527 Ok(Self {
7528 span: ::treesitter_types::Span::from(node),
7529 children: {
7530 #[allow(clippy::suspicious_else_formatting)]
7531 let non_field_children = {
7532 let mut cursor = node.walk();
7533 let mut result = ::std::vec::Vec::new();
7534 if cursor.goto_first_child() {
7535 loop {
7536 if cursor.field_name().is_none()
7537 && cursor.node().is_named()
7538 && !cursor.node().is_extra()
7539 {
7540 result.push(cursor.node());
7541 }
7542 if !cursor.goto_next_sibling() {
7543 break;
7544 }
7545 }
7546 }
7547 result
7548 };
7549 let mut items = ::std::vec::Vec::new();
7550 for child in non_field_children {
7551 items.push(
7552 <TemplateLiteralTypeChildren as ::treesitter_types::FromNode>::from_node(
7553 child, src,
7554 )?,
7555 );
7556 }
7557 items
7558 },
7559 })
7560 }
7561}
7562impl ::treesitter_types::Spanned for TemplateLiteralType<'_> {
7563 fn span(&self) -> ::treesitter_types::Span {
7564 self.span
7565 }
7566}
7567#[derive(Debug, Clone)]
7568pub struct TemplateString<'tree> {
7569 pub span: ::treesitter_types::Span,
7570 pub children: ::std::vec::Vec<TemplateStringChildren<'tree>>,
7571}
7572impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateString<'tree> {
7573 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7574 fn from_node(
7575 node: ::tree_sitter::Node<'tree>,
7576 src: &'tree [u8],
7577 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7578 debug_assert_eq!(node.kind(), "template_string");
7579 Ok(Self {
7580 span: ::treesitter_types::Span::from(node),
7581 children: {
7582 #[allow(clippy::suspicious_else_formatting)]
7583 let non_field_children = {
7584 let mut cursor = node.walk();
7585 let mut result = ::std::vec::Vec::new();
7586 if cursor.goto_first_child() {
7587 loop {
7588 if cursor.field_name().is_none()
7589 && cursor.node().is_named()
7590 && !cursor.node().is_extra()
7591 {
7592 result.push(cursor.node());
7593 }
7594 if !cursor.goto_next_sibling() {
7595 break;
7596 }
7597 }
7598 }
7599 result
7600 };
7601 let mut items = ::std::vec::Vec::new();
7602 for child in non_field_children {
7603 items.push(
7604 <TemplateStringChildren as ::treesitter_types::FromNode>::from_node(
7605 child, src,
7606 )?,
7607 );
7608 }
7609 items
7610 },
7611 })
7612 }
7613}
7614impl ::treesitter_types::Spanned for TemplateString<'_> {
7615 fn span(&self) -> ::treesitter_types::Span {
7616 self.span
7617 }
7618}
7619#[derive(Debug, Clone)]
7620pub struct TemplateSubstitution<'tree> {
7621 pub span: ::treesitter_types::Span,
7622 pub children: TemplateSubstitutionChildren<'tree>,
7623}
7624impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitution<'tree> {
7625 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7626 fn from_node(
7627 node: ::tree_sitter::Node<'tree>,
7628 src: &'tree [u8],
7629 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7630 debug_assert_eq!(node.kind(), "template_substitution");
7631 Ok(Self {
7632 span: ::treesitter_types::Span::from(node),
7633 children: {
7634 #[allow(clippy::suspicious_else_formatting)]
7635 let non_field_children = {
7636 let mut cursor = node.walk();
7637 let mut result = ::std::vec::Vec::new();
7638 if cursor.goto_first_child() {
7639 loop {
7640 if cursor.field_name().is_none()
7641 && cursor.node().is_named()
7642 && !cursor.node().is_extra()
7643 {
7644 result.push(cursor.node());
7645 }
7646 if !cursor.goto_next_sibling() {
7647 break;
7648 }
7649 }
7650 }
7651 result
7652 };
7653 let child = if let Some(&c) = non_field_children.first() {
7654 c
7655 } else {
7656 let mut fallback_cursor = node.walk();
7657 let mut fallback_child = None;
7658 if fallback_cursor.goto_first_child() {
7659 loop {
7660 if fallback_cursor.field_name().is_none()
7661 && !fallback_cursor.node().is_extra()
7662 {
7663 fallback_child = Some(fallback_cursor.node());
7664 break;
7665 }
7666 if !fallback_cursor.goto_next_sibling() {
7667 break;
7668 }
7669 }
7670 }
7671 fallback_child.ok_or_else(|| {
7672 ::treesitter_types::ParseError::missing_field("children", node)
7673 })?
7674 };
7675 <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
7676 child, src,
7677 )?
7678 },
7679 })
7680 }
7681}
7682impl ::treesitter_types::Spanned for TemplateSubstitution<'_> {
7683 fn span(&self) -> ::treesitter_types::Span {
7684 self.span
7685 }
7686}
7687#[derive(Debug, Clone)]
7688pub struct TemplateType<'tree> {
7689 pub span: ::treesitter_types::Span,
7690 pub children: TemplateTypeChildren<'tree>,
7691}
7692impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateType<'tree> {
7693 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7694 fn from_node(
7695 node: ::tree_sitter::Node<'tree>,
7696 src: &'tree [u8],
7697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7698 debug_assert_eq!(node.kind(), "template_type");
7699 Ok(Self {
7700 span: ::treesitter_types::Span::from(node),
7701 children: {
7702 #[allow(clippy::suspicious_else_formatting)]
7703 let non_field_children = {
7704 let mut cursor = node.walk();
7705 let mut result = ::std::vec::Vec::new();
7706 if cursor.goto_first_child() {
7707 loop {
7708 if cursor.field_name().is_none()
7709 && cursor.node().is_named()
7710 && !cursor.node().is_extra()
7711 {
7712 result.push(cursor.node());
7713 }
7714 if !cursor.goto_next_sibling() {
7715 break;
7716 }
7717 }
7718 }
7719 result
7720 };
7721 let child = if let Some(&c) = non_field_children.first() {
7722 c
7723 } else {
7724 let mut fallback_cursor = node.walk();
7725 let mut fallback_child = None;
7726 if fallback_cursor.goto_first_child() {
7727 loop {
7728 if fallback_cursor.field_name().is_none()
7729 && !fallback_cursor.node().is_extra()
7730 {
7731 fallback_child = Some(fallback_cursor.node());
7732 break;
7733 }
7734 if !fallback_cursor.goto_next_sibling() {
7735 break;
7736 }
7737 }
7738 }
7739 fallback_child.ok_or_else(|| {
7740 ::treesitter_types::ParseError::missing_field("children", node)
7741 })?
7742 };
7743 <TemplateTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7744 },
7745 })
7746 }
7747}
7748impl ::treesitter_types::Spanned for TemplateType<'_> {
7749 fn span(&self) -> ::treesitter_types::Span {
7750 self.span
7751 }
7752}
7753#[derive(Debug, Clone)]
7754pub struct TernaryExpression<'tree> {
7755 pub span: ::treesitter_types::Span,
7756 pub alternative: Expression<'tree>,
7757 pub condition: Expression<'tree>,
7758 pub consequence: Expression<'tree>,
7759}
7760impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
7761 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7762 fn from_node(
7763 node: ::tree_sitter::Node<'tree>,
7764 src: &'tree [u8],
7765 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7766 debug_assert_eq!(node.kind(), "ternary_expression");
7767 Ok(Self {
7768 span: ::treesitter_types::Span::from(node),
7769 alternative: {
7770 let child = node.child_by_field_name("alternative").ok_or_else(|| {
7771 ::treesitter_types::ParseError::missing_field("alternative", node)
7772 })?;
7773 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7774 },
7775 condition: {
7776 let child = node.child_by_field_name("condition").ok_or_else(|| {
7777 ::treesitter_types::ParseError::missing_field("condition", node)
7778 })?;
7779 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7780 },
7781 consequence: {
7782 let child = node.child_by_field_name("consequence").ok_or_else(|| {
7783 ::treesitter_types::ParseError::missing_field("consequence", node)
7784 })?;
7785 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
7786 },
7787 })
7788 }
7789}
7790impl ::treesitter_types::Spanned for TernaryExpression<'_> {
7791 fn span(&self) -> ::treesitter_types::Span {
7792 self.span
7793 }
7794}
7795#[derive(Debug, Clone)]
7796pub struct ThrowStatement<'tree> {
7797 pub span: ::treesitter_types::Span,
7798 pub children: ThrowStatementChildren<'tree>,
7799}
7800impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
7801 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7802 fn from_node(
7803 node: ::tree_sitter::Node<'tree>,
7804 src: &'tree [u8],
7805 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7806 debug_assert_eq!(node.kind(), "throw_statement");
7807 Ok(Self {
7808 span: ::treesitter_types::Span::from(node),
7809 children: {
7810 #[allow(clippy::suspicious_else_formatting)]
7811 let non_field_children = {
7812 let mut cursor = node.walk();
7813 let mut result = ::std::vec::Vec::new();
7814 if cursor.goto_first_child() {
7815 loop {
7816 if cursor.field_name().is_none()
7817 && cursor.node().is_named()
7818 && !cursor.node().is_extra()
7819 {
7820 result.push(cursor.node());
7821 }
7822 if !cursor.goto_next_sibling() {
7823 break;
7824 }
7825 }
7826 }
7827 result
7828 };
7829 let child = if let Some(&c) = non_field_children.first() {
7830 c
7831 } else {
7832 let mut fallback_cursor = node.walk();
7833 let mut fallback_child = None;
7834 if fallback_cursor.goto_first_child() {
7835 loop {
7836 if fallback_cursor.field_name().is_none()
7837 && !fallback_cursor.node().is_extra()
7838 {
7839 fallback_child = Some(fallback_cursor.node());
7840 break;
7841 }
7842 if !fallback_cursor.goto_next_sibling() {
7843 break;
7844 }
7845 }
7846 }
7847 fallback_child.ok_or_else(|| {
7848 ::treesitter_types::ParseError::missing_field("children", node)
7849 })?
7850 };
7851 <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
7852 },
7853 })
7854 }
7855}
7856impl ::treesitter_types::Spanned for ThrowStatement<'_> {
7857 fn span(&self) -> ::treesitter_types::Span {
7858 self.span
7859 }
7860}
7861#[derive(Debug, Clone)]
7862pub struct TryStatement<'tree> {
7863 pub span: ::treesitter_types::Span,
7864 pub body: StatementBlock<'tree>,
7865 pub finalizer: ::core::option::Option<FinallyClause<'tree>>,
7866 pub handler: ::core::option::Option<CatchClause<'tree>>,
7867}
7868impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
7869 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7870 fn from_node(
7871 node: ::tree_sitter::Node<'tree>,
7872 src: &'tree [u8],
7873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7874 debug_assert_eq!(node.kind(), "try_statement");
7875 Ok(Self {
7876 span: ::treesitter_types::Span::from(node),
7877 body: {
7878 let child = node
7879 .child_by_field_name("body")
7880 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
7881 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
7882 },
7883 finalizer: match node.child_by_field_name("finalizer") {
7884 Some(child) => Some(<FinallyClause as ::treesitter_types::FromNode>::from_node(
7885 child, src,
7886 )?),
7887 None => None,
7888 },
7889 handler: match node.child_by_field_name("handler") {
7890 Some(child) => Some(<CatchClause as ::treesitter_types::FromNode>::from_node(
7891 child, src,
7892 )?),
7893 None => None,
7894 },
7895 })
7896 }
7897}
7898impl ::treesitter_types::Spanned for TryStatement<'_> {
7899 fn span(&self) -> ::treesitter_types::Span {
7900 self.span
7901 }
7902}
7903#[derive(Debug, Clone)]
7904pub struct TupleType<'tree> {
7905 pub span: ::treesitter_types::Span,
7906 pub children: ::std::vec::Vec<TupleTypeChildren<'tree>>,
7907}
7908impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
7909 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7910 fn from_node(
7911 node: ::tree_sitter::Node<'tree>,
7912 src: &'tree [u8],
7913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7914 debug_assert_eq!(node.kind(), "tuple_type");
7915 Ok(Self {
7916 span: ::treesitter_types::Span::from(node),
7917 children: {
7918 #[allow(clippy::suspicious_else_formatting)]
7919 let non_field_children = {
7920 let mut cursor = node.walk();
7921 let mut result = ::std::vec::Vec::new();
7922 if cursor.goto_first_child() {
7923 loop {
7924 if cursor.field_name().is_none()
7925 && cursor.node().is_named()
7926 && !cursor.node().is_extra()
7927 {
7928 result.push(cursor.node());
7929 }
7930 if !cursor.goto_next_sibling() {
7931 break;
7932 }
7933 }
7934 }
7935 result
7936 };
7937 let mut items = ::std::vec::Vec::new();
7938 for child in non_field_children {
7939 items.push(
7940 <TupleTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
7941 );
7942 }
7943 items
7944 },
7945 })
7946 }
7947}
7948impl ::treesitter_types::Spanned for TupleType<'_> {
7949 fn span(&self) -> ::treesitter_types::Span {
7950 self.span
7951 }
7952}
7953#[derive(Debug, Clone)]
7954pub struct TypeAliasDeclaration<'tree> {
7955 pub span: ::treesitter_types::Span,
7956 pub name: TypeIdentifier<'tree>,
7957 pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
7958 pub value: Type<'tree>,
7959}
7960impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAliasDeclaration<'tree> {
7961 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
7962 fn from_node(
7963 node: ::tree_sitter::Node<'tree>,
7964 src: &'tree [u8],
7965 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7966 debug_assert_eq!(node.kind(), "type_alias_declaration");
7967 Ok(Self {
7968 span: ::treesitter_types::Span::from(node),
7969 name: {
7970 let child = node
7971 .child_by_field_name("name")
7972 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
7973 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
7974 },
7975 type_parameters: match node.child_by_field_name("type_parameters") {
7976 Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
7977 child, src,
7978 )?),
7979 None => None,
7980 },
7981 value: {
7982 let child = node
7983 .child_by_field_name("value")
7984 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
7985 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
7986 },
7987 })
7988 }
7989}
7990impl ::treesitter_types::Spanned for TypeAliasDeclaration<'_> {
7991 fn span(&self) -> ::treesitter_types::Span {
7992 self.span
7993 }
7994}
7995#[derive(Debug, Clone)]
7996pub struct TypeAnnotation<'tree> {
7997 pub span: ::treesitter_types::Span,
7998 pub children: Type<'tree>,
7999}
8000impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAnnotation<'tree> {
8001 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8002 fn from_node(
8003 node: ::tree_sitter::Node<'tree>,
8004 src: &'tree [u8],
8005 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8006 debug_assert_eq!(node.kind(), "type_annotation");
8007 Ok(Self {
8008 span: ::treesitter_types::Span::from(node),
8009 children: {
8010 #[allow(clippy::suspicious_else_formatting)]
8011 let non_field_children = {
8012 let mut cursor = node.walk();
8013 let mut result = ::std::vec::Vec::new();
8014 if cursor.goto_first_child() {
8015 loop {
8016 if cursor.field_name().is_none()
8017 && cursor.node().is_named()
8018 && !cursor.node().is_extra()
8019 {
8020 result.push(cursor.node());
8021 }
8022 if !cursor.goto_next_sibling() {
8023 break;
8024 }
8025 }
8026 }
8027 result
8028 };
8029 let child = if let Some(&c) = non_field_children.first() {
8030 c
8031 } else {
8032 let mut fallback_cursor = node.walk();
8033 let mut fallback_child = None;
8034 if fallback_cursor.goto_first_child() {
8035 loop {
8036 if fallback_cursor.field_name().is_none()
8037 && !fallback_cursor.node().is_extra()
8038 {
8039 fallback_child = Some(fallback_cursor.node());
8040 break;
8041 }
8042 if !fallback_cursor.goto_next_sibling() {
8043 break;
8044 }
8045 }
8046 }
8047 fallback_child.ok_or_else(|| {
8048 ::treesitter_types::ParseError::missing_field("children", node)
8049 })?
8050 };
8051 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8052 },
8053 })
8054 }
8055}
8056impl ::treesitter_types::Spanned for TypeAnnotation<'_> {
8057 fn span(&self) -> ::treesitter_types::Span {
8058 self.span
8059 }
8060}
8061#[derive(Debug, Clone)]
8062pub struct TypeArguments<'tree> {
8063 pub span: ::treesitter_types::Span,
8064 pub children: ::std::vec::Vec<Type<'tree>>,
8065}
8066impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
8067 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8068 fn from_node(
8069 node: ::tree_sitter::Node<'tree>,
8070 src: &'tree [u8],
8071 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8072 debug_assert_eq!(node.kind(), "type_arguments");
8073 Ok(Self {
8074 span: ::treesitter_types::Span::from(node),
8075 children: {
8076 #[allow(clippy::suspicious_else_formatting)]
8077 let non_field_children = {
8078 let mut cursor = node.walk();
8079 let mut result = ::std::vec::Vec::new();
8080 if cursor.goto_first_child() {
8081 loop {
8082 if cursor.field_name().is_none()
8083 && cursor.node().is_named()
8084 && !cursor.node().is_extra()
8085 {
8086 result.push(cursor.node());
8087 }
8088 if !cursor.goto_next_sibling() {
8089 break;
8090 }
8091 }
8092 }
8093 result
8094 };
8095 let mut items = ::std::vec::Vec::new();
8096 for child in non_field_children {
8097 items.push(<Type as ::treesitter_types::FromNode>::from_node(
8098 child, src,
8099 )?);
8100 }
8101 items
8102 },
8103 })
8104 }
8105}
8106impl ::treesitter_types::Spanned for TypeArguments<'_> {
8107 fn span(&self) -> ::treesitter_types::Span {
8108 self.span
8109 }
8110}
8111#[derive(Debug, Clone)]
8112pub struct TypeAssertion<'tree> {
8113 pub span: ::treesitter_types::Span,
8114 pub children: ::std::vec::Vec<TypeAssertionChildren<'tree>>,
8115}
8116impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAssertion<'tree> {
8117 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8118 fn from_node(
8119 node: ::tree_sitter::Node<'tree>,
8120 src: &'tree [u8],
8121 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8122 debug_assert_eq!(node.kind(), "type_assertion");
8123 Ok(Self {
8124 span: ::treesitter_types::Span::from(node),
8125 children: {
8126 #[allow(clippy::suspicious_else_formatting)]
8127 let non_field_children = {
8128 let mut cursor = node.walk();
8129 let mut result = ::std::vec::Vec::new();
8130 if cursor.goto_first_child() {
8131 loop {
8132 if cursor.field_name().is_none()
8133 && cursor.node().is_named()
8134 && !cursor.node().is_extra()
8135 {
8136 result.push(cursor.node());
8137 }
8138 if !cursor.goto_next_sibling() {
8139 break;
8140 }
8141 }
8142 }
8143 result
8144 };
8145 let mut items = ::std::vec::Vec::new();
8146 for child in non_field_children {
8147 items.push(
8148 <TypeAssertionChildren as ::treesitter_types::FromNode>::from_node(
8149 child, src,
8150 )?,
8151 );
8152 }
8153 items
8154 },
8155 })
8156 }
8157}
8158impl ::treesitter_types::Spanned for TypeAssertion<'_> {
8159 fn span(&self) -> ::treesitter_types::Span {
8160 self.span
8161 }
8162}
8163#[derive(Debug, Clone)]
8164pub struct TypeParameter<'tree> {
8165 pub span: ::treesitter_types::Span,
8166 pub constraint: ::core::option::Option<Constraint<'tree>>,
8167 pub name: TypeIdentifier<'tree>,
8168 pub value: ::core::option::Option<DefaultType<'tree>>,
8169}
8170impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
8171 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8172 fn from_node(
8173 node: ::tree_sitter::Node<'tree>,
8174 src: &'tree [u8],
8175 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8176 debug_assert_eq!(node.kind(), "type_parameter");
8177 Ok(Self {
8178 span: ::treesitter_types::Span::from(node),
8179 constraint: match node.child_by_field_name("constraint") {
8180 Some(child) => Some(<Constraint as ::treesitter_types::FromNode>::from_node(
8181 child, src,
8182 )?),
8183 None => None,
8184 },
8185 name: {
8186 let child = node
8187 .child_by_field_name("name")
8188 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8189 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
8190 },
8191 value: match node.child_by_field_name("value") {
8192 Some(child) => Some(<DefaultType as ::treesitter_types::FromNode>::from_node(
8193 child, src,
8194 )?),
8195 None => None,
8196 },
8197 })
8198 }
8199}
8200impl ::treesitter_types::Spanned for TypeParameter<'_> {
8201 fn span(&self) -> ::treesitter_types::Span {
8202 self.span
8203 }
8204}
8205#[derive(Debug, Clone)]
8206pub struct TypeParameters<'tree> {
8207 pub span: ::treesitter_types::Span,
8208 pub children: ::std::vec::Vec<TypeParameter<'tree>>,
8209}
8210impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
8211 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8212 fn from_node(
8213 node: ::tree_sitter::Node<'tree>,
8214 src: &'tree [u8],
8215 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8216 debug_assert_eq!(node.kind(), "type_parameters");
8217 Ok(Self {
8218 span: ::treesitter_types::Span::from(node),
8219 children: {
8220 #[allow(clippy::suspicious_else_formatting)]
8221 let non_field_children = {
8222 let mut cursor = node.walk();
8223 let mut result = ::std::vec::Vec::new();
8224 if cursor.goto_first_child() {
8225 loop {
8226 if cursor.field_name().is_none()
8227 && cursor.node().is_named()
8228 && !cursor.node().is_extra()
8229 {
8230 result.push(cursor.node());
8231 }
8232 if !cursor.goto_next_sibling() {
8233 break;
8234 }
8235 }
8236 }
8237 result
8238 };
8239 let mut items = ::std::vec::Vec::new();
8240 for child in non_field_children {
8241 items.push(<TypeParameter as ::treesitter_types::FromNode>::from_node(
8242 child, src,
8243 )?);
8244 }
8245 items
8246 },
8247 })
8248 }
8249}
8250impl ::treesitter_types::Spanned for TypeParameters<'_> {
8251 fn span(&self) -> ::treesitter_types::Span {
8252 self.span
8253 }
8254}
8255#[derive(Debug, Clone)]
8256pub struct TypePredicate<'tree> {
8257 pub span: ::treesitter_types::Span,
8258 pub name: TypePredicateName<'tree>,
8259 pub r#type: Type<'tree>,
8260}
8261impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicate<'tree> {
8262 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8263 fn from_node(
8264 node: ::tree_sitter::Node<'tree>,
8265 src: &'tree [u8],
8266 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8267 debug_assert_eq!(node.kind(), "type_predicate");
8268 Ok(Self {
8269 span: ::treesitter_types::Span::from(node),
8270 name: {
8271 let child = node
8272 .child_by_field_name("name")
8273 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8274 <TypePredicateName as ::treesitter_types::FromNode>::from_node(child, src)?
8275 },
8276 r#type: {
8277 let child = node
8278 .child_by_field_name("type")
8279 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
8280 <Type as ::treesitter_types::FromNode>::from_node(child, src)?
8281 },
8282 })
8283 }
8284}
8285impl ::treesitter_types::Spanned for TypePredicate<'_> {
8286 fn span(&self) -> ::treesitter_types::Span {
8287 self.span
8288 }
8289}
8290#[derive(Debug, Clone)]
8291pub struct TypePredicateAnnotation<'tree> {
8292 pub span: ::treesitter_types::Span,
8293 pub children: TypePredicate<'tree>,
8294}
8295impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicateAnnotation<'tree> {
8296 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8297 fn from_node(
8298 node: ::tree_sitter::Node<'tree>,
8299 src: &'tree [u8],
8300 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8301 debug_assert_eq!(node.kind(), "type_predicate_annotation");
8302 Ok(Self {
8303 span: ::treesitter_types::Span::from(node),
8304 children: {
8305 #[allow(clippy::suspicious_else_formatting)]
8306 let non_field_children = {
8307 let mut cursor = node.walk();
8308 let mut result = ::std::vec::Vec::new();
8309 if cursor.goto_first_child() {
8310 loop {
8311 if cursor.field_name().is_none()
8312 && cursor.node().is_named()
8313 && !cursor.node().is_extra()
8314 {
8315 result.push(cursor.node());
8316 }
8317 if !cursor.goto_next_sibling() {
8318 break;
8319 }
8320 }
8321 }
8322 result
8323 };
8324 let child = if let Some(&c) = non_field_children.first() {
8325 c
8326 } else {
8327 let mut fallback_cursor = node.walk();
8328 let mut fallback_child = None;
8329 if fallback_cursor.goto_first_child() {
8330 loop {
8331 if fallback_cursor.field_name().is_none()
8332 && !fallback_cursor.node().is_extra()
8333 {
8334 fallback_child = Some(fallback_cursor.node());
8335 break;
8336 }
8337 if !fallback_cursor.goto_next_sibling() {
8338 break;
8339 }
8340 }
8341 }
8342 fallback_child.ok_or_else(|| {
8343 ::treesitter_types::ParseError::missing_field("children", node)
8344 })?
8345 };
8346 <TypePredicate as ::treesitter_types::FromNode>::from_node(child, src)?
8347 },
8348 })
8349 }
8350}
8351impl ::treesitter_types::Spanned for TypePredicateAnnotation<'_> {
8352 fn span(&self) -> ::treesitter_types::Span {
8353 self.span
8354 }
8355}
8356#[derive(Debug, Clone)]
8357pub struct TypeQuery<'tree> {
8358 pub span: ::treesitter_types::Span,
8359 pub children: TypeQueryChildren<'tree>,
8360}
8361impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQuery<'tree> {
8362 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8363 fn from_node(
8364 node: ::tree_sitter::Node<'tree>,
8365 src: &'tree [u8],
8366 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8367 debug_assert_eq!(node.kind(), "type_query");
8368 Ok(Self {
8369 span: ::treesitter_types::Span::from(node),
8370 children: {
8371 #[allow(clippy::suspicious_else_formatting)]
8372 let non_field_children = {
8373 let mut cursor = node.walk();
8374 let mut result = ::std::vec::Vec::new();
8375 if cursor.goto_first_child() {
8376 loop {
8377 if cursor.field_name().is_none()
8378 && cursor.node().is_named()
8379 && !cursor.node().is_extra()
8380 {
8381 result.push(cursor.node());
8382 }
8383 if !cursor.goto_next_sibling() {
8384 break;
8385 }
8386 }
8387 }
8388 result
8389 };
8390 let child = if let Some(&c) = non_field_children.first() {
8391 c
8392 } else {
8393 let mut fallback_cursor = node.walk();
8394 let mut fallback_child = None;
8395 if fallback_cursor.goto_first_child() {
8396 loop {
8397 if fallback_cursor.field_name().is_none()
8398 && !fallback_cursor.node().is_extra()
8399 {
8400 fallback_child = Some(fallback_cursor.node());
8401 break;
8402 }
8403 if !fallback_cursor.goto_next_sibling() {
8404 break;
8405 }
8406 }
8407 }
8408 fallback_child.ok_or_else(|| {
8409 ::treesitter_types::ParseError::missing_field("children", node)
8410 })?
8411 };
8412 <TypeQueryChildren as ::treesitter_types::FromNode>::from_node(child, src)?
8413 },
8414 })
8415 }
8416}
8417impl ::treesitter_types::Spanned for TypeQuery<'_> {
8418 fn span(&self) -> ::treesitter_types::Span {
8419 self.span
8420 }
8421}
8422#[derive(Debug, Clone)]
8423pub struct UnaryExpression<'tree> {
8424 pub span: ::treesitter_types::Span,
8425 pub argument: UnaryExpressionArgument<'tree>,
8426 pub operator: UnaryExpressionOperator,
8427}
8428impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
8429 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8430 fn from_node(
8431 node: ::tree_sitter::Node<'tree>,
8432 src: &'tree [u8],
8433 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8434 debug_assert_eq!(node.kind(), "unary_expression");
8435 Ok(Self {
8436 span: ::treesitter_types::Span::from(node),
8437 argument: {
8438 let child = node.child_by_field_name("argument").ok_or_else(|| {
8439 ::treesitter_types::ParseError::missing_field("argument", node)
8440 })?;
8441 <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)?
8442 },
8443 operator: {
8444 let child = node.child_by_field_name("operator").ok_or_else(|| {
8445 ::treesitter_types::ParseError::missing_field("operator", node)
8446 })?;
8447 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
8448 },
8449 })
8450 }
8451}
8452impl ::treesitter_types::Spanned for UnaryExpression<'_> {
8453 fn span(&self) -> ::treesitter_types::Span {
8454 self.span
8455 }
8456}
8457#[derive(Debug, Clone)]
8458pub struct UnionType<'tree> {
8459 pub span: ::treesitter_types::Span,
8460 pub children: ::std::vec::Vec<Type<'tree>>,
8461}
8462impl<'tree> ::treesitter_types::FromNode<'tree> for UnionType<'tree> {
8463 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8464 fn from_node(
8465 node: ::tree_sitter::Node<'tree>,
8466 src: &'tree [u8],
8467 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8468 debug_assert_eq!(node.kind(), "union_type");
8469 Ok(Self {
8470 span: ::treesitter_types::Span::from(node),
8471 children: {
8472 #[allow(clippy::suspicious_else_formatting)]
8473 let non_field_children = {
8474 let mut cursor = node.walk();
8475 let mut result = ::std::vec::Vec::new();
8476 if cursor.goto_first_child() {
8477 loop {
8478 if cursor.field_name().is_none()
8479 && cursor.node().is_named()
8480 && !cursor.node().is_extra()
8481 {
8482 result.push(cursor.node());
8483 }
8484 if !cursor.goto_next_sibling() {
8485 break;
8486 }
8487 }
8488 }
8489 result
8490 };
8491 let mut items = ::std::vec::Vec::new();
8492 for child in non_field_children {
8493 items.push(<Type as ::treesitter_types::FromNode>::from_node(
8494 child, src,
8495 )?);
8496 }
8497 items
8498 },
8499 })
8500 }
8501}
8502impl ::treesitter_types::Spanned for UnionType<'_> {
8503 fn span(&self) -> ::treesitter_types::Span {
8504 self.span
8505 }
8506}
8507#[derive(Debug, Clone)]
8508pub struct UpdateExpression<'tree> {
8509 pub span: ::treesitter_types::Span,
8510 pub argument: Expression<'tree>,
8511 pub operator: UpdateExpressionOperator,
8512}
8513impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
8514 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8515 fn from_node(
8516 node: ::tree_sitter::Node<'tree>,
8517 src: &'tree [u8],
8518 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8519 debug_assert_eq!(node.kind(), "update_expression");
8520 Ok(Self {
8521 span: ::treesitter_types::Span::from(node),
8522 argument: {
8523 let child = node.child_by_field_name("argument").ok_or_else(|| {
8524 ::treesitter_types::ParseError::missing_field("argument", node)
8525 })?;
8526 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
8527 },
8528 operator: {
8529 let child = node.child_by_field_name("operator").ok_or_else(|| {
8530 ::treesitter_types::ParseError::missing_field("operator", node)
8531 })?;
8532 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
8533 },
8534 })
8535 }
8536}
8537impl ::treesitter_types::Spanned for UpdateExpression<'_> {
8538 fn span(&self) -> ::treesitter_types::Span {
8539 self.span
8540 }
8541}
8542#[derive(Debug, Clone)]
8543pub struct VariableDeclaration<'tree> {
8544 pub span: ::treesitter_types::Span,
8545 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
8546}
8547impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
8548 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8549 fn from_node(
8550 node: ::tree_sitter::Node<'tree>,
8551 src: &'tree [u8],
8552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8553 debug_assert_eq!(node.kind(), "variable_declaration");
8554 Ok(Self {
8555 span: ::treesitter_types::Span::from(node),
8556 children: {
8557 #[allow(clippy::suspicious_else_formatting)]
8558 let non_field_children = {
8559 let mut cursor = node.walk();
8560 let mut result = ::std::vec::Vec::new();
8561 if cursor.goto_first_child() {
8562 loop {
8563 if cursor.field_name().is_none()
8564 && cursor.node().is_named()
8565 && !cursor.node().is_extra()
8566 {
8567 result.push(cursor.node());
8568 }
8569 if !cursor.goto_next_sibling() {
8570 break;
8571 }
8572 }
8573 }
8574 result
8575 };
8576 let mut items = ::std::vec::Vec::new();
8577 for child in non_field_children {
8578 items.push(
8579 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
8580 child, src,
8581 )?,
8582 );
8583 }
8584 items
8585 },
8586 })
8587 }
8588}
8589impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
8590 fn span(&self) -> ::treesitter_types::Span {
8591 self.span
8592 }
8593}
8594#[derive(Debug, Clone)]
8595pub struct VariableDeclarator<'tree> {
8596 pub span: ::treesitter_types::Span,
8597 pub name: VariableDeclaratorName<'tree>,
8598 pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
8599 pub value: ::core::option::Option<Expression<'tree>>,
8600}
8601impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
8602 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8603 fn from_node(
8604 node: ::tree_sitter::Node<'tree>,
8605 src: &'tree [u8],
8606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8607 debug_assert_eq!(node.kind(), "variable_declarator");
8608 Ok(Self {
8609 span: ::treesitter_types::Span::from(node),
8610 name: {
8611 let child = node
8612 .child_by_field_name("name")
8613 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
8614 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)?
8615 },
8616 r#type: match node.child_by_field_name("type") {
8617 Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
8618 child, src,
8619 )?),
8620 None => None,
8621 },
8622 value: match node.child_by_field_name("value") {
8623 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
8624 child, src,
8625 )?),
8626 None => None,
8627 },
8628 })
8629 }
8630}
8631impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
8632 fn span(&self) -> ::treesitter_types::Span {
8633 self.span
8634 }
8635}
8636#[derive(Debug, Clone)]
8637pub struct WhileStatement<'tree> {
8638 pub span: ::treesitter_types::Span,
8639 pub body: Statement<'tree>,
8640 pub condition: ParenthesizedExpression<'tree>,
8641}
8642impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
8643 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8644 fn from_node(
8645 node: ::tree_sitter::Node<'tree>,
8646 src: &'tree [u8],
8647 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8648 debug_assert_eq!(node.kind(), "while_statement");
8649 Ok(Self {
8650 span: ::treesitter_types::Span::from(node),
8651 body: {
8652 let child = node
8653 .child_by_field_name("body")
8654 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8655 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
8656 },
8657 condition: {
8658 let child = node.child_by_field_name("condition").ok_or_else(|| {
8659 ::treesitter_types::ParseError::missing_field("condition", node)
8660 })?;
8661 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
8662 },
8663 })
8664 }
8665}
8666impl ::treesitter_types::Spanned for WhileStatement<'_> {
8667 fn span(&self) -> ::treesitter_types::Span {
8668 self.span
8669 }
8670}
8671#[derive(Debug, Clone)]
8672pub struct WithStatement<'tree> {
8673 pub span: ::treesitter_types::Span,
8674 pub body: Statement<'tree>,
8675 pub object: ParenthesizedExpression<'tree>,
8676}
8677impl<'tree> ::treesitter_types::FromNode<'tree> for WithStatement<'tree> {
8678 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8679 fn from_node(
8680 node: ::tree_sitter::Node<'tree>,
8681 src: &'tree [u8],
8682 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8683 debug_assert_eq!(node.kind(), "with_statement");
8684 Ok(Self {
8685 span: ::treesitter_types::Span::from(node),
8686 body: {
8687 let child = node
8688 .child_by_field_name("body")
8689 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
8690 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
8691 },
8692 object: {
8693 let child = node
8694 .child_by_field_name("object")
8695 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
8696 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
8697 },
8698 })
8699 }
8700}
8701impl ::treesitter_types::Spanned for WithStatement<'_> {
8702 fn span(&self) -> ::treesitter_types::Span {
8703 self.span
8704 }
8705}
8706#[derive(Debug, Clone)]
8707pub struct YieldExpression<'tree> {
8708 pub span: ::treesitter_types::Span,
8709 pub children: ::core::option::Option<Expression<'tree>>,
8710}
8711impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
8712 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8713 fn from_node(
8714 node: ::tree_sitter::Node<'tree>,
8715 src: &'tree [u8],
8716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8717 debug_assert_eq!(node.kind(), "yield_expression");
8718 Ok(Self {
8719 span: ::treesitter_types::Span::from(node),
8720 children: {
8721 #[allow(clippy::suspicious_else_formatting)]
8722 let non_field_children = {
8723 let mut cursor = node.walk();
8724 let mut result = ::std::vec::Vec::new();
8725 if cursor.goto_first_child() {
8726 loop {
8727 if cursor.field_name().is_none()
8728 && cursor.node().is_named()
8729 && !cursor.node().is_extra()
8730 {
8731 result.push(cursor.node());
8732 }
8733 if !cursor.goto_next_sibling() {
8734 break;
8735 }
8736 }
8737 }
8738 result
8739 };
8740 match non_field_children.first() {
8741 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
8742 child, src,
8743 )?),
8744 None => None,
8745 }
8746 },
8747 })
8748 }
8749}
8750impl ::treesitter_types::Spanned for YieldExpression<'_> {
8751 fn span(&self) -> ::treesitter_types::Span {
8752 self.span
8753 }
8754}
8755#[derive(Debug, Clone)]
8756pub struct Comment<'tree> {
8757 pub span: ::treesitter_types::Span,
8758 text: &'tree str,
8759}
8760impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
8761 fn from_node(
8762 node: ::tree_sitter::Node<'tree>,
8763 src: &'tree [u8],
8764 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8765 debug_assert_eq!(node.kind(), "comment");
8766 Ok(Self {
8767 span: ::treesitter_types::Span::from(node),
8768 text: node.utf8_text(src)?,
8769 })
8770 }
8771}
8772impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
8773 fn text(&self) -> &'tree str {
8774 self.text
8775 }
8776}
8777impl ::treesitter_types::Spanned for Comment<'_> {
8778 fn span(&self) -> ::treesitter_types::Span {
8779 self.span
8780 }
8781}
8782#[derive(Debug, Clone)]
8783pub struct EscapeSequence<'tree> {
8784 pub span: ::treesitter_types::Span,
8785 text: &'tree str,
8786}
8787impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
8788 fn from_node(
8789 node: ::tree_sitter::Node<'tree>,
8790 src: &'tree [u8],
8791 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8792 debug_assert_eq!(node.kind(), "escape_sequence");
8793 Ok(Self {
8794 span: ::treesitter_types::Span::from(node),
8795 text: node.utf8_text(src)?,
8796 })
8797 }
8798}
8799impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
8800 fn text(&self) -> &'tree str {
8801 self.text
8802 }
8803}
8804impl ::treesitter_types::Spanned for EscapeSequence<'_> {
8805 fn span(&self) -> ::treesitter_types::Span {
8806 self.span
8807 }
8808}
8809#[derive(Debug, Clone)]
8810pub struct False<'tree> {
8811 pub span: ::treesitter_types::Span,
8812 text: &'tree str,
8813}
8814impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
8815 fn from_node(
8816 node: ::tree_sitter::Node<'tree>,
8817 src: &'tree [u8],
8818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8819 debug_assert_eq!(node.kind(), "false");
8820 Ok(Self {
8821 span: ::treesitter_types::Span::from(node),
8822 text: node.utf8_text(src)?,
8823 })
8824 }
8825}
8826impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
8827 fn text(&self) -> &'tree str {
8828 self.text
8829 }
8830}
8831impl ::treesitter_types::Spanned for False<'_> {
8832 fn span(&self) -> ::treesitter_types::Span {
8833 self.span
8834 }
8835}
8836#[derive(Debug, Clone)]
8837pub struct HashBangLine<'tree> {
8838 pub span: ::treesitter_types::Span,
8839 text: &'tree str,
8840}
8841impl<'tree> ::treesitter_types::FromNode<'tree> for HashBangLine<'tree> {
8842 fn from_node(
8843 node: ::tree_sitter::Node<'tree>,
8844 src: &'tree [u8],
8845 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8846 debug_assert_eq!(node.kind(), "hash_bang_line");
8847 Ok(Self {
8848 span: ::treesitter_types::Span::from(node),
8849 text: node.utf8_text(src)?,
8850 })
8851 }
8852}
8853impl<'tree> ::treesitter_types::LeafNode<'tree> for HashBangLine<'tree> {
8854 fn text(&self) -> &'tree str {
8855 self.text
8856 }
8857}
8858impl ::treesitter_types::Spanned for HashBangLine<'_> {
8859 fn span(&self) -> ::treesitter_types::Span {
8860 self.span
8861 }
8862}
8863#[derive(Debug, Clone)]
8864pub struct HtmlComment<'tree> {
8865 pub span: ::treesitter_types::Span,
8866 text: &'tree str,
8867}
8868impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlComment<'tree> {
8869 fn from_node(
8870 node: ::tree_sitter::Node<'tree>,
8871 src: &'tree [u8],
8872 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8873 debug_assert_eq!(node.kind(), "html_comment");
8874 Ok(Self {
8875 span: ::treesitter_types::Span::from(node),
8876 text: node.utf8_text(src)?,
8877 })
8878 }
8879}
8880impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlComment<'tree> {
8881 fn text(&self) -> &'tree str {
8882 self.text
8883 }
8884}
8885impl ::treesitter_types::Spanned for HtmlComment<'_> {
8886 fn span(&self) -> ::treesitter_types::Span {
8887 self.span
8888 }
8889}
8890#[derive(Debug, Clone)]
8891pub struct Null<'tree> {
8892 pub span: ::treesitter_types::Span,
8893 text: &'tree str,
8894}
8895impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
8896 fn from_node(
8897 node: ::tree_sitter::Node<'tree>,
8898 src: &'tree [u8],
8899 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8900 debug_assert_eq!(node.kind(), "null");
8901 Ok(Self {
8902 span: ::treesitter_types::Span::from(node),
8903 text: node.utf8_text(src)?,
8904 })
8905 }
8906}
8907impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
8908 fn text(&self) -> &'tree str {
8909 self.text
8910 }
8911}
8912impl ::treesitter_types::Spanned for Null<'_> {
8913 fn span(&self) -> ::treesitter_types::Span {
8914 self.span
8915 }
8916}
8917#[derive(Debug, Clone)]
8918pub struct Number<'tree> {
8919 pub span: ::treesitter_types::Span,
8920 text: &'tree str,
8921}
8922impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
8923 fn from_node(
8924 node: ::tree_sitter::Node<'tree>,
8925 src: &'tree [u8],
8926 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8927 debug_assert_eq!(node.kind(), "number");
8928 Ok(Self {
8929 span: ::treesitter_types::Span::from(node),
8930 text: node.utf8_text(src)?,
8931 })
8932 }
8933}
8934impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
8935 fn text(&self) -> &'tree str {
8936 self.text
8937 }
8938}
8939impl ::treesitter_types::Spanned for Number<'_> {
8940 fn span(&self) -> ::treesitter_types::Span {
8941 self.span
8942 }
8943}
8944#[derive(Debug, Clone)]
8945pub struct PrivatePropertyIdentifier<'tree> {
8946 pub span: ::treesitter_types::Span,
8947 text: &'tree str,
8948}
8949impl<'tree> ::treesitter_types::FromNode<'tree> for PrivatePropertyIdentifier<'tree> {
8950 fn from_node(
8951 node: ::tree_sitter::Node<'tree>,
8952 src: &'tree [u8],
8953 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8954 debug_assert_eq!(node.kind(), "private_property_identifier");
8955 Ok(Self {
8956 span: ::treesitter_types::Span::from(node),
8957 text: node.utf8_text(src)?,
8958 })
8959 }
8960}
8961impl<'tree> ::treesitter_types::LeafNode<'tree> for PrivatePropertyIdentifier<'tree> {
8962 fn text(&self) -> &'tree str {
8963 self.text
8964 }
8965}
8966impl ::treesitter_types::Spanned for PrivatePropertyIdentifier<'_> {
8967 fn span(&self) -> ::treesitter_types::Span {
8968 self.span
8969 }
8970}
8971#[derive(Debug, Clone)]
8972pub struct PropertyIdentifier<'tree> {
8973 pub span: ::treesitter_types::Span,
8974 text: &'tree str,
8975}
8976impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyIdentifier<'tree> {
8977 fn from_node(
8978 node: ::tree_sitter::Node<'tree>,
8979 src: &'tree [u8],
8980 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8981 debug_assert_eq!(node.kind(), "property_identifier");
8982 Ok(Self {
8983 span: ::treesitter_types::Span::from(node),
8984 text: node.utf8_text(src)?,
8985 })
8986 }
8987}
8988impl<'tree> ::treesitter_types::LeafNode<'tree> for PropertyIdentifier<'tree> {
8989 fn text(&self) -> &'tree str {
8990 self.text
8991 }
8992}
8993impl ::treesitter_types::Spanned for PropertyIdentifier<'_> {
8994 fn span(&self) -> ::treesitter_types::Span {
8995 self.span
8996 }
8997}
8998#[derive(Debug, Clone)]
8999pub struct RegexFlags<'tree> {
9000 pub span: ::treesitter_types::Span,
9001 text: &'tree str,
9002}
9003impl<'tree> ::treesitter_types::FromNode<'tree> for RegexFlags<'tree> {
9004 fn from_node(
9005 node: ::tree_sitter::Node<'tree>,
9006 src: &'tree [u8],
9007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9008 debug_assert_eq!(node.kind(), "regex_flags");
9009 Ok(Self {
9010 span: ::treesitter_types::Span::from(node),
9011 text: node.utf8_text(src)?,
9012 })
9013 }
9014}
9015impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexFlags<'tree> {
9016 fn text(&self) -> &'tree str {
9017 self.text
9018 }
9019}
9020impl ::treesitter_types::Spanned for RegexFlags<'_> {
9021 fn span(&self) -> ::treesitter_types::Span {
9022 self.span
9023 }
9024}
9025#[derive(Debug, Clone)]
9026pub struct RegexPattern<'tree> {
9027 pub span: ::treesitter_types::Span,
9028 text: &'tree str,
9029}
9030impl<'tree> ::treesitter_types::FromNode<'tree> for RegexPattern<'tree> {
9031 fn from_node(
9032 node: ::tree_sitter::Node<'tree>,
9033 src: &'tree [u8],
9034 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9035 debug_assert_eq!(node.kind(), "regex_pattern");
9036 Ok(Self {
9037 span: ::treesitter_types::Span::from(node),
9038 text: node.utf8_text(src)?,
9039 })
9040 }
9041}
9042impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexPattern<'tree> {
9043 fn text(&self) -> &'tree str {
9044 self.text
9045 }
9046}
9047impl ::treesitter_types::Spanned for RegexPattern<'_> {
9048 fn span(&self) -> ::treesitter_types::Span {
9049 self.span
9050 }
9051}
9052#[derive(Debug, Clone)]
9053pub struct ShorthandPropertyIdentifier<'tree> {
9054 pub span: ::treesitter_types::Span,
9055 text: &'tree str,
9056}
9057impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifier<'tree> {
9058 fn from_node(
9059 node: ::tree_sitter::Node<'tree>,
9060 src: &'tree [u8],
9061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9062 debug_assert_eq!(node.kind(), "shorthand_property_identifier");
9063 Ok(Self {
9064 span: ::treesitter_types::Span::from(node),
9065 text: node.utf8_text(src)?,
9066 })
9067 }
9068}
9069impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifier<'tree> {
9070 fn text(&self) -> &'tree str {
9071 self.text
9072 }
9073}
9074impl ::treesitter_types::Spanned for ShorthandPropertyIdentifier<'_> {
9075 fn span(&self) -> ::treesitter_types::Span {
9076 self.span
9077 }
9078}
9079#[derive(Debug, Clone)]
9080pub struct ShorthandPropertyIdentifierPattern<'tree> {
9081 pub span: ::treesitter_types::Span,
9082 text: &'tree str,
9083}
9084impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
9085 fn from_node(
9086 node: ::tree_sitter::Node<'tree>,
9087 src: &'tree [u8],
9088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9089 debug_assert_eq!(node.kind(), "shorthand_property_identifier_pattern");
9090 Ok(Self {
9091 span: ::treesitter_types::Span::from(node),
9092 text: node.utf8_text(src)?,
9093 })
9094 }
9095}
9096impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
9097 fn text(&self) -> &'tree str {
9098 self.text
9099 }
9100}
9101impl ::treesitter_types::Spanned for ShorthandPropertyIdentifierPattern<'_> {
9102 fn span(&self) -> ::treesitter_types::Span {
9103 self.span
9104 }
9105}
9106#[derive(Debug, Clone)]
9107pub struct StatementIdentifier<'tree> {
9108 pub span: ::treesitter_types::Span,
9109 text: &'tree str,
9110}
9111impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
9112 fn from_node(
9113 node: ::tree_sitter::Node<'tree>,
9114 src: &'tree [u8],
9115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9116 debug_assert_eq!(node.kind(), "statement_identifier");
9117 Ok(Self {
9118 span: ::treesitter_types::Span::from(node),
9119 text: node.utf8_text(src)?,
9120 })
9121 }
9122}
9123impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
9124 fn text(&self) -> &'tree str {
9125 self.text
9126 }
9127}
9128impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
9129 fn span(&self) -> ::treesitter_types::Span {
9130 self.span
9131 }
9132}
9133#[derive(Debug, Clone)]
9134pub struct StringFragment<'tree> {
9135 pub span: ::treesitter_types::Span,
9136 text: &'tree str,
9137}
9138impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
9139 fn from_node(
9140 node: ::tree_sitter::Node<'tree>,
9141 src: &'tree [u8],
9142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9143 debug_assert_eq!(node.kind(), "string_fragment");
9144 Ok(Self {
9145 span: ::treesitter_types::Span::from(node),
9146 text: node.utf8_text(src)?,
9147 })
9148 }
9149}
9150impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
9151 fn text(&self) -> &'tree str {
9152 self.text
9153 }
9154}
9155impl ::treesitter_types::Spanned for StringFragment<'_> {
9156 fn span(&self) -> ::treesitter_types::Span {
9157 self.span
9158 }
9159}
9160#[derive(Debug, Clone)]
9161pub struct Super<'tree> {
9162 pub span: ::treesitter_types::Span,
9163 text: &'tree str,
9164}
9165impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
9166 fn from_node(
9167 node: ::tree_sitter::Node<'tree>,
9168 src: &'tree [u8],
9169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9170 debug_assert_eq!(node.kind(), "super");
9171 Ok(Self {
9172 span: ::treesitter_types::Span::from(node),
9173 text: node.utf8_text(src)?,
9174 })
9175 }
9176}
9177impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
9178 fn text(&self) -> &'tree str {
9179 self.text
9180 }
9181}
9182impl ::treesitter_types::Spanned for Super<'_> {
9183 fn span(&self) -> ::treesitter_types::Span {
9184 self.span
9185 }
9186}
9187#[derive(Debug, Clone)]
9188pub struct This<'tree> {
9189 pub span: ::treesitter_types::Span,
9190 text: &'tree str,
9191}
9192impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
9193 fn from_node(
9194 node: ::tree_sitter::Node<'tree>,
9195 src: &'tree [u8],
9196 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9197 debug_assert_eq!(node.kind(), "this");
9198 Ok(Self {
9199 span: ::treesitter_types::Span::from(node),
9200 text: node.utf8_text(src)?,
9201 })
9202 }
9203}
9204impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
9205 fn text(&self) -> &'tree str {
9206 self.text
9207 }
9208}
9209impl ::treesitter_types::Spanned for This<'_> {
9210 fn span(&self) -> ::treesitter_types::Span {
9211 self.span
9212 }
9213}
9214#[derive(Debug, Clone)]
9215pub struct ThisType<'tree> {
9216 pub span: ::treesitter_types::Span,
9217 text: &'tree str,
9218}
9219impl<'tree> ::treesitter_types::FromNode<'tree> for ThisType<'tree> {
9220 fn from_node(
9221 node: ::tree_sitter::Node<'tree>,
9222 src: &'tree [u8],
9223 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9224 debug_assert_eq!(node.kind(), "this_type");
9225 Ok(Self {
9226 span: ::treesitter_types::Span::from(node),
9227 text: node.utf8_text(src)?,
9228 })
9229 }
9230}
9231impl<'tree> ::treesitter_types::LeafNode<'tree> for ThisType<'tree> {
9232 fn text(&self) -> &'tree str {
9233 self.text
9234 }
9235}
9236impl ::treesitter_types::Spanned for ThisType<'_> {
9237 fn span(&self) -> ::treesitter_types::Span {
9238 self.span
9239 }
9240}
9241#[derive(Debug, Clone)]
9242pub struct True<'tree> {
9243 pub span: ::treesitter_types::Span,
9244 text: &'tree str,
9245}
9246impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
9247 fn from_node(
9248 node: ::tree_sitter::Node<'tree>,
9249 src: &'tree [u8],
9250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9251 debug_assert_eq!(node.kind(), "true");
9252 Ok(Self {
9253 span: ::treesitter_types::Span::from(node),
9254 text: node.utf8_text(src)?,
9255 })
9256 }
9257}
9258impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
9259 fn text(&self) -> &'tree str {
9260 self.text
9261 }
9262}
9263impl ::treesitter_types::Spanned for True<'_> {
9264 fn span(&self) -> ::treesitter_types::Span {
9265 self.span
9266 }
9267}
9268#[derive(Debug, Clone)]
9269pub struct TypeIdentifier<'tree> {
9270 pub span: ::treesitter_types::Span,
9271 text: &'tree str,
9272}
9273impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
9274 fn from_node(
9275 node: ::tree_sitter::Node<'tree>,
9276 src: &'tree [u8],
9277 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9278 debug_assert_eq!(node.kind(), "type_identifier");
9279 Ok(Self {
9280 span: ::treesitter_types::Span::from(node),
9281 text: node.utf8_text(src)?,
9282 })
9283 }
9284}
9285impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
9286 fn text(&self) -> &'tree str {
9287 self.text
9288 }
9289}
9290impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
9291 fn span(&self) -> ::treesitter_types::Span {
9292 self.span
9293 }
9294}
9295#[derive(Debug, Clone)]
9296pub struct Undefined<'tree> {
9297 pub span: ::treesitter_types::Span,
9298 text: &'tree str,
9299}
9300impl<'tree> ::treesitter_types::FromNode<'tree> for Undefined<'tree> {
9301 fn from_node(
9302 node: ::tree_sitter::Node<'tree>,
9303 src: &'tree [u8],
9304 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9305 debug_assert_eq!(node.kind(), "undefined");
9306 Ok(Self {
9307 span: ::treesitter_types::Span::from(node),
9308 text: node.utf8_text(src)?,
9309 })
9310 }
9311}
9312impl<'tree> ::treesitter_types::LeafNode<'tree> for Undefined<'tree> {
9313 fn text(&self) -> &'tree str {
9314 self.text
9315 }
9316}
9317impl ::treesitter_types::Spanned for Undefined<'_> {
9318 fn span(&self) -> ::treesitter_types::Span {
9319 self.span
9320 }
9321}
9322#[derive(Debug, Clone)]
9323pub enum AbstractMethodSignatureName<'tree> {
9324 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
9325 Number(::std::boxed::Box<Number<'tree>>),
9326 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
9327 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
9328 String(::std::boxed::Box<String<'tree>>),
9329}
9330impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureName<'tree> {
9331 #[allow(clippy::collapsible_else_if)]
9332 fn from_node(
9333 node: ::tree_sitter::Node<'tree>,
9334 src: &'tree [u8],
9335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9336 match node.kind() {
9337 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
9338 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
9339 ))),
9340 "number" => Ok(Self::Number(::std::boxed::Box::new(
9341 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
9342 ))),
9343 "private_property_identifier" => {
9344 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
9345 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
9346 node, src,
9347 )?,
9348 )))
9349 }
9350 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
9351 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9352 ))),
9353 "string" => Ok(Self::String(::std::boxed::Box::new(
9354 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
9355 ))),
9356 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9357 }
9358 }
9359}
9360impl ::treesitter_types::Spanned for AbstractMethodSignatureName<'_> {
9361 fn span(&self) -> ::treesitter_types::Span {
9362 match self {
9363 Self::ComputedPropertyName(inner) => inner.span(),
9364 Self::Number(inner) => inner.span(),
9365 Self::PrivatePropertyIdentifier(inner) => inner.span(),
9366 Self::PropertyIdentifier(inner) => inner.span(),
9367 Self::String(inner) => inner.span(),
9368 }
9369 }
9370}
9371#[derive(Debug, Clone)]
9372pub enum AbstractMethodSignatureReturnType<'tree> {
9373 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
9374 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
9375 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
9376}
9377impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureReturnType<'tree> {
9378 #[allow(clippy::collapsible_else_if)]
9379 fn from_node(
9380 node: ::tree_sitter::Node<'tree>,
9381 src: &'tree [u8],
9382 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9383 match node.kind() {
9384 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
9385 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9386 ))),
9387 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
9388 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9389 ))),
9390 "type_predicate_annotation" => {
9391 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
9392 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
9393 node, src,
9394 )?,
9395 )))
9396 }
9397 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9398 }
9399 }
9400}
9401impl ::treesitter_types::Spanned for AbstractMethodSignatureReturnType<'_> {
9402 fn span(&self) -> ::treesitter_types::Span {
9403 match self {
9404 Self::AssertsAnnotation(inner) => inner.span(),
9405 Self::TypeAnnotation(inner) => inner.span(),
9406 Self::TypePredicateAnnotation(inner) => inner.span(),
9407 }
9408 }
9409}
9410#[derive(Debug, Clone)]
9411pub enum AbstractMethodSignatureChildren<'tree> {
9412 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
9413 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
9414}
9415impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureChildren<'tree> {
9416 #[allow(clippy::collapsible_else_if)]
9417 fn from_node(
9418 node: ::tree_sitter::Node<'tree>,
9419 src: &'tree [u8],
9420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9421 match node.kind() {
9422 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
9423 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9424 ))),
9425 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
9426 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9427 ))),
9428 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9429 }
9430 }
9431}
9432impl ::treesitter_types::Spanned for AbstractMethodSignatureChildren<'_> {
9433 fn span(&self) -> ::treesitter_types::Span {
9434 match self {
9435 Self::AccessibilityModifier(inner) => inner.span(),
9436 Self::OverrideModifier(inner) => inner.span(),
9437 }
9438 }
9439}
9440#[derive(Debug, Clone)]
9441pub enum AmbientDeclarationChildren<'tree> {
9442 Declaration(::std::boxed::Box<Declaration<'tree>>),
9443 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
9444 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
9445 Type(::std::boxed::Box<Type<'tree>>),
9446}
9447impl<'tree> ::treesitter_types::FromNode<'tree> for AmbientDeclarationChildren<'tree> {
9448 #[allow(clippy::collapsible_else_if)]
9449 fn from_node(
9450 node: ::tree_sitter::Node<'tree>,
9451 src: &'tree [u8],
9452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9453 match node.kind() {
9454 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
9455 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9456 ))),
9457 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
9458 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9459 ))),
9460 _other => {
9461 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
9462 Ok(Self::Declaration(::std::boxed::Box::new(v)))
9463 } else {
9464 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9465 Ok(Self::Type(::std::boxed::Box::new(v)))
9466 } else {
9467 Err(::treesitter_types::ParseError::unexpected_kind(
9468 _other, node,
9469 ))
9470 }
9471 }
9472 }
9473 }
9474 }
9475}
9476impl ::treesitter_types::Spanned for AmbientDeclarationChildren<'_> {
9477 fn span(&self) -> ::treesitter_types::Span {
9478 match self {
9479 Self::Declaration(inner) => inner.span(),
9480 Self::PropertyIdentifier(inner) => inner.span(),
9481 Self::StatementBlock(inner) => inner.span(),
9482 Self::Type(inner) => inner.span(),
9483 }
9484 }
9485}
9486#[derive(Debug, Clone)]
9487pub enum ArgumentsChildren<'tree> {
9488 Expression(::std::boxed::Box<Expression<'tree>>),
9489 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
9490}
9491impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
9492 #[allow(clippy::collapsible_else_if)]
9493 fn from_node(
9494 node: ::tree_sitter::Node<'tree>,
9495 src: &'tree [u8],
9496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9497 match node.kind() {
9498 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
9499 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
9500 ))),
9501 _other => {
9502 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9503 Ok(Self::Expression(::std::boxed::Box::new(v)))
9504 } else {
9505 Err(::treesitter_types::ParseError::unexpected_kind(
9506 _other, node,
9507 ))
9508 }
9509 }
9510 }
9511 }
9512}
9513impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
9514 fn span(&self) -> ::treesitter_types::Span {
9515 match self {
9516 Self::Expression(inner) => inner.span(),
9517 Self::SpreadElement(inner) => inner.span(),
9518 }
9519 }
9520}
9521#[derive(Debug, Clone)]
9522pub enum ArrayChildren<'tree> {
9523 Expression(::std::boxed::Box<Expression<'tree>>),
9524 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
9525}
9526impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
9527 #[allow(clippy::collapsible_else_if)]
9528 fn from_node(
9529 node: ::tree_sitter::Node<'tree>,
9530 src: &'tree [u8],
9531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9532 match node.kind() {
9533 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
9534 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
9535 ))),
9536 _other => {
9537 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9538 Ok(Self::Expression(::std::boxed::Box::new(v)))
9539 } else {
9540 Err(::treesitter_types::ParseError::unexpected_kind(
9541 _other, node,
9542 ))
9543 }
9544 }
9545 }
9546 }
9547}
9548impl ::treesitter_types::Spanned for ArrayChildren<'_> {
9549 fn span(&self) -> ::treesitter_types::Span {
9550 match self {
9551 Self::Expression(inner) => inner.span(),
9552 Self::SpreadElement(inner) => inner.span(),
9553 }
9554 }
9555}
9556#[derive(Debug, Clone)]
9557pub enum ArrayPatternChildren<'tree> {
9558 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
9559 Pattern(::std::boxed::Box<Pattern<'tree>>),
9560}
9561impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
9562 #[allow(clippy::collapsible_else_if)]
9563 fn from_node(
9564 node: ::tree_sitter::Node<'tree>,
9565 src: &'tree [u8],
9566 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9567 match node.kind() {
9568 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
9569 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9570 ))),
9571 _other => {
9572 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
9573 Ok(Self::Pattern(::std::boxed::Box::new(v)))
9574 } else {
9575 Err(::treesitter_types::ParseError::unexpected_kind(
9576 _other, node,
9577 ))
9578 }
9579 }
9580 }
9581 }
9582}
9583impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
9584 fn span(&self) -> ::treesitter_types::Span {
9585 match self {
9586 Self::AssignmentPattern(inner) => inner.span(),
9587 Self::Pattern(inner) => inner.span(),
9588 }
9589 }
9590}
9591#[derive(Debug, Clone)]
9592pub enum ArrowFunctionBody<'tree> {
9593 Expression(::std::boxed::Box<Expression<'tree>>),
9594 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
9595}
9596impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionBody<'tree> {
9597 #[allow(clippy::collapsible_else_if)]
9598 fn from_node(
9599 node: ::tree_sitter::Node<'tree>,
9600 src: &'tree [u8],
9601 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9602 match node.kind() {
9603 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
9604 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
9605 ))),
9606 _other => {
9607 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9608 Ok(Self::Expression(::std::boxed::Box::new(v)))
9609 } else {
9610 Err(::treesitter_types::ParseError::unexpected_kind(
9611 _other, node,
9612 ))
9613 }
9614 }
9615 }
9616 }
9617}
9618impl ::treesitter_types::Spanned for ArrowFunctionBody<'_> {
9619 fn span(&self) -> ::treesitter_types::Span {
9620 match self {
9621 Self::Expression(inner) => inner.span(),
9622 Self::StatementBlock(inner) => inner.span(),
9623 }
9624 }
9625}
9626#[derive(Debug, Clone)]
9627pub enum ArrowFunctionReturnType<'tree> {
9628 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
9629 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
9630 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
9631}
9632impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionReturnType<'tree> {
9633 #[allow(clippy::collapsible_else_if)]
9634 fn from_node(
9635 node: ::tree_sitter::Node<'tree>,
9636 src: &'tree [u8],
9637 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9638 match node.kind() {
9639 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
9640 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9641 ))),
9642 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
9643 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
9644 ))),
9645 "type_predicate_annotation" => {
9646 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
9647 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
9648 node, src,
9649 )?,
9650 )))
9651 }
9652 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9653 }
9654 }
9655}
9656impl ::treesitter_types::Spanned for ArrowFunctionReturnType<'_> {
9657 fn span(&self) -> ::treesitter_types::Span {
9658 match self {
9659 Self::AssertsAnnotation(inner) => inner.span(),
9660 Self::TypeAnnotation(inner) => inner.span(),
9661 Self::TypePredicateAnnotation(inner) => inner.span(),
9662 }
9663 }
9664}
9665#[derive(Debug, Clone)]
9666pub enum AsExpressionChildren<'tree> {
9667 Expression(::std::boxed::Box<Expression<'tree>>),
9668 Type(::std::boxed::Box<Type<'tree>>),
9669}
9670impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpressionChildren<'tree> {
9671 #[allow(clippy::collapsible_else_if)]
9672 fn from_node(
9673 node: ::tree_sitter::Node<'tree>,
9674 src: &'tree [u8],
9675 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9676 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9677 Ok(Self::Expression(::std::boxed::Box::new(v)))
9678 } else {
9679 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
9680 Ok(Self::Type(::std::boxed::Box::new(v)))
9681 } else {
9682 Err(::treesitter_types::ParseError::unexpected_kind(
9683 node.kind(),
9684 node,
9685 ))
9686 }
9687 }
9688 }
9689}
9690impl ::treesitter_types::Spanned for AsExpressionChildren<'_> {
9691 fn span(&self) -> ::treesitter_types::Span {
9692 match self {
9693 Self::Expression(inner) => inner.span(),
9694 Self::Type(inner) => inner.span(),
9695 }
9696 }
9697}
9698#[derive(Debug, Clone)]
9699pub enum AssertsChildren<'tree> {
9700 Identifier(::std::boxed::Box<Identifier<'tree>>),
9701 This(::std::boxed::Box<This<'tree>>),
9702 TypePredicate(::std::boxed::Box<TypePredicate<'tree>>),
9703}
9704impl<'tree> ::treesitter_types::FromNode<'tree> for AssertsChildren<'tree> {
9705 #[allow(clippy::collapsible_else_if)]
9706 fn from_node(
9707 node: ::tree_sitter::Node<'tree>,
9708 src: &'tree [u8],
9709 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9710 match node.kind() {
9711 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9712 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9713 ))),
9714 "this" => Ok(Self::This(::std::boxed::Box::new(
9715 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
9716 ))),
9717 "type_predicate" => Ok(Self::TypePredicate(::std::boxed::Box::new(
9718 <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)?,
9719 ))),
9720 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9721 }
9722 }
9723}
9724impl ::treesitter_types::Spanned for AssertsChildren<'_> {
9725 fn span(&self) -> ::treesitter_types::Span {
9726 match self {
9727 Self::Identifier(inner) => inner.span(),
9728 Self::This(inner) => inner.span(),
9729 Self::TypePredicate(inner) => inner.span(),
9730 }
9731 }
9732}
9733#[derive(Debug, Clone)]
9734pub enum AssignmentExpressionLeft<'tree> {
9735 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
9736 Identifier(::std::boxed::Box<Identifier<'tree>>),
9737 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
9738 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
9739 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
9740 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
9741 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
9742 Undefined(::std::boxed::Box<Undefined<'tree>>),
9743}
9744impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
9745 #[allow(clippy::collapsible_else_if)]
9746 fn from_node(
9747 node: ::tree_sitter::Node<'tree>,
9748 src: &'tree [u8],
9749 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9750 match node.kind() {
9751 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
9752 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9753 ))),
9754 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9755 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9756 ))),
9757 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
9758 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9759 ))),
9760 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
9761 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9762 ))),
9763 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
9764 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
9765 ))),
9766 "parenthesized_expression" => {
9767 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
9768 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
9769 node, src,
9770 )?,
9771 )))
9772 }
9773 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
9774 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9775 ))),
9776 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
9777 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
9778 ))),
9779 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9780 }
9781 }
9782}
9783impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
9784 fn span(&self) -> ::treesitter_types::Span {
9785 match self {
9786 Self::ArrayPattern(inner) => inner.span(),
9787 Self::Identifier(inner) => inner.span(),
9788 Self::MemberExpression(inner) => inner.span(),
9789 Self::NonNullExpression(inner) => inner.span(),
9790 Self::ObjectPattern(inner) => inner.span(),
9791 Self::ParenthesizedExpression(inner) => inner.span(),
9792 Self::SubscriptExpression(inner) => inner.span(),
9793 Self::Undefined(inner) => inner.span(),
9794 }
9795 }
9796}
9797#[derive(Debug, Clone)]
9798pub enum AugmentedAssignmentExpressionLeft<'tree> {
9799 Identifier(::std::boxed::Box<Identifier<'tree>>),
9800 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
9801 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
9802 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
9803 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
9804}
9805impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
9806 #[allow(clippy::collapsible_else_if)]
9807 fn from_node(
9808 node: ::tree_sitter::Node<'tree>,
9809 src: &'tree [u8],
9810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9811 match node.kind() {
9812 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
9813 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
9814 ))),
9815 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
9816 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9817 ))),
9818 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
9819 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9820 ))),
9821 "parenthesized_expression" => {
9822 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
9823 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
9824 node, src,
9825 )?,
9826 )))
9827 }
9828 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
9829 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
9830 ))),
9831 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9832 }
9833 }
9834}
9835impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
9836 fn span(&self) -> ::treesitter_types::Span {
9837 match self {
9838 Self::Identifier(inner) => inner.span(),
9839 Self::MemberExpression(inner) => inner.span(),
9840 Self::NonNullExpression(inner) => inner.span(),
9841 Self::ParenthesizedExpression(inner) => inner.span(),
9842 Self::SubscriptExpression(inner) => inner.span(),
9843 }
9844 }
9845}
9846#[derive(Debug, Clone)]
9847pub enum AugmentedAssignmentExpressionOperator {
9848 PercentEq(::treesitter_types::Span),
9849 AmpAmpEq(::treesitter_types::Span),
9850 AmpEq(::treesitter_types::Span),
9851 StarStarEq(::treesitter_types::Span),
9852 StarEq(::treesitter_types::Span),
9853 PlusEq(::treesitter_types::Span),
9854 MinusEq(::treesitter_types::Span),
9855 SlashEq(::treesitter_types::Span),
9856 ShlEq(::treesitter_types::Span),
9857 ShrEq(::treesitter_types::Span),
9858 GtGtGtEq(::treesitter_types::Span),
9859 QuestionQuestionEq(::treesitter_types::Span),
9860 CaretEq(::treesitter_types::Span),
9861 PipeEq(::treesitter_types::Span),
9862 PipePipeEq(::treesitter_types::Span),
9863}
9864impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
9865 #[allow(clippy::collapsible_else_if)]
9866 fn from_node(
9867 node: ::tree_sitter::Node<'tree>,
9868 _src: &'tree [u8],
9869 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9870 match node.kind() {
9871 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
9872 "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
9873 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
9874 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
9875 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
9876 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
9877 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
9878 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
9879 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
9880 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
9881 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
9882 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
9883 node,
9884 ))),
9885 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
9886 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
9887 "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
9888 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
9889 }
9890 }
9891}
9892impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
9893 fn span(&self) -> ::treesitter_types::Span {
9894 match self {
9895 Self::PercentEq(span) => *span,
9896 Self::AmpAmpEq(span) => *span,
9897 Self::AmpEq(span) => *span,
9898 Self::StarStarEq(span) => *span,
9899 Self::StarEq(span) => *span,
9900 Self::PlusEq(span) => *span,
9901 Self::MinusEq(span) => *span,
9902 Self::SlashEq(span) => *span,
9903 Self::ShlEq(span) => *span,
9904 Self::ShrEq(span) => *span,
9905 Self::GtGtGtEq(span) => *span,
9906 Self::QuestionQuestionEq(span) => *span,
9907 Self::CaretEq(span) => *span,
9908 Self::PipeEq(span) => *span,
9909 Self::PipePipeEq(span) => *span,
9910 }
9911 }
9912}
9913#[derive(Debug, Clone)]
9914pub enum BinaryExpressionLeft<'tree> {
9915 Expression(::std::boxed::Box<Expression<'tree>>),
9916 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
9917}
9918impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
9919 #[allow(clippy::collapsible_else_if)]
9920 fn from_node(
9921 node: ::tree_sitter::Node<'tree>,
9922 src: &'tree [u8],
9923 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9924 match node.kind() {
9925 "private_property_identifier" => {
9926 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
9927 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
9928 node, src,
9929 )?,
9930 )))
9931 }
9932 _other => {
9933 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
9934 Ok(Self::Expression(::std::boxed::Box::new(v)))
9935 } else {
9936 Err(::treesitter_types::ParseError::unexpected_kind(
9937 _other, node,
9938 ))
9939 }
9940 }
9941 }
9942 }
9943}
9944impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
9945 fn span(&self) -> ::treesitter_types::Span {
9946 match self {
9947 Self::Expression(inner) => inner.span(),
9948 Self::PrivatePropertyIdentifier(inner) => inner.span(),
9949 }
9950 }
9951}
9952#[derive(Debug, Clone)]
9953pub enum BinaryExpressionOperator {
9954 NotEq(::treesitter_types::Span),
9955 BangEqEq(::treesitter_types::Span),
9956 Percent(::treesitter_types::Span),
9957 Amp(::treesitter_types::Span),
9958 AmpAmp(::treesitter_types::Span),
9959 Star(::treesitter_types::Span),
9960 StarStar(::treesitter_types::Span),
9961 Plus(::treesitter_types::Span),
9962 Minus(::treesitter_types::Span),
9963 Slash(::treesitter_types::Span),
9964 Lt(::treesitter_types::Span),
9965 Shl(::treesitter_types::Span),
9966 LtEq(::treesitter_types::Span),
9967 EqEq(::treesitter_types::Span),
9968 EqEqEq(::treesitter_types::Span),
9969 Gt(::treesitter_types::Span),
9970 GtEq(::treesitter_types::Span),
9971 Shr(::treesitter_types::Span),
9972 GtGtGt(::treesitter_types::Span),
9973 QuestionQuestion(::treesitter_types::Span),
9974 Caret(::treesitter_types::Span),
9975 In(::treesitter_types::Span),
9976 Instanceof(::treesitter_types::Span),
9977 Pipe(::treesitter_types::Span),
9978 PipePipe(::treesitter_types::Span),
9979}
9980impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
9981 #[allow(clippy::collapsible_else_if)]
9982 fn from_node(
9983 node: ::tree_sitter::Node<'tree>,
9984 _src: &'tree [u8],
9985 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
9986 match node.kind() {
9987 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
9988 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
9989 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
9990 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
9991 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
9992 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
9993 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
9994 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
9995 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
9996 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
9997 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
9998 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
9999 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
10000 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
10001 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
10002 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
10003 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
10004 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
10005 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
10006 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
10007 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
10008 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
10009 "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
10010 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
10011 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
10012 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10013 }
10014 }
10015}
10016impl ::treesitter_types::Spanned for BinaryExpressionOperator {
10017 fn span(&self) -> ::treesitter_types::Span {
10018 match self {
10019 Self::NotEq(span) => *span,
10020 Self::BangEqEq(span) => *span,
10021 Self::Percent(span) => *span,
10022 Self::Amp(span) => *span,
10023 Self::AmpAmp(span) => *span,
10024 Self::Star(span) => *span,
10025 Self::StarStar(span) => *span,
10026 Self::Plus(span) => *span,
10027 Self::Minus(span) => *span,
10028 Self::Slash(span) => *span,
10029 Self::Lt(span) => *span,
10030 Self::Shl(span) => *span,
10031 Self::LtEq(span) => *span,
10032 Self::EqEq(span) => *span,
10033 Self::EqEqEq(span) => *span,
10034 Self::Gt(span) => *span,
10035 Self::GtEq(span) => *span,
10036 Self::Shr(span) => *span,
10037 Self::GtGtGt(span) => *span,
10038 Self::QuestionQuestion(span) => *span,
10039 Self::Caret(span) => *span,
10040 Self::In(span) => *span,
10041 Self::Instanceof(span) => *span,
10042 Self::Pipe(span) => *span,
10043 Self::PipePipe(span) => *span,
10044 }
10045 }
10046}
10047#[derive(Debug, Clone)]
10048pub enum CallExpressionArguments<'tree> {
10049 Arguments(::std::boxed::Box<Arguments<'tree>>),
10050 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
10051}
10052impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionArguments<'tree> {
10053 #[allow(clippy::collapsible_else_if)]
10054 fn from_node(
10055 node: ::tree_sitter::Node<'tree>,
10056 src: &'tree [u8],
10057 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10058 match node.kind() {
10059 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
10060 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
10061 ))),
10062 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
10063 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
10064 ))),
10065 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10066 }
10067 }
10068}
10069impl ::treesitter_types::Spanned for CallExpressionArguments<'_> {
10070 fn span(&self) -> ::treesitter_types::Span {
10071 match self {
10072 Self::Arguments(inner) => inner.span(),
10073 Self::TemplateString(inner) => inner.span(),
10074 }
10075 }
10076}
10077#[derive(Debug, Clone)]
10078pub enum CallExpressionFunction<'tree> {
10079 Expression(::std::boxed::Box<Expression<'tree>>),
10080 Import(::std::boxed::Box<Import<'tree>>),
10081}
10082impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
10083 #[allow(clippy::collapsible_else_if)]
10084 fn from_node(
10085 node: ::tree_sitter::Node<'tree>,
10086 src: &'tree [u8],
10087 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10088 match node.kind() {
10089 "import" => Ok(Self::Import(::std::boxed::Box::new(
10090 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
10091 ))),
10092 _other => {
10093 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10094 Ok(Self::Expression(::std::boxed::Box::new(v)))
10095 } else {
10096 Err(::treesitter_types::ParseError::unexpected_kind(
10097 _other, node,
10098 ))
10099 }
10100 }
10101 }
10102 }
10103}
10104impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
10105 fn span(&self) -> ::treesitter_types::Span {
10106 match self {
10107 Self::Expression(inner) => inner.span(),
10108 Self::Import(inner) => inner.span(),
10109 }
10110 }
10111}
10112#[derive(Debug, Clone)]
10113pub enum CallSignatureReturnType<'tree> {
10114 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
10115 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
10116 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
10117}
10118impl<'tree> ::treesitter_types::FromNode<'tree> for CallSignatureReturnType<'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 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
10126 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10127 ))),
10128 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
10129 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10130 ))),
10131 "type_predicate_annotation" => {
10132 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
10133 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
10134 node, src,
10135 )?,
10136 )))
10137 }
10138 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10139 }
10140 }
10141}
10142impl ::treesitter_types::Spanned for CallSignatureReturnType<'_> {
10143 fn span(&self) -> ::treesitter_types::Span {
10144 match self {
10145 Self::AssertsAnnotation(inner) => inner.span(),
10146 Self::TypeAnnotation(inner) => inner.span(),
10147 Self::TypePredicateAnnotation(inner) => inner.span(),
10148 }
10149 }
10150}
10151#[derive(Debug, Clone)]
10152pub enum CatchClauseParameter<'tree> {
10153 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
10154 Identifier(::std::boxed::Box<Identifier<'tree>>),
10155 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
10156}
10157impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseParameter<'tree> {
10158 #[allow(clippy::collapsible_else_if)]
10159 fn from_node(
10160 node: ::tree_sitter::Node<'tree>,
10161 src: &'tree [u8],
10162 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10163 match node.kind() {
10164 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
10165 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10166 ))),
10167 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10168 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10169 ))),
10170 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
10171 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10172 ))),
10173 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10174 }
10175 }
10176}
10177impl ::treesitter_types::Spanned for CatchClauseParameter<'_> {
10178 fn span(&self) -> ::treesitter_types::Span {
10179 match self {
10180 Self::ArrayPattern(inner) => inner.span(),
10181 Self::Identifier(inner) => inner.span(),
10182 Self::ObjectPattern(inner) => inner.span(),
10183 }
10184 }
10185}
10186#[derive(Debug, Clone)]
10187pub enum ClassBodyChildren<'tree> {
10188 AbstractMethodSignature(::std::boxed::Box<AbstractMethodSignature<'tree>>),
10189 ClassStaticBlock(::std::boxed::Box<ClassStaticBlock<'tree>>),
10190 IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
10191 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
10192 MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
10193 PublicFieldDefinition(::std::boxed::Box<PublicFieldDefinition<'tree>>),
10194}
10195impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyChildren<'tree> {
10196 #[allow(clippy::collapsible_else_if)]
10197 fn from_node(
10198 node: ::tree_sitter::Node<'tree>,
10199 src: &'tree [u8],
10200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10201 match node.kind() {
10202 "abstract_method_signature" => {
10203 Ok(Self::AbstractMethodSignature(::std::boxed::Box::new(
10204 <AbstractMethodSignature as ::treesitter_types::FromNode>::from_node(
10205 node, src,
10206 )?,
10207 )))
10208 }
10209 "class_static_block" => Ok(Self::ClassStaticBlock(::std::boxed::Box::new(
10210 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
10211 ))),
10212 "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
10213 <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
10214 ))),
10215 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
10216 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
10217 ))),
10218 "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
10219 <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
10220 ))),
10221 "public_field_definition" => Ok(Self::PublicFieldDefinition(::std::boxed::Box::new(
10222 <PublicFieldDefinition 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 ClassBodyChildren<'_> {
10229 fn span(&self) -> ::treesitter_types::Span {
10230 match self {
10231 Self::AbstractMethodSignature(inner) => inner.span(),
10232 Self::ClassStaticBlock(inner) => inner.span(),
10233 Self::IndexSignature(inner) => inner.span(),
10234 Self::MethodDefinition(inner) => inner.span(),
10235 Self::MethodSignature(inner) => inner.span(),
10236 Self::PublicFieldDefinition(inner) => inner.span(),
10237 }
10238 }
10239}
10240#[derive(Debug, Clone)]
10241pub enum ClassHeritageChildren<'tree> {
10242 ExtendsClause(::std::boxed::Box<ExtendsClause<'tree>>),
10243 ImplementsClause(::std::boxed::Box<ImplementsClause<'tree>>),
10244}
10245impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritageChildren<'tree> {
10246 #[allow(clippy::collapsible_else_if)]
10247 fn from_node(
10248 node: ::tree_sitter::Node<'tree>,
10249 src: &'tree [u8],
10250 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10251 match node.kind() {
10252 "extends_clause" => Ok(Self::ExtendsClause(::std::boxed::Box::new(
10253 <ExtendsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10254 ))),
10255 "implements_clause" => Ok(Self::ImplementsClause(::std::boxed::Box::new(
10256 <ImplementsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10257 ))),
10258 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10259 }
10260 }
10261}
10262impl ::treesitter_types::Spanned for ClassHeritageChildren<'_> {
10263 fn span(&self) -> ::treesitter_types::Span {
10264 match self {
10265 Self::ExtendsClause(inner) => inner.span(),
10266 Self::ImplementsClause(inner) => inner.span(),
10267 }
10268 }
10269}
10270#[derive(Debug, Clone)]
10271pub enum DecoratorChildren<'tree> {
10272 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
10273 Identifier(::std::boxed::Box<Identifier<'tree>>),
10274 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
10275 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10276}
10277impl<'tree> ::treesitter_types::FromNode<'tree> for DecoratorChildren<'tree> {
10278 #[allow(clippy::collapsible_else_if)]
10279 fn from_node(
10280 node: ::tree_sitter::Node<'tree>,
10281 src: &'tree [u8],
10282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10283 match node.kind() {
10284 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
10285 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10286 ))),
10287 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10288 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10289 ))),
10290 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
10291 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10292 ))),
10293 "parenthesized_expression" => {
10294 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
10295 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
10296 node, src,
10297 )?,
10298 )))
10299 }
10300 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10301 }
10302 }
10303}
10304impl ::treesitter_types::Spanned for DecoratorChildren<'_> {
10305 fn span(&self) -> ::treesitter_types::Span {
10306 match self {
10307 Self::CallExpression(inner) => inner.span(),
10308 Self::Identifier(inner) => inner.span(),
10309 Self::MemberExpression(inner) => inner.span(),
10310 Self::ParenthesizedExpression(inner) => inner.span(),
10311 }
10312 }
10313}
10314#[derive(Debug, Clone)]
10315pub enum EnumAssignmentName<'tree> {
10316 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
10317 Number(::std::boxed::Box<Number<'tree>>),
10318 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
10319 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
10320 String(::std::boxed::Box<String<'tree>>),
10321}
10322impl<'tree> ::treesitter_types::FromNode<'tree> for EnumAssignmentName<'tree> {
10323 #[allow(clippy::collapsible_else_if)]
10324 fn from_node(
10325 node: ::tree_sitter::Node<'tree>,
10326 src: &'tree [u8],
10327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10328 match node.kind() {
10329 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
10330 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
10331 ))),
10332 "number" => Ok(Self::Number(::std::boxed::Box::new(
10333 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
10334 ))),
10335 "private_property_identifier" => {
10336 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
10337 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
10338 node, src,
10339 )?,
10340 )))
10341 }
10342 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
10343 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10344 ))),
10345 "string" => Ok(Self::String(::std::boxed::Box::new(
10346 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
10347 ))),
10348 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10349 }
10350 }
10351}
10352impl ::treesitter_types::Spanned for EnumAssignmentName<'_> {
10353 fn span(&self) -> ::treesitter_types::Span {
10354 match self {
10355 Self::ComputedPropertyName(inner) => inner.span(),
10356 Self::Number(inner) => inner.span(),
10357 Self::PrivatePropertyIdentifier(inner) => inner.span(),
10358 Self::PropertyIdentifier(inner) => inner.span(),
10359 Self::String(inner) => inner.span(),
10360 }
10361 }
10362}
10363#[derive(Debug, Clone)]
10364pub enum EnumBodyName<'tree> {
10365 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
10366 Number(::std::boxed::Box<Number<'tree>>),
10367 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
10368 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
10369 String(::std::boxed::Box<String<'tree>>),
10370}
10371impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyName<'tree> {
10372 #[allow(clippy::collapsible_else_if)]
10373 fn from_node(
10374 node: ::tree_sitter::Node<'tree>,
10375 src: &'tree [u8],
10376 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10377 match node.kind() {
10378 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
10379 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
10380 ))),
10381 "number" => Ok(Self::Number(::std::boxed::Box::new(
10382 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
10383 ))),
10384 "private_property_identifier" => {
10385 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
10386 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
10387 node, src,
10388 )?,
10389 )))
10390 }
10391 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
10392 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10393 ))),
10394 "string" => Ok(Self::String(::std::boxed::Box::new(
10395 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
10396 ))),
10397 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10398 }
10399 }
10400}
10401impl ::treesitter_types::Spanned for EnumBodyName<'_> {
10402 fn span(&self) -> ::treesitter_types::Span {
10403 match self {
10404 Self::ComputedPropertyName(inner) => inner.span(),
10405 Self::Number(inner) => inner.span(),
10406 Self::PrivatePropertyIdentifier(inner) => inner.span(),
10407 Self::PropertyIdentifier(inner) => inner.span(),
10408 Self::String(inner) => inner.span(),
10409 }
10410 }
10411}
10412#[derive(Debug, Clone)]
10413pub enum ExportSpecifierAlias<'tree> {
10414 Identifier(::std::boxed::Box<Identifier<'tree>>),
10415 String(::std::boxed::Box<String<'tree>>),
10416}
10417impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierAlias<'tree> {
10418 #[allow(clippy::collapsible_else_if)]
10419 fn from_node(
10420 node: ::tree_sitter::Node<'tree>,
10421 src: &'tree [u8],
10422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10423 match node.kind() {
10424 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10425 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10426 ))),
10427 "string" => Ok(Self::String(::std::boxed::Box::new(
10428 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
10429 ))),
10430 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10431 }
10432 }
10433}
10434impl ::treesitter_types::Spanned for ExportSpecifierAlias<'_> {
10435 fn span(&self) -> ::treesitter_types::Span {
10436 match self {
10437 Self::Identifier(inner) => inner.span(),
10438 Self::String(inner) => inner.span(),
10439 }
10440 }
10441}
10442#[derive(Debug, Clone)]
10443pub enum ExportSpecifierName<'tree> {
10444 Identifier(::std::boxed::Box<Identifier<'tree>>),
10445 String(::std::boxed::Box<String<'tree>>),
10446}
10447impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierName<'tree> {
10448 #[allow(clippy::collapsible_else_if)]
10449 fn from_node(
10450 node: ::tree_sitter::Node<'tree>,
10451 src: &'tree [u8],
10452 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10453 match node.kind() {
10454 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10455 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10456 ))),
10457 "string" => Ok(Self::String(::std::boxed::Box::new(
10458 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
10459 ))),
10460 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10461 }
10462 }
10463}
10464impl ::treesitter_types::Spanned for ExportSpecifierName<'_> {
10465 fn span(&self) -> ::treesitter_types::Span {
10466 match self {
10467 Self::Identifier(inner) => inner.span(),
10468 Self::String(inner) => inner.span(),
10469 }
10470 }
10471}
10472#[derive(Debug, Clone)]
10473pub enum ExportStatementChildren<'tree> {
10474 ExportClause(::std::boxed::Box<ExportClause<'tree>>),
10475 Expression(::std::boxed::Box<Expression<'tree>>),
10476 Identifier(::std::boxed::Box<Identifier<'tree>>),
10477 NamespaceExport(::std::boxed::Box<NamespaceExport<'tree>>),
10478}
10479impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatementChildren<'tree> {
10480 #[allow(clippy::collapsible_else_if)]
10481 fn from_node(
10482 node: ::tree_sitter::Node<'tree>,
10483 src: &'tree [u8],
10484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10485 match node.kind() {
10486 "export_clause" => Ok(Self::ExportClause(::std::boxed::Box::new(
10487 <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
10488 ))),
10489 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10490 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10491 ))),
10492 "namespace_export" => Ok(Self::NamespaceExport(::std::boxed::Box::new(
10493 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)?,
10494 ))),
10495 _other => {
10496 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10497 Ok(Self::Expression(::std::boxed::Box::new(v)))
10498 } else {
10499 Err(::treesitter_types::ParseError::unexpected_kind(
10500 _other, node,
10501 ))
10502 }
10503 }
10504 }
10505 }
10506}
10507impl ::treesitter_types::Spanned for ExportStatementChildren<'_> {
10508 fn span(&self) -> ::treesitter_types::Span {
10509 match self {
10510 Self::ExportClause(inner) => inner.span(),
10511 Self::Expression(inner) => inner.span(),
10512 Self::Identifier(inner) => inner.span(),
10513 Self::NamespaceExport(inner) => inner.span(),
10514 }
10515 }
10516}
10517#[derive(Debug, Clone)]
10518pub enum ExpressionStatementChildren<'tree> {
10519 Expression(::std::boxed::Box<Expression<'tree>>),
10520 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
10521}
10522impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
10523 #[allow(clippy::collapsible_else_if)]
10524 fn from_node(
10525 node: ::tree_sitter::Node<'tree>,
10526 src: &'tree [u8],
10527 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10528 match node.kind() {
10529 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
10530 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10531 ))),
10532 _other => {
10533 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10534 Ok(Self::Expression(::std::boxed::Box::new(v)))
10535 } else {
10536 Err(::treesitter_types::ParseError::unexpected_kind(
10537 _other, node,
10538 ))
10539 }
10540 }
10541 }
10542 }
10543}
10544impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
10545 fn span(&self) -> ::treesitter_types::Span {
10546 match self {
10547 Self::Expression(inner) => inner.span(),
10548 Self::SequenceExpression(inner) => inner.span(),
10549 }
10550 }
10551}
10552#[derive(Debug, Clone)]
10553pub enum ExtendsTypeClauseType<'tree> {
10554 GenericType(::std::boxed::Box<GenericType<'tree>>),
10555 NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
10556 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
10557}
10558impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsTypeClauseType<'tree> {
10559 #[allow(clippy::collapsible_else_if)]
10560 fn from_node(
10561 node: ::tree_sitter::Node<'tree>,
10562 src: &'tree [u8],
10563 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10564 match node.kind() {
10565 "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
10566 <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
10567 ))),
10568 "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
10569 <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10570 ))),
10571 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
10572 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10573 ))),
10574 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10575 }
10576 }
10577}
10578impl ::treesitter_types::Spanned for ExtendsTypeClauseType<'_> {
10579 fn span(&self) -> ::treesitter_types::Span {
10580 match self {
10581 Self::GenericType(inner) => inner.span(),
10582 Self::NestedTypeIdentifier(inner) => inner.span(),
10583 Self::TypeIdentifier(inner) => inner.span(),
10584 }
10585 }
10586}
10587#[derive(Debug, Clone)]
10588pub enum ForInStatementKind {
10589 Const(::treesitter_types::Span),
10590 Let(::treesitter_types::Span),
10591 Var(::treesitter_types::Span),
10592}
10593impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementKind {
10594 #[allow(clippy::collapsible_else_if)]
10595 fn from_node(
10596 node: ::tree_sitter::Node<'tree>,
10597 _src: &'tree [u8],
10598 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10599 match node.kind() {
10600 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
10601 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
10602 "var" => Ok(Self::Var(::treesitter_types::Span::from(node))),
10603 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10604 }
10605 }
10606}
10607impl ::treesitter_types::Spanned for ForInStatementKind {
10608 fn span(&self) -> ::treesitter_types::Span {
10609 match self {
10610 Self::Const(span) => *span,
10611 Self::Let(span) => *span,
10612 Self::Var(span) => *span,
10613 }
10614 }
10615}
10616#[derive(Debug, Clone)]
10617pub enum ForInStatementLeft<'tree> {
10618 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
10619 Identifier(::std::boxed::Box<Identifier<'tree>>),
10620 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
10621 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
10622 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
10623 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
10624 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
10625 Undefined(::std::boxed::Box<Undefined<'tree>>),
10626}
10627impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementLeft<'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 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
10635 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10636 ))),
10637 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
10638 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
10639 ))),
10640 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
10641 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10642 ))),
10643 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
10644 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10645 ))),
10646 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
10647 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
10648 ))),
10649 "parenthesized_expression" => {
10650 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
10651 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
10652 node, src,
10653 )?,
10654 )))
10655 }
10656 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
10657 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10658 ))),
10659 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
10660 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
10661 ))),
10662 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10663 }
10664 }
10665}
10666impl ::treesitter_types::Spanned for ForInStatementLeft<'_> {
10667 fn span(&self) -> ::treesitter_types::Span {
10668 match self {
10669 Self::ArrayPattern(inner) => inner.span(),
10670 Self::Identifier(inner) => inner.span(),
10671 Self::MemberExpression(inner) => inner.span(),
10672 Self::NonNullExpression(inner) => inner.span(),
10673 Self::ObjectPattern(inner) => inner.span(),
10674 Self::ParenthesizedExpression(inner) => inner.span(),
10675 Self::SubscriptExpression(inner) => inner.span(),
10676 Self::Undefined(inner) => inner.span(),
10677 }
10678 }
10679}
10680#[derive(Debug, Clone)]
10681pub enum ForInStatementOperator {
10682 In(::treesitter_types::Span),
10683 Of(::treesitter_types::Span),
10684}
10685impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementOperator {
10686 #[allow(clippy::collapsible_else_if)]
10687 fn from_node(
10688 node: ::tree_sitter::Node<'tree>,
10689 _src: &'tree [u8],
10690 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10691 match node.kind() {
10692 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
10693 "of" => Ok(Self::Of(::treesitter_types::Span::from(node))),
10694 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10695 }
10696 }
10697}
10698impl ::treesitter_types::Spanned for ForInStatementOperator {
10699 fn span(&self) -> ::treesitter_types::Span {
10700 match self {
10701 Self::In(span) => *span,
10702 Self::Of(span) => *span,
10703 }
10704 }
10705}
10706#[derive(Debug, Clone)]
10707pub enum ForInStatementRight<'tree> {
10708 Expression(::std::boxed::Box<Expression<'tree>>),
10709 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
10710}
10711impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementRight<'tree> {
10712 #[allow(clippy::collapsible_else_if)]
10713 fn from_node(
10714 node: ::tree_sitter::Node<'tree>,
10715 src: &'tree [u8],
10716 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10717 match node.kind() {
10718 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
10719 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10720 ))),
10721 _other => {
10722 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10723 Ok(Self::Expression(::std::boxed::Box::new(v)))
10724 } else {
10725 Err(::treesitter_types::ParseError::unexpected_kind(
10726 _other, node,
10727 ))
10728 }
10729 }
10730 }
10731 }
10732}
10733impl ::treesitter_types::Spanned for ForInStatementRight<'_> {
10734 fn span(&self) -> ::treesitter_types::Span {
10735 match self {
10736 Self::Expression(inner) => inner.span(),
10737 Self::SequenceExpression(inner) => inner.span(),
10738 }
10739 }
10740}
10741#[derive(Debug, Clone)]
10742pub enum ForStatementCondition<'tree> {
10743 Semicolon(::treesitter_types::Span),
10744 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
10745 Expression(::std::boxed::Box<Expression<'tree>>),
10746 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
10747}
10748impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
10749 #[allow(clippy::collapsible_else_if)]
10750 fn from_node(
10751 node: ::tree_sitter::Node<'tree>,
10752 src: &'tree [u8],
10753 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10754 match node.kind() {
10755 ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
10756 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
10757 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
10758 ))),
10759 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
10760 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10761 ))),
10762 _other => {
10763 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10764 Ok(Self::Expression(::std::boxed::Box::new(v)))
10765 } else {
10766 Err(::treesitter_types::ParseError::unexpected_kind(
10767 _other, node,
10768 ))
10769 }
10770 }
10771 }
10772 }
10773}
10774impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
10775 fn span(&self) -> ::treesitter_types::Span {
10776 match self {
10777 Self::Semicolon(span) => *span,
10778 Self::EmptyStatement(inner) => inner.span(),
10779 Self::Expression(inner) => inner.span(),
10780 Self::SequenceExpression(inner) => inner.span(),
10781 }
10782 }
10783}
10784#[derive(Debug, Clone)]
10785pub enum ForStatementIncrement<'tree> {
10786 Expression(::std::boxed::Box<Expression<'tree>>),
10787 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
10788}
10789impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementIncrement<'tree> {
10790 #[allow(clippy::collapsible_else_if)]
10791 fn from_node(
10792 node: ::tree_sitter::Node<'tree>,
10793 src: &'tree [u8],
10794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10795 match node.kind() {
10796 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
10797 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10798 ))),
10799 _other => {
10800 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10801 Ok(Self::Expression(::std::boxed::Box::new(v)))
10802 } else {
10803 Err(::treesitter_types::ParseError::unexpected_kind(
10804 _other, node,
10805 ))
10806 }
10807 }
10808 }
10809 }
10810}
10811impl ::treesitter_types::Spanned for ForStatementIncrement<'_> {
10812 fn span(&self) -> ::treesitter_types::Span {
10813 match self {
10814 Self::Expression(inner) => inner.span(),
10815 Self::SequenceExpression(inner) => inner.span(),
10816 }
10817 }
10818}
10819#[derive(Debug, Clone)]
10820pub enum ForStatementInitializer<'tree> {
10821 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
10822 Expression(::std::boxed::Box<Expression<'tree>>),
10823 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
10824 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
10825 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
10826}
10827impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
10828 #[allow(clippy::collapsible_else_if)]
10829 fn from_node(
10830 node: ::tree_sitter::Node<'tree>,
10831 src: &'tree [u8],
10832 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10833 match node.kind() {
10834 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
10835 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
10836 ))),
10837 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
10838 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10839 ))),
10840 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
10841 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
10842 ))),
10843 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
10844 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
10845 ))),
10846 _other => {
10847 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
10848 Ok(Self::Expression(::std::boxed::Box::new(v)))
10849 } else {
10850 Err(::treesitter_types::ParseError::unexpected_kind(
10851 _other, node,
10852 ))
10853 }
10854 }
10855 }
10856 }
10857}
10858impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
10859 fn span(&self) -> ::treesitter_types::Span {
10860 match self {
10861 Self::EmptyStatement(inner) => inner.span(),
10862 Self::Expression(inner) => inner.span(),
10863 Self::LexicalDeclaration(inner) => inner.span(),
10864 Self::SequenceExpression(inner) => inner.span(),
10865 Self::VariableDeclaration(inner) => inner.span(),
10866 }
10867 }
10868}
10869#[derive(Debug, Clone)]
10870pub enum FormalParametersChildren<'tree> {
10871 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
10872 RequiredParameter(::std::boxed::Box<RequiredParameter<'tree>>),
10873}
10874impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
10875 #[allow(clippy::collapsible_else_if)]
10876 fn from_node(
10877 node: ::tree_sitter::Node<'tree>,
10878 src: &'tree [u8],
10879 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10880 match node.kind() {
10881 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
10882 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10883 ))),
10884 "required_parameter" => Ok(Self::RequiredParameter(::std::boxed::Box::new(
10885 <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
10886 ))),
10887 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10888 }
10889 }
10890}
10891impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
10892 fn span(&self) -> ::treesitter_types::Span {
10893 match self {
10894 Self::OptionalParameter(inner) => inner.span(),
10895 Self::RequiredParameter(inner) => inner.span(),
10896 }
10897 }
10898}
10899#[derive(Debug, Clone)]
10900pub enum FunctionDeclarationReturnType<'tree> {
10901 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
10902 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
10903 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
10904}
10905impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarationReturnType<'tree> {
10906 #[allow(clippy::collapsible_else_if)]
10907 fn from_node(
10908 node: ::tree_sitter::Node<'tree>,
10909 src: &'tree [u8],
10910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10911 match node.kind() {
10912 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
10913 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10914 ))),
10915 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
10916 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10917 ))),
10918 "type_predicate_annotation" => {
10919 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
10920 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
10921 node, src,
10922 )?,
10923 )))
10924 }
10925 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10926 }
10927 }
10928}
10929impl ::treesitter_types::Spanned for FunctionDeclarationReturnType<'_> {
10930 fn span(&self) -> ::treesitter_types::Span {
10931 match self {
10932 Self::AssertsAnnotation(inner) => inner.span(),
10933 Self::TypeAnnotation(inner) => inner.span(),
10934 Self::TypePredicateAnnotation(inner) => inner.span(),
10935 }
10936 }
10937}
10938#[derive(Debug, Clone)]
10939pub enum FunctionExpressionReturnType<'tree> {
10940 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
10941 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
10942 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
10943}
10944impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpressionReturnType<'tree> {
10945 #[allow(clippy::collapsible_else_if)]
10946 fn from_node(
10947 node: ::tree_sitter::Node<'tree>,
10948 src: &'tree [u8],
10949 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10950 match node.kind() {
10951 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
10952 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10953 ))),
10954 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
10955 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10956 ))),
10957 "type_predicate_annotation" => {
10958 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
10959 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
10960 node, src,
10961 )?,
10962 )))
10963 }
10964 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
10965 }
10966 }
10967}
10968impl ::treesitter_types::Spanned for FunctionExpressionReturnType<'_> {
10969 fn span(&self) -> ::treesitter_types::Span {
10970 match self {
10971 Self::AssertsAnnotation(inner) => inner.span(),
10972 Self::TypeAnnotation(inner) => inner.span(),
10973 Self::TypePredicateAnnotation(inner) => inner.span(),
10974 }
10975 }
10976}
10977#[derive(Debug, Clone)]
10978pub enum FunctionSignatureReturnType<'tree> {
10979 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
10980 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
10981 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
10982}
10983impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureReturnType<'tree> {
10984 #[allow(clippy::collapsible_else_if)]
10985 fn from_node(
10986 node: ::tree_sitter::Node<'tree>,
10987 src: &'tree [u8],
10988 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
10989 match node.kind() {
10990 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
10991 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10992 ))),
10993 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
10994 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
10995 ))),
10996 "type_predicate_annotation" => {
10997 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
10998 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
10999 node, src,
11000 )?,
11001 )))
11002 }
11003 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11004 }
11005 }
11006}
11007impl ::treesitter_types::Spanned for FunctionSignatureReturnType<'_> {
11008 fn span(&self) -> ::treesitter_types::Span {
11009 match self {
11010 Self::AssertsAnnotation(inner) => inner.span(),
11011 Self::TypeAnnotation(inner) => inner.span(),
11012 Self::TypePredicateAnnotation(inner) => inner.span(),
11013 }
11014 }
11015}
11016#[derive(Debug, Clone)]
11017pub enum FunctionTypeReturnType<'tree> {
11018 Asserts(::std::boxed::Box<Asserts<'tree>>),
11019 Type(::std::boxed::Box<Type<'tree>>),
11020 TypePredicate(::std::boxed::Box<TypePredicate<'tree>>),
11021}
11022impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeReturnType<'tree> {
11023 #[allow(clippy::collapsible_else_if)]
11024 fn from_node(
11025 node: ::tree_sitter::Node<'tree>,
11026 src: &'tree [u8],
11027 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11028 match node.kind() {
11029 "asserts" => Ok(Self::Asserts(::std::boxed::Box::new(
11030 <Asserts as ::treesitter_types::FromNode>::from_node(node, src)?,
11031 ))),
11032 "type_predicate" => Ok(Self::TypePredicate(::std::boxed::Box::new(
11033 <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)?,
11034 ))),
11035 _other => {
11036 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11037 Ok(Self::Type(::std::boxed::Box::new(v)))
11038 } else {
11039 Err(::treesitter_types::ParseError::unexpected_kind(
11040 _other, node,
11041 ))
11042 }
11043 }
11044 }
11045 }
11046}
11047impl ::treesitter_types::Spanned for FunctionTypeReturnType<'_> {
11048 fn span(&self) -> ::treesitter_types::Span {
11049 match self {
11050 Self::Asserts(inner) => inner.span(),
11051 Self::Type(inner) => inner.span(),
11052 Self::TypePredicate(inner) => inner.span(),
11053 }
11054 }
11055}
11056#[derive(Debug, Clone)]
11057pub enum GeneratorFunctionReturnType<'tree> {
11058 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
11059 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
11060 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
11061}
11062impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionReturnType<'tree> {
11063 #[allow(clippy::collapsible_else_if)]
11064 fn from_node(
11065 node: ::tree_sitter::Node<'tree>,
11066 src: &'tree [u8],
11067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11068 match node.kind() {
11069 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
11070 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11071 ))),
11072 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
11073 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11074 ))),
11075 "type_predicate_annotation" => {
11076 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
11077 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
11078 node, src,
11079 )?,
11080 )))
11081 }
11082 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11083 }
11084 }
11085}
11086impl ::treesitter_types::Spanned for GeneratorFunctionReturnType<'_> {
11087 fn span(&self) -> ::treesitter_types::Span {
11088 match self {
11089 Self::AssertsAnnotation(inner) => inner.span(),
11090 Self::TypeAnnotation(inner) => inner.span(),
11091 Self::TypePredicateAnnotation(inner) => inner.span(),
11092 }
11093 }
11094}
11095#[derive(Debug, Clone)]
11096pub enum GeneratorFunctionDeclarationReturnType<'tree> {
11097 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
11098 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
11099 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
11100}
11101impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclarationReturnType<'tree> {
11102 #[allow(clippy::collapsible_else_if)]
11103 fn from_node(
11104 node: ::tree_sitter::Node<'tree>,
11105 src: &'tree [u8],
11106 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11107 match node.kind() {
11108 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
11109 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11110 ))),
11111 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
11112 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11113 ))),
11114 "type_predicate_annotation" => {
11115 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
11116 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
11117 node, src,
11118 )?,
11119 )))
11120 }
11121 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11122 }
11123 }
11124}
11125impl ::treesitter_types::Spanned for GeneratorFunctionDeclarationReturnType<'_> {
11126 fn span(&self) -> ::treesitter_types::Span {
11127 match self {
11128 Self::AssertsAnnotation(inner) => inner.span(),
11129 Self::TypeAnnotation(inner) => inner.span(),
11130 Self::TypePredicateAnnotation(inner) => inner.span(),
11131 }
11132 }
11133}
11134#[derive(Debug, Clone)]
11135pub enum GenericTypeName<'tree> {
11136 NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
11137 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11138}
11139impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeName<'tree> {
11140 #[allow(clippy::collapsible_else_if)]
11141 fn from_node(
11142 node: ::tree_sitter::Node<'tree>,
11143 src: &'tree [u8],
11144 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11145 match node.kind() {
11146 "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
11147 <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11148 ))),
11149 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11150 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11151 ))),
11152 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11153 }
11154 }
11155}
11156impl ::treesitter_types::Spanned for GenericTypeName<'_> {
11157 fn span(&self) -> ::treesitter_types::Span {
11158 match self {
11159 Self::NestedTypeIdentifier(inner) => inner.span(),
11160 Self::TypeIdentifier(inner) => inner.span(),
11161 }
11162 }
11163}
11164#[derive(Debug, Clone)]
11165pub enum ImportAliasChildren<'tree> {
11166 Identifier(::std::boxed::Box<Identifier<'tree>>),
11167 NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
11168}
11169impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAliasChildren<'tree> {
11170 #[allow(clippy::collapsible_else_if)]
11171 fn from_node(
11172 node: ::tree_sitter::Node<'tree>,
11173 src: &'tree [u8],
11174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11175 match node.kind() {
11176 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11177 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11178 ))),
11179 "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
11180 <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11181 ))),
11182 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11183 }
11184 }
11185}
11186impl ::treesitter_types::Spanned for ImportAliasChildren<'_> {
11187 fn span(&self) -> ::treesitter_types::Span {
11188 match self {
11189 Self::Identifier(inner) => inner.span(),
11190 Self::NestedIdentifier(inner) => inner.span(),
11191 }
11192 }
11193}
11194#[derive(Debug, Clone)]
11195pub enum ImportClauseChildren<'tree> {
11196 Identifier(::std::boxed::Box<Identifier<'tree>>),
11197 NamedImports(::std::boxed::Box<NamedImports<'tree>>),
11198 NamespaceImport(::std::boxed::Box<NamespaceImport<'tree>>),
11199}
11200impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClauseChildren<'tree> {
11201 #[allow(clippy::collapsible_else_if)]
11202 fn from_node(
11203 node: ::tree_sitter::Node<'tree>,
11204 src: &'tree [u8],
11205 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11206 match node.kind() {
11207 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11208 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11209 ))),
11210 "named_imports" => Ok(Self::NamedImports(::std::boxed::Box::new(
11211 <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)?,
11212 ))),
11213 "namespace_import" => Ok(Self::NamespaceImport(::std::boxed::Box::new(
11214 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)?,
11215 ))),
11216 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11217 }
11218 }
11219}
11220impl ::treesitter_types::Spanned for ImportClauseChildren<'_> {
11221 fn span(&self) -> ::treesitter_types::Span {
11222 match self {
11223 Self::Identifier(inner) => inner.span(),
11224 Self::NamedImports(inner) => inner.span(),
11225 Self::NamespaceImport(inner) => inner.span(),
11226 }
11227 }
11228}
11229#[derive(Debug, Clone)]
11230pub enum ImportSpecifierName<'tree> {
11231 Identifier(::std::boxed::Box<Identifier<'tree>>),
11232 String(::std::boxed::Box<String<'tree>>),
11233}
11234impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifierName<'tree> {
11235 #[allow(clippy::collapsible_else_if)]
11236 fn from_node(
11237 node: ::tree_sitter::Node<'tree>,
11238 src: &'tree [u8],
11239 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11240 match node.kind() {
11241 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11242 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11243 ))),
11244 "string" => Ok(Self::String(::std::boxed::Box::new(
11245 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11246 ))),
11247 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11248 }
11249 }
11250}
11251impl ::treesitter_types::Spanned for ImportSpecifierName<'_> {
11252 fn span(&self) -> ::treesitter_types::Span {
11253 match self {
11254 Self::Identifier(inner) => inner.span(),
11255 Self::String(inner) => inner.span(),
11256 }
11257 }
11258}
11259#[derive(Debug, Clone)]
11260pub enum ImportStatementChildren<'tree> {
11261 ImportAttribute(::std::boxed::Box<ImportAttribute<'tree>>),
11262 ImportClause(::std::boxed::Box<ImportClause<'tree>>),
11263 ImportRequireClause(::std::boxed::Box<ImportRequireClause<'tree>>),
11264}
11265impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatementChildren<'tree> {
11266 #[allow(clippy::collapsible_else_if)]
11267 fn from_node(
11268 node: ::tree_sitter::Node<'tree>,
11269 src: &'tree [u8],
11270 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11271 match node.kind() {
11272 "import_attribute" => Ok(Self::ImportAttribute(::std::boxed::Box::new(
11273 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
11274 ))),
11275 "import_clause" => Ok(Self::ImportClause(::std::boxed::Box::new(
11276 <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11277 ))),
11278 "import_require_clause" => Ok(Self::ImportRequireClause(::std::boxed::Box::new(
11279 <ImportRequireClause as ::treesitter_types::FromNode>::from_node(node, src)?,
11280 ))),
11281 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11282 }
11283 }
11284}
11285impl ::treesitter_types::Spanned for ImportStatementChildren<'_> {
11286 fn span(&self) -> ::treesitter_types::Span {
11287 match self {
11288 Self::ImportAttribute(inner) => inner.span(),
11289 Self::ImportClause(inner) => inner.span(),
11290 Self::ImportRequireClause(inner) => inner.span(),
11291 }
11292 }
11293}
11294#[derive(Debug, Clone)]
11295pub enum IndexSignatureSign {
11296 Plus(::treesitter_types::Span),
11297 Minus(::treesitter_types::Span),
11298}
11299impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignatureSign {
11300 #[allow(clippy::collapsible_else_if)]
11301 fn from_node(
11302 node: ::tree_sitter::Node<'tree>,
11303 _src: &'tree [u8],
11304 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11305 match node.kind() {
11306 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
11307 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
11308 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11309 }
11310 }
11311}
11312impl ::treesitter_types::Spanned for IndexSignatureSign {
11313 fn span(&self) -> ::treesitter_types::Span {
11314 match self {
11315 Self::Plus(span) => *span,
11316 Self::Minus(span) => *span,
11317 }
11318 }
11319}
11320#[derive(Debug, Clone)]
11321pub enum IndexSignatureType<'tree> {
11322 AddingTypeAnnotation(::std::boxed::Box<AddingTypeAnnotation<'tree>>),
11323 OmittingTypeAnnotation(::std::boxed::Box<OmittingTypeAnnotation<'tree>>),
11324 OptingTypeAnnotation(::std::boxed::Box<OptingTypeAnnotation<'tree>>),
11325 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
11326}
11327impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignatureType<'tree> {
11328 #[allow(clippy::collapsible_else_if)]
11329 fn from_node(
11330 node: ::tree_sitter::Node<'tree>,
11331 src: &'tree [u8],
11332 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11333 match node.kind() {
11334 "adding_type_annotation" => Ok(Self::AddingTypeAnnotation(::std::boxed::Box::new(
11335 <AddingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11336 ))),
11337 "omitting_type_annotation" => Ok(Self::OmittingTypeAnnotation(::std::boxed::Box::new(
11338 <OmittingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11339 ))),
11340 "opting_type_annotation" => Ok(Self::OptingTypeAnnotation(::std::boxed::Box::new(
11341 <OptingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11342 ))),
11343 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
11344 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11345 ))),
11346 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11347 }
11348 }
11349}
11350impl ::treesitter_types::Spanned for IndexSignatureType<'_> {
11351 fn span(&self) -> ::treesitter_types::Span {
11352 match self {
11353 Self::AddingTypeAnnotation(inner) => inner.span(),
11354 Self::OmittingTypeAnnotation(inner) => inner.span(),
11355 Self::OptingTypeAnnotation(inner) => inner.span(),
11356 Self::TypeAnnotation(inner) => inner.span(),
11357 }
11358 }
11359}
11360#[derive(Debug, Clone)]
11361pub enum InferTypeChildren<'tree> {
11362 Type(::std::boxed::Box<Type<'tree>>),
11363 TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
11364}
11365impl<'tree> ::treesitter_types::FromNode<'tree> for InferTypeChildren<'tree> {
11366 #[allow(clippy::collapsible_else_if)]
11367 fn from_node(
11368 node: ::tree_sitter::Node<'tree>,
11369 src: &'tree [u8],
11370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11371 match node.kind() {
11372 "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
11373 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11374 ))),
11375 _other => {
11376 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
11377 Ok(Self::Type(::std::boxed::Box::new(v)))
11378 } else {
11379 Err(::treesitter_types::ParseError::unexpected_kind(
11380 _other, node,
11381 ))
11382 }
11383 }
11384 }
11385 }
11386}
11387impl ::treesitter_types::Spanned for InferTypeChildren<'_> {
11388 fn span(&self) -> ::treesitter_types::Span {
11389 match self {
11390 Self::Type(inner) => inner.span(),
11391 Self::TypeIdentifier(inner) => inner.span(),
11392 }
11393 }
11394}
11395#[derive(Debug, Clone)]
11396pub enum InstantiationExpressionFunction<'tree> {
11397 Identifier(::std::boxed::Box<Identifier<'tree>>),
11398 Import(::std::boxed::Box<Import<'tree>>),
11399 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
11400 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
11401}
11402impl<'tree> ::treesitter_types::FromNode<'tree> for InstantiationExpressionFunction<'tree> {
11403 #[allow(clippy::collapsible_else_if)]
11404 fn from_node(
11405 node: ::tree_sitter::Node<'tree>,
11406 src: &'tree [u8],
11407 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11408 match node.kind() {
11409 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11410 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11411 ))),
11412 "import" => Ok(Self::Import(::std::boxed::Box::new(
11413 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
11414 ))),
11415 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
11416 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11417 ))),
11418 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
11419 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11420 ))),
11421 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11422 }
11423 }
11424}
11425impl ::treesitter_types::Spanned for InstantiationExpressionFunction<'_> {
11426 fn span(&self) -> ::treesitter_types::Span {
11427 match self {
11428 Self::Identifier(inner) => inner.span(),
11429 Self::Import(inner) => inner.span(),
11430 Self::MemberExpression(inner) => inner.span(),
11431 Self::SubscriptExpression(inner) => inner.span(),
11432 }
11433 }
11434}
11435#[derive(Debug, Clone)]
11436pub enum InterfaceBodyChildren<'tree> {
11437 CallSignature(::std::boxed::Box<CallSignature<'tree>>),
11438 ConstructSignature(::std::boxed::Box<ConstructSignature<'tree>>),
11439 ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
11440 IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
11441 MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
11442 PropertySignature(::std::boxed::Box<PropertySignature<'tree>>),
11443}
11444impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBodyChildren<'tree> {
11445 #[allow(clippy::collapsible_else_if)]
11446 fn from_node(
11447 node: ::tree_sitter::Node<'tree>,
11448 src: &'tree [u8],
11449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11450 match node.kind() {
11451 "call_signature" => Ok(Self::CallSignature(::std::boxed::Box::new(
11452 <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
11453 ))),
11454 "construct_signature" => Ok(Self::ConstructSignature(::std::boxed::Box::new(
11455 <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
11456 ))),
11457 "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
11458 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
11459 ))),
11460 "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
11461 <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
11462 ))),
11463 "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
11464 <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
11465 ))),
11466 "property_signature" => Ok(Self::PropertySignature(::std::boxed::Box::new(
11467 <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)?,
11468 ))),
11469 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11470 }
11471 }
11472}
11473impl ::treesitter_types::Spanned for InterfaceBodyChildren<'_> {
11474 fn span(&self) -> ::treesitter_types::Span {
11475 match self {
11476 Self::CallSignature(inner) => inner.span(),
11477 Self::ConstructSignature(inner) => inner.span(),
11478 Self::ExportStatement(inner) => inner.span(),
11479 Self::IndexSignature(inner) => inner.span(),
11480 Self::MethodSignature(inner) => inner.span(),
11481 Self::PropertySignature(inner) => inner.span(),
11482 }
11483 }
11484}
11485#[derive(Debug, Clone)]
11486pub enum InternalModuleName<'tree> {
11487 Identifier(::std::boxed::Box<Identifier<'tree>>),
11488 NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
11489 String(::std::boxed::Box<String<'tree>>),
11490}
11491impl<'tree> ::treesitter_types::FromNode<'tree> for InternalModuleName<'tree> {
11492 #[allow(clippy::collapsible_else_if)]
11493 fn from_node(
11494 node: ::tree_sitter::Node<'tree>,
11495 src: &'tree [u8],
11496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11497 match node.kind() {
11498 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11499 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11500 ))),
11501 "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
11502 <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11503 ))),
11504 "string" => Ok(Self::String(::std::boxed::Box::new(
11505 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11506 ))),
11507 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11508 }
11509 }
11510}
11511impl ::treesitter_types::Spanned for InternalModuleName<'_> {
11512 fn span(&self) -> ::treesitter_types::Span {
11513 match self {
11514 Self::Identifier(inner) => inner.span(),
11515 Self::NestedIdentifier(inner) => inner.span(),
11516 Self::String(inner) => inner.span(),
11517 }
11518 }
11519}
11520#[derive(Debug, Clone)]
11521pub enum LexicalDeclarationKind {
11522 Const(::treesitter_types::Span),
11523 Let(::treesitter_types::Span),
11524}
11525impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclarationKind {
11526 #[allow(clippy::collapsible_else_if)]
11527 fn from_node(
11528 node: ::tree_sitter::Node<'tree>,
11529 _src: &'tree [u8],
11530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11531 match node.kind() {
11532 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
11533 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
11534 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11535 }
11536 }
11537}
11538impl ::treesitter_types::Spanned for LexicalDeclarationKind {
11539 fn span(&self) -> ::treesitter_types::Span {
11540 match self {
11541 Self::Const(span) => *span,
11542 Self::Let(span) => *span,
11543 }
11544 }
11545}
11546#[derive(Debug, Clone)]
11547pub enum LiteralTypeChildren<'tree> {
11548 False(::std::boxed::Box<False<'tree>>),
11549 Null(::std::boxed::Box<Null<'tree>>),
11550 Number(::std::boxed::Box<Number<'tree>>),
11551 String(::std::boxed::Box<String<'tree>>),
11552 True(::std::boxed::Box<True<'tree>>),
11553 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
11554 Undefined(::std::boxed::Box<Undefined<'tree>>),
11555}
11556impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralTypeChildren<'tree> {
11557 #[allow(clippy::collapsible_else_if)]
11558 fn from_node(
11559 node: ::tree_sitter::Node<'tree>,
11560 src: &'tree [u8],
11561 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11562 match node.kind() {
11563 "false" => Ok(Self::False(::std::boxed::Box::new(
11564 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
11565 ))),
11566 "null" => Ok(Self::Null(::std::boxed::Box::new(
11567 <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
11568 ))),
11569 "number" => Ok(Self::Number(::std::boxed::Box::new(
11570 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
11571 ))),
11572 "string" => Ok(Self::String(::std::boxed::Box::new(
11573 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11574 ))),
11575 "true" => Ok(Self::True(::std::boxed::Box::new(
11576 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
11577 ))),
11578 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
11579 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11580 ))),
11581 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
11582 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
11583 ))),
11584 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11585 }
11586 }
11587}
11588impl ::treesitter_types::Spanned for LiteralTypeChildren<'_> {
11589 fn span(&self) -> ::treesitter_types::Span {
11590 match self {
11591 Self::False(inner) => inner.span(),
11592 Self::Null(inner) => inner.span(),
11593 Self::Number(inner) => inner.span(),
11594 Self::String(inner) => inner.span(),
11595 Self::True(inner) => inner.span(),
11596 Self::UnaryExpression(inner) => inner.span(),
11597 Self::Undefined(inner) => inner.span(),
11598 }
11599 }
11600}
11601#[derive(Debug, Clone)]
11602pub enum MemberExpressionObject<'tree> {
11603 Expression(::std::boxed::Box<Expression<'tree>>),
11604 Import(::std::boxed::Box<Import<'tree>>),
11605}
11606impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionObject<'tree> {
11607 #[allow(clippy::collapsible_else_if)]
11608 fn from_node(
11609 node: ::tree_sitter::Node<'tree>,
11610 src: &'tree [u8],
11611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11612 match node.kind() {
11613 "import" => Ok(Self::Import(::std::boxed::Box::new(
11614 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
11615 ))),
11616 _other => {
11617 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
11618 Ok(Self::Expression(::std::boxed::Box::new(v)))
11619 } else {
11620 Err(::treesitter_types::ParseError::unexpected_kind(
11621 _other, node,
11622 ))
11623 }
11624 }
11625 }
11626 }
11627}
11628impl ::treesitter_types::Spanned for MemberExpressionObject<'_> {
11629 fn span(&self) -> ::treesitter_types::Span {
11630 match self {
11631 Self::Expression(inner) => inner.span(),
11632 Self::Import(inner) => inner.span(),
11633 }
11634 }
11635}
11636#[derive(Debug, Clone)]
11637pub enum MemberExpressionProperty<'tree> {
11638 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
11639 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
11640}
11641impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionProperty<'tree> {
11642 #[allow(clippy::collapsible_else_if)]
11643 fn from_node(
11644 node: ::tree_sitter::Node<'tree>,
11645 src: &'tree [u8],
11646 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11647 match node.kind() {
11648 "private_property_identifier" => {
11649 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
11650 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
11651 node, src,
11652 )?,
11653 )))
11654 }
11655 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
11656 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11657 ))),
11658 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11659 }
11660 }
11661}
11662impl ::treesitter_types::Spanned for MemberExpressionProperty<'_> {
11663 fn span(&self) -> ::treesitter_types::Span {
11664 match self {
11665 Self::PrivatePropertyIdentifier(inner) => inner.span(),
11666 Self::PropertyIdentifier(inner) => inner.span(),
11667 }
11668 }
11669}
11670#[derive(Debug, Clone)]
11671pub enum MethodDefinitionName<'tree> {
11672 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
11673 Number(::std::boxed::Box<Number<'tree>>),
11674 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
11675 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
11676 String(::std::boxed::Box<String<'tree>>),
11677}
11678impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionName<'tree> {
11679 #[allow(clippy::collapsible_else_if)]
11680 fn from_node(
11681 node: ::tree_sitter::Node<'tree>,
11682 src: &'tree [u8],
11683 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11684 match node.kind() {
11685 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
11686 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
11687 ))),
11688 "number" => Ok(Self::Number(::std::boxed::Box::new(
11689 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
11690 ))),
11691 "private_property_identifier" => {
11692 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
11693 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
11694 node, src,
11695 )?,
11696 )))
11697 }
11698 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
11699 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11700 ))),
11701 "string" => Ok(Self::String(::std::boxed::Box::new(
11702 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11703 ))),
11704 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11705 }
11706 }
11707}
11708impl ::treesitter_types::Spanned for MethodDefinitionName<'_> {
11709 fn span(&self) -> ::treesitter_types::Span {
11710 match self {
11711 Self::ComputedPropertyName(inner) => inner.span(),
11712 Self::Number(inner) => inner.span(),
11713 Self::PrivatePropertyIdentifier(inner) => inner.span(),
11714 Self::PropertyIdentifier(inner) => inner.span(),
11715 Self::String(inner) => inner.span(),
11716 }
11717 }
11718}
11719#[derive(Debug, Clone)]
11720pub enum MethodDefinitionReturnType<'tree> {
11721 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
11722 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
11723 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
11724}
11725impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionReturnType<'tree> {
11726 #[allow(clippy::collapsible_else_if)]
11727 fn from_node(
11728 node: ::tree_sitter::Node<'tree>,
11729 src: &'tree [u8],
11730 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11731 match node.kind() {
11732 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
11733 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11734 ))),
11735 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
11736 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11737 ))),
11738 "type_predicate_annotation" => {
11739 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
11740 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
11741 node, src,
11742 )?,
11743 )))
11744 }
11745 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11746 }
11747 }
11748}
11749impl ::treesitter_types::Spanned for MethodDefinitionReturnType<'_> {
11750 fn span(&self) -> ::treesitter_types::Span {
11751 match self {
11752 Self::AssertsAnnotation(inner) => inner.span(),
11753 Self::TypeAnnotation(inner) => inner.span(),
11754 Self::TypePredicateAnnotation(inner) => inner.span(),
11755 }
11756 }
11757}
11758#[derive(Debug, Clone)]
11759pub enum MethodDefinitionChildren<'tree> {
11760 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
11761 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
11762}
11763impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionChildren<'tree> {
11764 #[allow(clippy::collapsible_else_if)]
11765 fn from_node(
11766 node: ::tree_sitter::Node<'tree>,
11767 src: &'tree [u8],
11768 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11769 match node.kind() {
11770 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
11771 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11772 ))),
11773 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
11774 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11775 ))),
11776 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11777 }
11778 }
11779}
11780impl ::treesitter_types::Spanned for MethodDefinitionChildren<'_> {
11781 fn span(&self) -> ::treesitter_types::Span {
11782 match self {
11783 Self::AccessibilityModifier(inner) => inner.span(),
11784 Self::OverrideModifier(inner) => inner.span(),
11785 }
11786 }
11787}
11788#[derive(Debug, Clone)]
11789pub enum MethodSignatureName<'tree> {
11790 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
11791 Number(::std::boxed::Box<Number<'tree>>),
11792 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
11793 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
11794 String(::std::boxed::Box<String<'tree>>),
11795}
11796impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureName<'tree> {
11797 #[allow(clippy::collapsible_else_if)]
11798 fn from_node(
11799 node: ::tree_sitter::Node<'tree>,
11800 src: &'tree [u8],
11801 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11802 match node.kind() {
11803 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
11804 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
11805 ))),
11806 "number" => Ok(Self::Number(::std::boxed::Box::new(
11807 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
11808 ))),
11809 "private_property_identifier" => {
11810 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
11811 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
11812 node, src,
11813 )?,
11814 )))
11815 }
11816 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
11817 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11818 ))),
11819 "string" => Ok(Self::String(::std::boxed::Box::new(
11820 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11821 ))),
11822 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11823 }
11824 }
11825}
11826impl ::treesitter_types::Spanned for MethodSignatureName<'_> {
11827 fn span(&self) -> ::treesitter_types::Span {
11828 match self {
11829 Self::ComputedPropertyName(inner) => inner.span(),
11830 Self::Number(inner) => inner.span(),
11831 Self::PrivatePropertyIdentifier(inner) => inner.span(),
11832 Self::PropertyIdentifier(inner) => inner.span(),
11833 Self::String(inner) => inner.span(),
11834 }
11835 }
11836}
11837#[derive(Debug, Clone)]
11838pub enum MethodSignatureReturnType<'tree> {
11839 AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
11840 TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
11841 TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
11842}
11843impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureReturnType<'tree> {
11844 #[allow(clippy::collapsible_else_if)]
11845 fn from_node(
11846 node: ::tree_sitter::Node<'tree>,
11847 src: &'tree [u8],
11848 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11849 match node.kind() {
11850 "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
11851 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11852 ))),
11853 "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
11854 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
11855 ))),
11856 "type_predicate_annotation" => {
11857 Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
11858 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
11859 node, src,
11860 )?,
11861 )))
11862 }
11863 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11864 }
11865 }
11866}
11867impl ::treesitter_types::Spanned for MethodSignatureReturnType<'_> {
11868 fn span(&self) -> ::treesitter_types::Span {
11869 match self {
11870 Self::AssertsAnnotation(inner) => inner.span(),
11871 Self::TypeAnnotation(inner) => inner.span(),
11872 Self::TypePredicateAnnotation(inner) => inner.span(),
11873 }
11874 }
11875}
11876#[derive(Debug, Clone)]
11877pub enum MethodSignatureChildren<'tree> {
11878 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
11879 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
11880}
11881impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureChildren<'tree> {
11882 #[allow(clippy::collapsible_else_if)]
11883 fn from_node(
11884 node: ::tree_sitter::Node<'tree>,
11885 src: &'tree [u8],
11886 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11887 match node.kind() {
11888 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
11889 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11890 ))),
11891 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
11892 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11893 ))),
11894 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11895 }
11896 }
11897}
11898impl ::treesitter_types::Spanned for MethodSignatureChildren<'_> {
11899 fn span(&self) -> ::treesitter_types::Span {
11900 match self {
11901 Self::AccessibilityModifier(inner) => inner.span(),
11902 Self::OverrideModifier(inner) => inner.span(),
11903 }
11904 }
11905}
11906#[derive(Debug, Clone)]
11907pub enum ModuleName<'tree> {
11908 Identifier(::std::boxed::Box<Identifier<'tree>>),
11909 NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
11910 String(::std::boxed::Box<String<'tree>>),
11911}
11912impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleName<'tree> {
11913 #[allow(clippy::collapsible_else_if)]
11914 fn from_node(
11915 node: ::tree_sitter::Node<'tree>,
11916 src: &'tree [u8],
11917 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11918 match node.kind() {
11919 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11920 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11921 ))),
11922 "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
11923 <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11924 ))),
11925 "string" => Ok(Self::String(::std::boxed::Box::new(
11926 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11927 ))),
11928 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11929 }
11930 }
11931}
11932impl ::treesitter_types::Spanned for ModuleName<'_> {
11933 fn span(&self) -> ::treesitter_types::Span {
11934 match self {
11935 Self::Identifier(inner) => inner.span(),
11936 Self::NestedIdentifier(inner) => inner.span(),
11937 Self::String(inner) => inner.span(),
11938 }
11939 }
11940}
11941#[derive(Debug, Clone)]
11942pub enum NamespaceExportChildren<'tree> {
11943 Identifier(::std::boxed::Box<Identifier<'tree>>),
11944 String(::std::boxed::Box<String<'tree>>),
11945}
11946impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExportChildren<'tree> {
11947 #[allow(clippy::collapsible_else_if)]
11948 fn from_node(
11949 node: ::tree_sitter::Node<'tree>,
11950 src: &'tree [u8],
11951 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11952 match node.kind() {
11953 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11954 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11955 ))),
11956 "string" => Ok(Self::String(::std::boxed::Box::new(
11957 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
11958 ))),
11959 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11960 }
11961 }
11962}
11963impl ::treesitter_types::Spanned for NamespaceExportChildren<'_> {
11964 fn span(&self) -> ::treesitter_types::Span {
11965 match self {
11966 Self::Identifier(inner) => inner.span(),
11967 Self::String(inner) => inner.span(),
11968 }
11969 }
11970}
11971#[derive(Debug, Clone)]
11972pub enum NestedIdentifierObject<'tree> {
11973 Identifier(::std::boxed::Box<Identifier<'tree>>),
11974 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
11975}
11976impl<'tree> ::treesitter_types::FromNode<'tree> for NestedIdentifierObject<'tree> {
11977 #[allow(clippy::collapsible_else_if)]
11978 fn from_node(
11979 node: ::tree_sitter::Node<'tree>,
11980 src: &'tree [u8],
11981 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
11982 match node.kind() {
11983 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
11984 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
11985 ))),
11986 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
11987 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
11988 ))),
11989 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
11990 }
11991 }
11992}
11993impl ::treesitter_types::Spanned for NestedIdentifierObject<'_> {
11994 fn span(&self) -> ::treesitter_types::Span {
11995 match self {
11996 Self::Identifier(inner) => inner.span(),
11997 Self::MemberExpression(inner) => inner.span(),
11998 }
11999 }
12000}
12001#[derive(Debug, Clone)]
12002pub enum NestedTypeIdentifierModule<'tree> {
12003 Identifier(::std::boxed::Box<Identifier<'tree>>),
12004 NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
12005}
12006impl<'tree> ::treesitter_types::FromNode<'tree> for NestedTypeIdentifierModule<'tree> {
12007 #[allow(clippy::collapsible_else_if)]
12008 fn from_node(
12009 node: ::tree_sitter::Node<'tree>,
12010 src: &'tree [u8],
12011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12012 match node.kind() {
12013 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12014 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12015 ))),
12016 "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
12017 <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12018 ))),
12019 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12020 }
12021 }
12022}
12023impl ::treesitter_types::Spanned for NestedTypeIdentifierModule<'_> {
12024 fn span(&self) -> ::treesitter_types::Span {
12025 match self {
12026 Self::Identifier(inner) => inner.span(),
12027 Self::NestedIdentifier(inner) => inner.span(),
12028 }
12029 }
12030}
12031#[derive(Debug, Clone)]
12032pub enum ObjectChildren<'tree> {
12033 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
12034 Pair(::std::boxed::Box<Pair<'tree>>),
12035 ShorthandPropertyIdentifier(::std::boxed::Box<ShorthandPropertyIdentifier<'tree>>),
12036 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
12037}
12038impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectChildren<'tree> {
12039 #[allow(clippy::collapsible_else_if)]
12040 fn from_node(
12041 node: ::tree_sitter::Node<'tree>,
12042 src: &'tree [u8],
12043 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12044 match node.kind() {
12045 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
12046 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
12047 ))),
12048 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
12049 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
12050 ))),
12051 "shorthand_property_identifier" => {
12052 Ok(Self::ShorthandPropertyIdentifier(::std::boxed::Box::new(
12053 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(
12054 node, src,
12055 )?,
12056 )))
12057 }
12058 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
12059 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
12060 ))),
12061 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12062 }
12063 }
12064}
12065impl ::treesitter_types::Spanned for ObjectChildren<'_> {
12066 fn span(&self) -> ::treesitter_types::Span {
12067 match self {
12068 Self::MethodDefinition(inner) => inner.span(),
12069 Self::Pair(inner) => inner.span(),
12070 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
12071 Self::SpreadElement(inner) => inner.span(),
12072 }
12073 }
12074}
12075#[derive(Debug, Clone)]
12076pub enum ObjectAssignmentPatternLeft<'tree> {
12077 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
12078 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
12079 ShorthandPropertyIdentifierPattern(
12080 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
12081 ),
12082}
12083impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPatternLeft<'tree> {
12084 #[allow(clippy::collapsible_else_if)]
12085 fn from_node(
12086 node: ::tree_sitter::Node<'tree>,
12087 src: &'tree [u8],
12088 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12089 match node.kind() {
12090 "array_pattern" => {
12091 Ok(
12092 Self::ArrayPattern(
12093 ::std::boxed::Box::new(
12094 <ArrayPattern as ::treesitter_types::FromNode>::from_node(
12095 node,
12096 src,
12097 )?,
12098 ),
12099 ),
12100 )
12101 }
12102 "object_pattern" => {
12103 Ok(
12104 Self::ObjectPattern(
12105 ::std::boxed::Box::new(
12106 <ObjectPattern as ::treesitter_types::FromNode>::from_node(
12107 node,
12108 src,
12109 )?,
12110 ),
12111 ),
12112 )
12113 }
12114 "shorthand_property_identifier_pattern" => {
12115 Ok(
12116 Self::ShorthandPropertyIdentifierPattern(
12117 ::std::boxed::Box::new(
12118 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
12119 node,
12120 src,
12121 )?,
12122 ),
12123 ),
12124 )
12125 }
12126 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12127 }
12128 }
12129}
12130impl ::treesitter_types::Spanned for ObjectAssignmentPatternLeft<'_> {
12131 fn span(&self) -> ::treesitter_types::Span {
12132 match self {
12133 Self::ArrayPattern(inner) => inner.span(),
12134 Self::ObjectPattern(inner) => inner.span(),
12135 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
12136 }
12137 }
12138}
12139#[derive(Debug, Clone)]
12140pub enum ObjectPatternChildren<'tree> {
12141 ObjectAssignmentPattern(::std::boxed::Box<ObjectAssignmentPattern<'tree>>),
12142 PairPattern(::std::boxed::Box<PairPattern<'tree>>),
12143 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
12144 ShorthandPropertyIdentifierPattern(
12145 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
12146 ),
12147}
12148impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPatternChildren<'tree> {
12149 #[allow(clippy::collapsible_else_if)]
12150 fn from_node(
12151 node: ::tree_sitter::Node<'tree>,
12152 src: &'tree [u8],
12153 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12154 match node.kind() {
12155 "object_assignment_pattern" => {
12156 Ok(
12157 Self::ObjectAssignmentPattern(
12158 ::std::boxed::Box::new(
12159 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(
12160 node,
12161 src,
12162 )?,
12163 ),
12164 ),
12165 )
12166 }
12167 "pair_pattern" => {
12168 Ok(
12169 Self::PairPattern(
12170 ::std::boxed::Box::new(
12171 <PairPattern as ::treesitter_types::FromNode>::from_node(
12172 node,
12173 src,
12174 )?,
12175 ),
12176 ),
12177 )
12178 }
12179 "rest_pattern" => {
12180 Ok(
12181 Self::RestPattern(
12182 ::std::boxed::Box::new(
12183 <RestPattern as ::treesitter_types::FromNode>::from_node(
12184 node,
12185 src,
12186 )?,
12187 ),
12188 ),
12189 )
12190 }
12191 "shorthand_property_identifier_pattern" => {
12192 Ok(
12193 Self::ShorthandPropertyIdentifierPattern(
12194 ::std::boxed::Box::new(
12195 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
12196 node,
12197 src,
12198 )?,
12199 ),
12200 ),
12201 )
12202 }
12203 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12204 }
12205 }
12206}
12207impl ::treesitter_types::Spanned for ObjectPatternChildren<'_> {
12208 fn span(&self) -> ::treesitter_types::Span {
12209 match self {
12210 Self::ObjectAssignmentPattern(inner) => inner.span(),
12211 Self::PairPattern(inner) => inner.span(),
12212 Self::RestPattern(inner) => inner.span(),
12213 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
12214 }
12215 }
12216}
12217#[derive(Debug, Clone)]
12218pub enum ObjectTypeChildren<'tree> {
12219 CallSignature(::std::boxed::Box<CallSignature<'tree>>),
12220 ConstructSignature(::std::boxed::Box<ConstructSignature<'tree>>),
12221 ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
12222 IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
12223 MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
12224 PropertySignature(::std::boxed::Box<PropertySignature<'tree>>),
12225}
12226impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectTypeChildren<'tree> {
12227 #[allow(clippy::collapsible_else_if)]
12228 fn from_node(
12229 node: ::tree_sitter::Node<'tree>,
12230 src: &'tree [u8],
12231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12232 match node.kind() {
12233 "call_signature" => Ok(Self::CallSignature(::std::boxed::Box::new(
12234 <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
12235 ))),
12236 "construct_signature" => Ok(Self::ConstructSignature(::std::boxed::Box::new(
12237 <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
12238 ))),
12239 "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
12240 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
12241 ))),
12242 "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
12243 <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
12244 ))),
12245 "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
12246 <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
12247 ))),
12248 "property_signature" => Ok(Self::PropertySignature(::std::boxed::Box::new(
12249 <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)?,
12250 ))),
12251 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12252 }
12253 }
12254}
12255impl ::treesitter_types::Spanned for ObjectTypeChildren<'_> {
12256 fn span(&self) -> ::treesitter_types::Span {
12257 match self {
12258 Self::CallSignature(inner) => inner.span(),
12259 Self::ConstructSignature(inner) => inner.span(),
12260 Self::ExportStatement(inner) => inner.span(),
12261 Self::IndexSignature(inner) => inner.span(),
12262 Self::MethodSignature(inner) => inner.span(),
12263 Self::PropertySignature(inner) => inner.span(),
12264 }
12265 }
12266}
12267#[derive(Debug, Clone)]
12268pub enum OptionalParameterPattern<'tree> {
12269 Pattern(::std::boxed::Box<Pattern<'tree>>),
12270 This(::std::boxed::Box<This<'tree>>),
12271}
12272impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterPattern<'tree> {
12273 #[allow(clippy::collapsible_else_if)]
12274 fn from_node(
12275 node: ::tree_sitter::Node<'tree>,
12276 src: &'tree [u8],
12277 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12278 match node.kind() {
12279 "this" => Ok(Self::This(::std::boxed::Box::new(
12280 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
12281 ))),
12282 _other => {
12283 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12284 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12285 } else {
12286 Err(::treesitter_types::ParseError::unexpected_kind(
12287 _other, node,
12288 ))
12289 }
12290 }
12291 }
12292 }
12293}
12294impl ::treesitter_types::Spanned for OptionalParameterPattern<'_> {
12295 fn span(&self) -> ::treesitter_types::Span {
12296 match self {
12297 Self::Pattern(inner) => inner.span(),
12298 Self::This(inner) => inner.span(),
12299 }
12300 }
12301}
12302#[derive(Debug, Clone)]
12303pub enum OptionalParameterChildren<'tree> {
12304 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
12305 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
12306}
12307impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterChildren<'tree> {
12308 #[allow(clippy::collapsible_else_if)]
12309 fn from_node(
12310 node: ::tree_sitter::Node<'tree>,
12311 src: &'tree [u8],
12312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12313 match node.kind() {
12314 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
12315 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12316 ))),
12317 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
12318 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12319 ))),
12320 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12321 }
12322 }
12323}
12324impl ::treesitter_types::Spanned for OptionalParameterChildren<'_> {
12325 fn span(&self) -> ::treesitter_types::Span {
12326 match self {
12327 Self::AccessibilityModifier(inner) => inner.span(),
12328 Self::OverrideModifier(inner) => inner.span(),
12329 }
12330 }
12331}
12332#[derive(Debug, Clone)]
12333pub enum PairKey<'tree> {
12334 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
12335 Number(::std::boxed::Box<Number<'tree>>),
12336 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
12337 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
12338 String(::std::boxed::Box<String<'tree>>),
12339}
12340impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'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 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
12348 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
12349 ))),
12350 "number" => Ok(Self::Number(::std::boxed::Box::new(
12351 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
12352 ))),
12353 "private_property_identifier" => {
12354 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
12355 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
12356 node, src,
12357 )?,
12358 )))
12359 }
12360 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
12361 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12362 ))),
12363 "string" => Ok(Self::String(::std::boxed::Box::new(
12364 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12365 ))),
12366 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12367 }
12368 }
12369}
12370impl ::treesitter_types::Spanned for PairKey<'_> {
12371 fn span(&self) -> ::treesitter_types::Span {
12372 match self {
12373 Self::ComputedPropertyName(inner) => inner.span(),
12374 Self::Number(inner) => inner.span(),
12375 Self::PrivatePropertyIdentifier(inner) => inner.span(),
12376 Self::PropertyIdentifier(inner) => inner.span(),
12377 Self::String(inner) => inner.span(),
12378 }
12379 }
12380}
12381#[derive(Debug, Clone)]
12382pub enum PairPatternKey<'tree> {
12383 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
12384 Number(::std::boxed::Box<Number<'tree>>),
12385 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
12386 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
12387 String(::std::boxed::Box<String<'tree>>),
12388}
12389impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternKey<'tree> {
12390 #[allow(clippy::collapsible_else_if)]
12391 fn from_node(
12392 node: ::tree_sitter::Node<'tree>,
12393 src: &'tree [u8],
12394 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12395 match node.kind() {
12396 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
12397 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
12398 ))),
12399 "number" => Ok(Self::Number(::std::boxed::Box::new(
12400 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
12401 ))),
12402 "private_property_identifier" => {
12403 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
12404 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
12405 node, src,
12406 )?,
12407 )))
12408 }
12409 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
12410 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12411 ))),
12412 "string" => Ok(Self::String(::std::boxed::Box::new(
12413 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12414 ))),
12415 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12416 }
12417 }
12418}
12419impl ::treesitter_types::Spanned for PairPatternKey<'_> {
12420 fn span(&self) -> ::treesitter_types::Span {
12421 match self {
12422 Self::ComputedPropertyName(inner) => inner.span(),
12423 Self::Number(inner) => inner.span(),
12424 Self::PrivatePropertyIdentifier(inner) => inner.span(),
12425 Self::PropertyIdentifier(inner) => inner.span(),
12426 Self::String(inner) => inner.span(),
12427 }
12428 }
12429}
12430#[derive(Debug, Clone)]
12431pub enum PairPatternValue<'tree> {
12432 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
12433 Pattern(::std::boxed::Box<Pattern<'tree>>),
12434}
12435impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternValue<'tree> {
12436 #[allow(clippy::collapsible_else_if)]
12437 fn from_node(
12438 node: ::tree_sitter::Node<'tree>,
12439 src: &'tree [u8],
12440 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12441 match node.kind() {
12442 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
12443 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12444 ))),
12445 _other => {
12446 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12447 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12448 } else {
12449 Err(::treesitter_types::ParseError::unexpected_kind(
12450 _other, node,
12451 ))
12452 }
12453 }
12454 }
12455 }
12456}
12457impl ::treesitter_types::Spanned for PairPatternValue<'_> {
12458 fn span(&self) -> ::treesitter_types::Span {
12459 match self {
12460 Self::AssignmentPattern(inner) => inner.span(),
12461 Self::Pattern(inner) => inner.span(),
12462 }
12463 }
12464}
12465#[derive(Debug, Clone)]
12466pub enum ParenthesizedExpressionChildren<'tree> {
12467 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
12468 Expression(::std::boxed::Box<Expression<'tree>>),
12469 Identifier(::std::boxed::Box<Identifier<'tree>>),
12470 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
12471 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
12472}
12473impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
12474 #[allow(clippy::collapsible_else_if)]
12475 fn from_node(
12476 node: ::tree_sitter::Node<'tree>,
12477 src: &'tree [u8],
12478 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12479 match node.kind() {
12480 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
12481 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12482 ))),
12483 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12484 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12485 ))),
12486 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
12487 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12488 ))),
12489 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
12490 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12491 ))),
12492 _other => {
12493 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12494 Ok(Self::Expression(::std::boxed::Box::new(v)))
12495 } else {
12496 Err(::treesitter_types::ParseError::unexpected_kind(
12497 _other, node,
12498 ))
12499 }
12500 }
12501 }
12502 }
12503}
12504impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
12505 fn span(&self) -> ::treesitter_types::Span {
12506 match self {
12507 Self::CallExpression(inner) => inner.span(),
12508 Self::Expression(inner) => inner.span(),
12509 Self::Identifier(inner) => inner.span(),
12510 Self::MemberExpression(inner) => inner.span(),
12511 Self::SequenceExpression(inner) => inner.span(),
12512 }
12513 }
12514}
12515#[derive(Debug, Clone)]
12516pub enum ProgramChildren<'tree> {
12517 HashBangLine(::std::boxed::Box<HashBangLine<'tree>>),
12518 Statement(::std::boxed::Box<Statement<'tree>>),
12519}
12520impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
12521 #[allow(clippy::collapsible_else_if)]
12522 fn from_node(
12523 node: ::tree_sitter::Node<'tree>,
12524 src: &'tree [u8],
12525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12526 match node.kind() {
12527 "hash_bang_line" => Ok(Self::HashBangLine(::std::boxed::Box::new(
12528 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)?,
12529 ))),
12530 _other => {
12531 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
12532 Ok(Self::Statement(::std::boxed::Box::new(v)))
12533 } else {
12534 Err(::treesitter_types::ParseError::unexpected_kind(
12535 _other, node,
12536 ))
12537 }
12538 }
12539 }
12540 }
12541}
12542impl ::treesitter_types::Spanned for ProgramChildren<'_> {
12543 fn span(&self) -> ::treesitter_types::Span {
12544 match self {
12545 Self::HashBangLine(inner) => inner.span(),
12546 Self::Statement(inner) => inner.span(),
12547 }
12548 }
12549}
12550#[derive(Debug, Clone)]
12551pub enum PropertySignatureName<'tree> {
12552 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
12553 Number(::std::boxed::Box<Number<'tree>>),
12554 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
12555 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
12556 String(::std::boxed::Box<String<'tree>>),
12557}
12558impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignatureName<'tree> {
12559 #[allow(clippy::collapsible_else_if)]
12560 fn from_node(
12561 node: ::tree_sitter::Node<'tree>,
12562 src: &'tree [u8],
12563 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12564 match node.kind() {
12565 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
12566 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
12567 ))),
12568 "number" => Ok(Self::Number(::std::boxed::Box::new(
12569 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
12570 ))),
12571 "private_property_identifier" => {
12572 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
12573 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
12574 node, src,
12575 )?,
12576 )))
12577 }
12578 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
12579 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12580 ))),
12581 "string" => Ok(Self::String(::std::boxed::Box::new(
12582 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12583 ))),
12584 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12585 }
12586 }
12587}
12588impl ::treesitter_types::Spanned for PropertySignatureName<'_> {
12589 fn span(&self) -> ::treesitter_types::Span {
12590 match self {
12591 Self::ComputedPropertyName(inner) => inner.span(),
12592 Self::Number(inner) => inner.span(),
12593 Self::PrivatePropertyIdentifier(inner) => inner.span(),
12594 Self::PropertyIdentifier(inner) => inner.span(),
12595 Self::String(inner) => inner.span(),
12596 }
12597 }
12598}
12599#[derive(Debug, Clone)]
12600pub enum PropertySignatureChildren<'tree> {
12601 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
12602 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
12603}
12604impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignatureChildren<'tree> {
12605 #[allow(clippy::collapsible_else_if)]
12606 fn from_node(
12607 node: ::tree_sitter::Node<'tree>,
12608 src: &'tree [u8],
12609 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12610 match node.kind() {
12611 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
12612 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12613 ))),
12614 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
12615 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12616 ))),
12617 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12618 }
12619 }
12620}
12621impl ::treesitter_types::Spanned for PropertySignatureChildren<'_> {
12622 fn span(&self) -> ::treesitter_types::Span {
12623 match self {
12624 Self::AccessibilityModifier(inner) => inner.span(),
12625 Self::OverrideModifier(inner) => inner.span(),
12626 }
12627 }
12628}
12629#[derive(Debug, Clone)]
12630pub enum PublicFieldDefinitionName<'tree> {
12631 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
12632 Number(::std::boxed::Box<Number<'tree>>),
12633 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
12634 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
12635 String(::std::boxed::Box<String<'tree>>),
12636}
12637impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinitionName<'tree> {
12638 #[allow(clippy::collapsible_else_if)]
12639 fn from_node(
12640 node: ::tree_sitter::Node<'tree>,
12641 src: &'tree [u8],
12642 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12643 match node.kind() {
12644 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
12645 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
12646 ))),
12647 "number" => Ok(Self::Number(::std::boxed::Box::new(
12648 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
12649 ))),
12650 "private_property_identifier" => {
12651 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
12652 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
12653 node, src,
12654 )?,
12655 )))
12656 }
12657 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
12658 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12659 ))),
12660 "string" => Ok(Self::String(::std::boxed::Box::new(
12661 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12662 ))),
12663 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12664 }
12665 }
12666}
12667impl ::treesitter_types::Spanned for PublicFieldDefinitionName<'_> {
12668 fn span(&self) -> ::treesitter_types::Span {
12669 match self {
12670 Self::ComputedPropertyName(inner) => inner.span(),
12671 Self::Number(inner) => inner.span(),
12672 Self::PrivatePropertyIdentifier(inner) => inner.span(),
12673 Self::PropertyIdentifier(inner) => inner.span(),
12674 Self::String(inner) => inner.span(),
12675 }
12676 }
12677}
12678#[derive(Debug, Clone)]
12679pub enum PublicFieldDefinitionChildren<'tree> {
12680 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
12681 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
12682}
12683impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinitionChildren<'tree> {
12684 #[allow(clippy::collapsible_else_if)]
12685 fn from_node(
12686 node: ::tree_sitter::Node<'tree>,
12687 src: &'tree [u8],
12688 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12689 match node.kind() {
12690 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
12691 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12692 ))),
12693 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
12694 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12695 ))),
12696 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12697 }
12698 }
12699}
12700impl ::treesitter_types::Spanned for PublicFieldDefinitionChildren<'_> {
12701 fn span(&self) -> ::treesitter_types::Span {
12702 match self {
12703 Self::AccessibilityModifier(inner) => inner.span(),
12704 Self::OverrideModifier(inner) => inner.span(),
12705 }
12706 }
12707}
12708#[derive(Debug, Clone)]
12709pub enum RequiredParameterName<'tree> {
12710 Identifier(::std::boxed::Box<Identifier<'tree>>),
12711 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
12712}
12713impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterName<'tree> {
12714 #[allow(clippy::collapsible_else_if)]
12715 fn from_node(
12716 node: ::tree_sitter::Node<'tree>,
12717 src: &'tree [u8],
12718 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12719 match node.kind() {
12720 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12721 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12722 ))),
12723 "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
12724 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12725 ))),
12726 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12727 }
12728 }
12729}
12730impl ::treesitter_types::Spanned for RequiredParameterName<'_> {
12731 fn span(&self) -> ::treesitter_types::Span {
12732 match self {
12733 Self::Identifier(inner) => inner.span(),
12734 Self::RestPattern(inner) => inner.span(),
12735 }
12736 }
12737}
12738#[derive(Debug, Clone)]
12739pub enum RequiredParameterPattern<'tree> {
12740 Pattern(::std::boxed::Box<Pattern<'tree>>),
12741 This(::std::boxed::Box<This<'tree>>),
12742}
12743impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterPattern<'tree> {
12744 #[allow(clippy::collapsible_else_if)]
12745 fn from_node(
12746 node: ::tree_sitter::Node<'tree>,
12747 src: &'tree [u8],
12748 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12749 match node.kind() {
12750 "this" => Ok(Self::This(::std::boxed::Box::new(
12751 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
12752 ))),
12753 _other => {
12754 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
12755 Ok(Self::Pattern(::std::boxed::Box::new(v)))
12756 } else {
12757 Err(::treesitter_types::ParseError::unexpected_kind(
12758 _other, node,
12759 ))
12760 }
12761 }
12762 }
12763 }
12764}
12765impl ::treesitter_types::Spanned for RequiredParameterPattern<'_> {
12766 fn span(&self) -> ::treesitter_types::Span {
12767 match self {
12768 Self::Pattern(inner) => inner.span(),
12769 Self::This(inner) => inner.span(),
12770 }
12771 }
12772}
12773#[derive(Debug, Clone)]
12774pub enum RequiredParameterChildren<'tree> {
12775 AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
12776 OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
12777}
12778impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterChildren<'tree> {
12779 #[allow(clippy::collapsible_else_if)]
12780 fn from_node(
12781 node: ::tree_sitter::Node<'tree>,
12782 src: &'tree [u8],
12783 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12784 match node.kind() {
12785 "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
12786 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12787 ))),
12788 "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
12789 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12790 ))),
12791 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12792 }
12793 }
12794}
12795impl ::treesitter_types::Spanned for RequiredParameterChildren<'_> {
12796 fn span(&self) -> ::treesitter_types::Span {
12797 match self {
12798 Self::AccessibilityModifier(inner) => inner.span(),
12799 Self::OverrideModifier(inner) => inner.span(),
12800 }
12801 }
12802}
12803#[derive(Debug, Clone)]
12804pub enum RestPatternChildren<'tree> {
12805 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
12806 Identifier(::std::boxed::Box<Identifier<'tree>>),
12807 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
12808 NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
12809 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
12810 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
12811 Undefined(::std::boxed::Box<Undefined<'tree>>),
12812}
12813impl<'tree> ::treesitter_types::FromNode<'tree> for RestPatternChildren<'tree> {
12814 #[allow(clippy::collapsible_else_if)]
12815 fn from_node(
12816 node: ::tree_sitter::Node<'tree>,
12817 src: &'tree [u8],
12818 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12819 match node.kind() {
12820 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
12821 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12822 ))),
12823 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
12824 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
12825 ))),
12826 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
12827 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12828 ))),
12829 "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
12830 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12831 ))),
12832 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
12833 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
12834 ))),
12835 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
12836 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12837 ))),
12838 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
12839 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
12840 ))),
12841 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12842 }
12843 }
12844}
12845impl ::treesitter_types::Spanned for RestPatternChildren<'_> {
12846 fn span(&self) -> ::treesitter_types::Span {
12847 match self {
12848 Self::ArrayPattern(inner) => inner.span(),
12849 Self::Identifier(inner) => inner.span(),
12850 Self::MemberExpression(inner) => inner.span(),
12851 Self::NonNullExpression(inner) => inner.span(),
12852 Self::ObjectPattern(inner) => inner.span(),
12853 Self::SubscriptExpression(inner) => inner.span(),
12854 Self::Undefined(inner) => inner.span(),
12855 }
12856 }
12857}
12858#[derive(Debug, Clone)]
12859pub enum ReturnStatementChildren<'tree> {
12860 Expression(::std::boxed::Box<Expression<'tree>>),
12861 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
12862}
12863impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
12864 #[allow(clippy::collapsible_else_if)]
12865 fn from_node(
12866 node: ::tree_sitter::Node<'tree>,
12867 src: &'tree [u8],
12868 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12869 match node.kind() {
12870 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
12871 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12872 ))),
12873 _other => {
12874 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12875 Ok(Self::Expression(::std::boxed::Box::new(v)))
12876 } else {
12877 Err(::treesitter_types::ParseError::unexpected_kind(
12878 _other, node,
12879 ))
12880 }
12881 }
12882 }
12883 }
12884}
12885impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
12886 fn span(&self) -> ::treesitter_types::Span {
12887 match self {
12888 Self::Expression(inner) => inner.span(),
12889 Self::SequenceExpression(inner) => inner.span(),
12890 }
12891 }
12892}
12893#[derive(Debug, Clone)]
12894pub enum SatisfiesExpressionChildren<'tree> {
12895 Expression(::std::boxed::Box<Expression<'tree>>),
12896 Type(::std::boxed::Box<Type<'tree>>),
12897}
12898impl<'tree> ::treesitter_types::FromNode<'tree> for SatisfiesExpressionChildren<'tree> {
12899 #[allow(clippy::collapsible_else_if)]
12900 fn from_node(
12901 node: ::tree_sitter::Node<'tree>,
12902 src: &'tree [u8],
12903 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12904 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12905 Ok(Self::Expression(::std::boxed::Box::new(v)))
12906 } else {
12907 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
12908 Ok(Self::Type(::std::boxed::Box::new(v)))
12909 } else {
12910 Err(::treesitter_types::ParseError::unexpected_kind(
12911 node.kind(),
12912 node,
12913 ))
12914 }
12915 }
12916 }
12917}
12918impl ::treesitter_types::Spanned for SatisfiesExpressionChildren<'_> {
12919 fn span(&self) -> ::treesitter_types::Span {
12920 match self {
12921 Self::Expression(inner) => inner.span(),
12922 Self::Type(inner) => inner.span(),
12923 }
12924 }
12925}
12926#[derive(Debug, Clone)]
12927pub enum StringChildren<'tree> {
12928 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
12929 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
12930}
12931impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
12932 #[allow(clippy::collapsible_else_if)]
12933 fn from_node(
12934 node: ::tree_sitter::Node<'tree>,
12935 src: &'tree [u8],
12936 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12937 match node.kind() {
12938 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
12939 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
12940 ))),
12941 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
12942 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
12943 ))),
12944 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
12945 }
12946 }
12947}
12948impl ::treesitter_types::Spanned for StringChildren<'_> {
12949 fn span(&self) -> ::treesitter_types::Span {
12950 match self {
12951 Self::EscapeSequence(inner) => inner.span(),
12952 Self::StringFragment(inner) => inner.span(),
12953 }
12954 }
12955}
12956#[derive(Debug, Clone)]
12957pub enum SubscriptExpressionIndex<'tree> {
12958 Expression(::std::boxed::Box<Expression<'tree>>),
12959 Number(::std::boxed::Box<Number<'tree>>),
12960 PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
12961 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
12962 String(::std::boxed::Box<String<'tree>>),
12963}
12964impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionIndex<'tree> {
12965 #[allow(clippy::collapsible_else_if)]
12966 fn from_node(
12967 node: ::tree_sitter::Node<'tree>,
12968 src: &'tree [u8],
12969 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12970 match node.kind() {
12971 "number" => Ok(Self::Number(::std::boxed::Box::new(
12972 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
12973 ))),
12974 "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
12975 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
12976 ))),
12977 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
12978 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
12979 ))),
12980 "string" => Ok(Self::String(::std::boxed::Box::new(
12981 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
12982 ))),
12983 _other => {
12984 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
12985 Ok(Self::Expression(::std::boxed::Box::new(v)))
12986 } else {
12987 Err(::treesitter_types::ParseError::unexpected_kind(
12988 _other, node,
12989 ))
12990 }
12991 }
12992 }
12993 }
12994}
12995impl ::treesitter_types::Spanned for SubscriptExpressionIndex<'_> {
12996 fn span(&self) -> ::treesitter_types::Span {
12997 match self {
12998 Self::Expression(inner) => inner.span(),
12999 Self::Number(inner) => inner.span(),
13000 Self::PredefinedType(inner) => inner.span(),
13001 Self::SequenceExpression(inner) => inner.span(),
13002 Self::String(inner) => inner.span(),
13003 }
13004 }
13005}
13006#[derive(Debug, Clone)]
13007pub enum SwitchBodyChildren<'tree> {
13008 SwitchCase(::std::boxed::Box<SwitchCase<'tree>>),
13009 SwitchDefault(::std::boxed::Box<SwitchDefault<'tree>>),
13010}
13011impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBodyChildren<'tree> {
13012 #[allow(clippy::collapsible_else_if)]
13013 fn from_node(
13014 node: ::tree_sitter::Node<'tree>,
13015 src: &'tree [u8],
13016 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13017 match node.kind() {
13018 "switch_case" => Ok(Self::SwitchCase(::std::boxed::Box::new(
13019 <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)?,
13020 ))),
13021 "switch_default" => Ok(Self::SwitchDefault(::std::boxed::Box::new(
13022 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)?,
13023 ))),
13024 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13025 }
13026 }
13027}
13028impl ::treesitter_types::Spanned for SwitchBodyChildren<'_> {
13029 fn span(&self) -> ::treesitter_types::Span {
13030 match self {
13031 Self::SwitchCase(inner) => inner.span(),
13032 Self::SwitchDefault(inner) => inner.span(),
13033 }
13034 }
13035}
13036#[derive(Debug, Clone)]
13037pub enum SwitchCaseValue<'tree> {
13038 Expression(::std::boxed::Box<Expression<'tree>>),
13039 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
13040}
13041impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCaseValue<'tree> {
13042 #[allow(clippy::collapsible_else_if)]
13043 fn from_node(
13044 node: ::tree_sitter::Node<'tree>,
13045 src: &'tree [u8],
13046 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13047 match node.kind() {
13048 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
13049 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13050 ))),
13051 _other => {
13052 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13053 Ok(Self::Expression(::std::boxed::Box::new(v)))
13054 } else {
13055 Err(::treesitter_types::ParseError::unexpected_kind(
13056 _other, node,
13057 ))
13058 }
13059 }
13060 }
13061 }
13062}
13063impl ::treesitter_types::Spanned for SwitchCaseValue<'_> {
13064 fn span(&self) -> ::treesitter_types::Span {
13065 match self {
13066 Self::Expression(inner) => inner.span(),
13067 Self::SequenceExpression(inner) => inner.span(),
13068 }
13069 }
13070}
13071#[derive(Debug, Clone)]
13072pub enum TemplateLiteralTypeChildren<'tree> {
13073 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
13074 TemplateType(::std::boxed::Box<TemplateType<'tree>>),
13075}
13076impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateLiteralTypeChildren<'tree> {
13077 #[allow(clippy::collapsible_else_if)]
13078 fn from_node(
13079 node: ::tree_sitter::Node<'tree>,
13080 src: &'tree [u8],
13081 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13082 match node.kind() {
13083 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
13084 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
13085 ))),
13086 "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
13087 <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
13088 ))),
13089 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13090 }
13091 }
13092}
13093impl ::treesitter_types::Spanned for TemplateLiteralTypeChildren<'_> {
13094 fn span(&self) -> ::treesitter_types::Span {
13095 match self {
13096 Self::StringFragment(inner) => inner.span(),
13097 Self::TemplateType(inner) => inner.span(),
13098 }
13099 }
13100}
13101#[derive(Debug, Clone)]
13102pub enum TemplateStringChildren<'tree> {
13103 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
13104 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
13105 TemplateSubstitution(::std::boxed::Box<TemplateSubstitution<'tree>>),
13106}
13107impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateStringChildren<'tree> {
13108 #[allow(clippy::collapsible_else_if)]
13109 fn from_node(
13110 node: ::tree_sitter::Node<'tree>,
13111 src: &'tree [u8],
13112 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13113 match node.kind() {
13114 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
13115 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
13116 ))),
13117 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
13118 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
13119 ))),
13120 "template_substitution" => Ok(Self::TemplateSubstitution(::std::boxed::Box::new(
13121 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)?,
13122 ))),
13123 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13124 }
13125 }
13126}
13127impl ::treesitter_types::Spanned for TemplateStringChildren<'_> {
13128 fn span(&self) -> ::treesitter_types::Span {
13129 match self {
13130 Self::EscapeSequence(inner) => inner.span(),
13131 Self::StringFragment(inner) => inner.span(),
13132 Self::TemplateSubstitution(inner) => inner.span(),
13133 }
13134 }
13135}
13136#[derive(Debug, Clone)]
13137pub enum TemplateSubstitutionChildren<'tree> {
13138 Expression(::std::boxed::Box<Expression<'tree>>),
13139 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
13140}
13141impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitutionChildren<'tree> {
13142 #[allow(clippy::collapsible_else_if)]
13143 fn from_node(
13144 node: ::tree_sitter::Node<'tree>,
13145 src: &'tree [u8],
13146 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13147 match node.kind() {
13148 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
13149 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13150 ))),
13151 _other => {
13152 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13153 Ok(Self::Expression(::std::boxed::Box::new(v)))
13154 } else {
13155 Err(::treesitter_types::ParseError::unexpected_kind(
13156 _other, node,
13157 ))
13158 }
13159 }
13160 }
13161 }
13162}
13163impl ::treesitter_types::Spanned for TemplateSubstitutionChildren<'_> {
13164 fn span(&self) -> ::treesitter_types::Span {
13165 match self {
13166 Self::Expression(inner) => inner.span(),
13167 Self::SequenceExpression(inner) => inner.span(),
13168 }
13169 }
13170}
13171#[derive(Debug, Clone)]
13172pub enum TemplateTypeChildren<'tree> {
13173 InferType(::std::boxed::Box<InferType<'tree>>),
13174 PrimaryType(::std::boxed::Box<PrimaryType<'tree>>),
13175}
13176impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateTypeChildren<'tree> {
13177 #[allow(clippy::collapsible_else_if)]
13178 fn from_node(
13179 node: ::tree_sitter::Node<'tree>,
13180 src: &'tree [u8],
13181 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13182 match node.kind() {
13183 "infer_type" => Ok(Self::InferType(::std::boxed::Box::new(
13184 <InferType as ::treesitter_types::FromNode>::from_node(node, src)?,
13185 ))),
13186 _other => {
13187 if let Ok(v) = <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src) {
13188 Ok(Self::PrimaryType(::std::boxed::Box::new(v)))
13189 } else {
13190 Err(::treesitter_types::ParseError::unexpected_kind(
13191 _other, node,
13192 ))
13193 }
13194 }
13195 }
13196 }
13197}
13198impl ::treesitter_types::Spanned for TemplateTypeChildren<'_> {
13199 fn span(&self) -> ::treesitter_types::Span {
13200 match self {
13201 Self::InferType(inner) => inner.span(),
13202 Self::PrimaryType(inner) => inner.span(),
13203 }
13204 }
13205}
13206#[derive(Debug, Clone)]
13207pub enum ThrowStatementChildren<'tree> {
13208 Expression(::std::boxed::Box<Expression<'tree>>),
13209 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
13210}
13211impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatementChildren<'tree> {
13212 #[allow(clippy::collapsible_else_if)]
13213 fn from_node(
13214 node: ::tree_sitter::Node<'tree>,
13215 src: &'tree [u8],
13216 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13217 match node.kind() {
13218 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
13219 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13220 ))),
13221 _other => {
13222 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13223 Ok(Self::Expression(::std::boxed::Box::new(v)))
13224 } else {
13225 Err(::treesitter_types::ParseError::unexpected_kind(
13226 _other, node,
13227 ))
13228 }
13229 }
13230 }
13231 }
13232}
13233impl ::treesitter_types::Spanned for ThrowStatementChildren<'_> {
13234 fn span(&self) -> ::treesitter_types::Span {
13235 match self {
13236 Self::Expression(inner) => inner.span(),
13237 Self::SequenceExpression(inner) => inner.span(),
13238 }
13239 }
13240}
13241#[derive(Debug, Clone)]
13242pub enum TupleTypeChildren<'tree> {
13243 OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
13244 OptionalType(::std::boxed::Box<OptionalType<'tree>>),
13245 RequiredParameter(::std::boxed::Box<RequiredParameter<'tree>>),
13246 RestType(::std::boxed::Box<RestType<'tree>>),
13247 Type(::std::boxed::Box<Type<'tree>>),
13248}
13249impl<'tree> ::treesitter_types::FromNode<'tree> for TupleTypeChildren<'tree> {
13250 #[allow(clippy::collapsible_else_if)]
13251 fn from_node(
13252 node: ::tree_sitter::Node<'tree>,
13253 src: &'tree [u8],
13254 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13255 match node.kind() {
13256 "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
13257 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
13258 ))),
13259 "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
13260 <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
13261 ))),
13262 "required_parameter" => Ok(Self::RequiredParameter(::std::boxed::Box::new(
13263 <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
13264 ))),
13265 "rest_type" => Ok(Self::RestType(::std::boxed::Box::new(
13266 <RestType as ::treesitter_types::FromNode>::from_node(node, src)?,
13267 ))),
13268 _other => {
13269 if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
13270 Ok(Self::Type(::std::boxed::Box::new(v)))
13271 } else {
13272 Err(::treesitter_types::ParseError::unexpected_kind(
13273 _other, node,
13274 ))
13275 }
13276 }
13277 }
13278 }
13279}
13280impl ::treesitter_types::Spanned for TupleTypeChildren<'_> {
13281 fn span(&self) -> ::treesitter_types::Span {
13282 match self {
13283 Self::OptionalParameter(inner) => inner.span(),
13284 Self::OptionalType(inner) => inner.span(),
13285 Self::RequiredParameter(inner) => inner.span(),
13286 Self::RestType(inner) => inner.span(),
13287 Self::Type(inner) => inner.span(),
13288 }
13289 }
13290}
13291#[derive(Debug, Clone)]
13292pub enum TypeAssertionChildren<'tree> {
13293 Expression(::std::boxed::Box<Expression<'tree>>),
13294 TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
13295}
13296impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAssertionChildren<'tree> {
13297 #[allow(clippy::collapsible_else_if)]
13298 fn from_node(
13299 node: ::tree_sitter::Node<'tree>,
13300 src: &'tree [u8],
13301 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13302 match node.kind() {
13303 "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
13304 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
13305 ))),
13306 _other => {
13307 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13308 Ok(Self::Expression(::std::boxed::Box::new(v)))
13309 } else {
13310 Err(::treesitter_types::ParseError::unexpected_kind(
13311 _other, node,
13312 ))
13313 }
13314 }
13315 }
13316 }
13317}
13318impl ::treesitter_types::Spanned for TypeAssertionChildren<'_> {
13319 fn span(&self) -> ::treesitter_types::Span {
13320 match self {
13321 Self::Expression(inner) => inner.span(),
13322 Self::TypeArguments(inner) => inner.span(),
13323 }
13324 }
13325}
13326#[derive(Debug, Clone)]
13327pub enum TypePredicateName<'tree> {
13328 Identifier(::std::boxed::Box<Identifier<'tree>>),
13329 This(::std::boxed::Box<This<'tree>>),
13330}
13331impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicateName<'tree> {
13332 #[allow(clippy::collapsible_else_if)]
13333 fn from_node(
13334 node: ::tree_sitter::Node<'tree>,
13335 src: &'tree [u8],
13336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13337 match node.kind() {
13338 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13339 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13340 ))),
13341 "this" => Ok(Self::This(::std::boxed::Box::new(
13342 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
13343 ))),
13344 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13345 }
13346 }
13347}
13348impl ::treesitter_types::Spanned for TypePredicateName<'_> {
13349 fn span(&self) -> ::treesitter_types::Span {
13350 match self {
13351 Self::Identifier(inner) => inner.span(),
13352 Self::This(inner) => inner.span(),
13353 }
13354 }
13355}
13356#[derive(Debug, Clone)]
13357pub enum TypeQueryChildren<'tree> {
13358 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
13359 Identifier(::std::boxed::Box<Identifier<'tree>>),
13360 InstantiationExpression(::std::boxed::Box<InstantiationExpression<'tree>>),
13361 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
13362 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
13363 This(::std::boxed::Box<This<'tree>>),
13364}
13365impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQueryChildren<'tree> {
13366 #[allow(clippy::collapsible_else_if)]
13367 fn from_node(
13368 node: ::tree_sitter::Node<'tree>,
13369 src: &'tree [u8],
13370 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13371 match node.kind() {
13372 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
13373 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13374 ))),
13375 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13376 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13377 ))),
13378 "instantiation_expression" => {
13379 Ok(Self::InstantiationExpression(::std::boxed::Box::new(
13380 <InstantiationExpression as ::treesitter_types::FromNode>::from_node(
13381 node, src,
13382 )?,
13383 )))
13384 }
13385 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
13386 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13387 ))),
13388 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
13389 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
13390 ))),
13391 "this" => Ok(Self::This(::std::boxed::Box::new(
13392 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
13393 ))),
13394 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13395 }
13396 }
13397}
13398impl ::treesitter_types::Spanned for TypeQueryChildren<'_> {
13399 fn span(&self) -> ::treesitter_types::Span {
13400 match self {
13401 Self::CallExpression(inner) => inner.span(),
13402 Self::Identifier(inner) => inner.span(),
13403 Self::InstantiationExpression(inner) => inner.span(),
13404 Self::MemberExpression(inner) => inner.span(),
13405 Self::SubscriptExpression(inner) => inner.span(),
13406 Self::This(inner) => inner.span(),
13407 }
13408 }
13409}
13410#[derive(Debug, Clone)]
13411pub enum UnaryExpressionArgument<'tree> {
13412 Expression(::std::boxed::Box<Expression<'tree>>),
13413 Number(::std::boxed::Box<Number<'tree>>),
13414}
13415impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
13416 #[allow(clippy::collapsible_else_if)]
13417 fn from_node(
13418 node: ::tree_sitter::Node<'tree>,
13419 src: &'tree [u8],
13420 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13421 match node.kind() {
13422 "number" => Ok(Self::Number(::std::boxed::Box::new(
13423 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
13424 ))),
13425 _other => {
13426 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
13427 Ok(Self::Expression(::std::boxed::Box::new(v)))
13428 } else {
13429 Err(::treesitter_types::ParseError::unexpected_kind(
13430 _other, node,
13431 ))
13432 }
13433 }
13434 }
13435 }
13436}
13437impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
13438 fn span(&self) -> ::treesitter_types::Span {
13439 match self {
13440 Self::Expression(inner) => inner.span(),
13441 Self::Number(inner) => inner.span(),
13442 }
13443 }
13444}
13445#[derive(Debug, Clone)]
13446pub enum UnaryExpressionOperator {
13447 Bang(::treesitter_types::Span),
13448 Plus(::treesitter_types::Span),
13449 Minus(::treesitter_types::Span),
13450 Delete(::treesitter_types::Span),
13451 Typeof(::treesitter_types::Span),
13452 Void(::treesitter_types::Span),
13453 Tilde(::treesitter_types::Span),
13454}
13455impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
13456 #[allow(clippy::collapsible_else_if)]
13457 fn from_node(
13458 node: ::tree_sitter::Node<'tree>,
13459 _src: &'tree [u8],
13460 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13461 match node.kind() {
13462 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
13463 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
13464 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
13465 "delete" => Ok(Self::Delete(::treesitter_types::Span::from(node))),
13466 "typeof" => Ok(Self::Typeof(::treesitter_types::Span::from(node))),
13467 "void" => Ok(Self::Void(::treesitter_types::Span::from(node))),
13468 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
13469 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13470 }
13471 }
13472}
13473impl ::treesitter_types::Spanned for UnaryExpressionOperator {
13474 fn span(&self) -> ::treesitter_types::Span {
13475 match self {
13476 Self::Bang(span) => *span,
13477 Self::Plus(span) => *span,
13478 Self::Minus(span) => *span,
13479 Self::Delete(span) => *span,
13480 Self::Typeof(span) => *span,
13481 Self::Void(span) => *span,
13482 Self::Tilde(span) => *span,
13483 }
13484 }
13485}
13486#[derive(Debug, Clone)]
13487pub enum UpdateExpressionOperator {
13488 PlusPlus(::treesitter_types::Span),
13489 MinusMinus(::treesitter_types::Span),
13490}
13491impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
13492 #[allow(clippy::collapsible_else_if)]
13493 fn from_node(
13494 node: ::tree_sitter::Node<'tree>,
13495 _src: &'tree [u8],
13496 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13497 match node.kind() {
13498 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
13499 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
13500 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13501 }
13502 }
13503}
13504impl ::treesitter_types::Spanned for UpdateExpressionOperator {
13505 fn span(&self) -> ::treesitter_types::Span {
13506 match self {
13507 Self::PlusPlus(span) => *span,
13508 Self::MinusMinus(span) => *span,
13509 }
13510 }
13511}
13512#[derive(Debug, Clone)]
13513pub enum VariableDeclaratorName<'tree> {
13514 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
13515 Identifier(::std::boxed::Box<Identifier<'tree>>),
13516 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
13517}
13518impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
13519 #[allow(clippy::collapsible_else_if)]
13520 fn from_node(
13521 node: ::tree_sitter::Node<'tree>,
13522 src: &'tree [u8],
13523 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13524 match node.kind() {
13525 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
13526 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
13527 ))),
13528 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
13529 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
13530 ))),
13531 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
13532 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
13533 ))),
13534 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
13535 }
13536 }
13537}
13538impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
13539 fn span(&self) -> ::treesitter_types::Span {
13540 match self {
13541 Self::ArrayPattern(inner) => inner.span(),
13542 Self::Identifier(inner) => inner.span(),
13543 Self::ObjectPattern(inner) => inner.span(),
13544 }
13545 }
13546}
13547#[derive(Debug, Clone)]
13548pub enum AnyNode<'tree> {
13549 Declaration(Declaration<'tree>),
13550 Expression(Expression<'tree>),
13551 Pattern(Pattern<'tree>),
13552 PrimaryExpression(PrimaryExpression<'tree>),
13553 PrimaryType(PrimaryType<'tree>),
13554 Statement(Statement<'tree>),
13555 Type(Type<'tree>),
13556 AbstractClassDeclaration(AbstractClassDeclaration<'tree>),
13557 AbstractMethodSignature(AbstractMethodSignature<'tree>),
13558 AccessibilityModifier(AccessibilityModifier<'tree>),
13559 AddingTypeAnnotation(AddingTypeAnnotation<'tree>),
13560 AmbientDeclaration(AmbientDeclaration<'tree>),
13561 Arguments(Arguments<'tree>),
13562 Array(Array<'tree>),
13563 ArrayPattern(ArrayPattern<'tree>),
13564 ArrayType(ArrayType<'tree>),
13565 ArrowFunction(ArrowFunction<'tree>),
13566 AsExpression(AsExpression<'tree>),
13567 Asserts(Asserts<'tree>),
13568 AssertsAnnotation(AssertsAnnotation<'tree>),
13569 AssignmentExpression(AssignmentExpression<'tree>),
13570 AssignmentPattern(AssignmentPattern<'tree>),
13571 AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
13572 AwaitExpression(AwaitExpression<'tree>),
13573 BinaryExpression(BinaryExpression<'tree>),
13574 BreakStatement(BreakStatement<'tree>),
13575 CallExpression(CallExpression<'tree>),
13576 CallSignature(CallSignature<'tree>),
13577 CatchClause(CatchClause<'tree>),
13578 Class(Class<'tree>),
13579 ClassBody(ClassBody<'tree>),
13580 ClassDeclaration(ClassDeclaration<'tree>),
13581 ClassHeritage(ClassHeritage<'tree>),
13582 ClassStaticBlock(ClassStaticBlock<'tree>),
13583 ComputedPropertyName(ComputedPropertyName<'tree>),
13584 ConditionalType(ConditionalType<'tree>),
13585 Constraint(Constraint<'tree>),
13586 ConstructSignature(ConstructSignature<'tree>),
13587 ConstructorType(ConstructorType<'tree>),
13588 ContinueStatement(ContinueStatement<'tree>),
13589 DebuggerStatement(DebuggerStatement<'tree>),
13590 Decorator(Decorator<'tree>),
13591 DefaultType(DefaultType<'tree>),
13592 DoStatement(DoStatement<'tree>),
13593 ElseClause(ElseClause<'tree>),
13594 EmptyStatement(EmptyStatement<'tree>),
13595 EnumAssignment(EnumAssignment<'tree>),
13596 EnumBody(EnumBody<'tree>),
13597 EnumDeclaration(EnumDeclaration<'tree>),
13598 ExistentialType(ExistentialType<'tree>),
13599 ExportClause(ExportClause<'tree>),
13600 ExportSpecifier(ExportSpecifier<'tree>),
13601 ExportStatement(ExportStatement<'tree>),
13602 ExpressionStatement(ExpressionStatement<'tree>),
13603 ExtendsClause(ExtendsClause<'tree>),
13604 ExtendsTypeClause(ExtendsTypeClause<'tree>),
13605 FinallyClause(FinallyClause<'tree>),
13606 FlowMaybeType(FlowMaybeType<'tree>),
13607 ForInStatement(ForInStatement<'tree>),
13608 ForStatement(ForStatement<'tree>),
13609 FormalParameters(FormalParameters<'tree>),
13610 FunctionDeclaration(FunctionDeclaration<'tree>),
13611 FunctionExpression(FunctionExpression<'tree>),
13612 FunctionSignature(FunctionSignature<'tree>),
13613 FunctionType(FunctionType<'tree>),
13614 GeneratorFunction(GeneratorFunction<'tree>),
13615 GeneratorFunctionDeclaration(GeneratorFunctionDeclaration<'tree>),
13616 GenericType(GenericType<'tree>),
13617 Identifier(Identifier<'tree>),
13618 IfStatement(IfStatement<'tree>),
13619 ImplementsClause(ImplementsClause<'tree>),
13620 Import(Import<'tree>),
13621 ImportAlias(ImportAlias<'tree>),
13622 ImportAttribute(ImportAttribute<'tree>),
13623 ImportClause(ImportClause<'tree>),
13624 ImportRequireClause(ImportRequireClause<'tree>),
13625 ImportSpecifier(ImportSpecifier<'tree>),
13626 ImportStatement(ImportStatement<'tree>),
13627 IndexSignature(IndexSignature<'tree>),
13628 IndexTypeQuery(IndexTypeQuery<'tree>),
13629 InferType(InferType<'tree>),
13630 InstantiationExpression(InstantiationExpression<'tree>),
13631 InterfaceBody(InterfaceBody<'tree>),
13632 InterfaceDeclaration(InterfaceDeclaration<'tree>),
13633 InternalModule(InternalModule<'tree>),
13634 IntersectionType(IntersectionType<'tree>),
13635 LabeledStatement(LabeledStatement<'tree>),
13636 LexicalDeclaration(LexicalDeclaration<'tree>),
13637 LiteralType(LiteralType<'tree>),
13638 LookupType(LookupType<'tree>),
13639 MappedTypeClause(MappedTypeClause<'tree>),
13640 MemberExpression(MemberExpression<'tree>),
13641 MetaProperty(MetaProperty<'tree>),
13642 MethodDefinition(MethodDefinition<'tree>),
13643 MethodSignature(MethodSignature<'tree>),
13644 Module(Module<'tree>),
13645 NamedImports(NamedImports<'tree>),
13646 NamespaceExport(NamespaceExport<'tree>),
13647 NamespaceImport(NamespaceImport<'tree>),
13648 NestedIdentifier(NestedIdentifier<'tree>),
13649 NestedTypeIdentifier(NestedTypeIdentifier<'tree>),
13650 NewExpression(NewExpression<'tree>),
13651 NonNullExpression(NonNullExpression<'tree>),
13652 Object(Object<'tree>),
13653 ObjectAssignmentPattern(ObjectAssignmentPattern<'tree>),
13654 ObjectPattern(ObjectPattern<'tree>),
13655 ObjectType(ObjectType<'tree>),
13656 OmittingTypeAnnotation(OmittingTypeAnnotation<'tree>),
13657 OptingTypeAnnotation(OptingTypeAnnotation<'tree>),
13658 OptionalChain(OptionalChain<'tree>),
13659 OptionalParameter(OptionalParameter<'tree>),
13660 OptionalType(OptionalType<'tree>),
13661 OverrideModifier(OverrideModifier<'tree>),
13662 Pair(Pair<'tree>),
13663 PairPattern(PairPattern<'tree>),
13664 ParenthesizedExpression(ParenthesizedExpression<'tree>),
13665 ParenthesizedType(ParenthesizedType<'tree>),
13666 PredefinedType(PredefinedType<'tree>),
13667 Program(Program<'tree>),
13668 PropertySignature(PropertySignature<'tree>),
13669 PublicFieldDefinition(PublicFieldDefinition<'tree>),
13670 ReadonlyType(ReadonlyType<'tree>),
13671 Regex(Regex<'tree>),
13672 RequiredParameter(RequiredParameter<'tree>),
13673 RestPattern(RestPattern<'tree>),
13674 RestType(RestType<'tree>),
13675 ReturnStatement(ReturnStatement<'tree>),
13676 SatisfiesExpression(SatisfiesExpression<'tree>),
13677 SequenceExpression(SequenceExpression<'tree>),
13678 SpreadElement(SpreadElement<'tree>),
13679 StatementBlock(StatementBlock<'tree>),
13680 String(String<'tree>),
13681 SubscriptExpression(SubscriptExpression<'tree>),
13682 SwitchBody(SwitchBody<'tree>),
13683 SwitchCase(SwitchCase<'tree>),
13684 SwitchDefault(SwitchDefault<'tree>),
13685 SwitchStatement(SwitchStatement<'tree>),
13686 TemplateLiteralType(TemplateLiteralType<'tree>),
13687 TemplateString(TemplateString<'tree>),
13688 TemplateSubstitution(TemplateSubstitution<'tree>),
13689 TemplateType(TemplateType<'tree>),
13690 TernaryExpression(TernaryExpression<'tree>),
13691 ThrowStatement(ThrowStatement<'tree>),
13692 TryStatement(TryStatement<'tree>),
13693 TupleType(TupleType<'tree>),
13694 TypeAliasDeclaration(TypeAliasDeclaration<'tree>),
13695 TypeAnnotation(TypeAnnotation<'tree>),
13696 TypeArguments(TypeArguments<'tree>),
13697 TypeAssertion(TypeAssertion<'tree>),
13698 TypeParameter(TypeParameter<'tree>),
13699 TypeParameters(TypeParameters<'tree>),
13700 TypePredicate(TypePredicate<'tree>),
13701 TypePredicateAnnotation(TypePredicateAnnotation<'tree>),
13702 TypeQuery(TypeQuery<'tree>),
13703 UnaryExpression(UnaryExpression<'tree>),
13704 UnionType(UnionType<'tree>),
13705 UpdateExpression(UpdateExpression<'tree>),
13706 VariableDeclaration(VariableDeclaration<'tree>),
13707 VariableDeclarator(VariableDeclarator<'tree>),
13708 WhileStatement(WhileStatement<'tree>),
13709 WithStatement(WithStatement<'tree>),
13710 YieldExpression(YieldExpression<'tree>),
13711 Comment(Comment<'tree>),
13712 EscapeSequence(EscapeSequence<'tree>),
13713 False(False<'tree>),
13714 HashBangLine(HashBangLine<'tree>),
13715 HtmlComment(HtmlComment<'tree>),
13716 Null(Null<'tree>),
13717 Number(Number<'tree>),
13718 PrivatePropertyIdentifier(PrivatePropertyIdentifier<'tree>),
13719 PropertyIdentifier(PropertyIdentifier<'tree>),
13720 RegexFlags(RegexFlags<'tree>),
13721 RegexPattern(RegexPattern<'tree>),
13722 ShorthandPropertyIdentifier(ShorthandPropertyIdentifier<'tree>),
13723 ShorthandPropertyIdentifierPattern(ShorthandPropertyIdentifierPattern<'tree>),
13724 StatementIdentifier(StatementIdentifier<'tree>),
13725 StringFragment(StringFragment<'tree>),
13726 Super(Super<'tree>),
13727 This(This<'tree>),
13728 ThisType(ThisType<'tree>),
13729 True(True<'tree>),
13730 TypeIdentifier(TypeIdentifier<'tree>),
13731 Undefined(Undefined<'tree>),
13732 Unknown(::tree_sitter::Node<'tree>),
13733}
13734impl<'tree> AnyNode<'tree> {
13735 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
13736 match node.kind() {
13737 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
13738 .map(Self::Declaration)
13739 .unwrap_or(Self::Unknown(node)),
13740 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
13741 .map(Self::Expression)
13742 .unwrap_or(Self::Unknown(node)),
13743 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
13744 .map(Self::Pattern)
13745 .unwrap_or(Self::Unknown(node)),
13746 "primary_expression" => {
13747 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13748 .map(Self::PrimaryExpression)
13749 .unwrap_or(Self::Unknown(node))
13750 }
13751 "primary_type" => <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src)
13752 .map(Self::PrimaryType)
13753 .unwrap_or(Self::Unknown(node)),
13754 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
13755 .map(Self::Statement)
13756 .unwrap_or(Self::Unknown(node)),
13757 "type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
13758 .map(Self::Type)
13759 .unwrap_or(Self::Unknown(node)),
13760 "abstract_class_declaration" => {
13761 <AbstractClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13762 .map(Self::AbstractClassDeclaration)
13763 .unwrap_or(Self::Unknown(node))
13764 }
13765 "abstract_method_signature" => {
13766 <AbstractMethodSignature as ::treesitter_types::FromNode>::from_node(node, src)
13767 .map(Self::AbstractMethodSignature)
13768 .unwrap_or(Self::Unknown(node))
13769 }
13770 "accessibility_modifier" => {
13771 <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
13772 .map(Self::AccessibilityModifier)
13773 .unwrap_or(Self::Unknown(node))
13774 }
13775 "adding_type_annotation" => {
13776 <AddingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
13777 .map(Self::AddingTypeAnnotation)
13778 .unwrap_or(Self::Unknown(node))
13779 }
13780 "ambient_declaration" => {
13781 <AmbientDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13782 .map(Self::AmbientDeclaration)
13783 .unwrap_or(Self::Unknown(node))
13784 }
13785 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
13786 .map(Self::Arguments)
13787 .unwrap_or(Self::Unknown(node)),
13788 "array" => <Array as ::treesitter_types::FromNode>::from_node(node, src)
13789 .map(Self::Array)
13790 .unwrap_or(Self::Unknown(node)),
13791 "array_pattern" => <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
13792 .map(Self::ArrayPattern)
13793 .unwrap_or(Self::Unknown(node)),
13794 "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
13795 .map(Self::ArrayType)
13796 .unwrap_or(Self::Unknown(node)),
13797 "arrow_function" => {
13798 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
13799 .map(Self::ArrowFunction)
13800 .unwrap_or(Self::Unknown(node))
13801 }
13802 "as_expression" => <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
13803 .map(Self::AsExpression)
13804 .unwrap_or(Self::Unknown(node)),
13805 "asserts" => <Asserts as ::treesitter_types::FromNode>::from_node(node, src)
13806 .map(Self::Asserts)
13807 .unwrap_or(Self::Unknown(node)),
13808 "asserts_annotation" => {
13809 <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
13810 .map(Self::AssertsAnnotation)
13811 .unwrap_or(Self::Unknown(node))
13812 }
13813 "assignment_expression" => {
13814 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
13815 .map(Self::AssignmentExpression)
13816 .unwrap_or(Self::Unknown(node))
13817 }
13818 "assignment_pattern" => {
13819 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
13820 .map(Self::AssignmentPattern)
13821 .unwrap_or(Self::Unknown(node))
13822 }
13823 "augmented_assignment_expression" => {
13824 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
13825 node, src,
13826 )
13827 .map(Self::AugmentedAssignmentExpression)
13828 .unwrap_or(Self::Unknown(node))
13829 }
13830 "await_expression" => {
13831 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
13832 .map(Self::AwaitExpression)
13833 .unwrap_or(Self::Unknown(node))
13834 }
13835 "binary_expression" => {
13836 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
13837 .map(Self::BinaryExpression)
13838 .unwrap_or(Self::Unknown(node))
13839 }
13840 "break_statement" => {
13841 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
13842 .map(Self::BreakStatement)
13843 .unwrap_or(Self::Unknown(node))
13844 }
13845 "call_expression" => {
13846 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
13847 .map(Self::CallExpression)
13848 .unwrap_or(Self::Unknown(node))
13849 }
13850 "call_signature" => {
13851 <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)
13852 .map(Self::CallSignature)
13853 .unwrap_or(Self::Unknown(node))
13854 }
13855 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
13856 .map(Self::CatchClause)
13857 .unwrap_or(Self::Unknown(node)),
13858 "class" => <Class as ::treesitter_types::FromNode>::from_node(node, src)
13859 .map(Self::Class)
13860 .unwrap_or(Self::Unknown(node)),
13861 "class_body" => <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
13862 .map(Self::ClassBody)
13863 .unwrap_or(Self::Unknown(node)),
13864 "class_declaration" => {
13865 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13866 .map(Self::ClassDeclaration)
13867 .unwrap_or(Self::Unknown(node))
13868 }
13869 "class_heritage" => {
13870 <ClassHeritage as ::treesitter_types::FromNode>::from_node(node, src)
13871 .map(Self::ClassHeritage)
13872 .unwrap_or(Self::Unknown(node))
13873 }
13874 "class_static_block" => {
13875 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)
13876 .map(Self::ClassStaticBlock)
13877 .unwrap_or(Self::Unknown(node))
13878 }
13879 "computed_property_name" => {
13880 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
13881 .map(Self::ComputedPropertyName)
13882 .unwrap_or(Self::Unknown(node))
13883 }
13884 "conditional_type" => {
13885 <ConditionalType as ::treesitter_types::FromNode>::from_node(node, src)
13886 .map(Self::ConditionalType)
13887 .unwrap_or(Self::Unknown(node))
13888 }
13889 "constraint" => <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
13890 .map(Self::Constraint)
13891 .unwrap_or(Self::Unknown(node)),
13892 "construct_signature" => {
13893 <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)
13894 .map(Self::ConstructSignature)
13895 .unwrap_or(Self::Unknown(node))
13896 }
13897 "constructor_type" => {
13898 <ConstructorType as ::treesitter_types::FromNode>::from_node(node, src)
13899 .map(Self::ConstructorType)
13900 .unwrap_or(Self::Unknown(node))
13901 }
13902 "continue_statement" => {
13903 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
13904 .map(Self::ContinueStatement)
13905 .unwrap_or(Self::Unknown(node))
13906 }
13907 "debugger_statement" => {
13908 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)
13909 .map(Self::DebuggerStatement)
13910 .unwrap_or(Self::Unknown(node))
13911 }
13912 "decorator" => <Decorator as ::treesitter_types::FromNode>::from_node(node, src)
13913 .map(Self::Decorator)
13914 .unwrap_or(Self::Unknown(node)),
13915 "default_type" => <DefaultType as ::treesitter_types::FromNode>::from_node(node, src)
13916 .map(Self::DefaultType)
13917 .unwrap_or(Self::Unknown(node)),
13918 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
13919 .map(Self::DoStatement)
13920 .unwrap_or(Self::Unknown(node)),
13921 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
13922 .map(Self::ElseClause)
13923 .unwrap_or(Self::Unknown(node)),
13924 "empty_statement" => {
13925 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
13926 .map(Self::EmptyStatement)
13927 .unwrap_or(Self::Unknown(node))
13928 }
13929 "enum_assignment" => {
13930 <EnumAssignment as ::treesitter_types::FromNode>::from_node(node, src)
13931 .map(Self::EnumAssignment)
13932 .unwrap_or(Self::Unknown(node))
13933 }
13934 "enum_body" => <EnumBody as ::treesitter_types::FromNode>::from_node(node, src)
13935 .map(Self::EnumBody)
13936 .unwrap_or(Self::Unknown(node)),
13937 "enum_declaration" => {
13938 <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
13939 .map(Self::EnumDeclaration)
13940 .unwrap_or(Self::Unknown(node))
13941 }
13942 "existential_type" => {
13943 <ExistentialType as ::treesitter_types::FromNode>::from_node(node, src)
13944 .map(Self::ExistentialType)
13945 .unwrap_or(Self::Unknown(node))
13946 }
13947 "export_clause" => <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)
13948 .map(Self::ExportClause)
13949 .unwrap_or(Self::Unknown(node)),
13950 "export_specifier" => {
13951 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
13952 .map(Self::ExportSpecifier)
13953 .unwrap_or(Self::Unknown(node))
13954 }
13955 "export_statement" => {
13956 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)
13957 .map(Self::ExportStatement)
13958 .unwrap_or(Self::Unknown(node))
13959 }
13960 "expression_statement" => {
13961 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
13962 .map(Self::ExpressionStatement)
13963 .unwrap_or(Self::Unknown(node))
13964 }
13965 "extends_clause" => {
13966 <ExtendsClause as ::treesitter_types::FromNode>::from_node(node, src)
13967 .map(Self::ExtendsClause)
13968 .unwrap_or(Self::Unknown(node))
13969 }
13970 "extends_type_clause" => {
13971 <ExtendsTypeClause as ::treesitter_types::FromNode>::from_node(node, src)
13972 .map(Self::ExtendsTypeClause)
13973 .unwrap_or(Self::Unknown(node))
13974 }
13975 "finally_clause" => {
13976 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
13977 .map(Self::FinallyClause)
13978 .unwrap_or(Self::Unknown(node))
13979 }
13980 "flow_maybe_type" => {
13981 <FlowMaybeType as ::treesitter_types::FromNode>::from_node(node, src)
13982 .map(Self::FlowMaybeType)
13983 .unwrap_or(Self::Unknown(node))
13984 }
13985 "for_in_statement" => {
13986 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)
13987 .map(Self::ForInStatement)
13988 .unwrap_or(Self::Unknown(node))
13989 }
13990 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
13991 .map(Self::ForStatement)
13992 .unwrap_or(Self::Unknown(node)),
13993 "formal_parameters" => {
13994 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
13995 .map(Self::FormalParameters)
13996 .unwrap_or(Self::Unknown(node))
13997 }
13998 "function_declaration" => {
13999 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14000 .map(Self::FunctionDeclaration)
14001 .unwrap_or(Self::Unknown(node))
14002 }
14003 "function_expression" => {
14004 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)
14005 .map(Self::FunctionExpression)
14006 .unwrap_or(Self::Unknown(node))
14007 }
14008 "function_signature" => {
14009 <FunctionSignature as ::treesitter_types::FromNode>::from_node(node, src)
14010 .map(Self::FunctionSignature)
14011 .unwrap_or(Self::Unknown(node))
14012 }
14013 "function_type" => <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
14014 .map(Self::FunctionType)
14015 .unwrap_or(Self::Unknown(node)),
14016 "generator_function" => {
14017 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)
14018 .map(Self::GeneratorFunction)
14019 .unwrap_or(Self::Unknown(node))
14020 }
14021 "generator_function_declaration" => {
14022 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14023 .map(Self::GeneratorFunctionDeclaration)
14024 .unwrap_or(Self::Unknown(node))
14025 }
14026 "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
14027 .map(Self::GenericType)
14028 .unwrap_or(Self::Unknown(node)),
14029 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
14030 .map(Self::Identifier)
14031 .unwrap_or(Self::Unknown(node)),
14032 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
14033 .map(Self::IfStatement)
14034 .unwrap_or(Self::Unknown(node)),
14035 "implements_clause" => {
14036 <ImplementsClause as ::treesitter_types::FromNode>::from_node(node, src)
14037 .map(Self::ImplementsClause)
14038 .unwrap_or(Self::Unknown(node))
14039 }
14040 "import" => <Import as ::treesitter_types::FromNode>::from_node(node, src)
14041 .map(Self::Import)
14042 .unwrap_or(Self::Unknown(node)),
14043 "import_alias" => <ImportAlias as ::treesitter_types::FromNode>::from_node(node, src)
14044 .map(Self::ImportAlias)
14045 .unwrap_or(Self::Unknown(node)),
14046 "import_attribute" => {
14047 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)
14048 .map(Self::ImportAttribute)
14049 .unwrap_or(Self::Unknown(node))
14050 }
14051 "import_clause" => <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)
14052 .map(Self::ImportClause)
14053 .unwrap_or(Self::Unknown(node)),
14054 "import_require_clause" => {
14055 <ImportRequireClause as ::treesitter_types::FromNode>::from_node(node, src)
14056 .map(Self::ImportRequireClause)
14057 .unwrap_or(Self::Unknown(node))
14058 }
14059 "import_specifier" => {
14060 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
14061 .map(Self::ImportSpecifier)
14062 .unwrap_or(Self::Unknown(node))
14063 }
14064 "import_statement" => {
14065 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)
14066 .map(Self::ImportStatement)
14067 .unwrap_or(Self::Unknown(node))
14068 }
14069 "index_signature" => {
14070 <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)
14071 .map(Self::IndexSignature)
14072 .unwrap_or(Self::Unknown(node))
14073 }
14074 "index_type_query" => {
14075 <IndexTypeQuery as ::treesitter_types::FromNode>::from_node(node, src)
14076 .map(Self::IndexTypeQuery)
14077 .unwrap_or(Self::Unknown(node))
14078 }
14079 "infer_type" => <InferType as ::treesitter_types::FromNode>::from_node(node, src)
14080 .map(Self::InferType)
14081 .unwrap_or(Self::Unknown(node)),
14082 "instantiation_expression" => {
14083 <InstantiationExpression as ::treesitter_types::FromNode>::from_node(node, src)
14084 .map(Self::InstantiationExpression)
14085 .unwrap_or(Self::Unknown(node))
14086 }
14087 "interface_body" => {
14088 <InterfaceBody as ::treesitter_types::FromNode>::from_node(node, src)
14089 .map(Self::InterfaceBody)
14090 .unwrap_or(Self::Unknown(node))
14091 }
14092 "interface_declaration" => {
14093 <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14094 .map(Self::InterfaceDeclaration)
14095 .unwrap_or(Self::Unknown(node))
14096 }
14097 "internal_module" => {
14098 <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)
14099 .map(Self::InternalModule)
14100 .unwrap_or(Self::Unknown(node))
14101 }
14102 "intersection_type" => {
14103 <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
14104 .map(Self::IntersectionType)
14105 .unwrap_or(Self::Unknown(node))
14106 }
14107 "labeled_statement" => {
14108 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
14109 .map(Self::LabeledStatement)
14110 .unwrap_or(Self::Unknown(node))
14111 }
14112 "lexical_declaration" => {
14113 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14114 .map(Self::LexicalDeclaration)
14115 .unwrap_or(Self::Unknown(node))
14116 }
14117 "literal_type" => <LiteralType as ::treesitter_types::FromNode>::from_node(node, src)
14118 .map(Self::LiteralType)
14119 .unwrap_or(Self::Unknown(node)),
14120 "lookup_type" => <LookupType as ::treesitter_types::FromNode>::from_node(node, src)
14121 .map(Self::LookupType)
14122 .unwrap_or(Self::Unknown(node)),
14123 "mapped_type_clause" => {
14124 <MappedTypeClause as ::treesitter_types::FromNode>::from_node(node, src)
14125 .map(Self::MappedTypeClause)
14126 .unwrap_or(Self::Unknown(node))
14127 }
14128 "member_expression" => {
14129 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
14130 .map(Self::MemberExpression)
14131 .unwrap_or(Self::Unknown(node))
14132 }
14133 "meta_property" => <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)
14134 .map(Self::MetaProperty)
14135 .unwrap_or(Self::Unknown(node)),
14136 "method_definition" => {
14137 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14138 .map(Self::MethodDefinition)
14139 .unwrap_or(Self::Unknown(node))
14140 }
14141 "method_signature" => {
14142 <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)
14143 .map(Self::MethodSignature)
14144 .unwrap_or(Self::Unknown(node))
14145 }
14146 "module" => <Module as ::treesitter_types::FromNode>::from_node(node, src)
14147 .map(Self::Module)
14148 .unwrap_or(Self::Unknown(node)),
14149 "named_imports" => <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)
14150 .map(Self::NamedImports)
14151 .unwrap_or(Self::Unknown(node)),
14152 "namespace_export" => {
14153 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)
14154 .map(Self::NamespaceExport)
14155 .unwrap_or(Self::Unknown(node))
14156 }
14157 "namespace_import" => {
14158 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)
14159 .map(Self::NamespaceImport)
14160 .unwrap_or(Self::Unknown(node))
14161 }
14162 "nested_identifier" => {
14163 <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14164 .map(Self::NestedIdentifier)
14165 .unwrap_or(Self::Unknown(node))
14166 }
14167 "nested_type_identifier" => {
14168 <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14169 .map(Self::NestedTypeIdentifier)
14170 .unwrap_or(Self::Unknown(node))
14171 }
14172 "new_expression" => {
14173 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
14174 .map(Self::NewExpression)
14175 .unwrap_or(Self::Unknown(node))
14176 }
14177 "non_null_expression" => {
14178 <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)
14179 .map(Self::NonNullExpression)
14180 .unwrap_or(Self::Unknown(node))
14181 }
14182 "object" => <Object as ::treesitter_types::FromNode>::from_node(node, src)
14183 .map(Self::Object)
14184 .unwrap_or(Self::Unknown(node)),
14185 "object_assignment_pattern" => {
14186 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
14187 .map(Self::ObjectAssignmentPattern)
14188 .unwrap_or(Self::Unknown(node))
14189 }
14190 "object_pattern" => {
14191 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
14192 .map(Self::ObjectPattern)
14193 .unwrap_or(Self::Unknown(node))
14194 }
14195 "object_type" => <ObjectType as ::treesitter_types::FromNode>::from_node(node, src)
14196 .map(Self::ObjectType)
14197 .unwrap_or(Self::Unknown(node)),
14198 "omitting_type_annotation" => {
14199 <OmittingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
14200 .map(Self::OmittingTypeAnnotation)
14201 .unwrap_or(Self::Unknown(node))
14202 }
14203 "opting_type_annotation" => {
14204 <OptingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
14205 .map(Self::OptingTypeAnnotation)
14206 .unwrap_or(Self::Unknown(node))
14207 }
14208 "optional_chain" => {
14209 <OptionalChain as ::treesitter_types::FromNode>::from_node(node, src)
14210 .map(Self::OptionalChain)
14211 .unwrap_or(Self::Unknown(node))
14212 }
14213 "optional_parameter" => {
14214 <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
14215 .map(Self::OptionalParameter)
14216 .unwrap_or(Self::Unknown(node))
14217 }
14218 "optional_type" => <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
14219 .map(Self::OptionalType)
14220 .unwrap_or(Self::Unknown(node)),
14221 "override_modifier" => {
14222 <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)
14223 .map(Self::OverrideModifier)
14224 .unwrap_or(Self::Unknown(node))
14225 }
14226 "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
14227 .map(Self::Pair)
14228 .unwrap_or(Self::Unknown(node)),
14229 "pair_pattern" => <PairPattern as ::treesitter_types::FromNode>::from_node(node, src)
14230 .map(Self::PairPattern)
14231 .unwrap_or(Self::Unknown(node)),
14232 "parenthesized_expression" => {
14233 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
14234 .map(Self::ParenthesizedExpression)
14235 .unwrap_or(Self::Unknown(node))
14236 }
14237 "parenthesized_type" => {
14238 <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)
14239 .map(Self::ParenthesizedType)
14240 .unwrap_or(Self::Unknown(node))
14241 }
14242 "predefined_type" => {
14243 <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
14244 .map(Self::PredefinedType)
14245 .unwrap_or(Self::Unknown(node))
14246 }
14247 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
14248 .map(Self::Program)
14249 .unwrap_or(Self::Unknown(node)),
14250 "property_signature" => {
14251 <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)
14252 .map(Self::PropertySignature)
14253 .unwrap_or(Self::Unknown(node))
14254 }
14255 "public_field_definition" => {
14256 <PublicFieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)
14257 .map(Self::PublicFieldDefinition)
14258 .unwrap_or(Self::Unknown(node))
14259 }
14260 "readonly_type" => <ReadonlyType as ::treesitter_types::FromNode>::from_node(node, src)
14261 .map(Self::ReadonlyType)
14262 .unwrap_or(Self::Unknown(node)),
14263 "regex" => <Regex as ::treesitter_types::FromNode>::from_node(node, src)
14264 .map(Self::Regex)
14265 .unwrap_or(Self::Unknown(node)),
14266 "required_parameter" => {
14267 <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)
14268 .map(Self::RequiredParameter)
14269 .unwrap_or(Self::Unknown(node))
14270 }
14271 "rest_pattern" => <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
14272 .map(Self::RestPattern)
14273 .unwrap_or(Self::Unknown(node)),
14274 "rest_type" => <RestType as ::treesitter_types::FromNode>::from_node(node, src)
14275 .map(Self::RestType)
14276 .unwrap_or(Self::Unknown(node)),
14277 "return_statement" => {
14278 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
14279 .map(Self::ReturnStatement)
14280 .unwrap_or(Self::Unknown(node))
14281 }
14282 "satisfies_expression" => {
14283 <SatisfiesExpression as ::treesitter_types::FromNode>::from_node(node, src)
14284 .map(Self::SatisfiesExpression)
14285 .unwrap_or(Self::Unknown(node))
14286 }
14287 "sequence_expression" => {
14288 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
14289 .map(Self::SequenceExpression)
14290 .unwrap_or(Self::Unknown(node))
14291 }
14292 "spread_element" => {
14293 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
14294 .map(Self::SpreadElement)
14295 .unwrap_or(Self::Unknown(node))
14296 }
14297 "statement_block" => {
14298 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
14299 .map(Self::StatementBlock)
14300 .unwrap_or(Self::Unknown(node))
14301 }
14302 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
14303 .map(Self::String)
14304 .unwrap_or(Self::Unknown(node)),
14305 "subscript_expression" => {
14306 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
14307 .map(Self::SubscriptExpression)
14308 .unwrap_or(Self::Unknown(node))
14309 }
14310 "switch_body" => <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
14311 .map(Self::SwitchBody)
14312 .unwrap_or(Self::Unknown(node)),
14313 "switch_case" => <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)
14314 .map(Self::SwitchCase)
14315 .unwrap_or(Self::Unknown(node)),
14316 "switch_default" => {
14317 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)
14318 .map(Self::SwitchDefault)
14319 .unwrap_or(Self::Unknown(node))
14320 }
14321 "switch_statement" => {
14322 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
14323 .map(Self::SwitchStatement)
14324 .unwrap_or(Self::Unknown(node))
14325 }
14326 "template_literal_type" => {
14327 <TemplateLiteralType as ::treesitter_types::FromNode>::from_node(node, src)
14328 .map(Self::TemplateLiteralType)
14329 .unwrap_or(Self::Unknown(node))
14330 }
14331 "template_string" => {
14332 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
14333 .map(Self::TemplateString)
14334 .unwrap_or(Self::Unknown(node))
14335 }
14336 "template_substitution" => {
14337 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)
14338 .map(Self::TemplateSubstitution)
14339 .unwrap_or(Self::Unknown(node))
14340 }
14341 "template_type" => <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
14342 .map(Self::TemplateType)
14343 .unwrap_or(Self::Unknown(node)),
14344 "ternary_expression" => {
14345 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14346 .map(Self::TernaryExpression)
14347 .unwrap_or(Self::Unknown(node))
14348 }
14349 "throw_statement" => {
14350 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
14351 .map(Self::ThrowStatement)
14352 .unwrap_or(Self::Unknown(node))
14353 }
14354 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
14355 .map(Self::TryStatement)
14356 .unwrap_or(Self::Unknown(node)),
14357 "tuple_type" => <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
14358 .map(Self::TupleType)
14359 .unwrap_or(Self::Unknown(node)),
14360 "type_alias_declaration" => {
14361 <TypeAliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14362 .map(Self::TypeAliasDeclaration)
14363 .unwrap_or(Self::Unknown(node))
14364 }
14365 "type_annotation" => {
14366 <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
14367 .map(Self::TypeAnnotation)
14368 .unwrap_or(Self::Unknown(node))
14369 }
14370 "type_arguments" => {
14371 <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
14372 .map(Self::TypeArguments)
14373 .unwrap_or(Self::Unknown(node))
14374 }
14375 "type_assertion" => {
14376 <TypeAssertion as ::treesitter_types::FromNode>::from_node(node, src)
14377 .map(Self::TypeAssertion)
14378 .unwrap_or(Self::Unknown(node))
14379 }
14380 "type_parameter" => {
14381 <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
14382 .map(Self::TypeParameter)
14383 .unwrap_or(Self::Unknown(node))
14384 }
14385 "type_parameters" => {
14386 <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
14387 .map(Self::TypeParameters)
14388 .unwrap_or(Self::Unknown(node))
14389 }
14390 "type_predicate" => {
14391 <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)
14392 .map(Self::TypePredicate)
14393 .unwrap_or(Self::Unknown(node))
14394 }
14395 "type_predicate_annotation" => {
14396 <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
14397 .map(Self::TypePredicateAnnotation)
14398 .unwrap_or(Self::Unknown(node))
14399 }
14400 "type_query" => <TypeQuery as ::treesitter_types::FromNode>::from_node(node, src)
14401 .map(Self::TypeQuery)
14402 .unwrap_or(Self::Unknown(node)),
14403 "unary_expression" => {
14404 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
14405 .map(Self::UnaryExpression)
14406 .unwrap_or(Self::Unknown(node))
14407 }
14408 "union_type" => <UnionType as ::treesitter_types::FromNode>::from_node(node, src)
14409 .map(Self::UnionType)
14410 .unwrap_or(Self::Unknown(node)),
14411 "update_expression" => {
14412 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
14413 .map(Self::UpdateExpression)
14414 .unwrap_or(Self::Unknown(node))
14415 }
14416 "variable_declaration" => {
14417 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
14418 .map(Self::VariableDeclaration)
14419 .unwrap_or(Self::Unknown(node))
14420 }
14421 "variable_declarator" => {
14422 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
14423 .map(Self::VariableDeclarator)
14424 .unwrap_or(Self::Unknown(node))
14425 }
14426 "while_statement" => {
14427 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
14428 .map(Self::WhileStatement)
14429 .unwrap_or(Self::Unknown(node))
14430 }
14431 "with_statement" => {
14432 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)
14433 .map(Self::WithStatement)
14434 .unwrap_or(Self::Unknown(node))
14435 }
14436 "yield_expression" => {
14437 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
14438 .map(Self::YieldExpression)
14439 .unwrap_or(Self::Unknown(node))
14440 }
14441 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
14442 .map(Self::Comment)
14443 .unwrap_or(Self::Unknown(node)),
14444 "escape_sequence" => {
14445 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
14446 .map(Self::EscapeSequence)
14447 .unwrap_or(Self::Unknown(node))
14448 }
14449 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
14450 .map(Self::False)
14451 .unwrap_or(Self::Unknown(node)),
14452 "hash_bang_line" => {
14453 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
14454 .map(Self::HashBangLine)
14455 .unwrap_or(Self::Unknown(node))
14456 }
14457 "html_comment" => <HtmlComment as ::treesitter_types::FromNode>::from_node(node, src)
14458 .map(Self::HtmlComment)
14459 .unwrap_or(Self::Unknown(node)),
14460 "null" => <Null as ::treesitter_types::FromNode>::from_node(node, src)
14461 .map(Self::Null)
14462 .unwrap_or(Self::Unknown(node)),
14463 "number" => <Number as ::treesitter_types::FromNode>::from_node(node, src)
14464 .map(Self::Number)
14465 .unwrap_or(Self::Unknown(node)),
14466 "private_property_identifier" => {
14467 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14468 .map(Self::PrivatePropertyIdentifier)
14469 .unwrap_or(Self::Unknown(node))
14470 }
14471 "property_identifier" => {
14472 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14473 .map(Self::PropertyIdentifier)
14474 .unwrap_or(Self::Unknown(node))
14475 }
14476 "regex_flags" => <RegexFlags as ::treesitter_types::FromNode>::from_node(node, src)
14477 .map(Self::RegexFlags)
14478 .unwrap_or(Self::Unknown(node)),
14479 "regex_pattern" => <RegexPattern as ::treesitter_types::FromNode>::from_node(node, src)
14480 .map(Self::RegexPattern)
14481 .unwrap_or(Self::Unknown(node)),
14482 "shorthand_property_identifier" => {
14483 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14484 .map(Self::ShorthandPropertyIdentifier)
14485 .unwrap_or(Self::Unknown(node))
14486 }
14487 "shorthand_property_identifier_pattern" => {
14488 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
14489 node, src,
14490 )
14491 .map(Self::ShorthandPropertyIdentifierPattern)
14492 .unwrap_or(Self::Unknown(node))
14493 }
14494 "statement_identifier" => {
14495 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14496 .map(Self::StatementIdentifier)
14497 .unwrap_or(Self::Unknown(node))
14498 }
14499 "string_fragment" => {
14500 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
14501 .map(Self::StringFragment)
14502 .unwrap_or(Self::Unknown(node))
14503 }
14504 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
14505 .map(Self::Super)
14506 .unwrap_or(Self::Unknown(node)),
14507 "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
14508 .map(Self::This)
14509 .unwrap_or(Self::Unknown(node)),
14510 "this_type" => <ThisType as ::treesitter_types::FromNode>::from_node(node, src)
14511 .map(Self::ThisType)
14512 .unwrap_or(Self::Unknown(node)),
14513 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
14514 .map(Self::True)
14515 .unwrap_or(Self::Unknown(node)),
14516 "type_identifier" => {
14517 <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
14518 .map(Self::TypeIdentifier)
14519 .unwrap_or(Self::Unknown(node))
14520 }
14521 "undefined" => <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
14522 .map(Self::Undefined)
14523 .unwrap_or(Self::Unknown(node)),
14524 _ => Self::Unknown(node),
14525 }
14526 }
14527}
14528impl ::treesitter_types::Spanned for AnyNode<'_> {
14529 fn span(&self) -> ::treesitter_types::Span {
14530 match self {
14531 Self::Declaration(inner) => inner.span(),
14532 Self::Expression(inner) => inner.span(),
14533 Self::Pattern(inner) => inner.span(),
14534 Self::PrimaryExpression(inner) => inner.span(),
14535 Self::PrimaryType(inner) => inner.span(),
14536 Self::Statement(inner) => inner.span(),
14537 Self::Type(inner) => inner.span(),
14538 Self::AbstractClassDeclaration(inner) => inner.span(),
14539 Self::AbstractMethodSignature(inner) => inner.span(),
14540 Self::AccessibilityModifier(inner) => inner.span(),
14541 Self::AddingTypeAnnotation(inner) => inner.span(),
14542 Self::AmbientDeclaration(inner) => inner.span(),
14543 Self::Arguments(inner) => inner.span(),
14544 Self::Array(inner) => inner.span(),
14545 Self::ArrayPattern(inner) => inner.span(),
14546 Self::ArrayType(inner) => inner.span(),
14547 Self::ArrowFunction(inner) => inner.span(),
14548 Self::AsExpression(inner) => inner.span(),
14549 Self::Asserts(inner) => inner.span(),
14550 Self::AssertsAnnotation(inner) => inner.span(),
14551 Self::AssignmentExpression(inner) => inner.span(),
14552 Self::AssignmentPattern(inner) => inner.span(),
14553 Self::AugmentedAssignmentExpression(inner) => inner.span(),
14554 Self::AwaitExpression(inner) => inner.span(),
14555 Self::BinaryExpression(inner) => inner.span(),
14556 Self::BreakStatement(inner) => inner.span(),
14557 Self::CallExpression(inner) => inner.span(),
14558 Self::CallSignature(inner) => inner.span(),
14559 Self::CatchClause(inner) => inner.span(),
14560 Self::Class(inner) => inner.span(),
14561 Self::ClassBody(inner) => inner.span(),
14562 Self::ClassDeclaration(inner) => inner.span(),
14563 Self::ClassHeritage(inner) => inner.span(),
14564 Self::ClassStaticBlock(inner) => inner.span(),
14565 Self::ComputedPropertyName(inner) => inner.span(),
14566 Self::ConditionalType(inner) => inner.span(),
14567 Self::Constraint(inner) => inner.span(),
14568 Self::ConstructSignature(inner) => inner.span(),
14569 Self::ConstructorType(inner) => inner.span(),
14570 Self::ContinueStatement(inner) => inner.span(),
14571 Self::DebuggerStatement(inner) => inner.span(),
14572 Self::Decorator(inner) => inner.span(),
14573 Self::DefaultType(inner) => inner.span(),
14574 Self::DoStatement(inner) => inner.span(),
14575 Self::ElseClause(inner) => inner.span(),
14576 Self::EmptyStatement(inner) => inner.span(),
14577 Self::EnumAssignment(inner) => inner.span(),
14578 Self::EnumBody(inner) => inner.span(),
14579 Self::EnumDeclaration(inner) => inner.span(),
14580 Self::ExistentialType(inner) => inner.span(),
14581 Self::ExportClause(inner) => inner.span(),
14582 Self::ExportSpecifier(inner) => inner.span(),
14583 Self::ExportStatement(inner) => inner.span(),
14584 Self::ExpressionStatement(inner) => inner.span(),
14585 Self::ExtendsClause(inner) => inner.span(),
14586 Self::ExtendsTypeClause(inner) => inner.span(),
14587 Self::FinallyClause(inner) => inner.span(),
14588 Self::FlowMaybeType(inner) => inner.span(),
14589 Self::ForInStatement(inner) => inner.span(),
14590 Self::ForStatement(inner) => inner.span(),
14591 Self::FormalParameters(inner) => inner.span(),
14592 Self::FunctionDeclaration(inner) => inner.span(),
14593 Self::FunctionExpression(inner) => inner.span(),
14594 Self::FunctionSignature(inner) => inner.span(),
14595 Self::FunctionType(inner) => inner.span(),
14596 Self::GeneratorFunction(inner) => inner.span(),
14597 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
14598 Self::GenericType(inner) => inner.span(),
14599 Self::Identifier(inner) => inner.span(),
14600 Self::IfStatement(inner) => inner.span(),
14601 Self::ImplementsClause(inner) => inner.span(),
14602 Self::Import(inner) => inner.span(),
14603 Self::ImportAlias(inner) => inner.span(),
14604 Self::ImportAttribute(inner) => inner.span(),
14605 Self::ImportClause(inner) => inner.span(),
14606 Self::ImportRequireClause(inner) => inner.span(),
14607 Self::ImportSpecifier(inner) => inner.span(),
14608 Self::ImportStatement(inner) => inner.span(),
14609 Self::IndexSignature(inner) => inner.span(),
14610 Self::IndexTypeQuery(inner) => inner.span(),
14611 Self::InferType(inner) => inner.span(),
14612 Self::InstantiationExpression(inner) => inner.span(),
14613 Self::InterfaceBody(inner) => inner.span(),
14614 Self::InterfaceDeclaration(inner) => inner.span(),
14615 Self::InternalModule(inner) => inner.span(),
14616 Self::IntersectionType(inner) => inner.span(),
14617 Self::LabeledStatement(inner) => inner.span(),
14618 Self::LexicalDeclaration(inner) => inner.span(),
14619 Self::LiteralType(inner) => inner.span(),
14620 Self::LookupType(inner) => inner.span(),
14621 Self::MappedTypeClause(inner) => inner.span(),
14622 Self::MemberExpression(inner) => inner.span(),
14623 Self::MetaProperty(inner) => inner.span(),
14624 Self::MethodDefinition(inner) => inner.span(),
14625 Self::MethodSignature(inner) => inner.span(),
14626 Self::Module(inner) => inner.span(),
14627 Self::NamedImports(inner) => inner.span(),
14628 Self::NamespaceExport(inner) => inner.span(),
14629 Self::NamespaceImport(inner) => inner.span(),
14630 Self::NestedIdentifier(inner) => inner.span(),
14631 Self::NestedTypeIdentifier(inner) => inner.span(),
14632 Self::NewExpression(inner) => inner.span(),
14633 Self::NonNullExpression(inner) => inner.span(),
14634 Self::Object(inner) => inner.span(),
14635 Self::ObjectAssignmentPattern(inner) => inner.span(),
14636 Self::ObjectPattern(inner) => inner.span(),
14637 Self::ObjectType(inner) => inner.span(),
14638 Self::OmittingTypeAnnotation(inner) => inner.span(),
14639 Self::OptingTypeAnnotation(inner) => inner.span(),
14640 Self::OptionalChain(inner) => inner.span(),
14641 Self::OptionalParameter(inner) => inner.span(),
14642 Self::OptionalType(inner) => inner.span(),
14643 Self::OverrideModifier(inner) => inner.span(),
14644 Self::Pair(inner) => inner.span(),
14645 Self::PairPattern(inner) => inner.span(),
14646 Self::ParenthesizedExpression(inner) => inner.span(),
14647 Self::ParenthesizedType(inner) => inner.span(),
14648 Self::PredefinedType(inner) => inner.span(),
14649 Self::Program(inner) => inner.span(),
14650 Self::PropertySignature(inner) => inner.span(),
14651 Self::PublicFieldDefinition(inner) => inner.span(),
14652 Self::ReadonlyType(inner) => inner.span(),
14653 Self::Regex(inner) => inner.span(),
14654 Self::RequiredParameter(inner) => inner.span(),
14655 Self::RestPattern(inner) => inner.span(),
14656 Self::RestType(inner) => inner.span(),
14657 Self::ReturnStatement(inner) => inner.span(),
14658 Self::SatisfiesExpression(inner) => inner.span(),
14659 Self::SequenceExpression(inner) => inner.span(),
14660 Self::SpreadElement(inner) => inner.span(),
14661 Self::StatementBlock(inner) => inner.span(),
14662 Self::String(inner) => inner.span(),
14663 Self::SubscriptExpression(inner) => inner.span(),
14664 Self::SwitchBody(inner) => inner.span(),
14665 Self::SwitchCase(inner) => inner.span(),
14666 Self::SwitchDefault(inner) => inner.span(),
14667 Self::SwitchStatement(inner) => inner.span(),
14668 Self::TemplateLiteralType(inner) => inner.span(),
14669 Self::TemplateString(inner) => inner.span(),
14670 Self::TemplateSubstitution(inner) => inner.span(),
14671 Self::TemplateType(inner) => inner.span(),
14672 Self::TernaryExpression(inner) => inner.span(),
14673 Self::ThrowStatement(inner) => inner.span(),
14674 Self::TryStatement(inner) => inner.span(),
14675 Self::TupleType(inner) => inner.span(),
14676 Self::TypeAliasDeclaration(inner) => inner.span(),
14677 Self::TypeAnnotation(inner) => inner.span(),
14678 Self::TypeArguments(inner) => inner.span(),
14679 Self::TypeAssertion(inner) => inner.span(),
14680 Self::TypeParameter(inner) => inner.span(),
14681 Self::TypeParameters(inner) => inner.span(),
14682 Self::TypePredicate(inner) => inner.span(),
14683 Self::TypePredicateAnnotation(inner) => inner.span(),
14684 Self::TypeQuery(inner) => inner.span(),
14685 Self::UnaryExpression(inner) => inner.span(),
14686 Self::UnionType(inner) => inner.span(),
14687 Self::UpdateExpression(inner) => inner.span(),
14688 Self::VariableDeclaration(inner) => inner.span(),
14689 Self::VariableDeclarator(inner) => inner.span(),
14690 Self::WhileStatement(inner) => inner.span(),
14691 Self::WithStatement(inner) => inner.span(),
14692 Self::YieldExpression(inner) => inner.span(),
14693 Self::Comment(inner) => inner.span(),
14694 Self::EscapeSequence(inner) => inner.span(),
14695 Self::False(inner) => inner.span(),
14696 Self::HashBangLine(inner) => inner.span(),
14697 Self::HtmlComment(inner) => inner.span(),
14698 Self::Null(inner) => inner.span(),
14699 Self::Number(inner) => inner.span(),
14700 Self::PrivatePropertyIdentifier(inner) => inner.span(),
14701 Self::PropertyIdentifier(inner) => inner.span(),
14702 Self::RegexFlags(inner) => inner.span(),
14703 Self::RegexPattern(inner) => inner.span(),
14704 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
14705 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
14706 Self::StatementIdentifier(inner) => inner.span(),
14707 Self::StringFragment(inner) => inner.span(),
14708 Self::Super(inner) => inner.span(),
14709 Self::This(inner) => inner.span(),
14710 Self::ThisType(inner) => inner.span(),
14711 Self::True(inner) => inner.span(),
14712 Self::TypeIdentifier(inner) => inner.span(),
14713 Self::Undefined(inner) => inner.span(),
14714 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
14715 }
14716 }
14717}