Collect getting psi classes in PsiClassFinder

#KT-3187 In Progress

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

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
@@ -50,6 +51,7 @@ public class InjectorForJavaDescriptorResolver {
     private JavaSemanticServices javaSemanticServices;
     private JavaDescriptorResolver javaDescriptorResolver;
     private PsiClassFinderImpl psiClassFinder;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
     private JavaTypeTransformer javaTypeTransformer;
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
@@ -76,6 +78,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaSemanticServices = new JavaSemanticServices();
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.psiClassFinder = new PsiClassFinderImpl();
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
@@ -95,6 +98,7 @@ public class InjectorForJavaDescriptorResolver {
 
         this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
+        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
         this.javaSemanticServices.setTrace(bindingTrace);
         this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 

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

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
@@ -50,6 +51,7 @@ public class InjectorForJavaSemanticServices {
     private PsiClassFinderImpl psiClassFinder;
     private ModuleDescriptor moduleDescriptor;
     private final Project project;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
     private JavaTypeTransformer javaTypeTransformer;
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
@@ -74,6 +76,7 @@ public class InjectorForJavaSemanticServices {
         this.psiClassFinder = new PsiClassFinderImpl();
         this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"));
         this.project = project;
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
@@ -90,6 +93,7 @@ public class InjectorForJavaSemanticServices {
 
         this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
+        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
         this.javaSemanticServices.setTrace(bindingTrace);
         this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 

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

@@ -47,6 +47,7 @@ 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.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
@@ -95,6 +96,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private TypeHierarchyResolver typeHierarchyResolver;
     private ScriptBodyResolver scriptBodyResolver;
     private JavaSemanticServices javaSemanticServices;
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
     private JavaTypeTransformer javaTypeTransformer;
     private JavaClassResolver javaClassResolver;
     private JavaAnnotationResolver javaAnnotationResolver;
@@ -144,6 +146,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.javaSemanticServices = new JavaSemanticServices();
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(psiClassFinder);
         this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
@@ -267,6 +270,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         javaSemanticServices.setPsiClassFinder(psiClassFinder);
+        javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
         javaSemanticServices.setTrace(bindingTrace);
         javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 

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

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -37,7 +38,8 @@ public class JavaSemanticServices {
     private PsiClassFinder psiClassFinder;
     @NotNull
     private BindingTrace trace;
-
+    @NotNull
+    private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
 
     @Inject
     public void setTypeTransformer(@NotNull JavaTypeTransformer typeTransformer) {
@@ -59,13 +61,16 @@ public class JavaSemanticServices {
         this.trace = trace;
     }
 
-
-
     @NotNull
     public JavaTypeTransformer getTypeTransformer() {
         return typeTransformer;
     }
 
+    @Inject
+    public void setPsiDeclarationProviderFactory(PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
+        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
+    }
+
     @NotNull
     public JavaDescriptorResolver getDescriptorResolver() {
         return descriptorResolver;
@@ -81,7 +86,10 @@ public class JavaSemanticServices {
         return psiClassFinder;
     }
 
-
+    @NotNull
+    public PsiDeclarationProviderFactory getPsiDeclarationProviderFactory() {
+        return psiDeclarationProviderFactory;
+    }
 
     @Nullable
     public ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) {

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

@@ -22,6 +22,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
+import java.util.List;
+
 public interface PsiClassFinder {
     enum RuntimeClassesHandleMode {
         THROW,
@@ -30,6 +32,13 @@ public interface PsiClassFinder {
 
     @Nullable
     PsiClass findPsiClass(@NotNull FqName fqName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode);
+
     @Nullable
     PsiPackage findPsiPackage(@NotNull FqName fqName);
+
+    @NotNull
+    List<PsiClass> findPsiClasses(@NotNull PsiPackage psiPackage);
+
+    @NotNull
+    List<PsiClass> findInnerPsiClasses(@NotNull PsiClass psiClass);
 }

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

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -32,6 +34,8 @@ import org.jetbrains.jet.plugin.JetFileType;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
+import java.util.List;
+import java.util.Set;
 
 public class PsiClassFinderImpl implements PsiClassFinder {
 
@@ -122,5 +126,32 @@ public class PsiClassFinderImpl implements PsiClassFinder {
         return javaFacade.findPackage(qualifiedName.getFqName());
     }
 
+    @NotNull
+    @Override
+    public List<PsiClass> findPsiClasses(@NotNull PsiPackage psiPackage) {
+        return filterDuplicateClasses(psiPackage.getClasses());
+    }
 
+    @NotNull
+    @Override
+    public List<PsiClass> findInnerPsiClasses(@NotNull PsiClass psiClass) {
+        return filterDuplicateClasses(psiClass.getInnerClasses());
+    }
+
+    private static List<PsiClass> filterDuplicateClasses(PsiClass[] classes) {
+        Set<String> addedQualifiedNames = Sets.newHashSet();
+        List<PsiClass> filteredClasses = Lists.newArrayList();
+
+        for (PsiClass aClass : classes) {
+            String qualifiedName = aClass.getQualifiedName();
+
+            if (qualifiedName != null) {
+                if (addedQualifiedNames.add(qualifiedName)) {
+                    filteredClasses.add(aClass);
+                }
+            }
+        }
+
+        return filteredClasses;
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.java

@@ -4,30 +4,34 @@ import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
 
 public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase implements ClassPsiDeclarationProvider {
 
-    @NotNull
-    private final PsiClass psiClass;
-    private final boolean staticMembers;
     @NotNull
     protected final DeclarationOrigin declarationOrigin;
+    @NotNull
+    protected final PsiClassFinder psiClassFinder;
 
-    protected ClassPsiDeclarationProviderImpl(
+    @NotNull
-            @NotNull PsiClass psiClass, boolean staticMembers
+    private final PsiClass psiClass;
-    ) {
+
+    private final boolean staticMembers;
+
+    protected ClassPsiDeclarationProviderImpl(@NotNull PsiClass psiClass, boolean staticMembers, @NotNull PsiClassFinder psiClassFinder) {
         this.staticMembers = staticMembers;
         this.psiClass = psiClass;
+        this.psiClassFinder = psiClassFinder;
         this.declarationOrigin = determineOrigin(psiClass);
     }
 
     @Override
     @NotNull
     protected MembersCache buildMembersCache() {
-        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClass, null, staticMembers, getDeclarationOrigin() == KOTLIN);
+        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers, getDeclarationOrigin() == KOTLIN);
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/KotlinNamespacePsiDeclarationProvider.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
 
@@ -29,10 +30,14 @@ public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclara
 
     public KotlinNamespacePsiDeclarationProvider(
             @NotNull PsiPackage psiPackage,
-            @NotNull PsiClass psiClass
+            @NotNull PsiClass psiClass,
+            @NotNull PsiDeclarationProviderFactory factory,
+            @NotNull PsiClassFinder psiClassFinder
     ) {
-        super(psiClass, true);
+        super(psiClass, true, psiClassFinder);
-        this.packagePsiDeclarationProvider = PsiDeclarationProviderFactory.createDeclarationProviderForNamespaceWithoutMembers(psiPackage);
+
+        // TODO: remove?
+        this.packagePsiDeclarationProvider = factory.createDeclarationProviderForNamespaceWithoutMembers(psiPackage);
     }
 
     @NotNull
@@ -45,7 +50,7 @@ public final class KotlinNamespacePsiDeclarationProvider extends ClassPsiDeclara
     @Override
     protected MembersCache buildMembersCache() {
         MembersCache cacheWithMembers = super.buildMembersCache();
-        MembersCache.buildMembersByNameCache(cacheWithMembers, null, packagePsiDeclarationProvider.getPsiPackage(), true, getDeclarationOrigin() == KOTLIN);
+        MembersCache.buildMembersByNameCache(cacheWithMembers, psiClassFinder, null, packagePsiDeclarationProvider.getPsiPackage(), true, getDeclarationOrigin() == KOTLIN);
         return cacheWithMembers;
     }
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.java.TypeSource;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.prop.PropertyNameUtils;
@@ -30,10 +31,10 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public final class MembersCache {
-
     @NotNull
     private final Map<Name, NamedMembers> namedMembersMap = new HashMap<Name, NamedMembers>();
 
@@ -59,7 +60,9 @@ public final class MembersCache {
 
     @NotNull
     public static MembersCache buildMembersByNameCache(
-            @NotNull MembersCache membersCache, @Nullable PsiClass psiClass,
+            @NotNull MembersCache membersCache,
+            @NotNull PsiClassFinder finder,
+            @Nullable PsiClass psiClass,
             @Nullable PsiPackage psiPackage,
             boolean staticMembers,
             boolean isKotlin
@@ -67,17 +70,18 @@ public final class MembersCache {
         if (psiClass != null) {
             membersCache.new ClassMemberProcessor(new PsiClassWrapper(psiClass), staticMembers, isKotlin).process();
         }
+
         //TODO:
-        PsiClass[] classes = psiPackage != null ? psiPackage.getClasses() : psiClass.getInnerClasses();
+        List<PsiClass> classes = psiPackage != null ? finder.findPsiClasses(psiPackage) : finder.findInnerPsiClasses(psiClass);
         membersCache.new ObjectClassProcessor(classes).process();
         return membersCache;
     }
 
     private class ObjectClassProcessor {
         @NotNull
-        private final PsiClass[] psiClasses;
+        private final List<PsiClass> psiClasses;
 
-        private ObjectClassProcessor(@NotNull PsiClass[] classes) {
+        private ObjectClassProcessor(@NotNull List<PsiClass> classes) {
             psiClasses = classes;
         }
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PackagePsiDeclarationProviderImpl.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.JAVA;
 import static org.jetbrains.jet.lang.resolve.java.provider.DeclarationOrigin.KOTLIN;
@@ -27,10 +28,15 @@ public final class PackagePsiDeclarationProviderImpl extends PsiDeclarationProvi
     @NotNull
     private final PsiPackage psiPackage;
 
+    @NotNull
+    private final PsiClassFinder psiClassFinder;
+
     /*package private*/ PackagePsiDeclarationProviderImpl(
-            @NotNull PsiPackage psiPackage
+            @NotNull PsiPackage psiPackage,
+            @NotNull PsiClassFinder psiClassFinder
     ) {
         this.psiPackage = psiPackage;
+        this.psiClassFinder = psiClassFinder;
     }
 
     @NotNull
@@ -42,7 +48,7 @@ public final class PackagePsiDeclarationProviderImpl extends PsiDeclarationProvi
     @NotNull
     @Override
     protected MembersCache buildMembersCache() {
-        return MembersCache.buildMembersByNameCache(new MembersCache(), null, getPsiPackage(), true, getDeclarationOrigin() == KOTLIN);
+        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, null, getPsiPackage(), true, getDeclarationOrigin() == KOTLIN);
     }
 
     @NotNull

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/PsiDeclarationProviderFactory.java

@@ -19,36 +19,38 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
 public final class PsiDeclarationProviderFactory {
-    private PsiDeclarationProviderFactory() {
+    @NotNull private final PsiClassFinder psiClassFinder;
+
+    public PsiDeclarationProviderFactory(@NotNull PsiClassFinder psiClassFinder) {
+        this.psiClassFinder = psiClassFinder;
     }
 
     @NotNull
-    public static ClassPsiDeclarationProvider createSyntheticClassObjectClassData(@NotNull PsiClass psiClass) {
+    public ClassPsiDeclarationProvider createSyntheticClassObjectClassData(@NotNull PsiClass psiClass) {
         return createDeclarationProviderForClassStaticMembers(psiClass);
     }
 
     @NotNull
-    public static ClassPsiDeclarationProvider createBinaryClassData(@NotNull PsiClass psiClass) {
+    public ClassPsiDeclarationProvider createBinaryClassData(@NotNull PsiClass psiClass) {
-        return new ClassPsiDeclarationProviderImpl(psiClass, false);
+        return new ClassPsiDeclarationProviderImpl(psiClass, false, psiClassFinder);
     }
 
     @NotNull
-    public static KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
+    public KotlinNamespacePsiDeclarationProvider createDeclarationForKotlinNamespace(
-            @NotNull PsiPackage psiPackage,
+            @NotNull PsiPackage psiPackage, @NotNull PsiClass psiClass) {
-            @NotNull PsiClass psiClass
+        return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass, this, psiClassFinder);
-    ) {
-        return new KotlinNamespacePsiDeclarationProvider(psiPackage, psiClass);
     }
 
     @NotNull
-    public static PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
+    public PackagePsiDeclarationProvider createDeclarationProviderForNamespaceWithoutMembers(@NotNull PsiPackage psiPackage) {
-        return new PackagePsiDeclarationProviderImpl(psiPackage);
+        return new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder);
     }
 
     @NotNull
-    public static ClassPsiDeclarationProvider createDeclarationProviderForClassStaticMembers(@NotNull PsiClass psiClass) {
+    public ClassPsiDeclarationProvider createDeclarationProviderForClassStaticMembers(@NotNull PsiClass psiClass) {
-        return new ClassPsiDeclarationProviderImpl(psiClass, true);
+        return new ClassPsiDeclarationProviderImpl(psiClass, true, psiClassFinder);
     }
 }

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

@@ -104,7 +104,7 @@ public final class JavaClassObjectResolver {
         String qualifiedName = classObjectPsiClass.getQualifiedName();
         assert qualifiedName != null;
         FqName fqName = new FqName(qualifiedName);
-        ClassPsiDeclarationProvider classObjectData = PsiDeclarationProviderFactory.createBinaryClassData(classObjectPsiClass);
+        ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass);
         ClassDescriptorFromJvmBytecode classObjectDescriptor
                 = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT);
         classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor,
@@ -144,7 +144,7 @@ public final class JavaClassObjectResolver {
     ) {
         FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass);
         ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT);
-        ClassPsiDeclarationProvider data = PsiDeclarationProviderFactory.createSyntheticClassObjectClassData(psiClass);
+        ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass);
         setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().getName()));
         return classObjectDescriptor;
     }

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

@@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -219,7 +218,7 @@ public final class JavaClassResolver {
     ) {
         JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
         ClassKind kind = getClassKind(psiClass, jetClassAnnotation);
-        ClassPsiDeclarationProvider classData = PsiDeclarationProviderFactory.createBinaryClassData(psiClass);
+        ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass);
         ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(containingDeclaration, kind);
 
         cache(javaClassToKotlinFqName(fqName), classDescriptor);

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

@@ -43,8 +43,6 @@ import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
-import static org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory.*;
-
 public final class JavaNamespaceResolver {
 
     @NotNull
@@ -150,13 +148,15 @@ public final class JavaNamespaceResolver {
             PsiClass psiClass = getPsiClassForJavaPackageScope(fqName);
             trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.PROPER);
             if (psiClass == null) {
-                return new JavaPackageScopeWithoutMembers(namespaceDescriptor,
+                return new JavaPackageScopeWithoutMembers(
-                                                          createDeclarationProviderForNamespaceWithoutMembers(psiPackage),
+                        namespaceDescriptor,
-                                                          fqName, javaSemanticServices);
+                        javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationProviderForNamespaceWithoutMembers(psiPackage),
+                        fqName, javaSemanticServices);
             }
-            return new JavaScopeForKotlinNamespace(namespaceDescriptor,
+            return new JavaScopeForKotlinNamespace(
-                                                   createDeclarationForKotlinNamespace(psiPackage, psiClass),
+                    namespaceDescriptor,
-                                                   fqName, javaSemanticServices);
+                    javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationForKotlinNamespace(psiPackage, psiClass),
+                    fqName, javaSemanticServices);
         }
 
         PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
@@ -169,9 +169,10 @@ public final class JavaNamespaceResolver {
             return null;
         }
         trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.CLASS_STATICS);
-        return new JavaClassStaticMembersScope(namespaceDescriptor,
+        return new JavaClassStaticMembersScope(
-                                               createDeclarationProviderForClassStaticMembers(psiClass),
+                namespaceDescriptor,
-                                               fqName, javaSemanticServices);
+                javaSemanticServices.getPsiDeclarationProviderFactory().createDeclarationProviderForClassStaticMembers(psiClass),
+                fqName, javaSemanticServices);
     }
 
     private void cache(@NotNull FqName fqName, @Nullable JavaBaseScope packageScope) {

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

@@ -52,7 +52,7 @@ public final class ScopeUtils {
             }
         }
 
-        for (PsiClass psiClass : psiPackage.getClasses()) {
+        for (PsiClass psiClass : javaSemanticServices.getPsiClassFinder().findPsiClasses(psiPackage)) {
             if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) {
                 continue;
             }