From c21cdaf413ee2b43eb927d4f26da772008f34e09 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Sun, 11 Mar 2012 22:11:13 +0400 Subject: [PATCH] Start working with spaces: KT-1532 IDEA should remove extra whitespaces when reformmating code KT-1378 Code formatting: spaces around ':' #KT-1532 fixed #KT-1378 fixed --- .../OverrideImplementMethodsHandler.java | 8 +- .../formatter/JetCodeStyleSettings.java | 4 + .../JetCodeStyleSettingsProvider.java | 3 + .../formatter/JetFormattingModelBuilder.java | 24 ++++- .../JetLanguageCodeStyleSettingsProvider.java | 89 +++++++++++++++++-- .../formatter/SpaceAroundTypeColon.kt | 9 ++ .../formatter/SpaceAroundTypeColon_after.kt | 9 ++ .../changeMutability/afterValWithSetter.kt | 4 +- .../jet/formatter/JetFormatterTest.java | 20 +++++ 9 files changed, 155 insertions(+), 15 deletions(-) create mode 100644 idea/testData/formatter/SpaceAroundTypeColon.kt create mode 100644 idea/testData/formatter/SpaceAroundTypeColon_after.kt diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java index 86d88633bb0..a12824792dc 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java @@ -31,8 +31,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.compiler.WholeProjectAnalyzerFacade; import org.jetbrains.jet.plugin.quickfix.ImportClassHelper; @@ -92,7 +92,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns else { bodyBuilder.append("val "); } - bodyBuilder.append(descriptor.getName()).append(" : ").append(descriptor.getType()); + bodyBuilder.append(descriptor.getName()).append(":").append(descriptor.getType()); ImportClassHelper.addImportDirectiveIfNeeded(descriptor.getType(), file); String initializer = defaultInitializer(descriptor.getType(), JetStandardLibrary.getInstance()); if (initializer != null) { @@ -115,7 +115,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns } first = false; bodyBuilder.append(parameterDescriptor.getName()); - bodyBuilder.append(" : "); + bodyBuilder.append(":"); bodyBuilder.append(parameterDescriptor.getType().toString()); ImportClassHelper.addImportDirectiveIfNeeded(parameterDescriptor.getType(), file); @@ -124,7 +124,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns final JetType returnType = descriptor.getReturnType(); final JetStandardLibrary stdlib = JetStandardLibrary.getInstance(); if (!returnType.equals(stdlib.getTuple0Type())) { - bodyBuilder.append(" : ").append(returnType.toString()); + bodyBuilder.append(":").append(returnType.toString()); ImportClassHelper.addImportDirectiveIfNeeded(returnType, file); } diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettings.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettings.java index ef75f5b6e4f..237517c76e7 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettings.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettings.java @@ -22,6 +22,10 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager; import com.intellij.psi.codeStyle.CustomCodeStyleSettings; public class JetCodeStyleSettings extends CustomCodeStyleSettings { + + public boolean SPACE_BEFORE_TYPE_COLON = true; + public boolean SPACE_AFTER_TYPE_COLON = true; + public static JetCodeStyleSettings getInstance(Project project) { return CodeStyleSettingsManager.getSettings(project).getCustomSettings(JetCodeStyleSettings.class); } diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettingsProvider.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettingsProvider.java index e5fd50d799c..b445630039f 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettingsProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetCodeStyleSettingsProvider.java @@ -44,6 +44,8 @@ public class JetCodeStyleSettingsProvider extends CodeStyleSettingsProvider { return new JetCodeStyleSettings(settings); } + + @NotNull @Override public Configurable createSettingsPage(CodeStyleSettings settings, CodeStyleSettings originalSettings) { @@ -55,6 +57,7 @@ public class JetCodeStyleSettingsProvider extends CodeStyleSettingsProvider { protected void initTabs(CodeStyleSettings settings) { // TODO: activate all parent tabs addIndentOptionsTab(settings); + addSpacesTab(settings); } }; } diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java index ea0813686ec..194f6050b62 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java @@ -43,7 +43,11 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { } private static SpacingBuilder createSpacingBuilder(CodeStyleSettings settings) { + JetCodeStyleSettings jetSettings = settings.getCustomSettings(JetCodeStyleSettings.class); + return new SpacingBuilder(settings) + + // ============ Line breaks ============== .after(NAMESPACE_HEADER).blankLines(1) .before(IMPORT_DIRECTIVE).lineBreakInCode() @@ -57,13 +61,27 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { .between(FUN, FUN).blankLines(1) .between(FUN, PROPERTY).blankLines(1) + .afterInside(LBRACE, BLOCK).lineBreakInCode() + .beforeInside(RBRACE, CLASS_BODY).lineBreakInCode() + .beforeInside(RBRACE, BLOCK).lineBreakInCode() + + // =============== Spacing ================ .before(COMMA).spaceIf(settings.SPACE_BEFORE_COMMA) .after(COMMA).spaceIf(settings.SPACE_AFTER_COMMA) .around(EQ).spaceIf(settings.SPACE_AROUND_ASSIGNMENT_OPERATORS) .beforeInside(BLOCK, FUN).spaceIf(settings.SPACE_BEFORE_METHOD_LBRACE) - .afterInside(LBRACE, BLOCK).lineBreakInCode() - .beforeInside(RBRACE, CLASS_BODY).lineBreakInCode() - .beforeInside(RBRACE, BLOCK).lineBreakInCode(); + + // TODO: Ask for better API + .beforeInside(COLON, PROPERTY).spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) + .afterInside(COLON, PROPERTY).spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON) + .beforeInside(COLON, CLASS).spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) + .afterInside(COLON, CLASS).spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON) + .beforeInside(COLON, FUN).spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) + .afterInside(COLON, FUN).spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON) + .beforeInside(COLON, TYPE_PARAMETER).spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) + .afterInside(COLON, TYPE_PARAMETER).spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON) + .beforeInside(COLON, VALUE_PARAMETER).spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) + .afterInside(COLON, VALUE_PARAMETER).spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetLanguageCodeStyleSettingsProvider.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetLanguageCodeStyleSettingsProvider.java index 43ae0d54a1e..2268b36c92a 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetLanguageCodeStyleSettingsProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetLanguageCodeStyleSettingsProvider.java @@ -38,11 +38,12 @@ public class JetLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSetti @Override public String getCodeSample(@NotNull SettingsType settingsType) { return - "class Some {\n" + - "fun foo() : Int {\n" + - "return 0\n" + - "}\n" + - "}"; + "class Some {\n" + + " fun foo() : Int {\n" + + " val test : Int = 12\n" + + " return test\n" + + " }\n" + + "}"; } @Override @@ -52,7 +53,83 @@ public class JetLanguageCodeStyleSettingsProvider extends LanguageCodeStyleSetti @Override public void customizeSettings(@NotNull CodeStyleSettingsCustomizable consumer, @NotNull SettingsType settingsType) { - consumer.showAllStandardOptions(); + if (settingsType == SettingsType.SPACING_SETTINGS) { + consumer.showStandardOptions( + "SPACE_AROUND_ASSIGNMENT_OPERATORS", + "SPACE_AROUND_LOGICAL_OPERATORS", + "SPACE_AROUND_EQUALITY_OPERATORS", + "SPACE_AROUND_RELATIONAL_OPERATORS", + "SPACE_AROUND_BITWISE_OPERATORS", + "SPACE_AROUND_ADDITIVE_OPERATORS", + "SPACE_AROUND_MULTIPLICATIVE_OPERATORS", + "SPACE_AROUND_SHIFT_OPERATORS", + "SPACE_AROUND_UNARY_OPERATOR", + "SPACE_AFTER_COMMA", + "SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS", + "SPACE_BEFORE_COMMA", + "SPACE_AFTER_SEMICOLON", + "SPACE_BEFORE_SEMICOLON", + "SPACE_WITHIN_PARENTHESES", + "SPACE_WITHIN_METHOD_CALL_PARENTHESES", + "SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES", + "SPACE_WITHIN_METHOD_PARENTHESES", + "SPACE_WITHIN_EMPTY_METHOD_PARENTHESES", + "SPACE_WITHIN_IF_PARENTHESES", + "SPACE_WITHIN_WHILE_PARENTHESES", + "SPACE_WITHIN_FOR_PARENTHESES", + "SPACE_WITHIN_TRY_PARENTHESES", + "SPACE_WITHIN_CATCH_PARENTHESES", + "SPACE_WITHIN_SWITCH_PARENTHESES", + // "SPACE_WITHIN_SYNCHRONIZED_PARENTHESES", + "SPACE_WITHIN_CAST_PARENTHESES", + "SPACE_WITHIN_BRACKETS", + "SPACE_WITHIN_BRACES", + // "SPACE_WITHIN_ARRAY_INITIALIZER_BRACES", + "SPACE_AFTER_TYPE_CAST", + "SPACE_BEFORE_METHOD_CALL_PARENTHESES", + "SPACE_BEFORE_METHOD_PARENTHESES", + "SPACE_BEFORE_IF_PARENTHESES", + "SPACE_BEFORE_WHILE_PARENTHESES", + "SPACE_BEFORE_FOR_PARENTHESES", + "SPACE_BEFORE_TRY_PARENTHESES", + "SPACE_BEFORE_CATCH_PARENTHESES", + "SPACE_BEFORE_SWITCH_PARENTHESES", + "SPACE_BEFORE_SYNCHRONIZED_PARENTHESES", + "SPACE_BEFORE_CLASS_LBRACE", + "SPACE_BEFORE_METHOD_LBRACE", + "SPACE_BEFORE_IF_LBRACE", + "SPACE_BEFORE_ELSE_LBRACE", + "SPACE_BEFORE_WHILE_LBRACE", + "SPACE_BEFORE_FOR_LBRACE", + "SPACE_BEFORE_DO_LBRACE", + "SPACE_BEFORE_SWITCH_LBRACE", + "SPACE_BEFORE_TRY_LBRACE", + "SPACE_BEFORE_CATCH_LBRACE", + "SPACE_BEFORE_FINALLY_LBRACE", + "SPACE_BEFORE_SYNCHRONIZED_LBRACE", + "SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE", + "SPACE_BEFORE_ANNOTATION_ARRAY_INITIALIZER_LBRACE", + "SPACE_BEFORE_ELSE_KEYWORD", + "SPACE_BEFORE_WHILE_KEYWORD", + "SPACE_BEFORE_CATCH_KEYWORD", + "SPACE_BEFORE_FINALLY_KEYWORD", + "SPACE_BEFORE_QUEST", + "SPACE_AFTER_QUEST", + "SPACE_BEFORE_COLON", + "SPACE_AFTER_COLON", + "SPACE_BEFORE_TYPE_PARAMETER_LIST" + ); + + consumer.showCustomOption(JetCodeStyleSettings.class, "SPACE_AFTER_TYPE_COLON", "Space after colon, before declarations' type", + CodeStyleSettingsCustomizable.SPACES_OTHER); + + consumer.showCustomOption(JetCodeStyleSettings.class, "SPACE_BEFORE_TYPE_COLON", "Space before colon, after declarations' name", + CodeStyleSettingsCustomizable.SPACES_OTHER); + } else { + consumer.showAllStandardOptions(); + } + + } @Override diff --git a/idea/testData/formatter/SpaceAroundTypeColon.kt b/idea/testData/formatter/SpaceAroundTypeColon.kt new file mode 100644 index 00000000000..0a6eca6c7fb --- /dev/null +++ b/idea/testData/formatter/SpaceAroundTypeColon.kt @@ -0,0 +1,9 @@ +import java.util.ArrayList +import java.lang.Iterable + +class Some :java.util.ArrayList() { + fun some>(array: Array) : Int { + val test:Int = 12 + return test + } +} \ No newline at end of file diff --git a/idea/testData/formatter/SpaceAroundTypeColon_after.kt b/idea/testData/formatter/SpaceAroundTypeColon_after.kt new file mode 100644 index 00000000000..48961cdb78b --- /dev/null +++ b/idea/testData/formatter/SpaceAroundTypeColon_after.kt @@ -0,0 +1,9 @@ +import java.util.ArrayList +import java.lang.Iterable + +class Some :java.util.ArrayList() { + fun some>(array :Array) :Int { + val test :Int = 12 + return test + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/variables/changeMutability/afterValWithSetter.kt b/idea/testData/quickfix/variables/changeMutability/afterValWithSetter.kt index ca89842347b..6c6d3bcca0b 100644 --- a/idea/testData/quickfix/variables/changeMutability/afterValWithSetter.kt +++ b/idea/testData/quickfix/variables/changeMutability/afterValWithSetter.kt @@ -1,6 +1,6 @@ // "Make variable mutable" "true" class A() { - var a: Int = 0 - set(v: Int) { + var a : Int = 0 + set(v : Int) { } } diff --git a/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java b/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java index 7209f79c747..9467b58278e 100644 --- a/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java +++ b/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java @@ -16,6 +16,10 @@ package org.jetbrains.jet.formatter; +import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.CodeStyleSettingsManager; +import org.jetbrains.jet.plugin.formatter.JetCodeStyleSettings; + /** * Based on com.intellij.psi.formatter.java.JavaFormatterTest */ @@ -45,6 +49,14 @@ public class JetFormatterTest extends AbstractJetFormatterTest { } public void testParameters() throws Exception { + getJetSettings().SPACE_AFTER_TYPE_COLON = true; + getJetSettings().SPACE_BEFORE_TYPE_COLON = false; + doTest(); + } + + public void testSpaceAroundTypeColon() throws Exception { + getJetSettings().SPACE_AFTER_TYPE_COLON = false; + getJetSettings().SPACE_BEFORE_TYPE_COLON = true; doTest(); } @@ -55,4 +67,12 @@ public class JetFormatterTest extends AbstractJetFormatterTest { public void testWhenEntryExpr() throws Exception { doTest(); } + + public static JetCodeStyleSettings getJetSettings() { + return getSettings().getCustomSettings(JetCodeStyleSettings.class); + } + + public static CodeStyleSettings getSettings() { + return CodeStyleSettingsManager.getSettings(getProject()); + } }