Merge branch 'dev'

22 files changed, 360 insertions, 90 deletions

diff --git a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
index be4285c0..5522d4f0 100644
--- a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
+++ b/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka
 
+import com.google.common.collect.ImmutableMap
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.core.CoreModuleManager
 import com.intellij.mock.MockComponentManager
@@ -13,11 +14,11 @@ import com.intellij.openapi.roots.ProjectFileIndex
 import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.io.URLUtil
 import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
@@ -35,16 +36,19 @@ import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JvmBuiltIns
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
+import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
+import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import java.io.File
 
 /**
@@ -114,11 +118,17 @@ class AnalysisEnvironment(val messageCollector: MessageCollector) : Disposable {
         val builtIns = JvmBuiltIns(projectContext.storageManager)
 
 
-        val javaRoots = run {
-            val jvfs = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL)
+        val javaRoots = classpath
+                .mapNotNull {
+                    val rootFile = when {
+                        it.extension == "jar" ->
+                            StandardFileSystems.jar().findFileByPath("${it.absolutePath}${URLUtil.JAR_SEPARATOR}")
+                        else ->
+                            StandardFileSystems.local().findFileByPath(it.absolutePath)
+                    }
 
-            classpath.map { JavaRoot(jvfs.findFileByPath("${it.absolutePath}${URLUtil.JAR_SEPARATOR}")!!, JavaRoot.RootType.BINARY) }
-        }
+                    rootFile?.let { JavaRoot(it, JavaRoot.RootType.BINARY) }
+                }
 
         val resolverForProject = ResolverForProjectImpl(
                 "Dokka",
@@ -141,7 +151,7 @@ class AnalysisEnvironment(val messageCollector: MessageCollector) : Disposable {
                 },
                 CompilerEnvironment,
                 packagePartProviderFactory = { info, content ->
-                    JvmPackagePartProvider(LanguageVersionSettingsImpl.DEFAULT, content.moduleContentScope).apply {
+                    JvmPackagePartProvider(configuration.languageVersionSettings, content.moduleContentScope).apply {
                         addRoots(javaRoots)
                     }
                 },
@@ -153,7 +163,17 @@ class AnalysisEnvironment(val messageCollector: MessageCollector) : Disposable {
         val resolverForModule = resolverForProject.resolverForModule(module)
         val moduleDescriptor = resolverForProject.descriptorForModule(module)
         builtIns.initialize(moduleDescriptor, true)
-        return DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
+        val created = DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
+        val projectComponentManager = environment.project as MockComponentManager
+        projectComponentManager.registerService(KotlinCacheService::class.java, CoreKotlinCacheService(created))
+
+        return created
+    }
+
+    fun loadLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?) {
+        val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
+        val apiVersion = apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
+        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
     }
 
     /**
@@ -236,6 +256,42 @@ class DokkaResolutionFacade(override val project: Project,
     val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
 
     override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        if (element is KtDeclaration) {
+            val descriptor = resolveToDescriptor(element)
+            return object : BindingContext {
+                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun getType(p0: KtExpression): KotlinType? {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
+                    if (key != element) {
+                        throw UnsupportedOperationException()
+                    }
+                    return when {
+                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
+                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
+                        else -> null
+                    }
+                }
+
+                override fun getDiagnostics(): Diagnostics {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
+                    throw UnsupportedOperationException()
+                }
+
+            }
+        }
         throw UnsupportedOperationException()
     }
 
diff --git a/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt
new file mode 100644
index 00000000..31b8ffc7
--- /dev/null
+++ b/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dokka
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
+
+
+class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
+    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade? {
+        return resolutionFacade
+    }
+
+    override fun getSuppressionCache(): KotlinSuppressCache {
+        throw UnsupportedOperationException()
+    }
+
+}
+
diff --git a/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
index 21f7e2da..4f6a7c76 100644
--- a/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
+++ b/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
@@ -32,7 +32,11 @@ import java.io.File
  * classes from projectModel-{api,impl}.
  */
 class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter): Boolean {
+    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
         throw UnsupportedOperationException()
     }
 
@@ -74,7 +78,7 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
             throw UnsupportedOperationException()
         }
 
-        override fun setOption(p0: String, p1: String) {
+        override fun setOption(p0: String, p1: String?) {
             throw UnsupportedOperationException()
         }
 
@@ -224,24 +228,26 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
     }
 
     private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
-        override fun getFiles(p0: OrderRootType?): Array<out VirtualFile> {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
             throw UnsupportedOperationException()
         }
 
