return firSymbolBuilder.buildScriptSymbol(psi.resolveToFirSymbolOfType<FirScriptSymbol>(firResolveSession))
    }

    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KaFunctionLikeSymbol {
        return when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(firResolveSession)) {
            is FirNamedFunctionSymbol -> {

    }

    private val KaSymbol.containingSymbolOrSelf: KaSymbol
        get() {
            return when (this) {
                is KaValueParameterSymbol -> {
                    getContainingDeclaration(this) as? KaFunctionLikeSymbol ?: this
                }
                is KaPropertyAccessorSymbol -> {
                    getContainingDeclaration(this) as? KaPropertySymbol ?: this
                }

        )
    }

    private fun ResolvedCall<*>.toFunctionKtCall(context: BindingContext): KaFunctionCall<*>? {
        val partiallyAppliedSymbol = toPartiallyAppliedFunctionSymbol<KaFunctionLikeSymbol>(context) ?: return null
        val argumentMapping = createArgumentMapping(partiallyAppliedSymbol.signature)
        if (partiallyAppliedSymbol.signature.symbol is KaConstructorSymbol) {

                    // if errorsness call without ()
                    is KaFunctionLikeSymbol -> {
                        @Suppress("UNCHECKED_CAST") // safe because of the above check on targetKtSymbol
                        KaSimpleFunctionCall(
                            partiallyAppliedSymbol as KaPartiallyAppliedFunctionSymbol<KaFunctionLikeSymbol>,
                            LinkedHashMap(),

        if (!platform.has<JvmPlatform>()) return null

        val containingSymbolOrSelf = when (symbol) {
            is KaValueParameterSymbol -> {
                getContainingDeclaration(symbol) as? KaFunctionLikeSymbol ?: symbol
            }
            is KaPropertyAccessorSymbol -> {
                getContainingDeclaration(symbol) as? KaPropertySymbol ?: symbol
            }

        override val diagnosticClass get() = AccidentalOverrideClashByJvmSignature::class
        val hidden: KaFunctionLikeSymbol
        val overrideDescription: String
        val regular: KaFunctionLikeSymbol
    }

    interface JavaTypeMismatch : KaFirDiagnostic<KtExpression> {
        override val diagnosticClass get() = JavaTypeMismatch::class

            KaClassLikeSymbol::class.createType()
        ),
        FirNamedFunctionSymbol::class to HLFunctionCallConversion(
            "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})",
            KaFunctionLikeSymbol::class.createType()
        ),
        FirPropertySymbol::class to HLFunctionCallConversion(
            "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0})",
            KaVariableSymbol::class.createType()

        if (ktSymbol is KaPropertySymbol) {
            yieldAll(ktSymbol.getter.withImplicitSymbols())
            yieldAll(ktSymbol.setter.withImplicitSymbols())
        }

        if (ktSymbol is KaFunctionLikeSymbol) {
            for (parameter in ktSymbol.valueParameters) {
                yieldAll(parameter.withImplicitSymbols())
            }
        }

        if (ktSymbol is KaValueParameterSymbol) {

internal class AccidentalOverrideClashByJvmSignatureImpl(
    override val hidden: KaFunctionLikeSymbol,
    override val overrideDescription: String,
    override val regular: KaFunctionLikeSymbol,
    firDiagnostic: KtPsiDiagnostic,
    token: KaLifetimeToken,