Fixing compilation errors to account for package fragment/view

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

@@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaClassResolver;
@@ -156,7 +155,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
                                 public JavaClass findClass(@NotNull FqName fqName) {
                                     // Do not look for JavaClasses for Kotlin binaries & built-ins
                                     if (kotlinClassesFromBinaries.invoke(fqName) != null
-                                        || kotlinNamespacesFromBinaries.invoke(fqName) != null
+                                        //|| kotlinNamespacesFromBinaries.invoke(fqName) != null
                                         || JavaClassResolver.getKotlinBuiltinClassDescriptor(fqName) != null) {
                                         return null;
                                     }

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

@@ -1,15 +1,15 @@
 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.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.JavaNamespaceResolver
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 
 public open class LazyJavaSubModule(
         private val outerContext: GlobalJavaResolverContext,
@@ -28,20 +28,16 @@ public open class LazyJavaSubModule(
             outerContext.javaDescriptorResolver
     )
 
-    private val _packageFragments: MemoizedFunctionToNullable<FqName, NamespaceDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {
+    private val _packageFragments: MemoizedFunctionToNullable<FqName, PackageFragmentDescriptor> = c.storageManager.createMemoizedFunctionWithNullableValues {
         fqName ->
         val jPackage = c.finder.findPackage(fqName)
         if (jPackage != null) {
-            val result = LazyPackageFragmentForJavaPackage(c, findParent(fqName), jPackage)
-            c.javaResolverCache.recordPackage(jPackage, result)
-            result
+            LazyPackageFragmentForJavaPackage(c, module, jPackage)
         }
         else {
             val jClass = c.finder.findClass(fqName)
-            if (jClass != null && JavaNamespaceResolver.hasStaticMembers(jClass)) {
-                val result = LazyPackageFragmentForJavaClass(c, findParent(fqName), jClass)
-                c.javaResolverCache.recordPackage(jClass, result)
-                result
+            if (jClass != null && DescriptorResolverUtils.isJavaClassVisibleAsPackage(jClass)) {
+                LazyPackageFragmentForJavaClass(c, module, jClass)
             }
             else null
         }
@@ -51,7 +47,7 @@ public open class LazyJavaSubModule(
             if (fqName.isRoot()) module else getPackageFragment(fqName.parent())
                             ?: throw IllegalStateException("Cannot resolve parent package for: $fqName")
 
-    fun getPackageFragment(fqName: FqName): NamespaceDescriptor? = _packageFragments(fqName)
+    fun getPackageFragment(fqName: FqName) = _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

@@ -172,7 +172,7 @@ public class LazyJavaClassMemberScope(
                 alreadyResolved
             else LazyJavaClassDescriptor(c,
                                     getContainingDeclaration(),
-                                    DescriptorUtils.getFQName(getContainingDeclaration()).child(name).toSafe(),
+                                    DescriptorUtils.getFqName(getContainingDeclaration()).child(name).toSafe(),
                                     jNestedClass)
         }
     }
@@ -189,7 +189,7 @@ public class LazyJavaClassMemberScope(
     }
 
     // namespaces should be resolved elsewhere
-    override fun getNamespace(name: Name): NamespaceDescriptor? = null
+    override fun getPackage(name: Name) = null
     override fun getAllPackageNames(): Collection<Name> = listOf()
 
     override fun toString() = "Lazy java member scope for " + jClass.getFqName()

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

@@ -6,7 +6,6 @@ import org.jetbrains.jet.lang.resolve.name.LabelName
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.utils.emptyList
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContextWithTypes
@@ -31,18 +30,15 @@ import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import java.util.LinkedHashSet
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver
-import org.jetbrains.jet.lang.resolve.java.lazy.types.toAttributes
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl
 import java.util.Collections
 import org.jetbrains.jet.utils.emptyOrSingletonList
-import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.annotations.TestOnly
-import org.jetbrains.jet.utils.Printer
 import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
 import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils
-import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl
 import org.jetbrains.jet.utils.Printer
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor
 
 public abstract class LazyJavaMemberScope(
         protected val c: LazyJavaResolverContextWithTypes,
@@ -83,9 +79,9 @@ public abstract class LazyJavaMemberScope(
                                   listOf(function).iterator()
                       }.toList())
 
-        if (_containingDeclaration is NamespaceDescriptor) {
-            val klass = JavaFunctionResolver.findClassInNamespace(_containingDeclaration, name);
-            if (klass != null && klass.getFunctionTypeForSamInterface() != null) {
+        if (_containingDeclaration is JavaPackageFragmentDescriptor) {
+            val klass = c.javaDescriptorResolver.resolveClass(_containingDeclaration.getFqName().child(name))
+            if (klass is LazyJavaClassDescriptor && klass.getFunctionTypeForSamInterface() != null) {
                 functions.add(SingleAbstractMethodUtils.createSamConstructorFunction(_containingDeclaration, klass))
             }
         }
@@ -128,7 +124,7 @@ public abstract class LazyJavaMemberScope(
         val signatureErrors: MutableList<String>
         val superFunctions: List<FunctionDescriptor>
         val effectiveSignature: ExternalSignatureResolver.AlternativeMethodSignature
-        if (_containingDeclaration is NamespaceDescriptor) {
+        if (_containingDeclaration is PackageFragmentDescriptor) {
             superFunctions = Collections.emptyList()
             effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters, methodTypeParameters)
             signatureErrors = effectiveSignature.getErrors()
@@ -284,7 +280,7 @@ public abstract class LazyJavaMemberScope(
         val result = LinkedHashSet<DeclarationDescriptor>()
 
         for (name in getAllPackageNames()) {
-            val descriptor = getNamespace(name)
+            val descriptor = getPackage(name)
             if (descriptor != null) {
                 // Null signifies that a package found in Java is not present in Kotlin
                 result.add(descriptor)

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

@@ -1,9 +1,5 @@
 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.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
@@ -12,23 +8,35 @@ 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
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorNonRootImpl
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor
+import org.jetbrains.jet.lang.types.TypeSubstitutor
+import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
 
 abstract class LazyJavaPackageFragment(
-        c: LazyJavaResolverContext,
-        containingDeclaration: NamespaceDescriptorParent,
+        private val c: LazyJavaResolverContext,
+        containingDeclaration: ModuleDescriptor,
         name: Name
-) : AbstractNamespaceDescriptorImpl(containingDeclaration, emptyList(), name), NamespaceDescriptor, LazyJavaDescriptor {
+) : DeclarationDescriptorNonRootImpl(containingDeclaration, listOf(), name), JavaPackageFragmentDescriptor, LazyJavaDescriptor {
 
     protected abstract val _memberScope: JetScope
 
     override fun getMemberScope() = _memberScope
 
+    override fun getJavaDescriptorResolver(): JavaDescriptorResolver = c.javaDescriptorResolver
+
+    override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D) = visitor.visitPackageFragmentDescriptor(this, data) as R
+
+    override fun substitute(substitutor: TypeSubstitutor) = this
+
     override fun toString() = "lazy java package fragment: " + getFqName()
 }
 
 public class LazyPackageFragmentForJavaPackage(
         c: LazyJavaResolverContext,
-        containingDeclaration: NamespaceDescriptorParent,
+        containingDeclaration: ModuleDescriptor,
         val jPackage: JavaPackage
 ) : LazyJavaPackageFragment(c, containingDeclaration, jPackage.getFqName().shortNameOrSpecial()) {
     override fun getFqName(): FqName = jPackage.getFqName()
@@ -38,7 +46,7 @@ public class LazyPackageFragmentForJavaPackage(
 
 public class LazyPackageFragmentForJavaClass(
         c: LazyJavaResolverContext,
-        containingDeclaration: NamespaceDescriptorParent,
+        containingDeclaration: ModuleDescriptor,
         val jClass: JavaClass
 ) : LazyJavaPackageFragment(c, containingDeclaration,
                             jClass.getFqName().sure("Attempt to build a package of an anonymous/local class: $jClass")

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

@@ -11,7 +11,6 @@ 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
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver
 import org.jetbrains.kotlin.util.inn
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule
 
@@ -20,7 +19,7 @@ public abstract class LazyJavaPackageFragmentScope(
         packageFragment: LazyJavaPackageFragment
 ) : LazyJavaMemberScope(c.withTypes(), packageFragment) {
     
-    protected val fqName: FqName = DescriptorUtils.getFQName(packageFragment).toSafe()
+    protected val fqName: FqName = DescriptorUtils.getFqName(packageFragment).toSafe()
     private val classes = c.storageManager.createMemoizedFunctionWithNullableValues<Name, ClassDescriptor> {
         name ->
         val fqName = fqName.child(name)
@@ -49,7 +48,8 @@ public abstract class LazyJavaPackageFragmentScope(
 
     override fun getClassifier(name: Name): ClassifierDescriptor? = classes(name)
 
-    override fun getNamespace(name: Name): NamespaceDescriptor? = c.javaDescriptorResolver.resolveNamespace(getContainingDeclaration().getFqName().child(name), DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES)
+    // Package fragments are not nested
+    override fun getPackage(name: Name) = null
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()