Fix proper structure for paramlist links (clientside)

3 files changed, 58 insertions, 22 deletions

diff --git a/dottydoc/js/src/html/Member.scala b/dottydoc/js/src/html/Member.scala
index 4ab214fdb..a8da9d126 100644
--- a/dottydoc/js/src/html/Member.scala
+++ b/dottydoc/js/src/html/Member.scala
@@ -57,7 +57,7 @@ trait MemberLayout {
               m.name
             ),
             spanWith("member-type-params no-left-margin", typeParams(m)),
-            spanWith("member-param-list no-left-margin", paramList(m)),
+            span(cls := "member-param-list no-left-margin", paramList(m)),
             returnValue(m, parent)
           ),
           shortComment,
@@ -73,23 +73,63 @@ trait MemberLayout {
     case _  => Some(span(cls := clazz, contents))
   }
 
-  def paramList(m: Entity): String = m match {
+  def paramList(m: Entity): Span = m match {
     case d: Def if d.paramLists.nonEmpty =>
-      d.paramLists.map { xs =>
-        xs.map { tr =>
-          // FIXME: should not cast like this - it won't be guaranteed to be a
-          // TypeReference after Or/Types for paramlists have been implemented
-          tr.title + ": " + decodeLink(tr.ref.asInstanceOf[TypeReference].tpeLink)
-        }.mkString ("(", ", ", ")")
-      }.mkString("")
-    case _ => ""
+      span(
+        cls := "member-param-lists",
+        d.paramLists.map { xs =>
+          span(
+            cls := "param-list",
+            "(",
+            xs.flatMap { tr =>
+              Seq(
+                span(cls := "param-name", tr.title).render,
+                span(cls := "type-separator no-left-margin", ":").render,
+                span(referenceToLinks(tr.ref)).render,
+                span(cls := "type-separator no-left-margin", ",").render
+              )
+            }.dropRight(1),
+            ")"
+          ).render
+        }
+      ).render
+    case _ => span().render
   }
 
-  def decodeLink: MaterializableLink => String = {
-    case MaterializedLink(t, _) => t
-    case NoLink(t, _) => t
-    //FIXME: there should be no UnsetLinks - either MaterializedLink or NoLink
-    case UnsetLink(_, q) => q
+  def referenceToLinks(ref: Reference): Span = {
+    def linkToAnchor(link: MaterializableLink) = link match {
+      case MaterializedLink(t, url) => a(href := url, t).render
+      case NoLink(t, _) => span(t).render
+
+      //FIXME: there should be no UnsetLinks - either MaterializedLink or NoLink
+      case UnsetLink(_, q) => span(q).render
+    }
+
+    ref match {
+      case ref: TypeReference if ref.paramLinks.nonEmpty => span(
+        linkToAnchor(ref.tpeLink),
+        "[",
+        ref
+          .paramLinks
+          .map(linkToAnchor)
+          .flatMap(link => Seq(link, span(cls := "type-separator no-left-margin", ",").render))
+          .dropRight(1),
+        "]"
+      ).render
+      case ref: TypeReference => span(linkToAnchor(ref.tpeLink)).render
+
+      case OrTypeReference(left, right) => span(
+        referenceToLinks(left),
+        span(cls := "type-separator", "|"),
+        referenceToLinks(right)
+      ).render
+
+      case AndTypeReference(left, right) => span(
+        referenceToLinks(left),
+        span(cls := "type-separator", "&"),
+        referenceToLinks(right)
+      ).render
+    }
   }
 
   def typeParams(m: Entity): String = m match {
diff --git a/dottydoc/jvm/resources/index.css b/dottydoc/jvm/resources/index.css
index e68cf5ac5..47e0ea717 100644
--- a/dottydoc/jvm/resources/index.css
+++ b/dottydoc/jvm/resources/index.css
@@ -146,7 +146,7 @@ div.summary-comment {
     margin-left: 0;
 }
 
-span.member-return-value > span.type-separator {
+span.type-separator {
     margin: 0 10px;
 }
 
diff --git a/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/factories.scala b/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/factories.scala
index e6a548b0f..e8d453842 100644
--- a/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/factories.scala
+++ b/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/factories.scala
@@ -107,12 +107,8 @@ object factories {
   }
 
   def paramLists(t: DefDef)(implicit ctx: Context): List[List[NamedReference]] = {
-    def getParams(xs: List[ValDef]): List[NamedReference] = xs map { vd =>
-      val name = vd.name.decode.toString
-      //TODO: should not be a TypeReference but a Reference since the argument can be an Or/And-types
-      val ref  = TypeReference(name, UnsetLink(Text(vd.tpt.show), vd.tpt.show), Nil)
-      NamedReference(name, ref)
-    }
+    def getParams(xs: List[ValDef]): List[NamedReference] =
+      xs.map(vd => NamedReference(vd.name.decode.toString, returnType(vd.tpt)))
 
     t.vparamss.map(getParams)
   }