override val symbolKind: KaSymbolKind get() = withValidityAssertion { getSymbolKind() }

    /**
     * We can use [FirRegularClassSymbol.rawStatus] to avoid unnecessary resolve unless there are status transformers present.
     * If they are present, we have to resort to [FirRegularClassSymbol.resolvedStatus] instead - otherwise we can observe incorrect status
     * properties.
     *

 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the
 * [declaration provider][org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProvider].
 *

        // `NewKotlinTypeCheckerImpl` is inconsistent with its error type leniency: `isSubtypeOf` is lenient by default while `equalTypes`
        // isn't. Hence, even without a `LENIENT` policy, we need to wrap `typeChecker` to achieve consistent strictness.
        return IsErrorTypeEqualToAnythingTypeChecker(typeChecker, errorTypePolicy == KaSubtypingErrorTypePolicy.LENIENT)
    }

    override fun getValue(thisRef: KaLifetimeOwner, property: KProperty<*>): T {
        return thisRef.withValidityAssertion { lazyValue.value }
    }
}

@Suppress("UnusedReceiverParameter") // we need to have the KtLifetimeOwner as receiver to make sure it's called only for KtLifetimeOwner
internal fun <T> KaLifetimeOwner.cached(init: () -> T): ValidityAwareCachedValue<T> {

            AnnotationUseSiteTarget.PROPERTY,
        )?.toDeprecationInfo()
    }

    private fun FirDeprecationInfo.toDeprecationInfo(): DeprecationInfo {
        // We pass null as the message, otherwise we can trigger a contract violation
        // as getMessage will call lazyResolveToPhase(ANNOTATION_ARGUMENTS)

    override val name: Name
        get() = withValidityAssertion { descriptor.name }

    // There doesn't seem to be a way to determine if `descriptor` has a body or not, so we return an initializer even for enum entries
    // without a body.
    override val enumEntryInitializer: KaEnumEntryInitializerSymbol?
        get() = this

For handy work with compiler tests it's recommended to use [
Kotlin Compiler Test Helper](https://github.com/demiurg906/test-data-helper-plugin)

### Dependency verification

We have a [dependencies verification](https://docs.gradle.org/current/userguide/dependency_verification.html) feature enabled in the

    // so the lowering fails.
    //
    // To solve the problem, we need to find all delegated properties with inline accessors
    // reachable from files that will be compiled, and include files these inline accessors
    // to the set of files that will be compiled (and do the same for these files recursively).
    // As it's basically a DAG traversal, we can keep a queue instead of making recursive calls.
    val allFiles = this

    override val token: KaLifetimeToken,
) : KaSmartCastProvider(), KaFirSessionComponent {

    private val KtExpression.isExplicitSmartCastInfoTarget: Boolean
        get() {
            // we want to handle only most top-level parenthesised expressions
            if (parent is KtParenthesizedExpression) return false

            // expressions like `|foo.bar()|` or `|foo?.baz()|` are ignored

            KaTypeMappingMode.VALUE_PARAMETER ->
                typeMapper.typeContext.getOptimalModeForValueParameter(type.fe10Type)
        }.let { typeMappingMode ->
            // Otherwise, i.e., if we won't skip type with no type arguments, flag overriding might bother a case like:
            // @JvmSuppressWildcards(false) Long -> java.lang.Long, not long, even though it should be no-op!