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
)

func (T9 /* ERRORx `invalid receiver type (\*\*T|T9)` */ ) m9() {}

		as5[54] = as6[(len(func(bool, G2) G3 {
			return G3("")
		}(false, G2(190.8)))|i1^i1)%i1-i1] + m2[68 != i || 'M'&'\xf4'|'H'&'\u1311' >= '4'&'\uab3e'>>uint(83) && (<-m6[G1(24)%i8_0] && <-ch1)][i].s1
		i = len([]G3{ast1[2].s0})
		i16_0 = <-ch6 / i16_0 & <-ch6
		i = (i1^i|i2|i2)/i + i
		m6 = m4
		am3 = am3
		m1[G2(869.6) == G2(i2)] = m2[func(float64, rune) byte {
			return func(G3, byte) byte {
				return byte(42)

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

            .dependsOn(m2, scope: 'runtime')
            .dependsOn(notRequired, scope: 'test')
            .dependsOn(notRequired, scope: 'provided')
            .publish()
        def m6 = mavenRepo.module('test', 'test6', '1.0')
            .dependsOn(m3, scope: 'compile')
            .dependsOn(m4, scope: 'runtime')
            .dependsOn(notRequired, scope: 'test')

                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["+"] }, "group": "g6"},
                { "module": "m7", "version": { "rejects": ["v7"] }, "group": "g7", "reason": "v7 is buggy"},

                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["v8"] }, "group": "g6"},
                { "module": "m7", "version": { "rejects": ["v7"] }, "group": "g7", "reason": "v7 is buggy"},

type n struct{}

func (r n) M1() int  { return a.G1 }
func (r n) M2() int  { return a.G2 }
func (r n) M3() int  { return a.G3 }
func (r n) M4() int  { return a.G4 }
func (r n) M5() int  { return a.G5 }
func (r n) M6() int  { return a.G6 }
func (r n) M7() int  { return a.G7 }
func (r n) M8() int  { return a.G8 }
func (r n) M9() int  { return a.G9 }

func (T[int]) m5()                                     {} // int is the type parameter name, not an instantiation

// inconvenient to have to choose a name. Since the receiver type expression
// serves as a declaration for its type parameters, we are free to choose the
// blank identifier:
func (t T1[_]) m6() {}

// Naturally, these rules apply to any number of type parameters on the receiver
// type. Here are some more complex examples.
type T2[A, B, C any] struct {
        a A
        b B
        c C
}

	F1:   "F1",
	F2:   "F2",
	F3:   "F3",
	F4:   "F4",
	F5:   "F5",
	F6:   "F6",
	F7:   "F7",
	M0:   "M0",
	M1:   "M1",
	M2:   "M2",
	M3:   "M3",
	M4:   "M4",
	M5:   "M5",
	M6:   "M6",
	M7:   "M7",
	X0:   "X0",
	X1:   "X1",
	X2:   "X2",
	X3:   "X3",
	X4:   "X4",
	X5:   "X5",
	X6:   "X6",
	X7:   "X7",
	X8:   "X8",
	X9:   "X9",
	X10:  "X10",
	X11:  "X11",