configurations = configurations.map { ConfigurationEntry(it) }
)


internal
typealias TypedProjectSchemaEntryList = List<ProjectSchemaEntry<SchemaType>>


internal
fun ClassLoader.schemaTypeFor(typeString: String): SchemaType =
    SchemaType(loadTypeOf(typeString))


internal
fun ClassLoader.loadTypeOf(typeString: String) =

class TypeAccessibilityProviderTest : TestWithClassPath() {

    @Test
    fun `public generic type with primitive component type is accessible`() {

        val genericTypeWithPrimitiveComponent = SchemaType.of<PublicGenericType<String>>()
        assertThat(
            accessibilityFor(
                genericTypeWithPrimitiveComponent,
                classPath = jarClassPathWith(PublicGenericType::class)
            ),

    InaccessibilityReason.TypeErasure(type)


internal
fun accessible(type: SchemaType): TypeAccessibility =
    TypeAccessibility.Accessible(type)


internal
fun inaccessible(type: SchemaType, vararg reasons: InaccessibilityReason) =
    inaccessible(type, reasons.toList())


internal
fun inaccessible(type: SchemaType, reasons: List<InaccessibilityReason>): TypeAccessibility =

    publicType.concreteClass.let { schemaType ->
        // Because a public Java class might not correspond necessarily to a
        // public Kotlin type due to Kotlin `internal` semantics, we check
        // whether the public Java class is also the first public Kotlin type,
        // otherwise we compute a new schema entry with the correct Kotlin type.
        val firstPublicKotlinType = schemaType.firstPublicKotlinAccessorTypeOrSelf

}


data class SchemaType(val value: TypeOf<*>) {

    companion object {
        inline fun <reified T> of() = SchemaType(typeOf<T>())
    }

    val kotlinString = kotlinTypeStringFor(value)

    override fun toString(): String = kotlinString
}


typealias TypedProjectSchema = ProjectSchema<SchemaType>


data class ProjectSchema<out T>(

            }
        }

        val schema = settingsEvaluationSchema(settingsMock)

        val schemaType = schema.analysisSchema.dataClassesByFqName.values.find { it.name.simpleName == MyExtension::class.simpleName }
        assertNotNull(schemaType)
        assertTrue(schemaType!!.properties.any { it.name == "id" })

}


internal
fun namedDomainObjectContainerOf(elementType: SchemaType) =
    SchemaType(parameterizedTypeOf(typeOf<NamedDomainObjectContainer<*>>(), elementType.value))


internal
inline fun <reified ReceiverType, reified EntryType> entry(name: String): ProjectSchemaEntry<SchemaType> =
    ProjectSchemaEntry(SchemaType.of<ReceiverType>(), name, SchemaType.of<EntryType>())


private

        nameSpec,
        accessibleType<Configuration>()
    )


private
inline fun <reified T> accessibleType() =

    is TypeAccessibility.Accessible -> typeAccessibility.run { type.kmType to internalName() }
    is TypeAccessibility.Inaccessible -> KotlinType.any to InternalNameOf.javaLangObject
}


private
val SchemaType.kmType: KmType
    get() = value.kmType


private
val TypeOf<*>.kmType: KmType
    get() = when {
        isParameterized -> genericTypeOf(
            classOf(parameterizedTypeDefinition.concreteClass),