From 3f2a790190da4f40ea6d8a976aa1929b2a1b002b Mon Sep 17 00:00:00 2001
From: Błażej Kardyś <bkardys@virtuslab.com>
Date: Tue, 5 May 2020 17:45:12 +0200
Subject: Changing approach from platform-driven to source-set-driven

---
 .../renderers/html/SourceSetDependentHintTest.kt   | 121 +++++++++++++++++++++
 1 file changed, 121 insertions(+)
 create mode 100644 plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
new file mode 100644
index 00000000..f774a09b
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -0,0 +1,121 @@
+package renderers.html
+
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.SourceRootImpl
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.pages.TextStyle
+import org.junit.jupiter.api.Test
+import renderers.Div
+import renderers.RenderingOnlyTestBase
+import renderers.TestPage
+import renderers.match
+
+class SourceSetDependentHintTest : RenderingOnlyTestBase() {
+    private val pl1 = SourceSetData("root", "pl1", Platform.js, listOf(SourceRootImpl("pl1")))
+    private val pl2 = SourceSetData("root","pl2", Platform.jvm, listOf(SourceRootImpl("pl1")))
+    private val pl3 = SourceSetData("root","pl3", Platform.native, listOf(SourceRootImpl("pl1")))
+
+    @Test
+    fun platformIndependentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+                text("c")
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("abc"))))
+    }
+
+    @Test
+    fun completelyDivergentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+                text("c", sourceSets = setOf(pl3))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("a")), Div(Div("b")), Div(Div("c"))))
+    }
+
+    @Test
+    fun overlappingCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl1, pl2))
+                text("c", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("ab")), Div(Div("bc"))))
+    }
+
+    @Test
+    fun caseThatCanBeSimplified() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1, pl2))
+                text("b", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("ab"))))
+    }
+
+    @Test
+    fun caseWithGroupBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                group(styles = setOf(TextStyle.Block)) {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div(Div("ab"))), Div(Div(Div("a"), "b"))))
+    }
+
+    @Test
+    fun caseWithGroupNotBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2)) {
+                group {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        println(renderedContent)
+        renderedContent.match(Div(Div("ab")))
+    }
+
+    @Test
+    fun partiallyUnifiedCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("a", sourceSets = setOf(pl2))
+                text("b", sourceSets = setOf(pl3))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("a")), Div(Div("b"))))
+    }
+}
\ No newline at end of file
-- 
cgit 


From 5f9299b074355e3f636da6eb6e1f9283f06ab8c7 Mon Sep 17 00:00:00 2001
From: Marcin Aman <maman@virtuslab.com>
Date: Thu, 21 May 2020 14:51:55 +0200
Subject: Return types links in inner classes with generic parents

---
 .../DefaultDescriptorToDocumentableTranslator.kt   | 15 ++++++--
 plugins/base/src/test/kotlin/basic/DRITest.kt      | 40 +++++++++++++++++++-
 .../kotlin/linkableContent/LinkableContentTest.kt  | 43 +++++++++++++++++++++-
 plugins/base/src/test/kotlin/markdown/LinkTest.kt  |  7 ++--
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt | 17 ---------
 .../renderers/html/SourceSetDependentHintTest.kt   |  1 -
 6 files changed, 97 insertions(+), 26 deletions(-)

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 65b83200..60182ba9 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -101,8 +101,7 @@ private class DokkaDescriptorVisitor(
         descriptor: PackageFragmentDescriptor,
         parent: DRIWithPlatformInfo
     ): DPackage {
-        val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?:
-            "[${sourceSet.sourceSetName} root]"// TODO: error-prone, find a better way to do it
+        val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?: fallbackPackageName()
         val driWithPlatform = DRI(packageName = name).withEmptyInfo()
         val scope = descriptor.getMemberScope()
 
@@ -544,7 +543,7 @@ private class DokkaDescriptorVisitor(
         is DynamicType -> Dynamic
         else -> when (val ctor = constructor.declarationDescriptor) {
             is TypeParameterDescriptor -> OtherParameter(
-                declarationDRI = DRI.from(ctor.containingDeclaration),
+                declarationDRI = DRI.from(ctor.containingDeclaration).withPackageFallbackTo(fallbackPackageName()),
                 name = ctor.name.asString()
             )
             else -> TypeConstructor(
@@ -694,4 +693,14 @@ private class DokkaDescriptorVisitor(
 
     private fun ConstantsEnumValue.fullEnumEntryName() =
         "${this.enumClassId.relativeClassName.asString()}.${this.enumEntryName.identifier}"
+
+    private fun fallbackPackageName(): String = "[${sourceSet.sourceSetName} root]"// TODO: error-prone, find a better way to do it
+}
+
+private fun DRI.withPackageFallbackTo(fallbackPackage: String): DRI {
+    return if(packageName.isNullOrBlank()){
+        copy(packageName = fallbackPackage)
+    } else {
+        this
+    }
 }
diff --git a/plugins/base/src/test/kotlin/basic/DRITest.kt b/plugins/base/src/test/kotlin/basic/DRITest.kt
index 1ac05177..b09932fe 100644
--- a/plugins/base/src/test/kotlin/basic/DRITest.kt
+++ b/plugins/base/src/test/kotlin/basic/DRITest.kt
@@ -4,6 +4,7 @@ import org.jetbrains.dokka.links.*
 import org.jetbrains.dokka.model.DClass
 import org.jetbrains.dokka.model.DFunction
 import org.jetbrains.dokka.model.DParameter
+import org.jetbrains.dokka.model.OtherParameter
 import org.jetbrains.dokka.pages.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
@@ -212,7 +213,7 @@ class DRITest : AbstractCoreTest() {
             |package example
             |
             |class Sample<S>(first: S){
-            |    fun <T> genericFun(param1: String): Triple<S,T> = TODO()
+            |    fun <T> genericFun(param1: String): Tuple<S,T> = TODO()
             |}
             |
             |
@@ -238,6 +239,43 @@ class DRITest : AbstractCoreTest() {
         }
     }
 
+    @Test
+    fun driForFunctionNestedInsideInnerClass() {
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/")
+                    classpath = listOfNotNull(jvmStdlibPath)
+                }
+            }
+        }
+        testInline(
+            """
+            |/src/main/kotlin/Test.kt
+            |package example
+            |
+            |class Sample<S>(first: S){
+            |    inner class SampleInner {
+            |       fun foo(): S = TODO()
+            |    }
+            |}
+            |
+            |
+        """.trimMargin(),
+            configuration
+        ) {
+            pagesGenerationStage = { module ->
+                val sampleClass = module.dfs { it.name == "Sample" } as ClasslikePageNode
+                val sampleInner = sampleClass.children.first { it.name == "SampleInner" } as ClasslikePageNode
+                val foo = sampleInner.children.first { it.name == "foo" } as MemberPageNode
+                val documentable = foo.documentable as DFunction
+
+                assertEquals(sampleClass.dri.first().toString(), (documentable.type as OtherParameter).declarationDRI.toString())
+                assertEquals(0, documentable.generics.size)
+            }
+        }
+    }
+
     @Test
     fun driForGenericExtensionFunction(){
         val configuration = dokkaConfiguration {
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index c34fa909..33d3f64c 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -11,7 +11,6 @@ import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import java.nio.file.Paths
 
@@ -182,4 +181,46 @@ class LinkableContentTest : AbstractCoreTest() {
             }
         }
     }
+
+    @Test
+    fun `Documenting return type for a function in inner class with generic parent`(){
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            |class Sample<S>(first: S){
+            |    inner class SampleInner {
+            |       fun foo(): S = TODO()
+            |    }
+            |}
+            |
+        """.trimIndent(),
+            dokkaConfiguration {
+                passes {
+                    pass {
+                        sourceRoots = listOf("src/")
+                        analysisPlatform = "jvm"
+                        targets = listOf("jvm")
+                    }
+                }
+            }
+        ) {
+            renderingStage = { module, _ ->
+                val sample = module.children.single { it.name == "test" }
+                    .children.single { it.name == "Sample" }.cast<ClasslikePageNode>()
+                val foo = sample
+                    .children.single { it.name == "SampleInner" }.cast<ClasslikePageNode>()
+                    .children.single { it.name == "foo" }.cast<MemberPageNode>()
+
+                val returnTypeNode = foo.content.dfs {
+                    val link = it.safeAs<ContentDRILink>()?.children
+                    val child = link?.first().safeAs<ContentText>()
+                    child?.text == "S"
+                }?.safeAs<ContentDRILink>()
+
+                Assertions.assertEquals(sample.dri.first(), returnTypeNode?.address)
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/markdown/LinkTest.kt b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
index bf234b6b..fe5b573a 100644
--- a/plugins/base/src/test/kotlin/markdown/LinkTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
@@ -51,14 +51,14 @@ class LinkTest : AbstractCoreTest() {
         val configuration = dokkaConfiguration {
             passes {
                 pass {
-                    sourceRoots = listOf("src/main/kotlin/parser")
+                    sourceRoots = listOf("src/main/kotlin")
                 }
             }
         }
+        //This does not contain a package to check for situation when the package has to be artificially generated
         testInline(
             """
             |/src/main/kotlin/parser/Test.kt
-            |package parser
             |
             |class Outer<OUTER> {
             |   inner class Inner<INNER> {
@@ -73,7 +73,8 @@ class LinkTest : AbstractCoreTest() {
                 val innerClass = root.children.first { it is ClasslikePageNode }
                 val foo = innerClass.children.first { it.name == "foo" } as MemberPageNode
 
-                assertNotNull(foo.content.dfs { it is ContentDRILink && it.address.toString() == "parser/Outer///PointingToDeclaration/" } )
+                assertEquals(root.dri.first().toString(), "[main root]/Outer///PointingToDeclaration/")
+                assertNotNull(foo.content.dfs { it is ContentDRILink && it.address.toString() == root.dri.first().toString() } )
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index dd4d1ee0..08d4a7b6 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -112,21 +112,4 @@ internal object EmptyCommentConverter : CommentsToContentConverter {
         styles: Set<Style>,
         extras: PropertyContainer<ContentNode>
     ): List<ContentNode> = emptyList()
-}
-
-internal object EmptyLocationProviderFactory: LocationProviderFactory {
-    override fun getLocationProvider(pageNode: RootPageNode) = object : LocationProvider {
-        override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String = ""
-
-        override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String = node.name
-
-        override fun resolveRoot(node: PageNode): String {
-            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
-        }
-
-        override fun ancestors(node: PageNode): List<PageNode> {
-            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
-        }
-
-    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index f774a09b..c1dc40a7 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -101,7 +101,6 @@ class SourceSetDependentHintTest : RenderingOnlyTestBase() {
         }
 
         HtmlRenderer(context).render(page)
-        println(renderedContent)
         renderedContent.match(Div(Div("ab")))
     }
 
-- 
cgit 


From f3baf10b4c882230d382bfcdd94163d070bd0e25 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Wed, 20 May 2020 12:05:26 +0200
Subject: Rework dokka configuration and Gradle plugin

---
 .idea/compiler.xml                                 | 148 +-----------------
 build.gradle.kts                                   |   7 +
 core/src/main/kotlin/DokkaGenerator.kt             |  14 +-
 core/src/main/kotlin/configuration.kt              |  10 +-
 core/src/main/kotlin/defaultConfiguration.kt       |  14 +-
 core/src/main/kotlin/model/SourceSetData.kt        |  23 ++-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  29 ++--
 .../kotlin/renderers/html/htmlPreprocessors.kt     |   2 +-
 .../resolvers/local/DefaultLocationProvider.kt     |  17 +--
 .../ModuleAndPackageDocumentationTransformer.kt    |   4 +-
 .../DefaultDescriptorToDocumentableTranslator.kt   |   2 +-
 .../annotations/ContentForAnnotationsTest.kt       |   1 -
 .../kotlin/content/params/ContentForParamsTest.kt  |   1 -
 .../content/seealso/ContentForSeeAlsoTest.kt       |   3 +-
 .../content/signatures/ContentForSignaturesTest.kt |   1 -
 .../kotlin/linkableContent/LinkableContentTest.kt  |   8 +-
 plugins/base/src/test/kotlin/markdown/LinkTest.kt  |   2 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |   2 -
 plugins/base/src/test/kotlin/model/PackagesTest.kt |   4 +-
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |   6 +-
 .../test/kotlin/renderers/html/DivergentTest.kt    |   6 +-
 .../renderers/html/SourceSetDependentHintTest.kt   |   6 +-
 plugins/base/src/test/kotlin/utils/ModelUtils.kt   |   2 -
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |   2 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  64 +++-----
 .../dokka/gradle/ConfigurationExtractor.kt         | 152 ++++++------------
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |   7 +-
 .../jetbrains/dokka/gradle/DokkaMultimoduleTask.kt |  10 +-
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt | 169 +++++++++++----------
 .../dokka/gradle/configurationImplementations.kt   |  11 +-
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |  24 ++-
 .../kotlin/org/jetbrains/dokka/gradle/utils.kt     |  17 ++-
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |  55 +++----
 settings.gradle.kts                                |   5 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  25 ++-
 35 files changed, 319 insertions(+), 534 deletions(-)

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index dd174dd7..a6b0adf4 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -12,148 +12,12 @@
       <entry name="!?*.clj" />
     </wildcardResourcePatterns>
     <bytecodeTargetLevel target="1.8">
-      <module name="android-gradle-plugin_main" target="1.8" />
-      <module name="android-gradle-plugin_test" target="1.8" />
-      <module name="ant_main" target="1.8" />
-      <module name="ant_test" target="1.8" />
-      <module name="base.dokka.plugins.base.main" target="1.8" />
-      <module name="base.dokka.plugins.base.test" target="1.8" />
-      <module name="blazejkardys.Workspace.dokka.buildSrc.main" target="1.8" />
-      <module name="blazejkardys.Workspace.dokka.buildSrc.test" target="1.8" />
-      <module name="buildSrc_main" target="1.8" />
-      <module name="buildSrc_test" target="1.8" />
-      <module name="cli.dokka.runners.cli.main" target="1.8" />
-      <module name="cli.dokka.runners.cli.test" target="1.8" />
-      <module name="cli_main" target="1.8" />
-      <module name="cli_test" target="1.8" />
-      <module name="core_main" target="1.8" />
-      <module name="core_test" target="1.8" />
-      <module name="dokka.core.search-component.main" target="1.8" />
-      <module name="dokka.core.search-component.test" target="1.8" />
-      <module name="dokka.core.testApi.main" target="1.8" />
-      <module name="dokka.core.testApi.test" target="1.8" />
-      <module name="dokka.integration.main" target="1.8" />
-      <module name="dokka.integration.test" target="1.8" />
-      <module name="dokka.plugins.base.search-component.main" target="1.8" />
-      <module name="dokka.plugins.base.search-component.test" target="1.8" />
-      <module name="dokka.plugins.javadoc8.main" target="1.8" />
-      <module name="dokka.plugins.javadoc8.test" target="1.8" />
-      <module name="dokka.plugins.ma.main" target="1.8" />
-      <module name="dokka.plugins.ma.test" target="1.8" />
-      <module name="dokka.plugins.xml.main" target="1.8" />
-      <module name="dokka.plugins.xml.test" target="1.8" />
-      <module name="dokka.runners.android-gradle-plugin.main" target="1.8" />
-      <module name="dokka.runners.android-gradle-plugin.test" target="1.8" />
-      <module name="dokka.runners.ant.main" target="1.8" />
-      <module name="dokka.runners.ant.test" target="1.8" />
-      <module name="dokka.runners.fatjar.main" target="1.8" />
-      <module name="dokka.runners.fatjar.test" target="1.8" />
-      <module name="dokka.runners.gradle-integration-tests.main" target="1.8" />
-      <module name="dokka.runners.gradle-integration-tests.test" target="1.8" />
-      <module name="fatjar_main" target="1.8" />
-      <module name="fatjar_test" target="1.8" />
-      <module name="gradle-integration-tests.dokka.integration-tests.gradle-integration-tests.main" target="1.8" />
-      <module name="gradle-integration-tests.dokka.integration-tests.gradle-integration-tests.test" target="1.8" />
-      <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.main" target="1.8" />
-      <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.test" target="1.8" />
-      <module name="gradle-integration-tests_main" target="1.8" />
-      <module name="gradle-integration-tests_test" target="1.8" />
-      <module name="gradle-plugin.dokka.runners.gradle-plugin.main" target="1.8" />
-      <module name="gradle-plugin.dokka.runners.gradle-plugin.test" target="1.8" />
-      <module name="gradle-plugin_main" target="1.8" />
-      <module name="gradle-plugin_test" target="1.8" />
-      <module name="integration_main" target="1.8" />
-      <module name="integration_test" target="1.8" />
-      <module name="kotlin-as-java.dokka.plugins.kotlin-as-java.main" target="1.8" />
-      <module name="kotlin-as-java.dokka.plugins.kotlin-as-java.test" target="1.8" />
-      <module name="mathjax.dokka.plugins.mathjax.main" target="1.8" />
-      <module name="mathjax.dokka.plugins.mathjax.test" target="1.8" />
-      <module name="maven-plugin.dokka.runners.maven-plugin.main" target="1.8" />
-      <module name="maven-plugin.dokka.runners.maven-plugin.test" target="1.8" />
-      <module name="maven-plugin_main" target="1.8" />
-      <module name="maven-plugin_test" target="1.8" />
-      <module name="org.jetbrains.dokka.android-gradle-plugin.main" target="1.8" />
-      <module name="org.jetbrains.dokka.android-gradle-plugin.test" target="1.8" />
-      <module name="org.jetbrains.dokka.ant.main" target="1.8" />
-      <module name="org.jetbrains.dokka.ant.test" target="1.8" />
-      <module name="org.jetbrains.dokka.buildSrc.main" target="1.8" />
-      <module name="org.jetbrains.dokka.buildSrc.test" target="1.8" />
-      <module name="org.jetbrains.dokka.cli.main" target="1.8" />
-      <module name="org.jetbrains.dokka.cli.test" target="1.8" />
-      <module name="org.jetbrains.dokka.core.main" target="1.8" />
-      <module name="org.jetbrains.dokka.core.test" target="1.8" />
-      <module name="org.jetbrains.dokka.coreDependencies.main" target="1.8" />
-      <module name="org.jetbrains.dokka.coreDependencies.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.core.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.core.search-component.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.core.search-component.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.core.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.coreDependencies.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.coreDependencies.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.integration-tests.gradle-integration-tests.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.integration-tests.gradle-integration-tests.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.integration-tests.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.integration-tests.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.base.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.base.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.gfm.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.gfm.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.jekyll.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.jekyll.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.kotlin-as-java.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.kotlin-as-java.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.mathjax.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.mathjax.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.plugins.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.cli.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.cli.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.gradle-plugin.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.gradle-plugin.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.maven-plugin.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.maven-plugin.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.runners.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.search-component.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.search-component.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.test-tools.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.test-tools.test" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.testApi.main" target="1.8" />
-      <module name="org.jetbrains.dokka.dokka.testApi.test" target="1.8" />
-      <module name="org.jetbrains.dokka.fatjar.main" target="1.8" />
-      <module name="org.jetbrains.dokka.fatjar.test" target="1.8" />
-      <module name="org.jetbrains.dokka.gradle-integration-tests.main" target="1.8" />
-      <module name="org.jetbrains.dokka.gradle-integration-tests.test" target="1.8" />
-      <module name="org.jetbrains.dokka.gradle-plugin.main" target="1.8" />
-      <module name="org.jetbrains.dokka.gradle-plugin.test" target="1.8" />
-      <module name="org.jetbrains.dokka.integration.main" target="1.8" />
-      <module name="org.jetbrains.dokka.integration.test" target="1.8" />
-      <module name="org.jetbrains.dokka.javadoc8.main" target="1.8" />
-      <module name="org.jetbrains.dokka.javadoc8.test" target="1.8" />
-      <module name="org.jetbrains.dokka.mathjax.main" target="1.8" />
-      <module name="org.jetbrains.dokka.mathjax.test" target="1.8" />
-      <module name="org.jetbrains.dokka.maven-plugin.main" target="1.8" />
-      <module name="org.jetbrains.dokka.maven-plugin.test" target="1.8" />
-      <module name="org.jetbrains.dokka.plugins.main" target="1.8" />
-      <module name="org.jetbrains.dokka.plugins.test" target="1.8" />
-      <module name="org.jetbrains.dokka.testApi.main" target="1.8" />
-      <module name="org.jetbrains.dokka.testApi.test" target="1.8" />
-      <module name="org.jetbrains.dokka.xml.main" target="1.8" />
-      <module name="org.jetbrains.dokka.xml.test" target="1.8" />
-      <module name="Workspace.dokka.buildSrc.main" target="1.8" />
-      <module name="Workspace.dokka.buildSrc.test" target="1.8" />
-      <module name="Workspace.dokka.core.main" target="1.8" />
-      <module name="Workspace.dokka.core.test" target="1.8" />
-      <module name="Workspace.dokka.coreDependencies.main" target="1.8" />
-      <module name="Workspace.dokka.coreDependencies.test" target="1.8" />
-      <module name="Workspace.dokka.integration-tests.main" target="1.8" />
-      <module name="Workspace.dokka.integration-tests.test" target="1.8" />
-      <module name="Workspace.dokka.plugins.main" target="1.8" />
-      <module name="Workspace.dokka.plugins.test" target="1.8" />
-      <module name="Workspace.dokka.runners.main" target="1.8" />
-      <module name="Workspace.dokka.runners.test" target="1.8" />
-      <module name="Workspace.dokka.testApi.main" target="1.8" />
-      <module name="Workspace.dokka.testApi.test" target="1.8" />
+      <module name="dokka" target="12" />
+      <module name="dokka.buildSrc" target="12" />
+      <module name="dokka.buildSrc.main" target="12" />
+      <module name="dokka.buildSrc.test" target="12" />
+      <module name="dokka.main" target="12" />
+      <module name="dokka.test" target="12" />
     </bytecodeTargetLevel>
   </component>
 </project>
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index 0b3c0da8..c94faa77 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -5,6 +5,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
     kotlin("jvm") apply false
     id("com.jfrog.bintray") apply false
+    id("java")
 }
 
 val dokka_version: String by project
@@ -39,6 +40,12 @@ allprojects {
 subprojects {
     apply {
         plugin("org.jetbrains.kotlin.jvm")
+        plugin("java")
+    }
+
+    // Gradle metadata
+    java {
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
 }
 
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 61fb7324..c8a892d7 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -5,7 +5,6 @@ import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.model.SourceSetData
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -81,7 +80,7 @@ class DokkaGenerator(
         sourceSetsCache: SourceSetCache
     ): Map<SourceSetData, EnvironmentAndFacade> =
         configuration.passesConfigurations.map {
-            sourceSetsCache.getSourceSet(it) to createEnvironmentAndFacade(it)
+            sourceSetsCache.getSourceSet(it) to createEnvironmentAndFacade(configuration, it)
         }.toMap()
 
     fun initializePlugins(
@@ -139,14 +138,21 @@ class DokkaGenerator(
         renderer.render(transformedPages)
     }
 
-    private fun createEnvironmentAndFacade(pass: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade =
+    private fun createEnvironmentAndFacade(
+        configuration: DokkaConfiguration,
+        pass: DokkaConfiguration.PassConfiguration
+    ): EnvironmentAndFacade =
         AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
             pass.classpath.forEach { addClasspath(File(it)) }
 
-            addSources((pass.sourceRoots + pass.dependentSourceRoots).map { it.path })
+            addSources(
+                (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
+                    .flatMap { it.sourceRoots })
+                    .map { it.path }
+            )
 
             loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
 
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index 0b59f301..fab7af37 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -27,20 +27,19 @@ enum class Platform(val key: String) {
 interface DokkaConfiguration {
     val outputDir: String
     val format: String
-    val generateIndexPages: Boolean
     val cacheRoot: String?
+    val offlineMode: Boolean
     val passesConfigurations: List<PassConfiguration>
     val modules: List<DokkaModuleDescription>
-    val impliedPlatforms: List<String>
     val pluginsClasspath: List<File>
     val pluginsConfiguration: Map<String, String>
 
     interface PassConfiguration {
         val moduleName: String
-        val sourceSetName: String
+        val displayName: String
+        val sourceSetID: String
         val classpath: List<String>
         val sourceRoots: List<SourceRoot>
-        val dependentSourceRoots: List<SourceRoot>
         val dependentSourceSets: List<String>
         val samples: List<String>
         val includes: List<String>
@@ -58,10 +57,7 @@ interface DokkaConfiguration {
         val noStdlibLink: Boolean
         val noJdkLink: Boolean
         val suppressedFiles: List<String>
-        val collectInheritedExtensionsFromLibraries: Boolean
         val analysisPlatform: Platform
-        val targets: List<String>
-        val sinceKotlin: String?
     }
 
     interface SourceRoot {
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index 7aaa1c89..23cf7e2d 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -6,21 +6,20 @@ import java.net.URL
 data class DokkaConfigurationImpl(
     override val outputDir: String,
     override val format: String,
-    override val generateIndexPages: Boolean,
     override val cacheRoot: String?,
-    override val impliedPlatforms: List<String>,
+    override val offlineMode: Boolean,
     override val passesConfigurations: List<PassConfigurationImpl>,
     override val pluginsClasspath: List<File>,
     override val pluginsConfiguration: Map<String, String>,
     override val modules: List<DokkaModuleDescriptionImpl>
 ) : DokkaConfiguration
 
-data class PassConfigurationImpl (
+data class PassConfigurationImpl(
     override val moduleName: String,
-    override val sourceSetName: String,
+    override val displayName: String,
+    override val sourceSetID: String,
     override val classpath: List<String>,
     override val sourceRoots: List<SourceRootImpl>,
-    override val dependentSourceRoots: List<SourceRootImpl>,
     override val dependentSourceSets: List<String>,
     override val samples: List<String>,
     override val includes: List<String>,
@@ -38,10 +37,7 @@ data class PassConfigurationImpl (
     override val noStdlibLink: Boolean,
     override val noJdkLink: Boolean,
     override val suppressedFiles: List<String>,
-    override val collectInheritedExtensionsFromLibraries: Boolean,
-    override val analysisPlatform: Platform,
-    override val targets: List<String>,
-    override val sinceKotlin: String?
+    override val analysisPlatform: Platform
 ) : DokkaConfiguration.PassConfiguration
 
 data class DokkaModuleDescriptionImpl(
diff --git a/core/src/main/kotlin/model/SourceSetData.kt b/core/src/main/kotlin/model/SourceSetData.kt
index 964d5ca9..7d118470 100644
--- a/core/src/main/kotlin/model/SourceSetData.kt
+++ b/core/src/main/kotlin/model/SourceSetData.kt
@@ -6,22 +6,33 @@ import org.jetbrains.dokka.plugability.DokkaContext
 
 data class SourceSetData(
     val moduleName: String,
-    val sourceSetName: String,
+    val sourceSetID: String,
+    val displayName: String,
     val platform: Platform,
     val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList(),
-    val dependentSourceSets: List<String>  = emptyList()
+    val dependentSourceSets: List<String> = emptyList()
 )
 
 class SourceSetCache {
     private val sourceSets = HashMap<String, SourceSetData>()
 
     val allSourceSets: List<SourceSetData>
-    get() = sourceSets.values.toList()
+        get() = sourceSets.values.toList()
 
     fun getSourceSet(pass: DokkaConfiguration.PassConfiguration) =
-        sourceSets.getOrPut("${pass.moduleName}/${pass.sourceSetName}",
-            { SourceSetData(pass.moduleName, pass.sourceSetName, pass.analysisPlatform, pass.sourceRoots, pass.dependentSourceSets) }
+        sourceSets.getOrPut("${pass.moduleName}/${pass.sourceSetID}",
+            {
+                SourceSetData(
+                    pass.moduleName,
+                    pass.sourceSetID,
+                    pass.displayName,
+                    pass.analysisPlatform,
+                    pass.sourceRoots,
+                    pass.dependentSourceSets
+                )
+            }
         )
 }
 
-fun DokkaContext.sourceSet(pass: DokkaConfiguration.PassConfiguration) : SourceSetData = sourceSetCache.getSourceSet(pass)
\ No newline at end of file
+fun DokkaContext.sourceSet(pass: DokkaConfiguration.PassConfiguration): SourceSetData =
+    sourceSetCache.getSourceSet(pass)
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 42273d20..528b7d16 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -22,7 +22,7 @@ open class HtmlRenderer(
 
     private val sourceSetDependencyMap = with(context.sourceSetCache) {
         allSourceSets.map { sourceSet ->
-            sourceSet to allSourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetName) }
+            sourceSet to allSourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetID ) }
         }.toMap()
     }
 
@@ -93,14 +93,14 @@ open class HtmlRenderer(
             group.sourceSets.forEach {
                 button(classes = "platform-tag platform-selector") {
                     attributes["data-active"] = ""
-                    attributes["data-filter"] = it.sourceSetName
-                    when (it.platform.key) {
+                    attributes["data-filter"] = it.sourceSetID
+                    when(it.platform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
                         "jvm" -> classes = classes + "jvm-like"
                         "js" -> classes = classes + "js-like"
                     }
-                    text(it.sourceSetName)
+                    text(it.displayName)
                 }
             }
         }
@@ -161,10 +161,10 @@ open class HtmlRenderer(
                     attributes["data-toggle-list"] = "data-toggle-list"
                     contents.forEachIndexed { index, pair ->
                         button(classes = "platform-bookmark") {
-                            attributes["data-filterable-current"] = pair.first.sourceSetName
-                            attributes["data-filterable-set"] = pair.first.sourceSetName
+                            attributes["data-filterable-current"] = pair.first.sourceSetID
+                            attributes["data-filterable-set"] = pair.first.sourceSetID
                             if (index == 0) attributes["data-active"] = ""
-                            attributes["data-toggle"] = pair.first.sourceSetName
+                            attributes["data-toggle"] = pair.first.sourceSetID
                             when (
                                 pair.first.platform.key
                                 ) {
@@ -173,8 +173,8 @@ open class HtmlRenderer(
                                 "jvm" -> classes = classes + "jvm-like"
                                 "js" -> classes = classes + "js-like"
                             }
-                            attributes["data-toggle"] = pair.first.sourceSetName
-                            text(pair.first.sourceSetName)
+                            attributes["data-toggle"] = pair.first.sourceSetID
+                            text(pair.first.displayName)
                         }
                     }
                 }
@@ -242,10 +242,10 @@ open class HtmlRenderer(
             consumer.onTagContentUnsafe {
                 +createHTML().div("divergent-group") {
                     attributes["data-filterable-current"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetName
+                        it.sourceSetID
                     }
                     attributes["data-filterable-set"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetName
+                        it.sourceSetID
                     }
 
                     val divergentForPlatformDependent = groupedDivergent.map { (sourceSet, elements) ->
@@ -346,12 +346,13 @@ open class HtmlRenderer(
                     div(classes = "table-row") {
                         if (!style.contains(MultimoduleTable)) {
                             attributes["data-filterable-current"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetName
+                                it.sourceSetID
                             }
                             attributes["data-filterable-set"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetName
+                                it.sourceSetID
                             }
                         }
+                        
                         it.filterIsInstance<ContentLink>().takeIf { it.isNotEmpty() }?.let {
                             div("main-subrow " + node.style.joinToString(" ")) {
                                 it.filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
@@ -396,7 +397,7 @@ open class HtmlRenderer(
                         "jvm" -> classes = classes + "jvm-like"
                         "js" -> classes = classes + "js-like"
                     }
-                    text(it.sourceSetName)
+                    text(it.displayName)
                 }
             }
         }
diff --git a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index f10c85d5..cdb30555 100644
--- a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -87,7 +87,7 @@ object StyleAndScriptsAppender : PageTransformer {
 class SourcesetDependencyAppender(val context: DokkaContext) : PageTransformer{
     override fun invoke(input: RootPageNode): RootPageNode {
         val dependenciesMap = context.configuration.passesConfigurations.map {
-            it.sourceSetName to it.dependentSourceSets
+            it.sourceSetID to it.dependentSourceSets
         }.toMap()
         fun createDependenciesJson() : String = "sourceset_dependencies = '{${
             dependenciesMap.entries.joinToString(", ") {
diff --git a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
index 322f4927..a9e58f17 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
@@ -98,26 +98,19 @@ open class DefaultLocationProvider(
                 if (info == null) {
                     toResolve.getOrPut(jdk) { mutableListOf() }.add(link)
                 } else if (info.packages.contains(dri.packageName)) {
-                    return link.url.toExternalForm() + getLink(
-                        dri,
-                        info
-                    )
+                    return link.url.toExternalForm() + getLink(dri, info)
                 }
             }
         }
         // Not in cache, resolve packageLists
         for ((jdk, links) in toResolve) {
             for (link in links) {
+                if(dokkaContext.configuration.offlineMode && link.packageListUrl.protocol.toLowerCase() != "file")
+                    continue
                 val locationInfo =
-                    loadPackageList(
-                        jdk,
-                        link.packageListUrl
-                    )
+                    loadPackageList(jdk, link.packageListUrl)
                 if (locationInfo.packages.contains(dri.packageName)) {
-                    return link.url.toExternalForm() + getLink(
-                        dri,
-                        locationInfo
-                    )
+                    return link.url.toExternalForm() + getLink(dri, locationInfo)
                 }
             }
             toResolve.remove(jdk)
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 04b2636c..2aab6018 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -53,7 +53,7 @@ internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContex
                 module.sourceSets.mapNotNull { pd ->
                     val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
                     val facade = context.platforms[pd]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") }
+                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetID}") }
                     try {
                         doc?.get("Module")?.get(module.name)?.run {
                             pd to MarkdownParser(
@@ -72,7 +72,7 @@ internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContex
                 it.name to it.sourceSets.mapNotNull { pd ->
                     val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
                     val facade = context.platforms[pd]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") }
+                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetID}") }
                     val descriptor = facade.moduleDescriptor.getPackage(FqName(it.name.let { if(it == "[JS root]") "" else it }))
                     doc?.get("Package")?.get(it.name)?.run {
                         pd to MarkdownParser(
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index bf92c849..33cad4f5 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -739,7 +739,7 @@ private class DokkaDescriptorVisitor(
     private fun ConstantsEnumValue.fullEnumEntryName() =
         "${this.enumClassId.relativeClassName.asString()}.${this.enumEntryName.identifier}"
 
-    private fun fallbackPackageName(): String = "[${sourceSet.sourceSetName} root]"// TODO: error-prone, find a better way to do it
+    private fun fallbackPackageName(): String = "[${sourceSet.displayName} root]"// TODO: error-prone, find a better way to do it
 }
 
 private fun DRI.withPackageFallbackTo(fallbackPackage: String): DRI {
diff --git a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
index d10bd151..f91b82d5 100644
--- a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
@@ -19,7 +19,6 @@ class ContentForAnnotationsTest : AbstractCoreTest() {
             pass {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
-                targets = listOf("jvm")
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index e25567e0..335d834e 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -12,7 +12,6 @@ class ContentForParamsTest : AbstractCoreTest() {
             pass {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
-                targets = listOf("jvm")
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
index c9adc0bf..696c3032 100644
--- a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
+++ b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
@@ -4,9 +4,9 @@ import matchers.content.*
 import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Test
+import utils.ParamAttributes
 import utils.bareSignature
 import utils.pWrapped
-import utils.ParamAttributes
 import utils.unnamedTag
 
 class ContentForSeeAlsoTest : AbstractCoreTest() {
@@ -15,7 +15,6 @@ class ContentForSeeAlsoTest : AbstractCoreTest() {
             pass {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
-                targets = listOf("jvm")
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
index bdefe45a..dc0488c8 100644
--- a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
@@ -16,7 +16,6 @@ class ContentForSignaturesTest : AbstractCoreTest() {
             pass {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
-                targets = listOf("jvm")
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index 7cdb0de3..d49ec8a5 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -27,7 +27,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "js"
-                    targets = listOf("js")
                     sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
@@ -37,7 +36,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "jvm"
-                    targets = listOf("jvm")
                     sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
@@ -68,7 +66,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "js"
-                    targets = listOf("js")
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
                     sourceLinks = listOf(
                         SourceLinkDefinitionImpl(
@@ -82,7 +79,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "jvm"
-                    targets = listOf("jvm")
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
                     sourceLinks = listOf(
                         SourceLinkDefinitionImpl(
@@ -133,7 +129,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "js"
-                    targets = listOf("js")
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
                     sourceSetName = "js"
                     samples = listOf("$testDataDir/jsMain/resources/Samples.kt")
@@ -141,7 +136,6 @@ class LinkableContentTest : AbstractCoreTest() {
                 pass {
                     moduleName = "example"
                     analysisPlatform = "jvm"
-                    targets = listOf("jvm")
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
                     sourceSetName = "jvm"
                     samples = listOf("$testDataDir/jvmMain/resources/Samples.kt")
@@ -199,7 +193,7 @@ class LinkableContentTest : AbstractCoreTest() {
                     pass {
                         sourceRoots = listOf("src/")
                         analysisPlatform = "jvm"
-                        targets = listOf("jvm")
+                        sourceSetName = "js"
                     }
                 }
             }
diff --git a/plugins/base/src/test/kotlin/markdown/LinkTest.kt b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
index 20bd24ee..ddcef5db 100644
--- a/plugins/base/src/test/kotlin/markdown/LinkTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
@@ -70,7 +70,7 @@ class LinkTest : AbstractCoreTest() {
                 val innerClass = root.children.first { it is ClasslikePageNode }
                 val foo = innerClass.children.first { it.name == "foo" } as MemberPageNode
 
-                assertEquals(root.dri.first().toString(), "[main root]/Outer///PointingToDeclaration/")
+                assertEquals(root.dri.first().toString(), "[JVM root]/Outer///PointingToDeclaration/")
                 assertNotNull(foo.content.dfs { it is ContentDRILink && it.address.toString() == root.dri.first().toString() } )
             }
         }
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index ce8a87ca..5daebb73 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -48,12 +48,10 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
                 pass {
                     sourceRoots = listOf("common/src/", "jvm/src/")
                     analysisPlatform = "jvm"
-                    targets = listOf("jvm")
                 }
                 pass {
                     sourceRoots = listOf("common/src/", "js/src/")
                     analysisPlatform = "js"
-                    targets = listOf("js")
                 }
             }
         }
diff --git a/plugins/base/src/test/kotlin/model/PackagesTest.kt b/plugins/base/src/test/kotlin/model/PackagesTest.kt
index 676f034a..c777ad05 100644
--- a/plugins/base/src/test/kotlin/model/PackagesTest.kt
+++ b/plugins/base/src/test/kotlin/model/PackagesTest.kt
@@ -14,8 +14,8 @@ class PackagesTest : AbstractModelTest("/src/main/kotlin/packages/Test.kt", "pac
             """.trimIndent(),
             prependPackage = false
         ) {
-            with((this / "[main root]").cast<DPackage>()) {
-                name equals "[main root]"
+            with((this / "[JVM root]").cast<DPackage>()) {
+                name equals "[JVM root]"
                 children counts 0
             }
         }
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index a3bf9188..a4d7bd04 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -33,10 +33,10 @@ abstract class RenderingOnlyTestBase {
         DokkaBase().outputWriter to { _ -> files },
         DokkaBase().locationProviderFactory to ::DefaultLocationProviderFactory,
         DokkaBase().htmlPreprocessors to { _ -> RootCreator },
-        DokkaBase().externalLocationProviderFactory to { _ -> ::JavadocExternalLocationProviderFactory },
-        DokkaBase().externalLocationProviderFactory to { _ -> ::DokkaExternalLocationProviderFactory },
+        DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
+        DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
         sourceSetCache = SourceSetCache(),
-        testConfiguration = DokkaConfigurationImpl("", "", false, null, emptyList(), emptyList(), emptyList(), emptyMap(), emptyList())
+        testConfiguration = DokkaConfigurationImpl("", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList())
     )
 
     protected val renderedContent: Element by lazy {
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index fa129760..b10202bb 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -10,9 +10,9 @@ import org.junit.jupiter.api.Test
 import renderers.*
 
 class DivergentTest : RenderingOnlyTestBase() {
-    private val js = SourceSetData("root", "JS", Platform.js, listOf(SourceRootImpl("pl1")))
-    private val jvm = SourceSetData("root", "JVM", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val native = SourceSetData("root", "NATIVE", Platform.native, listOf(SourceRootImpl("pl1")))
+    private val js = SourceSetData("root", "js", "JS", Platform.js, listOf(SourceRootImpl("pl1")))
+    private val jvm = SourceSetData("root", "jvm", "JVM", Platform.jvm, listOf(SourceRootImpl("pl1")))
+    private val native = SourceSetData("root", "native", "NATIVE", Platform.native, listOf(SourceRootImpl("pl1")))
 
     @Test
     fun simpleWrappingCase() {
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index c1dc40a7..878f442b 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -12,9 +12,9 @@ import renderers.TestPage
 import renderers.match
 
 class SourceSetDependentHintTest : RenderingOnlyTestBase() {
-    private val pl1 = SourceSetData("root", "pl1", Platform.js, listOf(SourceRootImpl("pl1")))
-    private val pl2 = SourceSetData("root","pl2", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val pl3 = SourceSetData("root","pl3", Platform.native, listOf(SourceRootImpl("pl1")))
+    private val pl1 = SourceSetData("root", "pl1", "pl3",Platform.js, listOf(SourceRootImpl("pl1")))
+    private val pl2 = SourceSetData("root","pl2", "pl3", Platform.jvm, listOf(SourceRootImpl("pl1")))
+    private val pl3 = SourceSetData("root","pl3", "pl3", Platform.native, listOf(SourceRootImpl("pl1")))
 
     @Test
     fun platformIndependentCase() {
diff --git a/plugins/base/src/test/kotlin/utils/ModelUtils.kt b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
index f65258b1..9697a843 100644
--- a/plugins/base/src/test/kotlin/utils/ModelUtils.kt
+++ b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
@@ -9,7 +9,6 @@ abstract class AbstractModelTest(val path: String? = null, val pkg: String) : Mo
     fun inlineModelTest(
         query: String,
         platform: String = "jvm",
-        targetList: List<String> = listOf("jvm"),
         prependPackage: Boolean = true,
         cleanupOutput: Boolean = true,
         pluginsOverrides: List<DokkaPlugin> = emptyList(),
@@ -21,7 +20,6 @@ abstract class AbstractModelTest(val path: String? = null, val pkg: String) : Mo
                 pass {
                     sourceRoots = listOf("src/")
                     analysisPlatform = platform
-                    targets = targetList
                 }
             }
         }
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index cc79291c..b10a45b8 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -120,7 +120,7 @@ open class CommonmarkRenderer(
             append(distinct.keys.single())
         else
             distinct.forEach { text, platforms ->
-                append(platforms.joinToString(prefix = " [", postfix = "] $text") { "${it.moduleName}/${it.sourceSetName}"  })
+                append(platforms.joinToString(prefix = " [", postfix = "] $text") { "${it.moduleName}/${it.sourceSetID}"  })
             }
     }
 
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index be42bc79..d217f83e 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -35,24 +35,22 @@ open class GlobalArguments(parser: DokkaArgumentsParser) : DokkaConfiguration {
         }
     }
 
-    override val generateIndexPages: Boolean by parser.singleFlag(
-        listOf("-generateIndexPages"),
-        "Generate index page"
-    )
-
     override val cacheRoot: String? by parser.stringOption(
         listOf("-cacheRoot"),
         "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled",
         null
     )
 
-    override val impliedPlatforms: List<String> = emptyList()
+    override val offlineMode: Boolean by parser.singleFlag(
+        listOf("-offlineMode"),
+        "Offline mode (do not download package lists from the Internet)"
+    )
 
     override val passesConfigurations: List<Arguments> by parser.repeatableFlag(
         listOf("-pass"),
         "Single dokka pass"
     ) {
-        Arguments(parser).also { if(it.moduleName.isEmpty()) DokkaConsoleLogger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module") }
+        Arguments(parser).also { if (it.moduleName.isEmpty()) DokkaConsoleLogger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module") }
     }
 
     override val modules: List<DokkaConfiguration.DokkaModuleDescription> = emptyList()
@@ -67,12 +65,17 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         ""
     )
 
-    override val sourceSetName: String by parser.stringOption(
-        listOf("-sourceSetName"),
-        "Name of the source set",
-        "main"
+    override val displayName: String by parser.stringOption(
+        listOf("-displayName"),
+        "Name displayed in the generated documentation",
+        ""
     )
 
+    override val sourceSetID: String by parser.stringOption(
+        listOf("-sourceSetID"),
+        "Source set ID used for declaring dependent source sets",
+        "main"
+    )
 
     override val classpath: List<String> by parser.repeatableOption<String>(
         listOf("-classpath"),
@@ -84,11 +87,6 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         "Source file or directory (allows many paths separated by the system path separator)"
     ) { SourceRootImpl(it) }
 
-    override val dependentSourceRoots: List<DokkaConfiguration.SourceRoot> by parser.repeatableOption(
-        listOf("-dependentRoots"),
-        "Source roots of dependent source sets"
-    ) { SourceRootImpl(it) }
-
     override val dependentSourceSets: List<String> by parser.repeatableOption<String>(
         listOf("-dependentSets"),
         "Names of dependent source sets"
@@ -163,16 +161,6 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         ""
     )
 
-    override val sinceKotlin: String? by parser.stringOption(
-        listOf("-sinceKotlin"),
-        "Kotlin Api version to use as base version, if none specified",
-        null
-    )
-
-    override val collectInheritedExtensionsFromLibraries: Boolean by parser.singleFlag(
-        listOf("-collectInheritedExtensionsFromLibraries"),
-        "Search for applicable extensions in libraries"
-    )
 
     override val analysisPlatform: Platform by parser.singleOption(
         listOf("-analysisPlatform"),
@@ -181,10 +169,6 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         { Platform.DEFAULT }
     )
 
-    override val targets: List<String> by parser.repeatableOption<String>(
-        listOf("-target"),
-        "Generation targets"
-    )
 
     override val perPackageOptions: MutableList<DokkaConfiguration.PackageOptions> by parser.singleOption(
         listOf("-packageOptions"),
@@ -215,16 +199,16 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
 object MainKt {
     fun defaultLinks(config: DokkaConfiguration.PassConfiguration): MutableList<ExternalDocumentationLink> =
         mutableListOf<ExternalDocumentationLink>().apply {
-        if (!config.noJdkLink)
-            this += DokkaConfiguration.ExternalDocumentationLink
-                .Builder("https://docs.oracle.com/javase/${config.jdkVersion}/docs/api/")
-                .build()
-
-        if (!config.noStdlibLink)
-            this += DokkaConfiguration.ExternalDocumentationLink
-                .Builder("https://kotlinlang.org/api/latest/jvm/stdlib/")
-                .build()
-    }
+            if (!config.noJdkLink)
+                this += DokkaConfiguration.ExternalDocumentationLink
+                    .Builder("https://docs.oracle.com/javase/${config.jdkVersion}/docs/api/")
+                    .build()
+
+            if (!config.noStdlibLink)
+                this += DokkaConfiguration.ExternalDocumentationLink
+                    .Builder("https://kotlinlang.org/api/latest/jvm/stdlib/")
+                    .build()
+        }
 
     fun parseLinks(links: String): List<ExternalDocumentationLink> {
         val (parsedLinks, parsedOfflineLinks) = links.split("^^")
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
index c69c6f67..44a0635f 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
@@ -1,9 +1,5 @@
 package org.jetbrains.dokka.gradle
 
-import com.android.build.gradle.*
-import com.android.build.gradle.api.BaseVariant
-import com.android.builder.core.BuilderConstants
-import org.gradle.api.NamedDomainObjectCollection
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.UnknownDomainObjectException
@@ -13,57 +9,60 @@ import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.jetbrains.dokka.ReflectDsl
-import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinSingleTargetExtension
-import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import java.io.File
 import java.io.Serializable
 
 class ConfigurationExtractor(private val project: Project) {
 
-    fun extractConfiguration(targetName: String, variantName: String?) =
-        extractFromKotlinProject(targetName, variantName)
-
-    fun extractFromKotlinProject(sourceSetName: String, variantName: String?): PlatformData? {
+    fun extractConfiguration(sourceSetName: String): PlatformData? {
         val projectExtension = project.extensions.getByType(KotlinProjectExtension::class.java)
         val sourceSet = projectExtension.sourceSets.findByName(sourceSetName)
             ?: run { project.logger.error("No source set with name '$sourceSetName' found"); return null }
         val compilation = when (projectExtension) {
-            is KotlinMultiplatformExtension -> projectExtension.targets.flatMap { it.compilations }
-                .find { it.kotlinSourceSets.contains(sourceSet) }
+            is KotlinMultiplatformExtension -> {
+                val targets = projectExtension.targets.flatMap { it.compilations }
+                targets.find { it.name == sourceSetName } ?: targets.find { it.kotlinSourceSets.contains(sourceSet) }
+            }
             is KotlinSingleTargetExtension -> projectExtension.target.compilations.find {
                 it.kotlinSourceSets.contains(sourceSet)
             }
             else -> null
-        } ?: run { project.logger.error("No compilation found for set with name '$sourceSetName'"); return null }
+        }
+
+        val sourceRoots = sourceSet.sourceFiles
+        val classpath = compilation?.classpath
+            ?: sourceRoots + sourceSet.allParentSourceFiles()
 
-        val classpath = compilation.compileDependencyFiles.files.filter { it.exists() }
-        val dependencies = (compilation.allKotlinSourceSets - sourceSet).flatMap { it.kotlin.sourceDirectories }
         return PlatformData(
             sourceSetName,
-            classpath,
-            sourceSet.kotlin.sourceDirectories.filter { it.exists() }.toList(),
-            dependencies,
-            sourceSet.dependsOn.map {  it.name },
-            compilation.target.targetName
+            classpath.filter { it.exists() },
+            sourceRoots,
+            sourceSet.dependsOn.map { it.name },
+            compilation?.target?.platformType?.name ?: "common"
         )
     }
 
+    private fun KotlinSourceSet.allParentSourceFiles(): List<File> =
+        sourceFiles + dependsOn.flatMap { it.allParentSourceFiles() }
+
     fun extractFromJavaPlugin(): PlatformData? =
         project.convention.findPlugin(JavaPluginConvention::class.java)
             ?.run { sourceSets.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.allSource?.srcDirs }
-            ?.let { PlatformData(null, emptyList(), it.toList(), emptyList(), emptyList(), "") }
+            ?.let { PlatformData(null, emptyList(), it.toList(), emptyList(), "") }
 
-    fun extractFromKotlinTasks(passName: String, kotlinTasks: List<Task>): PlatformData? =
+    fun extractFromKotlinTasks(kotlinTasks: List<Task>): List<PlatformData> =
         try {
-            kotlinTasks.find { it.toString() == passName }?.let { extractFromKotlinTask(it) }
+            kotlinTasks.map { extractFromKotlinTask(it) }
         } catch (e: Throwable) {
             when (e) {
                 is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    extractFromKotlinTasksTheHardWay(passName, kotlinTasks)
+                    listOfNotNull(extractFromKotlinTasksTheHardWay(kotlinTasks))
                 else -> throw e
             }
         }
@@ -80,18 +79,17 @@ class ConfigurationExtractor(private val project: Project) {
                         .flatMap { it.compilations }.firstOrNull { it.compileKotlinTask == task }
                 else -> throw e
             }
-        }.let {
+        }.let { compilation ->
             PlatformData(
                 task.name,
-                getClasspath(it),
-                getSourceSet(it),
-                getDependentSourceSetRoots(it),
-                getDependentSourceSet(it).map { it.name },
-                it?.platformType?.toString() ?: ""
+                compilation?.classpath.orEmpty(),
+                compilation?.sourceFiles.orEmpty(),
+                compilation?.dependentSourceSets?.map { it.name }.orEmpty(),
+                compilation?.platformType?.toString() ?: ""
             )
         }
 
-    private fun extractFromKotlinTasksTheHardWay(passName: String, kotlinTasks: List<Task>): PlatformData? {
+    private fun extractFromKotlinTasksTheHardWay(kotlinTasks: List<Task>): PlatformData? {
         val allClasspath = mutableSetOf<File>()
         var allClasspathFileCollection: FileCollection = project.files()
         val allSourceRoots = mutableSetOf<File>()
@@ -128,93 +126,41 @@ class ConfigurationExtractor(private val project: Project) {
         }
         classpath.addAll(project.files(allClasspath).toList())
 
-        return PlatformData(null, classpath, allSourceRoots.toList(), emptyList(), emptyList(),"")
+        return PlatformData(null, classpath, allSourceRoots.toList(), emptyList(), "")
     }
 
-    private fun getSourceSet(target: KotlinTarget, variantName: String? = null): List<File> =
-        if (variantName != null)
-            getSourceSet(getCompilation(target, variantName))
-        else
-            getSourceSet(getMainCompilation(target))
-
-    private fun getClasspath(target: KotlinTarget, variantName: String? = null): List<File> =
-        if (target.isAndroidTarget()) {
-            if (variantName != null)
-                getClasspathFromAndroidTask(getCompilation(target, variantName))
-            else
-                getClasspathFromAndroidTask(getMainCompilation(target))
-        } else {
-            getClasspath(getMainCompilation(target))
-        }
-
-    private fun getSourceSet(compilation: KotlinCompilation<*>?): List<File> = compilation
-        ?.kotlinSourceSets
-        ?.flatMap { it.kotlin.sourceDirectories }
-        ?.filter { it.exists() }
-        .orEmpty()
+    private val KotlinCompilation<*>.sourceFiles: List<File>
+        get() = kotlinSourceSets.flatMap { it.sourceFiles }
 
-    private fun getDependentSourceSet(compilation: KotlinCompilation<*>?) = compilation
-        ?.let { it.allKotlinSourceSets - it.kotlinSourceSets }.orEmpty()
+    private val KotlinSourceSet.sourceFiles: List<File>
+        get() = kotlin.sourceDirectories.filter { it.exists() }.toList()
 
-    private fun getDependentSourceSetRoots(compilation: KotlinCompilation<*>?): List<File> =
-        getDependentSourceSet(compilation)?.flatMap { it.kotlin.sourceDirectories }
-        .filter { it.exists() }
+    private val KotlinCompilation<*>.dependentSourceSets: Set<KotlinSourceSet>
+        get() = (allKotlinSourceSets - kotlinSourceSets)
 
-    private fun getClasspath(compilation: KotlinCompilation<*>?): List<File> = compilation
-        ?.compileDependencyFiles
-        ?.files
-        ?.toList()
-        ?.filter { it.exists() }
-        .orEmpty()
+    private val KotlinCompilation<*>.classpath: List<File>
+        get() = if (target.isAndroidTarget()) {
+            getClasspathFromAndroidTask(this)
+        } else {
+            getClasspathFromRegularTask(this)
+        }
 
     // This is a workaround for KT-33893
     private fun getClasspathFromAndroidTask(compilation: KotlinCompilation<*>): List<File> = (compilation
         .compileKotlinTask as? KotlinCompile)
-        ?.classpath?.files?.toList() ?: getClasspath(compilation)
-
-    private fun getMainCompilation(target: KotlinTarget) =
-        getCompilation(target, getMainCompilationName(target))
-
-    private fun getCompilation(target: KotlinTarget, name: String) =
-        target.compilations.getByName(name)
-
-    private fun getMainCompilationName(target: KotlinTarget) = if (target.isAndroidTarget())
-        getVariants(project).filter { it.buildType.name == BuilderConstants.RELEASE }.map { it.name }.first()
-    else
-        KotlinCompilation.MAIN_COMPILATION_NAME
-
-    private fun getVariants(project: Project): Set<BaseVariant> {
-        val androidExtension = project.extensions.getByName("android")
-        val baseVariants = when (androidExtension) {
-            is AppExtension -> androidExtension.applicationVariants.toSet()
-            is LibraryExtension -> {
-                androidExtension.libraryVariants.toSet() +
-                        if (androidExtension is FeatureExtension) {
-                            androidExtension.featureVariants.toSet()
-                        } else {
-                            emptySet<BaseVariant>()
-                        }
-            }
-            is TestExtension -> androidExtension.applicationVariants.toSet()
-            else -> emptySet()
-        }
-        val testVariants = if (androidExtension is TestedExtension) {
-            androidExtension.testVariants.toSet() + androidExtension.unitTestVariants.toSet()
-        } else {
-            emptySet<BaseVariant>()
-        }
-
-        return baseVariants + testVariants
-    }
+        ?.classpath?.files?.toList() ?: getClasspathFromRegularTask(compilation)
 
-    private fun getPlatformName(platform: KotlinPlatformType): String =
-        if (platform == KotlinPlatformType.androidJvm) KotlinPlatformType.jvm.toString() else platform.toString()
+    private fun getClasspathFromRegularTask(compilation: KotlinCompilation<*>): List<File> =
+        compilation
+            .compileDependencyFiles
+            .files
+            .toList()
+            .filter { it.exists() }
 
     data class PlatformData(
         val name: String?,
         val classpath: List<File>,
         val sourceRoots: List<File>,
-        val dependentSourceRoots: List<File>,
         val dependentSourceSets: List<String>,
         val platform: String
     ) : Serializable
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index f4fa7aaa..8c4e0c4c 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -20,7 +20,7 @@ open class DokkaCollectorTask : DefaultTask() {
 
     @TaskAction
     fun collect() {
-        val passesConfigurations = getProjects(project).filter { it.name in modules }.map {
+        val passesConfigurations = getProjects(project).filter { it.name in modules }.mapNotNull {
             val task = try {
                 it.tasks.getByName(DOKKA_TASK_NAME, DokkaTask::class)
             } catch (e: UnknownTaskException) {
@@ -33,12 +33,11 @@ open class DokkaCollectorTask : DefaultTask() {
             outputDir = outputDirectory
             cacheRoot = passesConfigurations.first().cacheRoot
             format = passesConfigurations.first().format
-            generateIndexPages = passesConfigurations.first().generateIndexPages
         }
 
         configuration = passesConfigurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
-            if(acc.format != it.format || acc.generateIndexPages != it.generateIndexPages || acc.cacheRoot != it.cacheRoot)
-                throw IllegalStateException("Dokka task configurations differ on core arguments (format, generateIndexPages, cacheRoot)")
+            if(acc.format != it.format || acc.cacheRoot != it.cacheRoot)
+                throw IllegalStateException("Dokka task configurations differ on core arguments (format, cacheRoot)")
             acc.passesConfigurations = acc.passesConfigurations + it.passesConfigurations
             acc.pluginsClasspath = (acc.pluginsClasspath + it.pluginsClasspath).distinct()
             acc
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
index a1bfdb96..2ef85de2 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultimoduleTask.kt
@@ -35,9 +35,9 @@ open class DokkaMultimoduleTask : DefaultTask(), Configurable {
         System.setProperty(DokkaTask.COLORS_ENABLED_PROPERTY, "false")
 
         try {
-            loadFatJar()
+            loadCore()
             val bootstrapClass =
-                ClassloaderContainer.fatJarClassLoader!!.loadClass("org.jetbrains.dokka.DokkaMultimoduleBootstrapImpl")
+                ClassloaderContainer.coreClassLoader!!.loadClass("org.jetbrains.dokka.DokkaMultimoduleBootstrapImpl")
             val bootstrapInstance = bootstrapClass.constructors.first().newInstance()
             val bootstrapProxy: DokkaBootstrap = automagicTypedProxy(
                 javaClass.classLoader,
@@ -85,10 +85,10 @@ open class DokkaMultimoduleTask : DefaultTask(), Configurable {
                 }
         }
 
-    private fun loadFatJar() {
-        if (ClassloaderContainer.fatJarClassLoader == null) {
+    private fun loadCore() {
+        if (ClassloaderContainer.coreClassLoader == null) {
             val jars = dokkaRuntime!!.resolve()
-            ClassloaderContainer.fatJarClassLoader = URLClassLoader(
+            ClassloaderContainer.coreClassLoader = URLClassLoader(
                 jars.map { it.toURI().toURL() }.toTypedArray(),
                 ClassLoader.getSystemClassLoader().parent
             )
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
index 2de95493..5a420d4d 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
@@ -15,15 +15,16 @@ import org.jetbrains.dokka.ReflectDsl
 import org.jetbrains.dokka.ReflectDsl.isNotInstance
 import org.jetbrains.dokka.gradle.ConfigurationExtractor.PlatformData
 import org.jetbrains.dokka.plugability.Configurable
-import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import java.io.File
 import java.net.URLClassLoader
 import java.util.concurrent.Callable
 import java.util.function.BiConsumer
+import kotlin.system.exitProcess
 
 open class DokkaTask : DefaultTask(), Configurable {
     private val ANDROID_REFERENCE_URL = Builder("https://developer.android.com/reference/").build()
     private val GLOBAL_CONFIGURATION_NAME = "global" // Used for copying perPackageOptions to other platforms
+    private val configExtractor = ConfigurationExtractor(project)
 
     @Suppress("MemberVisibilityCanBePrivate")
     fun defaultKotlinTasks(): List<Task> = with(ReflectDsl) {
@@ -57,8 +58,6 @@ open class DokkaTask : DefaultTask(), Configurable {
     var subProjects: List<String> = emptyList()
 
     @Input
-    var impliedPlatforms: MutableList<String> = arrayListOf()
-
     override val pluginsConfiguration: Map<String, String> = mutableMapOf()
 
     @Optional
@@ -66,54 +65,47 @@ open class DokkaTask : DefaultTask(), Configurable {
     var cacheRoot: String? = null
 
     @Classpath
-    lateinit var pluginsConfig: Configuration
+    lateinit var pluginsClasspathConfiguration: Configuration
 
     var dokkaSourceSets: NamedDomainObjectContainer<GradlePassConfigurationImpl>
         @Suppress("UNCHECKED_CAST")
         @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradlePassConfigurationImpl>)
         internal set(value) = DslObject(this).extensions.add(SOURCE_SETS_EXTENSION_NAME, value)
 
-    var configuration: GradlePassConfigurationImpl
-        @Suppress("UNCHECKED_CAST")
-        @Nested get() = DslObject(this).extensions.getByType(GradlePassConfigurationImpl::class.java)
-        internal set(value) = DslObject(this).extensions.add(CONFIGURATION_EXTENSION_NAME, value)
-
-    var config: GradleDokkaConfigurationImpl? = null
-
-    // Configure Dokka with closure in Gradle Kotlin DSL
-    fun configuration(action: Action<in GradlePassConfigurationImpl>) = action.execute(configuration)
-
     private val kotlinTasks: List<Task> by lazy {
-        extractKotlinCompileTasks(
-            configuration.collectKotlinTasks ?: { defaultKotlinTasks() })
+        extractKotlinCompileTasks({
+            dokkaSourceSets.map {
+                it.collectKotlinTasks?.invoke()
+            }
+        }.takeIf { it().isNotEmpty() } ?: { defaultKotlinTasks() }
+        )
     }
 
-    private val configExtractor = ConfigurationExtractor(project)
-
     @Input
     var disableAutoconfiguration: Boolean = false
 
+    @Input
+    var offlineMode: Boolean = false
+
     private var outputDiagnosticInfo: Boolean =
         false // Workaround for Gradle, which fires some methods (like collectConfigurations()) multiple times in its lifecycle
 
-    private fun loadFatJar() {
-        if (ClassloaderContainer.fatJarClassLoader == null) {
+    private fun loadCore() {
+        if (ClassloaderContainer.coreClassLoader == null) {
             val jars = dokkaRuntime!!.resolve()
-            ClassloaderContainer.fatJarClassLoader = URLClassLoader(
+            ClassloaderContainer.coreClassLoader = URLClassLoader(
                 jars.map { it.toURI().toURL() }.toTypedArray(),
                 ClassLoader.getSystemClassLoader().parent
             )
         }
     }
 
-    private fun extractKotlinCompileTasks(collectTasks: () -> List<Any?>?): List<Task> {
+    protected fun extractKotlinCompileTasks(collectTasks: () -> List<Any?>?): List<Task> {
         val inputList = (collectTasks.invoke() ?: emptyList()).filterNotNull()
         val (paths, other) = inputList.partition { it is String }
 
-        val taskContainer = project.tasks
-
         val tasksByPath = paths.map {
-            taskContainer.findByPath(it as String) ?: throw IllegalArgumentException("Task with path '$it' not found")
+            project.tasks.findByPath(it as String) ?: throw IllegalArgumentException("Task with path '$it' not found")
         }
 
         other
@@ -134,7 +126,7 @@ open class DokkaTask : DefaultTask(), Configurable {
     private fun Iterable<String>.toProjects(): List<Project> =
         project.subprojects.toList().filter { this.contains(it.name) }
 
-    private fun collectSuppressedFiles(sourceRoots: List<SourceRoot>) =
+    protected open fun collectSuppressedFiles(sourceRoots: List<SourceRoot>) =
         if (project.isAndroidProject()) {
             val generatedRoot = project.buildDir.resolve("generated").absoluteFile
             sourceRoots
@@ -147,25 +139,21 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
 
     @TaskAction
-    fun generate() {
-        generateForConfig(config ?: getConfiguration())
-    }
+    fun generate() = getConfiguration()?.let { generate(it) } ?: exitProcess(0)
 
-    internal fun generateForConfig(configuration: GradleDokkaConfigurationImpl) {
+    protected open fun generate(configuration: GradleDokkaConfigurationImpl) {
         outputDiagnosticInfo = true
         val kotlinColorsEnabledBefore = System.getProperty(COLORS_ENABLED_PROPERTY) ?: "false"
         System.setProperty(COLORS_ENABLED_PROPERTY, "false")
         try {
-            loadFatJar()
+            loadCore()
 
             val bootstrapClass =
-                ClassloaderContainer.fatJarClassLoader!!.loadClass("org.jetbrains.dokka.DokkaBootstrapImpl")
+                ClassloaderContainer.coreClassLoader!!.loadClass("org.jetbrains.dokka.DokkaBootstrapImpl")
             val bootstrapInstance = bootstrapClass.constructors.first().newInstance()
             val bootstrapProxy: DokkaBootstrap =
                 automagicTypedProxy(javaClass.classLoader, bootstrapInstance)
 
-            val gson = GsonBuilder().setPrettyPrinting().create()
-
             bootstrapProxy.configure(
                 BiConsumer { level, message ->
                     when (level) {
@@ -176,7 +164,7 @@ open class DokkaTask : DefaultTask(), Configurable {
                         "error" -> logger.error(message)
                     }
                 },
-                gson.toJson(configuration)
+                GsonBuilder().setPrettyPrinting().create().toJson(configuration)
             )
 
             bootstrapProxy.generate()
@@ -186,68 +174,78 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
     }
 
-    internal fun getConfiguration(): GradleDokkaConfigurationImpl {
+    internal open fun getConfiguration(): GradleDokkaConfigurationImpl? {
         val globalConfig = dokkaSourceSets.toList().find { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
-        val defaultModulesConfiguration = collectConfigurations()
-            .map { defaultPassConfiguration(it, globalConfig) }
+        val defaultModulesConfiguration = passConfigurations
+            .map { defaultPassConfiguration(it, globalConfig) }.takeIf { it.isNotEmpty() }
+            ?: listOf(
+                defaultPassConfiguration(
+                    collectSinglePassConfiguration(GradlePassConfigurationImpl("main")),
+                    null
+                )
+            ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
+
+        if (defaultModulesConfiguration.isEmpty()) {
+            logger.error("No source sets to document found, exiting")
+            return null
+        }
+
         return GradleDokkaConfigurationImpl().apply {
             outputDir = project.file(outputDirectory).absolutePath
             format = outputFormat
-            generateIndexPages = true
-            cacheRoot = cacheRoot
-            impliedPlatforms = impliedPlatforms
+            cacheRoot = this@DokkaTask.cacheRoot
+            offlineMode = this@DokkaTask.offlineMode
             passesConfigurations = defaultModulesConfiguration
-            pluginsClasspath = pluginsConfig.resolve().toList()
+            pluginsClasspath = pluginsClasspathConfiguration.resolve().toList()
             pluginsConfiguration = this@DokkaTask.pluginsConfiguration
         }
     }
 
-    private fun collectConfigurations() =
-        if (this.dokkaSourceSets.isNotEmpty()) collectMultipassConfiguration() else listOf(collectSinglePassConfiguration(configuration))
 
-    private fun collectMultipassConfiguration() = dokkaSourceSets
-        .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
-        .map { collectSinglePassConfiguration(it) }
+    protected val passConfigurations: List<GradlePassConfigurationImpl>
+        get() = dokkaSourceSets
+            .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
+            .map { collectSinglePassConfiguration(it) }
 
-    private fun collectSinglePassConfiguration(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
+    protected fun collectSinglePassConfiguration(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
         val userConfig = config
-        /*.let {
-            if (it.collectKotlinTasks != null) {
-                configExtractor.extractFromKotlinTasks(extractKotlinCompileTasks(it.collectKotlinTasks!!))
-                    ?.let { platformData -> mergeUserConfigurationAndPlatformData(it, platformData) } ?: it
-            } else {
-                it
+            .apply {
+                collectKotlinTasks?.let {
+                    configExtractor.extractFromKotlinTasks(extractKotlinCompileTasks(it))
+                        .fold(this) { config, platformData ->
+                            mergeUserConfigurationAndPlatformData(config, platformData)
+                        }
+                }
             }
-        }*/
 
         if (disableAutoconfiguration) return userConfig
 
-        val baseConfig = configExtractor.extractConfiguration(userConfig.name, userConfig.androidVariant)
+        val baseConfig = configExtractor.extractConfiguration(userConfig.name)
             ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
             ?: if (this.dokkaSourceSets.isNotEmpty()) {
                 if (outputDiagnosticInfo)
                     logger.warn(
-                        "Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin, " +
-                                "using only user provided configuration for this target"
+                        "Could not find source set with name: ${userConfig.name} in Kotlin Gradle Plugin, " +
+                                "using only user provided configuration for this source set"
                     )
                 userConfig
             } else {
-                logger.warn("Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin")
-                collectFromSinglePlatformOldPlugin(userConfig.name)
+                if (outputDiagnosticInfo)
+                    logger.warn("Could not find source set with name: ${userConfig.name} in Kotlin Gradle Plugin")
+                collectFromSinglePlatformOldPlugin(userConfig.name, userConfig)
             }
 
         return if (subProjects.isNotEmpty()) {
             try {
-                subProjects.toProjects().fold(baseConfig) { config, subProject ->
+                subProjects.toProjects().fold(baseConfig) { configAcc, subProject ->
                     mergeUserConfigurationAndPlatformData(
-                        config,
-                        ConfigurationExtractor(subProject).extractConfiguration(config.name, config.androidVariant)!!
+                        configAcc,
+                        ConfigurationExtractor(subProject).extractConfiguration(userConfig.name)!!
                     )
                 }
             } catch (e: NullPointerException) {
                 logger.warn(
-                    "Cannot extract sources from subProjects. Do you have the Kotlin plugin in version 1.3.30+ " +
-                            "and the Kotlin plugin applied in the root project?"
+                    "Cannot extract sources from subProjects. Do you have the Kotlin plugin applied in the root project?"
                 )
                 baseConfig
             }
@@ -256,49 +254,52 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
     }
 
-    private fun collectFromSinglePlatformOldPlugin(name: String) =
-        configExtractor.extractFromKotlinTasks(name, kotlinTasks)
-            ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
+    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradlePassConfigurationImpl) =
+        kotlinTasks.find { it.name == name }
+            ?.let { configExtractor.extractFromKotlinTasks(listOf(it)) }
+            ?.singleOrNull()
+            ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
             ?: configExtractor.extractFromJavaPlugin()
-                ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
-            ?: configuration
+                ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
+            ?: userConfig
 
-    private fun mergeUserConfigurationAndPlatformData(
+    protected fun mergeUserConfigurationAndPlatformData(
         userConfig: GradlePassConfigurationImpl,
         autoConfig: PlatformData
     ) =
         userConfig.copy().apply {
-            sourceSetName = autoConfig.name ?: ""
+            sourceSetID = autoConfig.name ?: ""
             sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
-            dependentSourceRoots.addAll(userConfig.dependentSourceRoots.union(autoConfig.dependentSourceRoots.toSourceRoots()).distinct())
             dependentSourceSets.addAll(userConfig.dependentSourceSets.union(autoConfig.dependentSourceSets).distinct())
             classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
             if (userConfig.platform == null && autoConfig.platform != "")
                 platform = autoConfig.platform
         }
 
-    private fun defaultPassConfiguration(
+    protected fun defaultPassConfiguration(
         config: GradlePassConfigurationImpl,
         globalConfig: GradlePassConfigurationImpl?
     ): GradlePassConfigurationImpl {
-        if (config.moduleName == "") {
+        if (config.moduleName.isBlank()) {
             config.moduleName = project.name
         }
-        if (config.sourceSetName.isEmpty()) {
-            config.sourceSetName = config.name.substringBeforeLast("Main").takeIf(String::isNotBlank) ?: config.platform.toString()
+        if (config.sourceSetID.isBlank()) {
+            config.sourceSetID = config.name.takeIf(String::isNotBlank) ?: config.analysisPlatform.key
         }
-        config.classpath = (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
+        config.displayName = config.sourceSetID.substringBeforeLast("Main")
+        config.classpath =
+            (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
         config.sourceRoots = config.sourceRoots.distinct().toMutableList()
         config.samples = config.samples.map { project.file(it).absolutePath }
         config.includes = config.includes.map { project.file(it).absolutePath }
         config.suppressedFiles += collectSuppressedFiles(config.sourceRoots)
-        if (project.isAndroidProject() && !config.noAndroidSdkLink) { // TODO: introduce Android as a separate Dokka platform?
+        if (project.isAndroidProject() && !config.noAndroidSdkLink) {
             config.externalDocumentationLinks.add(ANDROID_REFERENCE_URL)
         }
-        if (config.platform != null && config.platform.toString().isNotBlank()) {
+        if (config.platform?.isNotBlank() == true) {
             config.analysisPlatform = dokkaPlatformFromString(config.platform.toString())
         }
-        if (globalConfig != null) {
+        globalConfig?.let {
             config.perPackageOptions.addAll(globalConfig.perPackageOptions)
             config.externalDocumentationLinks.addAll(globalConfig.externalDocumentationLinks)
             config.sourceLinks.addAll(globalConfig.sourceLinks)
@@ -309,7 +310,7 @@ open class DokkaTask : DefaultTask(), Configurable {
     }
 
     private fun dokkaPlatformFromString(platform: String) = when (platform.toLowerCase()) {
-        KotlinPlatformType.androidJvm.toString().toLowerCase(), "androidjvm", "android" -> Platform.jvm
+        "androidjvm", "android" -> Platform.jvm
         "metadata" -> Platform.common
         else -> Platform.fromString(platform)
     }
@@ -321,7 +322,7 @@ open class DokkaTask : DefaultTask(), Configurable {
     // Needed for Gradle incremental build
     @InputFiles
     fun getInputFiles(): FileCollection {
-        val config = collectConfigurations()
+        val config = passConfigurations
         return project.files(config.flatMap { it.sourceRoots }.map { project.fileTree(File(it.path)) }) +
                 project.files(config.flatMap { it.includes }) +
                 project.files(config.flatMap { it.samples }.map { project.fileTree(File(it)) })
@@ -329,7 +330,7 @@ open class DokkaTask : DefaultTask(), Configurable {
 
     @Classpath
     fun getInputClasspath(): FileCollection =
-        project.files((collectConfigurations().flatMap { it.classpath } as List<Any>).map { project.fileTree(File(it.toString())) })
+        project.files((passConfigurations.flatMap { it.classpath } as List<Any>).map { project.fileTree(File(it.toString())) })
 
     companion object {
         const val COLORS_ENABLED_PROPERTY = "kotlin.colors.enabled"
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index 7fdadd41..2787bb4e 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -27,9 +27,9 @@ class GradleSourceRootImpl: SourceRoot, Serializable {
 open class GradlePassConfigurationImpl(@Transient val name: String = ""): PassConfiguration {
     @Input @Optional override var classpath: List<String> = emptyList()
     @Input override var moduleName: String = ""
-    @Input override var sourceSetName: String = ""
+    @Input override var displayName: String = ""
+    @Input override var sourceSetID: String = ""
     @Input override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
-    @Input override var dependentSourceRoots: MutableList<SourceRoot> = mutableListOf()
     @Input override var dependentSourceSets: MutableList<String> = mutableListOf()
     @Input override var samples: List<String> = emptyList()
     @Input override var includes: List<String> = emptyList()
@@ -48,13 +48,9 @@ open class GradlePassConfigurationImpl(@Transient val name: String = ""): PassCo
     @Input override var noJdkLink: Boolean = false
     @Input var noAndroidSdkLink: Boolean = false
     @Input override var suppressedFiles: List<String> = emptyList()
-    @Input override var collectInheritedExtensionsFromLibraries: Boolean = false
     @Input override var analysisPlatform: Platform = Platform.DEFAULT
     @Input @Optional var platform: String? = null
-    @Input override var targets: List<String> = emptyList()
-    @Input @Optional override var sinceKotlin: String? = null
     @Transient var collectKotlinTasks: (() -> List<Any?>?)? = null
-    @Input @Optional @Transient var androidVariant: String? = null
 
     fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
         collectKotlinTasks = { taskSupplier.call() }
@@ -129,9 +125,8 @@ class GradleDokkaModuleDescription: DokkaModuleDescription {
 class GradleDokkaConfigurationImpl: DokkaConfiguration {
     override var outputDir: String = ""
     override var format: String = "html"
-    override var generateIndexPages: Boolean = false
     override var cacheRoot: String? = null
-    override var impliedPlatforms: List<String> = emptyList()
+    override var offlineMode: Boolean = false
     override var passesConfigurations: List<GradlePassConfigurationImpl> = emptyList()
     override var pluginsClasspath: List<File> = emptyList()
     override var pluginsConfiguration: Map<String, String> = mutableMapOf()
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
index 1049656e..d2a0f043 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
@@ -8,23 +8,31 @@ import java.io.File
 import java.io.InputStream
 import java.util.*
 
-internal const val CONFIGURATION_EXTENSION_NAME = "configuration"
 internal const val SOURCE_SETS_EXTENSION_NAME = "dokkaSourceSets"
 internal const val DOKKA_TASK_NAME = "dokka"
 internal const val DOKKA_COLLECTOR_TASK_NAME = "dokkaCollector"
 internal const val DOKKA_MULTIMODULE_TASK_NAME = "dokkaMultimodule"
 
 open class DokkaPlugin : Plugin<Project> {
-
     override fun apply(project: Project) {
         loadDokkaVersion()
         val dokkaRuntimeConfiguration = addConfiguration(project)
         val pluginsConfiguration = project.configurations.create("dokkaPlugins").apply {
             dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-base:${DokkaVersion.version}"))
+            attributes.attribute(
+                    org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE,
+                    project.objects.named(org.gradle.api.attributes.Usage::class.java, "java-runtime")
+                )
+            isCanBeConsumed = false
         }
         addDokkaTasks(project, dokkaRuntimeConfiguration, pluginsConfiguration, DokkaTask::class.java)
         addDokkaCollectorTasks(project, DokkaCollectorTask::class.java)
-        addDokkaMultimoduleTasks(project.rootProject, dokkaRuntimeConfiguration, pluginsConfiguration, DokkaMultimoduleTask::class.java)
+        addDokkaMultimoduleTasks(
+            project.rootProject,
+            dokkaRuntimeConfiguration,
+            pluginsConfiguration,
+            DokkaMultimoduleTask::class.java
+        )
     }
 
     private fun loadDokkaVersion() =
@@ -32,7 +40,9 @@ open class DokkaPlugin : Plugin<Project> {
 
     private fun addConfiguration(project: Project) =
         project.configurations.create("dokkaRuntime").apply {
-            defaultDependencies { dependencies -> dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-core:${DokkaVersion.version}")) }
+            defaultDependencies { dependencies ->
+                dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-core:${DokkaVersion.version}"))
+            }
         }
 
     private fun addDokkaTasks(
@@ -48,9 +58,8 @@ open class DokkaPlugin : Plugin<Project> {
         }
         project.tasks.withType(taskClass) { task ->
             task.dokkaSourceSets = project.container(GradlePassConfigurationImpl::class.java)
-            task.configuration = GradlePassConfigurationImpl()
             task.dokkaRuntime = runtimeConfiguration
-            task.pluginsConfig = pluginsConfiguration
+            task.pluginsClasspathConfiguration = pluginsConfiguration
             task.outputDirectory = File(project.rootProject.buildDir, "$DOKKA_TASK_NAME/${project.name}").absolutePath
         }
     }
@@ -65,7 +74,6 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_COLLECTOR_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.modules = emptyList()
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
         }
     }
@@ -103,5 +111,5 @@ object DokkaVersion {
 
 object ClassloaderContainer {
     @JvmField
-    var fatJarClassLoader: ClassLoader? = null
+    var coreClassLoader: ClassLoader? = null
 }
\ No newline at end of file
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
index 3369a640..a4bf65ee 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
@@ -7,7 +7,7 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 
 
-fun Project.isAndroidProject() = try {
+internal fun Project.isAndroidProject() = try {
     project.extensions.getByName("android")
     true
 } catch(e: UnknownDomainObjectException) {
@@ -16,4 +16,17 @@ fun Project.isAndroidProject() = try {
     false
 }
 
-fun KotlinTarget.isAndroidTarget() = this.platformType == KotlinPlatformType.androidJvm
\ No newline at end of file
+internal fun Project.isNotMultiplatformProject() = !isMultiplatformProject()
+
+internal fun Project.isMultiplatformProject() = try {
+    project.extensions.getByType(KotlinMultiplatformExtension::class.java)
+    true
+} catch(e: UnknownDomainObjectException) {
+    false
+} catch (e: NoClassDefFoundError){
+    false
+} catch(e: ClassNotFoundException) {
+    false
+}
+
+internal fun KotlinTarget.isAndroidTarget() = this.platformType == KotlinPlatformType.androidJvm
\ No newline at end of file
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 8242d0d1..71fe5b40 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -29,11 +29,9 @@ import org.eclipse.aether.transport.file.FileTransporterFactory
 import org.eclipse.aether.transport.http.HttpTransporterFactory
 import org.eclipse.aether.util.graph.visitor.PreorderNodeListGenerator
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import java.io.File
 import java.net.URL
 
-
 class SourceLinkMapItem {
     @Parameter(name = "path", required = true)
     var path: String = ""
@@ -92,8 +90,6 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter
     var sourceRoots: List<SourceRoot> = emptyList()
 
-    @Parameter
-    var dependentSourceRoots: List<SourceRoot> = emptyList()
 
     @Parameter
     var dependentSourceSets: List<String> = emptyList()
@@ -146,6 +142,12 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter
     var cacheRoot: String? = null
 
+    @Parameter(defaultValue = "JVM")
+    var displayName: String = "JVM"
+
+    @Parameter(defaultValue = "false")
+    var offlineMode: Boolean = false
+
     @Parameter
     var languageVersion: String? = null
 
@@ -158,24 +160,13 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter
     var suppressedFiles: List<String> = emptyList()
 
-    @Parameter
-    var collectInheritedExtensionsFromLibraries: Boolean = false
 
     @Parameter
     var platform: String = ""
 
-    @Parameter
-    var targets: List<String> = emptyList()
-
-    @Parameter
-    var sinceKotlin: String? = null
-
     @Parameter
     var includeNonPublic: Boolean = false
 
-    @Parameter
-    var generateIndexPages: Boolean = false
-
     @Parameter
     var dokkaPlugins: List<Dependency> = emptyList()
 
@@ -209,19 +200,21 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
         }
 
         val passConfiguration = PassConfigurationImpl(
+            moduleName = moduleName,
+            displayName = displayName,
+            sourceSetID = sourceSetName,
             classpath = classpath,
-            sourceSetName = sourceSetName,
             sourceRoots = sourceDirectories.map { SourceRootImpl(it) },
-            dependentSourceRoots = dependentSourceRoots.map { SourceRootImpl(path = it.path) },
             dependentSourceSets = dependentSourceSets,
             samples = samples,
             includes = includes,
-            collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries, // TODO: Should we implement this?
-            sourceLinks = sourceLinks.map { SourceLinkDefinitionImpl(it.path, it.url, it.lineSuffix) },
-            jdkVersion = jdkVersion,
-            skipDeprecated = skipDeprecated,
-            skipEmptyPackages = skipEmptyPackages,
+            includeNonPublic = includeNonPublic,
+            includeRootPackage = includeRootPackage,
             reportUndocumented = reportUndocumented,
+            skipEmptyPackages = skipEmptyPackages,
+            skipDeprecated = skipDeprecated,
+            jdkVersion = jdkVersion,
+            sourceLinks = sourceLinks.map { SourceLinkDefinitionImpl(it.path, it.url, it.lineSuffix) },
             perPackageOptions = perPackageOptions.map {
                 PackageOptionsImpl(
                     prefix = it.prefix,
@@ -232,18 +225,13 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
                 )
             },
             externalDocumentationLinks = externalDocumentationLinks.map { it.build() as ExternalDocumentationLinkImpl },
-            noStdlibLink = noStdlibLink,
-            noJdkLink = noJdkLink,
             languageVersion = languageVersion,
             apiVersion = apiVersion,
-            moduleName = moduleName,
+            noStdlibLink = noStdlibLink,
+            noJdkLink = noJdkLink,
             suppressedFiles = suppressedFiles,
-            sinceKotlin = sinceKotlin,
-            analysisPlatform = if (platform.isNotEmpty()) Platform.fromString(platform) else Platform.DEFAULT,
-            targets = targets,
-            includeNonPublic = includeNonPublic,
-            includeRootPackage = includeRootPackage
-        ).let{
+            analysisPlatform = if (platform.isNotEmpty()) Platform.fromString(platform) else Platform.DEFAULT
+        ).let {
             it.copy(
                 externalDocumentationLinks = defaultLinks(it) + it.externalDocumentationLinks
             )
@@ -254,12 +242,11 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
         val configuration = DokkaConfigurationImpl(
             outputDir = getOutDir(),
             format = getOutFormat(),
-            impliedPlatforms = impliedPlatforms,
+            offlineMode = offlineMode,
             cacheRoot = cacheRoot,
             passesConfigurations = listOf(passConfiguration).also {
-                if(passConfiguration.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
+                if (passConfiguration.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
             },
-            generateIndexPages = generateIndexPages,
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
                     dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
             pluginsConfiguration = mutableMapOf(), //TODO implement as it is in Gradle
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 39a82007..b3e15ade 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,6 +1,7 @@
 rootProject.name = "dokka"
 
 include("core")
+include("plugins:base:search-component")
 include("coreDependencies")
 include("testApi")
 include("test-tools")
@@ -31,6 +32,4 @@ pluginManagement {
         jcenter()
         gradlePluginPortal()
     }
-}
-include("plugins:base:frontend")
-findProject(":plugins:base:frontend")?.name = "frontend"
+}
\ No newline at end of file
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 7f1be6b5..3aec2909 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -139,7 +139,7 @@ abstract class AbstractCoreTest {
     protected class DokkaConfigurationBuilder {
         var outputDir: String = "out"
         var format: String = "html"
-        var generateIndexPages: Boolean = true
+        var offlineMode: Boolean = false
         var cacheRoot: String? = null
         var pluginsClasspath: List<File> = emptyList()
         var pluginsConfigurations: Map<String, String> = emptyMap()
@@ -147,9 +147,8 @@ abstract class AbstractCoreTest {
         fun build() = DokkaConfigurationImpl(
             outputDir = outputDir,
             format = format,
-            generateIndexPages = generateIndexPages,
             cacheRoot = cacheRoot,
-            impliedPlatforms = emptyList(),
+            offlineMode = offlineMode,
             passesConfigurations = passesConfigurations,
             pluginsClasspath = pluginsClasspath,
             pluginsConfiguration = pluginsConfigurations,
@@ -171,9 +170,9 @@ abstract class AbstractCoreTest {
     protected class DokkaPassConfigurationBuilder(
         var moduleName: String = "root",
         var sourceSetName: String = "main",
+        var displayName: String = "JVM",
         var classpath: List<String> = emptyList(),
         var sourceRoots: List<String> = emptyList(),
-        var dependentSourceRoots: List<String> = emptyList(),
         var dependentSourceSets: List<String> = emptyList(),
         var samples: List<String> = emptyList(),
         var includes: List<String> = emptyList(),
@@ -188,20 +187,17 @@ abstract class AbstractCoreTest {
         var noStdlibLink: Boolean = false,
         var noJdkLink: Boolean = false,
         var suppressedFiles: List<String> = emptyList(),
-        var collectInheritedExtensionsFromLibraries: Boolean = true,
         var analysisPlatform: String = "jvm",
-        var targets: List<String> = listOf("jvm"),
-        var sinceKotlin: String? = null,
         var perPackageOptions: List<PackageOptionsImpl> = emptyList(),
         var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
         var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
     ) {
         fun build() = PassConfigurationImpl(
             moduleName = moduleName,
-            sourceSetName = sourceSetName,
+            displayName = displayName,
+            sourceSetID = sourceSetName,
             classpath = classpath,
             sourceRoots = sourceRoots.map { SourceRootImpl(it) },
-            dependentSourceRoots = dependentSourceRoots.map { SourceRootImpl(it) },
             dependentSourceSets = dependentSourceSets,
             samples = samples,
             includes = includes,
@@ -211,18 +207,15 @@ abstract class AbstractCoreTest {
             skipEmptyPackages = skipEmptyPackages,
             skipDeprecated = skipDeprecated,
             jdkVersion = jdkVersion,
+            sourceLinks = sourceLinks,
+            perPackageOptions = perPackageOptions,
+            externalDocumentationLinks = externalDocumentationLinks,
             languageVersion = languageVersion,
             apiVersion = apiVersion,
             noStdlibLink = noStdlibLink,
             noJdkLink = noJdkLink,
             suppressedFiles = suppressedFiles,
-            collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries,
-            analysisPlatform = Platform.fromString(analysisPlatform),
-            targets = targets,
-            sinceKotlin = sinceKotlin,
-            perPackageOptions = perPackageOptions,
-            externalDocumentationLinks = externalDocumentationLinks,
-            sourceLinks = sourceLinks
+            analysisPlatform = Platform.fromString(analysisPlatform)
         )
     }
 
-- 
cgit 


From 8cb6efc97f8fa321381c95cc5f85a3ce7bc13c3f Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 19 Jun 2020 14:08:49 +0200
Subject: Remove SourceSetDataCache, rename PassConfiguration to DokkaSourceSet
 and use it instead of SourceSetData

---
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   6 +-
 core/src/main/kotlin/DokkaGenerator.kt             |  25 ++--
 core/src/main/kotlin/configuration.kt              |   4 +-
 core/src/main/kotlin/defaultConfiguration.kt       |   6 +-
 core/src/main/kotlin/model/Documentable.kt         |  59 +++++----
 core/src/main/kotlin/model/SourceSetData.kt        |  38 ------
 .../main/kotlin/model/documentableProperties.kt    |  12 +-
 core/src/main/kotlin/model/documentableUtils.kt    |  12 +-
 core/src/main/kotlin/pages/ContentNodes.kt         |  35 ++---
 core/src/main/kotlin/plugability/DokkaContext.kt   |   8 +-
 .../sources/SourceToDocumentableTranslator.kt      |   4 +-
 .../dokka/analysis/EnvironmentAndFacade.kt         |  10 +-
 .../org/jetbrains/dokka/analysis/KotlinAnalysis.kt |  24 ++--
 .../kotlin/allModulePage/MultimodulePageCreator.kt |  10 +-
 .../src/main/kotlin/renderers/DefaultRenderer.kt   |  28 ++--
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  60 +++++----
 .../main/kotlin/renderers/html/NavigationPage.kt   |   8 +-
 .../kotlin/renderers/html/htmlPreprocessors.kt     |   2 +-
 .../resolvers/local/DefaultLocationProvider.kt     |  16 +--
 .../kotlin/resolvers/local/LocationProvider.kt     |   4 +-
 .../resolvers/local/MultimoduleLocationProvider.kt |   6 +-
 .../main/kotlin/signatures/JvmSignatureUtils.kt    |  12 +-
 .../kotlin/signatures/KotlinSignatureProvider.kt   |  16 ++-
 .../DeprecatedDocumentableFilterTransformer.kt     |  10 +-
 .../DocumentableVisibilityFilterTransformer.kt     |  36 +++--
 .../EmptyPackagesFilterTransformer.kt              |   8 +-
 .../InheritorsExtractorTransformer.kt              |   7 +-
 .../ModuleAndPackageDocumentationTransformer.kt    |   9 +-
 .../documentables/ReportUndocumentedTransformer.kt |  38 ++----
 .../pages/comments/CommentsToContentConverter.kt   |   4 +-
 .../pages/comments/DocTagToContentConverter.kt     |   4 +-
 .../pages/samples/SamplesTransformer.kt            |  13 +-
 .../pages/sourcelinks/SourceLinksTransformer.kt    |  18 +--
 .../DefaultDescriptorToDocumentableTranslator.kt   |  19 +--
 .../documentables/DefaultPageCreator.kt            | 147 +++++++++++++++------
 .../documentables/PageContentBuilder.kt            |  76 +++++------
 .../psi/DefaultPsiToDocumentableTranslator.kt      |   9 +-
 .../kotlin/content/params/ContentForParamsTest.kt  |  14 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |   6 +-
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |   9 +-
 .../test/kotlin/renderers/html/DivergentTest.kt    |  32 ++++-
 .../renderers/html/SourceSetDependentHintTest.kt   |  26 +++-
 .../test/kotlin/renderers/html/defaultSourceSet.kt |  30 +++++
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |  19 +--
 .../main/kotlin/javadoc/JavadocLocationProvider.kt |  35 ++---
 .../src/main/kotlin/javadoc/JavadocPageCreator.kt  |  19 +--
 .../main/kotlin/javadoc/KorteJavadocRenderer.kt    |  10 +-
 .../kotlin/javadoc/pages/JavadocContentNodes.kt    |  22 +--
 .../main/kotlin/javadoc/pages/JavadocPageNodes.kt  |   2 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  24 ++--
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |   2 +-
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  22 +--
 .../dokka/gradle/configurationImplementations.kt   |  98 +++++++++-----
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   2 +-
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |   9 +-
 .../src/main/kotlin/testApi/context/MockContext.kt |   6 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |   8 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  22 ++-
 58 files changed, 656 insertions(+), 564 deletions(-)
 delete mode 100644 core/src/main/kotlin/model/SourceSetData.kt
 create mode 100644 plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index 94792303..bd632546 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -84,7 +84,7 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
     fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) = with(configuration) {
 
-        fun defaultLinks(config: PassConfigurationImpl): List<ExternalDocumentationLinkImpl> {
+        fun defaultLinks(config: DokkaSourceSetImpl): List<ExternalDocumentationLinkImpl> {
             val links = mutableListOf<ExternalDocumentationLinkImpl>()
             if (!config.noJdkLink)
                 links += DokkaConfiguration.ExternalDocumentationLink
@@ -100,8 +100,8 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
         val configurationWithLinks =
             configuration.copy(
-                passesConfigurations =
-                passesConfigurations.map {
+                sourceSets =
+                sourceSets.map {
                     val links: List<ExternalDocumentationLinkImpl> =
                         it.externalDocumentationLinks + defaultLinks(it)
                     it.copy(externalDocumentationLinks = links)
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b88c6223..ce8d229a 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,8 +1,7 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.*
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -18,13 +17,11 @@ class DokkaGenerator(
     private val logger: DokkaLogger
 ) {
     fun generate() = timed {
-        val sourceSetsCache = SourceSetCache()
-
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSetsCache)
+        val context = initializePlugins(configuration, logger)
 
         report("Creating documentation models")
-        val modulesFromPlatforms = createDocumentationModels(context, sourceSetsCache)
+        val modulesFromPlatforms = createDocumentationModels(context)
 
         report("Transforming documentation model before merging")
         val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
@@ -48,9 +45,8 @@ class DokkaGenerator(
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
     fun generateAllModulesPage() = timed {
-        val sourceSetsCache = SourceSetCache()
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSetsCache)
+        val context = initializePlugins(configuration, logger)
 
         report("Creating all modules page")
         val pages = createAllModulePage(context)
@@ -66,15 +62,12 @@ class DokkaGenerator(
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        sourceSetsCache: SourceSetCache,
         pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, sourceSetsCache, pluginOverrides)
+    ) = DokkaContext.create(configuration, logger, pluginOverrides)
 
     fun createDocumentationModels(
-        context: DokkaContext,
-        sourceSetsCache: SourceSetCache
-    ) = context.configuration.passesConfigurations
-        .map { passConfiguration -> sourceSetsCache.getSourceSet(passConfiguration) }
+        context: DokkaContext
+    ) = context.configuration.sourceSets
         .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
 
     fun transformDocumentationModelBeforeMerge(
@@ -133,9 +126,9 @@ class DokkaGenerator(
         }
     }
 
-    private fun translateSources(platformData: SourceSetData, context: DokkaContext) =
+    private fun translateSources(sourceSet: DokkaSourceSet, context: DokkaContext) =
         context[CoreExtensions.sourceToDocumentableTranslator].map {
-            it.invoke(platformData, context)
+            it.invoke(sourceSet, context)
         }
 }
 
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index b016f83d..463d2342 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -49,12 +49,12 @@ interface DokkaConfiguration {
     val cacheRoot: String?
     val offlineMode: Boolean
     val failOnWarning: Boolean
-    val passesConfigurations: List<PassConfiguration>
+    val sourceSets: List<DokkaSourceSet>
     val modules: List<DokkaModuleDescription>
     val pluginsClasspath: List<File>
     val pluginsConfiguration: Map<String, String>
 
-    interface PassConfiguration {
+    interface DokkaSourceSet {
         val moduleName: String
         val displayName: String
         val sourceSetID: String
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index 4e83d3c3..d3ac9df2 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -8,14 +8,14 @@ data class DokkaConfigurationImpl(
     override val format: String,
     override val cacheRoot: String?,
     override val offlineMode: Boolean,
-    override val passesConfigurations: List<PassConfigurationImpl>,
+    override val sourceSets: List<DokkaSourceSetImpl>,
     override val pluginsClasspath: List<File>,
     override val pluginsConfiguration: Map<String, String>,
     override val modules: List<DokkaModuleDescriptionImpl>,
     override val failOnWarning: Boolean
 ) : DokkaConfiguration
 
-data class PassConfigurationImpl(
+data class DokkaSourceSetImpl(
     override val moduleName: String,
     override val displayName: String,
     override val sourceSetID: String,
@@ -39,7 +39,7 @@ data class PassConfigurationImpl(
     override val noJdkLink: Boolean,
     override val suppressedFiles: List<String>,
     override val analysisPlatform: Platform
-) : DokkaConfiguration.PassConfiguration
+) : DokkaConfiguration.DokkaSourceSet
 
 data class DokkaModuleDescriptionImpl(
     override val name: String,
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 768bddc5..35278302 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.model
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.properties.PropertyContainer
@@ -11,8 +12,8 @@ abstract class Documentable {
     abstract val dri: DRI
     abstract val children: List<Documentable>
     abstract val documentation: SourceSetDependent<DocumentationNode>
-    abstract val sourceSets: Set<SourceSetData>
-    abstract val expectPresentInSet: SourceSetData?
+    abstract val sourceSets: Set<DokkaSourceSet>
+    abstract val expectPresentInSet: DokkaSourceSet?
 
     override fun toString(): String =
         "${javaClass.simpleName}($dri)"
@@ -23,7 +24,7 @@ abstract class Documentable {
     override fun hashCode() = dri.hashCode()
 }
 
-typealias SourceSetDependent<T> = Map<SourceSetData, T>
+typealias SourceSetDependent<T> = Map<DokkaSourceSet, T>
 
 interface WithExpectActual {
     val sources: SourceSetDependent<DocumentableSource>
@@ -88,8 +89,8 @@ data class DModule(
     override val name: String,
     val packages: List<DPackage>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData? = null,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet? = null,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DModule> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DModule> {
     override val dri: DRI = DRI.topLevel
@@ -106,8 +107,8 @@ data class DPackage(
     override val classlikes: List<DClasslike>,
     val typealiases: List<DTypeAlias>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData? = null,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet? = null,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DPackage> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DPackage> {
     override val name = dri.packageName.orEmpty()
@@ -130,9 +131,9 @@ data class DClass(
     override val generics: List<DTypeParameter>,
     override val supertypes: SourceSetDependent<List<DRI>>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DClass> = PropertyContainer.empty()
 ) : DClasslike(), WithAbstraction, WithCompanion, WithConstructors, WithGenerics, WithSupertypes,
     WithExtraProperties<DClass> {
@@ -148,7 +149,7 @@ data class DEnum(
     override val name: String,
     val entries: List<DEnumEntry>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -157,7 +158,7 @@ data class DEnum(
     override val companion: DObject?,
     override val constructors: List<DFunction>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DEnum> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithSupertypes, WithExtraProperties<DEnum> {
     override val children: List<Documentable>
@@ -170,11 +171,11 @@ data class DEnumEntry(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DEnumEntry> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DEnumEntry> {
     override val children: List<Documentable>
@@ -189,14 +190,14 @@ data class DFunction(
     val isConstructor: Boolean,
     val parameters: List<DParameter>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
     override val generics: List<DTypeParameter>,
     override val receiver: DParameter?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DFunction> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithGenerics, WithExtraProperties<DFunction> {
     override val children: List<Documentable>
@@ -209,7 +210,7 @@ data class DInterface(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -218,7 +219,7 @@ data class DInterface(
     override val companion: DObject?,
     override val generics: List<DTypeParameter>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DInterface> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithGenerics, WithSupertypes, WithExtraProperties<DInterface> {
     override val children: List<Documentable>
@@ -231,14 +232,14 @@ data class DObject(
     override val name: String?,
     override val dri: DRI,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
     override val visibility: SourceSetDependent<Visibility>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DObject> = PropertyContainer.empty()
 ) : DClasslike(), WithSupertypes, WithExtraProperties<DObject> {
     override val children: List<Documentable>
@@ -251,7 +252,7 @@ data class DAnnotation(
     override val name: String,
     override val dri: DRI,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -260,7 +261,7 @@ data class DAnnotation(
     override val companion: DObject?,
     override val constructors: List<DFunction>,
     override val generics: List<DTypeParameter>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DAnnotation> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithExtraProperties<DAnnotation>, WithGenerics {
     override val children: List<Documentable>
@@ -273,7 +274,7 @@ data class DProperty(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
@@ -281,7 +282,7 @@ data class DProperty(
     val setter: DFunction?,
     val getter: DFunction?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val generics: List<DTypeParameter>,
     override val extra: PropertyContainer<DProperty> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithExtraProperties<DProperty>, WithGenerics {
@@ -296,9 +297,9 @@ data class DParameter(
     override val dri: DRI,
     override val name: String?,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     val type: Bound,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DParameter> {
     override val children: List<Nothing>
@@ -311,9 +312,9 @@ data class DTypeParameter(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     val bounds: List<Bound>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DTypeParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DTypeParameter> {
     override val children: List<Nothing>
@@ -329,8 +330,8 @@ data class DTypeAlias(
     val underlyingType: SourceSetDependent<Bound>,
     override val visibility: SourceSetDependent<Visibility>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet?,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DTypeAlias> = PropertyContainer.empty()
 ) : Documentable(), WithType, WithVisibility, WithExtraProperties<DTypeAlias> {
     override val children: List<Nothing>
diff --git a/core/src/main/kotlin/model/SourceSetData.kt b/core/src/main/kotlin/model/SourceSetData.kt
deleted file mode 100644
index 3e38cc7b..00000000
--- a/core/src/main/kotlin/model/SourceSetData.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.jetbrains.dokka.model
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Platform
-import org.jetbrains.dokka.plugability.DokkaContext
-
-data class SourceSetData(
-    val moduleName: String,
-    val sourceSetID: String,
-    val displayName: String,
-    val platform: Platform,
-    val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList(),
-    val dependentSourceSets: List<String> = emptyList()
-)
-
-class SourceSetCache {
-    private val sourceSets = HashMap<String, SourceSetData>()
-
-    val allSourceSets: List<SourceSetData>
-        get() = sourceSets.values.toList()
-
-    fun getSourceSet(pass: DokkaConfiguration.PassConfiguration) =
-        sourceSets.getOrPut(pass.sourceSetID,
-            {
-                SourceSetData(
-                    pass.moduleName,
-                    pass.sourceSetID,
-                    pass.displayName,
-                    pass.analysisPlatform,
-                    pass.sourceRoots,
-                    pass.dependentSourceSets
-                )
-            }
-        )
-}
-
-fun DokkaContext.sourceSet(pass: DokkaConfiguration.PassConfiguration): SourceSetData =
-    sourceSetCache.getSourceSet(pass)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/documentableProperties.kt b/core/src/main/kotlin/model/documentableProperties.kt
index 2aec199c..cd6a9335 100644
--- a/core/src/main/kotlin/model/documentableProperties.kt
+++ b/core/src/main/kotlin/model/documentableProperties.kt
@@ -1,26 +1,26 @@
 package org.jetbrains.dokka.model
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.properties.ExtraProperty
 import org.jetbrains.dokka.model.properties.MergeStrategy
 
-data class InheritedFunction(val inheritedFrom: SourceSetDependent<DRI?>): ExtraProperty<DFunction> {
+data class InheritedFunction(val inheritedFrom: SourceSetDependent<DRI?>) : ExtraProperty<DFunction> {
     companion object : ExtraProperty.Key<DFunction, InheritedFunction> {
         override fun mergeStrategyFor(left: InheritedFunction, right: InheritedFunction) = MergeStrategy.Replace(
             InheritedFunction(left.inheritedFrom + right.inheritedFrom)
         )
     }
 
-    fun isInherited(sourceSetDependent: SourceSetData): Boolean = inheritedFrom[sourceSetDependent] != null
+    fun isInherited(sourceSetDependent: DokkaSourceSet): Boolean = inheritedFrom[sourceSetDependent] != null
 
     override val key: ExtraProperty.Key<DFunction, *> = InheritedFunction
 }
 
-data class ImplementedInterfaces(val interfaces: SourceSetDependent<List<DRI>>): ExtraProperty<Documentable> {
+data class ImplementedInterfaces(val interfaces: SourceSetDependent<List<DRI>>) : ExtraProperty<Documentable> {
     companion object : ExtraProperty.Key<Documentable, ImplementedInterfaces> {
-        override fun mergeStrategyFor(left: ImplementedInterfaces, right: ImplementedInterfaces) = MergeStrategy.Replace(
-            ImplementedInterfaces(left.interfaces + right.interfaces)
-        )
+        override fun mergeStrategyFor(left: ImplementedInterfaces, right: ImplementedInterfaces) =
+            MergeStrategy.Replace(ImplementedInterfaces(left.interfaces + right.interfaces))
     }
 
     override val key: ExtraProperty.Key<Documentable, *> = ImplementedInterfaces
diff --git a/core/src/main/kotlin/model/documentableUtils.kt b/core/src/main/kotlin/model/documentableUtils.kt
index 2d4ade15..7057a62c 100644
--- a/core/src/main/kotlin/model/documentableUtils.kt
+++ b/core/src/main/kotlin/model/documentableUtils.kt
@@ -1,12 +1,14 @@
 package org.jetbrains.dokka.model
 
-fun <T> SourceSetDependent<T>.filtered(platformDataList: Set<SourceSetData>) = filter { it.key in platformDataList }
-fun SourceSetData?.filtered(platformDataList: Set<SourceSetData>) = takeIf { this in platformDataList }
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
-fun DTypeParameter.filter(filteredData: Set<SourceSetData>) =
-    if (filteredData.containsAll(sourceSets)) this
+fun <T> SourceSetDependent<T>.filtered(sourceSets: Set<DokkaSourceSet>) = filter { it.key in sourceSets }
+fun DokkaSourceSet?.filtered(sourceSets: Set<DokkaSourceSet>) = takeIf { this in sourceSets }
+
+fun DTypeParameter.filter(filteredSet: Set<DokkaSourceSet>) =
+    if (filteredSet.containsAll(sourceSets)) this
     else {
-        val intersection = filteredData.intersect(sourceSets)
+        val intersection = filteredSet.intersect(sourceSets)
         if (intersection.isEmpty()) null
         else DTypeParameter(
             dri,
diff --git a/core/src/main/kotlin/pages/ContentNodes.kt b/core/src/main/kotlin/pages/ContentNodes.kt
index 1b9c937d..dc23a082 100644
--- a/core/src/main/kotlin/pages/ContentNodes.kt
+++ b/core/src/main/kotlin/pages/ContentNodes.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.pages
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 
@@ -11,7 +11,7 @@ data class DCI(val dri: Set<DRI>, val kind: Kind) {
 
 interface ContentNode : WithExtraProperties<ContentNode> {
     val dci: DCI
-    val sourceSets: Set<SourceSetData>
+    val sourceSets: Set<DokkaSourceSet>
     val style: Set<Style>
 
     fun hasAnyContent(): Boolean
@@ -21,7 +21,7 @@ interface ContentNode : WithExtraProperties<ContentNode> {
 data class ContentText(
     val text: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentNode {
@@ -32,7 +32,7 @@ data class ContentText(
 
 // TODO: Remove
 data class ContentBreakLine(
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val dci: DCI = DCI(emptySet(), ContentKind.Empty),
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
@@ -47,11 +47,12 @@ data class ContentHeader(
     override val children: List<ContentNode>,
     val level: Int,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
     constructor(level: Int, c: ContentComposite) : this(c.children, level, c.dci, c.sourceSets, c.style, c.extra)
+
     override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentHeader = copy(extra = newExtras)
 }
 
@@ -60,7 +61,7 @@ data class ContentCode(
     override val children: List<ContentNode>,
     val language: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -75,7 +76,7 @@ data class ContentDRILink(
     override val children: List<ContentNode>,
     val address: DRI,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -87,7 +88,7 @@ data class ContentResolvedLink(
     override val children: List<ContentNode>,
     val address: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -101,7 +102,7 @@ data class ContentEmbeddedResource(
     val address: String,
     val altText: String?,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -121,7 +122,7 @@ data class ContentTable(
     val header: List<ContentGroup>,
     override val children: List<ContentGroup>,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -133,7 +134,7 @@ data class ContentList(
     override val children: List<ContentNode>,
     val ordered: Boolean,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -144,7 +145,7 @@ data class ContentList(
 data class ContentGroup(
     override val children: List<ContentNode>,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -164,7 +165,7 @@ data class ContentDivergentGroup(
 ) : ContentComposite {
     data class GroupID(val name: String)
 
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
         get() = children.flatMap { it.sourceSets }.distinct().toSet()
 
     override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentDivergentGroup =
@@ -177,7 +178,7 @@ data class ContentDivergentInstance(
     val divergent: ContentNode,
     val after: ContentNode?,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -190,7 +191,7 @@ data class ContentDivergentInstance(
 
 data class PlatformHintedContent(
     val inner: ContentNode,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : ContentComposite {
     override val children = listOf(inner)
 
@@ -231,9 +232,9 @@ enum class ContentStyle : Style {
     RowTitle, TabbedContent, WithExtraAttributes
 }
 
-object CommentTable: Style
+object CommentTable : Style
 
-object MultimoduleTable: Style
+object MultimoduleTable : Style
 
 fun ContentNode.dfs(predicate: (ContentNode) -> Boolean): ContentNode? = if (predicate(this)) {
     this
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index a2ff26c7..15349ff0 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
@@ -18,7 +17,6 @@ interface DokkaContext {
 
     fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T>
 
-    val sourceSetCache: SourceSetCache
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
     val unusedPoints: Collection<ExtensionPoint<*>>
@@ -28,10 +26,9 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            sourceSetsCache: SourceSetCache,
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, configuration, sourceSetsCache).apply {
+            DokkaContextConfigurationImpl(logger, configuration).apply {
                 // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
                 configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
@@ -54,8 +51,7 @@ interface DokkaContextConfiguration {
 
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
-    override val configuration: DokkaConfiguration,
-    override val sourceSetCache: SourceSetCache
+    override val configuration: DokkaConfiguration
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
diff --git a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
index f9c0a3d0..6bc8fb14 100644
--- a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
+++ b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.transformers.sources
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface SourceToDocumentableTranslator {
-    fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule
+    fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule
 }
\ No newline at end of file
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
index 9d15123a..a12becee 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
@@ -14,21 +14,21 @@ import java.io.File
 internal fun createEnvironmentAndFacade(
     logger: DokkaLogger,
     configuration: DokkaConfiguration,
-    pass: DokkaConfiguration.PassConfiguration
+    sourceSet: DokkaConfiguration.DokkaSourceSet
 ): EnvironmentAndFacade =
-    AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
+    AnalysisEnvironment(DokkaMessageCollector(logger), sourceSet.analysisPlatform).run {
         if (analysisPlatform == Platform.jvm) {
             addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
         }
-        pass.classpath.forEach { addClasspath(File(it)) }
+        sourceSet.classpath.forEach { addClasspath(File(it)) }
 
         addSources(
-            (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
+            (sourceSet.sourceRoots + configuration.sourceSets.filter { it.sourceSetID in sourceSet.dependentSourceSets }
                 .flatMap { it.sourceRoots })
                 .map { it.path }
         )
 
-        loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
+        loadLanguageVersionSettings(sourceSet.languageVersion, sourceSet.apiVersion)
 
         val environment = createCoreEnvironment()
         val (facade, _) = createResolutionFacade(environment)
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
index cd07b2a3..426ffdde 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
@@ -2,45 +2,37 @@
 
 package org.jetbrains.dokka.analysis
 
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 
 fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis {
-    val environments = context.configuration.passesConfigurations
-        .associate { passConfiguration ->
-            context.sourceSetCache.getSourceSet(passConfiguration) to createEnvironmentAndFacade(
+    val environments = context.configuration.sourceSets
+        .associate { sourceSet ->
+            sourceSet to createEnvironmentAndFacade(
                 logger = context.logger,
                 configuration = context.configuration,
-                pass = passConfiguration
+                sourceSet = sourceSet
             )
         }
 
-    return KotlinAnalysisImpl(context.sourceSetCache, environments)
+    return KotlinAnalysisImpl(environments)
 }
 
 interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade> {
-    override fun get(key: SourceSetData): EnvironmentAndFacade
+    override fun get(key: DokkaSourceSet): EnvironmentAndFacade
     operator fun get(sourceSetID: String): EnvironmentAndFacade
-    operator fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade
 }
 
 internal class KotlinAnalysisImpl(
-    private val sourceSetCache: SourceSetCache,
     private val environments: SourceSetDependent<EnvironmentAndFacade>
 ) : KotlinAnalysis, SourceSetDependent<EnvironmentAndFacade> by environments {
 
-    override fun get(key: SourceSetData): EnvironmentAndFacade {
+    override fun get(key: DokkaSourceSet): EnvironmentAndFacade {
         return environments[key] ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
     }
 
     override fun get(sourceSetID: String): EnvironmentAndFacade {
         return environments.entries.first { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }.value
     }
-
-    override fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade {
-        return get(sourceSetCache.getSourceSet(passConfiguration))
-    }
 }
diff --git a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
index cdaa0274..e3da9ecc 100644
--- a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
+++ b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
@@ -1,11 +1,11 @@
 package org.jetbrains.dokka.base.allModulePage
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.MultimoduleLocationProvider.Companion.MULTIMODULE_PACKAGE_PLACEHOLDER
 import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.P
 import org.jetbrains.dokka.pages.*
@@ -30,9 +30,13 @@ class MultimodulePageCreator(
         if (commentsConverter == null || signatureProvider == null)
             throw IllegalStateException("Both comments converter and signature provider must not be null")
 
-        val sourceSetData = emptySet<SourceSetData>()
+        val sourceSetData = emptySet<DokkaSourceSet>()
         val builder = PageContentBuilder(commentsConverter, signatureProvider, context.logger)
-        val contentNode = builder.contentFor(dri = DRI(MULTIMODULE_PACKAGE_PLACEHOLDER), kind = ContentKind.Cover, sourceSets = sourceSetData) {
+        val contentNode = builder.contentFor(
+            dri = DRI(MULTIMODULE_PACKAGE_PLACEHOLDER),
+            kind = ContentKind.Cover,
+            sourceSets = sourceSetData
+        ) {
             header(2, "All modules:")
             table(styles = setOf(MultimoduleTable)) {
                 modules.mapNotNull { module ->
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
index 141a18e6..f4d547e3 100644
--- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -1,10 +1,12 @@
 package org.jetbrains.dokka.base.renderers
 
-import kotlinx.coroutines.*
-import kotlinx.html.FlowContent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
@@ -28,7 +30,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     )
 
     abstract fun T.buildNewLine()
@@ -36,7 +38,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     )
 
     abstract fun T.buildText(textNode: ContentText)
@@ -48,18 +50,18 @@ abstract class DefaultRenderer<T>(
     open fun T.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) = buildContentNode(content.inner, pageContext)
 
     open fun T.buildGroup(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) =
         wrapGroup(node, pageContext) { node.children.forEach { it.build(this, pageContext, sourceSetRestriction) } }
 
     open fun T.buildDivergent(node: ContentDivergentGroup, pageContext: ContentPage) =
-         node.children.forEach { it.build(this, pageContext) }
+        node.children.forEach { it.build(this, pageContext) }
 
     open fun T.wrapGroup(node: ContentGroup, pageContext: ContentPage, childrenCallback: T.() -> Unit) =
         childrenCallback()
@@ -67,7 +69,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildLinkText(
         nodes: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         nodes.forEach { it.build(this, pageContext, sourceSetRestriction) }
     }
@@ -79,7 +81,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildHeader(
         node: ContentHeader,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         buildHeader(node.level, node) { node.children.forEach { it.build(this, pageContext, sourceSetRestriction) } }
     }
@@ -87,16 +89,16 @@ abstract class DefaultRenderer<T>(
     open fun ContentNode.build(
         builder: T,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) =
         builder.buildContentNode(this, pageContext, sourceSetRestriction)
 
     open fun T.buildContentNode(
         node: ContentNode,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
-        if (sourceSetRestriction == null || node.sourceSets.any { it in sourceSetRestriction }  ) {
+        if (sourceSetRestriction == null || node.sourceSets.any { it in sourceSetRestriction }) {
             when (node) {
                 is ContentText -> buildText(node)
                 is ContentHeader -> buildHeader(node, pageContext, sourceSetRestriction)
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 43722888..ee6f1e1f 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -1,13 +1,15 @@
 package org.jetbrains.dokka.base.renderers.html
 
-import kotlinx.coroutines.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -20,11 +22,10 @@ open class HtmlRenderer(
     context: DokkaContext
 ) : DefaultRenderer<FlowContent>(context) {
 
-    private val sourceSetDependencyMap = with(context.sourceSetCache) {
-        allSourceSets.map { sourceSet ->
-            sourceSet to allSourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetID) }
-        }.toMap()
-    }
+    private val sourceSetDependencyMap = context.configuration.sourceSets.map { sourceSet ->
+        sourceSet to context.configuration.sourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetID) }
+    }.toMap()
+
 
     private val pageList = mutableMapOf<String, Pair<String, String>>()
 
@@ -94,7 +95,7 @@ open class HtmlRenderer(
                 button(classes = "platform-tag platform-selector") {
                     attributes["data-active"] = ""
                     attributes["data-filter"] = it.sourceSetID
-                    when (it.platform.key) {
+                    when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
                         "jvm" -> classes = classes + "jvm-like"
@@ -138,7 +139,7 @@ open class HtmlRenderer(
     override fun FlowContent.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) =
         buildPlatformDependent(
             content.sourceSets.filter {
@@ -150,7 +151,7 @@ open class HtmlRenderer(
         )
 
     private fun FlowContent.buildPlatformDependent(
-        nodes: Map<SourceSetData, Collection<ContentNode>>,
+        nodes: Map<DokkaSourceSet, Collection<ContentNode>>,
         pageContext: ContentPage,
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
         styles: Set<Style> = emptySet()
@@ -172,7 +173,7 @@ open class HtmlRenderer(
                             if (index == 0) attributes["data-active"] = ""
                             attributes["data-toggle"] = pair.first.sourceSetID
                             when (
-                                pair.first.platform.key
+                                pair.first.analysisPlatform.key
                                 ) {
                                 "common" -> classes = classes + "common-like"
                                 "native" -> classes = classes + "native-like"
@@ -192,9 +193,9 @@ open class HtmlRenderer(
     }
 
     private fun contentsForSourceSetDependent(
-        nodes: Map<SourceSetData, Collection<ContentNode>>,
+        nodes: Map<DokkaSourceSet, Collection<ContentNode>>,
         pageContext: ContentPage,
-    ): List<Pair<SourceSetData, String>> {
+    ): List<Pair<DokkaSourceSet, String>> {
         var counter = 0
         return nodes.toList().map { (sourceSet, elements) ->
             sourceSet to createHTML(prettyPrint = false).div {
@@ -203,8 +204,8 @@ open class HtmlRenderer(
                 }
             }.stripDiv()
         }.groupBy(
-            Pair<SourceSetData, String>::second,
-            Pair<SourceSetData, String>::first
+            Pair<DokkaSourceSet, String>::second,
+            Pair<DokkaSourceSet, String>::first
         ).entries.flatMap { (html, sourceSets) ->
             sourceSets.filterNot {
                 sourceSetDependencyMap[it].orEmpty().any { dependency -> sourceSets.contains(dependency) }
@@ -238,8 +239,8 @@ open class HtmlRenderer(
                     )
                 }
             }.groupBy(
-                Pair<Pair<ContentDivergentInstance, SourceSetData>, Pair<String, String>>::second,
-                Pair<Pair<ContentDivergentInstance, SourceSetData>, Pair<String, String>>::first
+                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::second,
+                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::first
             )
 
         distinct.forEach {
@@ -293,14 +294,14 @@ open class HtmlRenderer(
     override fun FlowContent.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) = if (node.ordered) ol { buildListItems(node.children, pageContext, sourceSetRestriction) }
     else ul { buildListItems(node.children, pageContext, sourceSetRestriction) }
 
     open fun OL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         items.forEach {
             if (it is ContentList)
@@ -313,7 +314,7 @@ open class HtmlRenderer(
     open fun UL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         items.forEach {
             if (it is ContentList)
@@ -340,7 +341,7 @@ open class HtmlRenderer(
     private fun FlowContent.buildRow(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?,
+        sourceSetRestriction: Set<DokkaSourceSet>?,
         style: Set<Style>
     ) {
         node.children
@@ -393,11 +394,11 @@ open class HtmlRenderer(
             }
     }
 
-    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<SourceSetData>) {
+    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<DokkaSourceSet>) {
         div("platform-tags") {
             sourceSets.forEach {
                 div("platform-tag") {
-                    when (it.platform.key) {
+                    when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
                         "jvm" -> classes = classes + "jvm-like"
@@ -409,7 +410,7 @@ open class HtmlRenderer(
         }
     }
 
-    private fun FlowContent.createPlatformTags(node: ContentNode, sourceSetRestriction: Set<SourceSetData>? = null) {
+    private fun FlowContent.createPlatformTags(node: ContentNode, sourceSetRestriction: Set<DokkaSourceSet>? = null) {
         node.takeIf { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }?.let {
             createPlatformTagBubbles(node.sourceSets.filter {
                 sourceSetRestriction == null || it in sourceSetRestriction
@@ -420,7 +421,7 @@ open class HtmlRenderer(
     override fun FlowContent.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         when (node.dci.kind) {
             ContentKind.Comment -> buildDefaultTable(node, pageContext, sourceSetRestriction)
@@ -437,7 +438,7 @@ open class HtmlRenderer(
     fun FlowContent.buildDefaultTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         table {
             thead {
@@ -522,7 +523,7 @@ open class HtmlRenderer(
 
     fun FlowContent.buildLink(
         to: DRI,
-        platforms: List<SourceSetData>,
+        platforms: List<DokkaSourceSet>,
         from: PageNode? = null,
         block: FlowContent.() -> Unit
     ) = buildLink(locationProvider.resolve(to, platforms, from), block)
@@ -562,7 +563,7 @@ open class HtmlRenderer(
     private fun getSymbolSignature(page: ContentPage) = page.content.dfs { it.dci.kind == ContentKind.Symbol }
 
     private fun flattenToText(node: ContentNode): String {
-        fun getContentTextNodes(node: ContentNode, sourceSetRestriction: SourceSetData): List<ContentText> =
+        fun getContentTextNodes(node: ContentNode, sourceSetRestriction: DokkaSourceSet): List<ContentText> =
             when (node) {
                 is ContentText -> listOf(node)
                 is ContentComposite -> node.children
@@ -573,7 +574,8 @@ open class HtmlRenderer(
                 else -> emptyList()
             }
 
-        val sourceSetRestriction = node.sourceSets.find { it.platform == Platform.common } ?: node.sourceSets.first()
+        val sourceSetRestriction =
+            node.sourceSets.find { it.analysisPlatform == Platform.common } ?: node.sourceSets.first()
         return getContentTextNodes(node, sourceSetRestriction).joinToString("") { it.text }
     }
 
diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
index 4048c11e..eb563dbd 100644
--- a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.base.renderers.html
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RendererSpecificPage
 import org.jetbrains.dokka.pages.RenderingStrategy
@@ -25,7 +25,7 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
                 id = navId
                 attributes["pageId"] = node.dri.toString()
                 div("overview") {
-                    buildLink(node.dri, node.platforms) { +node.name }
+                    buildLink(node.dri, node.sourceSets) { +node.name }
                     if (node.children.isNotEmpty()) {
                         span("navButton") {
                             onClick = """document.getElementById("$navId").classList.toggle("hidden");"""
@@ -41,11 +41,11 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
 class NavigationNode(
     val name: String,
     val dri: DRI,
-    val platforms: List<SourceSetData>,
+    val sourceSets: List<DokkaSourceSet>,
     val children: List<NavigationNode>
 )
 
 fun NavigationPage.transform(block: (NavigationNode) -> NavigationNode) = NavigationPage(root.transform(block))
 
 fun NavigationNode.transform(block: (NavigationNode) -> NavigationNode) =
-    run(block).let { NavigationNode(it.name, it.dri, it.platforms, it.children.map(block)) }
+    run(block).let { NavigationNode(it.name, it.dri, it.sourceSets, it.children.map(block)) }
diff --git a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index cdb30555..af0525d7 100644
--- a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -86,7 +86,7 @@ object StyleAndScriptsAppender : PageTransformer {
 
 class SourcesetDependencyAppender(val context: DokkaContext) : PageTransformer{
     override fun invoke(input: RootPageNode): RootPageNode {
-        val dependenciesMap = context.configuration.passesConfigurations.map {
+        val dependenciesMap = context.configuration.sourceSets.map {
             it.sourceSetID to it.dependentSourceSets
         }.toMap()
         fun createDependenciesJson() : String = "sourceset_dependencies = '{${
diff --git a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
index a9e58f17..eada2e3b 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
@@ -1,16 +1,14 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.external.ExternalLocationProvider
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.query
-import java.lang.IllegalStateException
 import java.net.HttpURLConnection
 import java.net.URL
 import java.net.URLConnection
@@ -48,14 +46,12 @@ open class DefaultLocationProvider(
     override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
         pathTo(node, context) + if (!skipExtension) extension else ""
 
-    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         pagesIndex[dri]?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
-        getLocation(dri,
-            this.dokkaContext.configuration.passesConfigurations
-                .filter { passConfig ->
-                    sourceSets.toSet().contains(dokkaContext.sourceSet(passConfig))
-                }
+        getLocation(
+            dri,
+            sourceSets
                 .groupBy({ it.jdkVersion }, { it.externalDocumentationLinks })
                 .map { it.key to it.value.flatten().distinct() }.toMap()
         )
@@ -105,7 +101,7 @@ open class DefaultLocationProvider(
         // Not in cache, resolve packageLists
         for ((jdk, links) in toResolve) {
             for (link in links) {
-                if(dokkaContext.configuration.offlineMode && link.packageListUrl.protocol.toLowerCase() != "file")
+                if (dokkaContext.configuration.offlineMode && link.packageListUrl.protocol.toLowerCase() != "file")
                     continue
                 val locationInfo =
                     loadPackageList(jdk, link.packageListUrl)
diff --git a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
index c6c48d63..d6d616f3 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
 
 interface LocationProvider {
-    fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode? = null): String
+    fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode? = null): String
     fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
     fun resolveRoot(node: PageNode): String
     fun ancestors(node: PageNode): List<PageNode>
diff --git a/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
index 21692bf9..39b005a1 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -14,10 +14,10 @@ class MultimoduleLocationProvider(private val root: RootPageNode, context: Dokka
         it.name to it.path
     }.toMap()
 
-    override fun resolve(dri: DRI, platforms: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         dri.takeIf { it.packageName == MULTIMODULE_PACKAGE_PLACEHOLDER }?.classNames?.let { paths[it] }?.let {
             "$it/${dri.classNames}/index.html"
-        } ?: defaultLocationProvider.resolve(dri, platforms, context)
+        } ?: defaultLocationProvider.resolve(dri, sourceSets, context)
 
     override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
         defaultLocationProvider.resolve(node, context, skipExtension)
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index 8dbe7b12..f042eae3 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -1,10 +1,12 @@
 package org.jetbrains.dokka.base.signatures
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
 interface JvmSignatureUtils {
 
@@ -73,7 +75,7 @@ interface JvmSignatureUtils {
                     is All -> All
                     is Never, is OnlyOnce -> Never
                 }.let { strategy ->
-                     valueToSignature(it.value, strategy, listBrackets, classExtension)
+                    valueToSignature(it.value, strategy, listBrackets, classExtension)
                 }
                 if (i != a.params.entries.size - 1) text(", ")
             }
@@ -130,11 +132,11 @@ interface JvmSignatureUtils {
         }
     }
 
-    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: SourceSetData): Set<TextStyle> =
+    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> =
         if (extra[Annotations]?.content?.get(sourceSetData)?.any {
-            it.dri == DRI("kotlin", "Deprecated")
-                    || it.dri == DRI("java.lang", "Deprecated")
-        } == true) setOf(TextStyle.Strikethrough) else emptySet()
+                it.dri == DRI("kotlin", "Deprecated")
+                        || it.dri == DRI("java.lang", "Deprecated")
+            } == true) setOf(TextStyle.Strikethrough) else emptySet()
 }
 
 sealed class AtStrategy
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index 3e92b902..28c26dea 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.signatures
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
@@ -24,7 +25,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         ExtraModifiers.KotlinOnlyModifiers.TailRec,
         ExtraModifiers.KotlinOnlyModifiers.External
     )
-    private val platformSpecificModifiers : Map<ExtraModifiers, Set<Platform>> = mapOf(
+    private val platformSpecificModifiers: Map<ExtraModifiers, Set<Platform>> = mapOf(
         ExtraModifiers.KotlinOnlyModifiers.External to setOf(Platform.js)
     )
 
@@ -40,13 +41,14 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         )
     }
 
-    private fun <T> PageContentBuilder.DocumentableContentBuilder.processExtraModifiers (t: T)
-            where T: Documentable, T: WithExtraProperties<T> {
+    private fun <T> PageContentBuilder.DocumentableContentBuilder.processExtraModifiers(t: T)
+            where T : Documentable, T : WithExtraProperties<T> {
         sourceSetDependentText(
             t.modifiers()
                 .mapValues { entry ->
                     entry.value.filter {
-                        it !in ignoredExtraModifiers || entry.key.platform in (platformSpecificModifiers[it] ?: emptySet())
+                        it !in ignoredExtraModifiers || entry.key.analysisPlatform in (platformSpecificModifiers[it]
+                            ?: emptySet())
                     }
                 }
         ) {
@@ -73,7 +75,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             }
         }
 
-    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: SourceSetData, aliasedType: Bound) =
+    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound) =
         contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
@@ -97,7 +99,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         }
 
 
-    private fun regularSignature(c: DClasslike, sourceSet: SourceSetData) =
+    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet) =
         contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
@@ -315,7 +317,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             is UnresolvedBound -> text(p.name)
         }
 
-    private fun funType(dri: DRI, sourceSets: Set<SourceSetData>, type: TypeConstructor) =
+    private fun funType(dri: DRI, sourceSets: Set<DokkaSourceSet>, type: TypeConstructor) =
         contentBuilder.contentFor(dri, sourceSets, ContentKind.Main) {
             if (type.extension) {
                 signatureForProjection(type.projections.first())
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
index 27557107..109aa640 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
@@ -8,18 +8,16 @@ import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransf
 
 class DeprecatedDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
+        val sourceSet = original.sourceSets.single()
         val packageOptions =
-            passOptions.perPackageOptions
+            sourceSet.perPackageOptions
         original.let {
-            DeprecatedDocumentableFilter(passOptions, packageOptions).processModule(it)
+            DeprecatedDocumentableFilter(sourceSet, packageOptions).processModule(it)
         }
     }
 
     private class DeprecatedDocumentableFilter(
-        val globalOptions: DokkaConfiguration.PassConfiguration,
+        val globalOptions: DokkaConfiguration.DokkaSourceSet,
         val packageOptions: List<DokkaConfiguration.PackageOptions>
     ) {
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index 0a01680f..c3cc4d38 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -4,15 +4,13 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
 class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
-        val packageOptions =
-            passOptions.perPackageOptions
+        val passOptions = original.sourceSets.single()
+        val packageOptions = passOptions.perPackageOptions
         original.let {
             DocumentableVisibilityFilter(packageOptions, passOptions).processModule(it)
         }
@@ -20,7 +18,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
     private class DocumentableVisibilityFilter(
         val packageOptions: List<DokkaConfiguration.PackageOptions>,
-        val globalOptions: DokkaConfiguration.PassConfiguration
+        val globalOptions: DokkaSourceSet
     ) {
         fun Visibility.isAllowedInPackage(packageName: String?) = when (this) {
             is JavaVisibility.Public,
@@ -82,14 +80,14 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             return Pair(packagesListChanged, filteredPackages)
         }
 
-        private fun <T : WithVisibility> alwaysTrue(a: T, p: SourceSetData) = true
-        private fun <T : WithVisibility> alwaysFalse(a: T, p: SourceSetData) = false
+        private fun <T : WithVisibility> alwaysTrue(a: T, p: DokkaSourceSet) = true
+        private fun <T : WithVisibility> alwaysFalse(a: T, p: DokkaSourceSet) = false
 
-        private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data]
+        private fun WithVisibility.visibilityForPlatform(data: DokkaSourceSet): Visibility? = visibility[data]
 
         private fun <T> T.filterPlatforms(
-            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse
+            additionalCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysFalse
         ) where T : Documentable, T : WithVisibility =
             sourceSets.filter { d ->
                 visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true &&
@@ -98,9 +96,9 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             }.toSet()
 
         private fun <T> List<T>.transform(
-            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse,
-            recreate: (T, Set<SourceSetData>) -> T
+            additionalCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysFalse,
+            recreate: (T, Set<DokkaSourceSet>) -> T
         ): Pair<Boolean, List<T>> where T : Documentable, T : WithVisibility {
             var changed = false
             val values = mapNotNull { t ->
@@ -122,7 +120,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterFunctions(
             functions: List<DFunction>,
-            additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DFunction, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ) =
             functions.transform(additionalCondition) { original, filteredPlatforms ->
                 with(original) {
@@ -145,13 +143,13 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 }
             }
 
-        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) =
+        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: DokkaSourceSet) =
             property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true ||
                     property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true
 
         private fun filterProperties(
             properties: List<DProperty>,
-            additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DProperty, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DProperty>> =
             properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms ->
                 with(original) {
@@ -174,7 +172,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 }
             }
 
-        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: Set<SourceSetData>) =
+        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: Set<DokkaSourceSet>) =
             entries.mapNotNull { entry ->
                 if (filteredPlatforms.containsAll(entry.sourceSets)) entry
                 else {
@@ -196,7 +194,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterClasslikes(
             classlikeList: List<DClasslike>,
-            additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DClasslike, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DClasslike>> {
             var classlikesListChanged = false
             val filteredClasslikes: List<DClasslike> = classlikeList.mapNotNull {
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
index 6b29531c..3fd0081a 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
@@ -3,22 +3,18 @@ package org.jetbrains.dokka.base.transformers.documentables
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.DPackage
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 
 class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
     override fun invoke(modules: List<DModule>): List<DModule> = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
         original.let {
-            EmptyPackagesFilter(passOptions).processModule(it)
+            EmptyPackagesFilter(original.sourceSets.single()).processModule(it)
         }
     }
 
     private class EmptyPackagesFilter(
-        val passOptions: DokkaConfiguration.PassConfiguration
+        val passOptions: DokkaConfiguration.DokkaSourceSet
     ) {
         fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages &&
                 functions.isEmpty() &&
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
index 15ffc08a..f1bccd66 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
@@ -5,13 +5,14 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.ExtraProperty
 import org.jetbrains.dokka.model.properties.MergeStrategy
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
 
 class InheritorsExtractorTransformer : DocumentableTransformer {
     override fun invoke(original: DModule, context: DokkaContext): DModule =
         original.generateInheritanceMap().let { inheritanceMap -> original.appendInheritors(inheritanceMap) as DModule }
 
-    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<SourceSetData, Map<DRI, List<DRI>>>): Documentable =
+    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<DokkaSourceSet, Map<DRI, List<DRI>>>): Documentable =
         InheritorsInfo(inheritanceMap.getForDRI(dri)).let { info ->
             when (this) {
                 is DModule -> copy(packages = packages.map { it.appendInheritors(inheritanceMap) as DPackage })
@@ -45,7 +46,7 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
 
     private fun InheritorsInfo.isNotEmpty() = this.value.values.fold(0) { acc, list -> acc + list.size } > 0
 
-    private fun Map<SourceSetData, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
+    private fun Map<DokkaSourceSet, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
         map { (v, k) ->
             v to k[dri]
         }.map { (k, v) -> k to v.orEmpty() }.toMap()
@@ -57,7 +58,7 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
                     .groupBy({ it.first }) { it.second }.map { (k2, v2) -> k2 to v2.flatten() }.toMap()
             }.filter { it.second.values.isNotEmpty() }.toMap()
 
-    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<SourceSetData, List<Pair<DRI, DRI>>>> =
+    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<DokkaSourceSet, List<Pair<DRI, DRI>>>> =
         this.toInheritanceEntries() + children.flatMap { it.getInheritanceEntriesRec() }
 
     private fun <T : Documentable> T.toInheritanceEntries() =
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 63232793..1f718a7c 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -3,9 +3,8 @@ package org.jetbrains.dokka.base.transformers.documentables
 import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
-import org.jetbrains.dokka.model.sourceSet
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -23,9 +22,9 @@ internal class ModuleAndPackageDocumentationTransformer(
     override fun invoke(modules: List<DModule>): List<DModule> {
 
         val modulesAndPackagesDocumentation =
-            context.configuration.passesConfigurations
+            context.configuration.sourceSets
                 .map {
-                    Pair(it.moduleName, context.sourceSet(it)) to
+                    Pair(it.moduleName, it) to
                             it.includes.map { Paths.get(it) }
                                 .also {
                                     it.forEach {
@@ -101,7 +100,7 @@ internal class ModuleAndPackageDocumentationTransformer(
         }
     }
 
-    private fun mergeDocumentation(origin: Map<SourceSetData, DocumentationNode>, new: Map<SourceSetData, DocumentationNode>) =
+    private fun mergeDocumentation(origin: Map<DokkaSourceSet, DocumentationNode>, new: Map<DokkaSourceSet, DocumentationNode>) =
         (origin.asSequence() + new.asSequence())
             .distinct()
             .groupBy({ it.key }, { it.value })
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
index 0b47345d..2ebd4c62 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -26,12 +26,11 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     }
 
     private fun shouldBeReportedIfNotDocumented(
-        documentable: Documentable, sourceSet: SourceSetData, context: DokkaContext
+        documentable: Documentable, sourceSet: DokkaSourceSet, context: DokkaContext
     ): Boolean {
-        val passConfiguration = passConfiguration(context, sourceSet)
-        val packageOptionsOrNull = packageOptionsOrNull(passConfiguration, documentable)
+        val packageOptionsOrNull = packageOptionsOrNull(sourceSet, documentable)
 
-        if (!(packageOptionsOrNull?.reportUndocumented ?: passConfiguration.reportUndocumented)) {
+        if (!(packageOptionsOrNull?.reportUndocumented ?: sourceSet.reportUndocumented)) {
             return false
         }
 
@@ -61,7 +60,7 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     private fun reportIfUndocumented(
         context: DokkaContext,
         documentable: Documentable,
-        sourceSet: SourceSetData
+        sourceSet: DokkaSourceSet
     ) {
         if (isUndocumented(documentable, sourceSet)) {
             val documentableDescription = with(documentable) {
@@ -94,14 +93,14 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         }
     }
 
-    private fun isUndocumented(documentable: Documentable, sourceSet: SourceSetData): Boolean {
-        fun resolveDependentSourceSets(sourceSet: SourceSetData): List<SourceSetData> {
+    private fun isUndocumented(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
+        fun resolveDependentSourceSets(sourceSet: DokkaSourceSet): List<DokkaSourceSet> {
             return sourceSet.dependentSourceSets.mapNotNull { sourceSetID ->
                 documentable.sourceSets.singleOrNull { it.sourceSetID == sourceSetID }
             }
         }
 
-        fun withAllDependentSourceSets(sourceSet: SourceSetData): Sequence<SourceSetData> {
+        fun withAllDependentSourceSets(sourceSet: DokkaSourceSet): Sequence<DokkaSourceSet> {
             return sequence {
                 yield(sourceSet)
                 for (dependentSourceSet in resolveDependentSourceSets(sourceSet)) {
@@ -120,25 +119,16 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         return documentable.isConstructor
     }
 
-    private fun passConfiguration(context: DokkaContext, sourceSet: SourceSetData): PassConfiguration {
-        val passes = context.configuration.passesConfigurations.filter { configuration ->
-            configuration.sourceSetID == sourceSet.sourceSetID
-        }
-        if (passes.size > 1)
-            context.logger.error("Expected one passConfiguration with ID: ${sourceSet.sourceSetID} found: ${passes.size} in [${passes.joinToString { it.moduleName }}]")
-        return passes.first()
-    }
-
-    private fun isFakeOverride(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isFakeOverride(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return callableMemberDescriptorOrNull(documentable, sourceSet)?.kind == FAKE_OVERRIDE
     }
 
-    private fun isSynthesized(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isSynthesized(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return callableMemberDescriptorOrNull(documentable, sourceSet)?.kind == SYNTHESIZED
     }
 
     private fun callableMemberDescriptorOrNull(
-        documentable: Documentable, sourceSet: SourceSetData
+        documentable: Documentable, sourceSet: DokkaSourceSet
     ): CallableMemberDescriptor? {
         if (documentable is WithExpectActual) {
             return documentable.sources[sourceSet]
@@ -149,7 +139,7 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         return null
     }
 
-    private fun isPrivateOrInternalApi(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isPrivateOrInternalApi(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return when (documentable.safeAs<WithVisibility>()?.visibility?.get(sourceSet)) {
             KotlinVisibility.Public -> false
             KotlinVisibility.Private -> true
@@ -164,11 +154,11 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     }
 
     private fun packageOptionsOrNull(
-        passConfiguration: PassConfiguration,
+        dokkaSourceSet: DokkaSourceSet,
         documentable: Documentable
     ): DokkaConfiguration.PackageOptions? {
         val packageName = documentable.dri.packageName ?: return null
-        return passConfiguration.perPackageOptions
+        return dokkaSourceSet.perPackageOptions
             .filter { packageOptions -> packageName.startsWith(packageOptions.prefix) }
             .maxBy { packageOptions -> packageOptions.prefix.length }
     }
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
index cb74441e..fa9ce37e 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -9,7 +9,7 @@ interface CommentsToContentConverter {
     fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        platforms: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style> = emptySet(),
         extras: PropertyContainer<ContentNode> = PropertyContainer.empty()
     ): List<ContentNode>
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
index be1217db..14f3a996 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -9,7 +9,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
         extra: PropertyContainer<ContentNode>
     ): List<ContentNode> {
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index 0d133a65..a40f2f53 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -8,10 +8,9 @@ import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.base.renderers.platforms
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.Sample
 import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.pages.PageTransformer
@@ -40,8 +39,8 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         }
     }
 
-    private fun setUpAnalysis(context: DokkaContext) = context.configuration.passesConfigurations.map {
-        context.sourceSet(it) to AnalysisEnvironment(DokkaMessageCollector(context.logger), it.analysisPlatform).run {
+    private fun setUpAnalysis(context: DokkaContext) = context.configuration.sourceSets.map {
+        it to AnalysisEnvironment(DokkaMessageCollector(context.logger), it.analysisPlatform).run {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
@@ -59,9 +58,9 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
 
     private fun ContentNode.addSample(
         contentPage: ContentPage,
-        platform: SourceSetData,
+        platform: DokkaSourceSet,
         fqName: String,
-        analysis: Map<SourceSetData, EnvironmentAndFacade>
+        analysis: Map<DokkaSourceSet, EnvironmentAndFacade>
     ): ContentNode {
         val facade = analysis[platform]?.facade
             ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}") }
@@ -110,7 +109,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         return DescriptorToSourceUtils.descriptorToDeclaration(symbol)
     }
 
-    private fun contentCode(sourceSets: List<SourceSetData>, dri: Set<DRI>, content: String, language: String) =
+    private fun contentCode(sourceSets: List<DokkaSourceSet>, dri: Set<DRI>, content: String, language: String) =
         ContentCode(
             children = listOf(
                 ContentText(
diff --git a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
index 7603c80b..42422934 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
@@ -3,11 +3,11 @@ package org.jetbrains.dokka.base.transformers.pages.sourcelinks
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
-import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.DocumentableSource
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
+import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
+import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.model.WithExpectActual
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -29,8 +29,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             }
         }
 
-    private fun getSourceLinks() = context.configuration.passesConfigurations
-        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, context.sourceSetCache.getSourceSet(it)) } }
+    private fun getSourceLinks() = context.configuration.sourceSets
+        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, it) } }
 
     private fun resolveSources(documentable: WithExpectActual) = documentable.sources
         .mapNotNull { entry ->
@@ -42,7 +42,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             }
         }
 
-    private fun ContentPage.addSourcesContent(sources: List<Pair<SourceSetData, String>>) = builder
+    private fun ContentPage.addSourcesContent(sources: List<Pair<DokkaSourceSet, String>>) = builder
         .buildSourcesContent(this, sources)
         .let {
             this.modified(
@@ -52,7 +52,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
 
     private fun PageContentBuilder.buildSourcesContent(
         node: ContentPage,
-        sources: List<Pair<SourceSetData, String>>
+        sources: List<Pair<DokkaSourceSet, String>>
     ) = contentFor(
         node.dri.first(),
         node.documentable!!.sourceSets.toSet()
@@ -121,8 +121,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
     }
 }
 
-data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val sourceSetData: SourceSetData) {
-    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: SourceSetData) : this(
+data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val sourceSetData: DokkaSourceSet) {
+    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: DokkaSourceSet) : this(
         sourceLinkDefinition.path, sourceLinkDefinition.url, sourceLinkDefinition.lineSuffix, sourceSetData
     )
 }
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index cefea4ec..9cdd251c 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.translators.descriptors
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.*
 import org.jetbrains.dokka.links.*
 import org.jetbrains.dokka.links.Callable
@@ -50,13 +51,12 @@ import org.jetbrains.kotlin.resolve.constants.AnnotationValue as ConstantsAnnota
 import org.jetbrains.kotlin.resolve.constants.ArrayValue as ConstantsArrayValue
 import org.jetbrains.kotlin.resolve.constants.EnumValue as ConstantsEnumValue
 import org.jetbrains.kotlin.resolve.constants.KClassValue as ConstantsKtClassValue
-import kotlin.IllegalArgumentException
 
 class DefaultDescriptorToDocumentableTranslator(
     private val kotlinAnalysis: KotlinAnalysis
 ) : SourceToDocumentableTranslator {
 
-    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule {
         val (environment, facade) = kotlinAnalysis[sourceSet]
         val packageFragments = environment.getSourceFiles().asSequence()
             .map { it.packageFqName }
@@ -83,7 +83,7 @@ data class DRIWithPlatformInfo(
 fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, emptyMap())
 
 private class DokkaDescriptorVisitor(
-    private val sourceSet: SourceSetData,
+    private val sourceSet: DokkaSourceSet,
     private val resolutionFacade: DokkaResolutionFacade,
     private val logger: DokkaLogger
 ) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() {
@@ -729,11 +729,11 @@ private class DokkaDescriptorVisitor(
 
     private fun KtInitializerList.initializersAsText() =
         initializers.firstIsInstanceOrNull<KtCallElement>()
-        ?.getValueArgumentsInParentheses()
-        ?.flatMap { it.childrenAsText() }
-        .orEmpty()
+            ?.getValueArgumentsInParentheses()
+            ?.flatMap { it.childrenAsText() }
+            .orEmpty()
 
-    private fun ValueArgument.childrenAsText() = this.safeAs<KtValueArgument>()?.children?.map {it.text }.orEmpty()
+    private fun ValueArgument.childrenAsText() = this.safeAs<KtValueArgument>()?.children?.map { it.text }.orEmpty()
 
     private data class ClassInfo(val superclasses: List<DRI>, val interfaces: List<DRI>, val docs: SourceSetDependent<DocumentationNode>){
         val supertypes: List<DRI>
@@ -751,11 +751,12 @@ private class DokkaDescriptorVisitor(
     private fun ConstantsEnumValue.fullEnumEntryName() =
         "${this.enumClassId.relativeClassName.asString()}.${this.enumEntryName.identifier}"
 
-    private fun fallbackPackageName(): String = "[${sourceSet.displayName} root]"// TODO: error-prone, find a better way to do it
+    private fun fallbackPackageName(): String =
+        "[${sourceSet.displayName} root]"// TODO: error-prone, find a better way to do it
 }
 
 private fun DRI.withPackageFallbackTo(fallbackPackage: String): DRI {
-    return if(packageName.isNullOrBlank()){
+    return if (packageName.isNullOrBlank()) {
         copy(packageName = fallbackPackage)
     } else {
         this
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index 3fa950ed..c94b1814 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.translators.documentables
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.documentables.InheritorsInfo
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
@@ -14,8 +15,9 @@ import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
-private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<SourceSetData?, TagWrapper>>>
+private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<DokkaSourceSet?, TagWrapper>>>
 
 private val specialTags: Set<KClass<out TagWrapper>> =
     setOf(Property::class, Description::class, Constructor::class, Receiver::class, Param::class, See::class)
@@ -71,8 +73,13 @@ open class DefaultPageCreator(
     protected open fun contentForModule(m: DModule) = contentBuilder.contentFor(m) {
         group(kind = ContentKind.Cover) {
             cover(m.name)
-            if(contentForDescription(m).isNotEmpty()){
-                sourceSetDependentHint(m.dri, m.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = setOf(TextStyle.UnderCoverText)){
+            if (contentForDescription(m).isNotEmpty()) {
+                sourceSetDependentHint(
+                    m.dri,
+                    m.sourceSets.toSet(),
+                    kind = ContentKind.SourceSetDependantHint,
+                    styles = setOf(TextStyle.UnderCoverText)
+                ) {
                     +contentForDescription(m)
                 }
             }
@@ -88,13 +95,18 @@ open class DefaultPageCreator(
     protected open fun contentForPackage(p: DPackage) = contentBuilder.contentFor(p) {
         group(kind = ContentKind.Cover) {
             cover("Package ${p.name}")
-            if(contentForDescription(p).isNotEmpty()){
-                sourceSetDependentHint(p.dri, p.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = setOf(TextStyle.UnderCoverText)){
+            if (contentForDescription(p).isNotEmpty()) {
+                sourceSetDependentHint(
+                    p.dri,
+                    p.sourceSets.toSet(),
+                    kind = ContentKind.SourceSetDependantHint,
+                    styles = setOf(TextStyle.UnderCoverText)
+                ) {
                     +contentForDescription(p)
                 }
             }
         }
-        group(styles = setOf(ContentStyle.TabbedContent)){
+        group(styles = setOf(ContentStyle.TabbedContent)) {
             +contentForComments(p)
             +contentForScope(p, p.dri, p.sourceSets)
         }
@@ -103,15 +115,27 @@ open class DefaultPageCreator(
     protected open fun contentForScope(
         s: WithScope,
         dri: DRI,
-        sourceSets: Set<SourceSetData>
+        sourceSets: Set<DokkaSourceSet>
     ) = contentBuilder.contentFor(s as Documentable) {
         val types = listOf(
             s.classlikes,
             (s as? DPackage)?.typealiases ?: emptyList()
         ).flatten()
         divergentBlock("Types", types, ContentKind.Classlikes, extra = mainExtra + SimpleAttr.header("Types"))
-        divergentBlock("Functions", s.functions, ContentKind.Functions, extra = mainExtra + SimpleAttr.header( "Functions"))
-        block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet(), extra = mainExtra + SimpleAttr.header( "Properties")) {
+        divergentBlock(
+            "Functions",
+            s.functions,
+            ContentKind.Functions,
+            extra = mainExtra + SimpleAttr.header("Functions")
+        )
+        block(
+            "Properties",
+            2,
+            ContentKind.Properties,
+            s.properties,
+            sourceSets.toSet(),
+            extra = mainExtra + SimpleAttr.header("Properties")
+        ) {
             link(it.name, it.dri, kind = ContentKind.Main)
             sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 contentForBrief(it)
@@ -136,7 +160,7 @@ open class DefaultPageCreator(
                     DCI(setOf(dri), ContentKind.Inheritors),
                     sourceSets.toSet(),
                     style = emptySet(),
-                    extra = mainExtra + SimpleAttr.header( "Inheritors")
+                    extra = mainExtra + SimpleAttr.header("Inheritors")
                 )
             }
         }
@@ -150,7 +174,7 @@ open class DefaultPageCreator(
                 +buildSignature(e)
             }
         }
-        group(styles = setOf(ContentStyle.TabbedContent)){
+        group(styles = setOf(ContentStyle.TabbedContent)) {
             +contentForComments(e)
             +contentForScope(e, e.dri, e.sourceSets)
         }
@@ -177,14 +201,28 @@ open class DefaultPageCreator(
                     extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors")
                 ) {
                     link(it.name, it.dri, kind = ContentKind.Main)
-                    sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) {
+                    sourceSetDependentHint(
+                        it.dri,
+                        it.sourceSets.toSet(),
+                        kind = ContentKind.SourceSetDependantHint,
+                        styles = emptySet()
+                    ) {
                         contentForBrief(it)
                         +buildSignature(it)
                     }
                 }
             }
             if (c is DEnum) {
-                block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet(), needsSorting = false, extra = mainExtra + SimpleAttr.header("Entries"), styles = emptySet()) {
+                block(
+                    "Entries",
+                    2,
+                    ContentKind.Classlikes,
+                    c.entries,
+                    c.sourceSets.toSet(),
+                    needsSorting = false,
+                    extra = mainExtra + SimpleAttr.header("Entries"),
+                    styles = emptySet()
+                ) {
                     link(it.name, it.dri)
                     sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         contentForBrief(it)
@@ -198,11 +236,11 @@ open class DefaultPageCreator(
 
     @Suppress("UNCHECKED_CAST")
     private inline fun <reified T : TagWrapper> GroupedTags.withTypeUnnamed(): SourceSetDependent<T> =
-        (this[T::class] as List<Pair<SourceSetData, T>>?)?.toMap().orEmpty()
+        (this[T::class] as List<Pair<DokkaSourceSet, T>>?)?.toMap().orEmpty()
 
     @Suppress("UNCHECKED_CAST")
     private inline fun <reified T : NamedTagWrapper> GroupedTags.withTypeNamed(): Map<String, SourceSetDependent<T>> =
-        (this[T::class] as List<Pair<SourceSetData, T>>?)
+        (this[T::class] as List<Pair<DokkaSourceSet, T>>?)
             ?.groupBy { it.second.name }
             ?.mapValues { (_, v) -> v.toMap() }
             ?.toSortedMap(String.CASE_INSENSITIVE_ORDER)
@@ -234,8 +272,8 @@ open class DefaultPageCreator(
 
             val unnamedTags: List<SourceSetDependent<TagWrapper>> =
                 tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags }
-                    .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() }
-            if(unnamedTags.isNotEmpty()){
+                    .map { (_, v) -> v.mapNotNull { (k, v) -> k?.let { it to v } }.toMap() }
+            if (unnamedTags.isNotEmpty()) {
                 platforms.forEach { platform ->
                     unnamedTags.forEach { pdTag ->
                         pdTag[platform]?.also { tag ->
@@ -252,10 +290,10 @@ open class DefaultPageCreator(
         }.children
     }
 
-    private fun Documentable.getPossibleFallbackSourcesets(sourceSet: SourceSetData) =
+    private fun Documentable.getPossibleFallbackSourcesets(sourceSet: DokkaSourceSet) =
         this.sourceSets.filter { it.sourceSetID in sourceSet.dependentSourceSets }
 
-    private fun <V> Map<SourceSetData, V>.fallback(sourceSets: List<SourceSetData>) : V? =
+    private fun <V> Map<DokkaSourceSet, V>.fallback(sourceSets: List<DokkaSourceSet>): V? =
         sourceSets.firstOrNull { it in this.keys }.let { this[it] }
 
     protected open fun contentForComments(
@@ -270,7 +308,10 @@ open class DefaultPageCreator(
         fun DocumentableContentBuilder.contentForParams() {
             if (tags.isNotEmptyForTag<Param>()) {
                 header(2, "Parameters")
-                group(extra = mainExtra + SimpleAttr.header("Parameters"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("Parameters"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         val receiver = tags.withTypeUnnamed<Receiver>()
                         val params = tags.withTypeNamed<Param>()
@@ -287,7 +328,11 @@ open class DefaultPageCreator(
                                 val paramRows = params.mapNotNull { (_, param) ->
                                     (param[platform] ?: param.fallback(possibleFallbacks))?.let {
                                         buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
-                                            text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle)
+                                            text(
+                                                it.name,
+                                                kind = ContentKind.Parameters,
+                                                styles = mainStyles + ContentStyle.RowTitle
+                                            )
                                             comment(it.root)
                                         }
                                     }
@@ -304,7 +349,10 @@ open class DefaultPageCreator(
         fun DocumentableContentBuilder.contentForSeeAlso() {
             if (tags.isNotEmptyForTag<See>()) {
                 header(2, "See also")
-                group(extra = mainExtra + SimpleAttr.header("See also"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("See also"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         val seeAlsoTags = tags.withTypeNamed<See>()
                         table(kind = ContentKind.Sample) {
@@ -312,8 +360,16 @@ open class DefaultPageCreator(
                                 val possibleFallbacks = d.getPossibleFallbackSourcesets(platform)
                                 seeAlsoTags.mapNotNull { (_, see) ->
                                     (see[platform] ?: see.fallback(possibleFallbacks))?.let {
-                                        buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) {
-                                            if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment)
+                                        buildGroup(
+                                            sourceSets = setOf(platform),
+                                            kind = ContentKind.Comment,
+                                            styles = mainStyles + ContentStyle.RowTitle
+                                        ) {
+                                            if (it.address != null) link(
+                                                it.name,
+                                                it.address!!,
+                                                kind = ContentKind.Comment
+                                            )
                                             else text(it.name, kind = ContentKind.Comment)
                                             comment(it.root)
                                         }
@@ -330,11 +386,18 @@ open class DefaultPageCreator(
             val samples = tags.withTypeNamed<Sample>()
             if (samples.isNotEmpty()) {
                 header(2, "Samples")
-                group(extra = mainExtra + SimpleAttr.header("Samples"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("Samples"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         platforms.map { platformData ->
                             val content = samples.filter { it.value.isEmpty() || platformData in it.value }
-                            group(sourceSets = setOf(platformData), kind = ContentKind.Sample, styles = setOf(TextStyle.Monospace)) {
+                            group(
+                                sourceSets = setOf(platformData),
+                                kind = ContentKind.Sample,
+                                styles = setOf(TextStyle.Monospace)
+                            ) {
                                 content.forEach {
                                     text(it.key)
                                 }
@@ -413,29 +476,33 @@ open class DefaultPageCreator(
                     .mapValues { if (it.value.any { it is DClasslike }) it.value.filter { it !is DTypeAlias } else it.value }
                     .toSortedMap(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)){it})
                     .map { (elementName, elements) -> // This groupBy should probably use LocationProvider
-                    buildGroup(elements.map { it.dri }.toSet(), elements.flatMap { it.sourceSets }.toSet(), kind = kind) {
-                        link(elementName.orEmpty(), elements.first().dri, kind = kind)
-                        divergentGroup(
-                            ContentDivergentGroup.GroupID(name),
+                        buildGroup(
                             elements.map { it.dri }.toSet(),
+                            elements.flatMap { it.sourceSets }.toSet(),
                             kind = kind
                         ) {
-                            elements.map {
-                                instance(setOf(it.dri), it.sourceSets.toSet()) {
-                                    before {
-                                        contentForBrief(it)
-                                        contentForSinceKotlin(it)
-                                    }
-                                    divergent {
-                                        group {
-                                            +buildSignature(it)
+                            link(elementName.orEmpty(), elements.first().dri, kind = kind)
+                            divergentGroup(
+                                ContentDivergentGroup.GroupID(name),
+                                elements.map { it.dri }.toSet(),
+                                kind = kind
+                            ) {
+                                elements.map {
+                                    instance(setOf(it.dri), it.sourceSets.toSet()) {
+                                        before {
+                                            contentForBrief(it)
+                                            contentForSinceKotlin(it)
+                                        }
+                                        divergent {
+                                            group {
+                                                +buildSignature(it)
+                                            }
                                         }
                                     }
                                 }
                             }
                         }
                     }
-                }
             }
         }
     }
diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
index 9d10620e..a58ef114 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
@@ -1,9 +1,11 @@
 package org.jetbrains.dokka.base.translators.documentables
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -19,7 +21,7 @@ open class PageContentBuilder(
 ) {
     fun contentFor(
         dri: DRI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
@@ -31,7 +33,7 @@ open class PageContentBuilder(
 
     fun contentFor(
         dri: Set<DRI>,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
@@ -46,7 +48,7 @@ open class PageContentBuilder(
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
-        sourceSets: Set<SourceSetData> = d.sourceSets.toSet(),
+        sourceSets: Set<DokkaSourceSet> = d.sourceSets.toSet(),
         block: DocumentableContentBuilder.() -> Unit = {}
     ): ContentGroup =
         DocumentableContentBuilder(setOf(d.dri), sourceSets, styles, extra)
@@ -56,14 +58,14 @@ open class PageContentBuilder(
     @ContentBuilderMarker
     open inner class DocumentableContentBuilder(
         val mainDRI: Set<DRI>,
-        val mainPlatformData: Set<SourceSetData>,
+        val mainPlatformData: Set<DokkaSourceSet>,
         val mainStyles: Set<Style>,
         val mainExtra: PropertyContainer<ContentNode>
     ) {
         protected val contents = mutableListOf<ContentNode>()
 
         fun build(
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             kind: Kind,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
@@ -87,7 +89,7 @@ open class PageContentBuilder(
             level: Int,
             text: String,
             kind: Kind = ContentKind.Main,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit = {}
@@ -109,18 +111,18 @@ open class PageContentBuilder(
 
         fun cover(
             text: String,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles + TextStyle.Cover,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit = {}
-            ) {
+        ) {
             header(1, text, platformData = platformData, styles = styles, extra = extra, block = block)
         }
 
         fun text(
             text: String,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -132,7 +134,7 @@ open class PageContentBuilder(
         fun linkTable(
             elements: List<DRI>,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -150,7 +152,7 @@ open class PageContentBuilder(
 
         fun table(
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             operation: DocumentableContentBuilder.() -> List<ContentGroup>
@@ -168,7 +170,7 @@ open class PageContentBuilder(
             level: Int,
             kind: Kind = ContentKind.Main,
             elements: Iterable<T>,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             renderWhenEmpty: Boolean = false,
@@ -180,16 +182,16 @@ open class PageContentBuilder(
                 contents += ContentTable(
                     emptyList(),
                     elements
-                        .let{
+                        .let {
                             if (needsSorting)
-                                it.sortedWith(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)){ it.name })
+                                it.sortedWith(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)) { it.name })
                             else it
                         }
                         .map {
-                        buildGroup(setOf(it.dri), it.sourceSets.toSet(), kind, styles, extra) {
-                            operation(it)
-                        }
-                    },
+                            buildGroup(setOf(it.dri), it.sourceSets.toSet(), kind, styles, extra) {
+                                operation(it)
+                            }
+                        },
                     DCI(mainDRI, kind),
                     sourceSets, styles, extra
                 )
@@ -201,7 +203,7 @@ open class PageContentBuilder(
             prefix: String = "",
             suffix: String = "",
             separator: String = ", ",
-            sourceSets: Set<SourceSetData> = mainPlatformData, // TODO: children should be aware of this platform data
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData, // TODO: children should be aware of this platform data
             operation: DocumentableContentBuilder.(T) -> Unit
         ) {
             if (elements.isNotEmpty()) {
@@ -219,7 +221,7 @@ open class PageContentBuilder(
             text: String,
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -230,7 +232,7 @@ open class PageContentBuilder(
             text: String,
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) = ContentDRILink(
@@ -244,7 +246,7 @@ open class PageContentBuilder(
             text: String,
             address: String,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) =
@@ -260,7 +262,7 @@ open class PageContentBuilder(
         fun link(
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
@@ -276,7 +278,7 @@ open class PageContentBuilder(
         fun comment(
             docTag: DocTag,
             kind: Kind = ContentKind.Comment,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -290,7 +292,7 @@ open class PageContentBuilder(
 
         fun group(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -316,7 +318,7 @@ open class PageContentBuilder(
 
         fun buildGroup(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -325,7 +327,7 @@ open class PageContentBuilder(
 
         fun sourceSetDependentHint(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -339,7 +341,7 @@ open class PageContentBuilder(
 
         fun sourceSetDependentHint(
             dri: DRI,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -354,7 +356,7 @@ open class PageContentBuilder(
         protected fun createText(
             text: String,
             kind: Kind,
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
         ) =
@@ -362,7 +364,7 @@ open class PageContentBuilder(
 
         fun <T> sourceSetDependentText(
             value: SourceSetDependent<T>,
-            sourceSets: Set<SourceSetData> = value.keys,
+            sourceSets: Set<DokkaSourceSet> = value.keys,
             transform: (T) -> String
         ) = value.entries.filter { it.key in sourceSets }.mapNotNull { (p, v) ->
             transform(v).takeIf { it.isNotBlank() }?.let { it to p }
@@ -381,7 +383,7 @@ open class PageContentBuilder(
         private val instances: MutableList<ContentDivergentInstance> = mutableListOf()
         fun instance(
             dri: Set<DRI>,
-            sourceSets: Set<SourceSetData>,  // Having correct PlatformData is crucial here, that's why there's no default
+            sourceSets: Set<DokkaSourceSet>,  // Having correct PlatformData is crucial here, that's why there's no default
             kind: Kind = mainKind,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -411,7 +413,7 @@ open class PageContentBuilder(
     @ContentBuilderMarker
     open inner class DivergentInstanceBuilder(
         private val mainDRI: Set<DRI>,
-        private val mainSourceSets: Set<SourceSetData>,
+        private val mainSourceSets: Set<DokkaSourceSet>,
         private val mainStyles: Set<Style>,
         private val mainExtra: PropertyContainer<ContentNode>
     ) {
@@ -421,7 +423,7 @@ open class PageContentBuilder(
 
         fun before(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -434,7 +436,7 @@ open class PageContentBuilder(
 
         fun divergent(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -445,7 +447,7 @@ open class PageContentBuilder(
 
         fun after(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -459,7 +461,7 @@ open class PageContentBuilder(
 
         fun build(
             kind: Kind,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) =
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index e71d936a..8588534b 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -7,10 +7,10 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.PsiClassReferenceType
 import com.intellij.psi.impl.source.PsiImmediateClassType
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.analysis.from
-import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.nextTarget
 import org.jetbrains.dokka.links.withClass
@@ -21,7 +21,6 @@ import org.jetbrains.dokka.model.doc.Param
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
@@ -42,7 +41,7 @@ class DefaultPsiToDocumentableTranslator(
     private val kotlinAnalysis: KotlinAnalysis
 ) : SourceToDocumentableTranslator {
 
-    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule {
 
         fun isFileInSourceRoots(file: File): Boolean {
             return sourceSet.sourceRoots.any { root -> file.path.startsWith(File(root.path).absolutePath) }
@@ -93,7 +92,7 @@ class DefaultPsiToDocumentableTranslator(
     }
 
     class DokkaPsiParser(
-        private val sourceSetData: SourceSetData,
+        private val sourceSetData: DokkaSourceSet,
         private val logger: DokkaLogger
     ) {
 
@@ -187,7 +186,7 @@ class DefaultPsiToDocumentableTranslator(
                     fields.filterIsInstance<PsiEnumConstant>().map { entry ->
                         DEnumEntry(
                             dri.withClass("$name.${entry.name}"),
-                            entry.name.orEmpty(),
+                            entry.name,
                             javadocParser.parseDocumentation(entry).toSourceSetDependent(),
                             null,
                             emptyList(),
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index f66f88db..2e05d241 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -3,8 +3,6 @@ package content.params
 import matchers.content.*
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.model.DFunction
-import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.Param
 import org.jetbrains.dokka.model.doc.Text
@@ -570,7 +568,7 @@ class ContentForParamsTest : AbstractCoreTest() {
     }
 
     @Test
-    fun javaDocCommentWithDocumentedParameters(){
+    fun javaDocCommentWithDocumentedParameters() {
         testInline(
             """
             |/src/main/java/test/Main.java
@@ -587,14 +585,14 @@ class ContentForParamsTest : AbstractCoreTest() {
             |   }
             | }
         """.trimIndent(), testConfiguration
-        ){
-            pagesTransformationStage = {
-                module ->
+        ) {
+            pagesTransformationStage = { module ->
                 val sampleFunction = module.dfs {
-                    it is MemberPageNode && it.dri.first().toString() == "test/Main/sample/#java.lang.String#java.lang.String/PointingToDeclaration/"
+                    it is MemberPageNode && it.dri.first()
+                        .toString() == "test/Main/sample/#java.lang.String#java.lang.String/PointingToDeclaration/"
                 } as MemberPageNode
                 val forJvm = (sampleFunction.documentable as DFunction).parameters.mapNotNull {
-                    val jvm = it.documentation.keys.first { it.platform == Platform.jvm }
+                    val jvm = it.documentation.keys.first { it.analysisPlatform == Platform.jvm }
                     it.documentation[jvm]
                 }
 
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index 5daebb73..f5517abb 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -31,7 +31,7 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
         ) {
             with((this / "inheritors" / "A").cast<DInterface>()) {
                 val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
-                with(map.keys.also { it counts 1 }.find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
+                with(map.keys.also { it counts 1 }.find { it.analysisPlatform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
                 ) {
                     this counts 1
                     first().classNames equals "B"
@@ -77,11 +77,11 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
                 with((m / "inheritors" / "A").cast<DInterface>()) {
                     val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
                     with(map.keys.also { it counts 2 }) {
-                        with(find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
+                        with(find { it.analysisPlatform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
                             this counts 1
                             first().classNames equals "B"
                         }
-                        with(find { it.platform == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
+                        with(find { it.analysisPlatform == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
                             this counts 2
                             val classes = listOf("B", "C")
                             assertTrue(all { classes.contains(it.classNames) }, "One of subclasses missing in js" )
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index 452439e9..21a70802 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -1,21 +1,17 @@
 package renderers
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProviderFactory
-import org.jetbrains.dokka.base.resolvers.local.LocationProvider
-import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
 import org.jetbrains.dokka.base.signatures.KotlinSignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
-import org.jetbrains.dokka.base.transformers.pages.samples.DefaultSamplesTransformer
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -35,7 +31,6 @@ abstract class RenderingOnlyTestBase {
         DokkaBase().htmlPreprocessors to { _ -> RootCreator },
         DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
         DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
-        sourceSetCache = SourceSetCache(),
         testConfiguration = DokkaConfigurationImpl(
             "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
         )
@@ -110,7 +105,7 @@ internal object EmptyCommentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
         extras: PropertyContainer<ContentNode>
     ): List<ContentNode> = emptyList()
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index b10202bb..6ceb805b 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -4,15 +4,33 @@ import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.SourceRootImpl
 import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.ContentDivergentGroup
 import org.junit.jupiter.api.Test
 import renderers.*
 
 class DivergentTest : RenderingOnlyTestBase() {
-    private val js = SourceSetData("root", "js", "JS", Platform.js, listOf(SourceRootImpl("pl1")))
-    private val jvm = SourceSetData("root", "jvm", "JVM", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val native = SourceSetData("root", "native", "NATIVE", Platform.native, listOf(SourceRootImpl("pl1")))
+    private val js = defaultSourceSet.copy(
+        "root",
+        "JS",
+        "js",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val jvm = defaultSourceSet.copy(
+        "root",
+        "JVM",
+        "jvm",
+
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val native = defaultSourceSet.copy(
+        "root",
+        "NATIVE",
+        "native",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
 
     @Test
     fun simpleWrappingCase() {
@@ -178,10 +196,10 @@ class DivergentTest : RenderingOnlyTestBase() {
 
         HtmlRenderer(context).render(page)
         renderedContent.match(
-            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("a"))),"a+"),
-            Div(Div(Span(Div(Div("JS")))), Div(Div(Div("bd"))),"bd+"),
+            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("a"))), "a+"),
+            Div(Div(Span(Div(Div("JS")))), Div(Div(Div("bd"))), "bd+"),
             Div(Div(Span(Div(Div("JVM")))), Div(Div(Div("c")))),
-            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("e"))),"e+"),
+            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("e"))), "e+"),
         )
     }
 
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index 878f442b..c868cfd5 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -3,7 +3,6 @@ package renderers.html
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.SourceRootImpl
 import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
 import renderers.Div
@@ -12,9 +11,28 @@ import renderers.TestPage
 import renderers.match
 
 class SourceSetDependentHintTest : RenderingOnlyTestBase() {
-    private val pl1 = SourceSetData("root", "pl1", "pl3",Platform.js, listOf(SourceRootImpl("pl1")))
-    private val pl2 = SourceSetData("root","pl2", "pl3", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val pl3 = SourceSetData("root","pl3", "pl3", Platform.native, listOf(SourceRootImpl("pl1")))
+
+    private val pl1 = defaultSourceSet.copy(
+        "root",
+        "pl1",
+        "pl1",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl2 = defaultSourceSet.copy(
+        "root",
+        "pl2",
+        "pl2",
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl3 = defaultSourceSet.copy(
+        "root",
+        "pl3",
+        "pl3",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
 
     @Test
     fun platformIndependentCase() {
diff --git a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
new file mode 100644
index 00000000..771cabaa
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
@@ -0,0 +1,30 @@
+package renderers.html
+
+import org.jetbrains.dokka.DokkaSourceSetImpl
+import org.jetbrains.dokka.Platform
+
+internal val defaultSourceSet = DokkaSourceSetImpl(
+    moduleName = "DEFAULT",
+    displayName = "DEFAULT",
+    sourceSetID = "DEFAULT",
+    classpath = emptyList(),
+    sourceRoots = emptyList(),
+    dependentSourceSets = emptyList(),
+    samples = emptyList(),
+    includes = emptyList(),
+    includeNonPublic = false,
+    includeRootPackage = false,
+    reportUndocumented = false,
+    skipEmptyPackages = true,
+    skipDeprecated = false,
+    jdkVersion = 8,
+    sourceLinks = emptyList(),
+    perPackageOptions = emptyList(),
+    externalDocumentationLinks = emptyList(),
+    languageVersion = null,
+    apiVersion = null,
+    noStdlibLink = false,
+    noJdkLink = false,
+    suppressedFiles = emptyList(),
+    analysisPlatform = Platform.DEFAULT
+)
\ No newline at end of file
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index fb83d3b0..53ee2b53 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -1,20 +1,19 @@
 package org.jetbrains.dokka.gfm
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.base.renderers.PackageListCreator
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProvider
 import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.query
 import org.jetbrains.dokka.transformers.pages.PageTransformer
-import java.lang.StringBuilder
 
 
 class GfmPlugin : DokkaPlugin() {
@@ -66,7 +65,7 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        platformRestriction: Set<SourceSetData>?
+        platformRestriction: Set<DokkaSourceSet>?
     ) {
         buildParagraph()
         buildListLevel(node, pageContext)
@@ -114,17 +113,21 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         val distinct = content.sourceSets.map {
-            it to StringBuilder().apply {buildContentNode(content.inner, pageContext, setOf(it)) }.toString()
-        }.groupBy(Pair<SourceSetData, String>::second, Pair<SourceSetData, String>::first)
+            it to StringBuilder().apply { buildContentNode(content.inner, pageContext, setOf(it)) }.toString()
+        }.groupBy(Pair<DokkaSourceSet, String>::second, Pair<DokkaSourceSet, String>::first)
 
         if (distinct.size == 1)
             append(distinct.keys.single())
         else
             distinct.forEach { text, platforms ->
-                append(platforms.joinToString(prefix = " [", postfix = "] $text") { "${it.moduleName}/${it.sourceSetID}"  })
+                append(
+                    platforms.joinToString(
+                        prefix = " [",
+                        postfix = "] $text"
+                    ) { "${it.moduleName}/${it.sourceSetID}" })
             }
     }
 
@@ -135,7 +138,7 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        platformRestriction: Set<SourceSetData>?
+        platformRestriction: Set<DokkaSourceSet>?
     ) {
 
         buildParagraph()
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
index a92320dd..f8ecf868 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
@@ -1,11 +1,11 @@
 package javadoc
 
 import javadoc.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
@@ -22,8 +22,8 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
         externalLocationProviderFactories.asSequence().map { it.getExternalLocationProvider("javadoc10") }
             .filterNotNull().take(1).firstOrNull()
     private val externalDocumentationLinks by lazy {
-        context.configuration.passesConfigurations
-            .filter { passConfig -> passConfig.analysisPlatform == Platform.jvm }
+        context.configuration.sourceSets
+            .filter { sourceSet -> sourceSet.analysisPlatform == Platform.jvm }
             .flatMap { it.externalDocumentationLinks }
             .distinct()
     }
@@ -65,7 +65,7 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
 
     private operator fun IdentityHashMap<PageNode, List<String>>.get(dri: DRI) = this[nodeIndex[dri]]
 
-    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         context?.let { resolve(it, skipExtension = false) } ?: nodeIndex[dri]?.let {
             resolve(it, skipExtension = true)
         } ?: with(externalLocationProvider!!) {
@@ -79,19 +79,20 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
             throw IllegalStateException("Path for ${node::class.java.canonicalName}:${node.name} not found")
         }
 
-    fun resolve(link: LinkJavadocListEntry, dir: String = "", skipExtension: Boolean = true) = pathIndex[link.dri.first()]?.let {
-        when (link.kind) {
-            JavadocContentKind.Class -> it
-            JavadocContentKind.OverviewSummary -> it.dropLast(1) + "index"
-            JavadocContentKind.PackageSummary -> it.dropLast(1) + "package-summary"
-            JavadocContentKind.AllClasses -> it.dropLast(1) + "allclasses"
-            JavadocContentKind.OverviewTree -> it.dropLast(1) + "overview-tree"
-            JavadocContentKind.PackageTree -> it.dropLast(1) + "package-tree"
-            else -> it
-        }
-    }?.joinToString("/")?.let {if (skipExtension) "$it.html" else it}?.let {
-        Paths.get(dir).relativize(Paths.get(it)).toString()
-    } ?: run {""} //TODO just a glue to compile it on HMPP
+    fun resolve(link: LinkJavadocListEntry, dir: String = "", skipExtension: Boolean = true) =
+        pathIndex[link.dri.first()]?.let {
+            when (link.kind) {
+                  JavadocContentKind.Class -> it
+                JavadocContentKind.OverviewSummary -> it.dropLast(1) + "index"
+                JavadocContentKind.PackageSummary -> it.dropLast(1) + "package-summary"
+                JavadocContentKind.AllClasses -> it.dropLast(1) + "allclasses"
+                JavadocContentKind.OverviewTree -> it.dropLast(1) + "overview-tree"
+                JavadocContentKind.PackageTree -> it.dropLast(1) + "package-tree"
+                else -> it
+            }
+        }?.joinToString("/")?.let { if (skipExtension) "$it.html" else it }?.let {
+            Paths.get(dir).relativize(Paths.get(it)).toString()
+        } ?: run { "" } //TODO just a glue to compile it on HMPP
 
     override fun resolveRoot(node: PageNode): String {
         TODO("Not yet implemented")
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
index 53292225..6cf34ed1 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
@@ -1,6 +1,7 @@
 package javadoc
 
 import javadoc.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.signatures.function
@@ -40,7 +41,7 @@ open class JavadocPageCreator(
         )
 
     fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode? =
-        c.sourceSets.firstOrNull { it.platform == Platform.jvm }?.let { jvm ->
+        c.sourceSets.firstOrNull { it.analysisPlatform == Platform.jvm }?.let { jvm ->
             JavadocClasslikePageNode(
                 name = c.name.orEmpty(),
                 content = contentForClasslike(c),
@@ -72,11 +73,11 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(m.dri),
             JavadocContentKind.OverviewSummary,
-            m.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            m.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(m.name, "0.0.1", dri = setOf(m.dri), kind = ContentKind.Main)
             list("Packages", "Package", setOf(m.dri), ContentKind.Packages, m.packages.sortedBy { it.name }.map { p ->
-                val description = p.documentation.entries.find { (k, _) -> k.platform == Platform.jvm }?.value?.let {
+                val description = p.documentation.entries.find { (k, _) -> k.analysisPlatform == Platform.jvm }?.value?.let {
                     it.children.firstIsInstanceOrNull<Description>()?.let { description ->
                         DocTagToContentConverter.buildContent(
                             description.root,
@@ -96,7 +97,7 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(p.dri),
             JavadocContentKind.PackageSummary,
-            p.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            p.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(p.name, "0.0.1", dri = setOf(p.dri), kind = ContentKind.Packages)
             list("Packages", "Package", setOf(p.dri), ContentKind.Packages, p.classlikes.sortedBy { it.name }.map { c ->
@@ -111,7 +112,7 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(c.dri),
             JavadocContentKind.Class,
-            c.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            c.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(
                 c.name.orEmpty(),
@@ -146,7 +147,7 @@ open class JavadocPageCreator(
             is UnresolvedBound -> p.name
         }
 
-    private fun DFunction.toJavadocFunction(sourceSetData: SourceSetData) = JavadocFunctionNode(
+    private fun DFunction.toJavadocFunction(sourceSetData: DokkaSourceSet) = JavadocFunctionNode(
         name = name,
         signature = signatureProvider.signature(this).jvmSignature(),
         brief = TextNode(description(sourceSetData), setOf(sourceSetData)),
@@ -161,12 +162,12 @@ open class JavadocPageCreator(
     )
 
     fun List<ContentNode>.jvmSignature(): ContentNode =
-        first { it.sourceSets.any { it.platform == Platform.jvm } }
+        first { it.sourceSets.any { it.analysisPlatform == Platform.jvm } }
 
-    private fun Documentable.description(sourceSetData: SourceSetData): String =
+    private fun Documentable.description(sourceSetData: DokkaSourceSet): String =
         findNodeInDocumentation<Description>(sourceSetData)
 
-    private inline fun <reified T : TagWrapper> Documentable.findNodeInDocumentation(sourceSetData: SourceSetData): String =
+    private inline fun <reified T : TagWrapper> Documentable.findNodeInDocumentation(sourceSetData: DokkaSourceSet): String =
         documentation[sourceSetData]?.children?.firstIsInstanceOrNull<T>()?.root?.children?.firstIsInstanceOrNull<Text>()?.body.orEmpty()
 }
 
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt b/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
index 370ee68b..23a7c9ed 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
@@ -12,7 +12,7 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.sureClassNames
 import org.jetbrains.dokka.model.ImplementedInterfaces
 import org.jetbrains.dokka.model.InheritedFunction
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.renderers.Renderer
@@ -269,13 +269,13 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
             ) + renderJavadocContentNode(node.content)
 
         private fun renderImplementedInterfaces(node: JavadocClasslikePageNode) =
-            node.extras[ImplementedInterfaces]?.interfaces?.entries?.firstOrNull { it.key.platform == Platform.jvm }?.value?.map { it.displayable() } // TODO: REMOVE HARDCODED JVM DEPENDENCY
+            node.extras[ImplementedInterfaces]?.interfaces?.entries?.firstOrNull { it.key.analysisPlatform == Platform.jvm }?.value?.map { it.displayable() } // TODO: REMOVE HARDCODED JVM DEPENDENCY
             .orEmpty()
 
         private fun renderClasslikeMethods(nodes: List<JavadocFunctionNode>): TemplateMap {
             val (inherited, own) = nodes.partition {
                 val extra = it.extras[InheritedFunction]
-                extra?.inheritedFrom?.keys?.first { it.platform == Platform.jvm }?.let { jvm ->
+                extra?.inheritedFrom?.keys?.first { it.analysisPlatform == Platform.jvm }?.let { jvm ->
                     extra.isInherited(jvm)
                 } ?: false
             }
@@ -294,7 +294,7 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
         private fun renderInheritedMethod(node: JavadocFunctionNode): TemplateMap {
             val inheritedFrom = node.extras[InheritedFunction]?.inheritedFrom
             return mapOf(
-                "inheritedFrom" to inheritedFrom?.entries?.firstOrNull { it.key.platform == Platform.jvm }?.value?.displayable() // TODO: REMOVE HARDCODED JVM DEPENDENCY
+                "inheritedFrom" to inheritedFrom?.entries?.firstOrNull { it.key.analysisPlatform == Platform.jvm }?.value?.displayable() // TODO: REMOVE HARDCODED JVM DEPENDENCY
                 .orEmpty(),
                 "name" to node.name
             )
@@ -370,7 +370,7 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
             )
         }
 
-        private fun resolveLink(address: DRI, sourceSets: Set<SourceSetData>) =
+        private fun resolveLink(address: DRI, sourceSets: Set<DokkaSourceSet>) =
             locationProvider.resolve(address, sourceSets.toList()).let {
                 val afterFormattingToHtml = formatToEndWithHtml(it)
                 if (currentLocation != null) afterFormattingToHtml.relativizePath(currentLocation)
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
index 6587e290..286223fa 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
@@ -1,7 +1,7 @@
 package javadoc.pages
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
 
@@ -12,7 +12,7 @@ enum class JavadocContentKind : Kind {
 abstract class JavadocContentNode(
     dri: Set<DRI>,
     kind: Kind,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : ContentNode {
     override val dci: DCI = DCI(dri, kind)
     override val style: Set<Style> = emptySet()
@@ -27,7 +27,7 @@ interface JavadocListEntry {
 class EmptyNode(
     dri: DRI,
     kind: Kind,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentNode {
     override val dci: DCI = DCI(setOf(dri), kind)
@@ -42,7 +42,7 @@ class EmptyNode(
 class JavadocContentGroup(
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>,
+    sourceSets: Set<DokkaSourceSet>,
     val children: List<JavadocContentNode>
 ) : JavadocContentNode(dri, kind, sourceSets) {
 
@@ -50,7 +50,7 @@ class JavadocContentGroup(
         operator fun invoke(
             dri: Set<DRI>,
             kind: Kind,
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             block: JavaContentGroupBuilder.() -> Unit
         ): JavadocContentGroup =
             JavadocContentGroup(dri, kind, sourceSets, JavaContentGroupBuilder(sourceSets).apply(block).list)
@@ -59,7 +59,7 @@ class JavadocContentGroup(
     override fun hasAnyContent(): Boolean = children.isNotEmpty()
 }
 
-class JavaContentGroupBuilder(val sourceSets: Set<SourceSetData>) {
+class JavaContentGroupBuilder(val sourceSets: Set<DokkaSourceSet>) {
     val list = mutableListOf<JavadocContentNode>()
 }
 
@@ -69,7 +69,7 @@ class TitleNode(
     val parent: String?,
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>
+    sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(dri, kind, sourceSets) {
     override fun hasAnyContent(): Boolean = !title.isBlank() || !version.isBlank()
 }
@@ -86,7 +86,7 @@ fun JavaContentGroupBuilder.title(
 
 data class TextNode(
     val text: String,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(emptySet(), ContentKind.Main, sourceSets) {
     override fun hasAnyContent(): Boolean = !text.isBlank()
 }
@@ -97,7 +97,7 @@ class ListNode(
     val children: List<JavadocListEntry>,
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>
+    sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(dri, kind, sourceSets) {
     override fun hasAnyContent(): Boolean = children.isNotEmpty()
 }
@@ -117,7 +117,7 @@ class LinkJavadocListEntry(
     val name: String,
     val dri: Set<DRI>,
     val kind: Kind = ContentKind.Symbol,
-    val sourceSets: Set<SourceSetData>
+    val sourceSets: Set<DokkaSourceSet>
 ) :
     JavadocListEntry {
     override val stringTag: String
@@ -127,7 +127,7 @@ class LinkJavadocListEntry(
 
     private var builtString: String? = null
 
-    fun build(body: (String, Set<DRI>, Kind, List<SourceSetData>) -> String) {
+    fun build(body: (String, Set<DRI>, Kind, List<DokkaSourceSet>) -> String) {
         builtString = body(name, dri, kind, sourceSets.toList())
     }
 }
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
index becacd26..8cd16dba 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
@@ -418,7 +418,7 @@ class TreeViewPage(
         (this as? WithExpectActual).descriptorForPlatform(platform)
 
     private fun WithExpectActual?.descriptorForPlatform(platform: Platform = Platform.jvm) = this?.let {
-        it.sources.entries.find { it.key.platform == platform }?.value?.let { it as? DescriptorDocumentableSource }?.descriptor as? ClassDescriptor
+        it.sources.entries.find { it.key.analysisPlatform == platform }?.value?.let { it as? DescriptorDocumentableSource }?.descriptor as? ClassDescriptor
     }
 
     data class InheritanceNode(
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index 80971ae2..37c13442 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka
 import com.google.gson.Gson
 import kotlinx.cli.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
-import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet.*
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.cast
 import java.io.*
@@ -31,9 +31,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
         description = "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled"
     )
 
-    override val passesConfigurations by parser.option(
+    override val sourceSets by parser.option(
         ArgTypeArgument,
-        description = "Single dokka pass",
+        description = "Single dokka source set",
         fullName = "pass"
     ).multiple()
 
@@ -83,18 +83,18 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     init {
         parser.parse(args)
 
-        passesConfigurations.all {
+        sourceSets.all {
             it.perPackageOptions.cast<MutableList<DokkaConfiguration.PackageOptions>>()
                 .addAll(parsePerPackageOptions(globalPackageOptions))
         }
 
-        passesConfigurations.all {
+        sourceSets.all {
             it.externalDocumentationLinks.cast<MutableList<ExternalDocumentationLink>>().addAll(parseLinks(globalLinks))
         }
 
         globalSrcLink.forEach {
             if (it.isNotEmpty() && it.contains("="))
-                passesConfigurations.all { pass ->
+                sourceSets.all { pass ->
                     pass.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
                         .add(SourceLinkDefinitionImpl.parseSourceLinkDefinition(it))
                 }
@@ -103,13 +103,13 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
             }
         }
 
-        passesConfigurations.forEach {
+        sourceSets.forEach {
             it.externalDocumentationLinks.cast<MutableList<ExternalDocumentationLink>>().addAll(defaultLinks(it))
         }
     }
 }
 
-fun passArguments(args: Array<String>): DokkaConfiguration.PassConfiguration {
+fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
     val parser = ArgParser("passConfiguration", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
 
@@ -226,7 +226,7 @@ fun passArguments(args: Array<String>): DokkaConfiguration.PassConfiguration {
 
     parser.parse(args)
 
-    return object : DokkaConfiguration.PassConfiguration {
+    return object : DokkaConfiguration.DokkaSourceSet {
         override val moduleName = moduleName
         override val displayName = displayName
         override val sourceSetID = sourceSetID
@@ -289,8 +289,8 @@ object ArgTypeSourceLinkDefinition : ArgType<DokkaConfiguration.SourceLinkDefini
         get() = "{ String that represent source links }"
 }
 
-object ArgTypeArgument : ArgType<DokkaConfiguration.PassConfiguration>(true) {
-    override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.PassConfiguration =
+object ArgTypeArgument : ArgType<DokkaConfiguration.DokkaSourceSet>(true) {
+    override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.DokkaSourceSet =
         passArguments(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
 
     override val description: kotlin.String
@@ -305,7 +305,7 @@ object ArgTypeHelpPass : ArgType<Any>(false) {
         get() = ""
 }
 
-fun defaultLinks(config: DokkaConfiguration.PassConfiguration): MutableList<ExternalDocumentationLink> =
+fun defaultLinks(config: DokkaConfiguration.DokkaSourceSet): MutableList<ExternalDocumentationLink> =
     mutableListOf<ExternalDocumentationLink>().apply {
         if (!config.noJdkLink)
             this += DokkaConfiguration.ExternalDocumentationLink
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index cef3695a..8483cd60 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -38,7 +38,7 @@ open class DokkaCollectorTask : DefaultTask() {
         configuration = passesConfigurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
             if(acc.format != it.format || acc.cacheRoot != it.cacheRoot)
                 throw IllegalStateException("Dokka task configurations differ on core arguments (format, cacheRoot)")
-            acc.passesConfigurations = acc.passesConfigurations + it.passesConfigurations
+            acc.sourceSets = acc.sourceSets + it.sourceSets
             acc.pluginsClasspath = (acc.pluginsClasspath + it.pluginsClasspath).distinct()
             acc
         }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
index 1759b6f3..cc9471a1 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
@@ -69,9 +69,9 @@ open class DokkaTask : DefaultTask(), Configurable {
 
     internal var config: GradleDokkaConfigurationImpl? = null
 
-    var dokkaSourceSets: NamedDomainObjectContainer<GradlePassConfigurationImpl>
+    var dokkaSourceSets: NamedDomainObjectContainer<GradleDokkaSourceSet>
         @Suppress("UNCHECKED_CAST")
-        @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradlePassConfigurationImpl>)
+        @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradleDokkaSourceSet>)
         internal set(value) = DslObject(this).extensions.add(SOURCE_SETS_EXTENSION_NAME, value)
 
     private val kotlinTasks: List<Task> by lazy {
@@ -184,7 +184,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             .map { defaultPassConfiguration(it, globalConfig) }.takeIf { it.isNotEmpty() }
             ?: listOf(
                 defaultPassConfiguration(
-                    collectSinglePassConfiguration(GradlePassConfigurationImpl("main")),
+                    collectSinglePassConfiguration(GradleDokkaSourceSet("main")),
                     null
                 )
             ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
@@ -199,7 +199,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             format = outputFormat
             cacheRoot = this@DokkaTask.cacheRoot
             offlineMode = this@DokkaTask.offlineMode
-            passesConfigurations = defaultModulesConfiguration
+            sourceSets = passConfigurations
             pluginsClasspath = pluginsClasspathConfiguration.resolve().toList()
             pluginsConfiguration = this@DokkaTask.pluginsConfiguration
             failOnWarning = this@DokkaTask.failOnWarning
@@ -207,12 +207,12 @@ open class DokkaTask : DefaultTask(), Configurable {
     }
 
 
-    protected val passConfigurations: List<GradlePassConfigurationImpl>
+    protected val passConfigurations: List<GradleDokkaSourceSet>
         get() = dokkaSourceSets
             .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
             .map { collectSinglePassConfiguration(it) }
 
-    protected fun collectSinglePassConfiguration(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
+    protected fun collectSinglePassConfiguration(config: GradleDokkaSourceSet): GradleDokkaSourceSet {
         val userConfig = config
             .apply {
                 collectKotlinTasks?.let {
@@ -259,7 +259,7 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
     }
 
-    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradlePassConfigurationImpl) =
+    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradleDokkaSourceSet) =
         kotlinTasks.find { it.name == name }
             ?.let { configExtractor.extractFromKotlinTasks(listOf(it)) }
             ?.singleOrNull()
@@ -269,7 +269,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             ?: userConfig
 
     protected fun mergeUserConfigurationAndPlatformData(
-        userConfig: GradlePassConfigurationImpl,
+        userConfig: GradleDokkaSourceSet,
         autoConfig: PlatformData
     ) =
         userConfig.copy().apply {
@@ -281,9 +281,9 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
 
     protected fun defaultPassConfiguration(
-        config: GradlePassConfigurationImpl,
-        globalConfig: GradlePassConfigurationImpl?
-    ): GradlePassConfigurationImpl {
+        config: GradleDokkaSourceSet,
+        globalConfig: GradleDokkaSourceSet?
+    ): GradleDokkaSourceSet {
         if (config.moduleName.isBlank()) {
             config.moduleName = project.name
         }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index f4e7730e..c5169ef8 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -16,7 +16,7 @@ import java.util.concurrent.Callable
 import kotlin.reflect.KMutableProperty
 import kotlin.reflect.full.memberProperties
 
-class GradleSourceRootImpl: SourceRoot, Serializable {
+class GradleSourceRootImpl : SourceRoot, Serializable {
     override var path: String = ""
         set(value) {
             field = File(value).absolutePath
@@ -25,33 +25,63 @@ class GradleSourceRootImpl: SourceRoot, Serializable {
     override fun toString(): String = path
 }
 
-open class GradlePassConfigurationImpl(@Transient val name: String = ""): PassConfiguration {
-    @Input @Optional override var classpath: List<String> = emptyList()
-    @Input override var moduleName: String = ""
-    @Input override var displayName: String = ""
-    @Input override var sourceSetID: String = ""
-    @Input override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
-    @Input override var dependentSourceSets: MutableList<String> = mutableListOf()
-    @Input override var samples: List<String> = emptyList()
-    @Input override var includes: List<String> = emptyList()
-    @Input override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
-    @Input override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
-    @Input override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
-    @Input override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
-    @Input override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
-    @Input override var jdkVersion: Int = DokkaDefaults.jdkVersion
-    @Input override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
-    @Input override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
-    @Input override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
-    @Input @Optional override var languageVersion: String? = null
-    @Input @Optional override var apiVersion: String? = null
-    @Input override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
-    @Input override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
-    @Input var noAndroidSdkLink: Boolean = false
-    @Input override var suppressedFiles: List<String> = emptyList()
-    @Input override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
-    @Input @Optional var platform: String? = null
-    @Transient var collectKotlinTasks: (() -> List<Any?>?)? = null
+open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceSet {
+    @Input
+    @Optional
+    override var classpath: List<String> = emptyList()
+    @Input
+    override var moduleName: String = ""
+    @Input
+    override var displayName: String = ""
+    @Input
+    override var sourceSetID: String = ""
+    @Input
+    override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
+    @Input
+    override var dependentSourceSets: MutableList<String> = mutableListOf()
+    @Input
+    override var samples: List<String> = emptyList()
+    @Input
+    override var includes: List<String> = emptyList()
+    @Input
+    override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+    @Input
+    override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
+    @Input
+    override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
+    @Input
+    override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
+    @Input
+    override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
+    @Input
+    override var jdkVersion: Int = DokkaDefaults.jdkVersion
+    @Input
+    override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
+    @Input
+    override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
+    @Input
+    override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
+    @Input
+    @Optional
+    override var languageVersion: String? = null
+    @Input
+    @Optional
+    override var apiVersion: String? = null
+    @Input
+    override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
+    @Input
+    override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
+    @Input
+    var noAndroidSdkLink: Boolean = false
+    @Input
+    override var suppressedFiles: List<String> = emptyList()
+    @Input
+    override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
+    @Input
+    @Optional
+    var platform: String? = null
+    @Transient
+    var collectKotlinTasks: (() -> List<Any?>?)? = null
 
     fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
         collectKotlinTasks = { taskSupplier.call() }
@@ -117,25 +147,25 @@ class GradleExternalDocumentationLinkImpl : ExternalDocumentationLink, Serializa
     override var packageListUrl: URL = URL("http://")
 }
 
-class GradleDokkaModuleDescription: DokkaModuleDescription {
+class GradleDokkaModuleDescription : DokkaModuleDescription {
     override var name: String = ""
     override var path: String = ""
     override var docFile: String = ""
 }
 
-class GradleDokkaConfigurationImpl: DokkaConfiguration {
+class GradleDokkaConfigurationImpl : DokkaConfiguration {
     override var outputDir: String = ""
     override var format: String = DokkaDefaults.format
     override var cacheRoot: String? = DokkaDefaults.cacheRoot
     override var offlineMode: Boolean = DokkaDefaults.offlineMode
     override var failOnWarning: Boolean = DokkaDefaults.failOnWarning
-    override var passesConfigurations: List<GradlePassConfigurationImpl> = emptyList()
+    override var sourceSets: List<GradleDokkaSourceSet> = emptyList()
     override var pluginsClasspath: List<File> = emptyList()
     override var pluginsConfiguration: Map<String, String> = mutableMapOf()
     override var modules: List<GradleDokkaModuleDescription> = emptyList()
 }
 
-class GradlePackageOptionsImpl: PackageOptions, Serializable {
+class GradlePackageOptionsImpl : PackageOptions, Serializable {
     override var prefix: String = ""
     override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
     override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
@@ -143,8 +173,8 @@ class GradlePackageOptionsImpl: PackageOptions, Serializable {
     override var suppress: Boolean = DokkaDefaults.suppress
 }
 
-internal fun GradlePassConfigurationImpl.copy(): GradlePassConfigurationImpl {
-    val newObj = GradlePassConfigurationImpl(this.name)
+internal fun GradleDokkaSourceSet.copy(): GradleDokkaSourceSet {
+    val newObj = GradleDokkaSourceSet(this.name)
     this::class.memberProperties.forEach { field ->
         if (field is KMutableProperty<*>) {
             val value = field.getter.call(this)
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
index 41d6e67a..2b076fd0 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
@@ -57,7 +57,7 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.dokkaSourceSets = project.container(GradlePassConfigurationImpl::class.java)
+            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java)
             task.dokkaRuntime = runtimeConfiguration
             task.pluginsClasspathConfiguration = pluginsConfiguration
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 1ef04772..b0baabee 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -29,7 +29,6 @@ import org.eclipse.aether.transport.file.FileTransporterFactory
 import org.eclipse.aether.transport.http.HttpTransporterFactory
 import org.eclipse.aether.util.graph.visitor.PreorderNodeListGenerator
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
 import java.io.File
 import java.net.URL
 
@@ -187,7 +186,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
                 throw MojoExecutionException("Incorrect path property, only Unix based path allowed.")
             }
         }
-        fun defaultLinks(config: PassConfigurationImpl): List<ExternalDocumentationLinkImpl> {
+        fun defaultLinks(config: DokkaSourceSetImpl): List<ExternalDocumentationLinkImpl> {
             val links = mutableListOf<ExternalDocumentationLinkImpl>()
             if (!config.noJdkLink)
                 links += DokkaConfiguration.ExternalDocumentationLink
@@ -201,7 +200,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             return links
         }
 
-        val passConfiguration = PassConfigurationImpl(
+        val sourceSet = DokkaSourceSetImpl(
             moduleName = moduleName,
             displayName = displayName,
             sourceSetID = sourceSetName,
@@ -246,8 +245,8 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             format = getOutFormat(),
             offlineMode = offlineMode,
             cacheRoot = cacheRoot,
-            passesConfigurations = listOf(passConfiguration).also {
-                if (passConfiguration.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
+            sourceSets = listOf(sourceSet).also {
+                if (sourceSet.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
             },
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
                     dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index e3da5f68..07aedf28 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -1,8 +1,7 @@
 package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -15,8 +14,7 @@ import kotlin.reflect.full.memberProperties
 class MockContext(
     vararg extensions: Pair<ExtensionPoint<*>, (DokkaContext) -> Any>,
     private val testConfiguration: DokkaConfiguration? = null,
-    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null,
-    override val sourceSetCache: SourceSetCache
+    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null
 ) : DokkaContext {
     private val extensionMap by lazy {
         extensions.groupBy(Pair<ExtensionPoint<*>, (DokkaContext) -> Any>::first) {
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index 7248a4cb..ec2be689 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -1,9 +1,8 @@
 package org.jetbrains.dokka.testApi.testRunner
 
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
 
@@ -16,13 +15,12 @@ internal class DokkaTestGenerator(
 
     fun generate() = with(testMethods) {
         val dokkaGenerator = DokkaGenerator(configuration, logger)
-        val sourceSetsCache = SourceSetCache()
 
         val context =
-            dokkaGenerator.initializePlugins(configuration, logger, sourceSetsCache, pluginOverrides)
+            dokkaGenerator.initializePlugins(configuration, logger, pluginOverrides)
         pluginsSetupStage(context)
 
-        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context, sourceSetsCache)
+        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context)
         documentablesCreationStage(modulesFromPlatforms)
 
         val filteredModules = dokkaGenerator.transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 88595f85..624ea914 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -3,13 +3,11 @@ package org.jetbrains.dokka.testApi.testRunner
 import com.intellij.openapi.application.PathManager
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
-import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.DokkaLogger
 import org.junit.rules.TemporaryFolder
 import testApi.logger.TestLogger
 import java.io.File
@@ -66,7 +64,7 @@ abstract class AbstractCoreTest {
         val newConfiguration =
             configuration.copy(
                 outputDir = testDirPath.toAbsolutePath().toString(),
-                passesConfigurations = configuration.passesConfigurations.map {
+                sourceSets = configuration.sourceSets.map {
                     it.copy(sourceRoots = it.sourceRoots.map { it.copy(path = "${testDirPath.toAbsolutePath()}/${it.path}") })
                 }
             )
@@ -143,13 +141,13 @@ abstract class AbstractCoreTest {
         var pluginsClasspath: List<File> = emptyList()
         var pluginsConfigurations: Map<String, String> = emptyMap()
         var failOnWarning: Boolean = false
-        private val passesConfigurations = mutableListOf<PassConfigurationImpl>()
+        private val sourceSets = mutableListOf<DokkaSourceSetImpl>()
         fun build() = DokkaConfigurationImpl(
             outputDir = outputDir,
             format = format,
             cacheRoot = cacheRoot,
             offlineMode = offlineMode,
-            passesConfigurations = passesConfigurations,
+            sourceSets = sourceSets,
             pluginsClasspath = pluginsClasspath,
             pluginsConfiguration = pluginsConfigurations,
             modules = emptyList(),
@@ -157,18 +155,18 @@ abstract class AbstractCoreTest {
         )
 
         fun passes(block: Passes.() -> Unit) {
-            passesConfigurations.addAll(Passes().apply(block))
+            sourceSets.addAll(Passes().apply(block))
         }
     }
 
     @DokkaConfigurationDsl
-    protected class Passes : ArrayList<PassConfigurationImpl>() {
-        fun pass(block: DokkaPassConfigurationBuilder.() -> Unit) =
-            add(DokkaPassConfigurationBuilder().apply(block).build())
+    protected class Passes : ArrayList<DokkaSourceSetImpl>() {
+        fun pass(block: DokkaSourceSetBuilder.() -> Unit) =
+            add(DokkaSourceSetBuilder().apply(block).build())
     }
 
     @DokkaConfigurationDsl
-    protected class DokkaPassConfigurationBuilder(
+    protected class DokkaSourceSetBuilder(
         var moduleName: String = "root",
         var sourceSetID: String = "main",
         var displayName: String = "JVM",
@@ -193,7 +191,7 @@ abstract class AbstractCoreTest {
         var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
         var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
     ) {
-        fun build() = PassConfigurationImpl(
+        fun build() = DokkaSourceSetImpl(
             moduleName = moduleName,
             displayName = displayName,
             sourceSetID = sourceSetID,
-- 
cgit 


From b0e8622f374f6499058b0f083367b4a54512b702 Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Tue, 30 Jun 2020 23:06:03 +0200
Subject: Enforce workspace unique SourceSetID

---
 build.gradle.kts                                   |   4 +-
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   5 +-
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 .../main/kotlin/DokkaMultimoduleBootstrapImpl.kt   |   5 +-
 core/src/main/kotlin/configuration.kt              |  27 ++-
 core/src/main/kotlin/defaultConfiguration.kt       |  22 ++-
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |   2 +-
 .../org/jetbrains/dokka/analysis/KotlinAnalysis.kt |   5 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  22 +--
 .../main/kotlin/signatures/JvmSignatureUtils.kt    |   3 +-
 .../DocumentableVisibilityFilterTransformer.kt     |  12 +-
 .../EmptyPackagesFilterTransformer.kt              |   6 +-
 .../ModuleAndPackageDocumentationTransformer.kt    |   4 +-
 .../pages/samples/SamplesTransformer.kt            |   4 +-
 .../DefaultDescriptorToDocumentableTranslator.kt   |   4 +-
 .../psi/DefaultPsiToDocumentableTranslator.kt      |   2 +-
 plugins/base/src/test/kotlin/basic/DRITest.kt      |  40 ++--
 .../base/src/test/kotlin/basic/DokkaBasicTests.kt  |   6 +-
 .../src/test/kotlin/basic/FailOnWarningTest.kt     |  18 +-
 .../annotations/ContentForAnnotationsTest.kt       |   6 +-
 .../annotations/DepredatedAndSinceKotlinTest.kt    |   8 +-
 .../kotlin/content/params/ContentForParamsTest.kt  |   4 +-
 .../content/seealso/ContentForSeeAlsoTest.kt       |   6 +-
 .../content/signatures/ContentForSignaturesTest.kt |   4 +-
 .../SkippingParenthesisForConstructorsTest.kt      |   6 +-
 plugins/base/src/test/kotlin/enums/EnumsTest.kt    |  20 +-
 .../src/test/kotlin/expect/AbstractExpectTest.kt   |   6 +-
 .../test/kotlin/filter/DeprecationFilterTest.kt    |  22 +--
 .../test/kotlin/filter/EmptyPackagesFilterTest.kt  |  11 +-
 .../src/test/kotlin/filter/VisibilityFilterTest.kt |  22 +--
 plugins/base/src/test/kotlin/issues/IssuesTest.kt  |   6 +-
 .../kotlin/linkableContent/LinkableContentTest.kt  |  38 ++--
 .../DefaultLocationProviderTest.kt                 |   6 +-
 plugins/base/src/test/kotlin/markdown/KDocTest.kt  |   6 +-
 plugins/base/src/test/kotlin/markdown/LinkTest.kt  |  10 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |   8 +-
 plugins/base/src/test/kotlin/model/PropertyTest.kt |   6 +-
 .../kotlin/multiplatform/BasicMultiplatformTest.kt |  10 +-
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   |  10 +-
 .../test/kotlin/renderers/html/DivergentTest.kt    |   8 +-
 .../renderers/html/SourceSetDependentHintTest.kt   |   8 +-
 .../test/kotlin/renderers/html/defaultSourceSet.kt |   9 +-
 .../test/kotlin/resourceLinks/ResourceLinksTest.kt |   6 +-
 .../PageTransformerBuilderTest.kt                  |  12 +-
 .../ReportUndocumentedTransformerTest.kt           | 136 ++++++-------
 .../DefaultPsiToDocumentableTranslatorTest.kt      |  14 +-
 plugins/base/src/test/kotlin/utils/ModelUtils.kt   |   4 +-
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |   6 +-
 .../javadoc/AbstractJavadocTemplateMapTest.kt      |   5 +-
 .../javadoc/src/test/kotlin/javadoc/JavadocTest.kt |   4 +-
 .../kotlin/javadoc/location/JavadocLocationTest.kt |   6 +-
 .../src/test/kotlin/KotlinAsJavaPluginTest.kt      |  13 +-
 runners/ant/build.gradle                           |  18 --
 runners/ant/src/main/kotlin/ant/dokka.kt           | 210 ---------------------
 runners/ant/src/main/resources/dokka-antlib.xml    |   3 -
 runners/cli/build.gradle.kts                       |   3 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  57 +++---
 runners/gradle-plugin/build.gradle.kts             |   2 +
 .../dokka/gradle/ConfigurationExtractor.kt         |   2 +-
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |   8 +-
 .../dokka/gradle/DokkaSourceSetIDFactory.kt        |  10 +
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  36 ++--
 .../dokka/gradle/configurationImplementations.kt   |  93 +++++++--
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   4 +-
 .../gradle/KotlinDslDokkaTaskConfigurationTest.kt  |  77 ++++++++
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |  14 +-
 .../src/main/kotlin/testApi/context/MockContext.kt |   3 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |   3 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  19 +-
 69 files changed, 567 insertions(+), 634 deletions(-)
 delete mode 100644 runners/ant/build.gradle
 delete mode 100644 runners/ant/src/main/kotlin/ant/dokka.kt
 delete mode 100644 runners/ant/src/main/resources/dokka-antlib.xml
 create mode 100644 runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/build.gradle.kts b/build.gradle.kts
index c94faa77..04f4afd4 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -19,7 +19,7 @@ allprojects {
     val language_version: String by project
     tasks.withType(KotlinCompile::class).all {
         kotlinOptions {
-            freeCompilerArgs += "-Xjsr305=strict -Xskip-metadata-version-check"
+            freeCompilerArgs += "-Xjsr305=strict -Xskip-metadata-version-check -Xopt-in=kotlin.RequiresOptIn."
             languageVersion = language_version
             apiVersion = language_version
             jvmTarget = "1.8"
@@ -49,4 +49,4 @@ subprojects {
     }
 }
 
-println("Publication version: $dokka_version")
\ No newline at end of file
+println("Publication version: $dokka_version")
diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index bd632546..be3d6c9b 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -1,8 +1,6 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 import java.util.function.BiConsumer
@@ -80,7 +78,6 @@ class DokkaBootstrapImpl : DokkaBootstrap {
     }
 
     private lateinit var generator: DokkaGenerator
-    val gson = Gson()
 
     fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) = with(configuration) {
 
@@ -113,7 +110,7 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
     override fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String) = configure(
         DokkaProxyLogger(logger),
-        gson.fromJson(serializedConfigurationJSON, DokkaConfigurationImpl::class.java)
+        DokkaConfigurationImpl(serializedConfigurationJSON)
     )
 
     override fun generate() = generator.generate()
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index ce8d229a..ee1adf0b 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -68,7 +68,7 @@ class DokkaGenerator(
     fun createDocumentationModels(
         context: DokkaContext
     ) = context.configuration.sourceSets
-        .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
+        .flatMap { sourceSet -> translateSources(sourceSet, context) }
 
     fun transformDocumentationModelBeforeMerge(
         modulesFromPlatforms: List<DModule>,
diff --git a/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt b/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
index 6825ce64..70b99f8d 100644
--- a/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaBootstrapImpl.DokkaProxyLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.util.function.BiConsumer
@@ -15,11 +14,11 @@ class DokkaMultimoduleBootstrapImpl : DokkaBootstrap {
 
     override fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String) = configure(
         DokkaProxyLogger(logger),
-        Gson().fromJson(serializedConfigurationJSON, DokkaConfigurationImpl::class.java)
+        DokkaConfigurationImpl(serializedConfigurationJSON)
     )
 
     override fun generate() {
         generator.generateAllModulesPage()
     }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index 463d2342..c531ab9a 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -1,6 +1,10 @@
+@file:Suppress("FunctionName")
+
 package org.jetbrains.dokka
 
+import com.google.gson.Gson
 import java.io.File
+import java.io.Serializable
 import java.net.URL
 
 object DokkaDefaults {
@@ -43,6 +47,23 @@ enum class Platform(val key: String) {
     }
 }
 
+data class DokkaSourceSetID(
+    val moduleName: String,
+    val sourceSetName: String
+) : Serializable {
+    override fun toString(): String {
+        return "$moduleName/$sourceSetName"
+    }
+}
+
+fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl {
+    return Gson().fromJson(json, DokkaConfigurationImpl::class.java)
+}
+
+fun DokkaConfiguration.toJson(): String {
+    return Gson().toJson(this)
+}
+
 interface DokkaConfiguration {
     val outputDir: String
     val format: String
@@ -55,12 +76,12 @@ interface DokkaConfiguration {
     val pluginsConfiguration: Map<String, String>
 
     interface DokkaSourceSet {
-        val moduleName: String
+        val sourceSetID: DokkaSourceSetID
         val displayName: String
-        val sourceSetID: String
+        val moduleDisplayName: String
         val classpath: List<String>
         val sourceRoots: List<SourceRoot>
-        val dependentSourceSets: List<String>
+        val dependentSourceSets: Set<DokkaSourceSetID>
         val samples: List<String>
         val includes: List<String>
         val includeNonPublic: Boolean
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index d3ac9df2..47bd7fe2 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import java.io.File
 import java.net.URL
 
@@ -16,12 +17,12 @@ data class DokkaConfigurationImpl(
 ) : DokkaConfiguration
 
 data class DokkaSourceSetImpl(
-    override val moduleName: String,
+    override val moduleDisplayName: String,
     override val displayName: String,
-    override val sourceSetID: String,
+    override val sourceSetID: DokkaSourceSetID,
     override val classpath: List<String>,
     override val sourceRoots: List<SourceRootImpl>,
-    override val dependentSourceSets: List<String>,
+    override val dependentSourceSets: Set<DokkaSourceSetID>,
     override val samples: List<String>,
     override val includes: List<String>,
     override val includeNonPublic: Boolean,
@@ -39,23 +40,23 @@ data class DokkaSourceSetImpl(
     override val noJdkLink: Boolean,
     override val suppressedFiles: List<String>,
     override val analysisPlatform: Platform
-) : DokkaConfiguration.DokkaSourceSet
+) : DokkaSourceSet
 
 data class DokkaModuleDescriptionImpl(
     override val name: String,
     override val path: String,
     override val docFile: String
-): DokkaConfiguration.DokkaModuleDescription
+) : DokkaConfiguration.DokkaModuleDescription
 
 data class SourceRootImpl(
     override val path: String
-): DokkaConfiguration.SourceRoot
+) : DokkaConfiguration.SourceRoot
 
 data class SourceLinkDefinitionImpl(
     override val path: String,
     override val url: String,
     override val lineSuffix: String?
-): DokkaConfiguration.SourceLinkDefinition {
+) : DokkaConfiguration.SourceLinkDefinition {
     companion object {
         fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl {
             val (path, urlAndLine) = srcLink.split('=')
@@ -73,9 +74,10 @@ data class PackageOptionsImpl(
     override val reportUndocumented: Boolean?,
     override val skipDeprecated: Boolean,
     override val suppress: Boolean
-): DokkaConfiguration.PackageOptions
+) : DokkaConfiguration.PackageOptions
 
 
-data class ExternalDocumentationLinkImpl(override val url: URL,
-                                         override val packageListUrl: URL
+data class ExternalDocumentationLinkImpl(
+    override val url: URL,
+    override val packageListUrl: URL
 ) : DokkaConfiguration.ExternalDocumentationLink
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index fe472b12..7ead43b8 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -82,4 +82,4 @@ inline fun <reified T : DokkaPlugin, reified R : ConfigurableBlock> configuratio
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
index 426ffdde..e723768c 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
@@ -3,6 +3,7 @@
 package org.jetbrains.dokka.analysis
 
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 
@@ -21,7 +22,7 @@ fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis {
 
 interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade> {
     override fun get(key: DokkaSourceSet): EnvironmentAndFacade
-    operator fun get(sourceSetID: String): EnvironmentAndFacade
+    operator fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade
 }
 
 internal class KotlinAnalysisImpl(
@@ -32,7 +33,7 @@ internal class KotlinAnalysisImpl(
         return environments[key] ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
     }
 
-    override fun get(sourceSetID: String): EnvironmentAndFacade {
+    override fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade {
         return environments.entries.first { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }.value
     }
 }
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index de892bb1..f8fa3b2e 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -94,7 +94,7 @@ open class HtmlRenderer(
             group.sourceSets.forEach {
                 button(classes = "platform-tag platform-selector") {
                     attributes["data-active"] = ""
-                    attributes["data-filter"] = it.sourceSetID
+                    attributes["data-filter"] = it.sourceSetID.toString()
                     when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
@@ -168,10 +168,10 @@ open class HtmlRenderer(
                     attributes["data-toggle-list"] = "data-toggle-list"
                     contents.forEachIndexed { index, pair ->
                         button(classes = "platform-bookmark") {
-                            attributes["data-filterable-current"] = pair.first.sourceSetID
-                            attributes["data-filterable-set"] = pair.first.sourceSetID
+                            attributes["data-filterable-current"] = pair.first.sourceSetID.toString()
+                            attributes["data-filterable-set"] = pair.first.sourceSetID.toString()
                             if (index == 0) attributes["data-active"] = ""
-                            attributes["data-toggle"] = pair.first.sourceSetID
+                            attributes["data-toggle"] = pair.first.sourceSetID.toString()
                             when (
                                 pair.first.analysisPlatform.key
                                 ) {
@@ -180,7 +180,7 @@ open class HtmlRenderer(
                                 "jvm" -> classes = classes + "jvm-like"
                                 "js" -> classes = classes + "js-like"
                             }
-                            attributes["data-toggle"] = pair.first.sourceSetID
+                            attributes["data-toggle"] = pair.first.sourceSetID.toString()
                             text(pair.first.displayName)
                         }
                     }
@@ -212,7 +212,7 @@ open class HtmlRenderer(
             }.map {
                 it to createHTML(prettyPrint = false).div(classes = "content sourceset-depenent-content") {
                     if (counter++ == 0) attributes["data-active"] = ""
-                    attributes["data-togglable"] = it.sourceSetID
+                    attributes["data-togglable"] = it.sourceSetID.toString()
                     unsafe {
                         +html
                     }
@@ -249,10 +249,10 @@ open class HtmlRenderer(
             consumer.onTagContentUnsafe {
                 +createHTML().div("divergent-group") {
                     attributes["data-filterable-current"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetID
+                        it.sourceSetID.toString()
                     }
                     attributes["data-filterable-set"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetID
+                        it.sourceSetID.toString()
                     }
 
                     val divergentForPlatformDependent = groupedDivergent.map { (sourceSet, elements) ->
@@ -353,10 +353,10 @@ open class HtmlRenderer(
                     div(classes = "table-row") {
                         if (!style.contains(MultimoduleTable)) {
                             attributes["data-filterable-current"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetID
+                                it.sourceSetID.toString()
                             }
                             attributes["data-filterable-set"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetID
+                                it.sourceSetID.toString()
                             }
                         }
 
@@ -728,4 +728,4 @@ private fun String.stripDiv() = drop(5).dropLast(6) // TODO: Find a way to do it
 private val PageNode.isNavigable: Boolean
     get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
 
-fun PropertyContainer<ContentNode>.extraHtmlAttributes() = allOfType<SimpleAttr>()
\ No newline at end of file
+fun PropertyContainer<ContentNode>.extraHtmlAttributes() = allOfType<SimpleAttr>()
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index f042eae3..2a242948 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka.base.signatures
 
-import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
@@ -142,4 +141,4 @@ interface JvmSignatureUtils {
 sealed class AtStrategy
 object All : AtStrategy()
 object OnlyOnce : AtStrategy()
-object Never : AtStrategy()
\ No newline at end of file
+object Never : AtStrategy()
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index c3cc4d38..ff05beed 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -9,11 +9,9 @@ import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = original.sourceSets.single()
-        val packageOptions = passOptions.perPackageOptions
-        original.let {
-            DocumentableVisibilityFilter(packageOptions, passOptions).processModule(it)
-        }
+        val sourceSet = original.sourceSets.single()
+        val packageOptions = sourceSet.perPackageOptions
+        DocumentableVisibilityFilter(packageOptions, sourceSet).processModule(original)
     }
 
     private class DocumentableVisibilityFilter(
@@ -45,7 +43,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterPackages(packages: List<DPackage>): Pair<Boolean, List<DPackage>> {
             var packagesListChanged = false
-            val filteredPackages = packages.mapNotNull {
+            val filteredPackages = packages.map {
                 var modified = false
                 val functions = filterFunctions(it.functions).let { (listModified, list) ->
                     modified = modified || listModified
@@ -326,4 +324,4 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             return Pair(classlikesListChanged, filteredClasslikes)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
index 3fd0081a..61abfbd7 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
@@ -14,9 +14,9 @@ class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocume
     }
 
     private class EmptyPackagesFilter(
-        val passOptions: DokkaConfiguration.DokkaSourceSet
+        val sourceSet: DokkaConfiguration.DokkaSourceSet
     ) {
-        fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages &&
+        fun DPackage.shouldBeSkipped() = sourceSet.skipEmptyPackages &&
                 functions.isEmpty() &&
                 properties.isEmpty() &&
                 classlikes.isEmpty()
@@ -25,4 +25,4 @@ class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocume
             packages = module.packages.filter { !it.shouldBeSkipped() }
         )
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 1f718a7c..a0800da8 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -1,12 +1,10 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
-import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.parsers.MarkdownParser
-import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 import org.jetbrains.kotlin.name.FqName
@@ -24,7 +22,7 @@ internal class ModuleAndPackageDocumentationTransformer(
         val modulesAndPackagesDocumentation =
             context.configuration.sourceSets
                 .map {
-                    Pair(it.moduleName, it) to
+                    Pair(it.moduleDisplayName, it) to
                             it.includes.map { Paths.get(it) }
                                 .also {
                                     it.forEach {
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index b39715a7..41dea1a2 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -67,7 +67,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         analysis: Map<DokkaSourceSet, EnvironmentAndFacade>
     ): ContentNode {
         val facade = analysis[platform]?.facade
-            ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}") }
+            ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleDisplayName}") }
         val psiElement = fqNameToPsiElement(facade, fqName)
             ?: return this.also { context.logger.warn("Cannot find PsiElement corresponding to $fqName") }
         val imports =
@@ -147,4 +147,4 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
             style = styles + ContentStyle.RunnableSample + TextStyle.Monospace,
             extra = extra
         )
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 9cdd251c..b0374014 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
 import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.idea.kdoc.isBoringBuiltinClass
 import org.jetbrains.kotlin.load.kotlin.toSourceElement
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -36,7 +35,6 @@ import org.jetbrains.kotlin.resolve.constants.KClassValue.Value.NormalClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
-import org.jetbrains.kotlin.resolve.jvm.isInlineClassThatRequiresMangling
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
@@ -71,7 +69,7 @@ class DefaultDescriptorToDocumentableTranslator(
                     DRIWithPlatformInfo(DRI.topLevel, emptyMap())
                 )
             }
-        }.let { DModule(sourceSet.moduleName, it, emptyMap(), null, setOf(sourceSet)) }
+        }.let { DModule(sourceSet.moduleDisplayName, it, emptyMap(), null, setOf(sourceSet)) }
     }
 }
 
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index 76f8319d..5a55e3ec 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -68,7 +68,7 @@ class DefaultPsiToDocumentableTranslator(
                 context.logger
             )
         return DModule(
-            sourceSet.moduleName,
+            sourceSet.moduleDisplayName,
             psiFiles.mapNotNull { it.safeAs<PsiJavaFile>() }.groupBy { it.packageName }.map { (packageName, psiFiles) ->
                 val dri = DRI(packageName = packageName)
                 DPackage(
diff --git a/plugins/base/src/test/kotlin/basic/DRITest.kt b/plugins/base/src/test/kotlin/basic/DRITest.kt
index 1f4c7d93..559a2dbf 100644
--- a/plugins/base/src/test/kotlin/basic/DRITest.kt
+++ b/plugins/base/src/test/kotlin/basic/DRITest.kt
@@ -5,19 +5,19 @@ import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.links.Nullable
 import org.jetbrains.dokka.links.TypeConstructor
 import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.pages.dfs
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.jetbrains.dokka.pages.ClasslikePageNode
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.MemberPageNode
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
-
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 class DRITest : AbstractCoreTest() {
     @Test
     fun issue634() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -52,8 +52,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue634WithImmediateNullableSelf() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -82,8 +82,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue634WithGenericNullableReceiver() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -112,8 +112,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue642WithStarAndAny() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     analysisPlatform = "js"
                     sourceRoots = listOf("src/")
                 }
@@ -171,8 +171,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericClass(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -201,8 +201,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericFunction(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     classpath = listOfNotNull(jvmStdlibPath)
                 }
@@ -243,8 +243,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForFunctionNestedInsideInnerClass() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     classpath = listOfNotNull(jvmStdlibPath)
                 }
@@ -280,8 +280,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericExtensionFunction(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
index 5cc17bf3..bceb79ae 100644
--- a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
+++ b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
@@ -11,8 +11,8 @@ class DokkaBasicTests : AbstractCoreTest() {
     @Test
     fun basic1() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
             }
@@ -39,4 +39,4 @@ class DokkaBasicTests : AbstractCoreTest() {
 
     private fun ModulePageNode.getClasslikeToMemberMap() =
         this.parentMap.filterValues { it is ClasslikePageNode }.entries.groupBy({ it.value }) { it.key }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
index d548b75b..9d2c5825 100644
--- a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
+++ b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
@@ -14,8 +14,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `throws exception if one or more warnings were emitted`() {
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -39,8 +39,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `throws exception if one or more error were emitted`() {
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -66,8 +66,8 @@ class FailOnWarningTest : AbstractCoreTest() {
 
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -88,8 +88,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `does not throw if disabled`() {
         val configuration = dokkaConfiguration {
             failOnWarning = false
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -115,4 +115,4 @@ private class ZeroErrorOrWarningCountDokkaLogger(
 ) : DokkaLogger by logger {
     override var warningsCount: Int = 0
     override var errorsCount: Int = 0
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
index 7add4119..bf78b847 100644
--- a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
@@ -14,8 +14,8 @@ class ContentForAnnotationsTest : AbstractCoreTest() {
 
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -218,4 +218,4 @@ class ContentForAnnotationsTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt b/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
index 99ec25c5..69de1bcd 100644
--- a/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
@@ -3,19 +3,17 @@ package content.annotations
 
 import matchers.content.*
 import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PackagePageNode
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Test
 import utils.ParamAttributes
 import utils.bareSignature
-import utils.propertySignature
 
 
 class DepredatedAndSinceKotlinTest : AbstractCoreTest() {
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -102,4 +100,4 @@ class DepredatedAndSinceKotlinTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index f6e80891..a9689bc5 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -17,8 +17,8 @@ import utils.*
 
 class ContentForParamsTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
diff --git a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
index 696c3032..24970660 100644
--- a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
+++ b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
@@ -11,8 +11,8 @@ import utils.unnamedTag
 
 class ContentForSeeAlsoTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -456,4 +456,4 @@ class ContentForSeeAlsoTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
index 6cb8b0f4..cabe822d 100644
--- a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
@@ -14,8 +14,8 @@ import utils.typealiasSignature
 class ContentForSignaturesTest : AbstractCoreTest() {
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
                 includeNonPublic = true
diff --git a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
index d203025b..c2fbd26f 100644
--- a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
@@ -8,8 +8,8 @@ import utils.functionSignature
 
 class ConstructorsSignaturesTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -190,4 +190,4 @@ class ConstructorsSignaturesTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/enums/EnumsTest.kt b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
index be910b5c..6a973f8e 100644
--- a/plugins/base/src/test/kotlin/enums/EnumsTest.kt
+++ b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
@@ -14,8 +14,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun basicEnum() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -45,8 +45,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithCompanion() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -90,8 +90,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithConstructor() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -136,8 +136,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithMethods() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -179,8 +179,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithAnnotationsOnEntries(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
index 3b69a54e..4dfdc410 100644
--- a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
+++ b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
@@ -15,8 +15,8 @@ abstract class AbstractExpectTest(
     protected fun generateOutput(path: Path, outFormat: String): Path? {
         val config = dokkaConfiguration {
             format = outFormat
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf(path.toAbsolutePath().asString())
                 }
             }
@@ -101,4 +101,4 @@ abstract class AbstractExpectTest(
         ret?.let { Files.list(it).forEach { f -> f.copyRecursively(out.resolve(f.fileName)) } }
     }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt b/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
index c15e53e8..c8b9f2d4 100644
--- a/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
@@ -9,8 +9,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `function with false global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipDeprecated = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -39,8 +39,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with false global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipDeprecated = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -69,8 +69,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with true global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = true
                 }
@@ -99,8 +99,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with false global true package skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = false
                     perPackageOptions = mutableListOf(
@@ -136,8 +136,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with true global false package skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = true
                     perPackageOptions = mutableListOf(
@@ -170,4 +170,4 @@ class DeprecationFilterTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt b/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
index 7d96541b..e5b9e9c2 100644
--- a/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
@@ -1,6 +1,5 @@
 package filter
 
-import org.jetbrains.dokka.PackageOptionsImpl
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
@@ -9,8 +8,8 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
     @Test
     fun `empty package with false skipEmptyPackages`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipEmptyPackages = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -37,8 +36,8 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
     @Test
     fun `empty package with true skipEmptyPackages`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipEmptyPackages = true
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -61,4 +60,4 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
index 5e8e33dc..192de449 100644
--- a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
@@ -9,8 +9,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `public function with false global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     includeNonPublic = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -39,8 +39,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with false global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     includeNonPublic = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -69,8 +69,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with true global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = true
                 }
@@ -99,8 +99,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with false global true package includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = false
                     perPackageOptions = mutableListOf(
@@ -136,8 +136,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with true global false package includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = true
                     perPackageOptions = mutableListOf(
@@ -170,4 +170,4 @@ class VisibilityFilterTest : AbstractCoreTest() {
              }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/issues/IssuesTest.kt b/plugins/base/src/test/kotlin/issues/IssuesTest.kt
index f67229b7..7b065349 100644
--- a/plugins/base/src/test/kotlin/issues/IssuesTest.kt
+++ b/plugins/base/src/test/kotlin/issues/IssuesTest.kt
@@ -34,8 +34,8 @@ class IssuesTest : AbstractModelTest("/src/main/kotlin/issues/Test.kt", "issues"
             |}
         """,
             configuration = dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         classpath = listOfNotNull(jvmStdlibPath)
                     }
@@ -70,4 +70,4 @@ class IssuesTest : AbstractModelTest("/src/main/kotlin/issues/Test.kt", "issues"
     //        }
     //    }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index 191df066..2775fcf4 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -23,23 +23,23 @@ class LinkableContentTest : AbstractCoreTest() {
         val includesDir = getTestDataDir("linkable/includes").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
-                    sourceSetID = "js"
+                    name = "js"
                     includes = listOf(Paths.get("$includesDir/include2.md").toString())
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
-                    sourceSetID = "jvm"
+                    name = "jvm"
                     includes = listOf(Paths.get("$includesDir/include1.md").toString())
                 }
             }
@@ -62,8 +62,8 @@ class LinkableContentTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("linkable/sources").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
@@ -74,9 +74,9 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
-                    sourceSetID = "js"
+                    name = "js"
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
@@ -87,7 +87,7 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
-                    sourceSetID = "jvm"
+                    name = "jvm"
                 }
             }
         }
@@ -127,19 +127,19 @@ class LinkableContentTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("linkable/samples").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
-                    sourceSetID = "js"
+                    name = "js"
                     samples = listOf("$testDataDir/jsMain/resources/Samples.kt")
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
-                    sourceSetID = "jvm"
+                    name = "jvm"
                     samples = listOf("$testDataDir/jvmMain/resources/Samples.kt")
                 }
             }
@@ -196,11 +196,11 @@ class LinkableContentTest : AbstractCoreTest() {
             |
         """.trimIndent(),
             dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         analysisPlatform = "jvm"
-                        sourceSetID = "js"
+                        name = "js"
                     }
                 }
             }
@@ -222,4 +222,4 @@ class LinkableContentTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt b/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
index 1bc3ea29..a219fb04 100644
--- a/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
+++ b/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
@@ -10,8 +10,8 @@ class DefaultLocationProviderTest: AbstractCoreTest() {
     @Test
     fun `#644 same directory for module and package`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -38,4 +38,4 @@ class DefaultLocationProviderTest: AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/markdown/KDocTest.kt b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
index 218f7244..f5b29322 100644
--- a/plugins/base/src/test/kotlin/markdown/KDocTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
@@ -9,8 +9,8 @@ import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 abstract class KDocTest : AbstractCoreTest() {
 
     private val configuration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/main/kotlin/example/Test.kt")
             }
         }
@@ -44,4 +44,4 @@ abstract class KDocTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/markdown/LinkTest.kt b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
index ddcef5db..8e4e588e 100644
--- a/plugins/base/src/test/kotlin/markdown/LinkTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
@@ -13,8 +13,8 @@ class LinkTest : AbstractCoreTest() {
     @Test
     fun linkToClassLoader() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/parser")
                 }
             }
@@ -46,8 +46,8 @@ class LinkTest : AbstractCoreTest() {
     @Test
     fun returnTypeShouldHaveLinkToOuterClassFromInner() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -75,4 +75,4 @@ class LinkTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index f5517abb..503cf50c 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -44,12 +44,12 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
     @Test
     fun multiplatform() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("common/src/", "jvm/src/")
                     analysisPlatform = "jvm"
                 }
-                pass {
+                sourceSet {
                     sourceRoots = listOf("common/src/", "js/src/")
                     analysisPlatform = "js"
                 }
@@ -92,4 +92,4 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/model/PropertyTest.kt b/plugins/base/src/test/kotlin/model/PropertyTest.kt
index e384b920..af952b43 100644
--- a/plugins/base/src/test/kotlin/model/PropertyTest.kt
+++ b/plugins/base/src/test/kotlin/model/PropertyTest.kt
@@ -169,8 +169,8 @@ class PropertyTest : AbstractModelTest("/src/main/kotlin/property/Test.kt", "pro
                 |@Strictfp var property = "test"
                 """,
             configuration = dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         classpath = listOfNotNull(jvmStdlibPath)
                     }
@@ -262,4 +262,4 @@ class PropertyTest : AbstractModelTest("/src/main/kotlin/property/Test.kt", "pro
 //    }
 //
 //}
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
index 5facd194..b3ac7b07 100644
--- a/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
+++ b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
@@ -11,8 +11,8 @@ class BasicMultiplatformTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("multiplatform/basicMultiplatformTest").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("$testDataDir/jvmMain/")
                 }
             }
@@ -28,8 +28,8 @@ class BasicMultiplatformTest : AbstractCoreTest() {
     @Test
     fun inlineTestExample() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/multiplatform/Test.kt")
                 }
             }
@@ -51,4 +51,4 @@ class BasicMultiplatformTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
index 6ef38aa9..935b9377 100644
--- a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
+++ b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -39,8 +39,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
     fun sameNameStrategyTest() {
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
                 }
             }
@@ -82,8 +82,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
         val strList: MutableList<String> = mutableListOf()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
                 }
             }
@@ -123,4 +123,4 @@ class PageNodeMergerTest : AbstractCoreTest() {
 
     fun PageNode.childrenRec(): List<PageNode> = listOf(this) + children.flatMap { it.childrenRec() }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index 6ceb805b..d4778a8e 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -12,14 +12,14 @@ class DivergentTest : RenderingOnlyTestBase() {
     private val js = defaultSourceSet.copy(
         "root",
         "JS",
-        "js",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "js"),
         analysisPlatform = Platform.js,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val jvm = defaultSourceSet.copy(
         "root",
         "JVM",
-        "jvm",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "jvm"),
 
         analysisPlatform = Platform.jvm,
         sourceRoots = listOf(SourceRootImpl("pl1"))
@@ -27,7 +27,7 @@ class DivergentTest : RenderingOnlyTestBase() {
     private val native = defaultSourceSet.copy(
         "root",
         "NATIVE",
-        "native",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "native"),
         analysisPlatform = Platform.native,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
@@ -344,4 +344,4 @@ class DivergentTest : RenderingOnlyTestBase() {
             Div(Div("b-", Span()), Div(Div(Div(("b")))), "ab+")
         )
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index c868cfd5..ea1ea9ae 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -15,21 +15,21 @@ class SourceSetDependentHintTest : RenderingOnlyTestBase() {
     private val pl1 = defaultSourceSet.copy(
         "root",
         "pl1",
-        "pl1",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl1"),
         analysisPlatform = Platform.js,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val pl2 = defaultSourceSet.copy(
         "root",
         "pl2",
-        "pl2",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl2"),
         analysisPlatform = Platform.jvm,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val pl3 = defaultSourceSet.copy(
         "root",
         "pl3",
-        "pl3",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl3"),
         analysisPlatform = Platform.native,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
@@ -135,4 +135,4 @@ class SourceSetDependentHintTest : RenderingOnlyTestBase() {
         HtmlRenderer(context).render(page)
         renderedContent.match(Div(Div(Div("a")), Div(Div("b"))))
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
index 771cabaa..a9be1cfd 100644
--- a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
@@ -1,15 +1,16 @@
 package renderers.html
 
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.DokkaSourceSetImpl
 import org.jetbrains.dokka.Platform
 
 internal val defaultSourceSet = DokkaSourceSetImpl(
-    moduleName = "DEFAULT",
+    moduleDisplayName = "DEFAULT",
     displayName = "DEFAULT",
-    sourceSetID = "DEFAULT",
+    sourceSetID = DokkaSourceSetID("DEFAULT", "DEFAULT"),
     classpath = emptyList(),
     sourceRoots = emptyList(),
-    dependentSourceSets = emptyList(),
+    dependentSourceSets = emptySet(),
     samples = emptyList(),
     includes = emptyList(),
     includeNonPublic = false,
@@ -27,4 +28,4 @@ internal val defaultSourceSet = DokkaSourceSetImpl(
     noJdkLink = false,
     suppressedFiles = emptyList(),
     analysisPlatform = Platform.DEFAULT
-)
\ No newline at end of file
+)
diff --git a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
index be87813b..4f8a834b 100644
--- a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
+++ b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
@@ -26,8 +26,8 @@ class ResourceLinksTest : AbstractCoreTest() {
     @Test
     fun resourceLinksTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/test/Test.kt")
                 }
             }
@@ -68,4 +68,4 @@ class ResourceLinksTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt b/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
index e66490c1..d8e057da 100644
--- a/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
+++ b/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
@@ -21,8 +21,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun scannerTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
@@ -58,8 +58,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun mapperTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
@@ -98,8 +98,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun structureTransformerTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
index 523813fc..72948372 100644
--- a/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
+++ b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
@@ -12,8 +12,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -39,8 +39,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented non-public class does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -65,8 +65,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented function gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -95,8 +95,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented property gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -125,8 +125,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented primary constructor does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -153,8 +153,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `data class component functions do not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin")
                 }
@@ -183,8 +183,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented secondary constructor gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -213,8 +213,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented inherited function does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -246,8 +246,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented inherited property does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -279,8 +279,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `overridden function does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -315,8 +315,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `overridden property does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -349,10 +349,10 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     }
 
     @Test
-    fun `report disabled by pass configuration`() {
+    fun `report disabled by source set`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = false
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -377,8 +377,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report enabled by package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = true,
@@ -407,8 +407,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report enabled by more specific package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = false,
@@ -445,8 +445,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report disabled by more specific package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = true,
@@ -483,22 +483,22 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -526,22 +526,22 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented class does not get reported if expect is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -568,31 +568,31 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented function gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.native.toString()
-                    sourceSetID = "macosMain"
+                    name = "macosMain"
                     displayName = "macosMain"
                     sourceRoots = listOf("src/macosMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -625,8 +625,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -652,8 +652,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented non-public class does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -677,8 +677,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented constructor does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -706,8 +706,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented method gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -736,8 +736,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented property gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -766,8 +766,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented inherited method gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -805,8 +805,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java documented inherited method does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -842,8 +842,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java overridden function does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
diff --git a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
index 5f8a7864..95fbb3c6 100644
--- a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
+++ b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
@@ -12,8 +12,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding two documented classes picks closest class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -57,8 +57,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding class and interface picks class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -102,8 +102,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding two classes picks closest documented class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -153,4 +153,4 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
             ?.body.orEmpty()
     }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/utils/ModelUtils.kt b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
index 9697a843..87a9c802 100644
--- a/plugins/base/src/test/kotlin/utils/ModelUtils.kt
+++ b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
@@ -16,8 +16,8 @@ abstract class AbstractModelTest(val path: String? = null, val pkg: String) : Mo
         block: DModule.() -> Unit
     ) {
         val testConfiguration = configuration ?: dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     analysisPlatform = platform
                 }
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index b955d403..287ef74f 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -140,7 +140,7 @@ open class CommonmarkRenderer(
                     platforms.joinToString(
                         prefix = " [",
                         postfix = "] $text "
-                    ) { "${it.moduleName}/${it.sourceSetID}" })
+                    ) { "${it.moduleDisplayName}/${it.sourceSetID}" })
                 buildNewLine()
             }
         }
@@ -157,7 +157,7 @@ open class CommonmarkRenderer(
     ) {
         if(node.dci.kind == ContentKind.Sample || node.dci.kind == ContentKind.Parameters){
             node.sourceSets.forEach {sourcesetData ->
-                append("${sourcesetData.moduleName}/${sourcesetData.sourceSetID}")
+                append("${sourcesetData.moduleDisplayName}/${sourcesetData.sourceSetID}")
                 buildNewLine()
                 buildTable(node.copy(children = node.children.filter { it.sourceSets.contains(sourcesetData) }, dci = node.dci.copy(kind = ContentKind.Main)), pageContext, sourceSetRestriction)
                 buildNewLine()
@@ -286,4 +286,4 @@ class MarkdownLocationProvider(
     dokkaContext
 ) {
     override val extension = ".md"
-}
\ No newline at end of file
+}
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
index 138208ae..4fa65c58 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
@@ -15,8 +15,8 @@ import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() {
     protected var config: DokkaConfigurationImpl = dokkaConfiguration {
         format = "javadoc"
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src")
                 analysisPlatform = "jvm"
             }
@@ -62,7 +62,6 @@ internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() {
     ) {
         testInline(query, configuration) {
             renderingStage = { rootPageNode, dokkaContext ->
-                // TODO NOW: Clarify preprocessors!
                 val transformedRootPageNode = preprocessors.fold(rootPageNode) { acc, pageTransformer ->
                     pageTransformer(acc)
                 }
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
index 905cb61b..31a33ad5 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
@@ -10,8 +10,8 @@ class JavadocTest : AbstractCoreTest() {
     fun test() {
         val config = dokkaConfiguration {
             format = "javadoc"
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("jvmSrc/")
                     analysisPlatform = "jvm"
                 }
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
index cbaa3dd6..a47f0142 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
@@ -23,8 +23,8 @@ class JavadocTest : AbstractCoreTest() {
 
         val config = dokkaConfiguration {
             format = "javadoc"
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("jvmSrc/")
                     externalDocumentationLinks = listOf(
                         externalLink("https://docs.oracle.com/javase/8/docs/api/"),
@@ -60,4 +60,4 @@ class JavadocTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt b/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
index db87051b..96446201 100644
--- a/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
+++ b/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
@@ -3,7 +3,6 @@ package kotlinAsJavaPlugin
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.junit.jupiter.api.Test
 
 class KotlinAsJavaPluginTest : AbstractCoreTest() {
@@ -11,8 +10,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun topLevelTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -49,8 +48,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun topLevelWithClassTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -90,8 +89,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun kotlinAndJavaTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/runners/ant/build.gradle b/runners/ant/build.gradle
deleted file mode 100644
index 216420c6..00000000
--- a/runners/ant/build.gradle
+++ /dev/null
@@ -1,18 +0,0 @@
-apply plugin: 'kotlin'
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        freeCompilerArgs += "-Xjsr305=strict"
-        languageVersion = language_version
-        apiVersion = language_version
-        jvmTarget = "1.8"
-    }
-}
-
-dependencies {
-    compile project(":core")
-    compileOnly group: 'org.apache.ant', name: 'ant', version: ant_version
-}
-
diff --git a/runners/ant/src/main/kotlin/ant/dokka.kt b/runners/ant/src/main/kotlin/ant/dokka.kt
deleted file mode 100644
index d275ed82..00000000
--- a/runners/ant/src/main/kotlin/ant/dokka.kt
+++ /dev/null
@@ -1,210 +0,0 @@
-package org.jetbrains.dokka.ant
-
-import org.apache.tools.ant.BuildException
-import org.apache.tools.ant.Project
-import org.apache.tools.ant.Task
-import org.apache.tools.ant.types.Path
-import org.apache.tools.ant.types.Reference
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.DokkaLogger
-import java.io.File
-
-class AntLogger(val task: Task): DokkaLogger {
-    override var warningsCount: Int = 0
-    override var errorsCount: Int = 0
-    override fun debug(message: String) = task.log(message, Project.MSG_DEBUG)
-    override fun info(message: String) = task.log(message, Project.MSG_VERBOSE)
-    override fun progress(message: String) = task.log(message, Project.MSG_INFO)
-    override fun warn(message: String) = task.log(message, Project.MSG_WARN).also { warningsCount++ }
-    override fun error(message: String) = task.log(message, Project.MSG_ERR).also { errorsCount++ }
-    override fun report() {
-        if (warningsCount > 0 || errorsCount > 0) {
-            task.log("Generation completed with $warningsCount warning" +
-                    (if(warningsCount == 1) "" else "s") +
-                    " and $errorsCount error" +
-                    if(errorsCount == 1) "" else "s"
-            )
-        } else {
-            task.log("generation completed successfully")
-        }
-    }
-}
-
-class AntSourceLinkDefinition(var path: String? = null, var url: String? = null, var lineSuffix: String? = null)
-
-class AntSourceRoot(var path: String? = null) {
-    fun toSourceRoot(): SourceRootImpl? = path?.let { path ->
-        SourceRootImpl(path)
-    }
-}
-
-class TextProperty(var value: String = "")
-
-class AntPassConfig(task: Task) : DokkaConfiguration.PassConfiguration {
-    override var moduleName: String = ""
-    override val classpath: List<String>
-        get() = buildClassPath.list().toList()
-
-    override val sourceRoots: List<DokkaConfiguration.SourceRoot>
-        get() = sourcePath.list().map { SourceRootImpl(it) } + antSourceRoots.mapNotNull { it.toSourceRoot() }
-
-    override val samples: List<String>
-        get() = samplesPath.list().toList()
-    override val includes: List<String>
-        get() = includesPath.list().toList()
-    override var includeNonPublic: Boolean = false
-    override var includeRootPackage: Boolean = true
-    override var reportUndocumented: Boolean = false
-    override var skipEmptyPackages: Boolean = true
-    override var skipDeprecated: Boolean = false
-    override var jdkVersion: Int = 8
-    override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition>
-        get() = antSourceLinkDefinition.map {
-            val path = it.path!!
-            val url = it.url!!
-            SourceLinkDefinitionImpl(File(path).canonicalFile.absolutePath, url, it.lineSuffix)
-        }
-    override val perPackageOptions: MutableList<DokkaConfiguration.PackageOptions> = mutableListOf()
-    override val externalDocumentationLinks: List<ExternalDocumentationLink>
-        get() = buildExternalLinksBuilders.map { it.build() } + defaultExternalDocumentationLinks
-
-    override var languageVersion: String? = null
-    override var apiVersion: String? = null
-    override var noStdlibLink: Boolean = false
-    override var noJdkLink: Boolean = false
-    override var suppressedFiles: MutableList<String> = mutableListOf()
-    override var collectInheritedExtensionsFromLibraries: Boolean = false
-    override var analysisPlatform: Platform = Platform.DEFAULT
-    override var targets: List<String> = listOf()
-        get() = buildTargets.filter { it.value != "" }
-            .map { it.value }
-
-    override var sinceKotlin: String? = null
-
-    private val samplesPath: Path by lazy { Path(task.project) }
-    private val includesPath: Path by lazy { Path(task.project) }
-    private val buildClassPath: Path by lazy { Path(task.project) }
-    val sourcePath: Path by lazy { Path(task.project) }
-    val antSourceRoots: MutableList<AntSourceRoot> = mutableListOf()
-
-    private val buildTargets: MutableList<TextProperty> = mutableListOf()
-    private val buildExternalLinksBuilders: MutableList<ExternalDocumentationLink.Builder> = mutableListOf()
-    val antSourceLinkDefinition: MutableList<AntSourceLinkDefinition> = mutableListOf()
-
-    private val defaultExternalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink>
-        get() {
-            val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
-            if (!noJdkLink)
-                links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://docs.oracle.com/javase/$jdkVersion/docs/api/").build()
-
-            if (!noStdlibLink)
-                links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://kotlinlang.org/api/latest/jvm/stdlib/").build()
-            return links
-        }
-
-
-    fun setSamples(ref: Path) {
-        samplesPath.append(ref)
-    }
-
-    fun setSamplesRef(ref: Reference) {
-        samplesPath.createPath().refid = ref
-    }
-
-    fun setInclude(ref: Path) {
-        includesPath.append(ref)
-    }
-
-    fun setClasspath(classpath: Path) {
-        buildClassPath.append(classpath)
-    }
-
-    fun createPackageOptions(): AntPackageOptions = AntPackageOptions().apply { perPackageOptions.add(this) }
-
-    fun createSourceRoot(): AntSourceRoot = AntSourceRoot().apply {  antSourceRoots.add(this) }
-
-    fun createTarget(): TextProperty = TextProperty().apply {
-            buildTargets.add(this)
-    }
-
-    fun setClasspathRef(ref: Reference) {
-        buildClassPath.createPath().refid = ref
-    }
-
-    fun setSrc(src: Path) {
-        sourcePath.append(src)
-    }
-
-    fun setSrcRef(ref: Reference) {
-        sourcePath.createPath().refid = ref
-    }
-
-    fun createSourceLink(): AntSourceLinkDefinition {
-        val def = AntSourceLinkDefinition()
-        antSourceLinkDefinition.add(def)
-        return def
-    }
-
-    fun createExternalDocumentationLink() =
-        ExternalDocumentationLink.Builder().apply { buildExternalLinksBuilders.add(this) }
-
-}
-
-class AntPackageOptions(
-        override var prefix: String = "",
-        override var includeNonPublic: Boolean = false,
-        override var reportUndocumented: Boolean = true,
-        override var skipDeprecated: Boolean = false,
-        override var suppress: Boolean = false) : DokkaConfiguration.PackageOptions
-
-class DokkaAntTask: Task(), DokkaConfiguration {
-
-    override var format: String = "html"
-    override var generateIndexPages: Boolean = false
-    override var outputDir: String = ""
-    override var impliedPlatforms: List<String> = listOf()
-        get() = buildImpliedPlatforms.map { it.value }.toList()
-    private val buildImpliedPlatforms: MutableList<TextProperty> = mutableListOf()
-
-    override var cacheRoot: String? = null
-    override val passesConfigurations: MutableList<AntPassConfig> = mutableListOf()
-    override var pluginsClasspath: List<File> = mutableListOf()
-
-    fun createPassConfig() = AntPassConfig(this).apply { passesConfigurations.add(this) }
-    fun createImpliedPlatform(): TextProperty = TextProperty().apply { buildImpliedPlatforms.add(this) }
-
-
-    override fun execute() {
-        for (passConfig in passesConfigurations) {
-            if (passConfig.sourcePath.list().isEmpty() && passConfig.antSourceRoots.isEmpty()) {
-                throw BuildException("At least one source path needs to be specified")
-            }
-
-            if (passConfig.moduleName == "") {
-                throw BuildException("Module name needs to be specified and not empty")
-            }
-
-            for (sourceLink in passConfig.antSourceLinkDefinition) {
-                if (sourceLink.path == null) {
-                    throw BuildException("'path' attribute of a <sourceLink> element is required")
-                }
-                if (sourceLink.path!!.contains("\\")) {
-                    throw BuildException("'dir' attribute of a <sourceLink> - incorrect value, only Unix based path allowed")
-                }
-
-                if (sourceLink.url == null) {
-                    throw BuildException("'url' attribute of a <sourceLink> element is required")
-                }
-            }
-        }
-
-        if (outputDir == "") {
-            throw BuildException("Output directory needs to be specified and not empty")
-        }
-
-        val generator = DokkaGenerator(this, AntLogger(this))
-        generator.generate()
-    }
-}
\ No newline at end of file
diff --git a/runners/ant/src/main/resources/dokka-antlib.xml b/runners/ant/src/main/resources/dokka-antlib.xml
deleted file mode 100644
index 9c3373d5..00000000
--- a/runners/ant/src/main/resources/dokka-antlib.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<antlib>
-    <taskdef name="dokka" classname="org.jetbrains.dokka.ant.DokkaAntTask"/>
-</antlib>
diff --git a/runners/cli/build.gradle.kts b/runners/cli/build.gradle.kts
index 8c4955ca..bc09f2cd 100644
--- a/runners/cli/build.gradle.kts
+++ b/runners/cli/build.gradle.kts
@@ -10,7 +10,6 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-cli-jvm:0.2.1")
-    implementation("com.google.code.gson:gson:2.8.5")
     implementation(project(":core"))
     implementation(kotlin("stdlib"))
 }
@@ -36,4 +35,4 @@ publishing {
     }
 }
 
-configureBintrayPublication("dokkaCli")
\ No newline at end of file
+configureBintrayPublication("dokkaCli")
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index b0fb45b2..5e5cd6b2 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import kotlinx.cli.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet.*
@@ -34,7 +33,7 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     override val sourceSets by parser.option(
         ArgTypeArgument,
         description = "Single dokka source set",
-        fullName = "pass"
+        fullName = "sourceSet"
     ).multiple()
 
     override val pluginsConfiguration by parser.option(
@@ -60,7 +59,7 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
 
     val globalPackageOptions by parser.option(
         ArgType.String,
-        description = "List of package passConfiguration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
+        description = "List of package source sets in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
     ).delimiter(";")
 
     val globalLinks by parser.option(
@@ -73,9 +72,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
         description = "Mapping between a source directory and a Web site for browsing the code (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
-    val helpPass by parser.option(
-        ArgTypeHelpPass,
-        description = "Prints help for single -pass"
+    val helpSourceSet by parser.option(
+        ArgTypeHelpSourceSet,
+        description = "Prints help for single -sourceSet"
     )
 
     override val modules: List<DokkaConfiguration.DokkaModuleDescription> = emptyList()
@@ -94,8 +93,8 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
 
         globalSrcLink.forEach {
             if (it.isNotEmpty() && it.contains("="))
-                sourceSets.all { pass ->
-                    pass.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
+                sourceSets.all { sourceSet ->
+                    sourceSet.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
                         .add(SourceLinkDefinitionImpl.parseSourceLinkDefinition(it))
                 }
             else {
@@ -112,9 +111,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     }
 }
 
-fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
+private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
-    val parser = ArgParser("passConfiguration", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
+    val parser = ArgParser("sourceSet", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
 
     val moduleName by parser.option(
         ArgType.String,
@@ -122,16 +121,21 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
         fullName = "module"
     ).required()
 
-    val displayName by parser.option(
+    val moduleDisplayName by parser.option(
         ArgType.String,
-        description = "Name of the source set"
-    ).default("JVM")
+        description = "Name of the documentation module"
+    )
 
-    val sourceSetID by parser.option(
+    val name by parser.option(
         ArgType.String,
-        description = "ID of the source set"
+        description = "Name of the source set"
     ).default("main")
 
+    val displayName by parser.option(
+        ArgType.String,
+        description = "Displayed name of the source set"
+    ).default("JVM")
+
     val classpath by parser.option(
         ArgType.String,
         description = "Classpath for symbol resolution (allows many paths separated by the semicolon `;`)"
@@ -213,7 +217,7 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
     val perPackageOptions by parser.option(
         ArgType.String,
-        description = "List of package passConfiguration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
+        description = "List of package source set configuration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
     ).delimiter(";")
 
     val externalDocumentationLinks by parser.option(
@@ -230,12 +234,14 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
     parser.parse(args)
 
     return object : DokkaConfiguration.DokkaSourceSet {
-        override val moduleName = moduleName
+        override val moduleDisplayName = moduleDisplayName ?: moduleName
         override val displayName = displayName
-        override val sourceSetID = sourceSetID
+        override val sourceSetID = DokkaSourceSetID(moduleName, name)
         override val classpath = classpath
         override val sourceRoots = sourceRoots.map { SourceRootImpl(it.toAbsolutePath()) }
-        override val dependentSourceSets: List<String> = dependentSourceSets
+        override val dependentSourceSets: Set<DokkaSourceSetID> = dependentSourceSets
+            .map { dependentSourceSetName -> DokkaSourceSetID(moduleName, dependentSourceSetName)  }
+            .toSet()
         override val samples = samples.map { it.toAbsolutePath() }
         override val includes = includes.map { it.toAbsolutePath() }
         override val includeNonPublic = includeNonPublic
@@ -294,15 +300,15 @@ object ArgTypeSourceLinkDefinition : ArgType<DokkaConfiguration.SourceLinkDefini
 
 object ArgTypeArgument : ArgType<DokkaConfiguration.DokkaSourceSet>(true) {
     override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.DokkaSourceSet =
-        passArguments(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
+        parseSourceSet(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
 
     override val description: kotlin.String
         get() = ""
 }
 
 // Workaround for printing nested parsers help
-object ArgTypeHelpPass : ArgType<Any>(false) {
-    override fun convert(value: kotlin.String, name: kotlin.String): Any = Any().also { passArguments(arrayOf("-h")) }
+object ArgTypeHelpSourceSet : ArgType<Any>(false) {
+    override fun convert(value: kotlin.String, name: kotlin.String): Any = Any().also { parseSourceSet(arrayOf("-h")) }
 
     override val description: kotlin.String
         get() = ""
@@ -345,11 +351,10 @@ fun parseLinks(links: List<String>): List<ExternalDocumentationLink> {
 fun main(args: Array<String>) {
     val globalArguments = GlobalArguments(args)
     val configuration = if (globalArguments.json != null)
-        Gson().fromJson(
-            Paths.get(globalArguments.json).toFile().readText(),
-            DokkaConfigurationImpl::class.java
+        DokkaConfigurationImpl(
+            Paths.get(checkNotNull(globalArguments.json)).toFile().readText()
         )
     else
         globalArguments
     DokkaGenerator(configuration, DokkaConsoleLogger).generate()
-}
\ No newline at end of file
+}
diff --git a/runners/gradle-plugin/build.gradle.kts b/runners/gradle-plugin/build.gradle.kts
index 71d7e72f..2c25a707 100644
--- a/runners/gradle-plugin/build.gradle.kts
+++ b/runners/gradle-plugin/build.gradle.kts
@@ -19,6 +19,8 @@ dependencies {
     compileOnly(gradleKotlinDsl())
     testImplementation(gradleApi())
     testImplementation(kotlin("test-junit"))
+    testImplementation("org.jetbrains.kotlin:kotlin-gradle-plugin")
+
     constraints {
         val kotlin_version: String by project
         compileOnly("org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}") {
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
index 3bd0b6ab..c9693467 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
@@ -169,4 +169,4 @@ class ConfigurationExtractor(private val project: Project) {
         val dependentSourceSets: List<String>,
         val platform: String
     ) : Serializable
-}
\ No newline at end of file
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index ead0f90a..823206e3 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -19,7 +19,7 @@ open class DokkaCollectorTask : DefaultTask() {
 
     @TaskAction
     fun collect() {
-        val passesConfigurations = getProjects(project).filter { it.name in modules }.flatMap {
+        val sourceSets = getProjects(project).filter { it.name in modules }.flatMap {
             val tasks = try {
                 it.tasks.withType(DokkaTask::class.java)
             } catch (e: UnknownTaskException) {
@@ -30,11 +30,11 @@ open class DokkaCollectorTask : DefaultTask() {
 
         val initial = GradleDokkaConfigurationImpl().apply {
             outputDir = outputDirectory
-            cacheRoot = passesConfigurations.first().cacheRoot
-            format = passesConfigurations.first().format
+            cacheRoot = sourceSets.first().cacheRoot
+            format = sourceSets.first().format
         }
 
-        configuration = passesConfigurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
+        configuration = sourceSets.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
             if(acc.format != it.format || acc.cacheRoot != it.cacheRoot)
                 throw IllegalStateException("Dokka task configurations differ on core arguments (format, cacheRoot)")
             acc.sourceSets = acc.sourceSets + it.sourceSets
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt
new file mode 100644
index 00000000..3fadb4fd
--- /dev/null
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt
@@ -0,0 +1,10 @@
+@file:Suppress("FunctionName")
+
+package org.jetbrains.dokka.gradle
+
+import org.gradle.api.Project
+import org.jetbrains.dokka.DokkaSourceSetID
+
+internal fun DokkaSourceSetID(project: Project, sourceSetName: String): DokkaSourceSetID {
+    return DokkaSourceSetID(moduleName = project.path, sourceSetName = sourceSetName)
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
index e27357c9..aac7e2a0 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
@@ -7,11 +7,9 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.internal.plugins.DslObject
 import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.tasks.*
-import org.jetbrains.dokka.DokkaBootstrap
+import org.jetbrains.dokka.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink.Builder
 import org.jetbrains.dokka.DokkaConfiguration.SourceRoot
-import org.jetbrains.dokka.DokkaException
-import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.ReflectDsl
 import org.jetbrains.dokka.ReflectDsl.isNotInstance
 import org.jetbrains.dokka.gradle.ConfigurationExtractor.PlatformData
@@ -183,10 +181,7 @@ open class DokkaTask : DefaultTask(), Configurable {
         val defaultModulesConfiguration = configuredDokkaSourceSets
             .map { configureDefault(it, globalConfig) }.takeIf { it.isNotEmpty() }
             ?: listOf(
-                configureDefault(
-                    configureDokkaSourceSet(GradleDokkaSourceSet("main")),
-                    null
-                )
+                configureDefault(configureDokkaSourceSet(GradleDokkaSourceSet("main", project)), null)
             ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
 
         if (defaultModulesConfiguration.isEmpty()) {
@@ -288,28 +283,25 @@ open class DokkaTask : DefaultTask(), Configurable {
     protected fun mergeUserConfigurationAndPlatformData(
         userConfig: GradleDokkaSourceSet,
         autoConfig: PlatformData
-    ) =
-        userConfig.copy().apply {
-            sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
-            dependentSourceSets.addAll(userConfig.dependentSourceSets.union(autoConfig.dependentSourceSets).distinct())
-            classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
-            if (userConfig.platform == null && autoConfig.platform != "")
-                platform = autoConfig.platform
-        }
+    ) = userConfig.copy().apply {
+        sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
+        dependentSourceSets.addAll(userConfig.dependentSourceSets)
+        dependentSourceSets.addAll(autoConfig.dependentSourceSets.map { DokkaSourceSetID(project, it) })
+        classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
+        if (userConfig.platform == null && autoConfig.platform != "")
+            platform = autoConfig.platform
+    }
 
     protected fun configureDefault(
         config: GradleDokkaSourceSet,
         globalConfig: GradleDokkaSourceSet?
     ): GradleDokkaSourceSet {
-        if (config.moduleName.isBlank()) {
-            config.moduleName = project.name
+        if (config.moduleDisplayName.isBlank()) {
+            config.moduleDisplayName = project.name
         }
-        if (config.sourceSetID.isBlank()) {
-            config.sourceSetID = config.moduleName + "/" + config.name
-        }
-        config.dependentSourceSets = config.dependentSourceSets.map { config.moduleName + "/" + it }.toMutableList()
+
         if (config.displayName.isBlank()) {
-            config.displayName = config.sourceSetID.substringBeforeLast("Main", config.platform.toString())
+            config.displayName = config.name.substringBeforeLast("Main", config.platform.toString())
         }
         config.classpath =
             (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index a28416d6..7b2d05a6 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -1,13 +1,19 @@
+@file:Suppress("FunctionName")
+
 package org.jetbrains.dokka.gradle
 
+import com.android.build.gradle.api.AndroidSourceSet
 import groovy.lang.Closure
 import org.gradle.api.Action
+import org.gradle.api.Project
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaConfiguration.*
 import org.jetbrains.dokka.DokkaDefaults
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.Platform
 import java.io.File
 import java.io.Serializable
@@ -15,6 +21,8 @@ import java.net.URL
 import java.util.concurrent.Callable
 import kotlin.reflect.KMutableProperty
 import kotlin.reflect.full.memberProperties
+import org.gradle.api.tasks.SourceSet as GradleSourceSet
+import org.jetbrains.kotlin.gradle.model.SourceSet as KotlinSourceSet
 
 class GradleSourceRootImpl : SourceRoot, Serializable {
     override var path: String = ""
@@ -25,64 +33,113 @@ class GradleSourceRootImpl : SourceRoot, Serializable {
     override fun toString(): String = path
 }
 
-open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceSet {
+open class GradleDokkaSourceSet constructor(
+    @Transient val name: String,
+    @Transient internal val project: Project
+) : DokkaSourceSet {
+
     @Input
     @Optional
     override var classpath: List<String> = emptyList()
+
     @Input
-    override var moduleName: String = ""
+    override var moduleDisplayName: String = ""
+
     @Input
     override var displayName: String = ""
-    @Input
-    override var sourceSetID: String = ""
+
+    @get:Internal
+    override val sourceSetID: DokkaSourceSetID = DokkaSourceSetID(project, name)
+
     @Input
     override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
+
     @Input
-    override var dependentSourceSets: MutableList<String> = mutableListOf()
+    override var dependentSourceSets: MutableSet<DokkaSourceSetID> = mutableSetOf()
+
     @Input
     override var samples: List<String> = emptyList()
+
     @Input
     override var includes: List<String> = emptyList()
+
     @Input
     override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+
     @Input
     override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
+
     @Input
     override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
+
     @Input
     override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
+
     @Input
     override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
+
     @Input
     override var jdkVersion: Int = DokkaDefaults.jdkVersion
+
     @Input
     override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
+
     @Input
     override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
+
     @Input
     override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
+
     @Input
     @Optional
     override var languageVersion: String? = null
+
     @Input
     @Optional
     override var apiVersion: String? = null
+
     @Input
     override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
+
     @Input
     override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
+
     @Input
     var noAndroidSdkLink: Boolean = false
+
     @Input
     override var suppressedFiles: List<String> = emptyList()
+
     @Input
     override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
+
     @Input
     @Optional
     var platform: String? = null
+
     @Transient
     var collectKotlinTasks: (() -> List<Any?>?)? = null
 
+    fun DokkaSourceSetID(sourceSetName: String): DokkaSourceSetID {
+        return DokkaSourceSetID(project, sourceSetName)
+    }
+
+    fun dependsOn(sourceSet: GradleSourceSet) {
+        dependsOn(DokkaSourceSetID(sourceSet.name))
+    }
+
+    fun dependsOn(sourceSet: DokkaSourceSet) {
+        dependsOn(sourceSet.sourceSetID)
+    }
+
+    fun dependsOn(sourceSetName: String) {
+        dependsOn(DokkaSourceSetID(sourceSetName))
+    }
+
+    fun dependsOn(sourceSetID: DokkaSourceSetID) {
+        dependentSourceSets.add(sourceSetID)
+    }
+
     fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
         collectKotlinTasks = { taskSupplier.call() }
     }
@@ -136,6 +193,18 @@ open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceS
     }
 }
 
+fun GradleDokkaSourceSet.dependsOn(sourceSet: KotlinSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
+fun GradleDokkaSourceSet.dependsOn(sourceSet: org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
+fun GradleDokkaSourceSet.dependsOn(sourceSet: AndroidSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
 class GradleSourceLinkDefinitionImpl : SourceLinkDefinition, Serializable {
     override var path: String = ""
     override var url: String = ""
@@ -174,16 +243,16 @@ class GradlePackageOptionsImpl : PackageOptions, Serializable {
 }
 
 internal fun GradleDokkaSourceSet.copy(): GradleDokkaSourceSet {
-    val newObj = GradleDokkaSourceSet(this.name)
+    val newObj = GradleDokkaSourceSet(this.name, this.project)
     this::class.memberProperties.forEach { field ->
         if (field is KMutableProperty<*>) {
-            val value = field.getter.call(this)
-            if (value is Collection<*>) {
-                field.setter.call(newObj, value.toMutableList())
-            } else {
-                field.setter.call(newObj, field.getter.call(this))
+            when (val value = field.getter.call(this)) {
+                is List<*> -> field.setter.call(newObj, value.toMutableList())
+                is Set<*> -> field.setter.call(newObj, value.toMutableSet())
+                else -> field.setter.call(newObj, field.getter.call(this))
             }
+
         }
     }
     return newObj
-}
\ No newline at end of file
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
index 92d63a40..a92f5475 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
@@ -53,7 +53,9 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java)
+            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java) { name ->
+                GradleDokkaSourceSet(name, project)
+            }
             task.dokkaRuntime = runtimeConfiguration
             task.pluginsClasspathConfiguration = pluginsConfiguration
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
index 0b80f4a2..da6daeea 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
@@ -1,6 +1,9 @@
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.testfixtures.ProjectBuilder
+import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -16,4 +19,78 @@ class KotlinDslDokkaTaskConfigurationTest {
             assertEquals("test", dokkaTask.outputFormat)
         }
     }
+
+    @Test
+    fun `sourceSet dependsOn by String`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val commonMain = create("commonMain")
+                val jvmMain = create("jvmMain") {
+                    it.dependsOn("commonMain")
+                }
+
+                assertEquals(
+                    0, commonMain.dependentSourceSets.size,
+                    "Expected no dependent source set in commonMain"
+                )
+
+                assertEquals(
+                    1, jvmMain.dependentSourceSets.size,
+                    "Expected only one dependent source set in jvmMain"
+                )
+
+                assertEquals(
+                    commonMain.sourceSetID, jvmMain.dependentSourceSets.single(),
+                    "Expected jvmMain to depend on commonMain"
+                )
+
+                assertEquals(
+                    DokkaSourceSetID(project.path, "commonMain"), commonMain.sourceSetID
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `sourceSet dependsOn by DokkaSourceSet`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val commonMain = create("commonMain")
+                val jvmMain = create("jvmMain") {
+                    it.dependsOn(commonMain)
+                }
+
+                assertEquals(
+                    commonMain.sourceSetID, jvmMain.dependentSourceSets.single()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `sourceSet dependsOn by KotlinSourceSet`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+        project.plugins.apply("org.jetbrains.kotlin.jvm")
+
+        val kotlin = project.extensions.getByName("kotlin") as KotlinJvmProjectExtension
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val special = create("special") {
+                    it.dependsOn(kotlin.sourceSets.getByName("main"))
+                }
+
+                assertEquals(
+                    DokkaSourceSetID(project, "main"), special.dependentSourceSets.single()
+                )
+            }
+        }
+    }
 }
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 4c10568c..8160ab87 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -90,9 +90,6 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter
     var sourceRoots: List<SourceRoot> = emptyList()
 
-    @Parameter
-    var dependentSourceSets: List<String> = emptyList()
-
     @Parameter
     var samples: List<String> = emptyList()
 
@@ -108,6 +105,9 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter(required = true, defaultValue = "\${project.artifactId}")
     var moduleName: String = ""
 
+    @Parameter
+    var moduleDisplayName: String = ""
+
     @Parameter(required = false, defaultValue = "false")
     var skip: Boolean = false
 
@@ -201,12 +201,12 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
         }
 
         val sourceSet = DokkaSourceSetImpl(
-            moduleName = moduleName,
+            moduleDisplayName = moduleDisplayName.takeIf(String::isNotBlank) ?: moduleName,
             displayName = displayName,
-            sourceSetID = sourceSetName,
+            sourceSetID = DokkaSourceSetID(moduleName, sourceSetName),
             classpath = classpath,
             sourceRoots = sourceDirectories.map { SourceRootImpl(it) },
-            dependentSourceSets = dependentSourceSets,
+            dependentSourceSets = emptySet(),
             samples = samples,
             includes = includes,
             includeNonPublic = includeNonPublic,
@@ -246,7 +246,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             offlineMode = offlineMode,
             cacheRoot = cacheRoot,
             sourceSets = listOf(sourceSet).also {
-                if (sourceSet.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
+                if (sourceSet.moduleDisplayName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
             },
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
                     dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index 07aedf28..97347695 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -45,4 +44,4 @@ class MockContext(
 private fun DokkaPlugin.injectContext(context: DokkaContext) {
     (DokkaPlugin::class.memberProperties.single { it.name == "context" } as KMutableProperty<*>)
         .setter.call(this, context)
-}
\ No newline at end of file
+}
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index ec2be689..d3127263 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.testApi.testRunner
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaGenerator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -43,4 +42,4 @@ internal class DokkaTestGenerator(
 
         dokkaGenerator.reportAfterRendering(context)
     }
-}
\ No newline at end of file
+}
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 057045a8..381fb2af 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -174,25 +174,26 @@ abstract class AbstractCoreTest {
             failOnWarning = failOnWarning
         )
 
-        fun passes(block: Passes.() -> Unit) {
-            sourceSets.addAll(Passes().apply(block))
+        fun sourceSets(block: SourceSetsBuilder.() -> Unit) {
+            sourceSets.addAll(SourceSetsBuilder().apply(block))
         }
     }
 
     @DokkaConfigurationDsl
-    protected class Passes : ArrayList<DokkaSourceSetImpl>() {
-        fun pass(block: DokkaSourceSetBuilder.() -> Unit) =
-            add(DokkaSourceSetBuilder().apply(block).build())
+    protected class SourceSetsBuilder : ArrayList<DokkaSourceSetImpl>() {
+        fun sourceSet(block: DokkaSourceSetBuilder.() -> Unit): DokkaSourceSet =
+            DokkaSourceSetBuilder().apply(block).build().apply(::add)
     }
 
     @DokkaConfigurationDsl
     protected class DokkaSourceSetBuilder(
         var moduleName: String = "root",
-        var sourceSetID: String = "main",
+        var moduleDisplayName: String? = null,
+        var name: String = "main",
         var displayName: String = "JVM",
         var classpath: List<String> = emptyList(),
         var sourceRoots: List<String> = emptyList(),
-        var dependentSourceSets: List<String> = emptyList(),
+        var dependentSourceSets: Set<DokkaSourceSetID> = emptySet(),
         var samples: List<String> = emptyList(),
         var includes: List<String> = emptyList(),
         var includeNonPublic: Boolean = false,
@@ -212,9 +213,9 @@ abstract class AbstractCoreTest {
         var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
     ) {
         fun build() = DokkaSourceSetImpl(
-            moduleName = moduleName,
+            moduleDisplayName = moduleDisplayName ?: moduleName,
             displayName = displayName,
-            sourceSetID = sourceSetID,
+            sourceSetID = DokkaSourceSetID(moduleName, name),
             classpath = classpath,
             sourceRoots = sourceRoots.map { SourceRootImpl(it) },
             dependentSourceSets = dependentSourceSets,
-- 
cgit 


From f80d5938ccafcf5bd41d73f98bebe2d9699faa95 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Thu, 2 Jul 2020 11:33:52 +0200
Subject: Add GFM renderer tests

---
 plugins/base/build.gradle.kts                      |   6 +-
 .../src/main/kotlin/renderers/DefaultRenderer.kt   |  19 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  33 +-
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |  77 +----
 .../src/test/kotlin/renderers/defaultSourceSet.kt  |  31 ++
 .../test/kotlin/renderers/html/DivergentTest.kt    |   2 +-
 .../kotlin/renderers/html/GroupWrappingTest.kt     |   2 +-
 .../renderers/html/HtmlRenderingOnlyTestBase.kt    |  78 +++++
 .../renderers/html/SourceSetDependentHintTest.kt   |   6 +-
 .../test/kotlin/renderers/html/defaultSourceSet.kt |  31 --
 plugins/gfm/build.gradle.kts                       |   2 +
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |  70 +++-
 .../src/test/kotlin/renderers/gfm/DivergentTest.kt | 375 +++++++++++++++++++++
 .../renderers/gfm/GfmRenderingOnlyTestBase.kt      |  32 ++
 .../test/kotlin/renderers/gfm/GroupWrappingTest.kt |  77 +++++
 .../renderers/gfm/SourceSetDependentHintTest.kt    | 137 ++++++++
 16 files changed, 834 insertions(+), 144 deletions(-)
 create mode 100644 plugins/base/src/test/kotlin/renderers/defaultSourceSet.kt
 create mode 100644 plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
 delete mode 100644 plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
 create mode 100644 plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
 create mode 100644 plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
 create mode 100644 plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
 create mode 100644 plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index 02babd4d..08d1054a 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -4,6 +4,8 @@ plugins {
     id("com.jfrog.bintray")
 }
 
+val testUtils by configurations.creating
+
 dependencies {
     val coroutines_version: String by project
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
@@ -12,6 +14,8 @@ dependencies {
     implementation("org.jsoup:jsoup:1.12.1")
     implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
     testImplementation(project(":test-tools"))
+
+    testUtils(sourceSets.test.get().output)
 }
 
 task("copy_frontend", Copy::class) {
@@ -38,4 +42,4 @@ publishing {
     }
 }
 
-configureBintrayPublication("basePlugin")
+configureBintrayPublication("basePlugin")
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
index f2fce191..57a3d8d1 100644
--- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -170,6 +170,23 @@ abstract class DefaultRenderer<T>(
             renderPages(newRoot)
         }
     }
+
+    protected fun ContentDivergentGroup.groupDivergentInstances(
+        pageContext: ContentPage,
+        beforeTransformer: (ContentDivergentInstance, ContentPage, DokkaSourceSet) -> String,
+        afterTransformer: (ContentDivergentInstance, ContentPage, DokkaSourceSet) -> String
+    ): Map<Pair<String, String>, List<Pair<ContentDivergentInstance, DokkaSourceSet>>> =
+        children.flatMap { instance ->
+            instance.sourceSets.map { sourceSet ->
+                Pair(instance, sourceSet) to Pair(
+                    beforeTransformer(instance, pageContext, sourceSet),
+                    afterTransformer(instance, pageContext, sourceSet)
+                )
+            }
+        }.groupBy(
+            Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::second,
+            Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::first
+        )
 }
 
-fun ContentPage.sourceSets() = this.content.sourceSets
+fun ContentPage.sourceSets() = this.content.sourceSets
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index a950667f..595dc8d2 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -222,26 +222,21 @@ open class HtmlRenderer(
     }
 
     override fun FlowContent.buildDivergent(node: ContentDivergentGroup, pageContext: ContentPage) {
+
         val distinct =
-            node.children.flatMap { instance ->
-                instance.sourceSets.map { sourceSet ->
-                    Pair(instance, sourceSet) to Pair(
-                        createHTML(prettyPrint = false).div {
-                            instance.before?.let { before ->
-                                buildContentNode(before, pageContext, setOf(sourceSet))
-                            }
-                        }.stripDiv(),
-                        createHTML(prettyPrint = false).div {
-                            instance.after?.let { after ->
-                                buildContentNode(after, pageContext, setOf(sourceSet))
-                            }
-                        }.stripDiv()
-                    )
-                }
-            }.groupBy(
-                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::second,
-                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::first
-            )
+            node.groupDivergentInstances(pageContext, { instance, contentPage, sourceSet ->
+                createHTML(prettyPrint = false).div {
+                    instance.before?.let { before ->
+                        buildContentNode(before, pageContext, setOf(sourceSet))
+                    }
+                }.stripDiv()
+            }, { instance, contentPage, sourceSet ->
+                createHTML(prettyPrint = false).div {
+                    instance.after?.let { after ->
+                        buildContentNode(after, pageContext, setOf(sourceSet))
+                    }
+                }.stripDiv()
+            })
 
         distinct.forEach {
             val groupedDivergent = it.value.groupBy { it.second }
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index 21a70802..8e58bbcd 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -1,50 +1,19 @@
 package renderers
 
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
-import org.jetbrains.dokka.DokkaConfigurationImpl
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.renderers.RootCreator
-import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
-import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
-import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProviderFactory
 import org.jetbrains.dokka.base.signatures.KotlinSignatureProvider
-import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.doc.DocTag
-import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.pages.ContentNode
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.testApi.context.MockContext
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jsoup.Jsoup
-import org.jsoup.nodes.Element
-import org.jsoup.nodes.Node
-import org.jsoup.nodes.TextNode
-import utils.TestOutputWriter
+import renderers.html.EmptyCommentConverter
 
 abstract class RenderingOnlyTestBase {
-    val files = TestOutputWriter()
-    val context = MockContext(
-        DokkaBase().outputWriter to { _ -> files },
-        DokkaBase().locationProviderFactory to ::DefaultLocationProviderFactory,
-        DokkaBase().htmlPreprocessors to { _ -> RootCreator },
-        DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
-        DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
-        testConfiguration = DokkaConfigurationImpl(
-            "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
-        )
-    )
-
-    protected val renderedContent: Element by lazy {
-        files.contents.getValue("test-page.html").let { Jsoup.parse(it) }.select("#content").single()
-    }
-
-    protected fun linesAfterContentTag() =
-        files.contents.getValue("test-page.html").lines()
-            .dropWhile { !it.contains("""<div id="content">""") }
-            .joinToString(separator = "") { it.trim() }
-
+    abstract val context: MockContext
 }
 
 class TestPage(callback: PageContentBuilder.DocumentableContentBuilder.() -> Unit) : RootPageNode(), ContentPage {
@@ -76,37 +45,3 @@ class TestPage(callback: PageContentBuilder.DocumentableContentBuilder.() -> Uni
 
     override fun modified(name: String, children: List<PageNode>) = this
 }
-
-fun Element.match(vararg matchers: Any): Unit =
-    childNodes()
-        .filter { it !is TextNode || it.text().isNotBlank() }
-        .let { it.drop(it.size - matchers.size) }
-        .zip(matchers)
-        .forEach { (n, m) -> m.accepts(n) }
-
-open class Tag(val name: String, vararg val matchers: Any)
-class Div(vararg matchers: Any) : Tag("div", *matchers)
-class P(vararg matchers: Any) : Tag("p", *matchers)
-class Span(vararg matchers: Any) : Tag("span", *matchers)
-
-private fun Any.accepts(n: Node) {
-    when (this) {
-        is String -> assert(n is TextNode && n.text().trim() == this.trim()) { "\"$this\" expected but found: $n" }
-        is Tag -> {
-            assert(n is Element && n.tagName() == name) { "Tag $name expected but found: $n" }
-            if (n is Element && matchers.isNotEmpty()) n.match(*matchers)
-        }
-        else -> throw IllegalArgumentException("$this is not proper matcher")
-    }
-}
-
-
-internal object EmptyCommentConverter : CommentsToContentConverter {
-    override fun buildContent(
-        docTag: DocTag,
-        dci: DCI,
-        sourceSets: Set<DokkaSourceSet>,
-        styles: Set<Style>,
-        extras: PropertyContainer<ContentNode>
-    ): List<ContentNode> = emptyList()
-}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/renderers/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/defaultSourceSet.kt
new file mode 100644
index 00000000..7358d2c2
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/defaultSourceSet.kt
@@ -0,0 +1,31 @@
+package renderers
+
+import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.dokka.DokkaSourceSetImpl
+import org.jetbrains.dokka.Platform
+
+val defaultSourceSet = DokkaSourceSetImpl(
+    moduleDisplayName = "DEFAULT",
+    displayName = "DEFAULT",
+    sourceSetID = DokkaSourceSetID("DEFAULT", "DEFAULT"),
+    classpath = emptyList(),
+    sourceRoots = emptyList(),
+    dependentSourceSets = emptySet(),
+    samples = emptyList(),
+    includes = emptyList(),
+    includeNonPublic = false,
+    includeRootPackage = false,
+    reportUndocumented = false,
+    skipEmptyPackages = true,
+    skipDeprecated = false,
+    jdkVersion = 8,
+    sourceLinks = emptyList(),
+    perPackageOptions = emptyList(),
+    externalDocumentationLinks = emptyList(),
+    languageVersion = null,
+    apiVersion = null,
+    noStdlibLink = false,
+    noJdkLink = false,
+    suppressedFiles = emptyList(),
+    analysisPlatform = Platform.DEFAULT
+)
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index d4778a8e..f5565b48 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -8,7 +8,7 @@ import org.jetbrains.dokka.pages.ContentDivergentGroup
 import org.junit.jupiter.api.Test
 import renderers.*
 
-class DivergentTest : RenderingOnlyTestBase() {
+class DivergentTest : HtmlRenderingOnlyTestBase() {
     private val js = defaultSourceSet.copy(
         "root",
         "JS",
diff --git a/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt b/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
index 43eccae6..59150e18 100644
--- a/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
@@ -5,7 +5,7 @@ import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
 import renderers.*
 
-class GroupWrappingTest: RenderingOnlyTestBase() {
+class GroupWrappingTest : HtmlRenderingOnlyTestBase() {
 
     @Test
     fun notWrapped() {
diff --git a/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
new file mode 100644
index 00000000..69025947
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
@@ -0,0 +1,78 @@
+package renderers.html
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.renderers.RootCreator
+import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
+import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
+import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProviderFactory
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.dokka.model.properties.PropertyContainer
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.testApi.context.MockContext
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+import org.jsoup.nodes.Node
+import org.jsoup.nodes.TextNode
+import renderers.RenderingOnlyTestBase
+import utils.TestOutputWriter
+
+abstract class HtmlRenderingOnlyTestBase : RenderingOnlyTestBase() {
+
+    val files = TestOutputWriter()
+    override val context = MockContext(
+        DokkaBase().outputWriter to { _ -> files },
+        DokkaBase().locationProviderFactory to ::DefaultLocationProviderFactory,
+        DokkaBase().htmlPreprocessors to { _ -> RootCreator },
+        DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
+        DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
+        testConfiguration = DokkaConfigurationImpl(
+            "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
+        )
+    )
+
+    protected val renderedContent: Element by lazy {
+        files.contents.getValue("test-page.html").let { Jsoup.parse(it) }.select("#content").single()
+    }
+
+    protected fun linesAfterContentTag() =
+        files.contents.getValue("test-page.html").lines()
+            .dropWhile { !it.contains("""<div id="content">""") }
+            .joinToString(separator = "") { it.trim() }
+}
+
+fun Element.match(vararg matchers: Any): Unit =
+    childNodes()
+        .filter { it !is TextNode || it.text().isNotBlank() }
+        .let { it.drop(it.size - matchers.size) }
+        .zip(matchers)
+        .forEach { (n, m) -> m.accepts(n) }
+
+open class Tag(val name: String, vararg val matchers: Any)
+class Div(vararg matchers: Any) : Tag("div", *matchers)
+class P(vararg matchers: Any) : Tag("p", *matchers)
+class Span(vararg matchers: Any) : Tag("span", *matchers)
+
+private fun Any.accepts(n: Node) {
+    when (this) {
+        is String -> assert(n is TextNode && n.text().trim() == this.trim()) { "\"$this\" expected but found: $n" }
+        is Tag -> {
+            assert(n is Element && n.tagName() == name) { "Tag $name expected but found: $n" }
+            if (n is Element && matchers.isNotEmpty()) n.match(*matchers)
+        }
+        else -> throw IllegalArgumentException("$this is not proper matcher")
+    }
+}
+
+
+internal object EmptyCommentConverter : CommentsToContentConverter {
+    override fun buildContent(
+        docTag: DocTag,
+        dci: DCI,
+        sourceSets: Set<DokkaConfiguration.DokkaSourceSet>,
+        styles: Set<Style>,
+        extras: PropertyContainer<ContentNode>
+    ): List<ContentNode> = emptyList()
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index ea1ea9ae..87c67842 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -5,12 +5,10 @@ import org.jetbrains.dokka.SourceRootImpl
 import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
-import renderers.Div
-import renderers.RenderingOnlyTestBase
 import renderers.TestPage
-import renderers.match
+import renderers.defaultSourceSet
 
-class SourceSetDependentHintTest : RenderingOnlyTestBase() {
+class SourceSetDependentHintTest : HtmlRenderingOnlyTestBase() {
 
     private val pl1 = defaultSourceSet.copy(
         "root",
diff --git a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
deleted file mode 100644
index a9be1cfd..00000000
--- a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package renderers.html
-
-import org.jetbrains.dokka.DokkaSourceSetID
-import org.jetbrains.dokka.DokkaSourceSetImpl
-import org.jetbrains.dokka.Platform
-
-internal val defaultSourceSet = DokkaSourceSetImpl(
-    moduleDisplayName = "DEFAULT",
-    displayName = "DEFAULT",
-    sourceSetID = DokkaSourceSetID("DEFAULT", "DEFAULT"),
-    classpath = emptyList(),
-    sourceRoots = emptyList(),
-    dependentSourceSets = emptySet(),
-    samples = emptyList(),
-    includes = emptyList(),
-    includeNonPublic = false,
-    includeRootPackage = false,
-    reportUndocumented = false,
-    skipEmptyPackages = true,
-    skipDeprecated = false,
-    jdkVersion = 8,
-    sourceLinks = emptyList(),
-    perPackageOptions = emptyList(),
-    externalDocumentationLinks = emptyList(),
-    languageVersion = null,
-    apiVersion = null,
-    noStdlibLink = false,
-    noJdkLink = false,
-    suppressedFiles = emptyList(),
-    analysisPlatform = Platform.DEFAULT
-)
diff --git a/plugins/gfm/build.gradle.kts b/plugins/gfm/build.gradle.kts
index ffa12cba..7bea1b97 100644
--- a/plugins/gfm/build.gradle.kts
+++ b/plugins/gfm/build.gradle.kts
@@ -9,4 +9,6 @@ publishing {
 
 dependencies {
     compileOnly(project(":plugins:base"))
+    testImplementation(project(":plugins:base"))
+    testImplementation(project(":plugins:base", configuration = "testUtils"))
 }
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index 32c0b7b7..7db06bb2 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -62,6 +62,11 @@ open class CommonmarkRenderer(
                 childrenCallback()
                 buildNewLine()
             }
+            node.hasStyle(TextStyle.Paragraph) -> {
+                buildParagraph()
+                childrenCallback()
+                buildParagraph()
+            }
             else -> childrenCallback()
         }
     }
@@ -74,9 +79,9 @@ open class CommonmarkRenderer(
     }
 
     override fun StringBuilder.buildLink(address: String, content: StringBuilder.() -> Unit) {
-        append("""<a href="$address">""")
+        append("[")
         content()
-        append("</a>")
+        append("]($address)")
     }
 
     override fun StringBuilder.buildList(
@@ -136,7 +141,7 @@ open class CommonmarkRenderer(
             buildContentNode(content, pageContext)
         } else {
             val distinct = sourceSets.map {
-                it to StringBuilder().apply { buildContentNode(content, pageContext, setOf(it)) }.toString()
+                it to buildString { buildContentNode(content, pageContext, setOf(it)) }
             }.groupBy(Pair<DokkaSourceSet, String>::second, Pair<DokkaSourceSet, String>::first)
 
             distinct.filter { it.key.isNotBlank() }.forEach { (text, platforms) ->
@@ -222,28 +227,61 @@ open class CommonmarkRenderer(
     }
 
     override fun buildPage(page: ContentPage, content: (StringBuilder, ContentPage) -> Unit): String =
-        StringBuilder().apply {
+        buildString {
             content(this, page)
-        }.toString()
+        }
 
     override fun buildError(node: ContentNode) {
         context.logger.warn("Markdown renderer has encountered problem. The unmatched node is $node")
     }
 
-    override fun StringBuilder.buildDivergentInstance(node: ContentDivergentInstance, pageContext: ContentPage) {
-        node.before?.let {
-            buildPlatformDependentItem(it, it.sourceSets, pageContext)
+    override fun StringBuilder.buildDivergent(node: ContentDivergentGroup, pageContext: ContentPage) {
+
+        val distinct =
+            node.groupDivergentInstances(pageContext, { instance, contentPage, sourceSet ->
+                instance.before?.let { before ->
+                    buildString { buildContentNode(before, pageContext, setOf(sourceSet)) }
+                } ?: ""
+            }, { instance, contentPage, sourceSet ->
+                instance.after?.let { after ->
+                    buildString { buildContentNode(after, pageContext, setOf(sourceSet)) }
+                } ?: ""
+            })
+
+        distinct.values.forEach { entry ->
+            val (instance, sourceSets) = entry.getInstanceAndSourceSets()
+
+            append(sourceSets.joinToString(prefix = "#### [", postfix = "]") { "${it.moduleName}/${it.sourceSetID}" })
             buildNewLine()
-        }
-        node.divergent.build(this, pageContext)
-        buildNewLine()
-        node.after?.let {
-            buildPlatformDependentItem(it, it.sourceSets, pageContext)
+            instance.before?.let {
+                append("##### Brief description")
+                buildNewLine()
+                buildContentNode(it, pageContext)
+                buildNewLine()
+            }
+
+            append("##### Content")
             buildNewLine()
+            entry.groupBy { buildString { buildContentNode(it.first.divergent, pageContext, setOf(it.second)) } }
+                .values.forEach { innerEntry ->
+                    val (innerInstance, innerSourceSets) = innerEntry.getInstanceAndSourceSets()
+                    if(sourceSets.size > 1) {
+                        append(innerSourceSets.joinToString(prefix = "###### [", postfix = "]") { "${it.moduleName}/${it.sourceSetID}" })
+                        buildNewLine()
+                    }
+                    innerInstance.divergent.build(this@buildDivergent, pageContext)
+                    buildNewLine()
+                }
+            instance.after?.let {
+                append("##### More info")
+                buildNewLine()
+                buildContentNode(it, pageContext)
+                buildNewLine()
+            }
         }
     }
 
-    private fun decorators(styles: Set<Style>) = StringBuilder().apply {
+    private fun decorators(styles: Set<Style>) = buildString {
         styles.forEach {
             when (it) {
                 TextStyle.Bold -> append("**")
@@ -253,7 +291,7 @@ open class CommonmarkRenderer(
                 else -> Unit
             }
         }
-    }.toString()
+    }
 
     private val PageNode.isNavigable: Boolean
         get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
@@ -280,6 +318,8 @@ open class CommonmarkRenderer(
     }
 
     private fun String.withEntersAsHtml(): String = replace("\n", "<br>")
+
+    private fun List<Pair<ContentDivergentInstance, DokkaSourceSet>>.getInstanceAndSourceSets() = this.let { Pair(it.first().first, it.map { it.second }.toSet()) }
 }
 
 class MarkdownLocationProviderFactory(val context: DokkaContext) : LocationProviderFactory {
diff --git a/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
new file mode 100644
index 00000000..13231c43
--- /dev/null
+++ b/plugins/gfm/src/test/kotlin/renderers/gfm/DivergentTest.kt
@@ -0,0 +1,375 @@
+package renderers.gfm
+
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.SourceRootImpl
+import org.jetbrains.dokka.gfm.CommonmarkRenderer
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.ContentDivergentGroup
+import org.junit.jupiter.api.Test
+import renderers.gfm.GfmRenderingOnlyTestBase
+import renderers.defaultSourceSet
+import renderers.TestPage
+
+class DivergentTest : GfmRenderingOnlyTestBase() {
+    private val js = defaultSourceSet.copy(
+        "root",
+        "JS",
+        "js",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val jvm = defaultSourceSet.copy(
+        "root",
+        "JVM",
+        "jvm",
+
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val native = defaultSourceSet.copy(
+        "root",
+        "NATIVE",
+        "native",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+
+    @Test
+    fun simpleWrappingCase() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/js]  \n##### Content  \na  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun noPlatformHintCase() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test"), implicitlySourceSetHinted = false) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/js]  \n##### Content  \na  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentBetweenSourceSets() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/js, root/jvm, root/native]  \n##### Content  \n###### [root/js]  \na  \n###### [root/jvm]  \nb  \n###### [root/native]  \nc  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentInOneSourceSet() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(js)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/js]  \n##### Content  \na  \nb  \nc  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSets() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native, root/js, root/jvm]  \n##### Content  \n###### [root/native]  \na  \n###### [root/js]  \nb  \n###### [root/jvm]  \nc  \n###### [root/js]  \nd  \n###### [root/native]  \ne  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSetsWithGrouping() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("a+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                    after {
+                        text("e+")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Content  \na  \n##### More info  \na+  \n#### [root/js]  \n##### Content  \nb  \nd  \n##### More info  \nbd+  \n#### [root/jvm]  \n##### Content  \nc  \n#### [root/native]  \n##### Content  \ne  \n##### More info  \ne+  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentSameBefore() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Brief description  \nab-  \n##### Content  \na  \nb  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentSameAfter() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Content  \na  \nb  \n##### More info  \nab+  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentGroupedByBeforeAndAfter() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("ab-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Brief description  \nab-  \n##### Content  \na  \nb  \n##### More info  \nab+  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentDifferentBeforeAndAfter() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    before {
+                        text("a-")
+                    }
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(native)) {
+                    before {
+                        text("b-")
+                    }
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("ab+")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Brief description  \na-  \n##### Content  \na  \n##### More info  \nab+  \n#### [root/native]  \n##### Brief description  \nb-  \n##### Content  \nb  \n##### More info  \nab+  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+
+    @Test
+    fun divergentInAndBetweenSourceSetsWithGroupingAncCommonParts() {
+        val page = TestPage {
+            divergentGroup(ContentDivergentGroup.GroupID("test")) {
+                instance(setOf(DRI("test", "Test")), setOf(native)) {
+                    divergent {
+                        text("a")
+                    }
+                    after {
+                        text("a+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(js)) {
+                    divergent {
+                        text("b")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test")), setOf(jvm)) {
+                    divergent {
+                        text("c")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test2")), setOf(js)) {
+                    divergent {
+                        text("d")
+                    }
+                    after {
+                        text("bd+")
+                    }
+                }
+                instance(setOf(DRI("test", "Test3")), setOf(native)) {
+                    divergent {
+                        text("e")
+                    }
+                    after {
+                        text("e+")
+                    }
+                }
+            }
+        }
+        val expect = "//[testPage](test-page.md)\n\n#### [root/native]  \n##### Content  \na  \n##### More info  \na+  \n#### [root/js, root/jvm]  \n##### Content  \n###### [root/js]  \nb  \n###### [root/jvm]  \nc  \n###### [root/js]  \nd  \n##### More info  \nbd+  \n#### [root/native]  \n##### Content  \ne  \n##### More info  \ne+  \n"
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == expect)
+    }
+}
\ No newline at end of file
diff --git a/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
new file mode 100644
index 00000000..3636bf26
--- /dev/null
+++ b/plugins/gfm/src/test/kotlin/renderers/gfm/GfmRenderingOnlyTestBase.kt
@@ -0,0 +1,32 @@
+package renderers.gfm
+
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.gfm.GfmPlugin
+import org.jetbrains.dokka.gfm.MarkdownLocationProviderFactory
+import org.jetbrains.dokka.testApi.context.MockContext
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.renderers.RootCreator
+import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
+import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
+import renderers.RenderingOnlyTestBase
+import utils.TestOutputWriter
+
+abstract class GfmRenderingOnlyTestBase : RenderingOnlyTestBase() {
+
+    val files = TestOutputWriter()
+    override val context = MockContext(
+        DokkaBase().outputWriter to { _ -> files },
+        DokkaBase().locationProviderFactory to ::MarkdownLocationProviderFactory,
+        DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
+        DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
+        GfmPlugin().gfmPreprocessors to { _ -> RootCreator },
+
+        testConfiguration = DokkaConfigurationImpl(
+            "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
+        )
+    )
+
+    protected val renderedContent: String by lazy {
+        files.contents.getValue("test-page.md")
+    }
+}
\ No newline at end of file
diff --git a/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
new file mode 100644
index 00000000..2e1dc83a
--- /dev/null
+++ b/plugins/gfm/src/test/kotlin/renderers/gfm/GroupWrappingTest.kt
@@ -0,0 +1,77 @@
+package renderers.gfm
+
+import org.jetbrains.dokka.gfm.CommonmarkRenderer
+import renderers.gfm.GfmRenderingOnlyTestBase
+import org.jetbrains.dokka.pages.TextStyle
+import org.junit.jupiter.api.Test
+import renderers.*
+
+class GroupWrappingTest : GfmRenderingOnlyTestBase() {
+
+    @Test
+    fun notWrapped() {
+        val page = TestPage {
+            group {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        CommonmarkRenderer(context).render(page)
+
+        assert(renderedContent == "//[testPage](test-page.md)\n\nabc")
+    }
+
+    @Test
+    fun paragraphWrapped() {
+        val page = TestPage {
+            group(styles = setOf(TextStyle.Paragraph)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        CommonmarkRenderer(context).render(page)
+
+        assert(renderedContent == "//[testPage](test-page.md)\n\n\n\nab\n\nc")
+    }
+
+    @Test
+    fun blockWrapped() {
+        val page = TestPage {
+            group(styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+            }
+            text("c")
+        }
+
+        CommonmarkRenderer(context).render(page)
+
+        assert(renderedContent == "//[testPage](test-page.md)\n\nab  \nc")
+    }
+
+    @Test
+    fun nested() {
+        val page = TestPage {
+            group(styles = setOf(TextStyle.Block)) {
+                text("a")
+                group(styles = setOf(TextStyle.Block)) {
+                    group(styles = setOf(TextStyle.Block)) {
+                        text("b")
+                        text("c")
+                    }
+                }
+                text("d")
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+
+//        renderedContent.match(Div("a", Div(Div("bc")), "d"))
+        assert(renderedContent == "//[testPage](test-page.md)\n\nabc  \n  \nd  \n")
+    }
+
+}
diff --git a/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt b/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
new file mode 100644
index 00000000..64664d4a
--- /dev/null
+++ b/plugins/gfm/src/test/kotlin/renderers/gfm/SourceSetDependentHintTest.kt
@@ -0,0 +1,137 @@
+package renderers.gfm
+
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.SourceRootImpl
+import org.jetbrains.dokka.gfm.CommonmarkRenderer
+import renderers.gfm.GfmRenderingOnlyTestBase
+import org.jetbrains.dokka.pages.TextStyle
+import org.junit.jupiter.api.Test
+import renderers.TestPage
+import renderers.defaultSourceSet
+
+class SourceSetDependentHintTest : GfmRenderingOnlyTestBase() {
+
+    private val pl1 = defaultSourceSet.copy(
+        "root",
+        "pl1",
+        "pl1",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl2 = defaultSourceSet.copy(
+        "root",
+        "pl2",
+        "pl2",
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl3 = defaultSourceSet.copy(
+        "root",
+        "pl3",
+        "pl3",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+
+    @Test
+    fun platformIndependentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+                text("c")
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1, root/pl2, root/pl3] abc  \n ")
+    }
+
+    @Test
+    fun completelyDivergentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+                text("c", sourceSets = setOf(pl3))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1] a  \n  [root/pl2] b  \n  [root/pl3] c  \n ")
+    }
+
+    @Test
+    fun overlappingCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl1, pl2))
+                text("c", sourceSets = setOf(pl2))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1] ab  \n  [root/pl2] bc  \n ")
+    }
+
+    @Test
+    fun caseThatCanBeSimplified() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1, pl2))
+                text("b", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1, root/pl2] ab  \n ")
+    }
+
+    @Test
+    fun caseWithGroupBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                group(styles = setOf(TextStyle.Block)) {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1] ab  \n  \n  [root/pl2] a  \nb  \n ")
+    }
+
+    @Test
+    fun caseWithGroupNotBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2)) {
+                group {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1, root/pl2] ab ")
+    }
+
+    @Test
+    fun partiallyUnifiedCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("a", sourceSets = setOf(pl2))
+                text("b", sourceSets = setOf(pl3))
+            }
+        }
+
+        CommonmarkRenderer(context).render(page)
+        assert(renderedContent == "//[testPage](test-page.md)\n\n [root/pl1, root/pl2] a  \n  [root/pl3] b  \n ")
+    }
+}
\ No newline at end of file
-- 
cgit 


From 2ab810271d2b2dba7448a8cb2b53f0031e6ef40e Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Fri, 3 Jul 2020 16:52:56 +0200
Subject: Add tests for signatures rendering

---
 .../test/kotlin/renderers/html/DivergentTest.kt    |   3 +
 .../kotlin/renderers/html/GroupWrappingTest.kt     |   3 +
 .../renderers/html/HtmlRenderingOnlyTestBase.kt    |   5 -
 .../renderers/html/SourceSetDependentHintTest.kt   |   3 +
 .../kotlin/signatures/DivergentSignatureTest.kt    | 122 +++++++
 .../src/test/kotlin/signatures/SignatureTest.kt    | 379 +++++++++++++++++++++
 plugins/base/src/test/kotlin/utils/JsoupUtils.kt   |  29 ++
 plugins/base/src/test/kotlin/utils/TestUtils.kt    |   1 +
 .../jvmMain/kotlin/example/Clock.kt                |   3 +
 9 files changed, 543 insertions(+), 5 deletions(-)
 create mode 100644 plugins/base/src/test/kotlin/signatures/DivergentSignatureTest.kt
 create mode 100644 plugins/base/src/test/kotlin/signatures/SignatureTest.kt
 create mode 100644 plugins/base/src/test/kotlin/utils/JsoupUtils.kt

(limited to 'plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt')

diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index f5565b48..54d55721 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -7,6 +7,9 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.ContentDivergentGroup
 import org.junit.jupiter.api.Test
 import renderers.*
+import utils.Div
+import utils.Span
+import utils.match
 
 class DivergentTest : HtmlRenderingOnlyTestBase() {
     private val js = defaultSourceSet.copy(
diff --git a/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt b/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
index 59150e18..c0c03998 100644
--- a/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/GroupWrappingTest.kt
@@ -4,6 +4,9 @@ import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
 import renderers.*
+import utils.Div
+import utils.P
+import utils.match
 
 class GroupWrappingTest : HtmlRenderingOnlyTestBase() {
 
diff --git a/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
index f93eccb5..5ac5aafa 100644
--- a/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/HtmlRenderingOnlyTestBase.kt
@@ -1,16 +1,11 @@
 package renderers.html
 
-import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProviderFactory
-import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
-import org.jetbrains.dokka.model.doc.DocTag
-import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.testApi.context.MockContext
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Element
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index 87c67842..cf7f47e6 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -7,6 +7,9 @@ import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
 import renderers.TestPage
 import renderers.defaultSourceSet
+import renderers.RenderingOnlyTestBase
+import utils.Div
+import utils.match
 
 class SourceSetDependentHintTest : HtmlRenderingOnlyTestBase() {
 
diff --git a/plugins/base/src/test/kotlin/signatures/DivergentSignatureTest.kt b/plugins/base/src/test/kotlin/signatures/DivergentSignatureTest.kt
new file mode 100644
index 00000000..6ed17110
--- /dev/null
+++ b/plugins/base/src/test/kotlin/signatures/DivergentSignatureTest.kt
@@ -0,0 +1,122 @@
+package signatures
+
+import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
+import org.jsoup.Jsoup
+import org.junit.jupiter.api.Test
+import utils.*
+import java.nio.file.Paths
+
+class DivergentSignatureTest : AbstractCoreTest() {
+
+    @Test
+    fun `three divergent signatures for class`() {
+
+        val testDataDir = getTestDataDir("multiplatform/basicMultiplatformTest").toAbsolutePath()
+
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "js"
+                    sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "js"
+                }
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "jvm"
+                    sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "jvm"
+                }
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "common"
+                    sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "jvm"
+                }
+            }
+        }
+
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testFromData(
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                assert(writerPlugin.writer.contents.getValue("example/example/-clock/index.html")
+                    .let { Jsoup.parse(it) }.select("#content").single()
+                    .select("div.sourceset-depenent-content")
+                    .fold(0) { acc, elem ->
+                        acc + if (elem.child(0).html().contains(
+                                Regex("Documentation for (expected|actual) class Clock .*")
+                            )
+                        ) 1 else 0
+                    } == 3
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `three divergent signatures for class`() {
+
+        val testDataDir = getTestDataDir("multiplatform/basicMultiplatformTest").toAbsolutePath()
+
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "js"
+                    sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "js"
+                }
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "jvm"
+                    sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "jvm"
+                }
+                pass {
+                    moduleName = "example"
+                    analysisPlatform = "common"
+                    sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
+                        Paths.get("$testDataDir/$it/kotlin").toString()
+                    }
+                    sourceSetID = "jvm"
+                }
+            }
+        }
+
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testFromData(
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                assert(writerPlugin.writer.contents.getValue("example/example/-clock/index.html")
+                    .let { Jsoup.parse(it) }.select("#content").single()
+                    .select("div.sourceset-depenent-content")
+                    .fold(0) { acc, elem ->
+                        acc + if (elem.child(0).html().contains(
+                                Regex("Documentation for (expected|actual) class Clock .*")
+                            )
+                        ) 1 else 0
+                    } == 3
+                )
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/signatures/SignatureTest.kt b/plugins/base/src/test/kotlin/signatures/SignatureTest.kt
new file mode 100644
index 00000000..fbdebfa2
--- /dev/null
+++ b/plugins/base/src/test/kotlin/signatures/SignatureTest.kt
@@ -0,0 +1,379 @@
+package signatures
+
+import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
+import org.jsoup.Jsoup
+import org.junit.jupiter.api.Test
+import utils.*
+
+class SignatureTest : AbstractCoreTest() {
+
+    fun source(signature: String) =
+        """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | $signature
+            """.trimIndent()
+
+    @Test
+    fun `fun`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("fun simpleFun(): String = \"Celebrimbor\"")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "fun ", A("simpleFun"), "(): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `open fun`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("open fun simpleFun(): String = \"Celebrimbor\"")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "open fun ", A("simpleFun"), "(): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `open suspend fun`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("open suspend fun simpleFun(): String = \"Celebrimbor\"")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "open suspend fun ", A("simpleFun"), "(): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with params`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("fun simpleFun(a: Int, b: Boolean, c: Any): String = \"Celebrimbor\"")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "fun ", A("simpleFun"), "(a: ", A("Int"),
+                    ", b: ", A("Boolean"), ", c: ", A("Any"),
+                    "): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with function param`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("fun simpleFun(a: (Int) -> String): String = \"Celebrimbor\"")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "fun ", A("simpleFun"), "(a: (", A("Int"),
+                    ") -> ", A("String"), "): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with generic param`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("fun <T> simpleFun(): T = \"Celebrimbor\" as T")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "fun <", A("T"), " : ", A("Any"), "?> ", A("simpleFun"), "(): ",
+                    A("T"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with generic bounded param`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("fun <T : String> simpleFun(): T = \"Celebrimbor\" as T")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "fun <", A("T"), " : ", A("String"), "> ", A("simpleFun"),
+                    "(): ", A("T"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with keywords, params and generic bound`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = source("inline suspend fun <T : String> simpleFun(a: Int, b: String): T = \"Celebrimbor\" as T")
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    "inline suspend fun <", A("T"), " : ", A("String"), "> ", A("simpleFun"),
+                    "(a: ", A("Int"), ", b: ", A("String"), "): ", A("T"), Span()
+                )
+            }
+        }
+    }
+
+
+    @Test
+    fun `fun with annotation`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | @MustBeDocumented()
+            | @Target(AnnotationTarget.FUNCTION)
+            | annotation class Marking
+            |
+            | @Marking()
+            | fun simpleFun(): String = "Celebrimbor"
+            """.trimIndent()
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    Div(
+                        Div("@", A("Marking"), "()")
+                    ),
+                    "fun ", A("simpleFun"),
+                    "(): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with two annotations`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | @MustBeDocumented()
+            | @Target(AnnotationTarget.FUNCTION)
+            | annotation class Marking(val msg: String)
+            |
+            | @MustBeDocumented()
+            | @Target(AnnotationTarget.FUNCTION)
+            | annotation class Marking2(val int: Int)
+            |
+            | @Marking("Nenya")
+            | @Marking2(1)
+            | fun simpleFun(): String = "Celebrimbor"
+            """.trimIndent()
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html")
+                    .match(
+                        Div(
+                            Div("@", A("Marking"), "(", Span("msg = ", Span("\"Nenya\"")), Wbr, ")"),
+                            Div("@", A("Marking2"), "(", Span("int = ", Span("1")), Wbr, ")")
+                        ),
+                        "fun ", A("simpleFun"),
+                        "(): ", A("String"), Span()
+                    )
+            }
+        }
+    }
+
+    @Test
+    fun `fun with annotation with array`() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/test/Test.kt")
+                }
+            }
+        }
+
+        val source = """
+            |/src/main/kotlin/test/Test.kt
+            |package example
+            |
+            | @MustBeDocumented()
+            | @Target(AnnotationTarget.FUNCTION)
+            | annotation class Marking(val msg: Array<String>)
+            |
+            | @Marking(["Nenya", "Vilya", "Narya"])
+            | @Marking2(1)
+            | fun simpleFun(): String = "Celebrimbor"
+            """.trimIndent()
+        val writerPlugin = TestOutputWriterPlugin()
+
+        testInline(
+            source,
+            configuration,
+            pluginOverrides = listOf(writerPlugin)
+        ) {
+            renderingStage = { _, _ ->
+                writerPlugin.writer.renderedContent("root/example/simple-fun.html").match(
+                    Div(
+                        Div("@", A("Marking"), "(", Span("msg = [",
+                            Span(Span("\"Nenya\""), ", "), Wbr,
+                            Span(Span("\"Vilya\""), ", "), Wbr,
+                            Span(Span("\"Narya\"")), Wbr, "]"), Wbr, ")"
+                        )
+                    ),
+                    "fun ", A("simpleFun"),
+                    "(): ", A("String"), Span()
+                )
+            }
+        }
+    }
+
+    private fun TestOutputWriter.renderedContent(path: String = "root/example.html") =
+        contents.getValue(path).let { Jsoup.parse(it) }.select("#content")
+            .single().select("div.symbol div.monospace").first()
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/utils/JsoupUtils.kt b/plugins/base/src/test/kotlin/utils/JsoupUtils.kt
new file mode 100644
index 00000000..e8c7838d
--- /dev/null
+++ b/plugins/base/src/test/kotlin/utils/JsoupUtils.kt
@@ -0,0 +1,29 @@
+package utils
+
+import org.jsoup.nodes.Element
+import org.jsoup.nodes.Node
+import org.jsoup.nodes.TextNode
+
+fun Element.match(vararg matchers: Any): Unit =
+    childNodes()
+        .filter { it !is TextNode || it.text().isNotBlank() }
+        .let { it.drop(it.size - matchers.size) }
+        .zip(matchers)
+        .forEach { (n, m) -> m.accepts(n) }
+
+open class Tag(val name: String, vararg val matchers: Any)
+class Div(vararg matchers: Any) : Tag("div", *matchers)
+class P(vararg matchers: Any) : Tag("p", *matchers)
+class Span(vararg matchers: Any) : Tag("span", *matchers)
+class A(vararg matchers: Any) : Tag("a", *matchers)
+object Wbr : Tag("wbr")
+private fun Any.accepts(n: Node) {
+    when (this) {
+        is String -> assert(n is TextNode && n.text().trim() == this.trim()) { "\"$this\" expected but found: $n" }
+        is Tag -> {
+            assert(n is Element && n.tagName() == name) { "Tag $name expected but found: $n" }
+            if (n is Element && matchers.isNotEmpty()) n.match(*matchers)
+        }
+        else -> throw IllegalArgumentException("$this is not proper matcher")
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/utils/TestUtils.kt b/plugins/base/src/test/kotlin/utils/TestUtils.kt
index 44c23e96..bd0e1fe2 100644
--- a/plugins/base/src/test/kotlin/utils/TestUtils.kt
+++ b/plugins/base/src/test/kotlin/utils/TestUtils.kt
@@ -2,6 +2,7 @@ package utils
 
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.model.doc.P
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Assertions.assertTrue
 import kotlin.collections.orEmpty
diff --git a/plugins/base/src/test/resources/multiplatform/basicMultiplatformTest/jvmMain/kotlin/example/Clock.kt b/plugins/base/src/test/resources/multiplatform/basicMultiplatformTest/jvmMain/kotlin/example/Clock.kt
index 9ec01fb6..4d27d0a3 100644
--- a/plugins/base/src/test/resources/multiplatform/basicMultiplatformTest/jvmMain/kotlin/example/Clock.kt
+++ b/plugins/base/src/test/resources/multiplatform/basicMultiplatformTest/jvmMain/kotlin/example/Clock.kt
@@ -2,6 +2,9 @@ package example
 
 import greeteer.Greeter
 
+/**
+ * Documentation for actual class Clock in JVM
+ */
 actual open class Clock {
     actual fun getTime(): String = System.currentTimeMillis().toString()
     actual fun getTimesInMillis(): String = System.currentTimeMillis().toString()
-- 
cgit