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) editChildren(edit func(Node) Node) {
27 editNodes(n.init, edit)
28 editNodes(n.List, edit)
29 if n.Prealloc != nil {
30 n.Prealloc = edit(n.Prealloc).(*Name)
31 }
32 }
33 func (n *AddStringExpr) editChildrenWithHidden(edit func(Node) Node) {
34 editNodes(n.init, edit)
35 editNodes(n.List, edit)
36 if n.Prealloc != nil {
37 n.Prealloc = edit(n.Prealloc).(*Name)
38 }
39 }
40
41 func (n *AddrExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
42 func (n *AddrExpr) copy() Node {
43 c := *n
44 c.init = copyNodes(c.init)
45 return &c
46 }
47 func (n *AddrExpr) doChildren(do func(Node) bool) bool {
48 if doNodes(n.init, do) {
49 return true
50 }
51 if n.X != nil && do(n.X) {
52 return true
53 }
54 if n.Prealloc != nil && do(n.Prealloc) {
55 return true
56 }
57 return false
58 }
59 func (n *AddrExpr) editChildren(edit func(Node) Node) {
60 editNodes(n.init, edit)
61 if n.X != nil {
62 n.X = edit(n.X).(Node)
63 }
64 if n.Prealloc != nil {
65 n.Prealloc = edit(n.Prealloc).(*Name)
66 }
67 }
68 func (n *AddrExpr) editChildrenWithHidden(edit func(Node) Node) {
69 editNodes(n.init, edit)
70 if n.X != nil {
71 n.X = edit(n.X).(Node)
72 }
73 if n.Prealloc != nil {
74 n.Prealloc = edit(n.Prealloc).(*Name)
75 }
76 }
77
78 func (n *AssignListStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
79 func (n *AssignListStmt) copy() Node {
80 c := *n
81 c.init = copyNodes(c.init)
82 c.Lhs = copyNodes(c.Lhs)
83 c.Rhs = copyNodes(c.Rhs)
84 return &c
85 }
86 func (n *AssignListStmt) doChildren(do func(Node) bool) bool {
87 if doNodes(n.init, do) {
88 return true
89 }
90 if doNodes(n.Lhs, do) {
91 return true
92 }
93 if doNodes(n.Rhs, do) {
94 return true
95 }
96 return false
97 }
98 func (n *AssignListStmt) editChildren(edit func(Node) Node) {
99 editNodes(n.init, edit)
100 editNodes(n.Lhs, edit)
101 editNodes(n.Rhs, edit)
102 }
103 func (n *AssignListStmt) editChildrenWithHidden(edit func(Node) Node) {
104 editNodes(n.init, edit)
105 editNodes(n.Lhs, edit)
106 editNodes(n.Rhs, edit)
107 }
108
109 func (n *AssignOpStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
110 func (n *AssignOpStmt) copy() Node {
111 c := *n
112 c.init = copyNodes(c.init)
113 return &c
114 }
115 func (n *AssignOpStmt) doChildren(do func(Node) bool) bool {
116 if doNodes(n.init, do) {
117 return true
118 }
119 if n.X != nil && do(n.X) {
120 return true
121 }
122 if n.Y != nil && do(n.Y) {
123 return true
124 }
125 return false
126 }
127 func (n *AssignOpStmt) editChildren(edit func(Node) Node) {
128 editNodes(n.init, edit)
129 if n.X != nil {
130 n.X = edit(n.X).(Node)
131 }
132 if n.Y != nil {
133 n.Y = edit(n.Y).(Node)
134 }
135 }
136 func (n *AssignOpStmt) editChildrenWithHidden(edit func(Node) Node) {
137 editNodes(n.init, edit)
138 if n.X != nil {
139 n.X = edit(n.X).(Node)
140 }
141 if n.Y != nil {
142 n.Y = edit(n.Y).(Node)
143 }
144 }
145
146 func (n *AssignStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
147 func (n *AssignStmt) copy() Node {
148 c := *n
149 c.init = copyNodes(c.init)
150 return &c
151 }
152 func (n *AssignStmt) doChildren(do func(Node) bool) bool {
153 if doNodes(n.init, do) {
154 return true
155 }
156 if n.X != nil && do(n.X) {
157 return true
158 }
159 if n.Y != nil && do(n.Y) {
160 return true
161 }
162 return false
163 }
164 func (n *AssignStmt) editChildren(edit func(Node) Node) {
165 editNodes(n.init, edit)
166 if n.X != nil {
167 n.X = edit(n.X).(Node)
168 }
169 if n.Y != nil {
170 n.Y = edit(n.Y).(Node)
171 }
172 }
173 func (n *AssignStmt) editChildrenWithHidden(edit func(Node) Node) {
174 editNodes(n.init, edit)
175 if n.X != nil {
176 n.X = edit(n.X).(Node)
177 }
178 if n.Y != nil {
179 n.Y = edit(n.Y).(Node)
180 }
181 }
182
183 func (n *BasicLit) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
184 func (n *BasicLit) copy() Node {
185 c := *n
186 c.init = copyNodes(c.init)
187 return &c
188 }
189 func (n *BasicLit) doChildren(do func(Node) bool) bool {
190 if doNodes(n.init, do) {
191 return true
192 }
193 return false
194 }
195 func (n *BasicLit) editChildren(edit func(Node) Node) {
196 editNodes(n.init, edit)
197 }
198 func (n *BasicLit) editChildrenWithHidden(edit func(Node) Node) {
199 editNodes(n.init, edit)
200 }
201
202 func (n *BinaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
203 func (n *BinaryExpr) copy() Node {
204 c := *n
205 c.init = copyNodes(c.init)
206 return &c
207 }
208 func (n *BinaryExpr) doChildren(do func(Node) bool) bool {
209 if doNodes(n.init, do) {
210 return true
211 }
212 if n.X != nil && do(n.X) {
213 return true
214 }
215 if n.Y != nil && do(n.Y) {
216 return true
217 }
218 return false
219 }
220 func (n *BinaryExpr) editChildren(edit func(Node) Node) {
221 editNodes(n.init, edit)
222 if n.X != nil {
223 n.X = edit(n.X).(Node)
224 }
225 if n.Y != nil {
226 n.Y = edit(n.Y).(Node)
227 }
228 }
229 func (n *BinaryExpr) editChildrenWithHidden(edit func(Node) Node) {
230 editNodes(n.init, edit)
231 if n.X != nil {
232 n.X = edit(n.X).(Node)
233 }
234 if n.Y != nil {
235 n.Y = edit(n.Y).(Node)
236 }
237 if n.RType != nil {
238 n.RType = edit(n.RType).(Node)
239 }
240 }
241
242 func (n *BlockStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
243 func (n *BlockStmt) copy() Node {
244 c := *n
245 c.init = copyNodes(c.init)
246 c.List = copyNodes(c.List)
247 return &c
248 }
249 func (n *BlockStmt) doChildren(do func(Node) bool) bool {
250 if doNodes(n.init, do) {
251 return true
252 }
253 if doNodes(n.List, do) {
254 return true
255 }
256 return false
257 }
258 func (n *BlockStmt) editChildren(edit func(Node) Node) {
259 editNodes(n.init, edit)
260 editNodes(n.List, edit)
261 }
262 func (n *BlockStmt) editChildrenWithHidden(edit func(Node) Node) {
263 editNodes(n.init, edit)
264 editNodes(n.List, edit)
265 }
266
267 func (n *BranchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
268 func (n *BranchStmt) copy() Node {
269 c := *n
270 c.init = copyNodes(c.init)
271 return &c
272 }
273 func (n *BranchStmt) doChildren(do func(Node) bool) bool {
274 if doNodes(n.init, do) {
275 return true
276 }
277 return false
278 }
279 func (n *BranchStmt) editChildren(edit func(Node) Node) {
280 editNodes(n.init, edit)
281 }
282 func (n *BranchStmt) editChildrenWithHidden(edit func(Node) Node) {
283 editNodes(n.init, edit)
284 }
285
286 func (n *CallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
287 func (n *CallExpr) copy() Node {
288 c := *n
289 c.init = copyNodes(c.init)
290 c.Args = copyNodes(c.Args)
291 c.KeepAlive = copyNames(c.KeepAlive)
292 return &c
293 }
294 func (n *CallExpr) doChildren(do func(Node) bool) bool {
295 if doNodes(n.init, do) {
296 return true
297 }
298 if n.Fun != nil && do(n.Fun) {
299 return true
300 }
301 if doNodes(n.Args, do) {
302 return true
303 }
304 if doNames(n.KeepAlive, do) {
305 return true
306 }
307 return false
308 }
309 func (n *CallExpr) editChildren(edit func(Node) Node) {
310 editNodes(n.init, edit)
311 if n.Fun != nil {
312 n.Fun = edit(n.Fun).(Node)
313 }
314 editNodes(n.Args, edit)
315 editNames(n.KeepAlive, edit)
316 }
317 func (n *CallExpr) editChildrenWithHidden(edit func(Node) Node) {
318 editNodes(n.init, edit)
319 if n.Fun != nil {
320 n.Fun = edit(n.Fun).(Node)
321 }
322 editNodes(n.Args, edit)
323 if n.RType != nil {
324 n.RType = edit(n.RType).(Node)
325 }
326 editNames(n.KeepAlive, edit)
327 }
328
329 func (n *CaseClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
330 func (n *CaseClause) copy() Node {
331 c := *n
332 c.init = copyNodes(c.init)
333 c.List = copyNodes(c.List)
334 c.RTypes = copyNodes(c.RTypes)
335 c.Body = copyNodes(c.Body)
336 return &c
337 }
338 func (n *CaseClause) doChildren(do func(Node) bool) bool {
339 if doNodes(n.init, do) {
340 return true
341 }
342 if n.Var != nil && do(n.Var) {
343 return true
344 }
345 if doNodes(n.List, do) {
346 return true
347 }
348 if doNodes(n.RTypes, do) {
349 return true
350 }
351 if doNodes(n.Body, do) {
352 return true
353 }
354 return false
355 }
356 func (n *CaseClause) editChildren(edit func(Node) Node) {
357 editNodes(n.init, edit)
358 if n.Var != nil {
359 n.Var = edit(n.Var).(*Name)
360 }
361 editNodes(n.List, edit)
362 editNodes(n.RTypes, edit)
363 editNodes(n.Body, edit)
364 }
365 func (n *CaseClause) editChildrenWithHidden(edit func(Node) Node) {
366 editNodes(n.init, edit)
367 if n.Var != nil {
368 n.Var = edit(n.Var).(*Name)
369 }
370 editNodes(n.List, edit)
371 editNodes(n.RTypes, edit)
372 editNodes(n.Body, edit)
373 }
374
375 func (n *ClosureExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
376 func (n *ClosureExpr) copy() Node {
377 c := *n
378 c.init = copyNodes(c.init)
379 return &c
380 }
381 func (n *ClosureExpr) doChildren(do func(Node) bool) bool {
382 if doNodes(n.init, do) {
383 return true
384 }
385 if n.Prealloc != nil && do(n.Prealloc) {
386 return true
387 }
388 return false
389 }
390 func (n *ClosureExpr) editChildren(edit func(Node) Node) {
391 editNodes(n.init, edit)
392 if n.Prealloc != nil {
393 n.Prealloc = edit(n.Prealloc).(*Name)
394 }
395 }
396 func (n *ClosureExpr) editChildrenWithHidden(edit func(Node) Node) {
397 editNodes(n.init, edit)
398 if n.Prealloc != nil {
399 n.Prealloc = edit(n.Prealloc).(*Name)
400 }
401 }
402
403 func (n *CommClause) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
404 func (n *CommClause) copy() Node {
405 c := *n
406 c.init = copyNodes(c.init)
407 c.Body = copyNodes(c.Body)
408 return &c
409 }
410 func (n *CommClause) doChildren(do func(Node) bool) bool {
411 if doNodes(n.init, do) {
412 return true
413 }
414 if n.Comm != nil && do(n.Comm) {
415 return true
416 }
417 if doNodes(n.Body, do) {
418 return true
419 }
420 return false
421 }
422 func (n *CommClause) editChildren(edit func(Node) Node) {
423 editNodes(n.init, edit)
424 if n.Comm != nil {
425 n.Comm = edit(n.Comm).(Node)
426 }
427 editNodes(n.Body, edit)
428 }
429 func (n *CommClause) editChildrenWithHidden(edit func(Node) Node) {
430 editNodes(n.init, edit)
431 if n.Comm != nil {
432 n.Comm = edit(n.Comm).(Node)
433 }
434 editNodes(n.Body, edit)
435 }
436
437 func (n *CompLitExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
438 func (n *CompLitExpr) copy() Node {
439 c := *n
440 c.init = copyNodes(c.init)
441 c.List = copyNodes(c.List)
442 return &c
443 }
444 func (n *CompLitExpr) doChildren(do func(Node) bool) bool {
445 if doNodes(n.init, do) {
446 return true
447 }
448 if doNodes(n.List, do) {
449 return true
450 }
451 if n.Prealloc != nil && do(n.Prealloc) {
452 return true
453 }
454 return false
455 }
456 func (n *CompLitExpr) editChildren(edit func(Node) Node) {
457 editNodes(n.init, edit)
458 editNodes(n.List, edit)
459 if n.Prealloc != nil {
460 n.Prealloc = edit(n.Prealloc).(*Name)
461 }
462 }
463 func (n *CompLitExpr) editChildrenWithHidden(edit func(Node) Node) {
464 editNodes(n.init, edit)
465 editNodes(n.List, edit)
466 if n.RType != nil {
467 n.RType = edit(n.RType).(Node)
468 }
469 if n.Prealloc != nil {
470 n.Prealloc = edit(n.Prealloc).(*Name)
471 }
472 }
473
474 func (n *ConvExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
475 func (n *ConvExpr) copy() Node {
476 c := *n
477 c.init = copyNodes(c.init)
478 return &c
479 }
480 func (n *ConvExpr) doChildren(do func(Node) bool) bool {
481 if doNodes(n.init, do) {
482 return true
483 }
484 if n.X != nil && do(n.X) {
485 return true
486 }
487 return false
488 }
489 func (n *ConvExpr) editChildren(edit func(Node) Node) {
490 editNodes(n.init, edit)
491 if n.X != nil {
492 n.X = edit(n.X).(Node)
493 }
494 }
495 func (n *ConvExpr) editChildrenWithHidden(edit func(Node) Node) {
496 editNodes(n.init, edit)
497 if n.X != nil {
498 n.X = edit(n.X).(Node)
499 }
500 if n.TypeWord != nil {
501 n.TypeWord = edit(n.TypeWord).(Node)
502 }
503 if n.SrcRType != nil {
504 n.SrcRType = edit(n.SrcRType).(Node)
505 }
506 if n.ElemRType != nil {
507 n.ElemRType = edit(n.ElemRType).(Node)
508 }
509 if n.ElemElemRType != nil {
510 n.ElemElemRType = edit(n.ElemElemRType).(Node)
511 }
512 }
513
514 func (n *Decl) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
515 func (n *Decl) copy() Node {
516 c := *n
517 return &c
518 }
519 func (n *Decl) doChildren(do func(Node) bool) bool {
520 if n.X != nil && do(n.X) {
521 return true
522 }
523 return false
524 }
525 func (n *Decl) editChildren(edit func(Node) Node) {
526 if n.X != nil {
527 n.X = edit(n.X).(*Name)
528 }
529 }
530 func (n *Decl) editChildrenWithHidden(edit func(Node) Node) {
531 if n.X != nil {
532 n.X = edit(n.X).(*Name)
533 }
534 }
535
536 func (n *DynamicType) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
537 func (n *DynamicType) copy() Node {
538 c := *n
539 c.init = copyNodes(c.init)
540 return &c
541 }
542 func (n *DynamicType) doChildren(do func(Node) bool) bool {
543 if doNodes(n.init, do) {
544 return true
545 }
546 if n.RType != nil && do(n.RType) {
547 return true
548 }
549 if n.ITab != nil && do(n.ITab) {
550 return true
551 }
552 return false
553 }
554 func (n *DynamicType) editChildren(edit func(Node) Node) {
555 editNodes(n.init, edit)
556 if n.RType != nil {
557 n.RType = edit(n.RType).(Node)
558 }
559 if n.ITab != nil {
560 n.ITab = edit(n.ITab).(Node)
561 }
562 }
563 func (n *DynamicType) editChildrenWithHidden(edit func(Node) Node) {
564 editNodes(n.init, edit)
565 if n.RType != nil {
566 n.RType = edit(n.RType).(Node)
567 }
568 if n.ITab != nil {
569 n.ITab = edit(n.ITab).(Node)
570 }
571 }
572
573 func (n *DynamicTypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
574 func (n *DynamicTypeAssertExpr) copy() Node {
575 c := *n
576 c.init = copyNodes(c.init)
577 return &c
578 }
579 func (n *DynamicTypeAssertExpr) doChildren(do func(Node) bool) bool {
580 if doNodes(n.init, do) {
581 return true
582 }
583 if n.X != nil && do(n.X) {
584 return true
585 }
586 if n.SrcRType != nil && do(n.SrcRType) {
587 return true
588 }
589 if n.RType != nil && do(n.RType) {
590 return true
591 }
592 if n.ITab != nil && do(n.ITab) {
593 return true
594 }
595 return false
596 }
597 func (n *DynamicTypeAssertExpr) editChildren(edit func(Node) Node) {
598 editNodes(n.init, edit)
599 if n.X != nil {
600 n.X = edit(n.X).(Node)
601 }
602 if n.SrcRType != nil {
603 n.SrcRType = edit(n.SrcRType).(Node)
604 }
605 if n.RType != nil {
606 n.RType = edit(n.RType).(Node)
607 }
608 if n.ITab != nil {
609 n.ITab = edit(n.ITab).(Node)
610 }
611 }
612 func (n *DynamicTypeAssertExpr) editChildrenWithHidden(edit func(Node) Node) {
613 editNodes(n.init, edit)
614 if n.X != nil {
615 n.X = edit(n.X).(Node)
616 }
617 if n.SrcRType != nil {
618 n.SrcRType = edit(n.SrcRType).(Node)
619 }
620 if n.RType != nil {
621 n.RType = edit(n.RType).(Node)
622 }
623 if n.ITab != nil {
624 n.ITab = edit(n.ITab).(Node)
625 }
626 }
627
628 func (n *ForStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
629 func (n *ForStmt) copy() Node {
630 c := *n
631 c.init = copyNodes(c.init)
632 c.Body = copyNodes(c.Body)
633 return &c
634 }
635 func (n *ForStmt) doChildren(do func(Node) bool) bool {
636 if doNodes(n.init, do) {
637 return true
638 }
639 if n.Cond != nil && do(n.Cond) {
640 return true
641 }
642 if n.Post != nil && do(n.Post) {
643 return true
644 }
645 if doNodes(n.Body, do) {
646 return true
647 }
648 return false
649 }
650 func (n *ForStmt) editChildren(edit func(Node) Node) {
651 editNodes(n.init, edit)
652 if n.Cond != nil {
653 n.Cond = edit(n.Cond).(Node)
654 }
655 if n.Post != nil {
656 n.Post = edit(n.Post).(Node)
657 }
658 editNodes(n.Body, edit)
659 }
660 func (n *ForStmt) editChildrenWithHidden(edit func(Node) Node) {
661 editNodes(n.init, edit)
662 if n.Cond != nil {
663 n.Cond = edit(n.Cond).(Node)
664 }
665 if n.Post != nil {
666 n.Post = edit(n.Post).(Node)
667 }
668 editNodes(n.Body, edit)
669 }
670
671 func (n *Func) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
672
673 func (n *GoDeferStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
674 func (n *GoDeferStmt) copy() Node {
675 c := *n
676 c.init = copyNodes(c.init)
677 return &c
678 }
679 func (n *GoDeferStmt) doChildren(do func(Node) bool) bool {
680 if doNodes(n.init, do) {
681 return true
682 }
683 if n.Call != nil && do(n.Call) {
684 return true
685 }
686 return false
687 }
688 func (n *GoDeferStmt) editChildren(edit func(Node) Node) {
689 editNodes(n.init, edit)
690 if n.Call != nil {
691 n.Call = edit(n.Call).(Node)
692 }
693 }
694 func (n *GoDeferStmt) editChildrenWithHidden(edit func(Node) Node) {
695 editNodes(n.init, edit)
696 if n.Call != nil {
697 n.Call = edit(n.Call).(Node)
698 }
699 }
700
701 func (n *Ident) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
702 func (n *Ident) copy() Node {
703 c := *n
704 c.init = copyNodes(c.init)
705 return &c
706 }
707 func (n *Ident) doChildren(do func(Node) bool) bool {
708 if doNodes(n.init, do) {
709 return true
710 }
711 return false
712 }
713 func (n *Ident) editChildren(edit func(Node) Node) {
714 editNodes(n.init, edit)
715 }
716 func (n *Ident) editChildrenWithHidden(edit func(Node) Node) {
717 editNodes(n.init, edit)
718 }
719
720 func (n *IfStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
721 func (n *IfStmt) copy() Node {
722 c := *n
723 c.init = copyNodes(c.init)
724 c.Body = copyNodes(c.Body)
725 c.Else = copyNodes(c.Else)
726 return &c
727 }
728 func (n *IfStmt) doChildren(do func(Node) bool) bool {
729 if doNodes(n.init, do) {
730 return true
731 }
732 if n.Cond != nil && do(n.Cond) {
733 return true
734 }
735 if doNodes(n.Body, do) {
736 return true
737 }
738 if doNodes(n.Else, do) {
739 return true
740 }
741 return false
742 }
743 func (n *IfStmt) editChildren(edit func(Node) Node) {
744 editNodes(n.init, edit)
745 if n.Cond != nil {
746 n.Cond = edit(n.Cond).(Node)
747 }
748 editNodes(n.Body, edit)
749 editNodes(n.Else, edit)
750 }
751 func (n *IfStmt) editChildrenWithHidden(edit func(Node) Node) {
752 editNodes(n.init, edit)
753 if n.Cond != nil {
754 n.Cond = edit(n.Cond).(Node)
755 }
756 editNodes(n.Body, edit)
757 editNodes(n.Else, edit)
758 }
759
760 func (n *IndexExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
761 func (n *IndexExpr) copy() Node {
762 c := *n
763 c.init = copyNodes(c.init)
764 return &c
765 }
766 func (n *IndexExpr) doChildren(do func(Node) bool) bool {
767 if doNodes(n.init, do) {
768 return true
769 }
770 if n.X != nil && do(n.X) {
771 return true
772 }
773 if n.Index != nil && do(n.Index) {
774 return true
775 }
776 return false
777 }
778 func (n *IndexExpr) editChildren(edit func(Node) Node) {
779 editNodes(n.init, edit)
780 if n.X != nil {
781 n.X = edit(n.X).(Node)
782 }
783 if n.Index != nil {
784 n.Index = edit(n.Index).(Node)
785 }
786 }
787 func (n *IndexExpr) editChildrenWithHidden(edit func(Node) Node) {
788 editNodes(n.init, edit)
789 if n.X != nil {
790 n.X = edit(n.X).(Node)
791 }
792 if n.Index != nil {
793 n.Index = edit(n.Index).(Node)
794 }
795 if n.RType != nil {
796 n.RType = edit(n.RType).(Node)
797 }
798 }
799
800 func (n *InlineMarkStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
801 func (n *InlineMarkStmt) copy() Node {
802 c := *n
803 c.init = copyNodes(c.init)
804 return &c
805 }
806 func (n *InlineMarkStmt) doChildren(do func(Node) bool) bool {
807 if doNodes(n.init, do) {
808 return true
809 }
810 return false
811 }
812 func (n *InlineMarkStmt) editChildren(edit func(Node) Node) {
813 editNodes(n.init, edit)
814 }
815 func (n *InlineMarkStmt) editChildrenWithHidden(edit func(Node) Node) {
816 editNodes(n.init, edit)
817 }
818
819 func (n *InlinedCallExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
820 func (n *InlinedCallExpr) copy() Node {
821 c := *n
822 c.init = copyNodes(c.init)
823 c.Body = copyNodes(c.Body)
824 c.ReturnVars = copyNodes(c.ReturnVars)
825 return &c
826 }
827 func (n *InlinedCallExpr) doChildren(do func(Node) bool) bool {
828 if doNodes(n.init, do) {
829 return true
830 }
831 if doNodes(n.Body, do) {
832 return true
833 }
834 if doNodes(n.ReturnVars, do) {
835 return true
836 }
837 return false
838 }
839 func (n *InlinedCallExpr) editChildren(edit func(Node) Node) {
840 editNodes(n.init, edit)
841 editNodes(n.Body, edit)
842 editNodes(n.ReturnVars, edit)
843 }
844 func (n *InlinedCallExpr) editChildrenWithHidden(edit func(Node) Node) {
845 editNodes(n.init, edit)
846 editNodes(n.Body, edit)
847 editNodes(n.ReturnVars, edit)
848 }
849
850 func (n *InterfaceSwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
851 func (n *InterfaceSwitchStmt) copy() Node {
852 c := *n
853 c.init = copyNodes(c.init)
854 return &c
855 }
856 func (n *InterfaceSwitchStmt) doChildren(do func(Node) bool) bool {
857 if doNodes(n.init, do) {
858 return true
859 }
860 if n.Case != nil && do(n.Case) {
861 return true
862 }
863 if n.Itab != nil && do(n.Itab) {
864 return true
865 }
866 if n.RuntimeType != nil && do(n.RuntimeType) {
867 return true
868 }
869 return false
870 }
871 func (n *InterfaceSwitchStmt) editChildren(edit func(Node) Node) {
872 editNodes(n.init, edit)
873 if n.Case != nil {
874 n.Case = edit(n.Case).(Node)
875 }
876 if n.Itab != nil {
877 n.Itab = edit(n.Itab).(Node)
878 }
879 if n.RuntimeType != nil {
880 n.RuntimeType = edit(n.RuntimeType).(Node)
881 }
882 }
883 func (n *InterfaceSwitchStmt) editChildrenWithHidden(edit func(Node) Node) {
884 editNodes(n.init, edit)
885 if n.Case != nil {
886 n.Case = edit(n.Case).(Node)
887 }
888 if n.Itab != nil {
889 n.Itab = edit(n.Itab).(Node)
890 }
891 if n.RuntimeType != nil {
892 n.RuntimeType = edit(n.RuntimeType).(Node)
893 }
894 }
895
896 func (n *JumpTableStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
897 func (n *JumpTableStmt) copy() Node {
898 c := *n
899 c.init = copyNodes(c.init)
900 return &c
901 }
902 func (n *JumpTableStmt) doChildren(do func(Node) bool) bool {
903 if doNodes(n.init, do) {
904 return true
905 }
906 if n.Idx != nil && do(n.Idx) {
907 return true
908 }
909 return false
910 }
911 func (n *JumpTableStmt) editChildren(edit func(Node) Node) {
912 editNodes(n.init, edit)
913 if n.Idx != nil {
914 n.Idx = edit(n.Idx).(Node)
915 }
916 }
917 func (n *JumpTableStmt) editChildrenWithHidden(edit func(Node) Node) {
918 editNodes(n.init, edit)
919 if n.Idx != nil {
920 n.Idx = edit(n.Idx).(Node)
921 }
922 }
923
924 func (n *KeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
925 func (n *KeyExpr) copy() Node {
926 c := *n
927 c.init = copyNodes(c.init)
928 return &c
929 }
930 func (n *KeyExpr) doChildren(do func(Node) bool) bool {
931 if doNodes(n.init, do) {
932 return true
933 }
934 if n.Key != nil && do(n.Key) {
935 return true
936 }
937 if n.Value != nil && do(n.Value) {
938 return true
939 }
940 return false
941 }
942 func (n *KeyExpr) editChildren(edit func(Node) Node) {
943 editNodes(n.init, edit)
944 if n.Key != nil {
945 n.Key = edit(n.Key).(Node)
946 }
947 if n.Value != nil {
948 n.Value = edit(n.Value).(Node)
949 }
950 }
951 func (n *KeyExpr) editChildrenWithHidden(edit func(Node) Node) {
952 editNodes(n.init, edit)
953 if n.Key != nil {
954 n.Key = edit(n.Key).(Node)
955 }
956 if n.Value != nil {
957 n.Value = edit(n.Value).(Node)
958 }
959 }
960
961 func (n *LabelStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
962 func (n *LabelStmt) copy() Node {
963 c := *n
964 c.init = copyNodes(c.init)
965 return &c
966 }
967 func (n *LabelStmt) doChildren(do func(Node) bool) bool {
968 if doNodes(n.init, do) {
969 return true
970 }
971 return false
972 }
973 func (n *LabelStmt) editChildren(edit func(Node) Node) {
974 editNodes(n.init, edit)
975 }
976 func (n *LabelStmt) editChildrenWithHidden(edit func(Node) Node) {
977 editNodes(n.init, edit)
978 }
979
980 func (n *LinksymOffsetExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
981 func (n *LinksymOffsetExpr) copy() Node {
982 c := *n
983 c.init = copyNodes(c.init)
984 return &c
985 }
986 func (n *LinksymOffsetExpr) doChildren(do func(Node) bool) bool {
987 if doNodes(n.init, do) {
988 return true
989 }
990 return false
991 }
992 func (n *LinksymOffsetExpr) editChildren(edit func(Node) Node) {
993 editNodes(n.init, edit)
994 }
995 func (n *LinksymOffsetExpr) editChildrenWithHidden(edit func(Node) Node) {
996 editNodes(n.init, edit)
997 }
998
999 func (n *LogicalExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1000 func (n *LogicalExpr) copy() Node {
1001 c := *n
1002 c.init = copyNodes(c.init)
1003 return &c
1004 }
1005 func (n *LogicalExpr) doChildren(do func(Node) bool) bool {
1006 if doNodes(n.init, do) {
1007 return true
1008 }
1009 if n.X != nil && do(n.X) {
1010 return true
1011 }
1012 if n.Y != nil && do(n.Y) {
1013 return true
1014 }
1015 return false
1016 }
1017 func (n *LogicalExpr) editChildren(edit func(Node) Node) {
1018 editNodes(n.init, edit)
1019 if n.X != nil {
1020 n.X = edit(n.X).(Node)
1021 }
1022 if n.Y != nil {
1023 n.Y = edit(n.Y).(Node)
1024 }
1025 }
1026 func (n *LogicalExpr) editChildrenWithHidden(edit func(Node) Node) {
1027 editNodes(n.init, edit)
1028 if n.X != nil {
1029 n.X = edit(n.X).(Node)
1030 }
1031 if n.Y != nil {
1032 n.Y = edit(n.Y).(Node)
1033 }
1034 }
1035
1036 func (n *MakeExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1037 func (n *MakeExpr) copy() Node {
1038 c := *n
1039 c.init = copyNodes(c.init)
1040 return &c
1041 }
1042 func (n *MakeExpr) doChildren(do func(Node) bool) bool {
1043 if doNodes(n.init, do) {
1044 return true
1045 }
1046 if n.Len != nil && do(n.Len) {
1047 return true
1048 }
1049 if n.Cap != nil && do(n.Cap) {
1050 return true
1051 }
1052 return false
1053 }
1054 func (n *MakeExpr) editChildren(edit func(Node) Node) {
1055 editNodes(n.init, edit)
1056 if n.Len != nil {
1057 n.Len = edit(n.Len).(Node)
1058 }
1059 if n.Cap != nil {
1060 n.Cap = edit(n.Cap).(Node)
1061 }
1062 }
1063 func (n *MakeExpr) editChildrenWithHidden(edit func(Node) Node) {
1064 editNodes(n.init, edit)
1065 if n.RType != nil {
1066 n.RType = edit(n.RType).(Node)
1067 }
1068 if n.Len != nil {
1069 n.Len = edit(n.Len).(Node)
1070 }
1071 if n.Cap != nil {
1072 n.Cap = edit(n.Cap).(Node)
1073 }
1074 }
1075
1076 func (n *Name) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1077
1078 func (n *NilExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1079 func (n *NilExpr) copy() Node {
1080 c := *n
1081 c.init = copyNodes(c.init)
1082 return &c
1083 }
1084 func (n *NilExpr) doChildren(do func(Node) bool) bool {
1085 if doNodes(n.init, do) {
1086 return true
1087 }
1088 return false
1089 }
1090 func (n *NilExpr) editChildren(edit func(Node) Node) {
1091 editNodes(n.init, edit)
1092 }
1093 func (n *NilExpr) editChildrenWithHidden(edit func(Node) Node) {
1094 editNodes(n.init, edit)
1095 }
1096
1097 func (n *ParenExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1098 func (n *ParenExpr) copy() Node {
1099 c := *n
1100 c.init = copyNodes(c.init)
1101 return &c
1102 }
1103 func (n *ParenExpr) doChildren(do func(Node) bool) bool {
1104 if doNodes(n.init, do) {
1105 return true
1106 }
1107 if n.X != nil && do(n.X) {
1108 return true
1109 }
1110 return false
1111 }
1112 func (n *ParenExpr) editChildren(edit func(Node) Node) {
1113 editNodes(n.init, edit)
1114 if n.X != nil {
1115 n.X = edit(n.X).(Node)
1116 }
1117 }
1118 func (n *ParenExpr) editChildrenWithHidden(edit func(Node) Node) {
1119 editNodes(n.init, edit)
1120 if n.X != nil {
1121 n.X = edit(n.X).(Node)
1122 }
1123 }
1124
1125 func (n *RangeStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1126 func (n *RangeStmt) copy() Node {
1127 c := *n
1128 c.init = copyNodes(c.init)
1129 c.Body = copyNodes(c.Body)
1130 return &c
1131 }
1132 func (n *RangeStmt) doChildren(do func(Node) bool) bool {
1133 if doNodes(n.init, do) {
1134 return true
1135 }
1136 if n.X != nil && do(n.X) {
1137 return true
1138 }
1139 if n.Key != nil && do(n.Key) {
1140 return true
1141 }
1142 if n.Value != nil && do(n.Value) {
1143 return true
1144 }
1145 if doNodes(n.Body, do) {
1146 return true
1147 }
1148 if n.Prealloc != nil && do(n.Prealloc) {
1149 return true
1150 }
1151 return false
1152 }
1153 func (n *RangeStmt) editChildren(edit func(Node) Node) {
1154 editNodes(n.init, edit)
1155 if n.X != nil {
1156 n.X = edit(n.X).(Node)
1157 }
1158 if n.Key != nil {
1159 n.Key = edit(n.Key).(Node)
1160 }
1161 if n.Value != nil {
1162 n.Value = edit(n.Value).(Node)
1163 }
1164 editNodes(n.Body, edit)
1165 if n.Prealloc != nil {
1166 n.Prealloc = edit(n.Prealloc).(*Name)
1167 }
1168 }
1169 func (n *RangeStmt) editChildrenWithHidden(edit func(Node) Node) {
1170 editNodes(n.init, edit)
1171 if n.X != nil {
1172 n.X = edit(n.X).(Node)
1173 }
1174 if n.RType != nil {
1175 n.RType = edit(n.RType).(Node)
1176 }
1177 if n.Key != nil {
1178 n.Key = edit(n.Key).(Node)
1179 }
1180 if n.Value != nil {
1181 n.Value = edit(n.Value).(Node)
1182 }
1183 editNodes(n.Body, edit)
1184 if n.Prealloc != nil {
1185 n.Prealloc = edit(n.Prealloc).(*Name)
1186 }
1187 if n.KeyTypeWord != nil {
1188 n.KeyTypeWord = edit(n.KeyTypeWord).(Node)
1189 }
1190 if n.KeySrcRType != nil {
1191 n.KeySrcRType = edit(n.KeySrcRType).(Node)
1192 }
1193 if n.ValueTypeWord != nil {
1194 n.ValueTypeWord = edit(n.ValueTypeWord).(Node)
1195 }
1196 if n.ValueSrcRType != nil {
1197 n.ValueSrcRType = edit(n.ValueSrcRType).(Node)
1198 }
1199 }
1200
1201 func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1202 func (n *ResultExpr) copy() Node {
1203 c := *n
1204 c.init = copyNodes(c.init)
1205 return &c
1206 }
1207 func (n *ResultExpr) doChildren(do func(Node) bool) bool {
1208 if doNodes(n.init, do) {
1209 return true
1210 }
1211 return false
1212 }
1213 func (n *ResultExpr) editChildren(edit func(Node) Node) {
1214 editNodes(n.init, edit)
1215 }
1216 func (n *ResultExpr) editChildrenWithHidden(edit func(Node) Node) {
1217 editNodes(n.init, edit)
1218 }
1219
1220 func (n *ReturnStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1221 func (n *ReturnStmt) copy() Node {
1222 c := *n
1223 c.init = copyNodes(c.init)
1224 c.Results = copyNodes(c.Results)
1225 return &c
1226 }
1227 func (n *ReturnStmt) doChildren(do func(Node) bool) bool {
1228 if doNodes(n.init, do) {
1229 return true
1230 }
1231 if doNodes(n.Results, do) {
1232 return true
1233 }
1234 return false
1235 }
1236 func (n *ReturnStmt) editChildren(edit func(Node) Node) {
1237 editNodes(n.init, edit)
1238 editNodes(n.Results, edit)
1239 }
1240 func (n *ReturnStmt) editChildrenWithHidden(edit func(Node) Node) {
1241 editNodes(n.init, edit)
1242 editNodes(n.Results, edit)
1243 }
1244
1245 func (n *SelectStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1246 func (n *SelectStmt) copy() Node {
1247 c := *n
1248 c.init = copyNodes(c.init)
1249 c.Cases = copyCommClauses(c.Cases)
1250 c.Compiled = copyNodes(c.Compiled)
1251 return &c
1252 }
1253 func (n *SelectStmt) doChildren(do func(Node) bool) bool {
1254 if doNodes(n.init, do) {
1255 return true
1256 }
1257 if doCommClauses(n.Cases, do) {
1258 return true
1259 }
1260 if doNodes(n.Compiled, do) {
1261 return true
1262 }
1263 return false
1264 }
1265 func (n *SelectStmt) editChildren(edit func(Node) Node) {
1266 editNodes(n.init, edit)
1267 editCommClauses(n.Cases, edit)
1268 editNodes(n.Compiled, edit)
1269 }
1270 func (n *SelectStmt) editChildrenWithHidden(edit func(Node) Node) {
1271 editNodes(n.init, edit)
1272 editCommClauses(n.Cases, edit)
1273 editNodes(n.Compiled, edit)
1274 }
1275
1276 func (n *SelectorExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1277 func (n *SelectorExpr) copy() Node {
1278 c := *n
1279 c.init = copyNodes(c.init)
1280 return &c
1281 }
1282 func (n *SelectorExpr) doChildren(do func(Node) bool) bool {
1283 if doNodes(n.init, do) {
1284 return true
1285 }
1286 if n.X != nil && do(n.X) {
1287 return true
1288 }
1289 if n.Prealloc != nil && do(n.Prealloc) {
1290 return true
1291 }
1292 return false
1293 }
1294 func (n *SelectorExpr) editChildren(edit func(Node) Node) {
1295 editNodes(n.init, edit)
1296 if n.X != nil {
1297 n.X = edit(n.X).(Node)
1298 }
1299 if n.Prealloc != nil {
1300 n.Prealloc = edit(n.Prealloc).(*Name)
1301 }
1302 }
1303 func (n *SelectorExpr) editChildrenWithHidden(edit func(Node) Node) {
1304 editNodes(n.init, edit)
1305 if n.X != nil {
1306 n.X = edit(n.X).(Node)
1307 }
1308 if n.Prealloc != nil {
1309 n.Prealloc = edit(n.Prealloc).(*Name)
1310 }
1311 }
1312
1313 func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1314 func (n *SendStmt) copy() Node {
1315 c := *n
1316 c.init = copyNodes(c.init)
1317 return &c
1318 }
1319 func (n *SendStmt) doChildren(do func(Node) bool) bool {
1320 if doNodes(n.init, do) {
1321 return true
1322 }
1323 if n.Chan != nil && do(n.Chan) {
1324 return true
1325 }
1326 if n.Value != nil && do(n.Value) {
1327 return true
1328 }
1329 return false
1330 }
1331 func (n *SendStmt) editChildren(edit func(Node) Node) {
1332 editNodes(n.init, edit)
1333 if n.Chan != nil {
1334 n.Chan = edit(n.Chan).(Node)
1335 }
1336 if n.Value != nil {
1337 n.Value = edit(n.Value).(Node)
1338 }
1339 }
1340 func (n *SendStmt) editChildrenWithHidden(edit func(Node) Node) {
1341 editNodes(n.init, edit)
1342 if n.Chan != nil {
1343 n.Chan = edit(n.Chan).(Node)
1344 }
1345 if n.Value != nil {
1346 n.Value = edit(n.Value).(Node)
1347 }
1348 }
1349
1350 func (n *SliceExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1351 func (n *SliceExpr) copy() Node {
1352 c := *n
1353 c.init = copyNodes(c.init)
1354 return &c
1355 }
1356 func (n *SliceExpr) doChildren(do func(Node) bool) bool {
1357 if doNodes(n.init, do) {
1358 return true
1359 }
1360 if n.X != nil && do(n.X) {
1361 return true
1362 }
1363 if n.Low != nil && do(n.Low) {
1364 return true
1365 }
1366 if n.High != nil && do(n.High) {
1367 return true
1368 }
1369 if n.Max != nil && do(n.Max) {
1370 return true
1371 }
1372 return false
1373 }
1374 func (n *SliceExpr) editChildren(edit func(Node) Node) {
1375 editNodes(n.init, edit)
1376 if n.X != nil {
1377 n.X = edit(n.X).(Node)
1378 }
1379 if n.Low != nil {
1380 n.Low = edit(n.Low).(Node)
1381 }
1382 if n.High != nil {
1383 n.High = edit(n.High).(Node)
1384 }
1385 if n.Max != nil {
1386 n.Max = edit(n.Max).(Node)
1387 }
1388 }
1389 func (n *SliceExpr) editChildrenWithHidden(edit func(Node) Node) {
1390 editNodes(n.init, edit)
1391 if n.X != nil {
1392 n.X = edit(n.X).(Node)
1393 }
1394 if n.Low != nil {
1395 n.Low = edit(n.Low).(Node)
1396 }
1397 if n.High != nil {
1398 n.High = edit(n.High).(Node)
1399 }
1400 if n.Max != nil {
1401 n.Max = edit(n.Max).(Node)
1402 }
1403 }
1404
1405 func (n *SliceHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1406 func (n *SliceHeaderExpr) copy() Node {
1407 c := *n
1408 c.init = copyNodes(c.init)
1409 return &c
1410 }
1411 func (n *SliceHeaderExpr) doChildren(do func(Node) bool) bool {
1412 if doNodes(n.init, do) {
1413 return true
1414 }
1415 if n.Ptr != nil && do(n.Ptr) {
1416 return true
1417 }
1418 if n.Len != nil && do(n.Len) {
1419 return true
1420 }
1421 if n.Cap != nil && do(n.Cap) {
1422 return true
1423 }
1424 return false
1425 }
1426 func (n *SliceHeaderExpr) editChildren(edit func(Node) Node) {
1427 editNodes(n.init, edit)
1428 if n.Ptr != nil {
1429 n.Ptr = edit(n.Ptr).(Node)
1430 }
1431 if n.Len != nil {
1432 n.Len = edit(n.Len).(Node)
1433 }
1434 if n.Cap != nil {
1435 n.Cap = edit(n.Cap).(Node)
1436 }
1437 }
1438 func (n *SliceHeaderExpr) editChildrenWithHidden(edit func(Node) Node) {
1439 editNodes(n.init, edit)
1440 if n.Ptr != nil {
1441 n.Ptr = edit(n.Ptr).(Node)
1442 }
1443 if n.Len != nil {
1444 n.Len = edit(n.Len).(Node)
1445 }
1446 if n.Cap != nil {
1447 n.Cap = edit(n.Cap).(Node)
1448 }
1449 }
1450
1451 func (n *StarExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1452 func (n *StarExpr) copy() Node {
1453 c := *n
1454 c.init = copyNodes(c.init)
1455 return &c
1456 }
1457 func (n *StarExpr) doChildren(do func(Node) bool) bool {
1458 if doNodes(n.init, do) {
1459 return true
1460 }
1461 if n.X != nil && do(n.X) {
1462 return true
1463 }
1464 return false
1465 }
1466 func (n *StarExpr) editChildren(edit func(Node) Node) {
1467 editNodes(n.init, edit)
1468 if n.X != nil {
1469 n.X = edit(n.X).(Node)
1470 }
1471 }
1472 func (n *StarExpr) editChildrenWithHidden(edit func(Node) Node) {
1473 editNodes(n.init, edit)
1474 if n.X != nil {
1475 n.X = edit(n.X).(Node)
1476 }
1477 }
1478
1479 func (n *StringHeaderExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1480 func (n *StringHeaderExpr) copy() Node {
1481 c := *n
1482 c.init = copyNodes(c.init)
1483 return &c
1484 }
1485 func (n *StringHeaderExpr) doChildren(do func(Node) bool) bool {
1486 if doNodes(n.init, do) {
1487 return true
1488 }
1489 if n.Ptr != nil && do(n.Ptr) {
1490 return true
1491 }
1492 if n.Len != nil && do(n.Len) {
1493 return true
1494 }
1495 return false
1496 }
1497 func (n *StringHeaderExpr) editChildren(edit func(Node) Node) {
1498 editNodes(n.init, edit)
1499 if n.Ptr != nil {
1500 n.Ptr = edit(n.Ptr).(Node)
1501 }
1502 if n.Len != nil {
1503 n.Len = edit(n.Len).(Node)
1504 }
1505 }
1506 func (n *StringHeaderExpr) editChildrenWithHidden(edit func(Node) Node) {
1507 editNodes(n.init, edit)
1508 if n.Ptr != nil {
1509 n.Ptr = edit(n.Ptr).(Node)
1510 }
1511 if n.Len != nil {
1512 n.Len = edit(n.Len).(Node)
1513 }
1514 }
1515
1516 func (n *StructKeyExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1517 func (n *StructKeyExpr) copy() Node {
1518 c := *n
1519 c.init = copyNodes(c.init)
1520 return &c
1521 }
1522 func (n *StructKeyExpr) doChildren(do func(Node) bool) bool {
1523 if doNodes(n.init, do) {
1524 return true
1525 }
1526 if n.Value != nil && do(n.Value) {
1527 return true
1528 }
1529 return false
1530 }
1531 func (n *StructKeyExpr) editChildren(edit func(Node) Node) {
1532 editNodes(n.init, edit)
1533 if n.Value != nil {
1534 n.Value = edit(n.Value).(Node)
1535 }
1536 }
1537 func (n *StructKeyExpr) editChildrenWithHidden(edit func(Node) Node) {
1538 editNodes(n.init, edit)
1539 if n.Value != nil {
1540 n.Value = edit(n.Value).(Node)
1541 }
1542 }
1543
1544 func (n *SwitchStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1545 func (n *SwitchStmt) copy() Node {
1546 c := *n
1547 c.init = copyNodes(c.init)
1548 c.Cases = copyCaseClauses(c.Cases)
1549 c.Compiled = copyNodes(c.Compiled)
1550 return &c
1551 }
1552 func (n *SwitchStmt) doChildren(do func(Node) bool) bool {
1553 if doNodes(n.init, do) {
1554 return true
1555 }
1556 if n.Tag != nil && do(n.Tag) {
1557 return true
1558 }
1559 if doCaseClauses(n.Cases, do) {
1560 return true
1561 }
1562 if doNodes(n.Compiled, do) {
1563 return true
1564 }
1565 return false
1566 }
1567 func (n *SwitchStmt) editChildren(edit func(Node) Node) {
1568 editNodes(n.init, edit)
1569 if n.Tag != nil {
1570 n.Tag = edit(n.Tag).(Node)
1571 }
1572 editCaseClauses(n.Cases, edit)
1573 editNodes(n.Compiled, edit)
1574 }
1575 func (n *SwitchStmt) editChildrenWithHidden(edit func(Node) Node) {
1576 editNodes(n.init, edit)
1577 if n.Tag != nil {
1578 n.Tag = edit(n.Tag).(Node)
1579 }
1580 editCaseClauses(n.Cases, edit)
1581 editNodes(n.Compiled, edit)
1582 }
1583
1584 func (n *TailCallStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1585 func (n *TailCallStmt) copy() Node {
1586 c := *n
1587 c.init = copyNodes(c.init)
1588 return &c
1589 }
1590 func (n *TailCallStmt) doChildren(do func(Node) bool) bool {
1591 if doNodes(n.init, do) {
1592 return true
1593 }
1594 if n.Call != nil && do(n.Call) {
1595 return true
1596 }
1597 return false
1598 }
1599 func (n *TailCallStmt) editChildren(edit func(Node) Node) {
1600 editNodes(n.init, edit)
1601 if n.Call != nil {
1602 n.Call = edit(n.Call).(*CallExpr)
1603 }
1604 }
1605 func (n *TailCallStmt) editChildrenWithHidden(edit func(Node) Node) {
1606 editNodes(n.init, edit)
1607 if n.Call != nil {
1608 n.Call = edit(n.Call).(*CallExpr)
1609 }
1610 }
1611
1612 func (n *TypeAssertExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1613 func (n *TypeAssertExpr) copy() Node {
1614 c := *n
1615 c.init = copyNodes(c.init)
1616 return &c
1617 }
1618 func (n *TypeAssertExpr) doChildren(do func(Node) bool) bool {
1619 if doNodes(n.init, do) {
1620 return true
1621 }
1622 if n.X != nil && do(n.X) {
1623 return true
1624 }
1625 return false
1626 }
1627 func (n *TypeAssertExpr) editChildren(edit func(Node) Node) {
1628 editNodes(n.init, edit)
1629 if n.X != nil {
1630 n.X = edit(n.X).(Node)
1631 }
1632 }
1633 func (n *TypeAssertExpr) editChildrenWithHidden(edit func(Node) Node) {
1634 editNodes(n.init, edit)
1635 if n.X != nil {
1636 n.X = edit(n.X).(Node)
1637 }
1638 if n.ITab != nil {
1639 n.ITab = edit(n.ITab).(Node)
1640 }
1641 }
1642
1643 func (n *TypeSwitchGuard) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1644 func (n *TypeSwitchGuard) copy() Node {
1645 c := *n
1646 return &c
1647 }
1648 func (n *TypeSwitchGuard) doChildren(do func(Node) bool) bool {
1649 if n.Tag != nil && do(n.Tag) {
1650 return true
1651 }
1652 if n.X != nil && do(n.X) {
1653 return true
1654 }
1655 return false
1656 }
1657 func (n *TypeSwitchGuard) editChildren(edit func(Node) Node) {
1658 if n.Tag != nil {
1659 n.Tag = edit(n.Tag).(*Ident)
1660 }
1661 if n.X != nil {
1662 n.X = edit(n.X).(Node)
1663 }
1664 }
1665 func (n *TypeSwitchGuard) editChildrenWithHidden(edit func(Node) Node) {
1666 if n.Tag != nil {
1667 n.Tag = edit(n.Tag).(*Ident)
1668 }
1669 if n.X != nil {
1670 n.X = edit(n.X).(Node)
1671 }
1672 }
1673
1674 func (n *UnaryExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1675 func (n *UnaryExpr) copy() Node {
1676 c := *n
1677 c.init = copyNodes(c.init)
1678 return &c
1679 }
1680 func (n *UnaryExpr) doChildren(do func(Node) bool) bool {
1681 if doNodes(n.init, do) {
1682 return true
1683 }
1684 if n.X != nil && do(n.X) {
1685 return true
1686 }
1687 return false
1688 }
1689 func (n *UnaryExpr) editChildren(edit func(Node) Node) {
1690 editNodes(n.init, edit)
1691 if n.X != nil {
1692 n.X = edit(n.X).(Node)
1693 }
1694 }
1695 func (n *UnaryExpr) editChildrenWithHidden(edit func(Node) Node) {
1696 editNodes(n.init, edit)
1697 if n.X != nil {
1698 n.X = edit(n.X).(Node)
1699 }
1700 }
1701
1702 func (n *typeNode) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
1703 func (n *typeNode) copy() Node {
1704 c := *n
1705 return &c
1706 }
1707 func (n *typeNode) doChildren(do func(Node) bool) bool {
1708 return false
1709 }
1710 func (n *typeNode) editChildren(edit func(Node) Node) {
1711 }
1712 func (n *typeNode) editChildrenWithHidden(edit func(Node) Node) {
1713 }
1714
1715 func copyCaseClauses(list []*CaseClause) []*CaseClause {
1716 if list == nil {
1717 return nil
1718 }
1719 c := make([]*CaseClause, len(list))
1720 copy(c, list)
1721 return c
1722 }
1723 func doCaseClauses(list []*CaseClause, do func(Node) bool) bool {
1724 for _, x := range list {
1725 if x != nil && do(x) {
1726 return true
1727 }
1728 }
1729 return false
1730 }
1731 func editCaseClauses(list []*CaseClause, edit func(Node) Node) {
1732 for i, x := range list {
1733 if x != nil {
1734 list[i] = edit(x).(*CaseClause)
1735 }
1736 }
1737 }
1738
1739 func copyCommClauses(list []*CommClause) []*CommClause {
1740 if list == nil {
1741 return nil
1742 }
1743 c := make([]*CommClause, len(list))
1744 copy(c, list)
1745 return c
1746 }
1747 func doCommClauses(list []*CommClause, do func(Node) bool) bool {
1748 for _, x := range list {
1749 if x != nil && do(x) {
1750 return true
1751 }
1752 }
1753 return false
1754 }
1755 func editCommClauses(list []*CommClause, edit func(Node) Node) {
1756 for i, x := range list {
1757 if x != nil {
1758 list[i] = edit(x).(*CommClause)
1759 }
1760 }
1761 }
1762
1763 func copyNames(list []*Name) []*Name {
1764 if list == nil {
1765 return nil
1766 }
1767 c := make([]*Name, len(list))
1768 copy(c, list)
1769 return c
1770 }
1771 func doNames(list []*Name, do func(Node) bool) bool {
1772 for _, x := range list {
1773 if x != nil && do(x) {
1774 return true
1775 }
1776 }
1777 return false
1778 }
1779 func editNames(list []*Name, edit func(Node) Node) {
1780 for i, x := range list {
1781 if x != nil {
1782 list[i] = edit(x).(*Name)
1783 }
1784 }
1785 }
1786
1787 func copyNodes(list []Node) []Node {
1788 if list == nil {
1789 return nil
1790 }
1791 c := make([]Node, len(list))
1792 copy(c, list)
1793 return c
1794 }
1795 func doNodes(list []Node, do func(Node) bool) bool {
1796 for _, x := range list {
1797 if x != nil && do(x) {
1798 return true
1799 }
1800 }
1801 return false
1802 }
1803 func editNodes(list []Node, edit func(Node) Node) {
1804 for i, x := range list {
1805 if x != nil {
1806 list[i] = edit(x).(Node)
1807 }
1808 }
1809 }
1810
View as plain text