Differentiate package fragments loaded from java packages and java (static) classes

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

@@ -2,11 +2,12 @@ package org.jetbrains.jet.lang.resolve.java.lazy
 
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor
-import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
 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
 
 public open class LazyJavaSubModule(
         private val outerContext: GlobalJavaResolverContext,
@@ -22,10 +23,23 @@ public open class LazyJavaSubModule(
 
     private val _packageFragments: MemoizedFunctionToNullable<FqName, NamespaceDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {
         fqName ->
-        val parent = if (fqName.isRoot()) module else getPackageFragment(fqName.parent()) ?: throw IllegalStateException("Cannot resolve parent package for: $fqName")
+        val jPackage = c.finder.findPackage(fqName)
-        LazyJavaPackageFragment(c, parent, fqName)
+        if (jPackage != null) {
+            LazyPackageFragmentForJavaPackage(c, findParent(fqName), jPackage)
+        }
+        else {
+            val jClass = c.finder.findClass(fqName)
+            if (jClass != null && (jClass.getOuterClass() == null || jClass.isStatic())) {
+                LazyPackageFragmentForJavaClass(c, findParent(fqName), jClass)
+            }
+            else null
+        }
     }
 
+    private fun findParent(fqName: FqName) =
+            if (fqName.isRoot()) module else getPackageFragment(fqName.parent())
+                            ?: throw IllegalStateException("Cannot resolve parent package for: $fqName")
+
     fun getPackageFragment(fqName: FqName): NamespaceDescriptor? = _packageFragments(fqName)
 
     fun getClass(fqName: FqName): ClassDescriptor? = c.javaClassResolver.resolveClassByFqName(fqName)

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

@@ -267,4 +267,8 @@ public class LazyJavaClassMemberScope(
     override fun getContainingDeclaration(): LazyJavaClassDescriptor {
         return super.getContainingDeclaration() as LazyJavaClassDescriptor
     }
+
+    // namespaces should be resolved elsewhere
+    override fun getNamespace(name: Name): NamespaceDescriptor? = null
+    override fun getAllPackageNames(): Collection<Name> = listOf()
 }

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

@@ -40,9 +40,6 @@ public abstract class LazyJavaMemberScope(
     override fun getObjectDescriptor(name: Name): ClassDescriptor? = null
     override fun getObjectDescriptors() = emptyList<ClassDescriptor>()
 
-    // namespaces should be resolved elsewhere
-    override fun getNamespace(name: Name): NamespaceDescriptor? = null
-
     override fun getLocalVariable(name: Name): VariableDescriptor? = null
     override fun getDeclarationsByLabel(labelName: LabelName) = emptyList<DeclarationDescriptor>()
 
@@ -52,10 +49,14 @@ public abstract class LazyJavaMemberScope(
     private fun computeAllDescriptors(): MutableCollection<DeclarationDescriptor> {
         val result = arrayListOf<DeclarationDescriptor>()
 
+        for (name in getAllPackageNames()) {
+            val descriptor = getNamespace(name)
+            result.add(descriptor ?: throw IllegalStateException("Descriptor not found for name $name in " + getContainingDeclaration()))
+        }
+
         for (name in getAllClassNames()) {
             val descriptor = getClassifier(name)
-            assert(descriptor != null) {"Descriptor not found for name " + name + " in " + getContainingDeclaration()}
+            result.add(descriptor ?: throw IllegalStateException("Descriptor not found for name $name in " + getContainingDeclaration()))
-            result.add(descriptor!!)
         }
 
         for (name in getAllFunctionNames()) {
@@ -71,6 +72,7 @@ public abstract class LazyJavaMemberScope(
         return result
     }
 
+    protected abstract fun getAllPackageNames(): Collection<Name>
     protected abstract fun getAllClassNames(): Collection<Name>
     protected abstract fun getAllPropertyNames(): Collection<Name>
     protected abstract fun getAllFunctionNames(): Collection<Name>

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

@@ -3,23 +3,46 @@ package org.jetbrains.jet.lang.resolve.java.lazy.descriptors
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl
 import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent
-import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.utils.emptyList
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage
+import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
+import org.jetbrains.kotlin.util.sure
 
-public class LazyJavaPackageFragment(
+abstract class LazyJavaPackageFragment(
         c: LazyJavaResolverContext,
         containingDeclaration: NamespaceDescriptorParent,
-        private val _fqName: FqName
+        name: Name
-) : AbstractNamespaceDescriptorImpl(
+) : AbstractNamespaceDescriptorImpl(containingDeclaration, emptyList(), name), NamespaceDescriptor, LazyJavaDescriptor {
-        containingDeclaration,
-        emptyList(),
-        if (_fqName.isRoot()) FqNameUnsafe.ROOT_NAME else _fqName.shortName()
-    ), NamespaceDescriptor, LazyJavaDescriptor {
 
-    private val _memberScope = LazyJavaPackageFragmentScope(c, this)
+    protected abstract val _memberScope: JetScope
 
     override fun getMemberScope() = _memberScope
-    override fun getFqName() = _fqName
+}
+
+public class LazyPackageFragmentForJavaPackage(
+        c: LazyJavaResolverContext,
+        containingDeclaration: NamespaceDescriptorParent,
+        val jPackage: JavaPackage
+) : LazyJavaPackageFragment(c, containingDeclaration, jPackage.getFqName().shortNameOrSpecial()) {
+    override fun getFqName(): FqName = jPackage.getFqName()
+
+    override val _memberScope = LazyPackageFragmentScopeForJavaPackage(c, jPackage, this)
+}
+
+public class LazyPackageFragmentForJavaClass(
+        c: LazyJavaResolverContext,
+        containingDeclaration: NamespaceDescriptorParent,
+        val jClass: JavaClass
+) : LazyJavaPackageFragment(c, containingDeclaration,
+                            jClass.getFqName().sure("Attempt to build a package of an anonymous/local class: $jClass")
+                                    .shortNameOrRoot()
+) {
+    override fun getFqName(): FqName = jClass.getFqName()!!
+
+    override val _memberScope = LazyPackageFragmentScopeForJavaClass(c, jClass, this)
 }

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

@@ -7,44 +7,80 @@ import java.util.Collections
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.lazy.withTypes
 import org.jetbrains.jet.lang.resolve.java.lazy.TypeParameterResolver
+import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.utils.flatten
+import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 
-public class LazyJavaPackageFragmentScope(
+public abstract class LazyJavaPackageFragmentScope(
         c: LazyJavaResolverContext,
-        containingDeclaration: NamespaceDescriptor
+        packageFragment: LazyJavaPackageFragment
-) : LazyJavaMemberScope(c.withTypes(), containingDeclaration) {
+) : LazyJavaMemberScope(c.withTypes(), packageFragment) {
     
-    private val fqName = DescriptorUtils.getFQName(containingDeclaration).toSafe()
+    protected val fqName: FqName = DescriptorUtils.getFQName(packageFragment).toSafe()
     private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
-                name ->
+        name ->
-                val fqName = fqName.child(name)
+        val fqName = fqName.child(name)
-                val javaClass = c.finder.findClass(fqName)
+        val javaClass = c.finder.findClass(fqName)
-                if (javaClass == null)
+        if (javaClass == null)
-                    null
+            null
-                else
+        else
-                    LazyJavaClassDescriptor(c.withTypes(TypeParameterResolver.EMPTY), containingDeclaration, fqName, javaClass)
+            LazyJavaClassDescriptor(c.withTypes(TypeParameterResolver.EMPTY), packageFragment, fqName, javaClass)
-            }
-
-    override fun getAllClassNames(): Collection<Name> {
-        val javaPackage = c.finder.findPackage(fqName)
-        assert(javaPackage != null) { "Package not found:  $fqName" }
-        return javaPackage!!.getClasses().map { c -> c.getName() }
     }
 
-    override fun getAllPropertyNames() = Collections.emptyList<Name>()
-    override fun getAllFunctionNames() = Collections.emptyList<Name>()
-    
     override fun addExtraDescriptors(result: MutableCollection<in DeclarationDescriptor>) {
         // no extra descriptors
     }
 
     override fun getClassifier(name: Name): ClassifierDescriptor? = classes(name)
 
-    // TODO
+    override fun getNamespace(name: Name): NamespaceDescriptor? = c.subModule.getPackageFragment(getContainingDeclaration().getFqName().child(name))
-    override fun getProperties(name: Name): Collection<VariableDescriptor> = Collections.emptyList()
-
-    // TODO
-    override fun getFunctions(name: Name): Collection<FunctionDescriptor> = Collections.emptyList()
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()
 
+    override fun getContainingDeclaration()= super.getContainingDeclaration() as LazyJavaPackageFragment
+}
+
+public class LazyPackageFragmentScopeForJavaPackage(
+        c: LazyJavaResolverContext,
+        private val jPackage: JavaPackage,
+        packageFragment: LazyJavaPackageFragment
+) : LazyJavaPackageFragmentScope(c, packageFragment) {
+
+    override fun getAllClassNames(): Collection<Name> {
+        val javaPackage = c.finder.findPackage(fqName)
+        assert(javaPackage != null) { "Package not found:  $fqName" }
+        return javaPackage!!.getClasses().map { c -> c.getName() }
+    }
+
+    override fun getAllPackageNames(): Collection<Name> =
+            listOf(
+                jPackage.getClasses().map { c -> c.getName() },
+                jPackage.getSubPackages().map { sp -> sp.getFqName().shortName() }
+            ).flatten()
+
+
+    override fun getProperties(name: Name): Collection<VariableDescriptor> = Collections.emptyList()
+    override fun getAllPropertyNames() = Collections.emptyList<Name>()
+
+    override fun getFunctions(name: Name): Collection<FunctionDescriptor> = Collections.emptyList()
+    override fun getAllFunctionNames() = Collections.emptyList<Name>()
+}
+
+public class LazyPackageFragmentScopeForJavaClass(
+        c: LazyJavaResolverContext,
+        private val jClass: JavaClass,
+        packageFragment: LazyJavaPackageFragment
+) : LazyJavaPackageFragmentScope(c, packageFragment) {
+
+    override fun getAllClassNames(): Collection<Name> = jClass.getInnerClasses().map { c -> c.getName() }
+    override fun getAllPackageNames(): Collection<Name> = jClass.getInnerClasses().filter { c -> c.isStatic() }.map { c -> c.getName() }
+
+    // TODO
+    override fun getProperties(name: Name): Collection<VariableDescriptor> = Collections.emptyList()
+    override fun getAllPropertyNames() = Collections.emptyList<Name>()
+
+    // TODO
+    override fun getFunctions(name: Name): Collection<FunctionDescriptor> = Collections.emptyList()
+    override fun getAllFunctionNames() = Collections.emptyList<Name>()
 }