Refactor: split implementation of JavaBaseScope#computeAllDescriptors() and make computeInnerClasses() abstract, provide implementation in subclasses

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

@@ -20,17 +20,16 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.progress.ProgressIndicatorProvider;
-import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.provider.*;
+import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
+import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
@@ -39,8 +38,6 @@ import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
-import static org.jetbrains.jet.lang.resolve.java.scope.ScopeUtils.computeAllPackageDeclarations;
-
 public abstract class JavaBaseScope extends JetScopeImpl {
 
     @NotNull
@@ -130,21 +127,16 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     }
 
     @NotNull
-    private Collection<DeclarationDescriptor> computeAllDescriptors() {
+    protected Collection<DeclarationDescriptor> computeAllDescriptors() {
         Collection<DeclarationDescriptor> result = Sets.newHashSet();
-        if (declarationProvider instanceof ClassPsiDeclarationProvider) {
+        result.addAll(computeFieldAndFunctionDescriptors());
-            PsiClass psiClass = ((ClassPsiDeclarationProvider) declarationProvider).getPsiClass();
+        result.addAll(computeInnerClasses());
-            result.addAll(computeFieldAndFunctionDescriptors());
-            result.addAll(computeInnerClasses(psiClass));
-        }
-        if (declarationProvider instanceof PackagePsiDeclarationProvider) {
-            PsiPackage psiPackage = ((PackagePsiDeclarationProvider) declarationProvider).getPsiPackage();
-            assert descriptor instanceof NamespaceDescriptor;
-            result.addAll(computeAllPackageDeclarations(psiPackage, semanticServices, DescriptorUtils.getFQName(descriptor).toSafe()));
-        }
         return result;
     }
 
+    @NotNull
+    protected abstract Collection<ClassDescriptor> computeInnerClasses();
+
     @NotNull
     private Collection<DeclarationDescriptor> computeFieldAndFunctionDescriptors() {
         Collection<DeclarationDescriptor> result = Lists.newArrayList();
@@ -158,20 +150,6 @@ public abstract class JavaBaseScope extends JetScopeImpl {
         return result;
     }
 
-    @NotNull
-    private Collection<ClassDescriptor> computeInnerClasses(
-            @NotNull PsiClass psiClass
-    ) {
-        // TODO: Trying to hack the situation when we produce namespace descriptor for java class and still want to see inner classes
-        if (descriptor instanceof JavaNamespaceDescriptor) {
-            return getResolver().resolveInnerClasses(descriptor, psiClass, false);
-        }
-        else {
-            return getResolver().resolveInnerClasses(descriptor, psiClass,
-                                                     ((ClassPsiDeclarationProviderImpl) declarationProvider).isStaticMembers());
-        }
-    }
-
     @NotNull
     protected JavaDescriptorResolver getResolver() {
         return semanticServices.getDescriptorResolver();

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

@@ -28,6 +28,7 @@ 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 {
@@ -68,4 +69,10 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
         return null;
     }
 
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), declarationProvider.isStaticMembers());
+    }
 }

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

@@ -26,6 +26,8 @@ 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;
+
 public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     @NotNull
     private final FqName packageFQN;
@@ -55,4 +57,10 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
         return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), false);
+    }
 }

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

@@ -19,28 +19,37 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 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.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import java.util.Collection;
+
+import static org.jetbrains.jet.lang.resolve.java.scope.ScopeUtils.computeAllPackageDeclarations;
+
 /**
  * @author abreslav
  */
 public abstract class JavaPackageScope extends JavaBaseScope {
 
+    @NotNull
+    private final PackagePsiDeclarationProvider declarationProvider;
     @NotNull
     private final FqName packageFQN;
 
     protected JavaPackageScope(
             @NotNull NamespaceDescriptor descriptor,
-            @NotNull PsiDeclarationProvider declarationProvider,
+            @NotNull PackagePsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
             @NotNull JavaSemanticServices semanticServices
     ) {
         super(descriptor, semanticServices, declarationProvider);
+        this.declarationProvider = declarationProvider;
         this.packageFQN = packageFQN;
     }
 
@@ -59,4 +68,14 @@ public abstract class JavaPackageScope extends JavaBaseScope {
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
         return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
+
+    @NotNull
+    @Override
+    protected Collection<DeclarationDescriptor> computeAllDescriptors() {
+        Collection<DeclarationDescriptor> result = super.computeAllDescriptors();
+        result.addAll(computeAllPackageDeclarations(declarationProvider.getPsiPackage(),
+                                                    semanticServices,
+                                                    DescriptorUtils.getFQName(descriptor).toSafe()));
+        return result;
+    }
 }

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

@@ -17,20 +17,22 @@
 package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Set;
 
 public final class JavaPackageScopeWithoutMembers extends JavaPackageScope {
     public JavaPackageScopeWithoutMembers(
             @NotNull NamespaceDescriptor descriptor,
-            @NotNull PsiDeclarationProvider declarationProvider,
+            @NotNull PackagePsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
             @NotNull JavaSemanticServices semanticServices
     ) {
@@ -42,4 +44,10 @@ public final class JavaPackageScopeWithoutMembers extends JavaPackageScope {
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
             return Collections.emptySet();
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return Collections.emptyList();
+    }
 }

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
@@ -24,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclaratio
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import java.util.Collection;
 import java.util.Set;
 
 public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
@@ -45,4 +47,10 @@ public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
         return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return getResolver().resolveInnerClasses(descriptor, declarationProvider.getPsiClass(), false);
+    }
 }