* 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

    /**

                    { declarationRenderer.annotationRenderer.renderAnnotations(analysisSession, symbol, printer) },
                    {
                        // do not render (val a: Int, val b: Int), render `(a: Int, b: Int)` instead
                        val rendererWithoutValVar = declarationRenderer.with {
                            keywordsRenderer = keywordsRenderer.with {
                                keywordFilter =

    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].
 *

    // 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
    val filesQueueToAnalyze = ArrayDeque(allFiles)
    val collector = InlineFunctionsCollector(allFiles.first().project, reifiedInlineFunctionsOnly = false) { declaration ->

    /**
     * The [ClassId] of this class, or `null` if this class is local.
     */
    public abstract val classId: ClassId?

    @Deprecated("Use `classId` instead.", ReplaceWith("classId"))
    public val classIdIfNonLocal: ClassId? get() = classId

    abstract override fun createPointer(): KaSymbolPointer<KaClassLikeSymbol>
}

        originalFile: KtFile,
        nameExpression: KtSimpleNameExpression,
        explicitReceiver: KtExpression?
    ): KaCompletionExtensionCandidateChecker

    @Deprecated("Use createExtensionCandidateChecker() instead.")
    public abstract fun checkExtensionFitsCandidate(
        firSymbolForCandidate: KaCallableSymbol,
        originalFile: KtFile,
        nameExpression: KtSimpleNameExpression,