class TopLevel {
        val configuredLazy = lazy { Inner() }
        val added = mutableListOf<Inner>()

        @Suppress("unused")
        @Configuring
        fun configuring(block: Inner.() -> Unit = { }) {
            configuredLazy.value.block()
        }

        @Adding
        fun adding(block: Inner.() -> Unit = { }) =
            Inner().also(block).also(added::add)

        @Suppress("unused")

	M()
}

type S struct {
	str string
}

func (s *S) M() {}

var _ I = &S{}

type CloningMap[K comparable, V any] struct {
	inner map[K]V
}

func (cm CloningMap[K, V]) With(key K, value V) CloningMap[K, V] {
	result := CloneBad(cm.inner)
	result[key] = value
	return CloningMap[K, V]{result}
}

func CloneBad[M ~map[K]V, K comparable, V any](m M) M {
	r := make(M, len(m))

  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
  // +optional
  optional PodStatus status = 3;
}

// Pod affinity is a group of inter pod affinity scheduling rules.
message PodAffinity {
  // If the affinity requirements specified by this field are not met at
  // scheduling time, the pod will not be scheduled onto the node.

	// Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
	// +optional
	PodAntiAffinity *PodAntiAffinity
}

// PodAffinity is a group of inter pod affinity scheduling rules.
type PodAffinity struct {
	// NOT YET IMPLEMENTED. TODO: Uncomment field once it is implemented.
	// If the affinity requirements specified by this field are not met at

 *
 * Inner classes are included because they are accessible from a value of the outer class. For example:
 *
 * ```
 * class Outer {
 *     inner class Inner
 * }
 *
 * fun foo() {
 *     val outer = Outer()
 *     outer.Inner()
 * }
 * ```
 *

            """
            inner {
                x = 1
                y = 1
                f()
            }
            """.trimIndent()
        )

        assertTrue { result.errors.isEmpty() }
    }

    @Test
    fun `access on a property is not allowed`() {
        val result = schema.resolve(
            """
            inner.x = 1
            inner.y = 1
            inner.f()

    inner (anonymous) class MainKt$ArticleScreenContent$1
    inner (anonymous) class MainKt$ArticleScreenContent$1$1
    method <init>(p0: java.lang.String): void
    public synthetic bridge method invoke(): java.lang.Object
    public final method invoke(): kotlin.jvm.functions.Function0
}

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

    }

    private boolean implementedDirectly(CtClass interf, CtClass c) {
        return c.interfaces.any { it.name == interf.name }
    }

    private boolean addedInterfaceIsIncubatingOrInternal(CtClass interf, CtClass c) {
        return (isIncubating(interf) && !isIncubating(c)) || isInternal(interf)
    }

    private boolean isIncubating(CtClass c) {

	// matches the outer literal's element type exactly, the inner
	// literal type may be omitted
	if inner, ok := x.(*ast.CompositeLit); ok {
		if match(nil, typ, reflect.ValueOf(inner.Type)) {
			inner.Type = nil
		}
	}
	// if the outer literal's element type is a pointer type *T
	// and the element is & of a composite literal of type T,
	// the inner &T may be omitted.
	if ptr, ok := astType.(*ast.StarExpr); ok {

   * 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.
   *