From 0073c4c547dafaae5d465d4c410a52fd7fdc818d Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 24 Jan 2020 14:41:33 +0100
Subject: Cherry-pick 'analysis_rewrite_1.3.61'

---
 .idea/codeStyles/codeStyleConfig.xml | 1 +
 1 file changed, 1 insertion(+)

(limited to '.idea/codeStyles')

diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
index 79ee123c..6e6eec11 100644
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
   </state>
 </component>
\ No newline at end of file
-- 
cgit 


From 612e8c2f6f1b52f19c6ae51aa3d5655dfb43ba0c Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Thu, 23 Jan 2020 11:10:37 +0100
Subject: formatting

---
 .idea/codeStyles/Project.xml                       |  18 +---
 .idea/compiler.xml                                 |   4 +
 .idea/jarRepositories.xml                          |   5 +
 core/src/main/kotlin/model/Documentable.kt         | 120 +++++++++++++++++----
 core/src/main/kotlin/pages/PageBuilder.kt          |  64 +++++++++--
 core/src/main/kotlin/pages/PageContentBuilder.kt   |  17 ++-
 core/src/main/kotlin/pages/PageNodes.kt            |  10 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |   4 +-
 .../DefaultDescriptorToDocumentationTranslator.kt  |  61 ++++++++---
 .../DefaultDocumentationNodeMerger.kt              |  59 ++++++----
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |   2 +-
 11 files changed, 269 insertions(+), 95 deletions(-)

(limited to '.idea/codeStyles')

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index ba49a93e..1bec35e5 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,24 +1,10 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
-      <option name="CONTINUATION_INDENT_IN_PARAMETER_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_ARGUMENT_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_EXPRESSION_BODIES" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_CHAINED_CALLS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_SUPERTYPE_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_IF_CONDITIONS" value="false" />
-      <option name="WRAP_EXPRESSION_BODY_FUNCTIONS" value="1" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <codeStyleSettings language="kotlin">
-      <option name="CALL_PARAMETERS_WRAP" value="5" />
-      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_WRAP" value="5" />
-      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="EXTENDS_LIST_WRAP" value="1" />
-      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
-      <option name="ASSIGNMENT_WRAP" value="1" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </codeStyleSettings>
   </code_scheme>
 </component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index feb731d8..797b1d01 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -32,6 +32,8 @@
       <module name="dokka.coreDependencies.test" target="1.8" />
       <module name="dokka.integration-tests.gradle-integration-tests.main" target="1.8" />
       <module name="dokka.integration-tests.gradle-integration-tests.test" target="1.8" />
+      <module name="dokka.integration-tests.main" target="1.8" />
+      <module name="dokka.integration-tests.test" target="1.8" />
       <module name="dokka.integration.main" target="1.8" />
       <module name="dokka.integration.test" target="1.8" />
       <module name="dokka.plugins.javadoc8.main" target="1.8" />
@@ -56,8 +58,10 @@
       <module name="dokka.runners.gradle-integration-tests.test" target="1.8" />
       <module name="dokka.runners.gradle-plugin.main" target="1.8" />
       <module name="dokka.runners.gradle-plugin.test" target="1.8" />
