Added deprecated PackageFragmentProvider#getPackageFragments for BWC

Relates to ^KT-33394
^KT-42259 Fixed

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -42,24 +42,28 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.keysToMap
 
 class IncrementalPackageFragmentProvider(
-        sourceFiles: Collection<KtFile>,
+    sourceFiles: Collection<KtFile>,
-        val moduleDescriptor: ModuleDescriptor,
+    val moduleDescriptor: ModuleDescriptor,
-        val storageManager: StorageManager,
+    val storageManager: StorageManager,
-        val deserializationComponents: DeserializationComponents,
+    val deserializationComponents: DeserializationComponents,
-        val incrementalCache: IncrementalCache,
+    val incrementalCache: IncrementalCache,
-        val target: TargetId,
+    val target: TargetId,
-        private val kotlinClassFinder: KotlinClassFinder
+    private val kotlinClassFinder: KotlinClassFinder
 ) : PackageFragmentProvider {
     private val fqNameToPackageFragment =
-            PackagePartClassUtils.getFilesWithCallables(sourceFiles)
+        PackagePartClassUtils.getFilesWithCallables(sourceFiles)
-                    .mapTo(hashSetOf()) { it.packageFqName }
+            .mapTo(hashSetOf()) { it.packageFqName }
-                    .keysToMap(this::IncrementalPackageFragment)
+            .keysToMap(this::IncrementalPackageFragment)
 
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> = emptySet()
 
     override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) =
         packageFragments.addIfNotNull(fqNameToPackageFragment[fqName])
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+        return listOfNotNull(fqNameToPackageFragment[fqName])
+    }
+
     inner class IncrementalPackageFragment(fqName: FqName) : PackageFragmentDescriptorImpl(moduleDescriptor, fqName) {
         val target: TargetId
             get() = this@IncrementalPackageFragmentProvider.target
@@ -74,34 +78,34 @@ class IncrementalPackageFragmentProvider(
     }
 
     inner class IncrementalMultifileClassPackageFragment(
-            val facadeName: JvmClassName,
+        val facadeName: JvmClassName,
-            val partsInternalNames: Collection<String>,
+        val partsInternalNames: Collection<String>,
-            packageFqName: FqName
+        packageFqName: FqName
     ) : PackageFragmentDescriptorImpl(moduleDescriptor, packageFqName) {
         private val memberScope = storageManager.createLazyValue {
             ChainedMemberScope.create(
-                    "Member scope for incremental compilation: union of multifile class parts data for $facadeName",
+                "Member scope for incremental compilation: union of multifile class parts data for $facadeName",
-                    partsInternalNames.mapNotNull { internalName ->
+                partsInternalNames.mapNotNull { internalName ->
-                        incrementalCache.getPackagePartData(internalName)?.let { (data, strings) ->
+                    incrementalCache.getPackagePartData(internalName)?.let { (data, strings) ->
-                            val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(data, strings)
+                        val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(data, strings)
 
-                            val partName = JvmClassName.byInternalName(internalName)
+                        val partName = JvmClassName.byInternalName(internalName)
-                            val jvmBinaryClass =
+                        val jvmBinaryClass =
-                                    kotlinClassFinder.findKotlinClass(ClassId.topLevel(partName.fqNameForTopLevelClassMaybeWithDollars))
+                            kotlinClassFinder.findKotlinClass(ClassId.topLevel(partName.fqNameForTopLevelClassMaybeWithDollars))
 
-                            val metadataVersion =
+                        val metadataVersion =
-                                jvmBinaryClass?.classHeader?.metadataVersion
+                            jvmBinaryClass?.classHeader?.metadataVersion
                                 ?: JvmMetadataVersion.INSTANCE
 
-                            DeserializedPackageMemberScope(
+                        DeserializedPackageMemberScope(
-                                this, packageProto, nameResolver, metadataVersion,
+                            this, packageProto, nameResolver, metadataVersion,
-                                JvmPackagePartSource(
+                            JvmPackagePartSource(
-                                            partName, facadeName, packageProto, nameResolver, knownJvmBinaryClass = jvmBinaryClass
+                                partName, facadeName, packageProto, nameResolver, knownJvmBinaryClass = jvmBinaryClass
-                                    ),
+                            ),
-                                deserializationComponents, classNames = { emptyList() }
+                            deserializationComponents, classNames = { emptyList() }
-                            )
+                        )
-                        }
                     }
+                }
             )
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/multiplatform/OptionalAnnotationPackageFragmentProvider.kt

@@ -83,6 +83,9 @@ class OptionalAnnotationPackageFragmentProvider(
     override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) =
         packageFragments.addIfNotNull(packages[fqName])
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> =
+        packages[fqName]?.let(::listOf).orEmpty()
+
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> =
         emptyList()
 }

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt

@@ -241,6 +241,12 @@ private class DelegatingPackageFragmentProvider<M : ModuleInfo>(
 ) : PackageFragmentProvider {
     private val syntheticFilePackages = moduleContent.syntheticFiles.map { it.packageFqName }.toSet()
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+        if (certainlyDoesNotExist(fqName)) return emptyList()
+
+        return resolverForProject.resolverForModuleDescriptor(module).packageFragmentProvider.getPackageFragments(fqName)
+    }
+
     override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) {
         if (certainlyDoesNotExist(fqName)) return
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt

@@ -83,7 +83,7 @@ class DescriptorByIdSignatureFinder(
             LookupMode.MODULE_ONLY -> {
                 (moduleDescriptor as ModuleDescriptorImpl)
                     .packageFragmentProviderForModuleContentWithoutDependencies
-                    .getPackageFragments(packageFqName)
+                    .packageFragments(packageFqName)
                     .flatMap { it.getMemberScope().loadDescriptors(declarationName, isLeaf) }
             }
         }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/metadata/KlibMetadataMonolithicSerializer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.common.serialization.metadata
 
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.library.SerializedMetadata
 import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf
 import org.jetbrains.kotlin.metadata.ProtoBuf
@@ -28,7 +29,7 @@ class KlibMetadataMonolithicSerializer(
     private fun serializePackageFragment(fqName: FqName, module: ModuleDescriptor): List<ProtoBuf.PackageFragment> {
 
         val fragments = if (includeOnlyModuleContent) {
-            module.packageFragmentProviderForModuleContentWithoutDependencies.getPackageFragments(fqName)
+            module.packageFragmentProviderForModuleContentWithoutDependencies.packageFragments(fqName)
         } else {
             module.getPackage(fqName).fragments.filter { it.module == module }
         }

compiler/tests-common/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.builtins.StandardNames.COLLECTIONS_PACKAGE_FQ_NAME
 import org.jetbrains.kotlin.builtins.StandardNames.RANGES_PACKAGE_FQ_NAME
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
@@ -36,7 +37,7 @@ abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment()
         val module = JvmResolveUtil.analyze(environment).moduleDescriptor as ModuleDescriptorImpl
 
         for (packageFqName in listOf(BUILT_INS_PACKAGE_FQ_NAME, COLLECTIONS_PACKAGE_FQ_NAME, RANGES_PACKAGE_FQ_NAME)) {
-            val loaded = module.packageFragmentProvider.getPackageFragments(packageFqName)
+            val loaded = module.packageFragmentProvider.packageFragments(packageFqName)
                 .filterIsInstance<BuiltInsPackageFragment>()
                 .single { !it.isFallback }
             RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile(

compiler/tests/org/jetbrains/kotlin/serialization/NonStableParameterNamesSerializationTest.kt

@@ -78,7 +78,7 @@ class NonStableParameterNamesSerializationTest : TestCaseWithTmpdir() {
 
             fun recurse(packageFqName: FqName) {
                 packageFragmentProvider
-                    .getPackageFragments(packageFqName)
+                    .packageFragments(packageFqName)
                     .forEach { packageFragment ->
                         recurse(packageFragment.getMemberScope())
                     }

compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
+import org.jetbrains.kotlin.descriptors.PackageFragmentProviderKt;
 import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider;
 import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentDeclarationFilter;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -59,7 +60,7 @@ public class LoadBuiltinsTest extends KotlinTestWithEnvironment {
                     CollectionsKt.single(module.getPackage(packageFqName).getFragments());
             if (fromLazyResolve instanceof LazyPackageDescriptor) {
                 PackageFragmentDescriptor deserialized =
-                        CollectionsKt.single(packageFragmentProvider.getPackageFragments(packageFqName));
+                        CollectionsKt.single(PackageFragmentProviderKt.packageFragments(packageFragmentProvider, packageFqName));
                 RecursiveDescriptorComparator.validateAndCompareDescriptors(
                         fromLazyResolve, deserialized, AbstractBuiltInsWithJDKMembersTest.createComparatorConfiguration(),
                         new File("compiler/testData/builtin-classes/default/" + packageFqName.asString().replace('.', '-') + ".txt")

core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentProvider.kt

@@ -20,20 +20,27 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 interface PackageFragmentProvider {
-    fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>)
+    fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) {
-
+        // default implementation is provided only for BWC
-    fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+        packageFragments.addAll(getPackageFragments(fqName))
-        val packageFragments = mutableListOf<PackageFragmentDescriptor>()
-        collectPackageFragments(fqName, packageFragments)
-        return packageFragments
     }
 
-    fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName>
+    @Deprecated("for usages use #packageFragments(FqName) at final point, for impl use #collectPackageFragments(FqName, MutableCollection<PackageFragmentDescriptor>)")
+    fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor>
 
+    fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName>
 
     object Empty : PackageFragmentProvider {
         override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) {}
 
+        override fun getPackageFragments(fqName: FqName) = emptyList<PackageFragmentDescriptor>()
+
         override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean) = emptySet<FqName>()
     }
 }
+
+fun PackageFragmentProvider.packageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+    val packageFragments = mutableListOf<PackageFragmentDescriptor>()
+    collectPackageFragments(fqName, packageFragments)
+    return packageFragments
+}

core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFragmentProviderImpl.kt

@@ -26,6 +26,9 @@ class PackageFragmentProviderImpl(
         this.packageFragments.filterTo(packageFragments) { it.fqName == fqName }
     }
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> =
+        packageFragments.filter { it.fqName == fqName }
+
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> =
         packageFragments.asSequence()
             .map { it.fqName }

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/CompositePackageFragmentProvider.kt

@@ -32,6 +32,14 @@ class CompositePackageFragmentProvider(// can be modified from outside
         }
     }
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+        val result = ArrayList<PackageFragmentDescriptor>()
+        for (provider in providers) {
+            provider.collectPackageFragments(fqName, result)
+        }
+        return result.toList()
+    }
+
     override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) {
         for (provider in providers) {
             provider.collectPackageFragments(fqName, packageFragments)

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazyPackageViewDescriptorImpl.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptorVisitor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.scopes.ChainedMemberScope
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter
@@ -34,7 +35,7 @@ class LazyPackageViewDescriptorImpl(
 ) : DeclarationDescriptorImpl(Annotations.EMPTY, fqName.shortNameOrSpecial()), PackageViewDescriptor {
 
     override val fragments: List<PackageFragmentDescriptor> by storageManager.createLazyValue {
-        module.packageFragmentProvider.getPackageFragments(fqName)
+        module.packageFragmentProvider.packageFragments(fqName)
     }
 
     override val memberScope: MemberScope = LazyScopeAdapter(storageManager) {

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

@@ -43,5 +43,7 @@ abstract class AbstractDeserializedPackageFragmentProvider(
         packageFragments.addIfNotNull(fragments(fqName))
     }
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> = listOfNotNull(fragments(fqName))
+
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> = emptySet()
 }

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.metadata.deserialization.TypeTable
 import org.jetbrains.kotlin.metadata.deserialization.VersionRequirementTable
 import org.jetbrains.kotlin.name.ClassId
@@ -52,7 +53,7 @@ class ClassDeserializer(private val components: DeserializationComponents) {
 
             outerClass.c
         } else {
-            val fragments = components.packageFragmentProvider.getPackageFragments(classId.packageFqName)
+            val fragments = components.packageFragmentProvider.packageFragments(classId.packageFqName)
             val fragment = fragments.firstOrNull { it !is DeserializedPackageFragment || it.hasTopLevelClass(classId.shortClassName) }
                 ?: return null
 

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

@@ -17,11 +17,12 @@
 package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.name.ClassId
 
 class DeserializedClassDataFinder(private val packageFragmentProvider: PackageFragmentProvider) : ClassDataFinder {
     override fun findClassData(classId: ClassId): ClassData? {
-        val packageFragments = packageFragmentProvider.getPackageFragments(classId.packageFqName)
+        val packageFragments = packageFragmentProvider.packageFragments(classId.packageFqName)
         for (fragment in packageFragments) {
             if (fragment !is DeserializedPackageFragment) continue
 

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

@@ -33,6 +33,10 @@ abstract class DeserializerForDecompilerBase(val directoryPackageFqName: FqName)
             packageFragments.add(createDummyPackageFragment(fqName))
         }
 
+        override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
+            return listOf(createDummyPackageFragment(fqName))
+        }
+
         override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> {
             throw UnsupportedOperationException("This method is not supposed to be called.")
         }

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -314,7 +314,7 @@ fun Map<FqName, ByteArray>.missingMetadata(
 
         val fragment = KotlinJavascriptSerializationUtil.serializeDescriptors(
             bindingContext, moduleDescriptor,
-            moduleDescriptor.packageFragmentProviderForModuleContentWithoutDependencies.getPackageFragments(fqName).flatMap {
+            moduleDescriptor.packageFragmentProviderForModuleContentWithoutDependencies.packageFragments(fqName).flatMap {
                 it.getMemberScope().getContributedDescriptors()
             },
             fqName, languageVersionSettings, metadataVersion

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedPackageFragmentProvider.kt

@@ -21,6 +21,9 @@ internal class CommonizedPackageFragmentProvider : PackageFragmentProvider {
         this.packageFragments.filterTo(packageFragments) { it.fqName == fqName }
     }
 
+    override fun getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> =
+        packageFragments.filter { it.fqName == fqName }
+
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): Collection<FqName> =
         packageFragments.asSequence()
             .map { it.fqName }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/collectors.kt

@@ -72,7 +72,7 @@ internal fun ModuleDescriptor.collectNonEmptyPackageMemberScopes(collector: (FqN
         if (packageFqName.isUnderStandardKotlinPackages || packageFqName.isUnderKotlinNativeSyntheticPackages)
             return
 
-        val ownPackageFragments = packageFragmentProvider.getPackageFragments(packageFqName)
+        val ownPackageFragments = packageFragmentProvider.packageFragments(packageFqName)
         val ownPackageMemberScopes = ownPackageFragments.asSequence()
             .filter { it !is ExportedForwardDeclarationsPackageFragmentDescriptor }
             .map { it.getMemberScope() }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/moduleDescriptor.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptorWithTypeParameters
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.packageFragments
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
 import org.jetbrains.kotlin.library.metadata.NativeTypeTransformer
@@ -103,7 +104,7 @@ internal val ModuleDescriptor.hasSomethingUnderStandardKotlinPackages: Boolean
     get() {
         val packageFragmentProvider = packageFragmentProvider
         return STANDARD_KOTLIN_PACKAGE_FQNS.any { fqName ->
-            packageFragmentProvider.getPackageFragments(fqName).any { packageFragment ->
+            packageFragmentProvider.packageFragments(fqName).any { packageFragment ->
                 packageFragment !is ExportedForwardDeclarationsPackageFragmentDescriptor
                         && packageFragment.getMemberScope() != MemberScope.Empty
             }

plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/res/AndroidPackageFragmentProviderExtension.kt

@@ -136,6 +136,8 @@ class AndroidSyntheticPackageFragmentProvider(
     override fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) =
         packageFragments.addIfNotNull(packages[fqName]?.invoke())
 
+    override fun getPackageFragments(fqName: FqName) = listOfNotNull(packages[fqName]?.invoke())
+
     override fun getSubPackagesOf(fqName: FqName, nameFilter: (Name) -> Boolean): List<FqName> {
         return packages.asSequence()
             .filter { (k, _) -> !k.isRoot && k.parent() == fqName }