diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java
index 80342d509e4..fd2da0fdcc9 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaInnerClassResolver.java
@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
+import com.google.common.collect.Lists;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import org.jetbrains.annotations.NotNull;
@@ -29,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 public final class JavaInnerClassResolver {
@@ -49,40 +51,39 @@ public final class JavaInnerClassResolver {
         }
 
         PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
-        List<ClassDescriptor> r = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
+        List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
         for (PsiClass innerPsiClass : innerPsiClasses) {
-            if (innerPsiClass.hasModifierProperty(PsiModifier.PRIVATE)) {
-                // TODO: hack against inner classes
-                continue;
-            }
-            if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) {
-                continue;
-            }
-            if (DescriptorResolverUtils.isInnerEnum(innerPsiClass, owner)) {
-                // Inner enums will be put later into our class object
+            if (shouldBeIgnored(owner, innerPsiClass)) {
                 continue;
             }
             ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
-            r.add(classDescriptor);
+            result.add(classDescriptor);
         }
-        return r;
+        return result;
+    }
+
+    private static boolean shouldBeIgnored(DeclarationDescriptor owner, PsiClass innerPsiClass) {
+        // TODO: hack against inner classes
+        return innerPsiClass.hasModifierProperty(PsiModifier.PRIVATE)
+                || innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)
+                || DescriptorResolverUtils.isInnerEnum(innerPsiClass, owner);
     }
 
     private List<ClassDescriptor> resolveInnerClassesOfClassObject(DeclarationDescriptor owner, PsiClass psiClass) {
         if (!DescriptorUtils.isClassObject(owner)) {
-            return new ArrayList<ClassDescriptor>(0);
+            return Collections.emptyList();
         }
 
-        List<ClassDescriptor> r = new ArrayList<ClassDescriptor>(0);
+        List<ClassDescriptor> result = Lists.newArrayList();
         // If we're a class object, inner enums of our parent need to be put into us
         DeclarationDescriptor containingDeclaration = owner.getContainingDeclaration();
         for (PsiClass innerPsiClass : psiClass.getInnerClasses()) {
             if (DescriptorResolverUtils.isInnerEnum(innerPsiClass, containingDeclaration)) {
                 ClassDescriptor classDescriptor = resolveInnerClass(innerPsiClass);
-                r.add(classDescriptor);
+                result.add(classDescriptor);
             }
         }
-        return r;
+        return result;
     }
 
     private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {