1 files changed, 41 insertions, 21 deletions

diff --git a/src/Kotlin/ContentBuilder.kt b/src/Kotlin/ContentBuilder.kt
index 9ce81cee..c981eb42 100644
--- a/src/Kotlin/ContentBuilder.kt
+++ b/src/Kotlin/ContentBuilder.kt
@@ -1,14 +1,19 @@
 package org.jetbrains.dokka
 
-import java.util.ArrayDeque
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.scopes.*
-import org.jetbrains.kotlin.name.*
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.html.entities.EntityConverter
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.kdoc.getResolutionScope
-import org.intellij.markdown.*
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.psi.JetBlockExpression
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.scopes.KtScope
+import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope
+import java.util.*
 
 public fun buildContent(tree: MarkdownNode, linkResolver: (String) -> ContentBlock): MutableContent {
     val result = MutableContent()
@@ -43,7 +48,8 @@ public fun buildContentTo(tree: MarkdownNode, target: ContentBlock, linkResolver
             MarkdownElementTypes.EMPH -> appendNodeWithChildren(ContentEmphasis())
             MarkdownElementTypes.STRONG -> appendNodeWithChildren(ContentStrong())
             MarkdownElementTypes.CODE_SPAN -> appendNodeWithChildren(ContentCode())
-            MarkdownElementTypes.CODE_BLOCK -> appendNodeWithChildren(ContentBlockCode())
+            MarkdownElementTypes.CODE_BLOCK,
+            MarkdownElementTypes.CODE_FENCE -> appendNodeWithChildren(ContentBlockCode())
             MarkdownElementTypes.PARAGRAPH -> appendNodeWithChildren(ContentParagraph())
 
             MarkdownElementTypes.INLINE_LINK -> {
@@ -84,11 +90,24 @@ public fun buildContentTo(tree: MarkdownNode, target: ContentBlock, linkResolver
                 parent.append(block)
             }
 
-            MarkdownTokenTypes.HTML_ENTITY -> {
-                parent.append(ContentEntity(node.text))
+            MarkdownTokenTypes.TEXT -> {
+                fun createEntityOrText(text: String): ContentNode {
+                    if (text == "&" || text == """ || text == "<" || text == ">") {
+                        return ContentEntity(text)
+                    }
+                    if (text == "&") {
+                        return ContentEntity("&")
+                    }
+                    val decodedText = EntityConverter.replaceEntities(text, true, true)
+                    if (decodedText != text) {
+                        return ContentEntity(text)
+                    }
+                    return ContentText(text)
+                }
+
+                parent.append(createEntityOrText(node.text))
             }
 
-            MarkdownTokenTypes.TEXT,
             MarkdownTokenTypes.COLON,
             MarkdownTokenTypes.DOUBLE_QUOTE,
             MarkdownTokenTypes.LT,
@@ -96,7 +115,8 @@ public fun buildContentTo(tree: MarkdownNode, target: ContentBlock, linkResolver
             MarkdownTokenTypes.LPAREN,
             MarkdownTokenTypes.RPAREN,
             MarkdownTokenTypes.LBRACKET,
-            MarkdownTokenTypes.RBRACKET -> {
+            MarkdownTokenTypes.RBRACKET,
+            MarkdownTokenTypes.CODE_FENCE_CONTENT -> {
                 parent.append(ContentText(node.text))
             }
             else -> {
@@ -120,8 +140,8 @@ fun DocumentationBuilder.functionBody(descriptor: DeclarationDescriptor, functio
         logger.warn("Missing function name in @sample in ${descriptor.signature()}")
         return ContentBlockCode().let() { it.append(ContentText("Missing function name in @sample")); it }
     }
-    val scope = getResolutionScope(resolutionFacade, descriptor)
-    val rootPackage = session.getModuleDescriptor().getPackage(FqName.ROOT)
+    val scope = getResolutionScope(resolutionFacade, descriptor).asJetScope()
+    val rootPackage = resolutionFacade.moduleDescriptor.getPackage(FqName.ROOT)
     val rootScope = rootPackage.memberScope
     val symbol = resolveInScope(functionName, scope) ?: resolveInScope(functionName, rootScope)
     if (symbol == null) {
@@ -135,23 +155,23 @@ fun DocumentationBuilder.functionBody(descriptor: DeclarationDescriptor, functio
     }
 
     val text = when (psiElement) {
-        is JetDeclarationWithBody -> ContentBlockCode().let() {
+        is KtDeclarationWithBody -> ContentBlockCode().let() {
             val bodyExpression = psiElement.bodyExpression
             when (bodyExpression) {
-                is JetBlockExpression -> bodyExpression.text.removeSurrounding("{", "}")
+                is KtBlockExpression -> bodyExpression.text.removeSurrounding("{", "}")
                 else -> bodyExpression!!.text
             }
         }
         else -> psiElement.text
     }
 
-    val lines = text.trimEnd().split("\n".toRegex()).toTypedArray().filterNot { it.length() == 0 }
+    val lines = text.trimEnd().split("\n".toRegex()).toTypedArray().filterNot { it.length == 0 }
     val indent = lines.map { it.takeWhile { it.isWhitespace() }.count() }.min() ?: 0
-    val finalText = lines.map { it.drop(indent) }.join("\n")
+    val finalText = lines.map { it.drop(indent) }.joinToString("\n")
     return ContentBlockCode("kotlin").let() { it.append(ContentText(finalText)); it }
 }
 
-private fun DocumentationBuilder.resolveInScope(functionName: String, scope: JetScope): DeclarationDescriptor? {
+private fun DocumentationBuilder.resolveInScope(functionName: String, scope: KtScope): DeclarationDescriptor? {
     var currentScope = scope
     val parts = functionName.split('.')
 
@@ -169,7 +189,7 @@ private fun DocumentationBuilder.resolveInScope(functionName: String, scope: Jet
         currentScope = if (partSymbol is ClassDescriptor)
             partSymbol.defaultType.memberScope
         else
-            getResolutionScope(resolutionFacade, partSymbol)
+            getResolutionScope(resolutionFacade, partSymbol).asJetScope()
         symbol = partSymbol
     }