store ResolverScopeData in Java*Scope

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

@@ -33,25 +33,17 @@ import java.util.*;
  * @author abreslav
  */
 public class JavaClassMembersScope extends JavaClassOrPackageScope {
-    @NotNull
-    protected final PsiClass psiClass;
-    private final boolean staticMembers;
     private final Map<String, ClassifierDescriptor> classifiers = Maps.newHashMap();
     private Collection<DeclarationDescriptor> allDescriptors;
 
     public JavaClassMembersScope(
-            @NotNull ClassOrNamespaceDescriptor classOrNamespaceDescriptor,
-            @NotNull PsiClass psiClass,
             @NotNull JavaSemanticServices semanticServices,
-            boolean staticMembers) {
-        super(classOrNamespaceDescriptor, semanticServices, psiClass);
-        this.psiClass = psiClass;
-        this.staticMembers = staticMembers;
-    }
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverScopeData) {
+        super(semanticServices, resolverScopeData);
 
-    @Override
-    protected boolean staticMembers() {
-        return staticMembers;
+        if (resolverScopeData.psiClass == null) {
+            throw new IllegalArgumentException("must pass PsiClass here");
+        }
     }
 
     @NotNull
@@ -90,20 +82,21 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData));
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(resolverScopeData));
 
-            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(descriptor, psiClass, staticMembers));
+            allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(
+                    resolverScopeData.classOrNamespaceDescriptor, resolverScopeData.psiClass, resolverScopeData.staticMembers));
         }
         return allDescriptors;
     }
 
     private ClassifierDescriptor doGetClassifierDescriptor(String name) {
         // TODO : suboptimal, walk the list only once
-        for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
+        for (PsiClass innerClass : resolverScopeData.psiClass.getAllInnerClasses()) {
             if (name.equals(innerClass.getName())) {
-                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != staticMembers) return null;
+                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != resolverScopeData.staticMembers) return null;
                 ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver()
                         .resolveClass(new FqName(innerClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                 if (classDescriptor != null) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java

@@ -25,7 +25,6 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
-import java.util.Collections;
 import java.util.Set;
 
 /**
@@ -33,51 +32,34 @@ import java.util.Set;
  */
 public abstract class JavaClassOrPackageScope extends JetScopeImpl {
 
-    @NotNull
-    protected final ClassOrNamespaceDescriptor descriptor;
     @NotNull
     protected final JavaSemanticServices semanticServices;
-    @Nullable
-    protected final PsiClass psiClass;
+    @NotNull
+    protected final JavaDescriptorResolver.ResolverScopeData resolverScopeData;
 
-    protected JavaClassOrPackageScope(@NotNull ClassOrNamespaceDescriptor descriptor, @NotNull JavaSemanticServices semanticServices,
-                                      @Nullable PsiClass psiClass) {
-        this.descriptor = descriptor;
+    protected JavaClassOrPackageScope(
+            @NotNull JavaSemanticServices semanticServices,
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverScopeData) {
         this.semanticServices = semanticServices;
-        this.psiClass = psiClass;
-
-        JavaDescriptorResolver.checkPsiClassIsNotJet(psiClass);
+        this.resolverScopeData = resolverScopeData;
     }
 
     @NotNull
     @Override
     public DeclarationDescriptor getContainingDeclaration() {
-        return descriptor;
+        return resolverScopeData.classOrNamespaceDescriptor;
     }
 
-    protected abstract boolean staticMembers();
-
     @NotNull
     @Override
     public Set<VariableDescriptor> getProperties(@NotNull String name) {
-        if (psiClass == null) {
-            return Collections.emptySet();
-        }
-
-        // TODO: cache
-        return semanticServices.getDescriptorResolver().resolveFieldGroupByName(
-                descriptor, psiClass, name, staticMembers());
+        return semanticServices.getDescriptorResolver().resolveFieldGroupByName(name, resolverScopeData);
     }
 
     @NotNull
     @Override
     public Set<FunctionDescriptor> getFunctions(@NotNull String name) {
-
-        if (psiClass == null) {
-            return Collections.emptySet();
-        }
-
-        return semanticServices.getDescriptorResolver().resolveFunctionGroup(descriptor, psiClass, name, staticMembers());
+        return semanticServices.getDescriptorResolver().resolveFunctionGroup(name, resolverScopeData);
     }
 
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.google.common.collect.Sets;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiPackage;
@@ -46,11 +45,11 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     public JavaPackageScope(
             @NotNull FqName packageFQN,
-            @NotNull NamespaceDescriptor containingDescriptor,
             @NotNull JavaSemanticServices semanticServices,
             @Nullable PsiPackage psiPackage,
-            @Nullable PsiClass psiClass) {
-        super(containingDescriptor, semanticServices, psiClass);
+            @Nullable PsiClass psiClass,
+            @NotNull JavaDescriptorResolver.ResolverScopeData resolverNamespaceData) {
+        super(semanticServices, resolverNamespaceData);
         this.packageFQN = packageFQN;
         this.psiPackage = psiPackage;
 
@@ -61,7 +60,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @Override
     public ClassifierDescriptor getClassifier(@NotNull String name) {
-        ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+        ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         if (classDescriptor == null || DescriptorUtils.isObject(classDescriptor)) {
             // TODO: this is a big hack against several things that I barely understand myself and cannot explain
             // 1. We should not return objects from this method, and maybe JDR.resolveClass should not return too
@@ -79,12 +78,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @Override
     public NamespaceDescriptor getNamespace(@NotNull String name) {
-        return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name), DescriptorSearchRule.INCLUDE_KOTLIN);
-    }
-
-    @Override
-    protected boolean staticMembers() {
-        return true;
+        return semanticServices.getDescriptorResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
 
     /**
@@ -96,10 +90,10 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
-            if (psiClass != null) {
-                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass, descriptor));
+            if (resolverScopeData.psiClass != null) {
+                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData));
 
-                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers()));
+                allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(resolverScopeData));
             }
 
             if (psiPackage != null) {
@@ -107,7 +101,8 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                 final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver();
 
                 for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
-                    NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                    NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(
+                            new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                     if (childNs != null) {
                         allDescriptors.add(childNs);
                     }
@@ -140,9 +135,4 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
         return allDescriptors;
     }
-
-    @NotNull
-    static FqName getQualifiedName(@NotNull FqName packageFQN, @NotNull String name) {
-        return packageFQN.child(name);
-    }
 }