| blob | 5ccc6983193a9e35fc82c283cbbeb1e31b784011 |
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<<5bfb4c781ebab43cd0fb74db3c5b55ab>>
7 //
8 // To regenerate this file, run:
9 // hphp/hack/src/oxidized_regen.sh
11 use crate::aast::*;
12 use crate::ast_defs;
13 use crate::LocalIdMap;
14 impl<Ex, En> Stmt_<Ex, En> {
15 pub fn mk_fallthrough() -> Self {
16 Stmt_::Fallthrough
17 }
18 pub fn mk_expr(p0: Expr<Ex, En>) -> Self {
19 Stmt_::Expr(Box::new(p0))
20 }
21 pub fn mk_break() -> Self {
22 Stmt_::Break
23 }
24 pub fn mk_continue() -> Self {
25 Stmt_::Continue
26 }
27 pub fn mk_throw(p0: Expr<Ex, En>) -> Self {
28 Stmt_::Throw(Box::new(p0))
29 }
30 pub fn mk_return(p0: Option<Expr<Ex, En>>) -> Self {
31 Stmt_::Return(Box::new(p0))
32 }
33 pub fn mk_yield_break() -> Self {
34 Stmt_::YieldBreak
35 }
36 pub fn mk_awaitall(p0: Vec<(Option<Lid>, Expr<Ex, En>)>, p1: Block<Ex, En>) -> Self {
37 Stmt_::Awaitall(Box::new((p0, p1)))
38 }
39 pub fn mk_if(p0: Expr<Ex, En>, p1: Block<Ex, En>, p2: Block<Ex, En>) -> Self {
40 Stmt_::If(Box::new((p0, p1, p2)))
41 }
42 pub fn mk_do(p0: Block<Ex, En>, p1: Expr<Ex, En>) -> Self {
43 Stmt_::Do(Box::new((p0, p1)))
44 }
45 pub fn mk_while(p0: Expr<Ex, En>, p1: Block<Ex, En>) -> Self {
46 Stmt_::While(Box::new((p0, p1)))
47 }
48 pub fn mk_using(p0: UsingStmt<Ex, En>) -> Self {
49 Stmt_::Using(Box::new(p0))
50 }
51 pub fn mk_for(
52 p0: Vec<Expr<Ex, En>>,
53 p1: Option<Expr<Ex, En>>,
54 p2: Vec<Expr<Ex, En>>,
55 p3: Block<Ex, En>,
56 ) -> Self {
57 Stmt_::For(Box::new((p0, p1, p2, p3)))
58 }
59 pub fn mk_switch(p0: Expr<Ex, En>, p1: Vec<Case<Ex, En>>) -> Self {
60 Stmt_::Switch(Box::new((p0, p1)))
61 }
62 pub fn mk_foreach(p0: Expr<Ex, En>, p1: AsExpr<Ex, En>, p2: Block<Ex, En>) -> Self {
63 Stmt_::Foreach(Box::new((p0, p1, p2)))
64 }
65 pub fn mk_try(p0: Block<Ex, En>, p1: Vec<Catch<Ex, En>>, p2: Block<Ex, En>) -> Self {
66 Stmt_::Try(Box::new((p0, p1, p2)))
67 }
68 pub fn mk_noop() -> Self {
69 Stmt_::Noop
70 }
71 pub fn mk_block(p0: Block<Ex, En>) -> Self {
72 Stmt_::Block(p0)
73 }
74 pub fn mk_markup(p0: Pstring) -> Self {
75 Stmt_::Markup(Box::new(p0))
76 }
77 pub fn mk_assert_env(p0: EnvAnnot, p1: LocalIdMap<(Pos, Ex)>) -> Self {
78 Stmt_::AssertEnv(Box::new((p0, p1)))
79 }
80 pub fn is_fallthrough(&self) -> bool {
81 match self {
82 Stmt_::Fallthrough => true,
83 _ => false,
84 }
85 }
86 pub fn is_expr(&self) -> bool {
87 match self {
88 Stmt_::Expr(..) => true,
89 _ => false,
90 }
91 }
92 pub fn is_break(&self) -> bool {
93 match self {
94 Stmt_::Break => true,
95 _ => false,
96 }
97 }
98 pub fn is_continue(&self) -> bool {
99 match self {
100 Stmt_::Continue => true,
101 _ => false,
102 }
103 }
104 pub fn is_throw(&self) -> bool {
105 match self {
106 Stmt_::Throw(..) => true,
107 _ => false,
108 }
109 }
110 pub fn is_return(&self) -> bool {
111 match self {
112 Stmt_::Return(..) => true,
113 _ => false,
114 }
115 }
116 pub fn is_yield_break(&self) -> bool {
117 match self {
118 Stmt_::YieldBreak => true,
119 _ => false,
120 }
121 }
122 pub fn is_awaitall(&self) -> bool {
123 match self {
124 Stmt_::Awaitall(..) => true,
125 _ => false,
126 }
127 }
128 pub fn is_if(&self) -> bool {
129 match self {
130 Stmt_::If(..) => true,
131 _ => false,
132 }
133 }
134 pub fn is_do(&self) -> bool {
135 match self {
136 Stmt_::Do(..) => true,
137 _ => false,
138 }
139 }
140 pub fn is_while(&self) -> bool {
141 match self {
142 Stmt_::While(..) => true,
143 _ => false,
144 }
145 }
146 pub fn is_using(&self) -> bool {
147 match self {
148 Stmt_::Using(..) => true,
149 _ => false,
150 }
151 }
152 pub fn is_for(&self) -> bool {
153 match self {
154 Stmt_::For(..) => true,
155 _ => false,
156 }
157 }
158 pub fn is_switch(&self) -> bool {
159 match self {
160 Stmt_::Switch(..) => true,
161 _ => false,
162 }
163 }
164 pub fn is_foreach(&self) -> bool {
165 match self {
166 Stmt_::Foreach(..) => true,
167 _ => false,
168 }
169 }
170 pub fn is_try(&self) -> bool {
171 match self {
172 Stmt_::Try(..) => true,
173 _ => false,
174 }
175 }
176 pub fn is_noop(&self) -> bool {
177 match self {
178 Stmt_::Noop => true,
179 _ => false,
180 }
181 }
182 pub fn is_block(&self) -> bool {
183 match self {
184 Stmt_::Block(..) => true,
185 _ => false,
186 }
187 }
188 pub fn is_markup(&self) -> bool {
189 match self {
190 Stmt_::Markup(..) => true,
191 _ => false,
192 }
193 }
194 pub fn is_assert_env(&self) -> bool {
195 match self {
196 Stmt_::AssertEnv(..) => true,
197 _ => false,
198 }
199 }
200 pub fn as_expr(&self) -> Option<&Expr<Ex, En>> {
201 match self {
202 Stmt_::Expr(p0) => Some(&p0),
203 _ => None,
204 }
205 }
206 pub fn as_throw(&self) -> Option<&Expr<Ex, En>> {
207 match self {
208 Stmt_::Throw(p0) => Some(&p0),
209 _ => None,
210 }
211 }
212 pub fn as_return(&self) -> Option<&Option<Expr<Ex, En>>> {
213 match self {
214 Stmt_::Return(p0) => Some(&p0),
215 _ => None,
216 }
217 }
218 pub fn as_awaitall(&self) -> Option<(&Vec<(Option<Lid>, Expr<Ex, En>)>, &Block<Ex, En>)> {
219 match self {
220 Stmt_::Awaitall(p0) => Some((&p0.0, &p0.1)),
221 _ => None,
222 }
223 }
224 pub fn as_if(&self) -> Option<(&Expr<Ex, En>, &Block<Ex, En>, &Block<Ex, En>)> {
225 match self {
226 Stmt_::If(p0) => Some((&p0.0, &p0.1, &p0.2)),
227 _ => None,
228 }
229 }
230 pub fn as_do(&self) -> Option<(&Block<Ex, En>, &Expr<Ex, En>)> {
231 match self {
232 Stmt_::Do(p0) => Some((&p0.0, &p0.1)),
233 _ => None,
234 }
235 }
236 pub fn as_while(&self) -> Option<(&Expr<Ex, En>, &Block<Ex, En>)> {
237 match self {
238 Stmt_::While(p0) => Some((&p0.0, &p0.1)),
239 _ => None,
240 }
241 }
242 pub fn as_using(&self) -> Option<&UsingStmt<Ex, En>> {
243 match self {
244 Stmt_::Using(p0) => Some(&p0),
245 _ => None,
246 }
247 }
248 pub fn as_for(
249 &self,
250 ) -> Option<(
251 &Vec<Expr<Ex, En>>,
252 &Option<Expr<Ex, En>>,
253 &Vec<Expr<Ex, En>>,
254 &Block<Ex, En>,
255 )> {
256 match self {
257 Stmt_::For(p0) => Some((&p0.0, &p0.1, &p0.2, &p0.3)),
258 _ => None,
259 }
260 }
261 pub fn as_switch(&self) -> Option<(&Expr<Ex, En>, &Vec<Case<Ex, En>>)> {
262 match self {
263 Stmt_::Switch(p0) => Some((&p0.0, &p0.1)),
264 _ => None,
265 }
266 }
267 pub fn as_foreach(&self) -> Option<(&Expr<Ex, En>, &AsExpr<Ex, En>, &Block<Ex, En>)> {
268 match self {
269 Stmt_::Foreach(p0) => Some((&p0.0, &p0.1, &p0.2)),
270 _ => None,
271 }
272 }
273 pub fn as_try(&self) -> Option<(&Block<Ex, En>, &Vec<Catch<Ex, En>>, &Block<Ex, En>)> {
274 match self {
275 Stmt_::Try(p0) => Some((&p0.0, &p0.1, &p0.2)),
276 _ => None,
277 }
278 }
279 pub fn as_block(&self) -> Option<&Block<Ex, En>> {
280 match self {
281 Stmt_::Block(p0) => Some(p0),
282 _ => None,
283 }
284 }
285 pub fn as_markup(&self) -> Option<&Pstring> {
286 match self {
287 Stmt_::Markup(p0) => Some(&p0),
288 _ => None,
289 }
290 }
291 pub fn as_assert_env(&self) -> Option<(&EnvAnnot, &LocalIdMap<(Pos, Ex)>)> {
292 match self {
293 Stmt_::AssertEnv(p0) => Some((&p0.0, &p0.1)),
294 _ => None,
295 }
296 }
297 pub fn as_expr_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
298 match self {
299 Stmt_::Expr(p0) => Some(p0.as_mut()),
300 _ => None,
301 }
302 }
303 pub fn as_throw_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
304 match self {
305 Stmt_::Throw(p0) => Some(p0.as_mut()),
306 _ => None,
307 }
308 }
309 pub fn as_return_mut(&mut self) -> Option<&mut Option<Expr<Ex, En>>> {
310 match self {
311 Stmt_::Return(p0) => Some(p0.as_mut()),
312 _ => None,
313 }
314 }
315 pub fn as_awaitall_mut(
316 &mut self,
317 ) -> Option<(&mut Vec<(Option<Lid>, Expr<Ex, En>)>, &mut Block<Ex, En>)> {
318 match self {
319 Stmt_::Awaitall(p0) => Some((&mut p0.0, &mut p0.1)),
320 _ => None,
321 }
322 }
323 pub fn as_if_mut(
324 &mut self,
325 ) -> Option<(&mut Expr<Ex, En>, &mut Block<Ex, En>, &mut Block<Ex, En>)> {
326 match self {
327 Stmt_::If(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
328 _ => None,
329 }
330 }
331 pub fn as_do_mut(&mut self) -> Option<(&mut Block<Ex, En>, &mut Expr<Ex, En>)> {
332 match self {
333 Stmt_::Do(p0) => Some((&mut p0.0, &mut p0.1)),
334 _ => None,
335 }
336 }
337 pub fn as_while_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Block<Ex, En>)> {
338 match self {
339 Stmt_::While(p0) => Some((&mut p0.0, &mut p0.1)),
340 _ => None,
341 }
342 }
343 pub fn as_using_mut(&mut self) -> Option<&mut UsingStmt<Ex, En>> {
344 match self {
345 Stmt_::Using(p0) => Some(p0.as_mut()),
346 _ => None,
347 }
348 }
349 pub fn as_for_mut(
350 &mut self,
351 ) -> Option<(
352 &mut Vec<Expr<Ex, En>>,
353 &mut Option<Expr<Ex, En>>,
354 &mut Vec<Expr<Ex, En>>,
355 &mut Block<Ex, En>,
356 )> {
357 match self {
358 Stmt_::For(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2, &mut p0.3)),
359 _ => None,
360 }
361 }
362 pub fn as_switch_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Vec<Case<Ex, En>>)> {
363 match self {
364 Stmt_::Switch(p0) => Some((&mut p0.0, &mut p0.1)),
365 _ => None,
366 }
367 }
368 pub fn as_foreach_mut(
369 &mut self,
370 ) -> Option<(&mut Expr<Ex, En>, &mut AsExpr<Ex, En>, &mut Block<Ex, En>)> {
371 match self {
372 Stmt_::Foreach(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
373 _ => None,
374 }
375 }
376 pub fn as_try_mut(
377 &mut self,
378 ) -> Option<(
379 &mut Block<Ex, En>,
380 &mut Vec<Catch<Ex, En>>,
381 &mut Block<Ex, En>,
382 )> {
383 match self {
384 Stmt_::Try(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
385 _ => None,
386 }
387 }
388 pub fn as_block_mut(&mut self) -> Option<&mut Block<Ex, En>> {
389 match self {
390 Stmt_::Block(p0) => Some(p0),
391 _ => None,
392 }
393 }
394 pub fn as_markup_mut(&mut self) -> Option<&mut Pstring> {
395 match self {
396 Stmt_::Markup(p0) => Some(p0.as_mut()),
397 _ => None,
398 }
399 }
400 pub fn as_assert_env_mut(&mut self) -> Option<(&mut EnvAnnot, &mut LocalIdMap<(Pos, Ex)>)> {
401 match self {
402 Stmt_::AssertEnv(p0) => Some((&mut p0.0, &mut p0.1)),
403 _ => None,
404 }
405 }
406 pub fn as_expr_into(self) -> Option<Expr<Ex, En>> {
407 match self {
408 Stmt_::Expr(p0) => Some(*p0),
409 _ => None,
410 }
411 }
412 pub fn as_throw_into(self) -> Option<Expr<Ex, En>> {
413 match self {
414 Stmt_::Throw(p0) => Some(*p0),
415 _ => None,
416 }
417 }
418 pub fn as_return_into(self) -> Option<Option<Expr<Ex, En>>> {
419 match self {
420 Stmt_::Return(p0) => Some(*p0),
421 _ => None,
422 }
423 }
424 pub fn as_awaitall_into(self) -> Option<(Vec<(Option<Lid>, Expr<Ex, En>)>, Block<Ex, En>)> {
425 match self {
426 Stmt_::Awaitall(p0) => Some(((*p0).0, (*p0).1)),
427 _ => None,
428 }
429 }
430 pub fn as_if_into(self) -> Option<(Expr<Ex, En>, Block<Ex, En>, Block<Ex, En>)> {
431 match self {
432 Stmt_::If(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
433 _ => None,
434 }
435 }
436 pub fn as_do_into(self) -> Option<(Block<Ex, En>, Expr<Ex, En>)> {
437 match self {
438 Stmt_::Do(p0) => Some(((*p0).0, (*p0).1)),
439 _ => None,
440 }
441 }
442 pub fn as_while_into(self) -> Option<(Expr<Ex, En>, Block<Ex, En>)> {
443 match self {
444 Stmt_::While(p0) => Some(((*p0).0, (*p0).1)),
445 _ => None,
446 }
447 }
448 pub fn as_using_into(self) -> Option<UsingStmt<Ex, En>> {
449 match self {
450 Stmt_::Using(p0) => Some(*p0),
451 _ => None,
452 }
453 }
454 pub fn as_for_into(
455 self,
456 ) -> Option<(
457 Vec<Expr<Ex, En>>,
458 Option<Expr<Ex, En>>,
459 Vec<Expr<Ex, En>>,
460 Block<Ex, En>,
461 )> {
462 match self {
463 Stmt_::For(p0) => Some(((*p0).0, (*p0).1, (*p0).2, (*p0).3)),
464 _ => None,
465 }
466 }
467 pub fn as_switch_into(self) -> Option<(Expr<Ex, En>, Vec<Case<Ex, En>>)> {
468 match self {
469 Stmt_::Switch(p0) => Some(((*p0).0, (*p0).1)),
470 _ => None,
471 }
472 }
473 pub fn as_foreach_into(self) -> Option<(Expr<Ex, En>, AsExpr<Ex, En>, Block<Ex, En>)> {
474 match self {
475 Stmt_::Foreach(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
476 _ => None,
477 }
478 }
479 pub fn as_try_into(self) -> Option<(Block<Ex, En>, Vec<Catch<Ex, En>>, Block<Ex, En>)> {
480 match self {
481 Stmt_::Try(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
482 _ => None,
483 }
484 }
485 pub fn as_block_into(self) -> Option<Block<Ex, En>> {
486 match self {
487 Stmt_::Block(p0) => Some(p0),
488 _ => None,
489 }
490 }
491 pub fn as_markup_into(self) -> Option<Pstring> {
492 match self {
493 Stmt_::Markup(p0) => Some(*p0),
494 _ => None,
495 }
496 }
497 pub fn as_assert_env_into(self) -> Option<(EnvAnnot, LocalIdMap<(Pos, Ex)>)> {
498 match self {
499 Stmt_::AssertEnv(p0) => Some(((*p0).0, (*p0).1)),
500 _ => None,
501 }
502 }
503 }
504 impl EnvAnnot {
505 pub fn mk_join() -> Self {
506 EnvAnnot::Join
507 }
508 pub fn mk_refinement() -> Self {
509 EnvAnnot::Refinement
510 }
511 pub fn is_join(&self) -> bool {
512 match self {
513 EnvAnnot::Join => true,
514 _ => false,
515 }
516 }
517 pub fn is_refinement(&self) -> bool {
518 match self {
519 EnvAnnot::Refinement => true,
520 _ => false,
521 }
522 }
523 }
524 impl<Ex, En> AsExpr<Ex, En> {
525 pub fn mk_as_v(p0: Expr<Ex, En>) -> Self {
526 AsExpr::AsV(p0)
527 }
528 pub fn mk_as_kv(p0: Expr<Ex, En>, p1: Expr<Ex, En>) -> Self {
529 AsExpr::AsKv(p0, p1)
530 }
531 pub fn mk_await_as_v(p0: Pos, p1: Expr<Ex, En>) -> Self {
532 AsExpr::AwaitAsV(p0, p1)
533 }
534 pub fn mk_await_as_kv(p0: Pos, p1: Expr<Ex, En>, p2: Expr<Ex, En>) -> Self {
535 AsExpr::AwaitAsKv(p0, p1, p2)
536 }
537 pub fn is_as_v(&self) -> bool {
538 match self {
539 AsExpr::AsV(..) => true,
540 _ => false,
541 }
542 }
543 pub fn is_as_kv(&self) -> bool {
544 match self {
545 AsExpr::AsKv(..) => true,
546 _ => false,
547 }
548 }
549 pub fn is_await_as_v(&self) -> bool {
550 match self {
551 AsExpr::AwaitAsV(..) => true,
552 _ => false,
553 }
554 }
555 pub fn is_await_as_kv(&self) -> bool {
556 match self {
557 AsExpr::AwaitAsKv(..) => true,
558 _ => false,
559 }
560 }
561 pub fn as_as_v(&self) -> Option<&Expr<Ex, En>> {
562 match self {
563 AsExpr::AsV(p0) => Some(p0),
564 _ => None,
565 }
566 }
567 pub fn as_as_kv(&self) -> Option<(&Expr<Ex, En>, &Expr<Ex, En>)> {
568 match self {
569 AsExpr::AsKv(p0, p1) => Some((p0, p1)),
570 _ => None,
571 }
572 }
573 pub fn as_await_as_v(&self) -> Option<(&Pos, &Expr<Ex, En>)> {
574 match self {
575 AsExpr::AwaitAsV(p0, p1) => Some((p0, p1)),
576 _ => None,
577 }
578 }
579 pub fn as_await_as_kv(&self) -> Option<(&Pos, &Expr<Ex, En>, &Expr<Ex, En>)> {
580 match self {
581 AsExpr::AwaitAsKv(p0, p1, p2) => Some((p0, p1, p2)),
582 _ => None,
583 }
584 }
585 pub fn as_as_v_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
586 match self {
587 AsExpr::AsV(p0) => Some(p0),
588 _ => None,
589 }
590 }
591 pub fn as_as_kv_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Expr<Ex, En>)> {
592 match self {
593 AsExpr::AsKv(p0, p1) => Some((p0, p1)),
594 _ => None,
595 }
596 }
597 pub fn as_await_as_v_mut(&mut self) -> Option<(&mut Pos, &mut Expr<Ex, En>)> {
598 match self {
599 AsExpr::AwaitAsV(p0, p1) => Some((p0, p1)),
600 _ => None,
601 }
602 }
603 pub fn as_await_as_kv_mut(
604 &mut self,
605 ) -> Option<(&mut Pos, &mut Expr<Ex, En>, &mut Expr<Ex, En>)> {
606 match self {
607 AsExpr::AwaitAsKv(p0, p1, p2) => Some((p0, p1, p2)),
608 _ => None,
609 }
610 }
611 pub fn as_as_v_into(self) -> Option<Expr<Ex, En>> {
612 match self {
613 AsExpr::AsV(p0) => Some(p0),
614 _ => None,
615 }
616 }
617 pub fn as_as_kv_into(self) -> Option<(Expr<Ex, En>, Expr<Ex, En>)> {
618 match self {
619 AsExpr::AsKv(p0, p1) => Some((p0, p1)),
620 _ => None,
621 }
622 }
623 pub fn as_await_as_v_into(self) -> Option<(Pos, Expr<Ex, En>)> {
624 match self {
625 AsExpr::AwaitAsV(p0, p1) => Some((p0, p1)),
626 _ => None,
627 }
628 }
629 pub fn as_await_as_kv_into(self) -> Option<(Pos, Expr<Ex, En>, Expr<Ex, En>)> {
630 match self {
631 AsExpr::AwaitAsKv(p0, p1, p2) => Some((p0, p1, p2)),
632 _ => None,
633 }
634 }
635 }
636 impl<Ex, En> ClassId_<Ex, En> {
637 pub fn mk_ciparent() -> Self {
638 ClassId_::CIparent
639 }
640 pub fn mk_ciself() -> Self {
641 ClassId_::CIself
642 }
643 pub fn mk_cistatic() -> Self {
644 ClassId_::CIstatic
645 }
646 pub fn mk_ciexpr(p0: Expr<Ex, En>) -> Self {
647 ClassId_::CIexpr(p0)
648 }
649 pub fn mk_ci(p0: ClassName) -> Self {
650 ClassId_::CI(p0)
651 }
652 pub fn is_ciparent(&self) -> bool {
653 match self {
654 ClassId_::CIparent => true,
655 _ => false,
656 }
657 }
658 pub fn is_ciself(&self) -> bool {
659 match self {
660 ClassId_::CIself => true,
661 _ => false,
662 }
663 }
664 pub fn is_cistatic(&self) -> bool {
665 match self {
666 ClassId_::CIstatic => true,
667 _ => false,
668 }
669 }
670 pub fn is_ciexpr(&self) -> bool {
671 match self {
672 ClassId_::CIexpr(..) => true,
673 _ => false,
674 }
675 }
676 pub fn is_ci(&self) -> bool {
677 match self {
678 ClassId_::CI(..) => true,
679 _ => false,
680 }
681 }
682 pub fn as_ciexpr(&self) -> Option<&Expr<Ex, En>> {
683 match self {
684 ClassId_::CIexpr(p0) => Some(p0),
685 _ => None,
686 }
687 }
688 pub fn as_ci(&self) -> Option<&ClassName> {
689 match self {
690 ClassId_::CI(p0) => Some(p0),
691 _ => None,
692 }
693 }
694 pub fn as_ciexpr_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
695 match self {
696 ClassId_::CIexpr(p0) => Some(p0),
697 _ => None,
698 }
699 }
700 pub fn as_ci_mut(&mut self) -> Option<&mut ClassName> {
701 match self {
702 ClassId_::CI(p0) => Some(p0),
703 _ => None,
704 }
705 }
706 pub fn as_ciexpr_into(self) -> Option<Expr<Ex, En>> {
707 match self {
708 ClassId_::CIexpr(p0) => Some(p0),
709 _ => None,
710 }
711 }
712 pub fn as_ci_into(self) -> Option<ClassName> {
713 match self {
714 ClassId_::CI(p0) => Some(p0),
715 _ => None,
716 }
717 }
718 }
719 impl<Ex> CollectionTarg<Ex> {
720 pub fn mk_collectiontv(p0: Targ<Ex>) -> Self {
721 CollectionTarg::CollectionTV(p0)
722 }
723 pub fn mk_collectiontkv(p0: Targ<Ex>, p1: Targ<Ex>) -> Self {
724 CollectionTarg::CollectionTKV(p0, p1)
725 }
726 pub fn is_collectiontv(&self) -> bool {
727 match self {
728 CollectionTarg::CollectionTV(..) => true,
729 _ => false,
730 }
731 }
732 pub fn is_collectiontkv(&self) -> bool {
733 match self {
734 CollectionTarg::CollectionTKV(..) => true,
735 _ => false,
736 }
737 }
738 pub fn as_collectiontv(&self) -> Option<&Targ<Ex>> {
739 match self {
740 CollectionTarg::CollectionTV(p0) => Some(p0),
741 _ => None,
742 }
743 }
744 pub fn as_collectiontkv(&self) -> Option<(&Targ<Ex>, &Targ<Ex>)> {
745 match self {
746 CollectionTarg::CollectionTKV(p0, p1) => Some((p0, p1)),
747 _ => None,
748 }
749 }
750 pub fn as_collectiontv_mut(&mut self) -> Option<&mut Targ<Ex>> {
751 match self {
752 CollectionTarg::CollectionTV(p0) => Some(p0),
753 _ => None,
754 }
755 }
756 pub fn as_collectiontkv_mut(&mut self) -> Option<(&mut Targ<Ex>, &mut Targ<Ex>)> {
757 match self {
758 CollectionTarg::CollectionTKV(p0, p1) => Some((p0, p1)),
759 _ => None,
760 }
761 }
762 pub fn as_collectiontv_into(self) -> Option<Targ<Ex>> {
763 match self {
764 CollectionTarg::CollectionTV(p0) => Some(p0),
765 _ => None,
766 }
767 }
768 pub fn as_collectiontkv_into(self) -> Option<(Targ<Ex>, Targ<Ex>)> {
769 match self {
770 CollectionTarg::CollectionTKV(p0, p1) => Some((p0, p1)),
771 _ => None,
772 }
773 }
774 }
775 impl<Ex, En> FunctionPtrId<Ex, En> {
776 pub fn mk_fpid(p0: Sid) -> Self {
777 FunctionPtrId::FPId(p0)
778 }
779 pub fn mk_fpclass_const(p0: ClassId<Ex, En>, p1: Pstring) -> Self {
780 FunctionPtrId::FPClassConst(p0, p1)
781 }
782 pub fn is_fpid(&self) -> bool {
783 match self {
784 FunctionPtrId::FPId(..) => true,
785 _ => false,
786 }
787 }
788 pub fn is_fpclass_const(&self) -> bool {
789 match self {
790 FunctionPtrId::FPClassConst(..) => true,
791 _ => false,
792 }
793 }
794 pub fn as_fpid(&self) -> Option<&Sid> {
795 match self {
796 FunctionPtrId::FPId(p0) => Some(p0),
797 _ => None,
798 }
799 }
800 pub fn as_fpclass_const(&self) -> Option<(&ClassId<Ex, En>, &Pstring)> {
801 match self {
802 FunctionPtrId::FPClassConst(p0, p1) => Some((p0, p1)),
803 _ => None,
804 }
805 }
806 pub fn as_fpid_mut(&mut self) -> Option<&mut Sid> {
807 match self {
808 FunctionPtrId::FPId(p0) => Some(p0),
809 _ => None,
810 }
811 }
812 pub fn as_fpclass_const_mut(&mut self) -> Option<(&mut ClassId<Ex, En>, &mut Pstring)> {
813 match self {
814 FunctionPtrId::FPClassConst(p0, p1) => Some((p0, p1)),
815 _ => None,
816 }
817 }
818 pub fn as_fpid_into(self) -> Option<Sid> {
819 match self {
820 FunctionPtrId::FPId(p0) => Some(p0),
821 _ => None,
822 }
823 }
824 pub fn as_fpclass_const_into(self) -> Option<(ClassId<Ex, En>, Pstring)> {
825 match self {
826 FunctionPtrId::FPClassConst(p0, p1) => Some((p0, p1)),
827 _ => None,
828 }
829 }
830 }
831 impl<Ex, En> Expr_<Ex, En> {
832 pub fn mk_darray(
833 p0: Option<(Targ<Ex>, Targ<Ex>)>,
834 p1: Vec<(Expr<Ex, En>, Expr<Ex, En>)>,
835 ) -> Self {
836 Expr_::Darray(Box::new((p0, p1)))
837 }
838 pub fn mk_varray(p0: Option<Targ<Ex>>, p1: Vec<Expr<Ex, En>>) -> Self {
839 Expr_::Varray(Box::new((p0, p1)))
840 }
841 pub fn mk_shape(p0: Vec<(ast_defs::ShapeFieldName, Expr<Ex, En>)>) -> Self {
842 Expr_::Shape(p0)
843 }
844 pub fn mk_val_collection(p0: VcKind, p1: Option<Targ<Ex>>, p2: Vec<Expr<Ex, En>>) -> Self {
845 Expr_::ValCollection(Box::new((p0, p1, p2)))
846 }
847 pub fn mk_key_val_collection(
848 p0: KvcKind,
849 p1: Option<(Targ<Ex>, Targ<Ex>)>,
850 p2: Vec<Field<Ex, En>>,
851 ) -> Self {
852 Expr_::KeyValCollection(Box::new((p0, p1, p2)))
853 }
854 pub fn mk_null() -> Self {
855 Expr_::Null
856 }
857 pub fn mk_this() -> Self {
858 Expr_::This
859 }
860 pub fn mk_true() -> Self {
861 Expr_::True
862 }
863 pub fn mk_false() -> Self {
864 Expr_::False
865 }
866 pub fn mk_omitted() -> Self {
867 Expr_::Omitted
868 }
869 pub fn mk_id(p0: Sid) -> Self {
870 Expr_::Id(Box::new(p0))
871 }
872 pub fn mk_lvar(p0: Lid) -> Self {
873 Expr_::Lvar(Box::new(p0))
874 }
875 pub fn mk_dollardollar(p0: Lid) -> Self {
876 Expr_::Dollardollar(Box::new(p0))
877 }
878 pub fn mk_clone(p0: Expr<Ex, En>) -> Self {
879 Expr_::Clone(Box::new(p0))
880 }
881 pub fn mk_array_get(p0: Expr<Ex, En>, p1: Option<Expr<Ex, En>>) -> Self {
882 Expr_::ArrayGet(Box::new((p0, p1)))
883 }
884 pub fn mk_obj_get(p0: Expr<Ex, En>, p1: Expr<Ex, En>, p2: OgNullFlavor, p3: bool) -> Self {
885 Expr_::ObjGet(Box::new((p0, p1, p2, p3)))
886 }
887 pub fn mk_class_get(p0: ClassId<Ex, En>, p1: ClassGetExpr<Ex, En>, p2: bool) -> Self {
888 Expr_::ClassGet(Box::new((p0, p1, p2)))
889 }
890 pub fn mk_class_const(p0: ClassId<Ex, En>, p1: Pstring) -> Self {
891 Expr_::ClassConst(Box::new((p0, p1)))
892 }
893 pub fn mk_call(
894 p0: Expr<Ex, En>,
895 p1: Vec<Targ<Ex>>,
896 p2: Vec<(ast_defs::ParamKind, Expr<Ex, En>)>,
897 p3: Option<Expr<Ex, En>>,
898 ) -> Self {
899 Expr_::Call(Box::new((p0, p1, p2, p3)))
900 }
901 pub fn mk_function_pointer(p0: FunctionPtrId<Ex, En>, p1: Vec<Targ<Ex>>) -> Self {
902 Expr_::FunctionPointer(Box::new((p0, p1)))
903 }
904 pub fn mk_int(p0: String) -> Self {
905 Expr_::Int(p0)
906 }
907 pub fn mk_float(p0: String) -> Self {
908 Expr_::Float(p0)
909 }
910 pub fn mk_string(p0: bstr::BString) -> Self {
911 Expr_::String(p0)
912 }
913 pub fn mk_string2(p0: Vec<Expr<Ex, En>>) -> Self {
914 Expr_::String2(p0)
915 }
916 pub fn mk_prefixed_string(p0: String, p1: Expr<Ex, En>) -> Self {
917 Expr_::PrefixedString(Box::new((p0, p1)))
918 }
919 pub fn mk_yield(p0: Afield<Ex, En>) -> Self {
920 Expr_::Yield(Box::new(p0))
921 }
922 pub fn mk_await(p0: Expr<Ex, En>) -> Self {
923 Expr_::Await(Box::new(p0))
924 }
925 pub fn mk_readonly_expr(p0: Expr<Ex, En>) -> Self {
926 Expr_::ReadonlyExpr(Box::new(p0))
927 }
928 pub fn mk_tuple(p0: Vec<Expr<Ex, En>>) -> Self {
929 Expr_::Tuple(p0)
930 }
931 pub fn mk_list(p0: Vec<Expr<Ex, En>>) -> Self {
932 Expr_::List(p0)
933 }
934 pub fn mk_cast(p0: Hint, p1: Expr<Ex, En>) -> Self {
935 Expr_::Cast(Box::new((p0, p1)))
936 }
937 pub fn mk_unop(p0: ast_defs::Uop, p1: Expr<Ex, En>) -> Self {
938 Expr_::Unop(Box::new((p0, p1)))
939 }
940 pub fn mk_binop(p0: ast_defs::Bop, p1: Expr<Ex, En>, p2: Expr<Ex, En>) -> Self {
941 Expr_::Binop(Box::new((p0, p1, p2)))
942 }
943 pub fn mk_pipe(p0: Lid, p1: Expr<Ex, En>, p2: Expr<Ex, En>) -> Self {
944 Expr_::Pipe(Box::new((p0, p1, p2)))
945 }
946 pub fn mk_eif(p0: Expr<Ex, En>, p1: Option<Expr<Ex, En>>, p2: Expr<Ex, En>) -> Self {
947 Expr_::Eif(Box::new((p0, p1, p2)))
948 }
949 pub fn mk_is(p0: Expr<Ex, En>, p1: Hint) -> Self {
950 Expr_::Is(Box::new((p0, p1)))
951 }
952 pub fn mk_as(p0: Expr<Ex, En>, p1: Hint, p2: bool) -> Self {
953 Expr_::As(Box::new((p0, p1, p2)))
954 }
955 pub fn mk_upcast(p0: Expr<Ex, En>, p1: Hint) -> Self {
956 Expr_::Upcast(Box::new((p0, p1)))
957 }
958 pub fn mk_new(
959 p0: ClassId<Ex, En>,
960 p1: Vec<Targ<Ex>>,
961 p2: Vec<Expr<Ex, En>>,
962 p3: Option<Expr<Ex, En>>,
963 p4: Ex,
964 ) -> Self {
965 Expr_::New(Box::new((p0, p1, p2, p3, p4)))
966 }
967 pub fn mk_record(p0: Sid, p1: Vec<(Expr<Ex, En>, Expr<Ex, En>)>) -> Self {
968 Expr_::Record(Box::new((p0, p1)))
969 }
970 pub fn mk_efun(p0: Fun_<Ex, En>, p1: Vec<Lid>) -> Self {
971 Expr_::Efun(Box::new((p0, p1)))
972 }
973 pub fn mk_lfun(p0: Fun_<Ex, En>, p1: Vec<Lid>) -> Self {
974 Expr_::Lfun(Box::new((p0, p1)))
975 }
976 pub fn mk_xml(p0: ClassName, p1: Vec<XhpAttribute<Ex, En>>, p2: Vec<Expr<Ex, En>>) -> Self {
977 Expr_::Xml(Box::new((p0, p1, p2)))
978 }
979 pub fn mk_import(p0: ImportFlavor, p1: Expr<Ex, En>) -> Self {
980 Expr_::Import(Box::new((p0, p1)))
981 }
982 pub fn mk_collection(
983 p0: ClassName,
984 p1: Option<CollectionTarg<Ex>>,
985 p2: Vec<Afield<Ex, En>>,
986 ) -> Self {
987 Expr_::Collection(Box::new((p0, p1, p2)))
988 }
989 pub fn mk_expression_tree(p0: ExpressionTree<Ex, En>) -> Self {
990 Expr_::ExpressionTree(Box::new(p0))
991 }
992 pub fn mk_lplaceholder(p0: Pos) -> Self {
993 Expr_::Lplaceholder(Box::new(p0))
994 }
995 pub fn mk_fun_id(p0: Sid) -> Self {
996 Expr_::FunId(Box::new(p0))
997 }
998 pub fn mk_method_id(p0: Expr<Ex, En>, p1: Pstring) -> Self {
999 Expr_::MethodId(Box::new((p0, p1)))
1000 }
1001 pub fn mk_method_caller(p0: ClassName, p1: Pstring) -> Self {
1002 Expr_::MethodCaller(Box::new((p0, p1)))
1003 }
1004 pub fn mk_smethod_id(p0: ClassId<Ex, En>, p1: Pstring) -> Self {
1005 Expr_::SmethodId(Box::new((p0, p1)))
1006 }
1007 pub fn mk_pair(p0: Option<(Targ<Ex>, Targ<Ex>)>, p1: Expr<Ex, En>, p2: Expr<Ex, En>) -> Self {
1008 Expr_::Pair(Box::new((p0, p1, p2)))
1009 }
1010 pub fn mk_etsplice(p0: Expr<Ex, En>) -> Self {
1011 Expr_::ETSplice(Box::new(p0))
1012 }
1013 pub fn mk_enum_class_label(p0: Option<ClassName>, p1: String) -> Self {
1014 Expr_::EnumClassLabel(Box::new((p0, p1)))
1015 }
1016 pub fn mk_hole(p0: Expr<Ex, En>, p1: Ex, p2: Ex, p3: HoleSource) -> Self {
1017 Expr_::Hole(Box::new((p0, p1, p2, p3)))
1018 }
1019 pub fn is_darray(&self) -> bool {
1020 match self {
1021 Expr_::Darray(..) => true,
1022 _ => false,
1023 }
1024 }
1025 pub fn is_varray(&self) -> bool {
1026 match self {
1027 Expr_::Varray(..) => true,
1028 _ => false,
1029 }
1030 }
1031 pub fn is_shape(&self) -> bool {
1032 match self {
1033 Expr_::Shape(..) => true,
1034 _ => false,
1035 }
1036 }
1037 pub fn is_val_collection(&self) -> bool {
1038 match self {
1039 Expr_::ValCollection(..) => true,
1040 _ => false,
1041 }
1042 }
1043 pub fn is_key_val_collection(&self) -> bool {
1044 match self {
1045 Expr_::KeyValCollection(..) => true,
1046 _ => false,
1047 }
1048 }
1049 pub fn is_null(&self) -> bool {
1050 match self {
1051 Expr_::Null => true,
1052 _ => false,
1053 }
1054 }
1055 pub fn is_this(&self) -> bool {
1056 match self {
1057 Expr_::This => true,
1058 _ => false,
1059 }
1060 }
1061 pub fn is_true(&self) -> bool {
1062 match self {
1063 Expr_::True => true,
1064 _ => false,
1065 }
1066 }
1067 pub fn is_false(&self) -> bool {
1068 match self {
1069 Expr_::False => true,
1070 _ => false,
1071 }
1072 }
1073 pub fn is_omitted(&self) -> bool {
1074 match self {
1075 Expr_::Omitted => true,
1076 _ => false,
1077 }
1078 }
1079 pub fn is_id(&self) -> bool {
1080 match self {
1081 Expr_::Id(..) => true,
1082 _ => false,
1083 }
1084 }
1085 pub fn is_lvar(&self) -> bool {
1086 match self {
1087 Expr_::Lvar(..) => true,
1088 _ => false,
1089 }
1090 }
1091 pub fn is_dollardollar(&self) -> bool {
1092 match self {
1093 Expr_::Dollardollar(..) => true,
1094 _ => false,
1095 }
1096 }
1097 pub fn is_clone(&self) -> bool {
1098 match self {
1099 Expr_::Clone(..) => true,
1100 _ => false,
1101 }
1102 }
1103 pub fn is_array_get(&self) -> bool {
1104 match self {
1105 Expr_::ArrayGet(..) => true,
1106 _ => false,
1107 }
1108 }
1109 pub fn is_obj_get(&self) -> bool {
1110 match self {
1111 Expr_::ObjGet(..) => true,
1112 _ => false,
1113 }
1114 }
1115 pub fn is_class_get(&self) -> bool {
1116 match self {
1117 Expr_::ClassGet(..) => true,
1118 _ => false,
1119 }
1120 }
1121 pub fn is_class_const(&self) -> bool {
1122 match self {
1123 Expr_::ClassConst(..) => true,
1124 _ => false,
1125 }
1126 }
1127 pub fn is_call(&self) -> bool {
1128 match self {
1129 Expr_::Call(..) => true,
1130 _ => false,
1131 }
1132 }
1133 pub fn is_function_pointer(&self) -> bool {
1134 match self {
1135 Expr_::FunctionPointer(..) => true,
1136 _ => false,
1137 }
1138 }
1139 pub fn is_int(&self) -> bool {
1140 match self {
1141 Expr_::Int(..) => true,
1142 _ => false,
1143 }
1144 }
1145 pub fn is_float(&self) -> bool {
1146 match self {
1147 Expr_::Float(..) => true,
1148 _ => false,
1149 }
1150 }
1151 pub fn is_string(&self) -> bool {
1152 match self {
1153 Expr_::String(..) => true,
1154 _ => false,
1155 }
1156 }
1157 pub fn is_string2(&self) -> bool {
1158 match self {
1159 Expr_::String2(..) => true,
1160 _ => false,
1161 }
1162 }
1163 pub fn is_prefixed_string(&self) -> bool {
1164 match self {
1165 Expr_::PrefixedString(..) => true,
1166 _ => false,
1167 }
1168 }
1169 pub fn is_yield(&self) -> bool {
1170 match self {
1171 Expr_::Yield(..) => true,
1172 _ => false,
1173 }
1174 }
1175 pub fn is_await(&self) -> bool {
1176 match self {
1177 Expr_::Await(..) => true,
1178 _ => false,
1179 }
1180 }
1181 pub fn is_readonly_expr(&self) -> bool {
1182 match self {
1183 Expr_::ReadonlyExpr(..) => true,
1184 _ => false,
1185 }
1186 }
1187 pub fn is_tuple(&self) -> bool {
1188 match self {
1189 Expr_::Tuple(..) => true,
1190 _ => false,
1191 }
1192 }
1193 pub fn is_list(&self) -> bool {
1194 match self {
1195 Expr_::List(..) => true,
1196 _ => false,
1197 }
1198 }
1199 pub fn is_cast(&self) -> bool {
1200 match self {
1201 Expr_::Cast(..) => true,
1202 _ => false,
1203 }
1204 }
1205 pub fn is_unop(&self) -> bool {
1206 match self {
1207 Expr_::Unop(..) => true,
1208 _ => false,
1209 }
1210 }
1211 pub fn is_binop(&self) -> bool {
1212 match self {
1213 Expr_::Binop(..) => true,
1214 _ => false,
1215 }
1216 }
1217 pub fn is_pipe(&self) -> bool {
1218 match self {
1219 Expr_::Pipe(..) => true,
1220 _ => false,
1221 }
1222 }
1223 pub fn is_eif(&self) -> bool {
1224 match self {
1225 Expr_::Eif(..) => true,
1226 _ => false,
1227 }
1228 }
1229 pub fn is_is(&self) -> bool {
1230 match self {
1231 Expr_::Is(..) => true,
1232 _ => false,
1233 }
1234 }
1235 pub fn is_as(&self) -> bool {
1236 match self {
1237 Expr_::As(..) => true,
1238 _ => false,
1239 }
1240 }
1241 pub fn is_upcast(&self) -> bool {
1242 match self {
1243 Expr_::Upcast(..) => true,
1244 _ => false,
1245 }
1246 }
1247 pub fn is_new(&self) -> bool {
1248 match self {
1249 Expr_::New(..) => true,
1250 _ => false,
1251 }
1252 }
1253 pub fn is_record(&self) -> bool {
1254 match self {
1255 Expr_::Record(..) => true,
1256 _ => false,
1257 }
1258 }
1259 pub fn is_efun(&self) -> bool {
1260 match self {
1261 Expr_::Efun(..) => true,
1262 _ => false,
1263 }
1264 }
1265 pub fn is_lfun(&self) -> bool {
1266 match self {
1267 Expr_::Lfun(..) => true,
1268 _ => false,
1269 }
1270 }
1271 pub fn is_xml(&self) -> bool {
1272 match self {
1273 Expr_::Xml(..) => true,
1274 _ => false,
1275 }
1276 }
1277 pub fn is_import(&self) -> bool {
1278 match self {
1279 Expr_::Import(..) => true,
1280 _ => false,
1281 }
1282 }
1283 pub fn is_collection(&self) -> bool {
1284 match self {
1285 Expr_::Collection(..) => true,
1286 _ => false,
1287 }
1288 }
1289 pub fn is_expression_tree(&self) -> bool {
1290 match self {
1291 Expr_::ExpressionTree(..) => true,
1292 _ => false,
1293 }
1294 }
1295 pub fn is_lplaceholder(&self) -> bool {
1296 match self {
1297 Expr_::Lplaceholder(..) => true,
1298 _ => false,
1299 }
1300 }
1301 pub fn is_fun_id(&self) -> bool {
1302 match self {
1303 Expr_::FunId(..) => true,
1304 _ => false,
1305 }
1306 }
1307 pub fn is_method_id(&self) -> bool {
1308 match self {
1309 Expr_::MethodId(..) => true,
1310 _ => false,
1311 }
1312 }
1313 pub fn is_method_caller(&self) -> bool {
1314 match self {
1315 Expr_::MethodCaller(..) => true,
1316 _ => false,
1317 }
1318 }
1319 pub fn is_smethod_id(&self) -> bool {
1320 match self {
1321 Expr_::SmethodId(..) => true,
1322 _ => false,
1323 }
1324 }
1325 pub fn is_pair(&self) -> bool {
1326 match self {
1327 Expr_::Pair(..) => true,
1328 _ => false,
1329 }
1330 }
1331 pub fn is_etsplice(&self) -> bool {
1332 match self {
1333 Expr_::ETSplice(..) => true,
1334 _ => false,
1335 }
1336 }
1337 pub fn is_enum_class_label(&self) -> bool {
1338 match self {
1339 Expr_::EnumClassLabel(..) => true,
1340 _ => false,
1341 }
1342 }
1343 pub fn is_hole(&self) -> bool {
1344 match self {
1345 Expr_::Hole(..) => true,
1346 _ => false,
1347 }
1348 }
1349 pub fn as_darray(
1350 &self,
1351 ) -> Option<(
1352 &Option<(Targ<Ex>, Targ<Ex>)>,
1353 &Vec<(Expr<Ex, En>, Expr<Ex, En>)>,
1354 )> {
1355 match self {
1356 Expr_::Darray(p0) => Some((&p0.0, &p0.1)),
1357 _ => None,
1358 }
1359 }
1360 pub fn as_varray(&self) -> Option<(&Option<Targ<Ex>>, &Vec<Expr<Ex, En>>)> {
1361 match self {
1362 Expr_::Varray(p0) => Some((&p0.0, &p0.1)),
1363 _ => None,
1364 }
1365 }
1366 pub fn as_shape(&self) -> Option<&Vec<(ast_defs::ShapeFieldName, Expr<Ex, En>)>> {
1367 match self {
1368 Expr_::Shape(p0) => Some(p0),
1369 _ => None,
1370 }
1371 }
1372 pub fn as_val_collection(&self) -> Option<(&VcKind, &Option<Targ<Ex>>, &Vec<Expr<Ex, En>>)> {
1373 match self {
1374 Expr_::ValCollection(p0) => Some((&p0.0, &p0.1, &p0.2)),
1375 _ => None,
1376 }
1377 }
1378 pub fn as_key_val_collection(
1379 &self,
1380 ) -> Option<(&KvcKind, &Option<(Targ<Ex>, Targ<Ex>)>, &Vec<Field<Ex, En>>)> {
1381 match self {
1382 Expr_::KeyValCollection(p0) => Some((&p0.0, &p0.1, &p0.2)),
1383 _ => None,
1384 }
1385 }
1386 pub fn as_id(&self) -> Option<&Sid> {
1387 match self {
1388 Expr_::Id(p0) => Some(&p0),
1389 _ => None,
1390 }
1391 }
1392 pub fn as_lvar(&self) -> Option<&Lid> {
1393 match self {
1394 Expr_::Lvar(p0) => Some(&p0),
1395 _ => None,
1396 }
1397 }
1398 pub fn as_dollardollar(&self) -> Option<&Lid> {
1399 match self {
1400 Expr_::Dollardollar(p0) => Some(&p0),
1401 _ => None,
1402 }
1403 }
1404 pub fn as_clone(&self) -> Option<&Expr<Ex, En>> {
1405 match self {
1406 Expr_::Clone(p0) => Some(&p0),
1407 _ => None,
1408 }
1409 }
1410 pub fn as_array_get(&self) -> Option<(&Expr<Ex, En>, &Option<Expr<Ex, En>>)> {
1411 match self {
1412 Expr_::ArrayGet(p0) => Some((&p0.0, &p0.1)),
1413 _ => None,
1414 }
1415 }
1416 pub fn as_obj_get(&self) -> Option<(&Expr<Ex, En>, &Expr<Ex, En>, &OgNullFlavor, &bool)> {
1417 match self {
1418 Expr_::ObjGet(p0) => Some((&p0.0, &p0.1, &p0.2, &p0.3)),
1419 _ => None,
1420 }
1421 }
1422 pub fn as_class_get(&self) -> Option<(&ClassId<Ex, En>, &ClassGetExpr<Ex, En>, &bool)> {
1423 match self {
1424 Expr_::ClassGet(p0) => Some((&p0.0, &p0.1, &p0.2)),
1425 _ => None,
1426 }
1427 }
1428 pub fn as_class_const(&self) -> Option<(&ClassId<Ex, En>, &Pstring)> {
1429 match self {
1430 Expr_::ClassConst(p0) => Some((&p0.0, &p0.1)),
1431 _ => None,
1432 }
1433 }
1434 pub fn as_call(
1435 &self,
1436 ) -> Option<(
1437 &Expr<Ex, En>,
1438 &Vec<Targ<Ex>>,
1439 &Vec<(ast_defs::ParamKind, Expr<Ex, En>)>,
1440 &Option<Expr<Ex, En>>,
1441 )> {
1442 match self {
1443 Expr_::Call(p0) => Some((&p0.0, &p0.1, &p0.2, &p0.3)),
1444 _ => None,
1445 }
1446 }
1447 pub fn as_function_pointer(&self) -> Option<(&FunctionPtrId<Ex, En>, &Vec<Targ<Ex>>)> {
1448 match self {
1449 Expr_::FunctionPointer(p0) => Some((&p0.0, &p0.1)),
1450 _ => None,
1451 }
1452 }
1453 pub fn as_int(&self) -> Option<&String> {
1454 match self {
1455 Expr_::Int(p0) => Some(p0),
1456 _ => None,
1457 }
1458 }
1459 pub fn as_float(&self) -> Option<&String> {
1460 match self {
1461 Expr_::Float(p0) => Some(p0),
1462 _ => None,
1463 }
1464 }
1465 pub fn as_string(&self) -> Option<&bstr::BString> {
1466 match self {
1467 Expr_::String(p0) => Some(p0),
1468 _ => None,
1469 }
1470 }
1471 pub fn as_string2(&self) -> Option<&Vec<Expr<Ex, En>>> {
1472 match self {
1473 Expr_::String2(p0) => Some(p0),
1474 _ => None,
1475 }
1476 }
1477 pub fn as_prefixed_string(&self) -> Option<(&String, &Expr<Ex, En>)> {
1478 match self {
1479 Expr_::PrefixedString(p0) => Some((&p0.0, &p0.1)),
1480 _ => None,
1481 }
1482 }
1483 pub fn as_yield(&self) -> Option<&Afield<Ex, En>> {
1484 match self {
1485 Expr_::Yield(p0) => Some(&p0),
1486 _ => None,
1487 }
1488 }
1489 pub fn as_await(&self) -> Option<&Expr<Ex, En>> {
1490 match self {
1491 Expr_::Await(p0) => Some(&p0),
1492 _ => None,
1493 }
1494 }
1495 pub fn as_readonly_expr(&self) -> Option<&Expr<Ex, En>> {
1496 match self {
1497 Expr_::ReadonlyExpr(p0) => Some(&p0),
1498 _ => None,
1499 }
1500 }
1501 pub fn as_tuple(&self) -> Option<&Vec<Expr<Ex, En>>> {
1502 match self {
1503 Expr_::Tuple(p0) => Some(p0),
1504 _ => None,
1505 }
1506 }
1507 pub fn as_list(&self) -> Option<&Vec<Expr<Ex, En>>> {
1508 match self {
1509 Expr_::List(p0) => Some(p0),
1510 _ => None,
1511 }
1512 }
1513 pub fn as_cast(&self) -> Option<(&Hint, &Expr<Ex, En>)> {
1514 match self {
1515 Expr_::Cast(p0) => Some((&p0.0, &p0.1)),
1516 _ => None,
1517 }
1518 }
1519 pub fn as_unop(&self) -> Option<(&ast_defs::Uop, &Expr<Ex, En>)> {
1520 match self {
1521 Expr_::Unop(p0) => Some((&p0.0, &p0.1)),
1522 _ => None,
1523 }
1524 }
1525 pub fn as_binop(&self) -> Option<(&ast_defs::Bop, &Expr<Ex, En>, &Expr<Ex, En>)> {
1526 match self {
1527 Expr_::Binop(p0) => Some((&p0.0, &p0.1, &p0.2)),
1528 _ => None,
1529 }
1530 }
1531 pub fn as_pipe(&self) -> Option<(&Lid, &Expr<Ex, En>, &Expr<Ex, En>)> {
1532 match self {
1533 Expr_::Pipe(p0) => Some((&p0.0, &p0.1, &p0.2)),
1534 _ => None,
1535 }
1536 }
1537 pub fn as_eif(&self) -> Option<(&Expr<Ex, En>, &Option<Expr<Ex, En>>, &Expr<Ex, En>)> {
1538 match self {
1539 Expr_::Eif(p0) => Some((&p0.0, &p0.1, &p0.2)),
1540 _ => None,
1541 }
1542 }
1543 pub fn as_is(&self) -> Option<(&Expr<Ex, En>, &Hint)> {
1544 match self {
1545 Expr_::Is(p0) => Some((&p0.0, &p0.1)),
1546 _ => None,
1547 }
1548 }
1549 pub fn as_as(&self) -> Option<(&Expr<Ex, En>, &Hint, &bool)> {
1550 match self {
1551 Expr_::As(p0) => Some((&p0.0, &p0.1, &p0.2)),
1552 _ => None,
1553 }
1554 }
1555 pub fn as_upcast(&self) -> Option<(&Expr<Ex, En>, &Hint)> {
1556 match self {
1557 Expr_::Upcast(p0) => Some((&p0.0, &p0.1)),
1558 _ => None,
1559 }
1560 }
1561 pub fn as_new(
1562 &self,
1563 ) -> Option<(
1564 &ClassId<Ex, En>,
1565 &Vec<Targ<Ex>>,
1566 &Vec<Expr<Ex, En>>,
1567 &Option<Expr<Ex, En>>,
1568 &Ex,
1569 )> {
1570 match self {
1571 Expr_::New(p0) => Some((&p0.0, &p0.1, &p0.2, &p0.3, &p0.4)),
1572 _ => None,
1573 }
1574 }
1575 pub fn as_record(&self) -> Option<(&Sid, &Vec<(Expr<Ex, En>, Expr<Ex, En>)>)> {
1576 match self {
1577 Expr_::Record(p0) => Some((&p0.0, &p0.1)),
1578 _ => None,
1579 }
1580 }
1581 pub fn as_efun(&self) -> Option<(&Fun_<Ex, En>, &Vec<Lid>)> {
1582 match self {
1583 Expr_::Efun(p0) => Some((&p0.0, &p0.1)),
1584 _ => None,
1585 }
1586 }
1587 pub fn as_lfun(&self) -> Option<(&Fun_<Ex, En>, &Vec<Lid>)> {
1588 match self {
1589 Expr_::Lfun(p0) => Some((&p0.0, &p0.1)),
1590 _ => None,
1591 }
1592 }
1593 pub fn as_xml(&self) -> Option<(&ClassName, &Vec<XhpAttribute<Ex, En>>, &Vec<Expr<Ex, En>>)> {
1594 match self {
1595 Expr_::Xml(p0) => Some((&p0.0, &p0.1, &p0.2)),
1596 _ => None,
1597 }
1598 }
1599 pub fn as_import(&self) -> Option<(&ImportFlavor, &Expr<Ex, En>)> {
1600 match self {
1601 Expr_::Import(p0) => Some((&p0.0, &p0.1)),
1602 _ => None,
1603 }
1604 }
1605 pub fn as_collection(
1606 &self,
1607 ) -> Option<(
1608 &ClassName,
1609 &Option<CollectionTarg<Ex>>,
1610 &Vec<Afield<Ex, En>>,
1611 )> {
1612 match self {
1613 Expr_::Collection(p0) => Some((&p0.0, &p0.1, &p0.2)),
1614 _ => None,
1615 }
1616 }
1617 pub fn as_expression_tree(&self) -> Option<&ExpressionTree<Ex, En>> {
1618 match self {
1619 Expr_::ExpressionTree(p0) => Some(&p0),
1620 _ => None,
1621 }
1622 }
1623 pub fn as_lplaceholder(&self) -> Option<&Pos> {
1624 match self {
1625 Expr_::Lplaceholder(p0) => Some(&p0),
1626 _ => None,
1627 }
1628 }
1629 pub fn as_fun_id(&self) -> Option<&Sid> {
1630 match self {
1631 Expr_::FunId(p0) => Some(&p0),
1632 _ => None,
1633 }
1634 }
1635 pub fn as_method_id(&self) -> Option<(&Expr<Ex, En>, &Pstring)> {
1636 match self {
1637 Expr_::MethodId(p0) => Some((&p0.0, &p0.1)),
1638 _ => None,
1639 }
1640 }
1641 pub fn as_method_caller(&self) -> Option<(&ClassName, &Pstring)> {
1642 match self {
1643 Expr_::MethodCaller(p0) => Some((&p0.0, &p0.1)),
1644 _ => None,
1645 }
1646 }
1647 pub fn as_smethod_id(&self) -> Option<(&ClassId<Ex, En>, &Pstring)> {
1648 match self {
1649 Expr_::SmethodId(p0) => Some((&p0.0, &p0.1)),
1650 _ => None,
1651 }
1652 }
1653 pub fn as_pair(&self) -> Option<(&Option<(Targ<Ex>, Targ<Ex>)>, &Expr<Ex, En>, &Expr<Ex, En>)> {
1654 match self {
1655 Expr_::Pair(p0) => Some((&p0.0, &p0.1, &p0.2)),
1656 _ => None,
1657 }
1658 }
1659 pub fn as_etsplice(&self) -> Option<&Expr<Ex, En>> {
1660 match self {
1661 Expr_::ETSplice(p0) => Some(&p0),
1662 _ => None,
1663 }
1664 }
1665 pub fn as_enum_class_label(&self) -> Option<(&Option<ClassName>, &String)> {
1666 match self {
1667 Expr_::EnumClassLabel(p0) => Some((&p0.0, &p0.1)),
1668 _ => None,
1669 }
1670 }
1671 pub fn as_hole(&self) -> Option<(&Expr<Ex, En>, &Ex, &Ex, &HoleSource)> {
1672 match self {
1673 Expr_::Hole(p0) => Some((&p0.0, &p0.1, &p0.2, &p0.3)),
1674 _ => None,
1675 }
1676 }
1677 pub fn as_darray_mut(
1678 &mut self,
1679 ) -> Option<(
1680 &mut Option<(Targ<Ex>, Targ<Ex>)>,
1681 &mut Vec<(Expr<Ex, En>, Expr<Ex, En>)>,
1682 )> {
1683 match self {
1684 Expr_::Darray(p0) => Some((&mut p0.0, &mut p0.1)),
1685 _ => None,
1686 }
1687 }
1688 pub fn as_varray_mut(&mut self) -> Option<(&mut Option<Targ<Ex>>, &mut Vec<Expr<Ex, En>>)> {
1689 match self {
1690 Expr_::Varray(p0) => Some((&mut p0.0, &mut p0.1)),
1691 _ => None,
1692 }
1693 }
1694 pub fn as_shape_mut(&mut self) -> Option<&mut Vec<(ast_defs::ShapeFieldName, Expr<Ex, En>)>> {
1695 match self {
1696 Expr_::Shape(p0) => Some(p0),
1697 _ => None,
1698 }
1699 }
1700 pub fn as_val_collection_mut(
1701 &mut self,
1702 ) -> Option<(&mut VcKind, &mut Option<Targ<Ex>>, &mut Vec<Expr<Ex, En>>)> {
1703 match self {
1704 Expr_::ValCollection(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1705 _ => None,
1706 }
1707 }
1708 pub fn as_key_val_collection_mut(
1709 &mut self,
1710 ) -> Option<(
1711 &mut KvcKind,
1712 &mut Option<(Targ<Ex>, Targ<Ex>)>,
1713 &mut Vec<Field<Ex, En>>,
1714 )> {
1715 match self {
1716 Expr_::KeyValCollection(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1717 _ => None,
1718 }
1719 }
1720 pub fn as_id_mut(&mut self) -> Option<&mut Sid> {
1721 match self {
1722 Expr_::Id(p0) => Some(p0.as_mut()),
1723 _ => None,
1724 }
1725 }
1726 pub fn as_lvar_mut(&mut self) -> Option<&mut Lid> {
1727 match self {
1728 Expr_::Lvar(p0) => Some(p0.as_mut()),
1729 _ => None,
1730 }
1731 }
1732 pub fn as_dollardollar_mut(&mut self) -> Option<&mut Lid> {
1733 match self {
1734 Expr_::Dollardollar(p0) => Some(p0.as_mut()),
1735 _ => None,
1736 }
1737 }
1738 pub fn as_clone_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
1739 match self {
1740 Expr_::Clone(p0) => Some(p0.as_mut()),
1741 _ => None,
1742 }
1743 }
1744 pub fn as_array_get_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Option<Expr<Ex, En>>)> {
1745 match self {
1746 Expr_::ArrayGet(p0) => Some((&mut p0.0, &mut p0.1)),
1747 _ => None,
1748 }
1749 }
1750 pub fn as_obj_get_mut(
1751 &mut self,
1752 ) -> Option<(
1753 &mut Expr<Ex, En>,
1754 &mut Expr<Ex, En>,
1755 &mut OgNullFlavor,
1756 &mut bool,
1757 )> {
1758 match self {
1759 Expr_::ObjGet(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2, &mut p0.3)),
1760 _ => None,
1761 }
1762 }
1763 pub fn as_class_get_mut(
1764 &mut self,
1765 ) -> Option<(&mut ClassId<Ex, En>, &mut ClassGetExpr<Ex, En>, &mut bool)> {
1766 match self {
1767 Expr_::ClassGet(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1768 _ => None,
1769 }
1770 }
1771 pub fn as_class_const_mut(&mut self) -> Option<(&mut ClassId<Ex, En>, &mut Pstring)> {
1772 match self {
1773 Expr_::ClassConst(p0) => Some((&mut p0.0, &mut p0.1)),
1774 _ => None,
1775 }
1776 }
1777 pub fn as_call_mut(
1778 &mut self,
1779 ) -> Option<(
1780 &mut Expr<Ex, En>,
1781 &mut Vec<Targ<Ex>>,
1782 &mut Vec<(ast_defs::ParamKind, Expr<Ex, En>)>,
1783 &mut Option<Expr<Ex, En>>,
1784 )> {
1785 match self {
1786 Expr_::Call(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2, &mut p0.3)),
1787 _ => None,
1788 }
1789 }
1790 pub fn as_function_pointer_mut(
1791 &mut self,
1792 ) -> Option<(&mut FunctionPtrId<Ex, En>, &mut Vec<Targ<Ex>>)> {
1793 match self {
1794 Expr_::FunctionPointer(p0) => Some((&mut p0.0, &mut p0.1)),
1795 _ => None,
1796 }
1797 }
1798 pub fn as_int_mut(&mut self) -> Option<&mut String> {
1799 match self {
1800 Expr_::Int(p0) => Some(p0),
1801 _ => None,
1802 }
1803 }
1804 pub fn as_float_mut(&mut self) -> Option<&mut String> {
1805 match self {
1806 Expr_::Float(p0) => Some(p0),
1807 _ => None,
1808 }
1809 }
1810 pub fn as_string_mut(&mut self) -> Option<&mut bstr::BString> {
1811 match self {
1812 Expr_::String(p0) => Some(p0),
1813 _ => None,
1814 }
1815 }
1816 pub fn as_string2_mut(&mut self) -> Option<&mut Vec<Expr<Ex, En>>> {
1817 match self {
1818 Expr_::String2(p0) => Some(p0),
1819 _ => None,
1820 }
1821 }
1822 pub fn as_prefixed_string_mut(&mut self) -> Option<(&mut String, &mut Expr<Ex, En>)> {
1823 match self {
1824 Expr_::PrefixedString(p0) => Some((&mut p0.0, &mut p0.1)),
1825 _ => None,
1826 }
1827 }
1828 pub fn as_yield_mut(&mut self) -> Option<&mut Afield<Ex, En>> {
1829 match self {
1830 Expr_::Yield(p0) => Some(p0.as_mut()),
1831 _ => None,
1832 }
1833 }
1834 pub fn as_await_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
1835 match self {
1836 Expr_::Await(p0) => Some(p0.as_mut()),
1837 _ => None,
1838 }
1839 }
1840 pub fn as_readonly_expr_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
1841 match self {
1842 Expr_::ReadonlyExpr(p0) => Some(p0.as_mut()),
1843 _ => None,
1844 }
1845 }
1846 pub fn as_tuple_mut(&mut self) -> Option<&mut Vec<Expr<Ex, En>>> {
1847 match self {
1848 Expr_::Tuple(p0) => Some(p0),
1849 _ => None,
1850 }
1851 }
1852 pub fn as_list_mut(&mut self) -> Option<&mut Vec<Expr<Ex, En>>> {
1853 match self {
1854 Expr_::List(p0) => Some(p0),
1855 _ => None,
1856 }
1857 }
1858 pub fn as_cast_mut(&mut self) -> Option<(&mut Hint, &mut Expr<Ex, En>)> {
1859 match self {
1860 Expr_::Cast(p0) => Some((&mut p0.0, &mut p0.1)),
1861 _ => None,
1862 }
1863 }
1864 pub fn as_unop_mut(&mut self) -> Option<(&mut ast_defs::Uop, &mut Expr<Ex, En>)> {
1865 match self {
1866 Expr_::Unop(p0) => Some((&mut p0.0, &mut p0.1)),
1867 _ => None,
1868 }
1869 }
1870 pub fn as_binop_mut(
1871 &mut self,
1872 ) -> Option<(&mut ast_defs::Bop, &mut Expr<Ex, En>, &mut Expr<Ex, En>)> {
1873 match self {
1874 Expr_::Binop(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1875 _ => None,
1876 }
1877 }
1878 pub fn as_pipe_mut(&mut self) -> Option<(&mut Lid, &mut Expr<Ex, En>, &mut Expr<Ex, En>)> {
1879 match self {
1880 Expr_::Pipe(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1881 _ => None,
1882 }
1883 }
1884 pub fn as_eif_mut(
1885 &mut self,
1886 ) -> Option<(
1887 &mut Expr<Ex, En>,
1888 &mut Option<Expr<Ex, En>>,
1889 &mut Expr<Ex, En>,
1890 )> {
1891 match self {
1892 Expr_::Eif(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1893 _ => None,
1894 }
1895 }
1896 pub fn as_is_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Hint)> {
1897 match self {
1898 Expr_::Is(p0) => Some((&mut p0.0, &mut p0.1)),
1899 _ => None,
1900 }
1901 }
1902 pub fn as_as_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Hint, &mut bool)> {
1903 match self {
1904 Expr_::As(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1905 _ => None,
1906 }
1907 }
1908 pub fn as_upcast_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Hint)> {
1909 match self {
1910 Expr_::Upcast(p0) => Some((&mut p0.0, &mut p0.1)),
1911 _ => None,
1912 }
1913 }
1914 pub fn as_new_mut(
1915 &mut self,
1916 ) -> Option<(
1917 &mut ClassId<Ex, En>,
1918 &mut Vec<Targ<Ex>>,
1919 &mut Vec<Expr<Ex, En>>,
1920 &mut Option<Expr<Ex, En>>,
1921 &mut Ex,
1922 )> {
1923 match self {
1924 Expr_::New(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2, &mut p0.3, &mut p0.4)),
1925 _ => None,
1926 }
1927 }
1928 pub fn as_record_mut(&mut self) -> Option<(&mut Sid, &mut Vec<(Expr<Ex, En>, Expr<Ex, En>)>)> {
1929 match self {
1930 Expr_::Record(p0) => Some((&mut p0.0, &mut p0.1)),
1931 _ => None,
1932 }
1933 }
1934 pub fn as_efun_mut(&mut self) -> Option<(&mut Fun_<Ex, En>, &mut Vec<Lid>)> {
1935 match self {
1936 Expr_::Efun(p0) => Some((&mut p0.0, &mut p0.1)),
1937 _ => None,
1938 }
1939 }
1940 pub fn as_lfun_mut(&mut self) -> Option<(&mut Fun_<Ex, En>, &mut Vec<Lid>)> {
1941 match self {
1942 Expr_::Lfun(p0) => Some((&mut p0.0, &mut p0.1)),
1943 _ => None,
1944 }
1945 }
1946 pub fn as_xml_mut(
1947 &mut self,
1948 ) -> Option<(
1949 &mut ClassName,
1950 &mut Vec<XhpAttribute<Ex, En>>,
1951 &mut Vec<Expr<Ex, En>>,
1952 )> {
1953 match self {
1954 Expr_::Xml(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1955 _ => None,
1956 }
1957 }
1958 pub fn as_import_mut(&mut self) -> Option<(&mut ImportFlavor, &mut Expr<Ex, En>)> {
1959 match self {
1960 Expr_::Import(p0) => Some((&mut p0.0, &mut p0.1)),
1961 _ => None,
1962 }
1963 }
1964 pub fn as_collection_mut(
1965 &mut self,
1966 ) -> Option<(
1967 &mut ClassName,
1968 &mut Option<CollectionTarg<Ex>>,
1969 &mut Vec<Afield<Ex, En>>,
1970 )> {
1971 match self {
1972 Expr_::Collection(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
1973 _ => None,
1974 }
1975 }
1976 pub fn as_expression_tree_mut(&mut self) -> Option<&mut ExpressionTree<Ex, En>> {
1977 match self {
1978 Expr_::ExpressionTree(p0) => Some(p0.as_mut()),
1979 _ => None,
1980 }
1981 }
1982 pub fn as_lplaceholder_mut(&mut self) -> Option<&mut Pos> {
1983 match self {
1984 Expr_::Lplaceholder(p0) => Some(p0.as_mut()),
1985 _ => None,
1986 }
1987 }
1988 pub fn as_fun_id_mut(&mut self) -> Option<&mut Sid> {
1989 match self {
1990 Expr_::FunId(p0) => Some(p0.as_mut()),
1991 _ => None,
1992 }
1993 }
1994 pub fn as_method_id_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Pstring)> {
1995 match self {
1996 Expr_::MethodId(p0) => Some((&mut p0.0, &mut p0.1)),
1997 _ => None,
1998 }
1999 }
2000 pub fn as_method_caller_mut(&mut self) -> Option<(&mut ClassName, &mut Pstring)> {
2001 match self {
2002 Expr_::MethodCaller(p0) => Some((&mut p0.0, &mut p0.1)),
2003 _ => None,
2004 }
2005 }
2006 pub fn as_smethod_id_mut(&mut self) -> Option<(&mut ClassId<Ex, En>, &mut Pstring)> {
2007 match self {
2008 Expr_::SmethodId(p0) => Some((&mut p0.0, &mut p0.1)),
2009 _ => None,
2010 }
2011 }
2012 pub fn as_pair_mut(
2013 &mut self,
2014 ) -> Option<(
2015 &mut Option<(Targ<Ex>, Targ<Ex>)>,
2016 &mut Expr<Ex, En>,
2017 &mut Expr<Ex, En>,
2018 )> {
2019 match self {
2020 Expr_::Pair(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2)),
2021 _ => None,
2022 }
2023 }
2024 pub fn as_etsplice_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
2025 match self {
2026 Expr_::ETSplice(p0) => Some(p0.as_mut()),
2027 _ => None,
2028 }
2029 }
2030 pub fn as_enum_class_label_mut(&mut self) -> Option<(&mut Option<ClassName>, &mut String)> {
2031 match self {
2032 Expr_::EnumClassLabel(p0) => Some((&mut p0.0, &mut p0.1)),
2033 _ => None,
2034 }
2035 }
2036 pub fn as_hole_mut(
2037 &mut self,
2038 ) -> Option<(&mut Expr<Ex, En>, &mut Ex, &mut Ex, &mut HoleSource)> {
2039 match self {
2040 Expr_::Hole(p0) => Some((&mut p0.0, &mut p0.1, &mut p0.2, &mut p0.3)),
2041 _ => None,
2042 }
2043 }
2044 pub fn as_darray_into(
2045 self,
2046 ) -> Option<(
2047 Option<(Targ<Ex>, Targ<Ex>)>,
2048 Vec<(Expr<Ex, En>, Expr<Ex, En>)>,
2049 )> {
2050 match self {
2051 Expr_::Darray(p0) => Some(((*p0).0, (*p0).1)),
2052 _ => None,
2053 }
2054 }
2055 pub fn as_varray_into(self) -> Option<(Option<Targ<Ex>>, Vec<Expr<Ex, En>>)> {
2056 match self {
2057 Expr_::Varray(p0) => Some(((*p0).0, (*p0).1)),
2058 _ => None,
2059 }
2060 }
2061 pub fn as_shape_into(self) -> Option<Vec<(ast_defs::ShapeFieldName, Expr<Ex, En>)>> {
2062 match self {
2063 Expr_::Shape(p0) => Some(p0),
2064 _ => None,
2065 }
2066 }
2067 pub fn as_val_collection_into(self) -> Option<(VcKind, Option<Targ<Ex>>, Vec<Expr<Ex, En>>)> {
2068 match self {
2069 Expr_::ValCollection(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2070 _ => None,
2071 }
2072 }
2073 pub fn as_key_val_collection_into(
2074 self,
2075 ) -> Option<(KvcKind, Option<(Targ<Ex>, Targ<Ex>)>, Vec<Field<Ex, En>>)> {
2076 match self {
2077 Expr_::KeyValCollection(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2078 _ => None,
2079 }
2080 }
2081 pub fn as_id_into(self) -> Option<Sid> {
2082 match self {
2083 Expr_::Id(p0) => Some(*p0),
2084 _ => None,
2085 }
2086 }
2087 pub fn as_lvar_into(self) -> Option<Lid> {
2088 match self {
2089 Expr_::Lvar(p0) => Some(*p0),
2090 _ => None,
2091 }
2092 }
2093 pub fn as_dollardollar_into(self) -> Option<Lid> {
2094 match self {
2095 Expr_::Dollardollar(p0) => Some(*p0),
2096 _ => None,
2097 }
2098 }
2099 pub fn as_clone_into(self) -> Option<Expr<Ex, En>> {
2100 match self {
2101 Expr_::Clone(p0) => Some(*p0),
2102 _ => None,
2103 }
2104 }
2105 pub fn as_array_get_into(self) -> Option<(Expr<Ex, En>, Option<Expr<Ex, En>>)> {
2106 match self {
2107 Expr_::ArrayGet(p0) => Some(((*p0).0, (*p0).1)),
2108 _ => None,
2109 }
2110 }
2111 pub fn as_obj_get_into(self) -> Option<(Expr<Ex, En>, Expr<Ex, En>, OgNullFlavor, bool)> {
2112 match self {
2113 Expr_::ObjGet(p0) => Some(((*p0).0, (*p0).1, (*p0).2, (*p0).3)),
2114 _ => None,
2115 }
2116 }
2117 pub fn as_class_get_into(self) -> Option<(ClassId<Ex, En>, ClassGetExpr<Ex, En>, bool)> {
2118 match self {
2119 Expr_::ClassGet(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2120 _ => None,
2121 }
2122 }
2123 pub fn as_class_const_into(self) -> Option<(ClassId<Ex, En>, Pstring)> {
2124 match self {
2125 Expr_::ClassConst(p0) => Some(((*p0).0, (*p0).1)),
2126 _ => None,
2127 }
2128 }
2129 pub fn as_call_into(
2130 self,
2131 ) -> Option<(
2132 Expr<Ex, En>,
2133 Vec<Targ<Ex>>,
2134 Vec<(ast_defs::ParamKind, Expr<Ex, En>)>,
2135 Option<Expr<Ex, En>>,
2136 )> {
2137 match self {
2138 Expr_::Call(p0) => Some(((*p0).0, (*p0).1, (*p0).2, (*p0).3)),
2139 _ => None,
2140 }
2141 }
2142 pub fn as_function_pointer_into(self) -> Option<(FunctionPtrId<Ex, En>, Vec<Targ<Ex>>)> {
2143 match self {
2144 Expr_::FunctionPointer(p0) => Some(((*p0).0, (*p0).1)),
2145 _ => None,
2146 }
2147 }
2148 pub fn as_int_into(self) -> Option<String> {
2149 match self {
2150 Expr_::Int(p0) => Some(p0),
2151 _ => None,
2152 }
2153 }
2154 pub fn as_float_into(self) -> Option<String> {
2155 match self {
2156 Expr_::Float(p0) => Some(p0),
2157 _ => None,
2158 }
2159 }
2160 pub fn as_string_into(self) -> Option<bstr::BString> {
2161 match self {
2162 Expr_::String(p0) => Some(p0),
2163 _ => None,
2164 }
2165 }
2166 pub fn as_string2_into(self) -> Option<Vec<Expr<Ex, En>>> {
2167 match self {
2168 Expr_::String2(p0) => Some(p0),
2169 _ => None,
2170 }
2171 }
2172 pub fn as_prefixed_string_into(self) -> Option<(String, Expr<Ex, En>)> {
2173 match self {
2174 Expr_::PrefixedString(p0) => Some(((*p0).0, (*p0).1)),
2175 _ => None,
2176 }
2177 }
2178 pub fn as_yield_into(self) -> Option<Afield<Ex, En>> {
2179 match self {
2180 Expr_::Yield(p0) => Some(*p0),
2181 _ => None,
2182 }
2183 }
2184 pub fn as_await_into(self) -> Option<Expr<Ex, En>> {
2185 match self {
2186 Expr_::Await(p0) => Some(*p0),
2187 _ => None,
2188 }
2189 }
2190 pub fn as_readonly_expr_into(self) -> Option<Expr<Ex, En>> {
2191 match self {
2192 Expr_::ReadonlyExpr(p0) => Some(*p0),
2193 _ => None,
2194 }
2195 }
2196 pub fn as_tuple_into(self) -> Option<Vec<Expr<Ex, En>>> {
2197 match self {
2198 Expr_::Tuple(p0) => Some(p0),
2199 _ => None,
2200 }
2201 }
2202 pub fn as_list_into(self) -> Option<Vec<Expr<Ex, En>>> {
2203 match self {
2204 Expr_::List(p0) => Some(p0),
2205 _ => None,
2206 }
2207 }
2208 pub fn as_cast_into(self) -> Option<(Hint, Expr<Ex, En>)> {
2209 match self {
2210 Expr_::Cast(p0) => Some(((*p0).0, (*p0).1)),
2211 _ => None,
2212 }
2213 }
2214 pub fn as_unop_into(self) -> Option<(ast_defs::Uop, Expr<Ex, En>)> {
2215 match self {
2216 Expr_::Unop(p0) => Some(((*p0).0, (*p0).1)),
2217 _ => None,
2218 }
2219 }
2220 pub fn as_binop_into(self) -> Option<(ast_defs::Bop, Expr<Ex, En>, Expr<Ex, En>)> {
2221 match self {
2222 Expr_::Binop(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2223 _ => None,
2224 }
2225 }
2226 pub fn as_pipe_into(self) -> Option<(Lid, Expr<Ex, En>, Expr<Ex, En>)> {
2227 match self {
2228 Expr_::Pipe(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2229 _ => None,
2230 }
2231 }
2232 pub fn as_eif_into(self) -> Option<(Expr<Ex, En>, Option<Expr<Ex, En>>, Expr<Ex, En>)> {
2233 match self {
2234 Expr_::Eif(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2235 _ => None,
2236 }
2237 }
2238 pub fn as_is_into(self) -> Option<(Expr<Ex, En>, Hint)> {
2239 match self {
2240 Expr_::Is(p0) => Some(((*p0).0, (*p0).1)),
2241 _ => None,
2242 }
2243 }
2244 pub fn as_as_into(self) -> Option<(Expr<Ex, En>, Hint, bool)> {
2245 match self {
2246 Expr_::As(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2247 _ => None,
2248 }
2249 }
2250 pub fn as_upcast_into(self) -> Option<(Expr<Ex, En>, Hint)> {
2251 match self {
2252 Expr_::Upcast(p0) => Some(((*p0).0, (*p0).1)),
2253 _ => None,
2254 }
2255 }
2256 pub fn as_new_into(
2257 self,
2258 ) -> Option<(
2259 ClassId<Ex, En>,
2260 Vec<Targ<Ex>>,
2261 Vec<Expr<Ex, En>>,
2262 Option<Expr<Ex, En>>,
2263 Ex,
2264 )> {
2265 match self {
2266 Expr_::New(p0) => Some(((*p0).0, (*p0).1, (*p0).2, (*p0).3, (*p0).4)),
2267 _ => None,
2268 }
2269 }
2270 pub fn as_record_into(self) -> Option<(Sid, Vec<(Expr<Ex, En>, Expr<Ex, En>)>)> {
2271 match self {
2272 Expr_::Record(p0) => Some(((*p0).0, (*p0).1)),
2273 _ => None,
2274 }
2275 }
2276 pub fn as_efun_into(self) -> Option<(Fun_<Ex, En>, Vec<Lid>)> {
2277 match self {
2278 Expr_::Efun(p0) => Some(((*p0).0, (*p0).1)),
2279 _ => None,
2280 }
2281 }
2282 pub fn as_lfun_into(self) -> Option<(Fun_<Ex, En>, Vec<Lid>)> {
2283 match self {
2284 Expr_::Lfun(p0) => Some(((*p0).0, (*p0).1)),
2285 _ => None,
2286 }
2287 }
2288 pub fn as_xml_into(self) -> Option<(ClassName, Vec<XhpAttribute<Ex, En>>, Vec<Expr<Ex, En>>)> {
2289 match self {
2290 Expr_::Xml(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2291 _ => None,
2292 }
2293 }
2294 pub fn as_import_into(self) -> Option<(ImportFlavor, Expr<Ex, En>)> {
2295 match self {
2296 Expr_::Import(p0) => Some(((*p0).0, (*p0).1)),
2297 _ => None,
2298 }
2299 }
2300 pub fn as_collection_into(
2301 self,
2302 ) -> Option<(ClassName, Option<CollectionTarg<Ex>>, Vec<Afield<Ex, En>>)> {
2303 match self {
2304 Expr_::Collection(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2305 _ => None,
2306 }
2307 }
2308 pub fn as_expression_tree_into(self) -> Option<ExpressionTree<Ex, En>> {
2309 match self {
2310 Expr_::ExpressionTree(p0) => Some(*p0),
2311 _ => None,
2312 }
2313 }
2314 pub fn as_lplaceholder_into(self) -> Option<Pos> {
2315 match self {
2316 Expr_::Lplaceholder(p0) => Some(*p0),
2317 _ => None,
2318 }
2319 }
2320 pub fn as_fun_id_into(self) -> Option<Sid> {
2321 match self {
2322 Expr_::FunId(p0) => Some(*p0),
2323 _ => None,
2324 }
2325 }
2326 pub fn as_method_id_into(self) -> Option<(Expr<Ex, En>, Pstring)> {
2327 match self {
2328 Expr_::MethodId(p0) => Some(((*p0).0, (*p0).1)),
2329 _ => None,
2330 }
2331 }
2332 pub fn as_method_caller_into(self) -> Option<(ClassName, Pstring)> {
2333 match self {
2334 Expr_::MethodCaller(p0) => Some(((*p0).0, (*p0).1)),
2335 _ => None,
2336 }
2337 }
2338 pub fn as_smethod_id_into(self) -> Option<(ClassId<Ex, En>, Pstring)> {
2339 match self {
2340 Expr_::SmethodId(p0) => Some(((*p0).0, (*p0).1)),
2341 _ => None,
2342 }
2343 }
2344 pub fn as_pair_into(
2345 self,
2346 ) -> Option<(Option<(Targ<Ex>, Targ<Ex>)>, Expr<Ex, En>, Expr<Ex, En>)> {
2347 match self {
2348 Expr_::Pair(p0) => Some(((*p0).0, (*p0).1, (*p0).2)),
2349 _ => None,
2350 }
2351 }
2352 pub fn as_etsplice_into(self) -> Option<Expr<Ex, En>> {
2353 match self {
2354 Expr_::ETSplice(p0) => Some(*p0),
2355 _ => None,
2356 }
2357 }
2358 pub fn as_enum_class_label_into(self) -> Option<(Option<ClassName>, String)> {
2359 match self {
2360 Expr_::EnumClassLabel(p0) => Some(((*p0).0, (*p0).1)),
2361 _ => None,
2362 }
2363 }
2364 pub fn as_hole_into(self) -> Option<(Expr<Ex, En>, Ex, Ex, HoleSource)> {
2365 match self {
2366 Expr_::Hole(p0) => Some(((*p0).0, (*p0).1, (*p0).2, (*p0).3)),
2367 _ => None,
2368 }
2369 }
2370 }
2371 impl HoleSource {
2372 pub fn mk_typing() -> Self {
2373 HoleSource::Typing
2374 }
2375 pub fn mk_unsafe_cast(p0: Vec<Hint>) -> Self {
2376 HoleSource::UnsafeCast(p0)
2377 }
2378 pub fn mk_enforced_cast(p0: Vec<Hint>) -> Self {
2379 HoleSource::EnforcedCast(p0)
2380 }
2381 pub fn is_typing(&self) -> bool {
2382 match self {
2383 HoleSource::Typing => true,
2384 _ => false,
2385 }
2386 }
2387 pub fn is_unsafe_cast(&self) -> bool {
2388 match self {
2389 HoleSource::UnsafeCast(..) => true,
2390 _ => false,
2391 }
2392 }
2393 pub fn is_enforced_cast(&self) -> bool {
2394 match self {
2395 HoleSource::EnforcedCast(..) => true,
2396 _ => false,
2397 }
2398 }
2399 pub fn as_unsafe_cast(&self) -> Option<&Vec<Hint>> {
2400 match self {
2401 HoleSource::UnsafeCast(p0) => Some(p0),
2402 _ => None,
2403 }
2404 }
2405 pub fn as_enforced_cast(&self) -> Option<&Vec<Hint>> {
2406 match self {
2407 HoleSource::EnforcedCast(p0) => Some(p0),
2408 _ => None,
2409 }
2410 }
2411 pub fn as_unsafe_cast_mut(&mut self) -> Option<&mut Vec<Hint>> {
2412 match self {
2413 HoleSource::UnsafeCast(p0) => Some(p0),
2414 _ => None,
2415 }
2416 }
2417 pub fn as_enforced_cast_mut(&mut self) -> Option<&mut Vec<Hint>> {
2418 match self {
2419 HoleSource::EnforcedCast(p0) => Some(p0),
2420 _ => None,
2421 }
2422 }
2423 pub fn as_unsafe_cast_into(self) -> Option<Vec<Hint>> {
2424 match self {
2425 HoleSource::UnsafeCast(p0) => Some(p0),
2426 _ => None,
2427 }
2428 }
2429 pub fn as_enforced_cast_into(self) -> Option<Vec<Hint>> {
2430 match self {
2431 HoleSource::EnforcedCast(p0) => Some(p0),
2432 _ => None,
2433 }
2434 }
2435 }
2436 impl<Ex, En> ClassGetExpr<Ex, En> {
2437 pub fn mk_cgstring(p0: Pstring) -> Self {
2438 ClassGetExpr::CGstring(p0)
2439 }
2440 pub fn mk_cgexpr(p0: Expr<Ex, En>) -> Self {
2441 ClassGetExpr::CGexpr(p0)
2442 }
2443 pub fn is_cgstring(&self) -> bool {
2444 match self {
2445 ClassGetExpr::CGstring(..) => true,
2446 _ => false,
2447 }
2448 }
2449 pub fn is_cgexpr(&self) -> bool {
2450 match self {
2451 ClassGetExpr::CGexpr(..) => true,
2452 _ => false,
2453 }
2454 }
2455 pub fn as_cgstring(&self) -> Option<&Pstring> {
2456 match self {
2457 ClassGetExpr::CGstring(p0) => Some(p0),
2458 _ => None,
2459 }
2460 }
2461 pub fn as_cgexpr(&self) -> Option<&Expr<Ex, En>> {
2462 match self {
2463 ClassGetExpr::CGexpr(p0) => Some(p0),
2464 _ => None,
2465 }
2466 }
2467 pub fn as_cgstring_mut(&mut self) -> Option<&mut Pstring> {
2468 match self {
2469 ClassGetExpr::CGstring(p0) => Some(p0),
2470 _ => None,
2471 }
2472 }
2473 pub fn as_cgexpr_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
2474 match self {
2475 ClassGetExpr::CGexpr(p0) => Some(p0),
2476 _ => None,
2477 }
2478 }
2479 pub fn as_cgstring_into(self) -> Option<Pstring> {
2480 match self {
2481 ClassGetExpr::CGstring(p0) => Some(p0),
2482 _ => None,
2483 }
2484 }
2485 pub fn as_cgexpr_into(self) -> Option<Expr<Ex, En>> {
2486 match self {
2487 ClassGetExpr::CGexpr(p0) => Some(p0),
2488 _ => None,
2489 }
2490 }
2491 }
2492 impl<Ex, En> Case<Ex, En> {
2493 pub fn mk_default(p0: Pos, p1: Block<Ex, En>) -> Self {
2494 Case::Default(p0, p1)
2495 }
2496 pub fn mk_case(p0: Expr<Ex, En>, p1: Block<Ex, En>) -> Self {
2497 Case::Case(p0, p1)
2498 }
2499 pub fn is_default(&self) -> bool {
2500 match self {
2501 Case::Default(..) => true,
2502 _ => false,
2503 }
2504 }
2505 pub fn is_case(&self) -> bool {
2506 match self {
2507 Case::Case(..) => true,
2508 _ => false,
2509 }
2510 }
2511 pub fn as_default(&self) -> Option<(&Pos, &Block<Ex, En>)> {
2512 match self {
2513 Case::Default(p0, p1) => Some((p0, p1)),
2514 _ => None,
2515 }
2516 }
2517 pub fn as_case(&self) -> Option<(&Expr<Ex, En>, &Block<Ex, En>)> {
2518 match self {
2519 Case::Case(p0, p1) => Some((p0, p1)),
2520 _ => None,
2521 }
2522 }
2523 pub fn as_default_mut(&mut self) -> Option<(&mut Pos, &mut Block<Ex, En>)> {
2524 match self {
2525 Case::Default(p0, p1) => Some((p0, p1)),
2526 _ => None,
2527 }
2528 }
2529 pub fn as_case_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Block<Ex, En>)> {
2530 match self {
2531 Case::Case(p0, p1) => Some((p0, p1)),
2532 _ => None,
2533 }
2534 }
2535 pub fn as_default_into(self) -> Option<(Pos, Block<Ex, En>)> {
2536 match self {
2537 Case::Default(p0, p1) => Some((p0, p1)),
2538 _ => None,
2539 }
2540 }
2541 pub fn as_case_into(self) -> Option<(Expr<Ex, En>, Block<Ex, En>)> {
2542 match self {
2543 Case::Case(p0, p1) => Some((p0, p1)),
2544 _ => None,
2545 }
2546 }
2547 }
2548 impl<Ex, En> Afield<Ex, En> {
2549 pub fn mk_afvalue(p0: Expr<Ex, En>) -> Self {
2550 Afield::AFvalue(p0)
2551 }
2552 pub fn mk_afkvalue(p0: Expr<Ex, En>, p1: Expr<Ex, En>) -> Self {
2553 Afield::AFkvalue(p0, p1)
2554 }
2555 pub fn is_afvalue(&self) -> bool {
2556 match self {
2557 Afield::AFvalue(..) => true,
2558 _ => false,
2559 }
2560 }
2561 pub fn is_afkvalue(&self) -> bool {
2562 match self {
2563 Afield::AFkvalue(..) => true,
2564 _ => false,
2565 }
2566 }
2567 pub fn as_afvalue(&self) -> Option<&Expr<Ex, En>> {
2568 match self {
2569 Afield::AFvalue(p0) => Some(p0),
2570 _ => None,
2571 }
2572 }
2573 pub fn as_afkvalue(&self) -> Option<(&Expr<Ex, En>, &Expr<Ex, En>)> {
2574 match self {
2575 Afield::AFkvalue(p0, p1) => Some((p0, p1)),
2576 _ => None,
2577 }
2578 }
2579 pub fn as_afvalue_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
2580 match self {
2581 Afield::AFvalue(p0) => Some(p0),
2582 _ => None,
2583 }
2584 }
2585 pub fn as_afkvalue_mut(&mut self) -> Option<(&mut Expr<Ex, En>, &mut Expr<Ex, En>)> {
2586 match self {
2587 Afield::AFkvalue(p0, p1) => Some((p0, p1)),
2588 _ => None,
2589 }
2590 }
2591 pub fn as_afvalue_into(self) -> Option<Expr<Ex, En>> {
2592 match self {
2593 Afield::AFvalue(p0) => Some(p0),
2594 _ => None,
2595 }
2596 }
2597 pub fn as_afkvalue_into(self) -> Option<(Expr<Ex, En>, Expr<Ex, En>)> {
2598 match self {
2599 Afield::AFkvalue(p0, p1) => Some((p0, p1)),
2600 _ => None,
2601 }
2602 }
2603 }
2604 impl<Ex, En> XhpAttribute<Ex, En> {
2605 pub fn mk_xhp_simple(p0: XhpSimple<Ex, En>) -> Self {
2606 XhpAttribute::XhpSimple(p0)
2607 }
2608 pub fn mk_xhp_spread(p0: Expr<Ex, En>) -> Self {
2609 XhpAttribute::XhpSpread(p0)
2610 }
2611 pub fn is_xhp_simple(&self) -> bool {
2612 match self {
2613 XhpAttribute::XhpSimple(..) => true,
2614 _ => false,
2615 }
2616 }
2617 pub fn is_xhp_spread(&self) -> bool {
2618 match self {
2619 XhpAttribute::XhpSpread(..) => true,
2620 _ => false,
2621 }
2622 }
2623 pub fn as_xhp_simple(&self) -> Option<&XhpSimple<Ex, En>> {
2624 match self {
2625 XhpAttribute::XhpSimple(p0) => Some(p0),
2626 _ => None,
2627 }
2628 }
2629 pub fn as_xhp_spread(&self) -> Option<&Expr<Ex, En>> {
2630 match self {
2631 XhpAttribute::XhpSpread(p0) => Some(p0),
2632 _ => None,
2633 }
2634 }
2635 pub fn as_xhp_simple_mut(&mut self) -> Option<&mut XhpSimple<Ex, En>> {
2636 match self {
2637 XhpAttribute::XhpSimple(p0) => Some(p0),
2638 _ => None,
2639 }
2640 }
2641 pub fn as_xhp_spread_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
2642 match self {
2643 XhpAttribute::XhpSpread(p0) => Some(p0),
2644 _ => None,
2645 }
2646 }
2647 pub fn as_xhp_simple_into(self) -> Option<XhpSimple<Ex, En>> {
2648 match self {
2649 XhpAttribute::XhpSimple(p0) => Some(p0),
2650 _ => None,
2651 }
2652 }
2653 pub fn as_xhp_spread_into(self) -> Option<Expr<Ex, En>> {
2654 match self {
2655 XhpAttribute::XhpSpread(p0) => Some(p0),
2656 _ => None,
2657 }
2658 }
2659 }
2660 impl<Ex, En> FunVariadicity<Ex, En> {
2661 pub fn mk_fvvariadic_arg(p0: FunParam<Ex, En>) -> Self {
2662 FunVariadicity::FVvariadicArg(p0)
2663 }
2664 pub fn mk_fvellipsis(p0: Pos) -> Self {
2665 FunVariadicity::FVellipsis(p0)
2666 }
2667 pub fn mk_fvnon_variadic() -> Self {
2668 FunVariadicity::FVnonVariadic
2669 }
2670 pub fn is_fvvariadic_arg(&self) -> bool {
2671 match self {
2672 FunVariadicity::FVvariadicArg(..) => true,
2673 _ => false,
2674 }
2675 }
2676 pub fn is_fvellipsis(&self) -> bool {
2677 match self {
2678 FunVariadicity::FVellipsis(..) => true,
2679 _ => false,
2680 }
2681 }
2682 pub fn is_fvnon_variadic(&self) -> bool {
2683 match self {
2684 FunVariadicity::FVnonVariadic => true,
2685 _ => false,
2686 }
2687 }
2688 pub fn as_fvvariadic_arg(&self) -> Option<&FunParam<Ex, En>> {
2689 match self {
2690 FunVariadicity::FVvariadicArg(p0) => Some(p0),
2691 _ => None,
2692 }
2693 }
2694 pub fn as_fvellipsis(&self) -> Option<&Pos> {
2695 match self {
2696 FunVariadicity::FVellipsis(p0) => Some(p0),
2697 _ => None,
2698 }
2699 }
2700 pub fn as_fvvariadic_arg_mut(&mut self) -> Option<&mut FunParam<Ex, En>> {
2701 match self {
2702 FunVariadicity::FVvariadicArg(p0) => Some(p0),
2703 _ => None,
2704 }
2705 }
2706 pub fn as_fvellipsis_mut(&mut self) -> Option<&mut Pos> {
2707 match self {
2708 FunVariadicity::FVellipsis(p0) => Some(p0),
2709 _ => None,
2710 }
2711 }
2712 pub fn as_fvvariadic_arg_into(self) -> Option<FunParam<Ex, En>> {
2713 match self {
2714 FunVariadicity::FVvariadicArg(p0) => Some(p0),
2715 _ => None,
2716 }
2717 }
2718 pub fn as_fvellipsis_into(self) -> Option<Pos> {
2719 match self {
2720 FunVariadicity::FVellipsis(p0) => Some(p0),
2721 _ => None,
2722 }
2723 }
2724 }
2725 impl EmitId {
2726 pub fn mk_emit_id(p0: isize) -> Self {
2727 EmitId::EmitId(p0)
2728 }
2729 pub fn mk_anonymous() -> Self {
2730 EmitId::Anonymous
2731 }
2732 pub fn is_emit_id(&self) -> bool {
2733 match self {
2734 EmitId::EmitId(..) => true,
2735 _ => false,
2736 }
2737 }
2738 pub fn is_anonymous(&self) -> bool {
2739 match self {
2740 EmitId::Anonymous => true,
2741 _ => false,
2742 }
2743 }
2744 pub fn as_emit_id(&self) -> Option<&isize> {
2745 match self {
2746 EmitId::EmitId(p0) => Some(p0),
2747 _ => None,
2748 }
2749 }
2750 pub fn as_emit_id_mut(&mut self) -> Option<&mut isize> {
2751 match self {
2752 EmitId::EmitId(p0) => Some(p0),
2753 _ => None,
2754 }
2755 }
2756 pub fn as_emit_id_into(self) -> Option<isize> {
2757 match self {
2758 EmitId::EmitId(p0) => Some(p0),
2759 _ => None,
2760 }
2761 }
2762 }
2763 impl XhpAttrTag {
2764 pub fn mk_required() -> Self {
2765 XhpAttrTag::Required
2766 }
2767 pub fn mk_late_init() -> Self {
2768 XhpAttrTag::LateInit
2769 }
2770 pub fn is_required(&self) -> bool {
2771 match self {
2772 XhpAttrTag::Required => true,
2773 _ => false,
2774 }
2775 }
2776 pub fn is_late_init(&self) -> bool {
2777 match self {
2778 XhpAttrTag::LateInit => true,
2779 _ => false,
2780 }
2781 }
2782 }
2783 impl<Ex, En> ClassAttr<Ex, En> {
2784 pub fn mk_caname(p0: Sid) -> Self {
2785 ClassAttr::CAName(p0)
2786 }
2787 pub fn mk_cafield(p0: CaField<Ex, En>) -> Self {
2788 ClassAttr::CAField(p0)
2789 }
2790 pub fn is_caname(&self) -> bool {
2791 match self {
2792 ClassAttr::CAName(..) => true,
2793 _ => false,
2794 }
2795 }
2796 pub fn is_cafield(&self) -> bool {
2797 match self {
2798 ClassAttr::CAField(..) => true,
2799 _ => false,
2800 }
2801 }
2802 pub fn as_caname(&self) -> Option<&Sid> {
2803 match self {
2804 ClassAttr::CAName(p0) => Some(p0),
2805 _ => None,
2806 }
2807 }
2808 pub fn as_cafield(&self) -> Option<&CaField<Ex, En>> {
2809 match self {
2810 ClassAttr::CAField(p0) => Some(p0),
2811 _ => None,
2812 }
2813 }
2814 pub fn as_caname_mut(&mut self) -> Option<&mut Sid> {
2815 match self {
2816 ClassAttr::CAName(p0) => Some(p0),
2817 _ => None,
2818 }
2819 }
2820 pub fn as_cafield_mut(&mut self) -> Option<&mut CaField<Ex, En>> {
2821 match self {
2822 ClassAttr::CAField(p0) => Some(p0),
2823 _ => None,
2824 }
2825 }
2826 pub fn as_caname_into(self) -> Option<Sid> {
2827 match self {
2828 ClassAttr::CAName(p0) => Some(p0),
2829 _ => None,
2830 }
2831 }
2832 pub fn as_cafield_into(self) -> Option<CaField<Ex, En>> {
2833 match self {
2834 ClassAttr::CAField(p0) => Some(p0),
2835 _ => None,
2836 }
2837 }
2838 }
2839 impl CaType {
2840 pub fn mk_cahint(p0: Hint) -> Self {
2841 CaType::CAHint(p0)
2842 }
2843 pub fn mk_caenum(p0: Vec<String>) -> Self {
2844 CaType::CAEnum(p0)
2845 }
2846 pub fn is_cahint(&self) -> bool {
2847 match self {
2848 CaType::CAHint(..) => true,
2849 _ => false,
2850 }
2851 }
2852 pub fn is_caenum(&self) -> bool {
2853 match self {
2854 CaType::CAEnum(..) => true,
2855 _ => false,
2856 }
2857 }
2858 pub fn as_cahint(&self) -> Option<&Hint> {
2859 match self {
2860 CaType::CAHint(p0) => Some(p0),
2861 _ => None,
2862 }
2863 }
2864 pub fn as_caenum(&self) -> Option<&Vec<String>> {
2865 match self {
2866 CaType::CAEnum(p0) => Some(p0),
2867 _ => None,
2868 }
2869 }
2870 pub fn as_cahint_mut(&mut self) -> Option<&mut Hint> {
2871 match self {
2872 CaType::CAHint(p0) => Some(p0),
2873 _ => None,
2874 }
2875 }
2876 pub fn as_caenum_mut(&mut self) -> Option<&mut Vec<String>> {
2877 match self {
2878 CaType::CAEnum(p0) => Some(p0),
2879 _ => None,
2880 }
2881 }
2882 pub fn as_cahint_into(self) -> Option<Hint> {
2883 match self {
2884 CaType::CAHint(p0) => Some(p0),
2885 _ => None,
2886 }
2887 }
2888 pub fn as_caenum_into(self) -> Option<Vec<String>> {
2889 match self {
2890 CaType::CAEnum(p0) => Some(p0),
2891 _ => None,
2892 }
2893 }
2894 }
2895 impl<Ex, En> ClassConstKind<Ex, En> {
2896 pub fn mk_ccabstract(p0: Option<Expr<Ex, En>>) -> Self {
2897 ClassConstKind::CCAbstract(p0)
2898 }
2899 pub fn mk_ccconcrete(p0: Expr<Ex, En>) -> Self {
2900 ClassConstKind::CCConcrete(p0)
2901 }
2902 pub fn is_ccabstract(&self) -> bool {
2903 match self {
2904 ClassConstKind::CCAbstract(..) => true,
2905 _ => false,
2906 }
2907 }
2908 pub fn is_ccconcrete(&self) -> bool {
2909 match self {
2910 ClassConstKind::CCConcrete(..) => true,
2911 _ => false,
2912 }
2913 }
2914 pub fn as_ccabstract(&self) -> Option<&Option<Expr<Ex, En>>> {
2915 match self {
2916 ClassConstKind::CCAbstract(p0) => Some(p0),
2917 _ => None,
2918 }
2919 }
2920 pub fn as_ccconcrete(&self) -> Option<&Expr<Ex, En>> {
2921 match self {
2922 ClassConstKind::CCConcrete(p0) => Some(p0),
2923 _ => None,
2924 }
2925 }
2926 pub fn as_ccabstract_mut(&mut self) -> Option<&mut Option<Expr<Ex, En>>> {
2927 match self {
2928 ClassConstKind::CCAbstract(p0) => Some(p0),
2929 _ => None,
2930 }
2931 }
2932 pub fn as_ccconcrete_mut(&mut self) -> Option<&mut Expr<Ex, En>> {
2933 match self {
2934 ClassConstKind::CCConcrete(p0) => Some(p0),
2935 _ => None,
2936 }
2937 }
2938 pub fn as_ccabstract_into(self) -> Option<Option<Expr<Ex, En>>> {
2939 match self {
2940 ClassConstKind::CCAbstract(p0) => Some(p0),
2941 _ => None,
2942 }
2943 }
2944 pub fn as_ccconcrete_into(self) -> Option<Expr<Ex, En>> {
2945 match self {
2946 ClassConstKind::CCConcrete(p0) => Some(p0),
2947 _ => None,
2948 }
2949 }
2950 }
2951 impl ClassTypeconst {
2952 pub fn mk_tcabstract(p0: ClassAbstractTypeconst) -> Self {
2953 ClassTypeconst::TCAbstract(p0)
2954 }
2955 pub fn mk_tcconcrete(p0: ClassConcreteTypeconst) -> Self {
2956 ClassTypeconst::TCConcrete(p0)
2957 }
2958 pub fn is_tcabstract(&self) -> bool {
2959 match self {
2960 ClassTypeconst::TCAbstract(..) => true,
2961 _ => false,
2962 }
2963 }
2964 pub fn is_tcconcrete(&self) -> bool {
2965 match self {
2966 ClassTypeconst::TCConcrete(..) => true,
2967 _ => false,
2968 }
2969 }
2970 pub fn as_tcabstract(&self) -> Option<&ClassAbstractTypeconst> {
2971 match self {
2972 ClassTypeconst::TCAbstract(p0) => Some(p0),
2973 _ => None,
2974 }
2975 }
2976 pub fn as_tcconcrete(&self) -> Option<&ClassConcreteTypeconst> {
2977 match self {
2978 ClassTypeconst::TCConcrete(p0) => Some(p0),
2979 _ => None,
2980 }
2981 }
2982 pub fn as_tcabstract_mut(&mut self) -> Option<&mut ClassAbstractTypeconst> {
2983 match self {
2984 ClassTypeconst::TCAbstract(p0) => Some(p0),
2985 _ => None,
2986 }
2987 }
2988 pub fn as_tcconcrete_mut(&mut self) -> Option<&mut ClassConcreteTypeconst> {
2989 match self {
2990 ClassTypeconst::TCConcrete(p0) => Some(p0),
2991 _ => None,
2992 }
2993 }
2994 pub fn as_tcabstract_into(self) -> Option<ClassAbstractTypeconst> {
2995 match self {
2996 ClassTypeconst::TCAbstract(p0) => Some(p0),
2997 _ => None,
2998 }
2999 }
3000 pub fn as_tcconcrete_into(self) -> Option<ClassConcreteTypeconst> {
3001 match self {
3002 ClassTypeconst::TCConcrete(p0) => Some(p0),
3003 _ => None,
3004 }
3005 }
3006 }
3007 impl<Ex, En> Def<Ex, En> {
3008 pub fn mk_fun(p0: FunDef<Ex, En>) -> Self {
3009 Def::Fun(Box::new(p0))
3010 }
3011 pub fn mk_class(p0: Class_<Ex, En>) -> Self {
3012 Def::Class(Box::new(p0))
3013 }
3014 pub fn mk_record_def(p0: RecordDef<Ex, En>) -> Self {
3015 Def::RecordDef(Box::new(p0))
3016 }
3017 pub fn mk_stmt(p0: Stmt<Ex, En>) -> Self {
3018 Def::Stmt(Box::new(p0))
3019 }
3020 pub fn mk_typedef(p0: Typedef<Ex, En>) -> Self {
3021 Def::Typedef(Box::new(p0))
3022 }
3023 pub fn mk_constant(p0: Gconst<Ex, En>) -> Self {
3024 Def::Constant(Box::new(p0))
3025 }
3026 pub fn mk_namespace(p0: Sid, p1: Program<Ex, En>) -> Self {
3027 Def::Namespace(Box::new((p0, p1)))
3028 }
3029 pub fn mk_namespace_use(p0: Vec<(NsKind, Sid, Sid)>) -> Self {
3030 Def::NamespaceUse(p0)
3031 }
3032 pub fn mk_set_namespace_env(p0: Nsenv) -> Self {
3033 Def::SetNamespaceEnv(Box::new(p0))
3034 }
3035 pub fn mk_file_attributes(p0: FileAttribute<Ex, En>) -> Self {
3036 Def::FileAttributes(Box::new(p0))
3037 }
3038 pub fn is_fun(&self) -> bool {
3039 match self {
3040 Def::Fun(..) => true,
3041 _ => false,
3042 }
3043 }
3044 pub fn is_class(&self) -> bool {
3045 match self {
3046 Def::Class(..) => true,
3047 _ => false,
3048 }
3049 }
3050 pub fn is_record_def(&self) -> bool {
3051 match self {
3052 Def::RecordDef(..) => true,
3053 _ => false,
3054 }
3055 }
3056 pub fn is_stmt(&self) -> bool {
3057 match self {
3058 Def::Stmt(..) => true,
3059 _ => false,
3060 }
3061 }
3062 pub fn is_typedef(&self) -> bool {
3063 match self {
3064 Def::Typedef(..) => true,
3065 _ => false,
3066 }
3067 }
3068 pub fn is_constant(&self) -> bool {
3069 match self {
3070 Def::Constant(..) => true,
3071 _ => false,
3072 }
3073 }
3074 pub fn is_namespace(&self) -> bool {
3075 match self {
3076 Def::Namespace(..) => true,
3077 _ => false,
3078 }
3079 }
3080 pub fn is_namespace_use(&self) -> bool {
3081 match self {
3082 Def::NamespaceUse(..) => true,
3083 _ => false,
3084 }
3085 }
3086 pub fn is_set_namespace_env(&self) -> bool {
3087 match self {
3088 Def::SetNamespaceEnv(..) => true,
3089 _ => false,
3090 }
3091 }
3092 pub fn is_file_attributes(&self) -> bool {
3093 match self {
3094 Def::FileAttributes(..) => true,
3095 _ => false,
3096 }
3097 }
3098 pub fn as_fun(&self) -> Option<&FunDef<Ex, En>> {
3099 match self {
3100 Def::Fun(p0) => Some(&p0),
3101 _ => None,
3102 }
3103 }
3104 pub fn as_class(&self) -> Option<&Class_<Ex, En>> {
3105 match self {
3106 Def::Class(p0) => Some(&p0),
3107 _ => None,
3108 }
3109 }
3110 pub fn as_record_def(&self) -> Option<&RecordDef<Ex, En>> {
3111 match self {
3112 Def::RecordDef(p0) => Some(&p0),
3113 _ => None,
3114 }
3115 }
3116 pub fn as_stmt(&self) -> Option<&Stmt<Ex, En>> {
3117 match self {
3118 Def::Stmt(p0) => Some(&p0),
3119 _ => None,
3120 }
3121 }
3122 pub fn as_typedef(&self) -> Option<&Typedef<Ex, En>> {
3123 match self {
3124 Def::Typedef(p0) => Some(&p0),
3125 _ => None,
3126 }
3127 }
3128 pub fn as_constant(&self) -> Option<&Gconst<Ex, En>> {
3129 match self {
3130 Def::Constant(p0) => Some(&p0),
3131 _ => None,
3132 }
3133 }
3134 pub fn as_namespace(&self) -> Option<(&Sid, &Program<Ex, En>)> {
3135 match self {
3136 Def::Namespace(p0) => Some((&p0.0, &p0.1)),
3137 _ => None,
3138 }
3139 }
3140 pub fn as_namespace_use(&self) -> Option<&Vec<(NsKind, Sid, Sid)>> {
3141 match self {
3142 Def::NamespaceUse(p0) => Some(p0),
3143 _ => None,
3144 }
3145 }
3146 pub fn as_set_namespace_env(&self) -> Option<&Nsenv> {
3147 match self {
3148 Def::SetNamespaceEnv(p0) => Some(&p0),
3149 _ => None,
3150 }
3151 }
3152 pub fn as_file_attributes(&self) -> Option<&FileAttribute<Ex, En>> {
3153 match self {
3154 Def::FileAttributes(p0) => Some(&p0),
3155 _ => None,
3156 }
3157 }
3158 pub fn as_fun_mut(&mut self) -> Option<&mut FunDef<Ex, En>> {
3159 match self {
3160 Def::Fun(p0) => Some(p0.as_mut()),
3161 _ => None,
3162 }
3163 }
3164 pub fn as_class_mut(&mut self) -> Option<&mut Class_<Ex, En>> {
3165 match self {
3166 Def::Class(p0) => Some(p0.as_mut()),
3167 _ => None,
3168 }
3169 }
3170 pub fn as_record_def_mut(&mut self) -> Option<&mut RecordDef<Ex, En>> {
3171 match self {
3172 Def::RecordDef(p0) => Some(p0.as_mut()),
3173 _ => None,
3174 }
3175 }
3176 pub fn as_stmt_mut(&mut self) -> Option<&mut Stmt<Ex, En>> {
3177 match self {
3178 Def::Stmt(p0) => Some(p0.as_mut()),
3179 _ => None,
3180 }
3181 }
3182 pub fn as_typedef_mut(&mut self) -> Option<&mut Typedef<Ex, En>> {
3183 match self {
3184 Def::Typedef(p0) => Some(p0.as_mut()),
3185 _ => None,
3186 }
3187 }
3188 pub fn as_constant_mut(&mut self) -> Option<&mut Gconst<Ex, En>> {
3189 match self {
3190 Def::Constant(p0) => Some(p0.as_mut()),
3191 _ => None,
3192 }
3193 }
3194 pub fn as_namespace_mut(&mut self) -> Option<(&mut Sid, &mut Program<Ex, En>)> {
3195 match self {
3196 Def::Namespace(p0) => Some((&mut p0.0, &mut p0.1)),
3197 _ => None,
3198 }
3199 }
3200 pub fn as_namespace_use_mut(&mut self) -> Option<&mut Vec<(NsKind, Sid, Sid)>> {
3201 match self {
3202 Def::NamespaceUse(p0) => Some(p0),
3203 _ => None,
3204 }
3205 }
3206 pub fn as_set_namespace_env_mut(&mut self) -> Option<&mut Nsenv> {
3207 match self {
3208 Def::SetNamespaceEnv(p0) => Some(p0.as_mut()),
3209 _ => None,
3210 }
3211 }
3212 pub fn as_file_attributes_mut(&mut self) -> Option<&mut FileAttribute<Ex, En>> {
3213 match self {
3214 Def::FileAttributes(p0) => Some(p0.as_mut()),
3215 _ => None,
3216 }
3217 }
3218 pub fn as_fun_into(self) -> Option<FunDef<Ex, En>> {
3219 match self {
3220 Def::Fun(p0) => Some(*p0),
3221 _ => None,
3222 }
3223 }
3224 pub fn as_class_into(self) -> Option<Class_<Ex, En>> {
3225 match self {
3226 Def::Class(p0) => Some(*p0),
3227 _ => None,
3228 }
3229 }
3230 pub fn as_record_def_into(self) -> Option<RecordDef<Ex, En>> {
3231 match self {
3232 Def::RecordDef(p0) => Some(*p0),
3233 _ => None,
3234 }
3235 }
3236 pub fn as_stmt_into(self) -> Option<Stmt<Ex, En>> {
3237 match self {
3238 Def::Stmt(p0) => Some(*p0),
3239 _ => None,
3240 }
3241 }
3242 pub fn as_typedef_into(self) -> Option<Typedef<Ex, En>> {
3243 match self {
3244 Def::Typedef(p0) => Some(*p0),
3245 _ => None,
3246 }
3247 }
3248 pub fn as_constant_into(self) -> Option<Gconst<Ex, En>> {
3249 match self {
3250 Def::Constant(p0) => Some(*p0),
3251 _ => None,
3252 }
3253 }
3254 pub fn as_namespace_into(self) -> Option<(Sid, Program<Ex, En>)> {
3255 match self {
3256 Def::Namespace(p0) => Some(((*p0).0, (*p0).1)),
3257 _ => None,
3258 }
3259 }
3260 pub fn as_namespace_use_into(self) -> Option<Vec<(NsKind, Sid, Sid)>> {
3261 match self {
3262 Def::NamespaceUse(p0) => Some(p0),
3263 _ => None,
3264 }
3265 }
3266 pub fn as_set_namespace_env_into(self) -> Option<Nsenv> {
3267 match self {
3268 Def::SetNamespaceEnv(p0) => Some(*p0),
3269 _ => None,
3270 }
3271 }
3272 pub fn as_file_attributes_into(self) -> Option<FileAttribute<Ex, En>> {
3273 match self {
3274 Def::FileAttributes(p0) => Some(*p0),
3275 _ => None,
3276 }
3277 }
3278 }
3279 impl NsKind {
3280 pub fn mk_nsnamespace() -> Self {
3281 NsKind::NSNamespace
3282 }
3283 pub fn mk_nsclass() -> Self {
3284 NsKind::NSClass
3285 }
3286 pub fn mk_nsclass_and_namespace() -> Self {
3287 NsKind::NSClassAndNamespace
3288 }
3289 pub fn mk_nsfun() -> Self {
3290 NsKind::NSFun
3291 }
3292 pub fn mk_nsconst() -> Self {
3293 NsKind::NSConst
3294 }
3295 pub fn is_nsnamespace(&self) -> bool {
3296 match self {
3297 NsKind::NSNamespace => true,
3298 _ => false,
3299 }
3300 }
3301 pub fn is_nsclass(&self) -> bool {
3302 match self {
3303 NsKind::NSClass => true,
3304 _ => false,
3305 }
3306 }
3307 pub fn is_nsclass_and_namespace(&self) -> bool {
3308 match self {
3309 NsKind::NSClassAndNamespace => true,
3310 _ => false,
3311 }
3312 }
3313 pub fn is_nsfun(&self) -> bool {
3314 match self {
3315 NsKind::NSFun => true,
3316 _ => false,
3317 }
3318 }
3319 pub fn is_nsconst(&self) -> bool {
3320 match self {
3321 NsKind::NSConst => true,
3322 _ => false,
3323 }
3324 }
3325 }
3326 impl BreakContinueLevel {
3327 pub fn mk_level_ok(p0: Option<isize>) -> Self {
3328 BreakContinueLevel::LevelOk(p0)
3329 }
3330 pub fn mk_level_non_literal() -> Self {
3331 BreakContinueLevel::LevelNonLiteral
3332 }
3333 pub fn mk_level_non_positive() -> Self {
3334 BreakContinueLevel::LevelNonPositive
3335 }
3336 pub fn is_level_ok(&self) -> bool {
3337 match self {
3338 BreakContinueLevel::LevelOk(..) => true,
3339 _ => false,
3340 }
3341 }
3342 pub fn is_level_non_literal(&self) -> bool {
3343 match self {
3344 BreakContinueLevel::LevelNonLiteral => true,
3345 _ => false,
3346 }
3347 }
3348 pub fn is_level_non_positive(&self) -> bool {
3349 match self {
3350 BreakContinueLevel::LevelNonPositive => true,
3351 _ => false,
3352 }
3353 }
3354 pub fn as_level_ok(&self) -> Option<&Option<isize>> {
3355 match self {
3356 BreakContinueLevel::LevelOk(p0) => Some(p0),
3357 _ => None,
3358 }
3359 }
3360 pub fn as_level_ok_mut(&mut self) -> Option<&mut Option<isize>> {
3361 match self {
3362 BreakContinueLevel::LevelOk(p0) => Some(p0),
3363 _ => None,
3364 }
3365 }
3366 pub fn as_level_ok_into(self) -> Option<Option<isize>> {
3367 match self {
3368 BreakContinueLevel::LevelOk(p0) => Some(p0),
3369 _ => None,
3370 }
3371 }
3372 }