@Test
    fun `can handle anonymous enum subtypes`() {
        EnumSuperType.values().forEach {
            assertThat(
                configurationCacheRoundtripOf(it),
                sameInstance(it)
            )
        }
    }

    enum class EnumSuperType {

        SubType1 {
            override fun displayName() = "one"
        },
        SubType2 {
            override fun displayName() = "two"

 *
 * <p>
 * Property annotations are inherited from super-types on a per-category basis: subtypes can override each super-type annotation category separately.
 * If a subtype doesn't override a super-type defined category, the corresponding annotation in that category gets inherited.
 * Subtypes can mark methods to be ignored by using an ignore annotation.
 * Ignored methods don't inherit super-type annotations.
 * </p>
 *

/**
 * [KaSubtypingErrorTypePolicy] determines the treatment of error types in type equality and subtyping checks.
 */
public enum class KaSubtypingErrorTypePolicy {
    /**
     * Error types are not considered equal to or subtypes of any other type.
     *
     * [STRICT] is the default policy for the following reasons:
     *

import java.io.Serializable


@ToolingModelContract(subTypes = [
    FunctionSemantics.ConfigureSemantics::class,
    FunctionSemantics.NewObjectFunctionSemantics::class,
    FunctionSemantics.Builder::class
])
sealed interface FunctionSemantics : Serializable {

    val returnValueType: DataTypeRef

    @ToolingModelContract(subTypes = [
        AccessAndConfigure::class,
        AddAndConfigure::class
    ])

    val schema = schemaFromTypes(
        TopLevelForSubtyping::class,
        listOf(
            TopLevelForSubtyping::class, SuperClass::class, SuperInterface::class, Subtype::class, NotASubtype::class
        )
    )

    @Test
    fun `type-checks assignment of subtype to superclass type`() {
        val result = schema.resolve(
            """
            superClassProp = sub()
            """.trimIndent()
        )

        )
    }

    override fun isSubTypeOf(subType: KaType, superType: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean {
        superType.assertIsValidAndAccessible()
        check(subType is KaFirType)
        check(superType is KaFirType)
        return AbstractTypeChecker.isSubtypeOf(
            createTypeCheckerContext(errorTypePolicy),
            subType.coneType,
            superType.coneType,
        )
    }

                " type policy.",
    )

    val IS_SUBTYPE by stringDirective(
        description = "Whether `type1` is a subtype of `type2` (`true` or `false`).",
    )

    val IS_SUBTYPE_LENIENT by stringDirective(
        description = "Whether `type1` is a subtype of `type2` (`true` or `false`) when using the `${KaSubtypingErrorTypePolicy.LENIENT}`" +
                " error type policy.",
    )
}

    }

    override fun isSubTypeOf(subType: KaType, superType: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean {
        require(subType is KaFe10Type)
        require(superType is KaFe10Type)
        return getTypeCheckerFor(errorTypePolicy).isSubtypeOf(subType.fe10Type, superType.fe10Type)
    }

@ToolingModelContract(subTypes = [
    DataType.NullType::class,
    DataType.UnitType::class,
    DataType.ConstantType::class,
    DataType.IntDataType::class,
    DataType.LongDataType::class,
    DataType.StringDataType::class,
    DataType.BooleanDataType::class,
    DataClass::class
])
sealed interface DataType : Serializable {

    @ToolingModelContract(subTypes = [
        IntDataType::class,

            serializationProblem("Task `:notDeclared` of type `Broken`: cannot serialize object of type 'org.gradle.api.internal.artifacts.configurations.DefaultConfigurationContainer', a subtype of 'org.gradle.api.artifacts.ConfigurationContainer', as these are not supported with the...