Extract JavaMemberResolver out of JDR

JavaDescriptorResolver had a lot of methods which were used only in Java*Scope.
This is not good because JDR is a facade class that everyone uses from outside
and it's not required to find methods/fields/...
This logic is now extracted to JavaMemberResolver, which is passed to a scope
and is used to resolve its members ('members' here means classes, namespaces,
functions, properties, constructors)

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

@@ -33,13 +33,14 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolv
 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.resolver.JavaFunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -63,13 +64,14 @@ public class InjectorForJavaDescriptorResolver {
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final JavaNamespaceResolver javaNamespaceResolver;
-    private final JavaFunctionResolver javaFunctionResolver;
+    private final JavaMemberResolver javaMemberResolver;
-    private final JavaTypeParameterResolver javaTypeParameterResolver;
+    private final JavaConstructorResolver javaConstructorResolver;
     private final JavaTypeTransformer javaTypeTransformer;
     private final JavaValueParameterResolver javaValueParameterResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
+    private final JavaFunctionResolver javaFunctionResolver;
-    private final JavaConstructorResolver javaConstructorResolver;
+    private final JavaTypeParameterResolver javaTypeParameterResolver;
     private final JavaPropertyResolver javaPropertyResolver;
+    private final JavaSupertypeResolver javaSupertypeResolver;
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
@@ -92,13 +94,14 @@ public class InjectorForJavaDescriptorResolver {
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaFunctionResolver = new JavaFunctionResolver();
+        this.javaMemberResolver = new JavaMemberResolver();
-        this.javaTypeParameterResolver = new JavaTypeParameterResolver();
+        this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
+        this.javaFunctionResolver = new JavaFunctionResolver();
-        this.javaConstructorResolver = new JavaConstructorResolver();
+        this.javaTypeParameterResolver = new JavaTypeParameterResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
 
         javaClassFinder.setPsiClassFinder(psiClassFinder);
 
@@ -113,10 +116,7 @@ public class InjectorForJavaDescriptorResolver {
         psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
 
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
-        this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
-        this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
         this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
-        this.javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
 
         this.psiClassFinder.setProject(project);
 
@@ -125,7 +125,7 @@ public class InjectorForJavaDescriptorResolver {
         javaClassResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setJavaClassFinder(javaClassFinder);
-        javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassResolver.setMemberResolver(javaMemberResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver);
@@ -149,9 +149,24 @@ public class InjectorForJavaDescriptorResolver {
         javaNamespaceResolver.setCache(traceBasedJavaResolverCache);
         javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
         javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
-        javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaNamespaceResolver.setMemberResolver(javaMemberResolver);
         javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder);
 
+        javaMemberResolver.setClassResolver(javaClassResolver);
+        javaMemberResolver.setConstructorResolver(javaConstructorResolver);
+        javaMemberResolver.setFunctionResolver(javaFunctionResolver);
+        javaMemberResolver.setNamespaceResolver(javaNamespaceResolver);
+        javaMemberResolver.setPropertyResolver(javaPropertyResolver);
+
+        javaConstructorResolver.setCache(traceBasedJavaResolverCache);
+        javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
+        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
+        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
+
+        javaTypeTransformer.setClassResolver(javaClassResolver);
+
+        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
+
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
@@ -163,24 +178,15 @@ public class InjectorForJavaDescriptorResolver {
 
         javaTypeParameterResolver.setTypeTransformer(javaTypeTransformer);
 
-        javaTypeTransformer.setClassResolver(javaClassResolver);
-
-        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaConstructorResolver.setCache(traceBasedJavaResolverCache);
-        javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
-        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
-
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
         javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
+
         psiClassFinder.initialize();
 
     }

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

@@ -60,13 +60,14 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolv
 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.resolver.JavaFunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeParameterResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -117,13 +118,14 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final JavaNamespaceResolver javaNamespaceResolver;
-    private final JavaFunctionResolver javaFunctionResolver;
+    private final JavaMemberResolver javaMemberResolver;
-    private final JavaTypeParameterResolver javaTypeParameterResolver;
+    private final JavaConstructorResolver javaConstructorResolver;
     private final JavaTypeTransformer javaTypeTransformer;
     private final JavaValueParameterResolver javaValueParameterResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
+    private final JavaFunctionResolver javaFunctionResolver;
-    private final JavaConstructorResolver javaConstructorResolver;
+    private final JavaTypeParameterResolver javaTypeParameterResolver;
     private final JavaPropertyResolver javaPropertyResolver;
+    private final JavaSupertypeResolver javaSupertypeResolver;
     
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
@@ -175,13 +177,14 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaFunctionResolver = new JavaFunctionResolver();
+        this.javaMemberResolver = new JavaMemberResolver();
-        this.javaTypeParameterResolver = new JavaTypeParameterResolver();
+        this.javaConstructorResolver = new JavaConstructorResolver();
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
+        this.javaFunctionResolver = new JavaFunctionResolver();
-        this.javaConstructorResolver = new JavaConstructorResolver();
+        this.javaTypeParameterResolver = new JavaTypeParameterResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
+        this.javaSupertypeResolver = new JavaSupertypeResolver();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setContext(topDownAnalysisContext);
@@ -219,10 +222,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaBridgeConfiguration.setJavaDescriptorResolver(javaDescriptorResolver);
 
         javaDescriptorResolver.setClassResolver(javaClassResolver);
-        javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
-        javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
         javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
 
         psiClassFinder.setProject(project);
 
@@ -312,7 +312,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaClassResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setJavaClassFinder(javaClassFinder);
-        javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaClassResolver.setMemberResolver(javaMemberResolver);
         javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
         javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
         javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver);
@@ -336,9 +336,24 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaNamespaceResolver.setCache(traceBasedJavaResolverCache);
         javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
         javaNamespaceResolver.setJavaClassFinder(javaClassFinder);
-        javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        javaNamespaceResolver.setMemberResolver(javaMemberResolver);
         javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder);
 
+        javaMemberResolver.setClassResolver(javaClassResolver);
+        javaMemberResolver.setConstructorResolver(javaConstructorResolver);
+        javaMemberResolver.setFunctionResolver(javaFunctionResolver);
+        javaMemberResolver.setNamespaceResolver(javaNamespaceResolver);
+        javaMemberResolver.setPropertyResolver(javaPropertyResolver);
+
+        javaConstructorResolver.setCache(traceBasedJavaResolverCache);
+        javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
+        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
+        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
+
+        javaTypeTransformer.setClassResolver(javaClassResolver);
+
+        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
+
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
@@ -350,24 +365,15 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         javaTypeParameterResolver.setTypeTransformer(javaTypeTransformer);
 
-        javaTypeTransformer.setClassResolver(javaClassResolver);
-
-        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaConstructorResolver.setCache(traceBasedJavaResolverCache);
-        javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
-        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
-
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
         javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
+        javaSupertypeResolver.setClassResolver(javaClassResolver);
+        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
+
         psiClassFinder.initialize();
 
     }

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

@@ -18,35 +18,25 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.resolve.java.resolver.*;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
 
 import javax.inject.Inject;
-import java.util.Collection;
-import java.util.Set;
 
 import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
 
 public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver {
     public static final Name JAVA_ROOT = Name.special("<java_root>");
 
-    private JavaPropertyResolver propertiesResolver;
     private JavaClassResolver classResolver;
-    private JavaConstructorResolver constructorResolver;
-    private JavaFunctionResolver functionResolver;
     private JavaNamespaceResolver namespaceResolver;
 
-    @Inject
-    public void setFunctionResolver(JavaFunctionResolver functionResolver) {
-        this.functionResolver = functionResolver;
-    }
-
     @Inject
     public void setClassResolver(JavaClassResolver classResolver) {
         this.classResolver = classResolver;
@@ -57,16 +47,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         this.namespaceResolver = namespaceResolver;
     }
 
-    @Inject
-    public void setPropertiesResolver(JavaPropertyResolver propertiesResolver) {
-        this.propertiesResolver = propertiesResolver;
-    }
-
-    @Inject
-    public void setConstructorResolver(JavaConstructorResolver constructorResolver) {
-        this.constructorResolver = constructorResolver;
-    }
-
     @Nullable
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         return classResolver.resolveClass(qualifiedName, searchRule);
@@ -77,11 +57,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return classResolver.resolveClass(qualifiedName, IGNORE_KOTLIN_SOURCES);
     }
 
-    @NotNull
-    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor classDescriptor) {
-        return constructorResolver.resolveConstructors(javaClass, classDescriptor);
-    }
-
     @Nullable
     public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
