test/escape2n.go

   1 // errorcheck -0 -N -m -l
   2
   3 // Copyright 2010 The Go Authors.  All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Test, using compiler diagnostic flags, that the escape analysis is working.
   8 // Compiles but does not run.  Inlining is disabled.
   9 // Registerization is disabled too (-N), which should
  10 // have no effect on escape analysis.
  11
  12 package foo
  13
  14 import (
  15         "fmt"
  16         "unsafe"
  17 )
  18
  19 var gxx *int
  20
  21 func foo1(x int) { // ERROR "moved to heap: x"
  22         gxx = &x // ERROR "&x escapes to heap"
  23 }
  24
  25 func foo2(yy *int) { // ERROR "leaking param: yy"
  26         gxx = yy
  27 }
  28
  29 func foo3(x int) *int { // ERROR "moved to heap: x"
  30         return &x // ERROR "&x escapes to heap"
  31 }
  32
  33 type T *T
  34
  35 func foo3b(t T) { // ERROR "leaking param: t"
  36         *t = t
  37 }
  38
  39 // xx isn't going anywhere, so use of yy is ok
  40 func foo4(xx, yy *int) { // ERROR "xx does not escape" "yy does not escape"
  41         xx = yy
  42 }
  43
  44 // xx isn't going anywhere, so taking address of yy is ok
  45 func foo5(xx **int, yy *int) { // ERROR "xx does not escape" "yy does not escape"
  46         xx = &yy // ERROR "&yy does not escape"
  47 }
  48
  49 func foo6(xx **int, yy *int) { // ERROR "xx does not escape" "leaking param: yy"
  50         *xx = yy
  51 }
  52
  53 func foo7(xx **int, yy *int) { // ERROR "xx does not escape" "yy does not escape"
  54         **xx = *yy
  55 }
  56
  57 func foo8(xx, yy *int) int { // ERROR "xx does not escape" "yy does not escape"
  58         xx = yy
  59         return *xx
  60 }
  61
  62 func foo9(xx, yy *int) *int { // ERROR "leaking param: xx" "leaking param: yy"
  63         xx = yy
  64         return xx
  65 }
  66
  67 func foo10(xx, yy *int) { // ERROR "xx does not escape" "yy does not escape"
  68         *xx = *yy
  69 }
  70
  71 func foo11() int {
  72         x, y := 0, 42
  73         xx := &x // ERROR "&x does not escape"
  74         yy := &y // ERROR "&y does not escape"
  75         *xx = *yy
  76         return x
  77 }
  78
  79 var xxx **int
  80
  81 func foo12(yyy **int) { // ERROR "leaking param: yyy"
  82         xxx = yyy
  83 }
  84
  85 // Must treat yyy as leaking because *yyy leaks, and the escape analysis
  86 // summaries in exported metadata do not distinguish these two cases.
  87 func foo13(yyy **int) { // ERROR "leaking param: yyy"
  88         *xxx = *yyy
  89 }
  90
  91 func foo14(yyy **int) { // ERROR "yyy does not escape"
  92         **xxx = **yyy
  93 }
  94
  95 func foo15(yy *int) { // ERROR "moved to heap: yy"
  96         xxx = &yy // ERROR "&yy escapes to heap"
  97 }
  98
  99 func foo16(yy *int) { // ERROR "leaking param: yy"
 100         *xxx = yy
 101 }
 102
 103 func foo17(yy *int) { // ERROR "yy does not escape"
 104         **xxx = *yy
 105 }
 106
 107 func foo18(y int) { // ERROR "moved to heap: "y"
 108         *xxx = &y // ERROR "&y escapes to heap"
 109 }
 110
 111 func foo19(y int) {
 112         **xxx = y
 113 }
 114
 115 type Bar struct {
 116         i  int
 117         ii *int
 118 }
 119
 120 func NewBar() *Bar {
 121         return &Bar{42, nil} // ERROR "&Bar literal escapes to heap"
 122 }
 123
 124 func NewBarp(x *int) *Bar { // ERROR "leaking param: x"
 125         return &Bar{42, x} // ERROR "&Bar literal escapes to heap"
 126 }
 127
 128 func NewBarp2(x *int) *Bar { // ERROR "x does not escape"
 129         return &Bar{*x, nil} // ERROR "&Bar literal escapes to heap"
 130 }
 131
 132 func (b *Bar) NoLeak() int { // ERROR "b does not escape"
 133         return *(b.ii)
 134 }
 135
 136 func (b *Bar) Leak() *int { // ERROR "leaking param: b"
 137         return &b.i // ERROR "&b.i escapes to heap"
 138 }
 139
 140 func (b *Bar) AlsoNoLeak() *int { // ERROR "leaking param b content to result ~r0"
 141         return b.ii
 142 }
 143
 144 func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b"
 145         return b.ii
 146 }
 147
 148 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b"
 149         v := 0    // ERROR "moved to heap: v"
 150         b.ii = &v // ERROR "&v escapes"
 151         return b.ii
 152 }
 153
 154 func (b *Bar) LeaksABit() *int { // ERROR "leaking param b content to result ~r0"
 155         v := 0    // ERROR "moved to heap: v"
 156         b.ii = &v // ERROR "&v escapes"
 157         return b.ii
 158 }
 159
 160 func (b Bar) StillNoLeak() int { // ERROR "b does not escape"
 161         v := 0
 162         b.ii = &v // ERROR "&v does not escape"
 163         return b.i
 164 }
 165
 166 func goLeak(b *Bar) { // ERROR "leaking param: b"
 167         go b.NoLeak()
 168 }
 169
 170 type Bar2 struct {
 171         i  [12]int
 172         ii []int
 173 }
 174
 175 func NewBar2() *Bar2 {
 176         return &Bar2{[12]int{42}, nil} // ERROR "&Bar2 literal escapes to heap"
 177 }
 178
 179 func (b *Bar2) NoLeak() int { // ERROR "b does not escape"
 180         return b.i[0]
 181 }
 182
 183 func (b *Bar2) Leak() []int { // ERROR "leaking param: b"
 184         return b.i[:] // ERROR "b.i escapes to heap"
 185 }
 186
 187 func (b *Bar2) AlsoNoLeak() []int { // ERROR "leaking param b content to result ~r0"
 188         return b.ii[0:1]
 189 }
 190
 191 func (b Bar2) AgainNoLeak() [12]int { // ERROR "b does not escape"
 192         return b.i
 193 }
 194
 195 func (b *Bar2) LeakSelf() { // ERROR "leaking param: b"
 196         b.ii = b.i[0:4] // ERROR "b.i escapes to heap"
 197 }
 198
 199 func (b *Bar2) LeakSelf2() { // ERROR "leaking param: b"
 200         var buf []int
 201         buf = b.i[0:] // ERROR "b.i escapes to heap"
 202         b.ii = buf
 203 }
 204
 205 func foo21() func() int {
 206         x := 42
 207         return func() int { // ERROR "func literal escapes to heap"
 208                 return x
 209         }
 210 }
 211
 212 func foo21a() func() int {
 213         x := 42             // ERROR "moved to heap: x"
 214         return func() int { // ERROR "func literal escapes to heap"
 215                 x++ // ERROR "&x escapes to heap"
 216                 return x
 217         }
 218 }
 219
 220 func foo22() int {
 221         x := 42
 222         return func() int { // ERROR "func literal does not escape"
 223                 return x
 224         }()
 225 }
 226
 227 func foo23(x int) func() int {
 228         return func() int { // ERROR "func literal escapes to heap"
 229                 return x
 230         }
 231 }
 232
 233 func foo23a(x int) func() int {
 234         f := func() int { // ERROR "func literal escapes to heap"
 235                 return x
 236         }
 237         return f
 238 }
 239
 240 func foo23b(x int) *(func() int) {
 241         f := func() int { return x } // ERROR "moved to heap: f" "func literal escapes to heap"
 242         return &f                    // ERROR "&f escapes to heap"
 243 }
 244
 245 func foo23c(x int) func() int { // ERROR "moved to heap: x"
 246         return func() int { // ERROR "func literal escapes to heap"
 247                 x++ // ERROR "&x escapes to heap"
 248                 return x
 249         }
 250 }
 251
 252 func foo24(x int) int {
 253         return func() int { // ERROR "func literal does not escape"
 254                 return x
 255         }()
 256 }
 257
 258 var x *int
 259
 260 func fooleak(xx *int) int { // ERROR "leaking param: xx"
 261         x = xx
 262         return *x
 263 }
 264
 265 func foonoleak(xx *int) int { // ERROR "xx does not escape"
 266         return *x + *xx
 267 }
 268
 269 func foo31(x int) int { // ERROR "moved to heap: x"
 270         return fooleak(&x) // ERROR "&x escapes to heap"
 271 }
 272
 273 func foo32(x int) int {
 274         return foonoleak(&x) // ERROR "&x does not escape"
 275 }
 276
 277 type Foo struct {
 278         xx *int
 279         x  int
 280 }
 281
 282 var F Foo
 283 var pf *Foo
 284
 285 func (f *Foo) fooleak() { // ERROR "leaking param: f"
 286         pf = f
 287 }
 288
 289 func (f *Foo) foonoleak() { // ERROR "f does not escape"
 290         F.x = f.x
 291 }
 292
 293 func (f *Foo) Leak() { // ERROR "leaking param: f"
 294         f.fooleak()
 295 }
 296
 297 func (f *Foo) NoLeak() { // ERROR "f does not escape"
 298         f.foonoleak()
 299 }
 300
 301 func foo41(x int) { // ERROR "moved to heap: x"
 302         F.xx = &x // ERROR "&x escapes to heap"
 303 }
 304
 305 func (f *Foo) foo42(x int) { // ERROR "f does not escape" "moved to heap: x"
 306         f.xx = &x // ERROR "&x escapes to heap"
 307 }
 308
 309 func foo43(f *Foo, x int) { // ERROR "f does not escape" "moved to heap: x"
 310         f.xx = &x // ERROR "&x escapes to heap"
 311 }
 312
 313 func foo44(yy *int) { // ERROR "leaking param: yy"
 314         F.xx = yy
 315 }
 316
 317 func (f *Foo) foo45() { // ERROR "f does not escape"
 318         F.x = f.x
 319 }
 320
 321 // See foo13 above for explanation of why f leaks.
 322 func (f *Foo) foo46() { // ERROR "leaking param: f"
 323         F.xx = f.xx
 324 }
 325
 326 func (f *Foo) foo47() { // ERROR "leaking param: f"
 327         f.xx = &f.x // ERROR "&f.x escapes to heap"
 328 }
 329
 330 var ptrSlice []*int
 331
 332 func foo50(i *int) { // ERROR "leaking param: i"
 333         ptrSlice[0] = i
 334 }
 335
 336 var ptrMap map[*int]*int
 337
 338 func foo51(i *int) { // ERROR "leaking param: i"
 339         ptrMap[i] = i
 340 }
 341
 342 func indaddr1(x int) *int { // ERROR "moved to heap: x"
 343         return &x // ERROR "&x escapes to heap"
 344 }
 345
 346 func indaddr2(x *int) *int { // ERROR "leaking param: x"
 347         return *&x // ERROR "&x does not escape"
 348 }
 349
 350 func indaddr3(x *int32) *int { // ERROR "leaking param: x"
 351         return *(**int)(unsafe.Pointer(&x)) // ERROR "&x does not escape"
 352 }
 353
 354 // From package math:
 355
 356 func Float32bits(f float32) uint32 {
 357         return *(*uint32)(unsafe.Pointer(&f)) // ERROR "&f does not escape"
 358 }
 359
 360 func Float32frombits(b uint32) float32 {
 361         return *(*float32)(unsafe.Pointer(&b)) // ERROR "&b does not escape"
 362 }
 363
 364 func Float64bits(f float64) uint64 {
 365         return *(*uint64)(unsafe.Pointer(&f)) // ERROR "&f does not escape"
 366 }
 367
 368 func Float64frombits(b uint64) float64 {
 369         return *(*float64)(unsafe.Pointer(&b)) // ERROR "&b does not escape"
 370 }
 371
 372 // contrast with
 373 func float64bitsptr(f float64) *uint64 { // ERROR "moved to heap: f"
 374         return (*uint64)(unsafe.Pointer(&f)) // ERROR "&f escapes to heap"
 375 }
 376
 377 func float64ptrbitsptr(f *float64) *uint64 { // ERROR "leaking param: f"
 378         return (*uint64)(unsafe.Pointer(f))
 379 }
 380
 381 func typesw(i interface{}) *int { // ERROR "leaking param: i"
 382         switch val := i.(type) {
 383         case *int:
 384                 return val
 385         case *int8:
 386                 v := int(*val) // ERROR "moved to heap: v"
 387                 return &v      // ERROR "&v escapes to heap"
 388         }
 389         return nil
 390 }
 391
 392 func exprsw(i *int) *int { // ERROR "leaking param: i"
 393         switch j := i; *j + 110 {
 394         case 12:
 395                 return j
 396         case 42:
 397                 return nil
 398         }
 399         return nil
 400
 401 }
 402
 403 // assigning to an array element is like assigning to the array
 404 func foo60(i *int) *int { // ERROR "leaking param: i"
 405         var a [12]*int
 406         a[0] = i
 407         return a[1]
 408 }
 409
 410 func foo60a(i *int) *int { // ERROR "i does not escape"
 411         var a [12]*int
 412         a[0] = i
 413         return nil
 414 }
 415
 416 // assigning to a struct field  is like assigning to the struct
 417 func foo61(i *int) *int { // ERROR "leaking param: i"
 418         type S struct {
 419                 a, b *int
 420         }
 421         var s S
 422         s.a = i
 423         return s.b
 424 }
 425
 426 func foo61a(i *int) *int { // ERROR "i does not escape"
 427         type S struct {
 428                 a, b *int
 429         }
 430         var s S
 431         s.a = i
 432         return nil
 433 }
 434
 435 // assigning to a struct field is like assigning to the struct but
 436 // here this subtlety is lost, since s.a counts as an assignment to a
 437 // track-losing dereference.
 438 func foo62(i *int) *int { // ERROR "leaking param: i"
 439         type S struct {
 440                 a, b *int
 441         }
 442         s := new(S) // ERROR "new[(]S[)] does not escape"
 443         s.a = i
 444         return nil // s.b
 445 }
 446
 447 type M interface {
 448         M()
 449 }
 450
 451 func foo63(m M) { // ERROR "m does not escape"
 452 }
 453
 454 func foo64(m M) { // ERROR "leaking param: m"
 455         m.M()
 456 }
 457
 458 func foo64b(m M) { // ERROR "leaking param: m"
 459         defer m.M()
 460 }
 461
 462 type MV int
 463
 464 func (MV) M() {}
 465
 466 func foo65() {
 467         var mv MV
 468         foo63(&mv) // ERROR "&mv does not escape"
 469 }
 470
 471 func foo66() {
 472         var mv MV  // ERROR "moved to heap: mv"
 473         foo64(&mv) // ERROR "&mv escapes to heap"
 474 }
 475
 476 func foo67() {
 477         var mv MV
 478         foo63(mv)
 479 }
 480
 481 func foo68() {
 482         var mv MV
 483         foo64(mv) // escapes but it's an int so irrelevant
 484 }
 485
 486 func foo69(m M) { // ERROR "leaking param: m"
 487         foo64(m)
 488 }
 489
 490 func foo70(mv1 *MV, m M) { // ERROR "leaking param: mv1" "leaking param: m"
 491         m = mv1
 492         foo64(m)
 493 }
 494
 495 func foo71(x *int) []*int { // ERROR "leaking param: x"
 496         var y []*int
 497         y = append(y, x)
 498         return y
 499 }
 500
 501 func foo71a(x int) []*int { // ERROR "moved to heap: x"
 502         var y []*int
 503         y = append(y, &x) // ERROR "&x escapes to heap"
 504         return y
 505 }
 506
 507 func foo72() {
 508         var x int
 509         var y [1]*int
 510         y[0] = &x // ERROR "&x does not escape"
 511 }
 512
 513 func foo72aa() [10]*int {
 514         var x int // ERROR "moved to heap: x"
 515         var y [10]*int
 516         y[0] = &x // ERROR "&x escapes to heap"
 517         return y
 518 }
 519
 520 func foo72a() {
 521         var y [10]*int
 522         for i := 0; i < 10; i++ {
 523                 // escapes its scope
 524                 x := i    // ERROR "moved to heap: x"
 525                 y[i] = &x // ERROR "&x escapes to heap"
 526         }
 527         return
 528 }
 529
 530 func foo72b() [10]*int {
 531         var y [10]*int
 532         for i := 0; i < 10; i++ {
 533                 x := i    // ERROR "moved to heap: x"
 534                 y[i] = &x // ERROR "&x escapes to heap"
 535         }
 536         return y
 537 }
 538
 539 // issue 2145
 540 func foo73() {
 541         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 542         for _, v := range s {
 543                 vv := v
 544                 // actually just escapes its scope
 545                 defer func() { // ERROR "func literal escapes to heap"
 546                         println(vv)
 547                 }()
 548         }
 549 }
 550
 551 func foo731() {
 552         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 553         for _, v := range s {
 554                 vv := v // ERROR "moved to heap: vv"
 555                 // actually just escapes its scope
 556                 defer func() { // ERROR "func literal escapes to heap"
 557                         vv = 42 // ERROR "&vv escapes to heap"
 558                         println(vv)
 559                 }()
 560         }
 561 }
 562
 563 func foo74() {
 564         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 565         for _, v := range s {
 566                 vv := v
 567                 // actually just escapes its scope
 568                 fn := func() { // ERROR "func literal escapes to heap"
 569                         println(vv)
 570                 }
 571                 defer fn()
 572         }
 573 }
 574
 575 func foo74a() {
 576         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 577         for _, v := range s {
 578                 vv := v // ERROR "moved to heap: vv"
 579                 // actually just escapes its scope
 580                 fn := func() { // ERROR "func literal escapes to heap"
 581                         vv += 1 // ERROR "&vv escapes to heap"
 582                         println(vv)
 583                 }
 584                 defer fn()
 585         }
 586 }
 587
 588 // issue 3975
 589 func foo74b() {
 590         var array [3]func()
 591         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 592         for i, v := range s {
 593                 vv := v
 594                 // actually just escapes its scope
 595                 array[i] = func() { // ERROR "func literal escapes to heap"
 596                         println(vv)
 597                 }
 598         }
 599 }
 600
 601 func foo74c() {
 602         var array [3]func()
 603         s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
 604         for i, v := range s {
 605                 vv := v // ERROR "moved to heap: vv"
 606                 // actually just escapes its scope
 607                 array[i] = func() { // ERROR "func literal escapes to heap"
 608                         println(&vv) // ERROR "&vv escapes to heap" "&vv does not escape"
 609                 }
 610         }
 611 }
 612
 613 func myprint(y *int, x ...interface{}) *int { // ERROR "x does not escape" "leaking param: y to result ~r2"
 614         return y
 615 }
 616
 617 func myprint1(y *int, x ...interface{}) *interface{} { // ERROR "y does not escape" "leaking param: x to result ~r2"
 618         return &x[0] // ERROR "&x.0. escapes to heap"
 619 }
 620
 621 func foo75(z *int) { // ERROR "z does not escape"
 622         myprint(z, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 623 }
 624
 625 func foo75a(z *int) { // ERROR "z does not escape"
 626         myprint1(z, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 627 }
 628
 629 func foo75esc(z *int) { // ERROR "leaking param: z"
 630         gxx = myprint(z, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 631 }
 632
 633 func foo75aesc(z *int) { // ERROR "z does not escape"
 634         var ppi **interface{}       // assignments to pointer dereferences lose track
 635         *ppi = myprint1(z, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
 636 }
 637
 638 func foo75aesc1(z *int) { // ERROR "z does not escape"
 639         sink = myprint1(z, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
 640 }
 641
 642 // BAD: z does not escape here
 643 func foo76(z *int) { // ERROR "leaking param: z"
 644         myprint(nil, z) // ERROR "[.][.][.] argument does not escape"
 645 }
 646
 647 // BAD: z does not escape here
 648 func foo76a(z *int) { // ERROR "leaking param: z"
 649         myprint1(nil, z) // ERROR "[.][.][.] argument does not escape"
 650 }
 651
 652 func foo76b() {
 653         myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 654 }
 655
 656 func foo76c() {
 657         myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 658 }
 659
 660 func foo76d() {
 661         defer myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 662 }
 663
 664 func foo76e() {
 665         defer myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
 666 }
 667
 668 func foo76f() {
 669         for {
 670                 // TODO: This one really only escapes its scope, but we don't distinguish yet.
 671                 defer myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
 672         }
 673 }
 674
 675 func foo76g() {
 676         for {
 677                 defer myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
 678         }
 679 }
 680
 681 func foo77(z []interface{}) { // ERROR "z does not escape"
 682         myprint(nil, z...) // z does not escape
 683 }
 684
 685 func foo77a(z []interface{}) { // ERROR "z does not escape"
 686         myprint1(nil, z...)
 687 }
 688
 689 func foo77b(z []interface{}) { // ERROR "leaking param: z"
 690         var ppi **interface{}
 691         *ppi = myprint1(nil, z...)
 692 }
 693
 694 func foo77c(z []interface{}) { // ERROR "leaking param: z"
 695         sink = myprint1(nil, z...)
 696 }
 697
 698 func dotdotdot() {
 699         // BAD: i should not escape here
 700         i := 0           // ERROR "moved to heap: i"
 701         myprint(nil, &i) // ERROR "&i escapes to heap" "\.\.\. argument does not escape"
 702
 703         // BAD: j should not escape here
 704         j := 0            // ERROR "moved to heap: j"
 705         myprint1(nil, &j) // ERROR "&j escapes to heap" "\.\.\. argument does not escape"
 706 }
 707
 708 func foo78(z int) *int { // ERROR "moved to heap: z"
 709         return &z // ERROR "&z escapes to heap"
 710 }
 711
 712 func foo78a(z int) *int { // ERROR "moved to heap: z"
 713         y := &z   // ERROR "&z escapes to heap"
 714         x := &y   // ERROR "&y does not escape"
 715         return *x // really return y
 716 }
 717
 718 func foo79() *int {
 719         return new(int) // ERROR "new[(]int[)] escapes to heap"
 720 }
 721
 722 func foo80() *int {
 723         var z *int
 724         for {
 725                 // Really just escapes its scope but we don't distinguish
 726                 z = new(int) // ERROR "new[(]int[)] escapes to heap"
 727         }
 728         _ = z
 729         return nil
 730 }
 731
 732 func foo81() *int {
 733         for {
 734                 z := new(int) // ERROR "new[(]int[)] does not escape"
 735                 _ = z
 736         }
 737         return nil
 738 }
 739
 740 func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param"
 741
 742 func noop(x, y *int) {} // ERROR "does not escape"
 743
 744 func foo82() {
 745         var x, y, z int  // ERROR "moved to heap"
 746         go noop(tee(&z)) // ERROR "&z escapes to heap"
 747         go noop(&x, &y)  // ERROR "escapes to heap"
 748         for {
 749                 var u, v, w int     // ERROR "moved to heap"
 750                 defer noop(tee(&u)) // ERROR "&u escapes to heap"
 751                 defer noop(&v, &w)  // ERROR "escapes to heap"
 752         }
 753 }
 754
 755 type Fooer interface {
 756         Foo()
 757 }
 758
 759 type LimitedFooer struct {
 760         Fooer
 761         N int64
 762 }
 763
 764 func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r"
 765         return &LimitedFooer{r, n} // ERROR "&LimitedFooer literal escapes to heap"
 766 }
 767
 768 func foo90(x *int) map[*int]*int { // ERROR "leaking param: x"
 769         return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap"
 770 }
 771
 772 func foo91(x *int) map[*int]*int { // ERROR "leaking param: x"
 773         return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap"
 774 }
 775
 776 func foo92(x *int) [2]*int { // ERROR "leaking param: x"
 777         return [2]*int{x, nil}
 778 }
 779
 780 // does not leak c
 781 func foo93(c chan *int) *int { // ERROR "c does not escape"
 782         for v := range c {
 783                 return v
 784         }
 785         return nil
 786 }
 787
 788 // does not leak m
 789 func foo94(m map[*int]*int, b bool) *int { // ERROR "m does not escape"
 790         for k, v := range m {
 791                 if b {
 792                         return k
 793                 }
 794                 return v
 795         }
 796         return nil
 797 }
 798
 799 // does leak x
 800 func foo95(m map[*int]*int, x *int) { // ERROR "m does not escape" "leaking param: x"
 801         m[x] = x
 802 }
 803
 804 // does not leak m
 805 func foo96(m []*int) *int { // ERROR "m does not escape"
 806         return m[0]
 807 }
 808
 809 // does leak m
 810 func foo97(m [1]*int) *int { // ERROR "leaking param: m"
 811         return m[0]
 812 }
 813
 814 // does not leak m
 815 func foo98(m map[int]*int) *int { // ERROR "m does not escape"
 816         return m[0]
 817 }
 818
 819 // does leak m
 820 func foo99(m *[1]*int) []*int { // ERROR "leaking param: m"
 821         return m[:]
 822 }
 823
 824 // does not leak m
 825 func foo100(m []*int) *int { // ERROR "m does not escape"
 826         for _, v := range m {
 827                 return v
 828         }
 829         return nil
 830 }
 831
 832 // does leak m
 833 func foo101(m [1]*int) *int { // ERROR "leaking param: m"
 834         for _, v := range m {
 835                 return v
 836         }
 837         return nil
 838 }
 839
 840 // does not leak m
 841 func foo101a(m [1]*int) *int { // ERROR "m does not escape"
 842         for i := range m { // ERROR "moved to heap: i"
 843                 return &i // ERROR "&i escapes to heap"
 844         }
 845         return nil
 846 }
 847
 848 // does leak x
 849 func foo102(m []*int, x *int) { // ERROR "m does not escape" "leaking param: x"
 850         m[0] = x
 851 }
 852
 853 // does not leak x
 854 func foo103(m [1]*int, x *int) { // ERROR "m does not escape" "x does not escape"
 855         m[0] = x
 856 }
 857
 858 var y []*int
 859
 860 // does not leak x
 861 func foo104(x []*int) { // ERROR "x does not escape"
 862         copy(y, x)
 863 }
 864
 865 // does not leak x
 866 func foo105(x []*int) { // ERROR "x does not escape"
 867         _ = append(y, x...)
 868 }
 869
 870 // does leak x
 871 func foo106(x *int) { // ERROR "leaking param: x"
 872         _ = append(y, x)
 873 }
 874
 875 func foo107(x *int) map[*int]*int { // ERROR "leaking param: x"
 876         return map[*int]*int{x: nil} // ERROR "map.* literal escapes to heap"
 877 }
 878
 879 func foo108(x *int) map[*int]*int { // ERROR "leaking param: x"
 880         return map[*int]*int{nil: x} // ERROR "map.* literal escapes to heap"
 881 }
 882
 883 func foo109(x *int) *int { // ERROR "leaking param: x"
 884         m := map[*int]*int{x: nil} // ERROR "map.* literal does not escape"
 885         for k, _ := range m {
 886                 return k
 887         }
 888         return nil
 889 }
 890
 891 func foo110(x *int) *int { // ERROR "leaking param: x"
 892         m := map[*int]*int{nil: x} // ERROR "map.* literal does not escape"
 893         return m[nil]
 894 }
 895
 896 func foo111(x *int) *int { // ERROR "leaking param: x"
 897         m := []*int{x} // ERROR "\[\]\*int literal does not escape"
 898         return m[0]
 899 }
 900
 901 func foo112(x *int) *int { // ERROR "leaking param: x"
 902         m := [1]*int{x}
 903         return m[0]
 904 }
 905
 906 func foo113(x *int) *int { // ERROR "leaking param: x"
 907         m := Bar{ii: x}
 908         return m.ii
 909 }
 910
 911 func foo114(x *int) *int { // ERROR "leaking param: x"
 912         m := &Bar{ii: x} // ERROR "&Bar literal does not escape"
 913         return m.ii
 914 }
 915
 916 func foo115(x *int) *int { // ERROR "leaking param: x"
 917         return (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1))
 918 }
 919
 920 func foo116(b bool) *int {
 921         if b {
 922                 x := 1    // ERROR "moved to heap: x"
 923                 return &x // ERROR "&x escapes to heap"
 924         } else {
 925                 y := 1    // ERROR "moved to heap: y"
 926                 return &y // ERROR "&y escapes to heap"
 927         }
 928         return nil
 929 }
 930
 931 func foo117(unknown func(interface{})) { // ERROR "unknown does not escape"
 932         x := 1      // ERROR "moved to heap: x"
 933         unknown(&x) // ERROR "&x escapes to heap"
 934 }
 935
 936 func foo118(unknown func(*int)) { // ERROR "unknown does not escape"
 937         x := 1      // ERROR "moved to heap: x"
 938         unknown(&x) // ERROR "&x escapes to heap"
 939 }
 940
 941 func external(*int)
 942
 943 func foo119(x *int) { // ERROR "leaking param: x"
 944         external(x)
 945 }
 946
 947 func foo120() {
 948         // formerly exponential time analysis
 949 L1:
 950 L2:
 951 L3:
 952 L4:
 953 L5:
 954 L6:
 955 L7:
 956 L8:
 957 L9:
 958 L10:
 959 L11:
 960 L12:
 961 L13:
 962 L14:
 963 L15:
 964 L16:
 965 L17:
 966 L18:
 967 L19:
 968 L20:
 969 L21:
 970 L22:
 971 L23:
 972 L24:
 973 L25:
 974 L26:
 975 L27:
 976 L28:
 977 L29:
 978 L30:
 979 L31:
 980 L32:
 981 L33:
 982 L34:
 983 L35:
 984 L36:
 985 L37:
 986 L38:
 987 L39:
 988 L40:
 989 L41:
 990 L42:
 991 L43:
 992 L44:
 993 L45:
 994 L46:
 995 L47:
 996 L48:
 997 L49:
 998 L50:
 999 L51:
1000 L52:
1001 L53:
1002 L54:
1003 L55:
1004 L56:
1005 L57:
1006 L58:
1007 L59:
1008 L60:
1009 L61:
1010 L62:
1011 L63:
1012 L64:
1013 L65:
1014 L66:
1015 L67:
1016 L68:
1017 L69:
1018 L70:
1019 L71:
1020 L72:
1021 L73:
1022 L74:
1023 L75:
1024 L76:
1025 L77:
1026 L78:
1027 L79:
1028 L80:
1029 L81:
1030 L82:
1031 L83:
1032 L84:
1033 L85:
1034 L86:
1035 L87:
1036 L88:
1037 L89:
1038 L90:
1039 L91:
1040 L92:
1041 L93:
1042 L94:
1043 L95:
1044 L96:
1045 L97:
1046 L98:
1047 L99:
1048 L100:
1049         // use the labels to silence compiler errors
1050         goto L1
1051         goto L2
1052         goto L3
1053         goto L4
1054         goto L5
1055         goto L6
1056         goto L7
1057         goto L8
1058         goto L9
1059         goto L10
1060         goto L11
1061         goto L12
1062         goto L13
1063         goto L14
1064         goto L15
1065         goto L16
1066         goto L17
1067         goto L18
1068         goto L19
1069         goto L20
1070         goto L21
1071         goto L22
1072         goto L23
1073         goto L24
1074         goto L25
1075         goto L26
1076         goto L27
1077         goto L28
1078         goto L29
1079         goto L30
1080         goto L31
1081         goto L32
1082         goto L33
1083         goto L34
1084         goto L35
1085         goto L36
1086         goto L37
1087         goto L38
1088         goto L39
1089         goto L40
1090         goto L41
1091         goto L42
1092         goto L43
1093         goto L44
1094         goto L45
1095         goto L46
1096         goto L47
1097         goto L48
1098         goto L49
1099         goto L50
1100         goto L51
1101         goto L52
1102         goto L53
1103         goto L54
1104         goto L55
1105         goto L56
1106         goto L57
1107         goto L58
1108         goto L59
1109         goto L60
1110         goto L61
1111         goto L62
1112         goto L63
1113         goto L64
1114         goto L65
1115         goto L66
1116         goto L67
1117         goto L68
1118         goto L69
1119         goto L70
1120         goto L71
1121         goto L72
1122         goto L73
1123         goto L74
1124         goto L75
1125         goto L76
1126         goto L77
1127         goto L78
1128         goto L79
1129         goto L80
1130         goto L81
1131         goto L82
1132         goto L83
1133         goto L84
1134         goto L85
1135         goto L86
1136         goto L87
1137         goto L88
1138         goto L89
1139         goto L90
1140         goto L91
1141         goto L92
1142         goto L93
1143         goto L94
1144         goto L95
1145         goto L96
1146         goto L97
1147         goto L98
1148         goto L99
1149         goto L100
1150 }
1151
1152 func foo121() {
1153         for i := 0; i < 10; i++ {
1154                 defer myprint(nil, i) // ERROR "[.][.][.] argument escapes to heap"
1155                 go myprint(nil, i)    // ERROR "[.][.][.] argument escapes to heap"
1156         }
1157 }
1158
1159 // same as foo121 but check across import
1160 func foo121b() {
1161         for i := 0; i < 10; i++ {
1162                 defer fmt.Printf("%d", i) // ERROR "[.][.][.] argument escapes to heap"
1163                 go fmt.Printf("%d", i)    // ERROR "[.][.][.] argument escapes to heap"
1164         }
1165 }
1166
1167 // a harmless forward jump
1168 func foo122() {
1169         var i *int
1170
1171         goto L1
1172 L1:
1173         i = new(int) // ERROR "new.int. does not escape"
1174         _ = i
1175 }
1176
1177 // a backward jump, increases loopdepth
1178 func foo123() {
1179         var i *int
1180
1181 L1:
1182         i = new(int) // ERROR "new.int. escapes to heap"
1183
1184         goto L1
1185         _ = i
1186 }
1187
1188 func foo124(x **int) { // ERROR "x does not escape"
1189         var i int // ERROR "moved to heap: i"
1190         p := &i   // ERROR "&i escapes"
1191         func() {  // ERROR "func literal does not escape"
1192                 *x = p // ERROR "leaking closure reference p"
1193         }()
1194 }
1195
1196 func foo125(ch chan *int) { // ERROR "does not escape"
1197         var i int // ERROR "moved to heap"
1198         p := &i   // ERROR "&i escapes to heap"
1199         func() {  // ERROR "func literal does not escape"
1200                 ch <- p // ERROR "leaking closure reference p"
1201         }()
1202 }
1203
1204 func foo126() {
1205         var px *int // loopdepth 0
1206         for {
1207                 // loopdepth 1
1208                 var i int // ERROR "moved to heap"
1209                 func() {  // ERROR "func literal does not escape"
1210                         px = &i // ERROR "&i escapes"
1211                 }()
1212         }
1213         _ = px
1214 }
1215
1216 var px *int
1217
1218 func foo127() {
1219         var i int // ERROR "moved to heap: i"
1220         p := &i   // ERROR "&i escapes to heap"
1221         q := p
1222         px = q
1223 }
1224
1225 func foo128() {
1226         var i int
1227         p := &i // ERROR "&i does not escape"
1228         q := p
1229         _ = q
1230 }
1231
1232 func foo129() {
1233         var i int // ERROR "moved to heap: i"
1234         p := &i   // ERROR "&i escapes to heap"
1235         func() {  // ERROR "func literal does not escape"
1236                 q := p   // ERROR "leaking closure reference p"
1237                 func() { // ERROR "func literal does not escape"
1238                         r := q // ERROR "leaking closure reference q"
1239                         px = r
1240                 }()
1241         }()
1242 }
1243
1244 func foo130() {
1245         for {
1246                 var i int // ERROR "moved to heap"
1247                 func() {  // ERROR "func literal does not escape"
1248                         px = &i // ERROR "&i escapes" "leaking closure reference i"
1249                 }()
1250         }
1251 }
1252
1253 func foo131() {
1254         var i int // ERROR "moved to heap"
1255         func() {  // ERROR "func literal does not escape"
1256                 px = &i // ERROR "&i escapes" "leaking closure reference i"
1257         }()
1258 }
1259
1260 func foo132() {
1261         var i int   // ERROR "moved to heap"
1262         go func() { // ERROR "func literal escapes to heap"
1263                 px = &i // ERROR "&i escapes" "leaking closure reference i"
1264         }()
1265 }
1266
1267 func foo133() {
1268         var i int      // ERROR "moved to heap"
1269         defer func() { // ERROR "func literal does not escape"
1270                 px = &i // ERROR "&i escapes" "leaking closure reference i"
1271         }()
1272 }
1273
1274 func foo134() {
1275         var i int
1276         p := &i  // ERROR "&i does not escape"
1277         func() { // ERROR "func literal does not escape"
1278                 q := p
1279                 func() { // ERROR "func literal does not escape"
1280                         r := q
1281                         _ = r
1282                 }()
1283         }()
1284 }
1285
1286 func foo135() {
1287         var i int   // ERROR "moved to heap: i"
1288         p := &i     // ERROR "&i escapes to heap"
1289         go func() { // ERROR "func literal escapes to heap"
1290                 q := p
1291                 func() { // ERROR "func literal does not escape"
1292                         r := q
1293                         _ = r
1294                 }()
1295         }()
1296 }
1297
1298 func foo136() {
1299         var i int   // ERROR "moved to heap: i"
1300         p := &i     // ERROR "&i escapes to heap"
1301         go func() { // ERROR "func literal escapes to heap"
1302                 q := p   // ERROR "leaking closure reference p"
1303                 func() { // ERROR "func literal does not escape"
1304                         r := q // ERROR "leaking closure reference q"
1305                         px = r
1306                 }()
1307         }()
1308 }
1309
1310 func foo137() {
1311         var i int // ERROR "moved to heap: i"
1312         p := &i   // ERROR "&i escapes to heap"
1313         func() {  // ERROR "func literal does not escape"
1314                 q := p      // ERROR "leaking closure reference p"
1315                 go func() { // ERROR "func literal escapes to heap"
1316                         r := q
1317                         _ = r
1318                 }()
1319         }()
1320 }
1321
1322 func foo138() *byte {
1323         type T struct {
1324                 x [1]byte
1325         }
1326         t := new(T)    // ERROR "new.T. escapes to heap"
1327         return &t.x[0] // ERROR "&t.x.0. escapes to heap"
1328 }
1329
1330 func foo139() *byte {
1331         type T struct {
1332                 x struct {
1333                         y byte
1334                 }
1335         }
1336         t := new(T)   // ERROR "new.T. escapes to heap"
1337         return &t.x.y // ERROR "&t.x.y escapes to heap"
1338 }
1339
1340 // issue 4751
1341 func foo140() interface{} {
1342         type T struct {
1343                 X string
1344         }
1345         type U struct {
1346                 X string
1347                 T *T
1348         }
1349         t := &T{} // ERROR "&T literal escapes to heap"
1350         return U{
1351                 X: t.X,
1352                 T: t,
1353         }
1354 }
1355
1356 //go:noescape
1357
1358 func F1([]byte)
1359
1360 func F2([]byte)
1361
1362 //go:noescape
1363
1364 func F3(x []byte) // ERROR "F3 x does not escape"
1365
1366 func F4(x []byte)
1367
1368 func G() {
1369         var buf1 [10]byte
1370         F1(buf1[:]) // ERROR "buf1 does not escape"
1371
1372         var buf2 [10]byte // ERROR "moved to heap: buf2"
1373         F2(buf2[:])       // ERROR "buf2 escapes to heap"
1374
1375         var buf3 [10]byte
1376         F3(buf3[:]) // ERROR "buf3 does not escape"
1377
1378         var buf4 [10]byte // ERROR "moved to heap: buf4"
1379         F4(buf4[:])       // ERROR "buf4 escapes to heap"
1380 }
1381
1382 type Tm struct {
1383         x int
1384 }
1385
1386 func (t *Tm) M() { // ERROR "t does not escape"
1387 }
1388
1389 func foo141() {
1390         var f func()
1391
1392         t := new(Tm) // ERROR "escapes to heap"
1393         f = t.M      // ERROR "t.M does not escape"
1394         _ = f
1395 }
1396
1397 var gf func()
1398
1399 func foo142() {
1400         t := new(Tm) // ERROR "escapes to heap"
1401         gf = t.M     // ERROR "t.M escapes to heap"
1402 }
1403
1404 // issue 3888.
1405 func foo143() {
1406         for i := 0; i < 1000; i++ {
1407                 func() { // ERROR "func literal does not escape"
1408                         for i := 0; i < 1; i++ {
1409                                 var t Tm
1410                                 t.M() // ERROR "t does not escape"
1411                         }
1412                 }()
1413         }
1414 }
1415
1416 // issue 5773
1417 // Check that annotations take effect regardless of whether they
1418 // are before or after the use in the source code.
1419
1420 //go:noescape
1421
1422 func foo144a(*int)
1423
1424 func foo144() {
1425         var x int
1426         foo144a(&x) // ERROR "&x does not escape"
1427         var y int
1428         foo144b(&y) // ERROR "&y does not escape"
1429 }
1430
1431 //go:noescape
1432
1433 func foo144b(*int)
1434
1435 // issue 7313: for loop init should not be treated as "in loop"
1436
1437 type List struct {
1438         Next *List
1439 }
1440
1441 func foo145(l List) { // ERROR "l does not escape"
1442         var p *List
1443         for p = &l; p.Next != nil; p = p.Next { // ERROR "&l does not escape"
1444         }
1445 }
1446
1447 func foo146(l List) { // ERROR "l does not escape"
1448         var p *List
1449         p = &l // ERROR "&l does not escape"
1450         for ; p.Next != nil; p = p.Next {
1451         }
1452 }
1453
1454 func foo147(l List) { // ERROR "l does not escape"
1455         var p *List
1456         p = &l // ERROR "&l does not escape"
1457         for p.Next != nil {
1458                 p = p.Next
1459         }
1460 }
1461
1462 func foo148(l List) { // ERROR " l does not escape"
1463         for p := &l; p.Next != nil; p = p.Next { // ERROR "&l does not escape"
1464         }
1465 }
1466
1467 // related: address of variable should have depth of variable, not of loop
1468
1469 func foo149(l List) { // ERROR " l does not escape"
1470         var p *List
1471         for {
1472                 for p = &l; p.Next != nil; p = p.Next { // ERROR "&l does not escape"
1473                 }
1474         }
1475 }
1476
1477 // issue 7934: missed ... if element type had no pointers
1478
1479 var save150 []byte
1480
1481 func foo150(x ...byte) { // ERROR "leaking param: x"
1482         save150 = x
1483 }
1484
1485 func bar150() {
1486         foo150(1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
1487 }
1488
1489 // issue 7931: bad handling of slice of array
1490
1491 var save151 *int
1492
1493 func foo151(x *int) { // ERROR "leaking param: x"
1494         save151 = x
1495 }
1496
1497 func bar151() {
1498         var a [64]int // ERROR "moved to heap: a"
1499         a[4] = 101
1500         foo151(&(&a)[4:8][0]) // ERROR "&\(&a\)\[4:8\]\[0\] escapes to heap" "&a escapes to heap"
1501 }
1502
1503 func bar151b() {
1504         var a [10]int      // ERROR "moved to heap: a"
1505         b := a[:]          // ERROR "a escapes to heap"
1506         foo151(&b[4:8][0]) // ERROR "&b\[4:8\]\[0\] escapes to heap"
1507 }
1508
1509 func bar151c() {
1510         var a [64]int // ERROR "moved to heap: a"
1511         a[4] = 101
1512         foo151(&(&a)[4:8:8][0]) // ERROR "&\(&a\)\[4:8:8\]\[0\] escapes to heap" "&a escapes to heap"
1513 }
1514
1515 func bar151d() {
1516         var a [10]int        // ERROR "moved to heap: a"
1517         b := a[:]            // ERROR "a escapes to heap"
1518         foo151(&b[4:8:8][0]) // ERROR "&b\[4:8:8\]\[0\] escapes to heap"
1519 }
1520
1521 // issue 8120
1522
1523 type U struct {
1524         s *string
1525 }
1526
1527 func (u *U) String() *string { // ERROR "leaking param u content to result ~r0"
1528         return u.s
1529 }
1530
1531 type V struct {
1532         s *string
1533 }
1534
1535 func NewV(u U) *V { // ERROR "leaking param: u"
1536         return &V{u.String()} // ERROR "&V literal escapes to heap" "u does not escape"
1537 }
1538
1539 func foo152() {
1540         a := "a"   // ERROR "moved to heap: a"
1541         u := U{&a} // ERROR "&a escapes to heap"
1542         v := NewV(u)
1543         println(v)
1544 }
1545
1546 // issue 8176 - &x in type switch body not marked as escaping
1547
1548 func foo153(v interface{}) *int { // ERROR "leaking param: v"
1549         switch x := v.(type) {
1550         case int: // ERROR "moved to heap: x"
1551                 return &x // ERROR "&x escapes to heap"
1552         }
1553         panic(0)
1554 }
1555
1556 // issue 8185 - &result escaping into result
1557
1558 func f() (x int, y *int) { // ERROR "moved to heap: x"
1559         y = &x // ERROR "&x escapes to heap"
1560         return
1561 }
1562
1563 func g() (x interface{}) { // ERROR "moved to heap: x"
1564         x = &x // ERROR "&x escapes to heap"
1565         return
1566 }
1567
1568 var sink interface{}
1569
1570 type Lit struct {
1571         p *int
1572 }
1573
1574 func ptrlitNoescape() {
1575         // Both literal and element do not escape.
1576         i := 0
1577         x := &Lit{&i} // ERROR "&Lit literal does not escape" "&i does not escape"
1578         _ = x
1579 }
1580
1581 func ptrlitNoEscape2() {
1582         // Literal does not escape, but element does.
1583         i := 0        // ERROR "moved to heap: i"
1584         x := &Lit{&i} // ERROR "&Lit literal does not escape" "&i escapes to heap"
1585         sink = *x
1586 }
1587
1588 func ptrlitEscape() {
1589         // Both literal and element escape.
1590         i := 0        // ERROR "moved to heap: i"
1591         x := &Lit{&i} // ERROR "&Lit literal escapes to heap" "&i escapes to heap"
1592         sink = x
1593 }
1594
1595 // self-assignments
1596
1597 type Buffer struct {
1598         arr  [64]byte
1599         buf1 []byte
1600         buf2 []byte
1601         str1 string
1602         str2 string
1603 }
1604
1605 func (b *Buffer) foo() { // ERROR "b does not escape"
1606         b.buf1 = b.buf1[1:2]   // ERROR "ignoring self-assignment to b.buf1"
1607         b.buf1 = b.buf1[1:2:3] // ERROR "ignoring self-assignment to b.buf1"
1608         b.buf1 = b.buf2[1:2]   // ERROR "ignoring self-assignment to b.buf1"
1609         b.buf1 = b.buf2[1:2:3] // ERROR "ignoring self-assignment to b.buf1"
1610 }
1611
1612 func (b *Buffer) bar() { // ERROR "leaking param: b"
1613         b.buf1 = b.arr[1:2] // ERROR "b.arr escapes to heap"
1614 }
1615
1616 func (b *Buffer) baz() { // ERROR "b does not escape"
1617         b.str1 = b.str1[1:2] // ERROR "ignoring self-assignment to b.str1"
1618         b.str1 = b.str2[1:2] // ERROR "ignoring self-assignment to b.str1"
1619 }
1620
1621 func (b *Buffer) bat() { // ERROR "leaking param: b"
1622         o := new(Buffer) // ERROR "new\(Buffer\) escapes to heap"
1623         o.buf1 = b.buf1[1:2]
1624         sink = o
1625 }
1626
1627 func quux(sp *string, bp *[]byte) { // ERROR "sp does not escape" "bp does not escape"
1628         *sp = (*sp)[1:2] // ERROR "quux ignoring self-assignment to \*sp"
1629         *bp = (*bp)[1:2] // ERROR "quux ignoring self-assignment to \*bp"
1630 }
1631
1632 type StructWithString struct {
1633         p *int
1634         s string
1635 }
1636
1637 // This is escape analysis false negative.
1638 // We assign the pointer to x.p but leak x.s. Escape analysis coarsens flows
1639 // to just x, and thus &i looks escaping.
1640 func fieldFlowTracking() {
1641         var x StructWithString
1642         i := 0   // ERROR "moved to heap: i"
1643         x.p = &i // ERROR "&i escapes to heap"
1644         sink = x.s
1645 }
1646
1647 // String operations.
1648
1649 func slicebytetostring0() {
1650         b := make([]byte, 20) // ERROR "does not escape"
1651         s := string(b)        // ERROR "string\(b\) does not escape"
1652         _ = s
1653 }
1654
1655 func slicebytetostring1() {
1656         b := make([]byte, 20) // ERROR "does not escape"
1657         s := string(b)        // ERROR "string\(b\) does not escape"
1658         s1 := s[0:1]
1659         _ = s1
1660 }
1661
1662 func slicebytetostring2() {
1663         b := make([]byte, 20) // ERROR "does not escape"
1664         s := string(b)        // ERROR "string\(b\) escapes to heap"
1665         s1 := s[0:1]          // ERROR "moved to heap: s1"
1666         sink = &s1            // ERROR "&s1 escapes to heap"
1667 }
1668
1669 func slicebytetostring3() {
1670         b := make([]byte, 20) // ERROR "does not escape"
1671         s := string(b)        // ERROR "string\(b\) escapes to heap"
1672         s1 := s[0:1]
1673         sink = s1
1674 }
1675
1676 func addstr0() {
1677         s0 := "a"
1678         s1 := "b"
1679         s := s0 + s1 // ERROR "s0 \+ s1 does not escape"
1680         _ = s
1681 }
1682
1683 func addstr1() {
1684         s0 := "a"
1685         s1 := "b"
1686         s := "c"
1687         s += s0 + s1 // ERROR "s0 \+ s1 does not escape"
1688         _ = s
1689 }
1690
1691 func addstr2() {
1692         b := make([]byte, 20) // ERROR "does not escape"
1693         s0 := "a"
1694         s := string(b) + s0 // ERROR "string\(b\) does not escape" "string\(b\) \+ s0 does not escape"
1695         _ = s
1696 }
1697
1698 func addstr3() {
1699         s0 := "a"
1700         s1 := "b"
1701         s := s0 + s1 // ERROR "s0 \+ s1 escapes to heap"
1702         s2 := s[0:1]
1703         sink = s2
1704 }
1705
1706 func intstring0() bool {
1707         // string does not escape
1708         x := '0'
1709         s := string(x) // ERROR "string\(x\) does not escape"
1710         return s == "0"
1711 }
1712
1713 func intstring1() string {
1714         // string does not escape, but the buffer does
1715         x := '0'
1716         s := string(x) // ERROR "string\(x\) escapes to heap"
1717         return s
1718 }
1719
1720 func intstring2() {
1721         // string escapes to heap
1722         x := '0'
1723         s := string(x) // ERROR "string\(x\) escapes to heap" "moved to heap: s"
1724         sink = &s      // ERROR "&s escapes to heap"
1725 }
1726
1727 func stringtoslicebyte0() {
1728         s := "foo"
1729         x := []byte(s) // ERROR "\(\[\]byte\)\(s\) does not escape"
1730         _ = x
1731 }
1732
1733 func stringtoslicebyte1() []byte {
1734         s := "foo"
1735         return []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap"
1736 }
1737
1738 func stringtoslicebyte2() {
1739         s := "foo"
1740         sink = []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap"
1741 }
1742
1743 func stringtoslicerune0() {
1744         s := "foo"
1745         x := []rune(s) // ERROR "\(\[\]rune\)\(s\) does not escape"
1746         _ = x
1747 }
1748
1749 func stringtoslicerune1() []rune {
1750         s := "foo"
1751         return []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap"
1752 }
1753
1754 func stringtoslicerune2() {
1755         s := "foo"
1756         sink = []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap"
1757 }
1758
1759 func slicerunetostring0() {
1760         r := []rune{1, 2, 3} // ERROR "\[\]rune literal does not escape"
1761         s := string(r)       // ERROR "string\(r\) does not escape"
1762         _ = s
1763 }
1764
1765 func slicerunetostring1() string {
1766         r := []rune{1, 2, 3} // ERROR "\[\]rune literal does not escape"
1767         return string(r)     // ERROR "string\(r\) escapes to heap"
1768 }
1769
1770 func slicerunetostring2() {
1771         r := []rune{1, 2, 3} // ERROR "\[\]rune literal does not escape"
1772         sink = string(r)     // ERROR "string\(r\) escapes to heap"
1773 }
1774
1775 func makemap0() {
1776         m := make(map[int]int) // ERROR "make\(map\[int\]int\) does not escape"
1777         m[0] = 0
1778         m[1]++
1779         delete(m, 1)
1780         sink = m[0]
1781 }
1782
1783 func makemap1() map[int]int {
1784         return make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap"
1785 }
1786
1787 func makemap2() {
1788         m := make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap"
1789         sink = m
1790 }