package structs

// HostLayout marks a struct as using host memory layout. A struct with a
// field of type HostLayout will be laid out in memory according to host
// expectations, generally following the host's C ABI.
//
// HostLayout does not affect layout within any other struct-typed fields
// of the containing struct, nor does it affect layout of structs
// containing the struct marked as host layout.
//

	t = u    // ERROR "cannot use .* in assignment|incompatible type"
	t = T(u)
}

func _() {
	type E struct{ x int }
	type S struct {
		f func(struct {
			x int "foo"
		})
	}
	type T struct {
		f func(struct {
			x int "bar"
		})
	}
	var s S
	var t T
	var u struct{ f func(E) }
	s = s
	s = t // ERROR "cannot use .* in assignment|incompatible type"

	var _ func() int

	type _ struct{}
	type _ *struct{}
	type _ []struct{}
	type _ map[string]struct{}
	type _ chan struct{}
	type _ func() struct{}

	type _ interface{}
	type _ *interface{}
	type _ []interface{}
	type _ map[string]interface{}
	type _ chan interface{}
	type _ func() interface{}

	var _ struct{}
	var _ *struct{}
	var _ []struct{}
	var _ map[string]struct{}

	A5 [10]A6
	A6 *A5

	// slices
	L0 []L0

	// structs
	S0 /* ERROR "invalid recursive type: S0 refers to itself" */ struct{ _ S0 }
	S1 /* ERROR "invalid recursive type: S1 refers to itself" */ struct{ S1 }
	S2 struct{ _ *S2 }
	S3 struct{ *S3 }

	S4 /* ERROR "invalid recursive type" */ struct{ S5 }
	S5 struct{ S6 }
	S6 S4

	// pointers
	P0 *P0
	PP *struct{ PP.f /* ERROR "PP.f is not a type" */ }

	// functions

	var _ func() int

	type _ struct{}
	type _ *struct{}
	type _ []struct{}
	type _ map[string]struct{}
	type _ chan struct{}
	type _ func() struct{}

	type _ interface{}
	type _ *interface{}
	type _ []interface{}
	type _ map[string]interface{}
	type _ chan interface{}
	type _ func() interface{}

	var _ struct{}
	var _ *struct{}
	var _ []struct{}
	var _ map[string]struct{}

	// []Elem
	SliceType struct {
		Elem Expr
		expr
	}

	// ...Elem
	DotsType struct {
		Elem Expr
		expr
	}

	// struct { FieldList[0] TagList[0]; FieldList[1] TagList[1]; ... }
	StructType struct {
		FieldList []*Field
		TagList   []*BasicLit // i >= len(TagList) || TagList[i] == nil means no tag for field i
		expr
	}

	// Name Type
	//      Type
	Field struct {

		`0  []int (len = 3) {
		1  .  0: 1
		2  .  1: 2
		3  .  2: 3
		4  }`},

	// structs
	{struct{}{}, `0  struct {} {}`},
	{struct{ x int }{007}, `0  struct { x int } {}`},
	{struct{ X, y int }{42, 991},
		`0  struct { X int; y int } {
		1  .  X: 42
		2  }`},
	{struct{ X, Y int }{42, 991},
		`0  struct { X int; Y int } {
		1  .  X: 42
		2  .  Y: 991
		3  }`},
}

// go.dev/issue/49482
type (
	t[a *[]int] struct{}
	t[a *t,] struct{}
	t[a *t|[]int] struct{}
	t[a *t|t,] struct{}
	t[a *t|~t,] struct{}
	t[a *struct{}|t] struct{}
	t[a *t|struct{}] struct{}
	t[a *struct{}|~t] struct{}
)

// go.dev/issue/51488
type (
	t[a *t|t,] struct{}
	t[a *t|t, b t] struct{}
	t[a *t|t] struct{}
	t[a *[]t|t] struct{}
	t[a ([]t)] struct{}
	t[a ([]t)|t] struct{}
)

type (
        // these need a comma to disambiguate
        _[P *T,] struct{}
        _[P *T, _ any] struct{}
        _[P (*T),] struct{}
        _[P (*T), _ any] struct{}
        _[P (T),] struct{}
        _[P (T), _ any] struct{}

        // these parse as name followed by type
        _[P *struct{}] struct{}
        _[P (*struct{})] struct{}
        _[P ([]int)] struct{}

        // array declarations
        _ [P(T)]struct{}

func _[P ~int, Q int | string]() {}
func _[P struct{f int}, Q *P]() {}

// various potentially ambiguous type parameter lists (issue #49482)
type _[P *T,] struct{}
type _[P T | T] struct{}
type _[P T | T | T | T] struct{}
type _[P *T, _ any] struct{}
type _[P (*T),] struct{}
type _[P (*T), _ any] struct{}
type _[P (T),] struct{}
type _[P (T), _ any] struct{}

type _[P *struct{}] struct{}
type _[P (*struct{})] struct{}