return resolvedCall.typeArguments[paramDescriptor]
    }

    override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? {
        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
        val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression.receiverExpression] ?: return null
        return lhs.type.toKtType(analysisContext)
    }

      <option name="ALIGN_MULTILINE_THROWS_LIST" value="true" />
      <option name="ALIGN_MULTILINE_EXTENDS_LIST" value="true" />
      <option name="ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION" value="true" />
      <option name="SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE" value="true" />
      <option name="CALL_PARAMETERS_WRAP" value="1" />
      <option name="METHOD_PARAMETERS_WRAP" value="5" />

import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.diagnostics.WhenMissingCase
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.lexer.KtKeywordToken
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken

    override fun convertExpression(expression: String, context: ConversionContext): String {
        if (mappingConversionFirst.isTrivial && mappingConversionSecond.isTrivial) {
            return expression
        }
        val first = mappingConversionFirst.convertExpression("$expression.first", context)
        val second = mappingConversionSecond.convertExpression("$expression.second", context)
        return "$first to $second"

import org.jetbrains.kotlin.psi.KtCallExpression
import org.jetbrains.kotlin.psi.KtExpression

class KtFirInvokeFunctionReference(expression: KtCallExpression) : KtInvokeFunctionReference(expression), KtFirReference {
    override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
        return expression.resolveCall()?.calls.orEmpty().mapNotNull { call ->
            (call as? KtSimpleFunctionCall)

        return allowAnalysisOnEdt {
            allowAnalysisFromWriteAction {
                val resolveToPsiElements = try {
                    analyze(ref.expression) { ref.getResolvedToPsi(this) }
                } catch (e: Exception) {
                    if (shouldIjPlatformExceptionBeRethrown(e)) throw e

        }
    }

    private fun SmartPrinter.printParameter(parameter: HLDiagnosticParameter) {
        val expression = parameter.conversion.convertExpression(
            "firDiagnostic.${parameter.originalParameterName}",
            ConversionContext(currentIndentLengthInUnits, indentUnitLength)
        )
        println("$expression,")
    }

            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.EXPRESSION_EXPECTED) { firDiagnostic ->
        ExpressionExpectedImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ASSIGNMENT_IN_EXPRESSION_CONTEXT) { firDiagnostic ->
        AssignmentInExpressionContextImpl(
            firDiagnostic as KtPsiDiagnostic,

        get() = analysisSession.token

    override fun getSmartCastedInfo(expression: KtExpression): KtSmartCastInfo? {
        val bindingContext = analysisContext.analyze(expression)
        val stableSmartCasts = bindingContext[BindingContext.SMARTCAST, expression]
        val unstableSmartCasts = bindingContext[BindingContext.UNSTABLE_SMARTCAST, expression]

        return when {
            stableSmartCasts != null -> {