1
2
3 package ir
4
5 import "fmt"
6
7 func (n *AddStringExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
8 func (n *AddStringExpr) copy() Node {
9 c := *n
10 c.init = copyNodes(c.init)
11 c.List = copyNodes(c.List)
12 return &c
13 }
14 func (n *AddStringExpr) doChildren(do func(Node) bool) bool {
15 if doNodes(n.init, do) {
16 return true
17 }
18 if doNodes(n.List, do) {
19 return true
20 }
21 if n.Prealloc != nil && do(n.Prealloc) {
22 return true
23 }
24 return false
25 }
26 func (n *AddStringExpr) doChildrenWithHidden(do func(Node) bool) bool {
27 if doNodes(n.init, do) {
28 return true
29 }
30 if doNodes(n.List, do) {
31 return true
32 }
33 if n.Prealloc != nil && do(n.Prealloc) {
34 return true
35 }
36 return false
37 }
38 func (n *AddStringExpr) editChildren(edit func(Node) Node) {
39 editNodes(n.init, edit)
40 editNodes(n.List, edit)
41 if n.Prealloc != nil {
42 n.Prealloc = edit(n.Prealloc).(*Name)
43 }
44 }
45 func (n *AddStringExpr) editChildrenWithHidden(edit func(Node) Node) {
46 editNodes(n.init, edit)
47 editNodes(n.List, edit)
48 if n.Prealloc != nil {
49 n.Prealloc = edit(n.Prealloc).(*Name)
50 }
51 }
52
53 func (n *AddrExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
54 func (n *AddrExpr) copy() Node {
55 c := *n
56 c.init = copyNodes(c.init)
57 return &c
58 }
59 func (n *AddrExpr) doChildren(do func(Node) bool) bool {
60 if doNodes(n.init, do) {
61 return true
62 }
63 if n.X != nil && do(n.X) {
64 return true
65 }
66 if n.Prealloc != nil && do(n.Prealloc) {
67 return true
68 }
69 return false
70 }
71 func (n *AddrExpr) doChildrenWithHidden(do func(Node) bool) bool {
72 if doNodes(n.init, do) {
73 return true
74 }
75 if n.X != nil && do(n.X) {
76 return true
77 }
78 if n.Prealloc != nil && do(n.Prealloc) {
79 return true
80 }
81 return false
82 }
83 func (n *AddrExpr) editChildren(edit func(Node) Node) {
84 editNodes(n.init, edit)
85 if n.X != nil {
86 n.X = edit(n.X).(Node)
87 }
88 if n.Prealloc != nil {
89 n.Prealloc = edit(n.Prealloc).(*Name)
90 }
91 }
92 func (n *AddrExpr) editChildrenWithHidden(edit func(Node) Node) {
93 editNodes(n.init, edit)
94 if n.X != nil {
95 n.X = edit(n.X).(Node)
96 }
97 if n.Prealloc != nil {
98 n.Prealloc = edit(n.Prealloc).(*Name)
99 }
100 }
101
102 func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
103 func (n *AssignListStmt) copy() Node {
104 c := *n
105 c.init = copyNodes(c.init)
106 c.Lhs = copyNodes(c.Lhs)
107 c.Rhs = copyNodes(c.Rhs)
108 return &c
109 }
110 func (n *AssignListStmt) doChildren(do func(Node) bool) bool {
111 if doNodes(n.init, do) {
112 return true
113 }
114 if doNodes(n.Lhs, do) {
115 return true
116 }
117 if doNodes(n.Rhs, do) {
118 return true
119 }
120 return false
121 }
122 func (n *AssignListStmt) doChildrenWithHidden(do func(Node) bool) bool {
123 if doNodes(n.init, do) {
124 return true
125 }
126 if doNodes(n.Lhs, do) {
127 return true
128 }
129 if doNodes(n.Rhs, do) {
130 return true
131 }
132 return false
133 }
134 func (n *AssignListStmt) editChildren(edit func(Node) Node) {
135 editNodes(n.init, edit)
136 editNodes(n.Lhs, edit)
137 editNodes(n.Rhs, edit)
138 }
139 func (n *AssignListStmt) editChildrenWithHidden(edit func(Node) Node) {
140 editNodes(n.init, edit)
141 editNodes(n.Lhs, edit)
142 editNodes(n.Rhs, edit)
143 }
144
145 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
146 func (n *AssignOpStmt) copy() Node {
147 c := *n
148 c.init = copyNodes(c.init)
149 return &c
150 }
151 func (n *AssignOpStmt) doChildren(do func(Node) bool) bool {
152 if doNodes(n.init, do) {
153 return true
154 }
155 if n.X != nil && do(n.X) {
156 return true
157 }
158 if n.Y != nil && do(n.Y) {
159 return true
160 }
161 return false
162 }
163 func (n *AssignOpStmt) doChildrenWithHidden(do func(Node) bool) bool {
164 if doNodes(n.init, do) {
165 return true
166 }
167 if n.X != nil && do(n.X) {
168 return true
169 }
170 if n.Y != nil && do(n.Y) {
171 return true
172 }
173 return false
174 }
175 func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
176 editNodes(n.init, edit)
177 if n.X != nil {
178 n.X = edit(n.X).(Node)
179 }
180 if n.Y != nil {
181 n.Y = edit(n.Y).(Node)
182 }
183 }
184 func (n *AssignOpStmt) editChildrenWithHidden(edit func(Node) Node) {
185 editNodes(n.init, edit)
186 if n.X != nil {
187 n.X = edit(n.X).(Node)
188 }
189 if n.Y != nil {
190 n.Y = edit(n.Y).(Node)
191 }
192 }
193
194 func (n *AssignStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
195 func (n *AssignStmt) copy() Node {
196 c := *n
197 c.init = copyNodes(c.init)
198 return &c
199 }
200 func (n *AssignStmt) doChildren(do func(Node) bool) bool {
201 if doNodes(n.init, do) {
202 return true
203 }
204 if n.X != nil && do(n.X) {
205 return true
206 }
207 if n.Y != nil && do(n.Y) {
208 return true
209 }
210 return false
211 }
212 func (n *AssignStmt) doChildrenWithHidden(do func(Node) bool) bool {
213 if doNodes(n.init, do) {
214 return true
215 }
216 if n.X != nil && do(n.X) {
217 return true
218 }
219 if n.Y != nil && do(n.Y) {
220 return true
221 }
222 return false
223 }
224 func (n *AssignStmt) editChildren(edit func(Node) Node) {
225 editNodes(n.init, edit)
226 if n.X != nil {
227 n.X = edit(n.X).(Node)
228 }
229 if n.Y != nil {
230 n.Y = edit(n.Y).(Node)
231 }
232 }
233 func (n *AssignStmt) editChildrenWithHidden(edit func(Node) Node) {
234 editNodes(n.init, edit)
235 if n.X != nil {
236 n.X = edit(n.X).(Node)
237 }
238 if n.Y != nil {
239 n.Y = edit(n.Y).(Node)
240 }
241 }
242
243 func (n *BasicLit) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
244 func (n *BasicLit) copy() Node {
245 c := *n
246 c.init = copyNodes(c.init)
247 return &c
248 }
249 func (n *BasicLit) doChildren(do func(Node) bool) bool {
250 if doNodes(n.init, do) {
251 return true
252 }
253 return false
254 }
255 func (n *BasicLit) doChildrenWithHidden(do func(Node) bool) bool {
256 if doNodes(n.init, do) {
257 return true
258 }
259 return false
260 }
261 func (n *BasicLit) editChildren(edit func(Node) Node) {
262 editNodes(n.init, edit)
263 }
264 func (n *BasicLit) editChildrenWithHidden(edit func(Node) Node) {
265 editNodes(n.init, edit)
266 }
267
268 func (n *BinaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
269 func (n *BinaryExpr) copy() Node {
270 c := *n
271 c.init = copyNodes(c.init)
272 return &c
273 }
274 func (n *BinaryExpr) doChildren(do func(Node) bool) bool {
275 if doNodes(n.init, do) {
276 return true
277 }
278 if n.X != nil && do(n.X) {
279 return true
280 }
281 if n.Y != nil && do(n.Y) {
282 return true
283 }
284 return false
285 }
286 func (n *BinaryExpr) doChildrenWithHidden(do func(Node) bool) bool {
287 if doNodes(n.init, do) {
288 return true
289 }
290 if n.X != nil && do(n.X) {
291 return true
292 }
293 if n.Y != nil && do(n.Y) {
294 return true
295 }
296 if n.RType != nil && do(n.RType) {
297 return true
298 }
299 return false
300 }
301 func (n *BinaryExpr) editChildren(edit func(Node) Node) {
302 editNodes(n.init, edit)
303 if n.X != nil {
304 n.X = edit(n.X).(Node)
305 }
306 if n.Y != nil {
307 n.Y = edit(n.Y).(Node)
308 }
309 }
310 func (n *BinaryExpr) editChildrenWithHidden(edit func(Node) Node) {
311 editNodes(n.init, edit)
312 if n.X != nil {
313 n.X = edit(n.X).(Node)
314 }
315 if n.Y != nil {
316 n.Y = edit(n.Y).(Node)
317 }
318 if n.RType != nil {
319 n.RType = edit(n.RType).(Node)
320 }
321 }
322
323 func (n *BlockStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
324 func (n *BlockStmt) copy() Node {
325 c := *n
326 c.init = copyNodes(c.init)
327 c.List = copyNodes(c.List)
328 return &c
329 }
330 func (n *BlockStmt) doChildren(do func(Node) bool) bool {
331 if doNodes(n.init, do) {
332 return true
333 }
334 if doNodes(n.List, do) {
335 return true
336 }
337 return false
338 }
339 func (n *BlockStmt) doChildrenWithHidden(do func(Node) bool) bool {
340 if doNodes(n.init, do) {
341 return true
342 }
343 if doNodes(n.List, do) {
344 return true
345 }
346 return false
347 }
348 func (n *BlockStmt) editChildren(edit func(Node) Node) {
349 editNodes(n.init, edit)
350 editNodes(n.List, edit)
351 }
352 func (n *BlockStmt) editChildrenWithHidden(edit func(Node) Node) {
353 editNodes(n.init, edit)
354 editNodes(n.List, edit)
355 }
356
357 func (n *BranchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
358 func (n *BranchStmt) copy() Node {
359 c := *n
360 c.init = copyNodes(c.init)
361 return &c
362 }
363 func (n *BranchStmt) doChildren(do func(Node) bool) bool {
364 if doNodes(n.init, do) {
365 return true
366 }
367 return false
368 }
369 func (n *BranchStmt) doChildrenWithHidden(do func(Node) bool) bool {
370 if doNodes(n.init, do) {
371 return true
372 }
373 return false
374 }
375 func (n *BranchStmt) editChildren(edit func(Node) Node) {
376 editNodes(n.init, edit)
377 }
378 func (n *BranchStmt) editChildrenWithHidden(edit func(Node) Node) {
379 editNodes(n.init, edit)
380 }
381
382 func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
383 func (n *CallExpr) copy() Node {
384 c := *n
385 c.init = copyNodes(c.init)
386 c.Args = copyNodes(c.Args)
387 c.KeepAlive = copyNames(c.KeepAlive)
388 return &c
389 }
390 func (n *CallExpr) doChildren(do func(Node) bool) bool {
391 if doNodes(n.init, do) {
392 return true
393 }
394 if n.Fun != nil && do(n.Fun) {
395 return true
396 }
397 if doNodes(n.Args, do) {
398 return true
399 }
400 if n.DeferAt != nil && do(n.DeferAt) {
401 return true
402 }
403 if doNames(n.KeepAlive, do) {
404 return true
405 }
406 return false
407 }
408 func (n *CallExpr) doChildrenWithHidden(do func(Node) bool) bool {
409 if doNodes(n.init, do) {
410 return true
411 }
412 if n.Fun != nil && do(n.Fun) {
413 return true
414 }
415 if doNodes(n.Args, do) {
416 return true
417 }
418 if n.DeferAt != nil && do(n.DeferAt) {
419 return true
420 }
421 if n.RType != nil && do(n.RType) {
422 return true
423 }
424 if doNames(n.KeepAlive, do) {
425 return true
426 }
427 return false
428 }
429 func (n *CallExpr) editChildren(edit func(Node) Node) {
430 editNodes(n.init, edit)
431 if n.Fun != nil {
432 n.Fun = edit(n.Fun).(Node)
433 }
434 editNodes(n.Args, edit)
435 if n.DeferAt != nil {
436 n.DeferAt = edit(n.DeferAt).(Node)
437 }
438 editNames(n.KeepAlive, edit)
439 }
440 func (n *CallExpr) editChildrenWithHidden(edit func(Node) Node) {
441 editNodes(n.init, edit)
442 if n.Fun != nil {
443 n.Fun = edit(n.Fun).(Node)
444 }
445 editNodes(n.Args, edit)
446 if n.DeferAt != nil {
447 n.DeferAt = edit(n.DeferAt).(Node)
448 }
449 if n.RType != nil {
450 n.RType = edit(n.RType).(Node)
451 }
452 editNames(n.KeepAlive, edit)
453 }
454
455 func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
456 func (n *CaseClause) copy() Node {
457 c := *n
458 c.init = copyNodes(c.init)
459 c.List = copyNodes(c.List)
460 c.RTypes = copyNodes(c.RTypes)
461 c.Body = copyNodes(c.Body)
462 return &c
463 }
464 func (n *CaseClause) doChildren(do func(Node) bool) bool {
465 if doNodes(n.init, do) {
466 return true
467 }
468 if n.Var != nil && do(n.Var) {
469 return true
470 }
471 if doNodes(n.List, do) {
472 return true
473 }
474 if doNodes(n.RTypes, do) {
475 return true
476 }
477 if doNodes(n.Body, do) {
478 return true
479 }
480 return false
481 }
482 func (n *CaseClause) doChildrenWithHidden(do func(Node) bool) bool {
483 if doNodes(n.init, do) {
484 return true
485 }
486 if n.Var != nil && do(n.Var) {
487 return true
488 }
489 if doNodes(n.List, do) {
490 return true
491 }
492 if doNodes(n.RTypes, do) {
493 return true
494 }
495 if doNodes(n.Body, do) {
496 return true
497 }
498 return false
499 }
500 func (n *CaseClause) editChildren(edit func(Node) Node) {
501 editNodes(n.init, edit)
502 if n.Var != nil {
503 n.Var = edit(n.Var).(*Name)
504 }
505 editNodes(n.List, edit)
506 editNodes(n.RTypes, edit)
507 editNodes(n.Body, edit)
508 }
509 func (n *CaseClause) editChildrenWithHidden(edit func(Node) Node) {
510 editNodes(n.init, edit)
511 if n.Var != nil {
512 n.Var = edit(n.Var).(*Name)
513 }
514 editNodes(n.List, edit)
515 editNodes(n.RTypes, edit)
516 editNodes(n.Body, edit)
517 }
518
519 func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
520 func (n *ClosureExpr) copy() Node {
521 c := *n
522 c.init = copyNodes(c.init)
523 return &c
524 }
525 func (n *ClosureExpr) doChildren(do func(Node) bool) bool {
526 if doNodes(n.init, do) {
527 return true
528 }
529 if n.Prealloc != nil && do(n.Prealloc) {
530 return true
531 }
532 return false
533 }
534 func (n *ClosureExpr) doChildrenWithHidden(do func(Node) bool) bool {
535 if doNodes(n.init, do) {
536 return true
537 }
538 if n.Prealloc != nil && do(n.Prealloc) {
539 return true
540 }
541 return false
542 }
543 func (n *ClosureExpr) editChildren(edit func(Node) Node) {
544 editNodes(n.init, edit)
545 if n.Prealloc != nil {
546 n.Prealloc = edit(n.Prealloc).(*Name)
547 }
548 }
549 func (n *ClosureExpr) editChildrenWithHidden(edit func(Node) Node) {
550 editNodes(n.init, edit)
551 if n.Prealloc != nil {
552 n.Prealloc = edit(n.Prealloc).(*Name)
553 }
554 }
555
556 func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
557 func (n *CommClause) copy() Node {
558 c := *n
559 c.init = copyNodes(c.init)
560 c.Body = copyNodes(c.Body)
561 return &c
562 }
563 func (n *CommClause) doChildren(do func(Node) bool) bool {
564 if doNodes(n.init, do) {
565 return true
566 }
567 if n.Comm != nil && do(n.Comm) {
568 return true
569 }
570 if doNodes(n.Body, do) {
571 return true
572 }
573 return false
574 }
575 func (n *CommClause) doChildrenWithHidden(do func(Node) bool) bool {
576 if doNodes(n.init, do) {
577 return true
578 }
579 if n.Comm != nil && do(n.Comm) {
580 return true
581 }
582 if doNodes(n.Body, do) {
583 return true
584 }
585 return false
586 }
587 func (n *CommClause) editChildren(edit func(Node) Node) {
588 editNodes(n.init, edit)
589 if n.Comm != nil {
590 n.Comm = edit(n.Comm).(Node)
591 }
592 editNodes(n.Body, edit)
593 }
594 func (n *CommClause) editChildrenWithHidden(edit func(Node) Node) {
595 editNodes(n.init, edit)
596 if n.Comm != nil {
597 n.Comm = edit(n.Comm).(Node)
598 }
599 editNodes(n.Body, edit)
600 }
601
602 func (n *CompLitExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
603 func (n *CompLitExpr) copy() Node {
604 c := *n
605 c.init = copyNodes(c.init)
606 c.List = copyNodes(c.List)
607 return &c
608 }
609 func (n *CompLitExpr) doChildren(do func(Node) bool) bool {
610 if doNodes(n.init, do) {
611 return true
612 }
613 if doNodes(n.List, do) {
614 return true
615 }
616 if n.Prealloc != nil && do(n.Prealloc) {
617 return true
618 }
619 return false
620 }
621 func (n *CompLitExpr) doChildrenWithHidden(do func(Node) bool) bool {
622 if doNodes(n.init, do) {
623 return true
624 }
625 if doNodes(n.List, do) {
626 return true
627 }
628 if n.RType != nil && do(n.RType) {
629 return true
630 }
631 if n.Prealloc != nil && do(n.Prealloc) {
632 return true
633 }
634 return false
635 }
636 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
637 editNodes(n.init, edit)
638 editNodes(n.List, edit)
639 if n.Prealloc != nil {
640 n.Prealloc = edit(n.Prealloc).(*Name)
641 }
642 }
643 func (n *CompLitExpr) editChildrenWithHidden(edit func(Node) Node) {
644 editNodes(n.init, edit)
645 editNodes(n.List, edit)
646 if n.RType != nil {
647 n.RType = edit(n.RType).(Node)
648 }
649 if n.Prealloc != nil {
650 n.Prealloc = edit(n.Prealloc).(*Name)
651 }
652 }
653
654 func (n *ConvExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
655 func (n *ConvExpr) copy() Node {
656 c := *n
657 c.init = copyNodes(c.init)
658 return &c
659 }
660 func (n *ConvExpr) doChildren(do func(Node) bool) bool {
661 if doNodes(n.init, do) {
662 return true
663 }
664 if n.X != nil && do(n.X) {
665 return true
666 }
667 return false
668 }
669 func (n *ConvExpr) doChildrenWithHidden(do func(Node) bool) bool {
670 if doNodes(n.init, do) {
671 return true
672 }
673 if n.X != nil && do(n.X) {
674 return true
675 }
676 if n.TypeWord != nil && do(n.TypeWord) {
677 return true
678 }
679 if n.SrcRType != nil && do(n.SrcRType) {
680 return true
681 }
682 if n.ElemRType != nil && do(n.ElemRType) {
683 return true
684 }
685 if n.ElemElemRType != nil && do(n.ElemElemRType) {
686 return true
687 }
688 return false
689 }
690 func (n *ConvExpr) editChildren(edit func(Node) Node) {
691 editNodes(n.init, edit)
692 if n.X != nil {
693 n.X = edit(n.X).(Node)
694 }
695 }
696 func (n *ConvExpr) editChildrenWithHidden(edit func(Node) Node) {
697 editNodes(n.init, edit)
698 if n.X != nil {
699 n.X = edit(n.X).(Node)
700 }
701 if n.TypeWord != nil {
702 n.TypeWord = edit(n.TypeWord).(Node)
703 }
704 if n.SrcRType != nil {
705 n.SrcRType = edit(n.SrcRType).(Node)
706 }
707 if n.ElemRType != nil {
708 n.ElemRType = edit(n.ElemRType).(Node)
709 }
710 if n.ElemElemRType != nil {
711 n.ElemElemRType = edit(n.ElemElemRType).(Node)
712 }
713 }
714
715 func (n *Decl) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
716 func (n *Decl) copy() Node {
717 c := *n
718 return &c
719 }
720 func (n *Decl) doChildren(do func(Node) bool) bool {
721 if n.X != nil && do(n.X) {
722 return true
723 }
724 return false
725 }
726 func (n *Decl) doChildrenWithHidden(do func(Node) bool) bool {
727 if n.X != nil && do(n.X) {
728 return true
729 }
730 return false
731 }
732 func (n *Decl) editChildren(edit func(Node) Node) {
733 if n.X != nil {
734 n.X = edit(n.X).(*Name)
735 }
736 }
737 func (n *Decl) editChildrenWithHidden(edit func(Node) Node) {
738 if n.X != nil {
739 n.X = edit(n.X).(*Name)
740 }
741 }
742
743 func (n *DynamicType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
744 func (n *DynamicType) copy() Node {
745 c := *n
746 c.init = copyNodes(c.init)
747 return &c
748 }
749 func (n *DynamicType) doChildren(do func(Node) bool) bool {
750 if doNodes(n.init, do) {
751 return true
752 }
753 if n.RType != nil && do(n.RType) {
754 return true
755 }
756 if n.ITab != nil && do(n.ITab) {
757 return true
758 }
759 return false
760 }
761 func (n *DynamicType) doChildrenWithHidden(do func(Node) bool) bool {
762 if doNodes(n.init, do) {
763 return true
764 }
765 if n.RType != nil && do(n.RType) {
766 return true
767 }
768 if n.ITab != nil && do(n.ITab) {
769 return true
770 }
771 return false
772 }
773 func (n *DynamicType) editChildren(edit func(Node) Node) {
774 editNodes(n.init, edit)
775 if n.RType != nil {
776 n.RType = edit(n.RType).(Node)
777 }
778 if n.ITab != nil {
779 n.ITab = edit(n.ITab).(Node)
780 }
781 }
782 func (n *DynamicType) editChildrenWithHidden(edit func(Node) Node) {
783 editNodes(n.init, edit)
784 if n.RType != nil {
785 n.RType = edit(n.RType).(Node)
786 }
787 if n.ITab != nil {
788 n.ITab = edit(n.ITab).(Node)
789 }
790 }
791
792 func (n *DynamicTypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
793 func (n *DynamicTypeAssertExpr) copy() Node {
794 c := *n
795 c.init = copyNodes(c.init)
796 return &c
797 }
798 func (n *DynamicTypeAssertExpr) doChildren(do func(Node) bool) bool {
799 if doNodes(n.init, do) {
800 return true
801 }
802 if n.X != nil && do(n.X) {
803 return true
804 }
805 if n.SrcRType != nil && do(n.SrcRType) {
806 return true
807 }
808 if n.RType != nil && do(n.RType) {
809 return true
810 }
811 if n.ITab != nil && do(n.ITab) {
812 return true
813 }
814 return false
815 }
816 func (n *DynamicTypeAssertExpr) doChildrenWithHidden(do func(Node) bool) bool {
817 if doNodes(n.init, do) {
818 return true
819 }
820 if n.X != nil && do(n.X) {
821 return true
822 }
823 if n.SrcRType != nil && do(n.SrcRType) {
824 return true
825 }
826 if n.RType != nil && do(n.RType) {
827 return true
828 }
829 if n.ITab != nil && do(n.ITab) {
830 return true
831 }
832 return false
833 }
834 func (n *DynamicTypeAssertExpr) editChildren(edit func(Node) Node) {
835 editNodes(n.init, edit)
836 if n.X != nil {
837 n.X = edit(n.X).(Node)
838 }
839 if n.SrcRType != nil {
840 n.SrcRType = edit(n.SrcRType).(Node)
841 }
842 if n.RType != nil {
843 n.RType = edit(n.RType).(Node)
844 }
845 if n.ITab != nil {
846 n.ITab = edit(n.ITab).(Node)
847 }
848 }
849 func (n *DynamicTypeAssertExpr) editChildrenWithHidden(edit func(Node) Node) {
850 editNodes(n.init, edit)
851 if n.X != nil {
852 n.X = edit(n.X).(Node)
853 }
854 if n.SrcRType != nil {
855 n.SrcRType = edit(n.SrcRType).(Node)
856 }
857 if n.RType != nil {
858 n.RType = edit(n.RType).(Node)
859 }
860 if n.ITab != nil {
861 n.ITab = edit(n.ITab).(Node)
862 }
863 }
864
865 func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
866 func (n *ForStmt) copy() Node {
867 c := *n
868 c.init = copyNodes(c.init)
869 c.Body = copyNodes(c.Body)
870 return &c
871 }
872 func (n *ForStmt) doChildren(do func(Node) bool) bool {
873 if doNodes(n.init, do) {
874 return true
875 }
876 if n.Cond != nil && do(n.Cond) {
877 return true
878 }
879 if n.Post != nil && do(n.Post) {
880 return true
881 }
882 if doNodes(n.Body, do) {
883 return true
884 }
885 return false
886 }
887 func (n *ForStmt) doChildrenWithHidden(do func(Node) bool) bool {
888 if doNodes(n.init, do) {
889 return true
890 }
891 if n.Cond != nil && do(n.Cond) {
892 return true
893 }
894 if n.Post != nil && do(n.Post) {
895 return true
896 }
897 if doNodes(n.Body, do) {
898 return true
899 }
900 return false
901 }
902 func (n *ForStmt) editChildren(edit func(Node) Node) {
903 editNodes(n.init, edit)
904 if n.Cond != nil {
905 n.Cond = edit(n.Cond).(Node)
906 }
907 if n.Post != nil {
908 n.Post = edit(n.Post).(Node)
909 }
910 editNodes(n.Body, edit)
911 }
912 func (n *ForStmt) editChildrenWithHidden(edit func(Node) Node) {
913 editNodes(n.init, edit)
914 if n.Cond != nil {
915 n.Cond = edit(n.Cond).(Node)
916 }
917 if n.Post != nil {
918 n.Post = edit(n.Post).(Node)
919 }
920 editNodes(n.Body, edit)
921 }
922
923 func (n *Func) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
924
925 func (n *GoDeferStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
926 func (n *GoDeferStmt) copy() Node {
927 c := *n
928 c.init = copyNodes(c.init)
929 return &c
930 }
931 func (n *GoDeferStmt) doChildren(do func(Node) bool) bool {
932 if doNodes(n.init, do) {
933 return true
934 }
935 if n.Call != nil && do(n.Call) {
936 return true
937 }
938 if n.DeferAt != nil && do(n.DeferAt) {
939 return true
940 }
941 return false
942 }
943 func (n *GoDeferStmt) doChildrenWithHidden(do func(Node) bool) bool {
944 if doNodes(n.init, do) {
945 return true
946 }
947 if n.Call != nil && do(n.Call) {
948 return true
949 }
950 if n.DeferAt != nil && do(n.DeferAt) {
951 return true
952 }
953 return false
954 }
955 func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
956 editNodes(n.init, edit)
957 if n.Call != nil {
958 n.Call = edit(n.Call).(Node)
959 }
960 if n.DeferAt != nil {
961 n.DeferAt = edit(n.DeferAt).(Expr)
962 }
963 }
964 func (n *GoDeferStmt) editChildrenWithHidden(edit func(Node) Node) {
965 editNodes(n.init, edit)
966 if n.Call != nil {
967 n.Call = edit(n.Call).(Node)
968 }
969 if n.DeferAt != nil {
970 n.DeferAt = edit(n.DeferAt).(Expr)
971 }
972 }
973
974 func (n *Ident) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
975 func (n *Ident) copy() Node {
976 c := *n
977 c.init = copyNodes(c.init)
978 return &c
979 }
980 func (n *Ident) doChildren(do func(Node) bool) bool {
981 if doNodes(n.init, do) {
982 return true
983 }
984 return false
985 }
986 func (n *Ident) doChildrenWithHidden(do func(Node) bool) bool {
987 if doNodes(n.init, do) {
988 return true
989 }
990 return false
991 }
992 func (n *Ident) editChildren(edit func(Node) Node) {
993 editNodes(n.init, edit)
994 }
995 func (n *Ident) editChildrenWithHidden(edit func(Node) Node) {
996 editNodes(n.init, edit)
997 }
998
999 func (n *IfStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1000 func (n *IfStmt) copy() Node {
1001 c := *n
1002 c.init = copyNodes(c.init)
1003 c.Body = copyNodes(c.Body)
1004 c.Else = copyNodes(c.Else)
1005 return &c
1006 }
1007 func (n *IfStmt) doChildren(do func(Node) bool) bool {
1008 if doNodes(n.init, do) {
1009 return true
1010 }
1011 if n.Cond != nil && do(n.Cond) {
1012 return true
1013 }
1014 if doNodes(n.Body, do) {
1015 return true
1016 }
1017 if doNodes(n.Else, do) {
1018 return true
1019 }
1020 return false
1021 }
1022 func (n *IfStmt) doChildrenWithHidden(do func(Node) bool) bool {
1023 if doNodes(n.init, do) {
1024 return true
1025 }
1026 if n.Cond != nil && do(n.Cond) {
1027 return true
1028 }
1029 if doNodes(n.Body, do) {
1030 return true
1031 }
1032 if doNodes(n.Else, do) {
1033 return true
1034 }
1035 return false
1036 }
1037 func (n *IfStmt) editChildren(edit func(Node) Node) {
1038 editNodes(n.init, edit)
1039 if n.Cond != nil {
1040 n.Cond = edit(n.Cond).(Node)
1041 }
1042 editNodes(n.Body, edit)
1043 editNodes(n.Else, edit)
1044 }
1045 func (n *IfStmt) editChildrenWithHidden(edit func(Node) Node) {
1046 editNodes(n.init, edit)
1047 if n.Cond != nil {
1048 n.Cond = edit(n.Cond).(Node)
1049 }
1050 editNodes(n.Body, edit)
1051 editNodes(n.Else, edit)
1052 }
1053
1054 func (n *IndexExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1055 func (n *IndexExpr) copy() Node {
1056 c := *n
1057 c.init = copyNodes(c.init)
1058 return &c
1059 }
1060 func (n *IndexExpr) doChildren(do func(Node) bool) bool {
1061 if doNodes(n.init, do) {
1062 return true
1063 }
1064 if n.X != nil && do(n.X) {
1065 return true
1066 }
1067 if n.Index != nil && do(n.Index) {
1068 return true
1069 }
1070 return false
1071 }
1072 func (n *IndexExpr) doChildrenWithHidden(do func(Node) bool) bool {
1073 if doNodes(n.init, do) {
1074 return true
1075 }
1076 if n.X != nil && do(n.X) {
1077 return true
1078 }
1079 if n.Index != nil && do(n.Index) {
1080 return true
1081 }
1082 if n.RType != nil && do(n.RType) {
1083 return true
1084 }
1085 return false
1086 }
1087 func (n *IndexExpr) editChildren(edit func(Node) Node) {
1088 editNodes(n.init, edit)
1089 if n.X != nil {
1090 n.X = edit(n.X).(Node)
1091 }
1092 if n.Index != nil {
1093 n.Index = edit(n.Index).(Node)
1094 }
1095 }
1096 func (n *IndexExpr) editChildrenWithHidden(edit func(Node) Node) {
1097 editNodes(n.init, edit)
1098 if n.X != nil {
1099 n.X = edit(n.X).(Node)
1100 }
1101 if n.Index != nil {
1102 n.Index = edit(n.Index).(Node)
1103 }
1104 if n.RType != nil {
1105 n.RType = edit(n.RType).(Node)
1106 }
1107 }
1108
1109 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1110 func (n *InlineMarkStmt) copy() Node {
1111 c := *n
1112 c.init = copyNodes(c.init)
1113 return &c
1114 }
1115 func (n *InlineMarkStmt) doChildren(do func(Node) bool) bool {
1116 if doNodes(n.init, do) {
1117 return true
1118 }
1119 return false
1120 }
1121 func (n *InlineMarkStmt) doChildrenWithHidden(do func(Node) bool) bool {
1122 if doNodes(n.init, do) {
1123 return true
1124 }
1125 return false
1126 }
1127 func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
1128 editNodes(n.init, edit)
1129 }
1130 func (n *InlineMarkStmt) editChildrenWithHidden(edit func(Node) Node) {
1131 editNodes(n.init, edit)
1132 }
1133
1134 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1135 func (n *InlinedCallExpr) copy() Node {
1136 c := *n
1137 c.init = copyNodes(c.init)
1138 c.Body = copyNodes(c.Body)
1139 c.ReturnVars = copyNodes(c.ReturnVars)
1140 return &c
1141 }
1142 func (n *InlinedCallExpr) doChildren(do func(Node) bool) bool {
1143 if doNodes(n.init, do) {
1144 return true
1145 }
1146 if doNodes(n.Body, do) {
1147 return true
1148 }
1149 if doNodes(n.ReturnVars, do) {
1150 return true
1151 }
1152 return false
1153 }
1154 func (n *InlinedCallExpr) doChildrenWithHidden(do func(Node) bool) bool {
1155 if doNodes(n.init, do) {
1156 return true
1157 }
1158 if doNodes(n.Body, do) {
1159 return true
1160 }
1161 if doNodes(n.ReturnVars, do) {
1162 return true
1163 }
1164 return false
1165 }
1166 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
1167 editNodes(n.init, edit)
1168 editNodes(n.Body, edit)
1169 editNodes(n.ReturnVars, edit)
1170 }
1171 func (n *InlinedCallExpr) editChildrenWithHidden(edit func(Node) Node) {
1172 editNodes(n.init, edit)
1173 editNodes(n.Body, edit)
1174 editNodes(n.ReturnVars, edit)
1175 }
1176
1177 func (n *InterfaceSwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1178 func (n *InterfaceSwitchStmt) copy() Node {
1179 c := *n
1180 c.init = copyNodes(c.init)
1181 return &c
1182 }
1183 func (n *InterfaceSwitchStmt) doChildren(do func(Node) bool) bool {
1184 if doNodes(n.init, do) {
1185 return true
1186 }
1187 if n.Case != nil && do(n.Case) {
1188 return true
1189 }
1190 if n.Itab != nil && do(n.Itab) {
1191 return true
1192 }
1193 if n.RuntimeType != nil && do(n.RuntimeType) {
1194 return true
1195 }
1196 if n.Hash != nil && do(n.Hash) {
1197 return true
1198 }
1199 return false
1200 }
1201 func (n *InterfaceSwitchStmt) doChildrenWithHidden(do func(Node) bool) bool {
1202 if doNodes(n.init, do) {
1203 return true
1204 }
1205 if n.Case != nil && do(n.Case) {
1206 return true
1207 }
1208 if n.Itab != nil && do(n.Itab) {
1209 return true
1210 }
1211 if n.RuntimeType != nil && do(n.RuntimeType) {
1212 return true
1213 }
1214 if n.Hash != nil && do(n.Hash) {
1215 return true
1216 }
1217 return false
1218 }
1219 func (n *InterfaceSwitchStmt) editChildren(edit func(Node) Node) {
1220 editNodes(n.init, edit)
1221 if n.Case != nil {
1222 n.Case = edit(n.Case).(Node)
1223 }
1224 if n.Itab != nil {
1225 n.Itab = edit(n.Itab).(Node)
1226 }
1227 if n.RuntimeType != nil {
1228 n.RuntimeType = edit(n.RuntimeType).(Node)
1229 }
1230 if n.Hash != nil {
1231 n.Hash = edit(n.Hash).(Node)
1232 }
1233 }
1234 func (n *InterfaceSwitchStmt) editChildrenWithHidden(edit func(Node) Node) {
1235 editNodes(n.init, edit)
1236 if n.Case != nil {
1237 n.Case = edit(n.Case).(Node)
1238 }
1239 if n.Itab != nil {
1240 n.Itab = edit(n.Itab).(Node)
1241 }
1242 if n.RuntimeType != nil {
1243 n.RuntimeType = edit(n.RuntimeType).(Node)
1244 }
1245 if n.Hash != nil {
1246 n.Hash = edit(n.Hash).(Node)
1247 }
1248 }
1249
1250 func (n *JumpTableStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1251 func (n *JumpTableStmt) copy() Node {
1252 c := *n
1253 c.init = copyNodes(c.init)
1254 return &c
1255 }
1256 func (n *JumpTableStmt) doChildren(do func(Node) bool) bool {
1257 if doNodes(n.init, do) {
1258 return true
1259 }
1260 if n.Idx != nil && do(n.Idx) {
1261 return true
1262 }
1263 return false
1264 }
1265 func (n *JumpTableStmt) doChildrenWithHidden(do func(Node) bool) bool {
1266 if doNodes(n.init, do) {
1267 return true
1268 }
1269 if n.Idx != nil && do(n.Idx) {
1270 return true
1271 }
1272 return false
1273 }
1274 func (n *JumpTableStmt) editChildren(edit func(Node) Node) {
1275 editNodes(n.init, edit)
1276 if n.Idx != nil {
1277 n.Idx = edit(n.Idx).(Node)
1278 }
1279 }
1280 func (n *JumpTableStmt) editChildrenWithHidden(edit func(Node) Node) {
1281 editNodes(n.init, edit)
1282 if n.Idx != nil {
1283 n.Idx = edit(n.Idx).(Node)
1284 }
1285 }
1286
1287 func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1288 func (n *KeyExpr) copy() Node {
1289 c := *n
1290 c.init = copyNodes(c.init)
1291 return &c
1292 }
1293 func (n *KeyExpr) doChildren(do func(Node) bool) bool {
1294 if doNodes(n.init, do) {
1295 return true
1296 }
1297 if n.Key != nil && do(n.Key) {
1298 return true
1299 }
1300 if n.Value != nil && do(n.Value) {
1301 return true
1302 }
1303 return false
1304 }
1305 func (n *KeyExpr) doChildrenWithHidden(do func(Node) bool) bool {
1306 if doNodes(n.init, do) {
1307 return true
1308 }
1309 if n.Key != nil && do(n.Key) {
1310 return true
1311 }
1312 if n.Value != nil && do(n.Value) {
1313 return true
1314 }
1315 return false
1316 }
1317 func (n *KeyExpr) editChildren(edit func(Node) Node) {
1318 editNodes(n.init, edit)
1319 if n.Key != nil {
1320 n.Key = edit(n.Key).(Node)
1321 }
1322 if n.Value != nil {
1323 n.Value = edit(n.Value).(Node)
1324 }
1325 }
1326 func (n *KeyExpr) editChildrenWithHidden(edit func(Node) Node) {
1327 editNodes(n.init, edit)
1328 if n.Key != nil {
1329 n.Key = edit(n.Key).(Node)
1330 }
1331 if n.Value != nil {
1332 n.Value = edit(n.Value).(Node)
1333 }
1334 }
1335
1336 func (n *LabelStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1337 func (n *LabelStmt) copy() Node {
1338 c := *n
1339 c.init = copyNodes(c.init)
1340 return &c
1341 }
1342 func (n *LabelStmt) doChildren(do func(Node) bool) bool {
1343 if doNodes(n.init, do) {
1344 return true
1345 }
1346 return false
1347 }
1348 func (n *LabelStmt) doChildrenWithHidden(do func(Node) bool) bool {
1349 if doNodes(n.init, do) {
1350 return true
1351 }
1352 return false
1353 }
1354 func (n *LabelStmt) editChildren(edit func(Node) Node) {
1355 editNodes(n.init, edit)
1356 }
1357 func (n *LabelStmt) editChildrenWithHidden(edit func(Node) Node) {
1358 editNodes(n.init, edit)
1359 }
1360
1361 func (n *LinksymOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1362 func (n *LinksymOffsetExpr) copy() Node {
1363 c := *n
1364 c.init = copyNodes(c.init)
1365 return &c
1366 }
1367 func (n *LinksymOffsetExpr) doChildren(do func(Node) bool) bool {
1368 if doNodes(n.init, do) {
1369 return true
1370 }
1371 return false
1372 }
1373 func (n *LinksymOffsetExpr) doChildrenWithHidden(do func(Node) bool) bool {
1374 if doNodes(n.init, do) {
1375 return true
1376 }
1377 return false
1378 }
1379 func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
1380 editNodes(n.init, edit)
1381 }
1382 func (n *LinksymOffsetExpr) editChildrenWithHidden(edit func(Node) Node) {
1383 editNodes(n.init, edit)
1384 }
1385
1386 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1387 func (n *LogicalExpr) copy() Node {
1388 c := *n
1389 c.init = copyNodes(c.init)
1390 return &c
1391 }
1392 func (n *LogicalExpr) doChildren(do func(Node) bool) bool {
1393 if doNodes(n.init, do) {
1394 return true
1395 }
1396 if n.X != nil && do(n.X) {
1397 return true
1398 }
1399 if n.Y != nil && do(n.Y) {
1400 return true
1401 }
1402 return false
1403 }
1404 func (n *LogicalExpr) doChildrenWithHidden(do func(Node) bool) bool {
1405 if doNodes(n.init, do) {
1406 return true
1407 }
1408 if n.X != nil && do(n.X) {
1409 return true
1410 }
1411 if n.Y != nil && do(n.Y) {
1412 return true
1413 }
1414 return false
1415 }
1416 func (n *LogicalExpr) editChildren(edit func(Node) Node) {
1417 editNodes(n.init, edit)
1418 if n.X != nil {
1419 n.X = edit(n.X).(Node)
1420 }
1421 if n.Y != nil {
1422 n.Y = edit(n.Y).(Node)
1423 }
1424 }
1425 func (n *LogicalExpr) editChildrenWithHidden(edit func(Node) Node) {
1426 editNodes(n.init, edit)
1427 if n.X != nil {
1428 n.X = edit(n.X).(Node)
1429 }
1430 if n.Y != nil {
1431 n.Y = edit(n.Y).(Node)
1432 }
1433 }
1434
1435 func (n *MakeExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1436 func (n *MakeExpr) copy() Node {
1437 c := *n
1438 c.init = copyNodes(c.init)
1439 return &c
1440 }
1441 func (n *MakeExpr) doChildren(do func(Node) bool) bool {
1442 if doNodes(n.init, do) {
1443 return true
1444 }
1445 if n.Len != nil && do(n.Len) {
1446 return true
1447 }
1448 if n.Cap != nil && do(n.Cap) {
1449 return true
1450 }
1451 return false
1452 }
1453 func (n *MakeExpr) doChildrenWithHidden(do func(Node) bool) bool {
1454 if doNodes(n.init, do) {
1455 return true
1456 }
1457 if n.RType != nil && do(n.RType) {
1458 return true
1459 }
1460 if n.Len != nil && do(n.Len) {
1461 return true
1462 }
1463 if n.Cap != nil && do(n.Cap) {
1464 return true
1465 }
1466 return false
1467 }
1468 func (n *MakeExpr) editChildren(edit func(Node) Node) {
1469 editNodes(n.init, edit)
1470 if n.Len != nil {
1471 n.Len = edit(n.Len).(Node)
1472 }
1473 if n.Cap != nil {
1474 n.Cap = edit(n.Cap).(Node)
1475 }
1476 }
1477 func (n *MakeExpr) editChildrenWithHidden(edit func(Node) Node) {
1478 editNodes(n.init, edit)
1479 if n.RType != nil {
1480 n.RType = edit(n.RType).(Node)
1481 }
1482 if n.Len != nil {
1483 n.Len = edit(n.Len).(Node)
1484 }
1485 if n.Cap != nil {
1486 n.Cap = edit(n.Cap).(Node)
1487 }
1488 }
1489
1490 func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1491
1492 func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1493 func (n *NilExpr) copy() Node {
1494 c := *n
1495 c.init = copyNodes(c.init)
1496 return &c
1497 }
1498 func (n *NilExpr) doChildren(do func(Node) bool) bool {
1499 if doNodes(n.init, do) {
1500 return true
1501 }
1502 return false
1503 }
1504 func (n *NilExpr) doChildrenWithHidden(do func(Node) bool) bool {
1505 if doNodes(n.init, do) {
1506 return true
1507 }
1508 return false
1509 }
1510 func (n *NilExpr) editChildren(edit func(Node) Node) {
1511 editNodes(n.init, edit)
1512 }
1513 func (n *NilExpr) editChildrenWithHidden(edit func(Node) Node) {
1514 editNodes(n.init, edit)
1515 }
1516
1517 func (n *ParenExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1518 func (n *ParenExpr) copy() Node {
1519 c := *n
1520 c.init = copyNodes(c.init)
1521 return &c
1522 }
1523 func (n *ParenExpr) doChildren(do func(Node) bool) bool {
1524 if doNodes(n.init, do) {
1525 return true
1526 }
1527 if n.X != nil && do(n.X) {
1528 return true
1529 }
1530 return false
1531 }
1532 func (n *ParenExpr) doChildrenWithHidden(do func(Node) bool) bool {
1533 if doNodes(n.init, do) {
1534 return true
1535 }
1536 if n.X != nil && do(n.X) {
1537 return true
1538 }
1539 return false
1540 }
1541 func (n *ParenExpr) editChildren(edit func(Node) Node) {
1542 editNodes(n.init, edit)
1543 if n.X != nil {
1544 n.X = edit(n.X).(Node)
1545 }
1546 }
1547 func (n *ParenExpr) editChildrenWithHidden(edit func(Node) Node) {
1548 editNodes(n.init, edit)
1549 if n.X != nil {
1550 n.X = edit(n.X).(Node)
1551 }
1552 }
1553
1554 func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1555 func (n *RangeStmt) copy() Node {
1556 c := *n
1557 c.init = copyNodes(c.init)
1558 c.Body = copyNodes(c.Body)
1559 return &c
1560 }
1561 func (n *RangeStmt) doChildren(do func(Node) bool) bool {
1562 if doNodes(n.init, do) {
1563 return true
1564 }
1565 if n.X != nil && do(n.X) {
1566 return true
1567 }
1568 if n.Key != nil && do(n.Key) {
1569 return true
1570 }
1571 if n.Value != nil && do(n.Value) {
1572 return true
1573 }
1574 if doNodes(n.Body, do) {
1575 return true
1576 }
1577 if n.Prealloc != nil && do(n.Prealloc) {
1578 return true
1579 }
1580 return false
1581 }
1582 func (n *RangeStmt) doChildrenWithHidden(do func(Node) bool) bool {
1583 if doNodes(n.init, do) {
1584 return true
1585 }
1586 if n.X != nil && do(n.X) {
1587 return true
1588 }
1589 if n.RType != nil && do(n.RType) {
1590 return true
1591 }
1592 if n.Key != nil && do(n.Key) {
1593 return true
1594 }
1595 if n.Value != nil && do(n.Value) {
1596 return true
1597 }
1598 if doNodes(n.Body, do) {
1599 return true
1600 }
1601 if n.Prealloc != nil && do(n.Prealloc) {
1602 return true
1603 }
1604 if n.KeyTypeWord != nil && do(n.KeyTypeWord) {
1605 return true
1606 }
1607 if n.KeySrcRType != nil && do(n.KeySrcRType) {
1608 return true
1609 }
1610 if n.ValueTypeWord != nil && do(n.ValueTypeWord) {
1611 return true
1612 }
1613 if n.ValueSrcRType != nil && do(n.ValueSrcRType) {
1614 return true
1615 }
1616 return false
1617 }
1618 func (n *RangeStmt) editChildren(edit func(Node) Node) {
1619 editNodes(n.init, edit)
1620 if n.X != nil {
1621 n.X = edit(n.X).(Node)
1622 }
1623 if n.Key != nil {
1624 n.Key = edit(n.Key).(Node)
1625 }
1626 if n.Value != nil {
1627 n.Value = edit(n.Value).(Node)
1628 }
1629 editNodes(n.Body, edit)
1630 if n.Prealloc != nil {
1631 n.Prealloc = edit(n.Prealloc).(*Name)
1632 }
1633 }
1634 func (n *RangeStmt) editChildrenWithHidden(edit func(Node) Node) {
1635 editNodes(n.init, edit)
1636 if n.X != nil {
1637 n.X = edit(n.X).(Node)
1638 }
1639 if n.RType != nil {
1640 n.RType = edit(n.RType).(Node)
1641 }
1642 if n.Key != nil {
1643 n.Key = edit(n.Key).(Node)
1644 }
1645 if n.Value != nil {
1646 n.Value = edit(n.Value).(Node)
1647 }
1648 editNodes(n.Body, edit)
1649 if n.Prealloc != nil {
1650 n.Prealloc = edit(n.Prealloc).(*Name)
1651 }
1652 if n.KeyTypeWord != nil {
1653 n.KeyTypeWord = edit(n.KeyTypeWord).(Node)
1654 }
1655 if n.KeySrcRType != nil {
1656 n.KeySrcRType = edit(n.KeySrcRType).(Node)
1657 }
1658 if n.ValueTypeWord != nil {
1659 n.ValueTypeWord = edit(n.ValueTypeWord).(Node)
1660 }
1661 if n.ValueSrcRType != nil {
1662 n.ValueSrcRType = edit(n.ValueSrcRType).(Node)
1663 }
1664 }
1665
1666 func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1667 func (n *ResultExpr) copy() Node {
1668 c := *n
1669 c.init = copyNodes(c.init)
1670 return &c
1671 }
1672 func (n *ResultExpr) doChildren(do func(Node) bool) bool {
1673 if doNodes(n.init, do) {
1674 return true
1675 }
1676 return false
1677 }
1678 func (n *ResultExpr) doChildrenWithHidden(do func(Node) bool) bool {
1679 if doNodes(n.init, do) {
1680 return true
1681 }
1682 return false
1683 }
1684 func (n *ResultExpr) editChildren(edit func(Node) Node) {
1685 editNodes(n.init, edit)
1686 }
1687 func (n *ResultExpr) editChildrenWithHidden(edit func(Node) Node) {
1688 editNodes(n.init, edit)
1689 }
1690
1691 func (n *ReturnStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1692 func (n *ReturnStmt) copy() Node {
1693 c := *n
1694 c.init = copyNodes(c.init)
1695 c.Results = copyNodes(c.Results)
1696 return &c
1697 }
1698 func (n *ReturnStmt) doChildren(do func(Node) bool) bool {
1699 if doNodes(n.init, do) {
1700 return true
1701 }
1702 if doNodes(n.Results, do) {
1703 return true
1704 }
1705 return false
1706 }
1707 func (n *ReturnStmt) doChildrenWithHidden(do func(Node) bool) bool {
1708 if doNodes(n.init, do) {
1709 return true
1710 }
1711 if doNodes(n.Results, do) {
1712 return true
1713 }
1714 return false
1715 }
1716 func (n *ReturnStmt) editChildren(edit func(Node) Node) {
1717 editNodes(n.init, edit)
1718 editNodes(n.Results, edit)
1719 }
1720 func (n *ReturnStmt) editChildrenWithHidden(edit func(Node) Node) {
1721 editNodes(n.init, edit)
1722 editNodes(n.Results, edit)
1723 }
1724
1725 func (n *SelectStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1726 func (n *SelectStmt) copy() Node {
1727 c := *n
1728 c.init = copyNodes(c.init)
1729 c.Cases = copyCommClauses(c.Cases)
1730 c.Compiled = copyNodes(c.Compiled)
1731 return &c
1732 }
1733 func (n *SelectStmt) doChildren(do func(Node) bool) bool {
1734 if doNodes(n.init, do) {
1735 return true
1736 }
1737 if doCommClauses(n.Cases, do) {
1738 return true
1739 }
1740 if doNodes(n.Compiled, do) {
1741 return true
1742 }
1743 return false
1744 }
1745 func (n *SelectStmt) doChildrenWithHidden(do func(Node) bool) bool {
1746 if doNodes(n.init, do) {
1747 return true
1748 }
1749 if doCommClauses(n.Cases, do) {
1750 return true
1751 }
1752 if doNodes(n.Compiled, do) {
1753 return true
1754 }
1755 return false
1756 }
1757 func (n *SelectStmt) editChildren(edit func(Node) Node) {
1758 editNodes(n.init, edit)
1759 editCommClauses(n.Cases, edit)
1760 editNodes(n.Compiled, edit)
1761 }
1762 func (n *SelectStmt) editChildrenWithHidden(edit func(Node) Node) {
1763 editNodes(n.init, edit)
1764 editCommClauses(n.Cases, edit)
1765 editNodes(n.Compiled, edit)
1766 }
1767
1768 func (n *SelectorExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1769 func (n *SelectorExpr) copy() Node {
1770 c := *n
1771 c.init = copyNodes(c.init)
1772 return &c
1773 }
1774 func (n *SelectorExpr) doChildren(do func(Node) bool) bool {
1775 if doNodes(n.init, do) {
1776 return true
1777 }
1778 if n.X != nil && do(n.X) {
1779 return true
1780 }
1781 if n.Prealloc != nil && do(n.Prealloc) {
1782 return true
1783 }
1784 return false
1785 }
1786 func (n *SelectorExpr) doChildrenWithHidden(do func(Node) bool) bool {
1787 if doNodes(n.init, do) {
1788 return true
1789 }
1790 if n.X != nil && do(n.X) {
1791 return true
1792 }
1793 if n.Prealloc != nil && do(n.Prealloc) {
1794 return true
1795 }
1796 return false
1797 }
1798 func (n *SelectorExpr) editChildren(edit func(Node) Node) {
1799 editNodes(n.init, edit)
1800 if n.X != nil {
1801 n.X = edit(n.X).(Node)
1802 }
1803 if n.Prealloc != nil {
1804 n.Prealloc = edit(n.Prealloc).(*Name)
1805 }
1806 }
1807 func (n *SelectorExpr) editChildrenWithHidden(edit func(Node) Node) {
1808 editNodes(n.init, edit)
1809 if n.X != nil {
1810 n.X = edit(n.X).(Node)
1811 }
1812 if n.Prealloc != nil {
1813 n.Prealloc = edit(n.Prealloc).(*Name)
1814 }
1815 }
1816
1817 func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1818 func (n *SendStmt) copy() Node {
1819 c := *n
1820 c.init = copyNodes(c.init)
1821 return &c
1822 }
1823 func (n *SendStmt) doChildren(do func(Node) bool) bool {
1824 if doNodes(n.init, do) {
1825 return true
1826 }
1827 if n.Chan != nil && do(n.Chan) {
1828 return true
1829 }
1830 if n.Value != nil && do(n.Value) {
1831 return true
1832 }
1833 return false
1834 }
1835 func (n *SendStmt) doChildrenWithHidden(do func(Node) bool) bool {
1836 if doNodes(n.init, do) {
1837 return true
1838 }
1839 if n.Chan != nil && do(n.Chan) {
1840 return true
1841 }
1842 if n.Value != nil && do(n.Value) {
1843 return true
1844 }
1845 return false
1846 }
1847 func (n *SendStmt) editChildren(edit func(Node) Node) {
1848 editNodes(n.init, edit)
1849 if n.Chan != nil {
1850 n.Chan = edit(n.Chan).(Node)
1851 }
1852 if n.Value != nil {
1853 n.Value = edit(n.Value).(Node)
1854 }
1855 }
1856 func (n *SendStmt) editChildrenWithHidden(edit func(Node) Node) {
1857 editNodes(n.init, edit)
1858 if n.Chan != nil {
1859 n.Chan = edit(n.Chan).(Node)
1860 }
1861 if n.Value != nil {
1862 n.Value = edit(n.Value).(Node)
1863 }
1864 }
1865
1866 func (n *SliceExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1867 func (n *SliceExpr) copy() Node {
1868 c := *n
1869 c.init = copyNodes(c.init)
1870 return &c
1871 }
1872 func (n *SliceExpr) doChildren(do func(Node) bool) bool {
1873 if doNodes(n.init, do) {
1874 return true
1875 }
1876 if n.X != nil && do(n.X) {
1877 return true
1878 }
1879 if n.Low != nil && do(n.Low) {
1880 return true
1881 }
1882 if n.High != nil && do(n.High) {
1883 return true
1884 }
1885 if n.Max != nil && do(n.Max) {
1886 return true
1887 }
1888 return false
1889 }
1890 func (n *SliceExpr) doChildrenWithHidden(do func(Node) bool) bool {
1891 if doNodes(n.init, do) {
1892 return true
1893 }
1894 if n.X != nil && do(n.X) {
1895 return true
1896 }
1897 if n.Low != nil && do(n.Low) {
1898 return true
1899 }
1900 if n.High != nil && do(n.High) {
1901 return true
1902 }
1903 if n.Max != nil && do(n.Max) {
1904 return true
1905 }
1906 return false
1907 }
1908 func (n *SliceExpr) editChildren(edit func(Node) Node) {
1909 editNodes(n.init, edit)
1910 if n.X != nil {
1911 n.X = edit(n.X).(Node)
1912 }
1913 if n.Low != nil {
1914 n.Low = edit(n.Low).(Node)
1915 }
1916 if n.High != nil {
1917 n.High = edit(n.High).(Node)
1918 }
1919 if n.Max != nil {
1920 n.Max = edit(n.Max).(Node)
1921 }
1922 }
1923 func (n *SliceExpr) editChildrenWithHidden(edit func(Node) Node) {
1924 editNodes(n.init, edit)
1925 if n.X != nil {
1926 n.X = edit(n.X).(Node)
1927 }
1928 if n.Low != nil {
1929 n.Low = edit(n.Low).(Node)
1930 }
1931 if n.High != nil {
1932 n.High = edit(n.High).(Node)
1933 }
1934 if n.Max != nil {
1935 n.Max = edit(n.Max).(Node)
1936 }
1937 }
1938
1939 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1940 func (n *SliceHeaderExpr) copy() Node {
1941 c := *n
1942 c.init = copyNodes(c.init)
1943 return &c
1944 }
1945 func (n *SliceHeaderExpr) doChildren(do func(Node) bool) bool {
1946 if doNodes(n.init, do) {
1947 return true
1948 }
1949 if n.Ptr != nil && do(n.Ptr) {
1950 return true
1951 }
1952 if n.Len != nil && do(n.Len) {
1953 return true
1954 }
1955 if n.Cap != nil && do(n.Cap) {
1956 return true
1957 }
1958 return false
1959 }
1960 func (n *SliceHeaderExpr) doChildrenWithHidden(do func(Node) bool) bool {
1961 if doNodes(n.init, do) {
1962 return true
1963 }
1964 if n.Ptr != nil && do(n.Ptr) {
1965 return true
1966 }
1967 if n.Len != nil && do(n.Len) {
1968 return true
1969 }
1970 if n.Cap != nil && do(n.Cap) {
1971 return true
1972 }
1973 return false
1974 }
1975 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
1976 editNodes(n.init, edit)
1977 if n.Ptr != nil {
1978 n.Ptr = edit(n.Ptr).(Node)
1979 }
1980 if n.Len != nil {
1981 n.Len = edit(n.Len).(Node)
1982 }
1983 if n.Cap != nil {
1984 n.Cap = edit(n.Cap).(Node)
1985 }
1986 }
1987 func (n *SliceHeaderExpr) editChildrenWithHidden(edit func(Node) Node) {
1988 editNodes(n.init, edit)
1989 if n.Ptr != nil {
1990 n.Ptr = edit(n.Ptr).(Node)
1991 }
1992 if n.Len != nil {
1993 n.Len = edit(n.Len).(Node)
1994 }
1995 if n.Cap != nil {
1996 n.Cap = edit(n.Cap).(Node)
1997 }
1998 }
1999
2000 func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2001 func (n *StarExpr) copy() Node {
2002 c := *n
2003 c.init = copyNodes(c.init)
2004 return &c
2005 }
2006 func (n *StarExpr) doChildren(do func(Node) bool) bool {
2007 if doNodes(n.init, do) {
2008 return true
2009 }
2010 if n.X != nil && do(n.X) {
2011 return true
2012 }
2013 return false
2014 }
2015 func (n *StarExpr) doChildrenWithHidden(do func(Node) bool) bool {
2016 if doNodes(n.init, do) {
2017 return true
2018 }
2019 if n.X != nil && do(n.X) {
2020 return true
2021 }
2022 return false
2023 }
2024 func (n *StarExpr) editChildren(edit func(Node) Node) {
2025 editNodes(n.init, edit)
2026 if n.X != nil {
2027 n.X = edit(n.X).(Node)
2028 }
2029 }
2030 func (n *StarExpr) editChildrenWithHidden(edit func(Node) Node) {
2031 editNodes(n.init, edit)
2032 if n.X != nil {
2033 n.X = edit(n.X).(Node)
2034 }
2035 }
2036
2037 func (n *StringHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2038 func (n *StringHeaderExpr) copy() Node {
2039 c := *n
2040 c.init = copyNodes(c.init)
2041 return &c
2042 }
2043 func (n *StringHeaderExpr) doChildren(do func(Node) bool) bool {
2044 if doNodes(n.init, do) {
2045 return true
2046 }
2047 if n.Ptr != nil && do(n.Ptr) {
2048 return true
2049 }
2050 if n.Len != nil && do(n.Len) {
2051 return true
2052 }
2053 return false
2054 }
2055 func (n *StringHeaderExpr) doChildrenWithHidden(do func(Node) bool) bool {
2056 if doNodes(n.init, do) {
2057 return true
2058 }
2059 if n.Ptr != nil && do(n.Ptr) {
2060 return true
2061 }
2062 if n.Len != nil && do(n.Len) {
2063 return true
2064 }
2065 return false
2066 }
2067 func (n *StringHeaderExpr) editChildren(edit func(Node) Node) {
2068 editNodes(n.init, edit)
2069 if n.Ptr != nil {
2070 n.Ptr = edit(n.Ptr).(Node)
2071 }
2072 if n.Len != nil {
2073 n.Len = edit(n.Len).(Node)
2074 }
2075 }
2076 func (n *StringHeaderExpr) editChildrenWithHidden(edit func(Node) Node) {
2077 editNodes(n.init, edit)
2078 if n.Ptr != nil {
2079 n.Ptr = edit(n.Ptr).(Node)
2080 }
2081 if n.Len != nil {
2082 n.Len = edit(n.Len).(Node)
2083 }
2084 }
2085
2086 func (n *StructKeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2087 func (n *StructKeyExpr) copy() Node {
2088 c := *n
2089 c.init = copyNodes(c.init)
2090 return &c
2091 }
2092 func (n *StructKeyExpr) doChildren(do func(Node) bool) bool {
2093 if doNodes(n.init, do) {
2094 return true
2095 }
2096 if n.Value != nil && do(n.Value) {
2097 return true
2098 }
2099 return false
2100 }
2101 func (n *StructKeyExpr) doChildrenWithHidden(do func(Node) bool) bool {
2102 if doNodes(n.init, do) {
2103 return true
2104 }
2105 if n.Value != nil && do(n.Value) {
2106 return true
2107 }
2108 return false
2109 }
2110 func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
2111 editNodes(n.init, edit)
2112 if n.Value != nil {
2113 n.Value = edit(n.Value).(Node)
2114 }
2115 }
2116 func (n *StructKeyExpr) editChildrenWithHidden(edit func(Node) Node) {
2117 editNodes(n.init, edit)
2118 if n.Value != nil {
2119 n.Value = edit(n.Value).(Node)
2120 }
2121 }
2122
2123 func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2124 func (n *SwitchStmt) copy() Node {
2125 c := *n
2126 c.init = copyNodes(c.init)
2127 c.Cases = copyCaseClauses(c.Cases)
2128 c.Compiled = copyNodes(c.Compiled)
2129 return &c
2130 }
2131 func (n *SwitchStmt) doChildren(do func(Node) bool) bool {
2132 if doNodes(n.init, do) {
2133 return true
2134 }
2135 if n.Tag != nil && do(n.Tag) {
2136 return true
2137 }
2138 if doCaseClauses(n.Cases, do) {
2139 return true
2140 }
2141 if doNodes(n.Compiled, do) {
2142 return true
2143 }
2144 return false
2145 }
2146 func (n *SwitchStmt) doChildrenWithHidden(do func(Node) bool) bool {
2147 if doNodes(n.init, do) {
2148 return true
2149 }
2150 if n.Tag != nil && do(n.Tag) {
2151 return true
2152 }
2153 if doCaseClauses(n.Cases, do) {
2154 return true
2155 }
2156 if doNodes(n.Compiled, do) {
2157 return true
2158 }
2159 return false
2160 }
2161 func (n *SwitchStmt) editChildren(edit func(Node) Node) {
2162 editNodes(n.init, edit)
2163 if n.Tag != nil {
2164 n.Tag = edit(n.Tag).(Node)
2165 }
2166 editCaseClauses(n.Cases, edit)
2167 editNodes(n.Compiled, edit)
2168 }
2169 func (n *SwitchStmt) editChildrenWithHidden(edit func(Node) Node) {
2170 editNodes(n.init, edit)
2171 if n.Tag != nil {
2172 n.Tag = edit(n.Tag).(Node)
2173 }
2174 editCaseClauses(n.Cases, edit)
2175 editNodes(n.Compiled, edit)
2176 }
2177
2178 func (n *TailCallStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2179 func (n *TailCallStmt) copy() Node {
2180 c := *n
2181 c.init = copyNodes(c.init)
2182 return &c
2183 }
2184 func (n *TailCallStmt) doChildren(do func(Node) bool) bool {
2185 if doNodes(n.init, do) {
2186 return true
2187 }
2188 if n.Call != nil && do(n.Call) {
2189 return true
2190 }
2191 return false
2192 }
2193 func (n *TailCallStmt) doChildrenWithHidden(do func(Node) bool) bool {
2194 if doNodes(n.init, do) {
2195 return true
2196 }
2197 if n.Call != nil && do(n.Call) {
2198 return true
2199 }
2200 return false
2201 }
2202 func (n *TailCallStmt) editChildren(edit func(Node) Node) {
2203 editNodes(n.init, edit)
2204 if n.Call != nil {
2205 n.Call = edit(n.Call).(*CallExpr)
2206 }
2207 }
2208 func (n *TailCallStmt) editChildrenWithHidden(edit func(Node) Node) {
2209 editNodes(n.init, edit)
2210 if n.Call != nil {
2211 n.Call = edit(n.Call).(*CallExpr)
2212 }
2213 }
2214
2215 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2216 func (n *TypeAssertExpr) copy() Node {
2217 c := *n
2218 c.init = copyNodes(c.init)
2219 return &c
2220 }
2221 func (n *TypeAssertExpr) doChildren(do func(Node) bool) bool {
2222 if doNodes(n.init, do) {
2223 return true
2224 }
2225 if n.X != nil && do(n.X) {
2226 return true
2227 }
2228 return false
2229 }
2230 func (n *TypeAssertExpr) doChildrenWithHidden(do func(Node) bool) bool {
2231 if doNodes(n.init, do) {
2232 return true
2233 }
2234 if n.X != nil && do(n.X) {
2235 return true
2236 }
2237 if n.ITab != nil && do(n.ITab) {
2238 return true
2239 }
2240 return false
2241 }
2242 func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
2243 editNodes(n.init, edit)
2244 if n.X != nil {
2245 n.X = edit(n.X).(Node)
2246 }
2247 }
2248 func (n *TypeAssertExpr) editChildrenWithHidden(edit func(Node) Node) {
2249 editNodes(n.init, edit)
2250 if n.X != nil {
2251 n.X = edit(n.X).(Node)
2252 }
2253 if n.ITab != nil {
2254 n.ITab = edit(n.ITab).(Node)
2255 }
2256 }
2257
2258 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2259 func (n *TypeSwitchGuard) copy() Node {
2260 c := *n
2261 return &c
2262 }
2263 func (n *TypeSwitchGuard) doChildren(do func(Node) bool) bool {
2264 if n.Tag != nil && do(n.Tag) {
2265 return true
2266 }
2267 if n.X != nil && do(n.X) {
2268 return true
2269 }
2270 return false
2271 }
2272 func (n *TypeSwitchGuard) doChildrenWithHidden(do func(Node) bool) bool {
2273 if n.Tag != nil && do(n.Tag) {
2274 return true
2275 }
2276 if n.X != nil && do(n.X) {
2277 return true
2278 }
2279 return false
2280 }
2281 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
2282 if n.Tag != nil {
2283 n.Tag = edit(n.Tag).(*Ident)
2284 }
2285 if n.X != nil {
2286 n.X = edit(n.X).(Node)
2287 }
2288 }
2289 func (n *TypeSwitchGuard) editChildrenWithHidden(edit func(Node) Node) {
2290 if n.Tag != nil {
2291 n.Tag = edit(n.Tag).(*Ident)
2292 }
2293 if n.X != nil {
2294 n.X = edit(n.X).(Node)
2295 }
2296 }
2297
2298 func (n *UnaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2299 func (n *UnaryExpr) copy() Node {
2300 c := *n
2301 c.init = copyNodes(c.init)
2302 return &c
2303 }
2304 func (n *UnaryExpr) doChildren(do func(Node) bool) bool {
2305 if doNodes(n.init, do) {
2306 return true
2307 }
2308 if n.X != nil && do(n.X) {
2309 return true
2310 }
2311 return false
2312 }
2313 func (n *UnaryExpr) doChildrenWithHidden(do func(Node) bool) bool {
2314 if doNodes(n.init, do) {
2315 return true
2316 }
2317 if n.X != nil && do(n.X) {
2318 return true
2319 }
2320 return false
2321 }
2322 func (n *UnaryExpr) editChildren(edit func(Node) Node) {
2323 editNodes(n.init, edit)
2324 if n.X != nil {
2325 n.X = edit(n.X).(Node)
2326 }
2327 }
2328 func (n *UnaryExpr) editChildrenWithHidden(edit func(Node) Node) {
2329 editNodes(n.init, edit)
2330 if n.X != nil {
2331 n.X = edit(n.X).(Node)
2332 }
2333 }
2334
2335 func (n *typeNode) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
2336 func (n *typeNode) copy() Node {
2337 c := *n
2338 return &c
2339 }
2340 func (n *typeNode) doChildren(do func(Node) bool) bool {
2341 return false
2342 }
2343 func (n *typeNode) doChildrenWithHidden(do func(Node) bool) bool {
2344 return false
2345 }
2346 func (n *typeNode) editChildren(edit func(Node) Node) {
2347 }
2348 func (n *typeNode) editChildrenWithHidden(edit func(Node) Node) {
2349 }
2350
2351 func copyCaseClauses(list []*CaseClause) []*CaseClause {
2352 if list == nil {
2353 return nil
2354 }
2355 c := make([]*CaseClause, len(list))
2356 copy(c, list)
2357 return c
2358 }
2359 func doCaseClauses(list []*CaseClause, do func(Node) bool) bool {
2360 for _, x := range list {
2361 if x != nil && do(x) {
2362 return true
2363 }
2364 }
2365 return false
2366 }
2367 func editCaseClauses(list []*CaseClause, edit func(Node) Node) {
2368 for i, x := range list {
2369 if x != nil {
2370 list[i] = edit(x).(*CaseClause)
2371 }
2372 }
2373 }
2374
2375 func copyCommClauses(list []*CommClause) []*CommClause {
2376 if list == nil {
2377 return nil
2378 }
2379 c := make([]*CommClause, len(list))
2380 copy(c, list)
2381 return c
2382 }
2383 func doCommClauses(list []*CommClause, do func(Node) bool) bool {
2384 for _, x := range list {
2385 if x != nil && do(x) {
2386 return true
2387 }
2388 }
2389 return false
2390 }
2391 func editCommClauses(list []*CommClause, edit func(Node) Node) {
2392 for i, x := range list {
2393 if x != nil {
2394 list[i] = edit(x).(*CommClause)
2395 }
2396 }
2397 }
2398
2399 func copyNames(list []*Name) []*Name {
2400 if list == nil {
2401 return nil
2402 }
2403 c := make([]*Name, len(list))
2404 copy(c, list)
2405 return c
2406 }
2407 func doNames(list []*Name, do func(Node) bool) bool {
2408 for _, x := range list {
2409 if x != nil && do(x) {
2410 return true
2411 }
2412 }
2413 return false
2414 }
2415 func editNames(list []*Name, edit func(Node) Node) {
2416 for i, x := range list {
2417 if x != nil {
2418 list[i] = edit(x).(*Name)
2419 }
2420 }
2421 }
2422
2423 func copyNodes(list []Node) []Node {
2424 if list == nil {
2425 return nil
2426 }
2427 c := make([]Node, len(list))
2428 copy(c, list)
2429 return c
2430 }
2431 func doNodes(list []Node, do func(Node) bool) bool {
2432 for _, x := range list {
2433 if x != nil && do(x) {
2434 return true
2435 }
2436 }
2437 return false
2438 }
2439 func editNodes(list []Node, edit func(Node) Node) {
2440 for i, x := range list {
2441 if x != nil {
2442 list[i] = edit(x).(Node)
2443 }
2444 }
2445 }
2446
View as plain text