From 778e2b3f7ff62971e18a49d81a8825e5dd894c2e Mon Sep 17 00:00:00 2001
From: Ilya Ryzhenkov <orangy@jetbrains.com>
Date: Mon, 29 Sep 2014 20:54:59 +0400
Subject: Extract content model, make doc model independent from descriptors,
 parse doccomments with custom parser, some tests failing due to hanging new
 lines.

---
 .idea/runConfigurations/All_tests.xml              |   6 +
 .../jetbrains/markdown/MarkdownElementTypes.java   |  10 +-
 gen/org/jetbrains/markdown/MarkdownParser.java     | 386 +++++++++++++--------
 .../jetbrains/markdown/lexer/_MarkdownLexer.flex   |  42 +++
 .../jetbrains/markdown/lexer/_MarkdownLexer.java   |  14 +-
 src/Analysis/CommentsAPI.kt                        |   2 +-
 src/Formats/MarkdownFormatService.kt               |   4 -
 src/Formats/StructuredFormatService.kt             |  24 +-
 src/Formats/TextFormatService.kt                   |   3 -
 src/Kotlin/ContentBuilder.kt                       |  79 +++++
 src/Kotlin/Diagnostics.kt                          |  40 +++
 src/Kotlin/DocumentationBuildingVisitor.kt         | 122 +++++++
 src/Kotlin/DocumentationContext.kt                 |  47 +++
 src/Kotlin/DocumentationNodeBuilder.kt             | 177 ++++++++++
 src/Markdown/MarkdownProcessor.kt                  |  62 ++--
 src/Markdown/_MarkdownLexer.flex                   |  40 ---
 src/Markdown/markdown.bnf                          |  42 +--
 src/Model/Content.kt                               |  88 +++++
 src/Model/Diagnostics.kt                           |  40 ---
 src/Model/DocumentationBuildingVisitor.kt          | 121 -------
 src/Model/DocumentationContent.kt                  | 150 --------
 src/Model/DocumentationModule.kt                   |  23 +-
 src/Model/DocumentationNode.kt                     |   7 +-
 src/Model/DocumentationNodeBuilder.kt              | 153 --------
 test/data/comments/explicitSummary.kt              |   6 +
 test/data/comments/multilineDoc.kt                 |   1 +
 test/src/TestAPI.kt                                |  27 ++
 test/src/markdown/ParserTest.kt                    |  38 +-
 test/src/markdown/Specification.kt                 |   2 +-
 test/src/model/ClassTest.kt                        |  24 +-
 test/src/model/CommentTest.kt                      |  62 ++--
 test/src/model/FunctionTest.kt                     |  25 +-
 test/src/model/PackageTest.kt                      |  12 +-
 test/src/model/PropertyTest.kt                     |  16 +-
 34 files changed, 1065 insertions(+), 830 deletions(-)
 create mode 100644 gen/org/jetbrains/markdown/lexer/_MarkdownLexer.flex
 create mode 100644 src/Kotlin/ContentBuilder.kt
 create mode 100644 src/Kotlin/Diagnostics.kt
 create mode 100644 src/Kotlin/DocumentationBuildingVisitor.kt
 create mode 100644 src/Kotlin/DocumentationContext.kt
 create mode 100644 src/Kotlin/DocumentationNodeBuilder.kt
 delete mode 100644 src/Markdown/_MarkdownLexer.flex
 create mode 100644 src/Model/Content.kt
 delete mode 100644 src/Model/Diagnostics.kt
 delete mode 100644 src/Model/DocumentationBuildingVisitor.kt
 delete mode 100644 src/Model/DocumentationContent.kt
 delete mode 100644 src/Model/DocumentationNodeBuilder.kt
 create mode 100644 test/data/comments/explicitSummary.kt

diff --git a/.idea/runConfigurations/All_tests.xml b/.idea/runConfigurations/All_tests.xml
index 4e7c9c09..deb51b1a 100644
--- a/.idea/runConfigurations/All_tests.xml
+++ b/.idea/runConfigurations/All_tests.xml
@@ -23,8 +23,14 @@
       <option name="TRANSPORT" value="0" />
       <option name="LOCAL" value="true" />
     </RunnerSettings>
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="" />
+      <option name="TRANSPORT" value="0" />
+      <option name="LOCAL" value="true" />
+    </RunnerSettings>
     <RunnerSettings RunnerId="Run" />
     <ConfigurationWrapper RunnerId="Debug" />
+    <ConfigurationWrapper RunnerId="Debug" />
     <ConfigurationWrapper RunnerId="Run" />
     <method />
   </configuration>
