From 082a427ff9572e002bb1fc5c71e129e857f0aa81 Mon Sep 17 00:00:00 2001
From: Adriaan Moors <adriaan.moors@epfl.ch>
Date: Thu, 1 Oct 2009 13:34:17 +0000
Subject: missing test cases for #2261, #2293, #2421

---
 test/files/pos/t2261.scala             |  9 +++++++++
 test/files/pos/t2293.scala             |  5 +++++
 test/pending/pos/t2421.scala           | 14 +++++++++++++
 test/pending/pos/t2421_delitedsl.scala | 37 ++++++++++++++++++++++++++++++++++
 4 files changed, 65 insertions(+)
 create mode 100644 test/files/pos/t2261.scala
 create mode 100644 test/files/pos/t2293.scala
 create mode 100644 test/pending/pos/t2421.scala
 create mode 100644 test/pending/pos/t2421_delitedsl.scala

(limited to 'test')

diff --git a/test/files/pos/t2261.scala b/test/files/pos/t2261.scala
new file mode 100644
index 0000000000..aac5c9e0fd
--- /dev/null
+++ b/test/files/pos/t2261.scala
@@ -0,0 +1,9 @@
+class Bob[T]
+object Test {
+  implicit def foo2bar[T](xs: List[T]): Bob[T] = new Bob[T]
+  var x: Bob[Int] = null
+  x = List(1,2,3)
+  // the problem here was that somehow the type variable that was used to infer the type argument for List.apply
+  // would accumulate several conflicting constraints
+  // can't reproduce with
+}
\ No newline at end of file
diff --git a/test/files/pos/t2293.scala b/test/files/pos/t2293.scala
new file mode 100644
index 0000000000..65f717f851
--- /dev/null
+++ b/test/files/pos/t2293.scala
@@ -0,0 +1,5 @@
+import scala.collection.JavaConversions._
+
+object Test {
+  val m: java.util.Map[String,String] = collection.mutable.Map("1"->"2")
+}
\ No newline at end of file
diff --git a/test/pending/pos/t2421.scala b/test/pending/pos/t2421.scala
new file mode 100644
index 0000000000..0d01be29fc
--- /dev/null
+++ b/test/pending/pos/t2421.scala
@@ -0,0 +1,14 @@
+object Test {
+  abstract class <~<[-From, +To] extends (From => To)
+  implicit def trivial[A]: A <~< A = error("")
+
+
+  trait Forcible[T]
+  implicit val forcibleInt: (Int <~< Forcible[Int]) = error("")
+
+  def headProxy[P <: Forcible[Int]](implicit w: Int <~< P): P = error("")
+
+  headProxy
+  // trivial[Int] should not be considered a valid implicit, since w would have type Int <~< Int,
+  // and headProxy's type parameter P cannot be instantiated to Int
+}
\ No newline at end of file
diff --git a/test/pending/pos/t2421_delitedsl.scala b/test/pending/pos/t2421_delitedsl.scala
new file mode 100644
index 0000000000..a05887023a
--- /dev/null
+++ b/test/pending/pos/t2421_delitedsl.scala
@@ -0,0 +1,37 @@
+trait DeliteDSL {
+  abstract class <~<[-From, +To] extends (From => To)
+  implicit def trivial[A]: A <~< A = new (A <~< A) {def apply(x: A) = x}
+
+  trait Forcible[T]
+  object Forcible {
+    def factory[T](f: T => Forcible[T]) = new (T <~< Forcible[T]){def apply(x: T) = f(x)}
+  }
+
+  case class DeliteInt(x: Int) extends Forcible[Int]
+  implicit val forcibleInt = Forcible.factory(DeliteInt(_: Int))
+
+  import scala.collection.Traversable
+  class DeliteCollection[T](val xs: Traversable[T]) {
+    // must use existential in bound of P, instead of T itself, because we cannot both have:
+        // Test.x below: DeliteCollection[T=Int] -> P=DeliteInt <: Forcible[T=Int], as T=Int <~< P=DeliteInt
+        // Test.xAlready below: DeliteCollection[T=DeliteInt] -> P=DeliteInt <: Forcible[T=DeliteInt], as T=DeliteInt <~< P=DeliteInt
+        // this would required DeliteInt <: Forcible[Int] with Forcible[DeliteInt]
+
+    def headProxy[P <: Forcible[_]](implicit w: T <~< P): P = xs.head
+  }
+  // If T is already a proxy (it is forcible), the compiler should use
+  // forcibleIdentity to deduce that P=T.  If T is Int, the compiler
+  // should use intToForcible to deduce that P=DeliteInt.
+  //
+  // Without this feature, the user must write 'xs.proxyOfFirst[DeliteInt]',
+  // with the feature they can write 'xs.proxyOfFirst', which is shorter and
+  // avoids exposing internal DELITE types to the world.
+
+  object Test {
+    val x = new DeliteCollection(List(1,2,3)).headProxy
+    // inferred: val x: Forcible[Int] = new DeliteCollection[Int](List.apply[Int](1, 2, 3)).headProxy[Forcible[Int]](forcibleInt);
+
+    val xAlready = new DeliteCollection(List(DeliteInt(1),DeliteInt(2),DeliteInt(3))).headProxy
+    // inferred: val xAlready: DeliteInt = new DeliteCollection[DeliteInt](List.apply[DeliteInt](DeliteInt(1), DeliteInt(2), DeliteInt(3))).headProxy[DeliteInt](trivial[DeliteInt]);
+  }
+}
\ No newline at end of file
-- 
cgit v1.2.3