-        override fun getPresentableName(): String {
+        override fun getUrls(p0: OrderRootType): Array<String> {
             throw UnsupportedOperationException()
         }
 
-        override fun getUrls(p0: OrderRootType?): Array<out String> {
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
             throw UnsupportedOperationException()
         }
 
-        override fun getOwnerModule(): Module = module
 
-        override fun <R : Any?> accept(p0: RootPolicy<R>?, p1: R?): R {
+        override fun getPresentableName(): String {
             throw UnsupportedOperationException()
         }
 
+        override fun getOwnerModule(): Module = module
+
+
         override fun isValid(): Boolean {
             throw UnsupportedOperationException()
         }
@@ -258,29 +264,29 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
     }
 
     private val sdkOrderEntry = object : JdkOrderEntry {
-        override fun getJdkName(): String? {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
             throw UnsupportedOperationException()
         }
 
-        override fun getJdk(): Sdk = sdk
-
-        override fun getFiles(p0: OrderRootType?): Array<out VirtualFile> {
+        override fun getUrls(p0: OrderRootType): Array<String> {
             throw UnsupportedOperationException()
         }
 
-        override fun getPresentableName(): String {
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
             throw UnsupportedOperationException()
         }
 
-        override fun getUrls(p0: OrderRootType?): Array<out String> {
+        override fun getJdkName(): String? {
             throw UnsupportedOperationException()
         }
 
-        override fun getOwnerModule(): Module {
+        override fun getJdk(): Sdk = sdk
+
+        override fun getPresentableName(): String {
             throw UnsupportedOperationException()
         }
 
-        override fun <R : Any?> accept(p0: RootPolicy<R>?, p1: R?): R {
+        override fun getOwnerModule(): Module {
             throw UnsupportedOperationException()
         }
 
@@ -288,11 +294,11 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
             throw UnsupportedOperationException()
         }
 
-        override fun getRootFiles(p0: OrderRootType?): Array<out VirtualFile>? {
+        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
             throw UnsupportedOperationException()
         }
 
-        override fun getRootUrls(p0: OrderRootType?): Array<out String>? {
+        override fun getRootUrls(p0: OrderRootType): Array<out String> {
             throw UnsupportedOperationException()
         }
 
@@ -307,6 +313,10 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
     }
 
     inner class MyModuleRootManager : ModuleRootManager() {
+        override fun getExternalSource(): ProjectModelExternalSource? {
+            throw UnsupportedOperationException()
+        }
+
         override fun getExcludeRoots(): Array<out VirtualFile> {
             throw UnsupportedOperationException()
         }
@@ -350,7 +360,7 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
                     override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
                 })
 
-        override fun <T : Any?> getModuleExtension(p0: Class<T>?): T {
+        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
             throw UnsupportedOperationException()
         }
 
diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index e9d0f3d5..126a0175 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -17,7 +17,8 @@ fun parsePerPackageOptions(arg: String): List<PackageOptions> {
         val deprecated = args.find { it.endsWith("deprecated") }?.startsWith("+") ?: true
         val reportUndocumented = args.find { it.endsWith("warnUndocumented") }?.startsWith("+") ?: true
         val privateApi = args.find { it.endsWith("privateApi") }?.startsWith("+") ?: false
-        PackageOptionsImpl(prefix, includeNonPublic = privateApi, reportUndocumented = reportUndocumented, skipDeprecated = !deprecated)
+        val suppress = args.find { it.endsWith("suppress") }?.startsWith("+") ?: false
+        PackageOptionsImpl(prefix, includeNonPublic = privateApi, reportUndocumented = reportUndocumented, skipDeprecated = !deprecated, suppress = suppress)
     }
 }
 
@@ -65,6 +66,8 @@ class DokkaBootstrapImpl : DokkaBootstrap {
                         perPackageOptions,
                         externalDocumentationLinks,
                         noStdlibLink,
+                        languageVersion,
+                        apiVersion,
                         cacheRoot,
                         suppressedFiles.map { File(it) }
                 )
diff --git a/core/src/main/kotlin/Formats/FormatDescriptor.kt b/core/src/main/kotlin/Formats/FormatDescriptor.kt
index fc925f40..da0156a7 100644
--- a/core/src/main/kotlin/Formats/FormatDescriptor.kt
+++ b/core/src/main/kotlin/Formats/FormatDescriptor.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka.Formats
 
 import org.jetbrains.dokka.*
+import org.jetbrains.dokka.Model.DescriptorSignatureProvider
 import org.jetbrains.dokka.Samples.SampleProcessingService
 import kotlin.reflect.KClass
 
@@ -12,4 +13,5 @@ interface FormatDescriptor {
     val javaDocumentationBuilderClass: KClass<out JavaDocumentationBuilder>
     val sampleProcessingService: KClass<out SampleProcessingService>
     val packageListServiceClass: KClass<out PackageListService>?
+    val descriptorSignatureProvider: KClass<out DescriptorSignatureProvider>
 }
diff --git a/core/src/main/kotlin/Formats/StandardFormats.kt b/core/src/main/kotlin/Formats/StandardFormats.kt
index fad65ff1..f3d638c6 100644
--- a/core/src/main/kotlin/Formats/StandardFormats.kt
+++ b/core/src/main/kotlin/Formats/StandardFormats.kt
@@ -1,6 +1,9 @@
 package org.jetbrains.dokka.Formats
 
 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.Samples.DefaultSampleProcessingService
 import org.jetbrains.dokka.Samples.KotlinWebsiteSampleProcessingService
 import org.jetbrains.dokka.Samples.SampleProcessingService
@@ -14,6 +17,7 @@ abstract class KotlinFormatDescriptorBase : FormatDescriptor {
     override val outlineServiceClass: KClass<out OutlineFormatService>? = null
     override val sampleProcessingService: KClass<out SampleProcessingService> = DefaultSampleProcessingService::class
     override val packageListServiceClass: KClass<out PackageListService>? = DefaultPackageListService::class
+    override val descriptorSignatureProvider = KotlinDescriptorSignatureProvider::class
 }
 
 class HtmlFormatDescriptor : KotlinFormatDescriptorBase() {
@@ -29,6 +33,7 @@ class HtmlAsJavaFormatDescriptor : FormatDescriptor {
     override val javaDocumentationBuilderClass = JavaPsiDocumentationBuilder::class
     override val sampleProcessingService: KClass<out SampleProcessingService> = DefaultSampleProcessingService::class
     override val packageListServiceClass: KClass<out PackageListService>? = DefaultPackageListService::class
+    override val descriptorSignatureProvider = KotlinAsJavaDescriptorSignatureProvider::class
 }
 
 class KotlinWebsiteFormatDescriptor : KotlinFormatDescriptorBase() {
diff --git a/core/src/main/kotlin/Formats/StructuredFormatService.kt b/core/src/main/kotlin/Formats/StructuredFormatService.kt
index a8b000b7..5167a102 100644
--- a/core/src/main/kotlin/Formats/StructuredFormatService.kt
+++ b/core/src/main/kotlin/Formats/StructuredFormatService.kt
@@ -398,10 +398,29 @@ abstract class StructuredOutputBuilder(val to: StringBuilder,
                     else -> it.platformsToShow.toSet()
                 }
             }
+
+            fun String.isKotlinVersion() = this.startsWith("Kotlin")
+
             // Calculating common platforms for items
-            return platforms.fold(platforms.first()) {
-                result, platforms ->
-                result.intersect(platforms)
+            return platforms.reduce { result, platformsOfItem ->
+                val otherKotlinVersion = result.find { it.isKotlinVersion() }
+                val (kotlinVersions, otherPlatforms) = platformsOfItem.partition { it.isKotlinVersion() }
+
+                // When no Kotlin version specified, it means that version is 1.0
+                if (otherKotlinVersion != null && kotlinVersions.isNotEmpty()) {
+                    val allKotlinVersions = (kotlinVersions + otherKotlinVersion).distinct()
+
+                    val minVersion = allKotlinVersions.min()!!
+                    val resultVersion = when {
+                        allKotlinVersions.size == 1 -> allKotlinVersions.single()
+                        minVersion.endsWith("+") -> minVersion
+                        else -> minVersion + "+"
+                    }
+
+                    result.intersect(otherPlatforms) + resultVersion
+                } else {
+                    result.intersect(platformsOfItem)
+                }
             }
         }
 
diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 17b6b156..09e5cedf 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -94,6 +94,8 @@ class DokkaGenerator(val logger: DokkaLogger,
 
             addSources(sourcePaths)
             addSources(this@DokkaGenerator.samples)
+
+            loadLanguageVersionSettings(options.languageVersion, options.apiVersion)
         }
 
         return environment
diff --git a/core/src/main/kotlin/Generation/configurationImpl.kt b/core/src/main/kotlin/Generation/configurationImpl.kt
index f67582a7..34d4154e 100644
--- a/core/src/main/kotlin/Generation/configurationImpl.kt
+++ b/core/src/main/kotlin/Generation/configurationImpl.kt
@@ -32,26 +32,31 @@ class SourceRootImpl(path: String, override val platforms: List<String> = emptyL
 data class PackageOptionsImpl(override val prefix: String,
                               override val includeNonPublic: Boolean = false,
                               override val reportUndocumented: Boolean = true,
-                              override val skipDeprecated: Boolean = false) : DokkaConfiguration.PackageOptions
+                              override val skipDeprecated: Boolean = false,
+                              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>) : DokkaConfiguration
\ No newline at end of file
+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?
+) : DokkaConfiguration
\ 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 a950e432..cf2b0514 100644
--- a/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt
+++ b/core/src/main/kotlin/Java/JavaPsiDocumentationBuilder.kt
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtModifierListOwner
+import java.io.File
 
 fun getSignature(element: PsiElement?) = when(element) {
     is PsiClass -> element.qualifiedName
@@ -57,7 +58,7 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder {
     }
 
     override fun appendFile(file: PsiJavaFile, module: DocumentationModule, packageContent: Map<String, Content>) {
-        if (file.classes.all { skipElement(it) }) {
+        if (skipFile(file) || file.classes.all { skipElement(it) }) {
             return
         }
         val packageNode = module.findOrCreatePackageNode(file.packageName, emptyMap(), refGraph)
@@ -131,7 +132,12 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder {
         }
     }
 
-    private fun skipElement(element: Any) = skipElementByVisibility(element) || hasSuppressDocTag(element)
+    private fun skipFile(javaFile: PsiJavaFile): Boolean = options.effectivePackageOptions(javaFile.packageName).suppress
+
+    private fun skipElement(element: Any) =
+            skipElementByVisibility(element) ||
+                    hasSuppressDocTag(element) ||
+                    skipElementBySuppressedFiles(element)
 
     private fun skipElementByVisibility(element: Any): Boolean = element is PsiModifierListOwner &&
             !(options.effectivePackageOptions((element.containingFile as? PsiJavaFile)?.packageName ?: "").includeNonPublic) &&
@@ -139,6 +145,9 @@ class JavaPsiDocumentationBuilder : JavaDocumentationBuilder {
                     element.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) ||
                     element.isInternal())
 
+    private fun skipElementBySuppressedFiles(element: Any): Boolean =
+            element is PsiElement && File(element.containingFile.virtualFile.path).absoluteFile in options.suppressedFiles
+
     private fun PsiElement.isInternal(): Boolean {
         val ktElement = (this as? KtLightElement<*, *>)?.kotlinOrigin ?: return false
         return (ktElement as? KtModifierListOwner)?.hasModifier(KtTokens.INTERNAL_KEYWORD) ?: false
diff --git a/core/src/main/kotlin/Kotlin/ContentBuilder.kt b/core/src/main/kotlin/Kotlin/ContentBuilder.kt
index 771bc44b..c60625a4 100644
--- a/core/src/main/kotlin/Kotlin/ContentBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/ContentBuilder.kt
@@ -110,9 +110,12 @@ fun buildContentTo(tree: MarkdownNode, target: ContentBlock, linkResolver: LinkR
             }
 
             MarkdownTokenTypes.CODE_LINE -> {
-                val block = ContentBlockCode()
-                block.append(ContentText(node.text))
-                parent.append(block)
+                val content = ContentText(node.text)
+                if (parent is ContentBlockCode) {
+                    parent.append(content)
+                } else {
+                    parent.append(ContentBlockCode().apply { append(content) })
+                }
             }
 
             MarkdownTokenTypes.TEXT -> {
diff --git a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
index 2b085769..ffef399d 100644
--- a/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
+++ b/core/src/main/kotlin/Kotlin/DeclarationLinkResolver.kt
@@ -1,16 +1,21 @@
 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,
                             val refGraph: NodeReferenceGraph,
                             val logger: DokkaLogger,
                             val options: DocumentationOptions,
-                            val externalDocumentationLinkResolver: ExternalDocumentationLinkResolver) {
+                            val externalDocumentationLinkResolver: ExternalDocumentationLinkResolver,
+                            val descriptorSignatureProvider: DescriptorSignatureProvider) {
 
 
     fun tryResolveContentLink(fromDescriptor: DeclarationDescriptor, href: String): ContentBlock? {
@@ -29,7 +34,17 @@ class DeclarationLinkResolver
             if (externalHref != null) {
                 return ContentExternalLink(externalHref)
             }
-            return ContentNodeLazyLink(href, { -> refGraph.lookupOrWarn(symbol.signature(), logger) })
+            val signature = descriptorSignatureProvider.signature(symbol)
+            val referencedAt = fromDescriptor.signatureWithSourceLocation()
+
+            return ContentNodeLazyLink(href, { ->
+                val target = refGraph.lookup(signature)
+
+                if (target == null) {
+                    logger.warn("Can't find node by signature $signature, referenced at $referencedAt")
+                }
+                target
+            })
         }
         if ("/" in href) {
             return ContentExternalLink(href)
@@ -51,6 +66,9 @@ class DeclarationLinkResolver
         if (symbol is CallableMemberDescriptor && symbol.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
             return symbol.overriddenDescriptors.firstOrNull()
         }
+        if (symbol is TypeAliasDescriptor && !symbol.isDocumented(options)) {
+            return symbol.classDescriptor
+        }
         return symbol
     }
 
diff --git a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
index eb8c12d0..f2d9d3a7 100644
--- a/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
+++ b/core/src/main/kotlin/Kotlin/DescriptorDocumentationParser.kt
@@ -81,7 +81,7 @@ class DescriptorDocumentationParser
         val suppressAnnotation = annotations.findAnnotation(FqName(Suppress::class.qualifiedName!!))
         return if (suppressAnnotation != null) {
             @Suppress("UNCHECKED_CAST")
-            (suppressAnnotation.argumentValue("names") as List<StringValue>).any { it.value == "NOT_DOCUMENTED" }
+            (suppressAnnotation.argumentValue("names")?.value as List<StringValue>).any { it.value == "NOT_DOCUMENTED" }
         } else containingDeclaration?.isSuppressWarning() ?: false
     }
 
diff --git a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
index fddf0814..916f89c9 100644
--- a/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
+++ b/core/src/main/kotlin/Kotlin/DocumentationBuilder.kt
@@ -15,14 +15,14 @@ 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
 import org.jetbrains.kotlin.psi.KtModifierListOwner
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.isDocumentedAnnotation
+import org.jetbrains.kotlin.resolve.descriptorUtil.*
 import org.jetbrains.kotlin.resolve.findTopMostOverriddenDescriptors
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
@@ -50,6 +50,8 @@ class DocumentationOptions(val outputDir: String,
                            perPackageOptions: List<PackageOptions> = emptyList(),
                            externalDocumentationLinks: List<ExternalDocumentationLink> = emptyList(),
                            noStdlibLink: Boolean,
+                           val languageVersion: String?,
+                           val apiVersion: String?,
                            cacheRoot: String? = null,
                            val suppressedFiles: List<File> = emptyList()) {
     init {
@@ -576,6 +578,11 @@ class DocumentationBuilder
             descriptorsToDocument.mapTo(result) {
                 ClassMember(it, inheritedLinkKind = RefKind.InheritedCompanionObjectMember)
             }
+
+            if (companionObjectDescriptor.getAllSuperclassesWithoutAny().isNotEmpty()
+                    || companionObjectDescriptor.getSuperInterfaces().isNotEmpty()) {
+                result += ClassMember(companionObjectDescriptor)
+            }
         }
         return result
     }
@@ -726,6 +733,7 @@ class DocumentationBuilder
             }
             node.appendType(constraint, NodeKind.UpperBound)
         }
+        register(this, node)
         return node
     }
 
@@ -746,6 +754,7 @@ class DocumentationBuilder
 
         val node = DocumentationNode(name.asString(), Content.Empty, NodeKind.Receiver)
         node.appendType(type)
+        register(this, node)
         return node
     }
 
@@ -772,6 +781,14 @@ class DocumentationBuilder
                 "\"" + StringUtil.escapeStringCharacters(value) + "\""
             is EnumEntrySyntheticClassDescriptor ->
                 value.containingDeclaration.name.asString() + "." + value.name.asString()
+            is Pair<*, *> -> {
+                val (classId, name) = value
+                if (classId is ClassId && name is Name) {
+                    classId.shortClassName.asString() + "." + name.asString()
+                } else {
+                    value.toString()
+                }
+            }
             else -> value.toString()
         }.let { valueString ->
             DocumentationNode(valueString, Content.Empty, NodeKind.Value)
@@ -784,9 +801,9 @@ val visibleToDocumentation = setOf(Visibilities.PROTECTED, Visibilities.PUBLIC)
 fun DeclarationDescriptor.isDocumented(options: DocumentationOptions): Boolean {
     return (options.effectivePackageOptions(fqNameSafe).includeNonPublic
             || this !is MemberDescriptor
-            || this.visibility in visibleToDocumentation) &&
-            !isDocumentationSuppressed(options) &&
-            (!options.effectivePackageOptions(fqNameSafe).skipDeprecated || !isDeprecated())
+            || this.visibility in visibleToDocumentation)
+            && !isDocumentationSuppressed(options)
+            && (!options.effectivePackageOptions(fqNameSafe).skipDeprecated || !isDeprecated())
 }
 
 private fun DeclarationDescriptor.isGenerated() = this is CallableMemberDescriptor && kind != CallableMemberDescriptor.Kind.DECLARATION
