Fix packages not ending up in `packages` map in Phases.scala

6 files changed, 58 insertions, 58 deletions

diff --git a/dottydoc/js/src/html/Layout.scala b/dottydoc/js/src/html/Layout.scala
index 77f405576..868e5b71a 100644
--- a/dottydoc/js/src/html/Layout.scala
+++ b/dottydoc/js/src/html/Layout.scala
@@ -12,7 +12,12 @@ object IndexLayout {
   import CustomTags._
   import MemberLayout._
 
-  def layout(m: Entity) = div(
+  def layout(m: Entity) = m match {
+    case p: Package => h1(s"Package: ${p.name}")
+    case e => entity(e)
+  }
+
+  def entity(m: Entity) = div(
     cls := "mdl-layout mdl-js-layout mdl-layout--fixed-drawer",
     div(
       cls := "mdl-layout__drawer",
@@ -27,7 +32,7 @@ object IndexLayout {
       nav(
         cls := "related mdl-navigation",
         companion(m),
-        a(cls := "mdl-navigation__link", href := m.sourceUrl, "Source")
+        a(cls := "mdl-navigation__link", href := "#", "Source")
       ),
       span(
         cls := "mdl-layout-title",
@@ -78,7 +83,7 @@ object IndexLayout {
       keys.flatMap { k =>
         val pack = Index.packages(k)
         (a(cls := "mdl-navigation__link package", href := relativePath(pack), k) ::
-        pack.children.sortBy(_.name).map { c =>
+        pack.children.sortBy(_.name).filter(_.kind == "package").map { c =>
           a(cls := "mdl-navigation__link entity", href := relativePath(c), c.name)
         })
       }
diff --git a/dottydoc/js/src/html/Member.scala b/dottydoc/js/src/html/Member.scala
index 9dc5d4da2..57c66ea62 100644
--- a/dottydoc/js/src/html/Member.scala
+++ b/dottydoc/js/src/html/Member.scala
@@ -55,7 +55,7 @@ object MemberLayout {
           fullComment
         )
         Seq(divs)
-      case _ => Nil
+      case x => Seq(h1("ERROR: " + x.name))
     }
   }
 
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/DottyDoc.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/DottyDoc.scala
index 61c49eaf0..428bc17d8 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/DottyDoc.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/DottyDoc.scala
@@ -25,7 +25,7 @@ import scala.util.control.NonFatal
  *    4. Deserialize on client side with Scala.js
  *    5. Serve content using Scala.js
  */
-case object DottyDocCompiler extends Compiler {
+class DottyDocCompiler extends Compiler {
   override def phases: List[List[Phase]] =
     List(new FrontEnd) ::
     List(new DocPhase) ::
@@ -56,7 +56,7 @@ class DocRun(comp: Compiler)(implicit ctx: Context) extends Run(comp)(ctx) {
   )
 }
 
-object DottyDoc extends Driver {
+trait DottyDoc extends Driver {
   override def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
     val ctx     = rootCtx.fresh
     val summary = CompilerCommand.distill(args)(ctx)
@@ -68,5 +68,7 @@ object DottyDoc extends Driver {
     (fileNames, ctx)
   }
 
-  override def newCompiler(implicit ctx: Context): Compiler = DottyDocCompiler
+  override def newCompiler(implicit ctx: Context): Compiler = new DottyDocCompiler
 }
+
+object Main extends DottyDoc
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
index 2d3496f6f..cfbf67ecd 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
@@ -23,7 +23,7 @@ object Phases {
 
     def phaseName = "docphase"
 
-    private[this] var commentCache: Map[Entity, (Entity, Map[String, Package]) => Option[Comment]] = Map.empty
+    private[this] var commentCache: Map[String, (Entity, Map[String, Package]) => Option[Comment]] = Map.empty
 
     /** Saves the commentParser function for later evaluation, for when the AST has been filled */
     def track(symbol: Symbol, ctx: Context)(op: => Entity) = {
@@ -33,54 +33,45 @@ object Phases {
         wikiParser.parseHtml(symbol, entity, packs)(ctx)
       }
 
-      entity match {
-        case p: Package =>
-          val path = p.path.mkString(".")
-          commentCache = commentCache + (packages.get(path).map { ex =>
-            val children = (ex.children ::: p.children).distinct.sortBy(_.name)
-            Package(p.name, children, p.path, None)
-          }.getOrElse(p) -> commentParser)
-        case _ =>
-          commentCache = commentCache + (entity -> commentParser)
-      }
-
-
+      commentCache = commentCache + (entity.path.mkString(".") -> commentParser)
       entity
     }
 
     /** Build documentation hierarchy from existing tree */
-    def collect(tree: Tree)(implicit ctx: Context): Entity = track(tree.symbol, ctx) {
+    def collect(tree: Tree, prev: List[String] = Nil)(implicit ctx: Context): Entity = track(tree.symbol, ctx) {
 
-      def collectList(xs: List[Tree])(implicit ctx: Context): List[Entity] =
-        xs.map(collect).filter(_ != NonEntity)
+      def collectList(xs: List[Tree], ps: List[String])(implicit ctx: Context): List[Entity] =
+        xs.map(collect(_, ps)).filter(_ != NonEntity)
 
-      def collectPackageMembers(xs: List[Tree])(implicit ctx: Context): List[PackageMember] =
-        collectList(xs).asInstanceOf[List[PackageMember]]
+      def collectEntityMembers(xs: List[Tree], ps: List[String])(implicit ctx: Context): List[EntityMember] =
+        collectList(xs, ps).asInstanceOf[List[EntityMember]]
 
-      def collectMembers(tree: Tree)(implicit ctx: Context): List[Entity] = tree match {
-        case t: Template => collectList(t.body)
+      def collectMembers(tree: Tree, ps: List[String] = prev)(implicit ctx: Context): List[Entity] = tree match {
+        case t: Template => collectList(t.body, ps)
         case _ => Nil
       }
 
       tree match {
         /** package */
-        case p @ PackageDef(pid, st) =>
-          val name = pid.name.toString
-          Package(name, collectPackageMembers(st), path(p))
+        case pd @ PackageDef(pid, st) =>
+          val newPath = prev :+ pid.name.toString
+          addEntity(Package(newPath.mkString("."), collectEntityMembers(st, newPath), newPath))
 
         /** trait */
         case t @ TypeDef(n, rhs) if t.symbol.is(Flags.Trait) =>
           val name = n.toString
-          Trait(name, collectMembers(rhs), flags(t), path(t))
+          val newPath = prev :+ name
+          Trait(name, collectMembers(rhs), flags(t), newPath)
 
         /** objects, on the format "Object$" so drop the last letter */
         case o @ TypeDef(n, rhs) if o.symbol.is(Flags.Module) =>
           val name = n.toString.dropRight(1)
-          Object(name, collectMembers(rhs),  flags(o), path(o))
+          Object(name, collectMembers(rhs, prev :+ name),  flags(o), prev :+ (name + "$"))
 
         /** class / case class */
         case c @ TypeDef(name, rhs) if c.symbol.isClass =>
-          (name.toString, collectMembers(rhs), flags(c), path(c), None) match {
+          val newPath = prev :+ name.toString
+          (name.toString, collectMembers(rhs), flags(c), newPath, None) match {
             case x if c.symbol.is(Flags.CaseClass) => CaseClass.tupled(x)
             case x => Class.tupled(x)
           }
@@ -94,7 +85,7 @@ object Phases {
           Val(v.name.toString, flags(v), path(v), returnType(v.tpt))
 
         case x => {
-          //dottydoc.println(s"Found unwanted entity: $x (${x.pos}, ${comment})\n${x.show}")
+          //dottydoc.println(s"Found unwanted entity: $x (${x.pos},\n${x.show}")
           NonEntity
         }
       }
@@ -102,19 +93,19 @@ object Phases {
 
     var packages: Map[String, Package] = Map.empty
 
-    def addEntity(p: Package): Unit = {
-      val path = p.path.mkString(".")
-      packages = packages + (path -> packages.get(path).map { ex =>
+    def addEntity(p: Package): Package = {
+      val path    = p.path.mkString(".")
+      val newPack = packages.get(path).map { ex =>
         val children = (ex.children ::: p.children).distinct.sortBy(_.name)
         Package(p.name, children, p.path, None)
-      }.getOrElse(p))
+      }.getOrElse(p)
+
+      packages = packages + (path -> newPack)
+      newPack
     }
 
     override def run(implicit ctx: Context): Unit =
-      collect(ctx.compilationUnit.tpdTree) match {
-        case p: Package => addEntity(p)
-        case _ => ()
-      }
+      collect(ctx.compilationUnit.tpdTree) // Will put packages in `packages` var
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
       // (1) Create package structure for all `units`, this will give us a complete structure
@@ -150,13 +141,13 @@ object Phases {
       // (3) Create documentation template from docstrings, with internal links
       packages.values.foreach { p =>
         mutateEntities(p) {
-          case e: Package   => e.comment = commentCache(e)(e, packages)
-          case e: Class     => e.comment = commentCache(e)(e, packages)
-          case e: CaseClass => e.comment = commentCache(e)(e, packages)
-          case e: Object    => e.comment = commentCache(e)(e, packages)
-          case e: Trait     => e.comment = commentCache(e)(e, packages)
-          case e: Val       => e.comment = commentCache(e)(e, packages)
-          case e: Def       => e.comment = commentCache(e)(e, packages)
+          case e: Package   => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: Class     => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: CaseClass => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: Object    => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: Trait     => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: Val       => e.comment = commentCache(e.path.mkString("."))(e, packages)
+          case e: Def       => e.comment = commentCache(e.path.mkString("."))(e, packages)
           case _ => ()
         }
       }
@@ -166,7 +157,8 @@ object Phases {
 
 
       // (5) Clear caches
-      commentCache = Map.empty
+      // TODO: enable me!
+      //commentCache = Map.empty
 
       // Return super's result
       compUnits
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
index a911f05ca..6346bee20 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
@@ -7,14 +7,17 @@ object IndexWriters {
   import model.Html._
 
   def writeJs(packs: Map[String, Package], outPath: String): Unit = {
-    for ((_, pack) <- packs) {
+    for (pack <- packs.values) {
       println(s"""Writing '${pack.path.mkString(".")}'""")
       writeFile(
         entityHtml(pack),
-        outPath + pack.path.tail.mkString("/", "/", "/"),
+        outPath + pack.path.mkString("/", "/", "/"),
         "index.html")
 
-      for (child <- pack.children) {
+      for {
+        child <- pack.children
+        if child.kind != "package"
+      } {
         println(s"""Writing '${child.path.mkString(".")}'""")
         writeFile(
           entityHtml(child),
diff --git a/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/Entity.scala b/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/Entity.scala
index 5acdfee33..f95190578 100644
--- a/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/Entity.scala
+++ b/dottydoc/shared/src/main/scala/dotty/tools/dottydoc/model/Entity.scala
@@ -6,7 +6,7 @@ import comment.Comment
 object Entities {
   import prickle._
 
-  type PackageMember = Entity with Members with Modifiers
+  type EntityMember = Entity with Members
 
   sealed trait Entity {
     def name: String
@@ -16,8 +16,6 @@ object Entities {
 
     def comment: Option[Comment]
 
-    def sourceUrl: String = "#"
-
     def kind: String
 
     def parent: Option[Entity]
@@ -47,8 +45,8 @@ object Entities {
     override val kind = "package"
 
     var parent: Option[Entity] = None
-    val children: List[PackageMember] =
-      members.collect { case x: PackageMember => x }
+    val children: List[EntityMember] =
+      members.collect { case x: EntityMember => x }
   }
 
   final case class Class(