// Handle callable declarations with explicit return type first
        if (declaration is KtCallableDeclaration) {
            val typeReference = declaration.typeReference

            if (typeReference != null) {
                val bindingContext = analysisContext.analyze(typeReference, AnalysisMode.PARTIAL)
                val kotlinType =
                    if (declaration is KtParameter && declaration.isVarArg) {

    ): KtSymbol? {
        val classLikeDeclaration = this.toSymbol(session)?.fir
        if (classLikeDeclaration is FirRegularClass) {
            if (calleeReference is FirResolvedNamedReference) {
                val callee = calleeReference.resolvedSymbol.fir as? FirCallableDeclaration
                // TODO: check callee owner directly?
                if (callee !is FirConstructor && callee?.isStatic != true) {

        val fe10Type = type.fe10Type

        if (!KotlinBuiltIns.isArrayOrPrimitiveArray(fe10Type)) return null

        val arrayElementType = fe10Type.builtIns.getArrayElementType(fe10Type)
        return arrayElementType.toKtType(analysisContext)
    }

    private fun areTypesCompatible(a: KotlinType, b: KotlinType): Boolean {

        if (arg !is FirQualifiedAccessExpression) return
        val callableSymbol = arg.calleeReference.toResolvedCallableSymbol() ?: return
        if (callableSymbol.containingClassLookupTag()?.classId != expectedEnumClass) return
        val identifier = callableSymbol.callableId.callableName.identifier
        transformer(identifier)?.let(::add)
    }

    if (this@findFromRawArguments is FirAnnotationCall) {

        )
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as KtFe10VariableLikeSignature<*>

        if (backingSymbol != other.backingSymbol) return false
        if (backingReturnType != other.backingReturnType) return false
        if (backingReceiverType != other.backingReceiverType) return false

        return true

    override fun getNamedClassSymbol(psiClass: PsiClass): KtNamedClassOrObjectSymbol? {
        if (psiClass.qualifiedName == null) return null
        if (psiClass is PsiTypeParameter) return null
        if (psiClass is KtLightClassMarker) return null
        if (psiClass.isKotlinCompiledClass()) return null

        return KtFirPsiJavaClassSymbol(psiClass, analysisSession)
    }

        val symbolPsi = descriptor?.let(DescriptorToSourceUtils::getContainingFile) ?: symbol.psi
        if (symbolPsi != null) {
            return analysisSession.getModule(symbolPsi)
        }

        if (descriptor is DescriptorWithContainerSource) {
            return getFakeContainingKtModule(descriptor)
        }

        if (symbol is KtBackingFieldSymbol) {
            return getContainingModule(symbol.owningProperty)

    fun typeConversion(type: KType): String {
        val nullableSuffix = if (type.isMarkedNullable) "?" else ""
        val simpleName = if (shouldRenderFqName(type)) {
            type.qualifiedName
        } else {
            type.simpleName
        }
        return if (type.arguments.isEmpty()) simpleName + nullableSuffix

    override fun isVisible(
        candidateSymbol: KtSymbolWithVisibility,
        useSiteFile: KtFileSymbol,
        position: PsiElement,
        receiverExpression: KtExpression?
    ): Boolean {
        if (candidateSymbol.visibility == Visibilities.Public) {
            return true
        }

        val targetDescriptor = getSymbolDescriptor(candidateSymbol) as? DeclarationDescriptorWithVisibility ?: return false

import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
import org.jetbrains.kotlin.resolve.DescriptorEquivalenceForOverrides

internal fun KtFe10Symbol.isEqualTo(other: Any?): Boolean {
    if (this === other) return true
    if (other !is KtFe10Symbol) return false
    return DescriptorEquivalenceForOverrides.areEquivalent(
        this.getDescriptor(),
        other.getDescriptor(),
        allowCopiesFromTheSameDeclaration = false