Split implementation to internal mutable and external interface

9 files changed, 89 insertions, 71 deletions

diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
index a0235e7c6..1670313e1 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/core/Phases.scala
@@ -15,11 +15,13 @@ object Phases {
   class DocPhase extends Phase {
     import model.comment.Comment
     import model.CommentParsers.wikiParser
-    import model.Entities._
-    import model.EntityFactories._
+    import model.factories._
+    import model._
+    import model.internal._
     import dotty.tools.dotc.core.Flags
     import dotty.tools.dotc.ast.tpd._
-    import util.Traversing._
+    import util.traversing._
+    import util.internal.setters._
 
     def phaseName = "docphase"
 
@@ -29,11 +31,13 @@ object Phases {
     def track(symbol: Symbol, ctx: Context)(op: => Entity) = {
       val entity = op
 
-      val commentParser = { (entity: Entity, packs: Map[String, Package]) =>
-        wikiParser.parseHtml(symbol, entity, packs)(ctx)
-      }
+      if (entity != NonEntity) {
+        val commentParser = { (entity: Entity, packs: Map[String, Package]) =>
+          wikiParser.parseHtml(symbol, entity, packs)(ctx)
+        }
 
-      commentCache = commentCache + (entity.path.mkString(".") -> commentParser)
+        commentCache = commentCache + (entity.path.mkString(".") -> commentParser)
+      }
       entity
     }
 
@@ -43,8 +47,8 @@ object Phases {
       def collectList(xs: List[Tree], ps: List[String])(implicit ctx: Context): List[Entity] =
         xs.map(collect(_, ps)).filter(_ != NonEntity)
 
-      def collectEntityMembers(xs: List[Tree], ps: List[String])(implicit ctx: Context): List[EntityMember] =
-        collectList(xs, ps).asInstanceOf[List[EntityMember]]
+      def collectEntityMembers(xs: List[Tree], ps: List[String])(implicit ctx: Context) =
+        collectList(xs, ps).asInstanceOf[List[Entity with Members]]
 
       def collectMembers(tree: Tree, ps: List[String] = prev)(implicit ctx: Context): List[Entity] = tree match {
         case t: Template => collectList(t.body, ps)
@@ -55,34 +59,34 @@ object Phases {
         /** package */
         case pd @ PackageDef(pid, st) =>
           val newPath = prev :+ pid.name.toString
-          addEntity(Package(newPath.mkString("."), collectEntityMembers(st, newPath), newPath))
+          addEntity(PackageImpl(newPath.mkString("."), collectEntityMembers(st, newPath), newPath))
 
         /** trait */
         case t @ TypeDef(n, rhs) if t.symbol.is(Flags.Trait) =>
           val name = n.toString
           val newPath = prev :+ name
-          Trait(name, collectMembers(rhs), flags(t), newPath)
+          TraitImpl(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, prev :+ name),  flags(o), prev :+ (name + "$"))
+          ObjectImpl(name, collectMembers(rhs, prev :+ name),  flags(o), prev :+ (name + "$"))
 
         /** class / case class */
         case c @ TypeDef(name, rhs) if c.symbol.isClass =>
           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)
+            case x if c.symbol.is(Flags.CaseClass) => CaseClassImpl.tupled(x)
+            case x => ClassImpl.tupled(x)
           }
 
         /** def */
         case d: DefDef =>
-          Def(d.name.toString, flags(d), path(d), returnType(d.tpt))
+          DefImpl(d.name.toString, flags(d), path(d), returnType(d.tpt))
 
         /** val */
         case v: ValDef if !v.symbol.is(Flags.ModuleVal) =>
-          Val(v.name.toString, flags(v), path(v), returnType(v.tpt))
+          ValImpl(v.name.toString, flags(v), path(v), returnType(v.tpt))
 
         case x => {
           //dottydoc.println(s"Found unwanted entity: $x (${x.pos},\n${x.show}")
@@ -97,7 +101,7 @@ object Phases {
       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)
+        PackageImpl(p.name, children, p.path, None)
       }.getOrElse(p)
 
       packages = packages + (path -> newPack)
@@ -119,52 +123,18 @@ object Phases {
       val compUnits = super.runOn(units)
 
       // (2) Set parent of all package children
-      def setParent(ent: Entity, to: Entity): Unit =
-        ent match {
-          case e: Class =>
-            e.parent = Some(to)
-            e.members.foreach(setParent(_, e))
-          case e: CaseClass =>
-            e.parent = Some(to)
-            e.members.foreach(setParent(_, e))
-          case e: Object =>
-            e.parent = Some(to)
-            e.members.foreach(setParent(_, e))
-          case e: Trait =>
-            e.parent = Some(to)
-            e.members.foreach(setParent(_, e))
-          case e: Val =>
-            e.parent = Some(to)
-          case e: Def =>
-            e.parent = Some(to)
-          case _ => ()
-        }
-
-      println("Connecting parents to children...")
+      println("Connecting parents to children, finding companions...")
       for {
         parent <- packages.values
         child  <- parent.children
       } setParent(child, to = parent)
 
       // (3) Create documentation template from docstrings, with internal links
-      packages.values.foreach { p =>
-        mutateEntities(p) {
-          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 _ => ()
-        }
+      for {
+        pack <- packages.values
+      } mutateEntities(pack) { e =>
+        val comment = commentCache(e.path.mkString("."))(e, packages)
+        setComment(e, to = comment)
       }
 
       // (4) Write the finished model to JSON
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/html/Html.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/html/Html.scala
index aef86ffd8..91bf4d773 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/html/Html.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/html/Html.scala
@@ -2,11 +2,13 @@ package dotty.tools.dottydoc
 package html
 
 import scalatags.Text.all._
-import model.Entities._
+import model.internal._
+import model._
 
 case class EntityPage(entity: Entity, packages: Map[String, Package]) {
-  import prickle._
   import CustomTags._
+  import model.pickling._
+  import prickle._
 
   private def relPath(to: String, from: Entity) =
     "../" * from.path.length + to
@@ -77,7 +79,7 @@ case class EntityPage(entity: Entity, packages: Map[String, Package]) {
     str.replaceAll("\\$colon", ":")
 
   private def relativePath(to: Entity) =
-    util.Traversing.relativePath(entity, to)
+    util.traversing.relativePath(entity, to)
 
   def packageView = nav(
     cls := "mdl-navigation packages",
@@ -86,9 +88,16 @@ case class EntityPage(entity: Entity, packages: Map[String, Package]) {
       keys.flatMap { k =>
         val pack = packages(k)
         val children =
-          pack.children.sortBy(_.name).filterNot(_.kind == "package").map { c =>
-            a(cls := "mdl-navigation__link entity", href := relativePath(c), filteredName(c.name))
-          }
+          pack.children
+            .sortBy(_.name)
+            .filterNot(_.kind == "package")
+            .map { entity =>
+              a(
+                cls := "mdl-navigation__link entity",
+                href := relativePath(entity),
+                filteredName(entity.name)
+              )
+            }
 
         if (children.length > 0)
           a(cls := "mdl-navigation__link package", href := relativePath(pack), filteredName(k)) :: children
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/model/CommentParsers.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/model/CommentParsers.scala
index e47a17f49..e6adba977 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/model/CommentParsers.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/model/CommentParsers.scala
@@ -8,7 +8,7 @@ import dotc.core.Contexts.Context
 object CommentParsers {
   import comment._
   import BodyParsers._
-  import Entities.{Entity, Package}
+  import model.internal._
 
   sealed class WikiParser
   extends CommentCleaner with CommentParser with CommentExpander {
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyEntities.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyEntities.scala
index 9f06a7a9a..f423cf8de 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyEntities.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyEntities.scala
@@ -3,7 +3,6 @@ package model
 package comment
 
 import scala.collection._
-import Entities.Entity
 
 /** A body of text. A comment has a single body, which is composed of
   * at least one block. Inside every body is exactly one summary (see
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyParsers.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyParsers.scala
index b43440dd1..725d83557 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyParsers.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/BodyParsers.scala
@@ -3,7 +3,6 @@ package model
 package comment
 
 object BodyParsers {
-  import model.Entities.{Entity, Members}
 
   implicit class BodyToHtml(val body: Body) extends AnyVal {
     def toHtml(origin: Entity): String = {
@@ -37,7 +36,7 @@ object BodyParsers {
       }
 
       def relativePath(target: Entity) =
-        util.Traversing.relativePath(origin, target)
+        util.traversing.relativePath(origin, target)
 
       def bodyToHtml(body: Body): String =
         (body.blocks map blockToHtml).mkString
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/CommentParser.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
index 3c5411c5c..fb2119fc0 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
@@ -8,10 +8,10 @@ import dotty.tools.dotc.core.Contexts.Context
 import scala.collection.mutable
 import dotty.tools.dotc.config.Printers.dottydoc
 import scala.util.matching.Regex
-import Entities.{Entity, Package}
 
 trait CommentParser extends util.MemberLookup {
   import Regexes._
+  import model.internal._
 
   /** Parses a raw comment string into a `Comment` object.
    * @param packages     all packages parsed by Scaladoc tool, used for lookup
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
index 8ec62a7d4..70587e6b8 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/util/IndexWriters.scala
@@ -2,9 +2,10 @@ package dotty.tools.dottydoc
 package util
 
 object IndexWriters {
-  import prickle._
-  import model.Entities._
   import html.EntityPage
+  import model.Package
+  import model.pickling._
+  import prickle._
 
   def writeJs(packs: Map[String, Package], outPath: String): Unit = {
     for (pack <- packs.values) {
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/util/MemberLookup.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/util/MemberLookup.scala
index 933ed682f..f95829caf 100644
--- a/dottydoc/jvm/src/dotty/tools/dottydoc/util/MemberLookup.scala
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/util/MemberLookup.scala
@@ -10,8 +10,9 @@ import dotc.core.Symbols._
 import dotc.core.Types._
 import dotc.core.Names._
 import dotc.util.Positions._
+import model.internal._
 import model.comment._
-import model.Entities._
+import model._
 
 trait MemberLookup {
   /** Performs a lookup based on the provided (pruned) query string
diff --git a/dottydoc/jvm/src/dotty/tools/dottydoc/util/mutate.scala b/dottydoc/jvm/src/dotty/tools/dottydoc/util/mutate.scala
new file mode 100644
index 000000000..b491fb161
--- /dev/null
+++ b/dottydoc/jvm/src/dotty/tools/dottydoc/util/mutate.scala
@@ -0,0 +1,39 @@
+package dotty.tools.dottydoc
+package util
+package internal
+
+object setters {
+  import model._
+  import model.comment.Comment
+  import model.internal._
+
+  def setComment(ent: Entity, to: Option[Comment]) = ent match {
+    case x: PackageImpl   => x.comment = to
+    case x: ClassImpl     => x.comment = to
+    case x: CaseClassImpl => x.comment = to
+    case x: TraitImpl     => x.comment = to
+    case x: ObjectImpl    => x.comment = to
+    case x: DefImpl       => x.comment = to
+    case x: ValImpl       => x.comment = to
+  }
+
+  def setParent(ent: Entity, to: Entity): Unit = ent match {
+    case e: ClassImpl =>
+      e.parent = to
+      e.members.foreach(setParent(_, e))
+    case e: CaseClassImpl =>
+      e.parent = to
+      e.members.foreach(setParent(_, e))
+    case e: ObjectImpl =>
+      e.parent = to
+      e.members.foreach(setParent(_, e))
+    case e: TraitImpl =>
+      e.parent = to
+      e.members.foreach(setParent(_, e))
+    case e: ValImpl =>
+      e.parent = to
+    case e: DefImpl =>
+      e.parent = to
+    case _ => ()
+  }
+}