src/cmd/compile/internal/ir/node_gen.go

   1 // Code generated by mknode.go. DO NOT EDIT.
   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 }