Do not call findKotlinClass when loading class annotations

The main change is in AbstractBinaryClassAnnotationAndConstantLoader, where we
no longer perform unnecessary IO operations for classes which are already
loaded to memory

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.load.java.components
 
-import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.name.ClassId
@@ -28,10 +27,7 @@ import org.jetbrains.kotlin.util.slicedMap.Slices
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 
 class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
-
     companion object {
-        private val LOG = Logger.getInstance(TraceBasedErrorReporter::class.java)
-
         @JvmField
         val METADATA_VERSION_ERRORS: WritableSlice<String, IncompatibleVersionErrorData> = Slices.createCollectiveSlice()
 
@@ -50,8 +46,4 @@ class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
     override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) {
         OverrideResolver.createCannotInferVisibilityReporter(trace).invoke(descriptor)
     }
-
-    override fun reportLoadingError(message: String, exception: Exception?) {
-        LOG.error(message, exception)
-    }
 }

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

@@ -38,8 +38,7 @@ import java.util.*
 
 abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any, T : Any>(
         storageManager: StorageManager,
-        private val kotlinClassFinder: KotlinClassFinder,
+        private val kotlinClassFinder: KotlinClassFinder
-        private val errorReporter: ErrorReporter
 ) : AnnotationAndConstantLoader<A, C, T> {
     private val storage = storageManager.createMemoizedFunction<KotlinJvmBinaryClass, Storage<A, C>> {
         kotlinClass ->
@@ -66,14 +65,11 @@ abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any,
         return loadAnnotation(annotationClassId, source, result)
     }
 
+    private fun ProtoContainer.Class.toBinaryClass(): KotlinJvmBinaryClass? =
+            (source as? KotlinJvmBinarySourceElement)?.binaryClass
+
     override fun loadClassAnnotations(container: ProtoContainer.Class): List<A> {
-        val kotlinClass = kotlinClassFinder.findKotlinClass(container.classId)
+        val kotlinClass = container.toBinaryClass() ?: error("Class for loading annotations is not found: ${container.debugFqName()}")
-        if (kotlinClass == null) {
-            // This means that the resource we're constructing the descriptor from is no longer present: KotlinClassFinder had found the
-            // class earlier, but it can't now
-            errorReporter.reportLoadingError("Kotlin class for loading class annotations is not found: ${container.debugFqName()}", null)
-            return listOf()
-        }
 
         val result = ArrayList<A>(1)
 
@@ -208,18 +204,28 @@ abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any,
     private fun findClassWithAnnotationsAndInitializers(
             container: ProtoContainer, implClassName: ClassId?, field: Boolean
     ): KotlinJvmBinaryClass? {
-        if (implClassName != null) {
-            return kotlinClassFinder.findKotlinClass(implClassName)
-        }
-
         if (container is ProtoContainer.Class) {
+            val containerBinaryClass = container.toBinaryClass()
+
+            if (implClassName == container.classId) {
+                return containerBinaryClass
+            }
+
+            if (implClassName != null) {
+                return kotlinClassFinder.findKotlinClass(implClassName)
+            }
+
             if (field && container.kind == ProtoBuf.Class.Kind.COMPANION_OBJECT &&
                 (container.outerClassKind == ClassKind.CLASS || container.outerClassKind == ClassKind.ENUM_CLASS)) {
                 // Backing fields of properties of a companion object in a class are generated in the outer class
                 return kotlinClassFinder.findKotlinClass(container.classId.outerClassId)
             }
 
-            return kotlinClassFinder.findKotlinClass(container.classId)
+            return containerBinaryClass
+        }
+
+        if (implClassName != null) {
+            return kotlinClassFinder.findKotlinClass(implClassName)
         }
 
         return null

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

@@ -30,7 +30,10 @@ import org.jetbrains.kotlin.resolve.constants.AnnotationValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.*
+import org.jetbrains.kotlin.serialization.deserialization.AnnotationDeserializer
+import org.jetbrains.kotlin.serialization.deserialization.NameResolver
+import org.jetbrains.kotlin.serialization.deserialization.NotFoundClasses
+import org.jetbrains.kotlin.serialization.deserialization.findNonGenericClassAcrossDependencies
 import org.jetbrains.kotlin.storage.StorageManager
 import java.util.*
 
@@ -38,10 +41,9 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
         private val module: ModuleDescriptor,
         private val notFoundClasses: NotFoundClasses,
         storageManager: StorageManager,
-        kotlinClassFinder: KotlinClassFinder,
+        kotlinClassFinder: KotlinClassFinder
-        errorReporter: ErrorReporter
 ) : AbstractBinaryClassAnnotationAndConstantLoader<AnnotationDescriptor, ConstantValue<*>, AnnotationWithTarget>(
-        storageManager, kotlinClassFinder, errorReporter
+        storageManager, kotlinClassFinder
 ) {
     private val annotationDeserializer = AnnotationDeserializer(module, notFoundClasses)
     private val factory = ConstantValueFactory(module.builtIns)

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

@@ -18,8 +18,9 @@ package org.jetbrains.kotlin.load.kotlin
 
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.SourceFile
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.BinarySource
 
-class KotlinJvmBinarySourceElement(val binaryClass: KotlinJvmBinaryClass) : SourceElement {
+class KotlinJvmBinarySourceElement(val binaryClass: KotlinJvmBinaryClass) : SourceElement, BinarySource {
     override fun toString() = javaClass.name + ": " + binaryClass.toString()
     override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeErrorReporter.kt

@@ -39,7 +39,4 @@ object RuntimeErrorReporter : ErrorReporter {
         throw IllegalStateException("Cannot infer visibility for $descriptor")
     }
 
-    override fun reportLoadingError(message: String, exception: Exception?) {
-        throw IllegalStateException(message, exception)
-    }
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -68,7 +68,7 @@ class RuntimeModuleData private constructor(val deserialization: Deserialization
             val javaClassDataFinder = JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver)
             val notFoundClasses = NotFoundClasses(storageManager, module)
             val binaryClassAnnotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(
-                    module, notFoundClasses, storageManager, reflectKotlinClassFinder, RuntimeErrorReporter
+                    module, notFoundClasses, storageManager, reflectKotlinClassFinder
             )
             val deserializationComponentsForJava = DeserializationComponentsForJava(
                     storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader,

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ErrorReporter.java

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.serialization.deserialization;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.name.ClassId;
@@ -31,8 +30,6 @@ public interface ErrorReporter {
 
     void reportCannotInferVisibility(@NotNull CallableMemberDescriptor descriptor);
 
-    void reportLoadingError(@NotNull String message, @Nullable Exception exception);
-
     ErrorReporter DO_NOTHING = new ErrorReporter() {
         @Override
         public void reportIncompatibleMetadataVersion(
@@ -47,9 +44,5 @@ public interface ErrorReporter {
         @Override
         public void reportCannotInferVisibility(@NotNull CallableMemberDescriptor descriptor) {
         }
-
-        @Override
-        public void reportLoadingError(@NotNull String message, @Nullable Exception exception) {
-        }
     };
 }

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoContainer.kt

@@ -25,14 +25,16 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.BinarySour
 
 sealed class ProtoContainer(
         val nameResolver: NameResolver,
-        val typeTable: TypeTable
+        val typeTable: TypeTable,
+        val source: BinarySource?
 ) {
     class Class(
             val classProto: ProtoBuf.Class,
             nameResolver: NameResolver,
             typeTable: TypeTable,
+            source: BinarySource?,
             val outerClassKind: ClassKind?
-    ) : ProtoContainer(nameResolver, typeTable) {
+    ) : ProtoContainer(nameResolver, typeTable, source) {
         val classId: ClassId = nameResolver.getClassId(classProto.fqName)
 
         val kind: ProtoBuf.Class.Kind = Flags.CLASS_KIND.get(classProto.flags) ?: ProtoBuf.Class.Kind.CLASS
@@ -45,8 +47,8 @@ sealed class ProtoContainer(
             val fqName: FqName,
             nameResolver: NameResolver,
             typeTable: TypeTable,
-            val source: BinarySource?
+            source: BinarySource?
-    ) : ProtoContainer(nameResolver, typeTable) {
+    ) : ProtoContainer(nameResolver, typeTable, source) {
         override fun debugFqName(): FqName = fqName
     }
 

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt

@@ -73,8 +73,9 @@ class DeserializedClassDescriptor(
     private val constructors = c.storageManager.createLazyValue { computeConstructors() }
     private val companionObjectDescriptor = c.storageManager.createNullableLazyValue { computeCompanionObjectDescriptor() }
 
-    internal val thisAsProtoContainer =
+    internal val thisAsProtoContainer = ProtoContainer.Class(
-            ProtoContainer.Class(classProto, c.nameResolver, c.typeTable, (containingDeclaration as? ClassDescriptor)?.kind)
+            classProto, c.nameResolver, c.typeTable, sourceElement as? BinarySource, (containingDeclaration as? ClassDescriptor)?.kind
+    )
 
     private val annotations =
             if (!Flags.HAS_ANNOTATIONS.get(classProto.flags)) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/builtIns/KotlinBuiltInStubBuilder.kt

@@ -57,7 +57,9 @@ class KotlinBuiltInStubBuilder : ClsStubBuilder() {
                         packageProto.functionList, packageProto.propertyList
                 )
                 for (classProto in file.classesToDecompile) {
-                    createClassStub(fileStub, classProto, nameResolver, nameResolver.getClassId(classProto.fqName), context)
+                    createClassStub(
+                            fileStub, classProto, nameResolver, nameResolver.getClassId(classProto.fqName), source = null, context = context
+                    )
                 }
                 return fileStub
             }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/classFile/DeserializerForClassfileDecompiler.kt

@@ -57,14 +57,13 @@ class DeserializerForClassfileDecompiler(
 
     init {
         val classDataFinder = DirectoryBasedDataFinder(classFinder, LOG)
-        val errorReporter = LoggingErrorReporter(LOG)
         val notFoundClasses = NotFoundClasses(storageManager, moduleDescriptor)
         val annotationAndConstantLoader =
-                BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, notFoundClasses, storageManager, classFinder, errorReporter)
+                BinaryClassAnnotationAndConstantLoaderImpl(moduleDescriptor, notFoundClasses, storageManager, classFinder)
 
         deserializationComponents = DeserializationComponents(
                 storageManager, moduleDescriptor, classDataFinder, annotationAndConstantLoader, packageFragmentProvider,
-                ResolveEverythingToKotlinAnyLocalClassResolver(targetPlatform.builtIns), errorReporter,
+                ResolveEverythingToKotlinAnyLocalClassResolver(targetPlatform.builtIns), LoggingErrorReporter(LOG),
                 LookupTracker.DO_NOTHING, JavaFlexibleTypeCapabilitiesDeserializer, ClassDescriptorFactory.EMPTY, notFoundClasses
         )
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/classFile/KotlinClsStubBuilder.kt

@@ -26,16 +26,15 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.idea.caches.IDEKotlinBinaryClassCache
 import org.jetbrains.kotlin.idea.decompiler.stubBuilder.*
-import org.jetbrains.kotlin.idea.decompiler.textBuilder.LoggingErrorReporter
 import org.jetbrains.kotlin.load.kotlin.AbstractBinaryClassAnnotationAndConstantLoader
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
@@ -55,9 +54,9 @@ open class KotlinClsStubBuilder : ClsStubBuilder() {
     }
 
     fun doBuildFileStub(file: VirtualFile): PsiFileStub<KtFile>? {
-        val kotlinClassHeaderInfo = IDEKotlinBinaryClassCache.getKotlinBinaryClassHeaderData(file)!!
+        val kotlinClass = IDEKotlinBinaryClassCache.getKotlinBinaryClass(file)!!
-        val header = kotlinClassHeaderInfo.classHeader
+        val header = kotlinClass.classHeader
-        val classId = kotlinClassHeaderInfo.classId
+        val classId = kotlinClass.classId
         val packageFqName = classId.packageFqName
         if (!header.metadataVersion.isCompatible()) {
             return createIncompatibleAbiVersionFileStub()
@@ -84,7 +83,7 @@ open class KotlinClsStubBuilder : ClsStubBuilder() {
                 if (classId.isLocal) return null
                 val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(annotationData, strings)
                 val context = components.createContext(nameResolver, packageFqName, TypeTable(classProto.typeTable))
-                createTopLevelClassStub(classId, classProto, context)
+                createTopLevelClassStub(classId, classProto, KotlinJvmBinarySourceElement(kotlinClass), context)
             }
             KotlinClassHeader.Kind.FILE_FACADE -> {
                 val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(annotationData, strings)
@@ -98,7 +97,7 @@ open class KotlinClsStubBuilder : ClsStubBuilder() {
     private fun createStubBuilderComponents(file: VirtualFile, packageFqName: FqName): ClsStubBuilderComponents {
         val classFinder = DirectoryBasedClassFinder(file.parent!!, packageFqName)
         val classDataFinder = DirectoryBasedDataFinder(classFinder, LOG)
-        val annotationLoader = AnnotationLoaderForClassFileStubBuilder(classFinder, LoggingErrorReporter(LOG))
+        val annotationLoader = AnnotationLoaderForClassFileStubBuilder(classFinder)
         return ClsStubBuilderComponents(classDataFinder, annotationLoader, file)
     }
 
@@ -108,10 +107,8 @@ open class KotlinClsStubBuilder : ClsStubBuilder() {
 }
 
 class AnnotationLoaderForClassFileStubBuilder(
-        kotlinClassFinder: KotlinClassFinder,
+        kotlinClassFinder: KotlinClassFinder
-        errorReporter: ErrorReporter
+) : AbstractBinaryClassAnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget>(LockBasedStorageManager.NO_LOCKS, kotlinClassFinder) {
-) : AbstractBinaryClassAnnotationAndConstantLoader<ClassId, Unit, ClassIdWithTarget>(
-        LockBasedStorageManager.NO_LOCKS, kotlinClassFinder, errorReporter) {
 
     override fun loadTypeAnnotation(proto: ProtoBuf.Annotation, nameResolver: NameResolver): ClassId =
             nameResolver.getClassId(proto.id)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptStubBuilder.kt

@@ -70,7 +70,7 @@ class KotlinJavaScriptStubBuilder : ClsStubBuilder() {
             val classProto = ProtoBuf.Class.parseFrom(content, JsSerializerProtocol.extensionRegistry)
             val context = components.createContext(nameResolver, packageFqName, TypeTable(classProto.typeTable))
             val classId = JsMetaFileUtils.getClassId(file)
-            return createTopLevelClassStub(classId, classProto, context)
+            return createTopLevelClassStub(classId, classProto, source = null, context = context)
         }
     }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt

@@ -37,15 +37,17 @@ import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.BinarySource
 
 fun createClassStub(
         parent: StubElement<out PsiElement>,
         classProto: ProtoBuf.Class,
         nameResolver: NameResolver,
         classId: ClassId,
+        source: BinarySource?,
         context: ClsStubBuilderContext
 ) {
-    ClassClsStubBuilder(parent, classProto, nameResolver, classId, context).build()
+    ClassClsStubBuilder(parent, classProto, nameResolver, classId, source, context).build()
 }
 
 private class ClassClsStubBuilder(
@@ -53,6 +55,7 @@ private class ClassClsStubBuilder(
         private val classProto: ProtoBuf.Class,
         private val nameResolver: NameResolver,
         private val classId: ClassId,
+        private val source: BinarySource?,
         private val outerContext: ClsStubBuilderContext
 ) {
     private val classKind = Flags.CLASS_KIND[classProto.flags]
@@ -73,8 +76,9 @@ private class ClassClsStubBuilder(
     private val companionObjectName =
             if (classProto.hasCompanionObjectName()) c.nameResolver.getName(classProto.companionObjectName) else null
 
-    private val thisAsProtoContainer =
+    private val thisAsProtoContainer = ProtoContainer.Class(
-            ProtoContainer.Class(classProto, c.nameResolver, c.typeTable, outerContext.classKind?.let { Deserialization.classKind(it) })
+            classProto, c.nameResolver, c.typeTable, source, outerContext.classKind?.let { Deserialization.classKind(it) }
+    )
 
     private val classOrObjectStub = createClassOrObjectStubAndModifierListStub()
 
@@ -249,7 +253,7 @@ private class ClassClsStubBuilder(
             return
         }
         val (nameResolver, classProto) = classDataWithSource.classData
-        createClassStub(classBody, classProto, nameResolver, nestedClassId, c)
+        createClassStub(classBody, classProto, nameResolver, nestedClassId, classDataWithSource.sourceElement as? BinarySource, c)
     }
 
     companion object {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt

@@ -40,11 +40,17 @@ import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.AnnotatedCallableKind
 import org.jetbrains.kotlin.serialization.deserialization.ProtoContainer
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.BinarySource
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 
-fun createTopLevelClassStub(classId: ClassId, classProto: ProtoBuf.Class, context: ClsStubBuilderContext): KotlinFileStubImpl {
+fun createTopLevelClassStub(
+        classId: ClassId,
+        classProto: ProtoBuf.Class,
+        source: BinarySource?,
+        context: ClsStubBuilderContext
+): KotlinFileStubImpl {
     val fileStub = createFileStub(classId.packageFqName)
-    createClassStub(fileStub, classProto, context.nameResolver, classId, context)
+    createClassStub(fileStub, classProto, context.nameResolver, classId, source, context)
     return fileStub
 }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/LoggingErrorReporter.kt

@@ -24,10 +24,6 @@ import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
 
 class LoggingErrorReporter(private val log: Logger) : ErrorReporter {
-    override fun reportLoadingError(message: String, exception: Exception?) {
-        log.error(message, exception)
-    }
-
     override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: List<String>) {
         // This is absolutely fine for the decompiler
     }