Add UsecasePhase to dottydoc

Author: felixmulder

dottydoc/src/dotty/tools/dottydoc/DottyDoc.scala

@@ -31,7 +31,8 @@ class DocCompiler extends Compiler {
     List(new DocFrontEnd),
     List(new DocImplicitsPhase),
     List(new DocASTPhase),
-    List(DocMiniTransformations(new LinkReturnTypes,
+    List(DocMiniTransformations(new UsecasePhase,
+                                new LinkReturnTypes,
                                 new LinkParamListTypes,
                                 new LinkImplicitlyAddedTypes,
                                 new LinkSuperTypes,

dottydoc/src/dotty/tools/dottydoc/core/UsecasePhase.scala

@@ -0,0 +1,26 @@
+package dotty.tools
+package dottydoc
+package core
+
+import dotc.core.Contexts.Context
+import dotc.ast.tpd
+
+import transform.DocMiniPhase
+import model.internal._
+import model.factories._
+import dotty.tools.dotc.core.Symbols.Symbol
+
+class UsecasePhase extends DocMiniPhase {
+  private def defdefToDef(d: tpd.DefDef, sym: Symbol)(implicit ctx: Context) = DefImpl(
+    sym,
+    d.name.decode.toString,
+    flags(d), path(d.symbol),
+    returnType(d.tpt.tpe),
+    typeParams(d.symbol),
+    paramLists(d.symbol.info)
+  )
+
+  override def transformDef(implicit ctx: Context) = { case df: DefImpl =>
+    ctx.docbase.docstring(df.symbol).flatMap(_.usecases.headOption.map(_.tpdCode)).map(defdefToDef(_, df.symbol)).getOrElse(df)
+  }
+}

dottydoc/test/UsecaseTest.scala

@@ -0,0 +1,52 @@
+package dotty.tools
+package dottydoc
+
+import org.junit.Test
+import org.junit.Assert._
+
+import dotc.util.SourceFile
+import model._
+import model.internal._
+import model.references._
+
+class UsecaseTest extends DottyTest {
+  @Test def simpleUsecase = {
+    val source = new SourceFile(
+      "DefWithUseCase.scala",
+      """
+      |package scala
+      |
+      |trait Test[A] {
+      |  /** Definition with a "disturbing" signature
+      |   *
+      |   *  @usecase def foo: A
+      |   */
+      |  def foo[B]: A => B
+      |}
+      """.stripMargin
+    )
+
+    checkSources(source :: Nil) { packages =>
+      packages("scala") match {
+        case PackageImpl(_, _, List(trt: Trait), _, _) =>
+          val List(map: Def) = trt.members
+
+          val returnValue = map.returnValue match {
+            case ref: TypeReference => ref.title
+            case _ =>
+              assert(
+                false,
+                "Incorrect return value after usecase transformation"
+              )
+              ""
+          }
+
+          assert(
+            map.typeParams.isEmpty,
+            "Type parameters were not stripped by usecase"
+          )
+          assert(returnValue == "A", "Incorrect return type after usecase")
+      }
+    }
+  }
+}