1 files changed, 61 insertions, 40 deletions
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 55ae5902..623f2ea3 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,11 +1,11 @@
 package org.jetbrains.dokka.Model
 
+import org.jetbrains.dokka.KotlinTypeWrapper
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
 
-class Module(val packages: List<Package>) : DocumentationNode<Nothing>() {
+class Module(val packages: List<Package>) : DocumentationNode() {
     override val dri: DRI = DRI.topLevel
     override val children: List<Package> = packages
     override val extra: MutableSet<Extra> = mutableSetOf()
@@ -17,31 +17,36 @@ class Package(
     override val properties: List<Property>,
     override val classes: List<Class>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode<Nothing>() {
+) : ScopeNode() {
     val name = dri.packageName.orEmpty()
 }
 
 class Class(
     override val dri: DRI,
     val name: String,
+    val kind: ClassKind,
     val constructors: List<Function>,
     override val functions: List<Function>,
     override val properties: List<Property>,
     override val classes: List<Class>,
-    override val expectDescriptor: Descriptor<ClassDescriptor>?,
-    override val actualDescriptors: List<Descriptor<ClassDescriptor>>,
+    override val expected: ClassPlatformInfo?,
+    override val actual: List<ClassPlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode<ClassDescriptor>()
+) : ScopeNode() {
+    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+}
 
 class Function(
     override val dri: DRI,
     val name: String,
+    val returnType: TypeWrapper?,
+    val isConstructor: Boolean,
     override val receiver: Parameter?,
     val parameters: List<Parameter>,
-    override val expectDescriptor: Descriptor<FunctionDescriptor>?,
-    override val actualDescriptors: List<Descriptor<FunctionDescriptor>>,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode<FunctionDescriptor>() {
+) : CallableNode() {
     override val children: List<Parameter>
         get() = listOfNotNull(receiver) + parameters
 }
@@ -50,10 +55,10 @@ class Property(
     override val dri: DRI,
     val name: String,
     override val receiver: Parameter?,
-    override val expectDescriptor: Descriptor<PropertyDescriptor>?,
-    override val actualDescriptors: List<Descriptor<PropertyDescriptor>>,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode<PropertyDescriptor>() {
+) : CallableNode() {
     override val children: List<Parameter>
         get() = listOfNotNull(receiver)
 }
@@ -62,67 +67,75 @@ class Property(
 class Parameter(
     override val dri: DRI,
     val name: String?,
-    override val actualDescriptors: List<Descriptor<ParameterDescriptor>>,
+    val type: TypeWrapper,
+    override val actual: List<PlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
-) : DocumentationNode<ParameterDescriptor>() {
-    override val children: List<DocumentationNode<*>>
+) : DocumentationNode() {
+    override val children: List<DocumentationNode>
         get() = emptyList()
 }
 
-class Descriptor<out T : DeclarationDescriptor>(
-    val descriptor: T,
-    val docTag: KDocTag?,
-    val links: Map<String, DRI>,
+interface PlatformInfo {
+    val docTag: KDocTag?
+    val links: Map<String, DRI>
     val platformData: List<PlatformData>
-) : DeclarationDescriptor by descriptor {
+}
+
+class BasePlatformInfo(
+    override val docTag: KDocTag?,
+    override val links: Map<String, DRI>,
+    override val platformData: List<PlatformData>) : PlatformInfo {
 
     override fun equals(other: Any?): Boolean =
-        other is Descriptor<*> && (
-                descriptor.toString() == other.descriptor.toString() &&
-                        docTag?.text == other.docTag?.text &&
+        other is PlatformInfo && (
+                docTag?.text == other.docTag?.text &&
                         links == other.links)
 
     override fun hashCode(): Int =
-        listOf(descriptor.toString(), docTag?.text, links).hashCode()
+        listOf(docTag?.text, links).hashCode()
 }
 
-abstract class DocumentationNode<out T : DeclarationDescriptor> {
-    open val expectDescriptor: Descriptor<T>? = null
-    open val actualDescriptors: List<Descriptor<T>> = emptyList()
-    val descriptors by lazy { listOfNotNull(expectDescriptor) + actualDescriptors }
-    val platformData by lazy { descriptors.flatMap { it.platformData }.toSet() }
+class ClassPlatformInfo(
+    val info: PlatformInfo,
+    val inherited: List<DRI>) : PlatformInfo by info
+
+abstract class DocumentationNode {
+    open val expected: PlatformInfo? = null
+    open val actual: List<PlatformInfo> = emptyList()
+    val platformInfo by lazy { listOfNotNull(expected) + actual }
+    val platformData by lazy { platformInfo.flatMap { it.platformData }.toSet() }
 
     abstract val dri: DRI
 
-    abstract val children: List<DocumentationNode<*>>
+    abstract val children: List<DocumentationNode>
 
     override fun toString(): String {
         return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
     }
 
-    override fun equals(other: Any?) = other is DocumentationNode<*> && this.dri == other.dri
+    override fun equals(other: Any?) = other is DocumentationNode && this.dri == other.dri
 
     override fun hashCode() = dri.hashCode()
 
     val commentsData: List<Pair<String, Map<String, DRI>>>
-        get() = descriptors.mapNotNull { it.docTag?.let { tag -> Pair(tag.getContent(), it.links) } }
+        get() = platformInfo.mapNotNull { it.docTag?.let { tag -> Pair(tag.getContent(), it.links) } }
 
     val briefDocstring: String
-        get() = descriptors.firstOrNull()?.docTag?.getContent().orEmpty().shorten(40)
+        get() = platformInfo.firstOrNull()?.docTag?.getContent().orEmpty().shorten(40)
 
     open val extra: MutableSet<Extra> = mutableSetOf()
 }
 
-abstract class ScopeNode<out T : ClassOrPackageFragmentDescriptor> : DocumentationNode<T>() {
+abstract class ScopeNode : DocumentationNode() {
     abstract val functions: List<Function>
     abstract val properties: List<Property>
     abstract val classes: List<Class>
 
-    override val children: List<DocumentationNode<MemberDescriptor>>
+    override val children: List<DocumentationNode>
         get() = functions + properties + classes
 }
 
-abstract class CallableNode<out T : CallableDescriptor> : DocumentationNode<T>() {
+abstract class CallableNode : DocumentationNode() {
     abstract val receiver: Parameter?
 }
 
@@ -130,20 +143,28 @@ private fun String.shorten(maxLength: Int) = lineSequence().first().let {
     if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
 }
 
-fun DocumentationNode<*>.walk(process: DocumentationNode<*>.() -> Unit) {
+interface TypeWrapper {
+    val constructorFqName: String?
+    val constructorNamePathSegments: List<String>
+    val arguments: List<KotlinTypeWrapper>
+    val dri: DRI?
+}
+interface ClassKind
+
+fun DocumentationNode.walk(process: DocumentationNode.() -> Unit) {
     this.process()
     this.children.forEach { it.process() }
 }
 
-fun DocumentationNode<*>.dfs(predicate: (DocumentationNode<*>) -> Boolean): DocumentationNode<*>? =
+fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): DocumentationNode? =
     if (predicate(this)) {
         this
     } else {
         this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
     }
 
-fun DocumentationNode<*>.findAll(predicate: (DocumentationNode<*>) -> Boolean): Set<DocumentationNode<*>> {
-    val found = mutableSetOf<DocumentationNode<*>>()
+fun DocumentationNode.findAll(predicate: (DocumentationNode) -> Boolean): Set<DocumentationNode> {
+    val found = mutableSetOf<DocumentationNode>()
     if (predicate(this)) {
         found.add(this)
     } else {