fun test() {

    <expr>outer@</expr>while(true) {
        inner@while(false) {
            break@outer
        }
    }

	interface{ m1(string) }.m1(x, "d")
	want += " m1(d)"

	g := struct{ T }.m2
	g(struct{ T }{})
	want += " m2()"

	if got != want {
		panic("got" + got + ", want" + want)
	}

	h := (*Outer).M
	got := h(&Outer{&Inner{"hello"}})
	want := "hello"
	if got != want {
		panic("got " + got + ", want " + want)
	}

    expression = if (cond()) {
                    break
                } else if (cond()) {
                    break@outer
                }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = true
  jumpExpressions = [
    break,
    break@outer
  ]
  returnValueType = null
  valuedReturnExpressions = []

fun test() {
    outer@ while (cond()) {
        consume(1)
        while (cond()) {
            consume(2)
            <expr>if (cond()) {
                break
            } else if (cond()) {
                break@outer
            }</expr>
        }
    }
}

fun consume(obj: Any?) {}

// in the scope and a link to the immediately surrounding (outer)
// scope.
//
// Deprecated: use the type checker [go/types] instead; see [Object].
type Scope struct {
	Outer   *Scope
	Objects map[string]*Object
}

// NewScope creates a new scope nested in the outer scope.
func NewScope(outer *Scope) *Scope {
	const n = 4 // initial scope capacity
	return &Scope{outer, make(map[string]*Object, n)}
}

	codec := serializer.NewCodecFactory(s).LegacyCodec(externalGV)

	inner := &runtimetesting.EmbeddedTest{
		ID: "inner",
	}
	outer := &runtimetesting.EmbeddedTest{
		ID:     "outer",
		Object: runtime.NewEncodable(codec, inner),
	}

	wire, err := runtime.Encode(codec, outer)
	if err != nil {
		t.Fatalf("Unexpected encode error '%v'", err)
	}

	t.Logf("Wire format is:\n%v\n", string(wire))

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	f[int]()
}

func f[T1 any]() {
	var x Outer[T1, int]
	x.M()
}

type Outer[T1, T2 any] struct{ Inner[T2] }

type Inner[_ any] int

    }

    def "inner classes are described"() {
        when:
        def sb = new StringBuilder()
        MethodModelRuleDescriptor.of(weakMethod(Outer.Inner, "noArgs")).describeTo(sb)

        then:
        sb.toString() == 'MethodModelRuleDescriptorTest.Outer.Inner#noArgs()'
    }

    private WeaklyTypeReferencingMethod weakMethod(Class type, String name) {
        def declaringType = ModelType.of(type)

    }

    def "nested afterEvaluate action is executed after outer action completes"() {
        given:

        buildFile """
            afterEvaluate {
                println "> Outer"
                afterEvaluate {
                    println "Inner"
                }
                println "< Outer"
            }
        """

        when:
        succeeds 'help'

// The ambiguously live variable here is the hiter
// for the inner range loop.

package main

import "runtime"

func f(m map[int]int) {
outer:
	for i := 0; i < 10; i++ {
		for k := range m {
			if k == 5 {
				continue outer
			}
		}
		runtime.GC()
		break
	}
	runtime.GC()
}
func main() {
	m := map[int]int{1: 2, 2: 3, 3: 4}
	f(m)