IDEA-19061 Integrate the Rearranger-plugin into core-IDEA

1. 'Constructor' entry type is defined and supported at java rearranger;
2. Test data fixes;

java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementVisitor.java

@@ -94,7 +94,8 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
 
   @Override
   public void visitMethod(PsiMethod method) {
-    JavaElementArrangementEntry entry = createNewEntry(method.getTextRange(), ArrangementEntryType.METHOD, method.getName(), true);
+    ArrangementEntryType type = method.isConstructor() ? ArrangementEntryType.CONSTRUCTOR : ArrangementEntryType.METHOD;
+    JavaElementArrangementEntry entry = createNewEntry(method.getTextRange(), type, method.getName(), true);
     processEntry(entry, method, method.getBody());
   }
 

java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaElementArrangementEntry.java

@@ -58,6 +58,9 @@ public class JavaElementArrangementEntry extends DefaultArrangementEntry
     super(parent, startOffset, endOffset, canBeArranged);
     myType = type;
     myTypes = EnumSet.of(type);
+    if (myType == ArrangementEntryType.CONSTRUCTOR) {
+      myTypes.add(ArrangementEntryType.METHOD);
+    }
     myName = name;
   }
 

java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java

@@ -45,7 +45,7 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
 {
 
   // Type
-  @NotNull private static final Set<ArrangementEntryType> SUPPORTED_TYPES = EnumSet.of(INTERFACE, CLASS, ENUM, FIELD, METHOD);
+  @NotNull private static final Set<ArrangementEntryType> SUPPORTED_TYPES = EnumSet.of(INTERFACE, CLASS, ENUM, FIELD, METHOD, CONSTRUCTOR);
 
   // Modifier
   @NotNull private static final Set<ArrangementModifier> SUPPORTED_MODIFIERS = EnumSet.of(
@@ -68,6 +68,7 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
     MODIFIERS_BY_TYPE.put(INTERFACE, visibilityModifiers);
     MODIFIERS_BY_TYPE.put(CLASS, concat(commonModifiers, ABSTRACT));
     MODIFIERS_BY_TYPE.put(METHOD, concat(commonModifiers, SYNCHRONIZED, ABSTRACT));
+    MODIFIERS_BY_TYPE.put(CONSTRUCTOR, concat(commonModifiers, SYNCHRONIZED));
     MODIFIERS_BY_TYPE.put(FIELD, concat(commonModifiers, TRANSIENT, VOLATILE));
   }
 
@@ -86,6 +87,7 @@ public class JavaRearranger implements Rearranger<JavaElementArrangementEntry>,
     for (ArrangementModifier modifier : visibility) {
       and(FIELD, modifier);
     }
+    and(CONSTRUCTOR);
     and(METHOD);
     and(ENUM);
     and(INTERFACE);

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/bindFieldsFromParameters/afterSimple.java

@@ -1,12 +1,28 @@
+/*
+ * Copyright 2000-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.
+ */
+
 // "Bind Constructor Parameters to Fields" "true"
 
 class Bar {
 
-  private int myi1;
-  private int myi2;
     private final int myI1;
     private final int myI2;
     private final String myI3;
+    private int myi1;
+    private int myi2;
 
     Bar(int i1, int i2, String i3) {
         myI1 = i1;

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/bindFieldsFromParameters/beforeSimple.java

@@ -1,10 +1,26 @@
+/*
+ * Copyright 2000-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.
+ */
+
 // "Bind Constructor Parameters to Fields" "true"
 
 class Bar {
 
-  private int myi1;
-  private int myi2;
+    private int myi1;
+    private int myi2;
 
-  Bar(int <caret>i1, int i2, String i3) {
-  }
+    Bar(int <caret>i1, int i2, String i3) {
+    }
 }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeParameterClass/before6.java

@@ -1,9 +1,24 @@
+/*
+ * Copyright 2000-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.
+ */
+
 // "Make 'a' implement 'b'" "true"
 class a {
     void f(b<String> r) {
         r.g(<caret>this);
     }
-
 }
 interface b<T> {
   void g(b<T> t);

java/java-tests/testData/refactoring/extractMethodObject/WithPrivateMethodUsed1.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright 2000-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.
+ */
 import java.util.Date;
 
 public class TestClass {
@@ -50,5 +65,4 @@ public class TestClass {
         Date beginDate = ( today == null ? start : today );
         return ( ( endDate.getTime() - beginDate.getTime() ));
     }
-
 }

java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy

@@ -18,6 +18,7 @@ package com.intellij.psi.codeStyle.arrangement
 import org.junit.Before
 
 import static com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType.*
+import static com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier.PUBLIC
 /**
  * @author Denis Zhdanov
  * @since 7/20/12 2:45 PM
@@ -198,4 +199,36 @@ class Test {
             [rule(FIELD)]
     )
   }
+
+  void testMethodsAndConstructors() {
+    doTest('''\
+class Test {
+  abstract void method1();
+  Test() {}
+  abstract void method2();
+}''',
+           '''\
+class Test {
+  Test() {}
+  abstract void method1();
+  abstract void method2();
+}''',
+           [rule(CONSTRUCTOR), rule(METHOD)])
+  }
+
+  void testConstructorAsMethod() {
+    doTest('''\
+class Test {
+  private int i;
+  Test() {}
+  public int j;
+}''',
+           '''\
+class Test {
+  public int j;
+  Test() {}
+  private int i;
+}''',
+           [rule(FIELD, PUBLIC), rule(METHOD), rule(FIELD)])
+  }
 }

platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ArrangementEntryType.java

@@ -27,5 +27,5 @@ import com.intellij.psi.codeStyle.arrangement.ArrangementEntry;
  */
 public enum ArrangementEntryType {
   
-  CLASS, FIELD, METHOD, ENUM, INTERFACE
+  CLASS, FIELD, CONSTRUCTOR, METHOD, ENUM, INTERFACE
 }

platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/DefaultArrangementSettingsRepresentationManager.java

@@ -37,8 +37,8 @@ public class DefaultArrangementSettingsRepresentationManager implements Arrangem
     Object[] ids = {
       
       // Types.
-      ArrangementEntryType.FIELD, ArrangementEntryType.METHOD, ArrangementEntryType.CLASS, ArrangementEntryType.INTERFACE,
-      ArrangementEntryType.ENUM,
+      ArrangementEntryType.FIELD, ArrangementEntryType.CONSTRUCTOR, ArrangementEntryType.METHOD, ArrangementEntryType.CLASS,
+      ArrangementEntryType.INTERFACE, ArrangementEntryType.ENUM,
       
       // Visibility.
       ArrangementModifier.PUBLIC, ArrangementModifier.PROTECTED, ArrangementModifier.PACKAGE_PRIVATE, ArrangementModifier.PRIVATE,

platform/lang-impl/src/com/intellij/psi/codeStyle/arrangement/MemberOrderService.java

@@ -17,16 +17,17 @@ package com.intellij.psi.codeStyle.arrangement;
 
 import com.intellij.lang.Language;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.codeStyle.CommonCodeStyleSettings;
 import com.intellij.psi.codeStyle.arrangement.engine.ArrangementEngine;
 import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware;
+import com.intellij.util.containers.HashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 /**
  * The whole arrangement idea is to allow to change file entries order according to the user-provided rules.
@@ -83,15 +84,35 @@ public class MemberOrderService {
     }
 
     ArrangementEntry parentEntry = entries.get(0);
-    List<ArrangementEntry> entriesWithNew = new ArrayList<ArrangementEntry>(parentEntry.getChildren());
+    List<? extends ArrangementEntry> nonArranged = parentEntry.getChildren();
+    List<ArrangementEntry> entriesWithNew = new ArrayList<ArrangementEntry>(nonArranged);
     entriesWithNew.add(memberEntry);
     List<ArrangementEntry> arranged = ArrangementEngine.arrange(entriesWithNew, rules);
     int i = arranged.indexOf(memberEntry);
+    
     if (i <= 0) {
       return context;
     }
 
-    ArrangementEntry anchorEntry = arranged.get(i - 1);
+    ArrangementEntry anchorEntry = null;
+    if (i >= arranged.size() - 1) {
+      anchorEntry = nonArranged.get(nonArranged.size() - 1);
+    }
+    else {
+      Set<ArrangementEntry> entriesBelow = new HashSet<ArrangementEntry>();
+      entriesBelow.addAll(arranged.subList(i + 1, arranged.size()));
+      for (ArrangementEntry entry : nonArranged) {
+        if (entriesBelow.contains(entry)) {
+          break;
+        }
+        anchorEntry = entry;
+      }
+    }
+
+    if (anchorEntry == null) {
+      return context;
+    }
+    
     return context.findElementAt(anchorEntry.getEndOffset() - context.getTextRange().getStartOffset());
   }
 }