Add checkTypes to support type unit testing

Implementation mostly stolen from TypeStealer.

Author: milessabin

compiler/test/dotty/tools/CheckTypeTest.scala

@@ -0,0 +1,40 @@
+package dotty.tools
+
+import org.junit.Test
+import org.junit.Assert.{ assertFalse, assertTrue }
+
+import dotc.ast.Trees._
+import dotc.core.Decorators._
+
+class CheckTypeTest extends DottyTest {
+  @Test
+  def checkTypeTest: Unit = {
+    val source = """
+      |class A
+      |class B extends A
+    """.stripMargin
+
+    val types = List(
+      "A",
+      "B",
+      "List[_]",
+      "List[Int]",
+      "List[AnyRef]",
+      "List[String]",
+      "List[A]",
+      "List[B]"
+    )
+
+    checkTypes(source, types: _*) {
+      case (List(a, b, lu, li, lr, ls, la, lb), context) =>
+        implicit val ctx = context
+
+        assertTrue  ( b <:<  a)
+        assertTrue  (li <:< lu)
+        assertFalse (li <:< lr)
+        assertTrue  (ls <:< lr)
+        assertTrue  (lb <:< la)
+        assertFalse (la <:< lb)
+    }
+  }
+}

compiler/test/dotty/tools/DottyTest.scala

@@ -75,6 +75,25 @@ trait DottyTest extends ContextEscapeDetection {
     run.runContext
   }
 
+  def checkTypes(source: String, typeStrings: String*)(assertion: (List[Type], Context) => Unit) = {
+    val dummyName = "x_x_x"
+    val vals = typeStrings.zipWithIndex.map{case (s, x)=> s"val ${dummyName}$x: $s = ???"}.mkString("\n")
+    val gatheredSource = s" ${source}\n object A$dummyName {$vals}"
+    checkCompile("frontend", gatheredSource) {
+      (tree, context) =>
+        implicit val ctx = context
+        val findValDef: (List[tpd.ValDef], tpd.Tree) => List[tpd.ValDef] =
+          (acc , tree) =>  { tree match {
+          case t: tpd.ValDef if t.name.startsWith(dummyName) => t :: acc
+          case _ => acc
+        }
+      }
+      val d = new tpd.DeepFolder[List[tpd.ValDef]](findValDef).foldOver(Nil, tree)
+      val tpes = d.map(_.tpe.widen).reverse
+      assertion(tpes, context)
+    }
+  }
+
   def methType(names: String*)(paramTypes: Type*)(resultType: Type = defn.UnitType) =
     MethodType(names.toList map (_.toTermName), paramTypes.toList, resultType)
 }