[Gradle][Native] Setup refinesPaths as expectedBy module dependencies

Previously, dependsOn dependencies were just passed as friend modules
to shared native compilations.

^KT-55071 Verification Pending

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt

@@ -281,6 +281,16 @@ class K2NativeCompilerArguments : CommonCompilerArguments() {
     )
     var friendModules: String? = null
 
+    /**
+     * @see K2MetadataCompilerArguments.refinesPaths
+     */
+    @Argument(
+        value = "-Xrefines-paths",
+        valueDescription = "<path>",
+        description = "Paths to output directories for refined modules (whose expects this module can actualize)"
+    )
+    var refinesPaths: String? = null
+
     @Argument(value = "-Xdebug-info-version", description = "generate debug info of given version (1, 2)")
     var debugInfoFormatVersion: String = "1" /* command line parser doesn't accept kotlin.Int type */
 

compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/KlibResolvedModuleDescriptorsFactory.kt

@@ -1,12 +1,11 @@
 package org.jetbrains.kotlin.serialization.konan
 
-import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataModuleDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.storage.StorageManager
 
 interface KlibResolvedModuleDescriptorsFactory {
@@ -31,6 +30,7 @@ interface KlibResolvedModuleDescriptorsFactory {
         builtIns: KotlinBuiltIns?,
         languageVersionSettings: LanguageVersionSettings,
         friendModuleFiles: Set<File>,
+        refinesModuleFiles: Set<File>,
         includedLibraryFiles: Set<File>,
         additionalDependencyModules: Iterable<ModuleDescriptorImpl>,
         isForMetadataCompilation: Boolean,
@@ -51,5 +51,6 @@ class KotlinResolvedModuleDescriptors(
      */
     val forwardDeclarationsModule: ModuleDescriptorImpl,
 
-    val friendModules: Set<ModuleDescriptorImpl>
+    val friendModules: Set<ModuleDescriptorImpl>,
+    val refinesModules: Set<ModuleDescriptorImpl>
 )

compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/impl/KlibResolvedModuleDescriptorsFactoryImpl.kt

@@ -1,6 +1,5 @@
 package org.jetbrains.kotlin.serialization.konan.impl
 
-import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataModuleDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -13,9 +12,9 @@ import org.jetbrains.kotlin.descriptors.konan.SyntheticModulesOrigin
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.util.profile
 import org.jetbrains.kotlin.library.KotlinLibrary
 import org.jetbrains.kotlin.library.metadata.PackageAccessHandler
+import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
@@ -26,12 +25,13 @@ import org.jetbrains.kotlin.serialization.konan.KotlinResolvedModuleDescriptors
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
+import org.jetbrains.kotlin.util.profile
 import org.jetbrains.kotlin.utils.Printer
 
 // TODO: eliminate Native specifics.
 class KlibResolvedModuleDescriptorsFactoryImpl(
     override val moduleDescriptorFactory: KlibMetadataModuleDescriptorFactory
-): KlibResolvedModuleDescriptorsFactory {
+) : KlibResolvedModuleDescriptorsFactory {
 
     override fun createResolved(
         resolvedLibraries: KotlinLibraryResolveResult,
@@ -39,6 +39,7 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
         builtIns: KotlinBuiltIns?,
         languageVersionSettings: LanguageVersionSettings,
         friendModuleFiles: Set<File>,
+        refinesModuleFiles: Set<File>,
         includedLibraryFiles: Set<File>,
         additionalDependencyModules: Iterable<ModuleDescriptorImpl>,
         isForMetadataCompilation: Boolean,
@@ -50,6 +51,7 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
         var builtIns = builtIns
 
         val friendModuleDescriptors = mutableSetOf<ModuleDescriptorImpl>()
+        val refinesModuleDescriptors = mutableSetOf<ModuleDescriptorImpl>()
         val includedLibraryDescriptors = mutableSetOf<ModuleDescriptorImpl>()
 
         // Build module descriptors.
@@ -63,6 +65,8 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
                 builtIns = moduleDescriptor.builtIns
                 moduleDescriptors.add(moduleDescriptor)
 
+                if (refinesModuleFiles.contains(library.libraryFile))
+                    refinesModuleDescriptors.add(moduleDescriptor)
                 if (friendModuleFiles.contains(library.libraryFile))
                     friendModuleDescriptors.add(moduleDescriptor)
                 if (includedLibraryFiles.contains(library.libraryFile))
@@ -88,8 +92,11 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
         // Set inter-dependencies between module descriptors, add forwarding declarations module.
         for (module in moduleDescriptors) {
             val friends = additionalDependencyModules.toMutableSet()
-            if (module in includedLibraryDescriptors)
+            if (module in includedLibraryDescriptors) {
                 friends.addAll(friendModuleDescriptors)
+                friends.addAll(refinesModuleDescriptors)
+            }
+
             module.setDependencies(
                 // Yes, just to all of them.
                 moduleDescriptors + additionalDependencyModules + forwardDeclarationsModule,
@@ -97,7 +104,12 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
             )
         }
 
-        return KotlinResolvedModuleDescriptors(moduleDescriptors, forwardDeclarationsModule, friendModuleDescriptors)
+        return KotlinResolvedModuleDescriptors(
+            resolvedDescriptors = moduleDescriptors,
+            forwardDeclarationsModule = forwardDeclarationsModule,
+            friendModules = friendModuleDescriptors,
+            refinesModules = refinesModuleDescriptors
+        )
     }
 
     fun createForwardDeclarationsModule(
@@ -133,21 +145,21 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
     }
 
     private fun createDescriptorOptionalBuiltsIns(
-            name: Name,
+        name: Name,
-            storageManager: StorageManager,
+        storageManager: StorageManager,
-            builtIns: KotlinBuiltIns?,
+        builtIns: KotlinBuiltIns?,
-            moduleOrigin: KlibModuleOrigin
+        moduleOrigin: KlibModuleOrigin
     ) = if (builtIns != null)
         moduleDescriptorFactory.descriptorFactory.createDescriptor(name, storageManager, builtIns, moduleOrigin)
     else
         moduleDescriptorFactory.descriptorFactory.createDescriptorAndNewBuiltIns(name, storageManager, moduleOrigin)
 
     private fun createDescriptorOptionalBuiltsIns(
-            library: KotlinLibrary,
+        library: KotlinLibrary,
-            languageVersionSettings: LanguageVersionSettings,
+        languageVersionSettings: LanguageVersionSettings,
-            storageManager: StorageManager,
+        storageManager: StorageManager,
-            builtIns: KotlinBuiltIns?,
+        builtIns: KotlinBuiltIns?,
-            packageAccessHandler: PackageAccessHandler?
+        packageAccessHandler: PackageAccessHandler?
     ) = if (builtIns != null)
         moduleDescriptorFactory.createDescriptor(library, languageVersionSettings, storageManager, builtIns, packageAccessHandler)
     else

kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt

@@ -256,6 +256,9 @@ class K2Native : CLICompiler<K2NativeCompilerArguments>() {
                 if (arguments.friendModules != null)
                     put(FRIEND_MODULES, arguments.friendModules!!.split(File.pathSeparator).filterNot(String::isEmpty))
 
+                if(arguments.refinesPaths != null)
+                    put(REFINES_MODULES, arguments.refinesPaths!!.split(File.pathSeparator).filterNot(String::isEmpty))
+
                 put(EXPORTED_LIBRARIES, selectExportedLibraries(configuration, arguments, outputKind))
                 put(INCLUDED_LIBRARIES, selectIncludes(configuration, arguments, outputKind))
                 put(FRAMEWORK_IMPORT_HEADERS, arguments.frameworkImportHeaders.toNonNullList())

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt

@@ -339,6 +339,9 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
     internal val friendModuleFiles: Set<File> =
             configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet() ?: emptySet()
 
+    internal val refinesModuleFiles: Set<File> =
+            configuration.get(KonanConfigKeys.REFINES_MODULES)?.map { File(it) }?.toSet().orEmpty()
+
     internal val manifestProperties = configuration.get(KonanConfigKeys.MANIFEST_FILE)?.let {
         File(it).loadProperties()
     }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.konan.target.CompilerOutputKind
-import org.jetbrains.kotlin.serialization.js.ModuleKind
 
 class KonanConfigKeys {
     companion object {
@@ -46,6 +45,8 @@ class KonanConfigKeys {
                 = CompilerConfigurationKey.create<List<String>>("headers imported to framework header")
         val FRIEND_MODULES: CompilerConfigurationKey<List<String>>
                 = CompilerConfigurationKey.create<List<String>>("friend module paths")
+        val REFINES_MODULES: CompilerConfigurationKey<List<String>>
+                = CompilerConfigurationKey.create<List<String>>("refines module paths")
         val GENERATE_TEST_RUNNER: CompilerConfigurationKey<TestRunnerKind>
                 = CompilerConfigurationKey.create("generate test runner") 
         val INCLUDED_BINARY_FILES: CompilerConfigurationKey<List<String>>

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/TopDownAnalyzerFacadeForKonan.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContextImpl
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.impl.ModuleDependenciesImpl
 import org.jetbrains.kotlin.descriptors.konan.CurrentKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
@@ -31,7 +32,7 @@ internal object TopDownAnalyzerFacadeForKonan {
 
     fun analyzeFiles(files: Collection<KtFile>, context: Context): AnalysisResult {
         val config = context.config
-        val moduleName = Name.special("<${config.moduleId}>") 
+        val moduleName = Name.special("<${config.moduleId}>")
 
         val projectContext = ProjectContext(config.project, "TopDownAnalyzer for Konan")
 
@@ -41,13 +42,19 @@ internal object TopDownAnalyzerFacadeForKonan {
 
         val resolvedModuleDescriptors = nativeFactories.DefaultResolvedDescriptorsFactory.createResolved(
                 config.resolvedLibraries, projectContext.storageManager, module.builtIns, config.languageVersionSettings,
-                config.friendModuleFiles, config.resolve.includedLibraries.map { it.libraryFile }.toSet(), listOf(module),
+                config.friendModuleFiles, config.refinesModuleFiles,
+                config.resolve.includedLibraries.map { it.libraryFile }.toSet(), listOf(module),
                 isForMetadataCompilation = config.metadataKlib)
 
         val additionalPackages = mutableListOf<PackageFragmentProvider>()
         if (!module.isNativeStdlib()) {
-            val dependencies = listOf(module) + resolvedModuleDescriptors.resolvedDescriptors + resolvedModuleDescriptors.forwardDeclarationsModule
+            module.setDependencies(ModuleDependenciesImpl(
-            module.setDependencies(dependencies, resolvedModuleDescriptors.friendModules)
+                    allDependencies =
+                    listOf(module) + resolvedModuleDescriptors.resolvedDescriptors + resolvedModuleDescriptors.forwardDeclarationsModule,
+                    modulesWhoseInternalsAreVisible = resolvedModuleDescriptors.friendModules,
+                    directExpectedByDependencies = resolvedModuleDescriptors.refinesModules.toList(),
+                    allExpectedByDependencies = resolvedModuleDescriptors.refinesModules
+            ))
         } else {
             assert(resolvedModuleDescriptors.resolvedDescriptors.isEmpty())
             moduleContext.setDependencies(module)
@@ -70,7 +77,7 @@ internal object TopDownAnalyzerFacadeForKonan {
         // we print out each file we compile if frontend phase is verbose
         files.takeIf {
             context.shouldPrintFiles()
-        } ?.forEach(::println)
+        }?.forEach(::println)
 
         val container = createTopDownAnalyzerProviderForKonan(
                 moduleContext, trace,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinCompilationInfo.kt

@@ -11,10 +11,13 @@ import org.gradle.api.Project
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
 import org.gradle.api.file.SourceDirectorySet
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmAbstractFragmentMetadataCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmModule
+import org.jetbrains.kotlin.gradle.plugin.sources.dependsOnClosure
 import org.jetbrains.kotlin.gradle.utils.filesProvider
 import org.jetbrains.kotlin.project.model.LanguageSettings
 
@@ -30,6 +33,7 @@ internal sealed class KotlinCompilationInfo {
     abstract val compileAllTaskName: String
     abstract val languageSettings: LanguageSettings
     abstract val friendPaths: FileCollection
+    abstract val refinesPaths: FileCollection
     abstract val isMain: Boolean
     abstract val classesDirs: ConfigurableFileCollection
     abstract val compileDependencyFiles: FileCollection
@@ -70,6 +74,13 @@ internal sealed class KotlinCompilationInfo {
         override val friendPaths: FileCollection
             get() = project.filesProvider { origin.internal.friendPaths }
 
+        override val refinesPaths: FileCollection
+            get() = project.filesProvider files@{
+                val metadataTarget = project.multiplatformExtensionOrNull?.metadata() ?: return@files emptyList<Any>()
+                origin.kotlinSourceSets.dependsOnClosure
+                    .mapNotNull { sourceSet -> metadataTarget.compilations.findByName(sourceSet.name)?.output?.classesDirs }
+            }
+
         override val isMain: Boolean
             get() = origin.isMain()
 
@@ -117,6 +128,17 @@ internal sealed class KotlinCompilationInfo {
         override val friendPaths: FileCollection
             get() = project.filesProvider { origin.friendPaths }
 
+        override val refinesPaths: FileCollection
+            get() = project.filesProvider files@{
+                val compilationData = origin as? GradleKpmAbstractFragmentMetadataCompilationData<*> ?: return@files emptyList<Any>()
+                val fragment = compilationData.fragment
+
+                fragment.refinesClosure.minus(fragment).map {
+                    val compilation = compilationData.metadataCompilationRegistry.getForFragmentOrNull(it) ?: return@map project.files()
+                    compilation.output.classesDirs
+                }
+            }
+
         override val isMain: Boolean
             get() = origin.compilationPurpose == GradleKpmModule.MAIN_MODULE_NAME
 
@@ -146,4 +168,4 @@ internal val KotlinCompilationInfo.kpmOrNull: KotlinCompilationInfo.KPM?
     get() = when (this) {
         is KotlinCompilationInfo.KPM -> this
         is KotlinCompilationInfo.TCS -> null
-    }
+    }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/KotlinCompilationFriendPathsResolver.kt

@@ -10,8 +10,6 @@ import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
-import org.jetbrains.kotlin.gradle.targets.metadata.getMetadataCompilationForSourceSet
 import org.jetbrains.kotlin.gradle.utils.filesProvider
 
 internal interface KotlinCompilationFriendPathsResolver {
@@ -75,19 +73,6 @@ internal class DefaultKotlinCompilationFriendPathsResolver(
         }
     }
 
-    object AdditionalSharedNativeMetadataFriendArtifactResolver : FriendArtifactResolver {
-        override fun resolveFriendArtifacts(compilation: InternalKotlinCompilation<*>): FileCollection {
-            // TODO: implement proper dependsOn/refines compiler args for Kotlin/Native and pass the dependsOn klibs separately;
-            //       But for now, those dependencies don't have any special semantics, so passing all them as friends works, too
-            val friendSourceSets = getVisibleSourceSetsFromAssociateCompilations(compilation.defaultSourceSet) +
-                    compilation.defaultSourceSet.internal.dependsOnClosure
-
-            return compilation.project.files(
-                friendSourceSets.mapNotNull { compilation.project.getMetadataCompilationForSourceSet(it)?.output?.classesDirs }
-            )
-        }
-    }
-
     object AdditionalAndroidFriendArtifactResolver : FriendArtifactResolver {
         override fun resolveFriendArtifacts(compilation: InternalKotlinCompilation<*>): FileCollection {
             return compilation.project.files((compilation.decoratedInstance as KotlinJvmAndroidCompilation).testedVariantArtifacts)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/DefaultKotlinSourceSet.kt

@@ -213,8 +213,6 @@ val KotlinSourceSet.dependsOnClosure: Set<KotlinSourceSet> get() = this.internal
 @Deprecated("Use InternalKotlinSourceSet.withDependsOnClosure instead. Will be removed in Kotlin 1.9")
 val KotlinSourceSet.withDependsOnClosure: Set<KotlinSourceSet> get() = this.internal.withDependsOnClosure
 
-@Suppress("Unused") // Still part of public API
-@Deprecated("Use InternalKotlinSourceSet.withDependsOnClosure instead. Will be removed in Kotlin 1.9")
 val Iterable<KotlinSourceSet>.dependsOnClosure: Set<KotlinSourceSet>
     get() = flatMap { it.internal.dependsOnClosure }.toSet() - this.toSet()
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinSharedNativeCompilationFactory.kt

@@ -43,7 +43,7 @@ open class KotlinSharedNativeCompilationFactory internal constructor(
             compilationFriendPathsResolver = DefaultKotlinCompilationFriendPathsResolver(
                 friendArtifactResolver = DefaultKotlinCompilationFriendPathsResolver.FriendArtifactResolver.composite(
                     DefaultKotlinCompilationFriendPathsResolver.DefaultFriendArtifactResolver,
-                    DefaultKotlinCompilationFriendPathsResolver.AdditionalSharedNativeMetadataFriendArtifactResolver
+                    DefaultKotlinCompilationFriendPathsResolver.AdditionalMetadataFriendArtifactResolver
                 )
             ),
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt

@@ -23,7 +23,8 @@ internal class CompilerPluginData(
 
 internal class SharedCompilationData(
     val manifestFile: File,
-    val isAllowCommonizer: Boolean
+    val isAllowCommonizer: Boolean,
+    val refinesPaths: FileCollection
 )
 
 internal fun buildKotlinNativeKlibCompilerArgs(
@@ -63,6 +64,13 @@ internal fun buildKotlinNativeKlibCompilerArgs(
         addArg("-friend-modules", friends.joinToString(File.pathSeparator) { it.absolutePath })
     }
 
+    if (sharedCompilationData != null) {
+        val refinesPaths = sharedCompilationData.refinesPaths.files
+        if (refinesPaths.isNotEmpty()) {
+            addArg("-Xrefines-paths", refinesPaths.joinToString(File.pathSeparator) { it.absolutePath })
+        }
+    }
+
     addAll(buildKotlinNativeCompileCommonArgs(enableEndorsedLibs, languageSettings, compilerOptions, compilerPlugins))
 
     addAll(source.map { it.absolutePath })
@@ -205,4 +213,4 @@ private fun MutableList<String>.addKey(key: String, enabled: Boolean) {
     if (enabled) {
         add(key)
     }
-}
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeTasks.kt

@@ -181,6 +181,9 @@ abstract class AbstractKotlinNativeCompile<
     @get:Classpath
     protected val friendModule: FileCollection = project.files({ compilation.friendPaths })
 
+    @get:Classpath
+    protected val refinesModule: FileCollection = project.files({ compilation.refinesPaths })
+
     @get:Input
     val target: String by project.provider { konanTarget.name }
 
@@ -468,7 +471,7 @@ internal constructor(
         properties[KLIB_PROPERTY_NATIVE_TARGETS] = konanTargetsForManifest
         properties.saveToFile(org.jetbrains.kotlin.konan.file.File(manifestFile.toPath()))
 
-        return SharedCompilationData(manifestFile, isAllowCommonizer)
+        return SharedCompilationData(manifestFile, isAllowCommonizer, refinesModule)
     }
 
     @TaskAction

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KotlinCompileCommonConfig.kt

@@ -5,16 +5,10 @@
 
 package org.jetbrains.kotlin.gradle.tasks.configuration
 
-import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationInfo
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCommonCompilation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmAbstractFragmentMetadataCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmMetadataCompilationData
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon
-import java.io.File
 
 internal class KotlinCompileCommonConfig(
     private val compilationInfo: KotlinCompilationInfo,
@@ -27,33 +21,7 @@ internal class KotlinCompileCommonConfig(
                             compilationInfo.origin is GradleKpmMetadataCompilationData<*>
                 }
             ).disallowChanges()
-            task.refinesMetadataPaths.from(getRefinesMetadataPaths(project)).disallowChanges()
+            task.refinesMetadataPaths.from(compilationInfo.refinesPaths).disallowChanges()
-        }
-    }
-
-    private fun getRefinesMetadataPaths(project: Project): Provider<Iterable<File>> {
-        return project.provider {
-            when (compilationInfo) {
-                is KotlinCompilationInfo.TCS -> {
-                    val defaultKotlinSourceSet: KotlinSourceSet = compilationInfo.compilation.defaultSourceSet
-                    val metadataTarget = compilationInfo.compilation.target
-                    defaultKotlinSourceSet.internal.dependsOnClosure
-                        .mapNotNull { sourceSet -> metadataTarget.compilations.findByName(sourceSet.name)?.output?.classesDirs }
-                        .flatten()
-                }
-
-                is KotlinCompilationInfo.KPM -> {
-                    val compilationData = compilationInfo.compilationData as GradleKpmAbstractFragmentMetadataCompilationData<*>
-                    val fragment = compilationData.fragment
-                    project.files(
-                        fragment.refinesClosure.minus(fragment).map {
-                            val compilation = compilationData.metadataCompilationRegistry.getForFragmentOrNull(it)
-                                ?: return@map project.files()
-                            compilation.output.classesDirs
-                        }
-                    )
-                }
-            }
         }
     }
 }