/**
     * Checks if entity contains annotation with specified [classId].
     *
     * The semantic is equivalent to
     * ```
     * annotationsList.hasAnnotation(classId) == annotationsList.annotations.any { it.classId == classId }
     * ```
     * @param classId [ClassId] to search
     */
    public operator fun contains(classId: ClassId): Boolean

    override fun isSearchInLibraries(): Boolean = base.isSearchInLibraries
    override fun contains(file: VirtualFile): Boolean =
        (base.contains(file) && !shadowed.contains(file)) || file.isFromGeneratedModule(useSiteModule)

    override fun toString() =
        "Analysis scope for $useSiteModule (base: $base, shadowed: $shadowed)"
}

        return Collections.emptyIterator()
    }

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        throw IndexOutOfBoundsException("Index $index out of bounds")
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return false
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return emptyList()
    }

    /**
     * Returns the list of subpackages for a given package, which satisfies [nameFilter].
     *
     * The returned sub-package list contains sub-packages visible to Kotlin. (e.g., for Kotlin/JVM, it should include Java packages)
     *
     * Generally, the result is equal to [getKotlinOnlySubPackagesFqNames] union with [getPlatformSpecificSubPackagesFqNames]
     */

        typeMapper.mapType(type, mode, signatureWriter)

        val canonicalSignature = signatureWriter.toString()
        require(!canonicalSignature.contains(SpecialNames.ANONYMOUS_STRING))

        if (canonicalSignature.contains("L<error>")) return null
        if (canonicalSignature.contains(SpecialNames.NO_NAME_PROVIDED.asString())) return null

        val signature = SignatureParsing.CharIterator(canonicalSignature)

        if (!cachedCallableNames.contains(name)) return

        baseScope.processFunctionsByName(name) { function ->
            if (isTargetCallable(function)) {
                processor(function)
            }
        }
    }

    override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
        if (!cachedCallableNames.contains(name)) return

    get() = annotations

/**
 * Checks if entity has annotation with specified [classId].
 *
 * @see [KaAnnotationList.contains]
 */
@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("classId in annotations"))
public fun KaAnnotated.hasAnnotation(classId: ClassId): Boolean {
    return annotations.contains(classId)
}

/**
 * A list of annotations applied with specified [classId].
 *
 * @see [KaAnnotationList.classIds]

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtClass
import org.jetbrains.kotlin.psi.KtClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.contains
import kotlin.collections.filter

@OptIn(LLFirInternals::class, SymbolInternals::class)
internal class KotlinStandaloneFirDirectInheritorsProvider(private val project: Project) : KotlinDirectInheritorsProvider {

     * Return a sequence of [KaClassifierSymbol] which current scope contains, if classifier name present in [names].
     *
     * @see getClassifierSymbols
     */
    public fun getClassifierSymbols(vararg names: Name): Sequence<KaClassifierSymbol> =
        getClassifierSymbols(names.toList())

    /**
     * Return a sequence of [KaConstructorSymbol] which current scope contain
     */

        val nextInlineFunctions = HashSet<KtDeclarationWithBody>()
        val collector = InlineFunctionsCollector(project, analyzeOnlyReifiedInlineFunctions) { declaration ->
            if (!analyzedElements.contains(declaration)) {
                nextInlineFunctions.add(declaration)
            }
        }
        val propertyAccessor = InlineDelegatedPropertyAccessorsAnalyzer(analysisContext, collector)