Merge pull request #2074 from vlthr/dottydoc-entity-implicits

[WIP] consolidate entity serialization

1 files changed, 320 insertions, 0 deletions

diff --git a/doc-tool/test/JavaConverterTest.scala b/doc-tool/test/JavaConverterTest.scala
new file mode 100644
index 000000000..6301fc25d
--- /dev/null
+++ b/doc-tool/test/JavaConverterTest.scala
@@ -0,0 +1,320 @@
+package dotty.tools
+package dottydoc
+
+import org.junit.Test
+import org.junit.Assert._
+
+import model.{
+  Val,
+  Object => EObject,
+  CaseClass,
+  Entity,
+  Members,
+  SuperTypes,
+  Modifiers,
+  TypeParams,
+  Constructors => EConstructors,
+  Class,
+  Companion,
+  ReturnValue,
+  ImplicitlyAddedEntity,
+  TypeAlias,
+  Trait,
+  Package,
+  Def,
+  NonEntity,
+  ParamList
+}
+import model.references._
+import model.internal.{ParamListImpl}
+import model.comment.Comment
+import dotty.tools.dotc.core.Symbols.NoSymbol
+import java.util.{Optional => JOptional, Map => JMap, List => JList}
+
+class JavaConverterTest {
+  import model.JavaConverters._
+  import scala.collection.JavaConverters._
+
+  @Test def entityConversions = {
+    val paramList = new ParamListImpl(new NamedReference("x", new TypeReference("Int", new NoLink("title", "target"), List())) :: Nil, false)
+    val df = new Def {
+      def symbol = NoSymbol
+      def name = "test"
+      def path = "path" :: "to" :: "def" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "private" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def implicitlyAddedFrom = Some(
+          new TypeReference("String", new NoLink("title", "target"), List()))
+      def returnValue = new TypeReference("String", new NoLink("title", "target"), List())
+      def paramLists = List(paramList)
+    }
+    assertSerializedCorrectly(df, df.asJava())
+    val trt = new Trait {
+      def symbol = NoSymbol
+      def name = "someTrait"
+      def path = "path" :: "to" :: "trait" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "protected" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def superTypes = new NoLink("title", "query") :: Nil
+      def members = df :: Nil
+      def traitParams = List(paramList)
+      def companionPath = "path" :: "to" :: "companion" :: Nil
+      def companionPath_=(xs: List[String]) = Unit
+    }
+    assertSerializedCorrectly(trt, trt.asJava())
+    val cls = new Class {
+      def symbol = NoSymbol
+      def name = "test"
+      def path = "path" :: "to" :: "test" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "private" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def superTypes = new NoLink("title", "query") :: Nil
+      def members = Nil
+      def companionPath = "path" :: "to" :: "companion" :: Nil
+      def companionPath_=(xs: List[String]) = Unit
+      def constructors = List(List(paramList))
+    }
+    assertSerializedCorrectly(cls, cls.asJava())
+    val caseClass = new CaseClass {
+      def symbol = NoSymbol
+      def name = "test"
+      def path = "path" :: "to" :: "test" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "private" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def constructors = List(List(paramList))
+      def superTypes = new NoLink("title", "query") :: Nil
+      def members = Nil
+      def companionPath = "path" :: "to" :: "companion" :: Nil
+      def companionPath_=(xs: List[String]) = Unit
+    }
+    assertSerializedCorrectly(caseClass, caseClass.asJava())
+    val obj = new EObject {
+      def symbol = NoSymbol
+      def name = "someObject"
+      def path = "path" :: "to" :: "object" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "protected" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def superTypes = new NoLink("title", "query") :: Nil
+      def members = df :: Nil
+      def companionPath = "path" :: "to" :: "companion" :: Nil
+      def companionPath_=(xs: List[String]) = Unit
+    }
+    assertSerializedCorrectly(obj, obj.asJava())
+    val typeAlias = new TypeAlias {
+      def symbol = NoSymbol
+      def name = "typeAlias"
+      def path = "path" :: "to" :: "typeAlias" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "private" :: Nil
+      def typeParams = "String" :: "String" :: Nil
+      def alias = Some(new TypeReference("String", new NoLink("title", "target"), List()))
+    }
+    assertSerializedCorrectly(typeAlias, typeAlias.asJava())
+    val vl = new Val {
+      val kind = "val"
+      def symbol = NoSymbol
+      def name = "val"
+      def path = "path" :: "to" :: "val" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def modifiers = "private" :: Nil
+      def returnValue = new TypeReference("String", new NoLink("title", "target"), List())
+      def implicitlyAddedFrom = Some(
+        new TypeReference("String", new NoLink("title", "target"), List()))
+    }
+    assertSerializedCorrectly(vl, vl.asJava())
+    val pkg = new Package {
+      def symbol = NoSymbol
+      def name = "test"
+      def path = "path" :: "to" :: "test" :: Nil
+      def comment = None
+      def annotations = List("test")
+      def parent = NonEntity
+      def members = trt :: typeAlias :: Nil
+      def superTypes = new NoLink("title", "query") :: Nil
+    }
+    assertSerializedCorrectly(pkg, pkg.asJava())
+  }
+
+  def assertEach[E, C[E] <: Seq[E]](expected: C[E], serialized: Any)(pairwiseAssertion: (E, Any) => Unit) {
+    val actual = serialized.asInstanceOf[JList[_]].asScala.toList
+    assertEquals(expected.length, actual.length)
+    for ((exp, act) <- expected zip actual) {
+      pairwiseAssertion(exp, act)
+    }
+  }
+  def assertSameSeq[T, C[T] <: Seq[T]](expected: C[T], serialized: Any) = {
+    val actual = serialized.asInstanceOf[java.util.List[T]].asScala.toList
+    assertEquals(expected, actual);
+  }
+  def assertSerializedCorrectly(expected: ParamList, serialized: Any) {
+    val actual = serialized.asInstanceOf[JMap[String, _]]
+    assertEach(expected.list, actual.get("list")) {(exp, act) =>
+      assertSerializedCorrectly(exp, act)
+    }
+    assertEquals(expected.isImplicit, actual.get("isImplicit"))
+  }
+  def assertSerializedCorrectly(expected: Reference, serialized: Any) {
+    val actual = serialized.asInstanceOf[JMap[String, _]]
+    expected match {
+      case TypeReference(title, tpeLink, paramLinks) =>
+        assertEquals(title, actual.get("title"))
+        assertSerializedCorrectly(tpeLink, actual.get("tpeLink"))
+        assertEach(paramLinks, actual.get("paramLinks")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      case OrTypeReference(left, right) =>
+        assertSerializedCorrectly(left, actual.get("left"))
+        assertSerializedCorrectly(right, actual.get("right"))
+      case AndTypeReference(left, right) =>
+        assertSerializedCorrectly(left, actual.get("left"))
+        assertSerializedCorrectly(right, actual.get("right"))
+      case FunctionReference(args, returnValue) =>
+        assertEach(args, actual.get("args")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+        assertSerializedCorrectly(returnValue, actual.get("returnValue"))
+      case TupleReference(args) =>
+        assertEach(args, actual.get("args")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      case BoundsReference(low, high) =>
+        assertSerializedCorrectly(low, actual.get("low"))
+        assertSerializedCorrectly(high, actual.get("high"))
+      case NamedReference(title, ref, isByName, isRepeated) =>
+        assertEquals(title, actual.get("title"))
+        assertSerializedCorrectly(ref, actual.get("ref"))
+        assertEquals(isByName, actual.get("isByName"))
+        assertEquals(isRepeated, actual.get("isRepeated"))
+      case ConstantReference(title) =>
+        assertEquals(title, actual.get("title"))
+      case EmptyReference =>
+    }
+  }
+  def assertSerializedCorrectly(expected: MaterializableLink, serialized: Any) {
+    val actual = serialized.asInstanceOf[JMap[String, _]]
+    expected match {
+      case UnsetLink(title, query) =>
+        assertEquals(title, actual.get("title"))
+        assertEquals(query, actual.get("query"))
+      case MaterializedLink(title, target) =>
+        assertEquals(title, actual.get("title"))
+        assertEquals(target, actual.get("target"))
+      case NoLink(title, target) =>
+        assertEquals(title, actual.get("title"))
+        assertEquals(target, actual.get("target"))
+    }
+  }
+  def assertSerializedCorrectly(expected: Entity, serialized: Any) {
+    val actual = serialized.asInstanceOf[JMap[String, _]]
+    assertEquals(expected.name, actual.get("name"))
+    assertEquals(expected.kind, actual.get("kind"))
+    assertSameSeq(expected.annotations, actual.get("annotations"))
+    assertSameSeq(expected.path, actual.get("path"))
+    assertEquals(expected.hasShortenedDocstring, actual.get("hasShortenedDocstring"))
+    // Only test if a comment is present
+    expected.comment match {
+      case Some(c) => assertNotEquals(null, actual.get("comment"))
+      case _ =>
+    }
+    expected match {
+      case e: Members => {
+        assertEach(e.members, actual.get("members")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      }
+      case _ =>
+    }
+    expected match {
+      case e: SuperTypes => {
+        assertEach(e.superTypes, actual.get("superTypes")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      }
+      case _ =>
+    }
+    expected match {
+      case e: Modifiers => {
+        assertSameSeq(e.modifiers, actual.get("modifiers"))
+        assertEquals(e.isPrivate, actual.get("isPrivate"))
+        assertEquals(e.isProtected, actual.get("isProtected"))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: TypeParams => {
+        assertSameSeq(e.typeParams, actual.get("typeParams"))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: EConstructors => {
+        // constructors is of type List[List[ParamList]], so we need to apply assertEach twice
+        assertEach(e.constructors, actual.get("constructors")) { (exp, act) =>
+          assertEach(exp, act) { (exp, act) =>
+            assertSerializedCorrectly(exp, act)
+          }
+        }
+      }
+      case _ =>
+    }
+    expected match {
+      case e: Companion => {
+        assertSameSeq(e.companionPath, actual.get("companionPath"))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: ReturnValue => {
+        assertSerializedCorrectly(e.returnValue, actual.get("returnValue"))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: ImplicitlyAddedEntity => {
+        e.implicitlyAddedFrom.map(assertSerializedCorrectly(_, actual.get("implicitlyAddedFrom")))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: TypeAlias => {
+        e.alias.map(assertSerializedCorrectly(_, actual.get("alias")))
+      }
+      case _ =>
+    }
+    expected match {
+      case e: Def => {
+        assertEach(e.paramLists, actual.get("paramLists")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      }
+      case _ =>
+    }
+    expected match {
+      case e: Trait => {
+        assertEach(e.traitParams, actual.get("traitParams")) { (exp, act) =>
+          assertSerializedCorrectly(exp, act)
+        }
+      }
+      case _ =>
+    }
+  }
+}