Introduce JavaScopeForKotlinNamespace, JavaPackageScopeWithoutMembers, JavaClassStaticMembersScope, much clearer and more explicit logic in JavaNamespaceResolver#createNamespaceScope()

These classes explicitly represent 3 types of scopes that are created for NamespaceDescriptor in JDR

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

@@ -29,38 +29,17 @@ public final class PsiDeclarationProviderFactory {
     }
 
     @NotNull
-    public static ClassPsiDeclarationProvider createSyntheticClassObjectClassData(
+    public static ClassPsiDeclarationProvider createSyntheticClassObjectClassData(@NotNull PsiClass psiClass) {
-            @NotNull PsiClass psiClass
-    ) {
         return createDeclarationProviderForClassStaticMembers(psiClass);
     }
 
     @NotNull
-    public static ClassPsiDeclarationProvider createBinaryClassData(
+    public static ClassPsiDeclarationProvider createBinaryClassData(@NotNull PsiClass psiClass) {
-            @NotNull PsiClass psiClass
-    ) {
         return new ClassPsiDeclarationProviderImpl(psiClass, false);
     }
 
     @NotNull
-    public static PsiDeclarationProvider createDeclarationProviderForPackage(
+    public static KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
-            @Nullable PsiPackage psiPackage,
-            @Nullable PsiClass psiClass,
-            //TODO: remove this parameter
-            @Nullable FqName fqName
-    ) {
-        if (psiClass == null) {
-            assert psiPackage != null;
-            return createDeclarationProviderForNamespaceWithoutMembers(psiPackage);
-        }
-        if (psiPackage == null) {
-            return createDeclarationProviderForClassStaticMembers(psiClass);
-        }
-        return createDeclarationForKotlinNamespace(psiPackage, psiClass, fqName);
-    }
-
-    @NotNull
-    private static KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
             @NotNull PsiPackage psiPackage,
             @NotNull PsiClass psiClass,
             @Nullable FqName fqName
@@ -73,12 +52,12 @@ public final class PsiDeclarationProviderFactory {
     }
 
     @NotNull
-    /*package private*/ static PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
+    public static PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
         return new PackagePsiDeclarationProviderImpl(psiPackage);
     }
 
     @NotNull
-    private static ClassPsiDeclarationProvider createDeclarationProviderForClassStaticMembers(@NotNull PsiClass psiClass) {
+    public static ClassPsiDeclarationProvider createDeclarationProviderForClassStaticMembers(@NotNull PsiClass psiClass) {
         return new ClassPsiDeclarationProviderImpl(psiClass, true);
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java

@@ -173,7 +173,7 @@ public final class JavaClassObjectResolver {
         classObjectDescriptor.setVisibility(containing.getVisibility());
         classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObjectDescriptor.createTypeConstructor();
-        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(classObjectDescriptor, semanticServices, data);
+        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(classObjectDescriptor, data, semanticServices);
         WritableScopeImpl writableScope =
                 new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -241,7 +241,7 @@ public final class JavaClassResolver {
         classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass, jetClassAnnotation));
         classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
         classDescriptor.createTypeConstructor();
-        classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classDescriptor, semanticServices, classData));
+        classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classDescriptor, classData, semanticServices));
 
         String context = "class " + psiClass.getQualifiedName();
         signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor, context);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -31,9 +31,10 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers;
+import org.jetbrains.jet.lang.resolve.java.scope.JavaScopeForKotlinNamespace;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -42,6 +43,8 @@ import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
+import static org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory.*;
+
 public final class JavaNamespaceResolver {
 
     @NotNull
@@ -132,39 +135,37 @@ public final class JavaNamespaceResolver {
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
-        PsiDeclarationProvider namespaceData = createDeclarationProvider(fqName, namespaceDescriptor);
+        JavaPackageScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor);
-        JavaPackageScope javaPackageScope;
+        cache(fqName, namespaceScope);
-        if (namespaceData == null) {
+        return namespaceScope;
-            javaPackageScope = null;
-        }
-        else {
-            //TODO:
-            javaPackageScope = new JavaPackageScope(namespaceDescriptor, fqName, javaSemanticServices, namespaceData);
-        }
-
-        cache(fqName, javaPackageScope);
-
-        return javaPackageScope;
     }
 
     @Nullable
