- KT-1068 Formatter: no indent after for

- KT-1098  After entering "if (lock == null)" and pressing enter indent is wrong
- Move tests for formatter

compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java

@@ -20,6 +20,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private static final TokenSet WHEN_CONDITION_RECOVERY_SET = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD);
     private static final TokenSet WHEN_CONDITION_RECOVERY_SET_WITH_ARROW = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD, ARROW, DOT);
 
+
     private static final ImmutableMap<String, JetToken> KEYWORD_TEXTS = tokenSetToMap(KEYWORDS);
 
     private static ImmutableMap<String, JetToken> tokenSetToMap(TokenSet tokens) {
@@ -1406,9 +1407,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
             parseControlStructureBody();
         }
 
-        expect(WHILE_KEYWORD, "Expecting 'while' followed by a post-condition");
+        if (expect(WHILE_KEYWORD, "Expecting 'while' followed by a post-condition")) {
-
+            parseCondition();
-        parseCondition();
+        }
 
         loop.done(DO_WHILE);
     }

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

@@ -2,9 +2,9 @@ package org.jetbrains.jet.plugin.formatter;
 
 import com.intellij.formatting.*;
 import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.TokenType;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
+import com.intellij.psi.formatter.common.AbstractBlock;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
@@ -16,15 +16,14 @@ import java.util.Collections;
 import java.util.List;
 
 /**
+ * @see Block for good JavaDoc documentation
  * @author yole
  */
