| blob | faf85f06865db719be9fc4fe8b41d8a89759f93b |
1 // Copyright (c) Facebook, Inc. and its affiliates.
2 //
3 // This source code is licensed under the MIT license found in the
4 // LICENSE file in the "hack" directory of this source tree.
5 //
6 // @generated SignedSource<<e94f650f1df55e367a197d6d3e563c46>>
7 //
8 // To regenerate this file, run:
9 // hphp/hack/src/oxidized_regen.sh
11 #![allow(unused_variables)]
12 use super::node::Node;
13 use super::type_params::Params;
14 use super::visitor::Visitor;
15 use crate::{aast::*, aast_defs::*, ast_defs::*, doc_comment::*};
16 impl<P: Params> Node<P> for Afield<P::Ex, P::Fb, P::En, P::Hi> {
17 fn accept<'node>(
18 &'node self,
19 c: &mut P::Context,
20 v: &mut dyn Visitor<'node, P = P>,
21 ) -> Result<(), P::Error> {
22 v.visit_afield(c, self)
23 }
24 fn recurse<'node>(
25 &'node self,
26 c: &mut P::Context,
27 v: &mut dyn Visitor<'node, P = P>,
28 ) -> Result<(), P::Error> {
29 match self {
30 Afield::AFvalue(a0) => {
31 a0.accept(c, v)?;
32 Ok(())
33 }
34 Afield::AFkvalue(a0, a1) => {
35 a0.accept(c, v)?;
36 a1.accept(c, v)?;
37 Ok(())
38 }
39 }
40 }
41 }
42 impl<P: Params> Node<P> for AsExpr<P::Ex, P::Fb, P::En, P::Hi> {
43 fn accept<'node>(
44 &'node self,
45 c: &mut P::Context,
46 v: &mut dyn Visitor<'node, P = P>,
47 ) -> Result<(), P::Error> {
48 v.visit_as_expr(c, self)
49 }
50 fn recurse<'node>(
51 &'node self,
52 c: &mut P::Context,
53 v: &mut dyn Visitor<'node, P = P>,
54 ) -> Result<(), P::Error> {
55 match self {
56 AsExpr::AsV(a0) => {
57 a0.accept(c, v)?;
58 Ok(())
59 }
60 AsExpr::AsKv(a0, a1) => {
61 a0.accept(c, v)?;
62 a1.accept(c, v)?;
63 Ok(())
64 }
65 AsExpr::AwaitAsV(a0, a1) => {
66 a0.accept(c, v)?;
67 a1.accept(c, v)?;
68 Ok(())
69 }
70 AsExpr::AwaitAsKv(a0, a1, a2) => {
71 a0.accept(c, v)?;
72 a1.accept(c, v)?;
73 a2.accept(c, v)?;
74 Ok(())
75 }
76 }
77 }
78 }
79 impl<P: Params> Node<P> for Bop {
80 fn accept<'node>(
81 &'node self,
82 c: &mut P::Context,
83 v: &mut dyn Visitor<'node, P = P>,
84 ) -> Result<(), P::Error> {
85 v.visit_bop(c, self)
86 }
87 fn recurse<'node>(
88 &'node self,
89 c: &mut P::Context,
90 v: &mut dyn Visitor<'node, P = P>,
91 ) -> Result<(), P::Error> {
92 match self {
93 Bop::Plus => Ok(()),
94 Bop::Minus => Ok(()),
95 Bop::Star => Ok(()),
96 Bop::Slash => Ok(()),
97 Bop::Eqeq => Ok(()),
98 Bop::Eqeqeq => Ok(()),
99 Bop::Starstar => Ok(()),
100 Bop::Diff => Ok(()),
101 Bop::Diff2 => Ok(()),
102 Bop::Ampamp => Ok(()),
103 Bop::Barbar => Ok(()),
104 Bop::Lt => Ok(()),
105 Bop::Lte => Ok(()),
106 Bop::Gt => Ok(()),
107 Bop::Gte => Ok(()),
108 Bop::Dot => Ok(()),
109 Bop::Amp => Ok(()),
110 Bop::Bar => Ok(()),
111 Bop::Ltlt => Ok(()),
112 Bop::Gtgt => Ok(()),
113 Bop::Percent => Ok(()),
114 Bop::Xor => Ok(()),
115 Bop::Cmp => Ok(()),
116 Bop::QuestionQuestion => Ok(()),
117 Bop::Eq(a0) => {
118 a0.accept(c, v)?;
119 Ok(())
120 }
121 }
122 }
123 }
124 impl<P: Params> Node<P> for CaField<P::Ex, P::Fb, P::En, P::Hi> {
125 fn accept<'node>(
126 &'node self,
127 c: &mut P::Context,
128 v: &mut dyn Visitor<'node, P = P>,
129 ) -> Result<(), P::Error> {
130 v.visit_ca_field(c, self)
131 }
132 fn recurse<'node>(
133 &'node self,
134 c: &mut P::Context,
135 v: &mut dyn Visitor<'node, P = P>,
136 ) -> Result<(), P::Error> {
137 self.type_.accept(c, v)?;
138 self.id.accept(c, v)?;
139 self.value.accept(c, v)?;
140 self.required.accept(c, v)?;
141 Ok(())
142 }
143 }
144 impl<P: Params> Node<P> for CaType {
145 fn accept<'node>(
146 &'node self,
147 c: &mut P::Context,
148 v: &mut dyn Visitor<'node, P = P>,
149 ) -> Result<(), P::Error> {
150 v.visit_ca_type(c, self)
151 }
152 fn recurse<'node>(
153 &'node self,
154 c: &mut P::Context,
155 v: &mut dyn Visitor<'node, P = P>,
156 ) -> Result<(), P::Error> {
157 match self {
158 CaType::CAHint(a0) => {
159 a0.accept(c, v)?;
160 Ok(())
161 }
162 CaType::CAEnum(a0) => {
163 a0.accept(c, v)?;
164 Ok(())
165 }
166 }
167 }
168 }
169 impl<P: Params> Node<P> for Case<P::Ex, P::Fb, P::En, P::Hi> {
170 fn accept<'node>(
171 &'node self,
172 c: &mut P::Context,
173 v: &mut dyn Visitor<'node, P = P>,
174 ) -> Result<(), P::Error> {
175 v.visit_case(c, self)
176 }
177 fn recurse<'node>(
178 &'node self,
179 c: &mut P::Context,
180 v: &mut dyn Visitor<'node, P = P>,
181 ) -> Result<(), P::Error> {
182 match self {
183 Case::Default(a0, a1) => {
184 a0.accept(c, v)?;
185 a1.accept(c, v)?;
186 Ok(())
187 }
188 Case::Case(a0, a1) => {
189 a0.accept(c, v)?;
190 a1.accept(c, v)?;
191 Ok(())
192 }
193 }
194 }
195 }
196 impl<P: Params> Node<P> for Catch<P::Ex, P::Fb, P::En, P::Hi> {
197 fn accept<'node>(
198 &'node self,
199 c: &mut P::Context,
200 v: &mut dyn Visitor<'node, P = P>,
201 ) -> Result<(), P::Error> {
202 v.visit_catch(c, self)
203 }
204 fn recurse<'node>(
205 &'node self,
206 c: &mut P::Context,
207 v: &mut dyn Visitor<'node, P = P>,
208 ) -> Result<(), P::Error> {
209 self.0.accept(c, v)?;
210 self.1.accept(c, v)?;
211 self.2.accept(c, v)?;
212 Ok(())
213 }
214 }
215 impl<P: Params> Node<P> for ClassAttr<P::Ex, P::Fb, P::En, P::Hi> {
216 fn accept<'node>(
217 &'node self,
218 c: &mut P::Context,
219 v: &mut dyn Visitor<'node, P = P>,
220 ) -> Result<(), P::Error> {
221 v.visit_class_attr(c, self)
222 }
223 fn recurse<'node>(
224 &'node self,
225 c: &mut P::Context,
226 v: &mut dyn Visitor<'node, P = P>,
227 ) -> Result<(), P::Error> {
228 match self {
229 ClassAttr::CAName(a0) => {
230 a0.accept(c, v)?;
231 Ok(())
232 }
233 ClassAttr::CAField(a0) => {
234 a0.accept(c, v)?;
235 Ok(())
236 }
237 }
238 }
239 }
240 impl<P: Params> Node<P> for ClassConst<P::Ex, P::Fb, P::En, P::Hi> {
241 fn accept<'node>(
242 &'node self,
243 c: &mut P::Context,
244 v: &mut dyn Visitor<'node, P = P>,
245 ) -> Result<(), P::Error> {
246 v.visit_class_const(c, self)
247 }
248 fn recurse<'node>(
249 &'node self,
250 c: &mut P::Context,
251 v: &mut dyn Visitor<'node, P = P>,
252 ) -> Result<(), P::Error> {
253 self.type_.accept(c, v)?;
254 self.id.accept(c, v)?;
255 self.expr.accept(c, v)?;
256 self.doc_comment.accept(c, v)?;
257 Ok(())
258 }
259 }
260 impl<P: Params> Node<P> for ClassGetExpr<P::Ex, P::Fb, P::En, P::Hi> {
261 fn accept<'node>(
262 &'node self,
263 c: &mut P::Context,
264 v: &mut dyn Visitor<'node, P = P>,
265 ) -> Result<(), P::Error> {
266 v.visit_class_get_expr(c, self)
267 }
268 fn recurse<'node>(
269 &'node self,
270 c: &mut P::Context,
271 v: &mut dyn Visitor<'node, P = P>,
272 ) -> Result<(), P::Error> {
273 match self {
274 ClassGetExpr::CGstring(a0) => {
275 a0.accept(c, v)?;
276 Ok(())
277 }
278 ClassGetExpr::CGexpr(a0) => {
279 a0.accept(c, v)?;
280 Ok(())
281 }
282 }
283 }
284 }
285 impl<P: Params> Node<P> for ClassId<P::Ex, P::Fb, P::En, P::Hi> {
286 fn accept<'node>(
287 &'node self,
288 c: &mut P::Context,
289 v: &mut dyn Visitor<'node, P = P>,
290 ) -> Result<(), P::Error> {
291 v.visit_class_id(c, self)
292 }
293 fn recurse<'node>(
294 &'node self,
295 c: &mut P::Context,
296 v: &mut dyn Visitor<'node, P = P>,
297 ) -> Result<(), P::Error> {
298 v.visit_ex(c, &self.0)?;
299 self.1.accept(c, v)?;
300 Ok(())
301 }
302 }
303 impl<P: Params> Node<P> for ClassId_<P::Ex, P::Fb, P::En, P::Hi> {
304 fn accept<'node>(
305 &'node self,
306 c: &mut P::Context,
307 v: &mut dyn Visitor<'node, P = P>,
308 ) -> Result<(), P::Error> {
309 v.visit_class_id_(c, self)
310 }
311 fn recurse<'node>(
312 &'node self,
313 c: &mut P::Context,
314 v: &mut dyn Visitor<'node, P = P>,
315 ) -> Result<(), P::Error> {
316 match self {
317 ClassId_::CIparent => Ok(()),
318 ClassId_::CIself => Ok(()),
319 ClassId_::CIstatic => Ok(()),
320 ClassId_::CIexpr(a0) => {
321 a0.accept(c, v)?;
322 Ok(())
323 }
324 ClassId_::CI(a0) => {
325 a0.accept(c, v)?;
326 Ok(())
327 }
328 }
329 }
330 }
331 impl<P: Params> Node<P> for ClassKind {
332 fn accept<'node>(
333 &'node self,
334 c: &mut P::Context,
335 v: &mut dyn Visitor<'node, P = P>,
336 ) -> Result<(), P::Error> {
337 v.visit_class_kind(c, self)
338 }
339 fn recurse<'node>(
340 &'node self,
341 c: &mut P::Context,
342 v: &mut dyn Visitor<'node, P = P>,
343 ) -> Result<(), P::Error> {
344 match self {
345 ClassKind::Cabstract => Ok(()),
346 ClassKind::Cnormal => Ok(()),
347 ClassKind::Cinterface => Ok(()),
348 ClassKind::Ctrait => Ok(()),
349 ClassKind::Cenum => Ok(()),
350 }
351 }
352 }
353 impl<P: Params> Node<P> for ClassTypeconst<P::Ex, P::Fb, P::En, P::Hi> {
354 fn accept<'node>(
355 &'node self,
356 c: &mut P::Context,
357 v: &mut dyn Visitor<'node, P = P>,
358 ) -> Result<(), P::Error> {
359 v.visit_class_typeconst(c, self)
360 }
361 fn recurse<'node>(
362 &'node self,
363 c: &mut P::Context,
364 v: &mut dyn Visitor<'node, P = P>,
365 ) -> Result<(), P::Error> {
366 self.abstract_.accept(c, v)?;
367 self.name.accept(c, v)?;
368 self.as_constraint.accept(c, v)?;
369 self.type_.accept(c, v)?;
370 self.user_attributes.accept(c, v)?;
371 self.span.accept(c, v)?;
372 self.doc_comment.accept(c, v)?;
373 self.is_ctx.accept(c, v)?;
374 Ok(())
375 }
376 }
377 impl<P: Params> Node<P> for ClassVar<P::Ex, P::Fb, P::En, P::Hi> {
378 fn accept<'node>(
379 &'node self,
380 c: &mut P::Context,
381 v: &mut dyn Visitor<'node, P = P>,
382 ) -> Result<(), P::Error> {
383 v.visit_class_var(c, self)
384 }
385 fn recurse<'node>(
386 &'node self,
387 c: &mut P::Context,
388 v: &mut dyn Visitor<'node, P = P>,
389 ) -> Result<(), P::Error> {
390 self.final_.accept(c, v)?;
391 self.xhp_attr.accept(c, v)?;
392 self.abstract_.accept(c, v)?;
393 self.readonly.accept(c, v)?;
394 self.visibility.accept(c, v)?;
395 self.type_.accept(c, v)?;
396 self.id.accept(c, v)?;
397 self.expr.accept(c, v)?;
398 self.user_attributes.accept(c, v)?;
399 self.doc_comment.accept(c, v)?;
400 self.is_promoted_variadic.accept(c, v)?;
401 self.is_static.accept(c, v)?;
402 self.span.accept(c, v)?;
403 Ok(())
404 }
405 }
406 impl<P: Params> Node<P> for Class_<P::Ex, P::Fb, P::En, P::Hi> {
407 fn accept<'node>(
408 &'node self,
409 c: &mut P::Context,
410 v: &mut dyn Visitor<'node, P = P>,
411 ) -> Result<(), P::Error> {
412 v.visit_class_(c, self)
413 }
414 fn recurse<'node>(
415 &'node self,
416 c: &mut P::Context,
417 v: &mut dyn Visitor<'node, P = P>,
418 ) -> Result<(), P::Error> {
419 self.span.accept(c, v)?;
420 v.visit_en(c, &self.annotation)?;
421 self.mode.accept(c, v)?;
422 self.final_.accept(c, v)?;
423 self.is_xhp.accept(c, v)?;
424 self.has_xhp_keyword.accept(c, v)?;
425 self.kind.accept(c, v)?;
426 self.name.accept(c, v)?;
427 self.tparams.accept(c, v)?;
428 self.extends.accept(c, v)?;
429 self.uses.accept(c, v)?;
430 self.use_as_alias.accept(c, v)?;
431 self.insteadof_alias.accept(c, v)?;
432 self.xhp_attr_uses.accept(c, v)?;
433 self.xhp_category.accept(c, v)?;
434 self.reqs.accept(c, v)?;
435 self.implements.accept(c, v)?;
436 self.implements_dynamic.accept(c, v)?;
437 self.where_constraints.accept(c, v)?;
438 self.consts.accept(c, v)?;
439 self.typeconsts.accept(c, v)?;
440 self.vars.accept(c, v)?;
441 self.methods.accept(c, v)?;
442 self.attributes.accept(c, v)?;
443 self.xhp_children.accept(c, v)?;
444 self.xhp_attrs.accept(c, v)?;
445 self.namespace.accept(c, v)?;
446 self.user_attributes.accept(c, v)?;
447 self.file_attributes.accept(c, v)?;
448 self.enum_.accept(c, v)?;
449 self.doc_comment.accept(c, v)?;
450 self.emit_id.accept(c, v)?;
451 Ok(())
452 }
453 }
454 impl<P: Params> Node<P> for CollectionTarg<P::Hi> {
455 fn accept<'node>(
456 &'node self,
457 c: &mut P::Context,
458 v: &mut dyn Visitor<'node, P = P>,
459 ) -> Result<(), P::Error> {
460 v.visit_collection_targ(c, self)
461 }
462 fn recurse<'node>(
463 &'node self,
464 c: &mut P::Context,
465 v: &mut dyn Visitor<'node, P = P>,
466 ) -> Result<(), P::Error> {
467 match self {
468 CollectionTarg::CollectionTV(a0) => {
469 a0.accept(c, v)?;
470 Ok(())
471 }
472 CollectionTarg::CollectionTKV(a0, a1) => {
473 a0.accept(c, v)?;
474 a1.accept(c, v)?;
475 Ok(())
476 }
477 }
478 }
479 }
480 impl<P: Params> Node<P> for ConstraintKind {
481 fn accept<'node>(
482 &'node self,
483 c: &mut P::Context,
484 v: &mut dyn Visitor<'node, P = P>,
485 ) -> Result<(), P::Error> {
486 v.visit_constraint_kind(c, self)
487 }
488 fn recurse<'node>(
489 &'node self,
490 c: &mut P::Context,
491 v: &mut dyn Visitor<'node, P = P>,
492 ) -> Result<(), P::Error> {
493 match self {
494 ConstraintKind::ConstraintAs => Ok(()),
495 ConstraintKind::ConstraintEq => Ok(()),
496 ConstraintKind::ConstraintSuper => Ok(()),
497 }
498 }
499 }
500 impl<P: Params> Node<P> for Contexts {
501 fn accept<'node>(
502 &'node self,
503 c: &mut P::Context,
504 v: &mut dyn Visitor<'node, P = P>,
505 ) -> Result<(), P::Error> {
506 v.visit_contexts(c, self)
507 }
508 fn recurse<'node>(
509 &'node self,
510 c: &mut P::Context,
511 v: &mut dyn Visitor<'node, P = P>,
512 ) -> Result<(), P::Error> {
513 self.0.accept(c, v)?;
514 self.1.accept(c, v)?;
515 Ok(())
516 }
517 }
518 impl<P: Params> Node<P> for Def<P::Ex, P::Fb, P::En, P::Hi> {
519 fn accept<'node>(
520 &'node self,
521 c: &mut P::Context,
522 v: &mut dyn Visitor<'node, P = P>,
523 ) -> Result<(), P::Error> {
524 v.visit_def(c, self)
525 }
526 fn recurse<'node>(
527 &'node self,
528 c: &mut P::Context,
529 v: &mut dyn Visitor<'node, P = P>,
530 ) -> Result<(), P::Error> {
531 match self {
532 Def::Fun(a0) => {
533 a0.accept(c, v)?;
534 Ok(())
535 }
536 Def::Class(a0) => {
537 a0.accept(c, v)?;
538 Ok(())
539 }
540 Def::RecordDef(a0) => {
541 a0.accept(c, v)?;
542 Ok(())
543 }
544 Def::Stmt(a0) => {
545 a0.accept(c, v)?;
546 Ok(())
547 }
548 Def::Typedef(a0) => {
549 a0.accept(c, v)?;
550 Ok(())
551 }
552 Def::Constant(a0) => {
553 a0.accept(c, v)?;
554 Ok(())
555 }
556 Def::Namespace(a) => {
557 a.0.accept(c, v)?;
558 a.1.accept(c, v)?;
559 Ok(())
560 }
561 Def::NamespaceUse(a0) => {
562 a0.accept(c, v)?;
563 Ok(())
564 }
565 Def::SetNamespaceEnv(a0) => {
566 a0.accept(c, v)?;
567 Ok(())
568 }
569 Def::FileAttributes(a0) => {
570 a0.accept(c, v)?;
571 Ok(())
572 }
573 }
574 }
575 }
576 impl<P: Params> Node<P> for DocComment {
577 fn accept<'node>(
578 &'node self,
579 c: &mut P::Context,
580 v: &mut dyn Visitor<'node, P = P>,
581 ) -> Result<(), P::Error> {
582 v.visit_doc_comment(c, self)
583 }
584 fn recurse<'node>(
585 &'node self,
586 c: &mut P::Context,
587 v: &mut dyn Visitor<'node, P = P>,
588 ) -> Result<(), P::Error> {
589 self.0.accept(c, v)?;
590 Ok(())
591 }
592 }
593 impl<P: Params> Node<P> for EmitId {
594 fn accept<'node>(
595 &'node self,
596 c: &mut P::Context,
597 v: &mut dyn Visitor<'node, P = P>,
598 ) -> Result<(), P::Error> {
599 v.visit_emit_id(c, self)
600 }
601 fn recurse<'node>(
602 &'node self,
603 c: &mut P::Context,
604 v: &mut dyn Visitor<'node, P = P>,
605 ) -> Result<(), P::Error> {
606 match self {
607 EmitId::EmitId(a0) => {
608 a0.accept(c, v)?;
609 Ok(())
610 }
611 EmitId::Anonymous => Ok(()),
612 }
613 }
614 }
615 impl<P: Params> Node<P> for Enum_ {
616 fn accept<'node>(
617 &'node self,
618 c: &mut P::Context,
619 v: &mut dyn Visitor<'node, P = P>,
620 ) -> Result<(), P::Error> {
621 v.visit_enum_(c, self)
622 }
623 fn recurse<'node>(
624 &'node self,
625 c: &mut P::Context,
626 v: &mut dyn Visitor<'node, P = P>,
627 ) -> Result<(), P::Error> {
628 self.base.accept(c, v)?;
629 self.constraint.accept(c, v)?;
630 self.includes.accept(c, v)?;
631 self.enum_class.accept(c, v)?;
632 Ok(())
633 }
634 }
635 impl<P: Params> Node<P> for EnvAnnot {
636 fn accept<'node>(
637 &'node self,
638 c: &mut P::Context,
639 v: &mut dyn Visitor<'node, P = P>,
640 ) -> Result<(), P::Error> {
641 v.visit_env_annot(c, self)
642 }
643 fn recurse<'node>(
644 &'node self,
645 c: &mut P::Context,
646 v: &mut dyn Visitor<'node, P = P>,
647 ) -> Result<(), P::Error> {
648 match self {
649 EnvAnnot::Join => Ok(()),
650 EnvAnnot::Refinement => Ok(()),
651 }
652 }
653 }
654 impl<P: Params> Node<P> for Expr<P::Ex, P::Fb, P::En, P::Hi> {
655 fn accept<'node>(
656 &'node self,
657 c: &mut P::Context,
658 v: &mut dyn Visitor<'node, P = P>,
659 ) -> Result<(), P::Error> {
660 v.visit_expr(c, self)
661 }
662 fn recurse<'node>(
663 &'node self,
664 c: &mut P::Context,
665 v: &mut dyn Visitor<'node, P = P>,
666 ) -> Result<(), P::Error> {
667 v.visit_ex(c, &self.0)?;
668 self.1.accept(c, v)?;
669 Ok(())
670 }
671 }
672 impl<P: Params> Node<P> for Expr_<P::Ex, P::Fb, P::En, P::Hi> {
673 fn accept<'node>(
674 &'node self,
675 c: &mut P::Context,
676 v: &mut dyn Visitor<'node, P = P>,
677 ) -> Result<(), P::Error> {
678 v.visit_expr_(c, self)
679 }
680 fn recurse<'node>(
681 &'node self,
682 c: &mut P::Context,
683 v: &mut dyn Visitor<'node, P = P>,
684 ) -> Result<(), P::Error> {
685 match self {
686 Expr_::Darray(a) => {
687 a.0.accept(c, v)?;
688 a.1.accept(c, v)?;
689 Ok(())
690 }
691 Expr_::Varray(a) => {
692 a.0.accept(c, v)?;
693 a.1.accept(c, v)?;
694 Ok(())
695 }
696 Expr_::Shape(a0) => {
697 a0.accept(c, v)?;
698 Ok(())
699 }
700 Expr_::ValCollection(a) => {
701 a.0.accept(c, v)?;
702 a.1.accept(c, v)?;
703 a.2.accept(c, v)?;
704 Ok(())
705 }
706 Expr_::KeyValCollection(a) => {
707 a.0.accept(c, v)?;
708 a.1.accept(c, v)?;
709 a.2.accept(c, v)?;
710 Ok(())
711 }
712 Expr_::Null => Ok(()),
713 Expr_::This => Ok(()),
714 Expr_::True => Ok(()),
715 Expr_::False => Ok(()),
716 Expr_::Omitted => Ok(()),
717 Expr_::Id(a0) => {
718 a0.accept(c, v)?;
719 Ok(())
720 }
721 Expr_::Lvar(a0) => {
722 a0.accept(c, v)?;
723 Ok(())
724 }
725 Expr_::Dollardollar(a0) => {
726 a0.accept(c, v)?;
727 Ok(())
728 }
729 Expr_::Clone(a0) => {
730 a0.accept(c, v)?;
731 Ok(())
732 }
733 Expr_::ArrayGet(a) => {
734 a.0.accept(c, v)?;
735 a.1.accept(c, v)?;
736 Ok(())
737 }
738 Expr_::ObjGet(a) => {
739 a.0.accept(c, v)?;
740 a.1.accept(c, v)?;
741 a.2.accept(c, v)?;
742 a.3.accept(c, v)?;
743 Ok(())
744 }
745 Expr_::ClassGet(a) => {
746 a.0.accept(c, v)?;
747 a.1.accept(c, v)?;
748 a.2.accept(c, v)?;
749 Ok(())
750 }
751 Expr_::ClassConst(a) => {
752 a.0.accept(c, v)?;
753 a.1.accept(c, v)?;
754 Ok(())
755 }
756 Expr_::Call(a) => {
757 a.0.accept(c, v)?;
758 a.1.accept(c, v)?;
759 a.2.accept(c, v)?;
760 a.3.accept(c, v)?;
761 Ok(())
762 }
763 Expr_::FunctionPointer(a) => {
764 a.0.accept(c, v)?;
765 a.1.accept(c, v)?;
766 Ok(())
767 }
768 Expr_::Int(a0) => {
769 a0.accept(c, v)?;
770 Ok(())
771 }
772 Expr_::Float(a0) => {
773 a0.accept(c, v)?;
774 Ok(())
775 }
776 Expr_::String(a0) => {
777 a0.accept(c, v)?;
778 Ok(())
779 }
780 Expr_::String2(a0) => {
781 a0.accept(c, v)?;
782 Ok(())
783 }
784 Expr_::PrefixedString(a) => {
785 a.0.accept(c, v)?;
786 a.1.accept(c, v)?;
787 Ok(())
788 }
789 Expr_::Yield(a0) => {
790 a0.accept(c, v)?;
791 Ok(())
792 }
793 Expr_::Await(a0) => {
794 a0.accept(c, v)?;
795 Ok(())
796 }
797 Expr_::ReadonlyExpr(a0) => {
798 a0.accept(c, v)?;
799 Ok(())
800 }
801 Expr_::List(a0) => {
802 a0.accept(c, v)?;
803 Ok(())
804 }
805 Expr_::Cast(a) => {
806 a.0.accept(c, v)?;
807 a.1.accept(c, v)?;
808 Ok(())
809 }
810 Expr_::Unop(a) => {
811 a.0.accept(c, v)?;
812 a.1.accept(c, v)?;
813 Ok(())
814 }
815 Expr_::Binop(a) => {
816 a.0.accept(c, v)?;
817 a.1.accept(c, v)?;
818 a.2.accept(c, v)?;
819 Ok(())
820 }
821 Expr_::Pipe(a) => {
822 a.0.accept(c, v)?;
823 a.1.accept(c, v)?;
824 a.2.accept(c, v)?;
825 Ok(())
826 }
827 Expr_::Eif(a) => {
828 a.0.accept(c, v)?;
829 a.1.accept(c, v)?;
830 a.2.accept(c, v)?;
831 Ok(())
832 }
833 Expr_::Is(a) => {
834 a.0.accept(c, v)?;
835 a.1.accept(c, v)?;
836 Ok(())
837 }
838 Expr_::As(a) => {
839 a.0.accept(c, v)?;
840 a.1.accept(c, v)?;
841 a.2.accept(c, v)?;
842 Ok(())
843 }
844 Expr_::New(a) => {
845 a.0.accept(c, v)?;
846 a.1.accept(c, v)?;
847 a.2.accept(c, v)?;
848 a.3.accept(c, v)?;
849 v.visit_ex(c, &a.4)?;
850 Ok(())
851 }
852 Expr_::Record(a) => {
853 a.0.accept(c, v)?;
854 a.1.accept(c, v)?;
855 Ok(())
856 }
857 Expr_::Efun(a) => {
858 a.0.accept(c, v)?;
859 a.1.accept(c, v)?;
860 Ok(())
861 }
862 Expr_::Lfun(a) => {
863 a.0.accept(c, v)?;
864 a.1.accept(c, v)?;
865 Ok(())
866 }
867 Expr_::Xml(a) => {
868 a.0.accept(c, v)?;
869 a.1.accept(c, v)?;
870 a.2.accept(c, v)?;
871 Ok(())
872 }
873 Expr_::Callconv(a) => {
874 a.0.accept(c, v)?;
875 a.1.accept(c, v)?;
876 Ok(())
877 }
878 Expr_::Import(a) => {
879 a.0.accept(c, v)?;
880 a.1.accept(c, v)?;
881 Ok(())
882 }
883 Expr_::Collection(a) => {
884 a.0.accept(c, v)?;
885 a.1.accept(c, v)?;
886 a.2.accept(c, v)?;
887 Ok(())
888 }
889 Expr_::ExpressionTree(a0) => {
890 a0.accept(c, v)?;
891 Ok(())
892 }
893 Expr_::Lplaceholder(a0) => {
894 a0.accept(c, v)?;
895 Ok(())
896 }
897 Expr_::FunId(a0) => {
898 a0.accept(c, v)?;
899 Ok(())
900 }
901 Expr_::MethodId(a) => {
902 a.0.accept(c, v)?;
903 a.1.accept(c, v)?;
904 Ok(())
905 }
906 Expr_::MethodCaller(a) => {
907 a.0.accept(c, v)?;
908 a.1.accept(c, v)?;
909 Ok(())
910 }
911 Expr_::SmethodId(a) => {
912 a.0.accept(c, v)?;
913 a.1.accept(c, v)?;
914 Ok(())
915 }
916 Expr_::Pair(a) => {
917 a.0.accept(c, v)?;
918 a.1.accept(c, v)?;
919 a.2.accept(c, v)?;
920 Ok(())
921 }
922 Expr_::ETSplice(a0) => {
923 a0.accept(c, v)?;
924 Ok(())
925 }
926 Expr_::EnumAtom(a0) => {
927 a0.accept(c, v)?;
928 Ok(())
929 }
930 Expr_::Any => Ok(()),
931 }
932 }
933 }
934 impl<P: Params> Node<P> for ExpressionTree<P::Ex, P::Fb, P::En, P::Hi> {
935 fn accept<'node>(
936 &'node self,
937 c: &mut P::Context,
938 v: &mut dyn Visitor<'node, P = P>,
939 ) -> Result<(), P::Error> {
940 v.visit_expression_tree(c, self)
941 }
942 fn recurse<'node>(
943 &'node self,
944 c: &mut P::Context,
945 v: &mut dyn Visitor<'node, P = P>,
946 ) -> Result<(), P::Error> {
947 self.hint.accept(c, v)?;
948 self.src_expr.accept(c, v)?;
949 self.desugared_expr.accept(c, v)?;
950 Ok(())
951 }
952 }
953 impl<P: Params> Node<P> for Field<P::Ex, P::Fb, P::En, P::Hi> {
954 fn accept<'node>(
955 &'node self,
956 c: &mut P::Context,
957 v: &mut dyn Visitor<'node, P = P>,
958 ) -> Result<(), P::Error> {
959 v.visit_field(c, self)
960 }
961 fn recurse<'node>(
962 &'node self,
963 c: &mut P::Context,
964 v: &mut dyn Visitor<'node, P = P>,
965 ) -> Result<(), P::Error> {
966 self.0.accept(c, v)?;
967 self.1.accept(c, v)?;
968 Ok(())
969 }
970 }
971 impl<P: Params> Node<P> for FileAttribute<P::Ex, P::Fb, P::En, P::Hi> {
972 fn accept<'node>(
973 &'node self,
974 c: &mut P::Context,
975 v: &mut dyn Visitor<'node, P = P>,
976 ) -> Result<(), P::Error> {
977 v.visit_file_attribute(c, self)
978 }
979 fn recurse<'node>(
980 &'node self,
981 c: &mut P::Context,
982 v: &mut dyn Visitor<'node, P = P>,
983 ) -> Result<(), P::Error> {
984 self.user_attributes.accept(c, v)?;
985 self.namespace.accept(c, v)?;
986 Ok(())
987 }
988 }
989 impl<P: Params> Node<P> for FunKind {
990 fn accept<'node>(
991 &'node self,
992 c: &mut P::Context,
993 v: &mut dyn Visitor<'node, P = P>,
994 ) -> Result<(), P::Error> {
995 v.visit_fun_kind(c, self)
996 }
997 fn recurse<'node>(
998 &'node self,
999 c: &mut P::Context,
1000 v: &mut dyn Visitor<'node, P = P>,
1001 ) -> Result<(), P::Error> {
1002 match self {
1003 FunKind::FSync => Ok(()),
1004 FunKind::FAsync => Ok(()),
1005 FunKind::FGenerator => Ok(()),
1006 FunKind::FAsyncGenerator => Ok(()),
1007 }
1008 }
1009 }
1010 impl<P: Params> Node<P> for FunParam<P::Ex, P::Fb, P::En, P::Hi> {
1011 fn accept<'node>(
1012 &'node self,
1013 c: &mut P::Context,
1014 v: &mut dyn Visitor<'node, P = P>,
1015 ) -> Result<(), P::Error> {
1016 v.visit_fun_param(c, self)
1017 }
1018 fn recurse<'node>(
1019 &'node self,
1020 c: &mut P::Context,
1021 v: &mut dyn Visitor<'node, P = P>,
1022 ) -> Result<(), P::Error> {
1023 v.visit_ex(c, &self.annotation)?;
1024 self.type_hint.accept(c, v)?;
1025 self.is_variadic.accept(c, v)?;
1026 self.pos.accept(c, v)?;
1027 self.name.accept(c, v)?;
1028 self.expr.accept(c, v)?;
1029 self.readonly.accept(c, v)?;
1030 self.callconv.accept(c, v)?;
1031 self.user_attributes.accept(c, v)?;
1032 self.visibility.accept(c, v)?;
1033 Ok(())
1034 }
1035 }
1036 impl<P: Params> Node<P> for FunVariadicity<P::Ex, P::Fb, P::En, P::Hi> {
1037 fn accept<'node>(
1038 &'node self,
1039 c: &mut P::Context,
1040 v: &mut dyn Visitor<'node, P = P>,
1041 ) -> Result<(), P::Error> {
1042 v.visit_fun_variadicity(c, self)
1043 }
1044 fn recurse<'node>(
1045 &'node self,
1046 c: &mut P::Context,
1047 v: &mut dyn Visitor<'node, P = P>,
1048 ) -> Result<(), P::Error> {
1049 match self {
1050 FunVariadicity::FVvariadicArg(a0) => {
1051 a0.accept(c, v)?;
1052 Ok(())
1053 }
1054 FunVariadicity::FVellipsis(a0) => {
1055 a0.accept(c, v)?;
1056 Ok(())
1057 }
1058 FunVariadicity::FVnonVariadic => Ok(()),
1059 }
1060 }
1061 }
1062 impl<P: Params> Node<P> for Fun_<P::Ex, P::Fb, P::En, P::Hi> {
1063 fn accept<'node>(
1064 &'node self,
1065 c: &mut P::Context,
1066 v: &mut dyn Visitor<'node, P = P>,
1067 ) -> Result<(), P::Error> {
1068 v.visit_fun_(c, self)
1069 }
1070 fn recurse<'node>(
1071 &'node self,
1072 c: &mut P::Context,
1073 v: &mut dyn Visitor<'node, P = P>,
1074 ) -> Result<(), P::Error> {
1075 self.span.accept(c, v)?;
1076 v.visit_en(c, &self.annotation)?;
1077 self.mode.accept(c, v)?;
1078 self.readonly_ret.accept(c, v)?;
1079 self.ret.accept(c, v)?;
1080 self.name.accept(c, v)?;
1081 self.tparams.accept(c, v)?;
1082 self.where_constraints.accept(c, v)?;
1083 self.variadic.accept(c, v)?;
1084 self.params.accept(c, v)?;
1085 self.ctxs.accept(c, v)?;
1086 self.unsafe_ctxs.accept(c, v)?;
1087 self.body.accept(c, v)?;
1088 self.fun_kind.accept(c, v)?;
1089 self.user_attributes.accept(c, v)?;
1090 self.file_attributes.accept(c, v)?;
1091 self.external.accept(c, v)?;
1092 self.namespace.accept(c, v)?;
1093 self.doc_comment.accept(c, v)?;
1094 self.static_.accept(c, v)?;
1095 Ok(())
1096 }
1097 }
1098 impl<P: Params> Node<P> for FuncBody<P::Ex, P::Fb, P::En, P::Hi> {
1099 fn accept<'node>(
1100 &'node self,
1101 c: &mut P::Context,
1102 v: &mut dyn Visitor<'node, P = P>,
1103 ) -> Result<(), P::Error> {
1104 v.visit_func_body(c, self)
1105 }
1106 fn recurse<'node>(
1107 &'node self,
1108 c: &mut P::Context,
1109 v: &mut dyn Visitor<'node, P = P>,
1110 ) -> Result<(), P::Error> {
1111 self.ast.accept(c, v)?;
1112 v.visit_fb(c, &self.annotation)?;
1113 Ok(())
1114 }
1115 }
1116 impl<P: Params> Node<P> for FunctionPtrId<P::Ex, P::Fb, P::En, P::Hi> {
1117 fn accept<'node>(
1118 &'node self,
1119 c: &mut P::Context,
1120 v: &mut dyn Visitor<'node, P = P>,
1121 ) -> Result<(), P::Error> {
1122 v.visit_function_ptr_id(c, self)
1123 }
1124 fn recurse<'node>(
1125 &'node self,
1126 c: &mut P::Context,
1127 v: &mut dyn Visitor<'node, P = P>,
1128 ) -> Result<(), P::Error> {
1129 match self {
1130 FunctionPtrId::FPId(a0) => {
1131 a0.accept(c, v)?;
1132 Ok(())
1133 }
1134 FunctionPtrId::FPClassConst(a0, a1) => {
1135 a0.accept(c, v)?;
1136 a1.accept(c, v)?;
1137 Ok(())
1138 }
1139 }
1140 }
1141 }
1142 impl<P: Params> Node<P> for Gconst<P::Ex, P::Fb, P::En, P::Hi> {
1143 fn accept<'node>(
1144 &'node self,
1145 c: &mut P::Context,
1146 v: &mut dyn Visitor<'node, P = P>,
1147 ) -> Result<(), P::Error> {
1148 v.visit_gconst(c, self)
1149 }
1150 fn recurse<'node>(
1151 &'node self,
1152 c: &mut P::Context,
1153 v: &mut dyn Visitor<'node, P = P>,
1154 ) -> Result<(), P::Error> {
1155 v.visit_en(c, &self.annotation)?;
1156 self.mode.accept(c, v)?;
1157 self.name.accept(c, v)?;
1158 self.type_.accept(c, v)?;
1159 self.value.accept(c, v)?;
1160 self.namespace.accept(c, v)?;
1161 self.span.accept(c, v)?;
1162 self.emit_id.accept(c, v)?;
1163 Ok(())
1164 }
1165 }
1166 impl<P: Params> Node<P> for HfParamInfo {
1167 fn accept<'node>(
1168 &'node self,
1169 c: &mut P::Context,
1170 v: &mut dyn Visitor<'node, P = P>,
1171 ) -> Result<(), P::Error> {
1172 v.visit_hf_param_info(c, self)
1173 }
1174 fn recurse<'node>(
1175 &'node self,
1176 c: &mut P::Context,
1177 v: &mut dyn Visitor<'node, P = P>,
1178 ) -> Result<(), P::Error> {
1179 self.kind.accept(c, v)?;
1180 self.readonlyness.accept(c, v)?;
1181 Ok(())
1182 }
1183 }
1184 impl<P: Params> Node<P> for Hint {
1185 fn accept<'node>(
1186 &'node self,
1187 c: &mut P::Context,
1188 v: &mut dyn Visitor<'node, P = P>,
1189 ) -> Result<(), P::Error> {
1190 v.visit_hint(c, self)
1191 }
1192 fn recurse<'node>(
1193 &'node self,
1194 c: &mut P::Context,
1195 v: &mut dyn Visitor<'node, P = P>,
1196 ) -> Result<(), P::Error> {
1197 self.0.accept(c, v)?;
1198 self.1.accept(c, v)?;
1199 Ok(())
1200 }
1201 }
1202 impl<P: Params> Node<P> for HintFun {
1203 fn accept<'node>(
1204 &'node self,
1205 c: &mut P::Context,
1206 v: &mut dyn Visitor<'node, P = P>,
1207 ) -> Result<(), P::Error> {
1208 v.visit_hint_fun(c, self)
1209 }
1210 fn recurse<'node>(
1211 &'node self,
1212 c: &mut P::Context,
1213 v: &mut dyn Visitor<'node, P = P>,
1214 ) -> Result<(), P::Error> {
1215 self.param_tys.accept(c, v)?;
1216 self.param_info.accept(c, v)?;
1217 self.variadic_ty.accept(c, v)?;
1218 self.ctxs.accept(c, v)?;
1219 self.return_ty.accept(c, v)?;
1220 self.is_readonly_return.accept(c, v)?;
1221 Ok(())
1222 }
1223 }
1224 impl<P: Params> Node<P> for Hint_ {
1225 fn accept<'node>(
1226 &'node self,
1227 c: &mut P::Context,
1228 v: &mut dyn Visitor<'node, P = P>,
1229 ) -> Result<(), P::Error> {
1230 v.visit_hint_(c, self)
1231 }
1232 fn recurse<'node>(
1233 &'node self,
1234 c: &mut P::Context,
1235 v: &mut dyn Visitor<'node, P = P>,
1236 ) -> Result<(), P::Error> {
1237 match self {
1238 Hint_::Hoption(a0) => {
1239 a0.accept(c, v)?;
1240 Ok(())
1241 }
1242 Hint_::Hlike(a0) => {
1243 a0.accept(c, v)?;
1244 Ok(())
1245 }
1246 Hint_::Hfun(a0) => {
1247 a0.accept(c, v)?;
1248 Ok(())
1249 }
1250 Hint_::Htuple(a0) => {
1251 a0.accept(c, v)?;
1252 Ok(())
1253 }
1254 Hint_::Happly(a0, a1) => {
1255 a0.accept(c, v)?;
1256 a1.accept(c, v)?;
1257 Ok(())
1258 }
1259 Hint_::Hshape(a0) => {
1260 a0.accept(c, v)?;
1261 Ok(())
1262 }
1263 Hint_::Haccess(a0, a1) => {
1264 a0.accept(c, v)?;
1265 a1.accept(c, v)?;
1266 Ok(())
1267 }
1268 Hint_::Hsoft(a0) => {
1269 a0.accept(c, v)?;
1270 Ok(())
1271 }
1272 Hint_::Hany => Ok(()),
1273 Hint_::Herr => Ok(()),
1274 Hint_::Hmixed => Ok(()),
1275 Hint_::Hnonnull => Ok(()),
1276 Hint_::Habstr(a0, a1) => {
1277 a0.accept(c, v)?;
1278 a1.accept(c, v)?;
1279 Ok(())
1280 }
1281 Hint_::Hdarray(a0, a1) => {
1282 a0.accept(c, v)?;
1283 a1.accept(c, v)?;
1284 Ok(())
1285 }
1286 Hint_::Hvarray(a0) => {
1287 a0.accept(c, v)?;
1288 Ok(())
1289 }
1290 Hint_::HvarrayOrDarray(a0, a1) => {
1291 a0.accept(c, v)?;
1292 a1.accept(c, v)?;
1293 Ok(())
1294 }
1295 Hint_::HvecOrDict(a0, a1) => {
1296 a0.accept(c, v)?;
1297 a1.accept(c, v)?;
1298 Ok(())
1299 }
1300 Hint_::Hprim(a0) => {
1301 a0.accept(c, v)?;
1302 Ok(())
1303 }
1304 Hint_::Hthis => Ok(()),
1305 Hint_::Hdynamic => Ok(()),
1306 Hint_::Hnothing => Ok(()),
1307 Hint_::Hunion(a0) => {
1308 a0.accept(c, v)?;
1309 Ok(())
1310 }
1311 Hint_::Hintersection(a0) => {
1312 a0.accept(c, v)?;
1313 Ok(())
1314 }
1315 Hint_::HfunContext(a0) => {
1316 a0.accept(c, v)?;
1317 Ok(())
1318 }
1319 Hint_::Hvar(a0) => {
1320 a0.accept(c, v)?;
1321 Ok(())
1322 }
1323 }
1324 }
1325 }
1326 impl<P: Params> Node<P> for Id {
1327 fn accept<'node>(
1328 &'node self,
1329 c: &mut P::Context,
1330 v: &mut dyn Visitor<'node, P = P>,
1331 ) -> Result<(), P::Error> {
1332 v.visit_id(c, self)
1333 }
1334 fn recurse<'node>(
1335 &'node self,
1336 c: &mut P::Context,
1337 v: &mut dyn Visitor<'node, P = P>,
1338 ) -> Result<(), P::Error> {
1339 self.0.accept(c, v)?;
1340 self.1.accept(c, v)?;
1341 Ok(())
1342 }
1343 }
1344 impl<P: Params> Node<P> for ImportFlavor {
1345 fn accept<'node>(
1346 &'node self,
1347 c: &mut P::Context,
1348 v: &mut dyn Visitor<'node, P = P>,
1349 ) -> Result<(), P::Error> {
1350 v.visit_import_flavor(c, self)
1351 }
1352 fn recurse<'node>(
1353 &'node self,
1354 c: &mut P::Context,
1355 v: &mut dyn Visitor<'node, P = P>,
1356 ) -> Result<(), P::Error> {
1357 match self {
1358 ImportFlavor::Include => Ok(()),
1359 ImportFlavor::Require => Ok(()),
1360 ImportFlavor::IncludeOnce => Ok(()),
1361 ImportFlavor::RequireOnce => Ok(()),
1362 }
1363 }
1364 }
1365 impl<P: Params> Node<P> for InsteadofAlias {
1366 fn accept<'node>(
1367 &'node self,
1368 c: &mut P::Context,
1369 v: &mut dyn Visitor<'node, P = P>,
1370 ) -> Result<(), P::Error> {
1371 v.visit_insteadof_alias(c, self)
1372 }
1373 fn recurse<'node>(
1374 &'node self,
1375 c: &mut P::Context,
1376 v: &mut dyn Visitor<'node, P = P>,
1377 ) -> Result<(), P::Error> {
1378 self.0.accept(c, v)?;
1379 self.1.accept(c, v)?;
1380 self.2.accept(c, v)?;
1381 Ok(())
1382 }
1383 }
1384 impl<P: Params> Node<P> for KvcKind {
1385 fn accept<'node>(
1386 &'node self,
1387 c: &mut P::Context,
1388 v: &mut dyn Visitor<'node, P = P>,
1389 ) -> Result<(), P::Error> {
1390 v.visit_kvc_kind(c, self)
1391 }
1392 fn recurse<'node>(
1393 &'node self,
1394 c: &mut P::Context,
1395 v: &mut dyn Visitor<'node, P = P>,
1396 ) -> Result<(), P::Error> {
1397 match self {
1398 KvcKind::Map => Ok(()),
1399 KvcKind::ImmMap => Ok(()),
1400 KvcKind::Dict => Ok(()),
1401 }
1402 }
1403 }
1404 impl<P: Params> Node<P> for Lid {
1405 fn accept<'node>(
1406 &'node self,
1407 c: &mut P::Context,
1408 v: &mut dyn Visitor<'node, P = P>,
1409 ) -> Result<(), P::Error> {
1410 v.visit_lid(c, self)
1411 }
1412 fn recurse<'node>(
1413 &'node self,
1414 c: &mut P::Context,
1415 v: &mut dyn Visitor<'node, P = P>,
1416 ) -> Result<(), P::Error> {
1417 self.0.accept(c, v)?;
1418 self.1.accept(c, v)?;
1419 Ok(())
1420 }
1421 }
1422 impl<P: Params> Node<P> for Method_<P::Ex, P::Fb, P::En, P::Hi> {
1423 fn accept<'node>(
1424 &'node self,
1425 c: &mut P::Context,
1426 v: &mut dyn Visitor<'node, P = P>,
1427 ) -> Result<(), P::Error> {
1428 v.visit_method_(c, self)
1429 }
1430 fn recurse<'node>(
1431 &'node self,
1432 c: &mut P::Context,
1433 v: &mut dyn Visitor<'node, P = P>,
1434 ) -> Result<(), P::Error> {
1435 self.span.accept(c, v)?;
1436 v.visit_en(c, &self.annotation)?;
1437 self.final_.accept(c, v)?;
1438 self.abstract_.accept(c, v)?;
1439 self.static_.accept(c, v)?;
1440 self.readonly_this.accept(c, v)?;
1441 self.visibility.accept(c, v)?;
1442 self.name.accept(c, v)?;
1443 self.tparams.accept(c, v)?;
1444 self.where_constraints.accept(c, v)?;
1445 self.variadic.accept(c, v)?;
1446 self.params.accept(c, v)?;
1447 self.ctxs.accept(c, v)?;
1448 self.unsafe_ctxs.accept(c, v)?;
1449 self.body.accept(c, v)?;
1450 self.fun_kind.accept(c, v)?;
1451 self.user_attributes.accept(c, v)?;
1452 self.readonly_ret.accept(c, v)?;
1453 self.ret.accept(c, v)?;
1454 self.external.accept(c, v)?;
1455 self.doc_comment.accept(c, v)?;
1456 Ok(())
1457 }
1458 }
1459 impl<P: Params> Node<P> for NastShapeInfo {
1460 fn accept<'node>(
1461 &'node self,
1462 c: &mut P::Context,
1463 v: &mut dyn Visitor<'node, P = P>,
1464 ) -> Result<(), P::Error> {
1465 v.visit_nast_shape_info(c, self)
1466 }
1467 fn recurse<'node>(
1468 &'node self,
1469 c: &mut P::Context,
1470 v: &mut dyn Visitor<'node, P = P>,
1471 ) -> Result<(), P::Error> {
1472 self.allows_unknown_fields.accept(c, v)?;
1473 self.field_map.accept(c, v)?;
1474 Ok(())
1475 }
1476 }
1477 impl<P: Params> Node<P> for NsKind {
1478 fn accept<'node>(
1479 &'node self,
1480 c: &mut P::Context,
1481 v: &mut dyn Visitor<'node, P = P>,
1482 ) -> Result<(), P::Error> {
1483 v.visit_ns_kind(c, self)
1484 }
1485 fn recurse<'node>(
1486 &'node self,
1487 c: &mut P::Context,
1488 v: &mut dyn Visitor<'node, P = P>,
1489 ) -> Result<(), P::Error> {
1490 match self {
1491 NsKind::NSNamespace => Ok(()),
1492 NsKind::NSClass => Ok(()),
1493 NsKind::NSClassAndNamespace => Ok(()),
1494 NsKind::NSFun => Ok(()),
1495 NsKind::NSConst => Ok(()),
1496 }
1497 }
1498 }
1499 impl<P: Params> Node<P> for OgNullFlavor {
1500 fn accept<'node>(
1501 &'node self,
1502 c: &mut P::Context,
1503 v: &mut dyn Visitor<'node, P = P>,
1504 ) -> Result<(), P::Error> {
1505 v.visit_og_null_flavor(c, self)
1506 }
1507 fn recurse<'node>(
1508 &'node self,
1509 c: &mut P::Context,
1510 v: &mut dyn Visitor<'node, P = P>,
1511 ) -> Result<(), P::Error> {
1512 match self {
1513 OgNullFlavor::OGNullthrows => Ok(()),
1514 OgNullFlavor::OGNullsafe => Ok(()),
1515 }
1516 }
1517 }
1518 impl<P: Params> Node<P> for ParamKind {
1519 fn accept<'node>(
1520 &'node self,
1521 c: &mut P::Context,
1522 v: &mut dyn Visitor<'node, P = P>,
1523 ) -> Result<(), P::Error> {
1524 v.visit_param_kind(c, self)
1525 }
1526 fn recurse<'node>(
1527 &'node self,
1528 c: &mut P::Context,
1529 v: &mut dyn Visitor<'node, P = P>,
1530 ) -> Result<(), P::Error> {
1531 match self {
1532 ParamKind::Pinout => Ok(()),
1533 }
1534 }
1535 }
1536 impl<P: Params> Node<P> for ReadonlyKind {
1537 fn accept<'node>(
1538 &'node self,
1539 c: &mut P::Context,
1540 v: &mut dyn Visitor<'node, P = P>,
1541 ) -> Result<(), P::Error> {
1542 v.visit_readonly_kind(c, self)
1543 }
1544 fn recurse<'node>(
1545 &'node self,
1546 c: &mut P::Context,
1547 v: &mut dyn Visitor<'node, P = P>,
1548 ) -> Result<(), P::Error> {
1549 match self {
1550 ReadonlyKind::Readonly => Ok(()),
1551 }
1552 }
1553 }
1554 impl<P: Params> Node<P> for RecordDef<P::Ex, P::Fb, P::En, P::Hi> {
1555 fn accept<'node>(
1556 &'node self,
1557 c: &mut P::Context,
1558 v: &mut dyn Visitor<'node, P = P>,
1559 ) -> Result<(), P::Error> {
1560 v.visit_record_def(c, self)
1561 }
1562 fn recurse<'node>(
1563 &'node self,
1564 c: &mut P::Context,
1565 v: &mut dyn Visitor<'node, P = P>,
1566 ) -> Result<(), P::Error> {
1567 v.visit_en(c, &self.annotation)?;
1568 self.name.accept(c, v)?;
1569 self.extends.accept(c, v)?;
1570 self.abstract_.accept(c, v)?;
1571 self.fields.accept(c, v)?;
1572 self.user_attributes.accept(c, v)?;
1573 self.namespace.accept(c, v)?;
1574 self.span.accept(c, v)?;
1575 self.doc_comment.accept(c, v)?;
1576 self.emit_id.accept(c, v)?;
1577 Ok(())
1578 }
1579 }
1580 impl<P: Params> Node<P> for ReifyKind {
1581 fn accept<'node>(
1582 &'node self,
1583 c: &mut P::Context,
1584 v: &mut dyn Visitor<'node, P = P>,
1585 ) -> Result<(), P::Error> {
1586 v.visit_reify_kind(c, self)
1587 }
1588 fn recurse<'node>(
1589 &'node self,
1590 c: &mut P::Context,
1591 v: &mut dyn Visitor<'node, P = P>,
1592 ) -> Result<(), P::Error> {
1593 match self {
1594 ReifyKind::Erased => Ok(()),
1595 ReifyKind::SoftReified => Ok(()),
1596 ReifyKind::Reified => Ok(()),
1597 }
1598 }
1599 }
1600 impl<P: Params> Node<P> for ShapeFieldInfo {
1601 fn accept<'node>(
1602 &'node self,
1603 c: &mut P::Context,
1604 v: &mut dyn Visitor<'node, P = P>,
1605 ) -> Result<(), P::Error> {
1606 v.visit_shape_field_info(c, self)
1607 }
1608 fn recurse<'node>(
1609 &'node self,
1610 c: &mut P::Context,
1611 v: &mut dyn Visitor<'node, P = P>,
1612 ) -> Result<(), P::Error> {
1613 self.optional.accept(c, v)?;
1614 self.hint.accept(c, v)?;
1615 self.name.accept(c, v)?;
1616 Ok(())
1617 }
1618 }
1619 impl<P: Params> Node<P> for ShapeFieldName {
1620 fn accept<'node>(
1621 &'node self,
1622 c: &mut P::Context,
1623 v: &mut dyn Visitor<'node, P = P>,
1624 ) -> Result<(), P::Error> {
1625 v.visit_shape_field_name(c, self)
1626 }
1627 fn recurse<'node>(
1628 &'node self,
1629 c: &mut P::Context,
1630 v: &mut dyn Visitor<'node, P = P>,
1631 ) -> Result<(), P::Error> {
1632 match self {
1633 ShapeFieldName::SFlitInt(a0) => {
1634 a0.accept(c, v)?;
1635 Ok(())
1636 }
1637 ShapeFieldName::SFlitStr(a0) => {
1638 a0.accept(c, v)?;
1639 Ok(())
1640 }
1641 ShapeFieldName::SFclassConst(a0, a1) => {
1642 a0.accept(c, v)?;
1643 a1.accept(c, v)?;
1644 Ok(())
1645 }
1646 }
1647 }
1648 }
1649 impl<P: Params> Node<P> for Stmt<P::Ex, P::Fb, P::En, P::Hi> {
1650 fn accept<'node>(
1651 &'node self,
1652 c: &mut P::Context,
1653 v: &mut dyn Visitor<'node, P = P>,
1654 ) -> Result<(), P::Error> {
1655 v.visit_stmt(c, self)
1656 }
1657 fn recurse<'node>(
1658 &'node self,
1659 c: &mut P::Context,
1660 v: &mut dyn Visitor<'node, P = P>,
1661 ) -> Result<(), P::Error> {
1662 self.0.accept(c, v)?;
1663 self.1.accept(c, v)?;
1664 Ok(())
1665 }
1666 }
1667 impl<P: Params> Node<P> for Stmt_<P::Ex, P::Fb, P::En, P::Hi> {
1668 fn accept<'node>(
1669 &'node self,
1670 c: &mut P::Context,
1671 v: &mut dyn Visitor<'node, P = P>,
1672 ) -> Result<(), P::Error> {
1673 v.visit_stmt_(c, self)
1674 }
1675 fn recurse<'node>(
1676 &'node self,
1677 c: &mut P::Context,
1678 v: &mut dyn Visitor<'node, P = P>,
1679 ) -> Result<(), P::Error> {
1680 match self {
1681 Stmt_::Fallthrough => Ok(()),
1682 Stmt_::Expr(a0) => {
1683 a0.accept(c, v)?;
1684 Ok(())
1685 }
1686 Stmt_::Break => Ok(()),
1687 Stmt_::Continue => Ok(()),
1688 Stmt_::Throw(a0) => {
1689 a0.accept(c, v)?;
1690 Ok(())
1691 }
1692 Stmt_::Return(a0) => {
1693 a0.accept(c, v)?;
1694 Ok(())
1695 }
1696 Stmt_::YieldBreak => Ok(()),
1697 Stmt_::Awaitall(a) => {
1698 a.0.accept(c, v)?;
1699 a.1.accept(c, v)?;
1700 Ok(())
1701 }
1702 Stmt_::If(a) => {
1703 a.0.accept(c, v)?;
1704 a.1.accept(c, v)?;
1705 a.2.accept(c, v)?;
1706 Ok(())
1707 }
1708 Stmt_::Do(a) => {
1709 a.0.accept(c, v)?;
1710 a.1.accept(c, v)?;
1711 Ok(())
1712 }
1713 Stmt_::While(a) => {
1714 a.0.accept(c, v)?;
1715 a.1.accept(c, v)?;
1716 Ok(())
1717 }
1718 Stmt_::Using(a0) => {
1719 a0.accept(c, v)?;
1720 Ok(())
1721 }
1722 Stmt_::For(a) => {
1723 a.0.accept(c, v)?;
1724 a.1.accept(c, v)?;
1725 a.2.accept(c, v)?;
1726 a.3.accept(c, v)?;
1727 Ok(())
1728 }
1729 Stmt_::Switch(a) => {
1730 a.0.accept(c, v)?;
1731 a.1.accept(c, v)?;
1732 Ok(())
1733 }
1734 Stmt_::Foreach(a) => {
1735 a.0.accept(c, v)?;
1736 a.1.accept(c, v)?;
1737 a.2.accept(c, v)?;
1738 Ok(())
1739 }
1740 Stmt_::Try(a) => {
1741 a.0.accept(c, v)?;
1742 a.1.accept(c, v)?;
1743 a.2.accept(c, v)?;
1744 Ok(())
1745 }
1746 Stmt_::Noop => Ok(()),
1747 Stmt_::Block(a0) => {
1748 a0.accept(c, v)?;
1749 Ok(())
1750 }
1751 Stmt_::Markup(a0) => {
1752 a0.accept(c, v)?;
1753 Ok(())
1754 }
1755 Stmt_::AssertEnv(a) => {
1756 a.0.accept(c, v)?;
1757 a.1.accept(c, v)?;
1758 Ok(())
1759 }
1760 }
1761 }
1762 }
1763 impl<P: Params> Node<P> for Targ<P::Hi> {
1764 fn accept<'node>(
1765 &'node self,
1766 c: &mut P::Context,
1767 v: &mut dyn Visitor<'node, P = P>,
1768 ) -> Result<(), P::Error> {
1769 v.visit_targ(c, self)
1770 }
1771 fn recurse<'node>(
1772 &'node self,
1773 c: &mut P::Context,
1774 v: &mut dyn Visitor<'node, P = P>,
1775 ) -> Result<(), P::Error> {
1776 v.visit_hi(c, &self.0)?;
1777 self.1.accept(c, v)?;
1778 Ok(())
1779 }
1780 }
1781 impl<P: Params> Node<P> for Tparam<P::Ex, P::Fb, P::En, P::Hi> {
1782 fn accept<'node>(
1783 &'node self,
1784 c: &mut P::Context,
1785 v: &mut dyn Visitor<'node, P = P>,
1786 ) -> Result<(), P::Error> {
1787 v.visit_tparam(c, self)
1788 }
1789 fn recurse<'node>(
1790 &'node self,
1791 c: &mut P::Context,
1792 v: &mut dyn Visitor<'node, P = P>,
1793 ) -> Result<(), P::Error> {
1794 self.variance.accept(c, v)?;
1795 self.name.accept(c, v)?;
1796 self.parameters.accept(c, v)?;
1797 self.constraints.accept(c, v)?;
1798 self.reified.accept(c, v)?;
1799 self.user_attributes.accept(c, v)?;
1800 Ok(())
1801 }
1802 }
1803 impl<P: Params> Node<P> for Tprim {
1804 fn accept<'node>(
1805 &'node self,
1806 c: &mut P::Context,
1807 v: &mut dyn Visitor<'node, P = P>,
1808 ) -> Result<(), P::Error> {
1809 v.visit_tprim(c, self)
1810 }
1811 fn recurse<'node>(
1812 &'node self,
1813 c: &mut P::Context,
1814 v: &mut dyn Visitor<'node, P = P>,
1815 ) -> Result<(), P::Error> {
1816 match self {
1817 Tprim::Tnull => Ok(()),
1818 Tprim::Tvoid => Ok(()),
1819 Tprim::Tint => Ok(()),
1820 Tprim::Tbool => Ok(()),
1821 Tprim::Tfloat => Ok(()),
1822 Tprim::Tstring => Ok(()),
1823 Tprim::Tresource => Ok(()),
1824 Tprim::Tnum => Ok(()),
1825 Tprim::Tarraykey => Ok(()),
1826 Tprim::Tnoreturn => Ok(()),
1827 }
1828 }
1829 }
1830 impl<P: Params> Node<P> for TypeHint<P::Hi> {
1831 fn accept<'node>(
1832 &'node self,
1833 c: &mut P::Context,
1834 v: &mut dyn Visitor<'node, P = P>,
1835 ) -> Result<(), P::Error> {
1836 v.visit_type_hint(c, self)
1837 }
1838 fn recurse<'node>(
1839 &'node self,
1840 c: &mut P::Context,
1841 v: &mut dyn Visitor<'node, P = P>,
1842 ) -> Result<(), P::Error> {
1843 v.visit_hi(c, &self.0)?;
1844 self.1.accept(c, v)?;
1845 Ok(())
1846 }
1847 }
1848 impl<P: Params> Node<P> for TypeconstAbstractKind {
1849 fn accept<'node>(
1850 &'node self,
1851 c: &mut P::Context,
1852 v: &mut dyn Visitor<'node, P = P>,
1853 ) -> Result<(), P::Error> {
1854 v.visit_typeconst_abstract_kind(c, self)
1855 }
1856 fn recurse<'node>(
1857 &'node self,
1858 c: &mut P::Context,
1859 v: &mut dyn Visitor<'node, P = P>,
1860 ) -> Result<(), P::Error> {
1861 match self {
1862 TypeconstAbstractKind::TCAbstract(a0) => {
1863 a0.accept(c, v)?;
1864 Ok(())
1865 }
1866 TypeconstAbstractKind::TCPartiallyAbstract => Ok(()),
1867 TypeconstAbstractKind::TCConcrete => Ok(()),
1868 }
1869 }
1870 }
1871 impl<P: Params> Node<P> for Typedef<P::Ex, P::Fb, P::En, P::Hi> {
1872 fn accept<'node>(
1873 &'node self,
1874 c: &mut P::Context,
1875 v: &mut dyn Visitor<'node, P = P>,
1876 ) -> Result<(), P::Error> {
1877 v.visit_typedef(c, self)
1878 }
1879 fn recurse<'node>(
1880 &'node self,
1881 c: &mut P::Context,
1882 v: &mut dyn Visitor<'node, P = P>,
1883 ) -> Result<(), P::Error> {
1884 v.visit_en(c, &self.annotation)?;
1885 self.name.accept(c, v)?;
1886 self.tparams.accept(c, v)?;
1887 self.constraint.accept(c, v)?;
1888 self.kind.accept(c, v)?;
1889 self.user_attributes.accept(c, v)?;
1890 self.mode.accept(c, v)?;
1891 self.vis.accept(c, v)?;
1892 self.namespace.accept(c, v)?;
1893 self.span.accept(c, v)?;
1894 self.emit_id.accept(c, v)?;
1895 Ok(())
1896 }
1897 }
1898 impl<P: Params> Node<P> for TypedefVisibility {
1899 fn accept<'node>(
1900 &'node self,
1901 c: &mut P::Context,
1902 v: &mut dyn Visitor<'node, P = P>,
1903 ) -> Result<(), P::Error> {
1904 v.visit_typedef_visibility(c, self)
1905 }
1906 fn recurse<'node>(
1907 &'node self,
1908 c: &mut P::Context,
1909 v: &mut dyn Visitor<'node, P = P>,
1910 ) -> Result<(), P::Error> {
1911 match self {
1912 TypedefVisibility::Transparent => Ok(()),
1913 TypedefVisibility::Opaque => Ok(()),
1914 }
1915 }
1916 }
1917 impl<P: Params> Node<P> for Uop {
1918 fn accept<'node>(
1919 &'node self,
1920 c: &mut P::Context,
1921 v: &mut dyn Visitor<'node, P = P>,
1922 ) -> Result<(), P::Error> {
1923 v.visit_uop(c, self)
1924 }
1925 fn recurse<'node>(
1926 &'node self,
1927 c: &mut P::Context,
1928 v: &mut dyn Visitor<'node, P = P>,
1929 ) -> Result<(), P::Error> {
1930 match self {
1931 Uop::Utild => Ok(()),
1932 Uop::Unot => Ok(()),
1933 Uop::Uplus => Ok(()),
1934 Uop::Uminus => Ok(()),
1935 Uop::Uincr => Ok(()),
1936 Uop::Udecr => Ok(()),
1937 Uop::Upincr => Ok(()),
1938 Uop::Updecr => Ok(()),
1939 Uop::Usilence => Ok(()),
1940 }
1941 }
1942 }
1943 impl<P: Params> Node<P> for UseAsAlias {
1944 fn accept<'node>(
1945 &'node self,
1946 c: &mut P::Context,
1947 v: &mut dyn Visitor<'node, P = P>,
1948 ) -> Result<(), P::Error> {
1949 v.visit_use_as_alias(c, self)
1950 }
1951 fn recurse<'node>(
1952 &'node self,
1953 c: &mut P::Context,
1954 v: &mut dyn Visitor<'node, P = P>,
1955 ) -> Result<(), P::Error> {
1956 self.0.accept(c, v)?;
1957 self.1.accept(c, v)?;
1958 self.2.accept(c, v)?;
1959 self.3.accept(c, v)?;
1960 Ok(())
1961 }
1962 }
1963 impl<P: Params> Node<P> for UseAsVisibility {
1964 fn accept<'node>(
1965 &'node self,
1966 c: &mut P::Context,
1967 v: &mut dyn Visitor<'node, P = P>,
1968 ) -> Result<(), P::Error> {
1969 v.visit_use_as_visibility(c, self)
1970 }
1971 fn recurse<'node>(
1972 &'node self,
1973 c: &mut P::Context,
1974 v: &mut dyn Visitor<'node, P = P>,
1975 ) -> Result<(), P::Error> {
1976 match self {
1977 UseAsVisibility::UseAsPublic => Ok(()),
1978 UseAsVisibility::UseAsPrivate => Ok(()),
1979 UseAsVisibility::UseAsProtected => Ok(()),
1980 UseAsVisibility::UseAsFinal => Ok(()),
1981 }
1982 }
1983 }
1984 impl<P: Params> Node<P> for UserAttribute<P::Ex, P::Fb, P::En, P::Hi> {
1985 fn accept<'node>(
1986 &'node self,
1987 c: &mut P::Context,
1988 v: &mut dyn Visitor<'node, P = P>,
1989 ) -> Result<(), P::Error> {
1990 v.visit_user_attribute(c, self)
1991 }
1992 fn recurse<'node>(
1993 &'node self,
1994 c: &mut P::Context,
1995 v: &mut dyn Visitor<'node, P = P>,
1996 ) -> Result<(), P::Error> {
1997 self.name.accept(c, v)?;
1998 self.params.accept(c, v)?;
1999 Ok(())
2000 }
2001 }
2002 impl<P: Params> Node<P> for UsingStmt<P::Ex, P::Fb, P::En, P::Hi> {
2003 fn accept<'node>(
2004 &'node self,
2005 c: &mut P::Context,
2006 v: &mut dyn Visitor<'node, P = P>,
2007 ) -> Result<(), P::Error> {
2008 v.visit_using_stmt(c, self)
2009 }
2010 fn recurse<'node>(
2011 &'node self,
2012 c: &mut P::Context,
2013 v: &mut dyn Visitor<'node, P = P>,
2014 ) -> Result<(), P::Error> {
2015 self.is_block_scoped.accept(c, v)?;
2016 self.has_await.accept(c, v)?;
2017 self.exprs.accept(c, v)?;
2018 self.block.accept(c, v)?;
2019 Ok(())
2020 }
2021 }
2022 impl<P: Params> Node<P> for Variance {
2023 fn accept<'node>(
2024 &'node self,
2025 c: &mut P::Context,
2026 v: &mut dyn Visitor<'node, P = P>,
2027 ) -> Result<(), P::Error> {
2028 v.visit_variance(c, self)
2029 }
2030 fn recurse<'node>(
2031 &'node self,
2032 c: &mut P::Context,
2033 v: &mut dyn Visitor<'node, P = P>,
2034 ) -> Result<(), P::Error> {
2035 match self {
2036 Variance::Covariant => Ok(()),
2037 Variance::Contravariant => Ok(()),
2038 Variance::Invariant => Ok(()),
2039 }
2040 }
2041 }
2042 impl<P: Params> Node<P> for VcKind {
2043 fn accept<'node>(
2044 &'node self,
2045 c: &mut P::Context,
2046 v: &mut dyn Visitor<'node, P = P>,
2047 ) -> Result<(), P::Error> {
2048 v.visit_vc_kind(c, self)
2049 }
2050 fn recurse<'node>(
2051 &'node self,
2052 c: &mut P::Context,
2053 v: &mut dyn Visitor<'node, P = P>,
2054 ) -> Result<(), P::Error> {
2055 match self {
2056 VcKind::Vector => Ok(()),
2057 VcKind::ImmVector => Ok(()),
2058 VcKind::Vec => Ok(()),
2059 VcKind::Set => Ok(()),
2060 VcKind::ImmSet => Ok(()),
2061 VcKind::Keyset => Ok(()),
2062 }
2063 }
2064 }
2065 impl<P: Params> Node<P> for Visibility {
2066 fn accept<'node>(
2067 &'node self,
2068 c: &mut P::Context,
2069 v: &mut dyn Visitor<'node, P = P>,
2070 ) -> Result<(), P::Error> {
2071 v.visit_visibility(c, self)
2072 }
2073 fn recurse<'node>(
2074 &'node self,
2075 c: &mut P::Context,
2076 v: &mut dyn Visitor<'node, P = P>,
2077 ) -> Result<(), P::Error> {
2078 match self {
2079 Visibility::Private => Ok(()),
2080 Visibility::Public => Ok(()),
2081 Visibility::Protected => Ok(()),
2082 }
2083 }
2084 }
2085 impl<P: Params> Node<P> for WhereConstraintHint {
2086 fn accept<'node>(
2087 &'node self,
2088 c: &mut P::Context,
2089 v: &mut dyn Visitor<'node, P = P>,
2090 ) -> Result<(), P::Error> {
2091 v.visit_where_constraint_hint(c, self)
2092 }
2093 fn recurse<'node>(
2094 &'node self,
2095 c: &mut P::Context,
2096 v: &mut dyn Visitor<'node, P = P>,
2097 ) -> Result<(), P::Error> {
2098 self.0.accept(c, v)?;
2099 self.1.accept(c, v)?;
2100 self.2.accept(c, v)?;
2101 Ok(())
2102 }
2103 }
2104 impl<P: Params> Node<P> for XhpAttr<P::Ex, P::Fb, P::En, P::Hi> {
2105 fn accept<'node>(
2106 &'node self,
2107 c: &mut P::Context,
2108 v: &mut dyn Visitor<'node, P = P>,
2109 ) -> Result<(), P::Error> {
2110 v.visit_xhp_attr(c, self)
2111 }
2112 fn recurse<'node>(
2113 &'node self,
2114 c: &mut P::Context,
2115 v: &mut dyn Visitor<'node, P = P>,
2116 ) -> Result<(), P::Error> {
2117 self.0.accept(c, v)?;
2118 self.1.accept(c, v)?;
2119 self.2.accept(c, v)?;
2120 self.3.accept(c, v)?;
2121 Ok(())
2122 }
2123 }
2124 impl<P: Params> Node<P> for XhpAttrInfo {
2125 fn accept<'node>(
2126 &'node self,
2127 c: &mut P::Context,
2128 v: &mut dyn Visitor<'node, P = P>,
2129 ) -> Result<(), P::Error> {
2130 v.visit_xhp_attr_info(c, self)
2131 }
2132 fn recurse<'node>(
2133 &'node self,
2134 c: &mut P::Context,
2135 v: &mut dyn Visitor<'node, P = P>,
2136 ) -> Result<(), P::Error> {
2137 self.xai_tag.accept(c, v)?;
2138 Ok(())
2139 }
2140 }
2141 impl<P: Params> Node<P> for XhpAttrTag {
2142 fn accept<'node>(
2143 &'node self,
2144 c: &mut P::Context,
2145 v: &mut dyn Visitor<'node, P = P>,
2146 ) -> Result<(), P::Error> {
2147 v.visit_xhp_attr_tag(c, self)
2148 }
2149 fn recurse<'node>(
2150 &'node self,
2151 c: &mut P::Context,
2152 v: &mut dyn Visitor<'node, P = P>,
2153 ) -> Result<(), P::Error> {
2154 match self {
2155 XhpAttrTag::Required => Ok(()),
2156 XhpAttrTag::LateInit => Ok(()),
2157 }
2158 }
2159 }
2160 impl<P: Params> Node<P> for XhpAttribute<P::Ex, P::Fb, P::En, P::Hi> {
2161 fn accept<'node>(
2162 &'node self,
2163 c: &mut P::Context,
2164 v: &mut dyn Visitor<'node, P = P>,
2165 ) -> Result<(), P::Error> {
2166 v.visit_xhp_attribute(c, self)
2167 }
2168 fn recurse<'node>(
2169 &'node self,
2170 c: &mut P::Context,
2171 v: &mut dyn Visitor<'node, P = P>,
2172 ) -> Result<(), P::Error> {
2173 match self {
2174 XhpAttribute::XhpSimple(a0, a1) => {
2175 a0.accept(c, v)?;
2176 a1.accept(c, v)?;
2177 Ok(())
2178 }
2179 XhpAttribute::XhpSpread(a0) => {
2180 a0.accept(c, v)?;
2181 Ok(())
2182 }
2183 }
2184 }
2185 }
2186 impl<P: Params> Node<P> for XhpChild {
2187 fn accept<'node>(
2188 &'node self,
2189 c: &mut P::Context,
2190 v: &mut dyn Visitor<'node, P = P>,
2191 ) -> Result<(), P::Error> {
2192 v.visit_xhp_child(c, self)
2193 }
2194 fn recurse<'node>(
2195 &'node self,
2196 c: &mut P::Context,
2197 v: &mut dyn Visitor<'node, P = P>,
2198 ) -> Result<(), P::Error> {
2199 match self {
2200 XhpChild::ChildName(a0) => {
2201 a0.accept(c, v)?;
2202 Ok(())
2203 }
2204 XhpChild::ChildList(a0) => {
2205 a0.accept(c, v)?;
2206 Ok(())
2207 }
2208 XhpChild::ChildUnary(a0, a1) => {
2209 a0.accept(c, v)?;
2210 a1.accept(c, v)?;
2211 Ok(())
2212 }
2213 XhpChild::ChildBinary(a0, a1) => {
2214 a0.accept(c, v)?;
2215 a1.accept(c, v)?;
2216 Ok(())
2217 }
2218 }
2219 }
2220 }
2221 impl<P: Params> Node<P> for XhpChildOp {
2222 fn accept<'node>(
2223 &'node self,
2224 c: &mut P::Context,
2225 v: &mut dyn Visitor<'node, P = P>,
2226 ) -> Result<(), P::Error> {
2227 v.visit_xhp_child_op(c, self)
2228 }
2229 fn recurse<'node>(
2230 &'node self,
2231 c: &mut P::Context,
2232 v: &mut dyn Visitor<'node, P = P>,
2233 ) -> Result<(), P::Error> {
2234 match self {
2235 XhpChildOp::ChildStar => Ok(()),
2236 XhpChildOp::ChildPlus => Ok(()),
2237 XhpChildOp::ChildQuestion => Ok(()),
2238 }
2239 }
2240 }