@@ -91,19 +66,4 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     public JetScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) {
         return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(namespaceDescriptor);
     }
-
-    @NotNull
-    public Set<VariableDescriptor> resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor ownerDescriptor) {
-        return propertiesResolver.resolveFieldGroup(members, ownerDescriptor);
-    }
-
-    @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
-        return functionResolver.resolveFunctionGroupForClass(members, owner);
-    }
-
-    @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroupForPackage(@NotNull NamedMembers members, @NotNull NamespaceDescriptor owner) {
-        return functionResolver.resolveFunctionGroupForPackage(members, owner);
-    }
 }

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

@@ -30,7 +30,10 @@ import org.jetbrains.jet.descriptors.serialization.ClassId;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.resolve.java.JavaClassFinder;
+import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetJavaMirrorMarker;
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
@@ -84,7 +87,7 @@ public final class JavaClassResolver {
 
     private JavaResolverCache cache;
     private JavaTypeParameterResolver typeParameterResolver;
-    private JavaDescriptorResolver javaDescriptorResolver;
+    private JavaMemberResolver memberResolver;
     private JavaAnnotationResolver annotationResolver;
     private JavaClassFinder javaClassFinder;
     private JavaNamespaceResolver namespaceResolver;
@@ -117,8 +120,8 @@ public final class JavaClassResolver {
     }
 
     @Inject
-    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    public void setMemberResolver(JavaMemberResolver memberResolver) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+        this.memberResolver = memberResolver;
     }
 
     @Inject
