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

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

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

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

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

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

@@ -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) {
+    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
-        this.javaSemanticServices = javaSemanticServices;
+        this.javaDescriptorResolver = javaDescriptorResolver;
     }
 
     @Override
-    public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) {
+    public void extendNamespaceScope(
-        JetScope javaPackageScope = javaSemanticServices.getDescriptorResolver().getJavaPackageScope(namespaceDescriptor);
+            @NotNull BindingTrace trace,
+            @NotNull NamespaceDescriptor namespaceDescriptor,
+            @NotNull WritableScope namespaceMemberScope
+    ) {
+        JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor);
         if (javaPackageScope != null) {
             namespaceMemberScope.importScope(javaPackageScope);
         }

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

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

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

@@ -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) {
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
-        this.semanticServices = semanticServices;
+        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);
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, classData, javaDescriptorResolver);
-        classDescriptor.setScopeForMemberLookup(membersScope);
+        classDescriptor.setScopeForMemberLookup(scope);
-        classDescriptor.setScopeForConstructorResolve(membersScope);
+        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 =
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, javaDescriptorResolver);
-                new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices);
         WritableScopeImpl writableScope =
-                new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION,
+                new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
-                                      "Member lookup scope");
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
         classObjectDescriptor.setScopeForMemberLookup(writableScope);
-        classObjectDescriptor.setScopeForConstructorResolve(classMembersScope);
+        classObjectDescriptor.setScopeForConstructorResolve(scope);
     }
 }

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

@@ -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) {
+    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
-        this.javaSemanticServices = javaSemanticServices;
+        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) {

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

@@ -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() {

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

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

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

@@ -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()) {

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

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

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

@@ -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.*;
-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.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();
+    }
 }

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

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