consolidate entity serialization into single class

- refactored JavaEntity to be DRY with respect to repeating the
serialization of fields shared by many types of entities
- added tests

2 files changed, 194 insertions, 166 deletions

diff --git a/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala b/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala
index 4a9bfce0c..5ff2048e9 100644
--- a/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala
@@ -4,12 +4,11 @@ package model
 import comment._
 import references._
 
-import _root_.java.util.HashMap
 import _root_.java.util.LinkedList
 
 object JavaConverters {
   import scala.collection.JavaConverters._
-  import _root_.java.util.{ Optional => JOptional, Map => JMap }
+  import _root_.java.util.{ Map => JMap }
 
   implicit class OptStr(val opt: Option[String]) extends AnyVal {
     def asJava = opt.getOrElse(null)
@@ -44,160 +43,6 @@ object JavaConverters {
     ).asJava
   }
 
-  implicit class JavaPackage(val ent: Package) extends AnyVal {
-    def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map(
-      "kind"     -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name"     -> ent.name,
-      "path"     -> ent.path.asJava,
-      "members"  -> ent.members.map(_.asJava()).asJava,
-      "children"  -> ent.children.map(_.asJava()).asJava,
-      "comment"  -> ent.comment.map(_.asJava).asJava,
-      "superTypes" -> ent.superTypes,
-      "hasVisibleMembers" -> ent.hasVisibleMembers,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "signature" -> ent.signature
-    ) ++ extras).asJava
-  }
-
-  implicit class JavaCaseClass(val ent: CaseClass) extends AnyVal {
-    def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map(
-      "kind" -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name" -> ent.name,
-      "members" -> ent.members.map(_.asJava()).asJava,
-      "modifiers" -> ent.modifiers.asJava,
-      "path" -> ent.path.asJava,
-      "typeParams" -> ent.typeParams.asJava,
-      "superTypes" -> ent.superTypes.map(_.asJava).asJava,
-      "comment" -> ent.comment.map(_.asJava).asJava,
-      "constructors" -> ent.constructors.map(_.map(_.asJava).asJava).asJava,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "hasVisibleMembers" -> ent.hasVisibleMembers,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "hasCompanion" -> ent.hasCompanion,
-      "companionPath" -> ent.companionPath.asJava,
-      "signature" -> ent.signature
-    ) ++ extras).asJava
-  }
-
-  implicit class JavaClass(val ent: Class) extends AnyVal {
-    def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map(
-      "kind"       -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name"       -> ent.name,
-      "members"    -> ent.members.map(_.asJava()).asJava,
-      "modifiers"  -> ent.modifiers.asJava,
-      "path"       -> ent.path.asJava,
-      "typeParams" -> ent.typeParams.asJava,
-      "superTypes" -> ent.superTypes.map(_.asJava).asJava,
-      "comment"    -> ent.comment.map(_.asJava).asJava,
-      "constructors" -> ent.constructors.map(_.map(_.asJava).asJava).asJava,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "hasVisibleMembers" -> ent.hasVisibleMembers,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "hasCompanion" -> ent.hasCompanion,
-      "companionPath" -> ent.companionPath.asJava,
-      "signature" -> ent.signature
-    ) ++ extras).asJava
-  }
-
-  implicit class JavaTrait(val ent: Trait) extends AnyVal {
-    def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map(
-      "kind"       -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name"       -> ent.name,
-      "members"    -> ent.members.map(_.asJava()).asJava,
-      "modifiers"  -> ent.modifiers.asJava,
-      "path"       -> ent.path.asJava,
-      "typeParams" -> ent.typeParams.asJava,
-      "superTypes" -> ent.superTypes.map(_.asJava).asJava,
-      "comment"    -> ent.comment.map(_.asJava).asJava,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "hasVisibleMembers" -> ent.hasVisibleMembers,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "hasCompanion" -> ent.hasCompanion,
-      "companionPath" -> ent.companionPath.asJava,
-      "signature" -> ent.signature
-    ) ++ extras).asJava
-  }
-
-  implicit class JavaObject(val ent: Object) extends AnyVal {
-    def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = (Map(
-      "kind"       -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name"       -> ent.name,
-      "members"    -> ent.members.map(_.asJava()).asJava,
-      "modifiers"  -> ent.modifiers.asJava,
-      "path"       -> ent.path.asJava,
-      "superTypes" -> ent.superTypes.map(_.asJava).asJava,
-      "comment"    -> ent.comment.map(_.asJava).asJava,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "hasVisibleMembers" -> ent.hasVisibleMembers,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "hasCompanion" -> ent.hasCompanion,
-      "companionPath" -> ent.companionPath.asJava,
-      "signature" -> ent.signature
-    ) ++ extras).asJava
-  }
-
-  implicit class JavaDef(val ent: Def) extends AnyVal {
-    def asJava: JMap[String, _] = Map(
-      "kind"                -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name"                -> ent.name,
-      "modifiers"           -> ent.modifiers.asJava,
-      "path"                -> ent.path.asJava,
-      "returnValue"         -> ent.returnValue.asJava,
-      "typeParams"          -> ent.typeParams.asJava,
-      "paramLists"          -> ent.paramLists.map(_.asJava).asJava,
-      "comment"             -> ent.comment.map(_.asJava).asJava,
-      "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "signature" -> ent.signature
-    ).asJava
-  }
-
-  implicit class JavaVal(val ent: Val) extends AnyVal {
-    def asJava: JMap[String, _] = Map(
-      "kind" -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "name" -> ent.name,
-      "modifiers" -> ent.modifiers.asJava,
-      "path" -> ent.path.asJava,
-      "returnValue" -> ent.returnValue.asJava,
-      "comment" -> ent.comment.map(_.asJava).asJava,
-      "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "signature" -> ent.signature
-    ).asJava
-  }
-
-  implicit class JavaTypeAlias(val ent: TypeAlias) extends AnyVal {
-    def asJava: JMap[String, _] = Map(
-      "kind" -> ent.kind,
-      "annotations" -> ent.annotations.asJava,
-      "modifiers" -> ent.modifiers.asJava,
-      "name" -> ent.name,
-      "path" -> ent.path.asJava,
-      "alias" -> ent.alias.map(_.asJava).asJava,
-      "typeParams" -> ent.typeParams.asJava,
-      "comment" -> ent.comment.map(_.asJava).asJava,
-      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
-      "isPrivate" -> ent.isPrivate,
-      "isProtected" -> ent.isProtected,
-      "signature" -> ent.signature
-    ).asJava
-  }
-
   implicit class JavaParamList(val pl: ParamList) extends AnyVal {
     def asJava: JMap[String, _] = Map(
       "list"       -> pl.list.map(_.asJava).asJava,
@@ -298,16 +143,88 @@ object JavaConverters {
     def asJava(extras: Map[String, _] = Map.empty): JMap[String, _] = parseEntity(ent, extras)
   }
 
-  private def parseEntity(ent: Entity, extras: Map[String, _]): JMap[String, _] = ent match {
-    case ent: Package   => ent.asJava(extras)
-    case ent: CaseClass => ent.asJava(extras)
-    case ent: Class     => ent.asJava(extras)
-    case ent: Trait     => ent.asJava(extras)
-    case ent: Object    => ent.asJava(extras)
-    case ent: Def       => ent.asJava
-    case ent: Val       => ent.asJava
-    case ent: TypeAlias => ent.asJava
-    case _              => Map.empty.asJava
+  private def parseEntity(ent: Entity, extras: Map[String, _]): JMap[String, _] = {
+    val entity = Map(
+      "kind"     -> ent.kind,
+      "annotations" -> ent.annotations.asJava,
+      "name"     -> ent.name,
+      "path"     -> ent.path.asJava,
+      "children"  -> ent.children.map(_.asJava()).asJava,
+      "comment"  -> ent.comment.map(_.asJava).asJava,
+      "hasShortenedDocstring" -> ent.hasShortenedDocstring,
+      "signature" -> ent.signature
+    )
+    val members = ent match {
+      case ent: Members => Map(
+        "members"  -> ent.members.map(_.asJava()).asJava,
+        "hasVisibleMembers" -> ent.hasVisibleMembers
+      )
+      case _ => Map.empty
+    }
+    val superTypes = ent match {
+      case ent: SuperTypes => Map(
+        "superTypes" -> ent.superTypes.map(_.asJava).asJava
+      )
+      case _ => Map.empty
+    }
+    val modifiers = ent match {
+      case ent: Modifiers => Map(
+        "modifiers" -> ent.modifiers.asJava,
+        "isPrivate" -> ent.isPrivate,
+        "isProtected" -> ent.isProtected
+      )
+      case _ => Map.empty
+    }
+    val typeParams = ent match {
+      case ent: TypeParams => Map(
+        "typeParams" -> ent.typeParams.asJava
+      )
+      case _ => Map.empty
+    }
+    val constructors = ent match {
+      case ent: Constructors => Map(
+        "constructors" -> ent.constructors.map(_.map(_.asJava).asJava).asJava
+      )
+      case _ => Map.empty
+    }
+    val companion = ent match {
+      case ent: Companion => Map(
+        "hasCompanion" -> ent.hasCompanion,
+        "companionPath" -> ent.companionPath.asJava
+      )
+      case _ => Map.empty
+    }
+    val returnValue = ent match {
+      case ent: ReturnValue => Map(
+        "returnValue"         -> ent.returnValue.asJava
+      )
+      case _ => Map.empty
+    }
+    val implicitlyAddedEntity = ent match {
+      case ent: ImplicitlyAddedEntity => Map(
+        "implicitlyAddedFrom" -> ent.implicitlyAddedFrom.map(_.asJava).asJava
+      )
+      case _ => Map.empty
+    }
+    val typeAlias : Map[String, _] = ent match {
+      case ent: TypeAlias => Map(
+        "alias" -> ent.alias.map(_.asJava).asJava
+      )
+      case _ => Map.empty
+    }
+    val trt = ent match {
+      case ent: Trait => Map(
+        "traitParams"          -> ent.traitParams.map(_.asJava).asJava
+      )
+      case _ => Map.empty
+    }
+    val df = ent match {
+      case ent: Def => Map(
+        "paramLists"          -> ent.paramLists.map(_.asJava).asJava
+      )
+      case _ => Map.empty
+    }
+      (entity ++ members ++ superTypes ++ modifiers ++ typeParams ++ constructors ++ companion ++ returnValue ++ implicitlyAddedEntity ++ typeAlias ++ trt ++ df).asJava
   }
 
   implicit class JavaMap(val map: collection.Map[String, Package]) extends AnyVal {
diff --git a/doc-tool/test/JavaConverterTest.scala b/doc-tool/test/JavaConverterTest.scala
new file mode 100644
index 000000000..4f1dec5e9
--- /dev/null
+++ b/doc-tool/test/JavaConverterTest.scala
@@ -0,0 +1,111 @@
+package dotty.tools
+package dottydoc
+
+import org.junit.Test
+import org.junit.Assert._
+import model.{
+  Entity,
+  Members,
+  SuperTypes,
+  Modifiers,
+  TypeParams,
+  Constructors => MConstructors,
+  Companion,
+  ReturnValue,
+  ImplicitlyAddedEntity,
+  TypeAlias,
+  Trait,
+  Def,
+  NonEntity
+}
+import model.references.{ConstantReference, TypeReference, NoLink}
+import model.comment.Comment
+import dotty.tools.dotc.core.Symbols.NoSymbol
+import _root_.java.util.{Optional => JOptional, Map => JMap}
+
+class JavaConverterTest {
+  import model.JavaConverters._
+
+  @Test def entityConversions = {
+    trait TestEntity extends Entity {
+      def symbol = NoSymbol
+
+      def name = "test"
+
+      def kind = "ent"
+
+      def path = "path" :: "to" :: "test" :: Nil
+
+      def comment = Some(new Comment("", "", List(), List(), None, Map(), Map(), Map(), None, None, List(), None, List(), List(), None, None, Map(), Map(), Map(), List()))
+
+      def annotations = List("test")
+
+      def parent = NonEntity
+
+    }
+    trait TestMembers extends TestEntity with Members {
+      def members = new TestEntity{} :: Nil
+    }
+    trait TestSuperTypes extends TestEntity with SuperTypes {
+      def superTypes = new NoLink("title", "query") :: Nil
+    }
+    trait TestModifiers extends TestEntity with Modifiers {
+      def modifiers = "private" :: Nil
+    }
+    trait TestTypeParams extends TestEntity with TypeParams {
+      def typeParams = "String" :: "String" :: Nil
+    }
+    trait TestConstructors extends TestEntity with MConstructors {
+      def constructors = List(List())
+    }
+    trait TestCompanion extends TestEntity with Companion {
+      def companionPath = "path" :: "to" :: "companion" :: Nil
+      def companionPath_=(xs: List[String]) = Unit
+    }
+    trait TestReturnValue extends TestEntity with ReturnValue {
+      def returnValue =
+        new TypeReference("String", new NoLink("title", "target"), List())
+    }
+    trait TestImplicitlyAddedEntity
+        extends TestEntity
+        with ImplicitlyAddedEntity {
+      def implicitlyAddedFrom =
+        Some(
+          new TypeReference("String", new NoLink("title", "target"), List()))
+    }
+    trait TestTypeAlias extends TestTypeParams with TestModifiers with TypeAlias {
+      override val kind = "type"
+      def alias = None
+    }
+    trait TestDef extends TestModifiers with TestTypeParams with TestImplicitlyAddedEntity {
+      def paramLists = List()
+    }
+    trait TestTrait extends TestModifiers with TestTypeParams with TestSuperTypes with TestMembers with TestCompanion {
+      def traitParams = List()
+    }
+    val ent = new TestEntity {}
+    val members = new TestMembers {}
+    val superTypes = new TestSuperTypes {}
+    val modifiers = new TestModifiers {}
+    val typeParams = new TestTypeParams {}
+    val constructors = new TestConstructors {}
+    val companion = new TestCompanion {}
+    val returnValue = new TestReturnValue {}
+    val implicitlyAddedEntity = new TestImplicitlyAddedEntity {}
+    val typeAlias = new TestTypeAlias {}
+    val df = new TestDef {}
+    val trt = new TestTrait {}
+    val ent_serialized = ent.asJava()
+    val members_serialized = members.asJava()
+    val superTypes_serialized = superTypes.asJava()
+    val modifiers_serialized = modifiers.asJava()
+    val typeParams_serialized = typeParams.asJava()
+    val constructors_serialized = constructors.asJava()
+    val companion_serialized = companion.asJava()
+    val returnValue_serialized = returnValue.asJava()
+    val implicitlyAddedEntity_serialized = implicitlyAddedEntity.asJava()
+    val typeAlias_serialized = typeAlias.asJava()
+    val def_serialized = df.asJava()
+    val trait_serialized = trt.asJava()
+  }
+}