Simplify PsiDeclarationProvider

- simplify hierarchy, now there's only two kinds of providers: for packages and
  for classes
- remove getters from providers and thus almost get rid of dependencies on them
  from the outside resolver (the only usages left are those that call
  getMembersCache)

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

@@ -16,12 +16,11 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -191,10 +190,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @NotNull
-    public Collection<ConstructorDescriptor> resolveConstructors(
+    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor) {
-            @NotNull ClassPsiDeclarationProvider classData, @NotNull ClassDescriptor classDescriptor
+        return constructorResolver.resolveConstructors(psiClass, classDescriptor);
-    ) {
-        return constructorResolver.resolveConstructors(classData, classDescriptor);
     }
 
     @Nullable
@@ -215,10 +212,10 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name name,
-            @NotNull PsiDeclarationProvider data,
+            @NotNull PsiDeclarationProvider provider,
             @NotNull ClassOrNamespaceDescriptor ownerDescriptor
     ) {
-        return propertiesResolver.resolveFieldGroupByName(name, data, ownerDescriptor);
+        return propertiesResolver.resolveFieldGroupByName(name, provider, ownerDescriptor);
     }
 
     @Nullable
@@ -247,25 +244,26 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     }
 
     @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroup(
+    public Set<FunctionDescriptor> resolveFunctionGroupForClass(
             @NotNull Name methodName,
-            @NotNull ClassPsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider provider,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrNamespaceDescriptor ownerDescriptor,
+            @NotNull PsiClass psiClass
     ) {
-        return functionResolver.resolveFunctionGroup(methodName, scopeData, ownerDescriptor);
+        return functionResolver.resolveFunctionGroupForClass(methodName, provider, ownerDescriptor, psiClass);
     }
 
     @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroup(
+    public Set<FunctionDescriptor> resolveFunctionGroupForPackage(
             @NotNull Name methodName,
-            @NotNull PackagePsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider provider,
             @NotNull NamespaceDescriptor ownerDescriptor
     ) {
-        return functionResolver.resolveFunctionGroup(methodName, scopeData, ownerDescriptor);
+        return functionResolver.resolveFunctionGroupForPackage(methodName, provider, ownerDescriptor);
     }
 
     @NotNull
-    public List<ClassDescriptor> resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) {
+    public List<ClassDescriptor> resolveInnerClasses(@NotNull PsiClass psiClass) {
-        return innerClassResolver.resolveInnerClasses(declarationProvider);
+        return innerClassResolver.resolveInnerClasses(psiClass);
     }
 }

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

@@ -18,12 +18,23 @@ package org.jetbrains.jet.lang.resolve.java.provider;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
-public interface ClassPsiDeclarationProvider extends PsiDeclarationProvider {
+public final class ClassPsiDeclarationProvider extends PsiDeclarationProvider {
-
     @NotNull
-    PsiClass getPsiClass();
+    private final PsiClass psiClass;
 
-    //TODO: remove this method
+    private final boolean staticMembers;
-    boolean isStaticMembers();
+
+    public ClassPsiDeclarationProvider(@NotNull PsiClass psiClass, boolean staticMembers, @NotNull PsiClassFinder psiClassFinder) {
+        super(psiClassFinder);
+        this.staticMembers = staticMembers;
+        this.psiClass = psiClass;
+    }
+
+    @Override
+    @NotNull
+    protected MembersCache buildMembersCache() {
+        return MembersCache.buildMembersByNameCache(psiClassFinder, psiClass, null, staticMembers);
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/ClassPsiDeclarationProviderImpl.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.provider;
-
-import com.intellij.psi.PsiClass;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
-
-public class ClassPsiDeclarationProviderImpl extends PsiDeclarationProviderBase implements ClassPsiDeclarationProvider {
-    @NotNull
-    protected final PsiClassFinder psiClassFinder;
-
-    @NotNull
-    private final PsiClass psiClass;
-
-    private final boolean staticMembers;
-
-    public ClassPsiDeclarationProviderImpl(@NotNull PsiClass psiClass, boolean staticMembers, @NotNull PsiClassFinder psiClassFinder) {
-        this.staticMembers = staticMembers;
-        this.psiClass = psiClass;
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @Override
-    @NotNull
-    protected MembersCache buildMembersCache() {
-        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, psiClass, null, staticMembers);
-    }
-
-    @Override
-    @NotNull
-    public PsiClass getPsiClass() {
-        return psiClass;
-    }
-
-    @Override
-    public boolean isStaticMembers() {
-        return staticMembers;
-    }
-}

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

@@ -99,12 +99,13 @@ public final class MembersCache {
 
     @NotNull
     public static MembersCache buildMembersByNameCache(
-            @NotNull MembersCache membersCache,
             @NotNull PsiClassFinder finder,
             @Nullable PsiClass psiClass,
             @Nullable PsiPackage psiPackage,
             boolean staticMembers
     ) {
+        MembersCache membersCache = new MembersCache();
+
         if (psiClass != null) {
             membersCache.new ClassMemberProcessor(psiClass, staticMembers).process();
         }
@@ -112,6 +113,7 @@ public final class MembersCache {
         //TODO:
         List<PsiClass> classes = psiPackage != null ? finder.findPsiClasses(psiPackage) : finder.findInnerPsiClasses(psiClass);
         membersCache.new ExtraPackageMembersProcessor(classes).process();
+
         return membersCache;
     }
 

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

@@ -18,9 +18,20 @@ 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;
 
-public interface PackagePsiDeclarationProvider extends PsiDeclarationProvider {
+public final class PackagePsiDeclarationProvider extends PsiDeclarationProvider {
+    @NotNull
+    private final PsiPackage psiPackage;
+
+    public PackagePsiDeclarationProvider(@NotNull PsiPackage psiPackage, @NotNull PsiClassFinder psiClassFinder) {
+        super(psiClassFinder);
+        this.psiPackage = psiPackage;
+    }
 
     @NotNull
-    PsiPackage getPsiPackage();
+    @Override
+    protected MembersCache buildMembersCache() {
+        return MembersCache.buildMembersByNameCache(psiClassFinder, null, psiPackage, true);
+    }
 }

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

@@ -1,46 +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.provider;
-
-import com.intellij.psi.PsiPackage;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
-
-public final class PackagePsiDeclarationProviderImpl extends PsiDeclarationProviderBase implements PackagePsiDeclarationProvider {
-    @NotNull
-    private final PsiPackage psiPackage;
-
-    @NotNull
-    private final PsiClassFinder psiClassFinder;
-
-    public PackagePsiDeclarationProviderImpl(@NotNull PsiPackage psiPackage, @NotNull PsiClassFinder psiClassFinder) {
-        this.psiPackage = psiPackage;
-        this.psiClassFinder = psiClassFinder;
-    }
-
-    @NotNull
-    @Override
-    public PsiPackage getPsiPackage() {
-        return psiPackage;
-    }
-
-    @NotNull
-    @Override
-    protected MembersCache buildMembersCache() {
-        return MembersCache.buildMembersByNameCache(new MembersCache(), psiClassFinder, null, getPsiPackage(), true);
-    }
-}

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

@@ -17,9 +17,26 @@
 package org.jetbrains.jet.lang.resolve.java.provider;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 
-public interface PsiDeclarationProvider {
+public abstract class PsiDeclarationProvider {
+    @NotNull
+    protected final PsiClassFinder psiClassFinder;
+
+    private MembersCache membersCache;
+
+    protected PsiDeclarationProvider(@NotNull PsiClassFinder psiClassFinder) {
+        this.psiClassFinder = psiClassFinder;
+    }
 
     @NotNull
-    MembersCache getMembersCache();
+    public MembersCache getMembersCache() {
+        if (membersCache == null) {
+            membersCache = buildMembersCache();
+        }
+        return membersCache;
+    }
+
+    @NotNull
+    protected abstract MembersCache buildMembersCache();
 }

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

@@ -1,35 +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.provider;
-
-import org.jetbrains.annotations.NotNull;
-
-public abstract class PsiDeclarationProviderBase implements PsiDeclarationProvider {
-    private MembersCache membersCache = null;
-
-    @Override
-    @NotNull
-    public MembersCache getMembersCache() {
-        if (membersCache == null) {
-            membersCache = buildMembersCache();
-        }
-        return membersCache;
-    }
-
-    @NotNull
-    protected abstract MembersCache buildMembersCache();
-}

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

@@ -34,8 +34,6 @@ 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.ClassDescriptorFromJvmBytecode;
-import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
-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.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
@@ -275,12 +273,11 @@ public final class JavaClassResolver {
             @NotNull PostponedTasks taskList,
             @NotNull ClassOrNamespaceDescriptor containingDeclaration
     ) {
-        ClassKind kind = getClassKind(psiClass);
+        ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(containingDeclaration, getClassKind(psiClass),
-        ClassPsiDeclarationProvider classData = new ClassPsiDeclarationProviderImpl(psiClass, false, psiClassFinder);
+                                                                                            isInnerClass(psiClass));
-        ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(
-                containingDeclaration, kind, isInnerClass(psiClass));
 
         cache(javaClassToKotlinFqName(fqName), classDescriptor);
+
         classDescriptor.setName(Name.identifier(psiClass.getName()));
 
         List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
@@ -292,7 +289,9 @@ public final class JavaClassResolver {
         classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass));
         classDescriptor.setModality(resolveModality(psiClass, classDescriptor));
         classDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, classData, javaDescriptorResolver);
+
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, psiClass, false, psiClassFinder,
+                                                                                  javaDescriptorResolver);
         classDescriptor.setScopeForMemberLookup(scope);
         classDescriptor.setScopeForConstructorResolve(scope);
 
@@ -505,27 +504,21 @@ public final class JavaClassResolver {
     private ClassDescriptorFromJvmBytecode createSyntheticClassObject(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) {
         ClassDescriptorFromJvmBytecode classObjectDescriptor =
                 new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false);
-        ClassPsiDeclarationProvider provider = new ClassPsiDeclarationProviderImpl(psiClass, true, psiClassFinder);
-        setUpClassObjectDescriptor(classObjectDescriptor, containing, provider, getClassObjectName(containing.getName().asString()));
-        return classObjectDescriptor;
-    }
 
-    private void setUpClassObjectDescriptor(
+        classObjectDescriptor.setName(getClassObjectName(containing.getName()));
-            @NotNull ClassDescriptorFromJvmBytecode classObjectDescriptor,
-            @NotNull ClassDescriptor containing,
-            @NotNull ClassPsiDeclarationProvider data,
-            @NotNull Name classObjectName
-    ) {
-        classObjectDescriptor.setName(classObjectName);
         classObjectDescriptor.setModality(Modality.FINAL);
         classObjectDescriptor.setVisibility(containing.getVisibility());
         classObjectDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObjectDescriptor.createTypeConstructor();
-        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, javaDescriptorResolver);
+
+        JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, psiClass, true, psiClassFinder,
+                                                                                  javaDescriptorResolver);
         WritableScopeImpl writableScope =
                 new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope");
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
         classObjectDescriptor.setScopeForMemberLookup(writableScope);
         classObjectDescriptor.setScopeForConstructorResolve(scope);
+
+        return classObjectDescriptor;
     }
 }

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

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
-import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
@@ -68,13 +67,9 @@ public final class JavaConstructorResolver {
     }
 
     @NotNull
-    public Collection<ConstructorDescriptor> resolveConstructors(
+    public Collection<ConstructorDescriptor> resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor containingClass) {
-            @NotNull ClassPsiDeclarationProvider classData, @NotNull ClassDescriptor containingClass
-    ) {
         Collection<ConstructorDescriptor> constructors = Lists.newArrayList();
 
-        PsiClass psiClass = classData.getPsiClass();
-
         List<TypeParameterDescriptor> typeParameters = containingClass.getTypeConstructor().getParameters();
 
         TypeVariableResolver typeVariableResolver =

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

@@ -34,9 +34,8 @@ import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData;
-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;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -369,27 +368,26 @@ public final class JavaFunctionResolver {
     }
 
     @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroup(
+    public Set<FunctionDescriptor> resolveFunctionGroupForClass(
             @NotNull Name methodName,
-            @NotNull ClassPsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider provider,
-            @NotNull ClassOrNamespaceDescriptor ownerDescriptor
+            @NotNull ClassOrNamespaceDescriptor ownerDescriptor,
+            @NotNull PsiClass psiClass
     ) {
-
+        NamedMembers namedMembers = provider.getMembersCache().get(methodName);
-        NamedMembers namedMembers = scopeData.getMembersCache().get(methodName);
         if (namedMembers == null) {
             return Collections.emptySet();
         }
-        PsiClass psiClass = scopeData.getPsiClass();
         return resolveNamedGroupFunctions(ownerDescriptor, psiClass, namedMembers, methodName);
     }
 
     @NotNull
-    public Set<FunctionDescriptor> resolveFunctionGroup(
+    public Set<FunctionDescriptor> resolveFunctionGroupForPackage(
             @NotNull Name functionName,
-            @NotNull PackagePsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider provider,
             @NotNull NamespaceDescriptor ownerDescriptor
     ) {
-        NamedMembers namedMembers = scopeData.getMembersCache().get(functionName);
+        NamedMembers namedMembers = provider.getMembersCache().get(functionName);
         if (namedMembers != null) {
             SimpleFunctionDescriptor samConstructor = resolveSamConstructor(ownerDescriptor, namedMembers);
             if (samConstructor != null) {

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

@@ -20,12 +20,10 @@ import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 public final class JavaInnerClassResolver {
@@ -41,16 +39,7 @@ public final class JavaInnerClassResolver {
     }
 
     @NotNull
-    public List<ClassDescriptor> resolveInnerClasses(@NotNull ClassPsiDeclarationProvider declarationProvider) {
+    public List<ClassDescriptor> resolveInnerClasses(@NotNull PsiClass psiClass) {
-        if (declarationProvider.isStaticMembers()) {
-            return Collections.emptyList();
-        }
-
-        return resolveInnerClasses(declarationProvider.getPsiClass());
-    }
-
-    @NotNull
-    private List<ClassDescriptor> resolveInnerClasses(@NotNull PsiClass psiClass) {
         PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
         List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
         for (PsiClass innerPsiClass : innerPsiClasses) {

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

@@ -36,10 +36,7 @@ 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.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.JavaPackageScope;
@@ -190,8 +187,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 JavaPackageScope(namespaceDescriptor, psiPackage, fqName, javaDescriptorResolver, psiClassFinder);
-            return new JavaPackageScope(namespaceDescriptor, provider, fqName, javaDescriptorResolver, psiClassFinder);
         }
 
         PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
@@ -205,10 +201,7 @@ public final class JavaNamespaceResolver {
             return null;
         }
         trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.CLASS_STATICS);
-        return new JavaClassStaticMembersScope(
+        return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, psiClass, psiClassFinder, javaDescriptorResolver);
-                namespaceDescriptor,
-                new ClassPsiDeclarationProviderImpl(psiClass, true, psiClassFinder),
-                fqName, javaDescriptorResolver);
     }
 
     private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) {

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

@@ -70,10 +70,10 @@ public final class JavaPropertyResolver {
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name fieldName,
-            @NotNull PsiDeclarationProvider scopeData,
+            @NotNull PsiDeclarationProvider provider,
             @NotNull ClassOrNamespaceDescriptor ownerDescriptor
     ) {
-        NamedMembers namedMembers = scopeData.getMembersCache().get(fieldName);
+        NamedMembers namedMembers = provider.getMembersCache().get(fieldName);
         if (namedMembers == null) {
             return Collections.emptySet();
         }

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

@@ -27,9 +27,7 @@ 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.provider.ClassPsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers;
-import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
@@ -160,15 +158,7 @@ public abstract class JavaBaseScope extends JetScopeImpl {
 
     //TODO: remove this method
     @NotNull
-    public PsiElement getPsiElement() {
+    public abstract PsiElement getPsiElement();
-        if (declarationProvider instanceof ClassPsiDeclarationProvider) {
-            return ((ClassPsiDeclarationProvider) declarationProvider).getPsiClass();
-        }
-        if (declarationProvider instanceof PackagePsiDeclarationProvider) {
-            return ((PackagePsiDeclarationProvider) declarationProvider).getPsiPackage();
-        }
-        throw new IllegalStateException();
-    }
 
     @NotNull
     protected Collection<ClassDescriptor> getInnerClasses() {

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
+import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -31,16 +32,26 @@ import java.util.Set;
 public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
     protected final ClassPsiDeclarationProvider declarationProvider;
+    @NotNull
+    protected final PsiClass psiClass;
 
     private Map<Name, ClassDescriptor> innerClassesMap = null;
 
     protected JavaClassMembersScope(
             @NotNull ClassOrNamespaceDescriptor descriptor,
+            @NotNull PsiClass psiClass,
             @NotNull ClassPsiDeclarationProvider declarationProvider,
             @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
         super(descriptor, javaDescriptorResolver, declarationProvider);
         this.declarationProvider = declarationProvider;
+        this.psiClass = psiClass;
+    }
+
+    @NotNull
+    @Override
+    public PsiClass getPsiElement() {
+        return psiClass;
     }
 
     @NotNull
@@ -53,7 +64,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
     @NotNull
     @Override
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return javaDescriptorResolver.resolveFunctionGroup(name, declarationProvider, descriptor);
+        return javaDescriptorResolver.resolveFunctionGroupForClass(name, declarationProvider, descriptor, psiClass);
     }
 
     @NotNull
@@ -68,12 +79,6 @@ public abstract class JavaClassMembersScope extends JavaBaseScope {
         return innerClassesMap;
     }
 
-    @NotNull
-    @Override
-    protected Collection<ClassDescriptor> computeInnerClasses() {
-        return javaDescriptorResolver.resolveInnerClasses(declarationProvider);
-    }
-
     @Override
     public ClassDescriptor getObjectDescriptor(@NotNull Name name) {
         ClassDescriptor innerClass = getInnerClassesMap().get(name);

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

@@ -16,14 +16,17 @@
 
 package org.jetbrains.jet.lang.resolve.java.scope;
 
+import com.intellij.psi.PsiClass;
 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.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider;
 
 import java.util.Collection;
+import java.util.Collections;
 
 public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope {
 
@@ -31,14 +34,24 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
     private ConstructorDescriptor primaryConstructor = null;
     @NotNull
     private final ClassDescriptor descriptor;
+    @NotNull
+    private final PsiClass psiClass;
+    private final boolean staticMembersOfPsiClass;
 
     public JavaClassNonStaticMembersScope(
             @NotNull ClassDescriptor descriptor,
-            @NotNull ClassPsiDeclarationProvider psiDeclarationProvider,
+            @NotNull PsiClass psiClass,
+            boolean staticMembersOfPsiClass,
+            @NotNull PsiClassFinder psiClassFinder,
             @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, psiDeclarationProvider, javaDescriptorResolver);
+        super(descriptor,
+              psiClass,
+              new ClassPsiDeclarationProvider(psiClass, staticMembersOfPsiClass, psiClassFinder),
+              javaDescriptorResolver);
         this.descriptor = descriptor;
+        this.psiClass = psiClass;
+        this.staticMembersOfPsiClass = staticMembersOfPsiClass;
     }
 
 
@@ -56,7 +69,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
 
     private void initConstructorsIfNeeded() {
         if (constructors == null) {
-            constructors = javaDescriptorResolver.resolveConstructors(declarationProvider, descriptor);
+            constructors = javaDescriptorResolver.resolveConstructors(psiClass, descriptor);
 
             for (ConstructorDescriptor constructor : constructors) {
                 if (constructor.isPrimary()) {
@@ -69,4 +82,13 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope
             }
         }
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        if (staticMembersOfPsiClass) {
+            return Collections.emptyList();
+        }
+        return javaDescriptorResolver.resolveInnerClasses(psiClass);
+    }
 }

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

@@ -19,28 +19,35 @@ package org.jetbrains.jet.lang.resolve.java.scope;
 import com.intellij.psi.PsiClass;
 import com.intellij.util.containers.ContainerUtil;
 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.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 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;
 
 import java.util.Collection;
+import java.util.Collections;
 
 public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     @NotNull
     private final FqName packageFQN;
+    @NotNull
+    private final PsiClass psiClass;
 
     public JavaClassStaticMembersScope(
             @NotNull NamespaceDescriptor descriptor,
-            @NotNull ClassPsiDeclarationProvider declarationProvider,
             @NotNull FqName packageFQN,
+            @NotNull PsiClass psiClass,
+            @NotNull PsiClassFinder psiClassFinder,
             @NotNull JavaDescriptorResolver javaDescriptorResolver
     ) {
-        super(descriptor, declarationProvider, javaDescriptorResolver);
+        super(descriptor, psiClass, new ClassPsiDeclarationProvider(psiClass, true, psiClassFinder), javaDescriptorResolver);
         this.packageFQN = packageFQN;
+        this.psiClass = psiClass;
     }
 
     @Override
@@ -52,9 +59,15 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope {
     @Override
     protected Collection<DeclarationDescriptor> computeAllDescriptors() {
         Collection<DeclarationDescriptor> result = super.computeAllDescriptors();
-        for (PsiClass nested : declarationProvider.getPsiClass().getInnerClasses()) {
+        for (PsiClass nested : psiClass.getInnerClasses()) {
             ContainerUtil.addIfNotNull(result, getNamespace(Name.identifier(nested.getName())));
         }
         return result;
     }
+
+    @NotNull
+    @Override
+    protected Collection<ClassDescriptor> computeInnerClasses() {
+        return Collections.emptyList();
+    }
 }

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

@@ -33,6 +33,8 @@ import java.util.Collections;
 import java.util.Set;
 
 public final class JavaPackageScope extends JavaBaseScope {
+    @NotNull
+    private final PsiPackage psiPackage;
     @NotNull
     private final FqName packageFQN;
     @NotNull
@@ -40,16 +42,23 @@ public final class JavaPackageScope extends JavaBaseScope {
 
     public JavaPackageScope(
             @NotNull NamespaceDescriptor descriptor,
-            @NotNull PackagePsiDeclarationProvider declarationProvider,
+            @NotNull PsiPackage psiPackage,
             @NotNull FqName packageFQN,
             @NotNull JavaDescriptorResolver javaDescriptorResolver,
             @NotNull PsiClassFinder psiClassFinder
     ) {
-        super(descriptor, javaDescriptorResolver, declarationProvider);
+        super(descriptor, javaDescriptorResolver, new PackagePsiDeclarationProvider(psiPackage, psiClassFinder));
+        this.psiPackage = psiPackage;
         this.packageFQN = packageFQN;
         this.psiClassFinder = psiClassFinder;
     }
 
+    @Override
+    @NotNull
+    public PsiPackage getPsiElement() {
+        return psiPackage;
+    }
+
     @Override
     public ClassifierDescriptor getClassifier(@NotNull Name name) {
         ClassDescriptor classDescriptor =
@@ -87,8 +96,6 @@ public final class JavaPackageScope extends JavaBaseScope {
     private Collection<DeclarationDescriptor> computeAllPackageDeclarations() {
         Collection<DeclarationDescriptor> result = Sets.newHashSet();
 
-        PsiPackage psiPackage = ((PackagePsiDeclarationProvider) declarationProvider).getPsiPackage();
-
         for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) {
             FqName fqName = new FqName(psiSubPackage.getQualifiedName());
             NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
@@ -127,8 +134,7 @@ public final class JavaPackageScope extends JavaBaseScope {
     @Override
     @NotNull
     protected Set<FunctionDescriptor> computeFunctionDescriptor(@NotNull Name name) {
-        return javaDescriptorResolver.resolveFunctionGroup(name, (PackagePsiDeclarationProvider) declarationProvider,
+        return javaDescriptorResolver.resolveFunctionGroupForPackage(name, declarationProvider, (NamespaceDescriptor) descriptor);
-                                                           (NamespaceDescriptor) descriptor);
     }
 
     @NotNull