foo64(m)
}

func foo70(mv1 *MV, m M) { // ERROR "leaking param: m$" "leaking param: mv1$"
	m = mv1
	foo64(m)
}

func foo71(x *int) []*int { // ERROR "leaking param: x$"
	var y []*int
	y = append(y, x)
	return y
}

func foo71a(x int) []*int { // ERROR "moved to heap: x$"
	var y []*int
	y = append(y, &x)
	return y
}

func foo72() {
	var x int
	var y [1]*int

	foo053()
	foo054()
	foo055()
	foo056()
	foo057()
	foo058()
	foo059()
	foo060()
	foo061()
	foo062()
	foo063()
	foo064()
	foo065()
	foo066()
	foo067()
	foo068()
	foo069()
	foo070()
	foo071()
	foo072()
	foo073()
	foo074()
	foo075()
	foo076()
	foo077()
	foo078()
	foo079()
	foo080()
	foo081()
	foo082()
	foo083()
	foo084()
	foo085()
	foo086()
	foo087()

	foo64(m)
}

func foo70(mv1 *MV, m M) { // ERROR "leaking param: m$" "leaking param: mv1$"
	m = mv1
	foo64(m)
}

func foo71(x *int) []*int { // ERROR "leaking param: x$"
	var y []*int
	y = append(y, x)
	return y
}

func foo71a(x int) []*int { // ERROR "moved to heap: x$"
	var y []*int
	y = append(y, &x)
	return y
}

func foo72() {
	var x int
	var y [1]*int

  function {
    signature {
      name: "foo6"
    }
  }
  function {
    signature {
      name: "foo7"
    }
  }
  function {
    signature {
      name: "foo8"
    }
  }
  function {
    signature {
      name: "foo9"
    }
  }
  function {
    signature {
      name: "foo10"
    }
  }
  function {
    signature {
      name: "foo11"
    }
  }
  function {

    }

    def "old build script classloaders are collected"() {
        given:
        buildFile << """
            class Foo0 {
                static final byte[] MEMORY_HOG = new byte[10 * 1024 * 1024]
            }
            task myTask() {
                doLast {
                    println new Foo0()
                }
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {

# CHECK-LABEL:  func @main() {
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = true, f = @foo0}> {device = ""}
# CHECK:    "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# CHECK-LABEL:  func private @foo0()
# CHECK: "tf.LegacyCall"() <{_disable_call_shape_inference = false, f = @bar0}> {device = ""}

# the names are matching between the function definition and the uses / call
# site (a numerical suffix may be appended).

# CHECK: "tf.LegacyCall"(%outputs) <{_disable_call_shape_inference = false, f = @foo0}> {device = ""}

// crash 4
type Numeric4 interface{t4 /* ERROR "not a type" */ }
func t4[T Numeric4](s[]T){if( /* ERROR "non-boolean" */ 0){*s /* ERROR "cannot indirect" */ [0]}}

// crash 7
type foo7 interface { bar() }
type x7[A any] struct{ foo7 }
func main7() { var _ foo7 = x7[int]{} }

// crash 8
type foo8[A any] interface { ~A /* ERROR "cannot be a type parameter" */ }
func bar8[A foo8[A]](a A) {}

// crash 9

        }
    }

    void 'dependency updated through constraints has its transitive dependencies'() {
        given:
        def foo10 = mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'bar', '1.0').publish()
        mavenRepo.module('org', 'bar', '1.1').dependsOn(foo10).publish()
        writeSpec {
            rootProject {
                dependencies {
                    conf 'org:bar:1.0'

	c.Set("foo6", "bar")
	c.Set("foo7", "bar")

	wg := new(sync.WaitGroup)
	workers := runtime.NumCPU()
	each := b.N / workers
	wg.Add(workers)

	b.ResetTimer()
	for i := 0; i < workers; i++ {
		go func() {
			for j := 0; j < each; j++ {
				c.Get("foo1")
				c.Get("foo2")
				c.Get("foo3")
				c.Get("foo5")
				c.Get("foo6")
				c.Get("foo7")
				c.Get("foo8") // doesn't exist
			}