tests := []struct {
		name            string
		path            string
		recursive       bool
		fileExtensions  []string
		expectedPaths   []string
		expectPathError bool
	}{
		{
			name:           "Recursive with default file extensions",
			path:           testDir,
			recursive:      true,
			fileExtensions: FileExtensions,
			expectedPaths: []string{

package main

type T0 T0 // ERROR "invalid recursive type"
type _ map[T0]int

type T1 struct{ T1 } // ERROR "invalid recursive type"
type _ map[T1]int

func f() {
	type T2 T2 // ERROR "invalid recursive type"
	type _ map[T2]int
}

func g() {
	type T3 struct{ T3 } // ERROR "invalid recursive type"
	type _ map[T3]int
}

func h() {

package p

// parameterized types with self-recursive constraints
type (
	T1 /* ERROR "invalid recursive type" */ [P T1[P]]                            interface{}
	T2 /* ERROR "invalid recursive type" */ [P, Q T2[P, Q]]                      interface{}
	T3[P T2[P, Q], Q interface{ ~string }] interface{}

package p

// test case 1
type T /* ERROR "invalid recursive type" */ [U interface{ M() T[U] }] int

type X int

func (X) M() T[X] { return 0 }

// test case 2
type A /* ERROR "invalid recursive type" */ [T interface{ A[T] }] interface{}

// test case 3
// TODO(gri) should report error only once
type A2 /* ERROR "invalid recursive type" */ /* ERROR "invalid recursive type" */ [U interface{ A2[U] }] interface{ M() A2[U] }

type Error interface{ error }

var err Error
var _ = err.Error()


// more esoteric cases

type (
	T1 interface { T2 }
	T2 /* ERROR "invalid recursive type" */ T2
)

type (
	T3 interface { T4 }
	T4 /* ERROR "invalid recursive type" */ T5
	T5 = T6
	T6 = T7
	T7 = T4
)


// arbitrary code may appear inside an interface

const n = unsafe.Sizeof(func(){})

	}

	B1 struct {
		_ [unsafe.Sizeof(A1 /* ERROR "invalid recursive type" */ {})]int
	}
)

// a mutually recursive case using len
type (
	A2 struct {
		f [len(B2{}.f)]int
	}

	B2 struct {
		f [len(A2 /* ERROR "invalid recursive type" */ {}.f)]int
	}
)

// test case from issue
type a struct {
	_ [42 - unsafe.Sizeof(a /* ERROR "invalid recursive type" */ {})]byte

        }
        this.type = type;
    }

    @Override
    public boolean isRecursive() {
        return recursive;
    }

    @Override
    public void setRecursive(boolean recursive) {
        this.recursive = recursive;
    }

    @Override
    public ResourceFilterMatcher getMatcher() {
        return matcher;
    }

	Si  a.S[Si]             // ERROR "invalid recursive type"
	Pi  a.P[Pi]             // ok (indirection through a.P)
	M1i a.M[int, M1i]       // ok (indirection through a.M)
	M2i a.M[a.A[byte], M2i] // ok (indirection through a.M)

	A2i a.A[a.S[a.P[A2i]]] // ok (indirection through a.P)
	A3i a.A[a.S[a.S[A3i]]] // ERROR "invalid recursive type"

	T2 a.S[T0[T2]] // ERROR "invalid recursive type"

# Guia de Usuário Avançado

## Recursos Adicionais

O [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} deve ser o suficiente para dar a você um tour por todos os principais recursos do **FastAPI**.

Na próxima seção você verá outras opções, configurações, e recursos adicionais.

!!! tip "Dica"
    As próximas seções **não são necessáriamente "avançadas"**

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