Dottydoc: Show implicit modifier in implicit function types

doc-tool/src/dotty/tools/dottydoc/core/TypeLinkingPhases.scala

@@ -106,7 +106,7 @@ trait TypeLinker extends MemberLookup {
         ref.copy(left = linkReference(ent, left, packs), right = linkReference(ent, right, packs))
       case ref @ NamedReference(_, rf, _, _) =>
         ref.copy(ref = linkRef(rf))
-      case ref @ FunctionReference(args, rv) =>
+      case ref @ FunctionReference(args, rv, _) =>
         ref.copy(args = args.map(linkReference(ent, _, packs)), returnValue = linkReference(ent, rv, packs))
       case ref @ TupleReference(args) =>
         ref.copy(args = args.map(linkRef))

doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala

@@ -74,10 +74,11 @@ object JavaConverters {
         "scala" -> ref
       ).asJava
 
-      case FunctionReference(args, returnValue) => Map(
+      case FunctionReference(args, returnValue, isImplicit) => Map(
         "kind" -> "FunctionReference",
         "args" -> args.map(_.asJava).asJava,
         "returnValue" -> returnValue.asJava,
+        "isImplicit" -> isImplicit,
         "scala" -> ref
       ).asJava
 
@@ -273,15 +274,15 @@ object JavaConverters {
           e.paramLists.map { paramList =>
             Map(
               "isImplicit" -> paramList.isImplicit,
-              "list" -> paramList.list.map(_.showReference).asJava
+              "list" -> paramList.list.map(_.asJava).asJava
             ).asJava
           }
           .asJava
         }
       )
 
       def returnValue(e: ReturnValue) =
-        Map("returnValue" -> e.returnValue.showReference)
+        Map("returnValue" -> e.returnValue.asJava)
 
       entity(e) ++ (e match {
         case e: Package   => members(e)

doc-tool/src/dotty/tools/dottydoc/model/factories.scala

@@ -64,7 +64,7 @@ object factories {
         val cls = tycon.typeSymbol
 
         if (defn.isFunctionClass(cls))
-          FunctionReference(args.init.map(expandTpe(_, Nil)), expandTpe(args.last))
+          FunctionReference(args.init.map(expandTpe(_, Nil)), expandTpe(args.last), defn.isImplicitFunctionClass(cls))
         else if (defn.isTupleClass(cls))
           TupleReference(args.map(expandTpe(_, Nil)))
         else {

doc-tool/src/dotty/tools/dottydoc/model/references.scala

@@ -6,7 +6,7 @@ object references {
   final case class TypeReference(title: String, tpeLink: MaterializableLink, paramLinks: List[Reference]) extends Reference
   final case class OrTypeReference(left: Reference, right: Reference) extends Reference
   final case class AndTypeReference(left: Reference, right: Reference) extends Reference
-  final case class FunctionReference(args: List[Reference], returnValue: Reference) extends Reference
+  final case class FunctionReference(args: List[Reference], returnValue: Reference, isImplicit: Boolean) extends Reference
   final case class TupleReference(args: List[Reference]) extends Reference
   final case class BoundsReference(low: Reference, high: Reference) extends Reference
   final case class NamedReference(title: String, ref: Reference, isByName: Boolean = false, isRepeated: Boolean = false) extends Reference
@@ -27,43 +27,4 @@ object references {
     })
   }
   final case class NoLink(title: String, target: String) extends MaterializableLink
-
-  implicit class ReferenceShower(val ref: Reference) extends AnyVal {
-    def showReference: String = ref match {
-      case TypeReference(title, _, tparams) =>
-        title + {
-          if (tparams.nonEmpty) tparams.map(_.showReference).mkString("[", ",", "]")
-          else ""
-        }
-
-      case OrTypeReference(left, right) =>
-        left.showReference + " | " + right.showReference
-      case AndTypeReference(left, right) =>
-        left.showReference + " & " + right.showReference
-
-      case FunctionReference(args, ret) =>
-        if (args.isEmpty)
-          "() => " + ret.showReference
-        else if (args.tail.isEmpty)
-          args.head.showReference + " => " + ret.showReference
-        else
-          args.mkString("(", ",", s") => ${ret.showReference}")
-
-      case TupleReference(xs) =>
-        xs.mkString("(", ",", ")")
-
-      case BoundsReference(lo, hi) =>
-        lo.showReference + "<: " + hi.showReference
-
-      case NamedReference(title, ref, isByName, isRepeated) =>
-        val byName = if (isByName) "=> " else ""
-        val repeated = if (isRepeated) "*" else ""
-        s"$title: $byName${ref.showReference}$repeated"
-
-      case ConstantReference(title) => title
-      case EmptyReference =>
-        assert(false, "unexpected empty reference")
-        "<empty reference>"
-    }
-  }
 }

doc-tool/src/dotty/tools/dottydoc/staticsite/tags.scala

@@ -85,13 +85,14 @@ object tags {
       case AndTypeReference(left, right) =>
         s"""${renderReference(left)}<span class="and-or-separator"> &amp; </span>${renderReference(right)}"""
 
-      case FunctionReference(args, returnValue) => {
+      case FunctionReference(args, returnValue, isImplicit) => {
+        val implicitPrefix = if (isImplicit) "implicit " else ""
         val params =
           if (args.isEmpty) "<span>() =&gt; </span>"
           else if (args.tail.isEmpty) renderReference(args.head) + """<span class="right-arrow"> =&gt; </span>"""
           else args.map(renderReference).mkString("<span>(</span>", "<span>, </span>", "<span>) =&gt; </span>")
 
-        params + renderReference(returnValue)
+        implicitPrefix + params + renderReference(returnValue)
       }
 
       case TupleReference(args) =>

doc-tool/test/JavaConverterTest.scala → doc-tool/test/dotty/tools/dottydoc/JavaConverterTest.scala

@@ -186,7 +186,8 @@ class JavaConverterTest {
       case AndTypeReference(left, right) =>
         assertSerializedCorrectly(left, actual.get("left"))
         assertSerializedCorrectly(right, actual.get("right"))
-      case FunctionReference(args, returnValue) =>
+      case FunctionReference(args, returnValue, isImplicit) =>
+        assertEquals(isImplicit, actual.get("isImplicit"))
         assertEach(args, actual.get("args")) { (exp, act) =>
           assertSerializedCorrectly(exp, act)
         }

doc-tool/test/dotty/tools/dottydoc/TypeRendering.scala

@@ -0,0 +1,51 @@
+package dotty.tools
+package dottydoc
+
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dottydoc.model._
+import dotty.tools.dottydoc.model.internal._
+import dotty.tools.dottydoc.model.references._
+
+import org.junit.Test
+import org.junit.Assert.{assertTrue, fail}
+
+class TypeRenderingTestFromTasty extends TypeRenderingTest with CheckFromTasty
+class TypeRenderingTestFromSource extends TypeRenderingTest with CheckFromSource
+abstract class TypeRenderingTest extends DottyDocTest {
+  @Test def renderImplicitFunctionType = {
+    val source = new SourceFile(
+      "ImplicitFunctionType.scala",
+      """
+      |package scala
+      |
+      |trait Test {
+      |  def a: implicit Int => Int = ???
+      |  def b(x: implicit Int => Int) = ???
+      |  type c = implicit Int => Int
+      |}
+      """.stripMargin
+    )
+
+    def checkImplicitFunctionType(ref: Reference) = ref match {
+      case FunctionReference(_, _, isImplicit) =>
+        assertTrue("Should be an implicit function type", isImplicit)
+      case _ =>
+        fail("Unexpected: " + ref)
+    }
+
+    checkFromSource(source :: Nil) { case (_, packages) =>
+      packages("scala") match {
+        case PackageImpl(_, _, _, List(trt: Trait), _, _, _, _) =>
+          val List(a: Def, b: Def, c: TypeAlias) = trt.members.sortBy(_.name)
+          checkImplicitFunctionType(a.returnValue)
+          b.paramLists.head.list.head match {
+            case NamedReference("x", ref, _, _) =>
+              checkImplicitFunctionType(ref)
+            case _ =>
+              fail("Unexpected: " + b.paramLists.head.list.head)
+          }
+          checkImplicitFunctionType(c.alias.get)
+      }
+    }
+  }
+}