Merge pull request #2392 from vigdorchik/ticket/si-7367

SI-7367 scaladoc crash on constructing the model for annotations.

2 files changed, 29 insertions, 27 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 0a469c9227..d9b173bc43 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -897,32 +897,36 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     }
   }
 
-  /** */
   def makeAnnotation(annot: AnnotationInfo): scala.tools.nsc.doc.model.Annotation = {
     val aSym = annot.symbol
     new EntityImpl(aSym, makeTemplate(aSym.owner)) with scala.tools.nsc.doc.model.Annotation {
       lazy val annotationClass =
         makeTemplate(annot.symbol)
-      val arguments = { // lazy
-        def noParams = annot.args map { _ => None }
-        val params: List[Option[ValueParam]] = annotationClass match {
+      val arguments = {
+        val paramsOpt: Option[List[ValueParam]] = annotationClass match {
           case aClass: DocTemplateEntity with Class =>
-            (aClass.primaryConstructor map { _.valueParams.head }) match {
-              case Some(vps) => vps map { Some(_) }
-              case None => noParams
+            val constr = aClass.constructors collectFirst {
+              case c: MemberImpl if c.sym == annot.original.symbol => c
             }
-          case _ => noParams
+            constr flatMap (_.valueParams.headOption)
+          case _ => None
         }
-        assert(params.length == annot.args.length)
-        (params zip annot.args) flatMap { case (param, arg) =>
-          makeTree(arg) match {
-            case Some(tree) =>
-              Some(new ValueArgument {
-                def parameter = param
+        val argTrees = annot.args map makeTree
+        paramsOpt match {
+          case Some (params) =>
+            params zip argTrees map { case (param, tree) =>
+              new ValueArgument {
+                def parameter = Some(param)
                 def value = tree
-              })
-            case None => None
-          }
+              }
+            }
+          case None => 
+            argTrees map { tree =>
+              new ValueArgument {
+                def parameter = None
+                def value = tree
+              }
+            }
         }
       }
     }
@@ -962,9 +966,8 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
                 sym.name == aSym.name &&
                 sym.isParamWithDefault
               )
-              (unit.body find (t => isCorrespondingParam(t.symbol))) match {
-                case Some(ValDef(_,_,_,rhs)) => makeTree(rhs)
-                case _ => None
+              unit.body find (t => isCorrespondingParam(t.symbol)) collect {
+                case ValDef(_,_,_,rhs) if rhs ne EmptyTree  => makeTree(rhs)
               }
             case _ => None
           }
diff --git a/src/compiler/scala/tools/nsc/doc/model/TreeFactory.scala b/src/compiler/scala/tools/nsc/doc/model/TreeFactory.scala
index bd7534ded4..fdad84d0bc 100755
--- a/src/compiler/scala/tools/nsc/doc/model/TreeFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/TreeFactory.scala
@@ -19,7 +19,7 @@ trait TreeFactory { thisTreeFactory: ModelFactory with TreeFactory =>
   val global: Global
   import global._
 
-  def makeTree(rhs: Tree): Option[TreeEntity] = {
+  def makeTree(rhs: Tree): TreeEntity = {
 
     var expr = new StringBuilder
     var refs = new immutable.TreeMap[Int, (Entity, Int)] // start, (Entity to be linked to , end)
@@ -80,17 +80,16 @@ trait TreeFactory { thisTreeFactory: ModelFactory with TreeFactory =>
 
         traverser.traverse(rhs)
 
-        Some(new TreeEntity {
+        new TreeEntity {
           val expression = expr.toString
           val refEntity = refs
-        })
+        }
       }
-      case pos: OffsetPosition =>
-        Some(new TreeEntity {
+      case _ =>
+        new TreeEntity {
           val expression = rhs.toString
           val refEntity = new immutable.TreeMap[Int, (Entity, Int)]
-        })
-      case _ => None
+        }
     }
   }
 }