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
2012-11-08 19:13:55 +04:00
parent ff45322d1a
commit da47c31a86
9 changed files with 143 additions and 60 deletions
@@ -29,38 +29,17 @@ public final class PsiDeclarationProviderFactory {
    }

    @NotNull
-    public static ClassPsiDeclarationProvider createSyntheticClassObjectClassData(
-            @NotNull PsiClass psiClass
-    ) {
+    public static ClassPsiDeclarationProvider createSyntheticClassObjectClassData(@NotNull PsiClass psiClass) {
        return createDeclarationProviderForClassStaticMembers(psiClass);
    }

    @NotNull
-    public static ClassPsiDeclarationProvider createBinaryClassData(
-            @NotNull PsiClass psiClass
-    ) {
+    public static ClassPsiDeclarationProvider createBinaryClassData(@NotNull PsiClass psiClass) {
        return new ClassPsiDeclarationProviderImpl(psiClass, false);
    }

    @NotNull
-    public static PsiDeclarationProvider createDeclarationProviderForPackage(
-            @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(
+    public 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);
    }
 }
@@ -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);
@@ -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);
@@ -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.provider.PsiDeclarationProviderFactory;
+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;
 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 javaPackageScope;
-        if (namespaceData == null) {
-            javaPackageScope = null;
-        }
-        else {
-            //TODO:
-            javaPackageScope = new JavaPackageScope(namespaceDescriptor, fqName, javaSemanticServices, namespaceData);
-        }
-
-        cache(fqName, javaPackageScope);
-
-        return javaPackageScope;
+        JavaPackageScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor);
+        cache(fqName, namespaceScope);
+        return namespaceScope;
    }

    @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;
    }

@@ -47,10 +47,11 @@ public class JavaClassMembersScope extends JavaBaseScope {

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

    @NotNull
@@ -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);
+    }
+}
@@ -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(
-            @NotNull ClassOrNamespaceDescriptor descriptor,
+    protected JavaPackageScope(
+            @NotNull NamespaceDescriptor descriptor,
+            @NotNull PsiDeclarationProvider declarationProvider,
            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices,
-            @NotNull PsiDeclarationProvider declarationProvider) {
+            @NotNull JavaSemanticServices semanticServices
+    ) {
        super(descriptor, semanticServices, declarationProvider);
        this.declarationProvider = declarationProvider;
        this.packageFQN = packageFQN;
@@ -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);
+    }
+}
@@ -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);
+    }
+}