//fmt.Fprintln(os.Stderr, "Initiating panic")
		panic(rec)
	}
}

func recurseFnPanicRec(level int, maxlevel int) {
	defer func() {
		recover()
	}()
	recurseFn(level, maxlevel)
}

var saveInt uint32

func recurseFn(level int, maxlevel int) {

            "c": dependentSet(true, [], [])
        ])
        def deps = a.findTransitiveDependents(["a"], [:])

        expect:
        deps.dependencyToAll
    }

    def "recurses nested dependencies"() {
        def a = analysis([
            "Foo": dependentClasses([] as Set, ["Bar"] as Set),
            "Bar": dependentClasses([] as Set, ["Baz"] as Set),

		return &PathError{Op: "RemoveAll", Path: path, Err: syscall.EINVAL}
	}

	// Simple case: if Remove works, we're done.
	err := Remove(path)
	if err == nil || IsNotExist(err) {
		return nil
	}

	// RemoveAll recurses by deleting the path base from
	// its parent directory
	parentDir, base := splitPath(path)

	parent, err := Open(parentDir)
	if IsNotExist(err) {
		// If parent does not exist, base cannot exist. Fail silently

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"

package a

import (
	"unsafe"
)

func recurse(i int, s []byte) byte {
	s[0] = byte(i)
	if i == 0 {
		return s[i]
	} else {
		var a [1024]byte
		r := recurse(i-1, a[:])
		return r + a[0]
	}
}

//go:uintptrescapes
func F1(a uintptr) {
	var s [16]byte
	recurse(4096, s[:])
	*(*int)(unsafe.Pointer(a)) = 42
}

//go:uintptrescapes
func F2(a ...uintptr) {

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

			// It's a prefix for the field. Break and recurse
			// since it's not ok for one field path to be itself
			// the prefix for another field path.
			recurse = true

			// We can reuse the same slice as long as we
			// don't try to append to it.
			parents = finfo.parents[:len(parents)+1]
			break
		}
	}
	if !recurse {
		// We have no business with this element.
		return false, nil

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

// and change ID into ID-1 (our IDs start at 1, but text chars start at 0).
//
// map_32 packs the result, which is the input to the recursion,
// into the top of sa, so that the recursion result can be stored
// in the bottom of sa, which sets up for expand_8_32 well.
func map_32(sa []int32, numLMS int) {
	w := len(sa)
	for i := len(sa) / 2; i >= 0; i-- {
		j := sa[i]
		if j > 0 {
			w--
			sa[w] = j - 1
		}
	}