t.Errorf("T16.littleEndianStore got %x want %x\n", got, want)
	}
	t8.bigEndianStore(1<<8 + 2)
	if got, want := t8, (T8{1, 2}); got != want {
		t.Errorf("T8.bigEndianStore got %x want %x\n", got, want)
	}
	t8.littleEndianStore(1<<8 + 2)
	if got, want := t8, (T8{2, 1}); got != want {
		t.Errorf("T8.littleEndianStore got %x want %x\n", got, want)
	}

	Target() Element
}

// Check that accessing an interface method too early doesn't lead
// to follow-on errors due to an incorrectly computed type set.

type T8 interface {
	m() [unsafe.Sizeof(T8.m /* ERROR "undefined" */ )]int
}

	// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`
	// arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
	switch x.(type) {
	case I:
		return 1
	case J:
		return 2
	default:
		return 3
	}
}

func interfaceSwitch2(x K) int {
	// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`

type (
	T1  int
	T2  [10]int
	T3  []int
	T4  *int
	T5  chan int
	T6a chan<- int
	T6b chan (<-chan int)
	T6c chan<- (chan int)
	T7  <-chan *ast.File
	T8  struct{}
	T9  struct {
		a    int
		b, c float32
		d    []string `go:"tag"`
	}
	T10 struct {
		T8
		T9
		_ *T10
	}
	T11 map[int]string
	T12 any
	T13 interface {
		m1()
		m2(int) float32
	}
	T14 interface {
		T12
		T13

        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
        //           (see TODO in validtype.go).

        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
        T11 = T
)

}

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{

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

-T8
--builder

// 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 }
var x7p /* ERROR "initialization cycle" */ = new(T7p).m

type T8p int