JavaPackageScope refactoring

* store PsiClass and PsiPackage inside
* do not create if there's no PsiClass or PsiPackage

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

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import javax.annotation.PostConstruct;
@@ -84,7 +85,10 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
 
     @Override
     public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        namespaceMemberScope.importScope(javaSemanticServices.getDescriptorResolver().createJavaPackageScope(DescriptorUtils.getFQName(namespaceDescriptor).toSafe(), namespaceDescriptor));
+        JetScope javaPackageScope = javaSemanticServices.getDescriptorResolver().createJavaPackageScope(DescriptorUtils.getFQName(namespaceDescriptor).toSafe(), namespaceDescriptor);
+        if (javaPackageScope != null) {
+            namespaceMemberScope.importScope(javaPackageScope);
+        }
         delegateConfiguration.extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope);
     }
 

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

@@ -841,8 +841,27 @@ public class JavaDescriptorResolver {
         return namespaceData;
     }
 
+    @Nullable
     public JavaPackageScope createJavaPackageScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor ns) {
-        return new JavaPackageScope(fqName, ns, semanticServices);
+        PsiPackage psiPackage = semanticServices.getPsiClassFinder().findPsiPackage(fqName);
+        PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
+        if (psiClass == null && psiPackage == null) {
+            return null;
+        }
+        return new JavaPackageScope(fqName, ns, semanticServices, psiPackage, psiClass);
+    }
+
+    private PsiClass getPsiClassForJavaPackageScope(@NotNull FqName packageFQN) {
+        // TODO: move this check outside
+        // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and
+        // Kotlin functions are already there
+        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
+        if (kotlinNamespaceDescriptor != null) {
+            return null;
+        } else {
+            // TODO: what is GlobalSearchScope
+            return semanticServices.getPsiClassFinder().findPsiClass(JavaPackageScope.getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS));
+        }
     }
 
     @NotNull

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

@@ -22,6 +22,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
@@ -38,27 +39,23 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @NotNull
     private final FqName packageFQN;
+    @Nullable
+    private final PsiPackage psiPackage;
 
     private Collection<DeclarationDescriptor> allDescriptors;
 
     public JavaPackageScope(
             @NotNull FqName packageFQN,
             @NotNull NamespaceDescriptor containingDescriptor,
-            @NotNull JavaSemanticServices semanticServices) {
-        super(containingDescriptor, semanticServices, getPiClass(packageFQN, semanticServices));
+            @NotNull JavaSemanticServices semanticServices,
+            @Nullable PsiPackage psiPackage,
+            @Nullable PsiClass psiClass) {
+        super(containingDescriptor, semanticServices, psiClass);
         this.packageFQN = packageFQN;
-    }
+        this.psiPackage = psiPackage;
 
-    private static PsiClass getPiClass(FqName packageFQN, JavaSemanticServices semanticServices) {
-        // TODO: move this check outside
-        // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and
-        // Kotlin functions are already there
-        NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN);
-        if (kotlinNamespaceDescriptor != null) {
-            return null;
-        } else {
-            // TODO: what is GlobalSearchScope
-            return semanticServices.getPsiClassFinder().findPsiClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS));
+        if (psiClass == null && psiPackage == null) {
+            throw new IllegalStateException("both class and package cannot be null for " + packageFQN);
         }
     }
 
@@ -105,20 +102,18 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                 allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers()));
             }
 
-            final PsiPackage javaPackage = semanticServices.getPsiClassFinder().findPsiPackage(packageFQN);
-
-            if (javaPackage != null) {
-                boolean isKotlinNamespace = semanticServices.getKotlinNamespaceDescriptor(new FqName(javaPackage.getQualifiedName())) != null;
+            if (psiPackage != null) {
+                boolean isKotlinNamespace = semanticServices.getKotlinNamespaceDescriptor(packageFQN) != null;
                 final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver();
 
-                for (PsiPackage psiSubPackage : javaPackage.getSubPackages()) {
+                for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
                     NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                     if (childNs != null) {
                         allDescriptors.add(childNs);
                     }
                 }
 
-                for (PsiClass psiClass : javaPackage.getClasses()) {
+                for (PsiClass psiClass : psiPackage.getClasses()) {
                     if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) {
                         continue;
                     }
@@ -147,7 +142,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
     }
 
     @NotNull
-    private static FqName getQualifiedName(@NotNull FqName packageFQN, @NotNull String name) {
+    static FqName getQualifiedName(@NotNull FqName packageFQN, @NotNull String name) {
         return packageFQN.child(name);
     }
 }