[scaladoc] Fixes issue with code block in scala...

[scaladoc] Fixes issue with code block in scaladoc attribute (which were
wrongly attributed to main comment, instead of attribute). Review by
pedrofurla.

1 files changed, 149 insertions, 124 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/comment/CommentFactory.scala b/src/compiler/scala/tools/nsc/doc/model/comment/CommentFactory.scala
index 3b96281728..b6855353f4 100644
--- a/src/compiler/scala/tools/nsc/doc/model/comment/CommentFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/comment/CommentFactory.scala
@@ -44,14 +44,15 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory =>
   /** A comment is usualy created by the parser, however for some special cases we have to give
     * some inTpl comments (parent class for example) to the comment of the symbol
     * This function manages some of those cases : Param accessor and Primary constructor */
-  def defineComment(sym: global.Symbol, inTpl: => DocTemplateImpl):Option[Comment] =
+  def defineComment(sym: global.Symbol, inTpl: => DocTemplateImpl):Option[Comment] = {
+
     //param accessor case
     // We just need the @param argument, we put it into the body
     if( sym.isParamAccessor &&
         inTpl.comment.isDefined &&
         inTpl.comment.get.valueParams.isDefinedAt(sym.encodedName)) {
       val comContent = Some(inTpl.comment.get.valueParams(sym.encodedName))
-      Some(createComment(body0=comContent))
+      Some(createComment(body0 = comContent))
     }
 
     // Primary constructor case
@@ -74,6 +75,7 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory =>
                             ))
       else None
     }
+
     //other comment cases
     // parse function will make the comment
     else {
@@ -85,40 +87,41 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory =>
       else None
     }
 
-  /* Creates comments with necessary arguments */
-  def createComment(body0:        Option[Body]     = None,
-                    authors0:     List[Body]       = List.empty,
-                    see0:         List[Body]       = List.empty,
-                    result0:      Option[Body]     = None,
-                    throws0:      Map[String,Body] = Map.empty,
-                    valueParams0: Map[String,Body] = Map.empty,
-                    typeParams0:  Map[String,Body] = Map.empty,
-                    version0:     Option[Body]     = None,
-                    since0:       Option[Body]     = None,
-                    todo0:        List[Body]       = List.empty,
-                    deprecated0:  Option[Body]     = None,
-                    note0:        List[Body]       = List.empty,
-                    example0:     List[Body]       = List.empty,
-                    constructor0: Option[Body]     = None,
-                    source0:      Option[String]   = None
-                    ):Comment =
-    new Comment{
-      val body        = if(body0 isDefined) body0.get else Body(Seq.empty)
-      val authors     = authors0
-      val see         = see0
-      val result      = result0
-      val throws      = throws0
-      val valueParams = valueParams0
-      val typeParams  = typeParams0
-      val version     = version0
-      val since       = since0
-      val todo        = todo0
-      val deprecated  = deprecated0
-      val note        = note0
-      val example     = example0
-      val constructor = constructor0
-      val source      = source0
+  }
 
+  /* Creates comments with necessary arguments */
+  def createComment (
+    body0:        Option[Body]     = None,
+    authors0:     List[Body]       = List.empty,
+    see0:         List[Body]       = List.empty,
+    result0:      Option[Body]     = None,
+    throws0:      Map[String,Body] = Map.empty,
+    valueParams0: Map[String,Body] = Map.empty,
+    typeParams0:  Map[String,Body] = Map.empty,
+    version0:     Option[Body]     = None,
+    since0:       Option[Body]     = None,
+    todo0:        List[Body]       = List.empty,
+    deprecated0:  Option[Body]     = None,
+    note0:        List[Body]       = List.empty,
+    example0:     List[Body]       = List.empty,
+    constructor0: Option[Body]     = None,
+    source0:      Option[String]   = None
+  ) : Comment = new Comment{
+    val body        = if(body0 isDefined) body0.get else Body(Seq.empty)
+    val authors     = authors0
+    val see         = see0
+    val result      = result0
+    val throws      = throws0
+    val valueParams = valueParams0
+    val typeParams  = typeParams0
+    val version     = version0
+    val since       = since0
+    val todo        = todo0
+    val deprecated  = deprecated0
+    val note        = note0
+    val example     = example0
+    val constructor = constructor0
+    val source      = source0
   }
 
   protected val endOfText = '\u0003'