diff --git a/gen/org/jetbrains/markdown/MarkdownElementTypes.java b/gen/org/jetbrains/markdown/MarkdownElementTypes.java
index 757cc62f..8c2d77ba 100644
--- a/gen/org/jetbrains/markdown/MarkdownElementTypes.java
+++ b/gen/org/jetbrains/markdown/MarkdownElementTypes.java
@@ -6,7 +6,9 @@ import org.jetbrains.dokka.Markdown.MarkdownTokenType;
 
 public interface MarkdownElementTypes {
 
+  IElementType ANONYMOUS_SECTION = new IElementType("ANONYMOUS_SECTION", null);
   IElementType BLANK_LINE = new IElementType("BLANK_LINE", null);
+  IElementType BLOCK = new IElementType("BLOCK", null);
   IElementType BULLET = new IElementType("BULLET", null);
   IElementType BULLET_LIST = new IElementType("BULLET_LIST", null);
   IElementType EMPH = new IElementType("EMPH", null);
@@ -14,22 +16,22 @@ public interface MarkdownElementTypes {
   IElementType ENUMERATOR = new IElementType("ENUMERATOR", null);
   IElementType HORIZONTAL_RULE = new IElementType("HORIZONTAL_RULE", null);
   IElementType HREF = new IElementType("HREF", null);
-  IElementType INDENTED_LINE = new IElementType("INDENTED_LINE", null);
+  IElementType INLINE = new IElementType("INLINE", null);
   IElementType LINK = new IElementType("LINK", null);
   IElementType LIST_BLOCK = new IElementType("LIST_BLOCK", null);
   IElementType LIST_BLOCK_LINE = new IElementType("LIST_BLOCK_LINE", null);
   IElementType LIST_CONTINUATION_BLOCK = new IElementType("LIST_CONTINUATION_BLOCK", null);
   IElementType LIST_ITEM = new IElementType("LIST_ITEM", null);
-  IElementType NONBLANK_INDENTED_LINE = new IElementType("NONBLANK_INDENTED_LINE", null);
+  IElementType NAMED_SECTION = new IElementType("NAMED_SECTION", null);
   IElementType ORDERED_LIST = new IElementType("ORDERED_LIST", null);
   IElementType PARA = new IElementType("PARA", null);
   IElementType PLAIN_TEXT = new IElementType("PLAIN_TEXT", null);
+  IElementType SECTION_BODY = new IElementType("SECTION_BODY", null);
+  IElementType SECTION_NAME = new IElementType("SECTION_NAME", null);
   IElementType STRONG = new IElementType("STRONG", null);
   IElementType STRONG_STAR = new IElementType("STRONG_STAR", null);
   IElementType STRONG_UNDERSCORE = new IElementType("STRONG_UNDERSCORE", null);
   IElementType TARGET = new IElementType("TARGET", null);
-  IElementType VERBATIM = new IElementType("VERBATIM", null);
-  IElementType VERBATIM_ITEM = new IElementType("VERBATIM_ITEM", null);
   IElementType WHITESPACE = new IElementType("WHITESPACE", null);
 
   IElementType ANYCHAR = new MarkdownTokenType("AnyChar");
diff --git a/gen/org/jetbrains/markdown/MarkdownParser.java b/gen/org/jetbrains/markdown/MarkdownParser.java
index 90c69985..09c4a0f9 100644
--- a/gen/org/jetbrains/markdown/MarkdownParser.java
+++ b/gen/org/jetbrains/markdown/MarkdownParser.java
@@ -22,9 +22,15 @@ public class MarkdownParser implements PsiParser {
     boolean result_;
     builder_ = adapt_builder_(root_, builder_, this, null);
     Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
-    if (root_ == BLANK_LINE) {
+    if (root_ == ANONYMOUS_SECTION) {
+      result_ = AnonymousSection(builder_, 0);
+    }
+    else if (root_ == BLANK_LINE) {
       result_ = BlankLine(builder_, 0);
     }
+    else if (root_ == BLOCK) {
+      result_ = Block(builder_, 0);
+    }
     else if (root_ == BULLET) {
       result_ = Bullet(builder_, 0);
     }
@@ -46,8 +52,8 @@ public class MarkdownParser implements PsiParser {
     else if (root_ == HREF) {
       result_ = Href(builder_, 0);
     }
-    else if (root_ == INDENTED_LINE) {
-      result_ = IndentedLine(builder_, 0);
+    else if (root_ == INLINE) {
+      result_ = Inline(builder_, 0);
     }
     else if (root_ == LINK) {
       result_ = Link(builder_, 0);
@@ -64,8 +70,8 @@ public class MarkdownParser implements PsiParser {
     else if (root_ == LIST_ITEM) {
       result_ = ListItem(builder_, 0);
     }
-    else if (root_ == NONBLANK_INDENTED_LINE) {
-      result_ = NonblankIndentedLine(builder_, 0);
+    else if (root_ == NAMED_SECTION) {
+      result_ = NamedSection(builder_, 0);
     }
     else if (root_ == ORDERED_LIST) {
       result_ = OrderedList(builder_, 0);
@@ -76,6 +82,12 @@ public class MarkdownParser implements PsiParser {
     else if (root_ == PLAIN_TEXT) {
       result_ = PlainText(builder_, 0);
     }
+    else if (root_ == SECTION_BODY) {
+      result_ = SectionBody(builder_, 0);
+    }
+    else if (root_ == SECTION_NAME) {
+      result_ = SectionName(builder_, 0);
+    }
     else if (root_ == STRONG) {
       result_ = Strong(builder_, 0);
     }
@@ -88,12 +100,6 @@ public class MarkdownParser implements PsiParser {
     else if (root_ == TARGET) {
       result_ = Target(builder_, 0);
     }
-    else if (root_ == VERBATIM) {
-      result_ = Verbatim(builder_, 0);
-    }
-    else if (root_ == VERBATIM_ITEM) {
-      result_ = VerbatimItem(builder_, 0);
-    }
     else if (root_ == WHITESPACE) {
       result_ = Whitespace(builder_, 0);
     }
@@ -107,6 +113,17 @@ public class MarkdownParser implements PsiParser {
     return Document(builder_, level_ + 1);
   }
 
+  /* ********************************************************** */
+  // SectionBody
+  public static boolean AnonymousSection(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "AnonymousSection")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<anonymous section>");
+    result_ = SectionBody(builder_, level_ + 1);
+    exit_section_(builder_, level_, marker_, ANONYMOUS_SECTION, result_, false, null);
+    return result_;
+  }
+
   /* ********************************************************** */
   // OptionalSpace Newline
   public static boolean BlankLine(PsiBuilder builder_, int level_) {
@@ -122,19 +139,18 @@ public class MarkdownParser implements PsiParser {
 
   /* ********************************************************** */
   // BlankLine* (
-  //           Para
-  //         | Verbatim
-  //         | OrderedList
-  //         | BulletList
-  //         | Inlines
-  //         )
-  static boolean Block(PsiBuilder builder_, int level_) {
+  //               OrderedList
+  //             | BulletList
+  //             | HorizontalRule
+  //             | Para
+  //             )
+  public static boolean Block(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Block")) return false;
     boolean result_;
-    Marker marker_ = enter_section_(builder_);
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<block>");
     result_ = Block_0(builder_, level_ + 1);
     result_ = result_ && Block_1(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
+    exit_section_(builder_, level_, marker_, BLOCK, result_, false, null);
     return result_;
   }
 
@@ -150,20 +166,18 @@ public class MarkdownParser implements PsiParser {
     return true;
   }
 
-  // Para
-  //         | Verbatim
-  //         | OrderedList
-  //         | BulletList
-  //         | Inlines
+  // OrderedList
+  //             | BulletList
+  //             | HorizontalRule
+  //             | Para
   private static boolean Block_1(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Block_1")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = Para(builder_, level_ + 1);
-    if (!result_) result_ = Verbatim(builder_, level_ + 1);
-    if (!result_) result_ = OrderedList(builder_, level_ + 1);
+    result_ = OrderedList(builder_, level_ + 1);
     if (!result_) result_ = BulletList(builder_, level_ + 1);
-    if (!result_) result_ = Inlines(builder_, level_ + 1);
+    if (!result_) result_ = HorizontalRule(builder_, level_ + 1);
+    if (!result_) result_ = Para(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -243,13 +257,15 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // BOM? ( Block )*
+  // BOM? Whitespace* AnonymousSection? (Whitespace* NamedSection)*
   static boolean Document(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Document")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = Document_0(builder_, level_ + 1);
     result_ = result_ && Document_1(builder_, level_ + 1);
+    result_ = result_ && Document_2(builder_, level_ + 1);
+    result_ = result_ && Document_3(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -261,28 +277,60 @@ public class MarkdownParser implements PsiParser {
     return true;
   }
 
-  // ( Block )*
+  // Whitespace*
   private static boolean Document_1(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Document_1")) return false;
     int pos_ = current_position_(builder_);
     while (true) {
-      if (!Document_1_0(builder_, level_ + 1)) break;
+      if (!Whitespace(builder_, level_ + 1)) break;
       if (!empty_element_parsed_guard_(builder_, "Document_1", pos_)) break;
       pos_ = current_position_(builder_);
     }
     return true;
   }
 
-  // ( Block )
-  private static boolean Document_1_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "Document_1_0")) return false;
+  // AnonymousSection?
+  private static boolean Document_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Document_2")) return false;
+    AnonymousSection(builder_, level_ + 1);
+    return true;
+  }
+
+  // (Whitespace* NamedSection)*
+  private static boolean Document_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Document_3")) return false;
+    int pos_ = current_position_(builder_);
+    while (true) {
+      if (!Document_3_0(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "Document_3", pos_)) break;
+      pos_ = current_position_(builder_);
+    }
+    return true;
+  }
+
+  // Whitespace* NamedSection
+  private static boolean Document_3_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Document_3_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = Block(builder_, level_ + 1);
+    result_ = Document_3_0_0(builder_, level_ + 1);
+    result_ = result_ && NamedSection(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
+  // Whitespace*
+  private static boolean Document_3_0_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Document_3_0_0")) return false;
+    int pos_ = current_position_(builder_);
+    while (true) {
+      if (!Whitespace(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "Document_3_0_0", pos_)) break;
+      pos_ = current_position_(builder_);
+    }
+    return true;
+  }
+
   /* ********************************************************** */
   // EmphStar | EmphUnderscore
   public static boolean Emph(PsiBuilder builder_, int level_) {
@@ -662,29 +710,17 @@ public class MarkdownParser implements PsiParser {
     return result_;
   }
 
-  /* ********************************************************** */
-  // Indent PlainText
-  public static boolean IndentedLine(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "IndentedLine")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<indented line>");
-    result_ = Indent(builder_, level_ + 1);
-    result_ = result_ && PlainText(builder_, level_ + 1);
-    exit_section_(builder_, level_, marker_, INDENTED_LINE, result_, false, null);
-    return result_;
-  }
-
   /* ********************************************************** */
   // Strong | Emph | Link | PlainText
-  static boolean Inline(PsiBuilder builder_, int level_) {
+  public static boolean Inline(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Inline")) return false;
     boolean result_;
-    Marker marker_ = enter_section_(builder_);
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<inline>");
     result_ = Strong(builder_, level_ + 1);
     if (!result_) result_ = Emph(builder_, level_ + 1);
     if (!result_) result_ = Link(builder_, level_ + 1);
     if (!result_) result_ = PlainText(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
+    exit_section_(builder_, level_, marker_, INLINE, result_, false, null);
     return result_;
   }
 
@@ -1052,24 +1088,14 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // !BlankLine IndentedLine
-  public static boolean NonblankIndentedLine(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "NonblankIndentedLine")) return false;
+  // SectionHeader SectionBody
+  public static boolean NamedSection(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "NamedSection")) return false;
     boolean result_;
-    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<nonblank indented line>");
-    result_ = NonblankIndentedLine_0(builder_, level_ + 1);
-    result_ = result_ && IndentedLine(builder_, level_ + 1);
-    exit_section_(builder_, level_, marker_, NONBLANK_INDENTED_LINE, result_, false, null);
-    return result_;
-  }
-
-  // !BlankLine
-  private static boolean NonblankIndentedLine_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "NonblankIndentedLine_0")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
-    result_ = !BlankLine(builder_, level_ + 1);
-    exit_section_(builder_, level_, marker_, null, result_, false, null);
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<named section>");
+    result_ = SectionHeader(builder_, level_ + 1);
+    result_ = result_ && SectionBody(builder_, level_ + 1);
+    exit_section_(builder_, level_, marker_, NAMED_SECTION, result_, false, null);
     return result_;
   }
 
@@ -1094,22 +1120,21 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // OptionalSpace Newline !BlankLine
+  // Newline !BlankLine
   static boolean NormalEndline(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "NormalEndline")) return false;
-    if (!nextTokenIs(builder_, "", NEWLINE, SPACECHAR)) return false;
+    if (!nextTokenIs(builder_, NEWLINE)) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = OptionalSpace(builder_, level_ + 1);
-    result_ = result_ && consumeToken(builder_, NEWLINE);
-    result_ = result_ && NormalEndline_2(builder_, level_ + 1);
+    result_ = consumeToken(builder_, NEWLINE);
+    result_ = result_ && NormalEndline_1(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
   // !BlankLine
-  private static boolean NormalEndline_2(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "NormalEndline_2")) return false;
+  private static boolean NormalEndline_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "NormalEndline_1")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
     result_ = !BlankLine(builder_, level_ + 1);
@@ -1153,21 +1178,27 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // NonindentSpace Inlines (BlankLine | TerminalEndline)
+  // Inlines (BlankLine | TerminalEndline)?
   public static boolean Para(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "Para")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_, level_, _NONE_, "<para>");
-    result_ = NonindentSpace(builder_, level_ + 1);
-    result_ = result_ && Inlines(builder_, level_ + 1);
-    result_ = result_ && Para_2(builder_, level_ + 1);
+    result_ = Inlines(builder_, level_ + 1);
+    result_ = result_ && Para_1(builder_, level_ + 1);
     exit_section_(builder_, level_, marker_, PARA, result_, false, null);
     return result_;
   }
 
+  // (BlankLine | TerminalEndline)?
+  private static boolean Para_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Para_1")) return false;
+    Para_1_0(builder_, level_ + 1);
+    return true;
+  }
+
   // BlankLine | TerminalEndline
-  private static boolean Para_2(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "Para_2")) return false;
+  private static boolean Para_1_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "Para_1_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = BlankLine(builder_, level_ + 1);
@@ -1177,7 +1208,7 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // (String | Number | Spacechar)+
+  // (String | Number | Spacechar+)+
   public static boolean PlainText(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "PlainText")) return false;
     boolean result_;
@@ -1193,14 +1224,30 @@ public class MarkdownParser implements PsiParser {
     return result_;
   }
 
-  // String | Number | Spacechar
+  // String | Number | Spacechar+
   private static boolean PlainText_0(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "PlainText_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = consumeToken(builder_, STRING);
     if (!result_) result_ = consumeToken(builder_, NUMBER);
-    if (!result_) result_ = consumeToken(builder_, SPACECHAR);
+    if (!result_) result_ = PlainText_0_2(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // Spacechar+
+  private static boolean PlainText_0_2(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "PlainText_0_2")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, SPACECHAR);
+    int pos_ = current_position_(builder_);
+    while (result_) {
+      if (!consumeToken(builder_, SPACECHAR)) break;
+      if (!empty_element_parsed_guard_(builder_, "PlainText_0_2", pos_)) break;
+      pos_ = current_position_(builder_);
+    }
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
@@ -1219,23 +1266,120 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
+  // Block*
+  public static boolean SectionBody(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionBody")) return false;
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<section body>");
+    int pos_ = current_position_(builder_);
+    while (true) {
+      if (!Block(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "SectionBody", pos_)) break;
+      pos_ = current_position_(builder_);
+    }
+    exit_section_(builder_, level_, marker_, SECTION_BODY, true, false, null);
+    return true;
+  }
+
+  /* ********************************************************** */
+  // '$' SectionName OptionalSpace ':' OptionalSpace
+  static boolean SectionHeader(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionHeader")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, "$");
+    result_ = result_ && SectionName(builder_, level_ + 1);
+    result_ = result_ && OptionalSpace(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, ":");
+    result_ = result_ && OptionalSpace(builder_, level_ + 1);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  /* ********************************************************** */
+  // SectionNameStart | '{' OptionalSpace SectionNameStart (Spacechar+ String)* OptionalSpace '}'
+  public static boolean SectionName(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionName")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<section name>");
+    result_ = SectionNameStart(builder_, level_ + 1);
+    if (!result_) result_ = SectionName_1(builder_, level_ + 1);
+    exit_section_(builder_, level_, marker_, SECTION_NAME, result_, false, null);
+    return result_;
+  }
+
+  // '{' OptionalSpace SectionNameStart (Spacechar+ String)* OptionalSpace '}'
+  private static boolean SectionName_1(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionName_1")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = consumeToken(builder_, "{");
+    result_ = result_ && OptionalSpace(builder_, level_ + 1);
+    result_ = result_ && SectionNameStart(builder_, level_ + 1);
+    result_ = result_ && SectionName_1_3(builder_, level_ + 1);
+    result_ = result_ && OptionalSpace(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, "}");
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // (Spacechar+ String)*
+  private static boolean SectionName_1_3(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionName_1_3")) return false;
+    int pos_ = current_position_(builder_);
+    while (true) {
+      if (!SectionName_1_3_0(builder_, level_ + 1)) break;
+      if (!empty_element_parsed_guard_(builder_, "SectionName_1_3", pos_)) break;
+      pos_ = current_position_(builder_);
+    }
+    return true;
+  }
+
+  // Spacechar+ String
+  private static boolean SectionName_1_3_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionName_1_3_0")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = SectionName_1_3_0_0(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, STRING);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
   // Spacechar+
-  static boolean RequiredSpace(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "RequiredSpace")) return false;
-    if (!nextTokenIs(builder_, SPACECHAR)) return false;
+  private static boolean SectionName_1_3_0_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionName_1_3_0_0")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
     result_ = consumeToken(builder_, SPACECHAR);
     int pos_ = current_position_(builder_);
     while (result_) {
       if (!consumeToken(builder_, SPACECHAR)) break;
-      if (!empty_element_parsed_guard_(builder_, "RequiredSpace", pos_)) break;
+      if (!empty_element_parsed_guard_(builder_, "SectionName_1_3_0_0", pos_)) break;
       pos_ = current_position_(builder_);
     }
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
+  /* ********************************************************** */
+  // '$'? String
+  static boolean SectionNameStart(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionNameStart")) return false;
+    boolean result_;
+    Marker marker_ = enter_section_(builder_);
+    result_ = SectionNameStart_0(builder_, level_ + 1);
+    result_ = result_ && consumeToken(builder_, STRING);
+    exit_section_(builder_, marker_, null, result_);
+    return result_;
+  }
+
+  // '$'?
+  private static boolean SectionNameStart_0(PsiBuilder builder_, int level_) {
+    if (!recursion_guard_(builder_, level_, "SectionNameStart_0")) return false;
+    consumeToken(builder_, "$");
+    return true;
+  }
+
   /* ********************************************************** */
   // StrongStar | StrongUnderscore
   public static boolean Strong(PsiBuilder builder_, int level_) {
@@ -1383,81 +1527,17 @@ public class MarkdownParser implements PsiParser {
   }
 
   /* ********************************************************** */
-  // (OptionalSpace Newline <<eof>>) | (OptionalSpace <<eof>>)
+  // OptionalSpace <<eof>>
   static boolean TerminalEndline(PsiBuilder builder_, int level_) {
     if (!recursion_guard_(builder_, level_, "TerminalEndline")) return false;
     boolean result_;
     Marker marker_ = enter_section_(builder_);
-    result_ = TerminalEndline_0(builder_, level_ + 1);
-    if (!result_) result_ = TerminalEndline_1(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // OptionalSpace Newline <<eof>>
-  private static boolean TerminalEndline_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "TerminalEndline_0")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
-    result_ = OptionalSpace(builder_, level_ + 1);
-    result_ = result_ && consumeToken(builder_, NEWLINE);
-    result_ = result_ && eof(builder_, level_ + 1);
-    exit_section_(builder_, marker_, null, result_);
-    return result_;
-  }
-
-  // OptionalSpace <<eof>>
-  private static boolean TerminalEndline_1(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "TerminalEndline_1")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_);
     result_ = OptionalSpace(builder_, level_ + 1);
     result_ = result_ && eof(builder_, level_ + 1);
     exit_section_(builder_, marker_, null, result_);
     return result_;
   }
 
-  /* ********************************************************** */
-  // VerbatimItem+
-  public static boolean Verbatim(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "Verbatim")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<verbatim>");
-    result_ = VerbatimItem(builder_, level_ + 1);
-    int pos_ = current_position_(builder_);
-    while (result_) {
-      if (!VerbatimItem(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "Verbatim", pos_)) break;
-      pos_ = current_position_(builder_);
-    }
-    exit_section_(builder_, level_, marker_, VERBATIM, result_, false, null);
-    return result_;
-  }
-
-  /* ********************************************************** */
-  // BlankLine* NonblankIndentedLine
-  public static boolean VerbatimItem(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "VerbatimItem")) return false;
-    boolean result_;
-    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<verbatim item>");
-    result_ = VerbatimItem_0(builder_, level_ + 1);
-    result_ = result_ && NonblankIndentedLine(builder_, level_ + 1);
-    exit_section_(builder_, level_, marker_, VERBATIM_ITEM, result_, false, null);
-    return result_;
-  }
-
-  // BlankLine*
-  private static boolean VerbatimItem_0(PsiBuilder builder_, int level_) {
-    if (!recursion_guard_(builder_, level_, "VerbatimItem_0")) return false;
-    int pos_ = current_position_(builder_);
-    while (true) {
-      if (!BlankLine(builder_, level_ + 1)) break;
-      if (!empty_element_parsed_guard_(builder_, "VerbatimItem_0", pos_)) break;
-      pos_ = current_position_(builder_);
-    }
-    return true;
-  }
-
   /* ********************************************************** */
   // Spacechar | Newline
   public static boolean Whitespace(PsiBuilder builder_, int level_) {
diff --git a/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.flex b/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.flex
new file mode 100644
index 00000000..f5aab899
--- /dev/null
+++ b/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.flex
@@ -0,0 +1,42 @@
+package org.jetbrains.markdown.lexer;
+
+import com.intellij.lexer.*;
+import com.intellij.psi.tree.IElementType;
+import static org.jetbrains.markdown.MarkdownElementTypes.*;
+
+%%
+
+%{
+  public _MarkdownLexer() {
+    this((java.io.Reader)null);
+  }
+%}
+
+%public
+%class _MarkdownLexer
+%implements FlexLexer
+%function advance
+%type IElementType
+%unicode
+
+Newline="\r"|"\n"|"\r\n"
+Spacechar=[\ \t\f]
+Number=[0-9]+(\.[0-9]*)?
+String=[^~:{}$\*_`&\[\]()<!#\\ \t\n\r]+
+AnyChar=.
+Line=!'\r' !'\n' .* {Newline}
+
+%%
+<YYINITIAL> {
+  {Spacechar}                         { return SPACECHAR; }
+  {Newline}                             { return NEWLINE; }
+  "\\357\\273\\277"                 { return BOM; }
+
+
+  {Number}                          { return NUMBER; }
+  {String}                          { return STRING; }
+
+  {AnyChar}                         { return ANYCHAR; }
+
+  [^] { return com.intellij.psi.TokenType.BAD_CHARACTER; }
+}
diff --git a/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.java b/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.java
index 0052e3ea..c84a83d8 100644
--- a/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.java
+++ b/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.java
@@ -1,4 +1,4 @@
-/* The following code was generated by JFlex 1.4.3 on 9/25/14 10:26 PM */
+/* The following code was generated by JFlex 1.4.3 on 9/29/14 3:24 PM */
 
 package org.jetbrains.markdown.lexer;
 
@@ -10,8 +10,8 @@ import static org.jetbrains.markdown.MarkdownElementTypes.*;
 /**
  * This class is a scanner generated by 
  * <a href="http://www.jflex.de/">JFlex</a> 1.4.3
- * on 9/25/14 10:26 PM from the specification file
- * <tt>/Users/orangy/Projects/dokka/src/Markdown/_MarkdownLexer.flex</tt>
+ * on 9/29/14 3:24 PM from the specification file
+ * <tt>/Users/orangy/Projects/dokka/gen/org/jetbrains/markdown/lexer/_MarkdownLexer.flex</tt>
  */
 public class _MarkdownLexer implements FlexLexer {
   /** initial size of the lookahead buffer */
@@ -35,9 +35,9 @@ public class _MarkdownLexer implements FlexLexer {
    */
   private static final String ZZ_CMAP_PACKED = 
     "\11\0\1\7\1\2\1\0\1\3\1\1\22\0\1\7\1\6\1\0"+
-    "\1\6\2\0\1\6\1\0\3\6\3\0\1\5\1\0\2\4\1\14"+
-    "\1\11\1\4\1\12\1\4\1\13\2\4\2\0\1\6\36\0\1\6"+
-    "\1\10\1\6\1\0\2\6\35\0\1\6\uff81\0";
+    "\2\6\1\0\1\6\1\0\3\6\3\0\1\5\1\0\2\4\1\14"+
+    "\1\11\1\4\1\12\1\4\1\13\2\4\1\6\1\0\1\6\36\0"+
+    "\1\6\1\10\1\6\1\0\2\6\32\0\1\6\1\0\2\6\uff81\0";
 
   /** 
    * Translates characters to character classes
@@ -245,7 +245,7 @@ public class _MarkdownLexer implements FlexLexer {
     char [] map = new char[0x10000];
     int i = 0;  /* index in packed string  */
     int j = 0;  /* index in unpacked array */
-    while (i < 74) {
+    while (i < 80) {
       int  count = packed.charAt(i++);
       char value = packed.charAt(i++);
       do map[j++] = value; while (--count > 0);
diff --git a/src/Analysis/CommentsAPI.kt b/src/Analysis/CommentsAPI.kt
index 5df4bd38..a17b6aa4 100644
--- a/src/Analysis/CommentsAPI.kt
+++ b/src/Analysis/CommentsAPI.kt
@@ -31,5 +31,5 @@ fun KDoc?.extractText(): String {
             comment.substring(0, comment.length - 2)
         else
             comment).trim()
-    }.filter { it.any() }.join("\n")
+    }.join("\n")
 }
\ No newline at end of file
diff --git a/src/Formats/MarkdownFormatService.kt b/src/Formats/MarkdownFormatService.kt
index d7530a25..3b87835f 100644
--- a/src/Formats/MarkdownFormatService.kt
+++ b/src/Formats/MarkdownFormatService.kt
@@ -16,10 +16,6 @@ public open class MarkdownFormatService(locationService: LocationService,
         return text.htmlEscape()
     }
 
-    override public fun formatText(text: RichString): String {
-        return text.toString().htmlEscape()
-    }
-
     override public fun formatCode(code: String): String {
         return "`$code`"
     }
diff --git a/src/Formats/StructuredFormatService.kt b/src/Formats/StructuredFormatService.kt
index 0c58f553..b1e614f6 100644
--- a/src/Formats/StructuredFormatService.kt
+++ b/src/Formats/StructuredFormatService.kt
@@ -28,19 +28,17 @@ public abstract class StructuredFormatService(val locationService: LocationServi
     public abstract fun formatCode(code: String): String
     public abstract fun formatBreadcrumbs(items: Iterable<FormatLink>): String
 
-    open fun formatText(text: RichString): String {
+    open fun formatText(nodes: Iterable<ContentNode>): String {
+        return nodes.map { formatText(it) }.join("")
+    }
+
+    open fun formatText(text: ContentNode): String {
         return StringBuilder {
-            for (slice in text.slices) {
-                val style = slice.style
-                when (style) {
-                    is NormalStyle -> append(slice.text)
-                    is BoldStyle -> append(formatBold(slice.text))
-                    is CodeStyle -> append(formatCode(slice.text))
-                    is LinkStyle -> {
-                        val node = resolutionService.resolve(style.link)
-                        val location = locationService.location(node)
-                        append(formatLink(slice.text, location))
-                    }
+            for (node in text.children) {
+                when (node) {
+                    is ContentText -> append(node.text)
+                    is ContentEmphasis -> append(formatBold(formatText(node.children)))
+                    else -> append(formatText(node.children))
                 }
             }
         }.toString()
@@ -67,7 +65,7 @@ public abstract class StructuredFormatService(val locationService: LocationServi
                     if (label.startsWith("$"))
                         continue
                     appendLine(to, formatBold(formatText(label)))
-                    appendLine(to, formatText(section.text))
+                    appendLine(to, formatText(section))
                     appendLine(to)
                 }
             }
diff --git a/src/Formats/TextFormatService.kt b/src/Formats/TextFormatService.kt
index 77a0bb65..8fea5a6a 100644
--- a/src/Formats/TextFormatService.kt
+++ b/src/Formats/TextFormatService.kt
@@ -9,12 +9,9 @@ public class TextFormatService(val signatureGenerator: LanguageService) : Format
                 appendln(signatureGenerator.render(node))
                 appendln()
                 appendln(node.doc.summary)
-                for (n in 0..node.doc.summary.length())
-                    append("=")
 
                 for ((label,section) in node.doc.sections) {
                     appendln(label)
-                    appendln(section.text)
                 }
             }
         }
diff --git a/src/Kotlin/ContentBuilder.kt b/src/Kotlin/ContentBuilder.kt
new file mode 100644
index 00000000..78bd7eaf
--- /dev/null
+++ b/src/Kotlin/ContentBuilder.kt
@@ -0,0 +1,79 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.markdown.MarkdownElementTypes
+import java.util.ArrayDeque
+
+public fun MarkdownTree.toContent(): Content {
+    val nodeStack = ArrayDeque<ContentNode>()
+    nodeStack.push(Content())
+
+    visit {(node, text, processChildren) ->
+        val parent = nodeStack.peek()!!
+        val nodeType = node.getTokenType()
+        val nodeText = getNodeText(node)
+        when (nodeType) {
+            MarkdownElementTypes.BULLET_LIST -> {
+                nodeStack.push(ContentList())
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.ORDERED_LIST -> {
+                nodeStack.push(ContentList()) // TODO: add list kind
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.HORIZONTAL_RULE -> {
+            }
+            MarkdownElementTypes.LIST_BLOCK -> {
+                nodeStack.push(ContentBlock())
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.EMPH -> {
+                nodeStack.push(ContentEmphasis())
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.STRONG -> {
+                nodeStack.push(ContentStrong())
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.ANONYMOUS_SECTION -> {
+                nodeStack.push(ContentSection(""))
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.NAMED_SECTION -> {
+                val label = findChildByType(node, MarkdownElementTypes.SECTION_NAME)?.let { getNodeText(it) } ?: ""
+                nodeStack.push(ContentSection(label))
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.PLAIN_TEXT -> {
+                nodeStack.push(ContentText(nodeText))
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.END_LINE -> {
+                nodeStack.push(ContentText(nodeText))
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            MarkdownElementTypes.BLANK_LINE -> {
+                processChildren()
+            }
+            MarkdownElementTypes.PARA -> {
+                nodeStack.push(ContentBlock())
+                processChildren()
+                parent.children.add(nodeStack.pop())
+            }
+            else -> {
+                processChildren()
+            }
+        }
+    }
+    return nodeStack.pop() as Content
+}
+
+
diff --git a/src/Kotlin/Diagnostics.kt b/src/Kotlin/Diagnostics.kt
new file mode 100644
index 00000000..5548bc01
--- /dev/null
+++ b/src/Kotlin/Diagnostics.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.resolve.name.*
+import org.jetbrains.jet.lang.resolve.BindingContext
+
+fun DocumentationContext.checkResolveChildren(node: DocumentationNode) {
+    if (node.kind != DocumentationNode.Kind.Module && node.kind != DocumentationNode.Kind.Package) {
+        // TODO: we don't resolve packages and modules for now
+
+        val parentScope = getResolutionScope(node)
+        for (item in node.details + node.members) {
+            val symbolName = item.name
+            val symbol: DeclarationDescriptor? = when (item.kind) {
+                DocumentationNode.Kind.Modifier -> continue // do not resolve modifiers, they are not names
+                DocumentationNode.Kind.Receiver -> continue // what is receiver's name in platform?
+                DocumentationNode.Kind.Parameter -> parentScope.getLocalVariable(Name.guess(symbolName))
+                DocumentationNode.Kind.Function -> parentScope.getFunctions(Name.guess(symbolName)).firstOrNull()
+                DocumentationNode.Kind.Property -> parentScope.getProperties(Name.guess(symbolName)).firstOrNull()
+                DocumentationNode.Kind.Constructor -> parentScope.getFunctions(Name.guess(symbolName)).firstOrNull()
+                else -> parentScope.getClassifier(Name.guess(symbolName))
+            }
+
+            if (symbol == null)
+                println("WARNING: Cannot resolve $item in ${path(node)}")
+        }
+    }
+
+    for (reference in node.allReferences().filterNot { it.kind == DocumentationReference.Kind.Owner }) {
+        checkResolveChildren(reference.to)
+    }
+}
+
+fun path(node: DocumentationNode): String {
+    val owner = node.owner
+    if (owner != null)
+        return "$node in ${path(owner)}"
+    else
+        return "$node"
+}
\ No newline at end of file
diff --git a/src/Kotlin/DocumentationBuildingVisitor.kt b/src/Kotlin/DocumentationBuildingVisitor.kt
new file mode 100644
index 00000000..5654903b
--- /dev/null
+++ b/src/Kotlin/DocumentationBuildingVisitor.kt
@@ -0,0 +1,122 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.jet.lang.descriptors.*
+import org.jetbrains.jet.lang.resolve.name.*
+import org.jetbrains.jet.lang.resolve.*
+
+public data class DocumentationOptions(val includeNonPublic : Boolean = false)
+
+class DocumentationBuildingVisitor(val context: BindingContext,
+                                   val options: DocumentationOptions,
+                                   private val worker: DeclarationDescriptorVisitor<DocumentationNode, DocumentationNode>)
+: DeclarationDescriptorVisitor<DocumentationNode, DocumentationNode> {
+
+    private fun visitChildren(descriptors: Collection<DeclarationDescriptor>, data: DocumentationNode) {
+        for (descriptor in descriptors) {
+            visitChild(descriptor, data)
+        }
+    }
+
+    private fun visitChild(descriptor: DeclarationDescriptor?, data: DocumentationNode) {
+        if (descriptor != null && descriptor.isUserCode()) {
+            if (options.includeNonPublic || descriptor !is MemberDescriptor || descriptor.getVisibility().isPublicAPI()) {
+                descriptor.accept(this, data)
+            }
+        }
+    }
+
+    private fun createDocumentation(descriptor: DeclarationDescriptor, data: DocumentationNode): DocumentationNode {
+        return descriptor.accept(worker, data)
+    }
+
+    private fun processCallable(descriptor: CallableDescriptor, data: DocumentationNode): DocumentationNode {
+        val node = createDocumentation(descriptor, data)
+        visitChildren(descriptor.getTypeParameters(), node)
+        visitChild(descriptor.getReceiverParameter(), node)
+        visitChildren(descriptor.getValueParameters(), node)
+        return node
+    }
+
+    public override fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = createDocumentation(descriptor!!, data!!)
+        visitChildren(descriptor.getMemberScope().getAllDescriptors(), node)
+        return node
+    }
+
+    public override fun visitPackageViewDescriptor(descriptor: PackageViewDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = createDocumentation(descriptor!!, data!!)
+        visitChildren(descriptor.getMemberScope().getAllDescriptors(), node)
+        return node
+    }
+
+    public override fun visitVariableDescriptor(descriptor: VariableDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = processCallable(descriptor!!, data!!)
+        return node
+    }
+
+    public override fun visitPropertyDescriptor(descriptor: PropertyDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = processCallable(descriptor!!, data!!)
+        visitChild(descriptor.getGetter(), node)
+        visitChild(descriptor.getSetter(), node)
+        return node
+    }
+
+    public override fun visitFunctionDescriptor(descriptor: FunctionDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = processCallable(descriptor!!, data!!)
+        return node
+    }
+
+    public override fun visitTypeParameterDescriptor(descriptor: TypeParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = createDocumentation(descriptor!!, data!!)
+        return node
+    }
+
+    public override fun visitClassDescriptor(descriptor: ClassDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = createDocumentation(descriptor!!, data!!)
+        if (descriptor.getKind() != ClassKind.OBJECT) {
+            // do not go inside object for class object and constructors, they are generated
+            visitChildren(descriptor.getTypeConstructor().getParameters(), node)
+            visitChildren(descriptor.getConstructors(), node)
+            visitChild(descriptor.getClassObjectDescriptor(), node)
+        }
+        visitChildren(descriptor.getDefaultType().getMemberScope().getAllDescriptors(), node)
+        return node
+    }
+
+    public override fun visitModuleDeclaration(descriptor: ModuleDescriptor, data: DocumentationNode): DocumentationNode {
+        val node = createDocumentation(descriptor, data)
+        visitChild(descriptor.getPackage(FqName.ROOT), node)
+        return node
+    }
+
+    public override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = visitFunctionDescriptor(descriptor!!, data)
+        return node
+    }
+
+    public override fun visitScriptDescriptor(scriptDescriptor: ScriptDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val classDescriptor = scriptDescriptor!!.getClassDescriptor()
+        val node = visitClassDescriptor(classDescriptor, data)
+        return node
+    }
+
+    public override fun visitValueParameterDescriptor(descriptor: ValueParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = visitVariableDescriptor(descriptor!!, data)
+        return node
+    }
+
+    public override fun visitPropertyGetterDescriptor(descriptor: PropertyGetterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = visitFunctionDescriptor(descriptor!!, data)
+        return node
+    }
+
+    public override fun visitPropertySetterDescriptor(descriptor: PropertySetterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = visitFunctionDescriptor(descriptor!!, data)
+        return node
+    }
+
+    public override fun visitReceiverParameterDescriptor(descriptor: ReceiverParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        val node = createDocumentation(descriptor!!, data!!)
+        return node
+    }
+}
diff --git a/src/Kotlin/DocumentationContext.kt b/src/Kotlin/DocumentationContext.kt
new file mode 100644
index 00000000..1491aa2d
--- /dev/null
+++ b/src/Kotlin/DocumentationContext.kt
@@ -0,0 +1,47 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.resolve.name.FqName
+
+public class DocumentationContext(val bindingContext: BindingContext) {
+    val descriptorToNode = hashMapOf<DeclarationDescriptor, DocumentationNode>()
+    val nodeToDescriptor = hashMapOf<DocumentationNode, DeclarationDescriptor>()
+
+    fun register(descriptor: DeclarationDescriptor, node: DocumentationNode) {
+        descriptorToNode.put(descriptor, node)
+        nodeToDescriptor.put(node, descriptor)
+    }
+
+    fun getResolutionScope(node: DocumentationNode): JetScope {
+        val descriptor = nodeToDescriptor[node] ?: throw IllegalArgumentException("Node is not known to this context")
+        return bindingContext.getResolutionScope(descriptor)
+    }
+
+    fun parseDocumentation(descriptor: DeclarationDescriptor): Content {
+        val docText = bindingContext.getDocumentationElements(descriptor).map { it.extractText() }.join("\n")
+        val tree = MarkdownProcessor.parse(docText)
+        println(tree.toTestString())
+        val content = tree.toContent()
+        return content
+    }
+}
+
+fun BindingContext.createDocumentationModule(name: String,
+                                             module: ModuleDescriptor,
+                                             packages: Set<FqName>,
+                                             options: DocumentationOptions = DocumentationOptions()): DocumentationModule {
+    val documentationModule = DocumentationModule(name)
+    val context = DocumentationContext(this)
+    val visitor = DocumentationNodeBuilder(context)
+    for (packageName in packages) {
+        val pkg = module.getPackage(packageName)
+        pkg!!.accept(DocumentationBuildingVisitor(this, options, visitor), documentationModule)
+    }
+
+    // TODO: Uncomment for resolve verification
+    // checkResolveChildren(documentationModule)
+    return documentationModule
+}
diff --git a/src/Kotlin/DocumentationNodeBuilder.kt b/src/Kotlin/DocumentationNodeBuilder.kt
new file mode 100644
index 00000000..535f037f
--- /dev/null
+++ b/src/Kotlin/DocumentationNodeBuilder.kt
@@ -0,0 +1,177 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
+import org.jetbrains.jet.lang.descriptors.MemberDescriptor
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.lang.descriptors.Named
+import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
+import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor
+import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor
+import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.lang.descriptors.ClassKind
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+
+class DocumentationNodeBuilder(val context: DocumentationContext) : DeclarationDescriptorVisitorEmptyBodies<DocumentationNode, DocumentationNode>() {
+
+    fun reference(from: DocumentationNode, to: DocumentationNode, kind: DocumentationReference.Kind) {
+        from.addReferenceTo(to, kind)
+        if (kind == DocumentationReference.Kind.Link)
+            to.addReferenceTo(from, DocumentationReference.Kind.Link)
+        else
+            to.addReferenceTo(from, DocumentationReference.Kind.Owner)
+    }
+
+    fun addModality(descriptor: MemberDescriptor, data: DocumentationNode) {
+        val modifier = descriptor.getModality().name().toLowerCase()
+        val node = DocumentationNode(modifier, Content.Empty, DocumentationNode.Kind.Modifier)
+        reference(data, node, DocumentationReference.Kind.Detail)
+    }
+
+    fun addVisibility(descriptor: MemberDescriptor, data: DocumentationNode) {
+        val modifier = descriptor.getVisibility().toString()
+        val node = DocumentationNode(modifier, Content.Empty, DocumentationNode.Kind.Modifier)
+        reference(data, node, DocumentationReference.Kind.Detail)
+    }
+
+    fun addType(descriptor: DeclarationDescriptor, t: JetType?, data: DocumentationNode) {
+        if (t == null)
+            return
+        val typeConstructor = t.getConstructor()
+        val classifierDescriptor = typeConstructor.getDeclarationDescriptor()
+        val name = when (classifierDescriptor) {
+            is Named -> classifierDescriptor.getName().asString()
+            else -> "<anonymous>"
+        }
+        val node = DocumentationNode(name, Content.Empty, DocumentationNode.Kind.Type)
+        reference(data, node, DocumentationReference.Kind.Detail)
+
+        for (param in t.getArguments())
+            addType(descriptor, param.getType(), node)
+    }
+
+    override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.Unknown)
+        reference(data!!, node, DocumentationReference.Kind.Link)
+        context.register(descriptor, node)
+        return node
+    }
+
+    override fun visitReceiverParameterDescriptor(descriptor: ReceiverParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val node = DocumentationNode(descriptor.getName().asString(), Content.Empty, DocumentationNode.Kind.Receiver)
+        reference(data!!, node, DocumentationReference.Kind.Detail)
+
+        addType(descriptor, descriptor.getType(), node)
+
+        return node
+    }
+
+    override fun visitValueParameterDescriptor(descriptor: ValueParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.Parameter)
+        reference(data!!, node, DocumentationReference.Kind.Detail)
+
+        addType(descriptor, descriptor.getType(), node)
+
+        return node
+    }
+
+    override fun visitClassDescriptor(descriptor: ClassDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, when (descriptor.getKind()) {
+            ClassKind.OBJECT -> org.jetbrains.dokka.DocumentationNode.Kind.Object
+            ClassKind.CLASS_OBJECT -> org.jetbrains.dokka.DocumentationNode.Kind.Object
+            ClassKind.TRAIT -> org.jetbrains.dokka.DocumentationNode.Kind.Interface
+            ClassKind.ENUM_CLASS -> org.jetbrains.dokka.DocumentationNode.Kind.Enum
+            ClassKind.ENUM_ENTRY -> org.jetbrains.dokka.DocumentationNode.Kind.EnumItem
+            else -> DocumentationNode.Kind.Class
+        })
+        reference(data!!, node, DocumentationReference.Kind.Member)
+        addModality(descriptor, node)
+        addVisibility(descriptor, node)
+        context.register(descriptor, node)
+        return node
+    }
+
+    override fun visitFunctionDescriptor(descriptor: FunctionDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.Function)
+        reference(data!!, node, DocumentationReference.Kind.Member)
+
+        addType(descriptor, descriptor.getReturnType(), node)
+        addModality(descriptor, node)
+        addVisibility(descriptor, node)
+        context.register(descriptor, node)
+        return node
+    }
+
+    override fun visitTypeParameterDescriptor(descriptor: TypeParameterDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.TypeParameter)
+        reference(data!!, node, DocumentationReference.Kind.Detail)
+        val builtIns = KotlinBuiltIns.getInstance()
+        for (constraint in descriptor.getUpperBounds()) {
+            if (constraint == builtIns.getDefaultBound())
+                continue
+            val constraintNode = DocumentationNode(constraint.toString(), Content.Empty, DocumentationNode.Kind.UpperBound)
+            reference(node, constraintNode, DocumentationReference.Kind.Detail)
+        }
+        for (constraint in descriptor.getLowerBounds()) {
+            if (builtIns.isNothing(constraint))
+                continue
+            val constraintNode = DocumentationNode(constraint.toString(), Content.Empty, DocumentationNode.Kind.LowerBound)
+            reference(node, constraintNode, DocumentationReference.Kind.Detail)
+        }
+        return node
+    }
+
+    override fun visitPropertyDescriptor(descriptor: PropertyDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.Property)
+        reference(data!!, node, DocumentationReference.Kind.Member)
+
+        addType(descriptor, descriptor.getType(), node)
+        addModality(descriptor, node)
+        addVisibility(descriptor, node)
+        context.register(descriptor, node)
+        return node
+    }
+
+    override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val doc = context.parseDocumentation(descriptor)
+        val node = DocumentationNode(descriptor.getName().asString(), doc, DocumentationNode.Kind.Constructor)
+        reference(data!!, node, DocumentationReference.Kind.Member)
+
+        addVisibility(descriptor, node)
+        context.register(descriptor, node)
+        return node
+    }
+
+    override fun visitPackageViewDescriptor(descriptor: PackageViewDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val node = DocumentationNode(descriptor.getFqName().asString(), Content.Empty, DocumentationNode.Kind.Package)
+        reference(data!!, node, DocumentationReference.Kind.Member)
+        return node
+    }
+
+    override fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor?, data: DocumentationNode?): DocumentationNode? {
+        descriptor!!
+        val node = DocumentationNode(descriptor.fqName.asString(), Content.Empty, DocumentationNode.Kind.Package)
+        reference(data!!, node, DocumentationReference.Kind.Member)
+        return node
+    }
+}
\ No newline at end of file
diff --git a/src/Markdown/MarkdownProcessor.kt b/src/Markdown/MarkdownProcessor.kt
index fe6e8436..19d5a8fb 100644
--- a/src/Markdown/MarkdownProcessor.kt
+++ b/src/Markdown/MarkdownProcessor.kt
@@ -9,12 +9,11 @@ import com.intellij.lang.LighterASTNode
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import com.intellij.openapi.util.Ref
 import org.jetbrains.markdown.lexer.MarkdownLexer
+import com.intellij.psi.tree.IElementType
 
-public class MarkdownProcessor {
-    class object {
-        val EXPR_LANGUAGE = object : Language("MARKDOWN") {}
-        val DOCUMENT = IFileElementType("DOCUMENT", EXPR_LANGUAGE);
-    }
+public object MarkdownProcessor {
+    val EXPR_LANGUAGE = object : Language("MARKDOWN") {}
+    val DOCUMENT = IFileElementType("DOCUMENT", EXPR_LANGUAGE);
 
     public fun parse(markdown: String): MarkdownTree {
         val parser = MarkdownParser()
@@ -30,6 +29,28 @@ public class MarkdownTree(private val text: String, private val structure: Flywe
         visit(structure.getRoot(), action)
     }
 
+    fun findChildByType(node: LighterASTNode, findType: IElementType) : LighterASTNode? {
+        val ref = Ref.create<Array<LighterASTNode>?>()
+        val count = structure.getChildren(node, ref)
+        val children = ref.get()
+        if (children != null) {
+            for (index in 0..count - 1) {
+                val child = children[index]
+                val nodeType = child.getTokenType()
+                if (nodeType == findType)
+                    return child
+                val nestedChild = findChildByType(child, findType)
+                if (nestedChild != null)
+                    return nestedChild
+            }
+        }
+        return null
+    }
+
+    fun getNodeText(node: LighterASTNode) : String {
+        return text.substring(node.getStartOffset(), node.getEndOffset())
+    }
+
     fun visit(node: LighterASTNode, action: (LighterASTNode, String, visitChildren: () -> Unit) -> Unit) {
         action(node, text) {
             val ref = Ref.create<Array<LighterASTNode>?>()
@@ -46,7 +67,7 @@ public class MarkdownTree(private val text: String, private val structure: Flywe
 
 }
 
-public fun MarkdownTree.dump(): String {
+public fun MarkdownTree.toTestString(): String {
     val sb = StringBuilder()
     var level = 0
     visit {(node, text, visitChildren) ->
@@ -64,29 +85,25 @@ public fun MarkdownTree.dump(): String {
 
 public fun MarkdownTree.toHtml(): String {
     val sb = StringBuilder()
-    var level = 0
     visit {(node, text, processChildren) ->
         val nodeType = node.getTokenType()
         val nodeText = text.substring(node.getStartOffset(), node.getEndOffset())
-        val indent = " ".repeat(level * 2)
         when (nodeType) {
             MarkdownElementTypes.BULLET_LIST -> {
-                sb.appendln("$indent<ul>")
-                level++
+                sb.appendln("<ul>")
                 processChildren()
-                level--
-                sb.appendln("$indent</ul>")
+                sb.appendln("</ul>")
             }
             MarkdownElementTypes.HORIZONTAL_RULE -> {
-                sb.appendln("$indent<hr/>")
+                sb.appendln("<hr/>")
             }
             MarkdownElementTypes.ORDERED_LIST -> {
-                sb.appendln("$indent<ol>")
+                sb.appendln("<ol>")
                 processChildren()
-                sb.appendln("$indent</ol>")
+                sb.appendln("</ol>")
             }
             Markdo