* ```
     * @param classId [ClassId] to search
     */
    public operator fun contains(classId: ClassId): Boolean

    @Deprecated("Use 'contains' instead.", replaceWith = ReplaceWith("contains(classId)"))
    public fun hasAnnotation(classId: ClassId): Boolean = contains(classId)

    /**
     * A list of annotations applied with specified [classId].
     *

 *
 * @see [KaAnnotationList.annotations]
 */
@Deprecated("Use the 'annotations' the member property instead.")
public val KaAnnotated.annotations: List<KaAnnotation>
    get() = annotations

@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("annotations"))
public val KaAnnotated.annotationInfos: List<KaAnnotationApplicationInfo>
    get() = annotations

/**

    public abstract val qualifiers: List<KaClassTypeQualifier.KaResolvedClassTypeQualifier>

    @Deprecated("Use 'symbol' instead.", ReplaceWith("symbol"))
    public val classSymbol: KaClassLikeSymbol
        get() = symbol

    @Deprecated("Use 'typeArguments' instead.", ReplaceWith("typeArguments"))
    public val ownTypeArguments: List<KaTypeProjection>
        get() = typeArguments
}

        // which results in an exception since we don't have a decompiler for them. See KT-64898, KT-64899, and KT-64900. If not for these
        // issues, we would be able to use `analyze` instead of custom session logic.
        val session = LLFirSessionCache.getInstance(project).getSession(ktModule, preferBinary = true)
        return session.symbolProvider.getClassLikeSymbolByClassId(classId)
    }

     * because effectively you already have all necessary information in [KaAnnotationApplicationInfo]
     */
    public val hasArguments: Boolean

    @Deprecated("Use 'hasArguments' instead.", replaceWith = ReplaceWith("hasArguments"))
    public val isCallWithArguments: Boolean
        get() = hasArguments

    /**

    get() = (this as? KaNonErrorClassType)?.symbol

/**
 * Returns a [KtClassLikeSymbol] for this [KtType] if the type represents a uniquely resolvable class/object/type alias.
 */
@Deprecated("Use 'symbol' instead.", ReplaceWith("this.symbol"))
public val KtType.classSymbol: KaClassLikeSymbol?
    get() = symbol

/**

/**
 * An optional [KotlinPlatformComponent]. The Analysis API engine does not require an optional platform component to be implemented and
 * will use sensible fallbacks or disable/avoid certain behaviors instead.
 */

     *
     * #### Example 1
     *
     * ```
     * val x = 10<caret>
     * val z = x
     * ```
     *
     * If we change the initializer of `x` to `"str"` the return type of `x` will become `String` instead of the initial `Int`. This will
     * change the return type of `z` as it does not have an explicit type. So, it is an **OOBM**.
     *
     * #### Example 2
     *
     * ```
     * val x: Int = 10<caret>

    /**
     * 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.
     *
     * TODO This optimization should become obsolete after KT-56551 is fixed.
     */

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.utils.filterIsInstanceAnd

/**
 * This implementation works only for FQN annotations usages (`@foo.Bar` instead of `@Bar`).
 * It does not perform the full resolve of the annotation call, but it checks whether the annotation
 * with such FQN is present in the [scope] with [KotlinDeclarationProvider].
 *