var cycle /* =@cycle */ = cycle /* @cycle */ + 1

type chain /* =@chain */ struct {
	next /* =@next */ *chain /* @chain */
}

func recursive /* =@recursive */() {
	recursive /* @recursive */ ()

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

// Issue 22904: Make sure the compiler emits a proper error message about
// invalid recursive types rather than crashing.

package p

type a struct{ b } // ERROR "invalid recursive type"
type b struct{ a } // GCCGO_ERROR "invalid recursive type"

var x interface{}

func f() {
	x = a{}

	// Per https://learn.microsoft.com/en-us/windows/win32/fileio/reparse-points-and-file-operations,
	// “Applications that use the CreateFile function should specify the
	// FILE_FLAG_OPEN_REPARSE_POINT flag when opening the file if it is a reparse
	// point.”
	//
	// And per https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew,
	// “If the file is not a reparse point, then this flag is ignored.”
	//

type I2 int

type I3 interface{ int } // ERROR "interface"

type S struct { // GC_ERROR "invalid recursive type"
	x interface{ S } // GCCGO_ERROR "interface"
}
type I4 interface { // GC_ERROR "invalid recursive type: I4 refers to itself"
	I4 // GCCGO_ERROR "interface"
}

type I5 interface { // GC_ERROR "invalid recursive type I5\n\tLINE:.* I5 refers to\n\tLINE+4:.* I6 refers to\n\tLINE:.* I5$"
	I6
}

type I6 interface {

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

package p

import "unsafe"

type T0 /* ERROR "invalid recursive type" */ [P T0[P]] struct{}

type T1 /* ERROR "invalid recursive type" */ [P T2[P]] struct{}
type T2[P T1[P]] struct{}

type T3 /* ERROR "invalid recursive type" */ [P interface{ ~struct{ f T3[int] } }] struct{}

// valid cycle in M
type N[P M[P]] struct{}
type M[Q any] struct { F *M[Q] }

		Value: &AnySliceTest{
			Nested: "b",
		},
	},

	// Test recursive types.
	{
		Value: &RecurseA{
			A: "a1",
			B: &RecurseB{
				A: &RecurseA{"a2", nil},
				B: "b1",
			},
		},
		ExpectXML: `<RecurseA><A>a1</A><B><A><A>a2</A></A><B>b1</B></B></RecurseA>`,
	},

	// Test ignoring fields via "-" tag
	{
		ExpectXML: `<IgnoreTest></IgnoreTest>`,

                    boolean allowStubModel,
                    boolean recursive,
                    boolean processPlugins) {
                super(session);
                this.path = path;
                this.source = source;
                this.allowStubModel = allowStubModel;
                this.recursive = recursive;
                this.processPlugins = processPlugins;
            }

      <replaceConfiguration name="Join combined with collect" suppressId="join_with_collect" problemDescriptor="Use a `join` method overload" text="$callJoin$($sep$, $callCollect$($src$, $transform$))" recursive="false" caseInsensitive="false" type="JAVA" pattern_context="default" reformatAccordingToStyle="true" shortenFQN="true" useStaticImport="true" replacement="org.gradle.util.internal.CollectionUtils.join($sep$, $src$, $transform$)">

		lastHandout:  metaCacheTestsetTimestamp,
		dataVersion:  metacacheStreamVersion,
	},
	1: {
		id:           "case-2-recursive",
		bucket:       "bucket",
		root:         "folder/prefix",
		recursive:    true,
		status:       scanStateSuccess,
		fileNotFound: false,
		error:        "",
		started:      metaCacheTestsetTimestamp,
		ended:        metaCacheTestsetTimestamp.Add(time.Minute),

package p

func Two() (a, b int)

// F used to compile.
func F() (x interface{}, y int) {
	return Two(), 0 // ERROR "single-value context|2\-valued"
}

// Recursive used to trigger an internal compiler error.
func Recursive() (x interface{}, y int) {
	return Recursive(), 0 // ERROR "single-value context|2\-valued"