Simplify implementation of JavaClassNonStaticMembersScope#getClassifier()

Also cache inner classes and classifiers

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java

@@ -42,13 +42,10 @@ public abstract class JavaBaseScope extends JetScopeImpl {
 
     @NotNull
     protected final JavaSemanticServices semanticServices;
-
     @NotNull
     protected final PsiDeclarationProvider declarationProvider;
-
     @NotNull
     private final Map<Name, Set<FunctionDescriptor>> functionDescriptors = Maps.newHashMap();
-
     @NotNull
     private final Map<Name, Set<VariableDescriptor>> propertyDescriptors = Maps.newHashMap();
     @Nullable
@@ -56,6 +53,9 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     @NotNull
     protected final ClassOrNamespaceDescriptor descriptor;
 
+    private Collection<ClassDescriptor> innerClasses = null;
+
+
     protected JavaBaseScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull JavaSemanticServices semanticServices,
@@ -130,7 +130,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     protected Collection<DeclarationDescriptor> computeAllDescriptors() {
         Collection<DeclarationDescriptor> result = Sets.newHashSet();
         result.addAll(computeFieldAndFunctionDescriptors());
-        result.addAll(computeInnerClasses());
+        result.addAll(getInnerClasses());
         return result;
     }
 
@@ -166,4 +166,12 @@ public abstract class JavaBaseScope extends JetScopeImpl {
         }
         throw new IllegalStateException();
     }
+
+    @NotNull
+    protected Collection<ClassDescriptor> getInnerClasses() {
+        if (innerClasses == null) {
+            innerClasses = computeInnerClasses();
+        }
+        return innerClasses;
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java

@@ -17,21 +17,23 @@
 package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 
 public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
     protected final ClassPsiDeclarationProvider declarationProvider;
 
+    private Map<Name, ClassifierDescriptor> classifiersMap = null;
+
     protected JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull ClassPsiDeclarationProvider declarationProvider,
@@ -53,4 +55,21 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
         return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
     }
+
+    @Override
+    public ClassifierDescriptor getClassifier(@NotNull Name name) {
+        return getClassifiersMap().get(name);
+    }
+
+    @NotNull
+    private Map<Name, ClassifierDescriptor> getClassifiersMap() {
+        if (classifiersMap == null) {
+            Collection<ClassDescriptor> innerClasses = getInnerClasses();
+            classifiersMap = new HashMap<Name, ClassifierDescriptor>();
+            for (ClassDescriptor innerClass : innerClasses) {
+                classifiersMap.put(innerClass.getName(), innerClass);
+            }
+        }
+        return classifiersMap;
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java

@@ -16,27 +16,16 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
-import com.google.common.collect.Maps;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiModifier;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
-import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
-import java.util.Map;
 
 public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope {
 
-    @NotNull
-    private final Map<Name, ClassifierDescriptor> classifiers = Maps.newHashMap();
-
     private Collection<ConstructorDescriptor> constructors = null;
     @NotNull
     private final ClassDescriptor descriptor;
@@ -50,33 +39,6 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
         this.descriptor = descriptor;
     }
 
-    @Override
-    public ClassifierDescriptor getClassifier(@NotNull Name name) {
-        ClassifierDescriptor classifierDescriptor = classifiers.get(name);
-        if (classifierDescriptor == null) {
-            classifierDescriptor = doGetClassifierDescriptor(name);
-            classifiers.put(name, classifierDescriptor);
-        }
-        return classifierDescriptor;
-    }
-
-    private ClassifierDescriptor doGetClassifierDescriptor(Name name) {
-        // TODO : suboptimal, walk the list only once
-        for (PsiClass innerClass : declarationProvider.getPsiClass().getAllInnerClasses()) {
-            if (name.getName().equals(innerClass.getName())) {
-                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != declarationProvider.isStaticMembers()) return null;
-                String qualifiedName = innerClass.getQualifiedName();
-                assert qualifiedName != null;
-                ClassDescriptor classDescriptor = getResolver()
-                        .resolveClass(new FqName(qualifiedName), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-                if (classDescriptor != null) {
-                    return classDescriptor;
-                }
-            }
-        }
-        return null;
-    }
-
 
     @NotNull
     public Collection<ConstructorDescriptor> getConstructors() {