3 files changed, 40 insertions, 16 deletions

diff --git a/dottydoc/src/dotty/tools/dottydoc/core/UsecasePhase.scala b/dottydoc/src/dotty/tools/dottydoc/core/UsecasePhase.scala
index 758d65e92..4d9c0abbd 100644
--- a/dottydoc/src/dotty/tools/dottydoc/core/UsecasePhase.scala
+++ b/dottydoc/src/dotty/tools/dottydoc/core/UsecasePhase.scala
@@ -13,7 +13,7 @@ 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,
+    d.name.show.split("\\$").head, // UseCase defs get $pos appended to their names
     flags(d), path(d.symbol),
     returnType(d.tpt.tpe),
     typeParams(d.symbol),
diff --git a/dottydoc/test/UsecaseTest.scala b/dottydoc/test/UsecaseTest.scala
index e2190e709..d5f338892 100644
--- a/dottydoc/test/UsecaseTest.scala
+++ b/dottydoc/test/UsecaseTest.scala
@@ -29,9 +29,9 @@ class UsecaseTest extends DottyTest {
     checkSources(source :: Nil) { packages =>
       packages("scala") match {
         case PackageImpl(_, _, List(trt: Trait), _, _) =>
-          val List(map: Def) = trt.members
+          val List(foo: Def) = trt.members
 
-          val returnValue = map.returnValue match {
+          val returnValue = foo.returnValue match {
             case ref: TypeReference => ref.title
             case _ =>
               assert(
@@ -42,11 +42,22 @@ class UsecaseTest extends DottyTest {
           }
 
           assert(
-            map.typeParams.isEmpty,
+            foo.typeParams.isEmpty,
             "Type parameters were not stripped by usecase"
           )
           assert(returnValue == "A", "Incorrect return type after usecase")
+
+          assert(foo.name == "foo", s"Incorrect name after transform: ${foo.name}")
       }
     }
   }
+
+  @Test def checkIterator = {
+    val sources =
+      "./scala-scala/src/library/scala/collection/Iterator.scala" :: Nil
+
+    checkFiles(sources) { packages =>
+      // success if typer throws no errors! :)
+    }
+  }
 }
diff --git a/src/dotty/tools/dotc/core/Comments.scala b/src/dotty/tools/dotc/core/Comments.scala
index bf1f25537..0a57d331a 100644
--- a/src/dotty/tools/dotc/core/Comments.scala
+++ b/src/dotty/tools/dotc/core/Comments.scala
@@ -8,7 +8,7 @@ import Symbols._
 import Contexts.Context
 import Flags.EmptyFlags
 import dotc.util.SourceFile
-import dotc.util.Positions.Position
+import dotc.util.Positions._
 import dotc.parsing.Parsers.Parser
 import dotty.tools.dottydoc.model.comment.CommentUtils._
 
@@ -38,14 +38,22 @@ object Comments {
     private def decomposeUseCase(start: Int, end: Int): UseCase = {
       val codeStart    = skipWhitespace(raw, start + "@usecase".length)
       val codeEnd      = skipToEol(raw, codeStart)
-      val code         = raw.substring(codeStart, codeEnd)
-      val codePos      = Position(codeStart, codeEnd)
+      val code         = raw.substring(codeStart, codeEnd) + " = ???"
+      val codePos      = subPos(codeStart, codeEnd)
       val commentStart = skipLineLead(raw, codeEnd + 1) min end
       val comment      = "/** " + raw.substring(commentStart, end) + "*/"
-      val commentPos   = Position(commentStart, end)
+      val commentPos   = subPos(commentStart, end)
 
-      UseCase(Comment(commentPos, comment), code + " = ???", codePos)
+      UseCase(Comment(commentPos, comment), code, codePos)
     }
+
+    private def subPos(start: Int, end: Int) =
+      if (pos == NoPosition) NoPosition
+      else {
+        val start1 = pos.start + start
+        val end1 = pos.end + end
+        pos withStart start1 withPoint start1 withEnd end1
+      }
   }
 
   case class UseCase(comment: Comment, code: String, codePos: Position)(implicit ctx: Context) {
@@ -56,9 +64,11 @@ object Comments {
       val tree = new Parser(new SourceFile("<usecase>", code)).localDef(codePos.start, EmptyFlags)
 
       tree match {
-        case tree: untpd.DefDef => tree
+        case tree: untpd.DefDef =>
+          val newName = (tree.name.show + "$" + codePos.start).toTermName
+          untpd.DefDef(newName, tree.tparams, tree.vparamss, tree.tpt, tree.rhs)
         case _ =>
-          ctx.error("proper def was not found in `@usecase`", codePos)
+          ctx.error("proper definition was not found in `@usecase`", codePos)
           tree
       }
     }
@@ -67,11 +77,14 @@ object Comments {
     var tpdCode: tpd.DefDef = _
 
     def typeTree()(implicit ctx: Context): Unit = untpdCode match {
-      case df: untpd.DefDef => ctx.typer.typedDefDef(df, symbol) match {
-        case tree: tpd.DefDef => tpdCode = tree
-        case _ => ctx.error("proper def was not found in `@usecase`", codePos)
-      }
-      case _ => ctx.error("proper def was not found in `@usecase`", codePos)
+      case df: untpd.DefDef =>
+        ctx.typer.typedDefDef(df, symbol) match {
+          case tree: tpd.DefDef => tpdCode = tree
+          case _ =>
+            ctx.error("proper def could not be typed from `@usecase`", codePos)
+        }
+      case _ =>
+        ctx.error("proper def was not found in `@usecase`", codePos)
     }
   }
 }