/**
     * 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 contains(classId: ClassId): Boolean = withValidityAssertion {
        return backingAnnotations.any { it.classId == classId }
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return backingAnnotations.filter { it.classId == classId }
    }

    override val classIds: Collection<ClassId>
        get() = withValidityAssertion {

        fe10Annotations.hasAnnotation(classId.asSingleFqName())
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        if (classId in ignoredAnnotations) return@withValidityAssertion emptyList()

        fe10Annotations.mapIndexedNotNull { index, annotation ->
            if (annotation.classIdForAnnotation != classId) {

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

    override val classIds: Set<ClassId>
        get() = withValidityAssertion { emptySet() }

public fun KaAnnotated.annotationsByClassId(classId: ClassId): List<KaAnnotation> {
    return annotations[classId]
}

/**
 * A list of annotations applied.
 *
 * @see [KaAnnotationList.classIds]
 */
@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("annotations.classIds"))
public val KaAnnotated.annotationClassIds: Collection<ClassId>

    public val DOUBLE: ClassId = ClassId.topLevel(StandardNames.FqNames._double.toSafe())
    public val CHAR: ClassId = ClassId.topLevel(StandardNames.FqNames._char.toSafe())
    public val BOOLEAN: ClassId = ClassId.topLevel(StandardNames.FqNames._boolean.toSafe())
    public val STRING: ClassId = ClassId.topLevel(StandardNames.FqNames.string.toSafe())

        }
    }

    data class SamConstructorData(val classId: ClassId) : SymbolData() {
        override fun KaSession.toSymbols(ktFile: KtFile): List<KaSymbol> {
            val symbol = getClassOrObjectSymbolByClassId(classId)
                ?: getTypeAliasByClassId(classId)
                ?: error("Class-like symbol is not found by '$classId'")

        require(!owner.isLocal) {
            "Unexpected local Java class in ${FirJavaDeclaredMembersOnlyScope::class.simpleName}."
        }
    }

    private fun FirCallableDeclaration.isDeclared(): Boolean =
        symbol.callableId.classId == owner.classId
                && origin !is FirDeclarationOrigin.SubstitutionOverride
                && origin != FirDeclarationOrigin.IntersectionOverride

    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return hasAnnotation(firSymbol, classId, useSiteSession)
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return annotationsByClassId(firSymbol, classId, builder)
    }

    override val classIds: Collection<ClassId>
        get() = withValidityAssertion {

            }
        }

    override fun getClassLikeDeclarationByClassId(classId: ClassId): KtClassLikeDeclaration? {
        return getClassLikeDeclarationsByClassId(classId).firstOrNull()
    }

    override fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject> {
        return getClassLikeDeclarationsByClassId(classId).filterIsInstance<KtClassOrObject>().toList()
    }