type M2 interface {
	map[string]int | map[string]float64
}
type M3 interface{ map[string]int | map[rune]int }
type M4[K comparable, V any] interface{ map[K]V | map[rune]V }

func g1[T M1](m T) {
	delete(m, "foo")
}

func g2[T M2](m T) {
	delete(m, "foo")
}

func g3[T M4[rune, V], V any](m T) {
	delete(m, 'k')
}

// make

func m1[
	S1 interface{ []int },
	S2 interface{ []int | chan int },

func (S0) m1 (x S0.m1 /* ERROR "S0.m1 is not a type" */ ) {}
func (S0) m2 (x *S0.m2 /* ERROR "S0.m2 is not a type" */ ) {}
func (S0) m3 () (x S0.m3 /* ERROR "S0.m3 is not a type" */ ) { return }
func (S0) m4 () (x *S0.m4 /* ERROR "S0.m4 is not a type" */ ) { return }

// interfaces may not have any blank methods
type BlankI interface {
	_ /* ERROR "methods must have a unique non-blank name" */ ()

func (A1[P]) m2() {}

type A2 = T[int]

func (A2 /* ERRORx `cannot define new methods on instantiated type (T\[int\]|A2)` */) m3()   {}
func (_ /* ERRORx `cannot define new methods on instantiated type (T\[int\]|A2)` */ A2) m4() {}

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

        {
            "attributes": { "usage": "runtime", "packaging": "zip" },
            "dependencyConstraints": [
                { "module": "m3", "group": "g3", "version": { "prefers": "v3" }},
                { "module": "m4", "version": { "requires": "v4", "strictly": "v4a", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},

        {
            "attributes": { "usage": "runtime", "packaging": "zip" },
            "capabilities": [
                { "group": "g1", "name": "m3", "version": "1.1" },
                { "group": "g2", "name": "m4", "version": "2.1" }
            ],
            "name": "runtime"
        }
    ]

package b

import "./a"

var N n

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 }

	}
}

type T struct{}

func (T) M1() {
L:
	goto L
}

func (T) M2() {
L:
	for {
		break L
	}
}

func (T) M3() {
L:
	for {
		continue L
	}
}

func (T) M4() {
	switch {
	case true:
		fallthrough
	default:
	}

func (R[P]) m1(R[R[P]])                                   {}
func (R[P]) m2(R[*P])                                     {}
func (R[P]) m3([unsafe.Sizeof(new(R[P]))]int)             {}
func (R[P]) m4([unsafe.Sizeof(new(R[R[P]]))]int)          {}

// Mutual recursion
type M[P any] int

func (R[P]) m5(M[M[P]]) {}

        {
            "attributes": { "usage": "runtime", "packaging": "zip" },
            "dependencies": [
                { "module": "m3", "group": "g3", "version": { "prefers": "v3" }},
                { "module": "m4", "version": { "requires": "v4", "prefers": "v3", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},

        moduleIdSet(["g1", "m1"], ["g2", "m2"], ["g3", "m3"], ["g4", "m4"]) | moduleSet("m1", "m2")                       | anyOf(moduleIdSet(["g3", "m3"], ["g4", "m4"]), moduleSet("m1", "m2"))

        moduleId("g1", "m1")                                                | groupSet("g1", "g2")                        | groupSet("g1", "g2")