Experimental sources publication in the PM2.0 prototype

libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinGradleFragment.kt

@@ -14,6 +14,7 @@ import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.plugin.HasKotlinDependencies
 import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import org.jetbrains.kotlin.project.model.KotlinModuleFragment
+import org.jetbrains.kotlin.project.model.refinesClosure
 
 interface KotlinGradleFragment : KotlinModuleFragment, HasKotlinDependencies, Named {
     override val kotlinSourceRoots: SourceDirectorySet
@@ -49,3 +50,6 @@ interface KotlinGradleFragment : KotlinModuleFragment, HasKotlinDependencies, Na
                 // TODO: resolvable metadata configurations?
                 listOf(transitiveApiConfigurationName, transitiveImplementationConfigurationName)
 }
+
+val KotlinGradleFragment.refinesClosure: Set<KotlinGradleFragment>
+    get() = (this as KotlinModuleFragment).refinesClosure.mapTo(mutableSetOf()) { it as KotlinGradleFragment }

libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinGradleVariant.kt

@@ -26,7 +26,7 @@ interface KotlinGradleVariant : KotlinGradleFragment, KotlinModuleVariant {
     val compilationOutputs: KotlinCompilationOutput
 
     // TODO rewrite using our own artifacts API
-    val sourceArchiveTask: TaskProvider<AbstractArchiveTask>
+    val sourceArchiveTaskName: String
 
     // TODO generalize exposing outputs: what if a variant has more than one such configurations or none?
     val apiElementsConfigurationName: String

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/DefaultKotlinDependencyHandler.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.gradle.plugin.HasKotlinDependencies
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinGradleModule
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.CalculatedCapability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.targets.js.npm.NpmDependency
 import org.jetbrains.kotlin.gradle.targets.js.npm.directoryNpmDependency
 import org.jetbrains.kotlin.gradle.targets.js.npm.moduleName
@@ -77,7 +77,7 @@ class DefaultKotlinDependencyHandler(
             is KotlinGradleModule -> project.dependencies.create(dependencyNotation.project).apply {
                 (this as ModuleDependency).capabilities {
                     if (dependencyNotation.moduleClassifier != null) {
-                        it.requireCapability(CalculatedCapability.fromModule(dependencyNotation))
+                        it.requireCapability(ComputedCapability.fromModule(dependencyNotation))
                     }
                 }
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMultiplatformPlugin.kt

@@ -297,9 +297,14 @@ internal fun sourcesJarTask(
     sourceSets: Lazy<Map<String, FileCollection>>,
     componentName: String?,
     artifactNameAppendix: String
-): TaskProvider<Jar> {
+): TaskProvider<Jar> = sourcesJarTaskNamed(lowerCamelCaseName(componentName, "sourcesJar"), project, sourceSets, artifactNameAppendix)
-    val taskName = lowerCamelCaseName(componentName, "sourcesJar")
 
+internal fun sourcesJarTaskNamed(
+    taskName: String,
+    project: Project,
+    sourceSets: Lazy<Map<String, FileCollection>>,
+    artifactNameAppendix: String
+): TaskProvider<Jar> {
     project.locateTask<Jar>(taskName)?.let {
         return it
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinUsages.kt

@@ -19,6 +19,7 @@ object KotlinUsages {
     const val KOTLIN_API = "kotlin-api"
     const val KOTLIN_RUNTIME = "kotlin-runtime"
     const val KOTLIN_METADATA = "kotlin-metadata"
+    const val KOTLIN_SOURCES = "kotlin-sources"
 
     val values = setOf(KOTLIN_API, KOTLIN_RUNTIME)
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/ModuleIds.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.dsl.topLevelExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.CalculatedCapability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.utils.getValue
 import org.jetbrains.kotlin.project.model.KotlinModuleIdentifier
 import org.jetbrains.kotlin.project.model.LocalModuleIdentifier
@@ -88,7 +88,7 @@ internal object ModuleIds {
                 }
                 val capabilities = when (topLevelExtension) {
                     is KotlinMultiplatformExtension -> emptyList()
-                    is KotlinPm20ProjectExtension -> listOfNotNull(CalculatedCapability.capabilityStringFromModule(
+                    is KotlinPm20ProjectExtension -> listOfNotNull(ComputedCapability.capabilityStringFromModule(
                         topLevelExtension.modules.single { it.moduleIdentifier == moduleIdentifier }
                     ))
                     else -> error("unexpected top-level extension $topLevelExtension")

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/FragmentSourcesProvider.kt

@@ -8,22 +8,32 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 import org.gradle.api.Project
 import org.gradle.api.file.FileCollection
 import org.gradle.language.base.plugins.LifecycleBasePlugin
-import org.jetbrains.kotlin.project.model.refinesClosure
 import org.jetbrains.kotlin.project.model.utils.variantsContainingFragment
 
-open class VariantSourcesProvider {
+open class FragmentSourcesProvider {
-    open fun getSourcesFromRefinesClosure(variant: KotlinGradleVariant): FileCollection {
+    protected open fun getSourcesFromFragmentsAsMap(
-        val project = variant.containingModule.project
+        fragments: Iterable<KotlinGradleFragment>
-        return project.files(project.provider {
+    ): Map<KotlinGradleFragment, FileCollection> =
-            variant.refinesClosure.map { it.kotlinSourceRoots }
+        fragments.associateWith { it.project.files(it.project.provider { it.kotlinSourceRoots }) }
-        })
-    }
 
-    open fun getCommonSourcesFromRefinesClosure(variant: KotlinGradleVariant): FileCollection {
+    open fun getFragmentOwnSources(fragment: KotlinGradleFragment): FileCollection =
-        val containingModule = variant.containingModule
+        getSourcesFromFragmentsAsMap(listOf(fragment)).values.single()
+
+    open fun getAllFragmentSourcesAsMap(module: KotlinGradleModule): Map<KotlinGradleFragment, FileCollection> =
+        getSourcesFromFragmentsAsMap(module.fragments)
+
+    open fun getSourcesFromRefinesClosureAsMap(fragment: KotlinGradleFragment): Map<KotlinGradleFragment, FileCollection> =
+        getSourcesFromFragmentsAsMap(fragment.refinesClosure)
+
+    open fun getSourcesFromRefinesClosure(fragment: KotlinGradleFragment): FileCollection =
+        fragment.project.files(fragment.project.provider { getSourcesFromRefinesClosureAsMap(fragment).values })
+
+    open fun getCommonSourcesFromRefinesClosure(fragment: KotlinGradleFragment): FileCollection {
+        val containingModule = fragment.containingModule
         val project = containingModule.project
+        getSourcesFromRefinesClosureAsMap(fragment)
         return project.files(project.provider {
-            variant.refinesClosure.filter {
+            fragment.refinesClosure.filter {
                 // Every fragment refined by some other fragment should be considered common, even if it is included in just one variant
                 containingModule.variantsContainingFragment(it).toSet() != setOf(it)
             }.map { it.kotlinSourceRoots }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradlePlugin.kt

@@ -86,11 +86,13 @@ abstract class KotlinPm20GradlePlugin @Inject constructor(
         val project = module.project
 
         val metadataElements = project.configurations.getByName(metadataElementsConfigurationName(module))
+        val sourceElements = project.configurations.getByName(sourceElementsConfigurationName(module))
 
         val componentName = rootPublicationComponentName(module)
         val rootSoftwareComponent = softwareComponentFactory.adhoc(componentName).also {
             project.components.add(it)
             it.addVariantsFromConfiguration(metadataElements) { }
+            it.addVariantsFromConfiguration(sourceElements) { }
         }
 
         module.ifMadePublic {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinCompilationTaskConfigurator.kt

@@ -32,9 +32,9 @@ open class KotlinCompilationTaskConfigurator(
         fragment: KotlinGradleFragment,
         compilationData: KotlinCompilationData<*>
     ): TaskProvider<out KotlinCompile> {
-        Kotlin2JvmSourceSetProcessor(KotlinTasksProvider(), compilationData, kotlinPluginVersion).run()
+        Kotlin2JvmSourceSetProcessor(KotlinTasksProvider(), compilationData).run()
-        val allSources = variantSourcesProvider.getSourcesFromRefinesClosure(variant)
+        val allSources = getSourcesForFragmentCompilation(fragment)
-        val commonSources = variantSourcesProvider.getCommonSourcesFromRefinesClosure(variant)
+        val commonSources = getCommonSourcesForFragmentCompilation(fragment)
 
         // FIXME support custom source file extensions in the two calls below
         addSourcesToKotlinCompileTask(project, compilationData.compileKotlinTaskName, emptyList()) { allSources }
@@ -49,8 +49,8 @@ open class KotlinCompilationTaskConfigurator(
     ): TaskProvider<KotlinNativeCompile> {
         val compileTask = KotlinNativeTargetConfigurator.createKlibCompilationTask(compilationData)
 
-        val allSources = variantSourcesProvider.getSourcesFromRefinesClosure(variant)
+        val allSources = getSourcesForFragmentCompilation(fragment)
-        val commonSources = variantSourcesProvider.getSourcesFromRefinesClosure(variant)
+        val commonSources = getCommonSourcesForFragmentCompilation(fragment)
 
         compileTask.configure {
             it.source(allSources)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/abstractVariantFactories.kt

@@ -5,28 +5,15 @@
 
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
-import jdk.internal.org.objectweb.asm.tree.VarInsnNode
-import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ModuleDependency
+import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Attribute
+import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.AttributeContainer
 import org.gradle.api.attributes.Usage
-import org.gradle.api.component.AdhocComponentWithVariants
-import org.gradle.api.component.SoftwareComponentFactory
-import org.gradle.api.internal.project.ProjectInternal
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.maven.internal.publication.DefaultMavenPublication
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.CalculatedCapability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
-import org.jetbrains.kotlin.gradle.plugin.mpp.publishedConfigurationName
+import org.jetbrains.kotlin.gradle.plugin.mpp.sourcesJarTaskNamed
-import org.jetbrains.kotlin.gradle.plugin.mpp.sourcesJarTask
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
-import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
-import org.jetbrains.kotlin.project.model.refinesClosure
-import javax.inject.Inject
 
 abstract class AbstractKotlinGradleVariantFactory<T : KotlinGradleVariant>(
     module: KotlinGradleModule
@@ -51,17 +38,21 @@ abstract class AbstractKotlinGradleVariantFactory<T : KotlinGradleVariant>(
 
     open fun configureApiElementsConfiguration(fragment: T, configuration: Configuration) {
         setPlatformAttributesInConfiguration(fragment, configuration)
-        configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(project, fragment.platformType))
+        configuration.attributes.apply {
+            attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(project, fragment.platformType))
+            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category::class.java, Category.LIBRARY))
+            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
+        }
     }
 
     abstract fun configureKotlinCompilation(fragment: T)
 
     open fun createSourcesArchiveTask(fragment: T) {
-        sourcesJarTask(
+        sourcesJarTaskNamed(
+            fragment.sourceArchiveTaskName,
             project,
-            lazy { fragment.refinesClosure.associate { it.disambiguateName("") to project.files(it.kotlinSourceRoots) } },
+            lazy { FragmentSourcesProvider().getSourcesFromRefinesClosureAsMap(fragment).mapKeys { it.key.fragmentName } },
-            fragment.name,
+            fragment.name
-            fragment.name.toLowerCase()
         )
     }
 
@@ -104,7 +95,11 @@ abstract class AbstractKotlinGradleVariantWithRuntimeFactory<T : KotlinGradleVar
 
     open fun configureRuntimeElementsConfiguration(fragment: T, configuration: Configuration) {
         setPlatformAttributesInConfiguration(fragment, configuration)
-        configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerRuntimeUsage(project, fragment.platformType))
+        configuration.attributes.apply {
+            attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerRuntimeUsage(project, fragment.platformType))
+            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category::class.java, Category.LIBRARY))
+            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
+        }
     }
 
     override fun createDependencyConfigurations(fragment: T) {
@@ -153,6 +148,6 @@ abstract class AbstractKotlinGradleRuntimePublishedVariantFactory<T : KotlinGrad
 
 internal fun setModuleCapability(configuration: Configuration, module: KotlinGradleModule) {
     if (module.moduleClassifier != null) {
-        configuration.outgoing.capability(CalculatedCapability.fromModule(module))
+        configuration.outgoing.capability(ComputedCapability.fromModule(module))
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/abstractVariants.kt

@@ -15,7 +15,7 @@ import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.DefaultKotlinCompilationOutput
 import org.jetbrains.kotlin.gradle.plugin.mpp.MavenPublicationCoordinatesProvider
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.CalculatedCapability
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.plugin.mpp.publishedConfigurationName
 import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
@@ -49,8 +49,8 @@ abstract class KotlinGradleVariantInternal(
         )
 
     // TODO rewrite using our own artifacts API
-    override val sourceArchiveTask: TaskProvider<AbstractArchiveTask>
+    override val sourceArchiveTaskName: String
-        get() = project.tasks.withType<AbstractArchiveTask>().named(defaultSourceArtifactTaskName)
+        get() = defaultSourceArtifactTaskName
 
     // TODO generalize exposing outputs: what if a variant has more than one such configurations or none?
     override val apiElementsConfigurationName: String
@@ -81,7 +81,7 @@ class DefaultSingleMavenPublishedModuleHolder(
             project,
             { assignedMavenPublication },
             defaultPublishedModuleSuffix,
-            capabilities = listOfNotNull(CalculatedCapability.capabilityStringFromModule(module))
+            capabilities = listOfNotNull(ComputedCapability.capabilityStringFromModule(module))
         )
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/fragmentsMetadataCompilation.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.gradle.dsl.pm20Extension
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinCommonSourceSetProcessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.targets.metadata.NativeSharedCompilationProcessor
 import org.jetbrains.kotlin.gradle.targets.metadata.createGenerateProjectStructureMetadataTask
 import org.jetbrains.kotlin.gradle.targets.metadata.filesWithUnpackedArchives
@@ -22,6 +23,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider
 import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
+import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
 import org.jetbrains.kotlin.project.model.KotlinModuleFragment
@@ -58,11 +60,26 @@ internal fun configureMetadataExposure(module: KotlinGradleModule) {
         }
         setModuleCapability(this, module)
     }
+
+    val sourcesArtifactAppendix = dashSeparatedName(module.moduleClassifier, "all", "sources")
+    val sourcesArtifact = sourcesJarTaskNamed(
+        module.disambiguateName("allSourcesJar"),
+        project,
+        lazy { FragmentSourcesProvider().getAllFragmentSourcesAsMap(module).mapKeys { it.key.fragmentName } },
+        sourcesArtifactAppendix
+    )
+    DocumentationVariantConfigurator().createSourcesElementsConfiguration(
+        project, sourceElementsConfigurationName(module),
+        sourcesArtifact.get(), "sources", ComputedCapability.fromModuleOrNull(module)
+    )
 }
 
 fun metadataElementsConfigurationName(module: KotlinGradleModule) =
     module.disambiguateName("metadataElements")
 
+fun sourceElementsConfigurationName(module: KotlinGradleModule) =
+    module.disambiguateName("sourceElements")
+
 private fun generateAndExportProjectStructureMetadata(
     module: KotlinGradleModule
 ) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/util/capabilities.kt

@@ -9,7 +9,7 @@ import org.gradle.api.capabilities.Capability
 import org.gradle.api.provider.Provider
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinGradleModule
 
-internal class CalculatedCapability(
+internal class ComputedCapability(
     val groupProvider: Provider<String>,
     val nameValue: String,
     val versionProvider: Provider<String>,
@@ -22,9 +22,9 @@ internal class CalculatedCapability(
     override fun getVersion(): String? = versionProvider.get()
 
     companion object {
-        fun fromModule(module: KotlinGradleModule): CalculatedCapability {
+        fun fromModule(module: KotlinGradleModule): ComputedCapability {
             val project = module.project
-            return CalculatedCapability(
+            return ComputedCapability(
                 project.provider { project.group.toString() },
                 project.name,
                 project.provider { project.version.toString() },
@@ -32,6 +32,11 @@ internal class CalculatedCapability(
             )
         }
 
+        fun fromModuleOrNull(module: KotlinGradleModule): ComputedCapability? =
+            if (module.moduleClassifier != null)
+                fromModule(module)
+            else null
+
         fun capabilityStringFromModule(module: KotlinGradleModule): String? =
             if (module.moduleClassifier != null) fromModule(module).notation() else null
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/variantPublishing.kt

@@ -6,16 +6,21 @@
 package org.jetbrains.kotlin.gradle.plugin.mpp.pm20
 
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ModuleDependency
-import org.gradle.api.attributes.Attribute
+import org.gradle.api.attributes.*
-import org.gradle.api.attributes.AttributeContainer
+import org.gradle.api.capabilities.Capability
 import org.gradle.api.component.AdhocComponentWithVariants
 import org.gradle.api.component.SoftwareComponentFactory
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.maven.internal.publication.DefaultMavenPublication
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.CalculatedCapability
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.ComputedCapability
 import org.jetbrains.kotlin.gradle.plugin.mpp.publishedConfigurationName
+import org.jetbrains.kotlin.gradle.plugin.usageByName
+import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
 import javax.inject.Inject
 
@@ -37,7 +42,7 @@ open class VariantPublishingConfigurator @Inject constructor(
     private val softwareComponentFactory: SoftwareComponentFactory
 ) {
     companion object {
-        fun get(project: Project) = project.objects.newInstance(VariantPublishingConfigurator::class.java, project)
+        fun get(project: Project): VariantPublishingConfigurator = project.objects.newInstance(VariantPublishingConfigurator::class.java, project)
     }
 
     open fun platformComponentName(variant: KotlinGradleVariant) = variant.disambiguateName("")
@@ -59,11 +64,29 @@ open class VariantPublishingConfigurator @Inject constructor(
         val componentName = platformComponentName(variant)
         val configurationsMap = inferMavenScopes(variant, publishConfigurations)
 
-        // FIXME: add the sources artifact of the variant to the publication!!!
+        registerPlatformModulePublication(
-        //  do that following the Gradle's guidelines on publishing sources variant along library variants, if possible
+            componentName,
+            publishedModuleHolder,
+            configurationsMap,
+            variant.containingModule::ifMadePublic
+        )
 
-        registerPlatformModulePublication(componentName, publishedModuleHolder, configurationsMap, variant.containingModule::ifMadePublic)
+        configureSourceElementsPublishing(variant)
-        registerPlatformVariantsInRootModule(publishedModuleHolder, variant.containingModule, publishConfigurations)
+
+        registerPlatformVariantsInRootModule(
+            publishedModuleHolder,
+            variant.containingModule,
+            publishConfigurations
+        )
+    }
+
+    protected open fun configureSourceElementsPublishing(variant: KotlinGradleVariant) {
+        val configurationName = variant.disambiguateName("sourceElements")
+        val componentName = platformComponentName(variant)
+        val docsVariants = DocumentationVariantConfigurator().createSourcesElementsConfiguration(configurationName, variant)
+        project.components.withType(AdhocComponentWithVariants::class.java).named(componentName).configure { component ->
+            component.addVariantsFromConfiguration(docsVariants) { }
+        }
     }
 
     /**
@@ -79,7 +102,7 @@ open class VariantPublishingConfigurator @Inject constructor(
     ) {
         val platformComponent = softwareComponentFactory.adhoc(componentName)
         project.components.add(platformComponent)
-        publishConfigurationsWithMavenScopes.forEach { configurationName, mavenScopeOrNull ->
+        publishConfigurationsWithMavenScopes.forEach { (configurationName, mavenScopeOrNull) ->
             platformComponent.addVariantsFromConfiguration(project.configurations.getByName(configurationName)) { variantDetails ->
                 mavenScopeOrNull?.let { variantDetails.mapToMavenScope(it) }
             }
@@ -108,7 +131,7 @@ open class VariantPublishingConfigurator @Inject constructor(
             val coordinates = publishedModuleHolder.publishedMavenModuleCoordinates
             (project.dependencies.create("${coordinates.group}:${coordinates.name}:${coordinates.version}") as ModuleDependency).apply {
                 if (kotlinModule.moduleClassifier != null) {
-                    capabilities { it.requireCapability(CalculatedCapability.fromModule(kotlinModule)) }
+                    capabilities { it.requireCapability(ComputedCapability.fromModule(kotlinModule)) }
                 }
             }
         }
@@ -138,4 +161,44 @@ open class VariantPublishingConfigurator @Inject constructor(
             }
         }
     }
+}
+
+open class DocumentationVariantConfigurator {
+    open fun createSourcesElementsConfiguration(
+        project: Project,
+        configurationName: String,
+        sourcesArtifactProvider: AbstractArchiveTask,
+        artifactClassifier: String,
+        capability: Capability?
+    ): Configuration {
+        return project.configurations.create(configurationName).apply {
+            isCanBeResolved = false
+            isCanBeConsumed = true
+//            attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_SOURCES))
+            attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category::class.java, Category.DOCUMENTATION))
+            attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling::class.java, Bundling.EXTERNAL))
+            attributes.attribute(DocsType.DOCS_TYPE_ATTRIBUTE, project.objects.named(DocsType::class.java, DocsType.SOURCES))
+            outgoing.artifact(sourcesArtifactProvider) {
+                it.classifier = artifactClassifier
+            }
+            if (capability != null) {
+                outgoing.capability(capability)
+            }
+        }
+    }
+
+    open fun createSourcesElementsConfiguration(
+        configurationName: String,
+        variant: KotlinGradleVariant
+    ): Configuration {
+        val sourcesArtifactTask = variant.project.tasks.withType<AbstractArchiveTask>().named(variant.sourceArchiveTaskName)
+        val artifactClassifier = dashSeparatedName(variant.containingModule.moduleClassifier, "sources")
+        return createSourcesElementsConfiguration(
+            variant.project,
+            configurationName,
+            sourcesArtifactTask.get(),
+            artifactClassifier,
+            ComputedCapability.fromModuleOrNull(variant.containingModule)
+        )
+    }
 }