-    private PsiDeclarationProvider createDeclarationProvider(
+    private JavaPackageScope doCreateNamespaceScope(
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
-        PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
         PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName);
-        if (psiClass != null || psiPackage != null) {
+        if (psiPackage != null) {
+            PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
             trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.PROPER);
-            return PsiDeclarationProviderFactory.createDeclarationProviderForPackage(psiPackage, psiClass, fqName);
+            if (psiClass == null) {
+                return new JavaPackageScopeWithoutMembers(namespaceDescriptor,
+                                                          createDeclarationProviderForNamespaceWithoutMembers(psiPackage),
+                                                          fqName, javaSemanticServices);
+            }
+            return new JavaScopeForKotlinNamespace(namespaceDescriptor,
+                                                   createDeclarationForKotlinNamespace(psiPackage, psiClass, fqName),
+                                                   fqName, javaSemanticServices);
         }
 
-        psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
+        PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
         if (psiClass != null && !psiClass.isEnum()) {
             trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.CLASS_STATICS);
-            return PsiDeclarationProviderFactory.createDeclarationProviderForPackage(psiPackage, psiClass, fqName);
+            return new JavaClassStaticMembersScope(namespaceDescriptor,
+                                                   createDeclarationProviderForClassStaticMembers(psiClass),
+                                                   fqName, javaSemanticServices);
         }
-
         return null;
     }
 

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

@@ -47,10 +47,11 @@ public class JavaClassMembersScope extends JavaBaseScope {
 
     public JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
-            @NotNull JavaSemanticServices semanticServices,
+            @NotNull ClassPsiDeclarationProvider declarationProvider,
-            @NotNull ClassPsiDeclarationProvider resolverScopeData) {
+            @NotNull JavaSemanticServices semanticServices
-        super(descriptor, semanticServices, resolverScopeData);
+    ) {
-        this.classPsiDeclarationProvider = resolverScopeData;
+        super(descriptor, semanticServices, declarationProvider);
+        this.classPsiDeclarationProvider = declarationProvider;
     }
 
     @NotNull

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.scope;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+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;
+
+public final class JavaClassStaticMembersScope extends JavaPackageScope {
+    public JavaClassStaticMembersScope(
+            @NotNull NamespaceDescriptor descriptor,
+            @NotNull ClassPsiDeclarationProvider declarationProvider,
+            @NotNull FqName packageFQN,
+            @NotNull JavaSemanticServices semanticServices
+    ) {
+        super(descriptor, declarationProvider, packageFQN, semanticServices);
+    }
+}

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

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
@@ -33,18 +32,19 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 /**
  * @author abreslav
  */
-public class JavaPackageScope extends JavaBaseScope {
+public abstract class JavaPackageScope extends JavaBaseScope {
 
     @NotNull
     private final FqName packageFQN;
     @NotNull
     private final PsiDeclarationProvider declarationProvider;
 
-    public JavaPackageScope(
+    protected JavaPackageScope(
-            @NotNull ClassOrNamespaceDescriptor descriptor,
+            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices,
+            @NotNull JavaSemanticServices semanticServices
-            @NotNull PsiDeclarationProvider declarationProvider) {
+    ) {
         super(descriptor, semanticServices, declarationProvider);
         this.declarationProvider = declarationProvider;
         this.packageFQN = packageFQN;

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.scope;
+
+import org.jetbrains.annotations.NotNull;
+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.name.FqName;
+
+public final class JavaPackageScopeWithoutMembers extends JavaPackageScope {
+    public JavaPackageScopeWithoutMembers(
+            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PsiDeclarationProvider declarationProvider,
+            @NotNull FqName packageFQN,
+            @NotNull JavaSemanticServices semanticServices
+    ) {
+        super(descriptor, declarationProvider, packageFQN, semanticServices);
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java.scope;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.provider.KotlinNamespacePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+public final class JavaScopeForKotlinNamespace extends JavaPackageScope {
+    public JavaScopeForKotlinNamespace(
+            @NotNull NamespaceDescriptor descriptor,
+            @NotNull KotlinNamespacePsiDeclarationProvider declarationProvider,
+            @NotNull FqName packageFQN,
+            @NotNull JavaSemanticServices semanticServices
+    ) {
+        super(descriptor, declarationProvider, packageFQN, semanticServices);
+    }
+}