Implement function name formatting rules

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlBlock.kt

@@ -28,6 +28,7 @@ import org.domaframework.doma.intellij.formatter.block.comment.SqlBlockCommentBl
 import org.domaframework.doma.intellij.formatter.block.comment.SqlLineCommentBlock
 import org.domaframework.doma.intellij.formatter.builder.SqlCustomSpacingBuilder
 import org.domaframework.doma.intellij.formatter.util.IndentType
+import org.domaframework.doma.intellij.psi.SqlTypes
 
 open class SqlBlock(
     node: ASTNode,
@@ -59,6 +60,24 @@ open class SqlBlock(
     open var parentBlock: SqlBlock? = null
     open val childBlocks = mutableListOf<SqlBlock>()
 
+    fun getChildrenTextLen(): Int =
+        childBlocks.sumOf { child ->
+            val children =
+                child.childBlocks.filter { it !is SqlLineCommentBlock && it !is SqlBlockCommentBlock }
+            if (children.isNotEmpty()) {
+                child
+                    .getChildrenTextLen()
+                    .plus(child.getNodeText().length)
+            } else if (child.node.elementType == SqlTypes.DOT ||
+                child.node.elementType == SqlTypes.RIGHT_PAREN
+            ) {
+                // Since elements do not include surrounding spaces, they should be excluded from the character count.
+                0
+            } else {
+                child.getNodeText().length.plus(1)
+            }
+        }
+
     fun getChildBlocksDropLast(
         dropIndex: Int = 1,
         skipCommentBlock: Boolean = false,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlCommaBlock.kt

@@ -21,7 +21,6 @@ import org.domaframework.doma.intellij.common.util.TypeUtil
 import org.domaframework.doma.intellij.formatter.block.group.column.SqlColumnRawGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.keyword.SqlKeywordGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.keyword.condition.SqlConditionalExpressionGroupBlock
-import org.domaframework.doma.intellij.formatter.block.group.keyword.create.SqlCreateKeywordGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.keyword.insert.SqlInsertColumnGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.keyword.insert.SqlInsertValueGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.keyword.second.SqlFromGroupBlock
@@ -44,7 +43,6 @@ open class SqlCommaBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,
@@ -61,6 +59,14 @@ open class SqlCommaBlock(
                 SqlWithColumnGroupBlock::class,
                 SqlKeywordGroupBlock::class,
             )
+
+        private val PARENT_INDENT_SYNC_TYPES =
+            listOf(
+                SqlUpdateColumnGroupBlock::class,
+                SqlInsertColumnGroupBlock::class,
+                SqlWithColumnGroupBlock::class,
+                SqlFunctionParamBlock::class,
+            )
     }
 
     override val indent =
@@ -92,14 +98,8 @@ open class SqlCommaBlock(
                     return 0
                 }
 
-                val parentIndentSyncBlockTypes =
-                    listOf(
-                        SqlUpdateColumnGroupBlock::class,
-                        SqlInsertColumnGroupBlock::class,
-                        SqlWithColumnGroupBlock::class,
-                    )
                 val parentIndentLen = parent.indent.groupIndentLen
-                if (TypeUtil.isExpectedClassType(parentIndentSyncBlockTypes, parent)) {
+                if (TypeUtil.isExpectedClassType(PARENT_INDENT_SYNC_TYPES, parent)) {
                     return parentIndentLen
                 }
 
@@ -113,21 +113,22 @@ open class SqlCommaBlock(
                     return parentIndentLen.plus(1)
                 }
 
-                if (parent is SqlValuesParamGroupBlock) return 0
+                val notNewLineTypes =
+                    listOf(
+                        SqlValuesParamGroupBlock::class,
+                        SqlConditionalExpressionGroupBlock::class,
+                    )
+                if (TypeUtil.isExpectedClassType(notNewLineTypes, parent)) return 0
 
                 val grand = parent.parentBlock
                 grand?.let { grand ->
-                    if (grand is SqlCreateKeywordGroupBlock) {
-                        val grandIndentLen = grand.indent.groupIndentLen
-                        return grandIndentLen.plus(parentIndentLen).minus(1)
-                    }
-
                     val grandIndent = grand.indent.indentLen
                     val groupIndent = parentBlock?.indent?.groupIndentLen ?: 0
 
                     if (grand is SqlColumnRawGroupBlock) {
                         return groupIndent.plus(grandIndent)
                     }
+
                     return groupIndent.plus(grandIndent).minus(1)
                 }
                 return parentIndentLen.plus(1)

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlDataTypeBlock.kt

@@ -28,7 +28,6 @@ open class SqlDataTypeBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlFileBlock.kt

@@ -48,6 +48,8 @@ import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlDataTyp
 import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlFunctionParamBlock
 import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlSubGroupBlock
 import org.domaframework.doma.intellij.formatter.block.group.subgroup.SqlSubQueryGroupBlock
+import org.domaframework.doma.intellij.formatter.block.other.SqlEscapeBlock
+import org.domaframework.doma.intellij.formatter.block.other.SqlOtherBlock
 import org.domaframework.doma.intellij.formatter.block.word.SqlFunctionGroupBlock
 import org.domaframework.doma.intellij.formatter.block.word.SqlWordBlock
 import org.domaframework.doma.intellij.formatter.builder.SqlBlockBuilder
@@ -160,10 +162,18 @@ class SqlFileBlock(
                         defaultFormatCtx,
                     )
                 } else {
-                    SqlOtherBlock(
-                        child,
-                        defaultFormatCtx,
-                    )
+                    val escapeStrings = listOf("\"", "`", "[", "]")
+                    if (escapeStrings.contains(child.text)) {
+                        SqlEscapeBlock(
+                            child,
+                            defaultFormatCtx,
+                        )
+                    } else {
+                        SqlOtherBlock(
+                            child,
+                            defaultFormatCtx,
+                        )
+                    }
                 }
             }
 
@@ -422,64 +432,77 @@ class SqlFileBlock(
         child2: Block,
     ): Spacing? {
         if (isAdjustIndentOnEnter()) return null
+        val childBlock1: SqlBlock? = child1 as? SqlBlock
+        val childBlock2: SqlBlock = child2 as SqlBlock
 
         // The end of a line comment element is a newline, so just add a space for the indent.
-        if (child1 is SqlLineCommentBlock && child2 is SqlBlock) {
-            return SqlCustomSpacingBuilder().getSpacing(child2)
+        if (childBlock1 is SqlLineCommentBlock) {
+            return SqlCustomSpacingBuilder().getSpacing(childBlock2)
         }
 
-        if (child2 is SqlWithColumnGroupBlock) {
+        if (childBlock2 is SqlWithColumnGroupBlock) {
             return SqlCustomSpacingBuilder.normalSpacing
         }
 
-        if (child1 is SqlSubGroupBlock && child2 is SqlSubGroupBlock) {
+        if (childBlock1 is SqlSubGroupBlock && childBlock2 is SqlSubGroupBlock) {
             return SqlCustomSpacingBuilder.nonSpacing
         }
 
         // Do not leave a space after the comment block of the bind variable
-        if (child1 is SqlElBlockCommentBlock && child1 !is SqlElConditionLoopCommentBlock && child2 !is SqlCommentBlock) {
+        if (childBlock1 is SqlElBlockCommentBlock && childBlock1 !is SqlElConditionLoopCommentBlock && childBlock2 !is SqlCommentBlock) {
             return SqlCustomSpacingBuilder.nonSpacing
         }
 
-        if (child2 is SqlElBlockCommentBlock) {
-            return when (child1) {
+        if (childBlock2 is SqlElBlockCommentBlock) {
+            return when (childBlock1) {
                 is SqlElBlockCommentBlock, is SqlWhitespaceBlock -> {
-                    SqlCustomSpacingBuilder().getSpacing(child2)
+                    SqlCustomSpacingBuilder().getSpacing(childBlock2)
                 }
 
                 else -> SqlCustomSpacingBuilder.normalSpacing
             }
         }
 
-        if (child1 is SqlFunctionParamBlock) {
+        if (childBlock1?.node?.elementType == SqlTypes.DOT ||
+            childBlock2.node.elementType == SqlTypes.DOT
+        ) {
             return SqlCustomSpacingBuilder.nonSpacing
         }
 
-        if (child2 is SqlOtherBlock) {
-            if (child1 is SqlFunctionGroupBlock) {
-                val reservedWordEscapeSymbolList = listOf("\"", "[", "`")
-                if (reservedWordEscapeSymbolList.contains(child2.getNodeText())) {
-                    return SqlCustomSpacingBuilder.nonSpacing
-                }
+        if (childBlock1 is SqlEscapeBlock) {
+            return if (!childBlock1.isEndEscape) {
+                SqlCustomSpacingBuilder.nonSpacing
+            } else {
+                SqlCustomSpacingBuilder.normalSpacing
             }
-            return SqlCustomSpacingBuilder().getSpacing(child2)
         }
 
-        if (child1 is SqlWhitespaceBlock) {
-            when (child2) {
+        if (childBlock2 is SqlEscapeBlock) {
+            if (childBlock2.isEndEscape) {
+                return SqlCustomSpacingBuilder.nonSpacing
+            }
+            return SqlCustomSpacingBuilder().getSpacing(childBlock2)
+        }
+
+        if (childBlock2 is SqlOtherBlock) {
+            return SqlCustomSpacingBuilder().getSpacing(childBlock2)
+        }
+
+        if (childBlock1 is SqlWhitespaceBlock) {
+            when (childBlock2) {
                 is SqlBlockCommentBlock, is SqlLineCommentBlock, is SqlNewGroupBlock -> {
-                    return SqlCustomSpacingBuilder().getSpacing(child2)
+                    return SqlCustomSpacingBuilder().getSpacing(childBlock2)
                 }
             }
         }
 
-        if (child2 is SqlNewGroupBlock) {
-            if (child1 is SqlSubGroupBlock && child2.indent.indentLevel == IndentType.ATTACHED) {
+        if (childBlock2 is SqlNewGroupBlock) {
+            if (childBlock1 is SqlSubGroupBlock && childBlock2.indent.indentLevel == IndentType.ATTACHED) {
                 return SqlCustomSpacingBuilder.nonSpacing
             }
-            when (child2) {
+            when (childBlock2) {
                 is SqlSubQueryGroupBlock -> {
-                    if (child1 is SqlNewGroupBlock) {
+                    if (childBlock1 is SqlNewGroupBlock) {
                         return SqlCustomSpacingBuilder.normalSpacing
                     }
                 }
@@ -491,31 +514,31 @@ class SqlFileBlock(
         }
 
         // Create Table Column Definition Raw Group Block
-        CreateTableUtil.getColumnDefinitionRawGroupSpacing(child1, child2)?.let { return it }
+        CreateTableUtil.getColumnDefinitionRawGroupSpacing(childBlock1, childBlock2)?.let { return it }
 
-        when (child2) {
+        when (childBlock2) {
             is SqlColumnDefinitionRawGroupBlock ->
                 SqlCustomSpacingBuilder()
                     .getSpacingColumnDefinitionRaw(
-                        child2,
+                        childBlock2,
                     )?.let { return it }
 
             is SqlRightPatternBlock -> return SqlCustomSpacingBuilder().getSpacingRightPattern(
-                child2,
+                childBlock2,
             )
 
             is SqlColumnBlock ->
                 SqlCustomSpacingBuilder()
-                    .getSpacingColumnDefinition(child2)
+                    .getSpacingColumnDefinition(childBlock2)
                     ?.let { return it }
         }
 
-        if (child1 is SqlBlock && (child2 is SqlCommaBlock || child2 is SqlColumnRawGroupBlock)) {
-            SqlCustomSpacingBuilder().getSpacingWithIndentComma(child1, child2)?.let { return it }
+        if (childBlock1 is SqlBlock && (childBlock2 is SqlCommaBlock || childBlock2 is SqlColumnRawGroupBlock)) {
+            SqlCustomSpacingBuilder().getSpacingWithIndentComma(childBlock1, childBlock2)?.let { return it }
         }
 
-        val spacing: Spacing? = customSpacingBuilder?.getCustomSpacing(child1, child2)
-        return spacing ?: spacingBuilder.getSpacing(this, child1, child2)
+        val spacing: Spacing? = customSpacingBuilder?.getCustomSpacing(childBlock1, childBlock2)
+        return spacing ?: spacingBuilder.getSpacing(this, childBlock1, childBlock2)
     }
 
     override fun isLeaf(): Boolean = false

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlLiteralBlock.kt

@@ -27,7 +27,6 @@ open class SqlLiteralBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlRightPatternBlock.kt

@@ -45,7 +45,6 @@ open class SqlRightPatternBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlUnknownBlock.kt

@@ -27,7 +27,6 @@ class SqlUnknownBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/SqlWhitespaceBlock.kt

@@ -34,7 +34,6 @@ class SqlWhitespaceBlock(
         node,
         wrap,
         alignment,
-        null,
         spacingBuilder,
         false,
         FormattingMode.ADJUST_INDENT_ON_ENTER,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/comment/SqlCommentBlock.kt

@@ -29,7 +29,6 @@ abstract class SqlCommentBlock(
         node,
         context.wrap,
         context.alignment,
-        null,
         context.spacingBuilder,
         context.enableFormat,
         context.formatMode,

src/main/kotlin/org/domaframework/doma/intellij/formatter/block/expr/SqlElFieldAccessBlock.kt

@@ -66,7 +66,6 @@ class SqlElFieldAccessBlock(
                     child,
                     context.wrap,
                     context.alignment,
-                    customSpacingBuilder,
                     context.spacingBuilder,
                     context.enableFormat,
                     context.formatMode,