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