P3 *T13
	T13 /* ERROR "invalid recursive type" */ T13
)

// test cases for issue 18643
// (type cycle detection when non-type expressions are involved)
type (
	T14 [len(T14 /* ERROR "invalid recursive type" */ {})]int
	T15 [][len(T15 /* ERROR "invalid recursive type" */ {})]int
	T16 map[[len(T16 /* ERROR "invalid recursive type" */ {1:2})]int]int
	T17 map[int][len(T17 /* ERROR "invalid recursive type" */ {1:2})]int
)

    private final int filter;
    private final boolean recursive;


    /**
     * @param fh
     * @param filter
     * @param recursive
     * 
     */
    public SmbWatchHandleImpl ( SmbFileHandleImpl fh, int filter, boolean recursive ) {
        this.handle = fh;
        this.filter = filter;
        this.recursive = recursive;
    }


    /**
     * {@inheritDoc}
     *

// (This test used to have problems - see #15596.)

package p

// exported interfaces

type I1 interface { // ERROR "invalid recursive type: anonymous interface refers to itself"
      F() interface{I1}
}

type I2 interface { // ERROR "invalid recursive type: anonymous interface refers to itself"
      F() interface{I2}
}

var V1 I1
var V2 I2

func F() bool {
       return V1 == V2
}

type Error interface{ error }

var err Error
var _ = err.Error()


// more esoteric cases

type (
	T1 interface { T2 }
	T2 /* ERROR "invalid recursive type" */ T2
)

type (
	T3 interface { T4 }
	T4 /* ERROR "invalid recursive type" */ T5
	T5 = T6
	T6 = T7
	T7 = T4
)


// arbitrary code may appear inside an interface

const n = unsafe.Sizeof(func(){})

// license that can be found in the LICENSE file.

package p

type N /* ERROR "invalid recursive type" */ interface {
	int | N
}

type A /* ERROR "invalid recursive type" */ interface {
	int | B
}

type B interface {
	int | A
}

type S /* ERROR "invalid recursive type" */ struct {
	I // ERROR "interface contains type constraints"
}

type I interface {
	int | S
}

    from .app_pv2 import app

    client = TestClient(app)
    response = client.get("/items/recursive")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "sub_items": [{"name": "subitem", "sub_items": []}],
        "name": "item",
    }

    response = client.get("/items/recursive-submodel")
    assert response.status_code == 200, response.text
    assert response.json() == {

	*T
}

type B[T any] interface {
	B /* ERROR "invalid recursive type" */ [*T]
}

type C[T any, U B[U]] interface {
	*T
}

// Simplified reproducer:
type X[T any] interface {
	X /* ERROR "invalid recursive type" */ [*T]
}

var _ X[int]

// A related example that doesn't go through interfaces.
type A2[P any] [10]A2 /* ERROR "invalid recursive type" */ [*P]

package p

type A[P any] [1]P

type B[P any] A[P]

type C /* ERROR "invalid recursive type" */ B[C]

// test case from issue

type Foo[T any] struct {
	baz T
}

type Bar[T any] struct {
	foo Foo[T]
}

type Baz /* ERROR "invalid recursive type" */ struct {
	bar Bar[Baz]

    name: str


RecursiveSubitemInSubmodel.model_rebuild()
RecursiveItemViaSubmodel.model_rebuild()


@app.get("/items/recursive", response_model=RecursiveItem)
def get_recursive():
    return {"name": "item", "sub_items": [{"name": "subitem", "sub_items": []}]}


@app.get("/items/recursive-submodel", response_model=RecursiveItemViaSubmodel)
def get_recursive_submodel():
    return {
        "name": "item",

package p

// test case 1
type T /* ERROR "invalid recursive type" */ [U interface{ M() T[U] }] int

type X int

func (X) M() T[X] { return 0 }

// test case 2
type A /* ERROR "invalid recursive type" */ [T interface{ A[T] }] interface{}

// test case 3
type A2 /* ERROR "invalid recursive type" */ [U interface{ A2[U] }] interface{ M() A2[U] }