protected fun printParam()

in src/main/kotlin/org/arend/refactoring/changeSignature/entries/UsageEntry.kt [163:215]
49 lines of code
25 McCabe index (conditional complexity)

    protected fun printParam(globalReferable: GlobalReferable?,
                             oldParam: ParameterDescriptor?,
                             newParam: ParameterDescriptor,
                             parameterMap: Map<ParameterDescriptor, ArgumentPrintResult?>,
                             hasExplicitExternalArgument: Boolean,
                             parameterInfo: RenderedParameterKind? = null,
                             commentedText: String? = null): PrintedParameter {
        val parameter = oldParam?.let{ parameterMap[oldParam] }
        val referable = parameter?.printResult?.referable
        val inhibitParens = if (referable != null && parameterInfo != null && globalReferable != null) {
            if (referable == globalReferable) {
                parameterInfo == RenderedParameterKind.INFIX_LEFT && referable.precedence.associativity == Precedence.Associativity.LEFT_ASSOC ||
                        parameterInfo == RenderedParameterKind.INFIX_RIGHT && referable.precedence.associativity == Precedence.Associativity.RIGHT_ASSOC
            } else {
                referable.precedence.priority > globalReferable.precedence.priority
            }
        } else false

        val refactoringContext = descriptor?.moveRefactoringContext
        val thisText = if ((newParam.isThis() || oldParam?.isThis() == true) && refactoringContext != null && (parameter == null || parameter.printResult.text == "_")) {
            val parameterClass = newParam.getThisDefClass() ?: oldParam?.getThisDefClass()
            if (parameterClass != null) {
                val contextReferable = contextPsi.ancestor<PsiLocatedReferable>()
                val contextClass = contextReferable?.ancestors?.mapNotNull { refactoringContext.membersEnvelopingClasses[it] }?.firstOrNull()
                    ?: if (contextReferable != null) { getThisParameter(contextReferable)?.getThisDefClass() } else null

                when {
                    commentedText == "_" || commentedText == "{?}" || commentedText == "\\this" ->
                        "{?}"
                    commentedText != null ->
                        "{?} {-${commentedText}-}"
                    contextClass != null && contextClass.isSubClassOf(parameterClass) ->
                        "\\this"
                    contextClass != null -> "{?}"
                    else -> "_"
                }
            } else null
        } else null

        val (text, requiresParentheses) = when {
            thisText != null -> Pair(thisText, false)
            (oldParam == null) -> Pair("{?}", false)
            (oldParam.isExternal() && parameter == null && oldParam.getExternalScope()?.let{ usageContext.envelopingGroups.contains(it) } == true && !hasExplicitExternalArgument) ->
                Pair(oldParam.getNameOrUnderscore(), false)
            (parameter == null) -> Pair("_", false)
            else -> Pair(if (parameterInfo == RenderedParameterKind.INFIX_RIGHT && parameter.printResult.parenthesizedPrefixText != null) parameter.printResult.parenthesizedPrefixText else
                parameter.printResult.text, !parameter.printResult.isAtomic && !parameter.printResult.isLambda && !inhibitParens)
        }

        val result = if (newParam.isExplicit) (if (requiresParentheses) "(${text})" else text) else (if (text.startsWith("-")) "{ ${text}}" else "{${text}}")
        val spacingText = parameter?.spacingText ?: " "
        return PrintedParameter(result, spacingText)
    }