*(*int)(unsafe.Pointer(a)) = 42
}

//go:uintptrescapes
func F2(a ...uintptr) {
	var s [16]byte
	recurse(4096, s[:])
	*(*int)(unsafe.Pointer(a[0])) = 42
}

type t struct{}

func GetT() *t {
	return &t{}
}

//go:uintptrescapes
func (*t) M1(a uintptr) {
	var s [16]byte
	recurse(4096, s[:])
	*(*int)(unsafe.Pointer(a)) = 42
}

//go:uintptrescapes
func (*t) M2(a ...uintptr) {

func F1() int {
	var buf [1024]int
	a.F1(uintptr(unsafe.Pointer(&buf[0])))
	return buf[0]
}

func F2() int {
	var buf [1024]int
	a.F2(uintptr(unsafe.Pointer(&buf[0])))
	return buf[0]
}

var t = a.GetT()

func M1() int {
	var buf [1024]int
	t.M1(uintptr(unsafe.Pointer(&buf[0])))
	return buf[0]
}

func M2() int {
	var buf [1024]int
	t.M2(uintptr(unsafe.Pointer(&buf[0])))
	return buf[0]
}

            interface A {
                String getName()
                void setName(String name)

                B getB()
            }

            @Managed
            interface B {
                C getC()
            }

            @Managed
            interface C {
                A getA()
                void setA(A a)
            }

            class RulePlugin extends RuleSource {

            }

            @Managed
            interface A extends Item {
                B getB()
            }

            @Managed
            interface B extends Item {
                C getC()
            }

            @Managed
            interface C extends Item {
                D getD()
            }

            @Managed
            interface D extends Item {
            }

            " default value with `=` instead."
        ),
    ):

        @app.get("/")
        async def get(item_id: Annotated[int, Query(default=1)]):
            pass  # pragma: nocover


def test_multiple_annotations():
    async def dep():
        pass  # pragma: nocover

    @app.get("/multi-query")
    async def get(foo: Annotated[int, Query(gt=2), Query(lt=10)]):
        return foo

    with pytest.raises(

// See go.dev/issue/67401.
//
//go:linkname atomicwb
//go:nosplit
func atomicwb(ptr *unsafe.Pointer, new unsafe.Pointer) {
	slot := (*uintptr)(unsafe.Pointer(ptr))
	buf := getg().m.p.ptr().wbBuf.get2()
	buf[0] = *slot
	buf[1] = uintptr(new)
}

// atomicstorep performs *ptr = new atomically and invokes a write barrier.
//
//go:nosplit
func atomicstorep(ptr unsafe.Pointer, new unsafe.Pointer) {

	return request("GET", requestURL, t, nil)
}

func DoHTTPGet(requestURL string) (*bytes.Buffer, error) {
	return DoHTTPGetWithTimeout(requestURL, requestTimeout)
}

func GET(requestURL string, t time.Duration, headers map[string]string) (*bytes.Buffer, error) {
	return request("GET", requestURL, t, headers)
}

func (b *wbBuf) empty() bool {
	return b.next == uintptr(unsafe.Pointer(&b.buf[0]))
}

// getX returns space in the write barrier buffer to store X pointers.
// getX will flush the buffer if necessary. Callers should use this as:
//
//	buf := &getg().m.p.ptr().wbBuf
//	p := buf.get2()
//	p[0], p[1] = old, new
//	... actual memory write ...
//

		// observe this.
		throw("self deadlock")
	}
	gp := getg()
	if gp.m.locks < 0 {
		throw("lock count")
	}
	gp.m.locks++
	l.key = mutex_locked
}

func unlock(l *mutex) {
	unlockWithRank(l)
}

func unlock2(l *mutex) {
	if l.key == mutex_unlocked {
		throw("unlock of unlocked lock")
	}
	gp := getg()
	gp.m.locks--
	if gp.m.locks < 0 {
		throw("lock count")
	}

import org.gradle.api.tasks.OutputDirectory;
import java.io.File;

public class SomeTask extends DefaultTask {
    public SomeEnum e;
    @Input
    public SomeEnum getE() { return e; }

    public File f;
    @OutputDirectory
    public File getF() { return f; }

    @TaskAction
    public void go() { }
}
"""
        buildFile << """
task someTask(type: SomeTask) {
    e = SomeEnum.E1