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))

import org.junit.Assert.assertTrue
import org.junit.Test
import kotlin.reflect.KClass


class GeneralGradleDslSchemaTest {
    @Test
    fun `general dsl schema has types discovered via action functions`() {
        val schema = schemaFrom(TopLevelReceiver::class)
        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test

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

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

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

@Anno(Array<String>::class)

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

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

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

@Anno(List<String>::class)

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

@Anno(IntArray::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<*>)

fun test() {
    class LocalClass {}

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

    local()

import kotlin.reflect.KClass


/**
 * Utility [TypeDiscovery] implementation that allows introducing [discoverClasses] as soon as [keyClass] is encountered in type discovery.
 */
internal
class FixedTypeDiscovery(private val keyClass: KClass<*>, private val discoverClasses: List<KClass<*>>) : TypeDiscovery {
    override fun getClassesToVisitFrom(kClass: KClass<*>): Iterable<KClass<*>> =
        when (kClass) {