From 20f92c62006b3869eb0b8e0ec98767cbec163db5 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 21 Feb 2017 17:40:58 +0300 Subject: [PATCH] Use own kotlin settings for spacing instead of default set Mostly affected by settings: - KEEP_LINE_BREAKS, - KEEP_BLANK_LINES_IN_DECLARATIONS - KEEP_BLANK_LINES_IN_CODE Allow settings KEEP_LINE_BREAKS in UI. --- .../idea/formatter/KotlinSpacingBuilder.kt | 25 +++++++++---------- .../idea/formatter/kotlinSpacingRules.kt | 14 +++++------ ...tlinLanguageCodeStyleSettingsProvider.java | 13 +++++++++- 3 files changed, 31 insertions(+), 21 deletions(-) diff --git a/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt b/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt index e000ccbd7ae..aef606474cc 100644 --- a/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt +++ b/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt @@ -21,22 +21,21 @@ import com.intellij.formatting.DependentSpacingRule.Anchor import com.intellij.formatting.DependentSpacingRule.Trigger import com.intellij.lang.ASTNode import com.intellij.openapi.util.TextRange -import com.intellij.psi.codeStyle.CodeStyleSettings +import com.intellij.psi.codeStyle.CommonCodeStyleSettings import com.intellij.psi.tree.IElementType import com.intellij.psi.tree.TokenSet import org.jetbrains.kotlin.KtNodeTypes -import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.lexer.KtTokens import java.util.* -class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings, val spacingBuilderUtil: KotlinSpacingBuilderUtil) { +class KotlinSpacingBuilder(val commonCodeStyleSettings: CommonCodeStyleSettings, val spacingBuilderUtil: KotlinSpacingBuilderUtil) { private val builders = ArrayList() private interface Builder { fun getSpacing(parent: ASTBlock, left: ASTBlock, right: ASTBlock): Spacing? } - inner class BasicSpacingBuilder() : SpacingBuilder(codeStyleSettings, KotlinLanguage.INSTANCE), Builder { + inner class BasicSpacingBuilder() : SpacingBuilder(commonCodeStyleSettings), Builder { override fun getSpacing(parent: ASTBlock, left: ASTBlock, right: ASTBlock): Spacing? { return super.getSpacing(parent, left, right) } @@ -74,8 +73,8 @@ class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings, val spacing newRule { p, l, r -> Spacing.createDependentLFSpacing(numSpacesOtherwise, numSpacesOtherwise, p.textRange, - codeStyleSettings.KEEP_LINE_BREAKS, - if (allowBlankLines) codeStyleSettings.KEEP_BLANK_LINES_IN_CODE else 0) + commonCodeStyleSettings.KEEP_LINE_BREAKS, + if (allowBlankLines) commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE else 0) } } @@ -85,8 +84,8 @@ class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings, val spacing spacingBuilderUtil.createLineFeedDependentSpacing(numSpacesOtherwise, numSpacesOtherwise, numberOfLineFeedsOtherwise, - codeStyleSettings.KEEP_LINE_BREAKS, - codeStyleSettings.KEEP_BLANK_LINES_IN_DECLARATIONS, + commonCodeStyleSettings.KEEP_LINE_BREAKS, + commonCodeStyleSettings.KEEP_BLANK_LINES_IN_DECLARATIONS, left.textRange, dependentSpacingRule) } @@ -119,7 +118,7 @@ class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings, val spacing // TODO: it's a severe hack but I don't know how to implement it in other way if (child1.node.elementType == KtTokens.EOL_COMMENT && spacing.toString().contains("minLineFeeds=0")) { val isBeforeBlock = child2.node.elementType == KtNodeTypes.BLOCK || child2.node.firstChildNode?.elementType == KtNodeTypes.BLOCK - val keepBlankLines = if (isBeforeBlock) 0 else codeStyleSettings.KEEP_BLANK_LINES_IN_CODE + val keepBlankLines = if (isBeforeBlock) 0 else commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE return createSpacing(0, minLineFeeds = 1, keepLineBreaks = true, keepBlankLines = keepBlankLines) } return spacing @@ -143,8 +142,8 @@ class KotlinSpacingBuilder(val codeStyleSettings: CodeStyleSettings, val spacing fun createSpacing(minSpaces: Int, maxSpaces: Int = minSpaces, minLineFeeds: Int = 0, - keepLineBreaks: Boolean = codeStyleSettings.KEEP_LINE_BREAKS, - keepBlankLines: Int = codeStyleSettings.KEEP_BLANK_LINES_IN_CODE): Spacing { + keepLineBreaks: Boolean = commonCodeStyleSettings.KEEP_LINE_BREAKS, + keepBlankLines: Int = commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE): Spacing { return Spacing.createSpacing(minSpaces, maxSpaces, minLineFeeds, keepLineBreaks, keepBlankLines) } } @@ -163,8 +162,8 @@ interface KotlinSpacingBuilderUtil { fun isWhitespaceOrEmpty(node: ASTNode?): Boolean } -fun rules(codeStyleSettings: CodeStyleSettings, builderUtil: KotlinSpacingBuilderUtil, init: KotlinSpacingBuilder.() -> Unit): KotlinSpacingBuilder { - val builder = KotlinSpacingBuilder(codeStyleSettings, builderUtil) +fun rules(commonCodeStyleSettings: CommonCodeStyleSettings, builderUtil: KotlinSpacingBuilderUtil, init: KotlinSpacingBuilder.() -> Unit): KotlinSpacingBuilder { + val builder = KotlinSpacingBuilder(commonCodeStyleSettings, builderUtil) builder.init() return builder } diff --git a/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt b/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt index f1336dacb11..7e461b7dbf6 100644 --- a/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt +++ b/idea/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt @@ -50,7 +50,7 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing val kotlinSettings = settings.getCustomSettings(KotlinCodeStyleSettings::class.java)!! val kotlinCommonSettings = settings.getCommonSettings(KotlinLanguage.INSTANCE)!! - return rules(settings, builderUtil) { + return rules(kotlinCommonSettings, builderUtil) { val DECLARATIONS = TokenSet.create(PROPERTY, FUN, CLASS, OBJECT_DECLARATION, ENUM_ENTRY, SECONDARY_CONSTRUCTOR, CLASS_INITIALIZER) @@ -159,8 +159,8 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing betweenInside(RETURN_KEYWORD, LABEL_QUALIFIER, RETURN).spaces(0) afterInside(RETURN_KEYWORD, RETURN).spaces(1) afterInside(LABEL_QUALIFIER, RETURN).spaces(1) - betweenInside(LABEL_QUALIFIER, EOL_COMMENT, LABELED_EXPRESSION).spacing(0, Int.MAX_VALUE, 0, true, codeStyleSettings.KEEP_BLANK_LINES_IN_CODE) - betweenInside(LABEL_QUALIFIER, BLOCK_COMMENT, LABELED_EXPRESSION).spacing(0, Int.MAX_VALUE, 0, true, codeStyleSettings.KEEP_BLANK_LINES_IN_CODE) + betweenInside(LABEL_QUALIFIER, EOL_COMMENT, LABELED_EXPRESSION).spacing(0, Int.MAX_VALUE, 0, true, commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE) + betweenInside(LABEL_QUALIFIER, BLOCK_COMMENT, LABELED_EXPRESSION).spacing(0, Int.MAX_VALUE, 0, true, commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE) afterInside(LABEL_QUALIFIER, LABELED_EXPRESSION).spaces(1) betweenInside(FUN_KEYWORD, VALUE_PARAMETER_LIST, FUN).spacing(0, 0, 0, false, 0) @@ -429,8 +429,8 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing val spaces = if (empty) 0 else spacesInSimpleFunction Spacing.createDependentLFSpacing(spaces, spaces, psiElement.textRangeWithoutComments, - codeStyleSettings.KEEP_LINE_BREAKS, - codeStyleSettings.KEEP_BLANK_LINES_IN_CODE) + commonCodeStyleSettings.KEEP_LINE_BREAKS, + commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE) } inPosition(parent = BLOCK, left = LBRACE).customRule { parent, left, right -> @@ -441,8 +441,8 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing // Empty block is covered in above rule Spacing.createDependentLFSpacing(spacesInSimpleFunction, spacesInSimpleFunction, funNode.textRangeWithoutComments, - codeStyleSettings.KEEP_LINE_BREAKS, - codeStyleSettings.KEEP_BLANK_LINES_IN_CODE) + commonCodeStyleSettings.KEEP_LINE_BREAKS, + commonCodeStyleSettings.KEEP_BLANK_LINES_IN_CODE) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinLanguageCodeStyleSettingsProvider.java b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinLanguageCodeStyleSettingsProvider.java index d5c1ab78513..e644ee4fdf6 100644 --- a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinLanguageCodeStyleSettingsProvider.java +++ b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinLanguageCodeStyleSettingsProvider.java @@ -39,6 +39,9 @@ public class KotlinLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSe case WRAPPING_AND_BRACES_SETTINGS: return "public class ThisIsASampleClass {\n" + + " val test = \n" + + " 12\n" + + "\n" + " fun foo1(i1: Int, i2: Int, i3: Int) : Int {\n" + " when (i1) {\n" + " is Number -> 0\n" + @@ -64,7 +67,14 @@ public class KotlinLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSe " }" + " }\n" + " private val f = {(a: Int)->a*2}\n" + - "}"; + "}\n" + + "\n" + + "enum class Enumeration {\n" + + " A,\n" + + " B\n" + + "}\n" + + ""; + default: return "open class Some {\n"+ @@ -150,6 +160,7 @@ public class KotlinLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSe consumer.showStandardOptions( // "ALIGN_MULTILINE_CHAINED_METHODS", "KEEP_FIRST_COLUMN_COMMENT", + "KEEP_LINE_BREAKS", "ALIGN_MULTILINE_EXTENDS_LIST", "ALIGN_MULTILINE_PARAMETERS", "ALIGN_MULTILINE_PARAMETERS_IN_CALLS",