From d458983871a6fa6af10b86bc7529a8851a63b265 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Fri, 15 Dec 2017 00:16:10 +0300
Subject: [backport] Add class hierarchy for JLH

Original: 33426ea
---
 core/src/main/kotlin/Model/DocumentationNode.kt | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index da85cabf..897e3ad3 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -104,6 +104,12 @@ open class DocumentationNode(val name: String,
     val platforms: List<String>
         get() = references(RefKind.Platform).map { it.to.name }
 
+    val supertypes: List<DocumentationNode>
+        get() = references(RefKind.Superclass).map { it.to }
+
+    val superclass: DocumentationNode?
+        get() = supertypes.find { it.kind == NodeKind.Class }
+
     // TODO: Should we allow node mutation? Model merge will copy by ref, so references are transparent, which could nice
     fun addReferenceTo(to: DocumentationNode, kind: RefKind) {
         references.add(DocumentationReference(this, to, kind))
-- 
cgit 


From 63ab561b66974c52a7d13e0823bf94329c0cd7f7 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Fri, 15 Dec 2017 22:05:21 +0300
Subject: [backport] Make possible to generate signatures on output format side

Original: 4469044
---
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt |  1 +
 .../main/kotlin/Kotlin/KotlinLanguageService.kt    | 28 ++++++++++++----------
 core/src/main/kotlin/Model/DocumentationNode.kt    |  1 +
 3 files changed, 17 insertions(+), 13 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index 7b50fff5..99d4d888 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -234,6 +234,7 @@ class DocumentationBuilder
             val externalLink = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(classifierDescriptor)
             if (externalLink != null) {
                 node.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
+                node.append(DocumentationNode(classifierDescriptor.fqNameUnsafe.asString(), Content.Empty, NodeKind.QualifiedName), RefKind.Detail)
             } else {
                 link(node, classifierDescriptor,
                         if (classifierDescriptor.isBoringBuiltinClass()) RefKind.HiddenLink else RefKind.Link)
diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
index 708facdb..b6f44716 100644
--- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
+++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
@@ -48,8 +48,7 @@ class KotlinLanguageService : LanguageService {
             val typeParameter = functionWithTypeParameter.details(NodeKind.TypeParameter).first()
             if (functionWithTypeParameter.kind == NodeKind.Function) {
                 renderFunction(functionWithTypeParameter, RenderMode.SUMMARY, SummarizingMapper(receiverKind, typeParameter.name))
-            }
-            else {
+            } else {
                 renderProperty(functionWithTypeParameter, RenderMode.SUMMARY, SummarizingMapper(receiverKind, typeParameter.name))
             }
         }
@@ -103,7 +102,7 @@ class KotlinLanguageService : LanguageService {
         fun renderReceiver(receiver: DocumentationNode, to: ContentBlock)
     }
 
-    private class SummarizingMapper(val kind: ReceiverKind, val typeParameterName: String): SignatureMapper {
+    private class SummarizingMapper(val kind: ReceiverKind, val typeParameterName: String) : SignatureMapper {
         override fun renderReceiver(receiver: DocumentationNode, to: ContentBlock) {
             to.append(ContentIdentifier(kind.receiverName, IdentifierKind.SummarizedTypeName))
             to.text("<$typeParameterName>")
@@ -117,7 +116,7 @@ class KotlinLanguageService : LanguageService {
     }
 
     private fun <T> ContentBlock.renderList(nodes: List<T>, separator: String = ", ",
-                                        noWrap: Boolean = false, renderItem: (T) -> Unit) {
+                                            noWrap: Boolean = false, renderItem: (T) -> Unit) {
         if (nodes.none())
             return
         renderItem(nodes.first())
@@ -132,7 +131,7 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun ContentBlock.renderLinked(node: DocumentationNode, body: ContentBlock.(DocumentationNode)->Unit) {
+    private fun ContentBlock.renderLinked(node: DocumentationNode, body: ContentBlock.(DocumentationNode) -> Unit) {
         val to = node.links.firstOrNull()
         if (to == null)
             body(node)
@@ -216,13 +215,13 @@ class KotlinLanguageService : LanguageService {
 
     private fun ContentBlock.renderModifier(node: DocumentationNode, nowrap: Boolean = false) {
         when (node.name) {
-            "final", "public", "var" -> {}
+            "final", "public", "var" -> {
+            }
             else -> {
                 keyword(node.name)
                 if (nowrap) {
                     nbsp()
-                }
-                else {
+                } else {
                     text(" ")
                 }
             }
@@ -239,11 +238,12 @@ class KotlinLanguageService : LanguageService {
             nbsp()
             symbol(":")
             nbsp()
-            renderList(constraints, noWrap=true) {
+            renderList(constraints, noWrap = true) {
                 renderType(it, renderMode)
             }
         }
     }
+
     private fun ContentBlock.renderParameter(node: DocumentationNode, renderMode: RenderMode) {
         if (renderMode == RenderMode.FULL) {
             renderAnnotationsForNode(node)
@@ -402,8 +402,7 @@ class KotlinLanguageService : LanguageService {
             symbol(")")
             symbol(": ")
             renderType(node.detail(NodeKind.Type), renderMode)
-        }
-        else {
+        } else {
             symbol(")")
         }
         renderExtraTypeParameterConstraints(node, renderMode)
@@ -429,7 +428,7 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun needReturnType(node: DocumentationNode) = when(node.kind) {
+    private fun needReturnType(node: DocumentationNode) = when (node.kind) {
         NodeKind.Constructor -> false
         else -> !node.isUnitReturnType()
     }
@@ -476,4 +475,7 @@ class KotlinLanguageService : LanguageService {
     }
 }
 
-fun DocumentationNode.qualifiedNameFromType() = (links.firstOrNull() ?: hiddenLinks.firstOrNull())?.qualifiedName() ?: name
+fun DocumentationNode.qualifiedNameFromType() =
+        details.firstOrNull { it.kind == NodeKind.QualifiedName }?.name
+                ?: (links.firstOrNull() ?: hiddenLinks.firstOrNull())?.qualifiedName()
+                ?: name
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 897e3ad3..4b108798 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -48,6 +48,7 @@ enum class NodeKind {
     Signature,
 
     ExternalLink,
+    QualifiedName,
     Platform,
 
     AllTypes,
-- 
cgit 


From e4d3abee285844c002a8984efbae0bf0be23d237 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Thu, 28 Dec 2017 19:44:56 +0300
Subject: Build supertypes via Supertype nodes, not reference

---
 core/src/main/kotlin/Model/DocumentationNode.kt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 4b108798..813ff0f5 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka
 
+import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.util.*
 
 enum class NodeKind {
@@ -106,10 +107,10 @@ open class DocumentationNode(val name: String,
         get() = references(RefKind.Platform).map { it.to.name }
 
     val supertypes: List<DocumentationNode>
-        get() = references(RefKind.Superclass).map { it.to }
+        get() = details(NodeKind.Supertype)
 
     val superclass: DocumentationNode?
-        get() = supertypes.find { it.kind == NodeKind.Class }
+        get() = supertypes.firstNotNullResult { it.links.firstOrNull { it.kind in NodeKind.classLike } }
 
     // TODO: Should we allow node mutation? Model merge will copy by ref, so references are transparent, which could nice
     fun addReferenceTo(to: DocumentationNode, kind: RefKind) {
-- 
cgit 


From bd30fa4c84d749976568be00307297ab015d9b2e Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Sun, 7 Jan 2018 01:49:34 +0300
Subject: [backport] Show type parameters substitution in class hierarchy

Original: a06d6a8
---
 core/src/main/kotlin/Model/DocumentationNode.kt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 813ff0f5..a145ae8d 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.util.*
 
 enum class NodeKind {
@@ -110,7 +109,7 @@ open class DocumentationNode(val name: String,
         get() = details(NodeKind.Supertype)
 
     val superclass: DocumentationNode?
-        get() = supertypes.firstNotNullResult { it.links.firstOrNull { it.kind in NodeKind.classLike } }
+        get() = supertypes.firstOrNull { it.links.any { it.kind in NodeKind.classLike } }
 
     // TODO: Should we allow node mutation? Model merge will copy by ref, so references are transparent, which could nice
     fun addReferenceTo(to: DocumentationNode, kind: RefKind) {
@@ -163,7 +162,7 @@ val DocumentationNode.path: List<DocumentationNode>
     }
 
 fun DocumentationNode.findOrCreatePackageNode(packageName: String, packageContent: Map<String, Content>, refGraph: NodeReferenceGraph): DocumentationNode {
-    val existingNode = members(NodeKind.Package).firstOrNull { it.name  == packageName }
+    val existingNode = members(NodeKind.Package).firstOrNull { it.name == packageName }
     if (existingNode != null) {
         return existingNode
     }
@@ -181,7 +180,8 @@ fun DocumentationNode.append(child: DocumentationNode, kind: RefKind) {
         RefKind.Detail -> child.addReferenceTo(this, RefKind.Owner)
         RefKind.Member -> child.addReferenceTo(this, RefKind.Owner)
         RefKind.Owner -> child.addReferenceTo(this, RefKind.Member)
-        else -> { /* Do not add any links back for other types */ }
+        else -> { /* Do not add any links back for other types */
+        }
     }
 }
 
-- 
cgit 


From c776aaab9af80987e3c073a40f92de748dbd38ca Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Thu, 11 Jan 2018 22:22:36 +0300
Subject: [backport] Support deep inheritance with external classes

Original: 9e65c3d
---
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt | 70 ++++++++++++++--------
 .../main/kotlin/Kotlin/KotlinLanguageService.kt    |  2 +-
 core/src/main/kotlin/Model/DocumentationNode.kt    | 19 +++++-
 .../main/kotlin/Model/DocumentationReference.kt    |  3 +-
 core/src/test/kotlin/TestAPI.kt                    | 48 ++++++++-------
 core/src/test/kotlin/model/JavaTest.kt             |  2 +-
 6 files changed, 92 insertions(+), 52 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index 99d4d888..11a36a4f 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -103,6 +103,10 @@ interface DefaultPlatformsProvider {
     fun getDefaultPlatforms(descriptor: DeclarationDescriptor): List<String>
 }
 
+val ignoredSupertypes = setOf(
+    "kotlin.Annotation", "kotlin.Enum", "kotlin.Any"
+)
+
 class DocumentationBuilder
 @Inject constructor(val resolutionFacade: DokkaResolutionFacade,
                     val descriptorDocumentationParser: DescriptorDocumentationParser,
@@ -173,7 +177,7 @@ class DocumentationBuilder
         val unwrappedType = superType.unwrap()
         if (unwrappedType is AbbreviatedType) {
             appendSupertype(descriptor, unwrappedType.abbreviation)
-        } else if (!ignoreSupertype(unwrappedType)) {
+        } else {
             appendType(unwrappedType, NodeKind.Supertype)
             val superclass = unwrappedType.constructor.declarationDescriptor
             link(superclass, descriptor, RefKind.Inheritor)
@@ -181,15 +185,6 @@ class DocumentationBuilder
         }
     }
 
-    private fun ignoreSupertype(superType: KotlinType): Boolean {
-        val superClass = superType.constructor.declarationDescriptor as? ClassDescriptor
-        if (superClass != null) {
-            val fqName = DescriptorUtils.getFqNameSafe(superClass).asString()
-            return fqName == "kotlin.Annotation" || fqName == "kotlin.Enum" || fqName == "kotlin.Any"
-        }
-        return false
-    }
-
     fun DocumentationNode.appendProjection(projection: TypeProjection, kind: NodeKind = NodeKind.Type) {
         if (projection.isStarProjection) {
             appendTextNode("*", NodeKind.Type)
@@ -233,14 +228,25 @@ class DocumentationBuilder
         if (classifierDescriptor != null) {
             val externalLink = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(classifierDescriptor)
             if (externalLink != null) {
+                val targetNode = refGraph.lookup(classifierDescriptor.signature()) ?: classifierDescriptor.build(true)
                 node.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
-                node.append(DocumentationNode(classifierDescriptor.fqNameUnsafe.asString(), Content.Empty, NodeKind.QualifiedName), RefKind.Detail)
+                node.append(targetNode, RefKind.ExternalType)
             } else {
                 link(node, classifierDescriptor,
                         if (classifierDescriptor.isBoringBuiltinClass()) RefKind.HiddenLink else RefKind.Link)
             }
+            if (classifierDescriptor !is TypeParameterDescriptor) {
+                node.append(
+                    DocumentationNode(
+                        classifierDescriptor.fqNameUnsafe.asString(),
+                        Content.Empty,
+                        NodeKind.QualifiedName
+                    ), RefKind.Detail
+                )
+            }
         }
 
+
         append(node, RefKind.Detail)
         node.appendAnnotations(kotlinType)
         for (typeArgument in kotlinType.arguments) {
@@ -496,34 +502,42 @@ class DocumentationBuilder
     }
 
     fun DeclarationDescriptor.build(): DocumentationNode = when (this) {
-        is ClassDescriptor -> build()
+        is ClassifierDescriptor -> build()
         is ConstructorDescriptor -> build()
         is PropertyDescriptor -> build()
         is FunctionDescriptor -> build()
-        is TypeParameterDescriptor -> build()
         is ValueParameterDescriptor -> build()
         is ReceiverParameterDescriptor -> build()
-        is TypeAliasDescriptor -> build()
         else -> throw IllegalStateException("Descriptor $this is not known")
     }
 
-    fun TypeAliasDescriptor.build(): DocumentationNode {
+    fun ClassifierDescriptor.build(external: Boolean = false): DocumentationNode = when (this) {
+        is ClassDescriptor -> build(external)
+        is TypeAliasDescriptor -> build(external)
+        is TypeParameterDescriptor -> build()
+        else -> throw IllegalStateException("Descriptor $this is not known")
+    }
+
+    fun TypeAliasDescriptor.build(external: Boolean = false): DocumentationNode {
         val node = nodeForDescriptor(this, NodeKind.TypeAlias)
 
-        node.appendAnnotations(this)
+        if (!external) {
+            node.appendAnnotations(this)
+        }
         node.appendModifiers(this)
         node.appendInPageChildren(typeConstructor.parameters, RefKind.Detail)
 
         node.appendType(underlyingType, NodeKind.TypeAliasUnderlyingType)
 
-        node.appendSourceLink(source)
-        node.appendDefaultPlatforms(this)
-
+        if (!external) {
+            node.appendSourceLink(source)
+            node.appendDefaultPlatforms(this)
+        }
         register(this, node)
         return node
     }
 
-    fun ClassDescriptor.build(): DocumentationNode {
+    fun ClassDescriptor.build(external: Boolean = false): DocumentationNode {
         val kind = when {
             kind == ClassKind.OBJECT -> NodeKind.Object
             kind == ClassKind.INTERFACE -> NodeKind.Interface
@@ -534,20 +548,24 @@ class DocumentationBuilder
             else -> NodeKind.Class
         }
         val node = nodeForDescriptor(this, kind)
+        register(this, node)
         typeConstructor.supertypes.forEach {
             node.appendSupertype(this, it)
         }
         if (getKind() != ClassKind.OBJECT && getKind() != ClassKind.ENUM_ENTRY) {
             node.appendInPageChildren(typeConstructor.parameters, RefKind.Detail)
         }
-        for ((descriptor, inheritedLinkKind, extraModifier) in collectMembersToDocument()) {
-            node.appendClassMember(descriptor, inheritedLinkKind, extraModifier)
+        if (!external) {
+            for ((descriptor, inheritedLinkKind, extraModifier) in collectMembersToDocument()) {
+                node.appendClassMember(descriptor, inheritedLinkKind, extraModifier)
+            }
+            node.appendAnnotations(this)
         }
-        node.appendAnnotations(this)
         node.appendModifiers(this)
-        node.appendSourceLink(source)
-        node.appendDefaultPlatforms(this)
-        register(this, node)
+        if (!external) {
+            node.appendSourceLink(source)
+            node.appendDefaultPlatforms(this)
+        }
         return node
     }
 
diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
index b6f44716..aa185de7 100644
--- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
+++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
@@ -291,7 +291,7 @@ class KotlinLanguageService : LanguageService {
     }
 
     private fun ContentBlock.renderSupertypesForNode(node: DocumentationNode, renderMode: RenderMode) {
-        val supertypes = node.details(NodeKind.Supertype)
+        val supertypes = node.details(NodeKind.Supertype).filterNot { it.qualifiedNameFromType() in ignoredSupertypes }
         if (supertypes.any()) {
             nbsp()
             symbol(":")
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index a145ae8d..a792460f 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -104,12 +104,27 @@ open class DocumentationNode(val name: String,
         get() = references(RefKind.Deprecation).singleOrNull()?.to
     val platforms: List<String>
         get() = references(RefKind.Platform).map { it.to.name }
+    val externalType: DocumentationNode?
+        get() = references(RefKind.ExternalType).map { it.to }.firstOrNull()
 
     val supertypes: List<DocumentationNode>
         get() = details(NodeKind.Supertype)
 
-    val superclass: DocumentationNode?
-        get() = supertypes.firstOrNull { it.links.any { it.kind in NodeKind.classLike } }
+    val superclassType: DocumentationNode?
+        get() = when (kind) {
+            NodeKind.Supertype -> (links.firstOrNull { it.kind in NodeKind.classLike } ?: externalType)?.superclassType
+            NodeKind.Interface -> null
+            in NodeKind.classLike -> supertypes.firstOrNull {
+                it.links.any { it.kind in NodeKind.classLike } ||
+                        it.externalType != null
+            }
+            else -> null
+        }
+
+    val superclassTypeSequence: Sequence<DocumentationNode>
+        get() = generateSequence(superclassType) {
+            it.superclassType
+        }
 
     // TODO: Should we allow node mutation? Model merge will copy by ref, so references are transparent, which could nice
     fun addReferenceTo(to: DocumentationNode, kind: RefKind) {
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index a968f400..b0f011be 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -18,7 +18,8 @@ enum class RefKind {
     HiddenAnnotation,
     Deprecation,
     TopLevelPage,
-    Platform
+    Platform,
+    ExternalType
 }
 
 data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) {
diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
index aa3eff48..559b715e 100644
--- a/core/src/test/kotlin/TestAPI.kt
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -6,7 +6,6 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.rt.execution.junit.FileComparisonFailure
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.DokkaConfiguration.SourceLinkDefinition
 import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -25,6 +24,7 @@ fun verifyModel(vararg roots: ContentRoot,
                 format: String = "html",
                 includeNonPublic: Boolean = true,
                 perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
+                noStdlibLink: Boolean = true,
                 verifier: (DocumentationModule) -> Unit) {
     val documentation = DocumentationModule("test")
 
@@ -37,7 +37,7 @@ fun verifyModel(vararg roots: ContentRoot,
             sourceLinks = listOf(),
             perPackageOptions = perPackageOptions,
             generateIndexPages = false,
-            noStdlibLink = true,
+            noStdlibLink = noStdlibLink,
             cacheRoot = "default",
             languageVersion = null,
             apiVersion = null
@@ -161,13 +161,15 @@ fun verifyOutput(roots: Array<ContentRoot>,
                  withKotlinRuntime: Boolean = false,
                  format: String = "html",
                  includeNonPublic: Boolean = true,
+                 noStdlibLink: Boolean = true,
                  outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
     verifyModel(
-            *roots,
-            withJdk = withJdk,
-            withKotlinRuntime = withKotlinRuntime,
-            format = format,
-            includeNonPublic = includeNonPublic
+        *roots,
+        withJdk = withJdk,
+        withKotlinRuntime = withKotlinRuntime,
+        format = format,
+        includeNonPublic = includeNonPublic,
+        noStdlibLink = noStdlibLink
     ) {
         verifyModelOutput(it, outputExtension, roots.first().path, outputGenerator)
     }
@@ -184,21 +186,25 @@ fun verifyModelOutput(it: DocumentationModule,
     assertEqualsIgnoringSeparators(expectedFile, output.toString())
 }
 
-fun verifyOutput(path: String,
-                 outputExtension: String,
-                 withJdk: Boolean = false,
-                 withKotlinRuntime: Boolean = false,
-                 format: String = "html",
-                 includeNonPublic: Boolean = true,
-                 outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
+fun verifyOutput(
+    path: String,
+    outputExtension: String,
+    withJdk: Boolean = false,
+    withKotlinRuntime: Boolean = false,
+    format: String = "html",
+    includeNonPublic: Boolean = true,
+    noStdlibLink: Boolean = true,
+    outputGenerator: (DocumentationModule, StringBuilder) -> Unit
+) {
     verifyOutput(
-            arrayOf(contentRootFromPath(path)),
-            outputExtension,
-            withJdk,
-            withKotlinRuntime,
-            format,
-            includeNonPublic,
-            outputGenerator
+        arrayOf(contentRootFromPath(path)),
+        outputExtension,
+        withJdk,
+        withKotlinRuntime,
+        format,
+        includeNonPublic,
+        noStdlibLink,
+        outputGenerator
     )
 }
 
diff --git a/core/src/test/kotlin/model/JavaTest.kt b/core/src/test/kotlin/model/JavaTest.kt
index e6c22ee4..c2ede8f0 100644
--- a/core/src/test/kotlin/model/JavaTest.kt
+++ b/core/src/test/kotlin/model/JavaTest.kt
@@ -193,7 +193,7 @@ public class JavaTest {
     @Test fun enumValues() {
         verifyJavaPackageMember("testdata/java/enumValues.java") { cls ->
             val superTypes = cls.details(NodeKind.Supertype)
-            assertEquals(0, superTypes.size)
+            assertEquals(1, superTypes.size)
             assertEquals(1, cls.members(NodeKind.EnumItem).size)
         }
     }
-- 
cgit 


From 1391dcca35a871881420c53755fed08bf47e4087 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Wed, 17 Jan 2018 20:01:20 +0300
Subject: [backport] Support propagating inherited extensions from libraries

Original: bf2945d
---
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   3 +-
 core/src/main/kotlin/Generation/DokkaGenerator.kt  |   2 +
 .../main/kotlin/Generation/configurationImpl.kt    |  47 ++---
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt | 200 ++++++++++++++++-----
 .../Kotlin/ExternalDocumentationLinkResolver.kt    |   2 +-
 core/src/main/kotlin/Model/DocumentationNode.kt    |   2 +
 core/src/test/kotlin/TestAPI.kt                    |  32 ++--
 .../kotlin/org/jetbrains/dokka/configuration.kt    |  48 ++---
 runners/cli/src/main/kotlin/cli/main.kt            |  28 +--
 runners/gradle-plugin/src/main/kotlin/main.kt      |  51 +++---
 10 files changed, 273 insertions(+), 142 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index aeaca8be..b7787be8 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -69,7 +69,8 @@ class DokkaBootstrapImpl : DokkaBootstrap {
                         languageVersion,
                         apiVersion,
                         cacheRoot,
-                        suppressedFiles.map { File(it) }.toSet()
+                        suppressedFiles.map { File(it) }.toSet(),
+                        collectInheritedExtensionsFromLibraries
                 )
         )
     }
diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 09e5cedf..33170f35 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -160,6 +160,8 @@ fun buildDocumentationModule(injector: Injector,
     with(injector.getInstance(DocumentationBuilder::class.java)) {
         documentationModule.appendFragments(fragments, packageDocs.packageContent,
                 injector.getInstance(PackageDocumentationBuilder::class.java))
+
+        propagateExtensionFunctionsToSubclasses(fragments, resolutionFacade)
     }
 
     val javaFiles = coreEnvironment.getJavaSourceFiles().filter(filesToDocumentFilter)
diff --git a/core/src/main/kotlin/Generation/configurationImpl.kt b/core/src/main/kotlin/Generation/configurationImpl.kt
index 34d4154e..52e8446f 100644
--- a/core/src/main/kotlin/Generation/configurationImpl.kt
+++ b/core/src/main/kotlin/Generation/configurationImpl.kt
@@ -36,27 +36,28 @@ data class PackageOptionsImpl(override val prefix: String,
                               override val suppress: Boolean = false) : DokkaConfiguration.PackageOptions
 
 data class DokkaConfigurationImpl(
-        override val moduleName: String,
-        override val classpath: List<String>,
-        override val sourceRoots: List<SourceRootImpl>,
-        override val samples: List<String>,
-        override val includes: List<String>,
-        override val outputDir: String,
-        override val format: String,
-        override val includeNonPublic: Boolean,
-        override val includeRootPackage: Boolean,
-        override val reportUndocumented: Boolean,
-        override val skipEmptyPackages: Boolean,
-        override val skipDeprecated: Boolean,
-        override val jdkVersion: Int,
-        override val generateIndexPages: Boolean,
-        override val sourceLinks: List<SourceLinkDefinitionImpl>,
-        override val impliedPlatforms: List<String>,
-        override val perPackageOptions: List<PackageOptionsImpl>,
-        override val externalDocumentationLinks: List<ExternalDocumentationLinkImpl>,
-        override val noStdlibLink: Boolean,
-        override val cacheRoot: String?,
-        override val suppressedFiles: List<String>,
-        override val languageVersion: String?,
-        override val apiVersion: String?
+    override val moduleName: String,
+    override val classpath: List<String>,
+    override val sourceRoots: List<SourceRootImpl>,
+    override val samples: List<String>,
+    override val includes: List<String>,
+    override val outputDir: String,
+    override val format: String,
+    override val includeNonPublic: Boolean,
+    override val includeRootPackage: Boolean,
+    override val reportUndocumented: Boolean,
+    override val skipEmptyPackages: Boolean,
+    override val skipDeprecated: Boolean,
+    override val jdkVersion: Int,
+    override val generateIndexPages: Boolean,
+    override val sourceLinks: List<SourceLinkDefinitionImpl>,
+    override val impliedPlatforms: List<String>,
+    override val perPackageOptions: List<PackageOptionsImpl>,
+    override val externalDocumentationLinks: List<ExternalDocumentationLinkImpl>,
+    override val noStdlibLink: Boolean,
+    override val cacheRoot: String?,
+    override val suppressedFiles: List<String>,
+    override val languageVersion: String?,
+    override val apiVersion: String?,
+    override val collectInheritedExtensionsFromLibraries: Boolean
 ) : DokkaConfiguration
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index 11a36a4f..125f9fd4 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -11,6 +11,9 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.EnumEntrySyntheticClassDescriptor
 import org.jetbrains.kotlin.idea.kdoc.findKDoc
+import org.jetbrains.kotlin.idea.util.fuzzyExtensionReceiverType
+import org.jetbrains.kotlin.idea.util.makeNotNullable
+import org.jetbrains.kotlin.idea.util.toFuzzyType
 import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -25,10 +28,11 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.*
 import org.jetbrains.kotlin.resolve.findTopMostOverriddenDescriptors
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.io.File
 import java.nio.file.Path
@@ -53,7 +57,8 @@ class DocumentationOptions(val outputDir: String,
                            val languageVersion: String?,
                            val apiVersion: String?,
                            cacheRoot: String? = null,
-                           val suppressedFiles: Set<File> = emptySet()) {
+                           val suppressedFiles: Set<File> = emptySet(),
+                           val collectInheritedExtensionsFromLibraries: Boolean = false) {
     init {
         if (perPackageOptions.any { it.prefix == "" })
             throw IllegalArgumentException("Please do not register packageOptions with all match pattern, use global settings instead")
@@ -138,8 +143,20 @@ class DocumentationBuilder
         refGraph.register(descriptor.signature(), node)
     }
 
-    fun <T> nodeForDescriptor(descriptor: T, kind: NodeKind): DocumentationNode where T : DeclarationDescriptor, T : Named {
-        val (doc, callback) = descriptorDocumentationParser.parseDocumentationAndDetails(descriptor, kind == NodeKind.Parameter)
+    fun <T> nodeForDescriptor(
+        descriptor: T,
+        kind: NodeKind,
+        external: Boolean = false
+    ): DocumentationNode where T : DeclarationDescriptor, T : Named {
+        val (doc, callback) =
+                if (external) {
+                    Content.Empty to { node -> }
+                } else {
+                    descriptorDocumentationParser.parseDocumentationAndDetails(
+                        descriptor,
+                        kind == NodeKind.Parameter
+                    )
+                }
         val node = DocumentationNode(descriptor.name.asString(), doc, kind).withModifiers(descriptor)
         node.appendSignature(descriptor)
         callback(node)
@@ -226,14 +243,20 @@ class DocumentationBuilder
             node.appendTextNode("?", NodeKind.NullabilityModifier)
         }
         if (classifierDescriptor != null) {
-            val externalLink = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(classifierDescriptor)
+            val externalLink =
+                linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(classifierDescriptor)
             if (externalLink != null) {
-                val targetNode = refGraph.lookup(classifierDescriptor.signature()) ?: classifierDescriptor.build(true)
-                node.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
-                node.append(targetNode, RefKind.ExternalType)
+                if (classifierDescriptor !is TypeParameterDescriptor) {
+                    val targetNode =
+                        refGraph.lookup(classifierDescriptor.signature()) ?: classifierDescriptor.build(true)
+                    node.append(targetNode, RefKind.ExternalType)
+                    node.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
+                }
             } else {
-                link(node, classifierDescriptor,
-                        if (classifierDescriptor.isBoringBuiltinClass()) RefKind.HiddenLink else RefKind.Link)
+                link(
+                    node, classifierDescriptor,
+                    if (classifierDescriptor.isBoringBuiltinClass()) RefKind.HiddenLink else RefKind.Link
+                )
             }
             if (classifierDescriptor !is TypeParameterDescriptor) {
                 node.append(
@@ -280,6 +303,17 @@ class DocumentationBuilder
         }
     }
 
+    fun DocumentationNode.appendExternalLink(externalLink: String) {
+        append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
+    }
+
+    fun DocumentationNode.appendExternalLink(descriptor: DeclarationDescriptor) {
+        val target = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(descriptor)
+        if (target != null) {
+            appendExternalLink(target)
+        }
+    }
+
     fun DocumentationNode.appendSinceKotlin(annotation: DocumentationNode) {
         val kotlinVersion = annotation
                 .detail(NodeKind.Parameter)
@@ -426,15 +460,44 @@ class DocumentationBuilder
                     declarations, allFqNames)
         }
 
-        propagateExtensionFunctionsToSubclasses(fragments)
     }
 
-    private fun propagateExtensionFunctionsToSubclasses(fragments: Collection<PackageFragmentDescriptor>) {
-        val allDescriptors = fragments.flatMap { it.getMemberScope().getContributedDescriptors() }
-        val allClasses = allDescriptors.filterIsInstance<ClassDescriptor>()
-        val classHierarchy = buildClassHierarchy(allClasses)
+    fun propagateExtensionFunctionsToSubclasses(
+        fragments: Collection<PackageFragmentDescriptor>,
+        resolutionFacade: DokkaResolutionFacade
+    ) {
+
+        val moduleDescriptor = resolutionFacade.moduleDescriptor
+
+        // Wide-collect all view descriptors
+        val allPackageViewDescriptors = generateSequence(listOf(moduleDescriptor.getPackage(FqName.ROOT))) { packages ->
+            packages
+                .flatMap { pkg ->
+                    moduleDescriptor.getSubPackagesOf(pkg.fqName) { true }
+                }.map { fqName ->
+                    moduleDescriptor.getPackage(fqName)
+                }.takeUnless { it.isEmpty() }
+        }.flatten()
+
+        val allDescriptors =
+            if (options.collectInheritedExtensionsFromLibraries) {
+                allPackageViewDescriptors.map { it.memberScope }
+            } else {
+                fragments.asSequence().map { it.getMemberScope() }
+            }.flatMap {
+                it.getDescriptorsFiltered(
+                    DescriptorKindFilter.CALLABLES
+                ).asSequence()
+            }
+
 
-        val allExtensionFunctions = allDescriptors
+        val documentingDescriptors = fragments.flatMap { it.getMemberScope().getContributedDescriptors() }
+        val documentingClasses = documentingDescriptors.filterIsInstance<ClassDescriptor>()
+
+        val classHierarchy = buildClassHierarchy(documentingClasses)
+
+        val allExtensionFunctions =
+            allDescriptors
                 .filterIsInstance<CallableMemberDescriptor>()
                 .filter { it.extensionReceiverParameter != null }
         val extensionFunctionsByName = allExtensionFunctions.groupBy { it.name }
@@ -442,15 +505,31 @@ class DocumentationBuilder
         for (extensionFunction in allExtensionFunctions) {
             if (extensionFunction.dispatchReceiverParameter != null) continue
             val possiblyShadowingFunctions = extensionFunctionsByName[extensionFunction.name]
-                    ?.filter { fn -> fn.canShadow(extensionFunction) }
+                ?.filter { fn -> fn.canShadow(extensionFunction) }
                     ?: emptyList()
 
             if (extensionFunction.extensionReceiverParameter?.type?.isDynamic() == true) continue
-            val classDescriptor = extensionFunction.getExtensionClassDescriptor() ?: continue
-            val subclasses = classHierarchy[classDescriptor] ?: continue
-            subclasses.forEach { subclass ->
+            val subclasses =
+                classHierarchy.filter { (key) -> key.isExtensionApplicable(extensionFunction) }
+            if (subclasses.isEmpty()) continue
+            subclasses.values.flatten().forEach { subclass ->
                 if (subclass.isExtensionApplicable(extensionFunction) &&
-                        possiblyShadowingFunctions.none { subclass.isExtensionApplicable(it) }) {
+                    possiblyShadowingFunctions.none { subclass.isExtensionApplicable(it) }) {
+
+                    val hasExternalLink =
+                        linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(
+                            extensionFunction
+                        ) != null
+                    if (hasExternalLink) {
+                        val containerDesc =
+                            extensionFunction.containingDeclaration as? PackageFragmentDescriptor
+                        if (containerDesc != null) {
+                            val container = refGraph.lookup(containerDesc.signature())
+                                    ?: containerDesc.buildExternal()
+                            container.append(extensionFunction.buildExternal(), RefKind.Member)
+                        }
+                    }
+
                     refGraph.link(subclass.signature(), extensionFunction.signature(), RefKind.Extension)
                 }
             }
@@ -458,12 +537,9 @@ class DocumentationBuilder
     }
 
     private fun ClassDescriptor.isExtensionApplicable(extensionFunction: CallableMemberDescriptor): Boolean {
-        val receiverType = extensionFunction.extensionReceiverParameter!!.type
-        if (receiverType.arguments.any { it.type.constructor.declarationDescriptor is TypeParameterDescriptor }) {
-            val receiverClass = receiverType.constructor.declarationDescriptor
-            return receiverClass is ClassDescriptor && DescriptorUtils.isSubclass(this, receiverClass)
-        }
-        return defaultType.isSubtypeOf(receiverType)
+        val receiverType = extensionFunction.fuzzyExtensionReceiverType()?.makeNotNullable()
+        val classType = defaultType.toFuzzyType(declaredTypeParameters)
+        return receiverType != null && classType.checkIsSubtypeOf(receiverType) != null
     }
 
     private fun buildClassHierarchy(classes: List<ClassDescriptor>): Map<ClassDescriptor, List<ClassDescriptor>> {
@@ -511,6 +587,24 @@ class DocumentationBuilder
         else -> throw IllegalStateException("Descriptor $this is not known")
     }
 
+    fun PackageFragmentDescriptor.buildExternal(): DocumentationNode {
+        val node = DocumentationNode(fqName.asString(), Content.Empty, NodeKind.Package)
+
+        val externalLink = linkResolver.externalDocumentationLinkResolver.buildExternalDocumentationLink(this)
+        if (externalLink != null) {
+            node.append(DocumentationNode(externalLink, Content.Empty, NodeKind.ExternalLink), RefKind.Link)
+        }
+        register(this, node)
+        return node
+    }
+
+    fun CallableDescriptor.buildExternal(): DocumentationNode = when(this) {
+        is FunctionDescriptor -> build(true)
+        is PropertyDescriptor -> build(true)
+        else -> throw IllegalStateException("Descriptor $this is not known")
+    }
+
+
     fun ClassifierDescriptor.build(external: Boolean = false): DocumentationNode = when (this) {
         is ClassDescriptor -> build(external)
         is TypeAliasDescriptor -> build(external)
@@ -547,7 +641,7 @@ class DocumentationBuilder
             isSubclassOfThrowable() -> NodeKind.Exception
             else -> NodeKind.Class
         }
-        val node = nodeForDescriptor(this, kind)
+        val node = nodeForDescriptor(this, kind, external)
         register(this, node)
         typeConstructor.supertypes.forEach {
             node.appendSupertype(this, it)
@@ -632,12 +726,12 @@ class DocumentationBuilder
         return (receiver?.type?.constructor?.declarationDescriptor as? ClassDescriptor)?.isCompanionObject ?: false
     }
 
-    fun FunctionDescriptor.build(): DocumentationNode {
+    fun FunctionDescriptor.build(external: Boolean = false): DocumentationNode {
         if (ErrorUtils.containsErrorType(this)) {
             logger.warn("Found an unresolved type in ${signatureWithSourceLocation()}")
         }
 
-        val node = nodeForDescriptor(this, if (inCompanionObject()) NodeKind.CompanionObjectFunction else NodeKind.Function)
+        val node = nodeForDescriptor(this, if (inCompanionObject()) NodeKind.CompanionObjectFunction else NodeKind.Function, external)
 
         node.appendInPageChildren(typeParameters, RefKind.Detail)
         extensionReceiverParameter?.let { node.appendChild(it, RefKind.Detail) }
@@ -645,8 +739,12 @@ class DocumentationBuilder
         node.appendType(returnType)
         node.appendAnnotations(this)
         node.appendModifiers(this)
-        node.appendSourceLink(source)
-        node.appendDefaultPlatforms(this)
+        if (!external) {
+            node.appendSourceLink(source)
+            node.appendDefaultPlatforms(this)
+        } else {
+            node.appendExternalLink(this)
+        }
 
         overriddenDescriptors.forEach {
             addOverrideLink(it, this)
@@ -667,32 +765,42 @@ class DocumentationBuilder
         }
     }
 
-    fun PropertyDescriptor.build(): DocumentationNode {
-        val node = nodeForDescriptor(this, if (inCompanionObject()) NodeKind.CompanionObjectProperty else NodeKind.Property)
+    fun PropertyDescriptor.build(external: Boolean = false): DocumentationNode {
+        val node = nodeForDescriptor(
+            this,
+            if (inCompanionObject()) NodeKind.CompanionObjectProperty else NodeKind.Property,
+            external
+        )
         node.appendInPageChildren(typeParameters, RefKind.Detail)
         extensionReceiverParameter?.let { node.appendChild(it, RefKind.Detail) }
         node.appendType(returnType)
         node.appendAnnotations(this)
         node.appendModifiers(this)
-        node.appendSourceLink(source)
-        if (isVar) {
-            node.appendTextNode("var", NodeKind.Modifier)
-        }
-        getter?.let {
-            if (!it.isDefault) {
-                node.addAccessorDocumentation(descriptorDocumentationParser.parseDocumentation(it), "Getter")
+        if (!external) {
+            node.appendSourceLink(source)
+            if (isVar) {
+                node.appendTextNode("var", NodeKind.Modifier)
             }
-        }
-        setter?.let {
-            if (!it.isDefault) {
-                node.addAccessorDocumentation(descriptorDocumentationParser.parseDocumentation(it), "Setter")
+
+            getter?.let {
+                if (!it.isDefault) {
+                    node.addAccessorDocumentation(descriptorDocumentationParser.parseDocumentation(it), "Getter")
+                }
             }
+            setter?.let {
+                if (!it.isDefault) {
+                    node.addAccessorDocumentation(descriptorDocumentationParser.parseDocumentation(it), "Setter")
+                }
+            }
+            node.appendDefaultPlatforms(this)
+        }
+        if (external) {
+            node.appendExternalLink(this)
         }
 
         overriddenDescriptors.forEach {
             addOverrideLink(it, this)
         }
-        node.appendDefaultPlatforms(this)
 
         register(this, node)
         return node
diff --git a/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt b/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
index e19ecf76..400326d2 100644
--- a/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
+++ b/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
@@ -155,8 +155,8 @@ class ExternalDocumentationLinkResolver @Inject constructor(
     fun buildExternalDocumentationLink(symbol: DeclarationDescriptor): String? {
         val packageFqName: FqName =
                 when (symbol) {
-                    is DeclarationDescriptorNonRoot -> symbol.parents.firstOrNull { it is PackageFragmentDescriptor }?.fqNameSafe ?: return null
                     is PackageFragmentDescriptor -> symbol.fqName
+                    is DeclarationDescriptorNonRoot -> symbol.parents.firstOrNull { it is PackageFragmentDescriptor }?.fqNameSafe ?: return null
                     else -> return null
                 }
 
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index a792460f..85ecdf87 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -209,6 +209,8 @@ fun DocumentationNode.appendTextNode(text: String,
 fun DocumentationNode.qualifiedName(): String {
     if (kind == NodeKind.Type) {
         return qualifiedNameFromType()
+    } else if (kind == NodeKind.Package) {
+        return name
     }
     return path.drop(1).map { it.name }.filter { it.length > 0 }.joinToString(".")
 }
diff --git a/core/src/test/kotlin/TestAPI.kt b/core/src/test/kotlin/TestAPI.kt
index 559b715e..aeff9284 100644
--- a/core/src/test/kotlin/TestAPI.kt
+++ b/core/src/test/kotlin/TestAPI.kt
@@ -25,22 +25,24 @@ fun verifyModel(vararg roots: ContentRoot,
                 includeNonPublic: Boolean = true,
                 perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
                 noStdlibLink: Boolean = true,
+                collectInheritedExtensionsFromLibraries: Boolean = false,
                 verifier: (DocumentationModule) -> Unit) {
     val documentation = DocumentationModule("test")
 
     val options = DocumentationOptions(
-            "",
-            format,
-            includeNonPublic = includeNonPublic,
-            skipEmptyPackages = false,
-            includeRootPackage = true,
-            sourceLinks = listOf(),
-            perPackageOptions = perPackageOptions,
-            generateIndexPages = false,
-            noStdlibLink = noStdlibLink,
-            cacheRoot = "default",
-            languageVersion = null,
-            apiVersion = null
+        "",
+        format,
+        includeNonPublic = includeNonPublic,
+        skipEmptyPackages = false,
+        includeRootPackage = true,
+        sourceLinks = listOf(),
+        perPackageOptions = perPackageOptions,
+        generateIndexPages = false,
+        noStdlibLink = noStdlibLink,
+        cacheRoot = "default",
+        languageVersion = null,
+        apiVersion = null,
+        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
     )
 
     appendDocumentation(documentation, *roots,
@@ -162,6 +164,7 @@ fun verifyOutput(roots: Array<ContentRoot>,
                  format: String = "html",
                  includeNonPublic: Boolean = true,
                  noStdlibLink: Boolean = true,
+                 collectInheritedExtensionsFromLibraries: Boolean = false,
                  outputGenerator: (DocumentationModule, StringBuilder) -> Unit) {
     verifyModel(
         *roots,
@@ -169,7 +172,8 @@ fun verifyOutput(roots: Array<ContentRoot>,
         withKotlinRuntime = withKotlinRuntime,
         format = format,
         includeNonPublic = includeNonPublic,
-        noStdlibLink = noStdlibLink
+        noStdlibLink = noStdlibLink,
+        collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries
     ) {
         verifyModelOutput(it, outputExtension, roots.first().path, outputGenerator)
     }
@@ -194,6 +198,7 @@ fun verifyOutput(
     format: String = "html",
     includeNonPublic: Boolean = true,
     noStdlibLink: Boolean = true,
+    collectInheritedExtensionsFromLibraries: Boolean = false,
     outputGenerator: (DocumentationModule, StringBuilder) -> Unit
 ) {
     verifyOutput(
@@ -204,6 +209,7 @@ fun verifyOutput(
         format,
         includeNonPublic,
         noStdlibLink,
+        collectInheritedExtensionsFromLibraries,
         outputGenerator
     )
 }
diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt b/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
index 90e5b5fc..46a57278 100644
--- a/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
+++ b/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
@@ -41,6 +41,7 @@ interface DokkaConfiguration {
     val noStdlibLink: Boolean
     val cacheRoot: String?
     val suppressedFiles: List<String>
+    val collectInheritedExtensionsFromLibraries: Boolean
 
     interface SourceRoot {
         val path: String
@@ -82,29 +83,30 @@ interface DokkaConfiguration {
 }
 
 data class SerializeOnlyDokkaConfiguration(
-        override val moduleName: String,
-        override val classpath: List<String>,
-        override val sourceRoots: List<DokkaConfiguration.SourceRoot>,
-        override val samples: List<String>,
-        override val includes: List<String>,
-        override val outputDir: String,
-        override val format: String,
-        override val includeNonPublic: Boolean,
-        override val includeRootPackage: Boolean,
-        override val reportUndocumented: Boolean,
-        override val skipEmptyPackages: Boolean,
-        override val skipDeprecated: Boolean,
-        override val jdkVersion: Int,
-        override val generateIndexPages: Boolean,
-        override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition>,
-        override val impliedPlatforms: List<String>,
-        override val perPackageOptions: List<DokkaConfiguration.PackageOptions>,
-        override val externalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink>,
-        override val noStdlibLink: Boolean,
-        override val cacheRoot: String?,
-        override val suppressedFiles: List<String>,
-        override val languageVersion: String?,
-        override val apiVersion: String?
+    override val moduleName: String,
+    override val classpath: List<String>,
+    override val sourceRoots: List<DokkaConfiguration.SourceRoot>,
+    override val samples: List<String>,
+    override val includes: List<String>,
+    override val outputDir: String,
+    override val format: String,
+    override val includeNonPublic: Boolean,
+    override val includeRootPackage: Boolean,
+    override val reportUndocumented: Boolean,
+    override val skipEmptyPackages: Boolean,
+    override val skipDeprecated: Boolean,
+    override val jdkVersion: Int,
+    override val generateIndexPages: Boolean,
+    override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition>,
+    override val impliedPlatforms: List<String>,
+    override val perPackageOptions: List<DokkaConfiguration.PackageOptions>,
+    override val externalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink>,
+    override val noStdlibLink: Boolean,
+    override val cacheRoot: String?,
+    override val suppressedFiles: List<String>,
+    override val languageVersion: String?,
+    override val apiVersion: String?,
+    override val collectInheritedExtensionsFromLibraries: Boolean
 ) : DokkaConfiguration
 
 
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index fe945ed3..111e1420 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -62,6 +62,9 @@ class DokkaArguments {
     @set:Argument(value = "apiVersion", description = "Kotlin Api Version to pass to Kotlin Analysis")
     var apiVersion: String? = null
 
+    @set:Argument(value = "collectInheritedExtensionsFromLibraries", description = "Search for applicable extensions in libraries")
+    var collectInheritedExtensionsFromLibraries: Boolean = false
+
 }
 
 
@@ -106,18 +109,19 @@ object MainKt {
         val classPath = arguments.classpath.split(File.pathSeparatorChar).toList()
 
         val documentationOptions = DocumentationOptions(
-                arguments.outputDir.let { if (it.endsWith('/')) it else it + '/' },
-                arguments.outputFormat,
-                skipDeprecated = arguments.nodeprecated,
-                sourceLinks = sourceLinks,
-                impliedPlatforms = arguments.impliedPlatforms.split(','),
-                perPackageOptions = parsePerPackageOptions(arguments.packageOptions),
-                jdkVersion = arguments.jdkVersion,
-                externalDocumentationLinks = parseLinks(arguments.links),
-                noStdlibLink = arguments.noStdlibLink,
-                cacheRoot = arguments.cacheRoot,
-                languageVersion = arguments.languageVersion,
-                apiVersion = arguments.apiVersion
+            arguments.outputDir.let { if (it.endsWith('/')) it else it + '/' },
+            arguments.outputFormat,
+            skipDeprecated = arguments.nodeprecated,
+            sourceLinks = sourceLinks,
+            impliedPlatforms = arguments.impliedPlatforms.split(','),
+            perPackageOptions = parsePerPackageOptions(arguments.packageOptions),
+            jdkVersion = arguments.jdkVersion,
+            externalDocumentationLinks = parseLinks(arguments.links),
+            noStdlibLink = arguments.noStdlibLink,
+            cacheRoot = arguments.cacheRoot,
+            languageVersion = arguments.languageVersion,
+            apiVersion = arguments.apiVersion,
+            collectInheritedExtensionsFromLibraries = arguments.collectInheritedExtensionsFromLibraries
         )
 
         val generator = DokkaGenerator(
diff --git a/runners/gradle-plugin/src/main/kotlin/main.kt b/runners/gradle-plugin/src/main/kotlin/main.kt
index 5f02cd0e..4812e217 100644
--- a/runners/gradle-plugin/src/main/kotlin/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/main.kt
@@ -134,6 +134,9 @@ open class DokkaTask : DefaultTask() {
     @Optional @Input
     var apiVersion: String? = null
 
+    @Input
+    var collectInheritedExtensionsFromLibraries: Boolean = false
+
     @get:Internal
     internal val kotlinCompileBasedClasspathAndSourceRoots: ClasspathAndSourceRoots by lazy { extractClasspathAndSourceRootsFromKotlinTasks() }
 
@@ -287,29 +290,31 @@ open class DokkaTask : DefaultTask() {
             val bootstrapProxy: DokkaBootstrap = automagicTypedProxy(javaClass.classLoader, bootstrapInstance)
 
             val configuration = SerializeOnlyDokkaConfiguration(
-                    moduleName,
-                    fullClasspath.map { it.absolutePath },
-                    sourceRoots,
-                    samples.filterNotNull().map { project.file(it).absolutePath },
-                    includes.filterNotNull().map { project.file(it).absolutePath },
-                    outputDirectory,
-                    outputFormat,
-                    includeNonPublic,
-                    false,
-                    reportUndocumented,
-                    skipEmptyPackages,
-                    skipDeprecated,
-                    jdkVersion,
-                    true,
-                    linkMappings,
-                    impliedPlatforms,
-                    perPackageOptions,
-                    externalDocumentationLinks,
-                    noStdlibLink,
-                    cacheRoot,
-                    collectSuppressedFiles(sourceRoots),
-                    languageVersion,
-                    apiVersion)
+                moduleName,
+                fullClasspath.map { it.absolutePath },
+                sourceRoots,
+                samples.filterNotNull().map { project.file(it).absolutePath },
+                includes.filterNotNull().map { project.file(it).absolutePath },
+                outputDirectory,
+                outputFormat,
+                includeNonPublic,
+                false,
+                reportUndocumented,
+                skipEmptyPackages,
+                skipDeprecated,
+                jdkVersion,
+                true,
+                linkMappings,
+                impliedPlatforms,
+                perPackageOptions,
+                externalDocumentationLinks,
+                noStdlibLink,
+                cacheRoot,
+                collectSuppressedFiles(sourceRoots),
+                languageVersion,
+                apiVersion,
+                collectInheritedExtensionsFromLibraries
+            )
 
 
             bootstrapProxy.configure(
-- 
cgit 


From 8883839b8796589a1fa02b3dca5d1aae172b5c56 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Fri, 13 Apr 2018 19:47:07 +0300
Subject: [backport] Fix problems in as-java java-layout-html mode

Extract common part of LanguageServices & other improvements

Original: 853262e
---
 core/src/main/kotlin/Java/JavadocParser.kt         |  43 +++--
 .../main/kotlin/Kotlin/DeclarationLinkResolver.kt  |   2 +-
 .../main/kotlin/Kotlin/KotlinLanguageService.kt    | 164 ++++++++----------
 .../main/kotlin/Languages/CommonLanguageService.kt |  65 +++++++
 .../kotlin/Languages/NewJavaLanguageService.kt     | 190 +++++++++++++++++++++
 core/src/main/kotlin/Model/DocumentationNode.kt    |   2 +-
 .../main/kotlin/Model/DocumentationReference.kt    |   2 +-
 7 files changed, 353 insertions(+), 115 deletions(-)
 create mode 100644 core/src/main/kotlin/Languages/CommonLanguageService.kt
 create mode 100644 core/src/main/kotlin/Languages/NewJavaLanguageService.kt

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index c25f5813..db61a00a 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -20,8 +20,10 @@ interface JavaDocumentationParser {
     fun parseDocumentation(element: PsiNamedElement): JavadocParseResult
 }
 
-class JavadocParser(private val refGraph: NodeReferenceGraph,
-                    private val logger: DokkaLogger) : JavaDocumentationParser {
+class JavadocParser(
+    private val refGraph: NodeReferenceGraph,
+    private val logger: DokkaLogger
+) : JavaDocumentationParser {
     override fun parseDocumentation(element: PsiNamedElement): JavadocParseResult {
         val docComment = (element as? PsiDocCommentOwner)?.docComment
         if (docComment == null) return JavadocParseResult.Empty
@@ -31,7 +33,7 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
         result.append(para)
         para.convertJavadocElements(docComment.descriptionElements.dropWhile { it.text.trim().isEmpty() })
         docComment.tags.forEach { tag ->
-            when(tag.name) {
+            when (tag.name) {
                 "see" -> result.convertSeeTag(tag)
                 "deprecated" -> {
                     deprecatedContent = Content()
@@ -50,9 +52,9 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
 
     private fun PsiDocTag.contentElements(): Iterable<PsiElement> {
         val tagValueElements = children
-                .dropWhile { it.node?.elementType == JavaDocTokenType.DOC_TAG_NAME }
-                .dropWhile { it is PsiWhiteSpace }
-                .filterNot { it.node?.elementType == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS }
+            .dropWhile { it.node?.elementType == JavaDocTokenType.DOC_TAG_NAME }
+            .dropWhile { it is PsiWhiteSpace }
+            .filterNot { it.node?.elementType == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS }
         return if (getSubjectName() != null) tagValueElements.dropWhile { it is PsiDocTagValue } else tagValueElements
     }
 
@@ -83,7 +85,7 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
         }
     }
 
-    private fun createBlock(element: Element): ContentBlock = when(element.tagName()) {
+    private fun createBlock(element: Element): ContentBlock = when (element.tagName()) {
         "p" -> ContentParagraph()
         "b", "strong" -> ContentStrong()
         "i", "em" -> ContentEmphasis()
@@ -99,28 +101,26 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
     }
 
     private fun createLink(element: Element): ContentBlock {
-        val docref = element.attr("docref")
-        if (docref != null) {
-            return ContentNodeLazyLink(docref, { -> refGraph.lookupOrWarn(docref, logger)})
+        if (element.hasAttr("docref")) {
+            val docref = element.attr("docref")
+            return ContentNodeLazyLink(docref, { -> refGraph.lookupOrWarn(docref, logger) })
         }
-        val href = element.attr("href")
-        if (href != null) {
-            return ContentExternalLink(href)
+        return if (element.hasAttr("href")) {
+            val href = element.attr("href")
+            ContentExternalLink(href)
         } else {
-            return ContentBlock()
+            ContentBlock()
         }
     }
 
     private fun MutableContent.convertSeeTag(tag: PsiDocTag) {
-        val linkElement = tag.linkElement()
-        if (linkElement == null) {
-            return
-        }
+        val linkElement = tag.linkElement() ?: return
         val seeSection = findSectionByTag(ContentTags.SeeAlso) ?: addSection(ContentTags.SeeAlso, null)
         val linkSignature = resolveLink(linkElement)
         val text = ContentText(linkElement.text)
         if (linkSignature != null) {
-            val linkNode = ContentNodeLazyLink(tag.valueElement!!.text, { -> refGraph.lookupOrWarn(linkSignature, logger)})
+            val linkNode =
+                ContentNodeLazyLink(tag.valueElement!!.text, { -> refGraph.lookupOrWarn(linkSignature, logger) })
             linkNode.append(text)
             seeSection.append(linkNode)
         } else {
@@ -136,8 +136,7 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
                 val labelText = tag.dataElements.firstOrNull { it is PsiDocToken }?.text ?: valueElement!!.text
                 val link = "<a docref=\"$linkSignature\">${labelText.htmlEscape()}</a>"
                 if (tag.name == "link") "<code>$link</code>" else link
-            }
-            else if (valueElement != null) {
+            } else if (valueElement != null) {
                 valueElement.text
             } else {
                 ""
@@ -153,7 +152,7 @@ class JavadocParser(private val refGraph: NodeReferenceGraph,
     }
 
     private fun PsiDocTag.linkElement(): PsiElement? =
-            valueElement ?: dataElements.firstOrNull { it !is PsiWhiteSpace }
+        valueElement ?: dataElements.firstOrNull { it !is PsiWhiteSpace }
 
     private fun resolveLink(valueElement: PsiElement?): String? {
         val target = valueElement?.reference?.resolve()
diff --git a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
index ffef399d..ec474900 100644
--- a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
+++ b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
@@ -41,7 +41,7 @@ class DeclarationLinkResolver
                 val target = refGraph.lookup(signature)
 
                 if (target == null) {
-                    logger.warn("Can't find node by signature $signature, referenced at $referencedAt")
+                    logger.warn("Can't find node by signature `$signature`, referenced at $referencedAt")
                 }
                 target
             })
diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
index aa185de7..69a97848 100644
--- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
+++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
@@ -5,8 +5,9 @@ import org.jetbrains.dokka.LanguageService.RenderMode
 /**
  * Implements [LanguageService] and provides rendering of symbols in Kotlin language
  */
-class KotlinLanguageService : LanguageService {
-    private val fullOnlyModifiers = setOf("public", "protected", "private", "inline", "noinline", "crossinline", "reified")
+class KotlinLanguageService : CommonLanguageService() {
+    private val fullOnlyModifiers =
+        setOf("public", "protected", "private", "inline", "noinline", "crossinline", "reified")
 
     override fun render(node: DocumentationNode, renderMode: RenderMode): ContentNode {
         return content {
@@ -22,7 +23,7 @@ class KotlinLanguageService : LanguageService {
                 NodeKind.Type,
                 NodeKind.UpperBound -> renderType(node, renderMode)
 
-                NodeKind.Modifier -> renderModifier(node)
+                NodeKind.Modifier -> renderModifier(this, node)
                 NodeKind.Constructor,
                 NodeKind.Function,
                 NodeKind.CompanionObjectFunction -> renderFunction(node, renderMode)
@@ -33,12 +34,6 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    override fun renderName(node: DocumentationNode): String {
-        return when (node.kind) {
-            NodeKind.Constructor -> node.owner!!.name
-            else -> node.name
-        }
-    }
 
     override fun summarizeSignatures(nodes: List<DocumentationNode>): ContentNode? {
         if (nodes.size < 2) return null
@@ -47,9 +42,17 @@ class KotlinLanguageService : LanguageService {
         return content {
             val typeParameter = functionWithTypeParameter.details(NodeKind.TypeParameter).first()
             if (functionWithTypeParameter.kind == NodeKind.Function) {
-                renderFunction(functionWithTypeParameter, RenderMode.SUMMARY, SummarizingMapper(receiverKind, typeParameter.name))
+                renderFunction(
+                    functionWithTypeParameter,
+                    RenderMode.SUMMARY,
+                    SummarizingMapper(receiverKind, typeParameter.name)
+                )
             } else {
-                renderProperty(functionWithTypeParameter, RenderMode.SUMMARY, SummarizingMapper(receiverKind, typeParameter.name))
+                renderProperty(
+                    functionWithTypeParameter,
+                    RenderMode.SUMMARY,
+                    SummarizingMapper(receiverKind, typeParameter.name)
+                )
             }
         }
     }
@@ -70,26 +73,27 @@ class KotlinLanguageService : LanguageService {
 
     companion object {
         private val arrayClasses = setOf(
-                "kotlin.Array",
-                "kotlin.BooleanArray",
-                "kotlin.ByteArray",
-                "kotlin.CharArray",
-                "kotlin.ShortArray",
-                "kotlin.IntArray",
-                "kotlin.LongArray",
-                "kotlin.FloatArray",
-                "kotlin.DoubleArray"
+            "kotlin.Array",
+            "kotlin.BooleanArray",
+            "kotlin.ByteArray",
+            "kotlin.CharArray",
+            "kotlin.ShortArray",
+            "kotlin.IntArray",
+            "kotlin.LongArray",
+            "kotlin.FloatArray",
+            "kotlin.DoubleArray"
         )
 
         private val arrayOrListClasses = setOf("kotlin.List") + arrayClasses
 
         private val iterableClasses = setOf(
-                "kotlin.Collection",
-                "kotlin.Sequence",
-                "kotlin.Iterable",
-                "kotlin.Map",
-                "kotlin.String",
-                "kotlin.CharSequence") + arrayOrListClasses
+            "kotlin.Collection",
+            "kotlin.Sequence",
+            "kotlin.Iterable",
+            "kotlin.Map",
+            "kotlin.String",
+            "kotlin.CharSequence"
+        ) + arrayOrListClasses
     }
 
     private enum class ReceiverKind(val receiverName: String, val classes: Collection<String>) {
@@ -109,46 +113,14 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun ContentBlock.renderPackage(node: DocumentationNode) {
-        keyword("package")
-        text(" ")
-        identifier(node.name)
-    }
-
-    private fun <T> ContentBlock.renderList(nodes: List<T>, separator: String = ", ",
-                                            noWrap: Boolean = false, renderItem: (T) -> Unit) {
-        if (nodes.none())
-            return
-        renderItem(nodes.first())
-        nodes.drop(1).forEach {
-            if (noWrap) {
-                symbol(separator.removeSuffix(" "))
-                nbsp()
-            } else {
-                symbol(separator)
-            }
-            renderItem(it)
-        }
-    }
-
-    private fun ContentBlock.renderLinked(node: DocumentationNode, body: ContentBlock.(DocumentationNode) -> Unit) {
-        val to = node.links.firstOrNull()
-        if (to == null)
-            body(node)
-        else
-            link(to) {
-                body(node)
-            }
-    }
-
     private fun ContentBlock.renderFunctionalTypeParameterName(node: DocumentationNode, renderMode: RenderMode) {
         node.references(RefKind.HiddenAnnotation).map { it.to }
-                .find { it.name == "ParameterName" }?.let {
-            val parameterNameValue = it.detail(NodeKind.Parameter).detail(NodeKind.Value)
-            identifier(parameterNameValue.name.removeSurrounding("\""), IdentifierKind.ParameterName)
-            symbol(":")
-            nbsp()
-        }
+            .find { it.name == "ParameterName" }?.let {
+                val parameterNameValue = it.detail(NodeKind.Parameter).detail(NodeKind.Value)
+                identifier(parameterNameValue.name.removeSurrounding("\""), IdentifierKind.ParameterName)
+                symbol(":")
+                nbsp()
+            }
     }
 
     private fun ContentBlock.renderFunctionalType(node: DocumentationNode, renderMode: RenderMode) {
@@ -198,7 +170,7 @@ class KotlinLanguageService : LanguageService {
             renderAnnotationsForNode(node)
         }
         renderModifiersForNode(node, renderMode, true)
-        renderLinked(node) { identifier(it.name, IdentifierKind.TypeName) }
+        renderLinked(this, node) { identifier(it.name, IdentifierKind.TypeName) }
         val typeArguments = node.details(NodeKind.Type)
         if (typeArguments.isNotEmpty()) {
             symbol("<")
@@ -213,17 +185,16 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun ContentBlock.renderModifier(node: DocumentationNode, nowrap: Boolean = false) {
+    override fun renderModifier(
+        block: ContentBlock,
+        node: DocumentationNode,
+        nowrap: Boolean
+    ) {
         when (node.name) {
             "final", "public", "var" -> {
             }
             else -> {
-                keyword(node.name)
-                if (nowrap) {
-                    nbsp()
-                } else {
-                    text(" ")
-                }
+                super.renderModifier(block, node, nowrap)
             }
         }
     }
@@ -275,9 +246,12 @@ class KotlinLanguageService : LanguageService {
     }
 
     private fun ContentBlock.renderExtraTypeParameterConstraints(node: DocumentationNode, renderMode: RenderMode) {
-        val parametersWithMultipleConstraints = node.details(NodeKind.TypeParameter).filter { it.details(NodeKind.UpperBound).size > 1 }
+        val parametersWithMultipleConstraints =
+            node.details(NodeKind.TypeParameter).filter { it.details(NodeKind.UpperBound).size > 1 }
         val parametersWithConstraints = parametersWithMultipleConstraints
-                .flatMap { parameter -> parameter.details(NodeKind.UpperBound).map { constraint -> parameter to constraint } }
+            .flatMap { parameter ->
+                parameter.details(NodeKind.UpperBound).map { constraint -> parameter to constraint }
+            }
         if (parametersWithMultipleConstraints.isNotEmpty()) {
             keyword(" where ")
             renderList(parametersWithConstraints) {
@@ -303,9 +277,11 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun ContentBlock.renderModifiersForNode(node: DocumentationNode,
-                                                    renderMode: RenderMode,
-                                                    nowrap: Boolean = false) {
+    private fun ContentBlock.renderModifiersForNode(
+        node: DocumentationNode,
+        renderMode: RenderMode,
+        nowrap: Boolean = false
+    ) {
         val modifiers = node.details(NodeKind.Modifier)
         for (it in modifiers) {
             if (node.kind == org.jetbrains.dokka.NodeKind.Interface && it.name == "abstract")
@@ -313,7 +289,7 @@ class KotlinLanguageService : LanguageService {
             if (renderMode == RenderMode.SUMMARY && it.name in fullOnlyModifiers) {
                 continue
             }
-            renderModifier(it, nowrap)
+            renderModifier(this, it, nowrap)
         }
     }
 
@@ -366,9 +342,11 @@ class KotlinLanguageService : LanguageService {
         }
     }
 
-    private fun ContentBlock.renderFunction(node: DocumentationNode,
-                                            renderMode: RenderMode,
-                                            signatureMapper: SignatureMapper? = null) {
+    private fun ContentBlock.renderFunction(
+        node: DocumentationNode,
+        renderMode: RenderMode,
+        signatureMapper: SignatureMapper? = null
+    ) {
         if (renderMode == RenderMode.FULL) {
             renderAnnotationsForNode(node)
         }
@@ -408,7 +386,11 @@ class KotlinLanguageService : LanguageService {
         renderExtraTypeParameterConstraints(node, renderMode)
     }
 
-    private fun ContentBlock.renderReceiver(node: DocumentationNode, renderMode: RenderMode, signatureMapper: SignatureMapper?) {
+    private fun ContentBlock.renderReceiver(
+        node: DocumentationNode,
+        renderMode: RenderMode,
+        signatureMapper: SignatureMapper?
+    ) {
         val receiver = node.details(NodeKind.Receiver).singleOrNull()
         if (receiver != null) {
             if (signatureMapper != null) {
@@ -434,11 +416,13 @@ class KotlinLanguageService : LanguageService {
     }
 
     fun DocumentationNode.isUnitReturnType(): Boolean =
-            detail(NodeKind.Type).hiddenLinks.firstOrNull()?.qualifiedName() == "kotlin.Unit"
+        detail(NodeKind.Type).hiddenLinks.firstOrNull()?.qualifiedName() == "kotlin.Unit"
 
-    private fun ContentBlock.renderProperty(node: DocumentationNode,
-                                            renderMode: RenderMode,
-                                            signatureMapper: SignatureMapper? = null) {
+    private fun ContentBlock.renderProperty(
+        node: DocumentationNode,
+        renderMode: RenderMode,
+        signatureMapper: SignatureMapper? = null
+    ) {
         if (renderMode == RenderMode.FULL) {
             renderAnnotationsForNode(node)
         }
@@ -462,7 +446,7 @@ class KotlinLanguageService : LanguageService {
     }
 
     fun DocumentationNode.getPropertyKeyword() =
-            if (details(NodeKind.Modifier).any { it.name == "var" }) "var" else "val"
+        if (details(NodeKind.Modifier).any { it.name == "var" }) "var" else "val"
 
     fun ContentBlock.identifierOrDeprecated(node: DocumentationNode) {
         if (node.deprecation != null) {
@@ -476,6 +460,6 @@ class KotlinLanguageService : LanguageService {
 }
 
 fun DocumentationNode.qualifiedNameFromType() =
-        details.firstOrNull { it.kind == NodeKind.QualifiedName }?.name
-                ?: (links.firstOrNull() ?: hiddenLinks.firstOrNull())?.qualifiedName()
-                ?: name
+    details.firstOrNull { it.kind == NodeKind.QualifiedName }?.name
+            ?: (links.firstOrNull() ?: hiddenLinks.firstOrNull())?.qualifiedName()
+            ?: name
diff --git a/core/src/main/kotlin/Languages/CommonLanguageService.kt b/core/src/main/kotlin/Languages/CommonLanguageService.kt
new file mode 100644
index 00000000..f155192d
--- /dev/null
+++ b/core/src/main/kotlin/Languages/CommonLanguageService.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.dokka
+
+
+abstract class CommonLanguageService : LanguageService {
+
+    protected fun ContentBlock.renderPackage(node: DocumentationNode) {
+        keyword("package")
+        nbsp()
+        identifier(node.name)
+    }
+
+    override fun renderName(node: DocumentationNode): String {
+        return when (node.kind) {
+            NodeKind.Constructor -> node.owner!!.name
+            else -> node.name
+        }
+    }
+
+    open fun renderModifier(
+        block: ContentBlock,
+        node: DocumentationNode,
+        nowrap: Boolean = false
+    ) = with(block) {
+        keyword(node.name)
+        if (nowrap) {
+            nbsp()
+        } else {
+            text(" ")
+        }
+    }
+
+    protected fun renderLinked(
+        block: ContentBlock,
+        node: DocumentationNode,
+        body: ContentBlock.(DocumentationNode) -> Unit
+    ) = with(block) {
+        val to = node.links.firstOrNull()
+        if (to == null)
+            body(node)
+        else
+            link(to) {
+                this.body(node)
+            }
+    }
+
+    protected fun <T> ContentBlock.renderList(
+        nodes: List<T>, separator: String = ", ",
+        noWrap: Boolean = false, renderItem: (T) -> Unit
+    ) {
+        if (nodes.none())
+            return
+        renderItem(nodes.first())
+        nodes.drop(1).forEach {
+            if (noWrap) {
+                symbol(separator.removeSuffix(" "))
+                nbsp()
+            } else {
+                symbol(separator)
+            }
+            renderItem(it)
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Languages/NewJavaLanguageService.kt b/core/src/main/kotlin/Languages/NewJavaLanguageService.kt
new file mode 100644
index 00000000..22ad62b2
--- /dev/null
+++ b/core/src/main/kotlin/Languages/NewJavaLanguageService.kt
@@ -0,0 +1,190 @@
+package org.jetbrains.dokka
+
+/**
+ * Implements [LanguageService] and provides rendering of symbols in Java language
+ */
+class NewJavaLanguageService : CommonLanguageService() {
+    override fun render(node: DocumentationNode, renderMode: LanguageService.RenderMode): ContentNode {
+        return content {
+            (when (node.kind) {
+                NodeKind.Package -> renderPackage(node)
+                in NodeKind.classLike -> renderClass(node)
+
+                NodeKind.Modifier -> renderModifier(this, node)
+                NodeKind.TypeParameter -> renderTypeParameter(node)
+                NodeKind.Type,
+                NodeKind.UpperBound -> renderType(node)
+
+                NodeKind.Constructor,
+                NodeKind.Function -> renderFunction(node)
+                NodeKind.Property -> renderProperty(node)
+                else -> "${node.kind}: ${node.name}"
+            })
+        }
+    }
+
+    override fun summarizeSignatures(nodes: List<DocumentationNode>): ContentNode? = null
+
+
+    override fun renderModifier(block: ContentBlock, node: DocumentationNode, nowrap: Boolean) {
+        when (node.name) {
+            "open", "internal" -> {
+            }
+            else -> super.renderModifier(block, node, nowrap)
+        }
+    }
+
+    fun getArrayElementType(node: DocumentationNode): DocumentationNode? = when (node.qualifiedName()) {
+        "kotlin.Array" ->
+            node.details(NodeKind.Type).singleOrNull()?.let { et -> getArrayElementType(et) ?: et }
+                    ?: DocumentationNode("Object", node.content, NodeKind.ExternalClass)
+
+        "kotlin.IntArray", "kotlin.LongArray", "kotlin.ShortArray", "kotlin.ByteArray",
+        "kotlin.CharArray", "kotlin.DoubleArray", "kotlin.FloatArray", "kotlin.BooleanArray" ->
+            DocumentationNode(node.name.removeSuffix("Array").toLowerCase(), node.content, NodeKind.Type)
+
+        else -> null
+    }
+
+    fun getArrayDimension(node: DocumentationNode): Int = when (node.qualifiedName()) {
+        "kotlin.Array" ->
+            1 + (node.details(NodeKind.Type).singleOrNull()?.let { getArrayDimension(it) } ?: 0)
+
+        "kotlin.IntArray", "kotlin.LongArray", "kotlin.ShortArray", "kotlin.ByteArray",
+        "kotlin.CharArray", "kotlin.DoubleArray", "kotlin.FloatArray", "kotlin.BooleanArray" ->
+            1
+        else -> 0
+    }
+
+    fun ContentBlock.renderType(node: DocumentationNode) {
+        when (node.name) {
+            "Unit" -> identifier("void")
+            "Int" -> identifier("int")
+            "Long" -> identifier("long")
+            "Double" -> identifier("double")
+            "Float" -> identifier("float")
+            "Char" -> identifier("char")
+            "Boolean" -> identifier("bool")
+        // TODO: render arrays
+            else -> renderLinked(this, node) {
+                identifier(node.name)
+            }
+        }
+    }
+
+    private fun ContentBlock.renderTypeParameter(node: DocumentationNode) {
+        val constraints = node.details(NodeKind.UpperBound)
+        if (constraints.none())
+            identifier(node.name)
+        else {
+            identifier(node.name)
+            text(" ")
+            keyword("extends")
+            text(" ")
+            constraints.forEach { renderType(node) }
+        }
+    }
+
+    private fun ContentBlock.renderParameter(node: DocumentationNode) {
+        renderType(node.detail(NodeKind.Type))
+        text(" ")
+        identifier(node.name)
+    }
+
+    private fun ContentBlock.renderTypeParametersForNode(node: DocumentationNode) {
+        val typeParameters = node.details(NodeKind.TypeParameter)
+        if (typeParameters.any()) {
+            symbol("<")
+            renderList(typeParameters, noWrap = true) {
+                renderTypeParameter(it)
+            }
+            symbol(">")
+            text(" ")
+        }
+    }
+
+//    private fun renderModifiersForNode(node: DocumentationNode): String {
+//        val modifiers = node.details(NodeKind.Modifier).map { renderModifier(it) }.filter { it != "" }
+//        if (modifiers.none())
+//            return ""
+//        return modifiers.joinToString(" ", postfix = " ")
+//    }
+
+    private fun ContentBlock.renderClassKind(node: DocumentationNode) {
+        when (node.kind) {
+            NodeKind.Interface -> {
+                keyword("interface")
+            }
+            NodeKind.EnumItem -> {
+                keyword("enum value")
+            }
+            NodeKind.Enum -> {
+                keyword("enum")
+            }
+            NodeKind.Class, NodeKind.Exception, NodeKind.Object -> {
+                keyword("class")
+            }
+            else -> throw IllegalArgumentException("Node $node is not a class-like object")
+        }
+        text(" ")
+    }
+
+    private fun ContentBlock.renderClass(node: DocumentationNode) {
+        renderClassKind(node)
+
+        identifier(node.name)
+        renderTypeParametersForNode(node)
+    }
+
+    private fun ContentBlock.renderParameters(nodes: List<DocumentationNode>) {
+        renderList(nodes) {
+            renderParameter(it)
+        }
+    }
+
+    private fun ContentBlock.renderFunction(node: DocumentationNode) {
+        when (node.kind) {
+            NodeKind.Constructor -> identifier(node.owner?.name ?: "")
+            NodeKind.Function -> {
+                renderTypeParametersForNode(node)
+                renderType(node.detail(NodeKind.Type))
+                text(" ")
+                identifier(node.name)
+
+            }
+            else -> throw IllegalArgumentException("Node $node is not a function-like object")
+        }
+
+        val receiver = node.details(NodeKind.Receiver).singleOrNull()
+        symbol("(")
+        if (receiver != null)
+            renderParameters(listOf(receiver) + node.details(NodeKind.Parameter))
+        else
+            renderParameters(node.details(NodeKind.Parameter))
+
+        symbol(")")
+    }
+
+    private fun ContentBlock.renderProperty(node: DocumentationNode) {
+
+        when (node.kind) {
+            NodeKind.Property -> {
+                keyword("val")
+                text(" ")
+            }
+            else -> throw IllegalArgumentException("Node $node is not a property")
+        }
+        renderTypeParametersForNode(node)
+        val receiver = node.details(NodeKind.Receiver).singleOrNull()
+        if (receiver != null) {
+            renderType(receiver.detail(NodeKind.Type))
+            symbol(".")
+        }
+
+        identifier(node.name)
+        symbol(":")
+        text(" ")
+        renderType(node.detail(NodeKind.Type))
+
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 85ecdf87..84501d2b 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -63,7 +63,7 @@ enum class NodeKind {
 
     companion object {
         val classLike = setOf(Class, Interface, Enum, AnnotationClass, Exception, Object, TypeAlias)
-        val memberLike = setOf(Function, Property, Constructor, CompanionObjectFunction, CompanionObjectProperty, EnumItem)
+        val memberLike = setOf(Function, Property, Field, Constructor, CompanionObjectFunction, CompanionObjectProperty, EnumItem)
     }
 }
 
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index b0f011be..89ec1b3e 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -62,7 +62,7 @@ class NodeReferenceGraph() {
     fun lookupOrWarn(signature: String, logger: DokkaLogger): DocumentationNode? {
         val result = nodeMap[signature]
         if (result == null) {
-            logger.warn("Can't find node by signature $signature")
+            logger.warn("Can't find node by signature `$signature`")
         }
         return result
     }
-- 
cgit 


From a3f16fd75c200020465f79563ca58b2833236865 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Tue, 24 Apr 2018 20:35:42 +0300
Subject: [backport] Stabilize signatures to fix linking from Java to Kotlin

Basically there is 2 ways to get signature, from PSI and from
descriptors, and there should be only one way in one session

Original: adc09f2
---
 .../main/kotlin/Analysis/AnalysisEnvironment.kt    |   3 +-
 .../main/kotlin/Analysis/JavaResolveExtension.kt   | 131 +++++++++++++++++++++
 core/src/main/kotlin/Formats/AnalysisComponents.kt |  14 +--
 .../kotlin/Java/JavaPsiDocumentationBuilder.kt     |   6 +-
 core/src/main/kotlin/Java/JavadocParser.kt         |   5 +-
 .../main/kotlin/Kotlin/DeclarationLinkResolver.kt  |   7 +-
 .../kotlin/Kotlin/DescriptorDocumentationParser.kt |   6 +-
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt |  23 ++--
 .../KotlinAsJavaDescriptorSignatureProvider.kt     |  22 ----
 .../Kotlin/KotlinAsJavaElementSignatureProvider.kt |  25 ++++
 .../Kotlin/KotlinDescriptorSignatureProvider.kt    |   9 --
 .../Kotlin/KotlinElementSignatureProvider.kt       |  31 +++++
 .../kotlin/Model/DescriptorSignatureProvider.kt    |   7 --
 core/src/main/kotlin/Model/DocumentationNode.kt    |   7 +-
 .../main/kotlin/Model/ElementSignatureProvider.kt  |   9 ++
 core/src/main/kotlin/Utilities/DokkaModules.kt     |   3 -
 16 files changed, 230 insertions(+), 78 deletions(-)
 create mode 100644 core/src/main/kotlin/Analysis/JavaResolveExtension.kt
 delete mode 100644 core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt
 create mode 100644 core/src/main/kotlin/Kotlin/KotlinAsJavaElementSignatureProvider.kt
 delete mode 100644 core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt
 create mode 100644 core/src/main/kotlin/Kotlin/KotlinElementSignatureProvider.kt
 delete mode 100644 core/src/main/kotlin/Model/DescriptorSignatureProvider.kt
 create mode 100644 core/src/main/kotlin/Model/ElementSignatureProvider.kt

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
index b2e4b490..6854b323 100644
--- a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
+++ b/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.getService
+import org.jetbrains.kotlin.container.tryGetService
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -250,7 +251,7 @@ class DokkaResolutionFacade(override val project: Project,
     }
 
     override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
-        return null
+        return resolverForModule.componentProvider.tryGetService(serviceClass)
     }
 
     override fun resolveToDescriptor(declaration: KtDeclaration, bodyResolveMode: BodyResolveMode): DeclarationDescriptor {
diff --git a/core/src/main/kotlin/Analysis/JavaResolveExtension.kt b/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
new file mode 100644
index 00000000..f8992d45
--- /dev/null
+++ b/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("JavaResolutionUtils")
+
+package org.jetbrains.dokka
+
+import com.intellij.psi.*
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.unwrapped
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
+import org.jetbrains.kotlin.load.java.structure.*
+import org.jetbrains.kotlin.load.java.structure.impl.*
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.psiUtil.parameterIndex
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+
+// TODO: Remove that file
+
+@JvmOverloads
+fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val method = originalElement as? PsiMethod ?: return null
+    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
+    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
+    return when {
+        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
+        else -> resolver?.resolveMethod(JavaMethodImpl(method))
+    }
+}
+
+@JvmOverloads
+fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
+    val psiClass = originalElement as? PsiClass ?: return null
+    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
+}
+
+@JvmOverloads
+fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
+    val field = originalElement as? PsiField ?: return null
+    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
+}
+
+@JvmOverloads
+fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    return when (this) {
+        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
+        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
+        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
+        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
+        else -> null
+    }
+}
+
+@JvmOverloads
+fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val callable = unwrapped
+    return when (callable) {
+        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
+        is KtDeclaration -> {
+            val descriptor = resolutionFacade.resolveToDescriptor(callable)
+            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
+        }
+        else -> null
+    }
+}
+
+private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
+    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
+}
+
+private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
+    return getContainingScope(method)
+            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
+            ?.filterIsInstance<DeclarationDescriptorWithSource>()
+            ?.findByJavaElement(method)
+}
+
+private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
+    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
+}
+
+private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
+    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
+}
+
+private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
+    val containingClass = resolveClass(member.containingClass)
+    return if (member.isStatic)
+        containingClass?.staticScope
+    else
+        containingClass?.defaultType?.memberScope
+}
+
+private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
+    return firstOrNull { member ->
+        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
+        when {
+            memberJavaElement == javaElement ->
+                true
+            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
+                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
+            else ->
+                false
+        }
+    }
+}
+
+fun PsiElement.javaResolutionFacade() =
+    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)
diff --git a/core/src/main/kotlin/Formats/AnalysisComponents.kt b/core/src/main/kotlin/Formats/AnalysisComponents.kt
index c4d97dbb..d78d4a0c 100644
--- a/core/src/main/kotlin/Formats/AnalysisComponents.kt
+++ b/core/src/main/kotlin/Formats/AnalysisComponents.kt
@@ -2,9 +2,9 @@ package org.jetbrains.dokka.Formats
 
 import com.google.inject.Binder
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Kotlin.KotlinAsJavaDescriptorSignatureProvider
-import org.jetbrains.dokka.Kotlin.KotlinDescriptorSignatureProvider
-import org.jetbrains.dokka.Model.DescriptorSignatureProvider
+import org.jetbrains.dokka.KotlinAsJavaElementSignatureProvider
+import org.jetbrains.dokka.KotlinElementSignatureProvider
+import org.jetbrains.dokka.ElementSignatureProvider
 import org.jetbrains.dokka.Samples.DefaultSampleProcessingService
 import org.jetbrains.dokka.Samples.SampleProcessingService
 import org.jetbrains.dokka.Utilities.bind
@@ -16,12 +16,12 @@ interface DefaultAnalysisComponentServices {
     val packageDocumentationBuilderClass: KClass<out PackageDocumentationBuilder>
     val javaDocumentationBuilderClass: KClass<out JavaDocumentationBuilder>
     val sampleProcessingService: KClass<out SampleProcessingService>
-    val descriptorSignatureProvider: KClass<out DescriptorSignatureProvider>
+    val elementSignatureProvider: KClass<out ElementSignatureProvider>
 }
 
 interface DefaultAnalysisComponent : FormatDescriptorAnalysisComponent, DefaultAnalysisComponentServices {
     override fun configureAnalysis(binder: Binder): Unit = with(binder) {
-        bind<DescriptorSignatureProvider>() toType descriptorSignatureProvider
+        bind<ElementSignatureProvider>() toType elementSignatureProvider
         bind<PackageDocumentationBuilder>() toType packageDocumentationBuilderClass
         bind<JavaDocumentationBuilder>() toType javaDocumentationBuilderClass
         bind<SampleProcessingService>() toType sampleProcessingService
@@ -33,7 +33,7 @@ object KotlinAsJava : DefaultAnalysisComponentServices {
     override val packageDocumentationBuilderClass = KotlinAsJavaDocumentationBuilder::class
     override val javaDocumentationBuilderClass = JavaPsiDocumentationBuilder::class
     override val sampleProcessingService = DefaultSampleProcessingService::class
-    override val descriptorSignatureProvider = KotlinAsJavaDescriptorSignatureProvider::class
+    override val elementSignatureProvider = KotlinAsJavaElementSignatureProvider::class
 }
 
 
@@ -41,5 +41,5 @@ object KotlinAsKotlin : DefaultAnalysisComponentServices {
     override val packageDocumentationBuilderClass = KotlinPackageDocumentationBuilder::class
     override val javaDocumentationBuilderClass = KotlinJavaDocumentationBuilder::class
     override val sampleProcessingService = DefaultSampleProcessingService::class
-    override val descriptorSignatureProvider = KotlinDescriptorSignatureProvider::class
+    override val elementSignatureProvider = KotlinElementSignatureProvider::class
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt b/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt
index cf2b0514..646096e5 100644
--- a/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt
+++ b/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt
@@ -45,10 +45,10 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder {
     private val refGraph: NodeReferenceGraph
     private val docParser: JavaDocumentationParser
 
-    @Inject constructor(options: DocumentationOptions, refGraph: NodeReferenceGraph, logger: DokkaLogger) {
+    @Inject constructor(options: DocumentationOptions, refGraph: NodeReferenceGraph, logger: DokkaLogger, signatureProvider: ElementSignatureProvider) {
         this.options = options
         this.refGraph = refGraph
-        this.docParser = JavadocParser(refGraph, logger)
+        this.docParser = JavadocParser(refGraph, logger, signatureProvider)
     }
 
     constructor(options: DocumentationOptions, refGraph: NodeReferenceGraph, docParser: JavaDocumentationParser) {
@@ -61,7 +61,7 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder {
         if (skipFile(file) || file.classes.all { skipElement(it) }) {
             return
         }
-        val packageNode = module.findOrCreatePackageNode(file.packageName, emptyMap(), refGraph)
+        val packageNode = findOrCreatePackageNode(module, file.packageName, emptyMap(), refGraph)
         appendClasses(packageNode, file.classes)
     }
 
diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index db61a00a..365ae298 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -22,7 +22,8 @@ interface JavaDocumentationParser {
 
 class JavadocParser(
     private val refGraph: NodeReferenceGraph,
-    private val logger: DokkaLogger
+    private val logger: DokkaLogger,
+    private val signatureProvider: ElementSignatureProvider
 ) : JavaDocumentationParser {
     override fun parseDocumentation(element: PsiNamedElement): JavadocParseResult {
         val docComment = (element as? PsiDocCommentOwner)?.docComment
@@ -157,7 +158,7 @@ class JavadocParser(
     private fun resolveLink(valueElement: PsiElement?): String? {
         val target = valueElement?.reference?.resolve()
         if (target != null) {
-            return getSignature(target)
+            return signatureProvider.signature(target)
         }
         return null
     }
diff --git a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
index ec474900..d73bef4a 100644
--- a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
+++ b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
@@ -1,13 +1,10 @@
 package org.jetbrains.dokka
 
 import com.google.inject.Inject
-import org.jetbrains.dokka.Model.DescriptorSignatureProvider
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
 import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPrivateApi
-import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPublicApi
 
 class DeclarationLinkResolver
         @Inject constructor(val resolutionFacade: DokkaResolutionFacade,
@@ -15,7 +12,7 @@ class DeclarationLinkResolver
                             val logger: DokkaLogger,
                             val options: DocumentationOptions,
                             val externalDocumentationLinkResolver: ExternalDocumentationLinkResolver,
-                            val descriptorSignatureProvider: DescriptorSignatureProvider) {
+                            val elementSignatureProvider: ElementSignatureProvider) {
 
 
     fun tryResolveContentLink(fromDescriptor: DeclarationDescriptor, href: String): ContentBlock? {
@@ -34,7 +31,7 @@ class DeclarationLinkResolver
             if (externalHref != null) {
                 return ContentExternalLink(externalHref)
             }
-            val signature = descriptorSignatureProvider.signature(symbol)
+            val signature = elementSignatureProvider.signature(symbol)
             val referencedAt = fromDescriptor.signatureWithSourceLocation()
 
             return ContentNodeLazyLink(href, { ->
diff --git a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
index 6e44df74..5f1118e8 100644
--- a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
+++ b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
@@ -33,7 +33,9 @@ class DescriptorDocumentationParser
                              val linkResolver: DeclarationLinkResolver,
                              val resolutionFacade: DokkaResolutionFacade,
                              val refGraph: NodeReferenceGraph,
-                             val sampleService: SampleProcessingService)
+                             val sampleService: SampleProcessingService,
+                             val signatureProvider: KotlinElementSignatureProvider
+         )
 {
     fun parseDocumentation(descriptor: DeclarationDescriptor, inline: Boolean = false): Content =
             parseDocumentationAndDetails(descriptor, inline).first
@@ -129,7 +131,7 @@ class DescriptorDocumentationParser
     fun parseJavadoc(descriptor: DeclarationDescriptor): Pair<Content, (DocumentationNode) -> Unit> {
         val psi = ((descriptor as? DeclarationDescriptorWithSource)?.source as? PsiSourceElement)?.psi
         if (psi is PsiDocCommentOwner) {
-            val parseResult = JavadocParser(refGraph, logger).parseDocumentation(psi as PsiNamedElement)
+            val parseResult = JavadocParser(refGraph, logger, signatureProvider).parseDocumentation(psi as PsiNamedElement)
             return parseResult.content to { node ->
                 parseResult.deprecatedContent?.let {
                     val deprecationNode = DocumentationNode("", it, NodeKind.Modifier)
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index d7d30ebb..05bd2cc7 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.idea.util.toFuzzyType
 import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -29,7 +28,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.*
 import org.jetbrains.kotlin.resolve.findTopMostOverriddenDescriptors
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
@@ -192,14 +190,16 @@ class DocumentationBuilder
         appendTextNode(modifier, NodeKind.Modifier)
     }
 
-    fun DocumentationNode.appendSupertype(descriptor: ClassDescriptor, superType: KotlinType) {
+    fun DocumentationNode.appendSupertype(descriptor: ClassDescriptor, superType: KotlinType, backref: Boolean) {
         val unwrappedType = superType.unwrap()
         if (unwrappedType is AbbreviatedType) {
-            appendSupertype(descriptor, unwrappedType.abbreviation)
+            appendSupertype(descriptor, unwrappedType.abbreviation, backref)
         } else {
             appendType(unwrappedType, NodeKind.Supertype)
             val superclass = unwrappedType.constructor.declarationDescriptor
-            link(superclass, descriptor, RefKind.Inheritor)
+            if (backref) {
+                link(superclass, descriptor, RefKind.Inheritor)
+            }
             link(descriptor, superclass, RefKind.Superclass)
         }
     }
@@ -457,7 +457,7 @@ class DocumentationBuilder
 
             if (options.skipEmptyPackages && declarations.none { it.isDocumented(options) }) continue
             logger.info("  package $packageName: ${declarations.count()} declarations")
-            val packageNode = findOrCreatePackageNode(packageName.asString(), packageContent, this@DocumentationBuilder.refGraph)
+            val packageNode = findOrCreatePackageNode(this, packageName.asString(), packageContent, this@DocumentationBuilder.refGraph)
             packageDocumentationBuilder.buildPackageDocumentation(this@DocumentationBuilder, packageName, packageNode,
                     declarations, allFqNames)
         }
@@ -646,7 +646,7 @@ class DocumentationBuilder
         val node = nodeForDescriptor(this, kind, external)
         register(this, node)
         typeConstructor.supertypes.forEach {
-            node.appendSupertype(this, it)
+            node.appendSupertype(this, it, !external)
         }
         if (getKind() != ClassKind.OBJECT && getKind() != ClassKind.ENUM_ENTRY) {
             node.appendInPageChildren(typeConstructor.parameters, RefKind.Detail)
@@ -997,16 +997,11 @@ class KotlinJavaDocumentationBuilder
                     val logger: DokkaLogger) : JavaDocumentationBuilder {
     override fun appendFile(file: PsiJavaFile, module: DocumentationModule, packageContent: Map<String, Content>) {
         val classDescriptors = file.classes.map {
-            val javaDescriptorResolver = resolutionFacade.getFrontendService(JavaDescriptorResolver::class.java)
-
-            javaDescriptorResolver.resolveClass(JavaClassImpl(it)) ?: run {
-                logger.warn("Cannot find descriptor for Java class ${it.qualifiedName}")
-                null
-            }
+            it.getJavaClassDescriptor(resolutionFacade)
         }
 
         if (classDescriptors.any { it != null && it.isDocumented(options) }) {
-            val packageNode = module.findOrCreatePackageNode(file.packageName, packageContent, documentationBuilder.refGraph)
+            val packageNode = findOrCreatePackageNode(module, file.packageName, packageContent, documentationBuilder.refGraph)
 
             for (descriptor in classDescriptors.filterNotNull()) {
                 with(documentationBuilder) {
diff --git a/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt
deleted file mode 100644
index a3be658e..00000000
--- a/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package org.jetbrains.dokka.Kotlin
-
-import org.jetbrains.dokka.Model.DescriptorSignatureProvider
-import org.jetbrains.dokka.getSignature
-import org.jetbrains.dokka.sourcePsi
-import org.jetbrains.kotlin.asJava.toLightElements
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.KtElement
-
-class KotlinAsJavaDescriptorSignatureProvider : DescriptorSignatureProvider {
-    override fun signature(forDesc: DeclarationDescriptor): String {
-        val sourcePsi = forDesc.sourcePsi()
-        val javaLikePsi = if (sourcePsi is KtElement) {
-            sourcePsi.toLightElements().firstOrNull()
-        } else {
-            sourcePsi
-        }
-
-        return getSignature(javaLikePsi) ?:
-                "not implemented for $forDesc with psi: $sourcePsi"
-    }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/KotlinAsJavaElementSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinAsJavaElementSignatureProvider.kt
new file mode 100644
index 00000000..20ea179e
--- /dev/null
+++ b/core/src/main/kotlin/Kotlin/KotlinAsJavaElementSignatureProvider.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.dokka
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.asJava.toLightElements
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.psi.KtElement
+
+class KotlinAsJavaElementSignatureProvider : ElementSignatureProvider {
+
+    private fun PsiElement.javaLikePsi() = when {
+        this is KtElement -> toLightElements().firstOrNull()
+        else -> this
+    }
+
+    override fun signature(forPsi: PsiElement): String {
+        return getSignature(forPsi.javaLikePsi()) ?:
+                "not implemented for $forPsi"
+    }
+
+    override fun signature(forDesc: DeclarationDescriptor): String {
+        val sourcePsi = forDesc.sourcePsi()
+        return getSignature(sourcePsi?.javaLikePsi()) ?:
+                "not implemented for $forDesc with psi: $sourcePsi"
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt
deleted file mode 100644
index 7ecd0389..00000000
--- a/core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.jetbrains.dokka.Kotlin
-
-import org.jetbrains.dokka.Model.DescriptorSignatureProvider
-import org.jetbrains.dokka.signature
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-
-class KotlinDescriptorSignatureProvider : DescriptorSignatureProvider {
-    override fun signature(forDesc: DeclarationDescriptor): String = forDesc.signature()
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/KotlinElementSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinElementSignatureProvider.kt
new file mode 100644
index 00000000..4f788634
--- /dev/null
+++ b/core/src/main/kotlin/Kotlin/KotlinElementSignatureProvider.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.dokka
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMember
+import com.intellij.psi.PsiNameIdentifierOwner
+import org.jetbrains.kotlin.asJava.elements.KtLightElement
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.resolve.BindingContext
+import javax.inject.Inject
+
+class KotlinElementSignatureProvider @Inject constructor(
+        val resolutionFacade: DokkaResolutionFacade
+) : ElementSignatureProvider {
+    override fun signature(forPsi: PsiElement): String {
+
+        val desc = when (forPsi) {
+            is KtLightElement<*, *> -> return signature(forPsi.kotlinOrigin!!)
+            is PsiMember -> forPsi.getJavaOrKotlinMemberDescriptor(resolutionFacade)
+            else -> resolutionFacade.resolveSession.bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, forPsi]
+        }
+
+        if (desc == null && (forPsi as? PsiNameIdentifierOwner)?.name == "remove") {
+            (forPsi as? PsiMember)?.getJavaOrKotlinMemberDescriptor(resolutionFacade)
+        }
+
+        return desc?.let { signature(it) }
+                ?: run { "no desc for $forPsi in ${(forPsi as? PsiMember)?.containingClass}" }
+    }
+
+    override fun signature(forDesc: DeclarationDescriptor): String = forDesc.signature()
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DescriptorSignatureProvider.kt b/core/src/main/kotlin/Model/DescriptorSignatureProvider.kt
deleted file mode 100644
index 85584e3c..00000000
--- a/core/src/main/kotlin/Model/DescriptorSignatureProvider.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.jetbrains.dokka.Model
-
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-
-interface DescriptorSignatureProvider {
-    fun signature(forDesc: DeclarationDescriptor): String
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 84501d2b..4739d736 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -176,16 +176,17 @@ val DocumentationNode.path: List<DocumentationNode>
         return parent.path + this
     }
 
-fun DocumentationNode.findOrCreatePackageNode(packageName: String, packageContent: Map<String, Content>, refGraph: NodeReferenceGraph): DocumentationNode {
-    val existingNode = members(NodeKind.Package).firstOrNull { it.name == packageName }
+fun findOrCreatePackageNode(module: DocumentationNode?, packageName: String, packageContent: Map<String, Content>, refGraph: NodeReferenceGraph): DocumentationNode {
+    val existingNode = refGraph.lookup(packageName)
     if (existingNode != null) {
         return existingNode
     }
     val newNode = DocumentationNode(packageName,
             packageContent.getOrElse(packageName) { Content.Empty },
             NodeKind.Package)
-    append(newNode, RefKind.Member)
+
     refGraph.register(packageName, newNode)
+    module?.append(newNode, RefKind.Member)
     return newNode
 }
 
diff --git a/core/src/main/kotlin/Model/ElementSignatureProvider.kt b/core/src/main/kotlin/Model/ElementSignatureProvider.kt
new file mode 100644
index 00000000..e8fdde6e
--- /dev/null
+++ b/core/src/main/kotlin/Model/ElementSignatureProvider.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.dokka
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+
+interface ElementSignatureProvider {
+    fun signature(forDesc: DeclarationDescriptor): String
+    fun signature(forPsi: PsiElement): String
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Utilities/DokkaModules.kt b/core/src/main/kotlin/Utilities/DokkaModules.kt
index 36704918..907d5ca7 100644
--- a/core/src/main/kotlin/Utilities/DokkaModules.kt
+++ b/core/src/main/kotlin/Utilities/DokkaModules.kt
@@ -2,14 +2,11 @@ package org.jetbrains.dokka.Utilities
 
 import com.google.inject.Binder
 import com.google.inject.Module
-import com.google.inject.Provider
 import com.google.inject.TypeLiteral
 import com.google.inject.binder.AnnotatedBindingBuilder
 import com.google.inject.name.Names
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.Formats.FormatDescriptor
-import org.jetbrains.dokka.Model.DescriptorSignatureProvider
-import org.jetbrains.dokka.Samples.SampleProcessingService
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import java.io.File
 import kotlin.reflect.KClass
-- 
cgit 


From 54874733ff84998d26e21b57384ad3b2ca151fc2 Mon Sep 17 00:00:00 2001
From: Douglas Sigelbaum <sigelbaum@google.com>
Date: Tue, 24 Apr 2018 20:27:21 -0700
Subject: [backport] Added logic for inherited constants.

Also, switched to using recursively inherited members
instead of just inherited members in the immediate super class.

Original: 56c3558
---
 core/src/main/kotlin/Model/DocumentationNode.kt | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 4739d736..ca298802 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka
 
+import org.jetbrains.dokka.Formats.constantValue
 import java.util.*
 
 enum class NodeKind {
@@ -86,6 +87,8 @@ open class DocumentationNode(val name: String,
         get() = references(RefKind.Member).map { it.to }
     val inheritedMembers: List<DocumentationNode>
         get() = references(RefKind.InheritedMember).map { it.to }
+    val allInheritedMembers: List<DocumentationNode>
+        get() = recursiveInheritedMembers()
     val inheritedCompanionObjectMembers: List<DocumentationNode>
         get() = references(RefKind.InheritedCompanionObjectMember).map { it.to }
     val extensions: List<DocumentationNode>
@@ -145,7 +148,6 @@ open class DocumentationNode(val name: String,
         }
         (content as MutableContent).body()
     }
-
     fun details(kind: NodeKind): List<DocumentationNode> = details.filter { it.kind == kind }
     fun members(kind: NodeKind): List<DocumentationNode> = members.filter { it.kind == kind }
     fun inheritedMembers(kind: NodeKind): List<DocumentationNode> = inheritedMembers.filter { it.kind == kind }
@@ -217,3 +219,17 @@ fun DocumentationNode.qualifiedName(): String {
 }
 
 fun DocumentationNode.simpleName() = name.substringAfterLast('.')
+
+private fun DocumentationNode.recursiveInheritedMembers(): List<DocumentationNode> {
+    val allInheritedMembers = mutableListOf<DocumentationNode>()
+    recursiveInheritedMembers(allInheritedMembers)
+    return allInheritedMembers
+}
+
+private fun DocumentationNode.recursiveInheritedMembers(allInheritedMembers: MutableList<DocumentationNode>) {
+    allInheritedMembers.addAll(inheritedMembers)
+    System.out.println(allInheritedMembers.size)
+    inheritedMembers.groupBy { it.owner!! } .forEach { (node, _) ->
+        node.recursiveInheritedMembers(allInheritedMembers)
+    }
+}
\ No newline at end of file
-- 
cgit 


From 9539284e5dd72e2676dc5d656b78f21c1c7035ee Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Thu, 26 Apr 2018 19:37:07 +0300
Subject: KT-24109: Fix generation of superclass sequence

---
 core/src/main/kotlin/Kotlin/DocumentationBuilder.kt | 10 +++++++++-
 core/src/main/kotlin/Model/DocumentationNode.kt     | 16 +++++++++++++---
 2 files changed, 22 insertions(+), 4 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index 8fec0bfb..cb35e568 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.supertypes
+import org.jetbrains.kotlin.util.supertypesWithAny
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -645,7 +646,7 @@ class DocumentationBuilder
         }
         val node = nodeForDescriptor(this, kind, external)
         register(this, node)
-        typeConstructor.supertypes.forEach {
+        supertypesWithAnyPrecise().forEach {
             node.appendSupertype(this, it, !external)
         }
         if (getKind() != ClassKind.OBJECT && getKind() != ClassKind.ENUM_ENTRY) {
@@ -1152,3 +1153,10 @@ fun DocumentationNode.generateAllTypesNode() {
 
     append(allTypesNode, RefKind.Member)
 }
+
+fun ClassDescriptor.supertypesWithAnyPrecise(): Collection<KotlinType> {
+    if (KotlinBuiltIns.isAny(this)) {
+        return emptyList()
+    }
+    return typeConstructor.supertypesWithAny()
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index ca298802..a89f5080 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.Formats.constantValue
+import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.util.*
 
 enum class NodeKind {
@@ -115,11 +116,12 @@ open class DocumentationNode(val name: String,
 
     val superclassType: DocumentationNode?
         get() = when (kind) {
-            NodeKind.Supertype -> (links.firstOrNull { it.kind in NodeKind.classLike } ?: externalType)?.superclassType
+            NodeKind.Supertype -> {
+                (links + listOfNotNull(externalType)).firstOrNull { it.kind in NodeKind.classLike }?.superclassType
+            }
             NodeKind.Interface -> null
             in NodeKind.classLike -> supertypes.firstOrNull {
-                it.links.any { it.kind in NodeKind.classLike } ||
-                        it.externalType != null
+                (it.links + listOfNotNull(it.externalType)).any { it.isSuperclassFor(this) }
             }
             else -> null
         }
@@ -232,4 +234,12 @@ private fun DocumentationNode.recursiveInheritedMembers(allInheritedMembers: Mut
     inheritedMembers.groupBy { it.owner!! } .forEach { (node, _) ->
         node.recursiveInheritedMembers(allInheritedMembers)
     }
+}
+
+private fun DocumentationNode.isSuperclassFor(node: DocumentationNode): Boolean {
+    return when(node.kind) {
+        NodeKind.Object, NodeKind.Class, NodeKind.Enum -> kind == NodeKind.Class
+        NodeKind.Exception -> kind == NodeKind.Class || kind == NodeKind.Exception
+        else -> false
+    }
 }
\ No newline at end of file
-- 
cgit 


From a50de81d3d0ce88d2fd8e91a55b203ba49e66eb1 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Fri, 4 May 2018 00:32:40 +0300
Subject: [backport] KT-24028: Add type info to param and return section in
 javadoc

Original: a603157
---
 core/src/main/kotlin/Java/JavadocParser.kt | 23 +++++++++++++++++++++++
 core/src/main/kotlin/Model/Content.kt      | 30 +++++++++++++++++++++++++++++-
 2 files changed, 52 insertions(+), 1 deletion(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index 41b77aed..5e23e357 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -28,6 +28,18 @@ class JavadocParser(
     private val logger: DokkaLogger,
     private val signatureProvider: ElementSignatureProvider
 ) : JavaDocumentationParser {
+
+    private fun ContentSection.appendTypeElement(signature: String, selector: (DocumentationNode) -> DocumentationNode?) {
+        append(LazyContentBlock {
+            val node = refGraph.lookupOrWarn(signature, logger)?.let(selector)
+            if (node != null) {
+                it.append(NodeRenderContent(node, LanguageService.RenderMode.SUMMARY))
+                it.symbol(":")
+                it.text(" ")
+            }
+        })
+    }
+
     override fun parseDocumentation(element: PsiNamedElement): JavadocParseResult {
         val docComment = (element as? PsiDocCommentOwner)?.docComment
         if (docComment == null) return JavadocParseResult.Empty
@@ -49,6 +61,17 @@ class JavadocParser(
             for ((tagName, tags) in tagsByName) {
                 for ((tag, context) in tags) {
                     val section = result.addSection(javadocSectionDisplayName(tagName), tag.getSubjectName())
+                    val signature = signatureProvider.signature(element)
+                    when (tagName) {
+                        "param" -> {
+                            section.appendTypeElement(signature) {
+                                it.details.find { it.kind == NodeKind.Parameter }?.detailOrNull(NodeKind.Type)
+                            }
+                        }
+                        "return" -> {
+                            section.appendTypeElement(signature) { it.detailOrNull(NodeKind.Type) }
+                        }
+                    }
                     section.convertJavadocElements(tag.contentElements(), context)
                 }
             }
diff --git a/core/src/main/kotlin/Model/Content.kt b/core/src/main/kotlin/Model/Content.kt
index 1f5bbc83..010ee7ca 100644
--- a/core/src/main/kotlin/Model/Content.kt
+++ b/core/src/main/kotlin/Model/Content.kt
@@ -9,7 +9,7 @@ object ContentEmpty : ContentNode {
 }
 
 open class ContentBlock() : ContentNode {
-    val children = arrayListOf<ContentNode>()
+    open val children = arrayListOf<ContentNode>()
 
     fun append(node: ContentNode)  {
         children.add(node)
@@ -27,6 +27,34 @@ open class ContentBlock() : ContentNode {
         get() = children.sumBy { it.textLength }
 }
 
+class NodeRenderContent(
+    val node: DocumentationNode,
+    val mode: LanguageService.RenderMode
+): ContentNode {
+    override val textLength: Int
+        get() = 0 //TODO: Clarify?
+}
+
+class LazyContentBlock(private val fillChildren: (ContentBlock) -> Unit) : ContentBlock() {
+    private var computed = false
+    override val children: ArrayList<ContentNode>
+        get() {
+            if (!computed) {
+                computed = true
+                fillChildren(this)
+            }
+            return super.children
+        }
+
+    override fun equals(other: Any?): Boolean {
+        return other is LazyContentBlock && other.fillChildren == fillChildren && super.equals(other)
+    }
+
+    override fun hashCode(): Int {
+        return super.hashCode() + 31 * fillChildren.hashCode()
+    }
+}
+
 enum class IdentifierKind {
     TypeName,
     ParameterName,
-- 
cgit 


From 44ad68386658dde985207ea0aedb19c96d9b3f93 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Mon, 7 May 2018 16:37:12 +0300
Subject: [backport] KT-24277: Persist inpage anchors (aka bookmarks) from
 Javadoc

Original: 4fddba5
---
 core/src/main/kotlin/Java/JavadocParser.kt | 22 +++++++++++++---------
 core/src/main/kotlin/Model/Content.kt      |  2 ++
 2 files changed, 15 insertions(+), 9 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index e1b15cb2..8cd274e7 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -183,15 +183,19 @@ class JavadocParser(
     }
 
     private fun createLink(element: Element): ContentBlock {
-        if (element.hasAttr("docref")) {
-            val docref = element.attr("docref")
-            return ContentNodeLazyLink(docref, { -> refGraph.lookupOrWarn(docref, logger) })
-        }
-        return if (element.hasAttr("href")) {
-            val href = element.attr("href")
-            ContentExternalLink(href)
-        } else {
-            ContentBlock()
+        return when {
+            element.hasAttr("docref") -> {
+                val docref = element.attr("docref")
+                ContentNodeLazyLink(docref, { -> refGraph.lookupOrWarn(docref, logger) })
+            }
+            element.hasAttr("href") -> {
+                val href = element.attr("href")
+                ContentExternalLink(href)
+            }
+            element.hasAttr("name") -> {
+                ContentBookmark(element.attr("name"))
+            }
+            else -> ContentBlock()
         }
     }
 
diff --git a/core/src/main/kotlin/Model/Content.kt b/core/src/main/kotlin/Model/Content.kt
index 010ee7ca..4f142ca4 100644
--- a/core/src/main/kotlin/Model/Content.kt
+++ b/core/src/main/kotlin/Model/Content.kt
@@ -148,6 +148,8 @@ class ContentExternalLink(val href : String) : ContentBlock() {
         children.hashCode() * 31 + href.hashCode()
 }
 
+data class ContentBookmark(val name: String): ContentBlock()
+
 class ContentUnorderedList() : ContentBlock()
 class ContentOrderedList() : ContentBlock()
 class ContentListItem() : ContentBlock()
-- 
cgit 


From 4301503416ed45783a81250295adf4b5a86c4280 Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Mon, 7 May 2018 17:28:22 +0300
Subject: [backport] KT-24299: Fix local links resolved in incorrect context

Original: fababd4
---
 core/src/main/kotlin/Java/JavadocParser.kt | 14 +++++++++++++-
 core/src/main/kotlin/Model/Content.kt      |  1 +
 2 files changed, 14 insertions(+), 1 deletion(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index 8cd274e7..9f9ea017 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -12,6 +12,7 @@ import org.jsoup.Jsoup
 import org.jsoup.nodes.Element
 import org.jsoup.nodes.Node
 import org.jsoup.nodes.TextNode
+import java.net.URI
 
 data class JavadocParseResult(val content: Content, val deprecatedContent: Content?) {
     companion object {
@@ -190,7 +191,18 @@ class JavadocParser(
             }
             element.hasAttr("href") -> {
                 val href = element.attr("href")
-                ContentExternalLink(href)
+
+                val uri = try {
+                    URI(href)
+                } catch (_: Exception) {
+                    null
+                }
+
+                if (uri?.isAbsolute == false) {
+                    ContentLocalLink(href)
+                } else {
+                    ContentExternalLink(href)
+                }
             }
             element.hasAttr("name") -> {
                 ContentBookmark(element.attr("name"))
diff --git a/core/src/main/kotlin/Model/Content.kt b/core/src/main/kotlin/Model/Content.kt
index 4f142ca4..7c776bdb 100644
--- a/core/src/main/kotlin/Model/Content.kt
+++ b/core/src/main/kotlin/Model/Content.kt
@@ -149,6 +149,7 @@ class ContentExternalLink(val href : String) : ContentBlock() {
 }
 
 data class ContentBookmark(val name: String): ContentBlock()
+data class ContentLocalLink(val href: String) : ContentBlock()
 
 class ContentUnorderedList() : ContentBlock()
 class ContentOrderedList() : ContentBlock()
-- 
cgit 


From f301316151dc15b67d926423021abc5e3313aa2a Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Mon, 7 May 2018 20:08:43 +0300
Subject: KT-24300: Support inclusion overview.html into package summary

---
 core/src/main/kotlin/Generation/DokkaGenerator.kt | 15 ++++-
 core/src/main/kotlin/Model/PackageDocs.kt         | 69 ++++++++++++++++++++++-
 2 files changed, 82 insertions(+), 2 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 33170f35..91471849 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
-import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 import kotlin.system.measureTimeMillis
 
@@ -157,6 +156,8 @@ fun buildDocumentationModule(injector: Injector,
         }
     }
 
+    parseJavaPackageDocs(packageDocs, coreEnvironment)
+
     with(injector.getInstance(DocumentationBuilder::class.java)) {
         documentationModule.appendFragments(fragments, packageDocs.packageContent,
                 injector.getInstance(PackageDocumentationBuilder::class.java))
@@ -170,6 +171,18 @@ fun buildDocumentationModule(injector: Injector,
     }
 }
 
+fun parseJavaPackageDocs(packageDocs: PackageDocs, coreEnvironment: KotlinCoreEnvironment) {
+    val contentRoots = coreEnvironment.configuration.get(JVMConfigurationKeys.CONTENT_ROOTS)
+            ?.filterIsInstance<JavaSourceRoot>()
+            ?.map { it.file }
+            ?: listOf()
+    contentRoots.forEach { root ->
+        root.walkTopDown().filter { it.name == "overview.html" }.forEach {
+            packageDocs.parseJava(it.path, it.relativeTo(root).parent.replace("/", "."))
+        }
+    }
+}
+
 
 fun KotlinCoreEnvironment.getJavaSourceFiles(): List<PsiJavaFile> {
     val sourceRoots = configuration.get(JVMConfigurationKeys.CONTENT_ROOTS)
diff --git a/core/src/main/kotlin/Model/PackageDocs.kt b/core/src/main/kotlin/Model/PackageDocs.kt
index 1f6bdcb9..5b628914 100644
--- a/core/src/main/kotlin/Model/PackageDocs.kt
+++ b/core/src/main/kotlin/Model/PackageDocs.kt
@@ -2,16 +2,25 @@ package org.jetbrains.dokka
 
 import com.google.inject.Inject
 import com.google.inject.Singleton
+import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiFileFactory
+import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.util.LocalTimeCounter
 import org.intellij.markdown.MarkdownElementTypes
 import org.intellij.markdown.MarkdownTokenTypes
 import org.intellij.markdown.parser.LinkMap
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import java.io.File
 
 @Singleton
 class PackageDocs
         @Inject constructor(val linkResolver: DeclarationLinkResolver?,
-                            val logger: DokkaLogger)
+                            val logger: DokkaLogger,
+                            val environment: KotlinCoreEnvironment,
+                            val refGraph: NodeReferenceGraph,
+                            val elementSignatureProvider: ElementSignatureProvider)
 {
     val moduleContent: MutableContent = MutableContent()
     private val _packageContent: MutableMap<String, MutableContent> = hashMapOf()
@@ -40,6 +49,64 @@ class PackageDocs
         }
     }
 
+    private fun parseHtmlAsJavadoc(text: String, packageName: String, file: File) {
+        val javadocText = text
+                .replace("*/", "*&#47;")
+                .removeSurrounding("<html>", "</html>", true).trim()
+                .removeSurrounding("<body>", "</body>", true)
+                .lineSequence()
+                .map { "* $it" }
+                .joinToString (separator = "\n", prefix = "/**\n", postfix = "\n*/")
+        parseJavadoc(javadocText, packageName, file)
+    }
+
+    private fun CharSequence.removeSurrounding(prefix: CharSequence, suffix: CharSequence, ignoringCase: Boolean = false): CharSequence {
+        if ((length >= prefix.length + suffix.length) && startsWith(prefix, ignoringCase) && endsWith(suffix, ignoringCase)) {
+            return subSequence(prefix.length, length - suffix.length)
+        }
+        return subSequence(0, length)
+    }
+
+
+    private fun parseJavadoc(text: String, packageName: String, file: File) {
+
+        val psiFileFactory = PsiFileFactory.getInstance(environment.project)
+        val psiFile = psiFileFactory.createFileFromText(
+                file.nameWithoutExtension + ".java",
+                JavaFileType.INSTANCE,
+                "package $packageName; $text\npublic class C {}",
+                LocalTimeCounter.currentTime(),
+                false,
+                true
+        )
+
+        val psiClass = PsiTreeUtil.getChildOfType(psiFile, PsiClass::class.java)!!
+        val parser = JavadocParser(refGraph, logger, elementSignatureProvider, linkResolver?.externalDocumentationLinkResolver!!)
+        findOrCreatePackageContent(packageName).apply {
+            val content = parser.parseDocumentation(psiClass).content
+            children.addAll(content.children)
+            content.sections.forEach {
+                addSection(it.tag, it.subjectName).children.addAll(it.children)
+            }
+        }
+    }
+
+
+    fun parseJava(fileName: String, packageName: String) {
+        val file = File(fileName)
+        if (file.exists()) {
+            val text = file.readText()
+
+            val trimmedText = text.trim()
+
+            if (trimmedText.startsWith("/**")) {
+                parseJavadoc(text, packageName, file)
+            } else if (trimmedText.toLowerCase().startsWith("<html>")) {
+                parseHtmlAsJavadoc(trimmedText, packageName, file)
+            }
+        }
+    }
+
     private fun findTargetContent(heading: String): MutableContent {
         if (heading.startsWith("Module") || heading.startsWith("module")) {
             return moduleContent
-- 
cgit 


From f30807f4e78939fb59f8e46c39b3e538070aacfd Mon Sep 17 00:00:00 2001
From: Simon Ogorodnik <Simon.Ogorodnik@jetbrains.com>
Date: Sun, 15 Jul 2018 00:48:46 +0300
Subject: Fix missing functions after rebase

---
 core/src/main/kotlin/Analysis/JavaResolveExtension.kt | 2 +-
 core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt  | 3 +--
 core/src/main/kotlin/Generation/DokkaGenerator.kt     | 1 +
 core/src/main/kotlin/Kotlin/KotlinLanguageService.kt  | 1 -
 core/src/main/kotlin/Model/DocumentationNode.kt       | 7 +++++--
 5 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Analysis/JavaResolveExtension.kt b/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
index f8992d45..4dc6b366 100644
--- a/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
+++ b/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
@@ -128,4 +128,4 @@ private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElemen
 }
 
 fun PsiElement.javaResolutionFacade() =
-    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)
+    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)!!
diff --git a/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt b/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt
index f73cd23e..885cdf6c 100644
--- a/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt
+++ b/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt
@@ -6,7 +6,6 @@ import kotlinx.html.li
 import kotlinx.html.stream.appendHTML
 import kotlinx.html.ul
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Kotlin.KotlinDescriptorSignatureProvider
 import org.jetbrains.dokka.Samples.DefaultSampleProcessingService
 import org.jetbrains.dokka.Utilities.bind
 import org.jetbrains.dokka.Utilities.toType
@@ -17,7 +16,7 @@ class JavaLayoutHtmlFormatDescriptor : FormatDescriptor, DefaultAnalysisComponen
     override val packageDocumentationBuilderClass = KotlinPackageDocumentationBuilder::class
     override val javaDocumentationBuilderClass = KotlinJavaDocumentationBuilder::class
     override val sampleProcessingService = DefaultSampleProcessingService::class
-    override val descriptorSignatureProvider = KotlinDescriptorSignatureProvider::class
+    override val elementSignatureProvider = KotlinElementSignatureProvider::class
 
     override fun configureOutput(binder: Binder): Unit = with(binder) {
         bind<Generator>() toType generatorServiceClass
diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 91471849..46fdaf0a 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
+import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 import kotlin.system.measureTimeMillis
 
diff --git a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
index 237fa9b9..6088d3a5 100644
--- a/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
+++ b/core/src/main/kotlin/Kotlin/KotlinLanguageService.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.Formats.classNodeNameWithOuterClass
 import org.jetbrains.dokka.LanguageService.RenderMode
 
 /**
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index a89f5080..a3388031 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,7 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.Formats.constantValue
-import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import java.util.*
 
 enum class NodeKind {
@@ -242,4 +240,9 @@ private fun DocumentationNode.isSuperclassFor(node: DocumentationNode): Boolean
         NodeKind.Exception -> kind == NodeKind.Class || kind == NodeKind.Exception
         else -> false
     }
+}
+
+fun DocumentationNode.classNodeNameWithOuterClass(): String {
+    assert(kind in NodeKind.classLike)
+    return path.dropWhile { it.kind == NodeKind.Package || it.kind == NodeKind.Module }.joinToString(separator = ".") { it.name }
 }
\ No newline at end of file
-- 
cgit 


From 93a9052d8434879f8fdf192d9d498285a6a31127 Mon Sep 17 00:00:00 2001
From: Zubakov Aleksey <aleks.zubakov@gmail.com>
Date: Tue, 17 Jul 2018 17:13:01 +0300
Subject: NodeReferenceGraph style fixes

---
 core/src/main/kotlin/Model/DocumentationReference.kt | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index 89ec1b3e..5db1f05a 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -37,24 +37,24 @@ class PendingDocumentationReference(val lazyNodeFrom: () -> DocumentationNode?,
     }
 }
 
-class NodeReferenceGraph() {
+class NodeReferenceGraph {
     private val nodeMap = hashMapOf<String, DocumentationNode>()
     val references = arrayListOf<PendingDocumentationReference>()
 
     fun register(signature: String, node: DocumentationNode) {
-        nodeMap.put(signature, node)
+        nodeMap[signature] = node
     }
 
     fun link(fromNode: DocumentationNode, toSignature: String, kind: RefKind) {
-        references.add(PendingDocumentationReference({ -> fromNode}, { -> nodeMap[toSignature]}, kind))
+        references.add(PendingDocumentationReference({ fromNode }, { nodeMap[toSignature] }, kind))
     }
 
     fun link(fromSignature: String, toNode: DocumentationNode, kind: RefKind) {
-        references.add(PendingDocumentationReference({ -> nodeMap[fromSignature]}, { -> toNode}, kind))
+        references.add(PendingDocumentationReference({ nodeMap[fromSignature] }, { toNode }, kind))
     }
 
     fun link(fromSignature: String, toSignature: String, kind: RefKind) {
-        references.add(PendingDocumentationReference({ -> nodeMap[fromSignature]}, { -> nodeMap[toSignature]}, kind))
+        references.add(PendingDocumentationReference({ nodeMap[fromSignature] }, { nodeMap[toSignature] }, kind))
     }
 
     fun lookup(signature: String) = nodeMap[signature]
-- 
cgit 


From 899c11d36f565cd192945573860568ff62c16ef2 Mon Sep 17 00:00:00 2001
From: aleksZubakov <aleks.zubakov@gmail.com>
Date: Wed, 25 Jul 2018 17:24:00 +0300
Subject: Add logic of merging different platforms graphs

---
 .../main/kotlin/Formats/StructuredFormatService.kt |  12 +-
 core/src/main/kotlin/Generation/DokkaGenerator.kt  | 232 ++++++++++++++++++++-
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt |   6 +-
 core/src/main/kotlin/Model/DocumentationNode.kt    |  10 +-
 .../main/kotlin/Model/DocumentationReference.kt    |  53 ++++-
 5 files changed, 288 insertions(+), 25 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt
index ebc9cde6..41c8f29a 100644
--- a/core/src/main/kotlin/Formats/StructuredFormatService.kt
+++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt
@@ -514,15 +514,15 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
             appendSection("Exceptions", node.membersOrGroupMembers(NodeKind.Exception))
             appendSection("Type Aliases", node.membersOrGroupMembers(NodeKind.TypeAlias))
             appendSection("Extensions for External Classes", node.members(NodeKind.ExternalClass))
-            appendSection("Enum Values", node.members(NodeKind.EnumItem), sortMembers = false, omitSamePlatforms = true)
-            appendSection("Constructors", node.members(NodeKind.Constructor), omitSamePlatforms = true)
-            appendSection("Properties", node.members(NodeKind.Property), omitSamePlatforms = true)
+            appendSection("Enum Values", node.membersOrGroupMembers(NodeKind.EnumItem), sortMembers = false, omitSamePlatforms = true)
+            appendSection("Constructors", node.membersOrGroupMembers(NodeKind.Constructor), omitSamePlatforms = true)
+            appendSection("Properties", node.membersOrGroupMembers(NodeKind.Property), omitSamePlatforms = true)
             appendSection("Inherited Properties", node.inheritedMembers(NodeKind.Property))
-            appendSection("Functions", node.members(NodeKind.Function), omitSamePlatforms = true)
+            appendSection("Functions", node.membersOrGroupMembers(NodeKind.Function), omitSamePlatforms = true)
             appendSection("Inherited Functions", node.inheritedMembers(NodeKind.Function))
-            appendSection("Companion Object Properties", node.members(NodeKind.CompanionObjectProperty), omitSamePlatforms = true)
+            appendSection("Companion Object Properties", node.membersOrGroupMembers(NodeKind.CompanionObjectProperty), omitSamePlatforms = true)
             appendSection("Inherited Companion Object Properties", node.inheritedCompanionObjectMembers(NodeKind.Property))
-            appendSection("Companion Object Functions", node.members(NodeKind.CompanionObjectFunction), omitSamePlatforms = true)
+            appendSection("Companion Object Functions", node.membersOrGroupMembers(NodeKind.CompanionObjectFunction), omitSamePlatforms = true)
             appendSection("Inherited Companion Object Functions", node.inheritedCompanionObjectMembers(NodeKind.Function))
             appendSection("Other members", node.members.filter {
                 it.kind !in setOf(
diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 9de4396b..0c4b3b7e 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -2,6 +2,7 @@ package org.jetbrains.dokka
 
 import com.google.inject.Guice
 import com.google.inject.Injector
+import com.intellij.openapi.application.PathManager
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiFile
@@ -17,6 +18,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.KotlinSourceRoot
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
@@ -32,28 +34,34 @@ class DokkaGenerator(val logger: DokkaLogger,
                      val moduleName: String,
                      val options: DocumentationOptions) {
 
-    private val documentationModule = DocumentationModule(moduleName)
+    private val documentationModules: MutableList<DocumentationModule> = mutableListOf()
 
     fun generate() {
         val sourcesGroupedByPlatform = sources.groupBy { it.platforms.firstOrNull() to it.analysisPlatform }
         for ((platformsInfo, roots) in sourcesGroupedByPlatform) {
             val (platform, analysisPlatform) = platformsInfo
-            appendSourceModule(platform, analysisPlatform, roots)
+
+            val documentationModule = DocumentationModule(moduleName)
+            appendSourceModule(platform, analysisPlatform, roots, documentationModule)
+            documentationModules.add(documentationModule)
         }
-        documentationModule.prepareForGeneration(options)
+
+        val totalDocumentationModule = DocumentationMerger(documentationModules).merge()
+        totalDocumentationModule.prepareForGeneration(options)
 
         val timeBuild = measureTimeMillis {
             logger.info("Generating pages... ")
             val outputInjector = Guice.createInjector(DokkaOutputModule(options, logger))
-            outputInjector.getInstance(Generator::class.java).buildAll(documentationModule)
+            outputInjector.getInstance(Generator::class.java).buildAll(totalDocumentationModule)
         }
         logger.info("done in ${timeBuild / 1000} secs")
     }
 
-    private fun appendSourceModule(defaultPlatform: String?,
-                                   analysisPlatform: Platform,
-                                   sourceRoots: List<SourceRoot>
-
+    private fun appendSourceModule(
+        defaultPlatform: String?,
+        analysisPlatform: Platform,
+        sourceRoots: List<SourceRoot>,
+        documentationModule: DocumentationModule
     ) {
 
         val sourcePaths = sourceRoots.map { it.path }
@@ -81,6 +89,12 @@ class DokkaGenerator(val logger: DokkaLogger,
                 DokkaAnalysisModule(environment, options, defaultPlatformsProvider, documentationModule.nodeRefGraph, logger))
 
         buildDocumentationModule(injector, documentationModule, { isNotSample(it) }, includes)
+        documentationModule.nodeRefGraph.nodeMapView.forEach { (_, node) ->
+            node.addReferenceTo(
+                DocumentationNode(analysisPlatform.key, Content.Empty, NodeKind.Platform),
+                RefKind.Platform
+            )
+        }
 
         val timeAnalyse = System.currentTimeMillis() - startAnalyse
         logger.info("done in ${timeAnalyse / 1000} secs")
@@ -214,3 +228,205 @@ fun KotlinCoreEnvironment.getJavaSourceFiles(): List<PsiJavaFile> {
     }
     return result
 }
+
+class DocumentationMerger(
+    private val documentationModules: List<DocumentationModule>
+) {
+    private val producedNodeRefGraph: NodeReferenceGraph
+    private val signatureMap: Map<DocumentationNode, String>
+
+    init {
+        signatureMap = documentationModules
+            .flatMap { it.nodeRefGraph.nodeMapView.entries }
+            .map { (k, v) -> v to k }
+            .toMap()
+
+        producedNodeRefGraph = NodeReferenceGraph()
+        documentationModules.map { it.nodeRefGraph }
+            .flatMap { it.references }
+            .distinct()
+            .forEach { producedNodeRefGraph.addReference(it) }
+    }
+
+    private fun splitReferencesByKind(
+        source: List<DocumentationReference>,
+        kind: RefKind
+    ): Pair<List<DocumentationReference>, List<DocumentationReference>> =
+        Pair(source.filter { it.kind == kind }, source.filterNot { it.kind == kind })
+
+
+    private fun mergePackageReferences(
+        from: DocumentationNode,
+        packages: List<DocumentationReference>
+    ): List<DocumentationReference> {
+        val packagesByName = packages
+            .map { it.to }
+            .groupBy { it.name }
+
+        val mutableList: MutableList<DocumentationReference> = mutableListOf()
+        for ((name, listOfPackages) in packagesByName) {
+            val producedPackage = mergePackagesWithEqualNames(from, listOfPackages)
+            updatePendingReferences(name, producedPackage)
+
+            mutableList.add(
+                DocumentationReference(from, producedPackage, RefKind.Member)
+            )
+        }
+
+        return mutableList
+    }
+
+    private fun mergePackagesWithEqualNames(
+        from: DocumentationNode,
+        packages: List<DocumentationNode>
+    ): DocumentationNode {
+        val references = packages.flatMap { it.allReferences() }
+
+        val mergedPackage =
+            DocumentationNode(
+                packages.first().name,
+                Content.Empty,
+                NodeKind.Package
+            )
+
+        val mergedReferences = mergeReferences(mergedPackage, references)
+
+        for (packageNode in packages) {
+            mergedPackage.updateContent {
+                for (otherChild in packageNode.content.children) {
+                    children.add(otherChild)
+                }
+            }
+        }
+
+        mergedPackage.dropReferences { true } // clear()
+        for (ref in mergedReferences.distinct()) {
+            mergedPackage.addReference(ref)
+        }
+
+        from.append(mergedPackage, RefKind.Member)
+
+        return mergedPackage
+    }
+
+
+    private fun mergeMembers(
+        from: DocumentationNode,
+        refs: List<DocumentationReference>
+    ): List<DocumentationReference> {
+        val membersBySignature: Map<String, List<DocumentationNode>> = refs.map { it.to }
+            .filter { signatureMap.containsKey(it) }
+            .groupBy { signatureMap[it]!! }
+
+        val mergedMembers: MutableList<DocumentationReference> = mutableListOf()
+        for ((signature, members) in membersBySignature) {
+            val newNode = mergeMembersWithEqualSignature(signature, from, members)
+
+            producedNodeRefGraph.register(signature, newNode)
+            updatePendingReferences(signature, newNode)
+            from.append(newNode, RefKind.Member)
+
+            mergedMembers.add(DocumentationReference(from, newNode, RefKind.Member))
+        }
+
+        return mergedMembers
+    }
+
+    private fun mergeMembersWithEqualSignature(
+        signature: String,
+        from: DocumentationNode,
+        refs: List<DocumentationNode>
+    ): DocumentationNode {
+        if (refs.size == 1) {
+            val singleNode = refs.single()
+            singleNode.owner?.let { owner ->
+                singleNode.dropReferences { it.to == owner && it.kind == RefKind.Owner }
+            }
+            return singleNode
+        }
+        val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode)
+        groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail)
+
+        for (node in refs) {
+            if (node != groupNode) {
+                node.owner?.let { owner ->
+                    node.dropReferences { it.to == owner && it.kind == RefKind.Owner }
+                    from.dropReferences { it.to == node && it.kind == RefKind.Member }
+                }
+                groupNode.append(node, RefKind.Member)
+            }
+        }
+        return groupNode
+    }
+
+
+    private fun mergeReferences(
+        from: DocumentationNode,
+        refs: List<DocumentationReference>
+    ): List<DocumentationReference> {
+        val allRefsToPackages = refs.map { it.to }
+            .all { it.kind == NodeKind.Package }
+
+        if (allRefsToPackages) {
+            return mergePackageReferences(from, refs)
+        }
+
+        val (memberRefs, notMemberRefs) = splitReferencesByKind(refs, RefKind.Member)
+        val mergedMembers = mergeMembers(from, memberRefs)
+
+        return (mergedMembers + notMemberRefs).distinctBy {
+            it.kind to it.to.name
+        }
+    }
+
+
+    private fun updatePendingReferences(
+        signature: String,
+        nodeToUpdate: DocumentationNode
+    ) {
+        producedNodeRefGraph.references.forEach {
+            it.lazyNodeFrom.update(signature, nodeToUpdate)
+            it.lazyNodeTo.update(signature, nodeToUpdate)
+        }
+    }
+
+    private fun NodeResolver.update(signature: String, nodeToUpdate: DocumentationNode) {
+        when (this) {
+            is NodeResolver.BySignature -> update(signature, nodeToUpdate)
+            is NodeResolver.Exact -> update(signature, nodeToUpdate)
+        }
+    }
+
+    private fun NodeResolver.BySignature.update(signature: String, nodeToUpdate: DocumentationNode) {
+        if (signature == nodeToUpdate.name) {
+            nodeMap = producedNodeRefGraph.nodeMapView
+        }
+    }
+
+    private fun NodeResolver.Exact.update(signature: String, nodeToUpdate: DocumentationNode) {
+        exactNode?.let { it ->
+            val equalSignature =
+                it.anyReference { ref -> ref.to.kind == NodeKind.Signature && ref.to.name == signature }
+
+            if (equalSignature) {
+                exactNode = nodeToUpdate
+            }
+        }
+    }
+
+    fun merge(): DocumentationModule {
+        val refs = documentationModules.flatMap {
+            it.allReferences()
+        }
+        val mergedDocumentationModule = DocumentationModule(
+            name = documentationModules.first().name,
+            nodeRefGraph = producedNodeRefGraph
+        )
+
+        mergeReferences(mergedDocumentationModule, refs)
+
+        return mergedDocumentationModule
+    }
+
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index f1b8e3d3..e3675f9d 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -1079,7 +1079,7 @@ fun DeclarationDescriptor.signature(): String {
         is TypeAliasDescriptor -> DescriptorUtils.getFqName(this).asString()
 
         is PropertyDescriptor -> containingDeclaration.signature() + "$" + name + receiverSignature()
-        is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature()
+        is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature() + ":" + returnType?.signature()
         is ValueParameterDescriptor -> containingDeclaration.signature() + "/" + name
         is TypeParameterDescriptor -> containingDeclaration.signature() + "*" + name
         is ReceiverParameterDescriptor -> containingDeclaration.signature() + "/" + name
@@ -1149,7 +1149,9 @@ fun DocumentationModule.prepareForGeneration(options: DocumentationOptions) {
 
 fun DocumentationNode.generateAllTypesNode() {
     val allTypes = members(NodeKind.Package)
-            .flatMap { it.members.filter { it.kind in NodeKind.classLike || it.kind == NodeKind.ExternalClass } }
+            .flatMap { it.members.filter {
+                it.kind in NodeKind.classLike || it.kind == NodeKind.ExternalClass
+                        || (it.kind == NodeKind.GroupNode && it.anyReference { it.to.kind in NodeKind.classLike }) } }
             .sortedBy { if (it.kind == NodeKind.ExternalClass) it.name.substringAfterLast('.').toLowerCase() else it.name.toLowerCase() }
 
     val allTypesNode = DocumentationNode("alltypes", Content.Empty, NodeKind.AllTypes)
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index a3388031..bdb7cf20 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -134,6 +134,10 @@ open class DocumentationNode(val name: String,
         references.add(DocumentationReference(this, to, kind))
     }
 
+    fun addReference(reference: DocumentationReference) {
+        references.add(reference)
+    }
+
     fun dropReferences(predicate: (DocumentationReference) -> Boolean) {
         references.removeAll(predicate)
     }
@@ -159,6 +163,8 @@ open class DocumentationNode(val name: String,
     fun member(kind: NodeKind): DocumentationNode = members.filter { it.kind == kind }.single()
     fun link(kind: NodeKind): DocumentationNode = links.filter { it.kind == kind }.single()
 
+    fun anyReference(predicate: (DocumentationReference) -> Boolean): Boolean = references.any(predicate)
+
     fun references(kind: RefKind): List<DocumentationReference> = references.filter { it.kind == kind }
     fun allReferences(): Set<DocumentationReference> = references
 
@@ -167,9 +173,9 @@ open class DocumentationNode(val name: String,
     }
 }
 
-class DocumentationModule(name: String, content: Content = Content.Empty)
+class DocumentationModule(name: String, content: Content = Content.Empty, val nodeRefGraph: NodeReferenceGraph = NodeReferenceGraph())
     : DocumentationNode(name, content, NodeKind.Module) {
-    val nodeRefGraph = NodeReferenceGraph()
+
 }
 
 val DocumentationNode.path: List<DocumentationNode>
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index 5db1f05a..9223c17a 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -25,12 +25,27 @@ enum class RefKind {
 data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) {
 }
 
-class PendingDocumentationReference(val lazyNodeFrom: () -> DocumentationNode?,
-                                    val lazyNodeTo: () -> DocumentationNode?,
+sealed class NodeResolver {
+    abstract fun resolve(): DocumentationNode?
+    class BySignature(var signature: String, var nodeMap: Map<String, DocumentationNode>) : NodeResolver() {
+        override fun resolve(): DocumentationNode? {
+            return nodeMap[signature]
+        }
+    }
+
+    class Exact(var exactNode: DocumentationNode?) : NodeResolver() {
+        override fun resolve(): DocumentationNode? {
+            return exactNode
+        }
+    }
+}
+
+class PendingDocumentationReference(val lazyNodeFrom: NodeResolver,
+                                    val lazyNodeTo: NodeResolver,
                                     val kind: RefKind) {
     fun resolve() {
-        val fromNode = lazyNodeFrom()
-        val toNode = lazyNodeTo()
+        val fromNode = lazyNodeFrom.resolve()
+        val toNode = lazyNodeTo.resolve()
         if (fromNode != null && toNode != null) {
             fromNode.addReferenceTo(toNode, kind)
         }
@@ -39,6 +54,9 @@ class PendingDocumentationReference(val lazyNodeFrom: () -> DocumentationNode?,
 
 class NodeReferenceGraph {
     private val nodeMap = hashMapOf<String, DocumentationNode>()
+    val nodeMapView: Map<String, DocumentationNode>
+            get() = HashMap(nodeMap)
+
     val references = arrayListOf<PendingDocumentationReference>()
 
     fun register(signature: String, node: DocumentationNode) {
@@ -46,15 +64,36 @@ class NodeReferenceGraph {
     }
 
     fun link(fromNode: DocumentationNode, toSignature: String, kind: RefKind) {
-        references.add(PendingDocumentationReference({ fromNode }, { nodeMap[toSignature] }, kind))
+        references.add(
+            PendingDocumentationReference(
+                NodeResolver.Exact(fromNode),
+                NodeResolver.BySignature(toSignature, nodeMap),
+                kind
+            ))
     }
 
     fun link(fromSignature: String, toNode: DocumentationNode, kind: RefKind) {
-        references.add(PendingDocumentationReference({ nodeMap[fromSignature] }, { toNode }, kind))
+        references.add(
+            PendingDocumentationReference(
+                NodeResolver.BySignature(fromSignature, nodeMap),
+                NodeResolver.Exact(toNode),
+                kind
+            )
+        )
     }
 
     fun link(fromSignature: String, toSignature: String, kind: RefKind) {
-        references.add(PendingDocumentationReference({ nodeMap[fromSignature] }, { nodeMap[toSignature] }, kind))
+        references.add(
+            PendingDocumentationReference(
+                NodeResolver.BySignature(fromSignature, nodeMap),
+                NodeResolver.BySignature(toSignature, nodeMap),
+                kind
+            )
+        )
+    }
+
+    fun addReference(reference: PendingDocumentationReference) {
+        references.add(reference)
     }
 
     fun lookup(signature: String) = nodeMap[signature]
-- 
cgit 


From 77ce80517f79a774ef985be47ae00db828e34273 Mon Sep 17 00:00:00 2001
From: aleksZubakov <aleks.zubakov@gmail.com>
Date: Mon, 6 Aug 2018 13:42:44 +0300
Subject: DocumentationMerger refactoring

---
 .../main/kotlin/Generation/DocumentationMerger.kt  | 179 ++++++++++++++++
 core/src/main/kotlin/Generation/DokkaGenerator.kt  | 227 ++-------------------
 core/src/main/kotlin/Generation/FileGenerator.kt   |   2 +-
 .../main/kotlin/Generation/configurationImpl.kt    |   1 -
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt |   2 +-
 core/src/main/kotlin/Model/DocumentationNode.kt    |   1 -
 .../main/kotlin/Model/DocumentationReference.kt    |  26 +--
 7 files changed, 212 insertions(+), 226 deletions(-)
 create mode 100644 core/src/main/kotlin/Generation/DocumentationMerger.kt

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Generation/DocumentationMerger.kt b/core/src/main/kotlin/Generation/DocumentationMerger.kt
new file mode 100644
index 00000000..c2089821
--- /dev/null
+++ b/core/src/main/kotlin/Generation/DocumentationMerger.kt
@@ -0,0 +1,179 @@
+package org.jetbrains.dokka.Generation
+
+import org.jetbrains.dokka.*
+
+class DocumentationMerger(
+    private val documentationModules: List<DocumentationModule>
+) {
+    private val producedNodeRefGraph: NodeReferenceGraph
+    private val signatureMap: Map<DocumentationNode, String>
+    private val oldToNewNodeMap: MutableMap<DocumentationNode, DocumentationNode> = mutableMapOf()
+
+    init {
+        if (documentationModules.groupBy { it.name }.size > 1) {
+            throw IllegalArgumentException("Modules should have similar names")
+        }
+
+        signatureMap = documentationModules
+            .flatMap { it.nodeRefGraph.nodeMapView.entries }
+            .associate { (k, v) -> v to k }
+
+
+        producedNodeRefGraph = NodeReferenceGraph()
+        documentationModules.map { it.nodeRefGraph }
+            .flatMap { it.references }
+            .distinct()
+            .forEach { producedNodeRefGraph.addReference(it) }
+    }
+
+    private fun mergePackageReferences(
+        from: DocumentationNode,
+        packages: List<DocumentationReference>
+    ): List<DocumentationReference> {
+
+        val packagesByName = packages
+            .map { it.to }
+            .groupBy { it.name }
+
+        val mutableList = mutableListOf<DocumentationReference>()
+        for ((name, listOfPackages) in packagesByName) {
+            val producedPackage = mergePackagesWithEqualNames(name, from, listOfPackages)
+            updatePendingReferences()
+
+            mutableList.add(
+                DocumentationReference(from, producedPackage, RefKind.Member)
+            )
+        }
+
+        return mutableList
+    }
+
+    private fun mergePackagesWithEqualNames(
+        name: String,
+        from: DocumentationNode,
+        packages: List<DocumentationNode>
+    ): DocumentationNode {
+        val mergedPackage = DocumentationNode(name, Content.Empty, NodeKind.Package)
+        for (packageNode in packages) {
+            // TODO: Discuss
+            mergedPackage.updateContent {
+                for (otherChild in packageNode.content.children) {
+                    children.add(otherChild)
+                }
+            }
+            oldToNewNodeMap[packageNode] = mergedPackage
+        }
+        mergedPackage.clear()
+
+        val references = packages.flatMap { it.allReferences() }
+        val mergedReferences = mergeReferences(mergedPackage, references)
+        for (ref in mergedReferences.distinct()) {
+            mergedPackage.addReference(ref)
+        }
+
+        from.append(mergedPackage, RefKind.Member)
+
+        return mergedPackage
+    }
+
+    private fun DocumentationNode.clear() = dropReferences { true }
+
+    private fun mergeMembers(
+        from: DocumentationNode,
+        refs: List<DocumentationReference>
+    ): List<DocumentationReference> {
+        val membersBySignature: Map<String, List<DocumentationNode>> = refs.map { it.to }
+            .groupBy { signatureMap[it]!! }
+
+        val mergedMembers: MutableList<DocumentationReference> = mutableListOf()
+        for ((signature, members) in membersBySignature) {
+            val newNode = mergeMembersWithEqualSignature(signature, from, members)
+
+            producedNodeRefGraph.register(signature, newNode)
+            updatePendingReferences()
+            from.append(newNode, RefKind.Member)
+
+            mergedMembers.add(DocumentationReference(from, newNode, RefKind.Member))
+        }
+
+        return mergedMembers
+    }
+
+    private fun mergeMembersWithEqualSignature(
+        signature: String,
+        from: DocumentationNode,
+        refs: List<DocumentationNode>
+    ): DocumentationNode {
+        val singleNode = refs.singleOrNull()
+        if (singleNode != null) {
+            singleNode.owner?.let { owner ->
+                singleNode.dropReferences { it.to == owner && it.kind == RefKind.Owner }
+            }
+            return singleNode
+        }
+        val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode)
+        groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail)
+
+        for (node in refs) {
+            if (node != groupNode) {
+                node.owner?.let { owner ->
+                    node.dropReferences { it.to == owner && it.kind == RefKind.Owner }
+                    from.dropReferences { it.to == node && it.kind == RefKind.Member }
+                }
+                groupNode.append(node, RefKind.Member)
+
+                oldToNewNodeMap[node] = groupNode
+            }
+        }
+        return groupNode
+    }
+
+
+    private fun mergeReferences(
+        from: DocumentationNode,
+        refs: List<DocumentationReference>
+    ): List<DocumentationReference> {
+        val (refsToPackages, usualRefs) = refs.partition { it.to.kind == NodeKind.Package }
+        val mergedPackages = mergePackageReferences(from, refsToPackages)
+
+        val (refsToMembers, refsNotToMembers) = usualRefs.partition { it.kind == RefKind.Member }
+        val mergedMembers = mergeMembers(from, refsToMembers)
+
+        // TODO: think about
+        return mergedPackages + (mergedMembers + refsNotToMembers).distinctBy {
+            it.to.kind to it.to.name
+        }
+    }
+
+
+    private fun updatePendingReferences() {
+        producedNodeRefGraph.references.forEach {
+            it.lazyNodeFrom.update()
+            it.lazyNodeTo.update()
+        }
+    }
+
+    private fun NodeResolver.update() {
+        if (this is NodeResolver.Exact) {
+            if (exactNode != null && oldToNewNodeMap.containsKey(exactNode!!)) {
+                exactNode = oldToNewNodeMap[exactNode!!]
+            }
+        }
+    }
+
+    fun merge(): DocumentationModule {
+        val mergedDocumentationModule = DocumentationModule(
+            name = documentationModules.first().name,
+            nodeRefGraph = producedNodeRefGraph
+        )
+
+        val refs = documentationModules.flatMap {
+            it.allReferences()
+        }
+        mergeReferences(mergedDocumentationModule, refs)
+
+        return mergedDocumentationModule
+    }
+
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 22d1519f..37f62ed6 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -7,6 +7,7 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiManager
+import org.jetbrains.dokka.Generation.DocumentationMerger
 import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
 import org.jetbrains.dokka.Utilities.DokkaOutputModule
 import org.jetbrains.dokka.Utilities.DokkaRunModule
@@ -82,8 +83,8 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration,
                 DokkaAnalysisModule(environment, dokkaConfiguration, defaultPlatformsProvider, documentationModule.nodeRefGraph, passConfiguration, logger))
 
         buildDocumentationModule(injector, documentationModule, { isNotSample(it, passConfiguration.samples) }, includes)
-        documentationModule.nodeRefGraph.nodeMapView.forEach { (_, node) -> // FIXME: change to full graph visiting
-            node.addReferenceTo(
+        documentationModule.visit { it ->
+            it.addReferenceTo(
                 DocumentationNode(analysisPlatform.key, Content.Empty, NodeKind.Platform),
                 RefKind.Platform
             )
@@ -95,7 +96,19 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration,
         Disposer.dispose(environment)
     }
 
-   fun createAnalysisEnvironment(sourcePaths: List<String>, passConfiguration: DokkaConfiguration.PassConfiguration): AnalysisEnvironment {
+    private fun DocumentationNode.visit(action: (DocumentationNode) -> Unit) {
+        action(this)
+
+        for (member in members) {
+            member.visit(action)
+        }
+    }
+
+
+    fun createAnalysisEnvironment(
+        sourcePaths: List<String>,
+        passConfiguration: DokkaConfiguration.PassConfiguration
+    ): AnalysisEnvironment {
         val environment = AnalysisEnvironment(DokkaMessageCollector(logger), passConfiguration.analysisPlatform)
 
         environment.apply {
@@ -116,7 +129,7 @@ class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration,
         return environment
     }
 
-   fun isNotSample(file: PsiFile, samples: List<String>): Boolean {
+   private fun isNotSample(file: PsiFile, samples: List<String>): Boolean {
         val sourceFile = File(file.virtualFile!!.path)
         return samples.none { sample ->
             val canonicalSample = File(sample).canonicalPath
@@ -155,9 +168,7 @@ fun buildDocumentationModule(injector: Injector,
     val analyzer = resolutionFacade.getFrontendService(LazyTopDownAnalyzer::class.java)
     analyzer.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, fragmentFiles)
 
-    val fragments = fragmentFiles
-            .map { resolutionFacade.resolveSession.getPackageFragment(it.packageFqName) }
-            .filterNotNull()
+    val fragments = fragmentFiles.mapNotNull { resolutionFacade.resolveSession.getPackageFragment(it.packageFqName) }
             .distinct()
 
     val packageDocs = injector.getInstance(PackageDocs::class.java)
@@ -220,206 +231,4 @@ fun KotlinCoreEnvironment.getJavaSourceFiles(): List<PsiJavaFile> {
         }
     }
     return result
-}
-
-class DocumentationMerger(
-    private val documentationModules: List<DocumentationModule>
-) {
-    private val producedNodeRefGraph: NodeReferenceGraph
-    private val signatureMap: Map<DocumentationNode, String>
-
-    init {
-        signatureMap = documentationModules
-            .flatMap { it.nodeRefGraph.nodeMapView.entries }
-            .map { (k, v) -> v to k }
-            .toMap()
-
-        producedNodeRefGraph = NodeReferenceGraph()
-        documentationModules.map { it.nodeRefGraph }
-            .flatMap { it.references }
-            .distinct()
-            .forEach { producedNodeRefGraph.addReference(it) }
-    }
-
-    private fun splitReferencesByKind(
-        source: List<DocumentationReference>,
-        kind: RefKind
-    ): Pair<List<DocumentationReference>, List<DocumentationReference>> =
-        Pair(source.filter { it.kind == kind }, source.filterNot { it.kind == kind })
-
-
-    private fun mergePackageReferences(
-        from: DocumentationNode,
-        packages: List<DocumentationReference>
-    ): List<DocumentationReference> {
-        val packagesByName = packages
-            .map { it.to }
-            .groupBy { it.name }
-
-        val mutableList: MutableList<DocumentationReference> = mutableListOf()
-        for ((name, listOfPackages) in packagesByName) {
-            val producedPackage = mergePackagesWithEqualNames(from, listOfPackages)
-            updatePendingReferences(name, producedPackage)
-
-            mutableList.add(
-                DocumentationReference(from, producedPackage, RefKind.Member)
-            )
-        }
-
-        return mutableList
-    }
-
-    private fun mergePackagesWithEqualNames(
-        from: DocumentationNode,
-        packages: List<DocumentationNode>
-    ): DocumentationNode {
-        val references = packages.flatMap { it.allReferences() }
-
-        val mergedPackage =
-            DocumentationNode(
-                packages.first().name,
-                Content.Empty,
-                NodeKind.Package
-            )
-
-        val mergedReferences = mergeReferences(mergedPackage, references)
-
-        for (packageNode in packages) {
-            mergedPackage.updateContent {
-                for (otherChild in packageNode.content.children) {
-                    children.add(otherChild)
-                }
-            }
-        }
-
-        mergedPackage.dropReferences { true } // clear()
-        for (ref in mergedReferences.distinct()) {
-            mergedPackage.addReference(ref)
-        }
-
-        from.append(mergedPackage, RefKind.Member)
-
-        return mergedPackage
-    }
-
-
-    private fun mergeMembers(
-        from: DocumentationNode,
-        refs: List<DocumentationReference>
-    ): List<DocumentationReference> {
-        val membersBySignature: Map<String, List<DocumentationNode>> = refs.map { it.to }
-            .filter { signatureMap.containsKey(it) }
-            .groupBy { signatureMap[it]!! }
-
-        val mergedMembers: MutableList<DocumentationReference> = mutableListOf()
-        for ((signature, members) in membersBySignature) {
-            val newNode = mergeMembersWithEqualSignature(signature, from, members)
-
-            producedNodeRefGraph.register(signature, newNode)
-            updatePendingReferences(signature, newNode)
-            from.append(newNode, RefKind.Member)
-
-            mergedMembers.add(DocumentationReference(from, newNode, RefKind.Member))
-        }
-
-        return mergedMembers
-    }
-
-    private fun mergeMembersWithEqualSignature(
-        signature: String,
-        from: DocumentationNode,
-        refs: List<DocumentationNode>
-    ): DocumentationNode {
-        if (refs.size == 1) {
-            val singleNode = refs.single()
-            singleNode.owner?.let { owner ->
-                singleNode.dropReferences { it.to == owner && it.kind == RefKind.Owner }
-            }
-            return singleNode
-        }
-        val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode)
-        groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail)
-
-        for (node in refs) {
-            if (node != groupNode) {
-                node.owner?.let { owner ->
-                    node.dropReferences { it.to == owner && it.kind == RefKind.Owner }
-                    from.dropReferences { it.to == node && it.kind == RefKind.Member }
-                }
-                groupNode.append(node, RefKind.Member)
-            }
-        }
-        return groupNode
-    }
-
-
-    private fun mergeReferences(
-        from: DocumentationNode,
-        refs: List<DocumentationReference>
-    ): List<DocumentationReference> {
-        val allRefsToPackages = refs.map { it.to }
-            .all { it.kind == NodeKind.Package }
-
-        if (allRefsToPackages) {
-            return mergePackageReferences(from, refs)
-        }
-
-        val (memberRefs, notMemberRefs) = splitReferencesByKind(refs, RefKind.Member)
-        val mergedMembers = mergeMembers(from, memberRefs)
-
-        return (mergedMembers + notMemberRefs).distinctBy {
-            it.kind to it.to.name
-        }
-    }
-
-
-    private fun updatePendingReferences(
-        signature: String,
-        nodeToUpdate: DocumentationNode
-    ) {
-        producedNodeRefGraph.references.forEach {
-            it.lazyNodeFrom.update(signature, nodeToUpdate)
-            it.lazyNodeTo.update(signature, nodeToUpdate)
-        }
-    }
-
-    private fun NodeResolver.update(signature: String, nodeToUpdate: DocumentationNode) {
-        when (this) {
-            is NodeResolver.BySignature -> update(signature, nodeToUpdate)
-            is NodeResolver.Exact -> update(signature, nodeToUpdate)
-        }
-    }
-
-    private fun NodeResolver.BySignature.update(signature: String, nodeToUpdate: DocumentationNode) {
-        if (signature == nodeToUpdate.name) {
-            nodeMap = producedNodeRefGraph.nodeMapView
-        }
-    }
-
-    private fun NodeResolver.Exact.update(signature: String, nodeToUpdate: DocumentationNode) {
-        exactNode?.let { it ->
-            val equalSignature =
-                it.anyReference { ref -> ref.to.kind == NodeKind.Signature && ref.to.name == signature }
-
-            if (equalSignature) {
-                exactNode = nodeToUpdate
-            }
-        }
-    }
-
-    fun merge(): DocumentationModule {
-        val refs = documentationModules.flatMap {
-            it.allReferences()
-        }
-        val mergedDocumentationModule = DocumentationModule(
-            name = documentationModules.first().name,
-            nodeRefGraph = producedNodeRefGraph
-        )
-
-        mergeReferences(mergedDocumentationModule, refs)
-
-        return mergedDocumentationModule
-    }
-
-
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Generation/FileGenerator.kt b/core/src/main/kotlin/Generation/FileGenerator.kt
index eb6800b3..d7b35581 100644
--- a/core/src/main/kotlin/Generation/FileGenerator.kt
+++ b/core/src/main/kotlin/Generation/FileGenerator.kt
@@ -10,7 +10,7 @@ import java.io.OutputStreamWriter
 class FileGenerator @Inject constructor(@Named("outputDir") override val root: File) : NodeLocationAwareGenerator {
 
     @set:Inject(optional = true) var outlineService: OutlineFormatService? = null
-    @set:Inject(optional = true) lateinit var formatService: FormatService
+    @set:Inject lateinit var formatService: FormatService
     @set:Inject(optional = true) lateinit var dokkaConfiguration: DokkaConfiguration
     @set:Inject(optional = true) var packageListService: PackageListService? = null
 
diff --git a/core/src/main/kotlin/Generation/configurationImpl.kt b/core/src/main/kotlin/Generation/configurationImpl.kt
index 3e39b4ed..f2a91002 100644
--- a/core/src/main/kotlin/Generation/configurationImpl.kt
+++ b/core/src/main/kotlin/Generation/configurationImpl.kt
@@ -26,7 +26,6 @@ class SourceRootImpl(path: String, override val platforms: List<String> = emptyL
         fun parseSourceRoot(sourceRoot: String): SourceRoot {
             val components = sourceRoot.split("::", limit = 2)
 
-            // TODO: create syntax for cli
             val platform = if (components.size == 1) {
                 Platform.DEFAULT
             } else {
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index fb0b898a..be3eef71 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -1097,7 +1097,7 @@ fun DocumentationNode.generateAllTypesNode() {
     val allTypes = members(NodeKind.Package)
             .flatMap { it.members.filter {
                 it.kind in NodeKind.classLike || it.kind == NodeKind.ExternalClass
-                        || (it.kind == NodeKind.GroupNode && it.anyReference { it.to.kind in NodeKind.classLike }) } }
+                        || (it.kind == NodeKind.GroupNode && it.members.all { it.kind in NodeKind.classLike }) } }
             .sortedBy { if (it.kind == NodeKind.ExternalClass) it.name.substringAfterLast('.').toLowerCase() else it.name.toLowerCase() }
 
     val allTypesNode = DocumentationNode("alltypes", Content.Empty, NodeKind.AllTypes)
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index bdb7cf20..23137364 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -163,7 +163,6 @@ open class DocumentationNode(val name: String,
     fun member(kind: NodeKind): DocumentationNode = members.filter { it.kind == kind }.single()
     fun link(kind: NodeKind): DocumentationNode = links.filter { it.kind == kind }.single()
 
-    fun anyReference(predicate: (DocumentationReference) -> Boolean): Boolean = references.any(predicate)
 
     fun references(kind: RefKind): List<DocumentationReference> = references.filter { it.kind == kind }
     fun allReferences(): Set<DocumentationReference> = references
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index 9223c17a..282d87d8 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -26,15 +26,15 @@ data class DocumentationReference(val from: DocumentationNode, val to: Documenta
 }
 
 sealed class NodeResolver {
-    abstract fun resolve(): DocumentationNode?
-    class BySignature(var signature: String, var nodeMap: Map<String, DocumentationNode>) : NodeResolver() {
-        override fun resolve(): DocumentationNode? {
-            return nodeMap[signature]
+    abstract fun resolve(nodeRephGraph: NodeReferenceGraph): DocumentationNode?
+    class BySignature(var signature: String) : NodeResolver() {
+        override fun resolve(nodeRephGraph: NodeReferenceGraph): DocumentationNode? {
+            return nodeRephGraph.lookup(signature)
         }
     }
 
     class Exact(var exactNode: DocumentationNode?) : NodeResolver() {
-        override fun resolve(): DocumentationNode? {
+        override fun resolve(nodeRephGraph: NodeReferenceGraph): DocumentationNode? {
             return exactNode
         }
     }
@@ -43,9 +43,9 @@ sealed class NodeResolver {
 class PendingDocumentationReference(val lazyNodeFrom: NodeResolver,
                                     val lazyNodeTo: NodeResolver,
                                     val kind: RefKind) {
-    fun resolve() {
-        val fromNode = lazyNodeFrom.resolve()
-        val toNode = lazyNodeTo.resolve()
+    fun resolve(nodeRephGraph: NodeReferenceGraph) {
+        val fromNode = lazyNodeFrom.resolve(nodeRephGraph)
+        val toNode = lazyNodeTo.resolve(nodeRephGraph)
         if (fromNode != null && toNode != null) {
             fromNode.addReferenceTo(toNode, kind)
         }
@@ -67,7 +67,7 @@ class NodeReferenceGraph {
         references.add(
             PendingDocumentationReference(
                 NodeResolver.Exact(fromNode),
-                NodeResolver.BySignature(toSignature, nodeMap),
+                NodeResolver.BySignature(toSignature),
                 kind
             ))
     }
@@ -75,7 +75,7 @@ class NodeReferenceGraph {
     fun link(fromSignature: String, toNode: DocumentationNode, kind: RefKind) {
         references.add(
             PendingDocumentationReference(
-                NodeResolver.BySignature(fromSignature, nodeMap),
+                NodeResolver.BySignature(fromSignature),
                 NodeResolver.Exact(toNode),
                 kind
             )
@@ -85,8 +85,8 @@ class NodeReferenceGraph {
     fun link(fromSignature: String, toSignature: String, kind: RefKind) {
         references.add(
             PendingDocumentationReference(
-                NodeResolver.BySignature(fromSignature, nodeMap),
-                NodeResolver.BySignature(toSignature, nodeMap),
+                NodeResolver.BySignature(fromSignature),
+                NodeResolver.BySignature(toSignature),
                 kind
             )
         )
@@ -107,7 +107,7 @@ class NodeReferenceGraph {
     }
 
     fun resolveReferences() {
-        references.forEach { it.resolve() }
+        references.forEach { it.resolve(this) }
     }
 }
 
-- 
cgit 


From 0b43db4ff81746e44d06780d8d14bb49dc1d87aa Mon Sep 17 00:00:00 2001
From: Zubakov <aleks.zubakov@gmail.com>
Date: Mon, 27 Aug 2018 16:27:41 +0300
Subject: Introduce origin reference kind, change documentation graph merge
 logic, minor refactoring

---
 .../main/kotlin/Formats/StructuredFormatService.kt | 28 +++++-----
 .../main/kotlin/Generation/DocumentationMerger.kt  | 65 +++++++++++++---------
 .../src/main/kotlin/Kotlin/DocumentationBuilder.kt |  2 +-
 core/src/main/kotlin/Model/DocumentationNode.kt    |  4 ++
 .../main/kotlin/Model/DocumentationReference.kt    |  5 +-
 5 files changed, 61 insertions(+), 43 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt
index b810dfca..1ca636ec 100644
--- a/core/src/main/kotlin/Formats/StructuredFormatService.kt
+++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt
@@ -192,22 +192,20 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
         }
     }
 
-    open fun link(from: DocumentationNode,
-                  to: DocumentationNode,
-                  name: (DocumentationNode) -> String = DocumentationNode::name): FormatLink = link(from, to, extension, name)
+    open fun link(
+        from: DocumentationNode,
+        to: DocumentationNode,
+        name: (DocumentationNode) -> String = DocumentationNode::name
+    ): FormatLink = link(from, to, extension, name)
+
+    open fun link(
+        from: DocumentationNode,
+        to: DocumentationNode,
+        extension: String,
+        name: (DocumentationNode) -> String = DocumentationNode::name
+    ): FormatLink =
+        FormatLink(name(to), from.location().relativePathTo(to.location()))
 
-    open fun link(from: DocumentationNode,
-                  to: DocumentationNode,
-                  extension: String,
-                  name: (DocumentationNode) -> String = DocumentationNode::name): FormatLink {
-        if (to.owner?.kind == NodeKind.GroupNode)
-            return link(from, to.owner!!, extension, name)
-
-        if (from.owner?.kind == NodeKind.GroupNode)
-            return link(from.owner!!, to, extension, name)
-
-        return FormatLink(name(to), from.location().relativePathTo(to.location()))
-    }
 
     fun locationHref(from: Location, to: DocumentationNode): String {
         val topLevelPage = to.references(RefKind.TopLevelPage).singleOrNull()?.to
diff --git a/core/src/main/kotlin/Generation/DocumentationMerger.kt b/core/src/main/kotlin/Generation/DocumentationMerger.kt
index c4a40df6..0394dce2 100644
--- a/core/src/main/kotlin/Generation/DocumentationMerger.kt
+++ b/core/src/main/kotlin/Generation/DocumentationMerger.kt
@@ -5,7 +5,7 @@ import org.jetbrains.dokka.*
 class DocumentationMerger(
     private val documentationModules: List<DocumentationModule>
 ) {
-    private val producedNodeRefGraph: NodeReferenceGraph
+    private val producedNodeRefGraph: NodeReferenceGraph = NodeReferenceGraph()
     private val signatureMap: Map<DocumentationNode, String>
     private val oldToNewNodeMap: MutableMap<DocumentationNode, DocumentationNode> = mutableMapOf()
 
@@ -19,7 +19,6 @@ class DocumentationMerger(
             .associate { (k, v) -> v to k }
 
 
-        producedNodeRefGraph = NodeReferenceGraph()
         documentationModules.map { it.nodeRefGraph }
             .flatMap { it.references }
             .forEach { producedNodeRefGraph.addReference(it) }
@@ -33,17 +32,17 @@ class DocumentationMerger(
             .map { it.to }
             .groupBy { it.name }
 
-        val mutableList = mutableListOf<DocumentationReference>()
+        val resultReferences = mutableListOf<DocumentationReference>()
         for ((name, listOfPackages) in packagesByName) {
             val producedPackage = mergePackagesWithEqualNames(name, from, listOfPackages)
             updatePendingReferences()
 
-            mutableList.add(
+            resultReferences.add(
                 DocumentationReference(from, producedPackage, RefKind.Member)
             )
         }
 
-        return mutableList
+        return resultReferences
     }
 
     private fun mergePackagesWithEqualNames(
@@ -52,14 +51,17 @@ class DocumentationMerger(
         packages: List<DocumentationNode>
     ): DocumentationNode {
         val mergedPackage = DocumentationNode(name, Content.Empty, NodeKind.Package)
-        for (packageNode in packages) {
-            // TODO: Discuss
+
+        for (contentToAppend in packages.map { it.content }.distinct()) {
             mergedPackage.updateContent {
-                for (otherChild in packageNode.content.children) {
+                for (otherChild in contentToAppend.children) {
                     children.add(otherChild)
                 }
             }
-            oldToNewNodeMap[packageNode] = mergedPackage
+        }
+
+        for (node in packages) {
+            oldToNewNodeMap[node] = mergedPackage
         }
 
         val references = packages.flatMap { it.allReferences() }
@@ -76,7 +78,7 @@ class DocumentationMerger(
         return mergedPackage
     }
 
-    private fun mergeMembers(
+    private fun mergeMemberReferences(
         from: DocumentationNode,
         refs: List<DocumentationReference>
     ): List<DocumentationReference> {
@@ -85,7 +87,7 @@ class DocumentationMerger(
 
         val mergedMembers: MutableList<DocumentationReference> = mutableListOf()
         for ((signature, members) in membersBySignature) {
-            val newNode = mergeMembersWithEqualSignature(signature, from, members)
+            val newNode = mergeMembersWithEqualSignature(signature, members)
 
             producedNodeRefGraph.register(signature, newNode)
             updatePendingReferences()
@@ -99,23 +101,39 @@ class DocumentationMerger(
 
     private fun mergeMembersWithEqualSignature(
         signature: String,
-        from: DocumentationNode,
-        refs: List<DocumentationNode>
+        nodes: List<DocumentationNode>
     ): DocumentationNode {
-        val singleNode = refs.singleOrNull()
+        val singleNode = nodes.singleOrNull()
         if (singleNode != null) {
             singleNode.dropReferences { it.kind == RefKind.Owner }
             return singleNode
         }
-        val groupNode = DocumentationNode(refs.first().name, Content.Empty, NodeKind.GroupNode)
+
+        val groupNode = DocumentationNode(nodes.first().name, Content.Empty, NodeKind.GroupNode)
         groupNode.appendTextNode(signature, NodeKind.Signature, RefKind.Detail)
 
-        for (node in refs) {
+        for (node in nodes) {
             node.dropReferences { it.kind == RefKind.Owner }
-            groupNode.append(node, RefKind.Member)
+            groupNode.append(node, RefKind.Origin)
 
             oldToNewNodeMap[node] = groupNode
         }
+
+        // if nodes are classes, nested members should be also merged and
+        // inserted at the same level with class
+        if (nodes.all { it.kind == NodeKind.Class }) {
+            val members = nodes.flatMap { it.allReferences() }.filter { it.kind == RefKind.Member }
+            val mergedMembers = mergeMemberReferences(groupNode, members)
+
+            for (ref in mergedMembers) {
+                if (ref.kind == RefKind.Owner) {
+                    continue
+                }
+
+                groupNode.append(ref.to, RefKind.Member)
+            }
+        }
+
         return groupNode
     }
 
@@ -124,13 +142,12 @@ class DocumentationMerger(
         from: DocumentationNode,
         refs: List<DocumentationReference>
     ): List<DocumentationReference> {
-        val (refsToPackages, usualRefs) = refs.partition { it.to.kind == NodeKind.Package }
+        val (refsToPackages, otherRefs) = refs.partition { it.to.kind == NodeKind.Package }
         val mergedPackages = mergePackageReferences(from, refsToPackages)
 
-        val (refsToMembers, refsNotToMembers) = usualRefs.partition { it.kind == RefKind.Member }
-        val mergedMembers = mergeMembers(from, refsToMembers)
+        val (refsToMembers, refsNotToMembers) = otherRefs.partition { it.kind == RefKind.Member }
+        val mergedMembers = mergeMemberReferences(from, refsToMembers)
 
-        // TODO: think about
         return mergedPackages + mergedMembers + refsNotToMembers
     }
 
@@ -156,10 +173,8 @@ class DocumentationMerger(
     }
 
     private fun NodeResolver.update() {
-        if (this is NodeResolver.Exact) {
-            if (exactNode != null && exactNode!! in oldToNewNodeMap) {
-                exactNode = oldToNewNodeMap[exactNode!!]
-            }
+        if (this is NodeResolver.Exact && exactNode in oldToNewNodeMap) {
+            exactNode = oldToNewNodeMap[exactNode]!!
         }
     }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index c25a7069..e5bc32ab 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -1106,7 +1106,7 @@ fun DocumentationNode.generateAllTypesNode() {
     val allTypes = members(NodeKind.Package)
             .flatMap { it.members.filter {
                 it.kind in NodeKind.classLike || it.kind == NodeKind.ExternalClass
-                        || (it.kind == NodeKind.GroupNode && it.members.all { it.kind in NodeKind.classLike }) } }
+                        || (it.kind == NodeKind.GroupNode && it.origins.all { it.kind in NodeKind.classLike }) } }
             .sortedBy { if (it.kind == NodeKind.ExternalClass) it.name.substringAfterLast('.').toLowerCase() else it.name.toLowerCase() }
 
     val allTypesNode = DocumentationNode("alltypes", Content.Empty, NodeKind.AllTypes)
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 23137364..146c1e99 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -84,6 +84,9 @@ open class DocumentationNode(val name: String,
         get() = references(RefKind.Detail).map { it.to }
     val members: List<DocumentationNode>
         get() = references(RefKind.Member).map { it.to }
+    val origins: List<DocumentationNode>
+        get() = references(RefKind.Origin).map { it.to }
+
     val inheritedMembers: List<DocumentationNode>
         get() = references(RefKind.InheritedMember).map { it.to }
     val allInheritedMembers: List<DocumentationNode>
@@ -203,6 +206,7 @@ fun DocumentationNode.append(child: DocumentationNode, kind: RefKind) {
         RefKind.Detail -> child.addReferenceTo(this, RefKind.Owner)
         RefKind.Member -> child.addReferenceTo(this, RefKind.Owner)
         RefKind.Owner -> child.addReferenceTo(this, RefKind.Member)
+        RefKind.Origin -> child.addReferenceTo(this, RefKind.Owner)
         else -> { /* Do not add any links back for other types */
         }
     }
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
index 282d87d8..e10796d2 100644
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ b/core/src/main/kotlin/Model/DocumentationReference.kt
@@ -19,7 +19,8 @@ enum class RefKind {
     Deprecation,
     TopLevelPage,
     Platform,
-    ExternalType
+    ExternalType,
+    Origin
 }
 
 data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) {
@@ -33,7 +34,7 @@ sealed class NodeResolver {
         }
     }
 
-    class Exact(var exactNode: DocumentationNode?) : NodeResolver() {
+    class Exact(var exactNode: DocumentationNode) : NodeResolver() {
         override fun resolve(nodeRephGraph: NodeReferenceGraph): DocumentationNode? {
             return exactNode
         }
-- 
cgit 


From 0df19264ccae3d294946caf634ee15eea0c4fe4a Mon Sep 17 00:00:00 2001
From: Zubakov <aleks.zubakov@gmail.com>
Date: Thu, 6 Sep 2018 19:44:50 +0300
Subject: Minor refactoring, kotlin-website format change: add platforms to
 summary signatures, platform evaluating logic change

---
 .../Formats/KotlinWebsiteHtmlFormatService.kt      |   7 ++
 .../main/kotlin/Formats/StructuredFormatService.kt | 123 +++++++++++++++------
 core/src/main/kotlin/Model/DocumentationNode.kt    |   6 +-
 3 files changed, 103 insertions(+), 33 deletions(-)

(limited to 'core/src/main/kotlin/Model')

diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt
index 6ced75b5..16bec5a6 100644
--- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt
+++ b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt
@@ -169,6 +169,13 @@ open class KotlinWebsiteHtmlOutputBuilder(
             appendContent(section)
         }
     }
+
+    override fun appendAsBlockWithPlatforms(platforms: Set<String>, block: () -> Unit) {
+            if (platforms.isNotEmpty())
+                wrap("<div${calculateDataAttributes(platforms)}>", "</div>", block)
+            else
+                block()
+    }
 }
 
 class KotlinWebsiteHtmlFormatService @Inject constructor(
diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt
index b57f21be..53172563 100644
--- a/core/src/main/kotlin/Formats/StructuredFormatService.kt
+++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt
@@ -83,6 +83,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
         }
     }
 
+    open fun appendAsBlockWithPlatforms(platforms: Set<String>, block: () -> Unit) {
+        block()
+    }
+
     open fun appendSymbol(text: String) {
         appendText(text)
     }
@@ -465,6 +469,18 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
                     platformsToShow
 
 
+        protected fun mergeVersions(otherKotlinVersion: String, kotlinVersions: List<String>): String {
+            val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct()
+
+            val minVersion = allKotlinVersions.min()!!
+            val resultVersion: String = when {
+                allKotlinVersions.size == 1 -> allKotlinVersions.single()
+                minVersion.endsWith("+") -> minVersion
+                else -> "$minVersion+"
+            }
+
+            return resultVersion
+        }
 
         protected fun platformsOfItems(items: List<DocumentationNode>): Set<String> {
             val platforms = items.asSequence().map {
@@ -486,19 +502,38 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
 
                 // When no Kotlin version specified, it means that version is 1.0
                 if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) {
-                    val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct()
+                    result.intersect(platformsOfItem) + mergeVersions(otherKotlinVersion, kotlinVersions)
+                } else {
+                    result.intersect(platformsOfItem)
+                }
+            }
+        }
 
-                    val minVersion = allKotlinVersions.min()!!
-                    val resultVersion = when {
-                        allKotlinVersions.size == 1 -> allKotlinVersions.single()
-                        minVersion.endsWith("+") -> minVersion
-                        else -> "$minVersion+"
-                    }
+        protected fun unionPlatformsOfItems(items: List<DocumentationNode>): Set<String> {
+            val platforms = items.asSequence().map {
+                when (it.kind) {
+                    NodeKind.GroupNode -> unionPlatformsOfItems(it.origins)
+                    else -> it.platformsToShow.toSet()
+                }
+            }
+
+            fun String.isKotlinVersion() = this.startsWith("Kotlin")
+
+            if (platforms.count() == 0) return emptySet()
+
+            // Calculating common platforms for items
+            return platforms.reduce { result, platformsOfItem ->
+                val otherKotlinVersion = result.find { it.isKotlinVersion() }
+                val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() }
 
-                    result.intersect(otherPlatforms) + resultVersion
+                // When no Kotlin version specified, it means that version is 1.0
+                if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) {
+                    result.union(otherPlatforms) + mergeVersions(otherKotlinVersion, kotlinVersions)
                 } else {
-                    result.intersect(platformsOfItem)
+                    result.union(otherPlatforms)
                 }
+            }.let {
+                if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it
             }
         }
 
@@ -566,6 +601,17 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
         }
     }
 
+    private fun unionPlatformsOfItems(items: List<DocumentationNode>): Set<String> {
+        val platforms = items.flatMapTo(mutableSetOf<String>()) {
+            when (it.kind) {
+                NodeKind.GroupNode -> unionPlatformsOfItems(it.origins)
+                else -> it.platforms
+            }
+        }
+
+        return platforms.let { if (it.containsAll(impliedPlatforms)) it - impliedPlatforms else it }
+    }
+
 
     inner class SectionsBuilder(val node: DocumentationNode): PageBuilder(listOf(node)) {
         override fun build() {
@@ -666,12 +712,7 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
                                 }
                             }
                             appendTableCell {
-                                val nodesToAppend = if (members.all { it.kind == NodeKind.GroupNode }) {
-                                    members.flatMap { it.origins }
-                                } else {
-                                    members
-                                }
-                                appendSummarySignatures(nodesToAppend, platformsBasedOnMembers, omitSamePlatforms)
+                                appendSummarySignatures(members, platformsBasedOnMembers, omitSamePlatforms)
                             }
                         }
                     }
@@ -680,6 +721,10 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
         }
 
         private fun platformsOfItems(items: List<DocumentationNode>, omitSamePlatforms: Boolean = true): Set<String> {
+            if (items.all { it.kind != NodeKind.Package && it.kind != NodeKind.Module && it.kind != NodeKind.ExternalClass }) {
+                return unionPlatformsOfItems(items)
+            }
+
             val platforms = platformsOfItems(items)
             if (platforms.isNotEmpty() && (platforms != node.platformsToShow.toSet() || !omitSamePlatforms)) {
                 return platforms
@@ -688,35 +733,49 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
         }
 
         private fun appendSummarySignatures(items: List<DocumentationNode>, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) {
-            val summarySignature = languageService.summarizeSignatures(items)
-            if (summarySignature != null) {
-                appendSummarySignature(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms)
-                return
-            }
+            val groupBySummary = items.groupBy { it.summary }
 
+            for ((summary, node) in groupBySummary) {
+                val nodesToAppend = if (node.all { it.kind == NodeKind.GroupNode }) {
+                    node.flatMap { it.origins }
+                } else {
+                    node
+                }
 
-            val groupBySignature = items.groupBy {
-                languageService.render(it, RenderMode.SUMMARY)
-            }
-            for ((sign, node) in groupBySignature) {
-                appendSummarySignature(sign, node, platformsBasedOnMembers, omitSamePlatforms)
+                val summarySignature = languageService.summarizeSignatures(nodesToAppend)
+                if (summarySignature != null) {
+                    appendSignatures(summarySignature, items, platformsBasedOnMembers, omitSamePlatforms)
+                } else {
+                    val groupBySignature = nodesToAppend.groupBy {
+                        languageService.render(it, RenderMode.SUMMARY)
+                    }
+                    for ((sign, members) in groupBySignature) {
+                        appendSignatures(sign, members, platformsBasedOnMembers, omitSamePlatforms)
+                    }
+                }
+
+                val platforms = platformsOfItems(node)
+                appendAsBlockWithPlatforms(platforms) {
+                    appendContent(summary)
+                    appendSoftLineBreak()
+                }
             }
         }
 
-        private fun appendSummarySignature(signature: ContentNode, items: List<DocumentationNode>, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) {
+        private fun appendSignatures(signature: ContentNode, items: List<DocumentationNode>, platformsBasedOnMembers: Boolean, omitSamePlatforms: Boolean) {
             val elementPlatforms = platformsOfItems(items, omitSamePlatforms)
             val platforms = if (platformsBasedOnMembers)
                 items.flatMapTo(mutableSetOf()) { platformsOfItems(it.members) } + elementPlatforms
             else
                 elementPlatforms
 
-            appendPlatforms(platforms)
-            appendAsSignature(signature) {
-                signature.appendSignature()
+            appendAsBlockWithPlatforms(platforms) {
+                appendPlatforms(platforms)
+                    appendAsSignature(signature) {
+                        signature.appendSignature()
+                    }
+                appendSoftLineBreak()
             }
-
-            appendContent(items.first().summary)
-            appendSoftLineBreak()
         }
     }
 
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 146c1e99..f2b3a937 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -76,7 +76,11 @@ open class DocumentationNode(val name: String,
     var content: Content = content
         private set
 
-    val summary: ContentNode get() = content.summary
+    val summary: ContentNode get() = when (kind) {
+        NodeKind.GroupNode -> this.origins.first().summary
+        else -> content.summary
+    }
+
 
     val owner: DocumentationNode?
         get() = references(RefKind.Owner).singleOrNull()?.to
-- 
cgit