KT-1712 Formatting for getters and setters

 #KT-1712 fixed

idea/src/org/jetbrains/jet/plugin/formatter/ASTIndentStrategy.java

+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.plugin.formatter;
+
+import com.intellij.formatting.Indent;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Nikolay Krasko
+ */
+public abstract class ASTIndentStrategy {
+    public static ASTIndentStrategy constIndent(Indent indent) {
+        return new ConstIndentStrategy(indent);
+    }
+
+    public static PositionStrategy forNode(@Nullable String debugInfo) {
+        return new PositionStrategy(debugInfo);
+    }
+
+    @Nullable
+    public abstract Indent getIndent(@NotNull ASTNode node);
+
+    public static class ConstIndentStrategy extends ASTIndentStrategy {
+        private final Indent indent;
+
+        public ConstIndentStrategy(Indent indent) {
+            this.indent = indent;
+        }
+
+        @Nullable
+        @Override
+        public Indent getIndent(@NotNull ASTNode node) {
+            return indent;
+        }
+    }
+
+    public static class PositionStrategy extends ASTIndentStrategy {
+        private Indent defaultIndent = Indent.getNoneIndent();
+
+        private List<IElementType> in = new ArrayList<IElementType>();
+        private List<IElementType> notIn = new ArrayList<IElementType>();
+        private List<IElementType> forElement = new ArrayList<IElementType>();
+        private List<IElementType> notForElement = new ArrayList<IElementType>();
+
+        private String debugInfo;
+
+        public PositionStrategy(@Nullable String debugInfo) {
+            this.debugInfo = debugInfo;
+        }
+
+        @Override
+        public String toString() {
+            return "PositionStrategy " + (debugInfo != null ? debugInfo : "No debug info");
+        }
+
+        public PositionStrategy set(Indent indent) {
+            defaultIndent = indent;
+            return this;
+        }
+
+        public PositionStrategy in(@NotNull IElementType parentType, @NotNull IElementType... orParentTypes) {
+            in.clear();
+            in.add(parentType);
+            Collections.addAll(in, orParentTypes);
+            return this;
+        }
+
+        public PositionStrategy notIn(@NotNull IElementType parentType, @NotNull IElementType... orParentTypes) {
+            notIn.clear();
+            notIn.add(parentType);
+            Collections.addAll(notIn, orParentTypes);
+            return this;
+        }
+
+        public PositionStrategy inAny() {
+            in.clear();
+            notIn.clear();
+            return this;
+        }
+
+        public PositionStrategy forType(@NotNull IElementType elementType, @NotNull IElementType... otherTypes) {
+            forElement.clear();
+            forElement.add(elementType);
+            Collections.addAll(forElement, otherTypes);
+
+            return this;
+        }
+
+        public PositionStrategy notForType(@NotNull IElementType elementType, @NotNull IElementType... otherTypes) {
+            notForElement.clear();
+            notForElement.add(elementType);
+            Collections.addAll(notForElement, otherTypes);
+
+            return this;
+        }
+
+        public PositionStrategy forAny() {
+            forElement.clear();
+            notForElement.clear();
+            return this;
+        }
+
+        @Nullable
+        @Override
+        public Indent getIndent(@NotNull ASTNode node) {
+            if (!forElement.isEmpty()) {
+                if (!forElement.contains(node.getElementType())) {
+                    return null;
+                }
+            }
+
+            if (notForElement.contains(node.getElementType())) {
+                return null;
+            }
+
+            ASTNode parent = node.getTreeParent();
+            if (parent != null) {
+                if (!in.isEmpty()) {
+                    if (!in.contains(parent.getElementType())) {
+                        return null;
+                    }
+                }
+
+                if (notIn.contains(parent.getElementType())) {
+                    return null;
+                }
+            }
+            else {
+                if (!in.isEmpty()) {
+                    return null;
+                }
+            }
+
+            return defaultIndent;
+        }
+    }
+}

idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java

@@ -48,10 +48,6 @@ public class JetBlock extends AbstractBlock {
             JetNodeTypes.CLASS_BODY,
             JetNodeTypes.FUNCTION_LITERAL_EXPRESSION);
 
-    private static final TokenSet STATEMENT_PARTS = TokenSet.create(
-            JetNodeTypes.THEN,
-            JetNodeTypes.ELSE);
-
     // private static final List<IndentWhitespaceRule>
 
     public JetBlock(@NotNull ASTNode node,
@@ -241,35 +237,50 @@ public class JetBlock extends AbstractBlock {
         };
     }
 
-    @Override
-    protected Indent getChildIndent() {
-        return super.getChildIndent();    //To change body of overridden methods use File | Settings | File Templates.
-    }
+    static ASTIndentStrategy[] INDENT_RULES = new ASTIndentStrategy[] {
+            ASTIndentStrategy.forNode("No indent for braces in blocks")
+                    .in(JetNodeTypes.BLOCK, JetNodeTypes.CLASS_BODY, JetNodeTypes.FUNCTION_LITERAL_EXPRESSION)
+                    .forType(JetTokens.RBRACE, JetTokens.LBRACE)
+                    .set(Indent.getNoneIndent()),
+
+            ASTIndentStrategy.forNode("Indent for block content")
+                    .in(JetNodeTypes.BLOCK, JetNodeTypes.CLASS_BODY, JetNodeTypes.FUNCTION_LITERAL_EXPRESSION)
+                    .notForType(JetTokens.RBRACE, JetTokens.LBRACE)
+                    .set(Indent.getNormalIndent()),
+
+            ASTIndentStrategy.forNode("Indent for property accessors")
+                    .in(JetNodeTypes.PROPERTY)
+                    .forType(JetNodeTypes.PROPERTY_ACCESSOR)
+                    .set(Indent.getNormalIndent()),
+
+            ASTIndentStrategy.forNode("For a single statement if 'for'")
+                    .in(JetNodeTypes.BODY)
+                    .notForType(JetNodeTypes.BLOCK)
+                    .set(Indent.getNormalIndent()),
+
+            ASTIndentStrategy.forNode("For the entry in when")
+                    .forType(JetNodeTypes.WHEN_ENTRY)
+                    .set(Indent.getNormalIndent()),
+
+            ASTIndentStrategy.forNode("For single statement in THEN and ELSE")
+                    .in(JetNodeTypes.THEN, JetNodeTypes.ELSE)
+                    .notForType(JetNodeTypes.BLOCK)
+                    .set(Indent.getNormalIndent())
+    };
 
     @Nullable
