// may have a trailing comma.
type T7 struct {}

func (T7) m1() {}
func ((T7)) m2() {}
func ((*T7)) m3() {}
func (x *(T7),) m4() {}
func (x (*(T7)),) m5() {}
func (x ((*((T7)))),) m6() {}

// Check that methods with parenthesized receiver are actually present (issue #23130).
var (
	_ = T7.m1
	_ = T7.m2
	_ = (*T7).m3
	_ = (*T7).m4
	_ = (*T7).m5
	_ = (*T7).m6

type T6 struct {
	T9
	C T10
}

type T7 struct {
	T10
	T11
}

type T8 struct {
	T9
	C T7
}

type T9 struct {
	A T5
	B T3
	D T4
}

type T10 struct {
	W float64
}

type T11 struct {
	X float64
	Y float64
}

func MainTest(x T1, y T8, z T6) float64 {
	return Test(x.B, x.A, x.D, x.C, y.B, y.A, y.D, y.C, z.B, z.A, z.D,
		T7{
			T10: T10{
				W: z.C.W,
			},

}

func _(x T1, y T3) {
	x = y
}

// Check that interfaces are type-checked in order of
// (embedded interface) dependencies (was issue 7158).

var x1 T5 = T7(nil)

type T5 interface {
	T6
}

type T6 interface {
	m() T7
}
type T7 interface {
	T5
}

// Actual test case from issue 7158.

func wrapNode() Node {
	return wrapElement()
}

func wrapElement() Element {
	return nil

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

package main

type T1 struct {
	Next *T2
}

type T2 T1

type T3 struct {
	Next *T4
}

type T4 T5
type T5 T6
type T6 T7
type T7 T8
type T8 T9
type T9 T3

type T10 struct {
	x struct {
		y ***struct {
			z *struct {
				Next *T11
			}
		}
	}
}

type T11 T10

type T12 struct {
	F1 *T15
	F2 *T13

	_ map[T3]v    // ERROR "invalid map key"
	_ map[T4]v    // ERROR "invalid map key"
	_ map[T5]v
	_ map[T6]v
	_ map[T7]v
	_ map[T8]v
)

type T1 []int
type T2 struct { F T1 }
type T3 []T4
type T4 struct { F T3 }

type T5 *int
type T6 struct { F T5 }
type T7 *T4
type T8 struct { F *T7 }

func main() {
	m := make(map[int]int)
	delete()        // ERROR "missing arguments|not enough arguments"

        T2 interface { T1; T1 }
        T3 interface { T2; T2 }
        T4 interface { T3; T3 }
        T5 interface { T4; T4 }
        T6 interface { T5; T5 }
        T7 interface { T6; T6 }
        T8 interface { T7; T7 }
        T9 interface { T8; T8 }

        // TODO(gri) Enable this longer test once we have found a solution
        //           for the incorrect optimization in the validType check

type (
        T4 = ((*(T5)))
        T5 = T
)

func (T4) m4() {}
func _() { (T{}).m4 /* ERROR "cannot call pointer method m4 on T" */ () }
func _() { (&T{}).m4() }

type (
        T6 = (((T7)))
        T7 = (*(T8))
        T8 = T
)

func (T6) m6() {}
func _() { (T{}).m6 /* ERROR "cannot call pointer method m6 on T" */ () }
func _() { (&T{}).m6() }

type (
        T9 = *T10
        T10 = *T11

        _ E3[T3]
}

type T4 /* ERROR "invalid recursive type" */ [10]E5[T4]

type T5 struct {
	_ E0[E2[T5]]
}

type T6 struct {
	_ E0[E2[E0[E1[E2[[10]T6]]]]]
}

type T7 struct {
	_ E0[[10]E2[E0[E2[E2[T7]]]]]
}

type T8 struct {
	_ E0[[]E2[E0[E2[E2[T8]]]]]
}

type T9 /* ERROR "invalid recursive type" */ [10]E2[E5[E2[T9]]]

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

type I interface {
	m([unsafe.Sizeof(func() { I.m(nil, [n]byte{}) })]byte)
}

type E6p int
func (*E6p) m() int { _ = x6p; return 0 }
var x6p /* ERROR "initialization cycle" */ = (*T6p).m(nil)

// cycles through method values

type T7 int
func (T7) m() int { _ = x7; return 0 }
var x7 /* ERROR "initialization cycle" */ = T7(0).m

type T8 int
func (T8) m() int { _ = x8; return 0 }
var x8 /* ERROR "initialization cycle" */ = T8(0).m()

type T7p int
func (*T7p) m() int { _ = x7p; return 0 }