Delete JavaSemanticServices

Almost in all places only JavaDescriptorResolver was needed. The only exception is JavaPackageScope which needs PsiClassFinder, that is now passed as a constructor argument. Also merge JavaPackageScopeWithoutMembers into its superclass JavaPackageScope
2013-07-24 19:28:27 +04:00
parent a0cbe80aca
commit d708dc6ed4
12 changed files with 81 additions and 181 deletions
@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
@@ -55,7 +54,6 @@ public class InjectorForJavaDescriptorResolver {
    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
    private final JavaNamespaceResolver javaNamespaceResolver;
-    private final JavaSemanticServices javaSemanticServices;
    private final JavaSupertypeResolver javaSupertypeResolver;
    private final JavaConstructorResolver javaConstructorResolver;
    private final JavaInnerClassResolver javaInnerClassResolver;
@@ -79,7 +77,6 @@ public class InjectorForJavaDescriptorResolver {
        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
        this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaSemanticServices = new JavaSemanticServices();
        this.javaSupertypeResolver = new JavaSupertypeResolver();
        this.javaConstructorResolver = new JavaConstructorResolver();
        this.javaInnerClassResolver = new JavaInnerClassResolver();
@@ -96,10 +93,10 @@ public class InjectorForJavaDescriptorResolver {

        javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
        javaClassResolver.setFunctionResolver(javaFunctionResolver);
+        javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
        javaClassResolver.setSignatureResolver(javaSignatureResolver);
        javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
        javaClassResolver.setTrace(bindingTrace);
@@ -130,13 +127,10 @@ public class InjectorForJavaDescriptorResolver {
        annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder);

        javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
+        javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
        javaNamespaceResolver.setTrace(bindingTrace);

-        javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        javaSemanticServices.setPsiClassFinder(psiClassFinder);
-
        javaSupertypeResolver.setClassResolver(javaClassResolver);
        javaSupertypeResolver.setTrace(bindingTrace);
        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
@@ -47,7 +47,6 @@ import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
@@ -99,7 +98,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
    private final OverrideResolver overrideResolver;
    private final TypeHierarchyResolver typeHierarchyResolver;
    private final ScriptBodyResolver scriptBodyResolver;
-    private final JavaSemanticServices javaSemanticServices;
    private final JavaClassResolver javaClassResolver;
    private final JavaAnnotationResolver javaAnnotationResolver;
    private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
@@ -152,7 +150,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
        this.overrideResolver = new OverrideResolver();
        this.typeHierarchyResolver = new TypeHierarchyResolver();
        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.javaSemanticServices = new JavaSemanticServices();
        this.javaClassResolver = new JavaClassResolver();
        this.javaAnnotationResolver = new JavaAnnotationResolver();
        this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
@@ -201,7 +198,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
        this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
        this.descriptorResolver.setTypeResolver(typeResolver);

-        this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
+        this.javaBridgeConfiguration.setJavaDescriptorResolver(javaDescriptorResolver);

        javaDescriptorResolver.setClassResolver(javaClassResolver);
        javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
@@ -281,15 +278,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
        scriptBodyResolver.setTrace(bindingTrace);

-        javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        javaSemanticServices.setPsiClassFinder(psiClassFinder);
-
        javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
        javaClassResolver.setFunctionResolver(javaFunctionResolver);
+        javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
        javaClassResolver.setSignatureResolver(javaSignatureResolver);
        javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
        javaClassResolver.setTrace(bindingTrace);
@@ -320,7 +314,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
        annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder);

        javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
+        javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
        javaNamespaceResolver.setTrace(bindingTrace);

@@ -37,16 +37,20 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {
            .addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS)
            .build();

-    private JavaSemanticServices javaSemanticServices;
+    private JavaDescriptorResolver javaDescriptorResolver;

    @Inject
-    public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) {
-        this.javaSemanticServices = javaSemanticServices;
+    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
    }

    @Override
-    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
-        JetScope javaPackageScope = javaSemanticServices.getDescriptorResolver().getJavaPackageScope(namespaceDescriptor);
+    public void extendNamespaceScope(
+            @NotNull BindingTrace trace,
+            @NotNull NamespaceDescriptor namespaceDescriptor,
+            @NotNull WritableScope namespaceMemberScope
+    ) {
+        JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
        if (javaPackageScope != null) {
            namespaceMemberScope.importScope(javaPackageScope);
        }
@@ -1,48 +0,0 @@
-/*
- * Copyright 2010-2013 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;
-
-import org.jetbrains.annotations.NotNull;
-
-import javax.inject.Inject;
-
-public class JavaSemanticServices {
-    @NotNull
-    private JavaDescriptorResolver descriptorResolver;
-    @NotNull
-    private PsiClassFinder psiClassFinder;
-
-    @Inject
-    public void setDescriptorResolver(@NotNull JavaDescriptorResolver descriptorResolver) {
-        this.descriptorResolver = descriptorResolver;
-    }
-
-    @Inject
-    public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) {
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @NotNull
-    public JavaDescriptorResolver getDescriptorResolver() {
-        return descriptorResolver;
-    }
-
-    @NotNull
-    public PsiClassFinder getPsiClassFinder() {
-        return psiClassFinder;
-    }
-}
@@ -87,7 +87,7 @@ public final class JavaClassResolver {

    private BindingTrace trace;
    private JavaSignatureResolver signatureResolver;
-    private JavaSemanticServices semanticServices;
+    private JavaDescriptorResolver javaDescriptorResolver;
    private JavaAnnotationResolver annotationResolver;
    private PsiClassFinder psiClassFinder;
    private JavaNamespaceResolver namespaceResolver;
@@ -114,8 +114,8 @@ public final class JavaClassResolver {
    }

    @Inject
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
    }

    @Inject
@@ -292,9 +292,9 @@ public final class JavaClassResolver {
        classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass));
        classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
        classDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices);
-        classDescriptor.setScopeForMemberLookup(membersScope);
-        classDescriptor.setScopeForConstructorResolve(membersScope);
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, classData, javaDescriptorResolver);
+        classDescriptor.setScopeForMemberLookup(scope);
+        classDescriptor.setScopeForConstructorResolve(scope);

        String context = "class " + psiClass.getQualifiedName();
        signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor, context);
@@ -521,13 +521,11 @@ public final class JavaClassResolver {
        classObjectDescriptor.setVisibility(containing.getVisibility());
        classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
        classObjectDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope classMembersScope =
-                new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, javaDescriptorResolver);
        WritableScopeImpl writableScope =
-                new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION,
-                                      "Member lookup scope");
+                new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
        writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
        classObjectDescriptor.setScopeForMemberLookup(writableScope);
-        classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
+        classObjectDescriptor.setScopeForConstructorResolve(scope);
    }
 }
@@ -36,10 +36,13 @@ 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.*;
+import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProviderImpl;
+import org.jetbrains.jet.lang.resolve.java.provider.MembersCache;
+import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProviderImpl;
 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.JavaPackageScopeWithoutMembers;
+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;
@@ -62,7 +65,7 @@ public final class JavaNamespaceResolver {

    private PsiClassFinder psiClassFinder;
    private BindingTrace trace;
-    private JavaSemanticServices javaSemanticServices;
+    private JavaDescriptorResolver javaDescriptorResolver;

    private DeserializedDescriptorResolver deserializedDescriptorResolver;

@@ -80,8 +83,8 @@ public final class JavaNamespaceResolver {
    }

    @Inject
-    public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
-        this.javaSemanticServices = javaSemanticServices;
+    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
+        this.javaDescriptorResolver = javaDescriptorResolver;
    }

    @Inject
@@ -188,7 +191,7 @@ public final class JavaNamespaceResolver {

            // Otherwise (if psiClass is null or doesn't have a supported Kotlin annotation), it's a Java class and the package is empty
            PackagePsiDeclarationProvider provider = new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder);
-            return new JavaPackageScopeWithoutMembers(namespaceDescriptor, provider, fqName, javaSemanticServices);
+            return new JavaPackageScope(namespaceDescriptor, provider, fqName, javaDescriptorResolver, psiClassFinder);
        }

        PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
@@ -205,7 +208,7 @@ public final class JavaNamespaceResolver {
        return new JavaClassStaticMembersScope(
                namespaceDescriptor,
                new ClassPsiDeclarationProviderImpl(psiClass, true, psiClassFinder),
-                fqName, javaSemanticServices);
+                fqName, javaDescriptorResolver);
    }

    private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) {
@@ -27,7 +27,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
 import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
@@ -38,9 +37,8 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 import java.util.*;

 public abstract class JavaBaseScope extends JetScopeImpl {
-
    @NotNull
-    protected final JavaSemanticServices semanticServices;
+    protected final JavaDescriptorResolver javaDescriptorResolver;
    @NotNull
    protected final PsiDeclarationProvider declarationProvider;
    @NotNull
@@ -59,10 +57,10 @@ public abstract class JavaBaseScope extends JetScopeImpl {

    protected JavaBaseScope(
            @NotNull ClassOrNamespaceDescriptor descriptor,
-            @NotNull JavaSemanticServices semanticServices,
+            @NotNull JavaDescriptorResolver javaDescriptorResolver,
            @NotNull PsiDeclarationProvider declarationProvider
    ) {
-        this.semanticServices = semanticServices;
+        this.javaDescriptorResolver = javaDescriptorResolver;
        this.declarationProvider = declarationProvider;
        this.descriptor = descriptor;
    }
@@ -90,7 +88,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {

    @NotNull
    private Set<VariableDescriptor> computePropertyDescriptors(@NotNull Name name) {
-        return getResolver().resolveFieldGroupByName(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFieldGroupByName(name, declarationProvider, descriptor);
    }

    @NotNull
@@ -160,11 +158,6 @@ public abstract class JavaBaseScope extends JetScopeImpl {
        return result;
    }

-    @NotNull
-    protected JavaDescriptorResolver getResolver() {
-        return semanticServices.getDescriptorResolver();
-    }
-
    //TODO: remove this method
    @NotNull
    public PsiElement getPsiElement() {
@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.scope;

 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -37,9 +37,9 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
    protected JavaClassMembersScope(
            @NotNull ClassOrNamespaceDescriptor descriptor,
            @NotNull ClassPsiDeclarationProvider declarationProvider,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
    ) {
-        super(descriptor, semanticServices, declarationProvider);
+        super(descriptor, javaDescriptorResolver, declarationProvider);
        this.declarationProvider = declarationProvider;
    }

@@ -53,7 +53,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
    @NotNull
    @Override
    protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFunctionGroup(name, declarationProvider, descriptor);
    }

    @NotNull
@@ -71,7 +71,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
    @NotNull
    @Override
    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return getResolver().resolveInnerClasses(declarationProvider);
+        return javaDescriptorResolver.resolveInnerClasses(declarationProvider);
    }

    @Override
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;

 import java.util.Collection;
@@ -35,9 +35,9 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
    public JavaClassNonStaticMembersScope(
            @NotNull ClassDescriptor descriptor,
            @NotNull ClassPsiDeclarationProvider psiDeclarationProvider,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
    ) {
-        super(descriptor, psiDeclarationProvider, semanticServices);
+        super(descriptor, psiDeclarationProvider, javaDescriptorResolver);
        this.descriptor = descriptor;
    }

@@ -56,7 +56,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope

    private void initConstructorsIfNeeded() {
        if (constructors == null) {
-            constructors = getResolver().resolveConstructors(declarationProvider, descriptor);
+            constructors = javaDescriptorResolver.resolveConstructors(declarationProvider, descriptor);

            for (ConstructorDescriptor constructor : constructors) {
                if (constructor.isPrimary()) {
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 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.JavaDescriptorResolver;
 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;
@@ -37,15 +37,15 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
            @NotNull NamespaceDescriptor descriptor,
            @NotNull ClassPsiDeclarationProvider declarationProvider,
            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver
    ) {
-        super(descriptor, declarationProvider, semanticServices);
+        super(descriptor, declarationProvider, javaDescriptorResolver);
        this.packageFQN = packageFQN;
    }

    @Override
    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
+        return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
    }

    @NotNull
@@ -22,35 +22,38 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifier;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;

 import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;

-public abstract class JavaPackageScope extends JavaBaseScope {
+public final class JavaPackageScope extends JavaBaseScope {
    @NotNull
    private final FqName packageFQN;
+    @NotNull
+    private final PsiClassFinder psiClassFinder;

-    protected JavaPackageScope(
+    public JavaPackageScope(
            @NotNull NamespaceDescriptor descriptor,
            @NotNull PackagePsiDeclarationProvider declarationProvider,
            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
+            @NotNull JavaDescriptorResolver javaDescriptorResolver,
+            @NotNull PsiClassFinder psiClassFinder
    ) {
-        super(descriptor, semanticServices, declarationProvider);
+        super(descriptor, javaDescriptorResolver, declarationProvider);
        this.packageFQN = packageFQN;
+        this.psiClassFinder = psiClassFinder;
    }

    @Override
    public ClassifierDescriptor getClassifier(@NotNull Name name) {
        ClassDescriptor classDescriptor =
-                getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
        if (classDescriptor == null || classDescriptor.getKind().isObject()) {
            return null;
        }
@@ -60,7 +63,7 @@ public abstract class JavaPackageScope extends JavaBaseScope {
    @Override
    public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
        ClassDescriptor classDescriptor =
-                getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
        if (classDescriptor != null && classDescriptor.getKind().isObject()) {
            return classDescriptor;
        }
@@ -69,7 +72,7 @@ public abstract class JavaPackageScope extends JavaBaseScope {

    @Override
    public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
+        return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN);
    }

    @NotNull
@@ -88,13 +91,13 @@ public abstract class JavaPackageScope extends JavaBaseScope {

        for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
            FqName fqName = new FqName(psiSubPackage.getQualifiedName());
-            NamespaceDescriptor childNs = getResolver().resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+            NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
            if (childNs != null) {
                result.add(childNs);
            }
        }

-        for (PsiClass psiClass : semanticServices.getPsiClassFinder().findPsiClasses(psiPackage)) {
+        for (PsiClass psiClass : psiClassFinder.findPsiClasses(psiPackage)) {
            if (DescriptorResolverUtils.isCompiledKotlinPackageClass(psiClass)) continue;

            if (psiClass instanceof JetJavaMirrorMarker) continue;
@@ -107,12 +110,12 @@ public abstract class JavaPackageScope extends JavaBaseScope {
            if (qualifiedName == null) continue;
            FqName fqName = new FqName(qualifiedName);

-            ClassDescriptor classDescriptor = getResolver().resolveClass(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+            ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
            if (classDescriptor != null) {
                result.add(classDescriptor);
            }

-            NamespaceDescriptor namespace = getResolver().resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+            NamespaceDescriptor namespace = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
            if (namespace != null) {
                result.add(namespace);
            }
@@ -120,4 +123,17 @@ public abstract class JavaPackageScope extends JavaBaseScope {

        return result;
    }
+
+    @Override
+    @NotNull
+    protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
+        return javaDescriptorResolver.resolveFunctionGroup(name, (PackagePsiDeclarationProvider) declarationProvider,
+                                                           (NamespaceDescriptor) descriptor);
+    }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return Collections.emptyList();
+    }
 }
@@ -1,54 +0,0 @@
-/*
- * Copyright 2010-2013 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.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.Name;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-
-public final class JavaPackageScopeWithoutMembers extends JavaPackageScope {
-    public JavaPackageScopeWithoutMembers(
-            @NotNull NamespaceDescriptor descriptor,
-            @NotNull PackagePsiDeclarationProvider declarationProvider,
-            @NotNull FqName packageFQN,
-            @NotNull JavaSemanticServices semanticServices
-    ) {
-        super(descriptor, declarationProvider, packageFQN, semanticServices);
-    }
-
-    @Override
-    @NotNull
-    protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return getResolver().resolveFunctionGroup(
-                name, (PackagePsiDeclarationProvider) declarationProvider, (NamespaceDescriptor) descriptor);
-    }
-
-    @NotNull
-    @Override
-    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return Collections.emptyList();
-    }
-}