-    protected Indent createChildIndent(@NotNull ASTNode child) {
-        CommonCodeStyleSettings commonSettings = mySettings.getCommonSettings(JetLanguage.INSTANCE);
-
+    protected static Indent createChildIndent(@NotNull ASTNode child) {
         ASTNode childParent = child.getTreeParent();
         IElementType childType = child.getElementType();
 
-        if (CODE_BLOCKS.contains(myNode.getElementType())) {
-            return indentIfNotBrace(child);
-        }
-
-        if (childParent != null &&
-                 childParent.getElementType() == JetNodeTypes.BODY &&
-                 childType != JetNodeTypes.BLOCK) {
-
-            // For a single statement if 'for'
-            return Indent.getNormalIndent();
+        for (ASTIndentStrategy strategy : INDENT_RULES) {
+            Indent indent = strategy.getIndent(child);
+            if (indent != null) {
+                return indent;
+            }
         }
 
-        if (childType == JetNodeTypes.WHEN_ENTRY) {
-            // For the entry in when
-            // TODO: Add an option for configuration?
-            return Indent.getNormalIndent();
-        }
+        // TODO: Try to rewrite other rules to declarative style
 
         if (childParent != null && childParent.getElementType() == JetNodeTypes.WHEN_ENTRY) {
             ASTNode prev = getPrevWithoutWhitespace(child);
@@ -278,10 +289,6 @@ public class JetBlock extends AbstractBlock {
             }
         }
 
-        if (STATEMENT_PARTS.contains(myNode.getElementType()) && childType != JetNodeTypes.BLOCK) {
-            return Indent.getNormalIndent();
-        }
-
         if (childParent != null && childParent.getElementType() == JetNodeTypes.DOT_QUALIFIED_EXPRESSION) {
             if (childParent.getFirstChildNode() != child && childParent.getLastChildNode() != child) {
                 return Indent.getContinuationWithoutFirstIndent(false);

idea/testData/formatter/GetterAndSetter.kt

+class Test {
+    var test : Int
+    get () {
+        return 0
+    }
+    set (value) {
+        throw NotSupportedException()
+    }
+}
\ No newline at end of file

idea/testData/formatter/GetterAndSetter_after.kt

+class Test {
+    var test : Int
+        get () {
+            return 0
+        }
+        set (value) {
+            throw NotSupportedException()
+        }
+}
\ No newline at end of file

idea/testData/quickfix/typeAddition/afterWrongGetterParameterType.kt

 // "Change getter type to Int" "true"
 class A() {
     val i: Int
-    get(): Int = 1
+        get(): Int = 1
 }

idea/testData/quickfix/typeAddition/afterWrongSetterParameterType.kt

 // "Change setter parameter type to Int" "true"
 class A() {
     var i: Int = 0
-    set(v: Int) {}
+        set(v: Int) {}
 }

idea/testData/quickfix/typeAddition/beforeWrongGetterParameterType.kt

 // "Change getter type to Int" "true"
 class A() {
     val i: Int
-    get(): <caret>Any = 1
+        get(): <caret>Any = 1
 }

idea/testData/quickfix/typeAddition/beforeWrongSetterParameterType.kt

 // "Change setter parameter type to Int" "true"
 class A() {
     var i: Int = 0
-    set(v: <caret>Any) {}
+        set(v: <caret>Any) {}
 }

idea/testData/quickfix/variables/changeMutability/afterValWithSetter.kt

 // "Make variable mutable" "true"
 class A() {
     var a : Int = 0
-    set(v : Int) {
-    }
+        set(v : Int) {
+        }
 }

idea/testData/templates/exval.exp.kt

 val Int.v : Int
-get() {
-    <caret>
-}
+    get() {
+        <caret>
+    }
\ No newline at end of file

idea/testData/templates/exvar.exp.kt

 var Int.v : Int
-get() {
-    <caret>
-}
-set(value) {
+    get() {
+        <caret>
+    }
+    set(value) {
 
-}
+    }
\ No newline at end of file

idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java

@@ -67,6 +67,10 @@ public class JetFormatterTest extends AbstractJetFormatterTest {
         doTest();
     }
 
+    public void testGetterAndSetter() throws Exception {
+        doTest();
+    }
+
     public void testIf() throws Exception {
         doTest();
     }

idea/tests/org/jetbrains/jet/formatter/JetTypingIndentationTest.java

@@ -21,7 +21,6 @@ import com.intellij.psi.codeStyle.CodeStyleSettings;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.testFramework.LightCodeInsightTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
-import org.jetbrains.jet.plugin.formatter.JetCodeStyleSettings;
 
 import java.io.File;
 
@@ -106,10 +105,6 @@ public class JetTypingIndentationTest extends LightCodeInsightTestCase {
         checkResultByFile(afterFileName);
     }
 
-    public static JetCodeStyleSettings getJetSettings() {
-        return getSettings().getCustomSettings(JetCodeStyleSettings.class);
-    }
-
     public static CodeStyleSettings getSettings() {
         return CodeStyleSettingsManager.getSettings(getProject());
     }