fun getContextName()

in src/main/kotlin/org/arend/refactoring/changeSignature/entries/UsageEntry.kt [269:314]
40 lines of code
10 McCabe index (conditional complexity)

        fun getContextName(context: ChangeSignatureRefactoringContext, concreteExpr: Concrete.SourceNode): String {
            val referenceExpression = when (concreteExpr) {
                is Concrete.AppExpression -> concreteExpr.function.data
                is Concrete.ReferenceExpression -> concreteExpr.data
                is Concrete.ConstructorPattern -> concreteExpr.constructorData
                else -> null
            }

            val referent = when (concreteExpr) {
                is Concrete.ReferenceExpression -> concreteExpr.referent
                is Concrete.AppExpression -> (concreteExpr.function as? Concrete.ReferenceExpression)?.referent
                is Concrete.ConstructorPattern -> concreteExpr.constructor
                else -> null
            }

            val referenceList: List<ArendReference> = when (referenceExpression) {
                is ArendLongName -> referenceExpression.refIdentifierList.map { it.reference }
                is ArendPattern -> referenceExpression.childOfType<ArendLongName>()?.refIdentifierList?.map { it.reference } ?:
                (referenceExpression.singleReferable?.reference?.let { singletonList(it) }) ?: emptyList()
                is ArendIPName -> (referenceExpression.parentLongName?.refIdentifierList?.map { it.reference } ?: emptyList()) +
                         singletonList(referenceExpression.reference)
                else -> emptyList()
            }

            val longName: List<String> = when (referenceExpression) {
                is ArendLongName -> referenceExpression.longName
                is ArendPattern -> referenceList.map { it.element.text }
                is ArendIPName -> referenceExpression.longName
                else -> emptyList()
            }

            var resolvesOk = true
            for (i in 0..referenceList.size - 2) {
                val ref1 = referenceList[i].resolve() as? ArendGroup
                val ref2 = referenceList[i+1].resolve() as? PsiLocatedReferable
                if (ref1 == null || ref2 == null || !(ref1.dynamicSubgroups.contains(ref2) || ref1.internalReferables.contains(ref2) || ref1.statements.any { it.group == ref2 })) {
                    resolvesOk = false
                }
            }

            if (!resolvesOk && referent is PsiLocatedReferable && referenceExpression is ArendCompositeElement) {
                return getContextName(referent, referenceExpression, context)
            }

            return getCorrectedContextName(context, referenceList.zip(longName))
        }