* equal to each other. If two {@linkplain Object#equals equal} inputs are given to this method,
   * both calls will return the same instance. That is, {@code intern(a).equals(a)} always holds,
   * and {@code intern(a) == intern(b)} if and only if {@code a.equals(b)}. Note that {@code
   * intern(a)} is permitted to return one instance now and a different instance later if the
   * original interned instance was garbage-collected.
   *

public class JavaClassWithInnerTypes implements Sub2Interface {
    /**
     * This is an inner enum.
     */
    enum InnerEnum {
    }

    /**
     * This is an inner class.
     */
    static class InnerClass {
        InnerEnum getEnumProp() { return null; }

        /**
         * This is an inner inner class.
         */
        class AnotherInner {
            InnerClass getOuter() { return null; }

class GroovyClassWithInnerTypes implements GroovyInterface {
    /**
     * This is an inner enum.
     */
    enum InnerEnum {}

    /**
     * This is an inner class.
     */
    static class InnerClass {
        InnerEnum enumProp

        /**
         * This is an inner inner class.
         */
        class AnotherInner {
            InnerClass outer
        }
    }

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

                println "inner 1: " + it
            }
            conf($('param')) {
                println "inner 2: " + it
            }
        }
    }
    tasks {
        show(Task) { doLast { println $.thing } }
    }
}
'''

        expect:
        succeeds "show"
        output.contains("outer 1: param")
        output.contains("inner 1: param")

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
}

}

// NewListener creates a Listener which accepts connections from an inner
// Listener and wraps each connection with [Server].
// The configuration config must be non-nil and must include
// at least one certificate or else set GetCertificate.
func NewListener(inner net.Listener, config *Config) net.Listener {
	l := new(listener)
	l.Listener = inner
	l.config = config
	return l
}

    }

    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 {

        }
    }