override fun buildChildren()

in src/main/kotlin/org/arend/formatting/block/SimpleArendBlock.kt [303:385]
75 lines of code
21 McCabe index (conditional complexity)

    override fun buildChildren(): MutableList<Block> {
        val blocks = ArrayList<Block>()
        var child: ASTNode? = myNode.firstChildNode
        val alignment = Alignment.createAlignment()
        val alignment2 = Alignment.createAlignment()

        val nodePsi = myNode.psi
        val nodeET = myNode.elementType

        mainLoop@ while (child != null) {
            val childPsi = child.psi
            val childET = child.elementType

            if (childET != WHITE_SPACE) {
                val indent: Indent =
                        if (childPsi is ArendExpr || childPsi is PsiErrorElement) when (nodeET) {
                            CO_CLAUSE, LOCAL_CO_CLAUSE, LET_EXPR, LET_CLAUSE, CLAUSE, FUNCTION_BODY, CLASS_IMPLEMENT -> Indent.getNormalIndent()
                            PI_EXPR, SIGMA_EXPR, LAM_EXPR -> Indent.getContinuationIndent()
                            else -> Indent.getNoneIndent()
                        } else if (AREND_COMMENTS.contains(childET)) when (nodeET) {
                            CO_CLAUSE, LOCAL_CO_CLAUSE, LET_EXPR, LET_CLAUSE, CLAUSE, FUNCTION_BODY,
                            FUNCTION_CLAUSES, CLASS_IMPLEMENT, DATA_BODY, CONSTRUCTOR, DEF_CLASS, WITH_BODY,
                            DEF_FUNCTION, NEW_EXPR, WHERE, DEF_DATA -> Indent.getNormalIndent()
                            else -> Indent.getNoneIndent()
                        } else if (nodeET == DEF_FUNCTION) {
                            val notFBodyWithClauses = if (childPsi is ArendFunctionBody) childPsi.fatArrow != null else true
                            if ((blocks.size > 0) && notFBodyWithClauses) Indent.getNormalIndent() else Indent.getNoneIndent()
                        } else when (childET) {
                            CO_CLAUSE, LOCAL_CO_CLAUSE, CONSTRUCTOR_CLAUSE, LET_CLAUSE, WHERE, TUPLE_EXPR, CLASS_STAT,
                            NAME_TELE, TYPE_TELE, FIELD_TELE, CASE_ARG -> Indent.getNormalIndent()
                            STAT -> if (nodePsi is ArendFile) Indent.getNoneIndent() else Indent.getNormalIndent()
                            else -> Indent.getNoneIndent()
                        }

                val wrap: Wrap? =
                        if (nodeET == FUNCTION_BODY && childPsi is ArendExpr) Wrap.createWrap(WrapType.NORMAL, false) else null

                val align = when (myNode.elementType) {
                    LET_EXPR ->
                        if (AREND_COMMENTS.contains(childET)) alignment
                        else when (childET) {
                            HAVE_KW, HAVES_KW, LET_KW, LETS_KW, IN_KW -> alignment2
                            LET_CLAUSE -> if ((nodePsi as? ArendLetExpr)?.letClauses?.size?.let{it > 1} == true) alignment else null
                            else -> null
                        }
                    IMPLICIT_ARGUMENT -> when (childET) {
                        TUPLE_EXPR -> alignment
                        else -> null
                    }
                    TUPLE -> if ((nodePsi as ArendTuple).tupleExprList.size > 1) when (childET) {
                        TUPLE_EXPR -> alignment
                        else -> null
                    } else null
                    else -> when (childET) {
                        CO_CLAUSE, LOCAL_CO_CLAUSE, CLASS_STAT -> alignment
                        NAME_TELE, TYPE_TELE, FIELD_TELE, CASE_ARG -> alignment2
                        else -> null
                    }
                }

                if (childET == PIPE) when (nodeET) {
                    FUNCTION_CLAUSES, CO_CLAUSE_BODY, LET_EXPR, DATA_BODY, CONSTRUCTOR, DEF_CLASS, WITH_BODY, CONSTRUCTOR_CLAUSE, FUNCTION_BODY, INSTANCE_BODY -> if (nodeET != CONSTRUCTOR_CLAUSE || blocks.size > 0) {
                        val clauseGroup = findClauseGroup(child, null)
                        if (clauseGroup != null) {
                            child = clauseGroup.first.treeNext
                            blocks.add(GroupBlock(settings, clauseGroup.second, null, alignment, Indent.getNormalIndent(), this))
                            continue@mainLoop
                        }
                    }
                }

                if (childET == DOC_COMMENT) {
                    blocks.add(processDocComment(settings, this, alignment, indent, child))
                    child = child.treeNext
                    continue@mainLoop
                }

                blocks.add(createArendBlock(child, wrap, align, indent))
            }
            child = child.treeNext
        }
        return blocks
    }