Refactor: remove ResolverScopeData class, hack JavaBaseScope to use ClassPsiDeclarationProvider and PackagePsiDeclarationProvider interfaces

Compilation errors fixed

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

@@ -22,7 +22,7 @@ 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.data.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
@@ -132,7 +132,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name name,
-            @NotNull ResolverScopeData data,
+            @NotNull PsiDeclarationProvider data,
             @NotNull ClassOrNamespaceDescriptor ownerDescriptor
     ) {
         return propertiesResolver.resolveFieldGroupByName(name, data, ownerDescriptor);
@@ -166,7 +166,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     @NotNull
     public Set<FunctionDescriptor> resolveFunctionGroup(
             @NotNull Name methodName,
-            @NotNull ResolverScopeData scopeData,
+            @NotNull ClassPsiDeclarationProvider scopeData,
             @NotNull ClassOrNamespaceDescriptor ownerDescriptor
     ) {
         return functionResolver.resolveFunctionGroup(methodName, scopeData, ownerDescriptor);

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

@@ -64,6 +64,7 @@ public final class MembersCache {
         if (psiClass != null) {
             membersCache.new ClassMemberProcessor(new PsiClassWrapper(psiClass), staticMembers, isKotlin).process();
         }
+        //TODO:
         PsiClass[] classes = psiPackage != null ? psiPackage.getClasses() : psiClass.getInnerClasses();
         membersCache.new ObjectClassProcessor(classes).process();
         return membersCache;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ClassPsiDeclarationProvider.java

@@ -23,4 +23,7 @@ public interface ClassPsiDeclarationProvider extends PsiDeclarationProvider {
 
     @NotNull
     PsiClass getPsiClass();
+
+    //TODO: remove this method
+    boolean isStaticMembers();
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ClassPsiDeclarationProviderBase.java

@@ -38,11 +38,6 @@ public abstract class ClassPsiDeclarationProviderBase extends PsiDeclarationProv
         return psiClass;
     }
 
-    @Override
-    public boolean isEmpty() {
-        return false;
-    }
-
     @Override
     @NotNull
     public Origin getOrigin() {
@@ -54,6 +49,7 @@ public abstract class ClassPsiDeclarationProviderBase extends PsiDeclarationProv
         return ((psiClass != null) && DescriptorResolverUtils.isKotlinClass(psiClass)) ? KOTLIN : JAVA;
     }
 
+    @Override
     public boolean isStaticMembers() {
         return staticMembers;
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/PsiDeclarationProvider.java

@@ -26,7 +26,4 @@ public interface PsiDeclarationProvider {
 
     @NotNull
     Origin getOrigin();
-
-    //TODO: remove this method
-    boolean isEmpty();
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverNamespaceData.java

@@ -30,15 +30,20 @@ import static org.jetbrains.jet.lang.resolve.java.data.Origin.JAVA;
 public class ResolverNamespaceData extends PsiDeclarationProviderBase implements PackagePsiDeclarationProvider {
 
     @NotNull
-    public static PackagePsiDeclarationProvider createDeclarationProviderForPackage(
+    public static PsiDeclarationProvider createDeclarationProviderForPackage(
-            @NotNull PsiPackage psiPackage,
+            @Nullable PsiPackage psiPackage,
             @Nullable PsiClass psiClass,
             //TODO:
             @Nullable FqName fqName
     ) {
         if (psiClass == null) {
+
+            assert psiPackage != null;
             return new ResolverNamespaceData(psiPackage);
         }
+        if (psiPackage == null) {
+            return new ResolverClassData(psiClass, true);
+        }
         KotlinNamespacePsiDeclarationProvider result = new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass);
         if (fqName != null && fqName.lastSegmentIs(Name.identifier(JvmAbi.PACKAGE_CLASS))) {
             throw new IllegalStateException("Kotlin namespace cannot have last segment " + JvmAbi.PACKAGE_CLASS + ": " + fqName);
@@ -72,9 +77,4 @@ public class ResolverNamespaceData extends PsiDeclarationProviderBase implements
     public Origin getOrigin() {
         return JAVA;
     }
-
-    @Override
-    public boolean isEmpty() {
-        return false;
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/data/ResolverScopeData.java

@@ -1,53 +0,0 @@
-/*
- * 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.data;
-
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-
-public abstract class ResolverScopeData extends ClassPsiDeclarationProviderBase {
-
-    @Nullable
-    private final PsiPackage psiPackage;
-
-    public ResolverScopeData(
-            @Nullable PsiClass psiClass,
-            @Nullable PsiPackage psiPackage,
-            @Nullable FqName fqName,
-            boolean staticMembers
-    ) {
-        super(staticMembers, psiClass);
-        DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass);
-
-        this.psiPackage = psiPackage;
-
-        if (psiClass == null && psiPackage == null) {
-            throw new IllegalStateException("both psiClass and psiPackage cannot be null");
-        }
-
-        //TODO: move check to remove fqName parameter
-    }
-
-    @NotNull
-    public PsiPackage getPsiPackage() {
-        return psiPackage;
-    }
-}

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

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.data.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassMembersScope;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
@@ -175,8 +174,7 @@ public final class JavaClassObjectResolver {
         classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObjectDescriptor.createTypeConstructor();
         //TODO:
-        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(classObjectDescriptor, semanticServices,
+        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(classObjectDescriptor, semanticServices, data);
-                                                                            (ResolverScopeData) data);
         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/JavaNamespaceResolver.java

@@ -30,9 +30,8 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 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.data.PackagePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.data.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverNamespaceData;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -106,7 +105,7 @@ public final class JavaNamespaceResolver {
             return null;
         }
 
-        trace.record(BindingContext.NAMESPACE, newScope.getResolverScopeData().getPsiPackage(), javaNamespaceDescriptor);
+        trace.record(BindingContext.NAMESPACE, newScope.getPsiElement(), javaNamespaceDescriptor);
 
         javaNamespaceDescriptor.setMemberScope(newScope);
 
@@ -133,14 +132,14 @@ public final class JavaNamespaceResolver {
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
-        PackagePsiDeclarationProvider namespaceData = createNamespaceData(fqName, namespaceDescriptor);
+        PsiDeclarationProvider namespaceData = createNamespaceData(fqName, namespaceDescriptor);
         JavaPackageScope javaPackageScope;
         if (namespaceData == null) {
             javaPackageScope = null;
         }
         else {
             //TODO:
-            javaPackageScope = new JavaPackageScope(namespaceDescriptor, fqName, javaSemanticServices, (ResolverScopeData) namespaceData);
+            javaPackageScope = new JavaPackageScope(namespaceDescriptor, fqName, javaSemanticServices, namespaceData);
         }
 
         cache(fqName, javaPackageScope);
@@ -149,7 +148,7 @@ public final class JavaNamespaceResolver {
     }
 
     @Nullable
-    private PackagePsiDeclarationProvider createNamespaceData(
+    private PsiDeclarationProvider createNamespaceData(
             @NotNull FqName fqName,
             @NotNull NamespaceDescriptor namespaceDescriptor
     ) {
@@ -172,8 +171,6 @@ public final class JavaNamespaceResolver {
             }
             return null;
         }
-
-        assert psiPackage != null;
         return ResolverNamespaceData.createDeclarationProviderForPackage(psiPackage, psiClass, fqName);
     }
 

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

@@ -27,8 +27,8 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.data.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.data.PsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeFieldSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
 import org.jetbrains.jet.lang.resolve.java.kt.JetMethodAnnotation;
@@ -444,15 +444,13 @@ public final class JavaPropertyResolver {
     @NotNull
     private ClassOrNamespaceDescriptor getRealOwner(
             @NotNull ClassOrNamespaceDescriptor owner,
-            @NotNull PsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider declarationProvider,
             boolean isStatic
     ) {
-        //TODO: hack!
+        if (!(declarationProvider instanceof ClassPsiDeclarationProvider)) {
-        ResolverScopeData resolverScopeData = (ResolverScopeData) scopeData;
-        if (resolverScopeData.isEmpty()) {
             return owner;
         }
-        PsiClass psiClass = resolverScopeData.getPsiClass();
+        PsiClass psiClass = ((ClassPsiDeclarationProvider) declarationProvider).getPsiClass();
         if (!psiClass.isEnum() || !isStatic) {
             return owner;
         }

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

@@ -27,7 +27,10 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.NamedMembers;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ClassPsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.data.ClassPsiDeclarationProviderBase;
+import org.jetbrains.jet.lang.resolve.java.data.PackagePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.data.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
@@ -45,7 +48,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     protected final JavaSemanticServices semanticServices;
 
     @NotNull
-    protected final ResolverScopeData resolverScopeData;
+    protected final PsiDeclarationProvider resolverScopeData;
 
     @NotNull
     private final Map<Name, Set<FunctionDescriptor>> functionDescriptors = Maps.newHashMap();
@@ -60,7 +63,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     protected JavaBaseScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull JavaSemanticServices semanticServices,
-            @NotNull ResolverScopeData resolverScopeData
+            @NotNull PsiDeclarationProvider resolverScopeData
     ) {
         this.semanticServices = semanticServices;
         this.resolverScopeData = resolverScopeData;
@@ -110,7 +113,11 @@ public abstract class JavaBaseScope extends JetScopeImpl {
 
     @NotNull
     private Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return semanticServices.getDescriptorResolver().resolveFunctionGroup(name, resolverScopeData, descriptor);
+        if (!(resolverScopeData instanceof ClassPsiDeclarationProvider)) {
+            return Collections.emptySet();
+        }
+        return semanticServices.getDescriptorResolver()
+                .resolveFunctionGroup(name, (ClassPsiDeclarationProvider) resolverScopeData, descriptor);
     }
 
     @NotNull
@@ -132,14 +139,13 @@ public abstract class JavaBaseScope extends JetScopeImpl {
     @NotNull
     private Collection<DeclarationDescriptor> computeAllDescriptors() {
         Collection<DeclarationDescriptor> result = Sets.newHashSet();
-        if (!resolverScopeData.isEmpty()) {
+        if (resolverScopeData instanceof ClassPsiDeclarationProvider) {
-            PsiClass psiClass = resolverScopeData.getPsiClass();
+            PsiClass psiClass = ((ClassPsiDeclarationProvider) resolverScopeData).getPsiClass();
             computeFieldAndFunctionDescriptors(result);
             computeInnerClasses(psiClass, result);
         }
-
+        if (resolverScopeData instanceof PackagePsiDeclarationProvider) {
-        PsiPackage psiPackage = resolverScopeData.getPsiPackage();
+            PsiPackage psiPackage = ((PackagePsiDeclarationProvider) resolverScopeData).getPsiPackage();
-        if (psiPackage != null) {
             assert descriptor instanceof NamespaceDescriptor;
             result.addAll(computeAllPackageDeclarations(psiPackage, semanticServices, DescriptorUtils.getFQName(descriptor).toSafe()));
         }
@@ -166,12 +172,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
         }
         else {
             result.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(
-                    descriptor, psiClass, resolverScopeData.isStaticMembers()));
+                    descriptor, psiClass, ((ClassPsiDeclarationProviderBase) resolverScopeData).isStaticMembers()));
         }
     }
-
-    @NotNull
-    public ResolverScopeData getResolverScopeData() {
-        return resolverScopeData;
-    }
 }

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

@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.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;
@@ -40,17 +40,17 @@ import java.util.Map;
  * @author abreslav
  */
 public class JavaClassMembersScope extends JavaBaseScope {
+    @NotNull
     private final Map<Name, ClassifierDescriptor> classifiers = Maps.newHashMap();
+    @NotNull
+    private final ClassPsiDeclarationProvider classPsiDeclarationProvider;
 
     public JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull JavaSemanticServices semanticServices,
-            @NotNull ResolverScopeData resolverScopeData) {
+            @NotNull ClassPsiDeclarationProvider resolverScopeData) {
         super(descriptor, semanticServices, resolverScopeData);
-
+        this.classPsiDeclarationProvider = resolverScopeData;
-        if (resolverScopeData.getPsiClass() == null) {
-            throw new IllegalArgumentException("must pass PsiClass here");
-        }
     }
 
     @NotNull
@@ -71,9 +71,9 @@ public class JavaClassMembersScope extends JavaBaseScope {
 
     private ClassifierDescriptor doGetClassifierDescriptor(Name name) {
         // TODO : suboptimal, walk the list only once
-        for (PsiClass innerClass : resolverScopeData.getPsiClass().getAllInnerClasses()) {
+        for (PsiClass innerClass : classPsiDeclarationProvider.getPsiClass().getAllInnerClasses()) {
             if (name.getName().equals(innerClass.getName())) {
-                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != resolverScopeData.isStaticMembers()) return null;
+                if (innerClass.hasModifierProperty(PsiModifier.STATIC) != classPsiDeclarationProvider.isStaticMembers()) 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/scope/JavaPackageScope.java

@@ -16,6 +16,7 @@
 
 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;
@@ -23,7 +24,9 @@ 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.data.ResolverScopeData;
+import org.jetbrains.jet.lang.resolve.java.data.ClassPsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.data.PackagePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.data.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -34,13 +37,16 @@ public class JavaPackageScope extends JavaBaseScope {
 
     @NotNull
     private final FqName packageFQN;
+    @NotNull
+    private final PsiDeclarationProvider declarationProvider;
 
     public JavaPackageScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull FqName packageFQN,
             @NotNull JavaSemanticServices semanticServices,
-            @NotNull ResolverScopeData resolverNamespaceData) {
+            @NotNull PsiDeclarationProvider declarationProvider) {
-        super(descriptor, semanticServices, resolverNamespaceData);
+        super(descriptor, semanticServices, declarationProvider);
+        this.declarationProvider = declarationProvider;
         this.packageFQN = packageFQN;
     }
 
@@ -58,4 +64,16 @@ public class JavaPackageScope extends JavaBaseScope {
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
         return semanticServices.getDescriptorResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
+
+    //TODO: remove this method
+    @NotNull
+    public PsiElement getPsiElement() {
+        if (declarationProvider instanceof ClassPsiDeclarationProvider) {
+            return ((ClassPsiDeclarationProvider) declarationProvider).getPsiClass();
+        }
+        if (declarationProvider instanceof PackagePsiDeclarationProvider) {
+            return ((PackagePsiDeclarationProvider) declarationProvider).getPsiPackage();
+        }
+        throw new IllegalStateException();
+    }
 }