Refactor KotlinClassLookupResult, make it sealed

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -77,8 +77,11 @@ public class LazyJavaPackageFragmentProvider(
             }
             val outerClass = javaClass.getOuterClass()
             if (outerClass == null) {
-                return c.resolveBinaryClass(c.kotlinClassFinder.findKotlinClass(javaClass))?.descriptor
+                val kotlinResult = c.resolveKotlinBinaryClass(c.kotlinClassFinder.findKotlinClass(javaClass))
-                       ?: topLevelClasses(javaClass)
+                return when (kotlinResult) {
+                    is KotlinClassLookupResult.Found -> kotlinResult.descriptor
+                    else -> topLevelClasses(javaClass)
+                }
             }
             val outerClassScope = resolveClass(outerClass)?.getUnsubstitutedInnerClassesScope()
             return outerClassScope?.getClassifier(javaClass.getName()) as? ClassDescriptor

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyPackageFragmentScopeForJavaPackage.kt

@@ -21,8 +21,9 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptorKindExclude
+import org.jetbrains.kotlin.load.java.lazy.KotlinClassLookupResult
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
-import org.jetbrains.kotlin.load.java.lazy.resolveBinaryClass
+import org.jetbrains.kotlin.load.java.lazy.resolveKotlinBinaryClass
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaPackage
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
@@ -44,14 +45,14 @@ public class LazyPackageFragmentScopeForJavaPackage(
     // TODO: Storing references is a temporary hack until modules infrastructure is implemented.
     // See JetTypeMapperWithOutDirectories for details
     public val kotlinBinaryClass: KotlinJvmBinaryClass?
-            = c.kotlinClassFinder.findKotlinClass(PackageClassUtils.getPackageClassId(this.packageFragment.fqName))
+            = c.kotlinClassFinder.findKotlinClass(PackageClassUtils.getPackageClassId(packageFragment.fqName))
 
     private val deserializedPackageScope = c.storageManager.createLazyValue {
         val kotlinBinaryClass = kotlinBinaryClass
         if (kotlinBinaryClass == null)
             JetScope.Empty
         else
-            c.deserializedDescriptorResolver.createKotlinPackageScope(this.packageFragment, kotlinBinaryClass) ?: JetScope.Empty
+            c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.Empty
     }
 
     private val packageFragment: LazyJavaPackageFragment get() = getContainingDeclaration() as LazyJavaPackageFragment
@@ -63,19 +64,19 @@ public class LazyPackageFragmentScopeForJavaPackage(
 
         val classId = ClassId(packageFragment.fqName, name)
 
-        val kotlinClass = c.resolveBinaryClass(c.kotlinClassFinder.findKotlinClass(classId))
+        val kotlinResult = c.resolveKotlinBinaryClass(c.kotlinClassFinder.findKotlinClass(classId))
-        if (kotlinClass != null) return kotlinClass.descriptor
+        return when (kotlinResult) {
-
+            is KotlinClassLookupResult.Found -> kotlinResult.descriptor
-        val javaClass = c.finder.findClass(classId)
+            is KotlinClassLookupResult.SyntheticClass -> null
-        if (javaClass != null) {
+            is KotlinClassLookupResult.NotFound -> {
-            val classDescriptor = c.javaClassResolver.resolveClass(javaClass)
+                val javaClass = c.finder.findClass(classId) ?: return null
-            assert(classDescriptor == null || classDescriptor.containingDeclaration == packageFragment) {
+                val classDescriptor = c.javaClassResolver.resolveClass(javaClass)
-                "Wrong package fragment for $classDescriptor, expected $packageFragment"
+                assert(classDescriptor == null || classDescriptor.containingDeclaration == packageFragment) {
+                    "Wrong package fragment for $classDescriptor, expected $packageFragment"
+                }
+                return classDescriptor
             }
-            return classDescriptor
         }
-
-        return null
     }
 
     override fun getClassifier(name: Name, location: UsageLocation): ClassifierDescriptor? = classes(name)

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/resolvers.kt

@@ -59,29 +59,28 @@ class LazyJavaTypeParameterResolver(
     }
 }
 
-data class KotlinClassLookupResult(val descriptor: ClassDescriptor?) {
+sealed class KotlinClassLookupResult {
-    companion object {
+    class Found(val descriptor: ClassDescriptor): KotlinClassLookupResult()
-        val EMPTY = KotlinClassLookupResult(null)
+    object NotFound : KotlinClassLookupResult()
-    }
+    object SyntheticClass : KotlinClassLookupResult()
 }
 
-fun LazyJavaResolverContext.resolveBinaryClass(kotlinClass: KotlinJvmBinaryClass?): KotlinClassLookupResult? {
+fun LazyJavaResolverContext.resolveKotlinBinaryClass(kotlinClass: KotlinJvmBinaryClass?): KotlinClassLookupResult {
-    if (kotlinClass == null) return null
+    if (kotlinClass == null) return KotlinClassLookupResult.NotFound
 
     val header = kotlinClass.classHeader
-    if (!header.isCompatibleAbiVersion) {
+    return when {
-        errorReporter.reportIncompatibleAbiVersion(kotlinClass.classId, kotlinClass.location, header.version)
+        !header.isCompatibleAbiVersion -> {
-    }
+            errorReporter.reportIncompatibleAbiVersion(kotlinClass.classId, kotlinClass.location, header.version)
-    else if (header.kind == KotlinClassHeader.Kind.CLASS) {
+            KotlinClassLookupResult.NotFound
-        val descriptor = deserializedDescriptorResolver.resolveClass(kotlinClass)
+        }
-        if (descriptor != null) {
+        header.kind == KotlinClassHeader.Kind.CLASS -> {
-            return KotlinClassLookupResult(descriptor)
+            val descriptor = deserializedDescriptorResolver.resolveClass(kotlinClass)
+            if (descriptor != null) KotlinClassLookupResult.Found(descriptor) else KotlinClassLookupResult.NotFound
+        }
+        else -> {
+            // This is a package or trait-impl or something like that
+            KotlinClassLookupResult.SyntheticClass
         }
     }
-    else {
-        // This is a package or trait-impl or something like that
-        return KotlinClassLookupResult.EMPTY
-    }
-
-    return null
 }