restructure Dokka build to use Gradle for everything except for the Maven plugin

11 files changed, 0 insertions, 853 deletions

diff --git a/javadoc/src/main/kotlin/docbase.kt b/javadoc/src/main/kotlin/docbase.kt
deleted file mode 100644
index 1587db2a..00000000
--- a/javadoc/src/main/kotlin/docbase.kt
+++ /dev/null
@@ -1,501 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import com.sun.javadoc.*
-import org.jetbrains.dokka.*
-import java.lang.reflect.Modifier
-import java.util.*
-import kotlin.reflect.KClass
-
-private interface HasModule {
-    val module: ModuleNodeAdapter
-}
-
-private interface HasDocumentationNode {
-    val node: DocumentationNode
-}
-
-open class DocumentationNodeBareAdapter(override val node: DocumentationNode) : Doc, HasDocumentationNode {
-    private var rawCommentText_: String? = null
-
-    override fun name(): String = node.name
-    override fun position(): SourcePosition? = SourcePositionAdapter(node)
-
-    override fun inlineTags(): Array<out Tag>? = emptyArray()
-    override fun firstSentenceTags(): Array<out Tag>? = emptyArray()
-    override fun tags(): Array<out Tag> = emptyArray()
-    override fun tags(tagname: String?): Array<out Tag>? = tags().filter { it.kind() == tagname || it.kind() == "@$tagname" }.toTypedArray()
-    override fun seeTags(): Array<out SeeTag>? = tags().filterIsInstance<SeeTag>().toTypedArray()
-    override fun commentText(): String = ""
-
-    override fun setRawCommentText(rawDocumentation: String?) {
-        rawCommentText_ = rawDocumentation ?: ""
-    }
-
-    override fun getRawCommentText(): String = rawCommentText_ ?: ""
-
-    override fun isError(): Boolean = false
-    override fun isException(): Boolean = node.kind == DocumentationNode.Kind.Exception
-    override fun isEnumConstant(): Boolean = node.kind == DocumentationNode.Kind.EnumItem
-    override fun isEnum(): Boolean = node.kind == DocumentationNode.Kind.Enum
-    override fun isMethod(): Boolean = node.kind == DocumentationNode.Kind.Function
-    override fun isInterface(): Boolean = node.kind == DocumentationNode.Kind.Interface
-    override fun isField(): Boolean = node.kind == DocumentationNode.Kind.Field
-    override fun isClass(): Boolean = node.kind == DocumentationNode.Kind.Class
-    override fun isAnnotationType(): Boolean = node.kind == DocumentationNode.Kind.AnnotationClass
-    override fun isConstructor(): Boolean = node.kind == DocumentationNode.Kind.Constructor
-    override fun isOrdinaryClass(): Boolean = node.kind == DocumentationNode.Kind.Class
-    override fun isAnnotationTypeElement(): Boolean = node.kind == DocumentationNode.Kind.Annotation
-
-    override fun compareTo(other: Any?): Int = when (other) {
-        !is DocumentationNodeAdapter -> 1
-        else -> node.name.compareTo(other.node.name)
-    }
-
-    override fun equals(other: Any?): Boolean = node.qualifiedName() == (other as? DocumentationNodeAdapter)?.node?.qualifiedName()
-    override fun hashCode(): Int = node.name.hashCode()
-
-    override fun isIncluded(): Boolean = node.kind != DocumentationNode.Kind.ExternalClass
-}
-
-
-// TODO think of source position instead of null
-// TODO tags
-open class DocumentationNodeAdapter(override val module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeBareAdapter(node), HasModule {
-    override fun inlineTags(): Array<out Tag> = buildInlineTags(module, this, node.content).toTypedArray()
-    override fun firstSentenceTags(): Array<out Tag> = buildInlineTags(module, this, node.summary).toTypedArray()
-
-    override fun tags(): Array<out Tag> {
-        val result = ArrayList<Tag>(buildInlineTags(module, this, node.content))
-        node.content.sections.flatMapTo(result) {
-            when (it.tag) {
-                ContentTags.SeeAlso -> buildInlineTags(module, this, it)
-                else -> emptyList<Tag>()
-            }
-        }
-
-        node.deprecation?.let {
-            val content = it.content.asText()
-            if (content != null) {
-                result.add(TagImpl(this, "deprecated", content))
-            }
-        }
-
-        return result.toTypedArray()
-    }
-}
-
-// should be extension property but can't because of KT-8745
-private fun <T> nodeAnnotations(self: T): List<AnnotationDescAdapter> where T : HasModule, T : HasDocumentationNode
-    = self.node.annotations.map { AnnotationDescAdapter(self.module, it) }
-
-private fun DocumentationNode.hasAnnotation(klass: KClass<*>) = klass.qualifiedName in annotations.map { it.qualifiedName() }
-private fun DocumentationNode.hasModifier(name: String) = details(DocumentationNode.Kind.Modifier).any { it.name == name }
-
-
-class PackageAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), PackageDoc {
-    private val allClasses = listOf(node).collectAllTypesRecursively()
-
-    override fun findClass(className: String?): ClassDoc? =
-            allClasses.get(className)?.let { ClassDocumentationNodeAdapter(module, it) }
-
-    override fun annotationTypes(): Array<out AnnotationTypeDoc> = emptyArray()
-    override fun annotations(): Array<out AnnotationDesc> = node.members(DocumentationNode.Kind.AnnotationClass).map { AnnotationDescAdapter(module, it) }.toTypedArray()
-    override fun exceptions(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Exception).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun ordinaryClasses(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun interfaces(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Interface).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun errors(): Array<out ClassDoc> = emptyArray()
-    override fun enums(): Array<out ClassDoc> = node.members(DocumentationNode.Kind.Enum).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun allClasses(filter: Boolean): Array<out ClassDoc> = allClasses.values.map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun allClasses(): Array<out ClassDoc> = allClasses(true)
-
-    override fun isIncluded(): Boolean = node.name in module.allPackages
-}
-
-class AnnotationTypeDocAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : ClassDocumentationNodeAdapter(module, node), AnnotationTypeDoc {
-    override fun elements(): Array<out AnnotationTypeElementDoc>? = emptyArray() // TODO
-}
-
-class AnnotationDescAdapter(val module: ModuleNodeAdapter, val node: DocumentationNode) : AnnotationDesc {
-    override fun annotationType(): AnnotationTypeDoc? = AnnotationTypeDocAdapter(module, node) // TODO ?????
-    override fun isSynthesized(): Boolean = false
-    override fun elementValues(): Array<out AnnotationDesc.ElementValuePair>? = emptyArray() // TODO
-}
-
-class ProgramElementAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), ProgramElementDoc {
-    override fun isPublic(): Boolean = true
-    override fun isPackagePrivate(): Boolean = false
-    override fun isStatic(): Boolean = node.hasModifier("static")
-    override fun modifierSpecifier(): Int = Modifier.PUBLIC + if (isStatic) Modifier.STATIC else 0
-    override fun qualifiedName(): String? = if (node.kind == DocumentationNode.Kind.Type) node.qualifiedNameFromType() else node.qualifiedName()
-    override fun annotations(): Array<out AnnotationDesc>? = nodeAnnotations(this).toTypedArray()
-    override fun modifiers(): String? = "public ${if (isStatic) "static" else ""}".trim()
-    override fun isProtected(): Boolean = false
-
-    override fun isFinal(): Boolean = node.hasModifier("final")
-
-    override fun containingPackage(): PackageDoc? {
-        if (node.kind == DocumentationNode.Kind.Type) {
-            return null
-        }
-
-        var owner: DocumentationNode? = node
-        while (owner != null) {
-            if (owner.kind == DocumentationNode.Kind.Package) {
-                return PackageAdapter(module, owner)
-            }
-            owner = owner.owner
-        }
-
-        return null
-    }
-
-    override fun containingClass(): ClassDoc? {
-        if (node.kind == DocumentationNode.Kind.Type) {
-            return null
-        }
-
-        var owner = node.owner
-        while (owner != null) {
-            when (owner.kind) {
-                DocumentationNode.Kind.Class,
-                DocumentationNode.Kind.Interface,
-                DocumentationNode.Kind.Enum -> return ClassDocumentationNodeAdapter(module, owner)
-                else -> owner = owner.owner
-            }
-        }
-
-        return null
-    }
-
-    override fun isPrivate(): Boolean = false
-    override fun isIncluded(): Boolean = containingPackage()?.isIncluded ?: false && containingClass()?.let { it.isIncluded } ?: true
-}
-
-open class TypeAdapter(override val module: ModuleNodeAdapter, override val node: DocumentationNode) : Type, HasDocumentationNode, HasModule {
-    private val javaLanguageService = JavaLanguageService()
-
-    override fun qualifiedTypeName(): String = javaLanguageService.getArrayElementType(node)?.qualifiedNameFromType() ?: node.qualifiedNameFromType()
-    override fun typeName(): String = javaLanguageService.getArrayElementType(node)?.name ?: node.name
-    override fun simpleTypeName(): String = typeName() // TODO difference typeName() vs simpleTypeName()
-
-    override fun dimension(): String = Collections.nCopies(javaLanguageService.getArrayDimension(node), "[]").joinToString("")
-    override fun isPrimitive(): Boolean = simpleTypeName() in setOf("int", "long", "short", "byte", "char", "double", "float", "boolean", "void")
-
-    override fun asClassDoc(): ClassDoc? = if (isPrimitive) null else
-            elementType?.asClassDoc() ?:
-            when (node.kind) {
-                in DocumentationNode.Kind.classLike,
-                DocumentationNode.Kind.ExternalClass,
-                DocumentationNode.Kind.Exception -> module.classNamed(qualifiedTypeName()) ?: ClassDocumentationNodeAdapter(module, node)
-
-                else -> when {
-                    node.links.isNotEmpty() -> TypeAdapter(module, node.links.first()).asClassDoc()
-                    else -> ClassDocumentationNodeAdapter(module, node) // TODO ?
-                }
-            }
-
-    override fun asTypeVariable(): TypeVariable? = if (node.kind == DocumentationNode.Kind.TypeParameter) TypeVariableAdapter(module, node) else null
-    override fun asParameterizedType(): ParameterizedType? =
-            if (node.details(DocumentationNode.Kind.Type).isNotEmpty()) ParameterizedTypeAdapter(module, node)
-            else null  // TODO it should ignore dimensions
-
-    override fun asAnnotationTypeDoc(): AnnotationTypeDoc? = if (node.kind == DocumentationNode.Kind.AnnotationClass) AnnotationTypeDocAdapter(module, node) else null
-    override fun asAnnotatedType(): AnnotatedType? = if (node.annotations.isNotEmpty()) AnnotatedTypeAdapter(module, node) else null
-    override fun getElementType(): Type? = javaLanguageService.getArrayElementType(node)?.let { et -> TypeAdapter(module, et) }
-    override fun asWildcardType(): WildcardType? = null
-
-    override fun toString(): String = qualifiedTypeName() + dimension()
-    override fun hashCode(): Int = node.name.hashCode()
-    override fun equals(other: Any?): Boolean = other is TypeAdapter && toString() == other.toString()
-}
-
-class AnnotatedTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), AnnotatedType {
-    override fun underlyingType(): Type? = this
-    override fun annotations(): Array<out AnnotationDesc> = nodeAnnotations(this).toTypedArray()
-}
-
-class WildcardTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), WildcardType {
-    override fun extendsBounds(): Array<out Type> = node.details(DocumentationNode.Kind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray()
-    override fun superBounds(): Array<out Type> = node.details(DocumentationNode.Kind.LowerBound).map { TypeAdapter(module, it) }.toTypedArray()
-}
-
-class TypeVariableAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), TypeVariable {
-    override fun owner(): ProgramElementDoc = node.owner!!.let<DocumentationNode, ProgramElementDoc> { owner ->
-        when (owner.kind) {
-            DocumentationNode.Kind.Function,
-            DocumentationNode.Kind.Constructor -> ExecutableMemberAdapter(module, owner)
-
-            DocumentationNode.Kind.Class,
-            DocumentationNode.Kind.Interface,
-            DocumentationNode.Kind.Enum -> ClassDocumentationNodeAdapter(module, owner)
-
-            else -> ProgramElementAdapter(module, node.owner!!)
-        }
-    }
-
-    override fun bounds(): Array<out Type>? = node.details(DocumentationNode.Kind.UpperBound).map { TypeAdapter(module, it) }.toTypedArray()
-    override fun annotations(): Array<out AnnotationDesc>? = node.members(DocumentationNode.Kind.Annotation).map { AnnotationDescAdapter(module, it) }.toTypedArray()
-
-    override fun qualifiedTypeName(): String = node.name
-    override fun simpleTypeName(): String = node.name
-    override fun typeName(): String = node.name
-
-    override fun hashCode(): Int = node.name.hashCode()
-    override fun equals(other: Any?): Boolean = other is Type && other.typeName() == typeName() && other.asTypeVariable()?.owner() == owner()
-
-    override fun asTypeVariable(): TypeVariableAdapter = this
-}
-
-class ParameterizedTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), ParameterizedType {
-    override fun typeArguments(): Array<out Type> = node.details(DocumentationNode.Kind.Type).map { TypeVariableAdapter(module, it) }.toTypedArray()
-    override fun superclassType(): Type? =
-            node.lookupSuperClasses(module)
-                    .firstOrNull { it.kind == DocumentationNode.Kind.Class || it.kind == DocumentationNode.Kind.ExternalClass }
-                    ?.let { ClassDocumentationNodeAdapter(module, it) }
-
-    override fun interfaceTypes(): Array<out Type> =
-            node.lookupSuperClasses(module)
-                    .filter { it.kind == DocumentationNode.Kind.Interface }
-                    .map { ClassDocumentationNodeAdapter(module, it) }
-                    .toTypedArray()
-
-    override fun containingType(): Type? = when (node.owner?.kind) {
-        DocumentationNode.Kind.Package -> null
-        DocumentationNode.Kind.Class,
-        DocumentationNode.Kind.Interface,
-        DocumentationNode.Kind.Object,
-        DocumentationNode.Kind.Enum -> ClassDocumentationNodeAdapter(module, node.owner!!)
-
-        else -> null
-    }
-}
-
-class ParameterAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), Parameter {
-    override fun typeName(): String? = JavaLanguageService().renderType(node.detail(DocumentationNode.Kind.Type))
-    override fun type(): Type? = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type))
-    override fun annotations(): Array<out AnnotationDesc> = nodeAnnotations(this).toTypedArray()
-}
-
-class ReceiverParameterAdapter(module: ModuleNodeAdapter, val receiverType: DocumentationNode, val parent: ExecutableMemberAdapter) : DocumentationNodeAdapter(module, receiverType), Parameter {
-    override fun typeName(): String? = receiverType.name
-    override fun type(): Type? = TypeAdapter(module, receiverType)
-    override fun annotations(): Array<out AnnotationDesc> = nodeAnnotations(this).toTypedArray()
-    override fun name(): String = tryName("receiver")
-
-    private tailrec fun tryName(name: String): String = when (name) {
-        in parent.parameters().drop(1).map { it.name() } -> tryName("$$name")
-        else -> name
-    }
-}
-
-fun classOf(fqName: String, kind: DocumentationNode.Kind = DocumentationNode.Kind.Class) = DocumentationNode(fqName.substringAfterLast(".", fqName), Content.Empty, kind).let { node ->
-    val pkg = fqName.substringBeforeLast(".", "")
-    if (pkg.isNotEmpty()) {
-        node.append(DocumentationNode(pkg, Content.Empty, DocumentationNode.Kind.Package), DocumentationReference.Kind.Owner)
-    }
-
-    node
-}
-
-open class ExecutableMemberAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), ProgramElementDoc by ProgramElementAdapter(module, node), ExecutableMemberDoc {
-
-    override fun isSynthetic(): Boolean = false
-    override fun isNative(): Boolean = node.annotations.any { it.name == "native" }
-
-    override fun thrownExceptions(): Array<out ClassDoc> = emptyArray() // TODO
-    override fun throwsTags(): Array<out ThrowsTag> =
-            node.content.sections
-                    .filter { it.tag == "Exceptions" }
-                    .map { it.subjectName }
-                    .filterNotNull()
-                    .map { ThrowsTagAdapter(this, ClassDocumentationNodeAdapter(module, classOf(it, DocumentationNode.Kind.Exception))) }
-                    .toTypedArray()
-
-    override fun isVarArgs(): Boolean = node.details(DocumentationNode.Kind.Parameter).any { false } // TODO
-
-    override fun isSynchronized(): Boolean = node.annotations.any { it.name == "synchronized" }
-
-    override fun paramTags(): Array<out ParamTag> = node.details(DocumentationNode.Kind.Parameter)
-            .filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }
-            .map { ParamTagAdapter(module, this, it.name, false, it.content.children) }
-            .toTypedArray()
-
-    override fun thrownExceptionTypes(): Array<out Type> = emptyArray()
-    override fun receiverType(): Type? = receiverNode()?.let { receiver -> TypeAdapter(module, receiver) }
-    override fun flatSignature(): String = node.details(DocumentationNode.Kind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")")
-    override fun signature(): String = node.details(DocumentationNode.Kind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")") // TODO it should be FQ types
-
-    override fun parameters(): Array<out Parameter> =
-            ((receiverNode()?.let { receiver -> listOf<Parameter>(ReceiverParameterAdapter(module, receiver, this)) } ?: emptyList())
-                    + node.details(DocumentationNode.Kind.Parameter).map { ParameterAdapter(module, it) }
-                    ).toTypedArray()
-
-    override fun typeParameters(): Array<out TypeVariable> = node.details(DocumentationNode.Kind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray()
-
-    override fun typeParamTags(): Array<out ParamTag> = node.details(DocumentationNode.Kind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map {
-        ParamTagAdapter(module, this, it.name, true, it.content.children)
-    }.toTypedArray()
-
-    private fun receiverNode() = node.details(DocumentationNode.Kind.Receiver).let { receivers ->
-        when {
-            receivers.isNotEmpty() -> receivers.single().detail(DocumentationNode.Kind.Type)
-            else -> null
-        }
-    }
-}
-
-class ConstructorAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : ExecutableMemberAdapter(module, node), ConstructorDoc {
-    override fun name(): String = node.owner?.name ?: throw IllegalStateException("No owner for $node")
-}
-
-class MethodAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), ExecutableMemberDoc by ExecutableMemberAdapter(module, node), MethodDoc {
-    override fun overrides(meth: MethodDoc?): Boolean = false // TODO
-
-    override fun overriddenType(): Type? = node.overrides.firstOrNull()?.owner?.let { owner -> TypeAdapter(module, owner) }
-
-    override fun overriddenMethod(): MethodDoc? = node.overrides.map { MethodAdapter(module, it) }.firstOrNull()
-    override fun overriddenClass(): ClassDoc? = overriddenMethod()?.containingClass()
-
-    override fun isAbstract(): Boolean = false // TODO
-
-    override fun isDefault(): Boolean = false
-
-    override fun returnType(): Type = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type))
-}
-
-class FieldAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : DocumentationNodeAdapter(module, node), ProgramElementDoc by ProgramElementAdapter(module, node), FieldDoc {
-    override fun isSynthetic(): Boolean = false
-
-    override fun constantValueExpression(): String? = node.details(DocumentationNode.Kind.Value).firstOrNull()?.let { it.name }
-    override fun constantValue(): Any? = constantValueExpression()
-
-    override fun type(): Type = TypeAdapter(module, node.detail(DocumentationNode.Kind.Type))
-    override fun isTransient(): Boolean = node.hasAnnotation(Transient::class)
-    override fun serialFieldTags(): Array<out SerialFieldTag> = emptyArray()
-
-    override fun isVolatile(): Boolean = node.hasAnnotation(Volatile::class)
-}
-
-open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNode: DocumentationNode)
-    : DocumentationNodeAdapter(module, classNode),
-      Type by TypeAdapter(module, classNode),
-      ProgramElementDoc by ProgramElementAdapter(module, classNode),
-      ClassDoc {
-
-    override fun name(): String {
-        val parent = classNode.owner
-        if (parent?.kind in DocumentationNode.Kind.classLike) {
-            return parent!!.name + "." + classNode.name
-        }
-        return classNode.name
-    }
-
-    override fun constructors(filter: Boolean): Array<out ConstructorDoc> = classNode.members(DocumentationNode.Kind.Constructor).map { ConstructorAdapter(module, it) }.toTypedArray()
-    override fun constructors(): Array<out ConstructorDoc> = constructors(true)
-    override fun importedPackages(): Array<out PackageDoc> = emptyArray()
-    override fun importedClasses(): Array<out ClassDoc>? = emptyArray()
-    override fun typeParameters(): Array<out TypeVariable> = classNode.details(DocumentationNode.Kind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray()
-    override fun asTypeVariable(): TypeVariable? = if (classNode.kind == DocumentationNode.Kind.Class) TypeVariableAdapter(module, classNode) else null
-    override fun isExternalizable(): Boolean = interfaces().any { it.qualifiedName() == "java.io.Externalizable" }
-    override fun definesSerializableFields(): Boolean = false
-    override fun methods(filter: Boolean): Array<out MethodDoc> = classNode.members(DocumentationNode.Kind.Function).map { MethodAdapter(module, it) }.toTypedArray() // TODO include get/set methods
-    override fun methods(): Array<out MethodDoc> = methods(true)
-    override fun enumConstants(): Array<out FieldDoc>? = classNode.members(DocumentationNode.Kind.EnumItem).map { FieldAdapter(module, it) }.toTypedArray()
-    override fun isAbstract(): Boolean = classNode.details(DocumentationNode.Kind.Modifier).any { it.name == "abstract" }
-    override fun interfaceTypes(): Array<out Type> = classNode.lookupSuperClasses(module)
-            .filter { it.kind == DocumentationNode.Kind.Interface }
-            .map { ClassDocumentationNodeAdapter(module, it) }
-            .toTypedArray()
-
-    override fun interfaces(): Array<out ClassDoc> = classNode.lookupSuperClasses(module)
-            .filter { it.kind == DocumentationNode.Kind.Interface }
-            .map { ClassDocumentationNodeAdapter(module, it) }
-            .toTypedArray()
-
-    override fun typeParamTags(): Array<out ParamTag> = (classNode.details(DocumentationNode.Kind.TypeParameter).filter { it.content.summary !is ContentEmpty || it.content.description !is ContentEmpty || it.content.sections.isNotEmpty() }.map {
-        ParamTagAdapter(module, this, it.name, true, it.content.children)
-    } + classNode.content.sections.filter { it.subjectName in typeParameters().map { it.simpleTypeName() } }.map {
-        ParamTagAdapter(module, this, it.subjectName ?: "?", true, it.children)
-    }).toTypedArray()
-
-    override fun fields(): Array<out FieldDoc> = fields(true)
-    override fun fields(filter: Boolean): Array<out FieldDoc> = classNode.members(DocumentationNode.Kind.Field).map { FieldAdapter(module, it) }.toTypedArray()
-
-    override fun findClass(className: String?): ClassDoc? = null // TODO !!!
-    override fun serializableFields(): Array<out FieldDoc> = emptyArray()
-    override fun superclassType(): Type? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == DocumentationNode.Kind.Class }?.let { ClassDocumentationNodeAdapter(module, it) }
-    override fun serializationMethods(): Array<out MethodDoc> = emptyArray() // TODO
-    override fun superclass(): ClassDoc? = classNode.lookupSuperClasses(module).singleOrNull { it.kind == DocumentationNode.Kind.Class }?.let { ClassDocumentationNodeAdapter(module, it) }
-    override fun isSerializable(): Boolean = false // TODO
-    override fun subclassOf(cd: ClassDoc?): Boolean {
-        if (cd == null) {
-            return false
-        }
-
-        val expectedFQName = cd.qualifiedName()
-        val types = arrayListOf(classNode)
-        val visitedTypes = HashSet<String>()
-
-        while (types.isNotEmpty()) {
-            val type = types.removeAt(types.lastIndex)
-            val fqName = type.qualifiedName()
-
-            if (expectedFQName == fqName) {
-                return true
-            }
-
-            visitedTypes.add(fqName)
-            types.addAll(type.details(DocumentationNode.Kind.Supertype).filter { it.qualifiedName() !in visitedTypes })
-        }
-
-        return false
-    }
-
-    override fun innerClasses(): Array<out ClassDoc> = classNode.members(DocumentationNode.Kind.Class).map { ClassDocumentationNodeAdapter(module, it) }.toTypedArray()
-    override fun innerClasses(filter: Boolean): Array<out ClassDoc> = innerClasses()
-}
-
-fun DocumentationNode.lookupSuperClasses(module: ModuleNodeAdapter) =
-        details(DocumentationNode.Kind.Supertype)
-                .map { it.links.firstOrNull() }
-                .map { module.allTypes[it?.qualifiedName()] }
-                .filterNotNull()
-
-fun List<DocumentationNode>.collectAllTypesRecursively(): Map<String, DocumentationNode> {
-    val result = hashMapOf<String, DocumentationNode>()
-
-    fun DocumentationNode.collectTypesRecursively() {
-        val classLikeMembers = DocumentationNode.Kind.classLike.flatMap { members(it) }
-        classLikeMembers.forEach {
-            result.put(it.qualifiedName(), it)
-            it.collectTypesRecursively()
-        }
-    }
-
-    forEach { it.collectTypesRecursively() }
-    return result
-}
-
-class ModuleNodeAdapter(val module: DocumentationModule, val reporter: DocErrorReporter, val outputPath: String) : DocumentationNodeBareAdapter(module), DocErrorReporter by reporter, RootDoc {
-    val allPackages = module.members(DocumentationNode.Kind.Package).toMapBy { it.name }
-    val allTypes = module.members(DocumentationNode.Kind.Package).collectAllTypesRecursively()
-
-    override fun packageNamed(name: String?): PackageDoc? = allPackages[name]?.let { PackageAdapter(this, it) }
-
-    override fun classes(): Array<out ClassDoc> =
-            allTypes.values.map { ClassDocumentationNodeAdapter(this, it) }.toTypedArray()
-
-    override fun options(): Array<out Array<String>> = arrayOf(
-            arrayOf("-d", outputPath),
-            arrayOf("-docencoding", "UTF-8"),
-            arrayOf("-charset", "UTF-8"),
-            arrayOf("-keywords")
-    )
-
-    override fun specifiedPackages(): Array<out PackageDoc>? = module.members(DocumentationNode.Kind.Package).map { PackageAdapter(this, it) }.toTypedArray()
-
-    override fun classNamed(qualifiedName: String?): ClassDoc? =
-            allTypes[qualifiedName]?.let { ClassDocumentationNodeAdapter(this, it) }
-
-    override fun specifiedClasses(): Array<out ClassDoc> = classes()
-}
diff --git a/javadoc/src/main/kotlin/dokka-adapters.kt b/javadoc/src/main/kotlin/dokka-adapters.kt
deleted file mode 100644
index 00b73cae..00000000
--- a/javadoc/src/main/kotlin/dokka-adapters.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import com.google.inject.Inject
-import com.sun.tools.doclets.formats.html.HtmlDoclet
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Formats.FormatDescriptor
-
-class JavadocGenerator @Inject constructor (val options: DocumentationOptions, val logger: DokkaLogger) : Generator {
-    override fun buildPages(nodes: Iterable<DocumentationNode>) {
-        val module = nodes.single() as DocumentationModule
-
-        DokkaConsoleLogger.report()
-        HtmlDoclet.start(ModuleNodeAdapter(module, StandardReporter(logger), options.outputDir))
-    }
-
-    override fun buildOutlines(nodes: Iterable<DocumentationNode>) {
-        // no outline could be generated separately
-    }
-}
-
-class JavadocFormatDescriptor : FormatDescriptor {
-    override val formatServiceClass = null
-    override val outlineServiceClass = null
-    override val generatorServiceClass = JavadocGenerator::class
-    override val packageDocumentationBuilderClass = KotlinAsJavaDocumentationBuilder::class
-    override val javaDocumentationBuilderClass = JavaPsiDocumentationBuilder::class
-}
diff --git a/javadoc/src/main/kotlin/reporter.kt b/javadoc/src/main/kotlin/reporter.kt
deleted file mode 100644
index fc38368c..00000000
--- a/javadoc/src/main/kotlin/reporter.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import com.sun.javadoc.DocErrorReporter
-import com.sun.javadoc.SourcePosition
-import org.jetbrains.dokka.DokkaLogger
-
-class StandardReporter(val logger: DokkaLogger) : DocErrorReporter {
-    override fun printWarning(msg: String?) {
-        logger.warn(msg.toString())
-    }
-
-    override fun printWarning(pos: SourcePosition?, msg: String?) {
-        logger.warn(format(pos, msg))
-    }
-
-    override fun printError(msg: String?) {
-        logger.error(msg.toString())
-    }
-
-    override fun printError(pos: SourcePosition?, msg: String?) {
-        logger.error(format(pos, msg))
-    }
-
-    override fun printNotice(msg: String?) {
-        logger.info(msg.toString())
-    }
-
-    override fun printNotice(pos: SourcePosition?, msg: String?) {
-        logger.info(format(pos, msg))
-    }
-
-    private fun format(pos: SourcePosition?, msg: String?) =
-            if (pos == null) msg.toString() else "${pos.file()}:${pos.line()}:${pos.column()}: $msg"
-}
\ No newline at end of file
diff --git a/javadoc/src/main/kotlin/source-position.kt b/javadoc/src/main/kotlin/source-position.kt
deleted file mode 100644
index 0e4c6e3c..00000000
--- a/javadoc/src/main/kotlin/source-position.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import com.sun.javadoc.SourcePosition
-import org.jetbrains.dokka.DocumentationNode
-import java.io.File
-
-class SourcePositionAdapter(val docNode: DocumentationNode) : SourcePosition {
-
-    private val sourcePositionParts: List<String> by lazy {
-        docNode.details(DocumentationNode.Kind.SourcePosition).firstOrNull()?.name?.split(":") ?: emptyList()
-    }
-
-    override fun file(): File? = if (sourcePositionParts.isEmpty()) null else File(sourcePositionParts[0])
-
-    override fun line(): Int = sourcePositionParts.getOrNull(1)?.toInt() ?: -1
-
-    override fun column(): Int = sourcePositionParts.getOrNull(2)?.toInt() ?: -1
-}
diff --git a/javadoc/src/main/kotlin/tags.kt b/javadoc/src/main/kotlin/tags.kt
deleted file mode 100644
index 5872dbaa..00000000
--- a/javadoc/src/main/kotlin/tags.kt
+++ /dev/null
@@ -1,214 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import com.sun.javadoc.*
-import org.jetbrains.dokka.*
-import java.util.*
-
-class TagImpl(val holder: Doc, val name: String, val text: String): Tag {
-    override fun text(): String? = text
-
-    override fun holder(): Doc = holder
-    override fun firstSentenceTags(): Array<out Tag>? = arrayOf()
-    override fun inlineTags(): Array<out Tag>?  = arrayOf()
-
-    override fun name(): String = name
-    override fun kind(): String = name
-
-    override fun position(): SourcePosition = holder.position()
-}
-
-class TextTag(val holder: Doc, val content: ContentText) : Tag {
-    val plainText: String
-        get() = content.text
-
-    override fun name(): String = "Text"
-    override fun kind(): String = name()
-    override fun text(): String? = plainText
-    override fun inlineTags(): Array<out Tag> = arrayOf(this)
-    override fun holder(): Doc = holder
-    override fun firstSentenceTags(): Array<out Tag> = arrayOf(this)
-    override fun position(): SourcePosition = holder.position()
-}
-
-abstract class SeeTagAdapter(val holder: Doc, val content: ContentNodeLink) : SeeTag {
-    override fun position(): SourcePosition? = holder.position()
-    override fun name(): String = "@see"
-    override fun kind(): String = "@see"
-    override fun holder(): Doc = holder
-
-    override fun text(): String? = content.node?.name ?: "(?)"
-}
-
-class SeeExternalLinkTagAdapter(val holder: Doc, val link: ContentExternalLink) : SeeTag {
-    override fun position(): SourcePosition = holder.position()
-    override fun text(): String = label()
-    override fun inlineTags(): Array<out Tag> = emptyArray() // TODO
-
-    override fun label(): String {
-        val label = link.asText() ?: link.href
-        return "<a href=\"${link.href}\">$label</a>"
-    }
-
-    override fun referencedPackage(): PackageDoc? = null
-    override fun referencedClass(): ClassDoc? = null
-    override fun referencedMemberName(): String? = null
-    override fun referencedClassName(): String? = null
-    override fun referencedMember(): MemberDoc? = null
-    override fun holder(): Doc = holder
-    override fun firstSentenceTags(): Array<out Tag> = inlineTags()
-    override fun name(): String = "@link"
-    override fun kind(): String = "@see"
-}
-
-fun ContentBlock.asText(): String? {
-    val contentText = children.singleOrNull() as? ContentText
-    return contentText?.text
-}
-
-class SeeMethodTagAdapter(holder: Doc, val method: MethodAdapter, content: ContentNodeLink) : SeeTagAdapter(holder, content) {
-    override fun referencedMember(): MemberDoc = method
-    override fun referencedMemberName(): String = method.name()
-    override fun referencedPackage(): PackageDoc? = null
-    override fun referencedClass(): ClassDoc = method.containingClass()
-    override fun referencedClassName(): String = method.containingClass().name()
-    override fun label(): String = "${method.containingClass().name()}.${method.name()}"
-
-    override fun inlineTags(): Array<out Tag> = emptyArray() // TODO
-    override fun firstSentenceTags(): Array<out Tag> = inlineTags() // TODO
-}
-
-class SeeClassTagAdapter(holder: Doc, val clazz: ClassDocumentationNodeAdapter, content: ContentNodeLink) : SeeTagAdapter(holder, content) {
-    override fun referencedMember(): MemberDoc? = null
-    override fun referencedMemberName(): String? = null
-    override fun referencedPackage(): PackageDoc? = null
-    override fun referencedClass(): ClassDoc = clazz
-    override fun referencedClassName(): String = clazz.name()
-    override fun label(): String = "${clazz.classNode.kind.name.toLowerCase()} ${clazz.name()}"
-
-    override fun inlineTags(): Array<out Tag> = emptyArray() // TODO
-    override fun firstSentenceTags(): Array<out Tag> = inlineTags() // TODO
-}
-
-class ParamTagAdapter(val module: ModuleNodeAdapter,
-                      val holder: Doc,
-                      val parameterName: String,
-                      val typeParameter: Boolean,
-                      val content: List<ContentNode>) : ParamTag {
-
-    constructor(module: ModuleNodeAdapter, holder: Doc, parameterName: String, isTypeParameter: Boolean, content: ContentNode)
-        : this(module, holder, parameterName, isTypeParameter, listOf(content)) {
-    }
-
-    override fun name(): String = "@param"
-    override fun kind(): String = name()
-    override fun holder(): Doc = holder
-    override fun position(): SourcePosition? = holder.position()
-
-    override fun text(): String = "@param $parameterName ..."
-    override fun inlineTags(): Array<out Tag> = content.flatMap { buildInlineTags(module, holder, it) }.toTypedArray()
-    override fun firstSentenceTags(): Array<out Tag> = arrayOf(TextTag(holder, ContentText(text())))
-
-    override fun isTypeParameter(): Boolean = typeParameter
-    override fun parameterComment(): String = content.toString() // TODO
-    override fun parameterName(): String = parameterName
-}
-
-
-class ThrowsTagAdapter(val holder: Doc, val type: ClassDocumentationNodeAdapter) : ThrowsTag {
-    override fun name(): String = "@throws"
-    override fun kind(): String = name()
-    override fun holder(): Doc = holder
-    override fun position(): SourcePosition? = holder.position()
-
-    override fun text(): String = "@throws ${type.qualifiedTypeName()}"
-    override fun inlineTags(): Array<out Tag> = emptyArray()
-    override fun firstSentenceTags(): Array<out Tag> = emptyArray()
-
-    override fun exceptionComment(): String = ""
-    override fun exceptionType(): Type = type
-    override fun exception(): ClassDoc = type
-    override fun exceptionName(): String = type.qualifiedName()
-}
-
-fun buildInlineTags(module: ModuleNodeAdapter, holder: Doc, root: ContentNode): List<Tag> = ArrayList<Tag>().let { buildInlineTags(module, holder, root, it); it }
-
-private fun buildInlineTags(module: ModuleNodeAdapter, holder: Doc, nodes: List<ContentNode>, result: MutableList<Tag>) {
-    nodes.forEach {
-        buildInlineTags(module, holder, it, result)
-    }
-}
-
-
-private fun buildInlineTags(module: ModuleNodeAdapter, holder: Doc, node: ContentNode, result: MutableList<Tag>) {
-    fun surroundWith(module: ModuleNodeAdapter, holder: Doc, prefix: String, postfix: String, node: ContentBlock, result: MutableList<Tag>) {
-        if (node.children.isNotEmpty()) {
-            val open = TextTag(holder, ContentText(prefix))
-            val close = TextTag(holder, ContentText(postfix))
-
-            result.add(open)
-            buildInlineTags(module, holder, node.children, result)
-
-            if (result.last() === open) {
-                result.removeAt(result.lastIndex)
-            } else {
-                result.add(close)
-            }
-        }
-    }
-
-    fun surroundWith(module: ModuleNodeAdapter, holder: Doc, prefix: String, postfix: String, node: ContentNode, result: MutableList<Tag>) {
-        if (node !is ContentEmpty) {
-            val open = TextTag(holder, ContentText(prefix))
-            val close = TextTag(holder, ContentText(postfix))
-
-            result.add(open)
-            buildInlineTags(module, holder, node, result)
-            if (result.last() === open) {
-                result.removeAt(result.lastIndex)
-            } else {
-                result.add(close)
-            }
-        }
-    }
-
-    when (node) {
-        is ContentText -> result.add(TextTag(holder, node))
-        is ContentNodeLink -> {
-            val target = node.node
-            when (target?.kind) {
-                DocumentationNode.Kind.Function -> result.add(SeeMethodTagAdapter(holder, MethodAdapter(module, node.node!!), node))
-
-                in DocumentationNode.Kind.classLike -> result.add(SeeClassTagAdapter(holder, ClassDocumentationNodeAdapter(module, node.node!!), node))
-
-                else -> buildInlineTags(module, holder, node.children, result)
-            }
-        }
-        is ContentExternalLink -> result.add(SeeExternalLinkTagAdapter(holder, node))
-        is ContentCode -> surroundWith(module, holder, "<code>", "</code>", node, result)
-        is ContentBlockCode -> surroundWith(module, holder, "<code><pre>", "</pre></code>", node, result)
-        is ContentEmpty -> {}
-        is ContentEmphasis -> surroundWith(module, holder, "<em>", "</em>", node, result)
-        is ContentHeading -> surroundWith(module, holder, "<h${node.level}>", "</h${node.level}>", node, result)
-        is ContentEntity -> result.add(TextTag(holder, ContentText(node.text))) // TODO ??
-        is ContentIdentifier -> result.add(TextTag(holder, ContentText(node.text))) // TODO
-        is ContentKeyword -> result.add(TextTag(holder, ContentText(node.text))) // TODO
-        is ContentListItem ->  surroundWith(module, holder, "<li>", "</li>", node, result)
-        is ContentOrderedList -> surroundWith(module, holder, "<ol>", "</ol>", node, result)
-        is ContentUnorderedList -> surroundWith(module, holder, "<ul>", "</ul>", node, result)
-        is ContentParagraph -> surroundWith(module, holder, "<p>", "</p>", node, result)
-        is ContentSection -> surroundWith(module, holder, "<p>", "</p>", node, result) // TODO how section should be represented?
-        is ContentNonBreakingSpace -> result.add(TextTag(holder, ContentText("&nbsp;")))
-        is ContentStrikethrough -> surroundWith(module, holder, "<strike>", "</strike>", node, result)
-        is ContentStrong -> surroundWith(module, holder, "<strong>", "</strong>", node, result)
-        is ContentSymbol -> result.add(TextTag(holder, ContentText(node.text))) // TODO?
-        is Content -> {
-            surroundWith(module, holder, "<p>", "</p>", node.summary, result)
-            surroundWith(module, holder, "<p>", "</p>", node.description, result)
-//            node.sections.forEach {
-//                buildInlineTags(module, holder, it, result)
-//            }
-        }
-
-        else -> result.add(TextTag(holder, ContentText("$node")))
-    }
-}
\ No newline at end of file
diff --git a/javadoc/src/main/resources/dokka/format/javadoc.properties b/javadoc/src/main/resources/dokka/format/javadoc.properties
deleted file mode 100644
index a58317fc..00000000
--- a/javadoc/src/main/resources/dokka/format/javadoc.properties
+++ /dev/null
@@ -1 +0,0 @@
-class=org.jetbrains.dokka.javadoc.JavadocFormatDescriptor
\ No newline at end of file
diff --git a/javadoc/src/main/resources/dokka/generator/javadoc.properties b/javadoc/src/main/resources/dokka/generator/javadoc.properties
deleted file mode 100644
index 4075704f..00000000
--- a/javadoc/src/main/resources/dokka/generator/javadoc.properties
+++ /dev/null
@@ -1,2 +0,0 @@
-class=org.jetbrains.dokka.javadoc.JavadocGenerator
-description=Produces output via JDK javadoc tool
\ No newline at end of file
diff --git a/javadoc/src/main/resources/format/javadoc.properties b/javadoc/src/main/resources/format/javadoc.properties
deleted file mode 100644
index a58317fc..00000000
--- a/javadoc/src/main/resources/format/javadoc.properties
+++ /dev/null
@@ -1 +0,0 @@
-class=org.jetbrains.dokka.javadoc.JavadocFormatDescriptor
\ No newline at end of file
diff --git a/javadoc/src/test/data/obj.kt b/javadoc/src/test/data/obj.kt
deleted file mode 100644
index 1d10a422..00000000
--- a/javadoc/src/test/data/obj.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package foo
-
-class O {
-    companion object {
-
-    }
-}
diff --git a/javadoc/src/test/data/types.kt b/javadoc/src/test/data/types.kt
deleted file mode 100644
index 55be6058..00000000
--- a/javadoc/src/test/data/types.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-package foo
-
-fun foo(x: Int, o: Any): String {
-}
diff --git a/javadoc/src/test/kotlin/JavadocTest.kt b/javadoc/src/test/kotlin/JavadocTest.kt
deleted file mode 100644
index 1ac7069b..00000000
--- a/javadoc/src/test/kotlin/JavadocTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.DokkaConsoleLogger
-import org.jetbrains.dokka.tests.verifyModel
-import org.junit.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
-
-class JavadocTest {
-    @Test fun testTypes() {
-        verifyModel("javadoc/src/test/data/types.kt", format = "javadoc", withJdk = true) { model ->
-            val doc = ModuleNodeAdapter(model, StandardReporter(DokkaConsoleLogger), "")
-            val classDoc = doc.classNamed("foo.TypesKt")!!
-            val method = classDoc.methods().find { it.name() == "foo" }!!
-
-            val type = method.returnType()
-            assertFalse(type.asClassDoc().isIncluded)
-            assertEquals("java.lang.String", type.qualifiedTypeName())
-            assertEquals("java.lang.String", type.asClassDoc().qualifiedName())
-
-            val params = method.parameters()
-            assertTrue(params[0].type().isPrimitive)
-            assertFalse(params[1].type().asClassDoc().isIncluded)
-        }
-    }
-
-    @Test fun testObject() {
-        verifyModel("javadoc/src/test/data/obj.kt", format = "javadoc") { model ->
-            val doc = ModuleNodeAdapter(model, StandardReporter(DokkaConsoleLogger), "")
-
-            val classDoc = doc.classNamed("foo.O")
-            assertNotNull(classDoc)
-
-            val companionDoc = doc.classNamed("foo.O.Companion")
-            assertNotNull(companionDoc)
-
-            val pkgDoc = doc.packageNamed("foo")!!
-            assertEquals(2, pkgDoc.allClasses().size)
-        }
-    }
-
-}