Make JavaClassStaticMembersScope extend JavaClassMembersScope instead of JavaPackageScope, use JavaBaseScope instead of JavaPackageScope in JavaNamespaceResolver

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

@@ -36,11 +36,11 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -124,7 +124,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                     namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope());
                 }
                 if (psiClassFinder.findPsiPackage(fqName) != null) {
-                    JavaPackageScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
+                    JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
                     assert javaPackageScope != null;
                     namespaceMemberScope.importScope(javaPackageScope);
                 }

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

@@ -25,9 +25,9 @@ import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmByte
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 import org.jetbrains.jet.lang.types.JetType;
 
@@ -125,7 +125,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @Nullable
-    public JavaPackageScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) {
+    public JetScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) {
         return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(namespaceDescriptor);
     }
 

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

@@ -31,8 +31,8 @@ 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.scope.JavaBaseScope;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope;
-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;
@@ -50,7 +50,7 @@ public final class JavaNamespaceResolver {
     @NotNull
     public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptor(JavaDescriptorResolver.JAVA_ROOT);
     @NotNull
-    private final Map<FqName, JavaPackageScope> resolvedNamespaceCache = Maps.newHashMap();
+    private final Map<FqName, JavaBaseScope> resolvedNamespaceCache = Maps.newHashMap();
     @NotNull
     private final Set<FqName> unresolvedCache = Sets.newHashSet();
 
@@ -87,7 +87,7 @@ public final class JavaNamespaceResolver {
         if (unresolvedCache.contains(qualifiedName)) {
             return null;
         }
-        JavaPackageScope scope = resolvedNamespaceCache.get(qualifiedName);
+        JavaBaseScope scope = resolvedNamespaceCache.get(qualifiedName);
         if (scope != null) {
             return (NamespaceDescriptor) scope.getContainingDeclaration();
         }
@@ -103,7 +103,7 @@ public final class JavaNamespaceResolver {
                 qualifiedName
         );
 
-        JavaPackageScope newScope = createNamespaceScope(qualifiedName, javaNamespaceDescriptor);
+        JavaBaseScope newScope = createNamespaceScope(qualifiedName, javaNamespaceDescriptor);
         if (newScope == null) {
             return null;
         }
@@ -131,17 +131,17 @@ public final class JavaNamespaceResolver {
     }
 
     @Nullable
-    private JavaPackageScope createNamespaceScope(
+    private JavaBaseScope createNamespaceScope(
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
-        JavaPackageScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor);
+        JavaBaseScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor);
         cache(fqName, namespaceScope);
         return namespaceScope;
     }
 
     @Nullable
-    private JavaPackageScope doCreateNamespaceScope(
+    private JavaBaseScope doCreateNamespaceScope(
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
@@ -169,26 +169,26 @@ public final class JavaNamespaceResolver {
         return null;
     }
 
-    private void cache(@NotNull FqName fqName, @Nullable JavaPackageScope packageScope) {
+    private void cache(@NotNull FqName fqName, @Nullable JavaBaseScope packageScope) {
         if (packageScope == null) {
             unresolvedCache.add(fqName);
             return;
         }
-        JavaPackageScope oldValue = resolvedNamespaceCache.put(fqName, packageScope);
+        JavaBaseScope oldValue = resolvedNamespaceCache.put(fqName, packageScope);
         if (oldValue != null) {
             throw new IllegalStateException("rewrite at " + fqName);
         }
     }
 
     @Nullable
-    public JavaPackageScope getJavaPackageScopeForExistingNamespaceDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor) {
+    public JavaBaseScope getJavaPackageScopeForExistingNamespaceDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor) {
         FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe();
         if (unresolvedCache.contains(fqName)) {
             throw new IllegalStateException(
                     "This means that we are trying to create a Java package, but have a package with the same FQN defined in Kotlin: " +
                     fqName);
         }
-        JavaPackageScope alreadyResolvedScope = resolvedNamespaceCache.get(fqName);
+        JavaBaseScope alreadyResolvedScope = resolvedNamespaceCache.get(fqName);
         if (alreadyResolvedScope != null) {
             return alreadyResolvedScope;
         }

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

@@ -16,27 +16,21 @@
 
 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.*;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 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.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
-import java.util.Map;
 import java.util.Set;
 
 public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
-    private final Map<Name, ClassifierDescriptor> classifiers = Maps.newHashMap();
+    protected final ClassPsiDeclarationProvider declarationProvider;
-    @NotNull
-    private final ClassPsiDeclarationProvider classPsiDeclarationProvider;
 
     protected JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
@@ -44,7 +38,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
             @NotNull JavaSemanticServices semanticServices
     ) {
         super(descriptor, semanticServices, declarationProvider);
-        this.classPsiDeclarationProvider = declarationProvider;
+        this.declarationProvider = declarationProvider;
     }
 
     @NotNull
@@ -53,34 +47,10 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
         throw new UnsupportedOperationException(); // TODO
     }
 
-    @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 : classPsiDeclarationProvider.getPsiClass().getAllInnerClasses()) {
-            if (name.getName().equals(innerClass.getName())) {
-                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != classPsiDeclarationProvider.isStaticMembers()) return null;
-                ClassDescriptor classDescriptor = getResolver()
-                        .resolveClass(new FqName(innerClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-                if (classDescriptor != null) {
-                    return classDescriptor;
-                }
-            }
-        }
-        return null;
-    }
 
     @NotNull
     @Override
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, classPsiDeclarationProvider, descriptor);
+        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
     }
 }

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

