ClassMemberProcessor restructured

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java

@@ -38,7 +38,6 @@ import static com.intellij.psi.util.PsiFormatUtilBase.*;
 public final class MembersCache {
     private static final ImmutableSet<String> OBJECT_METHODS = ImmutableSet.of("hashCode()", "equals(java.lang.Object)", "toString()");
 
-    @NotNull
     private final Map<Name, NamedMembers> namedMembersMap = new HashMap<Name, NamedMembers>();
 
     @Nullable
@@ -135,6 +134,42 @@ public final class MembersCache {
             processNestedClasses();
         }
 
+        private void processFields() {
+            // Hack to load static members for enum class loaded from class file
+            if (kotlin && !psiClass.getPsiClass().isEnum()) {
+                return;
+            }
+            for (PsiField field : psiClass.getPsiClass().getAllFields()) {
+                processField(field);
+            }
+        }
+
+        private void processMethods() {
+            parseAllMethodsAsProperties();
+            processOwnMethods();
+        }
+
+        private void processOwnMethods() {
+            for (PsiMethod ownMethod : psiClass.getPsiClass().getMethods()) {
+                processOwnMethod(ownMethod);
+            }
+        }
+
+        private void parseAllMethodsAsProperties() {
+            for (PsiMethod method : psiClass.getPsiClass().getAllMethods()) {
+                parseMethodAsProperty(method);
+            }
+        }
+
+        private void processNestedClasses() {
+            if (!staticMembers) {
+                return;
+            }
+            for (PsiClass nested : psiClass.getPsiClass().getInnerClasses()) {
+                processNestedClass(nested);
+            }
+        }
+
         private boolean includeMember(PsiMemberWrapper member) {
             if (psiClass.getPsiClass().isEnum() && staticMembers) {
                 return member.isStatic();
@@ -161,37 +196,25 @@ public final class MembersCache {
             return true;
         }
 
-        private void processFields() {
+        private void processField(PsiField field) {
-            // Hack to load static members for enum class loaded from class file
-            if (kotlin && !psiClass.getPsiClass().isEnum()) {
-                return;
-            }
-            for (PsiField field : psiClass.getPsiClass().getAllFields()) {
             PsiFieldWrapper fieldWrapper = new PsiFieldWrapper(field);
 
             // group must be created even for excluded field
             NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(fieldWrapper.getName()));
 
             if (!includeMember(fieldWrapper)) {
-                    continue;
+                return;
             }
 
             TypeSource type = new TypeSource("", fieldWrapper.getType(), field);
             namedMembers.addPropertyAccessor(new PropertyPsiDataElement(fieldWrapper, type, null));
         }
-        }
 
-        private void processMethods() {
+        private void processOwnMethod(PsiMethod ownMethod) {
-            parseAllMethodsAsProperties();
-            processOwnMethods();
-        }
-
-        private void processOwnMethods() {
-            for (PsiMethod ownMethod : psiClass.getPsiClass().getMethods()) {
             PsiMethodWrapper method = new PsiMethodWrapper(ownMethod);
 
             if (!includeMember(method)) {
-                    continue;
+                return;
             }
 
             PropertyParseResult propertyParseResult = PropertyNameUtils.parseMethodToProperty(method.getName());
@@ -209,7 +232,6 @@ public final class MembersCache {
                 namedMembers.addMethod(method);
             }
         }
-        }
 
         private void processSetter(PsiMethodWrapper method, PropertyParseResult propertyParseResult) {
             String propertyName = propertyParseResult.getPropertyName();
@@ -287,8 +309,7 @@ public final class MembersCache {
             }
         }
 
-        private void parseAllMethodsAsProperties() {
+        private void parseMethodAsProperty(PsiMethod method) {
-            for (PsiMethod method : psiClass.getPsiClass().getAllMethods()) {
             createEmptyEntry(Name.identifier(method.getName()));
 
             PropertyParseResult propertyParseResult = PropertyNameUtils.parseMethodToProperty(method.getName());
@@ -296,24 +317,18 @@ public final class MembersCache {
                 createEmptyEntry(Name.identifier(propertyParseResult.getPropertyName()));
             }
         }
-        }
 
         private void createEmptyEntry(@NotNull Name identifier) {
             getOrCreateEmpty(identifier);
         }
 
-        private void processNestedClasses() {
+        private void processNestedClass(PsiClass nested) {
-            if (!staticMembers) {
-                return;
-            }
-            for (PsiClass nested : psiClass.getPsiClass().getInnerClasses()) {
             if (isSamInterface(nested)) {
                 NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(nested.getName()));
                 namedMembers.setSamInterface(nested);
             }
         }
     }
-    }
 
     public static boolean isObjectMethodInInterface(@NotNull PsiMember member) {
         if (!(member instanceof PsiMethod)) {