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)

}

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

// 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

	ok = m.match(typ, true)
	return m.reason, ok
}

// argMatcher recursively matches types against the printfArgType t.
//
// To short-circuit recursion, it keeps track of types that have already been
// matched (or are in the process of being matched) via the seen map. Recursion
// arises from the compound types {map,chan,slice} which may be printed with %d
// etc. if that is appropriate for their element types, as well as from type

// Note 2. About jn(n,x), yn(n,x)
//      For n=0, j0(x) is called,
//      for n=1, j1(x) is called,
//      for n<x, forward recursion is used starting
//      from values of j0(x) and j1(x).
//      for n>x, a continued fraction approximation to
//      j(n,x)/j(n-1,x) is evaluated and then backward
//      recursion is used starting from a supposed value
//      for j(n,x). The resulting value of j(0,x) is

TEXT ·chain1(SB),NOSPLIT,$48-0 // Doesn't go over
	RET
TEXT ·chain2(SB),NOSPLIT,$64-0
	CALL ·chainEnd(SB)
	RET
TEXT ·chainEnd(SB),NOSPLIT,$1000-0 // Should be reported twice
	RET

// Test reporting of rootless recursion
TEXT ·startRec(SB),NOSPLIT|NOFRAME,$0-0
	CALL ·startRec0(SB)
	RET
TEXT ·startRec0(SB),NOSPLIT|NOFRAME,$0-0
	CALL ·startRec(SB)

Checks: >
        # LINT.IfChange(checks)
        -*,clang-diagnostic-*,llvm-*,misc-*,
        -misc-unused-parameters,
        -misc-non-private-member-variables-in-classes,
        -misc-no-recursion,
        bugprone-argument-comment,
        bugprone-assert-side-effect,
        bugprone-branch-clone,
        bugprone-copy-constructor-init,
        bugprone-dangling-handle,
        bugprone-dynamic-static-initializers,