override val analysisSession: KtAnalysisSession,
) : KtKlibSourceFileNameProvider() {
    override fun getKlibSourceFileName(declaration: KtDeclarationSymbol): String? {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    override fun getExitPointSnapshot(statements: List<KtExpression>): KtDataFlowExitPointSnapshot {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

        else -> null
    }
}

/**
 * This logic should be equivalent to
 * [org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder.unwrapSubstitutionOverrideIfNeeded]. But this method unwrap all fake
 * overrides that do not change the signature.
 */
internal fun CallableDescriptor.unwrapFakeOverrideIfNeeded(): CallableDescriptor {
    val useSiteUnwrapped = unwrapUseSiteSubstitutionOverride()

- [`KT-58891`](https://youtrack.jetbrains.com/issue/KT-58891) K/JS: non-local return in lambda may leave an unreachable JS code after return
- [`KT-49077`](https://youtrack.jetbrains.com/issue/KT-49077) KJS / IR: Wrong method called when using overloaded methods and class with the same name
- [`KT-59718`](https://youtrack.jetbrains.com/issue/KT-59718) K/JS: Concatenating a String with a Char can lead to boxing of the Char

    }

    override fun getImplementationStatus(
        memberSymbol: KtCallableSymbol,
        parentClassSymbol: KtClassOrObjectSymbol
    ): ImplementationStatus?  {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    override fun unwrapFakeOverrides(symbol: KtCallableSymbol): KtCallableSymbol {
        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return symbol

    }

    private fun canBePossibleToDropLabel(thisReference: FirThisReference): Boolean {
        return shortenOptions.removeThisLabels && thisReference.labelName != null
    }

    /**
     * This method intentionally mirrors the appearance
     * of the [classShortenStrategy] and [callableShortenStrategy] filters,
     * but ATM we don't have a way to properly handle
     * [FirThisReference]s through the existing filters.

                        }
                    }
                    methods.singleOrNull { it.name.endsWith(JvmAbi.ANNOTATED_PROPERTY_METHOD_NAME_SUFFIX) }?.let {
                        bindings.put(
                            FirJvmSerializerExtension.SYNTHETIC_METHOD_FOR_FIR_VARIABLE,
                            fir,

        originalFile: KtFile,
        nameExpression: KtSimpleNameExpression,
        explicitReceiver: KtExpression?
    ): KtCompletionExtensionCandidateChecker {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    @Suppress("OVERRIDE_DEPRECATION")
    override fun checkExtensionFitsCandidate(
        firSymbolForCandidate: KtCallableSymbol,
        originalFile: KtFile,

internal object FirReferenceResolveHelper {
    fun FirResolvedTypeRef.toTargetSymbol(session: FirSession, symbolBuilder: KtSymbolByFirBuilder): KtSymbol? {
        // When you call a method from Java with type arguments, in FIR they are currently represented as flexible types.
        // TODO Consider handling other non-ConeLookupTagBasedType types here (see KT-66418)

            token,
        )
    }
    add(FirErrors.FUN_INTERFACE_ABSTRACT_METHOD_WITH_TYPE_PARAMETERS) { firDiagnostic ->
        FunInterfaceAbstractMethodWithTypeParametersImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.FUN_INTERFACE_ABSTRACT_METHOD_WITH_DEFAULT_VALUE) { firDiagnostic ->
        FunInterfaceAbstractMethodWithDefaultValueImpl(