@@ -303,7 +306,7 @@ public final class JavaClassResolver {
         classDescriptor.setModality(javaClass.getModality());
         classDescriptor.createTypeConstructor();
 
-        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, javaClass, false, javaDescriptorResolver);
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, javaClass, false, memberResolver);
         classDescriptor.setScopeForMemberLookup(scope);
         classDescriptor.setScopeForConstructorResolve(scope);
 
@@ -478,8 +481,7 @@ public final class JavaClassResolver {
         classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObjectDescriptor.createTypeConstructor();
 
-        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, javaClass, true,
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, javaClass, true, memberResolver);
-                                                                                  javaDescriptorResolver);
         WritableScopeImpl writableScope =
                 new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);

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

@@ -0,0 +1,92 @@
+/*
+ * 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.resolver;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers;
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import javax.inject.Inject;
+import java.util.Collection;
+import java.util.Set;
+
+public class JavaMemberResolver {
+    private JavaClassResolver classResolver;
+    private JavaNamespaceResolver namespaceResolver;
+    private JavaFunctionResolver functionResolver;
+    private JavaPropertyResolver propertyResolver;
+    private JavaConstructorResolver constructorResolver;
+
+    @Inject
+    public void setClassResolver(JavaClassResolver classResolver) {
+        this.classResolver = classResolver;
+    }
+
+    @Inject
+    public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) {
+        this.namespaceResolver = namespaceResolver;
+    }
+
+    @Inject
+    public void setFunctionResolver(JavaFunctionResolver functionResolver) {
+        this.functionResolver = functionResolver;
+    }
+
+    @Inject
+    public void setPropertyResolver(JavaPropertyResolver propertyResolver) {
+        this.propertyResolver = propertyResolver;
+    }
+
+    @Inject
+    public void setConstructorResolver(JavaConstructorResolver constructorResolver) {
+        this.constructorResolver = constructorResolver;
+    }
+
+    @Nullable
+    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
+        return classResolver.resolveClass(qualifiedName, searchRule);
+    }
+
+    @Nullable
+    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
+        return namespaceResolver.resolveNamespace(qualifiedName, searchRule);
+    }
+
+    @NotNull
+    public Set<FunctionDescriptor> resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
+        return functionResolver.resolveFunctionGroupForClass(members, owner);
+    }
+
+    @NotNull
+    public Set<FunctionDescriptor> resolveFunctionGroupForPackage(@NotNull NamedMembers members, @NotNull NamespaceDescriptor owner) {
+        return functionResolver.resolveFunctionGroupForPackage(members, owner);
+    }
+
+    @NotNull
+    public Set<VariableDescriptor> resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor ownerDescriptor) {
+        return propertyResolver.resolveFieldGroup(members, ownerDescriptor);
+    }
+
+    @NotNull
+    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor classDescriptor) {
+        return constructorResolver.resolveConstructors(javaClass, classDescriptor);
+    }
+}

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

@@ -60,7 +60,7 @@ public final class JavaNamespaceResolver {
 
     private JavaClassFinder javaClassFinder;
     private JavaResolverCache cache;
-    private JavaDescriptorResolver javaDescriptorResolver;
+    private JavaMemberResolver memberResolver;
 
     private DeserializedDescriptorResolver deserializedDescriptorResolver;
     private VirtualFileFinder virtualFileFinder;
@@ -81,8 +81,8 @@ public final class JavaNamespaceResolver {
     }
 
     @Inject
-    public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
+    public void setMemberResolver(@NotNull JavaMemberResolver memberResolver) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+        this.memberResolver = memberResolver;
     }
 
     @Inject
@@ -170,7 +170,7 @@ public final class JavaNamespaceResolver {
                 cache.recordPackage(javaPackage, namespaceDescriptor);
             }
 
-            return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, javaDescriptorResolver);
+            return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, memberResolver);
         }
 
         JavaClass javaClass = javaClassFinder.findClass(fqName);
@@ -191,7 +191,7 @@ public final class JavaNamespaceResolver {
             cache.recordPackage(javaClass, namespaceDescriptor);
         }
 
-        return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, javaDescriptorResolver);
+        return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, memberResolver);
     }
 
     private void cache(@NotNull FqName fqName, @Nullable JetScope packageScope) {

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

@@ -25,7 +25,7 @@ import com.intellij.util.containers.ContainerUtil;
 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.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
@@ -33,7 +33,7 @@ import java.util.*;
 
 public abstract class JavaBaseScope extends JetScopeImpl {
     @NotNull
-    protected final JavaDescriptorResolver javaDescriptorResolver;
+    protected final JavaMemberResolver memberResolver;
     @NotNull
     protected final MembersProvider membersProvider;
     @NotNull
@@ -52,10 +52,10 @@ public abstract class JavaBaseScope extends JetScopeImpl {
 
     protected JavaBaseScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
-            @NotNull JavaDescriptorResolver javaDescriptorResolver,
+            @NotNull JavaMemberResolver memberResolver,
             @NotNull MembersProvider membersProvider
     ) {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+        this.memberResolver = memberResolver;
         this.membersProvider = membersProvider;
         this.descriptor = descriptor;
     }
@@ -87,7 +87,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
         if (members == null) {
             return Collections.emptySet();
         }
-        return javaDescriptorResolver.resolveFieldGroup(members, descriptor);
+        return memberResolver.resolveFieldGroup(members, descriptor);
     }
 
     @NotNull

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.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -30,9 +30,9 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     protected JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
             @NotNull MembersProvider membersProvider,
-            @NotNull JavaDescriptorResolver javaDescriptorResolver
+            @NotNull JavaMemberResolver memberResolver
     ) {
-        super(descriptor, javaDescriptorResolver, membersProvider);
+        super(descriptor, memberResolver, membersProvider);
     }
 
     @NotNull
@@ -49,7 +49,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
         if (members == null) {
             return Collections.emptySet();
         }
-        return javaDescriptorResolver.resolveFunctionGroupForClass(members, descriptor);
+        return memberResolver.resolveFunctionGroupForClass(members, descriptor);
     }
 
     @NotNull

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.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -44,9 +44,9 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
             @NotNull ClassDescriptor descriptor,
             @NotNull JavaClass javaClass,
             boolean staticMembersOfClass,
-            @NotNull JavaDescriptorResolver javaDescriptorResolver
+            @NotNull JavaMemberResolver memberResolver
     ) {
-        super(descriptor, MembersProvider.forClass(javaClass, staticMembersOfClass), javaDescriptorResolver);
+        super(descriptor, MembersProvider.forClass(javaClass, staticMembersOfClass), memberResolver);
         this.descriptor = descriptor;
         this.javaClass = javaClass;
         this.staticMembersOfPsiClass = staticMembersOfClass;
@@ -67,7 +67,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
 
     private void initConstructorsIfNeeded() {
         if (constructors == null) {
-            constructors = javaDescriptorResolver.resolveConstructors(javaClass, descriptor);
+            constructors = memberResolver.resolveConstructors(javaClass, descriptor);
 
             for (ConstructorDescriptor constructor : constructors) {
                 if (constructor.isPrimary()) {
@@ -100,7 +100,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
     private ClassDescriptor resolveInnerClass(@NotNull JavaClass innerClass) {
         FqName fqName = innerClass.getFqName();
         assert fqName != null : "Inner class has no qualified name: " + innerClass;
-        ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES);
+        ClassDescriptor classDescriptor = memberResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES);
         assert classDescriptor != null : "Couldn't resolve inner class " + fqName;
         return classDescriptor;
     }

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

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -41,16 +41,16 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
             @NotNull NamespaceDescriptor descriptor,
             @NotNull FqName packageFQN,
             @NotNull JavaClass javaClass,
-            @NotNull JavaDescriptorResolver javaDescriptorResolver
+            @NotNull JavaMemberResolver memberResolver
     ) {
-        super(descriptor, MembersProvider.forClass(javaClass, true), javaDescriptorResolver);
+        super(descriptor, MembersProvider.forClass(javaClass, true), memberResolver);
         this.packageFQN = packageFQN;
         this.javaClass = javaClass;
     }
 
     @Override
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
+        return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
     }
 
     @NotNull

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

@@ -18,12 +18,11 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 
 import com.google.common.collect.Sets;
 import com.intellij.openapi.progress.ProgressIndicatorProvider;
-import com.intellij.psi.PsiModifier;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetJavaMirrorMarker;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -46,16 +45,16 @@ public final class JavaPackageScope extends JavaBaseScope {
             @NotNull NamespaceDescriptor descriptor,
             @NotNull JavaPackage javaPackage,
             @NotNull FqName packageFQN,
-            @NotNull JavaDescriptorResolver javaDescriptorResolver
+            @NotNull JavaMemberResolver memberResolver
     ) {
-        super(descriptor, javaDescriptorResolver, MembersProvider.forPackage(javaPackage));
+        super(descriptor, memberResolver, MembersProvider.forPackage(javaPackage));
         this.javaPackage = javaPackage;
         this.packageFQN = packageFQN;
     }
 
     @Override
     public ClassifierDescriptor getClassifier(@NotNull Name name) {
-        ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES);
+        ClassDescriptor classDescriptor = memberResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES);
         if (classDescriptor == null || classDescriptor.getKind().isObject()) {
             return null;
         }
@@ -64,7 +63,7 @@ public final class JavaPackageScope extends JavaBaseScope {
 
     @Override
     public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
-        ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES);
+        ClassDescriptor classDescriptor = memberResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES);
         if (classDescriptor != null && classDescriptor.getKind().isObject()) {
             return classDescriptor;
         }
@@ -73,7 +72,7 @@ public final class JavaPackageScope extends JavaBaseScope {
 
     @Override
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
-        return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
+        return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES);
     }
 
     @NotNull
@@ -89,7 +88,7 @@ public final class JavaPackageScope extends JavaBaseScope {
         Collection<DeclarationDescriptor> result = Sets.newHashSet();
 
         for (JavaPackage subPackage : javaPackage.getSubPackages()) {
-            NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(subPackage.getFqName(), IGNORE_KOTLIN_SOURCES);
+            NamespaceDescriptor childNs = memberResolver.resolveNamespace(subPackage.getFqName(), IGNORE_KOTLIN_SOURCES);
             if (childNs != null) {
                 result.add(childNs);
             }
@@ -98,21 +97,21 @@ public final class JavaPackageScope extends JavaBaseScope {
         for (JavaClass javaClass : DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses())) {
             if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass.getPsi())) continue;
 
-            if (isKotlinLightClass(javaClass)) continue;
+            if (javaClass.getPsi() instanceof JetJavaMirrorMarker) continue;
 
-            if (!javaClass.getPsi().hasModifierProperty(PsiModifier.PUBLIC)) continue;
+            if (javaClass.getVisibility() != Visibilities.PUBLIC) continue;
 
             ProgressIndicatorProvider.checkCanceled();
 
             FqName fqName = javaClass.getFqName();
             if (fqName == null) continue;
 
-            ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES);
+            ClassDescriptor classDescriptor = memberResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES);
             if (classDescriptor != null) {
                 result.add(classDescriptor);
             }
 
-            NamespaceDescriptor namespace = javaDescriptorResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES);
+            NamespaceDescriptor namespace = memberResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES);
             if (namespace != null) {
                 result.add(namespace);
             }
@@ -121,10 +120,6 @@ public final class JavaPackageScope extends JavaBaseScope {
         return result;
     }
 
-    private static boolean isKotlinLightClass(@NotNull JavaClass javaClass) {
-        return javaClass.getPsi() instanceof JetJavaMirrorMarker;
-    }
-
     @Override
     @NotNull
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
@@ -132,7 +127,7 @@ public final class JavaPackageScope extends JavaBaseScope {
         if (members == null) {
             return Collections.emptySet();
         }
-        return javaDescriptorResolver.resolveFunctionGroupForPackage(members, (NamespaceDescriptor) descriptor);
+        return memberResolver.resolveFunctionGroupForPackage(members, (NamespaceDescriptor) descriptor);
     }
 
     @NotNull