Introduce origin reference kind, change documentation graph merge logic, minor refactoring

5 files changed, 61 insertions, 43 deletions

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
         }