+      <module name="dokka.runners.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.test" target="1.8" />
+      <module name="dokka.runners.test" target="1.8" />
       <module name="dokka.testApi.main" target="1.8" />
       <module name="dokka.testApi.test" target="1.8" />
       <module name="fatjar_main" target="1.8" />
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index b5925b37..915691dd 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -86,5 +86,10 @@
       <option name="name" value="maven6" />
       <option name="url" value="https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/1.3.61/maven" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://dl.bintray.com/jetbrains/markdown/" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 7add2c3f..86ba24b7 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,9 +1,10 @@
 package org.jetbrains.dokka.model
 
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.transformers.descriptors.KotlinClassKindTypes
+import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
 
 class Module(override val name: String, val packages: List<Package>) : Documentable() {
     override val dri: DRI = DRI.topLevel
@@ -15,7 +16,7 @@ class Package(
     override val dri: DRI,
     override val functions: List<Function>,
     override val properties: List<Property>,
-    override val classes: List<Class>,
+    override val classlikes: List<Classlike>,
     override val extra: MutableSet<Extra> = mutableSetOf()
 ) : ScopeNode() {
     override val name = dri.packageName.orEmpty()
@@ -24,16 +25,79 @@ class Package(
 class Class(
     override val dri: DRI,
     override val name: String,
-    val kind: ClassKind,
+    override val kind: ClassKind,
     val constructors: List<Function>,
     override val functions: List<Function>,
     override val properties: List<Property>,
-    override val classes: List<Class>,
+    override val classlikes: List<Classlike>,
     override val expected: ClassPlatformInfo?,
     override val actual: List<ClassPlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode() {
-    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+) : Classlike(
+    name = name,
+    dri = dri,
+    kind = kind,
+    functions = functions,
+    properties = properties,
+    classlikes = classlikes,
+    expected = expected,
+    actual = actual,
+    extra = extra
+)
+
+class Enum(
+    override val dri: DRI,
+    override val name: String,
+    val entries: List<EnumEntry>,
+    val constructors: List<Function>,
+    override val functions: List<Function> = emptyList(),
+    override val properties: List<Property> = emptyList(),
+    override val classlikes: List<Classlike> = emptyList(),
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : Classlike(dri = dri, name = name, kind = KotlinClassKindTypes.ENUM_CLASS, actual = actual) {
+    constructor(c: Classlike, entries: List<EnumEntry>, ctors: List<Function>) : this(
+        dri = c.dri,
+        name = c.name,
+        entries = entries,
+        constructors = ctors,
+        functions = c.functions,
+        properties = c.properties,
+        classlikes = c.classlikes,
+        expected = c.expected,
+        actual = c.actual,
+        extra = c.extra
+    )
+
+    override val children: List<Documentable>
+        get() = entries
+}
+
+class EnumEntry(
+    override val dri: DRI,
+    override val name: String,
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : Classlike(
+    dri = dri,
+    name = name,
+    actual = actual,
+    expected = expected,
+    extra = extra,
+    kind = KotlinClassKindTypes.ENUM_ENTRY
+) {
+    constructor(c: Classlike) : this(
+        dri = c.dri,
+        name = c.name,
+        actual = c.actual,
+        expected = c.expected,
+        extra = c.extra
+    )
+
+    override val children: List<Parameter>
+        get() = emptyList()
 }
 
 class Function(
@@ -83,7 +147,8 @@ interface PlatformInfo {
 
 class BasePlatformInfo(
     override val documentationNode: DocumentationNode,
-    override val platformData: List<PlatformData>) : PlatformInfo {
+    override val platformData: List<PlatformData>
+) : PlatformInfo {
 
     override fun equals(other: Any?): Boolean =
         other is PlatformInfo && documentationNode == other.documentationNode
@@ -94,7 +159,8 @@ class BasePlatformInfo(
 
 class ClassPlatformInfo(
     val info: PlatformInfo,
-    val inherited: List<DRI>) : PlatformInfo by info
+    val inherited: List<DRI>
+) : PlatformInfo by info
 
 abstract class Documentable {
     open val expected: PlatformInfo? = null
@@ -114,27 +180,45 @@ abstract class Documentable {
 
     override fun hashCode() = dri.hashCode()
 
+
+    val commentsData: List<DocumentationNode>
+        get() = platformInfo.map { it.documentationNode }
+
     val briefDocTagString: String
         get() =
             platformInfo
-            .firstOrNull()
-            ?.documentationNode
-            ?.children
-            ?.firstOrNull()
-            ?.root
-            ?.docTagSummary()
-            ?.shorten(40) ?: ""
+                .firstOrNull()
+                ?.documentationNode
+                ?.children
+                ?.firstOrNull()
+                ?.root
+                ?.docTagSummary()
+                ?.shorten(40) ?: ""
 
     open val extra: MutableSet<Extra> = mutableSetOf()
 }
 
+abstract class Classlike(
+    override val dri: DRI,
+    override val name: String,
+    open val kind: ClassKind,
+    override val functions: List<Function> = emptyList(),
+    override val properties: List<Property> = emptyList(),
+    override val classlikes: List<Classlike> = emptyList(),
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+}
+
 abstract class ScopeNode : Documentable() {
     abstract val functions: List<Function>
     abstract val properties: List<Property>
-    abstract val classes: List<Class>
+    abstract val classlikes: List<Classlike>
 
     override val children: List<Documentable>
-        get() = functions + properties + classes
+        get() = functions + properties + classlikes
 }
 
 abstract class CallableNode : Documentable() {
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
index e8930fae..003cc815 100644
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ b/core/src/main/kotlin/pages/PageBuilder.kt
@@ -1,8 +1,9 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.model.doc.TagWrapper
 import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
 import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.doc.TagWrapper
 
 class DefaultPageBuilder(
     override val rootContentGroup: RootContentBuilder
@@ -13,14 +14,21 @@ class DefaultPageBuilder(
 
     override fun pageForPackage(p: Package) =
         PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
-            p.classes.map { pageForClass(it) } +
+            p.classlikes.map { pageForClasslike(it) } +
                     p.functions.map { pageForMember(it) })
 
-    override fun pageForClass(c: Class): ClassPageNode =
-        ClassPageNode(c.name, contentForClass(c), setOf(c.dri), c,
-            c.constructors.map { pageForMember(it) } +
-                    c.classes.map { pageForClass(it) } +
+    override fun pageForClasslike(c: Classlike): ClasslikePageNode {
+        val constructors = when (c) {
+            is Class -> c.constructors
+            is Enum -> c.constructors
+            else -> emptyList()
+        }
+
+        return ClasslikePageNode(c.name, contentForClasslike(c), setOf(c.dri), c,
+            constructors.map { pageForMember(it) } +
+                    c.classlikes.map { pageForClasslike(it) } +
                     c.functions.map { pageForMember(it) })
+    }
 
     override fun pageForMember(m: CallableNode): MemberPageNode =
         when (m) {
@@ -43,7 +51,7 @@ class DefaultPageBuilder(
 
     private fun contentForPackage(p: Package) = group(p) {
         header(1) { text("Package ${p.name}") }
-        block("Types", 2, ContentKind.Properties, p.classes, p.platformData) {
+        block("Types", 2, ContentKind.Properties, p.classlikes, p.platformData) {
             link(it.name, it.dri)
             text(it.briefDocTagString)
         }
@@ -54,6 +62,12 @@ class DefaultPageBuilder(
         }
     }
 
+    private fun contentForClasslike(c: Classlike): ContentGroup = when (c) {
+        is Class -> contentForClass(c)
+        is Enum -> contentForEnum(c)
+        else -> throw IllegalStateException("$c should not be present here")
+    }
+
     private fun contentForClass(c: Class) = group(c) {
         header(1) { text(c.name) }
         c.inherited.takeIf { it.isNotEmpty() }?.let {
@@ -69,7 +83,32 @@ class DefaultPageBuilder(
                 comment(it.root)
                 text("\n")
             }
+
+            block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
+                link(it.name, it.dri)
+                signature(it)
+                text(it.briefDocTagString)
+            }
+            block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
+                link(it.name, it.dri)
+                text(it.briefDocTagString)
+            }
+        }
+    }
+
+    fun contentForEnum(c: Enum): ContentGroup = group(c) {
+        header(1) { text("enum ${c.name}") }
+
+        block("Entries", 2, ContentKind.Properties, c.entries, c.platformData) { entry ->
+            link(entry.name, entry.dri)
+            contentForComments(entry)
+        }
+
+        c.inherited.takeIf { it.isNotEmpty() }?.let {
+            header(2) { text("SuperInterfaces") }
+            linkTable(it)
         }
+        contentForComments(c)
         block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
             link(it.name, it.dri)
             signature(it)
@@ -86,6 +125,15 @@ class DefaultPageBuilder(
         }
     }
 
+    private fun PageContentBuilder.contentForComments(d: Documentable) =
+        d.commentsData.forEach {
+            it.children.forEach {
+                header(3) { text(it.toHeaderString()) }
+                comment(it.root)
+                text("\n")
+            }
+        }
+
     private fun contentForFunction(f: Function) = group(f) {
         header(1) { text(f.name) }
         signature(f)
@@ -115,5 +163,5 @@ interface PageBuilder {
     fun pageForModule(m: Module): ModulePageNode
     fun pageForPackage(p: Package): PackagePageNode
     fun pageForMember(m: CallableNode): MemberPageNode
-    fun pageForClass(c: Class): ClassPageNode
+    fun pageForClasslike(c: Classlike): ClasslikePageNode
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index efe23b5a..d5ffe27a 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.model.doc.DocTag
-import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.Parameter
 import org.jetbrains.dokka.model.TypeWrapper
-import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 class DefaultPageContentBuilder(
     private val dri: Set<DRI>,
@@ -169,10 +169,9 @@ private fun PageContentBuilder.type(t: TypeWrapper) {
     else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
         text(t.toString())
     else (this as? DefaultPageContentBuilder)?.let {
-            logger.error("type $t cannot be resolved")
-            text("???")
-        }
-
+        logger.error("type $t cannot be resolved")
+        text("???")
+    }
     list(t.arguments, prefix = "<", suffix = ">") {
         type(it)
     }
@@ -199,8 +198,8 @@ interface PageContentBuilder {
     fun header(level: Int, block: PageContentBuilderFunction)
     fun <T> list(
         elements: List<T>,
-        prefix: String =  "",
-        suffix: String =  "",
+        prefix: String = "",
+        suffix: String = "",
         separator: String = ",",
         operation: PageContentBuilder.(T) -> Unit
     )
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 73d63cd7..6b67a734 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -47,7 +47,7 @@ abstract class RootPageNode: PageNode {
 
     fun transformContentPagesTree(operation: (ContentPage) -> ContentPage) = transformPageNodeTree {
         if (it is ContentPage) operation(it) else it
-    } as RootPageNode
+    }
 
     private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
         operation(this).let { newNode ->
@@ -105,7 +105,7 @@ class PackagePageNode(
         else PackagePageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
-class ClassPageNode(
+class ClasslikePageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: Set<DRI>,
@@ -113,7 +113,7 @@ class ClassPageNode(
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
 ) : ContentPage {
-    override fun modified(name: String, children: List<PageNode>): ClassPageNode =
+    override fun modified(name: String, children: List<PageNode>): ClasslikePageNode =
         modified(name = name, content = this.content, children = children)
 
     override fun modified(
@@ -121,9 +121,9 @@ class ClassPageNode(
         content: ContentNode,
         embeddedResources: List<String>,
         children: List<PageNode>
-    ): ClassPageNode =
+    ): ClasslikePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else ClassPageNode(name, content, dri, documentable, children, embeddedResources)
+        else ClasslikePageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
 class MemberPageNode(
diff --git a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 27197ce6..47f5d066 100644
--- a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -145,7 +145,7 @@ open class HtmlRenderer(
         super.renderPage(page)
         if (page is ContentPage) {
             pageList.add(
-                """{ "name": "${page.name}", ${if (page is ClassPageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
+                """{ "name": "${page.name}", ${if (page is ClasslikePageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
                     page
                 )}" }"""
             )
@@ -205,7 +205,7 @@ fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value
 
 private fun PageNode.pageKind() = when (this) {
     is PackagePageNode -> "package"
-    is ClassPageNode -> "class"
+    is ClasslikePageNode -> "class"
     is MemberPageNode -> when (this.documentable) {
         is Function -> "function"
         else -> "other"
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
index 54762303..651bd223 100644
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -1,15 +1,17 @@
 package org.jetbrains.dokka.transformers.descriptors
 
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.ClassKind
-import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.withClass
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
+import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.Property
+import org.jetbrains.dokka.model.ClassKind
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.parsers.MarkdownParser
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
@@ -20,10 +22,9 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.dokka.parsers.MarkdownParser
 import kotlin.reflect.KClass
 
-object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTranslator {
+object DefaultDescriptorToDocumentationTranslator : DescriptorToDocumentationTranslator {
     override fun invoke(
         moduleName: String,
         packageFragments: Iterable<PackageFragmentDescriptor>,
@@ -42,6 +43,8 @@ internal data class DRIWithPlatformInfo(
     val actual: List<PlatformInfo>
 )
 
+private fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, null, emptyList())
+
 internal class DokkaDescriptorVisitor(
     private val platformData: PlatformData,
     private val resolutionFacade: DokkaResolutionFacade
@@ -54,18 +57,42 @@ internal class DokkaDescriptorVisitor(
         descriptor: PackageFragmentDescriptor,
         parent: DRIWithPlatformInfo
     ): Package {
-        val driWithPlatform = DRIWithPlatformInfo(DRI(packageName = descriptor.fqName.asString()), null, emptyList())
+        val driWithPlatform = DRI(packageName = descriptor.fqName.asString()).withEmptyInfo()
         val scope = descriptor.getMemberScope()
         return Package(
             dri = driWithPlatform.dri,
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
-            classes = scope.classes(driWithPlatform)
+            classlikes = scope.classlikes(driWithPlatform)
+        )
+    }
+
+    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Classlike = when (descriptor.kind) {
+        org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS -> enumDescriptor(descriptor, parent)
+        else -> classDescriptor(descriptor, parent)
+    }
+
+    fun enumDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Enum {
+        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
+        val scope = descriptor.getMemberScope(emptyList())
+        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
+
+        return Enum(
+            dri = driWithPlatform.dri,
+            name = descriptor.name.asString(),
+            entries = scope.classlikes(driWithPlatform).filter { it.kind == KotlinClassKindTypes.ENUM_ENTRY }.map { EnumEntry(it) },
+            constructors = descriptor.constructors.map { visitConstructorDescriptor(it, driWithPlatform) },
+            functions = scope.functions(driWithPlatform),
+            properties = scope.properties(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform),
+            expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
+            actual = listOfNotNull(descriptorData),
+            extra = mutableSetOf() // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
         )
     }
 
-    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
-        val driWithPlatform = DRIWithPlatformInfo(parent.dri.withClass(descriptor.name.asString()), null, emptyList())
+    fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
+        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.getMemberScope(emptyList())
         val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
         val expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData()
@@ -87,7 +114,7 @@ internal class DokkaDescriptorVisitor(
             ) },
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
-            classes = scope.classes(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform),
             expected = expected,
             actual = actual,
             extra = mutableSetOf() // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
@@ -193,7 +220,7 @@ internal class DokkaDescriptorVisitor(
             .filterIsInstance<PropertyDescriptor>()
             .map { visitPropertyDescriptor(it, parent) }
 
-    private fun MemberScope.classes(parent: DRIWithPlatformInfo): List<Class> =
+    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<Classlike> =
         getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
             .filterIsInstance<ClassDescriptor>()
             .map { visitClassDescriptor(it, parent) }
@@ -242,10 +269,12 @@ class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
     override val constructorFqName = fqNameSafe?.asString()
     override val constructorNamePathSegments: List<String> =
         fqNameSafe?.pathSegments()?.map { it.asString() } ?: emptyList()
-    override val arguments: List<KotlinTypeWrapper> by lazy { kotlinType.arguments.map {
-        KotlinTypeWrapper(
-            it.type
-        )
-    } }
+    override val arguments: List<KotlinTypeWrapper> by lazy {
+        kotlinType.arguments.map {
+            KotlinTypeWrapper(
+                it.type
+            )
+        }
+    }
     override val dri: DRI? by lazy { declarationDescriptor?.let { DRI.from(it) } }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
index 86348206..ec67ea88 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka.transformers.documentation
 
 import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.plugability.DokkaContext
 
@@ -18,9 +19,9 @@ internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
     }
 }
 
-private fun <T: Documentable> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
+private fun <T : Documentable> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
     elements.groupingBy { it.dri }
-        .reduce { _, left, right -> reducer(left, right)}
+        .reduce { _, left, right -> reducer(left, right) }
         .values.toList()
 
 fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
@@ -33,17 +34,17 @@ fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
     (inherited + (other?.inherited ?: emptyList())).distinct()
 )
 
-fun List<ClassPlatformInfo>.mergeClassPlatformInfo() : List<ClassPlatformInfo> =
-    groupingBy { it.documentationNode.children + it.inherited}.reduce {
-            _, left, right -> left.mergeWith(right)
+fun List<ClassPlatformInfo>.mergeClassPlatformInfo(): List<ClassPlatformInfo> =
+    groupingBy { it.documentationNode.children + it.inherited }.reduce { _, left, right ->
+        left.mergeWith(right)
     }.values.toList()
 
-fun List<PlatformInfo>.merge() : List<PlatformInfo> =
-    groupingBy { it.documentationNode }.reduce {
-        _, left, right -> left.mergeWith(right)
+fun List<PlatformInfo>.merge(): List<PlatformInfo> =
+    groupingBy { it.documentationNode }.reduce { _, left, right ->
+        left.mergeWith(right)
     }.values.toList()
 
-fun Function.mergeWith(other: Function) = Function(
+fun Function.mergeWith(other: Function): Function = Function(
     dri,
     name,
     returnType,
@@ -62,16 +63,34 @@ fun Property.mergeWith(other: Property) = Property(
     (actual + other.actual).merge()
 )
 
+fun Classlike.mergeWith(other: Classlike): Classlike = when {
+    this is Class && other is Class -> mergeWith(other)
+    this is Enum && other is Enum -> mergeWith(other)
+    else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot be merged with ${other::class.qualifiedName} ${other.name}")
+}
+
 fun Class.mergeWith(other: Class) = Class(
-    dri,
-    name,
-    kind,
-    merge(constructors + other.constructors, Function::mergeWith),
-    merge(functions + other.functions, Function::mergeWith),
-    merge(properties + other.properties, Property::mergeWith),
-    merge(classes + other.classes, Class::mergeWith),
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).mergeClassPlatformInfo()
+    dri = dri,
+    name = name,
+    kind = kind,
+    constructors = merge(constructors + other.constructors, Function::mergeWith),
+    functions = merge(functions + other.functions, Function::mergeWith),
+    properties = merge(properties + other.properties, Property::mergeWith),
+    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
+    expected = expected?.mergeWith(other.expected),
+    actual = (actual + other.actual).mergeClassPlatformInfo()
+)
+
+fun Enum.mergeWith(other: Enum) = Enum(
+    dri = dri,
+    name = name,
+    functions = merge(functions + other.functions, Function::mergeWith),
+    properties = merge(properties + other.properties, Property::mergeWith),
+    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
+    expected = expected?.mergeWith(other.expected),
+    actual = (actual + other.actual).mergeClassPlatformInfo(),
+    entries = (this.entries + other.entries.distinctBy { it.dri }.toList()),
+    constructors = merge(constructors + other.constructors, Function::mergeWith)
 )
 
 fun Parameter.mergeWith(other: Parameter) = Parameter(
@@ -82,9 +101,9 @@ fun Parameter.mergeWith(other: Parameter) = Parameter(
     (actual + other.actual).merge()
 )
 
-fun Package.mergeWith(other: Package) = Package(
+fun Package.mergeWith(other: Package): Package = Package(
     dri,
     merge(functions + other.functions, Function::mergeWith),
     merge(properties + other.properties, Property::mergeWith),
-    merge(classes + other.classes, Class::mergeWith)
+    merge(classlikes + other.classlikes, Classlike::mergeWith)
 )
\ No newline at end of file
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 998a56ea..e19b76b3 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -27,7 +27,7 @@ class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransform
         input.transformPageNodeTree { if (it is ModulePageNode) transformModule(it) else it }
 
     private fun transformModule(module: ModulePageNode) = module.transformContentPagesTree { node ->
-        if (node !is ClassPageNode) node
+        if (node !is ClasslikePageNode) node
         else {
             val refs =
                 node.documentable?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
-- 
cgit 


From cb20227d354b1b74ca6784d55ea75cc8b5281abd Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Tue, 7 Jul 2020 11:08:34 +0200
Subject: Implement simple cli integration test

---
 .idea/codeStyles/Project.xml                       | 16 +++++
 integration-tests/build.gradle.kts                 | 10 +++
 integration-tests/cli/build.gradle.kts             | 39 ++++++++++
 .../main/java/it/basic/java/SampleJavaClass.java   | 17 +++++
 .../it-cli/src/main/kotlin/it/basic/PublicClass.kt | 48 +++++++++++++
 .../jetbrains/dokka/it/cli/CliIntegrationTest.kt   | 82 ++++++++++++++++++++++
 .../dokka/it/cli/AbstractCliIntegrationTest.kt     | 36 ++++++++++
 .../org/jetbrains/dokka/it/cli/processUtils.kt     | 51 ++++++++++++++
 .../it/gradle/AbstractGradleIntegrationTest.kt     | 37 +---------
 .../jetbrains/dokka/it/AbstractIntegrationTest.kt  | 39 ++++++++++
 runners/cli/src/main/kotlin/cli/main.kt            | 10 +--
 settings.gradle.kts                                |  1 +
 12 files changed, 346 insertions(+), 40 deletions(-)
 create mode 100644 integration-tests/cli/build.gradle.kts
 create mode 100644 integration-tests/cli/projects/it-cli/src/main/java/it/basic/java/SampleJavaClass.java
 create mode 100644 integration-tests/cli/projects/it-cli/src/main/kotlin/it/basic/PublicClass.kt
 create mode 100644 integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/CliIntegrationTest.kt
 create mode 100644 integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/AbstractCliIntegrationTest.kt
 create mode 100644 integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/processUtils.kt
 create mode 100644 integration-tests/src/main/kotlin/org/jetbrains/dokka/it/AbstractIntegrationTest.kt

(limited to '.idea/codeStyles')

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 1bec35e5..31d977a0 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,6 +1,22 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+          <package name="io.ktor" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <codeStyleSettings language="kotlin">
diff --git a/integration-tests/build.gradle.kts b/integration-tests/build.gradle.kts
index ec9b4004..44da74cf 100644
--- a/integration-tests/build.gradle.kts
+++ b/integration-tests/build.gradle.kts
@@ -5,6 +5,7 @@ subprojects {
             runtimeClasspath += sourceSets.main.get().output
         }
     }
+
     configurations.getByName("integrationTestImplementation") {
         extendsFrom(configurations.implementation.get())
     }
@@ -13,6 +14,10 @@ subprojects {
         extendsFrom(configurations.runtimeOnly.get())
     }
 
+    dependencies {
+        implementation(project(":integration-tests"))
+    }
+
     val integrationTest = task<Test>("integrationTest") {
         maxHeapSize = "2G"
         description = "Runs integration tests."
@@ -28,3 +33,8 @@ subprojects {
         dependsOn(integrationTest)
     }
 }
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation(kotlin("test-junit"))
+}
diff --git a/integration-tests/cli/build.gradle.kts b/integration-tests/cli/build.gradle.kts
new file mode 100644
index 00000000..c3e98d0a
--- /dev/null
+++ b/integration-tests/cli/build.gradle.kts
@@ -0,0 +1,39 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+}
+
+val dokka_version: String by project
+evaluationDependsOn(":runners:cli")
+evaluationDependsOn(":plugins:base")
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation(kotlin("test-junit"))
+
+    val coroutines_version: String by project
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
+
+}
+
+/* Create a fat base plugin jar for cli tests */
+val basePluginShadow: Configuration by configurations.creating
+dependencies {
+    basePluginShadow(project(":plugins:base"))
+}
+val basePluginShadowJar = tasks.create("basePluginShadowJar", ShadowJar::class) {
+    configurations = listOf(basePluginShadow)
+    archiveFileName.set("fat-base-plugin-$dokka_version.jar")
+    archiveClassifier.set("")
+}
+
+tasks.integrationTest {
+    val cliJar = tasks.getByPath(":runners:cli:shadowJar") as ShadowJar
+    environment("CLI_JAR_PATH", cliJar.archiveFile.get())
+    environment("BASE_PLUGIN_JAR_PATH", basePluginShadowJar.archiveFile.get())
+    dependsOn(cliJar)
+    dependsOn(basePluginShadowJar)
+}
+
diff --git a/integration-tests/cli/projects/it-cli/src/main/java/it/basic/java/SampleJavaClass.java b/integration-tests/cli/projects/it-cli/src/main/java/it/basic/java/SampleJavaClass.java
new file mode 100644
index 00000000..23b0202c
--- /dev/null
+++ b/integration-tests/cli/projects/it-cli/src/main/java/it/basic/java/SampleJavaClass.java
@@ -0,0 +1,17 @@
+package it.basic.java;
+
+import it.basic.PublicClass;
+
+/**
+ * This class is, unlike {@link PublicClass}, written in Java
+ */
+@SuppressWarnings("unused")
+public class SampleJavaClass {
+
+    /**
+     * @return Empty instance of {@link PublicClass}
+     */
+    public PublicClass publicDocumentedFunction() {
+        return new PublicClass();
+    }
+}
diff --git a/integration-tests/cli/projects/it-cli/src/main/kotlin/it/basic/PublicClass.kt b/integration-tests/cli/projects/it-cli/src/main/kotlin/it/basic/PublicClass.kt
new file mode 100644
index 00000000..71bc7e63
--- /dev/null
+++ b/integration-tests/cli/projects/it-cli/src/main/kotlin/it/basic/PublicClass.kt
@@ -0,0 +1,48 @@
+@file:Suppress("unused")
+
+package it.basic
+
+class PublicClass {
+    /**
+     * This function is public and documented
+     */
+    fun publicDocumentedFunction(): String = ""
+
+    fun publicUndocumentedFunction(): String = ""
+
+    /**
+     * This function is internal and documented
+     */
+    internal fun internalDocumentedFunction(): String = ""
+
+    internal fun internalUndocumentedFunction(): String = ""
+
+    /**
+     * This function is private and documented
+     */
+    private fun privateDocumentedFunction(): String = ""
+
+    private fun privateUndocumentedFunction(): String = ""
+
+
+    /**
+     * This property is public and documented
+     */
+    val publicDocumentedProperty: Int = 0
+
+    val publicUndocumentedProperty: Int = 0
+
+    /**
+     * This property internal and documented
+     */
+    val internalDocumentedProperty: Int = 0
+
+    val internalUndocumentedProperty: Int = 0
+
+    /**
+     * This property private and documented
+     */
+    private val privateDocumentedProperty: Int = 0
+
+    private val privateUndocumentedProperty: Int = 0
+}
diff --git a/integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/CliIntegrationTest.kt b/integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/CliIntegrationTest.kt
new file mode 100644
index 00000000..5e24c1cd
--- /dev/null
+++ b/integration-tests/cli/src/integrationTest/kotlin/org/jetbrains/dokka/it/cli/CliIntegrationTest.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.dokka.it.cli
+
+import java.io.File
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class CliIntegrationTest : AbstractCliIntegrationTest() {
+
+    @BeforeTest
+    fun copyProject() {
+        val templateProjectDir = File("projects", "it-cli")
+        templateProjectDir.copyRecursively(projectDir)
+    }
+
+    @Test
+    fun runHelp() {
+        val process = ProcessBuilder("java", "-jar", cliJarFile.path, "-h")
+            .redirectErrorStream(true)
+            .start()
+
+        val result = process.awaitProcessResult()
+        assertEquals(0, result.exitCode, "Expected exitCode 0 (Success)")
+        assertTrue("Usage: " in result.output)
+    }
+
+    @Test
+    fun runCli() {
+        val dokkaOutputDir = File(projectDir, "output")
+        assertTrue(dokkaOutputDir.mkdirs())
+        val process = ProcessBuilder(
+            "java", "-jar", cliJarFile.path,
+            "-outputDir", dokkaOutputDir.path,
+            "-format", "html",
+            "-pluginsClasspath", basePluginJarFile.path,
+            "-sourceSet",
+            buildString {
+                append(" -moduleName it-cli")
+                append(" -moduleDisplayName CLI-Example")
+                append(" -sourceSetName cliMain")
+                append(" -src ${File(projectDir, "src").path}")
+                append(" -jdkVersion 8")
+                append(" -analysisPlatform jvm")
+                append(" -reportUndocumented")
+                append(" -skipDeprecated")
+            }
+        )
+            .redirectErrorStream(true)
+            .start()
+
+        val result = process.awaitProcessResult()
+        assertEquals(0, result.exitCode, "Expected exitCode 0 (Success)")
+
+        val extensionLoadedRegex = Regex("""Extension: org\.jetbrains\.dokka\.base\.DokkaBase""")
+        val amountOfExtensionsLoaded = extensionLoadedRegex.findAll(result.output).count()
+
+        assertTrue(
+            amountOfExtensionsLoaded > 10,
+            "Expected more than 10 extensions being present (found $amountOfExtensionsLoaded)"
+        )
+
+        assertTrue(dokkaOutputDir.isDirectory, "Missing dokka output directory")
+
+        val imagesDir = File(dokkaOutputDir, "images")
+        assertTrue(imagesDir.isDirectory, "Missing images directory")
+
+        val scriptsDir = File(dokkaOutputDir, "scripts")
+        assertTrue(scriptsDir.isDirectory, "Missing scripts directory")
+
+        val stylesDir = File(dokkaOutputDir, "styles")
+        assertTrue(stylesDir.isDirectory, "Missing styles directory")
+
+        val navigationHtml = File(dokkaOutputDir, "navigation.html")
+        assertTrue(navigationHtml.isFile, "Missing navigation.html")
+
+        projectDir.allHtmlFiles().forEach { file ->
+            assertContainsNoErrorClass(file)
+            assertNoUnresolvedLInks(file)
+        }
+    }
+}
diff --git a/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/AbstractCliIntegrationTest.kt b/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/AbstractCliIntegrationTest.kt
new file mode 100644
index 00000000..7f6f9433
--- /dev/null
+++ b/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/AbstractCliIntegrationTest.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.dokka.it.cli
+
+import org.jetbrains.dokka.it.AbstractIntegrationTest
+import java.io.File
+import kotlin.test.BeforeTest
+import kotlin.test.assertTrue
+
+abstract class AbstractCliIntegrationTest : AbstractIntegrationTest() {
+
+    protected val cliJarFile: File by lazy {
+        File(temporaryTestFolder.root, "dokka.jar")
+    }
+
+    protected val basePluginJarFile: File by lazy {
+        File(temporaryTestFolder.root, "base-plugin.jar")
+    }
+
+    @BeforeTest
+    fun copyJarFiles() {
+        val cliJarPathEnvironmentKey = "CLI_JAR_PATH"
+        val cliJarFile = File(System.getenv(cliJarPathEnvironmentKey))
+        assertTrue(
+            cliJarFile.exists() && cliJarFile.isFile,
+            "Missing path to CLI jar System.getenv($cliJarPathEnvironmentKey)"
+        )
+        cliJarFile.copyTo(this.cliJarFile)
+
+        val basePluginPathEnvironmentKey = "BASE_PLUGIN_JAR_PATH"
+        val basePluginJarFile = File(System.getenv(basePluginPathEnvironmentKey))
+        assertTrue(
+            basePluginJarFile.exists() && basePluginJarFile.isFile,
+            "Missing path to base plugin jar System.getenv($basePluginPathEnvironmentKey)"
+        )
+        basePluginJarFile.copyTo(this.basePluginJarFile)
+    }
+}
diff --git a/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/processUtils.kt b/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/processUtils.kt
new file mode 100644
index 00000000..d2fa3b31
--- /dev/null
+++ b/integration-tests/cli/src/main/kotlin/org/jetbrains/dokka/it/cli/processUtils.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.dokka.it.cli
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import kotlin.concurrent.thread
+
+class ProcessResult(
+    val exitCode: Int,
+    val output: String
+)
+
+fun Process.awaitProcessResult() = runBlocking {
+    val exitCode = async { awaitExitCode() }
+    val output = async { awaitOutput() }
+    ProcessResult(
+        exitCode.await(),
+        output.await()
+    )
+}
+
+private suspend fun Process.awaitExitCode(): Int {
+    val deferred = CompletableDeferred<Int>()
+    thread {
+        try {
+            deferred.complete(this.waitFor())
+        } catch (e: Throwable) {
+            deferred.completeExceptionally(e)
+        }
+    }
+
+    return deferred.await()
+}
+
+private suspend fun Process.awaitOutput(): String {
+    val deferred = CompletableDeferred<String>()
+    thread {
+        try {
+            var string = ""
+            this.inputStream.bufferedReader().forEachLine { line ->
+                println(line)
+                string += line + System.lineSeparator()
+            }
+            deferred.complete(string)
+        } catch (e: Throwable) {
+            deferred.completeExceptionally(e)
+        }
+    }
+
+    return deferred.await()
+}
diff --git a/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt b/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
index bb2d0cc6..c8c8c844 100644
--- a/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
+++ b/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
@@ -2,25 +2,17 @@ package org.jetbrains.dokka.it.gradle
 
 import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.internal.DefaultGradleRunner
-import org.junit.Rule
-import org.junit.rules.TemporaryFolder
+import org.jetbrains.dokka.it.AbstractIntegrationTest
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
 import java.io.File
 import kotlin.test.BeforeTest
-import kotlin.test.Test
-import kotlin.test.assertFalse
 
 @RunWith(Parameterized::class)
-abstract class AbstractGradleIntegrationTest {
+abstract class AbstractGradleIntegrationTest : AbstractIntegrationTest() {
 
     abstract val versions: BuildVersions
 
-    @get:Rule
-    val temporaryTestFolder = TemporaryFolder()
-
-    val projectDir get() = File(temporaryTestFolder.root, "project")
-
     @BeforeTest
     fun copyTemplates() {
         File("projects").listFiles().orEmpty()
@@ -49,30 +41,5 @@ abstract class AbstractGradleIntegrationTest {
             ).run { this as DefaultGradleRunner }
             .withJvmArguments("-Xmx4G", "-XX:MaxMetaspaceSize=512M")
     }
-
-    fun File.allDescendentsWithExtension(extension: String): Sequence<File> {
-        return this.walkTopDown().filter { it.isFile && it.extension == extension }
-    }
-
-    fun File.allHtmlFiles(): Sequence<File> {
-        return allDescendentsWithExtension("html")
-    }
-
-    protected fun assertContainsNoErrorClass(file: File) {
-        val fileText = file.readText()
-        assertFalse(
-            fileText.contains("ERROR CLASS", ignoreCase = true),
-            "Unexpected `ERROR CLASS` in ${file.path}\n" + fileText
-        )
-    }
-
-    protected fun assertNoUnresolvedLInks(file: File) {
-        val regex = Regex("[\"']#[\"']")
-        val fileText = file.readText()
-        assertFalse(
-            fileText.contains(regex),
-            "Unexpected unresolved link in ${file.path}\n" + fileText
-        )
-    }
 }
 
diff --git a/integration-tests/src/main/kotlin/org/jetbrains/dokka/it/AbstractIntegrationTest.kt b/integration-tests/src/main/kotlin/org/jetbrains/dokka/it/AbstractIntegrationTest.kt
new file mode 100644
index 00000000..4af523a2
--- /dev/null
+++ b/integration-tests/src/main/kotlin/org/jetbrains/dokka/it/AbstractIntegrationTest.kt
@@ -0,0 +1,39 @@
+package org.jetbrains.dokka.it
+
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import java.io.File
+import kotlin.test.assertFalse
+
+abstract class AbstractIntegrationTest {
+
+    @get:Rule
+    val temporaryTestFolder = TemporaryFolder()
+
+    val projectDir get() = File(temporaryTestFolder.root, "project")
+
+    fun File.allDescendentsWithExtension(extension: String): Sequence<File> {
+        return this.walkTopDown().filter { it.isFile && it.extension == extension }
+    }
+
+    fun File.allHtmlFiles(): Sequence<File> {
+        return allDescendentsWithExtension("html")
+    }
+
+    protected fun assertContainsNoErrorClass(file: File) {
+        val fileText = file.readText()
+        assertFalse(
+            fileText.contains("ERROR CLASS", ignoreCase = true),
+            "Unexpected `ERROR CLASS` in ${file.path}\n" + fileText
+        )
+    }
+
+    protected fun assertNoUnresolvedLInks(file: File) {
+        val regex = Regex("[\"']#[\"']")
+        val fileText = file.readText()
+        assertFalse(
+            fileText.contains(regex),
+            "Unexpected unresolved link in ${file.path}\n" + fileText
+        )
+    }
+}
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index 5e5cd6b2..d284e653 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -118,7 +118,7 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
     val moduleName by parser.option(
         ArgType.String,
         description = "Name of the documentation module",
-        fullName = "module"
+        fullName = "moduleName"
     ).required()
 
     val moduleDisplayName by parser.option(
@@ -126,12 +126,12 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
         description = "Name of the documentation module"
     )
 
-    val name by parser.option(
+    val sourceSetName by parser.option(
         ArgType.String,
         description = "Name of the source set"
     ).default("main")
 
-    val displayName by parser.option(
+    val sourceSetDisplayName by parser.option(
         ArgType.String,
         description = "Displayed name of the source set"
     ).default("JVM")
@@ -235,8 +235,8 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
 
     return object : DokkaConfiguration.DokkaSourceSet {
         override val moduleDisplayName = moduleDisplayName ?: moduleName
-        override val displayName = displayName
-        override val sourceSetID = DokkaSourceSetID(moduleName, name)
+        override val displayName = sourceSetDisplayName
+        override val sourceSetID = DokkaSourceSetID(moduleName, sourceSetName)
         override val classpath = classpath
         override val sourceRoots = sourceRoots.map { SourceRootImpl(it.toAbsolutePath()) }
         override val dependentSourceSets: Set<DokkaSourceSetID> = dependentSourceSets
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 969bb53f..54245a96 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -19,6 +19,7 @@ include("plugins:kotlin-as-java")
 include("plugins:javadoc")
 include("integration-tests")
 include("integration-tests:gradle")
+include("integration-tests:cli")
 
 pluginManagement {
     val kotlin_version: String by settings
-- 
cgit 


From ec318a2ac97aa5ab88564dc36474131fc03cba61 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Fri, 10 Jul 2020 18:52:54 +0200
Subject: Render explicitly documented primary constructors

---
 .idea/codeStyles/Project.xml                       | 15 ++----
 .../documentables/DefaultPageCreator.kt            |  2 +-
 .../SkippingParenthesisForConstructorsTest.kt      | 61 ++++++++++++++++++++++
 3 files changed, 65 insertions(+), 13 deletions(-)

(limited to '.idea/codeStyles')

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 31d977a0..69ebce06 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -3,18 +3,9 @@
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
         <value>
-          <package name="java.util" alias="false" withSubpackages="false" />
-          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
-          <package name="io.ktor" alias="false" withSubpackages="true" />
-        </value>
-      </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
-        <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="java" alias="false" withSubpackages="true" />
-          <package name="javax" alias="false" withSubpackages="true" />
-          <package name="kotlin" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
+          <package name="java.util" withSubpackages="false" static="false" />
+          <package name="kotlinx.android.synthetic" withSubpackages="true" static="false" />
+          <package name="io.ktor" withSubpackages="true" static="false" />
         </value>
       </option>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index 19df2515..40283d82 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -197,7 +197,7 @@ open class DefaultPageCreator(
                     "Constructors",
                     2,
                     ContentKind.Constructors,
-                    c.constructors.filter { it.extra[PrimaryConstructorExtra] == null },
+                    c.constructors.filter { it.extra[PrimaryConstructorExtra] == null || it.documentation.isNotEmpty() },
                     c.sourceSets,
                     extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors")
                 ) {
diff --git a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
index c2fbd26f..7de48664 100644
--- a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
@@ -190,4 +190,65 @@ class ConstructorsSignaturesTest : AbstractCoreTest() {
             }
         }
     }
+
+    @Test
+    fun `class with explicitly documented constructor`() {
+        testInline(
+            """
+            |/src/main/kotlin/test/source.kt
+            |package test
+            |
+            | /**
+            |  * some comment
+            |  * @constructor ctor comment
+            | **/
+            |class SomeClass(a: String)
+        """.trimIndent(), testConfiguration
+        ) {
+            pagesTransformationStage = { module ->
+                val page = module.children.single { it.name == "test" }
+                    .children.single { it.name == "SomeClass" } as ContentPage
+                page.content.assertNode {
+                    group {
+                        header(1) { +"SomeClass" }
+                        platformHinted {
+                            skipAllNotMatching()
+                            group {
+                                +"class"
+                                link { +"SomeClass" }
+                                +"(a:"
+                                group { link { +"String" } }
+                                +")"
+                            }
+                        }
+                    }
+                    group {
+                        header { +"Constructors" }
+                        table {
+                            group {
+                                link { +"<init>" }
+                                platformHinted {
+                                    group {
+                                        group {
+                                            +"ctor comment"
+                                        }
+                                    }
+                                    group {
+                                        +"fun"
+                                        link { +"<init>" }
+                                        +"(a:"
+                                        group {
+                                            link { +"String" }
+                                        }
+                                        +")"
+                                    }
+                                }
+                            }
+                        }
+                        skipAllNotMatching()
+                    }
+                }
+            }
+        }
+    }
 }
-- 
cgit 


From 1df542dcb7edced840692ac4397debcc2556f4c2 Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Mon, 13 Jul 2020 10:52:08 +0200
Subject: Remove `global` dokka source set (in favor of configureEach)

---
 .idea/codeStyles/Project.xml                       | 15 +++++--
 .../gradle/projects/it-basic/build.gradle.kts      |  8 ++++
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |  5 +--
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt | 48 +++++++++-------------
 4 files changed, 40 insertions(+), 36 deletions(-)

(limited to '.idea/codeStyles')

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 69ebce06..31d977a0 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -3,9 +3,18 @@
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
         <value>
-          <package name="java.util" withSubpackages="false" static="false" />
-          <package name="kotlinx.android.synthetic" withSubpackages="true" static="false" />
-          <package name="io.ktor" withSubpackages="true" static="false" />
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+          <package name="io.ktor" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
         </value>
       </option>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
diff --git a/integration-tests/gradle/projects/it-basic/build.gradle.kts b/integration-tests/gradle/projects/it-basic/build.gradle.kts
index c6fd29b7..691634b7 100644
--- a/integration-tests/gradle/projects/it-basic/build.gradle.kts
+++ b/integration-tests/gradle/projects/it-basic/build.gradle.kts
@@ -8,3 +8,11 @@ apply(from = "../template.root.gradle.kts")
 dependencies {
     implementation(kotlin("stdlib"))
 }
+
+tasks.dokkaHtml {
+    dokkaSourceSets {
+        register("global") {
+            jdkVersion = 2
+        }
+    }
+}
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 27d25884..0270dbe2 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
@@ -1,10 +1,7 @@
 package org.jetbrains.dokka.gradle
 
 import org.gradle.api.DefaultTask
-import org.gradle.api.Project
-import org.gradle.api.UnknownTaskException
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.TaskAction
 import java.lang.IllegalStateException
 
@@ -43,7 +40,7 @@ open class DokkaCollectorTask : DefaultTask() {
             acc.pluginsClasspath = (acc.pluginsClasspath + it.pluginsClasspath).distinct()
             acc
         }
-        project.tasks.withType(DokkaTask::class.java).configureEach { it.config = configuration }
+        project.tasks.withType(DokkaTask::class.java).configureEach { it.enforcedConfiguration = configuration }
     }
 
     init {
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 db25fc47..75ca66d1 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
@@ -20,7 +20,6 @@ import java.util.concurrent.Callable
 
 open class DokkaTask : AbstractDokkaTask() {
     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")
@@ -52,7 +51,7 @@ open class DokkaTask : AbstractDokkaTask() {
 
 
     @get:Internal
-    internal var config: GradleDokkaConfigurationImpl? = null
+    internal var enforcedConfiguration: GradleDokkaConfigurationImpl? = null
 
     @get:Nested
     val dokkaSourceSets: NamedDomainObjectContainer<GradleDokkaSourceSet> =
@@ -119,7 +118,7 @@ open class DokkaTask : AbstractDokkaTask() {
         }
 
     @TaskAction
-    override fun generate() = config?.let { generate(it) } ?: generate(getConfigurationOrThrow())
+    override fun generate() = enforcedConfiguration?.let { generate(it) } ?: generate(getConfigurationOrThrow())
 
     protected open fun generate(configuration: GradleDokkaConfigurationImpl) {
         outputDiagnosticInfo = true
@@ -142,11 +141,10 @@ open class DokkaTask : AbstractDokkaTask() {
 
     @Internal
     internal fun getConfigurationOrNull(): GradleDokkaConfigurationImpl? {
-        val globalConfig = dokkaSourceSets.toList().find { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
         val defaultModulesConfiguration = configuredDokkaSourceSets
-            .map { configureDefault(it, globalConfig) }.takeIf { it.isNotEmpty() }
+            .map { configureDefault(it) }.takeIf { it.isNotEmpty() }
             ?: listOf(
-                configureDefault(configureDokkaSourceSet(GradleDokkaSourceSet("main", project)), null)
+                configureDefault(configureDokkaSourceSet(GradleDokkaSourceSet("main", project)))
             ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
 
         if (defaultModulesConfiguration.isEmpty()) {
@@ -185,11 +183,9 @@ open class DokkaTask : AbstractDokkaTask() {
 
     @get:Internal
     protected val configuredDokkaSourceSets: List<GradleDokkaSourceSet>
-        get() = dokkaSourceSets
-            .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
-            .map { configureDokkaSourceSet(it) }
+        get() = dokkaSourceSets.map { configureDokkaSourceSet(it) }
 
-    protected fun configureDokkaSourceSet(config: GradleDokkaSourceSet): GradleDokkaSourceSet {
+    private fun configureDokkaSourceSet(config: GradleDokkaSourceSet): GradleDokkaSourceSet {
         val userConfig = config
             .apply {
                 collectKotlinTasks?.let {
@@ -236,7 +232,7 @@ open class DokkaTask : AbstractDokkaTask() {
         }
     }
 
-    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradleDokkaSourceSet) =
+    private fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradleDokkaSourceSet) =
         kotlinTasks.find { it.name == name }
             ?.let { configExtractor.extractFromKotlinTasks(listOf(it)) }
             ?.singleOrNull()
@@ -245,7 +241,7 @@ open class DokkaTask : AbstractDokkaTask() {
                 ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
             ?: userConfig
 
-    protected fun mergeUserConfigurationAndPlatformData(
+    private fun mergeUserConfigurationAndPlatformData(
         userConfig: GradleDokkaSourceSet,
         autoConfig: PlatformData
     ) = userConfig.copy().apply {
@@ -257,10 +253,7 @@ open class DokkaTask : AbstractDokkaTask() {
             platform = autoConfig.platform
     }
 
-    protected fun configureDefault(
-        config: GradleDokkaSourceSet,
-        globalConfig: GradleDokkaSourceSet?
-    ): GradleDokkaSourceSet {
+    private fun configureDefault(config: GradleDokkaSourceSet): GradleDokkaSourceSet {
         if (config.moduleDisplayName.isBlank()) {
             config.moduleDisplayName = project.name
         }
@@ -268,25 +261,22 @@ open class DokkaTask : AbstractDokkaTask() {
         if (config.displayName.isBlank()) {
             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
-        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) {
             config.externalDocumentationLinks.add(ANDROID_REFERENCE_URL)
         }
+
         if (config.platform?.isNotBlank() == true) {
             config.analysisPlatform = dokkaPlatformFromString(config.platform.toString())
         }
-        globalConfig?.let {
-            config.perPackageOptions.addAll(globalConfig.perPackageOptions)
-            config.externalDocumentationLinks.addAll(globalConfig.externalDocumentationLinks)
-            config.sourceLinks.addAll(globalConfig.sourceLinks)
-            config.samples += globalConfig.samples.map { project.file(it).absolutePath }
-            config.includes += globalConfig.includes.map { project.file(it).absolutePath }
-        }
+
+        // Workaround for Groovy's GStringImpl
+        config.classpath = (config.classpath as List<Any>).map { it.toString() }.distinct()
+        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)
+
         return config
     }
 
-- 
cgit