1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Declaration<'tree> {
3 ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
4 FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
5 GeneratorFunctionDeclaration(::std::boxed::Box<GeneratorFunctionDeclaration<'tree>>),
6 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
7 UsingDeclaration(::std::boxed::Box<UsingDeclaration<'tree>>),
8 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
9}
10impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
11 #[allow(clippy::collapsible_else_if)]
12 fn from_node(
13 node: ::tree_sitter::Node<'tree>,
14 src: &'tree [u8],
15 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
16 match node.kind() {
17 "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
18 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
19 ))),
20 "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
21 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
22 ))),
23 "generator_function_declaration" => {
24 Ok(Self::GeneratorFunctionDeclaration(::std::boxed::Box::new(
25 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(
26 node, src,
27 )?,
28 )))
29 }
30 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
31 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
32 ))),
33 "using_declaration" => Ok(Self::UsingDeclaration(::std::boxed::Box::new(
34 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
35 ))),
36 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
37 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
38 ))),
39 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
40 }
41 }
42}
43impl ::treesitter_types::Spanned for Declaration<'_> {
44 fn span(&self) -> ::treesitter_types::Span {
45 match self {
46 Self::ClassDeclaration(inner) => inner.span(),
47 Self::FunctionDeclaration(inner) => inner.span(),
48 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
49 Self::LexicalDeclaration(inner) => inner.span(),
50 Self::UsingDeclaration(inner) => inner.span(),
51 Self::VariableDeclaration(inner) => inner.span(),
52 }
53 }
54}
55#[derive(Debug, Clone, PartialEq, Eq)]
56pub enum Expression<'tree> {
57 AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
58 AugmentedAssignmentExpression(::std::boxed::Box<AugmentedAssignmentExpression<'tree>>),
59 AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
60 BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
61 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
62 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
63 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
64 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
65 TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
66 UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
67 UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
68 YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
69}
70impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
71 #[allow(clippy::collapsible_else_if)]
72 fn from_node(
73 node: ::tree_sitter::Node<'tree>,
74 src: &'tree [u8],
75 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
76 match node.kind() {
77 "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
78 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
79 ))),
80 "augmented_assignment_expression" => {
81 Ok(Self::AugmentedAssignmentExpression(::std::boxed::Box::new(
82 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
83 node, src,
84 )?,
85 )))
86 }
87 "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
88 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
89 ))),
90 "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
91 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
92 ))),
93 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
94 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)?,
95 ))),
96 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
97 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)?,
98 ))),
99 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
100 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
101 ))),
102 "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
103 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
104 ))),
105 "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
106 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
107 ))),
108 "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
109 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
110 ))),
111 "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
112 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
113 ))),
114 _other => {
115 if let Ok(v) =
116 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
117 {
118 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
119 } else {
120 Err(::treesitter_types::ParseError::unexpected_kind(
121 _other, node,
122 ))
123 }
124 }
125 }
126 }
127}
128impl ::treesitter_types::Spanned for Expression<'_> {
129 fn span(&self) -> ::treesitter_types::Span {
130 match self {
131 Self::AssignmentExpression(inner) => inner.span(),
132 Self::AugmentedAssignmentExpression(inner) => inner.span(),
133 Self::AwaitExpression(inner) => inner.span(),
134 Self::BinaryExpression(inner) => inner.span(),
135 Self::JsxElement(inner) => inner.span(),
136 Self::JsxSelfClosingElement(inner) => inner.span(),
137 Self::NewExpression(inner) => inner.span(),
138 Self::PrimaryExpression(inner) => inner.span(),
139 Self::TernaryExpression(inner) => inner.span(),
140 Self::UnaryExpression(inner) => inner.span(),
141 Self::UpdateExpression(inner) => inner.span(),
142 Self::YieldExpression(inner) => inner.span(),
143 }
144 }
145}
146#[derive(Debug, Clone, PartialEq, Eq)]
147pub enum Pattern<'tree> {
148 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
149 Identifier(::std::boxed::Box<Identifier<'tree>>),
150 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
151 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
152 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
153 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
154 Undefined(::std::boxed::Box<Undefined<'tree>>),
155}
156impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
157 #[allow(clippy::collapsible_else_if)]
158 fn from_node(
159 node: ::tree_sitter::Node<'tree>,
160 src: &'tree [u8],
161 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
162 match node.kind() {
163 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
164 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
165 ))),
166 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
167 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
168 ))),
169 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
170 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
171 ))),
172 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
173 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
174 ))),
175 "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
176 <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
177 ))),
178 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
179 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
180 ))),
181 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
182 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
183 ))),
184 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
185 }
186 }
187}
188impl ::treesitter_types::Spanned for Pattern<'_> {
189 fn span(&self) -> ::treesitter_types::Span {
190 match self {
191 Self::ArrayPattern(inner) => inner.span(),
192 Self::Identifier(inner) => inner.span(),
193 Self::MemberExpression(inner) => inner.span(),
194 Self::ObjectPattern(inner) => inner.span(),
195 Self::RestPattern(inner) => inner.span(),
196 Self::SubscriptExpression(inner) => inner.span(),
197 Self::Undefined(inner) => inner.span(),
198 }
199 }
200}
201#[derive(Debug, Clone, PartialEq, Eq)]
202pub enum PrimaryExpression<'tree> {
203 Array(::std::boxed::Box<Array<'tree>>),
204 ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
205 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
206 Class(::std::boxed::Box<Class<'tree>>),
207 False(::std::boxed::Box<False<'tree>>),
208 FunctionExpression(::std::boxed::Box<FunctionExpression<'tree>>),
209 GeneratorFunction(::std::boxed::Box<GeneratorFunction<'tree>>),
210 Identifier(::std::boxed::Box<Identifier<'tree>>),
211 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
212 MetaProperty(::std::boxed::Box<MetaProperty<'tree>>),
213 Null(::std::boxed::Box<Null<'tree>>),
214 Number(::std::boxed::Box<Number<'tree>>),
215 Object(::std::boxed::Box<Object<'tree>>),
216 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
217 Regex(::std::boxed::Box<Regex<'tree>>),
218 String(::std::boxed::Box<String<'tree>>),
219 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
220 Super(::std::boxed::Box<Super<'tree>>),
221 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
222 This(::std::boxed::Box<This<'tree>>),
223 True(::std::boxed::Box<True<'tree>>),
224 Undefined(::std::boxed::Box<Undefined<'tree>>),
225}
226impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
227 #[allow(clippy::collapsible_else_if)]
228 fn from_node(
229 node: ::tree_sitter::Node<'tree>,
230 src: &'tree [u8],
231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
232 match node.kind() {
233 "array" => Ok(Self::Array(::std::boxed::Box::new(
234 <Array as ::treesitter_types::FromNode>::from_node(node, src)?,
235 ))),
236 "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
237 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
238 ))),
239 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
240 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
241 ))),
242 "class" => Ok(Self::Class(::std::boxed::Box::new(
243 <Class as ::treesitter_types::FromNode>::from_node(node, src)?,
244 ))),
245 "false" => Ok(Self::False(::std::boxed::Box::new(
246 <False as ::treesitter_types::FromNode>::from_node(node, src)?,
247 ))),
248 "function_expression" => Ok(Self::FunctionExpression(::std::boxed::Box::new(
249 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
250 ))),
251 "generator_function" => Ok(Self::GeneratorFunction(::std::boxed::Box::new(
252 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
253 ))),
254 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
255 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
256 ))),
257 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
258 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
259 ))),
260 "meta_property" => Ok(Self::MetaProperty(::std::boxed::Box::new(
261 <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)?,
262 ))),
263 "null" => Ok(Self::Null(::std::boxed::Box::new(
264 <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
265 ))),
266 "number" => Ok(Self::Number(::std::boxed::Box::new(
267 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
268 ))),
269 "object" => Ok(Self::Object(::std::boxed::Box::new(
270 <Object as ::treesitter_types::FromNode>::from_node(node, src)?,
271 ))),
272 "parenthesized_expression" => {
273 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
274 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
275 node, src,
276 )?,
277 )))
278 }
279 "regex" => Ok(Self::Regex(::std::boxed::Box::new(
280 <Regex as ::treesitter_types::FromNode>::from_node(node, src)?,
281 ))),
282 "string" => Ok(Self::String(::std::boxed::Box::new(
283 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
284 ))),
285 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
286 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
287 ))),
288 "super" => Ok(Self::Super(::std::boxed::Box::new(
289 <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
290 ))),
291 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
292 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
293 ))),
294 "this" => Ok(Self::This(::std::boxed::Box::new(
295 <This as ::treesitter_types::FromNode>::from_node(node, src)?,
296 ))),
297 "true" => Ok(Self::True(::std::boxed::Box::new(
298 <True as ::treesitter_types::FromNode>::from_node(node, src)?,
299 ))),
300 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
301 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
302 ))),
303 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
304 }
305 }
306}
307impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
308 fn span(&self) -> ::treesitter_types::Span {
309 match self {
310 Self::Array(inner) => inner.span(),
311 Self::ArrowFunction(inner) => inner.span(),
312 Self::CallExpression(inner) => inner.span(),
313 Self::Class(inner) => inner.span(),
314 Self::False(inner) => inner.span(),
315 Self::FunctionExpression(inner) => inner.span(),
316 Self::GeneratorFunction(inner) => inner.span(),
317 Self::Identifier(inner) => inner.span(),
318 Self::MemberExpression(inner) => inner.span(),
319 Self::MetaProperty(inner) => inner.span(),
320 Self::Null(inner) => inner.span(),
321 Self::Number(inner) => inner.span(),
322 Self::Object(inner) => inner.span(),
323 Self::ParenthesizedExpression(inner) => inner.span(),
324 Self::Regex(inner) => inner.span(),
325 Self::String(inner) => inner.span(),
326 Self::SubscriptExpression(inner) => inner.span(),
327 Self::Super(inner) => inner.span(),
328 Self::TemplateString(inner) => inner.span(),
329 Self::This(inner) => inner.span(),
330 Self::True(inner) => inner.span(),
331 Self::Undefined(inner) => inner.span(),
332 }
333 }
334}
335#[derive(Debug, Clone, PartialEq, Eq)]
336pub enum Statement<'tree> {
337 BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
338 ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
339 DebuggerStatement(::std::boxed::Box<DebuggerStatement<'tree>>),
340 Declaration(::std::boxed::Box<Declaration<'tree>>),
341 DoStatement(::std::boxed::Box<DoStatement<'tree>>),
342 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
343 ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
344 ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
345 ForInStatement(::std::boxed::Box<ForInStatement<'tree>>),
346 ForStatement(::std::boxed::Box<ForStatement<'tree>>),
347 IfStatement(::std::boxed::Box<IfStatement<'tree>>),
348 ImportStatement(::std::boxed::Box<ImportStatement<'tree>>),
349 LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
350 ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
351 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
352 SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
353 ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
354 TryStatement(::std::boxed::Box<TryStatement<'tree>>),
355 WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
356 WithStatement(::std::boxed::Box<WithStatement<'tree>>),
357}
358impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
359 #[allow(clippy::collapsible_else_if)]
360 fn from_node(
361 node: ::tree_sitter::Node<'tree>,
362 src: &'tree [u8],
363 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
364 match node.kind() {
365 "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
366 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
367 ))),
368 "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
369 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
370 ))),
371 "debugger_statement" => Ok(Self::DebuggerStatement(::std::boxed::Box::new(
372 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
373 ))),
374 "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
375 <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
376 ))),
377 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
378 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
379 ))),
380 "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
381 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
382 ))),
383 "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
384 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
385 ))),
386 "for_in_statement" => Ok(Self::ForInStatement(::std::boxed::Box::new(
387 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
388 ))),
389 "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
390 <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
391 ))),
392 "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
393 <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
394 ))),
395 "import_statement" => Ok(Self::ImportStatement(::std::boxed::Box::new(
396 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
397 ))),
398 "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
399 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
400 ))),
401 "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
402 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
403 ))),
404 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
405 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
406 ))),
407 "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
408 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
409 ))),
410 "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
411 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
412 ))),
413 "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
414 <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
415 ))),
416 "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
417 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
418 ))),
419 "with_statement" => Ok(Self::WithStatement(::std::boxed::Box::new(
420 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
421 ))),
422 _other => {
423 if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
424 Ok(Self::Declaration(::std::boxed::Box::new(v)))
425 } else {
426 Err(::treesitter_types::ParseError::unexpected_kind(
427 _other, node,
428 ))
429 }
430 }
431 }
432 }
433}
434impl ::treesitter_types::Spanned for Statement<'_> {
435 fn span(&self) -> ::treesitter_types::Span {
436 match self {
437 Self::BreakStatement(inner) => inner.span(),
438 Self::ContinueStatement(inner) => inner.span(),
439 Self::DebuggerStatement(inner) => inner.span(),
440 Self::Declaration(inner) => inner.span(),
441 Self::DoStatement(inner) => inner.span(),
442 Self::EmptyStatement(inner) => inner.span(),
443 Self::ExportStatement(inner) => inner.span(),
444 Self::ExpressionStatement(inner) => inner.span(),
445 Self::ForInStatement(inner) => inner.span(),
446 Self::ForStatement(inner) => inner.span(),
447 Self::IfStatement(inner) => inner.span(),
448 Self::ImportStatement(inner) => inner.span(),
449 Self::LabeledStatement(inner) => inner.span(),
450 Self::ReturnStatement(inner) => inner.span(),
451 Self::StatementBlock(inner) => inner.span(),
452 Self::SwitchStatement(inner) => inner.span(),
453 Self::ThrowStatement(inner) => inner.span(),
454 Self::TryStatement(inner) => inner.span(),
455 Self::WhileStatement(inner) => inner.span(),
456 Self::WithStatement(inner) => inner.span(),
457 }
458 }
459}
460#[derive(Debug, Clone, PartialEq, Eq)]
461pub struct Arguments<'tree> {
462 pub span: ::treesitter_types::Span,
463 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
464}
465impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
466 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
467 fn from_node(
468 node: ::tree_sitter::Node<'tree>,
469 src: &'tree [u8],
470 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
471 debug_assert_eq!(node.kind(), "arguments");
472 Ok(Self {
473 span: ::treesitter_types::Span::from(node),
474 children: {
475 #[allow(clippy::suspicious_else_formatting)]
476 let non_field_children = {
477 let mut cursor = node.walk();
478 let mut result = ::std::vec::Vec::new();
479 if cursor.goto_first_child() {
480 loop {
481 if cursor.field_name().is_none()
482 && cursor.node().is_named()
483 && !cursor.node().is_extra()
484 {
485 result.push(cursor.node());
486 }
487 if !cursor.goto_next_sibling() {
488 break;
489 }
490 }
491 }
492 result
493 };
494 let mut items = ::std::vec::Vec::new();
495 for child in non_field_children {
496 items.push(
497 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
498 );
499 }
500 items
501 },
502 })
503 }
504}
505impl ::treesitter_types::Spanned for Arguments<'_> {
506 fn span(&self) -> ::treesitter_types::Span {
507 self.span
508 }
509}
510#[derive(Debug, Clone, PartialEq, Eq)]
511pub struct Array<'tree> {
512 pub span: ::treesitter_types::Span,
513 pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
514}
515impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
516 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
517 fn from_node(
518 node: ::tree_sitter::Node<'tree>,
519 src: &'tree [u8],
520 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
521 debug_assert_eq!(node.kind(), "array");
522 Ok(Self {
523 span: ::treesitter_types::Span::from(node),
524 children: {
525 #[allow(clippy::suspicious_else_formatting)]
526 let non_field_children = {
527 let mut cursor = node.walk();
528 let mut result = ::std::vec::Vec::new();
529 if cursor.goto_first_child() {
530 loop {
531 if cursor.field_name().is_none()
532 && cursor.node().is_named()
533 && !cursor.node().is_extra()
534 {
535 result.push(cursor.node());
536 }
537 if !cursor.goto_next_sibling() {
538 break;
539 }
540 }
541 }
542 result
543 };
544 let mut items = ::std::vec::Vec::new();
545 for child in non_field_children {
546 items.push(<ArrayChildren as ::treesitter_types::FromNode>::from_node(
547 child, src,
548 )?);
549 }
550 items
551 },
552 })
553 }
554}
555impl ::treesitter_types::Spanned for Array<'_> {
556 fn span(&self) -> ::treesitter_types::Span {
557 self.span
558 }
559}
560#[derive(Debug, Clone, PartialEq, Eq)]
561pub struct ArrayPattern<'tree> {
562 pub span: ::treesitter_types::Span,
563 pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
564}
565impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
566 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
567 fn from_node(
568 node: ::tree_sitter::Node<'tree>,
569 src: &'tree [u8],
570 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
571 debug_assert_eq!(node.kind(), "array_pattern");
572 Ok(Self {
573 span: ::treesitter_types::Span::from(node),
574 children: {
575 #[allow(clippy::suspicious_else_formatting)]
576 let non_field_children = {
577 let mut cursor = node.walk();
578 let mut result = ::std::vec::Vec::new();
579 if cursor.goto_first_child() {
580 loop {
581 if cursor.field_name().is_none()
582 && cursor.node().is_named()
583 && !cursor.node().is_extra()
584 {
585 result.push(cursor.node());
586 }
587 if !cursor.goto_next_sibling() {
588 break;
589 }
590 }
591 }
592 result
593 };
594 let mut items = ::std::vec::Vec::new();
595 for child in non_field_children {
596 items.push(
597 <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
598 child, src,
599 )?,
600 );
601 }
602 items
603 },
604 })
605 }
606}
607impl ::treesitter_types::Spanned for ArrayPattern<'_> {
608 fn span(&self) -> ::treesitter_types::Span {
609 self.span
610 }
611}
612#[derive(Debug, Clone, PartialEq, Eq)]
613pub struct ArrowFunction<'tree> {
614 pub span: ::treesitter_types::Span,
615 pub body: ArrowFunctionBody<'tree>,
616 pub parameter: ::core::option::Option<Identifier<'tree>>,
617 pub parameters: ::core::option::Option<FormalParameters<'tree>>,
618}
619impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
620 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
621 fn from_node(
622 node: ::tree_sitter::Node<'tree>,
623 src: &'tree [u8],
624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
625 debug_assert_eq!(node.kind(), "arrow_function");
626 Ok(Self {
627 span: ::treesitter_types::Span::from(node),
628 body: {
629 let child = node
630 .child_by_field_name("body")
631 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
632 <ArrowFunctionBody as ::treesitter_types::FromNode>::from_node(child, src)?
633 },
634 parameter: match node.child_by_field_name("parameter") {
635 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
636 child, src,
637 )?),
638 None => None,
639 },
640 parameters: match node.child_by_field_name("parameters") {
641 Some(child) => {
642 Some(<FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
643 }
644 None => None,
645 },
646 })
647 }
648}
649impl ::treesitter_types::Spanned for ArrowFunction<'_> {
650 fn span(&self) -> ::treesitter_types::Span {
651 self.span
652 }
653}
654#[derive(Debug, Clone, PartialEq, Eq)]
655pub struct AssignmentExpression<'tree> {
656 pub span: ::treesitter_types::Span,
657 pub left: AssignmentExpressionLeft<'tree>,
658 pub right: Expression<'tree>,
659}
660impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
661 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
662 fn from_node(
663 node: ::tree_sitter::Node<'tree>,
664 src: &'tree [u8],
665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
666 debug_assert_eq!(node.kind(), "assignment_expression");
667 Ok(Self {
668 span: ::treesitter_types::Span::from(node),
669 left: {
670 let child = node
671 .child_by_field_name("left")
672 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
673 <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
674 },
675 right: {
676 let child = node
677 .child_by_field_name("right")
678 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
679 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
680 },
681 })
682 }
683}
684impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
685 fn span(&self) -> ::treesitter_types::Span {
686 self.span
687 }
688}
689#[derive(Debug, Clone, PartialEq, Eq)]
690pub struct AssignmentPattern<'tree> {
691 pub span: ::treesitter_types::Span,
692 pub left: Pattern<'tree>,
693 pub right: Expression<'tree>,
694}
695impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentPattern<'tree> {
696 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
697 fn from_node(
698 node: ::tree_sitter::Node<'tree>,
699 src: &'tree [u8],
700 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
701 debug_assert_eq!(node.kind(), "assignment_pattern");
702 Ok(Self {
703 span: ::treesitter_types::Span::from(node),
704 left: {
705 let child = node
706 .child_by_field_name("left")
707 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
708 <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
709 },
710 right: {
711 let child = node
712 .child_by_field_name("right")
713 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
714 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
715 },
716 })
717 }
718}
719impl ::treesitter_types::Spanned for AssignmentPattern<'_> {
720 fn span(&self) -> ::treesitter_types::Span {
721 self.span
722 }
723}
724#[derive(Debug, Clone, PartialEq, Eq)]
725pub struct AugmentedAssignmentExpression<'tree> {
726 pub span: ::treesitter_types::Span,
727 pub left: AugmentedAssignmentExpressionLeft<'tree>,
728 pub operator: AugmentedAssignmentExpressionOperator,
729 pub right: Expression<'tree>,
730}
731impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
732 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
733 fn from_node(
734 node: ::tree_sitter::Node<'tree>,
735 src: &'tree [u8],
736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
737 debug_assert_eq!(node.kind(), "augmented_assignment_expression");
738 Ok(Self {
739 span: ::treesitter_types::Span::from(node),
740 left: {
741 let child = node
742 .child_by_field_name("left")
743 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
744 <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
745 child, src,
746 )?
747 },
748 operator: {
749 let child = node.child_by_field_name("operator").ok_or_else(|| {
750 ::treesitter_types::ParseError::missing_field("operator", node)
751 })?;
752 <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
753 child, src,
754 )?
755 },
756 right: {
757 let child = node
758 .child_by_field_name("right")
759 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
760 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
761 },
762 })
763 }
764}
765impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
766 fn span(&self) -> ::treesitter_types::Span {
767 self.span
768 }
769}
770#[derive(Debug, Clone, PartialEq, Eq)]
771pub struct AwaitExpression<'tree> {
772 pub span: ::treesitter_types::Span,
773 pub children: Expression<'tree>,
774}
775impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
776 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
777 fn from_node(
778 node: ::tree_sitter::Node<'tree>,
779 src: &'tree [u8],
780 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
781 debug_assert_eq!(node.kind(), "await_expression");
782 Ok(Self {
783 span: ::treesitter_types::Span::from(node),
784 children: {
785 #[allow(clippy::suspicious_else_formatting)]
786 let non_field_children = {
787 let mut cursor = node.walk();
788 let mut result = ::std::vec::Vec::new();
789 if cursor.goto_first_child() {
790 loop {
791 if cursor.field_name().is_none()
792 && cursor.node().is_named()
793 && !cursor.node().is_extra()
794 {
795 result.push(cursor.node());
796 }
797 if !cursor.goto_next_sibling() {
798 break;
799 }
800 }
801 }
802 result
803 };
804 let child = if let Some(&c) = non_field_children.first() {
805 c
806 } else {
807 let mut fallback_cursor = node.walk();
808 let mut fallback_child = None;
809 if fallback_cursor.goto_first_child() {
810 loop {
811 if fallback_cursor.field_name().is_none()
812 && !fallback_cursor.node().is_extra()
813 {
814 let candidate = fallback_cursor.node();
815 #[allow(clippy::needless_question_mark)]
816 if (|| -> ::core::result::Result<
817 _,
818 ::treesitter_types::ParseError,
819 > {
820 let child = candidate;
821 Ok(
822 <Expression as ::treesitter_types::FromNode>::from_node(
823 child,
824 src,
825 )?,
826 )
827 })()
828 .is_ok()
829 {
830 fallback_child = Some(candidate);
831 break;
832 }
833 }
834 if !fallback_cursor.goto_next_sibling() {
835 break;
836 }
837 }
838 }
839 if fallback_child.is_none() {
840 let mut cursor2 = node.walk();
841 if cursor2.goto_first_child() {
842 loop {
843 if cursor2.node().is_named() && !cursor2.node().is_extra() {
844 let candidate = cursor2.node();
845 #[allow(clippy::needless_question_mark)]
846 if (|| -> ::core::result::Result<
847 _,
848 ::treesitter_types::ParseError,
849 > {
850 let child = candidate;
851 Ok(
852 <Expression as ::treesitter_types::FromNode>::from_node(
853 child,
854 src,
855 )?,
856 )
857 })()
858 .is_ok()
859 {
860 fallback_child = Some(candidate);
861 break;
862 }
863 }
864 if !cursor2.goto_next_sibling() {
865 break;
866 }
867 }
868 }
869 }
870 fallback_child.ok_or_else(|| {
871 ::treesitter_types::ParseError::missing_field("children", node)
872 })?
873 };
874 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
875 },
876 })
877 }
878}
879impl ::treesitter_types::Spanned for AwaitExpression<'_> {
880 fn span(&self) -> ::treesitter_types::Span {
881 self.span
882 }
883}
884#[derive(Debug, Clone, PartialEq, Eq)]
885pub struct BinaryExpression<'tree> {
886 pub span: ::treesitter_types::Span,
887 pub left: BinaryExpressionLeft<'tree>,
888 pub operator: BinaryExpressionOperator,
889 pub right: Expression<'tree>,
890}
891impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
892 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
893 fn from_node(
894 node: ::tree_sitter::Node<'tree>,
895 src: &'tree [u8],
896 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
897 debug_assert_eq!(node.kind(), "binary_expression");
898 Ok(Self {
899 span: ::treesitter_types::Span::from(node),
900 left: {
901 let child = node
902 .child_by_field_name("left")
903 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
904 <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
905 },
906 operator: {
907 let child = node.child_by_field_name("operator").ok_or_else(|| {
908 ::treesitter_types::ParseError::missing_field("operator", node)
909 })?;
910 <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
911 },
912 right: {
913 let child = node
914 .child_by_field_name("right")
915 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
916 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
917 },
918 })
919 }
920}
921impl ::treesitter_types::Spanned for BinaryExpression<'_> {
922 fn span(&self) -> ::treesitter_types::Span {
923 self.span
924 }
925}
926#[derive(Debug, Clone, PartialEq, Eq)]
927pub struct BreakStatement<'tree> {
928 pub span: ::treesitter_types::Span,
929 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
930}
931impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
932 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
933 fn from_node(
934 node: ::tree_sitter::Node<'tree>,
935 src: &'tree [u8],
936 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
937 debug_assert_eq!(node.kind(), "break_statement");
938 Ok(Self {
939 span: ::treesitter_types::Span::from(node),
940 label: match node.child_by_field_name("label") {
941 Some(child) => Some(
942 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
943 ),
944 None => None,
945 },
946 })
947 }
948}
949impl ::treesitter_types::Spanned for BreakStatement<'_> {
950 fn span(&self) -> ::treesitter_types::Span {
951 self.span
952 }
953}
954#[derive(Debug, Clone, PartialEq, Eq)]
955pub struct CallExpression<'tree> {
956 pub span: ::treesitter_types::Span,
957 pub arguments: CallExpressionArguments<'tree>,
958 pub function: CallExpressionFunction<'tree>,
959 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
960}
961impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
962 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
963 fn from_node(
964 node: ::tree_sitter::Node<'tree>,
965 src: &'tree [u8],
966 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
967 debug_assert_eq!(node.kind(), "call_expression");
968 Ok(Self {
969 span: ::treesitter_types::Span::from(node),
970 arguments: {
971 let child = node.child_by_field_name("arguments").ok_or_else(|| {
972 ::treesitter_types::ParseError::missing_field("arguments", node)
973 })?;
974 <CallExpressionArguments as ::treesitter_types::FromNode>::from_node(child, src)?
975 },
976 function: {
977 let child = node.child_by_field_name("function").ok_or_else(|| {
978 ::treesitter_types::ParseError::missing_field("function", node)
979 })?;
980 <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
981 },
982 optional_chain: match node.child_by_field_name("optional_chain") {
983 Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
984 child, src,
985 )?),
986 None => None,
987 },
988 })
989 }
990}
991impl ::treesitter_types::Spanned for CallExpression<'_> {
992 fn span(&self) -> ::treesitter_types::Span {
993 self.span
994 }
995}
996#[derive(Debug, Clone, PartialEq, Eq)]
997pub struct CatchClause<'tree> {
998 pub span: ::treesitter_types::Span,
999 pub body: StatementBlock<'tree>,
1000 pub parameter: ::core::option::Option<CatchClauseParameter<'tree>>,
1001}
1002impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
1003 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1004 fn from_node(
1005 node: ::tree_sitter::Node<'tree>,
1006 src: &'tree [u8],
1007 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1008 debug_assert_eq!(node.kind(), "catch_clause");
1009 Ok(Self {
1010 span: ::treesitter_types::Span::from(node),
1011 body: {
1012 let child = node
1013 .child_by_field_name("body")
1014 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1015 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
1016 },
1017 parameter: match node.child_by_field_name("parameter") {
1018 Some(child) => Some(
1019 <CatchClauseParameter as ::treesitter_types::FromNode>::from_node(child, src)?,
1020 ),
1021 None => None,
1022 },
1023 })
1024 }
1025}
1026impl ::treesitter_types::Spanned for CatchClause<'_> {
1027 fn span(&self) -> ::treesitter_types::Span {
1028 self.span
1029 }
1030}
1031#[derive(Debug, Clone, PartialEq, Eq)]
1032pub struct Class<'tree> {
1033 pub span: ::treesitter_types::Span,
1034 pub body: ClassBody<'tree>,
1035 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1036 pub name: ::core::option::Option<Identifier<'tree>>,
1037 pub children: ::core::option::Option<ClassHeritage<'tree>>,
1038}
1039impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
1040 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1041 fn from_node(
1042 node: ::tree_sitter::Node<'tree>,
1043 src: &'tree [u8],
1044 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1045 debug_assert_eq!(node.kind(), "class");
1046 Ok(Self {
1047 span: ::treesitter_types::Span::from(node),
1048 body: {
1049 let child = node
1050 .child_by_field_name("body")
1051 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1052 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
1053 },
1054 decorator: {
1055 let mut cursor = node.walk();
1056 let mut items = ::std::vec::Vec::new();
1057 for child in node.children_by_field_name("decorator", &mut cursor) {
1058 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
1059 child, src,
1060 )?);
1061 }
1062 items
1063 },
1064 name: match node.child_by_field_name("name") {
1065 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
1066 child, src,
1067 )?),
1068 None => None,
1069 },
1070 children: {
1071 #[allow(clippy::suspicious_else_formatting)]
1072 let non_field_children = {
1073 let mut cursor = node.walk();
1074 let mut result = ::std::vec::Vec::new();
1075 if cursor.goto_first_child() {
1076 loop {
1077 if cursor.field_name().is_none()
1078 && cursor.node().is_named()
1079 && !cursor.node().is_extra()
1080 {
1081 result.push(cursor.node());
1082 }
1083 if !cursor.goto_next_sibling() {
1084 break;
1085 }
1086 }
1087 }
1088 result
1089 };
1090 match non_field_children.first() {
1091 Some(&child) => Some(
1092 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
1093 ),
1094 None => None,
1095 }
1096 },
1097 })
1098 }
1099}
1100impl ::treesitter_types::Spanned for Class<'_> {
1101 fn span(&self) -> ::treesitter_types::Span {
1102 self.span
1103 }
1104}
1105#[derive(Debug, Clone, PartialEq, Eq)]
1106pub struct ClassBody<'tree> {
1107 pub span: ::treesitter_types::Span,
1108 pub member: ::std::vec::Vec<ClassBodyMember<'tree>>,
1109}
1110impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
1111 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1112 fn from_node(
1113 node: ::tree_sitter::Node<'tree>,
1114 src: &'tree [u8],
1115 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1116 debug_assert_eq!(node.kind(), "class_body");
1117 Ok(Self {
1118 span: ::treesitter_types::Span::from(node),
1119 member: {
1120 let mut cursor = node.walk();
1121 let mut items = ::std::vec::Vec::new();
1122 for child in node.children_by_field_name("member", &mut cursor) {
1123 items.push(
1124 <ClassBodyMember as ::treesitter_types::FromNode>::from_node(child, src)?,
1125 );
1126 }
1127 items
1128 },
1129 })
1130 }
1131}
1132impl ::treesitter_types::Spanned for ClassBody<'_> {
1133 fn span(&self) -> ::treesitter_types::Span {
1134 self.span
1135 }
1136}
1137#[derive(Debug, Clone, PartialEq, Eq)]
1138pub struct ClassDeclaration<'tree> {
1139 pub span: ::treesitter_types::Span,
1140 pub body: ClassBody<'tree>,
1141 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1142 pub name: Identifier<'tree>,
1143 pub children: ::core::option::Option<ClassHeritage<'tree>>,
1144}
1145impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
1146 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1147 fn from_node(
1148 node: ::tree_sitter::Node<'tree>,
1149 src: &'tree [u8],
1150 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1151 debug_assert_eq!(node.kind(), "class_declaration");
1152 Ok(Self {
1153 span: ::treesitter_types::Span::from(node),
1154 body: {
1155 let child = node
1156 .child_by_field_name("body")
1157 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1158 <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
1159 },
1160 decorator: {
1161 let mut cursor = node.walk();
1162 let mut items = ::std::vec::Vec::new();
1163 for child in node.children_by_field_name("decorator", &mut cursor) {
1164 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
1165 child, src,
1166 )?);
1167 }
1168 items
1169 },
1170 name: {
1171 let child = node
1172 .child_by_field_name("name")
1173 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1174 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
1175 },
1176 children: {
1177 #[allow(clippy::suspicious_else_formatting)]
1178 let non_field_children = {
1179 let mut cursor = node.walk();
1180 let mut result = ::std::vec::Vec::new();
1181 if cursor.goto_first_child() {
1182 loop {
1183 if cursor.field_name().is_none()
1184 && cursor.node().is_named()
1185 && !cursor.node().is_extra()
1186 {
1187 result.push(cursor.node());
1188 }
1189 if !cursor.goto_next_sibling() {
1190 break;
1191 }
1192 }
1193 }
1194 result
1195 };
1196 match non_field_children.first() {
1197 Some(&child) => Some(
1198 <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
1199 ),
1200 None => None,
1201 }
1202 },
1203 })
1204 }
1205}
1206impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
1207 fn span(&self) -> ::treesitter_types::Span {
1208 self.span
1209 }
1210}
1211#[derive(Debug, Clone, PartialEq, Eq)]
1212pub struct ClassHeritage<'tree> {
1213 pub span: ::treesitter_types::Span,
1214 pub children: Expression<'tree>,
1215}
1216impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritage<'tree> {
1217 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1218 fn from_node(
1219 node: ::tree_sitter::Node<'tree>,
1220 src: &'tree [u8],
1221 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1222 debug_assert_eq!(node.kind(), "class_heritage");
1223 Ok(Self {
1224 span: ::treesitter_types::Span::from(node),
1225 children: {
1226 #[allow(clippy::suspicious_else_formatting)]
1227 let non_field_children = {
1228 let mut cursor = node.walk();
1229 let mut result = ::std::vec::Vec::new();
1230 if cursor.goto_first_child() {
1231 loop {
1232 if cursor.field_name().is_none()
1233 && cursor.node().is_named()
1234 && !cursor.node().is_extra()
1235 {
1236 result.push(cursor.node());
1237 }
1238 if !cursor.goto_next_sibling() {
1239 break;
1240 }
1241 }
1242 }
1243 result
1244 };
1245 let child = if let Some(&c) = non_field_children.first() {
1246 c
1247 } else {
1248 let mut fallback_cursor = node.walk();
1249 let mut fallback_child = None;
1250 if fallback_cursor.goto_first_child() {
1251 loop {
1252 if fallback_cursor.field_name().is_none()
1253 && !fallback_cursor.node().is_extra()
1254 {
1255 let candidate = fallback_cursor.node();
1256 #[allow(clippy::needless_question_mark)]
1257 if (|| -> ::core::result::Result<
1258 _,
1259 ::treesitter_types::ParseError,
1260 > {
1261 let child = candidate;
1262 Ok(
1263 <Expression as ::treesitter_types::FromNode>::from_node(
1264 child,
1265 src,
1266 )?,
1267 )
1268 })()
1269 .is_ok()
1270 {
1271 fallback_child = Some(candidate);
1272 break;
1273 }
1274 }
1275 if !fallback_cursor.goto_next_sibling() {
1276 break;
1277 }
1278 }
1279 }
1280 if fallback_child.is_none() {
1281 let mut cursor2 = node.walk();
1282 if cursor2.goto_first_child() {
1283 loop {
1284 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1285 let candidate = cursor2.node();
1286 #[allow(clippy::needless_question_mark)]
1287 if (|| -> ::core::result::Result<
1288 _,
1289 ::treesitter_types::ParseError,
1290 > {
1291 let child = candidate;
1292 Ok(
1293 <Expression as ::treesitter_types::FromNode>::from_node(
1294 child,
1295 src,
1296 )?,
1297 )
1298 })()
1299 .is_ok()
1300 {
1301 fallback_child = Some(candidate);
1302 break;
1303 }
1304 }
1305 if !cursor2.goto_next_sibling() {
1306 break;
1307 }
1308 }
1309 }
1310 }
1311 fallback_child.ok_or_else(|| {
1312 ::treesitter_types::ParseError::missing_field("children", node)
1313 })?
1314 };
1315 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1316 },
1317 })
1318 }
1319}
1320impl ::treesitter_types::Spanned for ClassHeritage<'_> {
1321 fn span(&self) -> ::treesitter_types::Span {
1322 self.span
1323 }
1324}
1325#[derive(Debug, Clone, PartialEq, Eq)]
1326pub struct ClassStaticBlock<'tree> {
1327 pub span: ::treesitter_types::Span,
1328 pub body: StatementBlock<'tree>,
1329}
1330impl<'tree> ::treesitter_types::FromNode<'tree> for ClassStaticBlock<'tree> {
1331 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1332 fn from_node(
1333 node: ::tree_sitter::Node<'tree>,
1334 src: &'tree [u8],
1335 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1336 debug_assert_eq!(node.kind(), "class_static_block");
1337 Ok(Self {
1338 span: ::treesitter_types::Span::from(node),
1339 body: {
1340 let child = node
1341 .child_by_field_name("body")
1342 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1343 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
1344 },
1345 })
1346 }
1347}
1348impl ::treesitter_types::Spanned for ClassStaticBlock<'_> {
1349 fn span(&self) -> ::treesitter_types::Span {
1350 self.span
1351 }
1352}
1353#[derive(Debug, Clone, PartialEq, Eq)]
1354pub struct ComputedPropertyName<'tree> {
1355 pub span: ::treesitter_types::Span,
1356 pub children: Expression<'tree>,
1357}
1358impl<'tree> ::treesitter_types::FromNode<'tree> for ComputedPropertyName<'tree> {
1359 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1360 fn from_node(
1361 node: ::tree_sitter::Node<'tree>,
1362 src: &'tree [u8],
1363 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1364 debug_assert_eq!(node.kind(), "computed_property_name");
1365 Ok(Self {
1366 span: ::treesitter_types::Span::from(node),
1367 children: {
1368 #[allow(clippy::suspicious_else_formatting)]
1369 let non_field_children = {
1370 let mut cursor = node.walk();
1371 let mut result = ::std::vec::Vec::new();
1372 if cursor.goto_first_child() {
1373 loop {
1374 if cursor.field_name().is_none()
1375 && cursor.node().is_named()
1376 && !cursor.node().is_extra()
1377 {
1378 result.push(cursor.node());
1379 }
1380 if !cursor.goto_next_sibling() {
1381 break;
1382 }
1383 }
1384 }
1385 result
1386 };
1387 let child = if let Some(&c) = non_field_children.first() {
1388 c
1389 } else {
1390 let mut fallback_cursor = node.walk();
1391 let mut fallback_child = None;
1392 if fallback_cursor.goto_first_child() {
1393 loop {
1394 if fallback_cursor.field_name().is_none()
1395 && !fallback_cursor.node().is_extra()
1396 {
1397 let candidate = fallback_cursor.node();
1398 #[allow(clippy::needless_question_mark)]
1399 if (|| -> ::core::result::Result<
1400 _,
1401 ::treesitter_types::ParseError,
1402 > {
1403 let child = candidate;
1404 Ok(
1405 <Expression as ::treesitter_types::FromNode>::from_node(
1406 child,
1407 src,
1408 )?,
1409 )
1410 })()
1411 .is_ok()
1412 {
1413 fallback_child = Some(candidate);
1414 break;
1415 }
1416 }
1417 if !fallback_cursor.goto_next_sibling() {
1418 break;
1419 }
1420 }
1421 }
1422 if fallback_child.is_none() {
1423 let mut cursor2 = node.walk();
1424 if cursor2.goto_first_child() {
1425 loop {
1426 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1427 let candidate = cursor2.node();
1428 #[allow(clippy::needless_question_mark)]
1429 if (|| -> ::core::result::Result<
1430 _,
1431 ::treesitter_types::ParseError,
1432 > {
1433 let child = candidate;
1434 Ok(
1435 <Expression as ::treesitter_types::FromNode>::from_node(
1436 child,
1437 src,
1438 )?,
1439 )
1440 })()
1441 .is_ok()
1442 {
1443 fallback_child = Some(candidate);
1444 break;
1445 }
1446 }
1447 if !cursor2.goto_next_sibling() {
1448 break;
1449 }
1450 }
1451 }
1452 }
1453 fallback_child.ok_or_else(|| {
1454 ::treesitter_types::ParseError::missing_field("children", node)
1455 })?
1456 };
1457 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
1458 },
1459 })
1460 }
1461}
1462impl ::treesitter_types::Spanned for ComputedPropertyName<'_> {
1463 fn span(&self) -> ::treesitter_types::Span {
1464 self.span
1465 }
1466}
1467#[derive(Debug, Clone, PartialEq, Eq)]
1468pub struct ContinueStatement<'tree> {
1469 pub span: ::treesitter_types::Span,
1470 pub label: ::core::option::Option<StatementIdentifier<'tree>>,
1471}
1472impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
1473 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1474 fn from_node(
1475 node: ::tree_sitter::Node<'tree>,
1476 src: &'tree [u8],
1477 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1478 debug_assert_eq!(node.kind(), "continue_statement");
1479 Ok(Self {
1480 span: ::treesitter_types::Span::from(node),
1481 label: match node.child_by_field_name("label") {
1482 Some(child) => Some(
1483 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
1484 ),
1485 None => None,
1486 },
1487 })
1488 }
1489}
1490impl ::treesitter_types::Spanned for ContinueStatement<'_> {
1491 fn span(&self) -> ::treesitter_types::Span {
1492 self.span
1493 }
1494}
1495#[derive(Debug, Clone, PartialEq, Eq)]
1496pub struct DebuggerStatement<'tree> {
1497 pub span: ::treesitter_types::Span,
1498 text: &'tree str,
1499}
1500impl<'tree> ::treesitter_types::FromNode<'tree> for DebuggerStatement<'tree> {
1501 fn from_node(
1502 node: ::tree_sitter::Node<'tree>,
1503 src: &'tree [u8],
1504 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1505 debug_assert_eq!(node.kind(), "debugger_statement");
1506 Ok(Self {
1507 span: ::treesitter_types::Span::from(node),
1508 text: node.utf8_text(src)?,
1509 })
1510 }
1511}
1512impl<'tree> ::treesitter_types::LeafNode<'tree> for DebuggerStatement<'tree> {
1513 fn text(&self) -> &'tree str {
1514 self.text
1515 }
1516}
1517impl ::treesitter_types::Spanned for DebuggerStatement<'_> {
1518 fn span(&self) -> ::treesitter_types::Span {
1519 self.span
1520 }
1521}
1522#[derive(Debug, Clone, PartialEq, Eq)]
1523pub struct Decorator<'tree> {
1524 pub span: ::treesitter_types::Span,
1525 pub children: DecoratorChildren<'tree>,
1526}
1527impl<'tree> ::treesitter_types::FromNode<'tree> for Decorator<'tree> {
1528 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1529 fn from_node(
1530 node: ::tree_sitter::Node<'tree>,
1531 src: &'tree [u8],
1532 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1533 debug_assert_eq!(node.kind(), "decorator");
1534 Ok(Self {
1535 span: ::treesitter_types::Span::from(node),
1536 children: {
1537 #[allow(clippy::suspicious_else_formatting)]
1538 let non_field_children = {
1539 let mut cursor = node.walk();
1540 let mut result = ::std::vec::Vec::new();
1541 if cursor.goto_first_child() {
1542 loop {
1543 if cursor.field_name().is_none()
1544 && cursor.node().is_named()
1545 && !cursor.node().is_extra()
1546 {
1547 result.push(cursor.node());
1548 }
1549 if !cursor.goto_next_sibling() {
1550 break;
1551 }
1552 }
1553 }
1554 result
1555 };
1556 let child = if let Some(&c) = non_field_children.first() {
1557 c
1558 } else {
1559 let mut fallback_cursor = node.walk();
1560 let mut fallback_child = None;
1561 if fallback_cursor.goto_first_child() {
1562 loop {
1563 if fallback_cursor.field_name().is_none()
1564 && !fallback_cursor.node().is_extra()
1565 {
1566 let candidate = fallback_cursor.node();
1567 #[allow(clippy::needless_question_mark)]
1568 if (|| -> ::core::result::Result<
1569 _,
1570 ::treesitter_types::ParseError,
1571 > {
1572 let child = candidate;
1573 Ok(
1574 <DecoratorChildren as ::treesitter_types::FromNode>::from_node(
1575 child,
1576 src,
1577 )?,
1578 )
1579 })()
1580 .is_ok()
1581 {
1582 fallback_child = Some(candidate);
1583 break;
1584 }
1585 }
1586 if !fallback_cursor.goto_next_sibling() {
1587 break;
1588 }
1589 }
1590 }
1591 if fallback_child.is_none() {
1592 let mut cursor2 = node.walk();
1593 if cursor2.goto_first_child() {
1594 loop {
1595 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1596 let candidate = cursor2.node();
1597 #[allow(clippy::needless_question_mark)]
1598 if (|| -> ::core::result::Result<
1599 _,
1600 ::treesitter_types::ParseError,
1601 > {
1602 let child = candidate;
1603 Ok(
1604 <DecoratorChildren as ::treesitter_types::FromNode>::from_node(
1605 child,
1606 src,
1607 )?,
1608 )
1609 })()
1610 .is_ok()
1611 {
1612 fallback_child = Some(candidate);
1613 break;
1614 }
1615 }
1616 if !cursor2.goto_next_sibling() {
1617 break;
1618 }
1619 }
1620 }
1621 }
1622 fallback_child.ok_or_else(|| {
1623 ::treesitter_types::ParseError::missing_field("children", node)
1624 })?
1625 };
1626 <DecoratorChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1627 },
1628 })
1629 }
1630}
1631impl ::treesitter_types::Spanned for Decorator<'_> {
1632 fn span(&self) -> ::treesitter_types::Span {
1633 self.span
1634 }
1635}
1636#[derive(Debug, Clone, PartialEq, Eq)]
1637pub struct DoStatement<'tree> {
1638 pub span: ::treesitter_types::Span,
1639 pub body: Statement<'tree>,
1640 pub condition: ParenthesizedExpression<'tree>,
1641}
1642impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
1643 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1644 fn from_node(
1645 node: ::tree_sitter::Node<'tree>,
1646 src: &'tree [u8],
1647 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1648 debug_assert_eq!(node.kind(), "do_statement");
1649 Ok(Self {
1650 span: ::treesitter_types::Span::from(node),
1651 body: {
1652 let child = node
1653 .child_by_field_name("body")
1654 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
1655 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
1656 },
1657 condition: {
1658 let child = node.child_by_field_name("condition").ok_or_else(|| {
1659 ::treesitter_types::ParseError::missing_field("condition", node)
1660 })?;
1661 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
1662 },
1663 })
1664 }
1665}
1666impl ::treesitter_types::Spanned for DoStatement<'_> {
1667 fn span(&self) -> ::treesitter_types::Span {
1668 self.span
1669 }
1670}
1671#[derive(Debug, Clone, PartialEq, Eq)]
1672pub struct ElseClause<'tree> {
1673 pub span: ::treesitter_types::Span,
1674 pub children: Statement<'tree>,
1675}
1676impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
1677 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1678 fn from_node(
1679 node: ::tree_sitter::Node<'tree>,
1680 src: &'tree [u8],
1681 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1682 debug_assert_eq!(node.kind(), "else_clause");
1683 Ok(Self {
1684 span: ::treesitter_types::Span::from(node),
1685 children: {
1686 #[allow(clippy::suspicious_else_formatting)]
1687 let non_field_children = {
1688 let mut cursor = node.walk();
1689 let mut result = ::std::vec::Vec::new();
1690 if cursor.goto_first_child() {
1691 loop {
1692 if cursor.field_name().is_none()
1693 && cursor.node().is_named()
1694 && !cursor.node().is_extra()
1695 {
1696 result.push(cursor.node());
1697 }
1698 if !cursor.goto_next_sibling() {
1699 break;
1700 }
1701 }
1702 }
1703 result
1704 };
1705 let child = if let Some(&c) = non_field_children.first() {
1706 c
1707 } else {
1708 let mut fallback_cursor = node.walk();
1709 let mut fallback_child = None;
1710 if fallback_cursor.goto_first_child() {
1711 loop {
1712 if fallback_cursor.field_name().is_none()
1713 && !fallback_cursor.node().is_extra()
1714 {
1715 let candidate = fallback_cursor.node();
1716 #[allow(clippy::needless_question_mark)]
1717 if (|| -> ::core::result::Result<
1718 _,
1719 ::treesitter_types::ParseError,
1720 > {
1721 let child = candidate;
1722 Ok(
1723 <Statement as ::treesitter_types::FromNode>::from_node(
1724 child,
1725 src,
1726 )?,
1727 )
1728 })()
1729 .is_ok()
1730 {
1731 fallback_child = Some(candidate);
1732 break;
1733 }
1734 }
1735 if !fallback_cursor.goto_next_sibling() {
1736 break;
1737 }
1738 }
1739 }
1740 if fallback_child.is_none() {
1741 let mut cursor2 = node.walk();
1742 if cursor2.goto_first_child() {
1743 loop {
1744 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1745 let candidate = cursor2.node();
1746 #[allow(clippy::needless_question_mark)]
1747 if (|| -> ::core::result::Result<
1748 _,
1749 ::treesitter_types::ParseError,
1750 > {
1751 let child = candidate;
1752 Ok(
1753 <Statement as ::treesitter_types::FromNode>::from_node(
1754 child,
1755 src,
1756 )?,
1757 )
1758 })()
1759 .is_ok()
1760 {
1761 fallback_child = Some(candidate);
1762 break;
1763 }
1764 }
1765 if !cursor2.goto_next_sibling() {
1766 break;
1767 }
1768 }
1769 }
1770 }
1771 fallback_child.ok_or_else(|| {
1772 ::treesitter_types::ParseError::missing_field("children", node)
1773 })?
1774 };
1775 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
1776 },
1777 })
1778 }
1779}
1780impl ::treesitter_types::Spanned for ElseClause<'_> {
1781 fn span(&self) -> ::treesitter_types::Span {
1782 self.span
1783 }
1784}
1785#[derive(Debug, Clone, PartialEq, Eq)]
1786pub struct EmptyStatement<'tree> {
1787 pub span: ::treesitter_types::Span,
1788 text: &'tree str,
1789}
1790impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
1791 fn from_node(
1792 node: ::tree_sitter::Node<'tree>,
1793 src: &'tree [u8],
1794 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1795 debug_assert_eq!(node.kind(), "empty_statement");
1796 Ok(Self {
1797 span: ::treesitter_types::Span::from(node),
1798 text: node.utf8_text(src)?,
1799 })
1800 }
1801}
1802impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
1803 fn text(&self) -> &'tree str {
1804 self.text
1805 }
1806}
1807impl ::treesitter_types::Spanned for EmptyStatement<'_> {
1808 fn span(&self) -> ::treesitter_types::Span {
1809 self.span
1810 }
1811}
1812#[derive(Debug, Clone, PartialEq, Eq)]
1813pub struct ExportClause<'tree> {
1814 pub span: ::treesitter_types::Span,
1815 pub children: ::std::vec::Vec<ExportSpecifier<'tree>>,
1816}
1817impl<'tree> ::treesitter_types::FromNode<'tree> for ExportClause<'tree> {
1818 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1819 fn from_node(
1820 node: ::tree_sitter::Node<'tree>,
1821 src: &'tree [u8],
1822 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1823 debug_assert_eq!(node.kind(), "export_clause");
1824 Ok(Self {
1825 span: ::treesitter_types::Span::from(node),
1826 children: {
1827 #[allow(clippy::suspicious_else_formatting)]
1828 let non_field_children = {
1829 let mut cursor = node.walk();
1830 let mut result = ::std::vec::Vec::new();
1831 if cursor.goto_first_child() {
1832 loop {
1833 if cursor.field_name().is_none()
1834 && cursor.node().is_named()
1835 && !cursor.node().is_extra()
1836 {
1837 result.push(cursor.node());
1838 }
1839 if !cursor.goto_next_sibling() {
1840 break;
1841 }
1842 }
1843 }
1844 result
1845 };
1846 let mut items = ::std::vec::Vec::new();
1847 for child in non_field_children {
1848 items.push(
1849 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
1850 );
1851 }
1852 items
1853 },
1854 })
1855 }
1856}
1857impl ::treesitter_types::Spanned for ExportClause<'_> {
1858 fn span(&self) -> ::treesitter_types::Span {
1859 self.span
1860 }
1861}
1862#[derive(Debug, Clone, PartialEq, Eq)]
1863pub struct ExportSpecifier<'tree> {
1864 pub span: ::treesitter_types::Span,
1865 pub alias: ::core::option::Option<ExportSpecifierAlias<'tree>>,
1866 pub name: ExportSpecifierName<'tree>,
1867}
1868impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifier<'tree> {
1869 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1870 fn from_node(
1871 node: ::tree_sitter::Node<'tree>,
1872 src: &'tree [u8],
1873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1874 debug_assert_eq!(node.kind(), "export_specifier");
1875 Ok(Self {
1876 span: ::treesitter_types::Span::from(node),
1877 alias: match node.child_by_field_name("alias") {
1878 Some(child) => Some(
1879 <ExportSpecifierAlias as ::treesitter_types::FromNode>::from_node(child, src)?,
1880 ),
1881 None => None,
1882 },
1883 name: {
1884 let child = node
1885 .child_by_field_name("name")
1886 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
1887 <ExportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
1888 },
1889 })
1890 }
1891}
1892impl ::treesitter_types::Spanned for ExportSpecifier<'_> {
1893 fn span(&self) -> ::treesitter_types::Span {
1894 self.span
1895 }
1896}
1897#[derive(Debug, Clone, PartialEq, Eq)]
1898pub struct ExportStatement<'tree> {
1899 pub span: ::treesitter_types::Span,
1900 pub declaration: ::core::option::Option<Declaration<'tree>>,
1901 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
1902 pub source: ::core::option::Option<String<'tree>>,
1903 pub value: ::core::option::Option<Expression<'tree>>,
1904 pub children: ::core::option::Option<ExportStatementChildren<'tree>>,
1905}
1906impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatement<'tree> {
1907 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1908 fn from_node(
1909 node: ::tree_sitter::Node<'tree>,
1910 src: &'tree [u8],
1911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1912 debug_assert_eq!(node.kind(), "export_statement");
1913 Ok(Self {
1914 span: ::treesitter_types::Span::from(node),
1915 declaration: match node.child_by_field_name("declaration") {
1916 Some(child) => Some(<Declaration as ::treesitter_types::FromNode>::from_node(
1917 child, src,
1918 )?),
1919 None => None,
1920 },
1921 decorator: {
1922 let mut cursor = node.walk();
1923 let mut items = ::std::vec::Vec::new();
1924 for child in node.children_by_field_name("decorator", &mut cursor) {
1925 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
1926 child, src,
1927 )?);
1928 }
1929 items
1930 },
1931 source: match node.child_by_field_name("source") {
1932 Some(child) => Some(<String as ::treesitter_types::FromNode>::from_node(
1933 child, src,
1934 )?),
1935 None => None,
1936 },
1937 value: match node.child_by_field_name("value") {
1938 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
1939 child, src,
1940 )?),
1941 None => None,
1942 },
1943 children: {
1944 #[allow(clippy::suspicious_else_formatting)]
1945 let non_field_children = {
1946 let mut cursor = node.walk();
1947 let mut result = ::std::vec::Vec::new();
1948 if cursor.goto_first_child() {
1949 loop {
1950 if cursor.field_name().is_none()
1951 && cursor.node().is_named()
1952 && !cursor.node().is_extra()
1953 {
1954 result.push(cursor.node());
1955 }
1956 if !cursor.goto_next_sibling() {
1957 break;
1958 }
1959 }
1960 }
1961 result
1962 };
1963 match non_field_children.first() {
1964 Some(&child) => Some(
1965 <ExportStatementChildren as ::treesitter_types::FromNode>::from_node(
1966 child, src,
1967 )?,
1968 ),
1969 None => None,
1970 }
1971 },
1972 })
1973 }
1974}
1975impl ::treesitter_types::Spanned for ExportStatement<'_> {
1976 fn span(&self) -> ::treesitter_types::Span {
1977 self.span
1978 }
1979}
1980#[derive(Debug, Clone, PartialEq, Eq)]
1981pub struct ExpressionStatement<'tree> {
1982 pub span: ::treesitter_types::Span,
1983 pub children: ExpressionStatementChildren<'tree>,
1984}
1985impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
1986 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1987 fn from_node(
1988 node: ::tree_sitter::Node<'tree>,
1989 src: &'tree [u8],
1990 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1991 debug_assert_eq!(node.kind(), "expression_statement");
1992 Ok(Self {
1993 span: ::treesitter_types::Span::from(node),
1994 children: {
1995 #[allow(clippy::suspicious_else_formatting)]
1996 let non_field_children = {
1997 let mut cursor = node.walk();
1998 let mut result = ::std::vec::Vec::new();
1999 if cursor.goto_first_child() {
2000 loop {
2001 if cursor.field_name().is_none()
2002 && cursor.node().is_named()
2003 && !cursor.node().is_extra()
2004 {
2005 result.push(cursor.node());
2006 }
2007 if !cursor.goto_next_sibling() {
2008 break;
2009 }
2010 }
2011 }
2012 result
2013 };
2014 let child = if let Some(&c) = non_field_children.first() {
2015 c
2016 } else {
2017 let mut fallback_cursor = node.walk();
2018 let mut fallback_child = None;
2019 if fallback_cursor.goto_first_child() {
2020 loop {
2021 if fallback_cursor.field_name().is_none()
2022 && !fallback_cursor.node().is_extra()
2023 {
2024 let candidate = fallback_cursor.node();
2025 #[allow(clippy::needless_question_mark)]
2026 if (|| -> ::core::result::Result<
2027 _,
2028 ::treesitter_types::ParseError,
2029 > {
2030 let child = candidate;
2031 Ok(
2032 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2033 child,
2034 src,
2035 )?,
2036 )
2037 })()
2038 .is_ok()
2039 {
2040 fallback_child = Some(candidate);
2041 break;
2042 }
2043 }
2044 if !fallback_cursor.goto_next_sibling() {
2045 break;
2046 }
2047 }
2048 }
2049 if fallback_child.is_none() {
2050 let mut cursor2 = node.walk();
2051 if cursor2.goto_first_child() {
2052 loop {
2053 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2054 let candidate = cursor2.node();
2055 #[allow(clippy::needless_question_mark)]
2056 if (|| -> ::core::result::Result<
2057 _,
2058 ::treesitter_types::ParseError,
2059 > {
2060 let child = candidate;
2061 Ok(
2062 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2063 child,
2064 src,
2065 )?,
2066 )
2067 })()
2068 .is_ok()
2069 {
2070 fallback_child = Some(candidate);
2071 break;
2072 }
2073 }
2074 if !cursor2.goto_next_sibling() {
2075 break;
2076 }
2077 }
2078 }
2079 }
2080 fallback_child.ok_or_else(|| {
2081 ::treesitter_types::ParseError::missing_field("children", node)
2082 })?
2083 };
2084 <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
2085 child, src,
2086 )?
2087 },
2088 })
2089 }
2090}
2091impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
2092 fn span(&self) -> ::treesitter_types::Span {
2093 self.span
2094 }
2095}
2096#[derive(Debug, Clone, PartialEq, Eq)]
2097pub struct FieldDefinition<'tree> {
2098 pub span: ::treesitter_types::Span,
2099 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
2100 pub property: FieldDefinitionProperty<'tree>,
2101 pub value: ::core::option::Option<Expression<'tree>>,
2102}
2103impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDefinition<'tree> {
2104 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2105 fn from_node(
2106 node: ::tree_sitter::Node<'tree>,
2107 src: &'tree [u8],
2108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2109 debug_assert_eq!(node.kind(), "field_definition");
2110 Ok(Self {
2111 span: ::treesitter_types::Span::from(node),
2112 decorator: {
2113 let mut cursor = node.walk();
2114 let mut items = ::std::vec::Vec::new();
2115 for child in node.children_by_field_name("decorator", &mut cursor) {
2116 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
2117 child, src,
2118 )?);
2119 }
2120 items
2121 },
2122 property: {
2123 let child = node.child_by_field_name("property").ok_or_else(|| {
2124 ::treesitter_types::ParseError::missing_field("property", node)
2125 })?;
2126 <FieldDefinitionProperty as ::treesitter_types::FromNode>::from_node(child, src)?
2127 },
2128 value: match node.child_by_field_name("value") {
2129 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2130 child, src,
2131 )?),
2132 None => None,
2133 },
2134 })
2135 }
2136}
2137impl ::treesitter_types::Spanned for FieldDefinition<'_> {
2138 fn span(&self) -> ::treesitter_types::Span {
2139 self.span
2140 }
2141}
2142#[derive(Debug, Clone, PartialEq, Eq)]
2143pub struct FinallyClause<'tree> {
2144 pub span: ::treesitter_types::Span,
2145 pub body: StatementBlock<'tree>,
2146}
2147impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
2148 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2149 fn from_node(
2150 node: ::tree_sitter::Node<'tree>,
2151 src: &'tree [u8],
2152 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2153 debug_assert_eq!(node.kind(), "finally_clause");
2154 Ok(Self {
2155 span: ::treesitter_types::Span::from(node),
2156 body: {
2157 let child = node
2158 .child_by_field_name("body")
2159 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2160 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2161 },
2162 })
2163 }
2164}
2165impl ::treesitter_types::Spanned for FinallyClause<'_> {
2166 fn span(&self) -> ::treesitter_types::Span {
2167 self.span
2168 }
2169}
2170#[derive(Debug, Clone, PartialEq, Eq)]
2171pub struct ForInStatement<'tree> {
2172 pub span: ::treesitter_types::Span,
2173 pub body: Statement<'tree>,
2174 pub kind: ::std::vec::Vec<ForInStatementKind>,
2175 pub left: ForInStatementLeft<'tree>,
2176 pub operator: ForInStatementOperator,
2177 pub right: ForInStatementRight<'tree>,
2178 pub value: ::core::option::Option<Expression<'tree>>,
2179}
2180impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatement<'tree> {
2181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2182 fn from_node(
2183 node: ::tree_sitter::Node<'tree>,
2184 src: &'tree [u8],
2185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2186 debug_assert_eq!(node.kind(), "for_in_statement");
2187 Ok(Self {
2188 span: ::treesitter_types::Span::from(node),
2189 body: {
2190 let child = node
2191 .child_by_field_name("body")
2192 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2193 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2194 },
2195 kind: {
2196 let mut cursor = node.walk();
2197 let mut items = ::std::vec::Vec::new();
2198 for child in node.children_by_field_name("kind", &mut cursor) {
2199 items.push(
2200 <ForInStatementKind as ::treesitter_types::FromNode>::from_node(
2201 child, src,
2202 )?,
2203 );
2204 }
2205 items
2206 },
2207 left: {
2208 let child = node
2209 .child_by_field_name("left")
2210 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
2211 <ForInStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)?
2212 },
2213 operator: {
2214 let child = node.child_by_field_name("operator").ok_or_else(|| {
2215 ::treesitter_types::ParseError::missing_field("operator", node)
2216 })?;
2217 <ForInStatementOperator as ::treesitter_types::FromNode>::from_node(child, src)?
2218 },
2219 right: {
2220 let child = node
2221 .child_by_field_name("right")
2222 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
2223 <ForInStatementRight as ::treesitter_types::FromNode>::from_node(child, src)?
2224 },
2225 value: match node.child_by_field_name("value") {
2226 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
2227 child, src,
2228 )?),
2229 None => None,
2230 },
2231 })
2232 }
2233}
2234impl ::treesitter_types::Spanned for ForInStatement<'_> {
2235 fn span(&self) -> ::treesitter_types::Span {
2236 self.span
2237 }
2238}
2239#[derive(Debug, Clone, PartialEq, Eq)]
2240pub struct ForStatement<'tree> {
2241 pub span: ::treesitter_types::Span,
2242 pub body: Statement<'tree>,
2243 pub condition: ::std::vec::Vec<ForStatementCondition<'tree>>,
2244 pub increment: ::core::option::Option<ForStatementIncrement<'tree>>,
2245 pub initializer: ForStatementInitializer<'tree>,
2246}
2247impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
2248 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2249 fn from_node(
2250 node: ::tree_sitter::Node<'tree>,
2251 src: &'tree [u8],
2252 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2253 debug_assert_eq!(node.kind(), "for_statement");
2254 Ok(Self {
2255 span: ::treesitter_types::Span::from(node),
2256 body: {
2257 let child = node
2258 .child_by_field_name("body")
2259 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2260 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2261 },
2262 condition: {
2263 let mut cursor = node.walk();
2264 let mut items = ::std::vec::Vec::new();
2265 for child in node.children_by_field_name("condition", &mut cursor) {
2266 items.push(
2267 <ForStatementCondition as ::treesitter_types::FromNode>::from_node(
2268 child, src,
2269 )?,
2270 );
2271 }
2272 items
2273 },
2274 increment: match node.child_by_field_name("increment") {
2275 Some(child) => Some(
2276 <ForStatementIncrement as ::treesitter_types::FromNode>::from_node(child, src)?,
2277 ),
2278 None => None,
2279 },
2280 initializer: {
2281 let child = node.child_by_field_name("initializer").ok_or_else(|| {
2282 ::treesitter_types::ParseError::missing_field("initializer", node)
2283 })?;
2284 <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)?
2285 },
2286 })
2287 }
2288}
2289impl ::treesitter_types::Spanned for ForStatement<'_> {
2290 fn span(&self) -> ::treesitter_types::Span {
2291 self.span
2292 }
2293}
2294#[derive(Debug, Clone, PartialEq, Eq)]
2295pub struct FormalParameters<'tree> {
2296 pub span: ::treesitter_types::Span,
2297 pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
2298}
2299impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
2300 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2301 fn from_node(
2302 node: ::tree_sitter::Node<'tree>,
2303 src: &'tree [u8],
2304 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2305 debug_assert_eq!(node.kind(), "formal_parameters");
2306 Ok(Self {
2307 span: ::treesitter_types::Span::from(node),
2308 children: {
2309 #[allow(clippy::suspicious_else_formatting)]
2310 let non_field_children = {
2311 let mut cursor = node.walk();
2312 let mut result = ::std::vec::Vec::new();
2313 if cursor.goto_first_child() {
2314 loop {
2315 if cursor.field_name().is_none()
2316 && cursor.node().is_named()
2317 && !cursor.node().is_extra()
2318 {
2319 result.push(cursor.node());
2320 }
2321 if !cursor.goto_next_sibling() {
2322 break;
2323 }
2324 }
2325 }
2326 result
2327 };
2328 let mut items = ::std::vec::Vec::new();
2329 for child in non_field_children {
2330 items.push(
2331 <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
2332 child, src,
2333 )?,
2334 );
2335 }
2336 items
2337 },
2338 })
2339 }
2340}
2341impl ::treesitter_types::Spanned for FormalParameters<'_> {
2342 fn span(&self) -> ::treesitter_types::Span {
2343 self.span
2344 }
2345}
2346#[derive(Debug, Clone, PartialEq, Eq)]
2347pub struct FunctionDeclaration<'tree> {
2348 pub span: ::treesitter_types::Span,
2349 pub body: StatementBlock<'tree>,
2350 pub name: Identifier<'tree>,
2351 pub parameters: FormalParameters<'tree>,
2352}
2353impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
2354 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2355 fn from_node(
2356 node: ::tree_sitter::Node<'tree>,
2357 src: &'tree [u8],
2358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2359 debug_assert_eq!(node.kind(), "function_declaration");
2360 Ok(Self {
2361 span: ::treesitter_types::Span::from(node),
2362 body: {
2363 let child = node
2364 .child_by_field_name("body")
2365 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2366 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2367 },
2368 name: {
2369 let child = node
2370 .child_by_field_name("name")
2371 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2372 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2373 },
2374 parameters: {
2375 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2376 ::treesitter_types::ParseError::missing_field("parameters", node)
2377 })?;
2378 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2379 },
2380 })
2381 }
2382}
2383impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
2384 fn span(&self) -> ::treesitter_types::Span {
2385 self.span
2386 }
2387}
2388#[derive(Debug, Clone, PartialEq, Eq)]
2389pub struct FunctionExpression<'tree> {
2390 pub span: ::treesitter_types::Span,
2391 pub body: StatementBlock<'tree>,
2392 pub name: ::core::option::Option<Identifier<'tree>>,
2393 pub parameters: FormalParameters<'tree>,
2394}
2395impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpression<'tree> {
2396 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2397 fn from_node(
2398 node: ::tree_sitter::Node<'tree>,
2399 src: &'tree [u8],
2400 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2401 debug_assert_eq!(node.kind(), "function_expression");
2402 Ok(Self {
2403 span: ::treesitter_types::Span::from(node),
2404 body: {
2405 let child = node
2406 .child_by_field_name("body")
2407 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2408 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2409 },
2410 name: match node.child_by_field_name("name") {
2411 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2412 child, src,
2413 )?),
2414 None => None,
2415 },
2416 parameters: {
2417 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2418 ::treesitter_types::ParseError::missing_field("parameters", node)
2419 })?;
2420 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2421 },
2422 })
2423 }
2424}
2425impl ::treesitter_types::Spanned for FunctionExpression<'_> {
2426 fn span(&self) -> ::treesitter_types::Span {
2427 self.span
2428 }
2429}
2430#[derive(Debug, Clone, PartialEq, Eq)]
2431pub struct GeneratorFunction<'tree> {
2432 pub span: ::treesitter_types::Span,
2433 pub body: StatementBlock<'tree>,
2434 pub name: ::core::option::Option<Identifier<'tree>>,
2435 pub parameters: FormalParameters<'tree>,
2436}
2437impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunction<'tree> {
2438 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2439 fn from_node(
2440 node: ::tree_sitter::Node<'tree>,
2441 src: &'tree [u8],
2442 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2443 debug_assert_eq!(node.kind(), "generator_function");
2444 Ok(Self {
2445 span: ::treesitter_types::Span::from(node),
2446 body: {
2447 let child = node
2448 .child_by_field_name("body")
2449 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2450 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2451 },
2452 name: match node.child_by_field_name("name") {
2453 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2454 child, src,
2455 )?),
2456 None => None,
2457 },
2458 parameters: {
2459 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2460 ::treesitter_types::ParseError::missing_field("parameters", node)
2461 })?;
2462 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2463 },
2464 })
2465 }
2466}
2467impl ::treesitter_types::Spanned for GeneratorFunction<'_> {
2468 fn span(&self) -> ::treesitter_types::Span {
2469 self.span
2470 }
2471}
2472#[derive(Debug, Clone, PartialEq, Eq)]
2473pub struct GeneratorFunctionDeclaration<'tree> {
2474 pub span: ::treesitter_types::Span,
2475 pub body: StatementBlock<'tree>,
2476 pub name: Identifier<'tree>,
2477 pub parameters: FormalParameters<'tree>,
2478}
2479impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclaration<'tree> {
2480 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2481 fn from_node(
2482 node: ::tree_sitter::Node<'tree>,
2483 src: &'tree [u8],
2484 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2485 debug_assert_eq!(node.kind(), "generator_function_declaration");
2486 Ok(Self {
2487 span: ::treesitter_types::Span::from(node),
2488 body: {
2489 let child = node
2490 .child_by_field_name("body")
2491 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
2492 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
2493 },
2494 name: {
2495 let child = node
2496 .child_by_field_name("name")
2497 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2498 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
2499 },
2500 parameters: {
2501 let child = node.child_by_field_name("parameters").ok_or_else(|| {
2502 ::treesitter_types::ParseError::missing_field("parameters", node)
2503 })?;
2504 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
2505 },
2506 })
2507 }
2508}
2509impl ::treesitter_types::Spanned for GeneratorFunctionDeclaration<'_> {
2510 fn span(&self) -> ::treesitter_types::Span {
2511 self.span
2512 }
2513}
2514#[derive(Debug, Clone, PartialEq, Eq)]
2515pub struct IfStatement<'tree> {
2516 pub span: ::treesitter_types::Span,
2517 pub alternative: ::core::option::Option<ElseClause<'tree>>,
2518 pub condition: ParenthesizedExpression<'tree>,
2519 pub consequence: Statement<'tree>,
2520}
2521impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
2522 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2523 fn from_node(
2524 node: ::tree_sitter::Node<'tree>,
2525 src: &'tree [u8],
2526 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2527 debug_assert_eq!(node.kind(), "if_statement");
2528 Ok(Self {
2529 span: ::treesitter_types::Span::from(node),
2530 alternative: match node.child_by_field_name("alternative") {
2531 Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
2532 child, src,
2533 )?),
2534 None => None,
2535 },
2536 condition: {
2537 let child = node.child_by_field_name("condition").ok_or_else(|| {
2538 ::treesitter_types::ParseError::missing_field("condition", node)
2539 })?;
2540 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
2541 },
2542 consequence: {
2543 let child = node.child_by_field_name("consequence").ok_or_else(|| {
2544 ::treesitter_types::ParseError::missing_field("consequence", node)
2545 })?;
2546 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
2547 },
2548 })
2549 }
2550}
2551impl ::treesitter_types::Spanned for IfStatement<'_> {
2552 fn span(&self) -> ::treesitter_types::Span {
2553 self.span
2554 }
2555}
2556#[derive(Debug, Clone, PartialEq, Eq)]
2557pub struct Import<'tree> {
2558 pub span: ::treesitter_types::Span,
2559 text: &'tree str,
2560}
2561impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
2562 fn from_node(
2563 node: ::tree_sitter::Node<'tree>,
2564 src: &'tree [u8],
2565 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2566 debug_assert_eq!(node.kind(), "import");
2567 Ok(Self {
2568 span: ::treesitter_types::Span::from(node),
2569 text: node.utf8_text(src)?,
2570 })
2571 }
2572}
2573impl<'tree> ::treesitter_types::LeafNode<'tree> for Import<'tree> {
2574 fn text(&self) -> &'tree str {
2575 self.text
2576 }
2577}
2578impl ::treesitter_types::Spanned for Import<'_> {
2579 fn span(&self) -> ::treesitter_types::Span {
2580 self.span
2581 }
2582}
2583#[derive(Debug, Clone, PartialEq, Eq)]
2584pub struct ImportAttribute<'tree> {
2585 pub span: ::treesitter_types::Span,
2586 pub children: Object<'tree>,
2587}
2588impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAttribute<'tree> {
2589 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2590 fn from_node(
2591 node: ::tree_sitter::Node<'tree>,
2592 src: &'tree [u8],
2593 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2594 debug_assert_eq!(node.kind(), "import_attribute");
2595 Ok(Self {
2596 span: ::treesitter_types::Span::from(node),
2597 children: {
2598 #[allow(clippy::suspicious_else_formatting)]
2599 let non_field_children = {
2600 let mut cursor = node.walk();
2601 let mut result = ::std::vec::Vec::new();
2602 if cursor.goto_first_child() {
2603 loop {
2604 if cursor.field_name().is_none()
2605 && cursor.node().is_named()
2606 && !cursor.node().is_extra()
2607 {
2608 result.push(cursor.node());
2609 }
2610 if !cursor.goto_next_sibling() {
2611 break;
2612 }
2613 }
2614 }
2615 result
2616 };
2617 let child = if let Some(&c) = non_field_children.first() {
2618 c
2619 } else {
2620 let mut fallback_cursor = node.walk();
2621 let mut fallback_child = None;
2622 if fallback_cursor.goto_first_child() {
2623 loop {
2624 if fallback_cursor.field_name().is_none()
2625 && !fallback_cursor.node().is_extra()
2626 {
2627 let candidate = fallback_cursor.node();
2628 #[allow(clippy::needless_question_mark)]
2629 if (|| -> ::core::result::Result<
2630 _,
2631 ::treesitter_types::ParseError,
2632 > {
2633 let child = candidate;
2634 Ok(
2635 <Object as ::treesitter_types::FromNode>::from_node(
2636 child,
2637 src,
2638 )?,
2639 )
2640 })()
2641 .is_ok()
2642 {
2643 fallback_child = Some(candidate);
2644 break;
2645 }
2646 }
2647 if !fallback_cursor.goto_next_sibling() {
2648 break;
2649 }
2650 }
2651 }
2652 if fallback_child.is_none() {
2653 let mut cursor2 = node.walk();
2654 if cursor2.goto_first_child() {
2655 loop {
2656 if cursor2.node().is_named() && !cursor2.node().is_extra() {
2657 let candidate = cursor2.node();
2658 #[allow(clippy::needless_question_mark)]
2659 if (|| -> ::core::result::Result<
2660 _,
2661 ::treesitter_types::ParseError,
2662 > {
2663 let child = candidate;
2664 Ok(
2665 <Object as ::treesitter_types::FromNode>::from_node(
2666 child,
2667 src,
2668 )?,
2669 )
2670 })()
2671 .is_ok()
2672 {
2673 fallback_child = Some(candidate);
2674 break;
2675 }
2676 }
2677 if !cursor2.goto_next_sibling() {
2678 break;
2679 }
2680 }
2681 }
2682 }
2683 fallback_child.ok_or_else(|| {
2684 ::treesitter_types::ParseError::missing_field("children", node)
2685 })?
2686 };
2687 <Object as ::treesitter_types::FromNode>::from_node(child, src)?
2688 },
2689 })
2690 }
2691}
2692impl ::treesitter_types::Spanned for ImportAttribute<'_> {
2693 fn span(&self) -> ::treesitter_types::Span {
2694 self.span
2695 }
2696}
2697#[derive(Debug, Clone, PartialEq, Eq)]
2698pub struct ImportClause<'tree> {
2699 pub span: ::treesitter_types::Span,
2700 pub children: ::std::vec::Vec<ImportClauseChildren<'tree>>,
2701}
2702impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClause<'tree> {
2703 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2704 fn from_node(
2705 node: ::tree_sitter::Node<'tree>,
2706 src: &'tree [u8],
2707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2708 debug_assert_eq!(node.kind(), "import_clause");
2709 Ok(Self {
2710 span: ::treesitter_types::Span::from(node),
2711 children: {
2712 #[allow(clippy::suspicious_else_formatting)]
2713 let non_field_children = {
2714 let mut cursor = node.walk();
2715 let mut result = ::std::vec::Vec::new();
2716 if cursor.goto_first_child() {
2717 loop {
2718 if cursor.field_name().is_none()
2719 && cursor.node().is_named()
2720 && !cursor.node().is_extra()
2721 {
2722 result.push(cursor.node());
2723 }
2724 if !cursor.goto_next_sibling() {
2725 break;
2726 }
2727 }
2728 }
2729 result
2730 };
2731 let mut items = ::std::vec::Vec::new();
2732 for child in non_field_children {
2733 items.push(
2734 <ImportClauseChildren as ::treesitter_types::FromNode>::from_node(
2735 child, src,
2736 )?,
2737 );
2738 }
2739 items
2740 },
2741 })
2742 }
2743}
2744impl ::treesitter_types::Spanned for ImportClause<'_> {
2745 fn span(&self) -> ::treesitter_types::Span {
2746 self.span
2747 }
2748}
2749#[derive(Debug, Clone, PartialEq, Eq)]
2750pub struct ImportSpecifier<'tree> {
2751 pub span: ::treesitter_types::Span,
2752 pub alias: ::core::option::Option<Identifier<'tree>>,
2753 pub name: ImportSpecifierName<'tree>,
2754}
2755impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifier<'tree> {
2756 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2757 fn from_node(
2758 node: ::tree_sitter::Node<'tree>,
2759 src: &'tree [u8],
2760 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2761 debug_assert_eq!(node.kind(), "import_specifier");
2762 Ok(Self {
2763 span: ::treesitter_types::Span::from(node),
2764 alias: match node.child_by_field_name("alias") {
2765 Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
2766 child, src,
2767 )?),
2768 None => None,
2769 },
2770 name: {
2771 let child = node
2772 .child_by_field_name("name")
2773 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
2774 <ImportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
2775 },
2776 })
2777 }
2778}
2779impl ::treesitter_types::Spanned for ImportSpecifier<'_> {
2780 fn span(&self) -> ::treesitter_types::Span {
2781 self.span
2782 }
2783}
2784#[derive(Debug, Clone, PartialEq, Eq)]
2785pub struct ImportStatement<'tree> {
2786 pub span: ::treesitter_types::Span,
2787 pub source: String<'tree>,
2788 pub children: ::std::vec::Vec<ImportStatementChildren<'tree>>,
2789}
2790impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatement<'tree> {
2791 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2792 fn from_node(
2793 node: ::tree_sitter::Node<'tree>,
2794 src: &'tree [u8],
2795 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2796 debug_assert_eq!(node.kind(), "import_statement");
2797 Ok(Self {
2798 span: ::treesitter_types::Span::from(node),
2799 source: {
2800 let child = node
2801 .child_by_field_name("source")
2802 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("source", node))?;
2803 <String as ::treesitter_types::FromNode>::from_node(child, src)?
2804 },
2805 children: {
2806 #[allow(clippy::suspicious_else_formatting)]
2807 let non_field_children = {
2808 let mut cursor = node.walk();
2809 let mut result = ::std::vec::Vec::new();
2810 if cursor.goto_first_child() {
2811 loop {
2812 if cursor.field_name().is_none()
2813 && cursor.node().is_named()
2814 && !cursor.node().is_extra()
2815 {
2816 result.push(cursor.node());
2817 }
2818 if !cursor.goto_next_sibling() {
2819 break;
2820 }
2821 }
2822 }
2823 result
2824 };
2825 let mut items = ::std::vec::Vec::new();
2826 for child in non_field_children {
2827 items.push(
2828 <ImportStatementChildren as ::treesitter_types::FromNode>::from_node(
2829 child, src,
2830 )?,
2831 );
2832 }
2833 items
2834 },
2835 })
2836 }
2837}
2838impl ::treesitter_types::Spanned for ImportStatement<'_> {
2839 fn span(&self) -> ::treesitter_types::Span {
2840 self.span
2841 }
2842}
2843#[derive(Debug, Clone, PartialEq, Eq)]
2844pub struct JsxAttribute<'tree> {
2845 pub span: ::treesitter_types::Span,
2846 pub children: ::std::vec::Vec<JsxAttributeChildren<'tree>>,
2847}
2848impl<'tree> ::treesitter_types::FromNode<'tree> for JsxAttribute<'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(), "jsx_attribute");
2855 Ok(Self {
2856 span: ::treesitter_types::Span::from(node),
2857 children: {
2858 #[allow(clippy::suspicious_else_formatting)]
2859 let non_field_children = {
2860 let mut cursor = node.walk();
2861 let mut result = ::std::vec::Vec::new();
2862 if cursor.goto_first_child() {
2863 loop {
2864 if cursor.field_name().is_none()
2865 && cursor.node().is_named()
2866 && !cursor.node().is_extra()
2867 {
2868 result.push(cursor.node());
2869 }
2870 if !cursor.goto_next_sibling() {
2871 break;
2872 }
2873 }
2874 }
2875 result
2876 };
2877 let mut items = ::std::vec::Vec::new();
2878 for child in non_field_children {
2879 items.push(
2880 <JsxAttributeChildren as ::treesitter_types::FromNode>::from_node(
2881 child, src,
2882 )?,
2883 );
2884 }
2885 items
2886 },
2887 })
2888 }
2889}
2890impl ::treesitter_types::Spanned for JsxAttribute<'_> {
2891 fn span(&self) -> ::treesitter_types::Span {
2892 self.span
2893 }
2894}
2895#[derive(Debug, Clone, PartialEq, Eq)]
2896pub struct JsxClosingElement<'tree> {
2897 pub span: ::treesitter_types::Span,
2898 pub name: ::core::option::Option<JsxClosingElementName<'tree>>,
2899}
2900impl<'tree> ::treesitter_types::FromNode<'tree> for JsxClosingElement<'tree> {
2901 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2902 fn from_node(
2903 node: ::tree_sitter::Node<'tree>,
2904 src: &'tree [u8],
2905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2906 debug_assert_eq!(node.kind(), "jsx_closing_element");
2907 Ok(Self {
2908 span: ::treesitter_types::Span::from(node),
2909 name: match node.child_by_field_name("name") {
2910 Some(child) => Some(
2911 <JsxClosingElementName as ::treesitter_types::FromNode>::from_node(child, src)?,
2912 ),
2913 None => None,
2914 },
2915 })
2916 }
2917}
2918impl ::treesitter_types::Spanned for JsxClosingElement<'_> {
2919 fn span(&self) -> ::treesitter_types::Span {
2920 self.span
2921 }
2922}
2923#[derive(Debug, Clone, PartialEq, Eq)]
2924pub struct JsxElement<'tree> {
2925 pub span: ::treesitter_types::Span,
2926 pub close_tag: JsxClosingElement<'tree>,
2927 pub open_tag: JsxOpeningElement<'tree>,
2928 pub children: ::std::vec::Vec<JsxElementChildren<'tree>>,
2929}
2930impl<'tree> ::treesitter_types::FromNode<'tree> for JsxElement<'tree> {
2931 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2932 fn from_node(
2933 node: ::tree_sitter::Node<'tree>,
2934 src: &'tree [u8],
2935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2936 debug_assert_eq!(node.kind(), "jsx_element");
2937 Ok(Self {
2938 span: ::treesitter_types::Span::from(node),
2939 close_tag: {
2940 let child = node.child_by_field_name("close_tag").ok_or_else(|| {
2941 ::treesitter_types::ParseError::missing_field("close_tag", node)
2942 })?;
2943 <JsxClosingElement as ::treesitter_types::FromNode>::from_node(child, src)?
2944 },
2945 open_tag: {
2946 let child = node.child_by_field_name("open_tag").ok_or_else(|| {
2947 ::treesitter_types::ParseError::missing_field("open_tag", node)
2948 })?;
2949 <JsxOpeningElement as ::treesitter_types::FromNode>::from_node(child, src)?
2950 },
2951 children: {
2952 #[allow(clippy::suspicious_else_formatting)]
2953 let non_field_children = {
2954 let mut cursor = node.walk();
2955 let mut result = ::std::vec::Vec::new();
2956 if cursor.goto_first_child() {
2957 loop {
2958 if cursor.field_name().is_none()
2959 && cursor.node().is_named()
2960 && !cursor.node().is_extra()
2961 {
2962 result.push(cursor.node());
2963 }
2964 if !cursor.goto_next_sibling() {
2965 break;
2966 }
2967 }
2968 }
2969 result
2970 };
2971 let mut items = ::std::vec::Vec::new();
2972 for child in non_field_children {
2973 items.push(
2974 <JsxElementChildren as ::treesitter_types::FromNode>::from_node(
2975 child, src,
2976 )?,
2977 );
2978 }
2979 items
2980 },
2981 })
2982 }
2983}
2984impl ::treesitter_types::Spanned for JsxElement<'_> {
2985 fn span(&self) -> ::treesitter_types::Span {
2986 self.span
2987 }
2988}
2989#[derive(Debug, Clone, PartialEq, Eq)]
2990pub struct JsxExpression<'tree> {
2991 pub span: ::treesitter_types::Span,
2992 pub children: ::core::option::Option<JsxExpressionChildren<'tree>>,
2993}
2994impl<'tree> ::treesitter_types::FromNode<'tree> for JsxExpression<'tree> {
2995 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
2996 fn from_node(
2997 node: ::tree_sitter::Node<'tree>,
2998 src: &'tree [u8],
2999 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3000 debug_assert_eq!(node.kind(), "jsx_expression");
3001 Ok(Self {
3002 span: ::treesitter_types::Span::from(node),
3003 children: {
3004 #[allow(clippy::suspicious_else_formatting)]
3005 let non_field_children = {
3006 let mut cursor = node.walk();
3007 let mut result = ::std::vec::Vec::new();
3008 if cursor.goto_first_child() {
3009 loop {
3010 if cursor.field_name().is_none()
3011 && cursor.node().is_named()
3012 && !cursor.node().is_extra()
3013 {
3014 result.push(cursor.node());
3015 }
3016 if !cursor.goto_next_sibling() {
3017 break;
3018 }
3019 }
3020 }
3021 result
3022 };
3023 match non_field_children.first() {
3024 Some(&child) => Some(
3025 <JsxExpressionChildren as ::treesitter_types::FromNode>::from_node(
3026 child, src,
3027 )?,
3028 ),
3029 None => None,
3030 }
3031 },
3032 })
3033 }
3034}
3035impl ::treesitter_types::Spanned for JsxExpression<'_> {
3036 fn span(&self) -> ::treesitter_types::Span {
3037 self.span
3038 }
3039}
3040#[derive(Debug, Clone, PartialEq, Eq)]
3041pub struct JsxNamespaceName<'tree> {
3042 pub span: ::treesitter_types::Span,
3043 pub children: ::std::vec::Vec<Identifier<'tree>>,
3044}
3045impl<'tree> ::treesitter_types::FromNode<'tree> for JsxNamespaceName<'tree> {
3046 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3047 fn from_node(
3048 node: ::tree_sitter::Node<'tree>,
3049 src: &'tree [u8],
3050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3051 debug_assert_eq!(node.kind(), "jsx_namespace_name");
3052 Ok(Self {
3053 span: ::treesitter_types::Span::from(node),
3054 children: {
3055 #[allow(clippy::suspicious_else_formatting)]
3056 let non_field_children = {
3057 let mut cursor = node.walk();
3058 let mut result = ::std::vec::Vec::new();
3059 if cursor.goto_first_child() {
3060 loop {
3061 if cursor.field_name().is_none()
3062 && cursor.node().is_named()
3063 && !cursor.node().is_extra()
3064 {
3065 result.push(cursor.node());
3066 }
3067 if !cursor.goto_next_sibling() {
3068 break;
3069 }
3070 }
3071 }
3072 result
3073 };
3074 let mut items = ::std::vec::Vec::new();
3075 for child in non_field_children {
3076 items.push(<Identifier as ::treesitter_types::FromNode>::from_node(
3077 child, src,
3078 )?);
3079 }
3080 items
3081 },
3082 })
3083 }
3084}
3085impl ::treesitter_types::Spanned for JsxNamespaceName<'_> {
3086 fn span(&self) -> ::treesitter_types::Span {
3087 self.span
3088 }
3089}
3090#[derive(Debug, Clone, PartialEq, Eq)]
3091pub struct JsxOpeningElement<'tree> {
3092 pub span: ::treesitter_types::Span,
3093 pub attribute: ::std::vec::Vec<JsxOpeningElementAttribute<'tree>>,
3094 pub name: ::core::option::Option<JsxOpeningElementName<'tree>>,
3095}
3096impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElement<'tree> {
3097 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3098 fn from_node(
3099 node: ::tree_sitter::Node<'tree>,
3100 src: &'tree [u8],
3101 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3102 debug_assert_eq!(node.kind(), "jsx_opening_element");
3103 Ok(Self {
3104 span: ::treesitter_types::Span::from(node),
3105 attribute: {
3106 let mut cursor = node.walk();
3107 let mut items = ::std::vec::Vec::new();
3108 for child in node.children_by_field_name("attribute", &mut cursor) {
3109 items.push(
3110 <JsxOpeningElementAttribute as ::treesitter_types::FromNode>::from_node(
3111 child, src,
3112 )?,
3113 );
3114 }
3115 items
3116 },
3117 name: match node.child_by_field_name("name") {
3118 Some(child) => Some(
3119 <JsxOpeningElementName as ::treesitter_types::FromNode>::from_node(child, src)?,
3120 ),
3121 None => None,
3122 },
3123 })
3124 }
3125}
3126impl ::treesitter_types::Spanned for JsxOpeningElement<'_> {
3127 fn span(&self) -> ::treesitter_types::Span {
3128 self.span
3129 }
3130}
3131#[derive(Debug, Clone, PartialEq, Eq)]
3132pub struct JsxSelfClosingElement<'tree> {
3133 pub span: ::treesitter_types::Span,
3134 pub attribute: ::std::vec::Vec<JsxSelfClosingElementAttribute<'tree>>,
3135 pub name: JsxSelfClosingElementName<'tree>,
3136}
3137impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElement<'tree> {
3138 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3139 fn from_node(
3140 node: ::tree_sitter::Node<'tree>,
3141 src: &'tree [u8],
3142 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3143 debug_assert_eq!(node.kind(), "jsx_self_closing_element");
3144 Ok(Self {
3145 span: ::treesitter_types::Span::from(node),
3146 attribute: {
3147 let mut cursor = node.walk();
3148 let mut items = ::std::vec::Vec::new();
3149 for child in node.children_by_field_name("attribute", &mut cursor) {
3150 items
3151 .push(
3152 <JsxSelfClosingElementAttribute as ::treesitter_types::FromNode>::from_node(
3153 child,
3154 src,
3155 )?,
3156 );
3157 }
3158 items
3159 },
3160 name: {
3161 let child = node
3162 .child_by_field_name("name")
3163 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3164 <JsxSelfClosingElementName as ::treesitter_types::FromNode>::from_node(child, src)?
3165 },
3166 })
3167 }
3168}
3169impl ::treesitter_types::Spanned for JsxSelfClosingElement<'_> {
3170 fn span(&self) -> ::treesitter_types::Span {
3171 self.span
3172 }
3173}
3174#[derive(Debug, Clone, PartialEq, Eq)]
3175pub struct LabeledStatement<'tree> {
3176 pub span: ::treesitter_types::Span,
3177 pub body: Statement<'tree>,
3178 pub label: StatementIdentifier<'tree>,
3179}
3180impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
3181 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3182 fn from_node(
3183 node: ::tree_sitter::Node<'tree>,
3184 src: &'tree [u8],
3185 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3186 debug_assert_eq!(node.kind(), "labeled_statement");
3187 Ok(Self {
3188 span: ::treesitter_types::Span::from(node),
3189 body: {
3190 let child = node
3191 .child_by_field_name("body")
3192 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3193 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
3194 },
3195 label: {
3196 let child = node
3197 .child_by_field_name("label")
3198 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
3199 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
3200 },
3201 })
3202 }
3203}
3204impl ::treesitter_types::Spanned for LabeledStatement<'_> {
3205 fn span(&self) -> ::treesitter_types::Span {
3206 self.span
3207 }
3208}
3209#[derive(Debug, Clone, PartialEq, Eq)]
3210pub struct LexicalDeclaration<'tree> {
3211 pub span: ::treesitter_types::Span,
3212 pub kind: LexicalDeclarationKind,
3213 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
3214}
3215impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclaration<'tree> {
3216 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3217 fn from_node(
3218 node: ::tree_sitter::Node<'tree>,
3219 src: &'tree [u8],
3220 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3221 debug_assert_eq!(node.kind(), "lexical_declaration");
3222 Ok(Self {
3223 span: ::treesitter_types::Span::from(node),
3224 kind: {
3225 let child = node
3226 .child_by_field_name("kind")
3227 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
3228 <LexicalDeclarationKind as ::treesitter_types::FromNode>::from_node(child, src)?
3229 },
3230 children: {
3231 #[allow(clippy::suspicious_else_formatting)]
3232 let non_field_children = {
3233 let mut cursor = node.walk();
3234 let mut result = ::std::vec::Vec::new();
3235 if cursor.goto_first_child() {
3236 loop {
3237 if cursor.field_name().is_none()
3238 && cursor.node().is_named()
3239 && !cursor.node().is_extra()
3240 {
3241 result.push(cursor.node());
3242 }
3243 if !cursor.goto_next_sibling() {
3244 break;
3245 }
3246 }
3247 }
3248 result
3249 };
3250 let mut items = ::std::vec::Vec::new();
3251 for child in non_field_children {
3252 items.push(
3253 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
3254 child, src,
3255 )?,
3256 );
3257 }
3258 items
3259 },
3260 })
3261 }
3262}
3263impl ::treesitter_types::Spanned for LexicalDeclaration<'_> {
3264 fn span(&self) -> ::treesitter_types::Span {
3265 self.span
3266 }
3267}
3268#[derive(Debug, Clone, PartialEq, Eq)]
3269pub struct MemberExpression<'tree> {
3270 pub span: ::treesitter_types::Span,
3271 pub object: MemberExpressionObject<'tree>,
3272 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
3273 pub property: MemberExpressionProperty<'tree>,
3274}
3275impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpression<'tree> {
3276 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3277 fn from_node(
3278 node: ::tree_sitter::Node<'tree>,
3279 src: &'tree [u8],
3280 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3281 debug_assert_eq!(node.kind(), "member_expression");
3282 Ok(Self {
3283 span: ::treesitter_types::Span::from(node),
3284 object: {
3285 let child = node
3286 .child_by_field_name("object")
3287 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
3288 <MemberExpressionObject as ::treesitter_types::FromNode>::from_node(child, src)?
3289 },
3290 optional_chain: match node.child_by_field_name("optional_chain") {
3291 Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
3292 child, src,
3293 )?),
3294 None => None,
3295 },
3296 property: {
3297 let child = node.child_by_field_name("property").ok_or_else(|| {
3298 ::treesitter_types::ParseError::missing_field("property", node)
3299 })?;
3300 <MemberExpressionProperty as ::treesitter_types::FromNode>::from_node(child, src)?
3301 },
3302 })
3303 }
3304}
3305impl ::treesitter_types::Spanned for MemberExpression<'_> {
3306 fn span(&self) -> ::treesitter_types::Span {
3307 self.span
3308 }
3309}
3310#[derive(Debug, Clone, PartialEq, Eq)]
3311pub struct MetaProperty<'tree> {
3312 pub span: ::treesitter_types::Span,
3313 text: &'tree str,
3314}
3315impl<'tree> ::treesitter_types::FromNode<'tree> for MetaProperty<'tree> {
3316 fn from_node(
3317 node: ::tree_sitter::Node<'tree>,
3318 src: &'tree [u8],
3319 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3320 debug_assert_eq!(node.kind(), "meta_property");
3321 Ok(Self {
3322 span: ::treesitter_types::Span::from(node),
3323 text: node.utf8_text(src)?,
3324 })
3325 }
3326}
3327impl<'tree> ::treesitter_types::LeafNode<'tree> for MetaProperty<'tree> {
3328 fn text(&self) -> &'tree str {
3329 self.text
3330 }
3331}
3332impl ::treesitter_types::Spanned for MetaProperty<'_> {
3333 fn span(&self) -> ::treesitter_types::Span {
3334 self.span
3335 }
3336}
3337#[derive(Debug, Clone, PartialEq, Eq)]
3338pub struct MethodDefinition<'tree> {
3339 pub span: ::treesitter_types::Span,
3340 pub body: StatementBlock<'tree>,
3341 pub decorator: ::std::vec::Vec<Decorator<'tree>>,
3342 pub name: MethodDefinitionName<'tree>,
3343 pub parameters: FormalParameters<'tree>,
3344}
3345impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinition<'tree> {
3346 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3347 fn from_node(
3348 node: ::tree_sitter::Node<'tree>,
3349 src: &'tree [u8],
3350 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3351 debug_assert_eq!(node.kind(), "method_definition");
3352 Ok(Self {
3353 span: ::treesitter_types::Span::from(node),
3354 body: {
3355 let child = node
3356 .child_by_field_name("body")
3357 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
3358 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
3359 },
3360 decorator: {
3361 let mut cursor = node.walk();
3362 let mut items = ::std::vec::Vec::new();
3363 for child in node.children_by_field_name("decorator", &mut cursor) {
3364 items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
3365 child, src,
3366 )?);
3367 }
3368 items
3369 },
3370 name: {
3371 let child = node
3372 .child_by_field_name("name")
3373 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
3374 <MethodDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)?
3375 },
3376 parameters: {
3377 let child = node.child_by_field_name("parameters").ok_or_else(|| {
3378 ::treesitter_types::ParseError::missing_field("parameters", node)
3379 })?;
3380 <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
3381 },
3382 })
3383 }
3384}
3385impl ::treesitter_types::Spanned for MethodDefinition<'_> {
3386 fn span(&self) -> ::treesitter_types::Span {
3387 self.span
3388 }
3389}
3390#[derive(Debug, Clone, PartialEq, Eq)]
3391pub struct NamedImports<'tree> {
3392 pub span: ::treesitter_types::Span,
3393 pub children: ::std::vec::Vec<ImportSpecifier<'tree>>,
3394}
3395impl<'tree> ::treesitter_types::FromNode<'tree> for NamedImports<'tree> {
3396 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3397 fn from_node(
3398 node: ::tree_sitter::Node<'tree>,
3399 src: &'tree [u8],
3400 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3401 debug_assert_eq!(node.kind(), "named_imports");
3402 Ok(Self {
3403 span: ::treesitter_types::Span::from(node),
3404 children: {
3405 #[allow(clippy::suspicious_else_formatting)]
3406 let non_field_children = {
3407 let mut cursor = node.walk();
3408 let mut result = ::std::vec::Vec::new();
3409 if cursor.goto_first_child() {
3410 loop {
3411 if cursor.field_name().is_none()
3412 && cursor.node().is_named()
3413 && !cursor.node().is_extra()
3414 {
3415 result.push(cursor.node());
3416 }
3417 if !cursor.goto_next_sibling() {
3418 break;
3419 }
3420 }
3421 }
3422 result
3423 };
3424 let mut items = ::std::vec::Vec::new();
3425 for child in non_field_children {
3426 items.push(
3427 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
3428 );
3429 }
3430 items
3431 },
3432 })
3433 }
3434}
3435impl ::treesitter_types::Spanned for NamedImports<'_> {
3436 fn span(&self) -> ::treesitter_types::Span {
3437 self.span
3438 }
3439}
3440#[derive(Debug, Clone, PartialEq, Eq)]
3441pub struct NamespaceExport<'tree> {
3442 pub span: ::treesitter_types::Span,
3443 pub children: ::core::option::Option<NamespaceExportChildren<'tree>>,
3444}
3445impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExport<'tree> {
3446 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3447 fn from_node(
3448 node: ::tree_sitter::Node<'tree>,
3449 src: &'tree [u8],
3450 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3451 debug_assert_eq!(node.kind(), "namespace_export");
3452 Ok(Self {
3453 span: ::treesitter_types::Span::from(node),
3454 children: {
3455 #[allow(clippy::suspicious_else_formatting)]
3456 let non_field_children = {
3457 let mut cursor = node.walk();
3458 let mut result = ::std::vec::Vec::new();
3459 if cursor.goto_first_child() {
3460 loop {
3461 if cursor.field_name().is_none()
3462 && cursor.node().is_named()
3463 && !cursor.node().is_extra()
3464 {
3465 result.push(cursor.node());
3466 }
3467 if !cursor.goto_next_sibling() {
3468 break;
3469 }
3470 }
3471 }
3472 result
3473 };
3474 match non_field_children.first() {
3475 Some(&child) => Some(
3476 <NamespaceExportChildren as ::treesitter_types::FromNode>::from_node(
3477 child, src,
3478 )?,
3479 ),
3480 None => None,
3481 }
3482 },
3483 })
3484 }
3485}
3486impl ::treesitter_types::Spanned for NamespaceExport<'_> {
3487 fn span(&self) -> ::treesitter_types::Span {
3488 self.span
3489 }
3490}
3491#[derive(Debug, Clone, PartialEq, Eq)]
3492pub struct NamespaceImport<'tree> {
3493 pub span: ::treesitter_types::Span,
3494 pub children: Identifier<'tree>,
3495}
3496impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceImport<'tree> {
3497 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3498 fn from_node(
3499 node: ::tree_sitter::Node<'tree>,
3500 src: &'tree [u8],
3501 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3502 debug_assert_eq!(node.kind(), "namespace_import");
3503 Ok(Self {
3504 span: ::treesitter_types::Span::from(node),
3505 children: {
3506 #[allow(clippy::suspicious_else_formatting)]
3507 let non_field_children = {
3508 let mut cursor = node.walk();
3509 let mut result = ::std::vec::Vec::new();
3510 if cursor.goto_first_child() {
3511 loop {
3512 if cursor.field_name().is_none()
3513 && cursor.node().is_named()
3514 && !cursor.node().is_extra()
3515 {
3516 result.push(cursor.node());
3517 }
3518 if !cursor.goto_next_sibling() {
3519 break;
3520 }
3521 }
3522 }
3523 result
3524 };
3525 let child = if let Some(&c) = non_field_children.first() {
3526 c
3527 } else {
3528 let mut fallback_cursor = node.walk();
3529 let mut fallback_child = None;
3530 if fallback_cursor.goto_first_child() {
3531 loop {
3532 if fallback_cursor.field_name().is_none()
3533 && !fallback_cursor.node().is_extra()
3534 {
3535 let candidate = fallback_cursor.node();
3536 #[allow(clippy::needless_question_mark)]
3537 if (|| -> ::core::result::Result<
3538 _,
3539 ::treesitter_types::ParseError,
3540 > {
3541 let child = candidate;
3542 Ok(
3543 <Identifier as ::treesitter_types::FromNode>::from_node(
3544 child,
3545 src,
3546 )?,
3547 )
3548 })()
3549 .is_ok()
3550 {
3551 fallback_child = Some(candidate);
3552 break;
3553 }
3554 }
3555 if !fallback_cursor.goto_next_sibling() {
3556 break;
3557 }
3558 }
3559 }
3560 if fallback_child.is_none() {
3561 let mut cursor2 = node.walk();
3562 if cursor2.goto_first_child() {
3563 loop {
3564 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3565 let candidate = cursor2.node();
3566 #[allow(clippy::needless_question_mark)]
3567 if (|| -> ::core::result::Result<
3568 _,
3569 ::treesitter_types::ParseError,
3570 > {
3571 let child = candidate;
3572 Ok(
3573 <Identifier as ::treesitter_types::FromNode>::from_node(
3574 child,
3575 src,
3576 )?,
3577 )
3578 })()
3579 .is_ok()
3580 {
3581 fallback_child = Some(candidate);
3582 break;
3583 }
3584 }
3585 if !cursor2.goto_next_sibling() {
3586 break;
3587 }
3588 }
3589 }
3590 }
3591 fallback_child.ok_or_else(|| {
3592 ::treesitter_types::ParseError::missing_field("children", node)
3593 })?
3594 };
3595 <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
3596 },
3597 })
3598 }
3599}
3600impl ::treesitter_types::Spanned for NamespaceImport<'_> {
3601 fn span(&self) -> ::treesitter_types::Span {
3602 self.span
3603 }
3604}
3605#[derive(Debug, Clone, PartialEq, Eq)]
3606pub struct NewExpression<'tree> {
3607 pub span: ::treesitter_types::Span,
3608 pub arguments: ::core::option::Option<Arguments<'tree>>,
3609 pub constructor: NewExpressionConstructor<'tree>,
3610}
3611impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
3612 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3613 fn from_node(
3614 node: ::tree_sitter::Node<'tree>,
3615 src: &'tree [u8],
3616 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3617 debug_assert_eq!(node.kind(), "new_expression");
3618 Ok(Self {
3619 span: ::treesitter_types::Span::from(node),
3620 arguments: match node.child_by_field_name("arguments") {
3621 Some(child) => Some(<Arguments as ::treesitter_types::FromNode>::from_node(
3622 child, src,
3623 )?),
3624 None => None,
3625 },
3626 constructor: {
3627 let child = node.child_by_field_name("constructor").ok_or_else(|| {
3628 ::treesitter_types::ParseError::missing_field("constructor", node)
3629 })?;
3630 <NewExpressionConstructor as ::treesitter_types::FromNode>::from_node(child, src)?
3631 },
3632 })
3633 }
3634}
3635impl ::treesitter_types::Spanned for NewExpression<'_> {
3636 fn span(&self) -> ::treesitter_types::Span {
3637 self.span
3638 }
3639}
3640#[derive(Debug, Clone, PartialEq, Eq)]
3641pub struct Object<'tree> {
3642 pub span: ::treesitter_types::Span,
3643 pub children: ::std::vec::Vec<ObjectChildren<'tree>>,
3644}
3645impl<'tree> ::treesitter_types::FromNode<'tree> for Object<'tree> {
3646 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3647 fn from_node(
3648 node: ::tree_sitter::Node<'tree>,
3649 src: &'tree [u8],
3650 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3651 debug_assert_eq!(node.kind(), "object");
3652 Ok(Self {
3653 span: ::treesitter_types::Span::from(node),
3654 children: {
3655 #[allow(clippy::suspicious_else_formatting)]
3656 let non_field_children = {
3657 let mut cursor = node.walk();
3658 let mut result = ::std::vec::Vec::new();
3659 if cursor.goto_first_child() {
3660 loop {
3661 if cursor.field_name().is_none()
3662 && cursor.node().is_named()
3663 && !cursor.node().is_extra()
3664 {
3665 result.push(cursor.node());
3666 }
3667 if !cursor.goto_next_sibling() {
3668 break;
3669 }
3670 }
3671 }
3672 result
3673 };
3674 let mut items = ::std::vec::Vec::new();
3675 for child in non_field_children {
3676 items.push(<ObjectChildren as ::treesitter_types::FromNode>::from_node(
3677 child, src,
3678 )?);
3679 }
3680 items
3681 },
3682 })
3683 }
3684}
3685impl ::treesitter_types::Spanned for Object<'_> {
3686 fn span(&self) -> ::treesitter_types::Span {
3687 self.span
3688 }
3689}
3690#[derive(Debug, Clone, PartialEq, Eq)]
3691pub struct ObjectAssignmentPattern<'tree> {
3692 pub span: ::treesitter_types::Span,
3693 pub left: ObjectAssignmentPatternLeft<'tree>,
3694 pub right: Expression<'tree>,
3695}
3696impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPattern<'tree> {
3697 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3698 fn from_node(
3699 node: ::tree_sitter::Node<'tree>,
3700 src: &'tree [u8],
3701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3702 debug_assert_eq!(node.kind(), "object_assignment_pattern");
3703 Ok(Self {
3704 span: ::treesitter_types::Span::from(node),
3705 left: {
3706 let child = node
3707 .child_by_field_name("left")
3708 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
3709 <ObjectAssignmentPatternLeft as ::treesitter_types::FromNode>::from_node(
3710 child, src,
3711 )?
3712 },
3713 right: {
3714 let child = node
3715 .child_by_field_name("right")
3716 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
3717 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3718 },
3719 })
3720 }
3721}
3722impl ::treesitter_types::Spanned for ObjectAssignmentPattern<'_> {
3723 fn span(&self) -> ::treesitter_types::Span {
3724 self.span
3725 }
3726}
3727#[derive(Debug, Clone, PartialEq, Eq)]
3728pub struct ObjectPattern<'tree> {
3729 pub span: ::treesitter_types::Span,
3730 pub children: ::std::vec::Vec<ObjectPatternChildren<'tree>>,
3731}
3732impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPattern<'tree> {
3733 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3734 fn from_node(
3735 node: ::tree_sitter::Node<'tree>,
3736 src: &'tree [u8],
3737 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3738 debug_assert_eq!(node.kind(), "object_pattern");
3739 Ok(Self {
3740 span: ::treesitter_types::Span::from(node),
3741 children: {
3742 #[allow(clippy::suspicious_else_formatting)]
3743 let non_field_children = {
3744 let mut cursor = node.walk();
3745 let mut result = ::std::vec::Vec::new();
3746 if cursor.goto_first_child() {
3747 loop {
3748 if cursor.field_name().is_none()
3749 && cursor.node().is_named()
3750 && !cursor.node().is_extra()
3751 {
3752 result.push(cursor.node());
3753 }
3754 if !cursor.goto_next_sibling() {
3755 break;
3756 }
3757 }
3758 }
3759 result
3760 };
3761 let mut items = ::std::vec::Vec::new();
3762 for child in non_field_children {
3763 items.push(
3764 <ObjectPatternChildren as ::treesitter_types::FromNode>::from_node(
3765 child, src,
3766 )?,
3767 );
3768 }
3769 items
3770 },
3771 })
3772 }
3773}
3774impl ::treesitter_types::Spanned for ObjectPattern<'_> {
3775 fn span(&self) -> ::treesitter_types::Span {
3776 self.span
3777 }
3778}
3779#[derive(Debug, Clone, PartialEq, Eq)]
3780pub struct Pair<'tree> {
3781 pub span: ::treesitter_types::Span,
3782 pub key: PairKey<'tree>,
3783 pub value: Expression<'tree>,
3784}
3785impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
3786 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3787 fn from_node(
3788 node: ::tree_sitter::Node<'tree>,
3789 src: &'tree [u8],
3790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3791 debug_assert_eq!(node.kind(), "pair");
3792 Ok(Self {
3793 span: ::treesitter_types::Span::from(node),
3794 key: {
3795 let child = node
3796 .child_by_field_name("key")
3797 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
3798 <PairKey as ::treesitter_types::FromNode>::from_node(child, src)?
3799 },
3800 value: {
3801 let child = node
3802 .child_by_field_name("value")
3803 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3804 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
3805 },
3806 })
3807 }
3808}
3809impl ::treesitter_types::Spanned for Pair<'_> {
3810 fn span(&self) -> ::treesitter_types::Span {
3811 self.span
3812 }
3813}
3814#[derive(Debug, Clone, PartialEq, Eq)]
3815pub struct PairPattern<'tree> {
3816 pub span: ::treesitter_types::Span,
3817 pub key: PairPatternKey<'tree>,
3818 pub value: PairPatternValue<'tree>,
3819}
3820impl<'tree> ::treesitter_types::FromNode<'tree> for PairPattern<'tree> {
3821 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3822 fn from_node(
3823 node: ::tree_sitter::Node<'tree>,
3824 src: &'tree [u8],
3825 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3826 debug_assert_eq!(node.kind(), "pair_pattern");
3827 Ok(Self {
3828 span: ::treesitter_types::Span::from(node),
3829 key: {
3830 let child = node
3831 .child_by_field_name("key")
3832 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
3833 <PairPatternKey as ::treesitter_types::FromNode>::from_node(child, src)?
3834 },
3835 value: {
3836 let child = node
3837 .child_by_field_name("value")
3838 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
3839 <PairPatternValue as ::treesitter_types::FromNode>::from_node(child, src)?
3840 },
3841 })
3842 }
3843}
3844impl ::treesitter_types::Spanned for PairPattern<'_> {
3845 fn span(&self) -> ::treesitter_types::Span {
3846 self.span
3847 }
3848}
3849#[derive(Debug, Clone, PartialEq, Eq)]
3850pub struct ParenthesizedExpression<'tree> {
3851 pub span: ::treesitter_types::Span,
3852 pub children: ParenthesizedExpressionChildren<'tree>,
3853}
3854impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
3855 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3856 fn from_node(
3857 node: ::tree_sitter::Node<'tree>,
3858 src: &'tree [u8],
3859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3860 debug_assert_eq!(node.kind(), "parenthesized_expression");
3861 Ok(Self {
3862 span: ::treesitter_types::Span::from(node),
3863 children: {
3864 #[allow(clippy::suspicious_else_formatting)]
3865 let non_field_children = {
3866 let mut cursor = node.walk();
3867 let mut result = ::std::vec::Vec::new();
3868 if cursor.goto_first_child() {
3869 loop {
3870 if cursor.field_name().is_none()
3871 && cursor.node().is_named()
3872 && !cursor.node().is_extra()
3873 {
3874 result.push(cursor.node());
3875 }
3876 if !cursor.goto_next_sibling() {
3877 break;
3878 }
3879 }
3880 }
3881 result
3882 };
3883 let child = if let Some(&c) = non_field_children.first() {
3884 c
3885 } else {
3886 let mut fallback_cursor = node.walk();
3887 let mut fallback_child = None;
3888 if fallback_cursor.goto_first_child() {
3889 loop {
3890 if fallback_cursor.field_name().is_none()
3891 && !fallback_cursor.node().is_extra()
3892 {
3893 let candidate = fallback_cursor.node();
3894 #[allow(clippy::needless_question_mark)]
3895 if (|| -> ::core::result::Result<
3896 _,
3897 ::treesitter_types::ParseError,
3898 > {
3899 let child = candidate;
3900 Ok(
3901 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
3902 child,
3903 src,
3904 )?,
3905 )
3906 })()
3907 .is_ok()
3908 {
3909 fallback_child = Some(candidate);
3910 break;
3911 }
3912 }
3913 if !fallback_cursor.goto_next_sibling() {
3914 break;
3915 }
3916 }
3917 }
3918 if fallback_child.is_none() {
3919 let mut cursor2 = node.walk();
3920 if cursor2.goto_first_child() {
3921 loop {
3922 if cursor2.node().is_named() && !cursor2.node().is_extra() {
3923 let candidate = cursor2.node();
3924 #[allow(clippy::needless_question_mark)]
3925 if (|| -> ::core::result::Result<
3926 _,
3927 ::treesitter_types::ParseError,
3928 > {
3929 let child = candidate;
3930 Ok(
3931 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
3932 child,
3933 src,
3934 )?,
3935 )
3936 })()
3937 .is_ok()
3938 {
3939 fallback_child = Some(candidate);
3940 break;
3941 }
3942 }
3943 if !cursor2.goto_next_sibling() {
3944 break;
3945 }
3946 }
3947 }
3948 }
3949 fallback_child.ok_or_else(|| {
3950 ::treesitter_types::ParseError::missing_field("children", node)
3951 })?
3952 };
3953 <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
3954 child, src,
3955 )?
3956 },
3957 })
3958 }
3959}
3960impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
3961 fn span(&self) -> ::treesitter_types::Span {
3962 self.span
3963 }
3964}
3965#[derive(Debug, Clone, PartialEq, Eq)]
3966pub struct Program<'tree> {
3967 pub span: ::treesitter_types::Span,
3968 pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
3969}
3970impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
3971 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
3972 fn from_node(
3973 node: ::tree_sitter::Node<'tree>,
3974 src: &'tree [u8],
3975 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3976 debug_assert_eq!(node.kind(), "program");
3977 Ok(Self {
3978 span: ::treesitter_types::Span::from(node),
3979 children: {
3980 #[allow(clippy::suspicious_else_formatting)]
3981 let non_field_children = {
3982 let mut cursor = node.walk();
3983 let mut result = ::std::vec::Vec::new();
3984 if cursor.goto_first_child() {
3985 loop {
3986 if cursor.field_name().is_none()
3987 && cursor.node().is_named()
3988 && !cursor.node().is_extra()
3989 {
3990 result.push(cursor.node());
3991 }
3992 if !cursor.goto_next_sibling() {
3993 break;
3994 }
3995 }
3996 }
3997 result
3998 };
3999 let mut items = ::std::vec::Vec::new();
4000 for child in non_field_children {
4001 items.push(
4002 <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
4003 );
4004 }
4005 items
4006 },
4007 })
4008 }
4009}
4010impl ::treesitter_types::Spanned for Program<'_> {
4011 fn span(&self) -> ::treesitter_types::Span {
4012 self.span
4013 }
4014}
4015#[derive(Debug, Clone, PartialEq, Eq)]
4016pub struct Regex<'tree> {
4017 pub span: ::treesitter_types::Span,
4018 pub flags: ::core::option::Option<RegexFlags<'tree>>,
4019 pub pattern: RegexPattern<'tree>,
4020}
4021impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
4022 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4023 fn from_node(
4024 node: ::tree_sitter::Node<'tree>,
4025 src: &'tree [u8],
4026 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4027 debug_assert_eq!(node.kind(), "regex");
4028 Ok(Self {
4029 span: ::treesitter_types::Span::from(node),
4030 flags: match node.child_by_field_name("flags") {
4031 Some(child) => Some(<RegexFlags as ::treesitter_types::FromNode>::from_node(
4032 child, src,
4033 )?),
4034 None => None,
4035 },
4036 pattern: {
4037 let child = node.child_by_field_name("pattern").ok_or_else(|| {
4038 ::treesitter_types::ParseError::missing_field("pattern", node)
4039 })?;
4040 <RegexPattern as ::treesitter_types::FromNode>::from_node(child, src)?
4041 },
4042 })
4043 }
4044}
4045impl ::treesitter_types::Spanned for Regex<'_> {
4046 fn span(&self) -> ::treesitter_types::Span {
4047 self.span
4048 }
4049}
4050#[derive(Debug, Clone, PartialEq, Eq)]
4051pub struct RestPattern<'tree> {
4052 pub span: ::treesitter_types::Span,
4053 pub children: RestPatternChildren<'tree>,
4054}
4055impl<'tree> ::treesitter_types::FromNode<'tree> for RestPattern<'tree> {
4056 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4057 fn from_node(
4058 node: ::tree_sitter::Node<'tree>,
4059 src: &'tree [u8],
4060 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4061 debug_assert_eq!(node.kind(), "rest_pattern");
4062 Ok(Self {
4063 span: ::treesitter_types::Span::from(node),
4064 children: {
4065 #[allow(clippy::suspicious_else_formatting)]
4066 let non_field_children = {
4067 let mut cursor = node.walk();
4068 let mut result = ::std::vec::Vec::new();
4069 if cursor.goto_first_child() {
4070 loop {
4071 if cursor.field_name().is_none()
4072 && cursor.node().is_named()
4073 && !cursor.node().is_extra()
4074 {
4075 result.push(cursor.node());
4076 }
4077 if !cursor.goto_next_sibling() {
4078 break;
4079 }
4080 }
4081 }
4082 result
4083 };
4084 let child = if let Some(&c) = non_field_children.first() {
4085 c
4086 } else {
4087 let mut fallback_cursor = node.walk();
4088 let mut fallback_child = None;
4089 if fallback_cursor.goto_first_child() {
4090 loop {
4091 if fallback_cursor.field_name().is_none()
4092 && !fallback_cursor.node().is_extra()
4093 {
4094 let candidate = fallback_cursor.node();
4095 #[allow(clippy::needless_question_mark)]
4096 if (|| -> ::core::result::Result<
4097 _,
4098 ::treesitter_types::ParseError,
4099 > {
4100 let child = candidate;
4101 Ok(
4102 <RestPatternChildren as ::treesitter_types::FromNode>::from_node(
4103 child,
4104 src,
4105 )?,
4106 )
4107 })()
4108 .is_ok()
4109 {
4110 fallback_child = Some(candidate);
4111 break;
4112 }
4113 }
4114 if !fallback_cursor.goto_next_sibling() {
4115 break;
4116 }
4117 }
4118 }
4119 if fallback_child.is_none() {
4120 let mut cursor2 = node.walk();
4121 if cursor2.goto_first_child() {
4122 loop {
4123 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4124 let candidate = cursor2.node();
4125 #[allow(clippy::needless_question_mark)]
4126 if (|| -> ::core::result::Result<
4127 _,
4128 ::treesitter_types::ParseError,
4129 > {
4130 let child = candidate;
4131 Ok(
4132 <RestPatternChildren as ::treesitter_types::FromNode>::from_node(
4133 child,
4134 src,
4135 )?,
4136 )
4137 })()
4138 .is_ok()
4139 {
4140 fallback_child = Some(candidate);
4141 break;
4142 }
4143 }
4144 if !cursor2.goto_next_sibling() {
4145 break;
4146 }
4147 }
4148 }
4149 }
4150 fallback_child.ok_or_else(|| {
4151 ::treesitter_types::ParseError::missing_field("children", node)
4152 })?
4153 };
4154 <RestPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4155 },
4156 })
4157 }
4158}
4159impl ::treesitter_types::Spanned for RestPattern<'_> {
4160 fn span(&self) -> ::treesitter_types::Span {
4161 self.span
4162 }
4163}
4164#[derive(Debug, Clone, PartialEq, Eq)]
4165pub struct ReturnStatement<'tree> {
4166 pub span: ::treesitter_types::Span,
4167 pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
4168}
4169impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
4170 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4171 fn from_node(
4172 node: ::tree_sitter::Node<'tree>,
4173 src: &'tree [u8],
4174 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4175 debug_assert_eq!(node.kind(), "return_statement");
4176 Ok(Self {
4177 span: ::treesitter_types::Span::from(node),
4178 children: {
4179 #[allow(clippy::suspicious_else_formatting)]
4180 let non_field_children = {
4181 let mut cursor = node.walk();
4182 let mut result = ::std::vec::Vec::new();
4183 if cursor.goto_first_child() {
4184 loop {
4185 if cursor.field_name().is_none()
4186 && cursor.node().is_named()
4187 && !cursor.node().is_extra()
4188 {
4189 result.push(cursor.node());
4190 }
4191 if !cursor.goto_next_sibling() {
4192 break;
4193 }
4194 }
4195 }
4196 result
4197 };
4198 match non_field_children.first() {
4199 Some(&child) => Some(
4200 <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
4201 child, src,
4202 )?,
4203 ),
4204 None => None,
4205 }
4206 },
4207 })
4208 }
4209}
4210impl ::treesitter_types::Spanned for ReturnStatement<'_> {
4211 fn span(&self) -> ::treesitter_types::Span {
4212 self.span
4213 }
4214}
4215#[derive(Debug, Clone, PartialEq, Eq)]
4216pub struct SequenceExpression<'tree> {
4217 pub span: ::treesitter_types::Span,
4218 pub children: ::std::vec::Vec<Expression<'tree>>,
4219}
4220impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
4221 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4222 fn from_node(
4223 node: ::tree_sitter::Node<'tree>,
4224 src: &'tree [u8],
4225 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4226 debug_assert_eq!(node.kind(), "sequence_expression");
4227 Ok(Self {
4228 span: ::treesitter_types::Span::from(node),
4229 children: {
4230 #[allow(clippy::suspicious_else_formatting)]
4231 let non_field_children = {
4232 let mut cursor = node.walk();
4233 let mut result = ::std::vec::Vec::new();
4234 if cursor.goto_first_child() {
4235 loop {
4236 if cursor.field_name().is_none()
4237 && cursor.node().is_named()
4238 && !cursor.node().is_extra()
4239 {
4240 result.push(cursor.node());
4241 }
4242 if !cursor.goto_next_sibling() {
4243 break;
4244 }
4245 }
4246 }
4247 result
4248 };
4249 let mut items = ::std::vec::Vec::new();
4250 for child in non_field_children {
4251 items.push(<Expression as ::treesitter_types::FromNode>::from_node(
4252 child, src,
4253 )?);
4254 }
4255 items
4256 },
4257 })
4258 }
4259}
4260impl ::treesitter_types::Spanned for SequenceExpression<'_> {
4261 fn span(&self) -> ::treesitter_types::Span {
4262 self.span
4263 }
4264}
4265#[derive(Debug, Clone, PartialEq, Eq)]
4266pub struct SpreadElement<'tree> {
4267 pub span: ::treesitter_types::Span,
4268 pub children: Expression<'tree>,
4269}
4270impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadElement<'tree> {
4271 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4272 fn from_node(
4273 node: ::tree_sitter::Node<'tree>,
4274 src: &'tree [u8],
4275 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4276 debug_assert_eq!(node.kind(), "spread_element");
4277 Ok(Self {
4278 span: ::treesitter_types::Span::from(node),
4279 children: {
4280 #[allow(clippy::suspicious_else_formatting)]
4281 let non_field_children = {
4282 let mut cursor = node.walk();
4283 let mut result = ::std::vec::Vec::new();
4284 if cursor.goto_first_child() {
4285 loop {
4286 if cursor.field_name().is_none()
4287 && cursor.node().is_named()
4288 && !cursor.node().is_extra()
4289 {
4290 result.push(cursor.node());
4291 }
4292 if !cursor.goto_next_sibling() {
4293 break;
4294 }
4295 }
4296 }
4297 result
4298 };
4299 let child = if let Some(&c) = non_field_children.first() {
4300 c
4301 } else {
4302 let mut fallback_cursor = node.walk();
4303 let mut fallback_child = None;
4304 if fallback_cursor.goto_first_child() {
4305 loop {
4306 if fallback_cursor.field_name().is_none()
4307 && !fallback_cursor.node().is_extra()
4308 {
4309 let candidate = fallback_cursor.node();
4310 #[allow(clippy::needless_question_mark)]
4311 if (|| -> ::core::result::Result<
4312 _,
4313 ::treesitter_types::ParseError,
4314 > {
4315 let child = candidate;
4316 Ok(
4317 <Expression as ::treesitter_types::FromNode>::from_node(
4318 child,
4319 src,
4320 )?,
4321 )
4322 })()
4323 .is_ok()
4324 {
4325 fallback_child = Some(candidate);
4326 break;
4327 }
4328 }
4329 if !fallback_cursor.goto_next_sibling() {
4330 break;
4331 }
4332 }
4333 }
4334 if fallback_child.is_none() {
4335 let mut cursor2 = node.walk();
4336 if cursor2.goto_first_child() {
4337 loop {
4338 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4339 let candidate = cursor2.node();
4340 #[allow(clippy::needless_question_mark)]
4341 if (|| -> ::core::result::Result<
4342 _,
4343 ::treesitter_types::ParseError,
4344 > {
4345 let child = candidate;
4346 Ok(
4347 <Expression as ::treesitter_types::FromNode>::from_node(
4348 child,
4349 src,
4350 )?,
4351 )
4352 })()
4353 .is_ok()
4354 {
4355 fallback_child = Some(candidate);
4356 break;
4357 }
4358 }
4359 if !cursor2.goto_next_sibling() {
4360 break;
4361 }
4362 }
4363 }
4364 }
4365 fallback_child.ok_or_else(|| {
4366 ::treesitter_types::ParseError::missing_field("children", node)
4367 })?
4368 };
4369 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4370 },
4371 })
4372 }
4373}
4374impl ::treesitter_types::Spanned for SpreadElement<'_> {
4375 fn span(&self) -> ::treesitter_types::Span {
4376 self.span
4377 }
4378}
4379#[derive(Debug, Clone, PartialEq, Eq)]
4380pub struct StatementBlock<'tree> {
4381 pub span: ::treesitter_types::Span,
4382 pub children: ::std::vec::Vec<Statement<'tree>>,
4383}
4384impl<'tree> ::treesitter_types::FromNode<'tree> for StatementBlock<'tree> {
4385 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4386 fn from_node(
4387 node: ::tree_sitter::Node<'tree>,
4388 src: &'tree [u8],
4389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4390 debug_assert_eq!(node.kind(), "statement_block");
4391 Ok(Self {
4392 span: ::treesitter_types::Span::from(node),
4393 children: {
4394 #[allow(clippy::suspicious_else_formatting)]
4395 let non_field_children = {
4396 let mut cursor = node.walk();
4397 let mut result = ::std::vec::Vec::new();
4398 if cursor.goto_first_child() {
4399 loop {
4400 if cursor.field_name().is_none()
4401 && cursor.node().is_named()
4402 && !cursor.node().is_extra()
4403 {
4404 result.push(cursor.node());
4405 }
4406 if !cursor.goto_next_sibling() {
4407 break;
4408 }
4409 }
4410 }
4411 result
4412 };
4413 let mut items = ::std::vec::Vec::new();
4414 for child in non_field_children {
4415 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
4416 child, src,
4417 )?);
4418 }
4419 items
4420 },
4421 })
4422 }
4423}
4424impl ::treesitter_types::Spanned for StatementBlock<'_> {
4425 fn span(&self) -> ::treesitter_types::Span {
4426 self.span
4427 }
4428}
4429#[derive(Debug, Clone, PartialEq, Eq)]
4430pub struct String<'tree> {
4431 pub span: ::treesitter_types::Span,
4432 pub children: ::std::vec::Vec<StringChildren<'tree>>,
4433}
4434impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
4435 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4436 fn from_node(
4437 node: ::tree_sitter::Node<'tree>,
4438 src: &'tree [u8],
4439 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4440 debug_assert_eq!(node.kind(), "string");
4441 Ok(Self {
4442 span: ::treesitter_types::Span::from(node),
4443 children: {
4444 #[allow(clippy::suspicious_else_formatting)]
4445 let non_field_children = {
4446 let mut cursor = node.walk();
4447 let mut result = ::std::vec::Vec::new();
4448 if cursor.goto_first_child() {
4449 loop {
4450 if cursor.field_name().is_none()
4451 && cursor.node().is_named()
4452 && !cursor.node().is_extra()
4453 {
4454 result.push(cursor.node());
4455 }
4456 if !cursor.goto_next_sibling() {
4457 break;
4458 }
4459 }
4460 }
4461 result
4462 };
4463 let mut items = ::std::vec::Vec::new();
4464 for child in non_field_children {
4465 items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
4466 child, src,
4467 )?);
4468 }
4469 items
4470 },
4471 })
4472 }
4473}
4474impl ::treesitter_types::Spanned for String<'_> {
4475 fn span(&self) -> ::treesitter_types::Span {
4476 self.span
4477 }
4478}
4479#[derive(Debug, Clone, PartialEq, Eq)]
4480pub struct SubscriptExpression<'tree> {
4481 pub span: ::treesitter_types::Span,
4482 pub index: SubscriptExpressionIndex<'tree>,
4483 pub object: Expression<'tree>,
4484 pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
4485}
4486impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
4487 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4488 fn from_node(
4489 node: ::tree_sitter::Node<'tree>,
4490 src: &'tree [u8],
4491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4492 debug_assert_eq!(node.kind(), "subscript_expression");
4493 Ok(Self {
4494 span: ::treesitter_types::Span::from(node),
4495 index: {
4496 let child = node
4497 .child_by_field_name("index")
4498 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
4499 <SubscriptExpressionIndex as ::treesitter_types::FromNode>::from_node(child, src)?
4500 },
4501 object: {
4502 let child = node
4503 .child_by_field_name("object")
4504 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
4505 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4506 },
4507 optional_chain: match node.child_by_field_name("optional_chain") {
4508 Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
4509 child, src,
4510 )?),
4511 None => None,
4512 },
4513 })
4514 }
4515}
4516impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
4517 fn span(&self) -> ::treesitter_types::Span {
4518 self.span
4519 }
4520}
4521#[derive(Debug, Clone, PartialEq, Eq)]
4522pub struct SwitchBody<'tree> {
4523 pub span: ::treesitter_types::Span,
4524 pub children: ::std::vec::Vec<SwitchBodyChildren<'tree>>,
4525}
4526impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
4527 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4528 fn from_node(
4529 node: ::tree_sitter::Node<'tree>,
4530 src: &'tree [u8],
4531 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4532 debug_assert_eq!(node.kind(), "switch_body");
4533 Ok(Self {
4534 span: ::treesitter_types::Span::from(node),
4535 children: {
4536 #[allow(clippy::suspicious_else_formatting)]
4537 let non_field_children = {
4538 let mut cursor = node.walk();
4539 let mut result = ::std::vec::Vec::new();
4540 if cursor.goto_first_child() {
4541 loop {
4542 if cursor.field_name().is_none()
4543 && cursor.node().is_named()
4544 && !cursor.node().is_extra()
4545 {
4546 result.push(cursor.node());
4547 }
4548 if !cursor.goto_next_sibling() {
4549 break;
4550 }
4551 }
4552 }
4553 result
4554 };
4555 let mut items = ::std::vec::Vec::new();
4556 for child in non_field_children {
4557 items.push(
4558 <SwitchBodyChildren as ::treesitter_types::FromNode>::from_node(
4559 child, src,
4560 )?,
4561 );
4562 }
4563 items
4564 },
4565 })
4566 }
4567}
4568impl ::treesitter_types::Spanned for SwitchBody<'_> {
4569 fn span(&self) -> ::treesitter_types::Span {
4570 self.span
4571 }
4572}
4573#[derive(Debug, Clone, PartialEq, Eq)]
4574pub struct SwitchCase<'tree> {
4575 pub span: ::treesitter_types::Span,
4576 pub body: ::std::vec::Vec<Statement<'tree>>,
4577 pub value: SwitchCaseValue<'tree>,
4578}
4579impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCase<'tree> {
4580 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4581 fn from_node(
4582 node: ::tree_sitter::Node<'tree>,
4583 src: &'tree [u8],
4584 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4585 debug_assert_eq!(node.kind(), "switch_case");
4586 Ok(Self {
4587 span: ::treesitter_types::Span::from(node),
4588 body: {
4589 let mut cursor = node.walk();
4590 let mut items = ::std::vec::Vec::new();
4591 for child in node.children_by_field_name("body", &mut cursor) {
4592 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
4593 child, src,
4594 )?);
4595 }
4596 items
4597 },
4598 value: {
4599 let child = node
4600 .child_by_field_name("value")
4601 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4602 <SwitchCaseValue as ::treesitter_types::FromNode>::from_node(child, src)?
4603 },
4604 })
4605 }
4606}
4607impl ::treesitter_types::Spanned for SwitchCase<'_> {
4608 fn span(&self) -> ::treesitter_types::Span {
4609 self.span
4610 }
4611}
4612#[derive(Debug, Clone, PartialEq, Eq)]
4613pub struct SwitchDefault<'tree> {
4614 pub span: ::treesitter_types::Span,
4615 pub body: ::std::vec::Vec<Statement<'tree>>,
4616}
4617impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchDefault<'tree> {
4618 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4619 fn from_node(
4620 node: ::tree_sitter::Node<'tree>,
4621 src: &'tree [u8],
4622 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4623 debug_assert_eq!(node.kind(), "switch_default");
4624 Ok(Self {
4625 span: ::treesitter_types::Span::from(node),
4626 body: {
4627 let mut cursor = node.walk();
4628 let mut items = ::std::vec::Vec::new();
4629 for child in node.children_by_field_name("body", &mut cursor) {
4630 items.push(<Statement as ::treesitter_types::FromNode>::from_node(
4631 child, src,
4632 )?);
4633 }
4634 items
4635 },
4636 })
4637 }
4638}
4639impl ::treesitter_types::Spanned for SwitchDefault<'_> {
4640 fn span(&self) -> ::treesitter_types::Span {
4641 self.span
4642 }
4643}
4644#[derive(Debug, Clone, PartialEq, Eq)]
4645pub struct SwitchStatement<'tree> {
4646 pub span: ::treesitter_types::Span,
4647 pub body: SwitchBody<'tree>,
4648 pub value: ParenthesizedExpression<'tree>,
4649}
4650impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
4651 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4652 fn from_node(
4653 node: ::tree_sitter::Node<'tree>,
4654 src: &'tree [u8],
4655 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4656 debug_assert_eq!(node.kind(), "switch_statement");
4657 Ok(Self {
4658 span: ::treesitter_types::Span::from(node),
4659 body: {
4660 let child = node
4661 .child_by_field_name("body")
4662 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
4663 <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)?
4664 },
4665 value: {
4666 let child = node
4667 .child_by_field_name("value")
4668 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
4669 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
4670 },
4671 })
4672 }
4673}
4674impl ::treesitter_types::Spanned for SwitchStatement<'_> {
4675 fn span(&self) -> ::treesitter_types::Span {
4676 self.span
4677 }
4678}
4679#[derive(Debug, Clone, PartialEq, Eq)]
4680pub struct TemplateString<'tree> {
4681 pub span: ::treesitter_types::Span,
4682 pub children: ::std::vec::Vec<TemplateStringChildren<'tree>>,
4683}
4684impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateString<'tree> {
4685 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4686 fn from_node(
4687 node: ::tree_sitter::Node<'tree>,
4688 src: &'tree [u8],
4689 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4690 debug_assert_eq!(node.kind(), "template_string");
4691 Ok(Self {
4692 span: ::treesitter_types::Span::from(node),
4693 children: {
4694 #[allow(clippy::suspicious_else_formatting)]
4695 let non_field_children = {
4696 let mut cursor = node.walk();
4697 let mut result = ::std::vec::Vec::new();
4698 if cursor.goto_first_child() {
4699 loop {
4700 if cursor.field_name().is_none()
4701 && cursor.node().is_named()
4702 && !cursor.node().is_extra()
4703 {
4704 result.push(cursor.node());
4705 }
4706 if !cursor.goto_next_sibling() {
4707 break;
4708 }
4709 }
4710 }
4711 result
4712 };
4713 let mut items = ::std::vec::Vec::new();
4714 for child in non_field_children {
4715 items.push(
4716 <TemplateStringChildren as ::treesitter_types::FromNode>::from_node(
4717 child, src,
4718 )?,
4719 );
4720 }
4721 items
4722 },
4723 })
4724 }
4725}
4726impl ::treesitter_types::Spanned for TemplateString<'_> {
4727 fn span(&self) -> ::treesitter_types::Span {
4728 self.span
4729 }
4730}
4731#[derive(Debug, Clone, PartialEq, Eq)]
4732pub struct TemplateSubstitution<'tree> {
4733 pub span: ::treesitter_types::Span,
4734 pub children: TemplateSubstitutionChildren<'tree>,
4735}
4736impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitution<'tree> {
4737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4738 fn from_node(
4739 node: ::tree_sitter::Node<'tree>,
4740 src: &'tree [u8],
4741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4742 debug_assert_eq!(node.kind(), "template_substitution");
4743 Ok(Self {
4744 span: ::treesitter_types::Span::from(node),
4745 children: {
4746 #[allow(clippy::suspicious_else_formatting)]
4747 let non_field_children = {
4748 let mut cursor = node.walk();
4749 let mut result = ::std::vec::Vec::new();
4750 if cursor.goto_first_child() {
4751 loop {
4752 if cursor.field_name().is_none()
4753 && cursor.node().is_named()
4754 && !cursor.node().is_extra()
4755 {
4756 result.push(cursor.node());
4757 }
4758 if !cursor.goto_next_sibling() {
4759 break;
4760 }
4761 }
4762 }
4763 result
4764 };
4765 let child = if let Some(&c) = non_field_children.first() {
4766 c
4767 } else {
4768 let mut fallback_cursor = node.walk();
4769 let mut fallback_child = None;
4770 if fallback_cursor.goto_first_child() {
4771 loop {
4772 if fallback_cursor.field_name().is_none()
4773 && !fallback_cursor.node().is_extra()
4774 {
4775 let candidate = fallback_cursor.node();
4776 #[allow(clippy::needless_question_mark)]
4777 if (|| -> ::core::result::Result<
4778 _,
4779 ::treesitter_types::ParseError,
4780 > {
4781 let child = candidate;
4782 Ok(
4783 <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
4784 child,
4785 src,
4786 )?,
4787 )
4788 })()
4789 .is_ok()
4790 {
4791 fallback_child = Some(candidate);
4792 break;
4793 }
4794 }
4795 if !fallback_cursor.goto_next_sibling() {
4796 break;
4797 }
4798 }
4799 }
4800 if fallback_child.is_none() {
4801 let mut cursor2 = node.walk();
4802 if cursor2.goto_first_child() {
4803 loop {
4804 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4805 let candidate = cursor2.node();
4806 #[allow(clippy::needless_question_mark)]
4807 if (|| -> ::core::result::Result<
4808 _,
4809 ::treesitter_types::ParseError,
4810 > {
4811 let child = candidate;
4812 Ok(
4813 <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
4814 child,
4815 src,
4816 )?,
4817 )
4818 })()
4819 .is_ok()
4820 {
4821 fallback_child = Some(candidate);
4822 break;
4823 }
4824 }
4825 if !cursor2.goto_next_sibling() {
4826 break;
4827 }
4828 }
4829 }
4830 }
4831 fallback_child.ok_or_else(|| {
4832 ::treesitter_types::ParseError::missing_field("children", node)
4833 })?
4834 };
4835 <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
4836 child, src,
4837 )?
4838 },
4839 })
4840 }
4841}
4842impl ::treesitter_types::Spanned for TemplateSubstitution<'_> {
4843 fn span(&self) -> ::treesitter_types::Span {
4844 self.span
4845 }
4846}
4847#[derive(Debug, Clone, PartialEq, Eq)]
4848pub struct TernaryExpression<'tree> {
4849 pub span: ::treesitter_types::Span,
4850 pub alternative: Expression<'tree>,
4851 pub condition: Expression<'tree>,
4852 pub consequence: Expression<'tree>,
4853}
4854impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
4855 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4856 fn from_node(
4857 node: ::tree_sitter::Node<'tree>,
4858 src: &'tree [u8],
4859 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4860 debug_assert_eq!(node.kind(), "ternary_expression");
4861 Ok(Self {
4862 span: ::treesitter_types::Span::from(node),
4863 alternative: {
4864 let child = node.child_by_field_name("alternative").ok_or_else(|| {
4865 ::treesitter_types::ParseError::missing_field("alternative", node)
4866 })?;
4867 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4868 },
4869 condition: {
4870 let child = node.child_by_field_name("condition").ok_or_else(|| {
4871 ::treesitter_types::ParseError::missing_field("condition", node)
4872 })?;
4873 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4874 },
4875 consequence: {
4876 let child = node.child_by_field_name("consequence").ok_or_else(|| {
4877 ::treesitter_types::ParseError::missing_field("consequence", node)
4878 })?;
4879 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
4880 },
4881 })
4882 }
4883}
4884impl ::treesitter_types::Spanned for TernaryExpression<'_> {
4885 fn span(&self) -> ::treesitter_types::Span {
4886 self.span
4887 }
4888}
4889#[derive(Debug, Clone, PartialEq, Eq)]
4890pub struct ThrowStatement<'tree> {
4891 pub span: ::treesitter_types::Span,
4892 pub children: ThrowStatementChildren<'tree>,
4893}
4894impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
4895 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
4896 fn from_node(
4897 node: ::tree_sitter::Node<'tree>,
4898 src: &'tree [u8],
4899 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4900 debug_assert_eq!(node.kind(), "throw_statement");
4901 Ok(Self {
4902 span: ::treesitter_types::Span::from(node),
4903 children: {
4904 #[allow(clippy::suspicious_else_formatting)]
4905 let non_field_children = {
4906 let mut cursor = node.walk();
4907 let mut result = ::std::vec::Vec::new();
4908 if cursor.goto_first_child() {
4909 loop {
4910 if cursor.field_name().is_none()
4911 && cursor.node().is_named()
4912 && !cursor.node().is_extra()
4913 {
4914 result.push(cursor.node());
4915 }
4916 if !cursor.goto_next_sibling() {
4917 break;
4918 }
4919 }
4920 }
4921 result
4922 };
4923 let child = if let Some(&c) = non_field_children.first() {
4924 c
4925 } else {
4926 let mut fallback_cursor = node.walk();
4927 let mut fallback_child = None;
4928 if fallback_cursor.goto_first_child() {
4929 loop {
4930 if fallback_cursor.field_name().is_none()
4931 && !fallback_cursor.node().is_extra()
4932 {
4933 let candidate = fallback_cursor.node();
4934 #[allow(clippy::needless_question_mark)]
4935 if (|| -> ::core::result::Result<
4936 _,
4937 ::treesitter_types::ParseError,
4938 > {
4939 let child = candidate;
4940 Ok(
4941 <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(
4942 child,
4943 src,
4944 )?,
4945 )
4946 })()
4947 .is_ok()
4948 {
4949 fallback_child = Some(candidate);
4950 break;
4951 }
4952 }
4953 if !fallback_cursor.goto_next_sibling() {
4954 break;
4955 }
4956 }
4957 }
4958 if fallback_child.is_none() {
4959 let mut cursor2 = node.walk();
4960 if cursor2.goto_first_child() {
4961 loop {
4962 if cursor2.node().is_named() && !cursor2.node().is_extra() {
4963 let candidate = cursor2.node();
4964 #[allow(clippy::needless_question_mark)]
4965 if (|| -> ::core::result::Result<
4966 _,
4967 ::treesitter_types::ParseError,
4968 > {
4969 let child = candidate;
4970 Ok(
4971 <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(
4972 child,
4973 src,
4974 )?,
4975 )
4976 })()
4977 .is_ok()
4978 {
4979 fallback_child = Some(candidate);
4980 break;
4981 }
4982 }
4983 if !cursor2.goto_next_sibling() {
4984 break;
4985 }
4986 }
4987 }
4988 }
4989 fallback_child.ok_or_else(|| {
4990 ::treesitter_types::ParseError::missing_field("children", node)
4991 })?
4992 };
4993 <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
4994 },
4995 })
4996 }
4997}
4998impl ::treesitter_types::Spanned for ThrowStatement<'_> {
4999 fn span(&self) -> ::treesitter_types::Span {
5000 self.span
5001 }
5002}
5003#[derive(Debug, Clone, PartialEq, Eq)]
5004pub struct TryStatement<'tree> {
5005 pub span: ::treesitter_types::Span,
5006 pub body: StatementBlock<'tree>,
5007 pub finalizer: ::core::option::Option<FinallyClause<'tree>>,
5008 pub handler: ::core::option::Option<CatchClause<'tree>>,
5009}
5010impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
5011 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5012 fn from_node(
5013 node: ::tree_sitter::Node<'tree>,
5014 src: &'tree [u8],
5015 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5016 debug_assert_eq!(node.kind(), "try_statement");
5017 Ok(Self {
5018 span: ::treesitter_types::Span::from(node),
5019 body: {
5020 let child = node
5021 .child_by_field_name("body")
5022 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5023 <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
5024 },
5025 finalizer: match node.child_by_field_name("finalizer") {
5026 Some(child) => Some(<FinallyClause as ::treesitter_types::FromNode>::from_node(
5027 child, src,
5028 )?),
5029 None => None,
5030 },
5031 handler: match node.child_by_field_name("handler") {
5032 Some(child) => Some(<CatchClause as ::treesitter_types::FromNode>::from_node(
5033 child, src,
5034 )?),
5035 None => None,
5036 },
5037 })
5038 }
5039}
5040impl ::treesitter_types::Spanned for TryStatement<'_> {
5041 fn span(&self) -> ::treesitter_types::Span {
5042 self.span
5043 }
5044}
5045#[derive(Debug, Clone, PartialEq, Eq)]
5046pub struct UnaryExpression<'tree> {
5047 pub span: ::treesitter_types::Span,
5048 pub argument: Expression<'tree>,
5049 pub operator: UnaryExpressionOperator,
5050}
5051impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
5052 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5053 fn from_node(
5054 node: ::tree_sitter::Node<'tree>,
5055 src: &'tree [u8],
5056 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5057 debug_assert_eq!(node.kind(), "unary_expression");
5058 Ok(Self {
5059 span: ::treesitter_types::Span::from(node),
5060 argument: {
5061 let child = node.child_by_field_name("argument").ok_or_else(|| {
5062 ::treesitter_types::ParseError::missing_field("argument", node)
5063 })?;
5064 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5065 },
5066 operator: {
5067 let child = node.child_by_field_name("operator").ok_or_else(|| {
5068 ::treesitter_types::ParseError::missing_field("operator", node)
5069 })?;
5070 <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
5071 },
5072 })
5073 }
5074}
5075impl ::treesitter_types::Spanned for UnaryExpression<'_> {
5076 fn span(&self) -> ::treesitter_types::Span {
5077 self.span
5078 }
5079}
5080#[derive(Debug, Clone, PartialEq, Eq)]
5081pub struct UpdateExpression<'tree> {
5082 pub span: ::treesitter_types::Span,
5083 pub argument: Expression<'tree>,
5084 pub operator: UpdateExpressionOperator,
5085}
5086impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
5087 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5088 fn from_node(
5089 node: ::tree_sitter::Node<'tree>,
5090 src: &'tree [u8],
5091 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5092 debug_assert_eq!(node.kind(), "update_expression");
5093 Ok(Self {
5094 span: ::treesitter_types::Span::from(node),
5095 argument: {
5096 let child = node.child_by_field_name("argument").ok_or_else(|| {
5097 ::treesitter_types::ParseError::missing_field("argument", node)
5098 })?;
5099 <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
5100 },
5101 operator: {
5102 let child = node.child_by_field_name("operator").ok_or_else(|| {
5103 ::treesitter_types::ParseError::missing_field("operator", node)
5104 })?;
5105 <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
5106 },
5107 })
5108 }
5109}
5110impl ::treesitter_types::Spanned for UpdateExpression<'_> {
5111 fn span(&self) -> ::treesitter_types::Span {
5112 self.span
5113 }
5114}
5115#[derive(Debug, Clone, PartialEq, Eq)]
5116pub struct UsingDeclaration<'tree> {
5117 pub span: ::treesitter_types::Span,
5118 pub kind: ::std::vec::Vec<UsingDeclarationKind>,
5119 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
5120}
5121impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclaration<'tree> {
5122 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5123 fn from_node(
5124 node: ::tree_sitter::Node<'tree>,
5125 src: &'tree [u8],
5126 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5127 debug_assert_eq!(node.kind(), "using_declaration");
5128 Ok(Self {
5129 span: ::treesitter_types::Span::from(node),
5130 kind: {
5131 let mut cursor = node.walk();
5132 let mut items = ::std::vec::Vec::new();
5133 for child in node.children_by_field_name("kind", &mut cursor) {
5134 items.push(
5135 <UsingDeclarationKind as ::treesitter_types::FromNode>::from_node(
5136 child, src,
5137 )?,
5138 );
5139 }
5140 items
5141 },
5142 children: {
5143 #[allow(clippy::suspicious_else_formatting)]
5144 let non_field_children = {
5145 let mut cursor = node.walk();
5146 let mut result = ::std::vec::Vec::new();
5147 if cursor.goto_first_child() {
5148 loop {
5149 if cursor.field_name().is_none()
5150 && cursor.node().is_named()
5151 && !cursor.node().is_extra()
5152 {
5153 result.push(cursor.node());
5154 }
5155 if !cursor.goto_next_sibling() {
5156 break;
5157 }
5158 }
5159 }
5160 result
5161 };
5162 let mut items = ::std::vec::Vec::new();
5163 for child in non_field_children {
5164 items.push(
5165 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
5166 child, src,
5167 )?,
5168 );
5169 }
5170 items
5171 },
5172 })
5173 }
5174}
5175impl ::treesitter_types::Spanned for UsingDeclaration<'_> {
5176 fn span(&self) -> ::treesitter_types::Span {
5177 self.span
5178 }
5179}
5180#[derive(Debug, Clone, PartialEq, Eq)]
5181pub struct VariableDeclaration<'tree> {
5182 pub span: ::treesitter_types::Span,
5183 pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
5184}
5185impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
5186 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5187 fn from_node(
5188 node: ::tree_sitter::Node<'tree>,
5189 src: &'tree [u8],
5190 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5191 debug_assert_eq!(node.kind(), "variable_declaration");
5192 Ok(Self {
5193 span: ::treesitter_types::Span::from(node),
5194 children: {
5195 #[allow(clippy::suspicious_else_formatting)]
5196 let non_field_children = {
5197 let mut cursor = node.walk();
5198 let mut result = ::std::vec::Vec::new();
5199 if cursor.goto_first_child() {
5200 loop {
5201 if cursor.field_name().is_none()
5202 && cursor.node().is_named()
5203 && !cursor.node().is_extra()
5204 {
5205 result.push(cursor.node());
5206 }
5207 if !cursor.goto_next_sibling() {
5208 break;
5209 }
5210 }
5211 }
5212 result
5213 };
5214 let mut items = ::std::vec::Vec::new();
5215 for child in non_field_children {
5216 items.push(
5217 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
5218 child, src,
5219 )?,
5220 );
5221 }
5222 items
5223 },
5224 })
5225 }
5226}
5227impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
5228 fn span(&self) -> ::treesitter_types::Span {
5229 self.span
5230 }
5231}
5232#[derive(Debug, Clone, PartialEq, Eq)]
5233pub struct VariableDeclarator<'tree> {
5234 pub span: ::treesitter_types::Span,
5235 pub name: VariableDeclaratorName<'tree>,
5236 pub value: ::core::option::Option<Expression<'tree>>,
5237}
5238impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
5239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5240 fn from_node(
5241 node: ::tree_sitter::Node<'tree>,
5242 src: &'tree [u8],
5243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5244 debug_assert_eq!(node.kind(), "variable_declarator");
5245 Ok(Self {
5246 span: ::treesitter_types::Span::from(node),
5247 name: {
5248 let child = node
5249 .child_by_field_name("name")
5250 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
5251 <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)?
5252 },
5253 value: match node.child_by_field_name("value") {
5254 Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5255 child, src,
5256 )?),
5257 None => None,
5258 },
5259 })
5260 }
5261}
5262impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
5263 fn span(&self) -> ::treesitter_types::Span {
5264 self.span
5265 }
5266}
5267#[derive(Debug, Clone, PartialEq, Eq)]
5268pub struct WhileStatement<'tree> {
5269 pub span: ::treesitter_types::Span,
5270 pub body: Statement<'tree>,
5271 pub condition: ParenthesizedExpression<'tree>,
5272}
5273impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
5274 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5275 fn from_node(
5276 node: ::tree_sitter::Node<'tree>,
5277 src: &'tree [u8],
5278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5279 debug_assert_eq!(node.kind(), "while_statement");
5280 Ok(Self {
5281 span: ::treesitter_types::Span::from(node),
5282 body: {
5283 let child = node
5284 .child_by_field_name("body")
5285 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5286 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5287 },
5288 condition: {
5289 let child = node.child_by_field_name("condition").ok_or_else(|| {
5290 ::treesitter_types::ParseError::missing_field("condition", node)
5291 })?;
5292 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5293 },
5294 })
5295 }
5296}
5297impl ::treesitter_types::Spanned for WhileStatement<'_> {
5298 fn span(&self) -> ::treesitter_types::Span {
5299 self.span
5300 }
5301}
5302#[derive(Debug, Clone, PartialEq, Eq)]
5303pub struct WithStatement<'tree> {
5304 pub span: ::treesitter_types::Span,
5305 pub body: Statement<'tree>,
5306 pub object: ParenthesizedExpression<'tree>,
5307}
5308impl<'tree> ::treesitter_types::FromNode<'tree> for WithStatement<'tree> {
5309 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5310 fn from_node(
5311 node: ::tree_sitter::Node<'tree>,
5312 src: &'tree [u8],
5313 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5314 debug_assert_eq!(node.kind(), "with_statement");
5315 Ok(Self {
5316 span: ::treesitter_types::Span::from(node),
5317 body: {
5318 let child = node
5319 .child_by_field_name("body")
5320 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
5321 <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
5322 },
5323 object: {
5324 let child = node
5325 .child_by_field_name("object")
5326 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
5327 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
5328 },
5329 })
5330 }
5331}
5332impl ::treesitter_types::Spanned for WithStatement<'_> {
5333 fn span(&self) -> ::treesitter_types::Span {
5334 self.span
5335 }
5336}
5337#[derive(Debug, Clone, PartialEq, Eq)]
5338pub struct YieldExpression<'tree> {
5339 pub span: ::treesitter_types::Span,
5340 pub children: ::core::option::Option<Expression<'tree>>,
5341}
5342impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
5343 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
5344 fn from_node(
5345 node: ::tree_sitter::Node<'tree>,
5346 src: &'tree [u8],
5347 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5348 debug_assert_eq!(node.kind(), "yield_expression");
5349 Ok(Self {
5350 span: ::treesitter_types::Span::from(node),
5351 children: {
5352 #[allow(clippy::suspicious_else_formatting)]
5353 let non_field_children = {
5354 let mut cursor = node.walk();
5355 let mut result = ::std::vec::Vec::new();
5356 if cursor.goto_first_child() {
5357 loop {
5358 if cursor.field_name().is_none()
5359 && cursor.node().is_named()
5360 && !cursor.node().is_extra()
5361 {
5362 result.push(cursor.node());
5363 }
5364 if !cursor.goto_next_sibling() {
5365 break;
5366 }
5367 }
5368 }
5369 result
5370 };
5371 match non_field_children.first() {
5372 Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
5373 child, src,
5374 )?),
5375 None => None,
5376 }
5377 },
5378 })
5379 }
5380}
5381impl ::treesitter_types::Spanned for YieldExpression<'_> {
5382 fn span(&self) -> ::treesitter_types::Span {
5383 self.span
5384 }
5385}
5386#[derive(Debug, Clone, PartialEq, Eq)]
5387pub struct Comment<'tree> {
5388 pub span: ::treesitter_types::Span,
5389 text: &'tree str,
5390}
5391impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
5392 fn from_node(
5393 node: ::tree_sitter::Node<'tree>,
5394 src: &'tree [u8],
5395 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5396 debug_assert_eq!(node.kind(), "comment");
5397 Ok(Self {
5398 span: ::treesitter_types::Span::from(node),
5399 text: node.utf8_text(src)?,
5400 })
5401 }
5402}
5403impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
5404 fn text(&self) -> &'tree str {
5405 self.text
5406 }
5407}
5408impl ::treesitter_types::Spanned for Comment<'_> {
5409 fn span(&self) -> ::treesitter_types::Span {
5410 self.span
5411 }
5412}
5413#[derive(Debug, Clone, PartialEq, Eq)]
5414pub struct EscapeSequence<'tree> {
5415 pub span: ::treesitter_types::Span,
5416 text: &'tree str,
5417}
5418impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
5419 fn from_node(
5420 node: ::tree_sitter::Node<'tree>,
5421 src: &'tree [u8],
5422 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5423 debug_assert_eq!(node.kind(), "escape_sequence");
5424 Ok(Self {
5425 span: ::treesitter_types::Span::from(node),
5426 text: node.utf8_text(src)?,
5427 })
5428 }
5429}
5430impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
5431 fn text(&self) -> &'tree str {
5432 self.text
5433 }
5434}
5435impl ::treesitter_types::Spanned for EscapeSequence<'_> {
5436 fn span(&self) -> ::treesitter_types::Span {
5437 self.span
5438 }
5439}
5440#[derive(Debug, Clone, PartialEq, Eq)]
5441pub struct False<'tree> {
5442 pub span: ::treesitter_types::Span,
5443 text: &'tree str,
5444}
5445impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
5446 fn from_node(
5447 node: ::tree_sitter::Node<'tree>,
5448 src: &'tree [u8],
5449 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5450 debug_assert_eq!(node.kind(), "false");
5451 Ok(Self {
5452 span: ::treesitter_types::Span::from(node),
5453 text: node.utf8_text(src)?,
5454 })
5455 }
5456}
5457impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
5458 fn text(&self) -> &'tree str {
5459 self.text
5460 }
5461}
5462impl ::treesitter_types::Spanned for False<'_> {
5463 fn span(&self) -> ::treesitter_types::Span {
5464 self.span
5465 }
5466}
5467#[derive(Debug, Clone, PartialEq, Eq)]
5468pub struct HashBangLine<'tree> {
5469 pub span: ::treesitter_types::Span,
5470 text: &'tree str,
5471}
5472impl<'tree> ::treesitter_types::FromNode<'tree> for HashBangLine<'tree> {
5473 fn from_node(
5474 node: ::tree_sitter::Node<'tree>,
5475 src: &'tree [u8],
5476 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5477 debug_assert_eq!(node.kind(), "hash_bang_line");
5478 Ok(Self {
5479 span: ::treesitter_types::Span::from(node),
5480 text: node.utf8_text(src)?,
5481 })
5482 }
5483}
5484impl<'tree> ::treesitter_types::LeafNode<'tree> for HashBangLine<'tree> {
5485 fn text(&self) -> &'tree str {
5486 self.text
5487 }
5488}
5489impl ::treesitter_types::Spanned for HashBangLine<'_> {
5490 fn span(&self) -> ::treesitter_types::Span {
5491 self.span
5492 }
5493}
5494#[derive(Debug, Clone, PartialEq, Eq)]
5495pub struct HtmlCharacterReference<'tree> {
5496 pub span: ::treesitter_types::Span,
5497 text: &'tree str,
5498}
5499impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlCharacterReference<'tree> {
5500 fn from_node(
5501 node: ::tree_sitter::Node<'tree>,
5502 src: &'tree [u8],
5503 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5504 debug_assert_eq!(node.kind(), "html_character_reference");
5505 Ok(Self {
5506 span: ::treesitter_types::Span::from(node),
5507 text: node.utf8_text(src)?,
5508 })
5509 }
5510}
5511impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlCharacterReference<'tree> {
5512 fn text(&self) -> &'tree str {
5513 self.text
5514 }
5515}
5516impl ::treesitter_types::Spanned for HtmlCharacterReference<'_> {
5517 fn span(&self) -> ::treesitter_types::Span {
5518 self.span
5519 }
5520}
5521#[derive(Debug, Clone, PartialEq, Eq)]
5522pub struct HtmlComment<'tree> {
5523 pub span: ::treesitter_types::Span,
5524 text: &'tree str,
5525}
5526impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlComment<'tree> {
5527 fn from_node(
5528 node: ::tree_sitter::Node<'tree>,
5529 src: &'tree [u8],
5530 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5531 debug_assert_eq!(node.kind(), "html_comment");
5532 Ok(Self {
5533 span: ::treesitter_types::Span::from(node),
5534 text: node.utf8_text(src)?,
5535 })
5536 }
5537}
5538impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlComment<'tree> {
5539 fn text(&self) -> &'tree str {
5540 self.text
5541 }
5542}
5543impl ::treesitter_types::Spanned for HtmlComment<'_> {
5544 fn span(&self) -> ::treesitter_types::Span {
5545 self.span
5546 }
5547}
5548#[derive(Debug, Clone, PartialEq, Eq)]
5549pub struct Identifier<'tree> {
5550 pub span: ::treesitter_types::Span,
5551 text: &'tree str,
5552}
5553impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
5554 fn from_node(
5555 node: ::tree_sitter::Node<'tree>,
5556 src: &'tree [u8],
5557 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5558 debug_assert_eq!(node.kind(), "identifier");
5559 Ok(Self {
5560 span: ::treesitter_types::Span::from(node),
5561 text: node.utf8_text(src)?,
5562 })
5563 }
5564}
5565impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
5566 fn text(&self) -> &'tree str {
5567 self.text
5568 }
5569}
5570impl ::treesitter_types::Spanned for Identifier<'_> {
5571 fn span(&self) -> ::treesitter_types::Span {
5572 self.span
5573 }
5574}
5575#[derive(Debug, Clone, PartialEq, Eq)]
5576pub struct JsxText<'tree> {
5577 pub span: ::treesitter_types::Span,
5578 text: &'tree str,
5579}
5580impl<'tree> ::treesitter_types::FromNode<'tree> for JsxText<'tree> {
5581 fn from_node(
5582 node: ::tree_sitter::Node<'tree>,
5583 src: &'tree [u8],
5584 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5585 debug_assert_eq!(node.kind(), "jsx_text");
5586 Ok(Self {
5587 span: ::treesitter_types::Span::from(node),
5588 text: node.utf8_text(src)?,
5589 })
5590 }
5591}
5592impl<'tree> ::treesitter_types::LeafNode<'tree> for JsxText<'tree> {
5593 fn text(&self) -> &'tree str {
5594 self.text
5595 }
5596}
5597impl ::treesitter_types::Spanned for JsxText<'_> {
5598 fn span(&self) -> ::treesitter_types::Span {
5599 self.span
5600 }
5601}
5602#[derive(Debug, Clone, PartialEq, Eq)]
5603pub struct Null<'tree> {
5604 pub span: ::treesitter_types::Span,
5605 text: &'tree str,
5606}
5607impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
5608 fn from_node(
5609 node: ::tree_sitter::Node<'tree>,
5610 src: &'tree [u8],
5611 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5612 debug_assert_eq!(node.kind(), "null");
5613 Ok(Self {
5614 span: ::treesitter_types::Span::from(node),
5615 text: node.utf8_text(src)?,
5616 })
5617 }
5618}
5619impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
5620 fn text(&self) -> &'tree str {
5621 self.text
5622 }
5623}
5624impl ::treesitter_types::Spanned for Null<'_> {
5625 fn span(&self) -> ::treesitter_types::Span {
5626 self.span
5627 }
5628}
5629#[derive(Debug, Clone, PartialEq, Eq)]
5630pub struct Number<'tree> {
5631 pub span: ::treesitter_types::Span,
5632 text: &'tree str,
5633}
5634impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
5635 fn from_node(
5636 node: ::tree_sitter::Node<'tree>,
5637 src: &'tree [u8],
5638 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5639 debug_assert_eq!(node.kind(), "number");
5640 Ok(Self {
5641 span: ::treesitter_types::Span::from(node),
5642 text: node.utf8_text(src)?,
5643 })
5644 }
5645}
5646impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
5647 fn text(&self) -> &'tree str {
5648 self.text
5649 }
5650}
5651impl ::treesitter_types::Spanned for Number<'_> {
5652 fn span(&self) -> ::treesitter_types::Span {
5653 self.span
5654 }
5655}
5656#[derive(Debug, Clone, PartialEq, Eq)]
5657pub struct OptionalChain<'tree> {
5658 pub span: ::treesitter_types::Span,
5659 text: &'tree str,
5660}
5661impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalChain<'tree> {
5662 fn from_node(
5663 node: ::tree_sitter::Node<'tree>,
5664 src: &'tree [u8],
5665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5666 debug_assert_eq!(node.kind(), "optional_chain");
5667 Ok(Self {
5668 span: ::treesitter_types::Span::from(node),
5669 text: node.utf8_text(src)?,
5670 })
5671 }
5672}
5673impl<'tree> ::treesitter_types::LeafNode<'tree> for OptionalChain<'tree> {
5674 fn text(&self) -> &'tree str {
5675 self.text
5676 }
5677}
5678impl ::treesitter_types::Spanned for OptionalChain<'_> {
5679 fn span(&self) -> ::treesitter_types::Span {
5680 self.span
5681 }
5682}
5683#[derive(Debug, Clone, PartialEq, Eq)]
5684pub struct PrivatePropertyIdentifier<'tree> {
5685 pub span: ::treesitter_types::Span,
5686 text: &'tree str,
5687}
5688impl<'tree> ::treesitter_types::FromNode<'tree> for PrivatePropertyIdentifier<'tree> {
5689 fn from_node(
5690 node: ::tree_sitter::Node<'tree>,
5691 src: &'tree [u8],
5692 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5693 debug_assert_eq!(node.kind(), "private_property_identifier");
5694 Ok(Self {
5695 span: ::treesitter_types::Span::from(node),
5696 text: node.utf8_text(src)?,
5697 })
5698 }
5699}
5700impl<'tree> ::treesitter_types::LeafNode<'tree> for PrivatePropertyIdentifier<'tree> {
5701 fn text(&self) -> &'tree str {
5702 self.text
5703 }
5704}
5705impl ::treesitter_types::Spanned for PrivatePropertyIdentifier<'_> {
5706 fn span(&self) -> ::treesitter_types::Span {
5707 self.span
5708 }
5709}
5710#[derive(Debug, Clone, PartialEq, Eq)]
5711pub struct PropertyIdentifier<'tree> {
5712 pub span: ::treesitter_types::Span,
5713 text: &'tree str,
5714}
5715impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyIdentifier<'tree> {
5716 fn from_node(
5717 node: ::tree_sitter::Node<'tree>,
5718 src: &'tree [u8],
5719 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5720 debug_assert_eq!(node.kind(), "property_identifier");
5721 Ok(Self {
5722 span: ::treesitter_types::Span::from(node),
5723 text: node.utf8_text(src)?,
5724 })
5725 }
5726}
5727impl<'tree> ::treesitter_types::LeafNode<'tree> for PropertyIdentifier<'tree> {
5728 fn text(&self) -> &'tree str {
5729 self.text
5730 }
5731}
5732impl ::treesitter_types::Spanned for PropertyIdentifier<'_> {
5733 fn span(&self) -> ::treesitter_types::Span {
5734 self.span
5735 }
5736}
5737#[derive(Debug, Clone, PartialEq, Eq)]
5738pub struct RegexFlags<'tree> {
5739 pub span: ::treesitter_types::Span,
5740 text: &'tree str,
5741}
5742impl<'tree> ::treesitter_types::FromNode<'tree> for RegexFlags<'tree> {
5743 fn from_node(
5744 node: ::tree_sitter::Node<'tree>,
5745 src: &'tree [u8],
5746 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5747 debug_assert_eq!(node.kind(), "regex_flags");
5748 Ok(Self {
5749 span: ::treesitter_types::Span::from(node),
5750 text: node.utf8_text(src)?,
5751 })
5752 }
5753}
5754impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexFlags<'tree> {
5755 fn text(&self) -> &'tree str {
5756 self.text
5757 }
5758}
5759impl ::treesitter_types::Spanned for RegexFlags<'_> {
5760 fn span(&self) -> ::treesitter_types::Span {
5761 self.span
5762 }
5763}
5764#[derive(Debug, Clone, PartialEq, Eq)]
5765pub struct RegexPattern<'tree> {
5766 pub span: ::treesitter_types::Span,
5767 text: &'tree str,
5768}
5769impl<'tree> ::treesitter_types::FromNode<'tree> for RegexPattern<'tree> {
5770 fn from_node(
5771 node: ::tree_sitter::Node<'tree>,
5772 src: &'tree [u8],
5773 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5774 debug_assert_eq!(node.kind(), "regex_pattern");
5775 Ok(Self {
5776 span: ::treesitter_types::Span::from(node),
5777 text: node.utf8_text(src)?,
5778 })
5779 }
5780}
5781impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexPattern<'tree> {
5782 fn text(&self) -> &'tree str {
5783 self.text
5784 }
5785}
5786impl ::treesitter_types::Spanned for RegexPattern<'_> {
5787 fn span(&self) -> ::treesitter_types::Span {
5788 self.span
5789 }
5790}
5791#[derive(Debug, Clone, PartialEq, Eq)]
5792pub struct ShorthandPropertyIdentifier<'tree> {
5793 pub span: ::treesitter_types::Span,
5794 text: &'tree str,
5795}
5796impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifier<'tree> {
5797 fn from_node(
5798 node: ::tree_sitter::Node<'tree>,
5799 src: &'tree [u8],
5800 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5801 debug_assert_eq!(node.kind(), "shorthand_property_identifier");
5802 Ok(Self {
5803 span: ::treesitter_types::Span::from(node),
5804 text: node.utf8_text(src)?,
5805 })
5806 }
5807}
5808impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifier<'tree> {
5809 fn text(&self) -> &'tree str {
5810 self.text
5811 }
5812}
5813impl ::treesitter_types::Spanned for ShorthandPropertyIdentifier<'_> {
5814 fn span(&self) -> ::treesitter_types::Span {
5815 self.span
5816 }
5817}
5818#[derive(Debug, Clone, PartialEq, Eq)]
5819pub struct ShorthandPropertyIdentifierPattern<'tree> {
5820 pub span: ::treesitter_types::Span,
5821 text: &'tree str,
5822}
5823impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
5824 fn from_node(
5825 node: ::tree_sitter::Node<'tree>,
5826 src: &'tree [u8],
5827 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5828 debug_assert_eq!(node.kind(), "shorthand_property_identifier_pattern");
5829 Ok(Self {
5830 span: ::treesitter_types::Span::from(node),
5831 text: node.utf8_text(src)?,
5832 })
5833 }
5834}
5835impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
5836 fn text(&self) -> &'tree str {
5837 self.text
5838 }
5839}
5840impl ::treesitter_types::Spanned for ShorthandPropertyIdentifierPattern<'_> {
5841 fn span(&self) -> ::treesitter_types::Span {
5842 self.span
5843 }
5844}
5845#[derive(Debug, Clone, PartialEq, Eq)]
5846pub struct StatementIdentifier<'tree> {
5847 pub span: ::treesitter_types::Span,
5848 text: &'tree str,
5849}
5850impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
5851 fn from_node(
5852 node: ::tree_sitter::Node<'tree>,
5853 src: &'tree [u8],
5854 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5855 debug_assert_eq!(node.kind(), "statement_identifier");
5856 Ok(Self {
5857 span: ::treesitter_types::Span::from(node),
5858 text: node.utf8_text(src)?,
5859 })
5860 }
5861}
5862impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
5863 fn text(&self) -> &'tree str {
5864 self.text
5865 }
5866}
5867impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
5868 fn span(&self) -> ::treesitter_types::Span {
5869 self.span
5870 }
5871}
5872#[derive(Debug, Clone, PartialEq, Eq)]
5873pub struct StringFragment<'tree> {
5874 pub span: ::treesitter_types::Span,
5875 text: &'tree str,
5876}
5877impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
5878 fn from_node(
5879 node: ::tree_sitter::Node<'tree>,
5880 src: &'tree [u8],
5881 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5882 debug_assert_eq!(node.kind(), "string_fragment");
5883 Ok(Self {
5884 span: ::treesitter_types::Span::from(node),
5885 text: node.utf8_text(src)?,
5886 })
5887 }
5888}
5889impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
5890 fn text(&self) -> &'tree str {
5891 self.text
5892 }
5893}
5894impl ::treesitter_types::Spanned for StringFragment<'_> {
5895 fn span(&self) -> ::treesitter_types::Span {
5896 self.span
5897 }
5898}
5899#[derive(Debug, Clone, PartialEq, Eq)]
5900pub struct Super<'tree> {
5901 pub span: ::treesitter_types::Span,
5902 text: &'tree str,
5903}
5904impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
5905 fn from_node(
5906 node: ::tree_sitter::Node<'tree>,
5907 src: &'tree [u8],
5908 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5909 debug_assert_eq!(node.kind(), "super");
5910 Ok(Self {
5911 span: ::treesitter_types::Span::from(node),
5912 text: node.utf8_text(src)?,
5913 })
5914 }
5915}
5916impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
5917 fn text(&self) -> &'tree str {
5918 self.text
5919 }
5920}
5921impl ::treesitter_types::Spanned for Super<'_> {
5922 fn span(&self) -> ::treesitter_types::Span {
5923 self.span
5924 }
5925}
5926#[derive(Debug, Clone, PartialEq, Eq)]
5927pub struct This<'tree> {
5928 pub span: ::treesitter_types::Span,
5929 text: &'tree str,
5930}
5931impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
5932 fn from_node(
5933 node: ::tree_sitter::Node<'tree>,
5934 src: &'tree [u8],
5935 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5936 debug_assert_eq!(node.kind(), "this");
5937 Ok(Self {
5938 span: ::treesitter_types::Span::from(node),
5939 text: node.utf8_text(src)?,
5940 })
5941 }
5942}
5943impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
5944 fn text(&self) -> &'tree str {
5945 self.text
5946 }
5947}
5948impl ::treesitter_types::Spanned for This<'_> {
5949 fn span(&self) -> ::treesitter_types::Span {
5950 self.span
5951 }
5952}
5953#[derive(Debug, Clone, PartialEq, Eq)]
5954pub struct True<'tree> {
5955 pub span: ::treesitter_types::Span,
5956 text: &'tree str,
5957}
5958impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
5959 fn from_node(
5960 node: ::tree_sitter::Node<'tree>,
5961 src: &'tree [u8],
5962 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5963 debug_assert_eq!(node.kind(), "true");
5964 Ok(Self {
5965 span: ::treesitter_types::Span::from(node),
5966 text: node.utf8_text(src)?,
5967 })
5968 }
5969}
5970impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
5971 fn text(&self) -> &'tree str {
5972 self.text
5973 }
5974}
5975impl ::treesitter_types::Spanned for True<'_> {
5976 fn span(&self) -> ::treesitter_types::Span {
5977 self.span
5978 }
5979}
5980#[derive(Debug, Clone, PartialEq, Eq)]
5981pub struct Undefined<'tree> {
5982 pub span: ::treesitter_types::Span,
5983 text: &'tree str,
5984}
5985impl<'tree> ::treesitter_types::FromNode<'tree> for Undefined<'tree> {
5986 fn from_node(
5987 node: ::tree_sitter::Node<'tree>,
5988 src: &'tree [u8],
5989 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5990 debug_assert_eq!(node.kind(), "undefined");
5991 Ok(Self {
5992 span: ::treesitter_types::Span::from(node),
5993 text: node.utf8_text(src)?,
5994 })
5995 }
5996}
5997impl<'tree> ::treesitter_types::LeafNode<'tree> for Undefined<'tree> {
5998 fn text(&self) -> &'tree str {
5999 self.text
6000 }
6001}
6002impl ::treesitter_types::Spanned for Undefined<'_> {
6003 fn span(&self) -> ::treesitter_types::Span {
6004 self.span
6005 }
6006}
6007#[derive(Debug, Clone, PartialEq, Eq)]
6008pub enum ArgumentsChildren<'tree> {
6009 Expression(::std::boxed::Box<Expression<'tree>>),
6010 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
6011}
6012impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
6013 #[allow(clippy::collapsible_else_if)]
6014 fn from_node(
6015 node: ::tree_sitter::Node<'tree>,
6016 src: &'tree [u8],
6017 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6018 match node.kind() {
6019 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
6020 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
6021 ))),
6022 _other => {
6023 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6024 Ok(Self::Expression(::std::boxed::Box::new(v)))
6025 } else {
6026 Err(::treesitter_types::ParseError::unexpected_kind(
6027 _other, node,
6028 ))
6029 }
6030 }
6031 }
6032 }
6033}
6034impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
6035 fn span(&self) -> ::treesitter_types::Span {
6036 match self {
6037 Self::Expression(inner) => inner.span(),
6038 Self::SpreadElement(inner) => inner.span(),
6039 }
6040 }
6041}
6042#[derive(Debug, Clone, PartialEq, Eq)]
6043pub enum ArrayChildren<'tree> {
6044 Expression(::std::boxed::Box<Expression<'tree>>),
6045 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
6046}
6047impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
6048 #[allow(clippy::collapsible_else_if)]
6049 fn from_node(
6050 node: ::tree_sitter::Node<'tree>,
6051 src: &'tree [u8],
6052 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6053 match node.kind() {
6054 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
6055 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
6056 ))),
6057 _other => {
6058 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6059 Ok(Self::Expression(::std::boxed::Box::new(v)))
6060 } else {
6061 Err(::treesitter_types::ParseError::unexpected_kind(
6062 _other, node,
6063 ))
6064 }
6065 }
6066 }
6067 }
6068}
6069impl ::treesitter_types::Spanned for ArrayChildren<'_> {
6070 fn span(&self) -> ::treesitter_types::Span {
6071 match self {
6072 Self::Expression(inner) => inner.span(),
6073 Self::SpreadElement(inner) => inner.span(),
6074 }
6075 }
6076}
6077#[derive(Debug, Clone, PartialEq, Eq)]
6078pub enum ArrayPatternChildren<'tree> {
6079 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
6080 Pattern(::std::boxed::Box<Pattern<'tree>>),
6081}
6082impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
6083 #[allow(clippy::collapsible_else_if)]
6084 fn from_node(
6085 node: ::tree_sitter::Node<'tree>,
6086 src: &'tree [u8],
6087 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6088 match node.kind() {
6089 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
6090 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6091 ))),
6092 _other => {
6093 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
6094 Ok(Self::Pattern(::std::boxed::Box::new(v)))
6095 } else {
6096 Err(::treesitter_types::ParseError::unexpected_kind(
6097 _other, node,
6098 ))
6099 }
6100 }
6101 }
6102 }
6103}
6104impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
6105 fn span(&self) -> ::treesitter_types::Span {
6106 match self {
6107 Self::AssignmentPattern(inner) => inner.span(),
6108 Self::Pattern(inner) => inner.span(),
6109 }
6110 }
6111}
6112#[derive(Debug, Clone, PartialEq, Eq)]
6113pub enum ArrowFunctionBody<'tree> {
6114 Expression(::std::boxed::Box<Expression<'tree>>),
6115 StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
6116}
6117impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionBody<'tree> {
6118 #[allow(clippy::collapsible_else_if)]
6119 fn from_node(
6120 node: ::tree_sitter::Node<'tree>,
6121 src: &'tree [u8],
6122 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6123 match node.kind() {
6124 "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
6125 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
6126 ))),
6127 _other => {
6128 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6129 Ok(Self::Expression(::std::boxed::Box::new(v)))
6130 } else {
6131 Err(::treesitter_types::ParseError::unexpected_kind(
6132 _other, node,
6133 ))
6134 }
6135 }
6136 }
6137 }
6138}
6139impl ::treesitter_types::Spanned for ArrowFunctionBody<'_> {
6140 fn span(&self) -> ::treesitter_types::Span {
6141 match self {
6142 Self::Expression(inner) => inner.span(),
6143 Self::StatementBlock(inner) => inner.span(),
6144 }
6145 }
6146}
6147#[derive(Debug, Clone, PartialEq, Eq)]
6148pub enum AssignmentExpressionLeft<'tree> {
6149 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
6150 Identifier(::std::boxed::Box<Identifier<'tree>>),
6151 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6152 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
6153 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
6154 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
6155 Undefined(::std::boxed::Box<Undefined<'tree>>),
6156}
6157impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
6158 #[allow(clippy::collapsible_else_if)]
6159 fn from_node(
6160 node: ::tree_sitter::Node<'tree>,
6161 src: &'tree [u8],
6162 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6163 match node.kind() {
6164 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
6165 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6166 ))),
6167 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6168 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6169 ))),
6170 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6171 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6172 ))),
6173 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
6174 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6175 ))),
6176 "parenthesized_expression" => {
6177 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
6178 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
6179 node, src,
6180 )?,
6181 )))
6182 }
6183 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
6184 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6185 ))),
6186 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
6187 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
6188 ))),
6189 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6190 }
6191 }
6192}
6193impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
6194 fn span(&self) -> ::treesitter_types::Span {
6195 match self {
6196 Self::ArrayPattern(inner) => inner.span(),
6197 Self::Identifier(inner) => inner.span(),
6198 Self::MemberExpression(inner) => inner.span(),
6199 Self::ObjectPattern(inner) => inner.span(),
6200 Self::ParenthesizedExpression(inner) => inner.span(),
6201 Self::SubscriptExpression(inner) => inner.span(),
6202 Self::Undefined(inner) => inner.span(),
6203 }
6204 }
6205}
6206#[derive(Debug, Clone, PartialEq, Eq)]
6207pub enum AugmentedAssignmentExpressionLeft<'tree> {
6208 Identifier(::std::boxed::Box<Identifier<'tree>>),
6209 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6210 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
6211 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
6212}
6213impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
6214 #[allow(clippy::collapsible_else_if)]
6215 fn from_node(
6216 node: ::tree_sitter::Node<'tree>,
6217 src: &'tree [u8],
6218 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6219 match node.kind() {
6220 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6221 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6222 ))),
6223 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6224 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6225 ))),
6226 "parenthesized_expression" => {
6227 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
6228 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
6229 node, src,
6230 )?,
6231 )))
6232 }
6233 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
6234 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6235 ))),
6236 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6237 }
6238 }
6239}
6240impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
6241 fn span(&self) -> ::treesitter_types::Span {
6242 match self {
6243 Self::Identifier(inner) => inner.span(),
6244 Self::MemberExpression(inner) => inner.span(),
6245 Self::ParenthesizedExpression(inner) => inner.span(),
6246 Self::SubscriptExpression(inner) => inner.span(),
6247 }
6248 }
6249}
6250#[derive(Debug, Clone, PartialEq, Eq)]
6251pub enum AugmentedAssignmentExpressionOperator {
6252 PercentEq(::treesitter_types::Span),
6253 AmpAmpEq(::treesitter_types::Span),
6254 AmpEq(::treesitter_types::Span),
6255 StarStarEq(::treesitter_types::Span),
6256 StarEq(::treesitter_types::Span),
6257 PlusEq(::treesitter_types::Span),
6258 MinusEq(::treesitter_types::Span),
6259 SlashEq(::treesitter_types::Span),
6260 ShlEq(::treesitter_types::Span),
6261 ShrEq(::treesitter_types::Span),
6262 GtGtGtEq(::treesitter_types::Span),
6263 QuestionQuestionEq(::treesitter_types::Span),
6264 CaretEq(::treesitter_types::Span),
6265 PipeEq(::treesitter_types::Span),
6266 PipePipeEq(::treesitter_types::Span),
6267}
6268impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
6269 #[allow(clippy::collapsible_else_if)]
6270 fn from_node(
6271 node: ::tree_sitter::Node<'tree>,
6272 _src: &'tree [u8],
6273 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6274 match node.kind() {
6275 "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
6276 "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
6277 "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
6278 "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
6279 "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
6280 "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
6281 "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
6282 "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
6283 "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
6284 ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
6285 ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
6286 "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
6287 node,
6288 ))),
6289 "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
6290 "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
6291 "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
6292 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6293 }
6294 }
6295}
6296impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
6297 fn span(&self) -> ::treesitter_types::Span {
6298 match self {
6299 Self::PercentEq(span) => *span,
6300 Self::AmpAmpEq(span) => *span,
6301 Self::AmpEq(span) => *span,
6302 Self::StarStarEq(span) => *span,
6303 Self::StarEq(span) => *span,
6304 Self::PlusEq(span) => *span,
6305 Self::MinusEq(span) => *span,
6306 Self::SlashEq(span) => *span,
6307 Self::ShlEq(span) => *span,
6308 Self::ShrEq(span) => *span,
6309 Self::GtGtGtEq(span) => *span,
6310 Self::QuestionQuestionEq(span) => *span,
6311 Self::CaretEq(span) => *span,
6312 Self::PipeEq(span) => *span,
6313 Self::PipePipeEq(span) => *span,
6314 }
6315 }
6316}
6317#[derive(Debug, Clone, PartialEq, Eq)]
6318pub enum BinaryExpressionLeft<'tree> {
6319 Expression(::std::boxed::Box<Expression<'tree>>),
6320 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
6321}
6322impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
6323 #[allow(clippy::collapsible_else_if)]
6324 fn from_node(
6325 node: ::tree_sitter::Node<'tree>,
6326 src: &'tree [u8],
6327 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6328 match node.kind() {
6329 "private_property_identifier" => {
6330 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
6331 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
6332 node, src,
6333 )?,
6334 )))
6335 }
6336 _other => {
6337 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6338 Ok(Self::Expression(::std::boxed::Box::new(v)))
6339 } else {
6340 Err(::treesitter_types::ParseError::unexpected_kind(
6341 _other, node,
6342 ))
6343 }
6344 }
6345 }
6346 }
6347}
6348impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
6349 fn span(&self) -> ::treesitter_types::Span {
6350 match self {
6351 Self::Expression(inner) => inner.span(),
6352 Self::PrivatePropertyIdentifier(inner) => inner.span(),
6353 }
6354 }
6355}
6356#[derive(Debug, Clone, PartialEq, Eq)]
6357pub enum BinaryExpressionOperator {
6358 NotEq(::treesitter_types::Span),
6359 BangEqEq(::treesitter_types::Span),
6360 Percent(::treesitter_types::Span),
6361 Amp(::treesitter_types::Span),
6362 AmpAmp(::treesitter_types::Span),
6363 Star(::treesitter_types::Span),
6364 StarStar(::treesitter_types::Span),
6365 Plus(::treesitter_types::Span),
6366 Minus(::treesitter_types::Span),
6367 Slash(::treesitter_types::Span),
6368 Lt(::treesitter_types::Span),
6369 Shl(::treesitter_types::Span),
6370 LtEq(::treesitter_types::Span),
6371 EqEq(::treesitter_types::Span),
6372 EqEqEq(::treesitter_types::Span),
6373 Gt(::treesitter_types::Span),
6374 GtEq(::treesitter_types::Span),
6375 Shr(::treesitter_types::Span),
6376 GtGtGt(::treesitter_types::Span),
6377 QuestionQuestion(::treesitter_types::Span),
6378 Caret(::treesitter_types::Span),
6379 In(::treesitter_types::Span),
6380 Instanceof(::treesitter_types::Span),
6381 Pipe(::treesitter_types::Span),
6382 PipePipe(::treesitter_types::Span),
6383}
6384impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
6385 #[allow(clippy::collapsible_else_if)]
6386 fn from_node(
6387 node: ::tree_sitter::Node<'tree>,
6388 _src: &'tree [u8],
6389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6390 match node.kind() {
6391 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
6392 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
6393 "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
6394 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
6395 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
6396 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
6397 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
6398 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
6399 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
6400 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
6401 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
6402 "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
6403 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
6404 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
6405 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
6406 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
6407 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
6408 ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
6409 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
6410 "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
6411 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
6412 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
6413 "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
6414 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
6415 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
6416 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6417 }
6418 }
6419}
6420impl ::treesitter_types::Spanned for BinaryExpressionOperator {
6421 fn span(&self) -> ::treesitter_types::Span {
6422 match self {
6423 Self::NotEq(span) => *span,
6424 Self::BangEqEq(span) => *span,
6425 Self::Percent(span) => *span,
6426 Self::Amp(span) => *span,
6427 Self::AmpAmp(span) => *span,
6428 Self::Star(span) => *span,
6429 Self::StarStar(span) => *span,
6430 Self::Plus(span) => *span,
6431 Self::Minus(span) => *span,
6432 Self::Slash(span) => *span,
6433 Self::Lt(span) => *span,
6434 Self::Shl(span) => *span,
6435 Self::LtEq(span) => *span,
6436 Self::EqEq(span) => *span,
6437 Self::EqEqEq(span) => *span,
6438 Self::Gt(span) => *span,
6439 Self::GtEq(span) => *span,
6440 Self::Shr(span) => *span,
6441 Self::GtGtGt(span) => *span,
6442 Self::QuestionQuestion(span) => *span,
6443 Self::Caret(span) => *span,
6444 Self::In(span) => *span,
6445 Self::Instanceof(span) => *span,
6446 Self::Pipe(span) => *span,
6447 Self::PipePipe(span) => *span,
6448 }
6449 }
6450}
6451#[derive(Debug, Clone, PartialEq, Eq)]
6452pub enum CallExpressionArguments<'tree> {
6453 Arguments(::std::boxed::Box<Arguments<'tree>>),
6454 TemplateString(::std::boxed::Box<TemplateString<'tree>>),
6455}
6456impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionArguments<'tree> {
6457 #[allow(clippy::collapsible_else_if)]
6458 fn from_node(
6459 node: ::tree_sitter::Node<'tree>,
6460 src: &'tree [u8],
6461 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6462 match node.kind() {
6463 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
6464 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
6465 ))),
6466 "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
6467 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
6468 ))),
6469 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6470 }
6471 }
6472}
6473impl ::treesitter_types::Spanned for CallExpressionArguments<'_> {
6474 fn span(&self) -> ::treesitter_types::Span {
6475 match self {
6476 Self::Arguments(inner) => inner.span(),
6477 Self::TemplateString(inner) => inner.span(),
6478 }
6479 }
6480}
6481#[derive(Debug, Clone, PartialEq, Eq)]
6482pub enum CallExpressionFunction<'tree> {
6483 Expression(::std::boxed::Box<Expression<'tree>>),
6484 Import(::std::boxed::Box<Import<'tree>>),
6485}
6486impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
6487 #[allow(clippy::collapsible_else_if)]
6488 fn from_node(
6489 node: ::tree_sitter::Node<'tree>,
6490 src: &'tree [u8],
6491 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6492 match node.kind() {
6493 "import" => Ok(Self::Import(::std::boxed::Box::new(
6494 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
6495 ))),
6496 _other => {
6497 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6498 Ok(Self::Expression(::std::boxed::Box::new(v)))
6499 } else {
6500 Err(::treesitter_types::ParseError::unexpected_kind(
6501 _other, node,
6502 ))
6503 }
6504 }
6505 }
6506 }
6507}
6508impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
6509 fn span(&self) -> ::treesitter_types::Span {
6510 match self {
6511 Self::Expression(inner) => inner.span(),
6512 Self::Import(inner) => inner.span(),
6513 }
6514 }
6515}
6516#[derive(Debug, Clone, PartialEq, Eq)]
6517pub enum CatchClauseParameter<'tree> {
6518 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
6519 Identifier(::std::boxed::Box<Identifier<'tree>>),
6520 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
6521}
6522impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseParameter<'tree> {
6523 #[allow(clippy::collapsible_else_if)]
6524 fn from_node(
6525 node: ::tree_sitter::Node<'tree>,
6526 src: &'tree [u8],
6527 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6528 match node.kind() {
6529 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
6530 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6531 ))),
6532 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6533 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6534 ))),
6535 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
6536 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6537 ))),
6538 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6539 }
6540 }
6541}
6542impl ::treesitter_types::Spanned for CatchClauseParameter<'_> {
6543 fn span(&self) -> ::treesitter_types::Span {
6544 match self {
6545 Self::ArrayPattern(inner) => inner.span(),
6546 Self::Identifier(inner) => inner.span(),
6547 Self::ObjectPattern(inner) => inner.span(),
6548 }
6549 }
6550}
6551#[derive(Debug, Clone, PartialEq, Eq)]
6552pub enum ClassBodyMember<'tree> {
6553 ClassStaticBlock(::std::boxed::Box<ClassStaticBlock<'tree>>),
6554 FieldDefinition(::std::boxed::Box<FieldDefinition<'tree>>),
6555 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
6556}
6557impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyMember<'tree> {
6558 #[allow(clippy::collapsible_else_if)]
6559 fn from_node(
6560 node: ::tree_sitter::Node<'tree>,
6561 src: &'tree [u8],
6562 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6563 match node.kind() {
6564 "class_static_block" => Ok(Self::ClassStaticBlock(::std::boxed::Box::new(
6565 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
6566 ))),
6567 "field_definition" => Ok(Self::FieldDefinition(::std::boxed::Box::new(
6568 <FieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
6569 ))),
6570 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
6571 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
6572 ))),
6573 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6574 }
6575 }
6576}
6577impl ::treesitter_types::Spanned for ClassBodyMember<'_> {
6578 fn span(&self) -> ::treesitter_types::Span {
6579 match self {
6580 Self::ClassStaticBlock(inner) => inner.span(),
6581 Self::FieldDefinition(inner) => inner.span(),
6582 Self::MethodDefinition(inner) => inner.span(),
6583 }
6584 }
6585}
6586#[derive(Debug, Clone, PartialEq, Eq)]
6587pub enum DecoratorChildren<'tree> {
6588 CallExpression(::std::boxed::Box<CallExpression<'tree>>),
6589 Identifier(::std::boxed::Box<Identifier<'tree>>),
6590 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6591}
6592impl<'tree> ::treesitter_types::FromNode<'tree> for DecoratorChildren<'tree> {
6593 #[allow(clippy::collapsible_else_if)]
6594 fn from_node(
6595 node: ::tree_sitter::Node<'tree>,
6596 src: &'tree [u8],
6597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6598 match node.kind() {
6599 "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
6600 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6601 ))),
6602 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6603 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6604 ))),
6605 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6606 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6607 ))),
6608 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6609 }
6610 }
6611}
6612impl ::treesitter_types::Spanned for DecoratorChildren<'_> {
6613 fn span(&self) -> ::treesitter_types::Span {
6614 match self {
6615 Self::CallExpression(inner) => inner.span(),
6616 Self::Identifier(inner) => inner.span(),
6617 Self::MemberExpression(inner) => inner.span(),
6618 }
6619 }
6620}
6621#[derive(Debug, Clone, PartialEq, Eq)]
6622pub enum ExportSpecifierAlias<'tree> {
6623 Default(::treesitter_types::Span),
6624 Identifier(::std::boxed::Box<Identifier<'tree>>),
6625 String(::std::boxed::Box<String<'tree>>),
6626}
6627impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierAlias<'tree> {
6628 #[allow(clippy::collapsible_else_if)]
6629 fn from_node(
6630 node: ::tree_sitter::Node<'tree>,
6631 src: &'tree [u8],
6632 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6633 match node.kind() {
6634 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
6635 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6636 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6637 ))),
6638 "string" => Ok(Self::String(::std::boxed::Box::new(
6639 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
6640 ))),
6641 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6642 }
6643 }
6644}
6645impl ::treesitter_types::Spanned for ExportSpecifierAlias<'_> {
6646 fn span(&self) -> ::treesitter_types::Span {
6647 match self {
6648 Self::Default(span) => *span,
6649 Self::Identifier(inner) => inner.span(),
6650 Self::String(inner) => inner.span(),
6651 }
6652 }
6653}
6654#[derive(Debug, Clone, PartialEq, Eq)]
6655pub enum ExportSpecifierName<'tree> {
6656 Default(::treesitter_types::Span),
6657 Identifier(::std::boxed::Box<Identifier<'tree>>),
6658 String(::std::boxed::Box<String<'tree>>),
6659}
6660impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierName<'tree> {
6661 #[allow(clippy::collapsible_else_if)]
6662 fn from_node(
6663 node: ::tree_sitter::Node<'tree>,
6664 src: &'tree [u8],
6665 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6666 match node.kind() {
6667 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
6668 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6669 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6670 ))),
6671 "string" => Ok(Self::String(::std::boxed::Box::new(
6672 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
6673 ))),
6674 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6675 }
6676 }
6677}
6678impl ::treesitter_types::Spanned for ExportSpecifierName<'_> {
6679 fn span(&self) -> ::treesitter_types::Span {
6680 match self {
6681 Self::Default(span) => *span,
6682 Self::Identifier(inner) => inner.span(),
6683 Self::String(inner) => inner.span(),
6684 }
6685 }
6686}
6687#[derive(Debug, Clone, PartialEq, Eq)]
6688pub enum ExportStatementChildren<'tree> {
6689 ExportClause(::std::boxed::Box<ExportClause<'tree>>),
6690 NamespaceExport(::std::boxed::Box<NamespaceExport<'tree>>),
6691}
6692impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatementChildren<'tree> {
6693 #[allow(clippy::collapsible_else_if)]
6694 fn from_node(
6695 node: ::tree_sitter::Node<'tree>,
6696 src: &'tree [u8],
6697 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6698 match node.kind() {
6699 "export_clause" => Ok(Self::ExportClause(::std::boxed::Box::new(
6700 <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
6701 ))),
6702 "namespace_export" => Ok(Self::NamespaceExport(::std::boxed::Box::new(
6703 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)?,
6704 ))),
6705 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6706 }
6707 }
6708}
6709impl ::treesitter_types::Spanned for ExportStatementChildren<'_> {
6710 fn span(&self) -> ::treesitter_types::Span {
6711 match self {
6712 Self::ExportClause(inner) => inner.span(),
6713 Self::NamespaceExport(inner) => inner.span(),
6714 }
6715 }
6716}
6717#[derive(Debug, Clone, PartialEq, Eq)]
6718pub enum ExpressionStatementChildren<'tree> {
6719 Expression(::std::boxed::Box<Expression<'tree>>),
6720 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
6721}
6722impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
6723 #[allow(clippy::collapsible_else_if)]
6724 fn from_node(
6725 node: ::tree_sitter::Node<'tree>,
6726 src: &'tree [u8],
6727 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6728 match node.kind() {
6729 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
6730 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6731 ))),
6732 _other => {
6733 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6734 Ok(Self::Expression(::std::boxed::Box::new(v)))
6735 } else {
6736 Err(::treesitter_types::ParseError::unexpected_kind(
6737 _other, node,
6738 ))
6739 }
6740 }
6741 }
6742 }
6743}
6744impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
6745 fn span(&self) -> ::treesitter_types::Span {
6746 match self {
6747 Self::Expression(inner) => inner.span(),
6748 Self::SequenceExpression(inner) => inner.span(),
6749 }
6750 }
6751}
6752#[derive(Debug, Clone, PartialEq, Eq)]
6753pub enum FieldDefinitionProperty<'tree> {
6754 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
6755 Number(::std::boxed::Box<Number<'tree>>),
6756 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
6757 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
6758 String(::std::boxed::Box<String<'tree>>),
6759}
6760impl<'tree> ::treesitter_types::FromNode<'tree> for FieldDefinitionProperty<'tree> {
6761 #[allow(clippy::collapsible_else_if)]
6762 fn from_node(
6763 node: ::tree_sitter::Node<'tree>,
6764 src: &'tree [u8],
6765 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6766 match node.kind() {
6767 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
6768 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
6769 ))),
6770 "number" => Ok(Self::Number(::std::boxed::Box::new(
6771 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
6772 ))),
6773 "private_property_identifier" => {
6774 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
6775 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
6776 node, src,
6777 )?,
6778 )))
6779 }
6780 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
6781 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6782 ))),
6783 "string" => Ok(Self::String(::std::boxed::Box::new(
6784 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
6785 ))),
6786 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6787 }
6788 }
6789}
6790impl ::treesitter_types::Spanned for FieldDefinitionProperty<'_> {
6791 fn span(&self) -> ::treesitter_types::Span {
6792 match self {
6793 Self::ComputedPropertyName(inner) => inner.span(),
6794 Self::Number(inner) => inner.span(),
6795 Self::PrivatePropertyIdentifier(inner) => inner.span(),
6796 Self::PropertyIdentifier(inner) => inner.span(),
6797 Self::String(inner) => inner.span(),
6798 }
6799 }
6800}
6801#[derive(Debug, Clone, PartialEq, Eq)]
6802pub enum ForInStatementKind {
6803 Await(::treesitter_types::Span),
6804 Const(::treesitter_types::Span),
6805 Let(::treesitter_types::Span),
6806 Using(::treesitter_types::Span),
6807 Var(::treesitter_types::Span),
6808}
6809impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementKind {
6810 #[allow(clippy::collapsible_else_if)]
6811 fn from_node(
6812 node: ::tree_sitter::Node<'tree>,
6813 _src: &'tree [u8],
6814 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6815 match node.kind() {
6816 "await" => Ok(Self::Await(::treesitter_types::Span::from(node))),
6817 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
6818 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
6819 "using" => Ok(Self::Using(::treesitter_types::Span::from(node))),
6820 "var" => Ok(Self::Var(::treesitter_types::Span::from(node))),
6821 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6822 }
6823 }
6824}
6825impl ::treesitter_types::Spanned for ForInStatementKind {
6826 fn span(&self) -> ::treesitter_types::Span {
6827 match self {
6828 Self::Await(span) => *span,
6829 Self::Const(span) => *span,
6830 Self::Let(span) => *span,
6831 Self::Using(span) => *span,
6832 Self::Var(span) => *span,
6833 }
6834 }
6835}
6836#[derive(Debug, Clone, PartialEq, Eq)]
6837pub enum ForInStatementLeft<'tree> {
6838 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
6839 Identifier(::std::boxed::Box<Identifier<'tree>>),
6840 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
6841 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
6842 ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
6843 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
6844 Undefined(::std::boxed::Box<Undefined<'tree>>),
6845}
6846impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementLeft<'tree> {
6847 #[allow(clippy::collapsible_else_if)]
6848 fn from_node(
6849 node: ::tree_sitter::Node<'tree>,
6850 src: &'tree [u8],
6851 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6852 match node.kind() {
6853 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
6854 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6855 ))),
6856 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
6857 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
6858 ))),
6859 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
6860 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6861 ))),
6862 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
6863 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
6864 ))),
6865 "parenthesized_expression" => {
6866 Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
6867 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
6868 node, src,
6869 )?,
6870 )))
6871 }
6872 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
6873 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6874 ))),
6875 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
6876 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
6877 ))),
6878 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6879 }
6880 }
6881}
6882impl ::treesitter_types::Spanned for ForInStatementLeft<'_> {
6883 fn span(&self) -> ::treesitter_types::Span {
6884 match self {
6885 Self::ArrayPattern(inner) => inner.span(),
6886 Self::Identifier(inner) => inner.span(),
6887 Self::MemberExpression(inner) => inner.span(),
6888 Self::ObjectPattern(inner) => inner.span(),
6889 Self::ParenthesizedExpression(inner) => inner.span(),
6890 Self::SubscriptExpression(inner) => inner.span(),
6891 Self::Undefined(inner) => inner.span(),
6892 }
6893 }
6894}
6895#[derive(Debug, Clone, PartialEq, Eq)]
6896pub enum ForInStatementOperator {
6897 In(::treesitter_types::Span),
6898 Of(::treesitter_types::Span),
6899}
6900impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementOperator {
6901 #[allow(clippy::collapsible_else_if)]
6902 fn from_node(
6903 node: ::tree_sitter::Node<'tree>,
6904 _src: &'tree [u8],
6905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6906 match node.kind() {
6907 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
6908 "of" => Ok(Self::Of(::treesitter_types::Span::from(node))),
6909 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6910 }
6911 }
6912}
6913impl ::treesitter_types::Spanned for ForInStatementOperator {
6914 fn span(&self) -> ::treesitter_types::Span {
6915 match self {
6916 Self::In(span) => *span,
6917 Self::Of(span) => *span,
6918 }
6919 }
6920}
6921#[derive(Debug, Clone, PartialEq, Eq)]
6922pub enum ForInStatementRight<'tree> {
6923 Expression(::std::boxed::Box<Expression<'tree>>),
6924 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
6925}
6926impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementRight<'tree> {
6927 #[allow(clippy::collapsible_else_if)]
6928 fn from_node(
6929 node: ::tree_sitter::Node<'tree>,
6930 src: &'tree [u8],
6931 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6932 match node.kind() {
6933 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
6934 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6935 ))),
6936 _other => {
6937 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6938 Ok(Self::Expression(::std::boxed::Box::new(v)))
6939 } else {
6940 Err(::treesitter_types::ParseError::unexpected_kind(
6941 _other, node,
6942 ))
6943 }
6944 }
6945 }
6946 }
6947}
6948impl ::treesitter_types::Spanned for ForInStatementRight<'_> {
6949 fn span(&self) -> ::treesitter_types::Span {
6950 match self {
6951 Self::Expression(inner) => inner.span(),
6952 Self::SequenceExpression(inner) => inner.span(),
6953 }
6954 }
6955}
6956#[derive(Debug, Clone, PartialEq, Eq)]
6957pub enum ForStatementCondition<'tree> {
6958 Semicolon(::treesitter_types::Span),
6959 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
6960 Expression(::std::boxed::Box<Expression<'tree>>),
6961 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
6962}
6963impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
6964 #[allow(clippy::collapsible_else_if)]
6965 fn from_node(
6966 node: ::tree_sitter::Node<'tree>,
6967 src: &'tree [u8],
6968 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6969 match node.kind() {
6970 ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
6971 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
6972 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
6973 ))),
6974 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
6975 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
6976 ))),
6977 _other => {
6978 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
6979 Ok(Self::Expression(::std::boxed::Box::new(v)))
6980 } else {
6981 Err(::treesitter_types::ParseError::unexpected_kind(
6982 _other, node,
6983 ))
6984 }
6985 }
6986 }
6987 }
6988}
6989impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
6990 fn span(&self) -> ::treesitter_types::Span {
6991 match self {
6992 Self::Semicolon(span) => *span,
6993 Self::EmptyStatement(inner) => inner.span(),
6994 Self::Expression(inner) => inner.span(),
6995 Self::SequenceExpression(inner) => inner.span(),
6996 }
6997 }
6998}
6999#[derive(Debug, Clone, PartialEq, Eq)]
7000pub enum ForStatementIncrement<'tree> {
7001 Expression(::std::boxed::Box<Expression<'tree>>),
7002 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7003}
7004impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementIncrement<'tree> {
7005 #[allow(clippy::collapsible_else_if)]
7006 fn from_node(
7007 node: ::tree_sitter::Node<'tree>,
7008 src: &'tree [u8],
7009 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7010 match node.kind() {
7011 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7012 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7013 ))),
7014 _other => {
7015 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7016 Ok(Self::Expression(::std::boxed::Box::new(v)))
7017 } else {
7018 Err(::treesitter_types::ParseError::unexpected_kind(
7019 _other, node,
7020 ))
7021 }
7022 }
7023 }
7024 }
7025}
7026impl ::treesitter_types::Spanned for ForStatementIncrement<'_> {
7027 fn span(&self) -> ::treesitter_types::Span {
7028 match self {
7029 Self::Expression(inner) => inner.span(),
7030 Self::SequenceExpression(inner) => inner.span(),
7031 }
7032 }
7033}
7034#[derive(Debug, Clone, PartialEq, Eq)]
7035pub enum ForStatementInitializer<'tree> {
7036 EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
7037 Expression(::std::boxed::Box<Expression<'tree>>),
7038 LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
7039 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7040 VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
7041}
7042impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
7043 #[allow(clippy::collapsible_else_if)]
7044 fn from_node(
7045 node: ::tree_sitter::Node<'tree>,
7046 src: &'tree [u8],
7047 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7048 match node.kind() {
7049 "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
7050 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
7051 ))),
7052 "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
7053 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
7054 ))),
7055 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7056 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7057 ))),
7058 "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
7059 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
7060 ))),
7061 _other => {
7062 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7063 Ok(Self::Expression(::std::boxed::Box::new(v)))
7064 } else {
7065 Err(::treesitter_types::ParseError::unexpected_kind(
7066 _other, node,
7067 ))
7068 }
7069 }
7070 }
7071 }
7072}
7073impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
7074 fn span(&self) -> ::treesitter_types::Span {
7075 match self {
7076 Self::EmptyStatement(inner) => inner.span(),
7077 Self::Expression(inner) => inner.span(),
7078 Self::LexicalDeclaration(inner) => inner.span(),
7079 Self::SequenceExpression(inner) => inner.span(),
7080 Self::VariableDeclaration(inner) => inner.span(),
7081 }
7082 }
7083}
7084#[derive(Debug, Clone, PartialEq, Eq)]
7085pub enum FormalParametersChildren<'tree> {
7086 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
7087 Pattern(::std::boxed::Box<Pattern<'tree>>),
7088}
7089impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
7090 #[allow(clippy::collapsible_else_if)]
7091 fn from_node(
7092 node: ::tree_sitter::Node<'tree>,
7093 src: &'tree [u8],
7094 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7095 match node.kind() {
7096 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
7097 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
7098 ))),
7099 _other => {
7100 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
7101 Ok(Self::Pattern(::std::boxed::Box::new(v)))
7102 } else {
7103 Err(::treesitter_types::ParseError::unexpected_kind(
7104 _other, node,
7105 ))
7106 }
7107 }
7108 }
7109 }
7110}
7111impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
7112 fn span(&self) -> ::treesitter_types::Span {
7113 match self {
7114 Self::AssignmentPattern(inner) => inner.span(),
7115 Self::Pattern(inner) => inner.span(),
7116 }
7117 }
7118}
7119#[derive(Debug, Clone, PartialEq, Eq)]
7120pub enum ImportClauseChildren<'tree> {
7121 Identifier(::std::boxed::Box<Identifier<'tree>>),
7122 NamedImports(::std::boxed::Box<NamedImports<'tree>>),
7123 NamespaceImport(::std::boxed::Box<NamespaceImport<'tree>>),
7124}
7125impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClauseChildren<'tree> {
7126 #[allow(clippy::collapsible_else_if)]
7127 fn from_node(
7128 node: ::tree_sitter::Node<'tree>,
7129 src: &'tree [u8],
7130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7131 match node.kind() {
7132 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7133 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7134 ))),
7135 "named_imports" => Ok(Self::NamedImports(::std::boxed::Box::new(
7136 <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)?,
7137 ))),
7138 "namespace_import" => Ok(Self::NamespaceImport(::std::boxed::Box::new(
7139 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)?,
7140 ))),
7141 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7142 }
7143 }
7144}
7145impl ::treesitter_types::Spanned for ImportClauseChildren<'_> {
7146 fn span(&self) -> ::treesitter_types::Span {
7147 match self {
7148 Self::Identifier(inner) => inner.span(),
7149 Self::NamedImports(inner) => inner.span(),
7150 Self::NamespaceImport(inner) => inner.span(),
7151 }
7152 }
7153}
7154#[derive(Debug, Clone, PartialEq, Eq)]
7155pub enum ImportSpecifierName<'tree> {
7156 Default(::treesitter_types::Span),
7157 Identifier(::std::boxed::Box<Identifier<'tree>>),
7158 String(::std::boxed::Box<String<'tree>>),
7159}
7160impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifierName<'tree> {
7161 #[allow(clippy::collapsible_else_if)]
7162 fn from_node(
7163 node: ::tree_sitter::Node<'tree>,
7164 src: &'tree [u8],
7165 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7166 match node.kind() {
7167 "default" => Ok(Self::Default(::treesitter_types::Span::from(node))),
7168 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7169 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7170 ))),
7171 "string" => Ok(Self::String(::std::boxed::Box::new(
7172 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7173 ))),
7174 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7175 }
7176 }
7177}
7178impl ::treesitter_types::Spanned for ImportSpecifierName<'_> {
7179 fn span(&self) -> ::treesitter_types::Span {
7180 match self {
7181 Self::Default(span) => *span,
7182 Self::Identifier(inner) => inner.span(),
7183 Self::String(inner) => inner.span(),
7184 }
7185 }
7186}
7187#[derive(Debug, Clone, PartialEq, Eq)]
7188pub enum ImportStatementChildren<'tree> {
7189 ImportAttribute(::std::boxed::Box<ImportAttribute<'tree>>),
7190 ImportClause(::std::boxed::Box<ImportClause<'tree>>),
7191}
7192impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatementChildren<'tree> {
7193 #[allow(clippy::collapsible_else_if)]
7194 fn from_node(
7195 node: ::tree_sitter::Node<'tree>,
7196 src: &'tree [u8],
7197 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7198 match node.kind() {
7199 "import_attribute" => Ok(Self::ImportAttribute(::std::boxed::Box::new(
7200 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
7201 ))),
7202 "import_clause" => Ok(Self::ImportClause(::std::boxed::Box::new(
7203 <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
7204 ))),
7205 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7206 }
7207 }
7208}
7209impl ::treesitter_types::Spanned for ImportStatementChildren<'_> {
7210 fn span(&self) -> ::treesitter_types::Span {
7211 match self {
7212 Self::ImportAttribute(inner) => inner.span(),
7213 Self::ImportClause(inner) => inner.span(),
7214 }
7215 }
7216}
7217#[derive(Debug, Clone, PartialEq, Eq)]
7218pub enum JsxAttributeChildren<'tree> {
7219 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
7220 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7221 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7222 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
7223 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7224 String(::std::boxed::Box<String<'tree>>),
7225}
7226impl<'tree> ::treesitter_types::FromNode<'tree> for JsxAttributeChildren<'tree> {
7227 #[allow(clippy::collapsible_else_if)]
7228 fn from_node(
7229 node: ::tree_sitter::Node<'tree>,
7230 src: &'tree [u8],
7231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7232 match node.kind() {
7233 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
7234 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7235 ))),
7236 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7237 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7238 ))),
7239 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7240 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
7241 ))),
7242 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
7243 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7244 ))),
7245 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7246 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7247 ))),
7248 "string" => Ok(Self::String(::std::boxed::Box::new(
7249 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7250 ))),
7251 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7252 }
7253 }
7254}
7255impl ::treesitter_types::Spanned for JsxAttributeChildren<'_> {
7256 fn span(&self) -> ::treesitter_types::Span {
7257 match self {
7258 Self::JsxElement(inner) => inner.span(),
7259 Self::JsxExpression(inner) => inner.span(),
7260 Self::JsxNamespaceName(inner) => inner.span(),
7261 Self::JsxSelfClosingElement(inner) => inner.span(),
7262 Self::PropertyIdentifier(inner) => inner.span(),
7263 Self::String(inner) => inner.span(),
7264 }
7265 }
7266}
7267#[derive(Debug, Clone, PartialEq, Eq)]
7268pub enum JsxClosingElementName<'tree> {
7269 Identifier(::std::boxed::Box<Identifier<'tree>>),
7270 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7271 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7272}
7273impl<'tree> ::treesitter_types::FromNode<'tree> for JsxClosingElementName<'tree> {
7274 #[allow(clippy::collapsible_else_if)]
7275 fn from_node(
7276 node: ::tree_sitter::Node<'tree>,
7277 src: &'tree [u8],
7278 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7279 match node.kind() {
7280 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7281 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7282 ))),
7283 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7284 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
7285 ))),
7286 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7287 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7288 ))),
7289 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7290 }
7291 }
7292}
7293impl ::treesitter_types::Spanned for JsxClosingElementName<'_> {
7294 fn span(&self) -> ::treesitter_types::Span {
7295 match self {
7296 Self::Identifier(inner) => inner.span(),
7297 Self::JsxNamespaceName(inner) => inner.span(),
7298 Self::MemberExpression(inner) => inner.span(),
7299 }
7300 }
7301}
7302#[derive(Debug, Clone, PartialEq, Eq)]
7303pub enum JsxElementChildren<'tree> {
7304 HtmlCharacterReference(::std::boxed::Box<HtmlCharacterReference<'tree>>),
7305 JsxElement(::std::boxed::Box<JsxElement<'tree>>),
7306 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7307 JsxSelfClosingElement(::std::boxed::Box<JsxSelfClosingElement<'tree>>),
7308 JsxText(::std::boxed::Box<JsxText<'tree>>),
7309}
7310impl<'tree> ::treesitter_types::FromNode<'tree> for JsxElementChildren<'tree> {
7311 #[allow(clippy::collapsible_else_if)]
7312 fn from_node(
7313 node: ::tree_sitter::Node<'tree>,
7314 src: &'tree [u8],
7315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7316 match node.kind() {
7317 "html_character_reference" => Ok(Self::HtmlCharacterReference(::std::boxed::Box::new(
7318 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)?,
7319 ))),
7320 "jsx_element" => Ok(Self::JsxElement(::std::boxed::Box::new(
7321 <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7322 ))),
7323 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7324 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7325 ))),
7326 "jsx_self_closing_element" => Ok(Self::JsxSelfClosingElement(::std::boxed::Box::new(
7327 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7328 ))),
7329 "jsx_text" => Ok(Self::JsxText(::std::boxed::Box::new(
7330 <JsxText as ::treesitter_types::FromNode>::from_node(node, src)?,
7331 ))),
7332 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7333 }
7334 }
7335}
7336impl ::treesitter_types::Spanned for JsxElementChildren<'_> {
7337 fn span(&self) -> ::treesitter_types::Span {
7338 match self {
7339 Self::HtmlCharacterReference(inner) => inner.span(),
7340 Self::JsxElement(inner) => inner.span(),
7341 Self::JsxExpression(inner) => inner.span(),
7342 Self::JsxSelfClosingElement(inner) => inner.span(),
7343 Self::JsxText(inner) => inner.span(),
7344 }
7345 }
7346}
7347#[derive(Debug, Clone, PartialEq, Eq)]
7348pub enum JsxExpressionChildren<'tree> {
7349 Expression(::std::boxed::Box<Expression<'tree>>),
7350 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
7351 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
7352}
7353impl<'tree> ::treesitter_types::FromNode<'tree> for JsxExpressionChildren<'tree> {
7354 #[allow(clippy::collapsible_else_if)]
7355 fn from_node(
7356 node: ::tree_sitter::Node<'tree>,
7357 src: &'tree [u8],
7358 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7359 match node.kind() {
7360 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
7361 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7362 ))),
7363 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
7364 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7365 ))),
7366 _other => {
7367 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7368 Ok(Self::Expression(::std::boxed::Box::new(v)))
7369 } else {
7370 Err(::treesitter_types::ParseError::unexpected_kind(
7371 _other, node,
7372 ))
7373 }
7374 }
7375 }
7376 }
7377}
7378impl ::treesitter_types::Spanned for JsxExpressionChildren<'_> {
7379 fn span(&self) -> ::treesitter_types::Span {
7380 match self {
7381 Self::Expression(inner) => inner.span(),
7382 Self::SequenceExpression(inner) => inner.span(),
7383 Self::SpreadElement(inner) => inner.span(),
7384 }
7385 }
7386}
7387#[derive(Debug, Clone, PartialEq, Eq)]
7388pub enum JsxOpeningElementAttribute<'tree> {
7389 JsxAttribute(::std::boxed::Box<JsxAttribute<'tree>>),
7390 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7391}
7392impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElementAttribute<'tree> {
7393 #[allow(clippy::collapsible_else_if)]
7394 fn from_node(
7395 node: ::tree_sitter::Node<'tree>,
7396 src: &'tree [u8],
7397 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7398 match node.kind() {
7399 "jsx_attribute" => Ok(Self::JsxAttribute(::std::boxed::Box::new(
7400 <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
7401 ))),
7402 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7403 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7404 ))),
7405 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7406 }
7407 }
7408}
7409impl ::treesitter_types::Spanned for JsxOpeningElementAttribute<'_> {
7410 fn span(&self) -> ::treesitter_types::Span {
7411 match self {
7412 Self::JsxAttribute(inner) => inner.span(),
7413 Self::JsxExpression(inner) => inner.span(),
7414 }
7415 }
7416}
7417#[derive(Debug, Clone, PartialEq, Eq)]
7418pub enum JsxOpeningElementName<'tree> {
7419 Identifier(::std::boxed::Box<Identifier<'tree>>),
7420 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7421 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7422}
7423impl<'tree> ::treesitter_types::FromNode<'tree> for JsxOpeningElementName<'tree> {
7424 #[allow(clippy::collapsible_else_if)]
7425 fn from_node(
7426 node: ::tree_sitter::Node<'tree>,
7427 src: &'tree [u8],
7428 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7429 match node.kind() {
7430 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7431 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7432 ))),
7433 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7434 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
7435 ))),
7436 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7437 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7438 ))),
7439 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7440 }
7441 }
7442}
7443impl ::treesitter_types::Spanned for JsxOpeningElementName<'_> {
7444 fn span(&self) -> ::treesitter_types::Span {
7445 match self {
7446 Self::Identifier(inner) => inner.span(),
7447 Self::JsxNamespaceName(inner) => inner.span(),
7448 Self::MemberExpression(inner) => inner.span(),
7449 }
7450 }
7451}
7452#[derive(Debug, Clone, PartialEq, Eq)]
7453pub enum JsxSelfClosingElementAttribute<'tree> {
7454 JsxAttribute(::std::boxed::Box<JsxAttribute<'tree>>),
7455 JsxExpression(::std::boxed::Box<JsxExpression<'tree>>),
7456}
7457impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElementAttribute<'tree> {
7458 #[allow(clippy::collapsible_else_if)]
7459 fn from_node(
7460 node: ::tree_sitter::Node<'tree>,
7461 src: &'tree [u8],
7462 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7463 match node.kind() {
7464 "jsx_attribute" => Ok(Self::JsxAttribute(::std::boxed::Box::new(
7465 <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
7466 ))),
7467 "jsx_expression" => Ok(Self::JsxExpression(::std::boxed::Box::new(
7468 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7469 ))),
7470 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7471 }
7472 }
7473}
7474impl ::treesitter_types::Spanned for JsxSelfClosingElementAttribute<'_> {
7475 fn span(&self) -> ::treesitter_types::Span {
7476 match self {
7477 Self::JsxAttribute(inner) => inner.span(),
7478 Self::JsxExpression(inner) => inner.span(),
7479 }
7480 }
7481}
7482#[derive(Debug, Clone, PartialEq, Eq)]
7483pub enum JsxSelfClosingElementName<'tree> {
7484 Identifier(::std::boxed::Box<Identifier<'tree>>),
7485 JsxNamespaceName(::std::boxed::Box<JsxNamespaceName<'tree>>),
7486 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
7487}
7488impl<'tree> ::treesitter_types::FromNode<'tree> for JsxSelfClosingElementName<'tree> {
7489 #[allow(clippy::collapsible_else_if)]
7490 fn from_node(
7491 node: ::tree_sitter::Node<'tree>,
7492 src: &'tree [u8],
7493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7494 match node.kind() {
7495 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7496 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7497 ))),
7498 "jsx_namespace_name" => Ok(Self::JsxNamespaceName(::std::boxed::Box::new(
7499 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)?,
7500 ))),
7501 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
7502 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7503 ))),
7504 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7505 }
7506 }
7507}
7508impl ::treesitter_types::Spanned for JsxSelfClosingElementName<'_> {
7509 fn span(&self) -> ::treesitter_types::Span {
7510 match self {
7511 Self::Identifier(inner) => inner.span(),
7512 Self::JsxNamespaceName(inner) => inner.span(),
7513 Self::MemberExpression(inner) => inner.span(),
7514 }
7515 }
7516}
7517#[derive(Debug, Clone, PartialEq, Eq)]
7518pub enum LexicalDeclarationKind {
7519 Const(::treesitter_types::Span),
7520 Let(::treesitter_types::Span),
7521}
7522impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclarationKind {
7523 #[allow(clippy::collapsible_else_if)]
7524 fn from_node(
7525 node: ::tree_sitter::Node<'tree>,
7526 _src: &'tree [u8],
7527 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7528 match node.kind() {
7529 "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
7530 "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
7531 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7532 }
7533 }
7534}
7535impl ::treesitter_types::Spanned for LexicalDeclarationKind {
7536 fn span(&self) -> ::treesitter_types::Span {
7537 match self {
7538 Self::Const(span) => *span,
7539 Self::Let(span) => *span,
7540 }
7541 }
7542}
7543#[derive(Debug, Clone, PartialEq, Eq)]
7544pub enum MemberExpressionObject<'tree> {
7545 Expression(::std::boxed::Box<Expression<'tree>>),
7546 Import(::std::boxed::Box<Import<'tree>>),
7547}
7548impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionObject<'tree> {
7549 #[allow(clippy::collapsible_else_if)]
7550 fn from_node(
7551 node: ::tree_sitter::Node<'tree>,
7552 src: &'tree [u8],
7553 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7554 match node.kind() {
7555 "import" => Ok(Self::Import(::std::boxed::Box::new(
7556 <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
7557 ))),
7558 _other => {
7559 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
7560 Ok(Self::Expression(::std::boxed::Box::new(v)))
7561 } else {
7562 Err(::treesitter_types::ParseError::unexpected_kind(
7563 _other, node,
7564 ))
7565 }
7566 }
7567 }
7568 }
7569}
7570impl ::treesitter_types::Spanned for MemberExpressionObject<'_> {
7571 fn span(&self) -> ::treesitter_types::Span {
7572 match self {
7573 Self::Expression(inner) => inner.span(),
7574 Self::Import(inner) => inner.span(),
7575 }
7576 }
7577}
7578#[derive(Debug, Clone, PartialEq, Eq)]
7579pub enum MemberExpressionProperty<'tree> {
7580 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
7581 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7582}
7583impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionProperty<'tree> {
7584 #[allow(clippy::collapsible_else_if)]
7585 fn from_node(
7586 node: ::tree_sitter::Node<'tree>,
7587 src: &'tree [u8],
7588 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7589 match node.kind() {
7590 "private_property_identifier" => {
7591 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
7592 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7593 node, src,
7594 )?,
7595 )))
7596 }
7597 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7598 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7599 ))),
7600 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7601 }
7602 }
7603}
7604impl ::treesitter_types::Spanned for MemberExpressionProperty<'_> {
7605 fn span(&self) -> ::treesitter_types::Span {
7606 match self {
7607 Self::PrivatePropertyIdentifier(inner) => inner.span(),
7608 Self::PropertyIdentifier(inner) => inner.span(),
7609 }
7610 }
7611}
7612#[derive(Debug, Clone, PartialEq, Eq)]
7613pub enum MethodDefinitionName<'tree> {
7614 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
7615 Number(::std::boxed::Box<Number<'tree>>),
7616 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
7617 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7618 String(::std::boxed::Box<String<'tree>>),
7619}
7620impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionName<'tree> {
7621 #[allow(clippy::collapsible_else_if)]
7622 fn from_node(
7623 node: ::tree_sitter::Node<'tree>,
7624 src: &'tree [u8],
7625 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7626 match node.kind() {
7627 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
7628 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
7629 ))),
7630 "number" => Ok(Self::Number(::std::boxed::Box::new(
7631 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
7632 ))),
7633 "private_property_identifier" => {
7634 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
7635 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7636 node, src,
7637 )?,
7638 )))
7639 }
7640 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7641 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7642 ))),
7643 "string" => Ok(Self::String(::std::boxed::Box::new(
7644 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7645 ))),
7646 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7647 }
7648 }
7649}
7650impl ::treesitter_types::Spanned for MethodDefinitionName<'_> {
7651 fn span(&self) -> ::treesitter_types::Span {
7652 match self {
7653 Self::ComputedPropertyName(inner) => inner.span(),
7654 Self::Number(inner) => inner.span(),
7655 Self::PrivatePropertyIdentifier(inner) => inner.span(),
7656 Self::PropertyIdentifier(inner) => inner.span(),
7657 Self::String(inner) => inner.span(),
7658 }
7659 }
7660}
7661#[derive(Debug, Clone, PartialEq, Eq)]
7662pub enum NamespaceExportChildren<'tree> {
7663 Identifier(::std::boxed::Box<Identifier<'tree>>),
7664 String(::std::boxed::Box<String<'tree>>),
7665}
7666impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExportChildren<'tree> {
7667 #[allow(clippy::collapsible_else_if)]
7668 fn from_node(
7669 node: ::tree_sitter::Node<'tree>,
7670 src: &'tree [u8],
7671 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7672 match node.kind() {
7673 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
7674 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7675 ))),
7676 "string" => Ok(Self::String(::std::boxed::Box::new(
7677 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7678 ))),
7679 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7680 }
7681 }
7682}
7683impl ::treesitter_types::Spanned for NamespaceExportChildren<'_> {
7684 fn span(&self) -> ::treesitter_types::Span {
7685 match self {
7686 Self::Identifier(inner) => inner.span(),
7687 Self::String(inner) => inner.span(),
7688 }
7689 }
7690}
7691#[derive(Debug, Clone, PartialEq, Eq)]
7692pub enum NewExpressionConstructor<'tree> {
7693 NewExpression(::std::boxed::Box<NewExpression<'tree>>),
7694 PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
7695}
7696impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpressionConstructor<'tree> {
7697 #[allow(clippy::collapsible_else_if)]
7698 fn from_node(
7699 node: ::tree_sitter::Node<'tree>,
7700 src: &'tree [u8],
7701 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7702 match node.kind() {
7703 "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
7704 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
7705 ))),
7706 _other => {
7707 if let Ok(v) =
7708 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
7709 {
7710 Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
7711 } else {
7712 Err(::treesitter_types::ParseError::unexpected_kind(
7713 _other, node,
7714 ))
7715 }
7716 }
7717 }
7718 }
7719}
7720impl ::treesitter_types::Spanned for NewExpressionConstructor<'_> {
7721 fn span(&self) -> ::treesitter_types::Span {
7722 match self {
7723 Self::NewExpression(inner) => inner.span(),
7724 Self::PrimaryExpression(inner) => inner.span(),
7725 }
7726 }
7727}
7728#[derive(Debug, Clone, PartialEq, Eq)]
7729pub enum ObjectChildren<'tree> {
7730 MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
7731 Pair(::std::boxed::Box<Pair<'tree>>),
7732 ShorthandPropertyIdentifier(::std::boxed::Box<ShorthandPropertyIdentifier<'tree>>),
7733 SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
7734}
7735impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectChildren<'tree> {
7736 #[allow(clippy::collapsible_else_if)]
7737 fn from_node(
7738 node: ::tree_sitter::Node<'tree>,
7739 src: &'tree [u8],
7740 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7741 match node.kind() {
7742 "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
7743 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
7744 ))),
7745 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
7746 <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
7747 ))),
7748 "shorthand_property_identifier" => {
7749 Ok(Self::ShorthandPropertyIdentifier(::std::boxed::Box::new(
7750 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7751 node, src,
7752 )?,
7753 )))
7754 }
7755 "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
7756 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
7757 ))),
7758 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7759 }
7760 }
7761}
7762impl ::treesitter_types::Spanned for ObjectChildren<'_> {
7763 fn span(&self) -> ::treesitter_types::Span {
7764 match self {
7765 Self::MethodDefinition(inner) => inner.span(),
7766 Self::Pair(inner) => inner.span(),
7767 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
7768 Self::SpreadElement(inner) => inner.span(),
7769 }
7770 }
7771}
7772#[derive(Debug, Clone, PartialEq, Eq)]
7773pub enum ObjectAssignmentPatternLeft<'tree> {
7774 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
7775 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
7776 ShorthandPropertyIdentifierPattern(
7777 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
7778 ),
7779}
7780impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPatternLeft<'tree> {
7781 #[allow(clippy::collapsible_else_if)]
7782 fn from_node(
7783 node: ::tree_sitter::Node<'tree>,
7784 src: &'tree [u8],
7785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7786 match node.kind() {
7787 "array_pattern" => {
7788 Ok(
7789 Self::ArrayPattern(
7790 ::std::boxed::Box::new(
7791 <ArrayPattern as ::treesitter_types::FromNode>::from_node(
7792 node,
7793 src,
7794 )?,
7795 ),
7796 ),
7797 )
7798 }
7799 "object_pattern" => {
7800 Ok(
7801 Self::ObjectPattern(
7802 ::std::boxed::Box::new(
7803 <ObjectPattern as ::treesitter_types::FromNode>::from_node(
7804 node,
7805 src,
7806 )?,
7807 ),
7808 ),
7809 )
7810 }
7811 "shorthand_property_identifier_pattern" => {
7812 Ok(
7813 Self::ShorthandPropertyIdentifierPattern(
7814 ::std::boxed::Box::new(
7815 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
7816 node,
7817 src,
7818 )?,
7819 ),
7820 ),
7821 )
7822 }
7823 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7824 }
7825 }
7826}
7827impl ::treesitter_types::Spanned for ObjectAssignmentPatternLeft<'_> {
7828 fn span(&self) -> ::treesitter_types::Span {
7829 match self {
7830 Self::ArrayPattern(inner) => inner.span(),
7831 Self::ObjectPattern(inner) => inner.span(),
7832 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
7833 }
7834 }
7835}
7836#[derive(Debug, Clone, PartialEq, Eq)]
7837pub enum ObjectPatternChildren<'tree> {
7838 ObjectAssignmentPattern(::std::boxed::Box<ObjectAssignmentPattern<'tree>>),
7839 PairPattern(::std::boxed::Box<PairPattern<'tree>>),
7840 RestPattern(::std::boxed::Box<RestPattern<'tree>>),
7841 ShorthandPropertyIdentifierPattern(
7842 ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
7843 ),
7844}
7845impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPatternChildren<'tree> {
7846 #[allow(clippy::collapsible_else_if)]
7847 fn from_node(
7848 node: ::tree_sitter::Node<'tree>,
7849 src: &'tree [u8],
7850 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7851 match node.kind() {
7852 "object_assignment_pattern" => {
7853 Ok(
7854 Self::ObjectAssignmentPattern(
7855 ::std::boxed::Box::new(
7856 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(
7857 node,
7858 src,
7859 )?,
7860 ),
7861 ),
7862 )
7863 }
7864 "pair_pattern" => {
7865 Ok(
7866 Self::PairPattern(
7867 ::std::boxed::Box::new(
7868 <PairPattern as ::treesitter_types::FromNode>::from_node(
7869 node,
7870 src,
7871 )?,
7872 ),
7873 ),
7874 )
7875 }
7876 "rest_pattern" => {
7877 Ok(
7878 Self::RestPattern(
7879 ::std::boxed::Box::new(
7880 <RestPattern as ::treesitter_types::FromNode>::from_node(
7881 node,
7882 src,
7883 )?,
7884 ),
7885 ),
7886 )
7887 }
7888 "shorthand_property_identifier_pattern" => {
7889 Ok(
7890 Self::ShorthandPropertyIdentifierPattern(
7891 ::std::boxed::Box::new(
7892 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
7893 node,
7894 src,
7895 )?,
7896 ),
7897 ),
7898 )
7899 }
7900 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7901 }
7902 }
7903}
7904impl ::treesitter_types::Spanned for ObjectPatternChildren<'_> {
7905 fn span(&self) -> ::treesitter_types::Span {
7906 match self {
7907 Self::ObjectAssignmentPattern(inner) => inner.span(),
7908 Self::PairPattern(inner) => inner.span(),
7909 Self::RestPattern(inner) => inner.span(),
7910 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
7911 }
7912 }
7913}
7914#[derive(Debug, Clone, PartialEq, Eq)]
7915pub enum PairKey<'tree> {
7916 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
7917 Number(::std::boxed::Box<Number<'tree>>),
7918 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
7919 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7920 String(::std::boxed::Box<String<'tree>>),
7921}
7922impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
7923 #[allow(clippy::collapsible_else_if)]
7924 fn from_node(
7925 node: ::tree_sitter::Node<'tree>,
7926 src: &'tree [u8],
7927 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7928 match node.kind() {
7929 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
7930 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
7931 ))),
7932 "number" => Ok(Self::Number(::std::boxed::Box::new(
7933 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
7934 ))),
7935 "private_property_identifier" => {
7936 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
7937 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7938 node, src,
7939 )?,
7940 )))
7941 }
7942 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7943 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7944 ))),
7945 "string" => Ok(Self::String(::std::boxed::Box::new(
7946 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7947 ))),
7948 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7949 }
7950 }
7951}
7952impl ::treesitter_types::Spanned for PairKey<'_> {
7953 fn span(&self) -> ::treesitter_types::Span {
7954 match self {
7955 Self::ComputedPropertyName(inner) => inner.span(),
7956 Self::Number(inner) => inner.span(),
7957 Self::PrivatePropertyIdentifier(inner) => inner.span(),
7958 Self::PropertyIdentifier(inner) => inner.span(),
7959 Self::String(inner) => inner.span(),
7960 }
7961 }
7962}
7963#[derive(Debug, Clone, PartialEq, Eq)]
7964pub enum PairPatternKey<'tree> {
7965 ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
7966 Number(::std::boxed::Box<Number<'tree>>),
7967 PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
7968 PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
7969 String(::std::boxed::Box<String<'tree>>),
7970}
7971impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternKey<'tree> {
7972 #[allow(clippy::collapsible_else_if)]
7973 fn from_node(
7974 node: ::tree_sitter::Node<'tree>,
7975 src: &'tree [u8],
7976 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
7977 match node.kind() {
7978 "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
7979 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
7980 ))),
7981 "number" => Ok(Self::Number(::std::boxed::Box::new(
7982 <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
7983 ))),
7984 "private_property_identifier" => {
7985 Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
7986 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
7987 node, src,
7988 )?,
7989 )))
7990 }
7991 "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
7992 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
7993 ))),
7994 "string" => Ok(Self::String(::std::boxed::Box::new(
7995 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
7996 ))),
7997 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
7998 }
7999 }
8000}
8001impl ::treesitter_types::Spanned for PairPatternKey<'_> {
8002 fn span(&self) -> ::treesitter_types::Span {
8003 match self {
8004 Self::ComputedPropertyName(inner) => inner.span(),
8005 Self::Number(inner) => inner.span(),
8006 Self::PrivatePropertyIdentifier(inner) => inner.span(),
8007 Self::PropertyIdentifier(inner) => inner.span(),
8008 Self::String(inner) => inner.span(),
8009 }
8010 }
8011}
8012#[derive(Debug, Clone, PartialEq, Eq)]
8013pub enum PairPatternValue<'tree> {
8014 AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
8015 Pattern(::std::boxed::Box<Pattern<'tree>>),
8016}
8017impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternValue<'tree> {
8018 #[allow(clippy::collapsible_else_if)]
8019 fn from_node(
8020 node: ::tree_sitter::Node<'tree>,
8021 src: &'tree [u8],
8022 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8023 match node.kind() {
8024 "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
8025 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8026 ))),
8027 _other => {
8028 if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
8029 Ok(Self::Pattern(::std::boxed::Box::new(v)))
8030 } else {
8031 Err(::treesitter_types::ParseError::unexpected_kind(
8032 _other, node,
8033 ))
8034 }
8035 }
8036 }
8037 }
8038}
8039impl ::treesitter_types::Spanned for PairPatternValue<'_> {
8040 fn span(&self) -> ::treesitter_types::Span {
8041 match self {
8042 Self::AssignmentPattern(inner) => inner.span(),
8043 Self::Pattern(inner) => inner.span(),
8044 }
8045 }
8046}
8047#[derive(Debug, Clone, PartialEq, Eq)]
8048pub enum ParenthesizedExpressionChildren<'tree> {
8049 Expression(::std::boxed::Box<Expression<'tree>>),
8050 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8051}
8052impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
8053 #[allow(clippy::collapsible_else_if)]
8054 fn from_node(
8055 node: ::tree_sitter::Node<'tree>,
8056 src: &'tree [u8],
8057 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8058 match node.kind() {
8059 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8060 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8061 ))),
8062 _other => {
8063 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8064 Ok(Self::Expression(::std::boxed::Box::new(v)))
8065 } else {
8066 Err(::treesitter_types::ParseError::unexpected_kind(
8067 _other, node,
8068 ))
8069 }
8070 }
8071 }
8072 }
8073}
8074impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
8075 fn span(&self) -> ::treesitter_types::Span {
8076 match self {
8077 Self::Expression(inner) => inner.span(),
8078 Self::SequenceExpression(inner) => inner.span(),
8079 }
8080 }
8081}
8082#[derive(Debug, Clone, PartialEq, Eq)]
8083pub enum ProgramChildren<'tree> {
8084 HashBangLine(::std::boxed::Box<HashBangLine<'tree>>),
8085 Statement(::std::boxed::Box<Statement<'tree>>),
8086}
8087impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
8088 #[allow(clippy::collapsible_else_if)]
8089 fn from_node(
8090 node: ::tree_sitter::Node<'tree>,
8091 src: &'tree [u8],
8092 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8093 match node.kind() {
8094 "hash_bang_line" => Ok(Self::HashBangLine(::std::boxed::Box::new(
8095 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)?,
8096 ))),
8097 _other => {
8098 if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
8099 Ok(Self::Statement(::std::boxed::Box::new(v)))
8100 } else {
8101 Err(::treesitter_types::ParseError::unexpected_kind(
8102 _other, node,
8103 ))
8104 }
8105 }
8106 }
8107 }
8108}
8109impl ::treesitter_types::Spanned for ProgramChildren<'_> {
8110 fn span(&self) -> ::treesitter_types::Span {
8111 match self {
8112 Self::HashBangLine(inner) => inner.span(),
8113 Self::Statement(inner) => inner.span(),
8114 }
8115 }
8116}
8117#[derive(Debug, Clone, PartialEq, Eq)]
8118pub enum RestPatternChildren<'tree> {
8119 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
8120 Identifier(::std::boxed::Box<Identifier<'tree>>),
8121 MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
8122 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
8123 SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
8124 Undefined(::std::boxed::Box<Undefined<'tree>>),
8125}
8126impl<'tree> ::treesitter_types::FromNode<'tree> for RestPatternChildren<'tree> {
8127 #[allow(clippy::collapsible_else_if)]
8128 fn from_node(
8129 node: ::tree_sitter::Node<'tree>,
8130 src: &'tree [u8],
8131 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8132 match node.kind() {
8133 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
8134 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8135 ))),
8136 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8137 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8138 ))),
8139 "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
8140 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8141 ))),
8142 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
8143 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8144 ))),
8145 "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
8146 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8147 ))),
8148 "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
8149 <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
8150 ))),
8151 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8152 }
8153 }
8154}
8155impl ::treesitter_types::Spanned for RestPatternChildren<'_> {
8156 fn span(&self) -> ::treesitter_types::Span {
8157 match self {
8158 Self::ArrayPattern(inner) => inner.span(),
8159 Self::Identifier(inner) => inner.span(),
8160 Self::MemberExpression(inner) => inner.span(),
8161 Self::ObjectPattern(inner) => inner.span(),
8162 Self::SubscriptExpression(inner) => inner.span(),
8163 Self::Undefined(inner) => inner.span(),
8164 }
8165 }
8166}
8167#[derive(Debug, Clone, PartialEq, Eq)]
8168pub enum ReturnStatementChildren<'tree> {
8169 Expression(::std::boxed::Box<Expression<'tree>>),
8170 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8171}
8172impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
8173 #[allow(clippy::collapsible_else_if)]
8174 fn from_node(
8175 node: ::tree_sitter::Node<'tree>,
8176 src: &'tree [u8],
8177 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8178 match node.kind() {
8179 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8180 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8181 ))),
8182 _other => {
8183 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8184 Ok(Self::Expression(::std::boxed::Box::new(v)))
8185 } else {
8186 Err(::treesitter_types::ParseError::unexpected_kind(
8187 _other, node,
8188 ))
8189 }
8190 }
8191 }
8192 }
8193}
8194impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
8195 fn span(&self) -> ::treesitter_types::Span {
8196 match self {
8197 Self::Expression(inner) => inner.span(),
8198 Self::SequenceExpression(inner) => inner.span(),
8199 }
8200 }
8201}
8202#[derive(Debug, Clone, PartialEq, Eq)]
8203pub enum StringChildren<'tree> {
8204 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8205 HtmlCharacterReference(::std::boxed::Box<HtmlCharacterReference<'tree>>),
8206 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
8207}
8208impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
8209 #[allow(clippy::collapsible_else_if)]
8210 fn from_node(
8211 node: ::tree_sitter::Node<'tree>,
8212 src: &'tree [u8],
8213 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8214 match node.kind() {
8215 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8216 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
8217 ))),
8218 "html_character_reference" => Ok(Self::HtmlCharacterReference(::std::boxed::Box::new(
8219 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)?,
8220 ))),
8221 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
8222 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
8223 ))),
8224 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8225 }
8226 }
8227}
8228impl ::treesitter_types::Spanned for StringChildren<'_> {
8229 fn span(&self) -> ::treesitter_types::Span {
8230 match self {
8231 Self::EscapeSequence(inner) => inner.span(),
8232 Self::HtmlCharacterReference(inner) => inner.span(),
8233 Self::StringFragment(inner) => inner.span(),
8234 }
8235 }
8236}
8237#[derive(Debug, Clone, PartialEq, Eq)]
8238pub enum SubscriptExpressionIndex<'tree> {
8239 Expression(::std::boxed::Box<Expression<'tree>>),
8240 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8241}
8242impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionIndex<'tree> {
8243 #[allow(clippy::collapsible_else_if)]
8244 fn from_node(
8245 node: ::tree_sitter::Node<'tree>,
8246 src: &'tree [u8],
8247 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8248 match node.kind() {
8249 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8250 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8251 ))),
8252 _other => {
8253 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8254 Ok(Self::Expression(::std::boxed::Box::new(v)))
8255 } else {
8256 Err(::treesitter_types::ParseError::unexpected_kind(
8257 _other, node,
8258 ))
8259 }
8260 }
8261 }
8262 }
8263}
8264impl ::treesitter_types::Spanned for SubscriptExpressionIndex<'_> {
8265 fn span(&self) -> ::treesitter_types::Span {
8266 match self {
8267 Self::Expression(inner) => inner.span(),
8268 Self::SequenceExpression(inner) => inner.span(),
8269 }
8270 }
8271}
8272#[derive(Debug, Clone, PartialEq, Eq)]
8273pub enum SwitchBodyChildren<'tree> {
8274 SwitchCase(::std::boxed::Box<SwitchCase<'tree>>),
8275 SwitchDefault(::std::boxed::Box<SwitchDefault<'tree>>),
8276}
8277impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBodyChildren<'tree> {
8278 #[allow(clippy::collapsible_else_if)]
8279 fn from_node(
8280 node: ::tree_sitter::Node<'tree>,
8281 src: &'tree [u8],
8282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8283 match node.kind() {
8284 "switch_case" => Ok(Self::SwitchCase(::std::boxed::Box::new(
8285 <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)?,
8286 ))),
8287 "switch_default" => Ok(Self::SwitchDefault(::std::boxed::Box::new(
8288 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)?,
8289 ))),
8290 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8291 }
8292 }
8293}
8294impl ::treesitter_types::Spanned for SwitchBodyChildren<'_> {
8295 fn span(&self) -> ::treesitter_types::Span {
8296 match self {
8297 Self::SwitchCase(inner) => inner.span(),
8298 Self::SwitchDefault(inner) => inner.span(),
8299 }
8300 }
8301}
8302#[derive(Debug, Clone, PartialEq, Eq)]
8303pub enum SwitchCaseValue<'tree> {
8304 Expression(::std::boxed::Box<Expression<'tree>>),
8305 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8306}
8307impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCaseValue<'tree> {
8308 #[allow(clippy::collapsible_else_if)]
8309 fn from_node(
8310 node: ::tree_sitter::Node<'tree>,
8311 src: &'tree [u8],
8312 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8313 match node.kind() {
8314 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8315 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8316 ))),
8317 _other => {
8318 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8319 Ok(Self::Expression(::std::boxed::Box::new(v)))
8320 } else {
8321 Err(::treesitter_types::ParseError::unexpected_kind(
8322 _other, node,
8323 ))
8324 }
8325 }
8326 }
8327 }
8328}
8329impl ::treesitter_types::Spanned for SwitchCaseValue<'_> {
8330 fn span(&self) -> ::treesitter_types::Span {
8331 match self {
8332 Self::Expression(inner) => inner.span(),
8333 Self::SequenceExpression(inner) => inner.span(),
8334 }
8335 }
8336}
8337#[derive(Debug, Clone, PartialEq, Eq)]
8338pub enum TemplateStringChildren<'tree> {
8339 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
8340 StringFragment(::std::boxed::Box<StringFragment<'tree>>),
8341 TemplateSubstitution(::std::boxed::Box<TemplateSubstitution<'tree>>),
8342}
8343impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateStringChildren<'tree> {
8344 #[allow(clippy::collapsible_else_if)]
8345 fn from_node(
8346 node: ::tree_sitter::Node<'tree>,
8347 src: &'tree [u8],
8348 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8349 match node.kind() {
8350 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
8351 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
8352 ))),
8353 "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
8354 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
8355 ))),
8356 "template_substitution" => Ok(Self::TemplateSubstitution(::std::boxed::Box::new(
8357 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)?,
8358 ))),
8359 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8360 }
8361 }
8362}
8363impl ::treesitter_types::Spanned for TemplateStringChildren<'_> {
8364 fn span(&self) -> ::treesitter_types::Span {
8365 match self {
8366 Self::EscapeSequence(inner) => inner.span(),
8367 Self::StringFragment(inner) => inner.span(),
8368 Self::TemplateSubstitution(inner) => inner.span(),
8369 }
8370 }
8371}
8372#[derive(Debug, Clone, PartialEq, Eq)]
8373pub enum TemplateSubstitutionChildren<'tree> {
8374 Expression(::std::boxed::Box<Expression<'tree>>),
8375 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8376}
8377impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitutionChildren<'tree> {
8378 #[allow(clippy::collapsible_else_if)]
8379 fn from_node(
8380 node: ::tree_sitter::Node<'tree>,
8381 src: &'tree [u8],
8382 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8383 match node.kind() {
8384 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8385 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8386 ))),
8387 _other => {
8388 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8389 Ok(Self::Expression(::std::boxed::Box::new(v)))
8390 } else {
8391 Err(::treesitter_types::ParseError::unexpected_kind(
8392 _other, node,
8393 ))
8394 }
8395 }
8396 }
8397 }
8398}
8399impl ::treesitter_types::Spanned for TemplateSubstitutionChildren<'_> {
8400 fn span(&self) -> ::treesitter_types::Span {
8401 match self {
8402 Self::Expression(inner) => inner.span(),
8403 Self::SequenceExpression(inner) => inner.span(),
8404 }
8405 }
8406}
8407#[derive(Debug, Clone, PartialEq, Eq)]
8408pub enum ThrowStatementChildren<'tree> {
8409 Expression(::std::boxed::Box<Expression<'tree>>),
8410 SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
8411}
8412impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatementChildren<'tree> {
8413 #[allow(clippy::collapsible_else_if)]
8414 fn from_node(
8415 node: ::tree_sitter::Node<'tree>,
8416 src: &'tree [u8],
8417 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8418 match node.kind() {
8419 "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
8420 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
8421 ))),
8422 _other => {
8423 if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
8424 Ok(Self::Expression(::std::boxed::Box::new(v)))
8425 } else {
8426 Err(::treesitter_types::ParseError::unexpected_kind(
8427 _other, node,
8428 ))
8429 }
8430 }
8431 }
8432 }
8433}
8434impl ::treesitter_types::Spanned for ThrowStatementChildren<'_> {
8435 fn span(&self) -> ::treesitter_types::Span {
8436 match self {
8437 Self::Expression(inner) => inner.span(),
8438 Self::SequenceExpression(inner) => inner.span(),
8439 }
8440 }
8441}
8442#[derive(Debug, Clone, PartialEq, Eq)]
8443pub enum UnaryExpressionOperator {
8444 Bang(::treesitter_types::Span),
8445 Plus(::treesitter_types::Span),
8446 Minus(::treesitter_types::Span),
8447 Delete(::treesitter_types::Span),
8448 Typeof(::treesitter_types::Span),
8449 Void(::treesitter_types::Span),
8450 Tilde(::treesitter_types::Span),
8451}
8452impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
8453 #[allow(clippy::collapsible_else_if)]
8454 fn from_node(
8455 node: ::tree_sitter::Node<'tree>,
8456 _src: &'tree [u8],
8457 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8458 match node.kind() {
8459 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
8460 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
8461 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
8462 "delete" => Ok(Self::Delete(::treesitter_types::Span::from(node))),
8463 "typeof" => Ok(Self::Typeof(::treesitter_types::Span::from(node))),
8464 "void" => Ok(Self::Void(::treesitter_types::Span::from(node))),
8465 "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
8466 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8467 }
8468 }
8469}
8470impl ::treesitter_types::Spanned for UnaryExpressionOperator {
8471 fn span(&self) -> ::treesitter_types::Span {
8472 match self {
8473 Self::Bang(span) => *span,
8474 Self::Plus(span) => *span,
8475 Self::Minus(span) => *span,
8476 Self::Delete(span) => *span,
8477 Self::Typeof(span) => *span,
8478 Self::Void(span) => *span,
8479 Self::Tilde(span) => *span,
8480 }
8481 }
8482}
8483#[derive(Debug, Clone, PartialEq, Eq)]
8484pub enum UpdateExpressionOperator {
8485 PlusPlus(::treesitter_types::Span),
8486 MinusMinus(::treesitter_types::Span),
8487}
8488impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
8489 #[allow(clippy::collapsible_else_if)]
8490 fn from_node(
8491 node: ::tree_sitter::Node<'tree>,
8492 _src: &'tree [u8],
8493 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8494 match node.kind() {
8495 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
8496 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
8497 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8498 }
8499 }
8500}
8501impl ::treesitter_types::Spanned for UpdateExpressionOperator {
8502 fn span(&self) -> ::treesitter_types::Span {
8503 match self {
8504 Self::PlusPlus(span) => *span,
8505 Self::MinusMinus(span) => *span,
8506 }
8507 }
8508}
8509#[derive(Debug, Clone, PartialEq, Eq)]
8510pub enum UsingDeclarationKind {
8511 Await(::treesitter_types::Span),
8512 Using(::treesitter_types::Span),
8513}
8514impl<'tree> ::treesitter_types::FromNode<'tree> for UsingDeclarationKind {
8515 #[allow(clippy::collapsible_else_if)]
8516 fn from_node(
8517 node: ::tree_sitter::Node<'tree>,
8518 _src: &'tree [u8],
8519 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8520 match node.kind() {
8521 "await" => Ok(Self::Await(::treesitter_types::Span::from(node))),
8522 "using" => Ok(Self::Using(::treesitter_types::Span::from(node))),
8523 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8524 }
8525 }
8526}
8527impl ::treesitter_types::Spanned for UsingDeclarationKind {
8528 fn span(&self) -> ::treesitter_types::Span {
8529 match self {
8530 Self::Await(span) => *span,
8531 Self::Using(span) => *span,
8532 }
8533 }
8534}
8535#[derive(Debug, Clone, PartialEq, Eq)]
8536pub enum VariableDeclaratorName<'tree> {
8537 ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
8538 Identifier(::std::boxed::Box<Identifier<'tree>>),
8539 ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
8540}
8541impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
8542 #[allow(clippy::collapsible_else_if)]
8543 fn from_node(
8544 node: ::tree_sitter::Node<'tree>,
8545 src: &'tree [u8],
8546 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
8547 match node.kind() {
8548 "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
8549 <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8550 ))),
8551 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
8552 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
8553 ))),
8554 "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
8555 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
8556 ))),
8557 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
8558 }
8559 }
8560}
8561impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
8562 fn span(&self) -> ::treesitter_types::Span {
8563 match self {
8564 Self::ArrayPattern(inner) => inner.span(),
8565 Self::Identifier(inner) => inner.span(),
8566 Self::ObjectPattern(inner) => inner.span(),
8567 }
8568 }
8569}
8570#[derive(Debug, Clone, PartialEq, Eq)]
8571pub enum AnyNode<'tree> {
8572 Declaration(Declaration<'tree>),
8573 Expression(Expression<'tree>),
8574 Pattern(Pattern<'tree>),
8575 PrimaryExpression(PrimaryExpression<'tree>),
8576 Statement(Statement<'tree>),
8577 Arguments(Arguments<'tree>),
8578 Array(Array<'tree>),
8579 ArrayPattern(ArrayPattern<'tree>),
8580 ArrowFunction(ArrowFunction<'tree>),
8581 AssignmentExpression(AssignmentExpression<'tree>),
8582 AssignmentPattern(AssignmentPattern<'tree>),
8583 AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
8584 AwaitExpression(AwaitExpression<'tree>),
8585 BinaryExpression(BinaryExpression<'tree>),
8586 BreakStatement(BreakStatement<'tree>),
8587 CallExpression(CallExpression<'tree>),
8588 CatchClause(CatchClause<'tree>),
8589 Class(Class<'tree>),
8590 ClassBody(ClassBody<'tree>),
8591 ClassDeclaration(ClassDeclaration<'tree>),
8592 ClassHeritage(ClassHeritage<'tree>),
8593 ClassStaticBlock(ClassStaticBlock<'tree>),
8594 ComputedPropertyName(ComputedPropertyName<'tree>),
8595 ContinueStatement(ContinueStatement<'tree>),
8596 DebuggerStatement(DebuggerStatement<'tree>),
8597 Decorator(Decorator<'tree>),
8598 DoStatement(DoStatement<'tree>),
8599 ElseClause(ElseClause<'tree>),
8600 EmptyStatement(EmptyStatement<'tree>),
8601 ExportClause(ExportClause<'tree>),
8602 ExportSpecifier(ExportSpecifier<'tree>),
8603 ExportStatement(ExportStatement<'tree>),
8604 ExpressionStatement(ExpressionStatement<'tree>),
8605 FieldDefinition(FieldDefinition<'tree>),
8606 FinallyClause(FinallyClause<'tree>),
8607 ForInStatement(ForInStatement<'tree>),
8608 ForStatement(ForStatement<'tree>),
8609 FormalParameters(FormalParameters<'tree>),
8610 FunctionDeclaration(FunctionDeclaration<'tree>),
8611 FunctionExpression(FunctionExpression<'tree>),
8612 GeneratorFunction(GeneratorFunction<'tree>),
8613 GeneratorFunctionDeclaration(GeneratorFunctionDeclaration<'tree>),
8614 IfStatement(IfStatement<'tree>),
8615 Import(Import<'tree>),
8616 ImportAttribute(ImportAttribute<'tree>),
8617 ImportClause(ImportClause<'tree>),
8618 ImportSpecifier(ImportSpecifier<'tree>),
8619 ImportStatement(ImportStatement<'tree>),
8620 JsxAttribute(JsxAttribute<'tree>),
8621 JsxClosingElement(JsxClosingElement<'tree>),
8622 JsxElement(JsxElement<'tree>),
8623 JsxExpression(JsxExpression<'tree>),
8624 JsxNamespaceName(JsxNamespaceName<'tree>),
8625 JsxOpeningElement(JsxOpeningElement<'tree>),
8626 JsxSelfClosingElement(JsxSelfClosingElement<'tree>),
8627 LabeledStatement(LabeledStatement<'tree>),
8628 LexicalDeclaration(LexicalDeclaration<'tree>),
8629 MemberExpression(MemberExpression<'tree>),
8630 MetaProperty(MetaProperty<'tree>),
8631 MethodDefinition(MethodDefinition<'tree>),
8632 NamedImports(NamedImports<'tree>),
8633 NamespaceExport(NamespaceExport<'tree>),
8634 NamespaceImport(NamespaceImport<'tree>),
8635 NewExpression(NewExpression<'tree>),
8636 Object(Object<'tree>),
8637 ObjectAssignmentPattern(ObjectAssignmentPattern<'tree>),
8638 ObjectPattern(ObjectPattern<'tree>),
8639 Pair(Pair<'tree>),
8640 PairPattern(PairPattern<'tree>),
8641 ParenthesizedExpression(ParenthesizedExpression<'tree>),
8642 Program(Program<'tree>),
8643 Regex(Regex<'tree>),
8644 RestPattern(RestPattern<'tree>),
8645 ReturnStatement(ReturnStatement<'tree>),
8646 SequenceExpression(SequenceExpression<'tree>),
8647 SpreadElement(SpreadElement<'tree>),
8648 StatementBlock(StatementBlock<'tree>),
8649 String(String<'tree>),
8650 SubscriptExpression(SubscriptExpression<'tree>),
8651 SwitchBody(SwitchBody<'tree>),
8652 SwitchCase(SwitchCase<'tree>),
8653 SwitchDefault(SwitchDefault<'tree>),
8654 SwitchStatement(SwitchStatement<'tree>),
8655 TemplateString(TemplateString<'tree>),
8656 TemplateSubstitution(TemplateSubstitution<'tree>),
8657 TernaryExpression(TernaryExpression<'tree>),
8658 ThrowStatement(ThrowStatement<'tree>),
8659 TryStatement(TryStatement<'tree>),
8660 UnaryExpression(UnaryExpression<'tree>),
8661 UpdateExpression(UpdateExpression<'tree>),
8662 UsingDeclaration(UsingDeclaration<'tree>),
8663 VariableDeclaration(VariableDeclaration<'tree>),
8664 VariableDeclarator(VariableDeclarator<'tree>),
8665 WhileStatement(WhileStatement<'tree>),
8666 WithStatement(WithStatement<'tree>),
8667 YieldExpression(YieldExpression<'tree>),
8668 Comment(Comment<'tree>),
8669 EscapeSequence(EscapeSequence<'tree>),
8670 False(False<'tree>),
8671 HashBangLine(HashBangLine<'tree>),
8672 HtmlCharacterReference(HtmlCharacterReference<'tree>),
8673 HtmlComment(HtmlComment<'tree>),
8674 Identifier(Identifier<'tree>),
8675 JsxText(JsxText<'tree>),
8676 Null(Null<'tree>),
8677 Number(Number<'tree>),
8678 OptionalChain(OptionalChain<'tree>),
8679 PrivatePropertyIdentifier(PrivatePropertyIdentifier<'tree>),
8680 PropertyIdentifier(PropertyIdentifier<'tree>),
8681 RegexFlags(RegexFlags<'tree>),
8682 RegexPattern(RegexPattern<'tree>),
8683 ShorthandPropertyIdentifier(ShorthandPropertyIdentifier<'tree>),
8684 ShorthandPropertyIdentifierPattern(ShorthandPropertyIdentifierPattern<'tree>),
8685 StatementIdentifier(StatementIdentifier<'tree>),
8686 StringFragment(StringFragment<'tree>),
8687 Super(Super<'tree>),
8688 This(This<'tree>),
8689 True(True<'tree>),
8690 Undefined(Undefined<'tree>),
8691 Unknown(::tree_sitter::Node<'tree>),
8692}
8693impl<'tree> AnyNode<'tree> {
8694 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
8695 match node.kind() {
8696 "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
8697 .map(Self::Declaration)
8698 .unwrap_or(Self::Unknown(node)),
8699 "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
8700 .map(Self::Expression)
8701 .unwrap_or(Self::Unknown(node)),
8702 "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
8703 .map(Self::Pattern)
8704 .unwrap_or(Self::Unknown(node)),
8705 "primary_expression" => {
8706 <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
8707 .map(Self::PrimaryExpression)
8708 .unwrap_or(Self::Unknown(node))
8709 }
8710 "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
8711 .map(Self::Statement)
8712 .unwrap_or(Self::Unknown(node)),
8713 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
8714 .map(Self::Arguments)
8715 .unwrap_or(Self::Unknown(node)),
8716 "array" => <Array as ::treesitter_types::FromNode>::from_node(node, src)
8717 .map(Self::Array)
8718 .unwrap_or(Self::Unknown(node)),
8719 "array_pattern" => <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
8720 .map(Self::ArrayPattern)
8721 .unwrap_or(Self::Unknown(node)),
8722 "arrow_function" => {
8723 <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
8724 .map(Self::ArrowFunction)
8725 .unwrap_or(Self::Unknown(node))
8726 }
8727 "assignment_expression" => {
8728 <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
8729 .map(Self::AssignmentExpression)
8730 .unwrap_or(Self::Unknown(node))
8731 }
8732 "assignment_pattern" => {
8733 <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
8734 .map(Self::AssignmentPattern)
8735 .unwrap_or(Self::Unknown(node))
8736 }
8737 "augmented_assignment_expression" => {
8738 <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
8739 node, src,
8740 )
8741 .map(Self::AugmentedAssignmentExpression)
8742 .unwrap_or(Self::Unknown(node))
8743 }
8744 "await_expression" => {
8745 <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
8746 .map(Self::AwaitExpression)
8747 .unwrap_or(Self::Unknown(node))
8748 }
8749 "binary_expression" => {
8750 <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
8751 .map(Self::BinaryExpression)
8752 .unwrap_or(Self::Unknown(node))
8753 }
8754 "break_statement" => {
8755 <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
8756 .map(Self::BreakStatement)
8757 .unwrap_or(Self::Unknown(node))
8758 }
8759 "call_expression" => {
8760 <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
8761 .map(Self::CallExpression)
8762 .unwrap_or(Self::Unknown(node))
8763 }
8764 "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
8765 .map(Self::CatchClause)
8766 .unwrap_or(Self::Unknown(node)),
8767 "class" => <Class as ::treesitter_types::FromNode>::from_node(node, src)
8768 .map(Self::Class)
8769 .unwrap_or(Self::Unknown(node)),
8770 "class_body" => <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
8771 .map(Self::ClassBody)
8772 .unwrap_or(Self::Unknown(node)),
8773 "class_declaration" => {
8774 <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8775 .map(Self::ClassDeclaration)
8776 .unwrap_or(Self::Unknown(node))
8777 }
8778 "class_heritage" => {
8779 <ClassHeritage as ::treesitter_types::FromNode>::from_node(node, src)
8780 .map(Self::ClassHeritage)
8781 .unwrap_or(Self::Unknown(node))
8782 }
8783 "class_static_block" => {
8784 <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)
8785 .map(Self::ClassStaticBlock)
8786 .unwrap_or(Self::Unknown(node))
8787 }
8788 "computed_property_name" => {
8789 <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
8790 .map(Self::ComputedPropertyName)
8791 .unwrap_or(Self::Unknown(node))
8792 }
8793 "continue_statement" => {
8794 <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
8795 .map(Self::ContinueStatement)
8796 .unwrap_or(Self::Unknown(node))
8797 }
8798 "debugger_statement" => {
8799 <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)
8800 .map(Self::DebuggerStatement)
8801 .unwrap_or(Self::Unknown(node))
8802 }
8803 "decorator" => <Decorator as ::treesitter_types::FromNode>::from_node(node, src)
8804 .map(Self::Decorator)
8805 .unwrap_or(Self::Unknown(node)),
8806 "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
8807 .map(Self::DoStatement)
8808 .unwrap_or(Self::Unknown(node)),
8809 "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
8810 .map(Self::ElseClause)
8811 .unwrap_or(Self::Unknown(node)),
8812 "empty_statement" => {
8813 <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
8814 .map(Self::EmptyStatement)
8815 .unwrap_or(Self::Unknown(node))
8816 }
8817 "export_clause" => <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)
8818 .map(Self::ExportClause)
8819 .unwrap_or(Self::Unknown(node)),
8820 "export_specifier" => {
8821 <ExportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8822 .map(Self::ExportSpecifier)
8823 .unwrap_or(Self::Unknown(node))
8824 }
8825 "export_statement" => {
8826 <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)
8827 .map(Self::ExportStatement)
8828 .unwrap_or(Self::Unknown(node))
8829 }
8830 "expression_statement" => {
8831 <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
8832 .map(Self::ExpressionStatement)
8833 .unwrap_or(Self::Unknown(node))
8834 }
8835 "field_definition" => {
8836 <FieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8837 .map(Self::FieldDefinition)
8838 .unwrap_or(Self::Unknown(node))
8839 }
8840 "finally_clause" => {
8841 <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
8842 .map(Self::FinallyClause)
8843 .unwrap_or(Self::Unknown(node))
8844 }
8845 "for_in_statement" => {
8846 <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)
8847 .map(Self::ForInStatement)
8848 .unwrap_or(Self::Unknown(node))
8849 }
8850 "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
8851 .map(Self::ForStatement)
8852 .unwrap_or(Self::Unknown(node)),
8853 "formal_parameters" => {
8854 <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
8855 .map(Self::FormalParameters)
8856 .unwrap_or(Self::Unknown(node))
8857 }
8858 "function_declaration" => {
8859 <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8860 .map(Self::FunctionDeclaration)
8861 .unwrap_or(Self::Unknown(node))
8862 }
8863 "function_expression" => {
8864 <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)
8865 .map(Self::FunctionExpression)
8866 .unwrap_or(Self::Unknown(node))
8867 }
8868 "generator_function" => {
8869 <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)
8870 .map(Self::GeneratorFunction)
8871 .unwrap_or(Self::Unknown(node))
8872 }
8873 "generator_function_declaration" => {
8874 <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8875 .map(Self::GeneratorFunctionDeclaration)
8876 .unwrap_or(Self::Unknown(node))
8877 }
8878 "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
8879 .map(Self::IfStatement)
8880 .unwrap_or(Self::Unknown(node)),
8881 "import" => <Import as ::treesitter_types::FromNode>::from_node(node, src)
8882 .map(Self::Import)
8883 .unwrap_or(Self::Unknown(node)),
8884 "import_attribute" => {
8885 <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)
8886 .map(Self::ImportAttribute)
8887 .unwrap_or(Self::Unknown(node))
8888 }
8889 "import_clause" => <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)
8890 .map(Self::ImportClause)
8891 .unwrap_or(Self::Unknown(node)),
8892 "import_specifier" => {
8893 <ImportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
8894 .map(Self::ImportSpecifier)
8895 .unwrap_or(Self::Unknown(node))
8896 }
8897 "import_statement" => {
8898 <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)
8899 .map(Self::ImportStatement)
8900 .unwrap_or(Self::Unknown(node))
8901 }
8902 "jsx_attribute" => <JsxAttribute as ::treesitter_types::FromNode>::from_node(node, src)
8903 .map(Self::JsxAttribute)
8904 .unwrap_or(Self::Unknown(node)),
8905 "jsx_closing_element" => {
8906 <JsxClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
8907 .map(Self::JsxClosingElement)
8908 .unwrap_or(Self::Unknown(node))
8909 }
8910 "jsx_element" => <JsxElement as ::treesitter_types::FromNode>::from_node(node, src)
8911 .map(Self::JsxElement)
8912 .unwrap_or(Self::Unknown(node)),
8913 "jsx_expression" => {
8914 <JsxExpression as ::treesitter_types::FromNode>::from_node(node, src)
8915 .map(Self::JsxExpression)
8916 .unwrap_or(Self::Unknown(node))
8917 }
8918 "jsx_namespace_name" => {
8919 <JsxNamespaceName as ::treesitter_types::FromNode>::from_node(node, src)
8920 .map(Self::JsxNamespaceName)
8921 .unwrap_or(Self::Unknown(node))
8922 }
8923 "jsx_opening_element" => {
8924 <JsxOpeningElement as ::treesitter_types::FromNode>::from_node(node, src)
8925 .map(Self::JsxOpeningElement)
8926 .unwrap_or(Self::Unknown(node))
8927 }
8928 "jsx_self_closing_element" => {
8929 <JsxSelfClosingElement as ::treesitter_types::FromNode>::from_node(node, src)
8930 .map(Self::JsxSelfClosingElement)
8931 .unwrap_or(Self::Unknown(node))
8932 }
8933 "labeled_statement" => {
8934 <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
8935 .map(Self::LabeledStatement)
8936 .unwrap_or(Self::Unknown(node))
8937 }
8938 "lexical_declaration" => {
8939 <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
8940 .map(Self::LexicalDeclaration)
8941 .unwrap_or(Self::Unknown(node))
8942 }
8943 "member_expression" => {
8944 <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
8945 .map(Self::MemberExpression)
8946 .unwrap_or(Self::Unknown(node))
8947 }
8948 "meta_property" => <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)
8949 .map(Self::MetaProperty)
8950 .unwrap_or(Self::Unknown(node)),
8951 "method_definition" => {
8952 <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
8953 .map(Self::MethodDefinition)
8954 .unwrap_or(Self::Unknown(node))
8955 }
8956 "named_imports" => <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)
8957 .map(Self::NamedImports)
8958 .unwrap_or(Self::Unknown(node)),
8959 "namespace_export" => {
8960 <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)
8961 .map(Self::NamespaceExport)
8962 .unwrap_or(Self::Unknown(node))
8963 }
8964 "namespace_import" => {
8965 <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)
8966 .map(Self::NamespaceImport)
8967 .unwrap_or(Self::Unknown(node))
8968 }
8969 "new_expression" => {
8970 <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
8971 .map(Self::NewExpression)
8972 .unwrap_or(Self::Unknown(node))
8973 }
8974 "object" => <Object as ::treesitter_types::FromNode>::from_node(node, src)
8975 .map(Self::Object)
8976 .unwrap_or(Self::Unknown(node)),
8977 "object_assignment_pattern" => {
8978 <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
8979 .map(Self::ObjectAssignmentPattern)
8980 .unwrap_or(Self::Unknown(node))
8981 }
8982 "object_pattern" => {
8983 <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
8984 .map(Self::ObjectPattern)
8985 .unwrap_or(Self::Unknown(node))
8986 }
8987 "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
8988 .map(Self::Pair)
8989 .unwrap_or(Self::Unknown(node)),
8990 "pair_pattern" => <PairPattern as ::treesitter_types::FromNode>::from_node(node, src)
8991 .map(Self::PairPattern)
8992 .unwrap_or(Self::Unknown(node)),
8993 "parenthesized_expression" => {
8994 <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
8995 .map(Self::ParenthesizedExpression)
8996 .unwrap_or(Self::Unknown(node))
8997 }
8998 "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
8999 .map(Self::Program)
9000 .unwrap_or(Self::Unknown(node)),
9001 "regex" => <Regex as ::treesitter_types::FromNode>::from_node(node, src)
9002 .map(Self::Regex)
9003 .unwrap_or(Self::Unknown(node)),
9004 "rest_pattern" => <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
9005 .map(Self::RestPattern)
9006 .unwrap_or(Self::Unknown(node)),
9007 "return_statement" => {
9008 <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
9009 .map(Self::ReturnStatement)
9010 .unwrap_or(Self::Unknown(node))
9011 }
9012 "sequence_expression" => {
9013 <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
9014 .map(Self::SequenceExpression)
9015 .unwrap_or(Self::Unknown(node))
9016 }
9017 "spread_element" => {
9018 <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
9019 .map(Self::SpreadElement)
9020 .unwrap_or(Self::Unknown(node))
9021 }
9022 "statement_block" => {
9023 <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
9024 .map(Self::StatementBlock)
9025 .unwrap_or(Self::Unknown(node))
9026 }
9027 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
9028 .map(Self::String)
9029 .unwrap_or(Self::Unknown(node)),
9030 "subscript_expression" => {
9031 <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
9032 .map(Self::SubscriptExpression)
9033 .unwrap_or(Self::Unknown(node))
9034 }
9035 "switch_body" => <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
9036 .map(Self::SwitchBody)
9037 .unwrap_or(Self::Unknown(node)),
9038 "switch_case" => <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)
9039 .map(Self::SwitchCase)
9040 .unwrap_or(Self::Unknown(node)),
9041 "switch_default" => {
9042 <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)
9043 .map(Self::SwitchDefault)
9044 .unwrap_or(Self::Unknown(node))
9045 }
9046 "switch_statement" => {
9047 <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
9048 .map(Self::SwitchStatement)
9049 .unwrap_or(Self::Unknown(node))
9050 }
9051 "template_string" => {
9052 <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
9053 .map(Self::TemplateString)
9054 .unwrap_or(Self::Unknown(node))
9055 }
9056 "template_substitution" => {
9057 <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)
9058 .map(Self::TemplateSubstitution)
9059 .unwrap_or(Self::Unknown(node))
9060 }
9061 "ternary_expression" => {
9062 <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9063 .map(Self::TernaryExpression)
9064 .unwrap_or(Self::Unknown(node))
9065 }
9066 "throw_statement" => {
9067 <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
9068 .map(Self::ThrowStatement)
9069 .unwrap_or(Self::Unknown(node))
9070 }
9071 "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
9072 .map(Self::TryStatement)
9073 .unwrap_or(Self::Unknown(node)),
9074 "unary_expression" => {
9075 <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
9076 .map(Self::UnaryExpression)
9077 .unwrap_or(Self::Unknown(node))
9078 }
9079 "update_expression" => {
9080 <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
9081 .map(Self::UpdateExpression)
9082 .unwrap_or(Self::Unknown(node))
9083 }
9084 "using_declaration" => {
9085 <UsingDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9086 .map(Self::UsingDeclaration)
9087 .unwrap_or(Self::Unknown(node))
9088 }
9089 "variable_declaration" => {
9090 <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
9091 .map(Self::VariableDeclaration)
9092 .unwrap_or(Self::Unknown(node))
9093 }
9094 "variable_declarator" => {
9095 <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
9096 .map(Self::VariableDeclarator)
9097 .unwrap_or(Self::Unknown(node))
9098 }
9099 "while_statement" => {
9100 <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
9101 .map(Self::WhileStatement)
9102 .unwrap_or(Self::Unknown(node))
9103 }
9104 "with_statement" => {
9105 <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)
9106 .map(Self::WithStatement)
9107 .unwrap_or(Self::Unknown(node))
9108 }
9109 "yield_expression" => {
9110 <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
9111 .map(Self::YieldExpression)
9112 .unwrap_or(Self::Unknown(node))
9113 }
9114 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
9115 .map(Self::Comment)
9116 .unwrap_or(Self::Unknown(node)),
9117 "escape_sequence" => {
9118 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
9119 .map(Self::EscapeSequence)
9120 .unwrap_or(Self::Unknown(node))
9121 }
9122 "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
9123 .map(Self::False)
9124 .unwrap_or(Self::Unknown(node)),
9125 "hash_bang_line" => {
9126 <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
9127 .map(Self::HashBangLine)
9128 .unwrap_or(Self::Unknown(node))
9129 }
9130 "html_character_reference" => {
9131 <HtmlCharacterReference as ::treesitter_types::FromNode>::from_node(node, src)
9132 .map(Self::HtmlCharacterReference)
9133 .unwrap_or(Self::Unknown(node))
9134 }
9135 "html_comment" => <HtmlComment as ::treesitter_types::FromNode>::from_node(node, src)
9136 .map(Self::HtmlComment)
9137 .unwrap_or(Self::Unknown(node)),
9138 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
9139 .map(Self::Identifier)
9140 .unwrap_or(Self::Unknown(node)),
9141 "jsx_text" => <JsxText as ::treesitter_types::FromNode>::from_node(node, src)
9142 .map(Self::JsxText)
9143 .unwrap_or(Self::Unknown(node)),
9144 "null" => <Null as ::treesitter_types::FromNode>::from_node(node, src)
9145 .map(Self::Null)
9146 .unwrap_or(Self::Unknown(node)),
9147 "number" => <Number as ::treesitter_types::FromNode>::from_node(node, src)
9148 .map(Self::Number)
9149 .unwrap_or(Self::Unknown(node)),
9150 "optional_chain" => {
9151 <OptionalChain as ::treesitter_types::FromNode>::from_node(node, src)
9152 .map(Self::OptionalChain)
9153 .unwrap_or(Self::Unknown(node))
9154 }
9155 "private_property_identifier" => {
9156 <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9157 .map(Self::PrivatePropertyIdentifier)
9158 .unwrap_or(Self::Unknown(node))
9159 }
9160 "property_identifier" => {
9161 <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9162 .map(Self::PropertyIdentifier)
9163 .unwrap_or(Self::Unknown(node))
9164 }
9165 "regex_flags" => <RegexFlags as ::treesitter_types::FromNode>::from_node(node, src)
9166 .map(Self::RegexFlags)
9167 .unwrap_or(Self::Unknown(node)),
9168 "regex_pattern" => <RegexPattern as ::treesitter_types::FromNode>::from_node(node, src)
9169 .map(Self::RegexPattern)
9170 .unwrap_or(Self::Unknown(node)),
9171 "shorthand_property_identifier" => {
9172 <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9173 .map(Self::ShorthandPropertyIdentifier)
9174 .unwrap_or(Self::Unknown(node))
9175 }
9176 "shorthand_property_identifier_pattern" => {
9177 <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
9178 node, src,
9179 )
9180 .map(Self::ShorthandPropertyIdentifierPattern)
9181 .unwrap_or(Self::Unknown(node))
9182 }
9183 "statement_identifier" => {
9184 <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
9185 .map(Self::StatementIdentifier)
9186 .unwrap_or(Self::Unknown(node))
9187 }
9188 "string_fragment" => {
9189 <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
9190 .map(Self::StringFragment)
9191 .unwrap_or(Self::Unknown(node))
9192 }
9193 "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
9194 .map(Self::Super)
9195 .unwrap_or(Self::Unknown(node)),
9196 "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
9197 .map(Self::This)
9198 .unwrap_or(Self::Unknown(node)),
9199 "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
9200 .map(Self::True)
9201 .unwrap_or(Self::Unknown(node)),
9202 "undefined" => <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
9203 .map(Self::Undefined)
9204 .unwrap_or(Self::Unknown(node)),
9205 _ => Self::Unknown(node),
9206 }
9207 }
9208}
9209impl ::treesitter_types::Spanned for AnyNode<'_> {
9210 fn span(&self) -> ::treesitter_types::Span {
9211 match self {
9212 Self::Declaration(inner) => inner.span(),
9213 Self::Expression(inner) => inner.span(),
9214 Self::Pattern(inner) => inner.span(),
9215 Self::PrimaryExpression(inner) => inner.span(),
9216 Self::Statement(inner) => inner.span(),
9217 Self::Arguments(inner) => inner.span(),
9218 Self::Array(inner) => inner.span(),
9219 Self::ArrayPattern(inner) => inner.span(),
9220 Self::ArrowFunction(inner) => inner.span(),
9221 Self::AssignmentExpression(inner) => inner.span(),
9222 Self::AssignmentPattern(inner) => inner.span(),
9223 Self::AugmentedAssignmentExpression(inner) => inner.span(),
9224 Self::AwaitExpression(inner) => inner.span(),
9225 Self::BinaryExpression(inner) => inner.span(),
9226 Self::BreakStatement(inner) => inner.span(),
9227 Self::CallExpression(inner) => inner.span(),
9228 Self::CatchClause(inner) => inner.span(),
9229 Self::Class(inner) => inner.span(),
9230 Self::ClassBody(inner) => inner.span(),
9231 Self::ClassDeclaration(inner) => inner.span(),
9232 Self::ClassHeritage(inner) => inner.span(),
9233 Self::ClassStaticBlock(inner) => inner.span(),
9234 Self::ComputedPropertyName(inner) => inner.span(),
9235 Self::ContinueStatement(inner) => inner.span(),
9236 Self::DebuggerStatement(inner) => inner.span(),
9237 Self::Decorator(inner) => inner.span(),
9238 Self::DoStatement(inner) => inner.span(),
9239 Self::ElseClause(inner) => inner.span(),
9240 Self::EmptyStatement(inner) => inner.span(),
9241 Self::ExportClause(inner) => inner.span(),
9242 Self::ExportSpecifier(inner) => inner.span(),
9243 Self::ExportStatement(inner) => inner.span(),
9244 Self::ExpressionStatement(inner) => inner.span(),
9245 Self::FieldDefinition(inner) => inner.span(),
9246 Self::FinallyClause(inner) => inner.span(),
9247 Self::ForInStatement(inner) => inner.span(),
9248 Self::ForStatement(inner) => inner.span(),
9249 Self::FormalParameters(inner) => inner.span(),
9250 Self::FunctionDeclaration(inner) => inner.span(),
9251 Self::FunctionExpression(inner) => inner.span(),
9252 Self::GeneratorFunction(inner) => inner.span(),
9253 Self::GeneratorFunctionDeclaration(inner) => inner.span(),
9254 Self::IfStatement(inner) => inner.span(),
9255 Self::Import(inner) => inner.span(),
9256 Self::ImportAttribute(inner) => inner.span(),
9257 Self::ImportClause(inner) => inner.span(),
9258 Self::ImportSpecifier(inner) => inner.span(),
9259 Self::ImportStatement(inner) => inner.span(),
9260 Self::JsxAttribute(inner) => inner.span(),
9261 Self::JsxClosingElement(inner) => inner.span(),
9262 Self::JsxElement(inner) => inner.span(),
9263 Self::JsxExpression(inner) => inner.span(),
9264 Self::JsxNamespaceName(inner) => inner.span(),
9265 Self::JsxOpeningElement(inner) => inner.span(),
9266 Self::JsxSelfClosingElement(inner) => inner.span(),
9267 Self::LabeledStatement(inner) => inner.span(),
9268 Self::LexicalDeclaration(inner) => inner.span(),
9269 Self::MemberExpression(inner) => inner.span(),
9270 Self::MetaProperty(inner) => inner.span(),
9271 Self::MethodDefinition(inner) => inner.span(),
9272 Self::NamedImports(inner) => inner.span(),
9273 Self::NamespaceExport(inner) => inner.span(),
9274 Self::NamespaceImport(inner) => inner.span(),
9275 Self::NewExpression(inner) => inner.span(),
9276 Self::Object(inner) => inner.span(),
9277 Self::ObjectAssignmentPattern(inner) => inner.span(),
9278 Self::ObjectPattern(inner) => inner.span(),
9279 Self::Pair(inner) => inner.span(),
9280 Self::PairPattern(inner) => inner.span(),
9281 Self::ParenthesizedExpression(inner) => inner.span(),
9282 Self::Program(inner) => inner.span(),
9283 Self::Regex(inner) => inner.span(),
9284 Self::RestPattern(inner) => inner.span(),
9285 Self::ReturnStatement(inner) => inner.span(),
9286 Self::SequenceExpression(inner) => inner.span(),
9287 Self::SpreadElement(inner) => inner.span(),
9288 Self::StatementBlock(inner) => inner.span(),
9289 Self::String(inner) => inner.span(),
9290 Self::SubscriptExpression(inner) => inner.span(),
9291 Self::SwitchBody(inner) => inner.span(),
9292 Self::SwitchCase(inner) => inner.span(),
9293 Self::SwitchDefault(inner) => inner.span(),
9294 Self::SwitchStatement(inner) => inner.span(),
9295 Self::TemplateString(inner) => inner.span(),
9296 Self::TemplateSubstitution(inner) => inner.span(),
9297 Self::TernaryExpression(inner) => inner.span(),
9298 Self::ThrowStatement(inner) => inner.span(),
9299 Self::TryStatement(inner) => inner.span(),
9300 Self::UnaryExpression(inner) => inner.span(),
9301 Self::UpdateExpression(inner) => inner.span(),
9302 Self::UsingDeclaration(inner) => inner.span(),
9303 Self::VariableDeclaration(inner) => inner.span(),
9304 Self::VariableDeclarator(inner) => inner.span(),
9305 Self::WhileStatement(inner) => inner.span(),
9306 Self::WithStatement(inner) => inner.span(),
9307 Self::YieldExpression(inner) => inner.span(),
9308 Self::Comment(inner) => inner.span(),
9309 Self::EscapeSequence(inner) => inner.span(),
9310 Self::False(inner) => inner.span(),
9311 Self::HashBangLine(inner) => inner.span(),
9312 Self::HtmlCharacterReference(inner) => inner.span(),
9313 Self::HtmlComment(inner) => inner.span(),
9314 Self::Identifier(inner) => inner.span(),
9315 Self::JsxText(inner) => inner.span(),
9316 Self::Null(inner) => inner.span(),
9317 Self::Number(inner) => inner.span(),
9318 Self::OptionalChain(inner) => inner.span(),
9319 Self::PrivatePropertyIdentifier(inner) => inner.span(),
9320 Self::PropertyIdentifier(inner) => inner.span(),
9321 Self::RegexFlags(inner) => inner.span(),
9322 Self::RegexPattern(inner) => inner.span(),
9323 Self::ShorthandPropertyIdentifier(inner) => inner.span(),
9324 Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
9325 Self::StatementIdentifier(inner) => inner.span(),
9326 Self::StringFragment(inner) => inner.span(),
9327 Self::Super(inner) => inner.span(),
9328 Self::This(inner) => inner.span(),
9329 Self::True(inner) => inner.span(),
9330 Self::Undefined(inner) => inner.span(),
9331 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
9332 }
9333 }
9334}