// these are not ok (interface and non-interface types)
	g(t, t1 /* ERROR "does not match" */)
	g(t1, t /* ERROR "does not match" */)
	g(tn, t1 /* ERROR "does not match" */)
	g(t1, tn /* ERROR "does not match" */)

	g(t, t1 /* ERROR "does not match" */, t2)
	g(t1, t2 /* ERROR "does not match" */, t)
	g(tn, t1 /* ERROR "does not match" */, t2)
	g(t1, t2 /* ERROR "does not match" */, tn)

Method <org.gradle.api.plugins.quality.PmdExtension.getRuleSetFiles()> does not have raw return type assignable to org.gradle.api.file.ConfigurableFileCollection in (PmdExtension.java:0)
Method <org.gradle.api.tasks.SourceSet.getAnnotationProcessorPath()> does not have raw return type assignable to org.gradle.api.file.ConfigurableFileCollection in (SourceSet.java:0)

			return x + 2
		}
		y, sink = func(x int) int { // ERROR "can inline main.func9" "func literal does not escape"
			return x + 1
		}, 42
		if y(40) != 41 {
			ppanic("y(40) != 41")
		}
	}

	{
		func() { // ERROR "func literal does not escape"
			y := func(x int) int { // ERROR "can inline main.func10.1" "func literal does not escape"
				return x + 2
			}

	ps2 := &s2
	ps4 := &s4
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"
	u3 := &U{&s5, &ps6}  // ERROR "&U{...} does not escape$"
	v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$"
	Ssink = v.UPiSPPia() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
}

	ps2 := &s2
	ps4 := &s4
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}
	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"
	u3 := &U{&s5, &ps6}  // ERROR "&U{...} does not escape$"
	v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$"
	Ssink = v.UPiSPPia() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
}

	// misspelled     x.Foo   ==    FoO    type X has no field or method Foo, but does have field FoO
	// misspelled     x.Foo   ==    foo    type X has no field or method Foo, but does have field foo
	// misspelled     x.Foo   ==    foO    type X has no field or method Foo, but does have field foO
	//
	// misspelled     x.foo   ==    Foo    type X has no field or method foo, but does have field Foo

func bufferNoEscape2(xs []string) int { // ERROR "xs does not escape$"
	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "&bytes.Buffer{...} does not escape$" "make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"
	for _, x := range xs {
		b.WriteString(x)
	}
	return b.Len() // ERROR "inlining call to bytes.\(\*Buffer\).Len$"
}

func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"

	// misspelled     x.Foo   ==    FoO    type X has no field or method Foo, but does have field FoO
	// misspelled     x.Foo   ==    foo    type X has no field or method Foo, but does have field foo
	// misspelled     x.Foo   ==    foO    type X has no field or method Foo, but does have field foO
	//
	// misspelled     x.foo   ==    Foo    type X has no field or method foo, but does have field Foo

func _[P comparable, Q ~int, R any]() {
	_ = f1[int]
	_ = f1[T /* T does satisfy comparable */]
	_ = f1[any /* any does satisfy comparable */]
	_ = f1[P]
	_ = f1[Q]
	_ = f1[R /* ERROR "R does not satisfy comparable" */]

	_ = f2[int]
	_ = f2[T /* T does satisfy comparable */]
	_ = f2[any /* any does satisfy comparable */]
	_ = f2[P]
	_ = f2[Q]
	_ = f2[R /* ERROR "R does not satisfy comparable" */]

	_ = a.G(1).(*int)                                 // ERROR "inlining call to a.G" "does not escape"
	_ = a.G(2.0).(*float64)                           // ERROR "inlining call to a.G" "does not escape"
	_ = (*a.G("").(*interface{})).(string)            // ERROR "inlining call to a.G" "does not escape"
	_ = (*a.G(([]byte)(nil)).(*interface{})).([]byte) // ERROR "inlining call to a.G" "does not escape"