@@ -16,12 +16,25 @@
 
 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.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.Map;
 
 public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope {
+
+    @NotNull
+    private final Map<Name, ClassifierDescriptor> classifiers = Maps.newHashMap();
+
     public JavaClassNonStaticMembersScope(
             @NotNull ClassDescriptor descriptor,
             @NotNull ClassPsiDeclarationProvider psiDeclarationProvider,
@@ -29,4 +42,30 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
     ) {
         super(descriptor, psiDeclarationProvider, semanticServices);
     }
+
+    @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;
+                ClassDescriptor classDescriptor = getResolver()
+                        .resolveClass(new FqName(innerClass.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                if (classDescriptor != null) {
+                    return classDescriptor;
+                }
+            }
+        }
+        return null;
+    }
+
 }

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

@@ -17,18 +17,18 @@
 package org.jetbrains.jet.lang.resolve.java.scope;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+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.Set;
+public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
-
-public final class JavaClassStaticMembersScope extends JavaPackageScope {
     @NotNull
-    private final ClassPsiDeclarationProvider declarationProvider;
+    private final FqName packageFQN;
 
     public JavaClassStaticMembersScope(
             @NotNull NamespaceDescriptor descriptor,
@@ -36,13 +36,23 @@ public final class JavaClassStaticMembersScope extends JavaPackageScope {
             @NotNull FqName packageFQN,
             @NotNull JavaSemanticServices semanticServices
     ) {
-        super(descriptor, declarationProvider, packageFQN, semanticServices);
+        super(descriptor, declarationProvider, semanticServices);
-        this.declarationProvider = declarationProvider;
+        this.packageFQN = packageFQN;
     }
 
-    @NotNull
     @Override
-    protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
+    public ClassifierDescriptor getClassifier(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
+        return getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+    }
+
+    @Override
+    public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
+        //TODO: check that class is an object
+        return getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+    }
+
+    @Override
+    public NamespaceDescriptor getNamespace(@NotNull Name name) {
+        return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -36,9 +36,9 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
-import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -114,7 +114,7 @@ public class LazyResolveTestUtil {
                     namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope());
                 }
                 if (psiClassFinder.findPsiPackage(fqName) != null) {
-                    JavaPackageScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
+                    JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
                     assert javaPackageScope != null;
                     namespaceMemberScope.importScope(javaPackageScope);
                 }