'adding'   | 'class A { } \nclass B { } \n'            | 'class A{}\nclass B{}\nclass C{}'          | ['A', 'B', 'C']  | []
        'removing' | 'class A { } \nclass B { } \nclass C { }' | 'class A{}\nclass B{}\n'                   | ['A', 'B']       | ['C']
        'changing' | 'class A { } \nclass B { } \nclass C { }' | 'class A{}\nclass B{}\n class C { int i }' | ['A', 'B', 'C']  | []
    }

            // Class<T> to KClass<T>
            objects.property(Long::class)

            // Groovy named arguments to vararg of Pair
            fileTree("dir" to "src", "excludes" to listOf("**/ignore/**", "**/.data/**"))

            // Class<T> + Action<T> to KClass<T> + T.() -> Unit
            tasks.register("foo", Copy::class) {
                from("src")
                into("dst")

        then:
        received1.class.classLoader == received2.class.classLoader
        received1.payload.class.classLoader == received2.payload.class.classLoader
        reply1.class == wrapperClass
        reply1.payload.class == payloadClass
        reply2.class == wrapperClass
        reply2.payload.class == payloadClass
    }

    void assertNotVisible(Class<?> from, Class<?> to) {
        try {

package org.gradle.kotlin.dsl.fixtures

import kotlin.reflect.KClass


fun classEntriesFor(classes: Array<out KClass<*>>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntriesFor(vararg classes: Class<*>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)

    }
}


private
fun KClassifier.isInScope(typeScope: DataSchemaBuilder.PreIndex) =
    isBuiltInType || this is KClass<*> && typeScope.hasType(this)


private
val KClassifier.isBuiltInType: Boolean
    get() = when (this) {
        Int::class, String::class, Boolean::class, Long::class, Unit::class -> true
        else -> false
    }


val KCallable<*>.annotationsWithGetters: List<Annotation>

// FILE: issue/pack/RowIcon.java
package issue.pack;

public class RowIcon {
    public static class RClass {}
}

// FILE: usage.kt
package usage

fun testJavaNestedClass(alignment: issue.pack.RowIcon.RClass) {
}

fun checkIt() {
    testJavaNestedClass(issue.pack.RowIcon.RClass())

    val writeOnlyPropertyContributor = object : PropertyExtractor {
        override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> {
            return if (kClass == MyReceiver::class) {
                listOf(
                    CollectedPropertyInformation(
                        "z",
                        typeOf<Int>(),

// MODULE: dep
// FILE: issue/pack/RowIcon.java
package issue.pack;

public class RowIcon {
    public class RClass {}
}

// MODULE: main(dep)
// FILE: usage.kt
package usage

fun testJavaNestedClass(alignment: issue.pack.RowIcon.RClass) {
}

fun checkIt() {
    testJavaNestedClass(issue.pack.RowIcon().RClass())

     */
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        kClass.memberFunctions
            .filter { memberFilter.shouldIncludeMember(it) }
            .mapNotNullTo(mutableSetOf()) { fn -> fn.parameters.lastOrNull()?.let { configureLambdas.getTypeConfiguredByLambda(it.type)?.classifier as? KClass<*> } }
}


private
class FunctionReturnTypeDiscovery(

    }
}


private
class PropertyReturnTypeDiscovery(
    private val propertyExtractor: PropertyExtractor
) : TypeDiscovery {
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        propertyExtractor.extractProperties(kClass).mapNotNull { propertyValueType(it.originalReturnType).classifier as? KClass<*> }
}


private