-public class JetBlock implements ASTBlock {
+public class JetBlock extends AbstractBlock {
-    private ASTNode myNode;
-    private Alignment myAlignment;
     private Indent myIndent;
-    private Wrap myWrap;
     private CodeStyleSettings mySettings;
     private final SpacingBuilder mySpacingBuilder;
+    
     private List<Block> mySubBlocks;
 
     private static final TokenSet CODE_BLOCKS = TokenSet.create(
@@ -35,52 +34,35 @@ public class JetBlock implements ASTBlock {
     private static final TokenSet STATEMENT_PARTS = TokenSet.create(
             JetNodeTypes.THEN,
             JetNodeTypes.ELSE);
+    
+    // private static final List<IndentWhitespaceRule>
 
-    public JetBlock(ASTNode node, Alignment alignment, Indent indent, Wrap wrap, CodeStyleSettings settings,
+    public JetBlock(@NotNull ASTNode node,
-                    SpacingBuilder spacingBuilder) {
+            Alignment alignment,
-        myNode = node;
+            Indent indent,
-        myAlignment = alignment;
+            Wrap wrap,
+            CodeStyleSettings settings,
+            SpacingBuilder spacingBuilder) {
+
+        super(node, wrap, alignment);
         myIndent = indent;
-        myWrap = wrap;
         mySettings = settings;
         mySpacingBuilder = spacingBuilder;
     }
 
-    @Override
-    public ASTNode getNode() {
-        return myNode;
-    }
-
-    @NotNull
-    @Override
-    public TextRange getTextRange() {
-        return myNode.getTextRange();
-    }
-
-    @Override
-    public Wrap getWrap() {
-        return myWrap;
-    }
-
     @Override
     public Indent getIndent() {
         return myIndent;
     }
 
     @Override
-    public Alignment getAlignment() {
+    protected List<Block> buildChildren() {
-        return myAlignment;
-    }
-
-    @NotNull
-    @Override
-    public List<Block> getSubBlocks() {
         if (mySubBlocks == null) {
             mySubBlocks = buildSubBlocks();
         }
         return new ArrayList<Block>(mySubBlocks);
     }
-
+    
     private List<Block> buildSubBlocks() {
         List<Block> blocks = new ArrayList<Block>();
         for (ASTNode child = myNode.getFirstChildNode(); child != null; child = child.getTreeNext()) {
@@ -97,7 +79,8 @@ public class JetBlock implements ASTBlock {
         return Collections.unmodifiableList(blocks);
     }
 
-    private Block buildSubBlock(ASTNode child) {
+    @NotNull
+    private Block buildSubBlock(@NotNull ASTNode child) {
         Wrap wrap = null;
         Indent childIndent = Indent.getNoneIndent();
         Alignment childAlignment = null;
@@ -128,7 +111,7 @@ public class JetBlock implements ASTBlock {
         return new JetBlock(child, childAlignment, childIndent, wrap, mySettings, mySpacingBuilder);
     }
 
-    private static Indent indentIfNotBrace(ASTNode child) {
+    private static Indent indentIfNotBrace(@NotNull ASTNode child) {
         return child.getElementType() == JetTokens.RBRACE || child.getElementType() == JetTokens.LBRACE
                 ? Indent.getNoneIndent()
                 : Indent.getNormalIndent();
@@ -151,16 +134,18 @@ public class JetBlock implements ASTBlock {
     @NotNull
     @Override
     public ChildAttributes getChildAttributes(int newChildIndex) {
-        Indent childIndent = Indent.getNoneIndent();
+        final IElementType type = getNode().getElementType();
-        if (CODE_BLOCKS.contains(myNode.getElementType()) || myNode.getElementType() == JetNodeTypes.WHEN) {
+        if (CODE_BLOCKS.contains(type) ||
-            childIndent = Indent.getNormalIndent();
+                type == JetNodeTypes.WHEN ||
-        }
+                type == JetNodeTypes.IF ||
-        return new ChildAttributes(childIndent, null);
+                type == JetNodeTypes.FOR ||
-    }
+                type == JetNodeTypes.WHILE ||
+                type == JetNodeTypes.DO_WHILE) {
 
-    @Override
+            return new ChildAttributes(Indent.getNormalIndent(), null);
-    public boolean isIncomplete() {
+        }
-        return false;
+
+        return new ChildAttributes(Indent.getNoneIndent(), null);
     }
 
     @Override

idea/testData/formatter/IndentationOnNewline/DoInFun.after.kt

@@ -0,0 +1,4 @@
+fun some() {
+    do
+        <caret>
+}

idea/testData/formatter/IndentationOnNewline/DoInFun.kt

@@ -0,0 +1,3 @@
+fun some() {
+    do<caret>
+}

idea/testData/formatter/IndentationOnNewline/For.after.kt

@@ -0,0 +1,3 @@
+fun some() {
+    for (var i in 1..10)
+        <caret>

idea/testData/formatter/IndentationOnNewline/For.kt

@@ -0,0 +1,2 @@
+fun some() {
+    for (var i in 1..10)<caret>

idea/testData/formatter/IndentationOnNewline/If.after.kt

@@ -0,0 +1,4 @@
+fun some() {
+    if (3 > 5)
+        <caret>
+}

idea/testData/formatter/IndentationOnNewline/If.kt

@@ -0,0 +1,3 @@
+fun some() {
+    if (3 > 5)<caret>
+}

idea/testData/formatter/IndentationOnNewline/While.after.kt

@@ -0,0 +1,4 @@
+fun some() {
+    var t = 12
+    while (t > 0)
+        <caret>

idea/testData/formatter/IndentationOnNewline/While.kt

@@ -0,0 +1,3 @@
+fun some() {
+    var t = 12
+    while (t > 0)<caret>

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

@@ -39,7 +39,7 @@ import java.util.Map;
 
 // Based on from com.intellij.psi.formatter.java.AbstractJavaFormatterTest
 @SuppressWarnings("UnusedDeclaration")
-public abstract class AbstractKotlinFormatterTest extends LightIdeaTestCase {
+public abstract class AbstractJetFormatterTest extends LightIdeaTestCase {
 
     protected enum Action {REFORMAT, INDENT}
 
@@ -96,6 +96,10 @@ public abstract class AbstractKotlinFormatterTest extends LightIdeaTestCase {
         doTextTest(Action.REFORMAT, text, textAfter);
     }
 
+    public void doIndentTextTest(@NonNls final String text, @NonNls String textAfter) throws IncorrectOperationException {
+        doTextTest(Action.INDENT, text, textAfter);
+    }
+
     public void doTextTest(final Action action, final String text, String textAfter) throws IncorrectOperationException {
         final PsiFile file = createFile("A.kt", text);
 

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

@@ -3,7 +3,7 @@ package org.jetbrains.jet.formatter;
 /**
  * Based on com.intellij.psi.formatter.java.JavaFormatterTest
  */
-public class KotlinFormatterTest extends AbstractKotlinFormatterTest {
+public class JetFormatterTest extends AbstractJetFormatterTest {
     public void testBlockFor() throws Exception {
         doTest();
     }

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

@@ -0,0 +1,40 @@
+package org.jetbrains.jet.formatter;
+
+import com.intellij.testFramework.LightCodeInsightTestCase;
+import org.jetbrains.jet.plugin.PluginTestCaseBase;
+
+import java.io.File;
+
+/**
+ * @author Nikolay Krasko
+ */
+public class JetTypingIndentationTest extends LightCodeInsightTestCase {
+    public void testWhile() {
+        doFileNewlineTest();
+    }
+
+    public void testFor() {
+        doFileNewlineTest();
+    }
+
+    public void testIf() {
+        doFileNewlineTest();
+    }
+
+    public void testDoInFun() {
+        doFileNewlineTest();
+    }
+
+    public void doFileNewlineTest() {
+        configureByFile(getTestName(false) + ".kt");
+        type('\n');
+        checkResultByFile(getTestName(false) + ".after.kt");
+    }
+
+    @Override
+    protected String getTestDataPath() {
+        final String testRelativeDir = "formatter/IndentationOnNewline";
+        return new File(PluginTestCaseBase.getTestDataPathBase(), testRelativeDir).getPath() +
+               File.separator;
+    }
+}