Added deprecated PackageFragmentProvider#getPackageFragments for BWC

Relates to ^KT-33394 ^KT-42259 Fixed
2020-09-29 19:14:44 +00:00
parent a228206cf5
commit 3c380faeb5
21 changed files with 97 additions and 48 deletions
@@ -42,24 +42,28 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.keysToMap

 class IncrementalPackageFragmentProvider(
-        sourceFiles: Collection<KtFile>,
-        val moduleDescriptor: ModuleDescriptor,
-        val storageManager: StorageManager,
-        val deserializationComponents: DeserializationComponents,
-        val incrementalCache: IncrementalCache,
-        val target: TargetId,
-        private val kotlinClassFinder: KotlinClassFinder
+    sourceFiles: Collection<KtFile>,
+    val moduleDescriptor: ModuleDescriptor,
+    val storageManager: StorageManager,
+    val deserializationComponents: DeserializationComponents,
+    val incrementalCache: IncrementalCache,
+    val target: TargetId,
+    private val kotlinClassFinder: KotlinClassFinder
 ) : PackageFragmentProvider {
    private val fqNameToPackageFragment =
-            PackagePartClassUtils.getFilesWithCallables(sourceFiles)
-                    .mapTo(hashSetOf()) { it.packageFqName }
-                    .keysToMap(this::IncrementalPackageFragment)
+        PackagePartClassUtils.getFilesWithCallables(sourceFiles)
+            .mapTo(hashSetOf()) { it.packageFqName }
+            .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 partsInternalNames: Collection<String>,
-            packageFqName: FqName
+        val facadeName: JvmClassName,
+        val partsInternalNames: Collection<String>,
+        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",
-                    partsInternalNames.mapNotNull { internalName ->
-                        incrementalCache.getPackagePartData(internalName)?.let { (data, strings) ->
-                            val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(data, strings)
+                "Member scope for incremental compilation: union of multifile class parts data for $facadeName",
+                partsInternalNames.mapNotNull { internalName ->
+                    incrementalCache.getPackagePartData(internalName)?.let { (data, strings) ->
+                        val (nameResolver, packageProto) = JvmProtoBufUtil.readPackageDataFrom(data, strings)

-                            val partName = JvmClassName.byInternalName(internalName)
-                            val jvmBinaryClass =
-                                    kotlinClassFinder.findKotlinClass(ClassId.topLevel(partName.fqNameForTopLevelClassMaybeWithDollars))
+                        val partName = JvmClassName.byInternalName(internalName)
+                        val jvmBinaryClass =
+                            kotlinClassFinder.findKotlinClass(ClassId.topLevel(partName.fqNameForTopLevelClassMaybeWithDollars))

-                            val metadataVersion =
-                                jvmBinaryClass?.classHeader?.metadataVersion
+                        val metadataVersion =
+                            jvmBinaryClass?.classHeader?.metadataVersion
                                ?: JvmMetadataVersion.INSTANCE

-                            DeserializedPackageMemberScope(
-                                this, packageProto, nameResolver, metadataVersion,
-                                JvmPackagePartSource(
-                                            partName, facadeName, packageProto, nameResolver, knownJvmBinaryClass = jvmBinaryClass
-                                    ),
-                                deserializationComponents, classNames = { emptyList() }
-                            )
-                        }
+                        DeserializedPackageMemberScope(
+                            this, packageProto, nameResolver, metadataVersion,
+                            JvmPackagePartSource(
+                                partName, facadeName, packageProto, nameResolver, knownJvmBinaryClass = jvmBinaryClass
+                            ),
+                            deserializationComponents, classNames = { emptyList() }
+                        )
                    }
+                }
            )
        }

@@ -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()
 }
@@ -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

@@ -83,7 +83,7 @@ class DescriptorByIdSignatureFinder(
            LookupMode.MODULE_ONLY -> {
                (moduleDescriptor as ModuleDescriptorImpl)
                    .packageFragmentProviderForModuleContentWithoutDependencies
-                    .getPackageFragments(packageFqName)
+                    .packageFragments(packageFqName)
                    .flatMap { it.getMemberScope().loadDescriptors(declarationName, isLeaf) }
            }
        }
@@ -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 }
        }
@@ -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(
@@ -78,7 +78,7 @@ class NonStableParameterNamesSerializationTest : TestCaseWithTmpdir() {

            fun recurse(packageFqName: FqName) {
                packageFragmentProvider
-                    .getPackageFragments(packageFqName)
+                    .packageFragments(packageFqName)
                    .forEach { packageFragment ->
                        recurse(packageFragment.getMemberScope())
                    }
@@ -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")
@@ -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 getPackageFragments(fqName: FqName): List<PackageFragmentDescriptor> {
-        val packageFragments = mutableListOf<PackageFragmentDescriptor>()
-        collectPackageFragments(fqName, packageFragments)
-        return packageFragments
+    fun collectPackageFragments(fqName: FqName, packageFragments: MutableCollection<PackageFragmentDescriptor>) {
+        // default implementation is provided only for BWC
+        packageFragments.addAll(getPackageFragments(fqName))
    }

-    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
+}
@@ -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 }
@@ -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)
@@ -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) {
@@ -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()
 }
@@ -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

@@ -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

@@ -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.")
        }
@@ -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
@@ -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 }
@@ -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() }
@@ -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
            }
@@ -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 }