@@ -856,6 +873,8 @@ fun AnnotationDescriptor.mustBeDocumented(): Boolean {
 
 fun DeclarationDescriptor.isDocumentationSuppressed(options: DocumentationOptions): Boolean {
 
+    if (options.effectivePackageOptions(fqNameSafe).suppress) return true
+
     val path = this.findPsi()?.containingFile?.virtualFile?.path
     if (path != null) {
         if (File(path).absoluteFile in options.suppressedFiles) return true
@@ -905,17 +924,21 @@ fun CallableMemberDescriptor.getExtensionClassDescriptor(): ClassifierDescriptor
     return null
 }
 
-fun DeclarationDescriptor.signature(): String = when (this) {
-    is ClassDescriptor,
-    is PackageFragmentDescriptor,
-    is PackageViewDescriptor,
-    is TypeAliasDescriptor -> DescriptorUtils.getFqName(this).asString()
-
-    is PropertyDescriptor -> containingDeclaration.signature() + "$" + name + receiverSignature()
-    is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature()
-    is ValueParameterDescriptor -> containingDeclaration.signature() + "/" + name
-    is TypeParameterDescriptor -> containingDeclaration.signature() + "*" + name
-    else -> throw UnsupportedOperationException("Don't know how to calculate signature for $this")
+fun DeclarationDescriptor.signature(): String {
+    if (this != original) return original.signature()
+    return when (this) {
+        is ClassDescriptor,
+        is PackageFragmentDescriptor,
+        is PackageViewDescriptor,
+        is TypeAliasDescriptor -> DescriptorUtils.getFqName(this).asString()
+
+        is PropertyDescriptor -> containingDeclaration.signature() + "$" + name + receiverSignature()
+        is FunctionDescriptor -> containingDeclaration.signature() + "$" + name + parameterSignature()
+        is ValueParameterDescriptor -> containingDeclaration.signature() + "/" + name
+        is TypeParameterDescriptor -> containingDeclaration.signature() + "*" + name
+        is ReceiverParameterDescriptor -> containingDeclaration.signature() + "/" + name
+        else -> throw UnsupportedOperationException("Don't know how to calculate signature for $this")
+    }
 }
 
 fun PropertyDescriptor.receiverSignature(): String {
@@ -932,7 +955,7 @@ fun CallableMemberDescriptor.parameterSignature(): String {
     if (extensionReceiver != null) {
         params.add(0, extensionReceiver.type)
     }
-    return "(" + params.map { it.signature() }.joinToString() + ")"
+    return params.joinToString(prefix = "(", postfix = ")") { it.signature() }
 }
 
 fun KotlinType.signature(): String {
diff --git a/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt b/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
index 84d83c73..108cee78 100644
--- a/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
+++ b/core/src/main/kotlin/Kotlin/ExternalDocumentationLinkResolver.kt
@@ -15,7 +15,9 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.parents
 import java.io.ByteArrayOutputStream
 import java.io.PrintWriter
+import java.net.HttpURLConnection
 import java.net.URL
+import java.net.URLConnection
 import java.nio.file.Path
 import java.security.MessageDigest
 
@@ -30,12 +32,44 @@ class ExternalDocumentationLinkResolver @Inject constructor(
     val packageFqNameToLocation = mutableMapOf<FqName, ExternalDocumentationRoot>()
     val formats = mutableMapOf<String, InboundExternalLinkResolutionService>()
 
-    class ExternalDocumentationRoot(val rootUrl: URL, val resolver: InboundExternalLinkResolutionService, val locations: Map<String, String>)
+    class ExternalDocumentationRoot(val rootUrl: URL, val resolver: InboundExternalLinkResolutionService, val locations: Map<String, String>) {
+        override fun toString(): String = rootUrl.toString()
+    }
 
     val cacheDir: Path? = options.cacheRoot?.resolve("packageListCache")?.apply { createDirectories() }
 
     val cachedProtocols = setOf("http", "https", "ftp")
 
+    fun URL.doOpenConnectionToReadContent(timeout: Int = 10000, redirectsAllowed: Int = 16): URLConnection {
+        val connection = this.openConnection()
+        connection.connectTimeout = timeout
+        connection.readTimeout = timeout
+
+        when (connection) {
+            is HttpURLConnection -> {
+                return when (connection.responseCode) {
+                    in 200..299 -> {
+                        connection
+                    }
+                    HttpURLConnection.HTTP_MOVED_PERM,
+                    HttpURLConnection.HTTP_MOVED_TEMP,
+                    HttpURLConnection.HTTP_SEE_OTHER -> {
+                        if (redirectsAllowed > 0) {
+                            val newUrl = connection.getHeaderField("Location")
+                            URL(newUrl).doOpenConnectionToReadContent(timeout, redirectsAllowed - 1)
+                        } else {
+                            throw RuntimeException("Too many redirects")
+                        }
+                    }
+                    else -> {
+                        throw RuntimeException("Unhandled http code: ${connection.responseCode}")
+                    }
+                }
+            }
+            else -> return connection
+        }
+    }
+
     fun loadPackageList(link: DokkaConfiguration.ExternalDocumentationLink) {
 
         val packageListUrl = link.packageListUrl
@@ -50,7 +84,7 @@ class ExternalDocumentationLinkResolver @Inject constructor(
 
             if (cacheEntry.exists()) {
                 try {
-                    val connection = packageListUrl.openConnection()
+                    val connection = packageListUrl.doOpenConnectionToReadContent()
                     val originModifiedDate = connection.date
                     val cacheDate = cacheEntry.lastModified().toMillis()
                     if (originModifiedDate > cacheDate || originModifiedDate == 0L) {
@@ -60,7 +94,7 @@ class ExternalDocumentationLinkResolver @Inject constructor(
                             logger.info("Renewing package-list from $packageListUrl")
                         connection.getInputStream().copyTo(cacheEntry.outputStream())
                     }
-                } catch(e: Exception) {
+                } catch (e: Exception) {
                     logger.error("Failed to update package-list cache for $link")
                     val baos = ByteArrayOutputStream()
                     PrintWriter(baos).use {
@@ -75,7 +109,7 @@ class ExternalDocumentationLinkResolver @Inject constructor(
             }
             cacheEntry.inputStream()
         } else {
-            packageListUrl.openStream()
+            packageListUrl.doOpenConnectionToReadContent().getInputStream()
         }
 
         val (params, packages) =
diff --git a/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt
new file mode 100644
index 00000000..a3be658e
--- /dev/null
+++ b/core/src/main/kotlin/Kotlin/KotlinAsJavaDescriptorSignatureProvider.kt
@@ -0,0 +1,22 @@
+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/KotlinDescriptorSignatureProvider.kt b/core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt
new file mode 100644
index 00000000..7ecd0389
--- /dev/null
+++ b/core/src/main/kotlin/Kotlin/KotlinDescriptorSignatureProvider.kt
@@ -0,0 +1,9 @@
+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/Model/DescriptorSignatureProvider.kt b/core/src/main/kotlin/Model/DescriptorSignatureProvider.kt
new file mode 100644
index 00000000..85584e3c
--- /dev/null
+++ b/core/src/main/kotlin/Model/DescriptorSignatureProvider.kt
@@ -0,0 +1,7 @@
+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/PackageDocs.kt b/core/src/main/kotlin/Model/PackageDocs.kt
index 3b03324c..1f6bdcb9 100644
--- a/core/src/main/kotlin/Model/PackageDocs.kt
+++ b/core/src/main/kotlin/Model/PackageDocs.kt
@@ -32,7 +32,7 @@ class PackageDocs
                         targetContent = findTargetContent(headingText.trimStart())
                     }
                 } else {
-                    buildContentTo(it, targetContent, LinkResolver(linkMap, { resolveContentLink(it, linkResolveContext) }))
+                    buildContentTo(it, targetContent, LinkResolver(linkMap, { resolveContentLink(fileName, it, linkResolveContext) }))
                 }
             }
         } else {
@@ -53,7 +53,7 @@ class PackageDocs
     private fun findOrCreatePackageContent(packageName: String) =
         _packageContent.getOrPut(packageName) { -> MutableContent() }
 
-    private fun resolveContentLink(href: String, linkResolveContext: List<PackageFragmentDescriptor>): ContentBlock {
+    private fun resolveContentLink(fileName: String, href: String, linkResolveContext: List<PackageFragmentDescriptor>): ContentBlock {
         if (linkResolver != null) {
             linkResolveContext
                     .asSequence()
@@ -62,6 +62,7 @@ class PackageDocs
                     .firstOrNull()
                     ?.let { return it }
         }
+        logger.warn("Unresolved link to `$href` in include ($fileName)")
         return ContentExternalLink("#")
     }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt b/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt
index 4dd0bc7f..b0988c35 100644
--- a/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt
+++ b/core/src/main/kotlin/Samples/KotlinWebsiteSampleProcessingService.kt
@@ -2,11 +2,13 @@ package org.jetbrains.dokka.Samples
 
 import com.google.inject.Inject
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.dokka.*
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
+import org.jetbrains.kotlin.psi.psiUtil.prevLeaf
 import org.jetbrains.kotlin.resolve.ImportPath
 
 open class KotlinWebsiteSampleProcessingService
@@ -35,14 +37,19 @@ open class KotlinWebsiteSampleProcessingService
             }
         }
 
-        fun convertAssertTrue(expression: KtCallExpression) {
+        fun convertAssertTrueFalse(expression: KtCallExpression, expectedResult: Boolean) {
             val (argument) = expression.valueArguments
             builder.apply {
+                expression.valueArguments.getOrNull(1)?.let {
+                    append("// ${it.extractStringArgumentValue()}")
+                    val ws = expression.prevLeaf { it is PsiWhiteSpace }
+                    append(ws?.text ?: "\n")
+                }
                 append("println(\"")
                 append(argument.text)
                 append(" is \${")
                 append(argument.text)
-                append("}\") // true")
+                append("}\") // $expectedResult")
             }
         }
 
@@ -77,7 +84,8 @@ open class KotlinWebsiteSampleProcessingService
         override fun visitCallExpression(expression: KtCallExpression) {
             when (expression.calleeExpression?.text) {
                 "assertPrints" -> convertAssertPrints(expression)
-                "assertTrue" -> convertAssertTrue(expression)
+                "assertTrue" -> convertAssertTrueFalse(expression, expectedResult = true)
+                "assertFalse" -> convertAssertTrueFalse(expression, expectedResult = false)
                 "assertFails" -> convertAssertFails(expression)
                 "assertFailsWith" -> convertAssertFailsWith(expression)
                 else -> super.visitCallExpression(expression)
diff --git a/core/src/main/kotlin/Utilities/DokkaModules.kt b/core/src/main/kotlin/Utilities/DokkaModules.kt
index 28c5dc45..dfb114ec 100644
--- a/core/src/main/kotlin/Utilities/DokkaModules.kt
+++ b/core/src/main/kotlin/Utilities/DokkaModules.kt
@@ -7,6 +7,7 @@ import com.google.inject.TypeLiteral
 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
@@ -22,7 +23,7 @@ class DokkaAnalysisModule(val environment: AnalysisEnvironment,
         binder.bind<DokkaLogger>().toInstance(logger)
 
         val descriptor = ServiceLocator.lookup<FormatDescriptor>("format", options.outputFormat)
-
+        binder.bind<DescriptorSignatureProvider>().to(descriptor.descriptorSignatureProvider.java)
         binder.registerCategory<LanguageService>("language")
         binder.bind<PackageDocumentationBuilder>().to(descriptor.packageDocumentationBuilderClass.java)
         binder.bind<JavaDocumentationBuilder>().to(descriptor.javaDocumentationBuilderClass.java)
diff --git a/core/src/main/kotlin/javadoc/dokka-adapters.kt b/core/src/main/kotlin/javadoc/dokka-adapters.kt
index 9555aeb9..c98a3801 100644
--- a/core/src/main/kotlin/javadoc/dokka-adapters.kt
+++ b/core/src/main/kotlin/javadoc/dokka-adapters.kt
@@ -4,6 +4,8 @@ import com.google.inject.Inject
 import com.sun.tools.doclets.formats.html.HtmlDoclet
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.Formats.FormatDescriptor
+import org.jetbrains.dokka.Kotlin.KotlinAsJavaDescriptorSignatureProvider
+import org.jetbrains.dokka.Model.DescriptorSignatureProvider
 import org.jetbrains.dokka.Samples.DefaultSampleProcessingService
 import kotlin.reflect.KClass
 
@@ -36,4 +38,5 @@ class JavadocFormatDescriptor : FormatDescriptor {
     override val javaDocumentationBuilderClass = JavaPsiDocumentationBuilder::class
     override val sampleProcessingService = DefaultSampleProcessingService::class
     override val packageListServiceClass: KClass<out PackageListService>? = null
+    override val descriptorSignatureProvider = KotlinAsJavaDescriptorSignatureProvider::class
 }