FIR: Optimize case with no annotations on package

build-common/src/org/jetbrains/kotlin/incremental/JavaClassDescriptorCreator.kt

@@ -117,7 +117,7 @@ private class BinaryJavaClassFinder(binaryJavaClasses: List<BinaryJavaClass>) :
         return nameToJavaClass[request.classId.asSingleFqName()]
     }
 
-    override fun findPackage(fqName: FqName): JavaPackage {
+    override fun findPackage(fqName: FqName, mayHaveAnnotations: Boolean): JavaPackage {
         return object : JavaPackage {
 
             override val fqName: FqName

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt

@@ -53,9 +53,16 @@ class FirJavaFacade(
 ) {
     companion object {
         val VALUE_METHOD_NAME = Name.identifier("value")
+        private const val PACKAGE_INFO_CLASS_NAME = "package-info"
     }
 
-    private val packageCache = session.firCachesFactory.createCache(classFinder::findPackage)
+    private val packageCache = session.firCachesFactory.createCache { fqName: FqName ->
+        val knownClassNames: Set<String>? = knownClassNamesInPackage.getValue(fqName)
+        classFinder.findPackage(
+            fqName,
+            mayHaveAnnotations = if (knownClassNames != null) PACKAGE_INFO_CLASS_NAME in knownClassNames else true
+        )
+    }
     private val knownClassNamesInPackage = session.firCachesFactory.createCache(classFinder::knownClassNamesInPackage)
 
     private val parentClassTypeParameterStackCache = mutableMapOf<FirRegularClassSymbol, JavaTypeParameterStack>()

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/JavaClassFinderImpl.kt

@@ -44,8 +44,8 @@ class JavaClassFinderImpl : AbstractJavaClassFinder() {
         return javaFacade.findClass(request, javaSearchScope)
     }
 
-    override fun findPackage(fqName: FqName): JavaPackage? {
-        return javaFacade.findPackage(fqName.asString(), javaSearchScope)?.let { JavaPackageImpl(it, javaSearchScope) }
+    override fun findPackage(fqName: FqName, mayHaveAnnotations: Boolean): JavaPackage? {
+        return javaFacade.findPackage(fqName.asString(), javaSearchScope)?.let { JavaPackageImpl(it, javaSearchScope, mayHaveAnnotations) }
     }
 
     override fun knownClassNamesInPackage(packageFqName: FqName): Set<String>? {

compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/components/JavacBasedClassFinder.kt

@@ -42,7 +42,7 @@ class JavacBasedClassFinder : AbstractJavaClassFinder() {
         // TODO: reuse previouslyFoundClassFileContent if it's possible in javac
         javac.findClass(request.classId, javaSearchScope)
 
-    override fun findPackage(fqName: FqName) = javac.findPackage(fqName, javaSearchScope)
+    override fun findPackage(fqName: FqName, mayHaveAnnotations: Boolean) = javac.findPackage(fqName, javaSearchScope)
 
     override fun knownClassNamesInPackage(packageFqName: FqName) = javac.knownClassNamesInPackage(packageFqName)
 }

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt

@@ -23,7 +23,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 class JavaPackageImpl(
-        psiPackage: PsiPackage, private val scope: GlobalSearchScope
+    psiPackage: PsiPackage, private val scope: GlobalSearchScope,
+    private val mayHaveAnnotations: Boolean = true,
 ) : JavaElementImpl<PsiPackage>(psiPackage), JavaPackage, MapBasedJavaAnnotationOwner {
 
     override fun getClasses(nameFilter: (Name) -> Boolean): Collection<JavaClass> {
@@ -41,7 +42,11 @@ class JavaPackageImpl(
         get() = FqName(psi.qualifiedName)
 
     override val annotations: Collection<JavaAnnotation>
-        get() = org.jetbrains.kotlin.load.java.structure.impl.annotations(psi.annotationList?.annotations.orEmpty())
+        get() =
+            if (mayHaveAnnotations)
+                org.jetbrains.kotlin.load.java.structure.impl.annotations(psi.annotationList?.annotations.orEmpty())
+            else
+                emptyList()
 
     override val annotationsByFqName: Map<FqName?, JavaAnnotation> by buildLazyValueForMap()
 }

core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JavaClassFinder.kt

@@ -21,7 +21,7 @@ interface JavaClassFinder {
     fun findClass(request: Request): JavaClass?
     fun findClass(classId: ClassId): JavaClass? = findClass(Request(classId))
 
-    fun findPackage(fqName: FqName): JavaPackage?
+    fun findPackage(fqName: FqName, mayHaveAnnotations: Boolean = true): JavaPackage?
 
     fun knownClassNamesInPackage(packageFqName: FqName): Set<String>?
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/components/ReflectJavaClassFinder.kt

@@ -36,7 +36,7 @@ class ReflectJavaClassFinder(private val classLoader: ClassLoader) : JavaClassFi
         return if (klass != null) ReflectJavaClass(klass) else null
     }
 
-    override fun findPackage(fqName: FqName): JavaPackage? {
+    override fun findPackage(fqName: FqName, mayHaveAnnotations: Boolean): JavaPackage? {
         // We don't know which packages our class loader has and has not, so we behave as if it contains any package in the world
         return ReflectJavaPackage(fqName)
     }