type S struct {
}

func (S) m()          { got += " m()" }
func (S) m1(s string) { got += " m1(" + s + ")" }

type T int

func (T) m2() { got += " m2()" }

type Outer struct{ *Inner }
type Inner struct{ s string }

func (i Inner) M() string { return i.s }

func main() {
	// method expressions with named receiver types
	I.m(S{})
	want += " m()"

	S.m1(S{}, "a")
	want += " m1(a)"

    --- FAIL: TestPanicHelper/1 (N.NNs)
        panic_test.go:NNN: TestPanicHelper/1
`,
	}, {
		desc:  "subtest panics with inner cleanup panic",
		flags: []string{"-test_panic_test=TestPanicHelper/1", "-test_panic_cleanup", "-test_panic_cleanup_panic=inner"},
		want: `
ran inner cleanup 1
ran middle cleanup 1
ran outer cleanup
--- FAIL: TestPanicHelper (N.NNs)
    panic_test.go:NNN: TestPanicHelper

type it struct {
	Floats bool
	inner  string
}

func main() {
	i1 := it{Floats: true}
	if i1.floats { // ERROR "(type it .* field or method floats, but does have field Floats)|undefined field or method"
	}
	i2 := &it{floats: false} // ERROR "cannot refer to unexported field floats in struct literal|unknown field|declared and not used"
	_ = &it{InneR: "foo"}    // ERROR "(but does have field inner)|unknown field"
	_ = i2

    public final inner class Operation$Subtract
}

public abstract class Operation {
    // source: 'classKinds.kt'
    private method <init>(): void
    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
    public final inner class Operation$Add
    public final inner class Operation$Negate
    public final inner class Operation$Subtract
}

    }

    def "inner class name format"() {
        expect:
        MethodDescription.name('a').owner(Outer.Inner).toString() == 'org.gradle.internal.reflect.MethodDescriptionTest$Outer$Inner#a'
    }

    class Outer {
        static class Inner {

        }
    }

	noVetErrorf := fmt.Errorf

	wrapped := errors.New("inner error")
	for _, test := range []struct {
		err        error
		wantText   string
		wantUnwrap error
		wantSplit  []error
	}{{
		err:        fmt.Errorf("%w", wrapped),
		wantText:   "inner error",
		wantUnwrap: wrapped,
	}, {
		err:        fmt.Errorf("added context: %w", wrapped),
		wantText:   "added context: inner error",
		wantUnwrap: wrapped,
	}, {

class X {
    fun foo() {
        class U {
            inner class K {
                inner class D {
                    fun check() {
                        class F {
                            inner class L
                        }
                    }
                }
            }

            class T
        }
    }

type RecomputeTrigger struct {
	inner StaticSingleton[int32]
	// krt will suppress events for unchanged resources. To workaround this, we constantly change and int each time TriggerRecomputation
	// is called to ensure our event is not suppressed.
	i *atomic.Int32
}

func NewRecomputeTrigger() *RecomputeTrigger {
	inner := NewStatic[int32](ptr.Of(int32(0)))
	return &RecomputeTrigger{inner: inner, i: atomic.NewInt32(0)}
}

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

    synthetic final field $title: java.lang.String
    inner (anonymous) class MainKt$ArticleScreenContent$2
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): void
}

public final class MainKt {
    // source: 'main.kt'
    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$2