diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementVisitor.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementVisitor.java
index 197e71a0ecbf..bd56761a3292 100644
--- a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementVisitor.java
+++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaArrangementVisitor.java
@@ -35,7 +35,7 @@ import java.util.*;
 import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.*;
 import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Modifier.*;
 
-public class JavaArrangementVisitor extends JavaElementVisitor {
+public class JavaArrangementVisitor extends JavaRecursiveElementVisitor {
 
   private static final String NULL_CONTENT = "no content";
 
@@ -90,6 +90,10 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
     processEntry(entry, aClass, aClass);
   }
 
+  @Override
+  public void visitTypeParameter(PsiTypeParameter parameter) {
+  }
+
   @Override
   public void visitAnonymousClass(PsiAnonymousClass aClass) {
     JavaElementArrangementEntry entry = createNewEntry(
@@ -98,13 +102,6 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
     processEntry(entry, null, aClass);
   }
 
-  @Override
-  public void visitJavaFile(PsiJavaFile file) {
-    for (PsiClass psiClass : file.getClasses()) {
-      visitClass(psiClass);
-    }
-  }
-
   @Override
   public void visitField(PsiField field) {
     // There is a possible case that more than one field is declared for the same type like 'int i, j;'. We want to process only
@@ -348,36 +345,6 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
     }
   }
 
-  @Override
-  public void visitExpressionStatement(PsiExpressionStatement statement) {
-    statement.getExpression().acceptChildren(this);
-  }
-
-  @Override
-  public void visitNewExpression(PsiNewExpression expression) {
-    PsiAnonymousClass anonymousClass = expression.getAnonymousClass();
-    if (anonymousClass == null) {
-      return;
-    }
-    JavaElementArrangementEntry entry =
-      createNewEntry(anonymousClass, anonymousClass.getTextRange(), CLASS, anonymousClass.getName(), false);
-    processEntry(entry, null, anonymousClass);
-  }
-
-  @Override
-  public void visitExpressionList(PsiExpressionList list) {
-    for (PsiExpression expression : list.getExpressions()) {
-      expression.acceptChildren(this);
-    }
-  }
-
-  @Override
-  public void visitDeclarationStatement(PsiDeclarationStatement statement) {
-    for (PsiElement element : statement.getDeclaredElements()) {
-      element.acceptChildren(this);
-    }
-  }
-
   @Override
   public void visitEnumConstant(PsiEnumConstant enumConstant) {
   }
@@ -468,7 +435,7 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
   }
   
   private static class MethodBodyProcessor extends JavaRecursiveElementVisitor {
-    
+
     @NotNull private final JavaArrangementParseInfo myInfo;
     @Nullable private PsiMethod myBaseMethod;
 
@@ -489,7 +456,7 @@ public class JavaArrangementVisitor extends JavaElementVisitor {
           myInfo.registerMethodCallDependency(myBaseMethod, m);
         }
       }
-      
+
       // We process all method call expression children because there is a possible case like below:
       //   new Runnable() {
       //     void test();
diff --git a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerAnonymousClassesTest.groovy b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerAnonymousClassesTest.groovy
index 3d79cd525cfd..a8a1c3e87513 100644
--- a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerAnonymousClassesTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerAnonymousClassesTest.groovy
@@ -15,6 +15,8 @@
  */
 package com.intellij.psi.codeStyle.arrangement
 
+import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.*
+
 class JavaRearrangerAnonymousClassesTest extends AbstractJavaRearrangerTest {
 
   public void "test rearrangement doesn't brake anon classes alignment"() {
@@ -42,10 +44,56 @@ public class Test {
     )
   }
 
+  public void "test anonymous classes inside method"() {
+    doTest(
+      initial: '''\
+public class Rearranging {
 
+    public void Testing() {
 
+        class Model {
+            private Cat cat = new Cat();
+            private Dog dog = new Dog();
+            class Cat { private String catSound = "MIAU"; }
+            class Dog { private String dogSound = "AUAU"; }
+        }
 
+        class Born { private String date; }
 
+        class Die { private String date; }
 
+    }
 
+    private int value;
+}
+''',
+      expected: '''\
+public class Rearranging {
+
+    private int value;
+
+    public void Testing() {
+
+        class Model {
+            private Cat cat = new Cat();
+            private Dog dog = new Dog();
+            class Cat { private String catSound = "MIAU"; }
+            class Dog { private String dogSound = "AUAU"; }
+        }
+
+        class Born { private String date; }
+
+        class Die { private String date; }
+
+    }
+}
+''',
+      rules: [rule(FIELD),
+              rule(ENUM),
+              rule(INTERFACE),
+              rule(CLASS),
+              rule(CONSTRUCTOR),
+              rule(METHOD)]
+    )
+  }
 }
diff --git a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy
index 9ff692e20188..47c7dee212b1 100644
--- a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy
@@ -426,4 +426,48 @@ public enum ErrorResponse {
       ]
     )
   }
+
+  void "test parameterized class"() {
+    doTest(
+      initial: '''\
+public class Seq<T> {
+
+    public Seq(T x) {
+    }
+
+    public Seq() {}
+
+    static <T> Seq<T> nil() {
+        return new Seq<T>();
+    }
+
+    static <V> Seq<V> cons(V x) {
+        return new Seq<V>(x);
+    }
+
+    int filed;
+}
+''',
+      expected: '''\
+public class Seq<T> {
+
+    int filed;
+
+    public Seq(T x) {
+    }
+
+    public Seq() {}
+    static <T> Seq<T> nil() {
+        return new Seq<T>();
+    }
+    static <V> Seq<V> cons(V x) {
+        return new Seq<V>(x);
+    }
+}
+''',
+      rules: [
+        rule(FIELD)
+      ]
+    )
+  }
 }