function {
    signature {
      name: "foo9"
    }
  }
  function {
    signature {
      name: "foo10"
    }
  }
  function {
    signature {
      name: "foo11"
    }
  }
  function {
    signature {
      name: "foo12"
    }
  }
  function {
    signature {
      name: "foo13"
    }
  }
  function {
    signature {
      name: "foo14"
    }
  }
  function {

}

func foo16(yy *int) { // ERROR "leaking param: yy$"
	*xxx = yy
}

func foo17(yy *int) { // ERROR "yy does not escape$"
	**xxx = *yy
}

func foo18(y int) { // ERROR "moved to heap: y$"
	*xxx = &y
}

func foo19(y int) {
	**xxx = y
}

type Bar struct {
	i  int
	ii *int
}

func NewBar() *Bar {
	return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$"
}

}

func foo16(yy *int) { // ERROR "leaking param: yy$"
	*xxx = yy
}

func foo17(yy *int) { // ERROR "yy does not escape$"
	**xxx = *yy
}

func foo18(y int) { // ERROR "moved to heap: y$"
	*xxx = &y
}

func foo19(y int) {
	**xxx = y
}

type Bar struct {
	i  int
	ii *int
}

func NewBar() *Bar {
	return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$"
}

        def bar20 = mavenRepo.module('org', 'bar', '2.0').publish()
        def foo10 = mavenRepo.module('org', 'foo', '1.0').dependsOn(bar10).publish()
        def foo13 = mavenRepo.module('org', 'foo', '1.3').dependsOn(bar10).publish()
        def bar15 = mavenRepo.module('org', 'bar', '1.5').publish()
        def foo15 = mavenRepo.module('org', 'foo', '1.5').dependsOn(bar15).publish()

		ObjectMeta: metav1.ObjectMeta{Name: "foo11"},
		Spec: storage.CSINodeSpec{
			Drivers: []storage.CSINodeDriver{{
				Name:         "driver1",
				NodeID:       "node1",
				TopologyKeys: []string{"key1", "key1"},
			}},
		},
	}, {
		// multiple drivers with one set of duplicate topology keys in driver specs
		ObjectMeta: metav1.ObjectMeta{Name: "foo12"},
		Spec: storage.CSINodeSpec{

type G15[X any] s /* ERROR "undefined" */
func (G15 /* ERRORx `generic type .* without instantiation` */ ) p()

// crash 16
type Foo16[T any] r16 /* ERROR "not a type" */
func r16[T any]() Foo16[Foo16[T]] { panic(0) }

// crash 17
type Y17 interface{ c() }
type Z17 interface {
	c() Y17
	Y17 /* ERROR "duplicate method" */
}
func F17[T Z17](T) {}

// crash 18

        checkConfiguration("compileClasspath")

        when:
        platform.pom.expectGet()
        platform.moduleMetadata.expectGet()
        foo11.pom.expectGet()
        foo11.moduleMetadata.expectGet()
        foo10.pom.expectGet()
        foo10.moduleMetadata.expectGet()
        foo10.artifact.expectGet()

        run ":checkDeps"

        then:
        resolve.expectGraph {
            root(":", "org.test:test:1.9") {

            }
            configurations {
                conf
            }
        """
        def foo11 = mavenRepo.module("org", "foo", '1.0').publish()
        mavenRepo.module("org", "foo", '1.1').publish()
        mavenRepo.module("org", "bar", '1.0').dependsOn(foo11).publish()
    }

    void "force resolution strategy is applied to dependency constraints"() {
        given:
        buildFile << """

	_ = x.foo1 // ERROR "x.foo1 undefined (type S has no field or method foo1, but does have field Foo1)"
	_ = x.foo2 // ERROR "x.foo2 undefined (type S has no field or method foo2, but does have field FoO2)"
	_ = x.foo3 // OK
	_ = x.foo4 // ERROR "x.foo4 undefined (type S has no field or method foo4, but does have field foO4)"
}

func _() {
	_ = S{Foo1: 0} // OK

				constructResource("foo1", "foo1.bar.com", "192.1.1.1", "1"),
				constructResource("foo2", "foo2.bar.com", "192.1.1.2", "1"),
			},
			expectedResources: [][]string{
				{"foo1", "foo1.bar.com", "192.1.1.1"},
				{"foo2", "foo2.bar.com", "192.1.1.2"},
			},
		},
		{
			desc: "create-resources-rev-1",
			resources: []*anypb.Any{
				constructResource("foo1", "foo1.bar.com", "192.1.1.1", "1"),