private
        val propertyOriginalTypes = mutableMapOf<KClass<*>, MutableMap<String, KType>>()

        private
        val claimedFunctions = mutableMapOf<KClass<*>, MutableSet<KFunction<*>>>()

        fun addType(kClass: KClass<*>) {
            properties.getOrPut(kClass) { mutableMapOf() }
            propertyOriginalTypes.getOrPut(kClass) { mutableMapOf() }
        }

func buildTestEnv() (*cel.Env, error) {
	fooType := common.SchemaDeclType(simpleMapSchema("foo", spec.StringProperty()), true).MaybeAssignTypeName("fooType")
	barType := common.SchemaDeclType(simpleMapSchema("bar", spec.Int64Property()), true).MaybeAssignTypeName("barType")

	env, err := environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true).Extend(
		environment.VersionedOptions{

            val beanType = value.javaClass
            writeClass(beanType)
            val record = recordWritingOf(beanType, value)
            record.run { playback() }
        }
    }

    private
    fun recordWritingOf(beanType: Class<Externalizable>, value: Externalizable): RecordingObjectOutputStream =
        RecordingObjectOutputStream(beanType, value).also { recordingObjectOutputStream ->

    fun constructorForSerialization(beanType: Class<*>): Constructor<out Any> {
        return cache.get(beanType) { -> createConstructor(beanType) }
    }

    private
    fun createConstructor(beanType: Class<*>): Constructor<out Any> {
        // Initialize the super types of the bean type, as this does not seem to happen via the generated constructors
        maybeInit(beanType)

        encodePreservingIdentityOf(value) {
            val beanType = GeneratedSubclasses.unpackType(value)
            withBeanTrace(beanType) {
                writeBeanOf(beanType, value)
            }
        }
    }

    override suspend fun ReadContext.decode(): Any =
        decodePreservingIdentity { id ->
            val beanType = readClass()
            val generated = readBoolean()

)


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


private
fun relevantFieldsOf(beanType: Class<*>) =
    relevantTypeHierarchyOf(beanType)
        .flatMap(Class<*>::relevantFields)

    }

    def "reports when task field is declared with type #baseType"() {
        buildFile << """
            plugins { id "java" }

            class SomeBean {
                private ${baseType.name} badField
            }

            class SomeTask extends DefaultTask {
                private final ${baseType.name} badField
                private final bean = new SomeBean()

    val beanType = value.javaClass
    withBeanTrace(beanType) {
        writeClass(beanType)
        beanStateWriterFor(beanType).run {
            writeStateOf(value)
        }
    }
}


suspend fun ReadContext.decodeBean(): Any {
    val beanType = readClass()
    return withBeanTrace(beanType) {
        beanStateReaderFor(beanType).run {
            newBean(false).also {

}


fun IsolateContext.logUnsupported(
    action: String,
    baseType: KClass<*>,
    documentationSection: DocumentationSection = RequirementsDisallowedTypes,
    appendix: StructuredMessageBuilder = {}
) {
    logUnsupported(action, documentationSection, appendix) {
        text(" object of type ")
        reference(baseType)
    }
}


fun IsolateContext.logUnsupported(
    action: String,

    @Test
    fun `field of bean found in input property of task`() {

        val beanType = PropertyTraceTest::class.java
        val taskType = Task::class.java

        assertThat(
            PropertyTrace.Property(
                PropertyKind.Field,
                "f",
                PropertyTrace.Bean(
                    beanType,
                    PropertyTrace.Property(