Rewrite Java resolve to use static class scope instead of synthesized packages

#KT-4149 Fixed
 #KT-4839 Fixed

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.kt

@@ -16,29 +16,16 @@
 
 package org.jetbrains.jet.lang.resolve.java
 
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.resolve.java.structure.*
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
-import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.resolve.java.structure.JavaField
-import org.jetbrains.jet.lang.resolve.java.structure.JavaMember
-import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
 import org.jetbrains.jet.lang.resolve.java.sources.JavaSourceElement
-import org.jetbrains.jet.lang.resolve.java.structure.JavaElement
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorWithSource
 
 public class JavaDescriptorResolver(public val packageFragmentProvider: LazyJavaPackageFragmentProvider, private val module: ModuleDescriptor) {
     public fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
         return packageFragmentProvider.getClass(javaClass)
     }
-
-    public fun getPackageFragment(javaClass: JavaClass): PackageFragmentDescriptor? {
-        return packageFragmentProvider.getPackageFragment(javaClass)
-    }
 }
 
 public fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): FunctionDescriptor? {
@@ -54,12 +41,12 @@ public fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescri
     return getContainingScope(field)?.getProperties(field.getName())?.findByJavaElement(field) as? PropertyDescriptor
 }
 
-private fun JavaDescriptorResolver.getContainingScope(method: JavaMember): JetScope? {
-    val containingClass = method.getContainingClass()
-    return if (method.isStatic())
-        getPackageFragment(containingClass)?.getMemberScope()
+private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): JetScope? {
+    val containingClass = resolveClass(member.getContainingClass())
+    return if (member.isStatic())
+        containingClass?.getStaticScope()
     else
-        resolveClass(containingClass)?.getDefaultType()?.getMemberScope()
+        containingClass?.getDefaultType()?.getMemberScope()
 }
 
 private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java

