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

        )
    }

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

     * subtyping requirements, as [KaEnumEntryInitializerSymbol] is not a subtype of
     * [org.jetbrains.kotlin.analysis.api.symbols.KaAnonymousObjectSymbol]. (It cannot be a subtype in the general Analysis API because enum
     * entry initializers are classes in FE10.)
     */

import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.abbreviatedType
import org.jetbrains.kotlin.fir.types.toRegularClassSymbol

/**
 * Returns whether [subClass] is a strict subtype of [superClass]. Resolves [subClass] to [FirResolvePhase.SUPER_TYPES].
 */
fun isSubClassOf(subClass: FirClass, superClass: FirClass, useSiteSession: FirSession, allowIndirectSubtyping: Boolean = true): Boolean {

   *       Serializable}.
   *   <li>Serialization test is not performed on method return values unless the method is a
   *       visible static factory method whose return type is {@code C} or {@code C}'s subtype.
   * </ul>
   *
   * <p>In all cases, if {@code C} needs custom logic for testing serialization, you can add an
   * explicit {@code testSerializable()} test in the corresponding {@code CTest} class, and {@code

 *
 * A composite provider should only contain providers of the same base type as the composite provider itself, so implementations of
 * [KotlinCompositeProvider] should always be a subtype of their type argument [P]. (This is not enforceable in the Kotlin type system.)
 */
public interface KotlinCompositeProvider<P : KotlinComposableProvider> : KotlinComposableProvider {
    public val providers: List<P>
}

            // error is unfortunate, but to properly type this, we'd need to be able to restrict `KotlinCompositeProvider<P>` to be a
            // subtype of `P`, which is not possible in Kotlin.
            @Suppress("UNCHECKED_CAST")
            when (provider) {
                is KotlinCompositeProvider<*> -> (provider as KotlinCompositeProvider<P>).providers

        withValidityAssertion { analysisSession.typeProvider.approximateToSuperPublicDenotableType(this, approximateLocalTypes) }

    /**
     * Approximates [KaType] with a subtype which can be rendered in a source code
     *
     * Return `null` if the type do not need approximation and can be rendered as is