1use crate::ast::*;
2use crate::ast::statements::control_flow::{ForInStatement, ForOfStatement};
3use crate::vm::types::NodeCount;
4
5pub struct DefaultVisitor;
6
7impl Visitor for DefaultVisitor {
8 type Output = ();
9
10 fn visit_program(&mut self, program: &Program) -> Self::Output {
11 for statement in &program.body {
12 self.visit_node(statement);
13 }
14 }
15
16 fn visit_variable_declaration(&mut self, decl: &VariableDeclaration) -> Self::Output {
17 for declarator in &decl.declarations {
18 self.visit_node(&declarator.id);
19 if let Some(init) = &declarator.init {
20 self.visit_node(init);
21 }
22 }
23 }
24
25 fn visit_function_declaration(&mut self, decl: &FunctionDeclaration) -> Self::Output {
26 if let Some(id) = &decl.id {
27 self.visit_node(id);
28 }
29 for param in &decl.params {
30 self.visit_node(param);
31 }
32 self.visit_node(&decl.body);
33 }
34
35 fn visit_class_declaration(&mut self, decl: &ClassDeclaration) -> Self::Output {
36 if let Some(id) = &decl.id {
37 self.visit_node(id);
38 }
39 if let Some(super_class) = &decl.super_class {
40 self.visit_node(super_class);
41 }
42 self.visit_node(&decl.body);
43 }
44
45 fn visit_binary_expression(&mut self, expr: &BinaryExpression) -> Self::Output {
46 self.visit_node(&expr.left);
47 self.visit_node(&expr.right);
48 }
49
50 fn visit_unary_expression(&mut self, expr: &UnaryExpression) -> Self::Output {
51 self.visit_node(&expr.argument);
52 }
53
54 fn visit_call_expression(&mut self, expr: &CallExpression) -> Self::Output {
55 self.visit_node(&expr.callee);
56 for arg in &expr.arguments {
57 self.visit_node(arg);
58 }
59 }
60
61 fn visit_new_expression(&mut self, expr: &NewExpression) -> Self::Output {
62 self.visit_node(&expr.callee);
63 for arg in &expr.arguments {
64 self.visit_node(arg);
65 }
66 }
67
68 fn visit_member_expression(&mut self, expr: &MemberExpression) -> Self::Output {
69 self.visit_node(&expr.object);
70 if expr.computed {
71 self.visit_node(&expr.property);
72 }
73 }
74
75 fn visit_assignment_expression(&mut self, expr: &AssignmentExpression) -> Self::Output {
76 self.visit_node(&expr.left);
77 self.visit_node(&expr.right);
78 }
79
80 fn visit_conditional_expression(&mut self, expr: &ConditionalExpression) -> Self::Output {
81 self.visit_node(&expr.test);
82 self.visit_node(&expr.consequent);
83 self.visit_node(&expr.alternate);
84 }
85
86 fn visit_logical_expression(&mut self, expr: &LogicalExpression) -> Self::Output {
87 self.visit_node(&expr.left);
88 self.visit_node(&expr.right);
89 }
90
91 fn visit_update_expression(&mut self, expr: &UpdateExpression) -> Self::Output {
92 self.visit_node(&expr.argument);
93 }
94
95 fn visit_block_statement(&mut self, stmt: &BlockStatement) -> Self::Output {
96 for statement in &stmt.body {
97 self.visit_node(statement);
98 }
99 }
100
101 fn visit_if_statement(&mut self, stmt: &IfStatement) -> Self::Output {
102 self.visit_node(&stmt.test);
103 self.visit_node(&stmt.consequent);
104 if let Some(alternate) = &stmt.alternate {
105 self.visit_node(alternate);
106 }
107 }
108
109 fn visit_for_statement(&mut self, stmt: &ForStatement) -> Self::Output {
110 if let Some(init) = &stmt.init {
111 self.visit_node(init);
112 }
113 if let Some(test) = &stmt.test {
114 self.visit_node(test);
115 }
116 if let Some(update) = &stmt.update {
117 self.visit_node(update);
118 }
119 self.visit_node(&stmt.body);
120 }
121
122 fn visit_for_in_statement(&mut self, stmt: &ForInStatement) -> Self::Output {
123 self.visit_node(&stmt.left);
124 self.visit_node(&stmt.right);
125 self.visit_node(&stmt.body);
126 }
127
128 fn visit_for_of_statement(&mut self, stmt: &ForOfStatement) -> Self::Output {
129 self.visit_node(&stmt.left);
130 self.visit_node(&stmt.right);
131 self.visit_node(&stmt.body);
132 }
133
134 fn visit_while_statement(&mut self, stmt: &WhileStatement) -> Self::Output {
135 self.visit_node(&stmt.test);
136 self.visit_node(&stmt.body);
137 }
138
139 fn visit_do_while_statement(&mut self, stmt: &DoWhileStatement) -> Self::Output {
140 self.visit_node(&stmt.body);
141 self.visit_node(&stmt.test);
142 }
143
144 fn visit_switch_statement(&mut self, stmt: &SwitchStatement) -> Self::Output {
145 self.visit_node(&stmt.discriminant);
146 for case in &stmt.cases {
147 if let Some(test) = &case.test {
148 self.visit_node(test);
149 }
150 for consequent in &case.consequent {
151 self.visit_node(consequent);
152 }
153 }
154 }
155
156 fn visit_try_statement(&mut self, stmt: &TryStatement) -> Self::Output {
157 self.visit_node(&stmt.block);
158 if let Some(handler) = &stmt.handler {
159 self.visit_node(handler);
160 }
161 if let Some(finalizer) = &stmt.finalizer {
162 self.visit_node(finalizer);
163 }
164 }
165
166 fn visit_catch_clause(&mut self, clause: &CatchClause) -> Self::Output {
167 self.visit_node(&clause.param);
168 self.visit_node(&clause.body);
169 }
170
171 fn visit_throw_statement(&mut self, stmt: &ThrowStatement) -> Self::Output {
172 self.visit_node(&stmt.argument);
173 }
174
175 fn visit_return_statement(&mut self, stmt: &ReturnStatement) -> Self::Output {
176 if let Some(argument) = &stmt.argument {
177 self.visit_node(argument);
178 }
179 }
180
181 fn visit_break_statement(&mut self, _stmt: &BreakStatement) -> Self::Output {}
182
183 fn visit_continue_statement(&mut self, _stmt: &ContinueStatement) -> Self::Output {}
184
185 fn visit_expression_statement(&mut self, stmt: &ExpressionStatement) -> Self::Output {
186 self.visit_node(&stmt.expression);
187 }
188
189 fn visit_array_literal(&mut self, lit: &ArrayLiteral) -> Self::Output {
190 for elem in lit.elements.iter().flatten() {
191 self.visit_node(elem);
192 }
193 }
194
195 fn visit_object_literal(&mut self, lit: &ObjectLiteral) -> Self::Output {
196 for property in &lit.properties {
197 self.visit_node(property);
198 }
199 }
200
201 fn visit_property(&mut self, prop: &Property) -> Self::Output {
202 if prop.computed {
203 self.visit_node(&prop.key);
204 }
205 self.visit_node(&prop.value);
206 }
207
208 fn visit_identifier(&mut self, _id: &str) -> Self::Output {}
209
210 fn visit_number(&mut self, _num: f64) -> Self::Output {}
211
212 fn visit_string(&mut self, _s: &str) -> Self::Output {}
213
214 fn visit_boolean(&mut self, _b: bool) -> Self::Output {}
215
216 fn visit_null(&mut self) -> Self::Output {}
217
218 fn visit_undefined(&mut self) -> Self::Output {}
219
220 fn visit_this(&mut self) -> Self::Output {}
221
222 fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression) -> Self::Output {
223 for param in &expr.params {
224 self.visit_node(param);
225 }
226 self.visit_node(&expr.body);
227 }
228
229 fn visit_function_expression(&mut self, expr: &FunctionExpression) -> Self::Output {
230 if let Some(id) = &expr.id {
231 self.visit_node(id);
232 }
233 for param in &expr.params {
234 self.visit_node(param);
235 }
236 self.visit_node(&expr.body);
237 }
238
239 fn visit_class_expression(&mut self, expr: &ClassExpression) -> Self::Output {
240 if let Some(id) = &expr.id {
241 self.visit_node(id);
242 }
243 if let Some(super_class) = &expr.super_class {
244 self.visit_node(super_class);
245 }
246 self.visit_node(&expr.body);
247 }
248
249 fn visit_yield_expression(&mut self, expr: &YieldExpression) -> Self::Output {
250 if let Some(argument) = &expr.argument {
251 self.visit_node(argument);
252 }
253 }
254
255 fn visit_await_expression(&mut self, expr: &AwaitExpression) -> Self::Output {
256 self.visit_node(&expr.argument);
257 }
258
259 fn visit_super(&mut self, _super_expr: &Super) -> Self::Output {}
260
261 fn visit_meta_property(&mut self, _prop: &MetaProperty) -> Self::Output {}
262
263 fn visit_spread_element(&mut self, elem: &SpreadElement) -> Self::Output {
264 self.visit_node(&elem.argument);
265 }
266
267 fn visit_rest_element(&mut self, elem: &RestElement) -> Self::Output {
268 self.visit_node(&elem.argument);
269 }
270
271 fn visit_template_literal(&mut self, lit: &TemplateLiteral) -> Self::Output {
272 for expr in &lit.expressions {
273 self.visit_node(expr);
274 }
275 }
276
277 fn visit_tagged_template_expression(&mut self, expr: &TaggedTemplateExpression) -> Self::Output {
278 self.visit_node(&expr.tag);
279 self.visit_node(&expr.quasi);
280 }
281
282 fn visit_import_declaration(&mut self, decl: &ImportDeclaration) -> Self::Output {
283 for specifier in &decl.specifiers {
284 self.visit_node(specifier);
285 }
286 }
287
288 fn visit_export_declaration(&mut self, decl: &ExportDeclaration) -> Self::Output {
289 if let Some(declaration) = &decl.declaration {
290 self.visit_node(declaration);
291 }
292 for specifier in &decl.specifiers {
293 self.visit_node(specifier);
294 }
295 if let Some(source) = &decl.source {
296 self.visit_node(source);
297 }
298 }
299
300 fn visit_labeled_statement(&mut self, stmt: &LabeledStatement) -> Self::Output {
301 self.visit_node(&stmt.label);
302 self.visit_node(&stmt.body);
303 }
304
305 fn visit_with_statement(&mut self, stmt: &WithStatement) -> Self::Output {
306 self.visit_node(&stmt.object);
307 self.visit_node(&stmt.body);
308 }
309
310 fn visit_debugger_statement(&mut self, _stmt: &DebuggerStatement) -> Self::Output {}
311
312 fn visit_bigint(&mut self, _bigint: &str) -> Self::Output {}
313
314 fn visit_regexp(&mut self, _regexp: &RegExp) -> Self::Output {}
315}
316
317pub struct NodeCounter {
318 pub count: NodeCount,
319}
320
321impl NodeCounter {
322 pub fn new() -> Self {
323 Self {
324 count: NodeCount::new(0),
325 }
326 }
327}
328
329impl Default for NodeCounter {
330 fn default() -> Self {
331 Self::new()
332 }
333}
334
335impl Visitor for NodeCounter {
336 type Output = ();
337
338 fn visit_node(&mut self, node: &Node) {
339 self.count.increment();
340 match node {
341 Node::Program(program) => self.visit_program(program),
342 Node::VariableDeclaration(decl) => self.visit_variable_declaration(decl),
343 Node::FunctionDeclaration(decl) => self.visit_function_declaration(decl),
344 Node::ClassDeclaration(decl) => self.visit_class_declaration(decl),
345 Node::BinaryExpression(expr) => self.visit_binary_expression(expr),
346 Node::UnaryExpression(expr) => self.visit_unary_expression(expr),
347 Node::CallExpression(expr) => self.visit_call_expression(expr),
348 Node::NewExpression(expr) => self.visit_new_expression(expr),
349 Node::MemberExpression(expr) => self.visit_member_expression(expr),
350 Node::AssignmentExpression(expr) => self.visit_assignment_expression(expr),
351 Node::ConditionalExpression(expr) => self.visit_conditional_expression(expr),
352 Node::LogicalExpression(expr) => self.visit_logical_expression(expr),
353 Node::UpdateExpression(expr) => self.visit_update_expression(expr),
354 Node::BlockStatement(stmt) => self.visit_block_statement(stmt),
355 Node::IfStatement(stmt) => self.visit_if_statement(stmt),
356 Node::ForStatement(stmt) => self.visit_for_statement(stmt),
357 Node::ForInStatement(stmt) => self.visit_for_in_statement(stmt),
358 Node::ForOfStatement(stmt) => self.visit_for_of_statement(stmt),
359 Node::WhileStatement(stmt) => self.visit_while_statement(stmt),
360 Node::DoWhileStatement(stmt) => self.visit_do_while_statement(stmt),
361 Node::SwitchStatement(stmt) => self.visit_switch_statement(stmt),
362 Node::TryStatement(stmt) => self.visit_try_statement(stmt),
363 Node::CatchClause(clause) => self.visit_catch_clause(clause),
364 Node::ThrowStatement(stmt) => self.visit_throw_statement(stmt),
365 Node::ReturnStatement(stmt) => self.visit_return_statement(stmt),
366 Node::BreakStatement(stmt) => self.visit_break_statement(stmt),
367 Node::ContinueStatement(stmt) => self.visit_continue_statement(stmt),
368 Node::ExpressionStatement(stmt) => self.visit_expression_statement(stmt),
369 Node::ArrayLiteral(lit) => self.visit_array_literal(lit),
370 Node::ObjectLiteral(lit) => self.visit_object_literal(lit),
371 Node::Property(prop) => self.visit_property(prop),
372 Node::Identifier(id) => self.visit_identifier(id),
373 Node::Number(num) => self.visit_number(*num),
374 Node::String(s) => self.visit_string(s),
375 Node::Boolean(b) => self.visit_boolean(*b),
376 Node::Null => self.visit_null(),
377 Node::Undefined => self.visit_undefined(),
378 Node::This => self.visit_this(),
379 Node::ArrowFunctionExpression(expr) => self.visit_arrow_function_expression(expr),
380 Node::FunctionExpression(expr) => self.visit_function_expression(expr),
381 Node::ClassExpression(expr) => self.visit_class_expression(expr),
382 Node::YieldExpression(expr) => self.visit_yield_expression(expr),
383 Node::AwaitExpression(expr) => self.visit_await_expression(expr),
384 Node::Super(super_expr) => self.visit_super(super_expr),
385 Node::MetaProperty(prop) => self.visit_meta_property(prop),
386 Node::SpreadElement(elem) => self.visit_spread_element(elem),
387 Node::RestElement(elem) => self.visit_rest_element(elem),
388 Node::TemplateLiteral(lit) => self.visit_template_literal(lit),
389 Node::TaggedTemplateExpression(expr) => self.visit_tagged_template_expression(expr),
390 Node::ImportDeclaration(decl) => self.visit_import_declaration(decl),
391 Node::ExportDeclaration(decl) => self.visit_export_declaration(decl),
392 Node::LabeledStatement(stmt) => self.visit_labeled_statement(stmt),
393 Node::WithStatement(stmt) => self.visit_with_statement(stmt),
394 Node::DebuggerStatement(stmt) => self.visit_debugger_statement(stmt),
395 Node::BigInt(bigint) => self.visit_bigint(bigint),
396 Node::RegExp(regexp) => self.visit_regexp(regexp),
397 }
398 }
399
400 fn visit_program(&mut self, program: &Program) -> Self::Output {
401 for statement in &program.body {
402 self.visit_node(statement);
403 }
404 }
405
406 fn visit_variable_declaration(&mut self, decl: &VariableDeclaration) -> Self::Output {
407 for declarator in &decl.declarations {
408 self.visit_node(&declarator.id);
409 if let Some(init) = &declarator.init {
410 self.visit_node(init);
411 }
412 }
413 }
414
415 fn visit_function_declaration(&mut self, decl: &FunctionDeclaration) -> Self::Output {
416 if let Some(id) = &decl.id {
417 self.visit_node(id);
418 }
419 for param in &decl.params {
420 self.visit_node(param);
421 }
422 self.visit_node(&decl.body);
423 }
424
425 fn visit_class_declaration(&mut self, decl: &ClassDeclaration) -> Self::Output {
426 if let Some(id) = &decl.id {
427 self.visit_node(id);
428 }
429 if let Some(super_class) = &decl.super_class {
430 self.visit_node(super_class);
431 }
432 self.visit_node(&decl.body);
433 }
434
435 fn visit_binary_expression(&mut self, expr: &BinaryExpression) -> Self::Output {
436 self.visit_node(&expr.left);
437 self.visit_node(&expr.right);
438 }
439
440 fn visit_unary_expression(&mut self, expr: &UnaryExpression) -> Self::Output {
441 self.visit_node(&expr.argument);
442 }
443
444 fn visit_call_expression(&mut self, expr: &CallExpression) -> Self::Output {
445 self.visit_node(&expr.callee);
446 for arg in &expr.arguments {
447 self.visit_node(arg);
448 }
449 }
450
451 fn visit_new_expression(&mut self, expr: &NewExpression) -> Self::Output {
452 self.visit_node(&expr.callee);
453 for arg in &expr.arguments {
454 self.visit_node(arg);
455 }
456 }
457
458 fn visit_member_expression(&mut self, expr: &MemberExpression) -> Self::Output {
459 self.visit_node(&expr.object);
460 if expr.computed {
461 self.visit_node(&expr.property);
462 }
463 }
464
465 fn visit_assignment_expression(&mut self, expr: &AssignmentExpression) -> Self::Output {
466 self.visit_node(&expr.left);
467 self.visit_node(&expr.right);
468 }
469
470 fn visit_conditional_expression(&mut self, expr: &ConditionalExpression) -> Self::Output {
471 self.visit_node(&expr.test);
472 self.visit_node(&expr.consequent);
473 self.visit_node(&expr.alternate);
474 }
475
476 fn visit_logical_expression(&mut self, expr: &LogicalExpression) -> Self::Output {
477 self.visit_node(&expr.left);
478 self.visit_node(&expr.right);
479 }
480
481 fn visit_update_expression(&mut self, expr: &UpdateExpression) -> Self::Output {
482 self.visit_node(&expr.argument);
483 }
484
485 fn visit_block_statement(&mut self, stmt: &BlockStatement) -> Self::Output {
486 for statement in &stmt.body {
487 self.visit_node(statement);
488 }
489 }
490
491 fn visit_if_statement(&mut self, stmt: &IfStatement) -> Self::Output {
492 self.visit_node(&stmt.test);
493 self.visit_node(&stmt.consequent);
494 if let Some(alternate) = &stmt.alternate {
495 self.visit_node(alternate);
496 }
497 }
498
499 fn visit_for_statement(&mut self, stmt: &ForStatement) -> Self::Output {
500 if let Some(init) = &stmt.init {
501 self.visit_node(init);
502 }
503 if let Some(test) = &stmt.test {
504 self.visit_node(test);
505 }
506 if let Some(update) = &stmt.update {
507 self.visit_node(update);
508 }
509 self.visit_node(&stmt.body);
510 }
511
512 fn visit_for_in_statement(&mut self, stmt: &ForInStatement) -> Self::Output {
513 self.visit_node(&stmt.left);
514 self.visit_node(&stmt.right);
515 self.visit_node(&stmt.body);
516 }
517
518 fn visit_for_of_statement(&mut self, stmt: &ForOfStatement) -> Self::Output {
519 self.visit_node(&stmt.left);
520 self.visit_node(&stmt.right);
521 self.visit_node(&stmt.body);
522 }
523
524 fn visit_while_statement(&mut self, stmt: &WhileStatement) -> Self::Output {
525 self.visit_node(&stmt.test);
526 self.visit_node(&stmt.body);
527 }
528
529 fn visit_do_while_statement(&mut self, stmt: &DoWhileStatement) -> Self::Output {
530 self.visit_node(&stmt.body);
531 self.visit_node(&stmt.test);
532 }
533
534 fn visit_switch_statement(&mut self, stmt: &SwitchStatement) -> Self::Output {
535 self.visit_node(&stmt.discriminant);
536 for case in &stmt.cases {
537 if let Some(test) = &case.test {
538 self.visit_node(test);
539 }
540 for consequent in &case.consequent {
541 self.visit_node(consequent);
542 }
543 }
544 }
545
546 fn visit_try_statement(&mut self, stmt: &TryStatement) -> Self::Output {
547 self.visit_node(&stmt.block);
548 if let Some(handler) = &stmt.handler {
549 self.visit_node(handler);
550 }
551 if let Some(finalizer) = &stmt.finalizer {
552 self.visit_node(finalizer);
553 }
554 }
555
556 fn visit_catch_clause(&mut self, clause: &CatchClause) -> Self::Output {
557 self.visit_node(&clause.param);
558 self.visit_node(&clause.body);
559 }
560
561 fn visit_throw_statement(&mut self, stmt: &ThrowStatement) -> Self::Output {
562 self.visit_node(&stmt.argument);
563 }
564
565 fn visit_return_statement(&mut self, stmt: &ReturnStatement) -> Self::Output {
566 if let Some(argument) = &stmt.argument {
567 self.visit_node(argument);
568 }
569 }
570
571 fn visit_break_statement(&mut self, _stmt: &BreakStatement) -> Self::Output {}
572
573 fn visit_continue_statement(&mut self, _stmt: &ContinueStatement) -> Self::Output {}
574
575 fn visit_expression_statement(&mut self, stmt: &ExpressionStatement) -> Self::Output {
576 self.visit_node(&stmt.expression);
577 }
578
579 fn visit_array_literal(&mut self, lit: &ArrayLiteral) -> Self::Output {
580 for elem in lit.elements.iter().flatten() {
581 self.visit_node(elem);
582 }
583 }
584
585 fn visit_object_literal(&mut self, lit: &ObjectLiteral) -> Self::Output {
586 for property in &lit.properties {
587 self.visit_node(property);
588 }
589 }
590
591 fn visit_property(&mut self, prop: &Property) -> Self::Output {
592 if prop.computed {
593 self.visit_node(&prop.key);
594 }
595 self.visit_node(&prop.value);
596 }
597
598 fn visit_identifier(&mut self, _id: &str) -> Self::Output {}
599
600 fn visit_number(&mut self, _num: f64) -> Self::Output {}
601
602 fn visit_string(&mut self, _s: &str) -> Self::Output {}
603
604 fn visit_boolean(&mut self, _b: bool) -> Self::Output {}
605
606 fn visit_null(&mut self) -> Self::Output {}
607
608 fn visit_undefined(&mut self) -> Self::Output {}
609
610 fn visit_this(&mut self) -> Self::Output {}
611
612 fn visit_arrow_function_expression(&mut self, expr: &ArrowFunctionExpression) -> Self::Output {
613 for param in &expr.params {
614 self.visit_node(param);
615 }
616 self.visit_node(&expr.body);
617 }
618
619 fn visit_function_expression(&mut self, expr: &FunctionExpression) -> Self::Output {
620 if let Some(id) = &expr.id {
621 self.visit_node(id);
622 }
623 for param in &expr.params {
624 self.visit_node(param);
625 }
626 self.visit_node(&expr.body);
627 }
628
629 fn visit_class_expression(&mut self, expr: &ClassExpression) -> Self::Output {
630 if let Some(id) = &expr.id {
631 self.visit_node(id);
632 }
633 if let Some(super_class) = &expr.super_class {
634 self.visit_node(super_class);
635 }
636 self.visit_node(&expr.body);
637 }
638
639 fn visit_yield_expression(&mut self, expr: &YieldExpression) -> Self::Output {
640 if let Some(argument) = &expr.argument {
641 self.visit_node(argument);
642 }
643 }
644
645 fn visit_await_expression(&mut self, expr: &AwaitExpression) -> Self::Output {
646 self.visit_node(&expr.argument);
647 }
648
649 fn visit_super(&mut self, _super_expr: &Super) -> Self::Output {}
650
651 fn visit_meta_property(&mut self, _prop: &MetaProperty) -> Self::Output {}
652
653 fn visit_spread_element(&mut self, elem: &SpreadElement) -> Self::Output {
654 self.visit_node(&elem.argument);
655 }
656
657 fn visit_rest_element(&mut self, elem: &RestElement) -> Self::Output {
658 self.visit_node(&elem.argument);
659 }
660
661 fn visit_template_literal(&mut self, lit: &TemplateLiteral) -> Self::Output {
662 for expr in &lit.expressions {
663 self.visit_node(expr);
664 }
665 }
666
667 fn visit_tagged_template_expression(&mut self, expr: &TaggedTemplateExpression) -> Self::Output {
668 self.visit_node(&expr.tag);
669 self.visit_node(&expr.quasi);
670 }
671
672 fn visit_import_declaration(&mut self, decl: &ImportDeclaration) -> Self::Output {
673 for specifier in &decl.specifiers {
674 self.visit_node(specifier);
675 }
676 }
677
678 fn visit_export_declaration(&mut self, decl: &ExportDeclaration) -> Self::Output {
679 if let Some(declaration) = &decl.declaration {
680 self.visit_node(declaration);
681 }
682 for specifier in &decl.specifiers {
683 self.visit_node(specifier);
684 }
685 if let Some(source) = &decl.source {
686 self.visit_node(source);
687 }
688 }
689
690 fn visit_labeled_statement(&mut self, stmt: &LabeledStatement) -> Self::Output {
691 self.visit_node(&stmt.label);
692 self.visit_node(&stmt.body);
693 }
694
695 fn visit_with_statement(&mut self, stmt: &WithStatement) -> Self::Output {
696 self.visit_node(&stmt.object);
697 self.visit_node(&stmt.body);
698 }
699
700 fn visit_debugger_statement(&mut self, _stmt: &DebuggerStatement) -> Self::Output {}
701
702 fn visit_bigint(&mut self, _bigint: &str) -> Self::Output {}
703
704 fn visit_regexp(&mut self, _regexp: &RegExp) -> Self::Output {}
705}