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

    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
}

 *
 * @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

/**

    <caret_context>val x = 0
}

// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
// Need to choose public foo(Any) call instead of more specific but private call foo(Int)

        }
    }

    /**
     * [KaFirEnumEntryInitializerSymbol] is the required return type instead of [KaEnumEntryInitializerSymbol] to fulfill return type
     * subtyping requirements, as [KaEnumEntryInitializerSymbol] is not a subtype of

    /**
     * A [CallableId] of a substituted symbol
     */
    public open val callableId: CallableId? get() = withValidityAssertion { symbol.callableId }

    @Deprecated("Use `callableId` instead.", ReplaceWith("callableId"))
    public val callableIdIfNonLocal: CallableId? get() = callableId

    /**
     * Applies a [substitutor] to the given signature and return a new signature with substituted types.
     *

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

    /**
     * The callable's [CallableId] if it exists, or `null` otherwise (e.g. when the callable is local).
     */
    public abstract val callableId: CallableId?

    @Deprecated("Use `callableId` instead.", ReplaceWith("callableId"))
    public val callableIdIfNonLocal: CallableId? get() = callableId

    public abstract val returnType: KaType

    public abstract val receiverParameter: KaReceiverParameterSymbol?

 * [TestModuleKind][org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind] supplied by generated tests applies to
 * the expansion-site module instead of the use-site module in these tests, as we want to check the `KaType` when it's built with an
 * expanded type from a library vs. from a source module. (Abbreviated types from libraries and from sources aren't necessarily constructed

     * 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

    /**