annotation class Anno(val value: KClass<*>)

@Anno(Array<Array<String>>::class)

annotation class Anno(val value: KClass<*>)

@Anno(List<String>::class)

        bind(type.java, codec)

    fun bind(type: KClass<*>, serializer: Serializer<*>) =
        bind(type.java, serializer)

    fun bind(type: Class<*>, serializer: Serializer<*>) =
        bind(type, SerializerCodec(serializer))

    fun bind(type: Class<*>, codec: Codec<*>) {
        require(bindings.all { it.encodingForType(type) == null }) {
            "There's already an encoding for type '$type'"

annotation class Anno(val value: KClass<*>)

@Anno(IntArray::class)

annotation class Anno(val value: KClass<*>)

fun test() {
    class LocalClass {}

    @Anno(LocalClass::class)
    fun loc<caret>al() {}

    local()

    private static Set<Class<?>> findAnnotatedSupertypes(Class<?> serviceType) {
        Set<Class<?>> annotatedSuperTypes = new LinkedHashSet<Class<?>>();

        Set<Class<?>> seen = new HashSet<Class<?>>();
        seen.add(Object.class);

        Queue<Class<?>> queue = new ArrayDeque<Class<?>>();
        queue.add(serviceType);

        while (!queue.isEmpty()) {

    private
    val schema = schemaFromTypes(Receiver::class, listOf(Receiver::class))

    @Suppress("unused")
    private
    abstract class Receiver {
        @Adding
        abstract fun lambdaRequired(x: Int, configure: Receiver.() -> Unit): Receiver

        @Adding
        abstract fun lambdaOptional(x: Int, configure: Receiver.() -> Unit = { }): Receiver

        @Adding
        abstract fun lambdaNotAllowed(x: Int): Receiver

    }

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);
        Optional<String> reasonNotToTrackState = Optional.ofNullable(type.getAnnotation(UntrackedTask.class))
            .map(UntrackedTask::because);
        Map<String, Class<?>> processedMethods = new HashMap<>();

            System.setProperty("java.security.manager", securityManagerType);
            SecurityManager securityManager;
            try {
                Class<?> aClass = systemClassLoader.loadClass(securityManagerType);
                securityManager = (SecurityManager) JavaReflectionUtil.newInstance(aClass);
            } catch (Exception e) {

    object Gradle : PropertyTrace()

    class BuildLogic(
        val source: DisplayName,
        val lineNumber: Int? = null
    ) : PropertyTrace()

    class BuildLogicClass(
        val name: String
    ) : PropertyTrace()

    class Task(
        val type: Class<*>,
        val path: String
    ) : PropertyTrace()

    class Bean(
        val type: Class<*>,
        val trace: PropertyTrace