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