Merge pull request #835 from dotty-staging/add-more-tests

Add more tests

Author: odersky

src/dotty/tools/dotc/typer/Inferencing.scala

@@ -82,7 +82,7 @@ object Inferencing {
         force.appliesTo(tvar) && {
           val direction = instDirection(tvar.origin)
           if (direction != 0) {
-            if (direction > 0) println(s"inst $tvar dir = up")
+            //if (direction > 0) println(s"inst $tvar dir = up")
             instantiate(tvar, direction < 0)
           }
           else {

tests/pending/pos/contraImplicits.scala

@@ -0,0 +1,18 @@
+import scala.reflect._
+// this needs to be fleshed out further
+class Contra[-T]
+
+object Test {
+  def getParam[T](c: Contra[T])(implicit ct: ClassTag[T]): Unit = {
+    println(ct)
+    ct
+  }
+  def f[T](x: Contra[T]): Contra[T] = x
+
+  def main(args: Array[String]): Unit = {
+    val x = f(new Contra[Int])
+    val y: Contra[Int] = x
+    getParam(new Contra[Int])
+  }
+}
+

tests/pending/pos/depsel.scala

@@ -0,0 +1,14 @@
+// demonstrates selection on non-path types. Needs to be fleshed out to
+// become a real test.
+object Test {
+
+  class C {
+    type T
+    val f: T => T = ???
+  }
+
+  var x = new C
+  val y = x.f
+
+
+}

tests/pending/run/ordered.scala

@@ -0,0 +1,22 @@
+// infers wrong instance --> an implementatioin is missing
+trait Ord[-T] {
+  def less(x: T, y: T): Boolean
+}
+
+object Test {
+
+  implicit val anyIsOrd: Ord[Any] = new Ord[Any] {
+    def less(x: Any, y: Any): Boolean = ???
+  }
+
+  implicit val intIsOrd: Ord[Int] = new Ord[Int] {
+    def less(x: Int, y: Int): Boolean = x < y
+  }
+
+  def less[T: Ord](x: T, y: T): Boolean =
+    implicitly[Ord[T]].less(x, y)
+
+  def main(args: Array[String]) =
+    assert(less(1, 2))
+
+}

tests/pos/finalvals.scala

@@ -0,0 +1,8 @@
+object Test {
+  final val x = 2
+  final val y = { println("x"); 2 }
+  val x1 = x
+  val y1 = y
+  object O { val x = 42 }
+  println(O.x)
+}

tests/pos/freezeBounds.scala

@@ -0,0 +1,6 @@
+object Test {
+
+  def f[X]: (Set[X], Set[X]) = ???
+
+  val a = if (true) f else (Set[Int](), Set[String]())
+}

tests/pos/inf.scala

@@ -0,0 +1,28 @@
+object Test {
+
+  def f[T](x: T, y: T): T = x
+  def g[T](x: T)(y: T): T = x
+
+  val x: Int = 1
+  val y: Long = x
+
+  val xs: Seq[Int] = Seq(1)
+  val ys: Traversable[Int] = xs
+
+  val r1 = f(x, y)
+  val s1: AnyVal = r1
+  val r2 = f(y, x)
+  val s2: AnyVal = r2
+  val r3 = f(xs, ys)
+  val s3: Traversable[Int] = r3
+  val r4 = f(ys, xs)
+  val s4: Traversable[Int] = r4
+  val r5 = g(x)(y)
+  val s5: AnyVal = r5
+  val r6 = g(y)(x)
+  val s6: AnyVal = r6
+  val r7 = g(xs)(ys)
+  val s7: Traversable[Int]= r7
+  val r8 = g(ys)(xs)
+  val s8: Traversable[Int] = r8
+}

tests/pos/sets.scala

@@ -0,0 +1,11 @@
+object Test {
+
+  val subPatBinders = List[Symbol]()
+
+  def extraStoredBinders: Set[Symbol] = ???
+
+  val storedBinders: Set[Symbol] =
+    (if (true) subPatBinders.toSet else Set.empty) ++ extraStoredBinders// -- ignoredSubPatBinders
+
+
+}

tests/run/i806.scala

@@ -0,0 +1,10 @@
+trait T{
+ def foo(a: List[String]): String = "1"
+ def foo(a: List[Int]): Int = 1
+ foo(List("1"))
+ foo(List(1))
+}
+// to be compiled by dotty
+object Test extends T{
+  def main(args: Array[String]): Unit = ()
+}

tests/run/puzzle.check

@@ -0,0 +1,2 @@
+53.0
+53.0