getErrorCallInfo: FirDiagnosticHolder.(psiToResolve: KtElement) -> List<T>,
        getCallInfo: FirElement.(
            psiToResolve: KtElement,
            resolveCalleeExpressionOfFunctionCall: Boolean,
            resolveFragmentOfCall: Boolean
        ) -> List<T>
    ): List<T> {
        if (!canBeResolvedAsCall(psi)) return emptyList()

        if (property.backingField?.symbol?.hasAnnotation(JvmStandardClassIds.Annotations.JvmField, analysisSession.useSiteSession) == true) {
            return property.name
        }
        return Name.identifier(getJvmNameAsString(property, isSetter))
    }

    private fun getJvmNameAsString(property: FirProperty, isSetter: Boolean): String {

            }
        }
    override val returnType: KtType
        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val isVal: Boolean
        get() = withValidityAssertion { !psi.isVar }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion { KtSymbolKind.LOCAL }

    abstract override fun substitute(substitutor: KtSubstitutor): KtFirVariableLikeSignature<S>

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

        other as KtFirVariableLikeSignature<*>
        return firSymbol == other.firSymbol
    }

    abstract override fun substitute(substitutor: KtSubstitutor): KtFirFunctionLikeSignature<S>

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

        other as KtFirFunctionLikeSignature<*>
        return firSymbol == other.firSymbol
    }

import org.jetbrains.kotlin.analysis.api.contracts.description.KtContractReturnsContractEffectDeclaration.*
import org.jetbrains.kotlin.analysis.api.contracts.description.booleans.*
import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol

        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KtScope {
        return KtEmptyScope(token)
    }

    override fun isResolveExtensionFile(file: VirtualFile): Boolean = false

    override fun getResolveExtensionNavigationElements(originalPsi: KtElement): Collection<PsiElement> = emptyList()

        return KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext)
    }

    override fun pointsToTheSameSymbolAs(other: KtSymbolPointer<KtSymbol>): Boolean = this === other ||
            other is KtFe10DescNamedClassOrObjectSymbolSymbol &&
            other.classId == classId

        val kotlinType = (type as KtFe10Type).fe10Type
        return typeMapper.mapType(kotlinType, mode)
    }

    override fun isPrimitiveBacked(type: KtType): Boolean {
        val kotlinType = (type as KtFe10Type).fe10Type
        return typeMapper.isPrimitiveBacked(kotlinType)
    }

 * condition.
 */
internal abstract class FirCallableFilteringScope(private val baseScope: FirContainingNamesAwareScope) : FirContainingNamesAwareScope() {
    protected abstract fun isTargetCallable(callable: FirCallableSymbol<*>): Boolean

    private val cachedCallableNames by lazy(LazyThreadSafetyMode.NONE) {
        buildSet {
            baseScope.processAllCallables { callable ->
                if (isTargetCallable(callable)) {