Temp changes

2 files changed, 42 insertions, 412 deletions

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 66ee33e1..19ba22a6 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,330 +1,75 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import java.util.*
-import kotlin.reflect.KClass
-import kotlin.reflect.full.primaryConstructor
+import org.jetbrains.dokka.links.ClassReference
+import org.jetbrains.kotlin.descriptors.*
 
 class DocumentationNodes {
 
-    class Unknown(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
+    class Module(name: String, parent: DocumentationNode<*>? = null):
+        DocumentationNode<Nothing>(name, parent = parent)
 
-    class Package(name: String) :
-        DocumentationNode(name)
+    class Package(name: String, parent: DocumentationNode<*>):
+        DocumentationNode<Nothing>(name, parent = parent)
 
-    class Class(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
+    class Class(name: String, descriptor: ClassDescriptor, parent: DocumentationNode<*>? = null) :
+        DocumentationNode<ClassDescriptor>(name, descriptor, parent) {
         override val classLike: Boolean = true
-    }
-
-    class Interface(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val classLike: Boolean = true
-        override val superclassType: DocumentationNode? = null
-    }
-
-    class Enum(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val classLike: Boolean = true
-    }
-
-    class AnnotationClass(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val classLike: Boolean = true
-    }
-
-    class Exception(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val classLike: Boolean = true
-    }
-
-    class EnumItem(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val memberLike = true
-    }
-
-    class Object(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val classLike: Boolean = true
-    }
-
-    class TypeAlias(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Constructor(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
+        val supertypes = mutableListOf<ClassReference>()
+        val isInterface: Boolean
+            get() = descriptor?.kind == ClassKind.CLASS
+        val isEnum: Boolean
+            get() = descriptor?.kind == ClassKind.ENUM_CLASS
+        val isEnumEntry: Boolean
+            get() = descriptor?.kind == ClassKind.ENUM_ENTRY
+        val isAnnotationClass: Boolean
+            get() = descriptor?.kind == ClassKind.ANNOTATION_CLASS
+        val isObject: Boolean
+            get() = descriptor?.kind == ClassKind.OBJECT
+    }
+
+    class Constructor(name: String, descriptor: ConstructorDescriptor) :
+        DocumentationNode<ConstructorDescriptor>(name, descriptor) {
         override val memberLike = true
     }
 
-    class Function(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
+    class Function(name: String, descriptor: FunctionDescriptor) :
+        DocumentationNode<FunctionDescriptor>(name, descriptor) {
         override val memberLike = true
     }
 
-    class Property(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
+    class Property(name: String, descriptor: PropertyDescriptor) :
+        DocumentationNode<PropertyDescriptor>(name, descriptor) {
         override val memberLike = true
     }
-
-    class Field(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
+/*
+    class Field(name: String, descriptor: FieldDescriptor) :
+        DocumentationNode<FieldDescriptor>(name, descriptor) {
         override val memberLike = true
-    }
-
-    class CompanionObjectProperty(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val memberLike = true
-    }
-
-    class CompanionObjectFunction(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val memberLike = true
-    }
-
-    class Parameter(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Receiver(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class TypeParameter(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Type(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Supertype(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor) {
-        override val superclassType: DocumentationNode? =
-            (links + listOfNotNull(externalType)).firstOrNull { it.classLike }?.superclassType
-    }
-
-    class UpperBound(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class LowerBound(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class TypeAliasUnderlyingType(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class NullabilityModifier(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Module(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class ExternalClass(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Annotation(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class Value(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class SourceUrl(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class SourcePosition(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class ExternalLink(name: String) : DocumentationNode(name)
-
-    class QualifiedName(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
+    }*/
 
-    class Platform(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class AllTypes(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
-
-    class OverloadGroupNote(name: String, descriptor: DeclarationDescriptor?) :
-        DocumentationNode(name, descriptor)
+    class Parameter(name: String, descriptor: ParameterDescriptor?) :
+        DocumentationNode<ParameterDescriptor>(name, descriptor)
+/*
+    class Annotation(name: String, descriptor: AnnotationDescriptor?) :
+        DocumentationNode<AnnotationDescriptor>(name, descriptor)*/
 }
 
-abstract class DocumentationNode(
+abstract class DocumentationNode<T: DeclarationDescriptor>(
     var name: String,
-    val descriptor: DeclarationDescriptor? = null
+    val descriptor: T? = null,
+    val parent: DocumentationNode<*>? = null
 ) {
 
-    private val references = LinkedHashSet<DocumentationReference>()
+    private val children = mutableListOf<DocumentationNode<*>>()
 
     open val classLike = false
 
     open val memberLike = false
 
-    val owner: DocumentationNode?
-        get() = references(RefKind.Owner).singleOrNull()?.to
-    val details: List<DocumentationNode>
-        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>
-        get() = recursiveInheritedMembers()
-    val inheritedCompanionObjectMembers: List<DocumentationNode>
-        get() = references(RefKind.InheritedCompanionObjectMember).map { it.to }
-    val extensions: List<DocumentationNode>
-        get() = references(RefKind.Extension).map { it.to }
-    val inheritors: List<DocumentationNode>
-        get() = references(RefKind.Inheritor).map { it.to }
-    val overrides: List<DocumentationNode>
-        get() = references(RefKind.Override).map { it.to }
-    val links: List<DocumentationNode>
-        get() = references(RefKind.Link).map { it.to }
-    val hiddenLinks: List<DocumentationNode>
-        get() = references(RefKind.HiddenLink).map { it.to }
-    val annotations: List<DocumentationNode>
-        get() = references(RefKind.Annotation).map { it.to }
-    val deprecation: DocumentationNode?
-        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()
-
-    open val superclassType: DocumentationNode?
-        get() = if (classLike) {
-            supertypes.firstOrNull {
-                (it.links + listOfNotNull(it.externalType)).any { it.isSuperclassFor(this) }
-            }
-        } 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) {
-        references.add(DocumentationReference(this, to, kind))
-    }
-
-    fun addReference(reference: DocumentationReference) {
-        references.add(reference)
-    }
-
-    fun dropReferences(predicate: (DocumentationReference) -> Boolean) {
-        references.removeAll(predicate)
-    }
-
-    fun addAllReferencesFrom(other: DocumentationNode) {
-        references.addAll(other.references)
-    }
-
-    private fun Collection<DocumentationNode>.filterByKind(kind: KClass<out DocumentationNode>) =
-        filter { node: DocumentationNode -> node::class == kind }
-
-    private fun Collection<DocumentationNode>.singleByKind(kind: KClass<out DocumentationNode>) =
-        single { node: DocumentationNode -> node::class == kind }
-
-    fun details(kind: KClass<out DocumentationNode>) = details.filterByKind(kind)
-    fun members(kind: KClass<out DocumentationNode>) = members.filterByKind(kind)
-    fun inheritedMembers(kind: KClass<out DocumentationNode>): List<DocumentationNode> =
-        inheritedMembers.filterByKind(kind)
-
-    fun inheritedCompanionObjectMembers(kind: KClass<out DocumentationNode>): List<DocumentationNode> =
-        inheritedCompanionObjectMembers.filterByKind(kind)
-
-    fun links(kind: KClass<out DocumentationNode>): List<DocumentationNode> = links.filterByKind(kind)
-
-    fun detail(kind: KClass<out DocumentationNode>): DocumentationNode = details.singleByKind(kind)
-    fun detailOrNull(kind: KClass<out DocumentationNode>): DocumentationNode? =
-        details.singleOrNull { it::class == kind }
-
-    fun member(kind: KClass<out DocumentationNode>): DocumentationNode = members.singleByKind(kind)
-    fun link(kind: KClass<out DocumentationNode>): DocumentationNode = links.singleByKind(kind)
-
-
-    fun references(kind: RefKind): List<DocumentationReference> = references.filter { it.kind == kind }
-    fun allReferences(): Set<DocumentationReference> = references
+    fun addChild(child: DocumentationNode<*>) =
+        children.add(child)
 
     override fun toString(): String {
         return "${javaClass.name}:$name"
     }
-}
-
-fun KClass<out DocumentationNode>.createNode(name: String, descriptor: DeclarationDescriptor? = null) =
-    primaryConstructor?.call(name, descriptor)
-            ?: throw IllegalArgumentException("Cannot create node of type ${this::class}: invalid primary constructor")
-
-val DocumentationNode.supertypes: List<DocumentationNode>
-    get() = details(DocumentationNodes.Supertype::class)
-
-class DocumentationModule(name: String) : DocumentationNode(name)
-
-val DocumentationNode.path: List<DocumentationNode>
-    get() {
-        val parent = owner ?: return listOf(this)
-        return parent.path + this
-    }
-
-fun DocumentationNode.append(child: DocumentationNode, kind: RefKind) {
-    addReferenceTo(child, kind)
-    when (kind) {
-        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 */
-        }
-    }
-}
-
-fun DocumentationNode.appendTextNode(
-    text: String,
-    kind: KClass<out DocumentationNode>,
-    descriptor: DeclarationDescriptor? = null,
-    refKind: RefKind = RefKind.Detail
-) {
-    append(kind.createNode(text, descriptor), refKind)
-}
-
-fun DocumentationNode.qualifiedName(): String {
-    if (this is DocumentationNodes.Type) {
-        return qualifiedNameFromType()
-    } else if (this is DocumentationNodes.Package) {
-        return name
-    }
-    return path.dropWhile { it is DocumentationNodes.Module }.map { it.name }.filter { it.isNotEmpty() }
-        .joinToString(".")
-}
-
-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)
-    }
-}
-
-private fun DocumentationNode.isSuperclassFor(node: DocumentationNode): Boolean {
-    return when (node) {
-        is DocumentationNodes.Object,
-        is DocumentationNodes.Class,
-        is DocumentationNodes.Enum -> this is DocumentationNodes.Class
-        is DocumentationNodes.Exception -> this is DocumentationNodes.Class || this is DocumentationNodes.Exception
-        else -> false
-    }
-}
-
-fun DocumentationNode.classNodeNameWithOuterClass(): String {
-    assert(classLike)
-    return path.dropWhile { it is DocumentationNodes.Package || it is DocumentationNodes.Module }
-        .joinToString(separator = ".") { it.name }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DocumentationReference.kt b/core/src/main/kotlin/Model/DocumentationReference.kt
deleted file mode 100644
index e46a4a21..00000000
--- a/core/src/main/kotlin/Model/DocumentationReference.kt
+++ /dev/null
@@ -1,115 +0,0 @@
-package org.jetbrains.dokka
-
-import com.google.inject.Singleton
-
-enum class RefKind {
-    Owner,
-    Member,
-    InheritedMember,
-    InheritedCompanionObjectMember,
-    Detail,
-    Link,
-    HiddenLink,
-    Extension,
-    Inheritor,
-    Superclass,
-    Override,
-    Annotation,
-    HiddenAnnotation,
-    Deprecation,
-    TopLevelPage,
-    Platform,
-    ExternalType,
-    Origin,
-    SinceKotlin
-}
-
-data class DocumentationReference(val from: DocumentationNode, val to: DocumentationNode, val kind: RefKind) {
-}
-
-sealed class NodeResolver {
-    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(nodeRephGraph: NodeReferenceGraph): DocumentationNode? {
-            return exactNode
-        }
-    }
-}
-
-class PendingDocumentationReference(val lazyNodeFrom: NodeResolver,
-                                    val lazyNodeTo: NodeResolver,
-                                    val kind: RefKind) {
-    fun resolve(nodeRephGraph: NodeReferenceGraph) {
-        val fromNode = lazyNodeFrom.resolve(nodeRephGraph)
-        val toNode = lazyNodeTo.resolve(nodeRephGraph)
-        if (fromNode != null && toNode != null) {
-            fromNode.addReferenceTo(toNode, kind)
-        }
-    }
-}
-
-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) {
-        nodeMap[signature] = node
-    }
-
-    fun link(fromNode: DocumentationNode, toSignature: String, kind: RefKind) {
-        references.add(
-            PendingDocumentationReference(
-                NodeResolver.Exact(fromNode),
-                NodeResolver.BySignature(toSignature),
-                kind
-            ))
-    }
-
-    fun link(fromSignature: String, toNode: DocumentationNode, kind: RefKind) {
-        references.add(
-            PendingDocumentationReference(
-                NodeResolver.BySignature(fromSignature),
-                NodeResolver.Exact(toNode),
-                kind
-            )
-        )
-    }
-
-    fun link(fromSignature: String, toSignature: String, kind: RefKind) {
-        references.add(
-            PendingDocumentationReference(
-                NodeResolver.BySignature(fromSignature),
-                NodeResolver.BySignature(toSignature),
-                kind
-            )
-        )
-    }
-
-    fun addReference(reference: PendingDocumentationReference) {
-        references.add(reference)
-    }
-
-    fun lookup(signature: String) = nodeMap[signature]
-
-    fun lookupOrWarn(signature: String, logger: DokkaLogger): DocumentationNode? {
-        val result = nodeMap[signature]
-        if (result == null) {
-            logger.warn("Can't find node by signature `$signature`." +
-                    "This is probably caused by invalid configuration of cross-module dependencies")
-        }
-        return result
-    }
-
-    fun resolveReferences() {
-        references.forEach { it.resolve(this) }
-    }
-}
\ No newline at end of file