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

import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
import kotlin.reflect.KClass

public class KaPsiBasedSymbolPointer<S : KaSymbol> private constructor(
    private val psiPointer: SmartPsiElementPointer<out KtElement>,
    private val expectedClass: KClass<S>,
) : KaSymbolPointer<S>() {
    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KaSession.restoreSymbol")

        Class<?> aClass = readClass();
        ObjectStreamClass descriptor = ObjectStreamClass.lookupAny(aClass);
        if (descriptor == null) {
            throw new ClassNotFoundException(aClass.getName());
        }
        return descriptor;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {

import java.lang.reflect.Modifier.isStatic
import java.lang.reflect.Modifier.isTransient
import kotlin.reflect.KClass


val unsupportedFieldDeclaredTypes = listOf(
    Configuration::class,
    SourceDirectorySet::class
)


internal
fun relevantStateOf(beanType: Class<*>): List<RelevantField> =
    when (IConventionAware::class.java.isAssignableFrom(beanType)) {
        true -> applyConventionMappingTo(beanType, relevantFieldsOf(beanType))

                .or(type(KClass.class))
                .or(type(KClass[].class))
                .or(type(KProperty.class))
                .or(type(Pair[].class))
                .as("Kotlin classes")
            );
    private static final DescribedPredicate<JavaClass> public_api_tasks_or_plugins =
            gradlePublicApi().and(assignableTo(Task.class).or(assignableTo(Plugin.class)));

    @ArchTest

import org.gradle.internal.declarativedsl.schemaBuilder.ConfigureLambdaHandler
import kotlin.reflect.KClass
import kotlin.reflect.full.memberFunctions


interface RuntimeFunctionResolver {
    fun resolve(receiverClass: KClass<*>, name: String, parameterValueBinding: ParameterValueBinding): Resolution

    sealed interface Resolution {
        data class Resolved(val function: DeclarativeRuntimeFunction) : Resolution

        analyze(SomeSourceAnnotation).privateClassDependencies.isEmpty()
        analyze(SomeSourceAnnotation).dependencyToAllReason
    }

    InputStream classStream(Class aClass) {
        aClass.classLoader.getResourceAsStream(aClass.getName().replace(".", "/") + ".class")
    }

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

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

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

@Anno(Array<String>::class)