@@ -235,107 +238,129 @@ trait CommentFactory { thisFactory: ModelFactory with CommentFactory =>
       *                    are part of the previous tag or, if none exists, of the body.
       * @param remaining   The lines that must still recursively be parsed.
       * @param inCodeBlock Whether the next line is part of a code block (in which no tags must be read). */
-    def parse0(docBody: String, tags: Map[TagKey, List[String]], lastTagKey: Option[TagKey], remaining: List[String], inCodeBlock: Boolean): Comment = {
-      remaining match {
-
-        case CodeBlockStart(before, after) :: ls if (!inCodeBlock) =>
-          if (before.trim != "")
-            parse0(docBody, tags, lastTagKey, before :: ("{{{" + after) :: ls, false)
-          else if (after.trim != "")
-            parse0(docBody, tags, lastTagKey, "{{{" :: after :: ls, true)
-          else
+    def parse0 (
+      docBody: String,
+      tags: Map[TagKey, List[String]],
+      lastTagKey: Option[TagKey],
+      remaining: List[String],
+      inCodeBlock: Boolean
+    ): Comment = remaining match {
+
+      case CodeBlockStart(before, after) :: ls if (!inCodeBlock) =>
+        if (before.trim != "")
+          parse0(docBody, tags, lastTagKey, before :: ("{{{" + after) :: ls, false)
+        else if (after.trim != "")
+          parse0(docBody, tags, lastTagKey, "{{{" :: after :: ls, true)
+        else lastTagKey match {
+          case Some(key) =>
+            val value =
+              ((tags get key): @unchecked) match {
+                case Some(b :: bs) => (b + endOfLine + "{{{") :: bs
+                case None => oops("lastTagKey set when no tag exists for key")
+              }
+            parse0(docBody, tags + (key -> value), lastTagKey, ls, true)
+          case None =>
             parse0(docBody + endOfLine + "{{{", tags, lastTagKey, ls, true)
+        }
 
-        case CodeBlockEnd(before, after) :: ls =>
-          if (before.trim != "")
-            parse0(docBody, tags, lastTagKey, before :: ("}}}" + after) :: ls, true)
-          else if (after.trim != "")
-            parse0(docBody, tags, lastTagKey, "}}}" :: after :: ls, false)
-          else
+      case CodeBlockEnd(before, after) :: ls =>
+        if (before.trim != "")
+          parse0(docBody, tags, lastTagKey, before :: ("}}}" + after) :: ls, true)
+        else if (after.trim != "")
+          parse0(docBody, tags, lastTagKey, "}}}" :: after :: ls, false)
+        else lastTagKey match {
+          case Some(key) =>
+            val value =
+              ((tags get key): @unchecked) match {
+                case Some(b :: bs) => (b + endOfLine + "}}}") :: bs
+                case None => oops("lastTagKey set when no tag exists for key")
+              }
+            parse0(docBody, tags + (key -> value), lastTagKey, ls, false)
+          case None =>
             parse0(docBody + endOfLine + "}}}", tags, lastTagKey, ls, false)
+        }
 
-        case SymbolTag(name, sym, body) :: ls if (!inCodeBlock) =>
-          val key = SymbolTagKey(name, sym)
-          val value = body :: tags.getOrElse(key, Nil)
-          parse0(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
-
-        case SimpleTag(name, body) :: ls if (!inCodeBlock) =>
-          val key = SimpleTagKey(name)
-          val value = body :: tags.getOrElse(key, Nil)
-          parse0(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
-
-        case line :: ls if (lastTagKey.isDefined) =>
-          val key = lastTagKey.get
-          val value =
-            ((tags get key): @unchecked) match {
-              case Some(b :: bs) => (b + endOfLine + line) :: bs
-              case None => oops("lastTagKey set when no tag exists for key")
-            }
-          parse0(docBody, tags + (key -> value), lastTagKey, ls, inCodeBlock)
+      case SymbolTag(name, sym, body) :: ls if (!inCodeBlock) =>
+        val key = SymbolTagKey(name, sym)
+        val value = body :: tags.getOrElse(key, Nil)
+        parse0(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
+
+      case SimpleTag(name, body) :: ls if (!inCodeBlock) =>
+        val key = SimpleTagKey(name)
+        val value = body :: tags.getOrElse(key, Nil)
+        parse0(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
+
+      case line :: ls if (lastTagKey.isDefined) =>
+        val key = lastTagKey.get
+        val value =
+          ((tags get key): @unchecked) match {
+            case Some(b :: bs) => (b + endOfLine + line) :: bs
+            case None => oops("lastTagKey set when no tag exists for key")
+          }
+        parse0(docBody, tags + (key -> value), lastTagKey, ls, inCodeBlock)
 
-        case line :: ls =>
-          val newBody = if (docBody == "") line else docBody + endOfLine + line
-          parse0(newBody, tags, lastTagKey, ls, inCodeBlock)
+      case line :: ls =>
+        val newBody = if (docBody == "") line else docBody + endOfLine + line
+        parse0(newBody, tags, lastTagKey, ls, inCodeBlock)
 
-        case Nil =>
+      case Nil =>
 
-          val bodyTags: mutable.Map[TagKey, List[Body]] =
-            mutable.Map(tags mapValues (_ map (parseWiki(_, pos))) toSeq: _*)
+        val bodyTags: mutable.Map[TagKey, List[Body]] =
+          mutable.Map(tags mapValues {tag => tag map (parseWiki(_, pos))} toSeq: _*)
 
-          def oneTag(key: SimpleTagKey): Option[Body] =
-            ((bodyTags remove key): @unchecked) match {
-              case Some(r :: rs) =>
-                if (!rs.isEmpty) reporter.warning(pos, "Only one '@" + key.name + "' tag is allowed")
-                Some(r)
-              case None => None
+        def oneTag(key: SimpleTagKey): Option[Body] =
+          ((bodyTags remove key): @unchecked) match {
+            case Some(r :: rs) =>
+              if (!rs.isEmpty) reporter.warning(pos, "Only one '@" + key.name + "' tag is allowed")
+              Some(r)
+            case None => None
+          }
+
+        def allTags(key: SimpleTagKey): List[Body] =
+          (bodyTags remove key) getOrElse Nil
+
+        def allSymsOneTag(key: TagKey): Map[String, Body] = {
+          val keys: Seq[SymbolTagKey] =
+            bodyTags.keys.toSeq flatMap {
+              case stk: SymbolTagKey if (stk.name == key.name) => Some(stk)
+              case stk: SimpleTagKey if (stk.name == key.name) =>
+                reporter.warning(pos, "Tag '@" + stk.name + "' must be followed by a symbol name")
+                None
+              case _ => None
+            }
+          val pairs: Seq[(String, Body)] =
+            for (key <- keys) yield {
+              val bs = (bodyTags remove key).get
+              if (bs.length > 1)
+                reporter.warning(pos, "Only one '@" + key.name + "' tag for symbol " + key.symbol + " is allowed")
+              (key.symbol, bs.head)
             }
+          Map.empty[String, Body] ++ pairs
+        }
 
-          def allTags(key: SimpleTagKey): List[Body] =
-            (bodyTags remove key) getOrElse Nil
-
-          def allSymsOneTag(key: TagKey): Map[String, Body] = {
-            val keys: Seq[SymbolTagKey] =
-              bodyTags.keys.toSeq flatMap {
-                case stk: SymbolTagKey if (stk.name == key.name) => Some(stk)
-                case stk: SimpleTagKey if (stk.name == key.name) =>
-                  reporter.warning(pos, "Tag '@" + stk.name + "' must be followed by a symbol name")
-                  None
-                case _ => None
-              }
-            val pairs: Seq[(String, Body)] =
-              for (key <- keys) yield {
-                val bs = (bodyTags remove key).get
-                if (bs.length > 1)
-                  reporter.warning(pos, "Only one '@" + key.name + "' tag for symbol " + key.symbol + " is allowed")
-                (key.symbol, bs.head)
-              }
-            Map.empty[String, Body] ++ pairs
-          }
+        val com = createComment (
+          body0        = Some(parseWiki(docBody, pos)),
+          authors0     = allTags(SimpleTagKey("author")),
+          see0         = allTags(SimpleTagKey("see")),
+          result0      = oneTag(SimpleTagKey("return")),
+          throws0      = allSymsOneTag(SimpleTagKey("throws")),
+          valueParams0 = allSymsOneTag(SimpleTagKey("param")),
+          typeParams0  = allSymsOneTag(SimpleTagKey("tparam")),
+          version0     = oneTag(SimpleTagKey("version")),
+          since0       = oneTag(SimpleTagKey("since")),
+          todo0        = allTags(SimpleTagKey("todo")),
+          deprecated0  = oneTag(SimpleTagKey("deprecated")),
+          note0        = allTags(SimpleTagKey("note")),
+          example0     = allTags(SimpleTagKey("example")),
+          constructor0 = oneTag(SimpleTagKey("constructor")),
+          source0      = Some(clean(src).mkString("\n"))
+        )
 
-          val com = createComment (
-            body0        = Some(parseWiki(docBody, pos)),
-            authors0     = allTags(SimpleTagKey("author")),
-            see0         = allTags(SimpleTagKey("see")),
-            result0      = oneTag(SimpleTagKey("return")),
-            throws0      = allSymsOneTag(SimpleTagKey("throws")),
-            valueParams0 = allSymsOneTag(SimpleTagKey("param")),
-            typeParams0  = allSymsOneTag(SimpleTagKey("tparam")),
-            version0     = oneTag(SimpleTagKey("version")),
-            since0       = oneTag(SimpleTagKey("since")),
-            todo0        = allTags(SimpleTagKey("todo")),
-            deprecated0  = oneTag(SimpleTagKey("deprecated")),
-            note0        = allTags(SimpleTagKey("note")),
-            example0     = allTags(SimpleTagKey("example")),
-            constructor0 = oneTag(SimpleTagKey("constructor")),
-            source0      = Some(clean(src).mkString("\n"))
-          )
-
-          for ((key, _) <- bodyTags)
-            reporter.warning(pos, "Tag '@" + key.name + "' is not recognised")
-
-          com
+        for ((key, _) <- bodyTags)
+          reporter.warning(pos, "Tag '@" + key.name + "' is not recognised")
+
+        com
 
-      }
     }
 
     parse0("", Map.empty, None, clean(comment), false)