Names of subpackages and classes are computed in LazyJavaPackageFragmentProvider

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

@@ -10,7 +10,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyPackageFragmentF
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider
-import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragment
 import org.jetbrains.jet.lang.resolve.name.Name
 
 public open class LazyJavaPackageFragmentProvider(
@@ -34,7 +34,7 @@ public open class LazyJavaPackageFragmentProvider(
 
     override fun getJavaDescriptorResolver() = c.javaDescriptorResolver
 
-    private val _packageFragments: MemoizedFunctionToNullable<FqName, JavaPackageFragmentDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {
+    private val _packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> = c.storageManager.createMemoizedFunctionWithNullableValues {
         fqName ->
         val jPackage = c.finder.findPackage(fqName)
         if (jPackage != null) {
@@ -52,8 +52,10 @@ public open class LazyJavaPackageFragmentProvider(
     override fun getPackageFragment(fqName: FqName) = _packageFragments(fqName)
     override fun getPackageFragments(fqName: FqName) = getPackageFragment(fqName)?.let {listOf(it)} ?: listOf()
 
-    override fun getSubPackagesOf(fqName: FqName) = listOf<FqName>() // TODO
-    override fun getClassNamesInPackage(packageName: FqName) = listOf<Name>() // TODO
+    override fun getSubPackagesOf(fqName: FqName) = getPackageFragment(fqName)?.getMemberScope()?.getSubPackages()
+                                                                        ?: listOf<FqName>()
+    override fun getClassNamesInPackage(packageName: FqName) = getPackageFragment(packageName)?.getMemberScope()?.getAllClassNames()
+                                                                    ?: listOf<Name>()
 
     fun getClass(fqName: FqName): ClassDescriptor? = c.javaClassResolver.resolveClassByFqName(fqName)
 

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

@@ -36,12 +36,12 @@ class LazyJavaPackageFragment(
         containingDeclaration: ModuleDescriptor,
         val _kind: JavaPackageFragmentDescriptor.Kind,
         val _fqName: FqName,
-        createMemberScope: LazyJavaPackageFragment.() -> JetScope
+        createMemberScope: LazyJavaPackageFragment.() -> LazyJavaPackageFragmentScope
 ) : DeclarationDescriptorNonRootImpl(containingDeclaration, listOf(), _fqName.shortNameOrSpecial()),
     JavaPackageFragmentDescriptor, LazyJavaDescriptor
 {
     private val _memberScope = createMemberScope()
-    override fun getMemberScope() = _memberScope
+    override fun getMemberScope(): LazyJavaPackageFragmentScope = _memberScope
 
     override fun getKind() = _kind
     override fun getFqName() = _fqName

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

@@ -13,6 +13,7 @@ import org.jetbrains.jet.utils.flatten
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.kotlin.util.inn
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule
+import org.jetbrains.kotlin.util.sure
 
 public abstract class LazyJavaPackageFragmentScope(
         c: LazyJavaResolverContext,
@@ -47,9 +48,12 @@ public abstract class LazyJavaPackageFragmentScope(
     }
 
     override fun getClassifier(name: Name): ClassifierDescriptor? = classes(name)
+    public abstract override fun getAllClassNames(): Collection<Name>
 
     // Package fragments are not nested
     override fun getPackage(name: Name) = null
+    final override fun getAllPackageNames() = listOf<Name>()
+    abstract fun getSubPackages(): Collection<FqName>
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()
 
@@ -70,12 +74,12 @@ public class LazyPackageFragmentScopeForJavaPackage(
                 .map { c -> c.getName() }.toList()
     }
 
-    override fun getAllPackageNames(): Collection<Name> =
+    override fun getSubPackages(): Collection<FqName> =
             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.getName() },
-                jPackage.getSubPackages().map { sp -> sp.getFqName().shortName() }
+                jPackage.getClasses().map { c -> c.getFqName().sure("Toplevel class has no fqName: $c}") },
+                jPackage.getSubPackages().map { sp -> sp.getFqName() }
             ).flatten()
 
 
@@ -97,7 +101,7 @@ public class LazyPackageFragmentScopeForJavaClass(
 
     // 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 getAllPackageNames(): Collection<Name> = jClass.getInnerClasses().iterator()
+    override fun getSubPackages(): Collection<FqName> = jClass.getInnerClasses().iterator()
                                                                 .filter { c -> c.isStatic() }
-                                                                .map { c -> c.getName() }.toList()
+                                                                .map { c -> c.getFqName().sure("Nested class has no fqName: $c}") }.toList()
 }