@@ -17,10 +17,8 @@
 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.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor;
 
 public class JavaVisibilities {
     private JavaVisibilities() {
@@ -61,20 +59,9 @@ public class JavaVisibilities {
             ClassDescriptor fromClass = DescriptorUtils.getParentOfType(from, ClassDescriptor.class, false);
             if (fromClass == null) return false;
 
-            ClassDescriptor whatClass;
-            // protected static class
-            if (what instanceof ClassDescriptor) {
-                DeclarationDescriptor containingDeclaration = what.getContainingDeclaration();
-                assert containingDeclaration instanceof ClassDescriptor : "Only static nested classes can have protected_static visibility";
-                whatClass = (ClassDescriptor) containingDeclaration;
-            }
-            // protected static function or property
-            else {
-                DeclarationDescriptor whatDeclarationDescriptor = what.getContainingDeclaration();
-                assert whatDeclarationDescriptor instanceof JavaClassStaticsPackageFragmentDescriptor
-                        : "Only static declarations can have protected_static visibility";
-                whatClass = ((JavaClassStaticsPackageFragmentDescriptor) whatDeclarationDescriptor).getCorrespondingClass();
-            }
+            DeclarationDescriptor containingDeclaration = what.getContainingDeclaration();
+            assert containingDeclaration instanceof ClassDescriptor : "Only class members can have protected_static visibility";
+            ClassDescriptor whatClass = (ClassDescriptor) containingDeclaration;
 
             if (DescriptorUtils.isSubclass(fromClass, whatClass)) {
                 return true;
@@ -134,18 +121,8 @@ public class JavaVisibilities {
     };
 
     private static boolean areInSamePackage(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
-        PackageFragmentDescriptor whatPackage = getPackageStaticsAware(first);
-        PackageFragmentDescriptor fromPackage = getPackageStaticsAware(second);
+        PackageFragmentDescriptor whatPackage = DescriptorUtils.getParentOfType(first, PackageFragmentDescriptor.class, false);
+        PackageFragmentDescriptor fromPackage = DescriptorUtils.getParentOfType(second, PackageFragmentDescriptor.class, false);
         return fromPackage != null && whatPackage != null && whatPackage.getFqName().equals(fromPackage.getFqName());
     }
-
-    @Nullable
-    private static PackageFragmentDescriptor getPackageStaticsAware(@NotNull DeclarationDescriptor member) {
-        PackageFragmentDescriptor packageFragment = DescriptorUtils.getParentOfType(member, PackageFragmentDescriptor.class, false);
-        if (packageFragment instanceof JavaClassStaticsPackageFragmentDescriptor) {
-            ClassDescriptor classForPackage = ((JavaClassStaticsPackageFragmentDescriptor) packageFragment).getCorrespondingClass();
-            return DescriptorUtils.getParentOfType(classForPackage, PackageFragmentDescriptor.class, false);
-        }
-        return packageFragment;
-    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaClassDescriptor.java

@@ -23,7 +23,4 @@ import org.jetbrains.jet.lang.types.JetType;
 public interface JavaClassDescriptor extends ClassDescriptor {
     @Nullable
     JetType getFunctionTypeForSamInterface();
-
-    @Nullable
-    JavaClassStaticsPackageFragmentDescriptor getCorrespondingPackageFragment();
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.kt

@@ -19,7 +19,3 @@ package org.jetbrains.jet.lang.resolve.java.descriptor
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 
 public trait JavaPackageFragmentDescriptor : PackageFragmentDescriptor
-
-public trait JavaClassStaticsPackageFragmentDescriptor : JavaPackageFragmentDescriptor {
-    public fun getCorrespondingClass(): JavaClassDescriptor
-}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -21,13 +21,9 @@ import org.jetbrains.jet.storage.MemoizedFunctionToNullable
 import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyPackageFragmentForJavaPackage
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyPackageFragmentForJavaClass
-import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
+import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.*
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaClassDescriptor
 
 public class LazyJavaPackageFragmentProvider(
         outerContext: GlobalJavaResolverContext,
@@ -53,20 +49,15 @@ public class LazyJavaPackageFragmentProvider(
 
     override fun getModule() = _module
 
-    private val _packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> = c.storageManager.createMemoizedFunctionWithNullableValues {
-        fqName ->
-        val jPackage = c.finder.findPackage(fqName)
-        if (jPackage != null) {
-            LazyPackageFragmentForJavaPackage(c, _module, jPackage)
-        }
-        else {
-            val jClass = c.findJavaClass(fqName)
-            if (jClass != null) {
-                packageFragmentsForClasses(jClass)
+    private val _packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
+            c.storageManager.createMemoizedFunctionWithNullableValues {
+                fqName ->
+                val jPackage = c.finder.findPackage(fqName)
+                if (jPackage != null) {
+                    LazyJavaPackageFragment(c, _module, jPackage)
+                }
+                else null
             }
-            else null
-        }
-    }
 
     private val topLevelClasses = c.storageManager.createMemoizedFunctionWithNullableValues @lambda {
         (jClass: JavaClass): LazyJavaClassDescriptor? ->
@@ -84,17 +75,7 @@ public class LazyJavaPackageFragmentProvider(
         )
     }
 
-    private val packageFragmentsForClasses: MemoizedFunctionToNullable<JavaClass, LazyPackageFragmentForJavaClass> = c.storageManager.createMemoizedFunctionWithNullableValues {
-        jClass ->
-        if (DescriptorResolverUtils.hasStaticMembers(jClass)) {
-            val correspondingClass = c.javaClassResolver.resolveClass(jClass)
-            if (correspondingClass != null) LazyPackageFragmentForJavaClass(c, _module, jClass) else null
-        }
-        else null
-    }
-
-    override fun getPackageFragment(fqName: FqName) = _packageFragments(fqName)
-    fun getPackageFragment(javaClass: JavaClass) = packageFragmentsForClasses(javaClass)
+    fun getPackageFragment(fqName: FqName) = _packageFragments(fqName)
 
     override fun getPackageFragments(fqName: FqName) = getPackageFragment(fqName)?.let {listOf(it)}.orEmpty()
 
@@ -120,4 +101,4 @@ public class LazyJavaPackageFragmentProvider(
             return outerClassScope?.getClassifier(javaClass.getName()) as? ClassDescriptor
         }
     }
-}
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt

@@ -16,16 +16,13 @@
 
 package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 
+import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor
 import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 import org.jetbrains.jet.lang.types.TypeConstructor
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
 import org.jetbrains.jet.lang.resolve.java.lazy.child
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage
@@ -36,18 +33,13 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.utils.*
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
-import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.jet.lang.types.TypeUtils
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor
-import org.jetbrains.jet.lang.descriptors.Modality
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
-import org.jetbrains.jet.lang.descriptors.ClassKind
 import java.util.ArrayList
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor
 import org.jetbrains.jet.lang.types.AbstractClassTypeConstructor
 import org.jetbrains.jet.lang.descriptors.impl.EnumClassObjectDescriptor
-import org.jetbrains.jet.lang.resolve.scopes.StaticScopeForKotlinClass
 
 class LazyJavaClassDescriptor(
         private val outerC: LazyJavaResolverContextWithTypes,
@@ -91,7 +83,8 @@ class LazyJavaClassDescriptor(
     private val _innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
     override fun getUnsubstitutedInnerClassesScope(): JetScope = _innerClassesScope
 
-    override fun getStaticScope(): JetScope = StaticScopeForKotlinClass(this) // TODO
+    private val _staticScope = LazyJavaStaticClassScope(c, jClass, this)
+    override fun getStaticScope(): JetScope = _staticScope
 
     override fun getUnsubstitutedPrimaryConstructor(): ConstructorDescriptor? = null
 
@@ -102,9 +95,6 @@ class LazyJavaClassDescriptor(
         else null
     }
 
-    override fun getCorrespondingPackageFragment() =
-            c.packageFragmentProvider.getPackageFragment(fqName) as? JavaClassStaticsPackageFragmentDescriptor
-
     override fun getClassObjectDescriptor(): ClassDescriptor? = _classObjectDescriptor()
     override fun getClassObjectType(): JetType? = getClassObjectDescriptor()?.let { d -> d.getDefaultType() }
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt

@@ -18,55 +18,21 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage
-import org.jetbrains.jet.lang.resolve.name.FqName
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
-import org.jetbrains.kotlin.util.sure
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.PackageFragmentDescriptorImpl
 import kotlin.properties.Delegates
 
-class LazyPackageFragmentForJavaPackage(
-        c: LazyJavaResolverContext,
-        containingDeclaration: ModuleDescriptor,
+class LazyJavaPackageFragment(
+        private val c: LazyJavaResolverContext,
+        module: ModuleDescriptor,
         private val jPackage: JavaPackage
-) : LazyJavaPackageFragment(c, containingDeclaration, jPackage.getFqName()) {
-    override fun createMemberScope() = LazyPackageFragmentScopeForJavaPackage(c, jPackage, this)
-}
-
-public class LazyPackageFragmentForJavaClass(
-        c: LazyJavaResolverContext,
-        containingDeclaration: ModuleDescriptor,
-        private val jClass: JavaClass
-) : JavaClassStaticsPackageFragmentDescriptor,
-    LazyJavaPackageFragment(c, containingDeclaration,
-                            jClass.getFqName().sure("Attempt to build a package of an anonymous/local class: $jClass")) {
-
-    override fun createMemberScope() = LazyPackageFragmentScopeForJavaClass(c, jClass, this)
-
-    override fun getCorrespondingClass(): JavaClassDescriptor {
-        val classDescriptor = c.javaClassResolver.resolveClass(jClass)
-        if (classDescriptor !is JavaClassDescriptor) {
-            throw AssertionError("Corresponding class not found for package with static members: $this")
-        }
-        return classDescriptor
-    }
-}
-
-abstract class LazyJavaPackageFragment(
-        protected val c: LazyJavaResolverContext,
-        containingDeclaration: ModuleDescriptor,
-        fqName: FqName
-) : PackageFragmentDescriptorImpl(containingDeclaration, fqName),
+) : PackageFragmentDescriptorImpl(module, jPackage.getFqName()),
     JavaPackageFragmentDescriptor, LazyJavaDescriptor
 {
-    private val _memberScope by Delegates.lazy { createMemberScope() }
+    private val _memberScope by Delegates.lazy { LazyPackageFragmentScopeForJavaPackage(c, jPackage, this) }
 
-    abstract fun createMemberScope(): LazyJavaPackageFragmentScope
+    override fun getMemberScope() = _memberScope
 
-    override fun getMemberScope(): LazyJavaPackageFragmentScope = _memberScope
-
-    override fun toString() = "lazy java package fragment: " + fqName
-}
+    override fun toString() = "lazy java package fragment: $fqName"
+}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt

@@ -28,7 +28,6 @@ import org.jetbrains.jet.utils.flatten
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.kotlin.util.inn
 import org.jetbrains.kotlin.util.sure
-import org.jetbrains.jet.lang.resolve.java.lazy.findJavaClass
 import org.jetbrains.jet.lang.resolve.java.lazy.findClassInJava
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
@@ -40,16 +39,16 @@ import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
 import org.jetbrains.jet.lang.resolve.name.SpecialNames
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 
-public abstract class LazyJavaPackageFragmentScope(
+public abstract class LazyJavaStaticScope(
         c: LazyJavaResolverContext,
-        packageFragment: LazyJavaPackageFragment
-) : LazyJavaMemberScope(c.withTypes(), packageFragment) {
+        descriptor: ClassOrPackageFragmentDescriptor
+) : LazyJavaMemberScope(c.withTypes(), descriptor) {
     
-    protected val fqName: FqName = DescriptorUtils.getFqName(packageFragment).toSafe()
+    protected val fqName: FqName = DescriptorUtils.getFqName(descriptor).toSafe()
 
     protected fun computeMemberIndexForSamConstructors(delegate: MemberIndex): MemberIndex = object : MemberIndex by delegate {
         override fun getAllMethodNames(): Collection<Name> {
-            val jClass = c.findJavaClass(fqName)
+            val jClass = c.findClassInJava(fqName).jClass
             return delegate.getAllMethodNames() +
                    // For SAM-constructors
                    getAllClassNames() +
@@ -76,11 +75,11 @@ public abstract class LazyJavaPackageFragmentScope(
         //no undeclared properties
     }
 
-    override fun getContainingDeclaration() = super.getContainingDeclaration() as LazyJavaPackageFragment
+    override fun getContainingDeclaration() = super.getContainingDeclaration() as ClassOrPackageFragmentDescriptor
 
     fun ClassifierDescriptor.createSamConstructor(): SamConstructorDescriptor? {
         if (this is LazyJavaClassDescriptor && this.getFunctionTypeForSamInterface() != null) {
-            return SingleAbstractMethodUtils.createSamConstructorFunction(this@LazyJavaPackageFragmentScope.getContainingDeclaration(), this)
+            return SingleAbstractMethodUtils.createSamConstructorFunction(this@LazyJavaStaticScope.getContainingDeclaration(), this)
         }
         return null
     }
@@ -89,8 +88,8 @@ public abstract class LazyJavaPackageFragmentScope(
 public class LazyPackageFragmentScopeForJavaPackage(
         c: LazyJavaResolverContext,
         private val jPackage: JavaPackage,
-        packageFragment: LazyPackageFragmentForJavaPackage
-) : LazyJavaPackageFragmentScope(c, packageFragment) {
+        packageFragment: LazyJavaPackageFragment
+) : LazyJavaStaticScope(c, packageFragment) {
 
     // TODO: Storing references is a temporary hack until modules infrastructure is implemented.
     // See JetTypeMapperWithOutDirectories for details
@@ -143,7 +142,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
                                     listOf(
                                         // We do not filter by hasStaticMembers() because it's slow (e.g. it triggers light class generation),
                                         // and there's no harm in having some names in the result that can not be resolved
-                                        jPackage.getClasses().map { c -> c.getFqName().sure("Toplevel class has no fqName: $c}") },
+                                        jPackage.getClasses().map { c -> c.getFqName().sure("Toplevel class has no fqName: $c") },
                                         jPackage.getSubPackages().map { sp -> sp.getFqName() }
                                     ).flatten()
                                 },
@@ -162,32 +161,30 @@ public class LazyPackageFragmentScopeForJavaPackage(
     override fun getAllPropertyNames() = Collections.emptyList<Name>()
 }
 
-public class LazyPackageFragmentScopeForJavaClass(
+public class LazyJavaStaticClassScope(
         c: LazyJavaResolverContext,
         private val jClass: JavaClass,
-        packageFragment: LazyPackageFragmentForJavaClass
-) : LazyJavaPackageFragmentScope(c, packageFragment) {
+        descriptor: LazyJavaClassDescriptor
+) : LazyJavaStaticScope(c, descriptor) {
 
     override fun computeMemberIndex(): MemberIndex = computeMemberIndexForSamConstructors(ClassMemberIndex(jClass, { m -> m.isStatic() }))
 
-    // nested classes are loaded as members of their outer classes, not packages
     override fun getAllClassNames(): Collection<Name> = listOf()
     override fun getClassifier(name: Name): ClassifierDescriptor? = null
 
     // We do not filter by hasStaticMembers() because it's slow (e.g. it triggers light class generation),
     // and there's no harm in having some names in the result that can not be resolved
     override fun getSubPackages(): Collection<FqName> = jClass.getInnerClasses().stream()
-                                                                .filter { c -> c.isStatic() }
-                                                                .map { c -> c.getFqName().sure("Nested class has no fqName: $c}") }.toList()
+            .filter { c -> c.isStatic() }
+            .map { c -> c.getFqName().sure("Nested class has no fqName: $c") }.toList()
 
     override fun computeNonDeclaredFunctions(result: MutableCollection<SimpleFunctionDescriptor>, name: Name) {
         //NOTE: assuming that all sam constructors are created for interfaces which are static and should be placed in this scope
-        val samConstructor = getContainingDeclaration().getCorrespondingClass().getUnsubstitutedInnerClassesScope().getClassifier(name)
-                ?.createSamConstructor()
+        val samConstructor = getContainingDeclaration().getUnsubstitutedInnerClassesScope().getClassifier(name)?.createSamConstructor()
         if (samConstructor != null) {
             result.add(samConstructor)
         }
     }
 
-    override fun getContainingDeclaration() = super.getContainingDeclaration() as LazyPackageFragmentForJavaClass
+    override fun getContainingDeclaration() = super.getContainingDeclaration() as LazyJavaClassDescriptor
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt

@@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaTypeParamete
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader
-import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.lang.resolve.resolveTopLevelClass
 
@@ -65,8 +64,6 @@ class LazyJavaTypeParameterResolver(
     }
 }
 
-fun LazyJavaResolverContext.findJavaClass(fqName: FqName): JavaClass? = findClassInJava(fqName).jClass
-
 data class JavaClassLookupResult(val jClass: JavaClass? = null, val kClass: ClassDescriptor? = null)
 
 fun LazyJavaResolverContext.lookupBinaryClass(javaClass: JavaClass): ClassDescriptor? {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java

@@ -23,16 +23,13 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
-import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils;
 import org.jetbrains.jet.lang.resolve.java.structure.*;
 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.TypeConstructor;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.TypeProjectionImpl;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.*;
 
@@ -262,29 +259,4 @@ public final class DescriptorResolverUtils {
         }
         return TypeSubstitutor.create(typeSubstitutionContext);
     }
-
-    public static boolean hasStaticMembers(@NotNull JavaClass javaClass) {
-        for (JavaMethod method : javaClass.getMethods()) {
-            if (method.isStatic() && !shouldBeInEnumClassObject(method)) {
-                return true;
-            }
-        }
-
-        for (JavaField field : javaClass.getFields()) {
-            if (field.isStatic() && !field.isEnumEntry()) {
-                return true;
-            }
-        }
-
-        for (JavaClass nestedClass : javaClass.getInnerClasses()) {
-            if (SingleAbstractMethodUtils.isSamInterface(nestedClass)) {
-                return true;
-            }
-            if (nestedClass.isStatic() && hasStaticMembers(nestedClass)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java

@@ -17,16 +17,10 @@
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface JavaPackageFragmentProvider extends PackageFragmentProvider {
-    @Nullable
-    JavaPackageFragmentDescriptor getPackageFragment(@NotNull FqName fqName);
-
     @NotNull
     ModuleDescriptor getModule();
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java

@@ -280,10 +280,6 @@ public class SingleAbstractMethodUtils {
         return new TypeParameters(typeParameters, typeParametersSubstitutor);
     }
 
-    public static boolean isSamInterface(@NotNull JavaClass javaClass) {
-        return getSamInterfaceMethod(javaClass) != null;
-    }
-
     // Returns null if not SAM interface
     @Nullable
     public static JavaMethod getSamInterfaceMethod(@NotNull JavaClass javaClass) {