package p

type I1 = interface {
	I2
}

// BAD: type loop should mention I1; see also #41669
type I2 interface { // GC_ERROR "invalid recursive type: I2 refers to itself"
	I1 // GCCGO_ERROR "invalid recursive interface"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// issue 8507
// used to call algtype on invalid recursive type and get into infinite recursion

package p

type T struct{ T } // ERROR "invalid recursive type.*T"

func f() {
	println(T{} == T{})

func (B1 /* ERRORx "cannot define new methods on non-local type (int|B)" */ ) n() {}

// cycles
type (
	C2 /* ERROR "invalid recursive type" */ = C2
	C3 /* ERROR "invalid recursive type" */ = C4
	C4 = C3
	C5 struct {
		f *C6
	}
	C6 = C5
	C7 /* ERROR "invalid recursive type" */  struct {
		f C8
	}
	C8 = C7
)

// embedded fields
var (
	s0 struct { T0 }

// HasActiveRules - returns whether replication policy has active rules
// Optionally a prefix can be supplied.
// If recursive is specified the function will also return true if any level below the
// prefix has active rules. If no prefix is specified recursive is effectively true.
func (c Config) HasActiveRules(prefix string, recursive bool) bool {
	if len(c.Rules) == 0 {
		return false
	}
	for _, rule := range c.Rules {

    private final boolean recursive;

    public ResolvableConfigurationsSpec(@Nullable String searchTarget, boolean showLegacy, boolean recursive, boolean showAttributePrecedence) {
        super(searchTarget, showLegacy, showAttributePrecedence);
        this.recursive = recursive;
    }

    @Override
    public String getReportedTypeAlias() {

    name: str


RecursiveSubitemInSubmodel.update_forward_refs()


@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",

	createTestDir(t, fmt.Sprintf("%s/%s", tmpDir, "recursive/pod/pod_1"))
	createTestDir(t, fmt.Sprintf("%s/%s", tmpDir, "recursive/rc/rc_1"))
	createTestDir(t, fmt.Sprintf("%s/%s", tmpDir, "inode/hardlink"))
	defer os.RemoveAll(tmpDir)

	// create test files
	writeTestFile(t, fmt.Sprintf("%s/recursive/pod/busybox.json", tmpDir), strings.Replace(aPod, "{id}", "0", -1))

				return
			}
		case "BaseDir":
			z.BaseDir, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "BaseDir")
				return
			}
		case "Recursive":
			z.Recursive, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Recursive")
				return
			}
		case "ReportNotFound":
			z.ReportNotFound, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "ReportNotFound")
				return

	}
	S3 struct {
		x S2
	}
	S4/* ERROR "invalid recursive type" */ struct {
		S4
	}
	S5 /* ERROR "invalid recursive type" */ struct {
		S6
	}
	S6 struct {
		field S7
	}
	S7 struct {
		S5
	}

	L1 []L1
	L2 []int

	A1 [10.0]int
	A2 /* ERROR "invalid recursive type" */ [10]A2
	A3 /* ERROR "invalid recursive type" */ [10]struct {
		x A4
	}
	A4 [10]A3

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

package p

// The example from the issue.
type (
	N[P any] M /* ERROR "invalid recursive type" */ [P]
	M[P any] N[P]
)

// A slightly more complicated case.
type (
	A[P any] B /* ERROR "invalid recursive type" */ [P]
	B[P any] C[P]
	C[P any] A[P]
)

// Confusing but valid (note that `type T *T` is valid).
type (
	N1[P any] *M1[P]