package p

// Self recursion.
type i interface{ m() interface{ i } } // ERROR "invalid recursive type"
type _ interface{ i }                  // no redundant error

// Mutual recursion.
type j interface{ m() interface{ k } } // ERROR "invalid recursive type"
type k interface{ m() interface{ j } }

// Both self and mutual recursion.
type (
	a interface { // ERROR "invalid recursive type"

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

package p

// Type checking the following code should not cause an infinite recursion.
func f[M map[K]int, K comparable](m M) {
        f(m)
}

// Equivalent code using mutual recursion.
func f1[M map[K]int, K comparable](m M) {
        f2(m)
}
func f2[M map[K]int, K comparable](m M) {
        f1(m)

^V--- SKIP: chatty with recursion and json/#00/#01 (N.NNs)
^V=== NAME  chatty with recursion and json/#00
^V=== RUN   chatty with recursion and json/#00/#02
    sub_test.go:NNN: fail
^V--- FAIL: chatty with recursion and json/#00/#02 (N.NNs)
^V=== NAME  chatty with recursion and json/#00
^V--- FAIL: chatty with recursion and json/#00 (N.NNs)
^V=== NAME  chatty with recursion and json
^V--- FAIL: chatty with recursion and json (N.NNs)

}

// -----
// Handle error case of infinite recursion.
// expected-error @+1 {{recursive call graph cannot be transformed}}
module {
  func.func private @f() {
    func.call @f() : () -> ()
    func.call @f() : () -> ()
    func.return
  }
}

// -----
// Handle error case of infinite recursion with mutually recursive ops.
// expected-error @+1 {{recursive call graph cannot be transformed}}
module {

package p

import "unsafe"

// The actual example from the issue.
type List[P any] struct{}

func (_ List[P]) m() (_ List[List[P]]) { return }

// Other types of recursion through methods.
type R[P any] int

func (*R[R /* ERROR "must be an identifier" */ [int]]) m0() {}
func (R[P]) m1(R[R[P]])                                   {}
func (R[P]) m2(R[*P])                                     {}

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Based on what a {@link Type} is, dispatch it to the corresponding {@code visit*} method. By
 * default, no recursion is done for type arguments or type bounds. But subclasses can opt to do
 * recursion by calling {@link #visit} for any {@code Type} while visitation is in progress. For
 * example, this can be used to reject wildcards or type variables contained in a type as in:
 *

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Based on what a {@link Type} is, dispatch it to the corresponding {@code visit*} method. By
 * default, no recursion is done for type arguments or type bounds. But subclasses can opt to do
 * recursion by calling {@link #visit} for any {@code Type} while visitation is in progress. For
 * example, this can be used to reject wildcards or type variables contained in a type as in:
 *

	return
}

// B does a little bit of recursion dribbling not-zero onto the stack.
//go:noinline
func B(n int64) (res int64) {
	if n <= 1 { // Prefer to leave a 1 on the stack.
		return n
	}
	return 1 + B(n-1)
}

func main() {
	x, e := A(0, 0)
	for j := 0; j < 4; j++ { // j controls amount of B's stack dribble
		for i := 0; i < 1000; i++ { // try more and more recursion until stack growth occurs in newobject in prologue

// 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{})

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

package p

import "unsafe"

type T /* ERROR "invalid recursive type: T refers to itself" */ struct {
	T
}

func _(t T) {
	_ = unsafe.Sizeof(t) // should not go into infinite recursion here