More retrofit of scaladoc model factory.

1 files changed, 14 insertions, 23 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 9f3e7db7d0..1013204816 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -191,7 +191,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
         case NullaryMethodType(res) => resultTpe(res)
         case _ => tpe
       }
-      val tpe = if (!isImplicitlyInherited) sym.tpe else byConversion.get.toType memberInfo sym
+      val tpe = byConversion.fold(sym.tpe) (_.toType memberInfo sym)
       makeTypeInTemplateContext(resultTpe(tpe), inTemplate, sym)
     }
     def isDef = false
@@ -429,12 +429,12 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
       conversions flatMap (conv =>
         if (!implicitExcluded(conv.conversionQualifiedName))
           conv.targetTypeComponents map {
-            case pair@(template, tpe) =>
+            case (template, tpe) =>
               template match {
                 case d: DocTemplateImpl if (d != this) => d.registerImplicitlyConvertibleClass(this, conv)
                 case _ => // nothing
               }
-              (pair._1, pair._2, conv)
+              (template, tpe, conv)
           }
         else List()
       )
@@ -483,23 +483,14 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def inheritanceDiagram = makeInheritanceDiagram(this)
     def contentDiagram = makeContentDiagram(this)
 
-    def groupSearch[T](extractor: Comment => T, default: T): T = {
-      // query this template
-      for (c <- comment) {
-        val entity = extractor(c)
-        if (entity != default) return entity
-      }
-      // query linearization
-      for (tpl <- linearizationTemplates.collect{ case dtpl: DocTemplateImpl if dtpl!=this => dtpl}) {
-        val entity = tpl.groupSearch(extractor, default)
-        if (entity != default) return entity
-      }
-      default
+    def groupSearch[T](extractor: Comment => Option[T]): Option[T] = {
+      val comments = comment +: linearizationTemplates.collect { case dtpl: DocTemplateImpl => dtpl.comment }
+      comments.flatten.map(extractor).flatten.headOption
     }
 
-    def groupDescription(group: String): Option[Body] = groupSearch(_.groupDesc.get(group), None)
-    def groupPriority(group: String): Int = groupSearch(_.groupPrio.get(group) match { case Some(prio) => prio; case _ => 0 }, 0)
-    def groupName(group: String): String = groupSearch(_.groupNames.get(group) match { case Some(name) => name; case _ => group }, group)
+    def groupDescription(group: String): Option[Body] = groupSearch(_.groupDesc.get(group))
+    def groupPriority(group: String): Int = groupSearch(_.groupPrio.get(group)) getOrElse 0
+    def groupName(group: String): String = groupSearch(_.groupNames.get(group)) getOrElse group
   }
 
   abstract class PackageImpl(sym: Symbol, inTpl: PackageImpl) extends DocTemplateImpl(sym, inTpl) with Package {
@@ -554,7 +545,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
                                             useCaseOf: Option[MemberEntity], inTpl: DocTemplateImpl)
            extends NonTemplateMemberImpl(sym, conversion, useCaseOf, inTpl) {
     def valueParams = {
-      val info = if (!isImplicitlyInherited) sym.info else conversion.get.toType memberInfo sym
+      val info = conversion.fold(sym.info)(_.toType memberInfo sym)
       info.paramss map { ps => (ps.zipWithIndex) map { case (p, i) =>
         if (p.nameString contains "$") makeValueParam(p, inTpl, optimize("arg" + i)) else makeValueParam(p, inTpl)
       }}
@@ -967,10 +958,10 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
       val ignoreParents = Set[Symbol](AnyClass, AnyRefClass, ObjectClass)
       val filtParents =
         // we don't want to expose too many links to AnyRef, that will just be redundant information
-        if (tpl.isDefined && { val sym = tpl.get.sym; (!sym.isModule && parents.length < 2) || (sym == AnyValClass) || (sym == AnyRefClass) || (sym == AnyClass) })
-          parents
-        else
-          parents.filterNot((p: Type) => ignoreParents(p.typeSymbol))
+        tpl match {
+          case Some(tpl) if (!tpl.sym.isModule && parents.length < 2) || (tpl.sym == AnyValClass) || (tpl.sym == AnyRefClass) || (tpl.sym == AnyClass) => parents
+          case _ => parents.filterNot((p: Type) => ignoreParents(p.typeSymbol))
+        }
 
       /** Returns:
        *   - a DocTemplate if the type's symbol is documented