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

Compilation errors fixed
2012-11-05 13:41:00 +04:00
parent 5405b03f21
commit 791120a2be
13 changed files with 70 additions and 114 deletions
@@ -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);
@@ -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;
@@ -23,4 +23,7 @@ public interface ClassPsiDeclarationProvider extends PsiDeclarationProvider {

    @NotNull
    PsiClass getPsiClass();
+
+    //TODO: remove this method
+    boolean isStaticMembers();
 }
@@ -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;
    }
@@ -26,7 +26,4 @@ public interface PsiDeclarationProvider {

    @NotNull
    Origin getOrigin();
-
-    //TODO: remove this method
-    boolean isEmpty();
 }
@@ -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(
-            @NotNull PsiPackage psiPackage,
+    public static PsiDeclarationProvider createDeclarationProviderForPackage(
+            @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;
-    }
 }
@@ -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;
-    }
-}
@@ -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,
-                                                                            (ResolverScopeData) data);
+        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(classObjectDescriptor, semanticServices, data);
        WritableScopeImpl writableScope =
                new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -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);
    }

@@ -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!
-        ResolverScopeData resolverScopeData = (ResolverScopeData) scopeData;
-        if (resolverScopeData.isEmpty()) {
+        if (!(declarationProvider instanceof ClassPsiDeclarationProvider)) {
            return owner;
        }
-        PsiClass psiClass = resolverScopeData.getPsiClass();
+        PsiClass psiClass = ((ClassPsiDeclarationProvider) declarationProvider).getPsiClass();
        if (!psiClass.isEnum() || !isStatic) {
            return owner;
        }
@@ -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()) {
-            PsiClass psiClass = resolverScopeData.getPsiClass();
+        if (resolverScopeData instanceof ClassPsiDeclarationProvider) {
+            PsiClass psiClass = ((ClassPsiDeclarationProvider) resolverScopeData).getPsiClass();
            computeFieldAndFunctionDescriptors(result);
            computeInnerClasses(psiClass, result);
        }
-
-        PsiPackage psiPackage = resolverScopeData.getPsiPackage();
-        if (psiPackage != null) {
+        if (resolverScopeData instanceof PackagePsiDeclarationProvider) {
+            PsiPackage psiPackage = ((PackagePsiDeclarationProvider) resolverScopeData).getPsiPackage();
            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;
-    }
 }
@@ -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);
-
-        if (resolverScopeData.getPsiClass() == null) {
-            throw new IllegalArgumentException("must pass PsiClass here");
-        }
+        this.classPsiDeclarationProvider = resolverScopeData;
    }

    @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) {
@@ -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) {
-        super(descriptor, semanticServices, resolverNamespaceData);
+            @NotNull PsiDeclarationProvider declarationProvider) {
+        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();
+    }
 }