diff options
author | Adriaan Moors <adriaan.moors@epfl.ch> | 2009-10-01 13:34:17 +0000 |
---|---|---|
committer | Adriaan Moors <adriaan.moors@epfl.ch> | 2009-10-01 13:34:17 +0000 |
commit | 082a427ff9572e002bb1fc5c71e129e857f0aa81 (patch) | |
tree | f46b02f21b4d8fef7d9807e7f3b04a7fe9d7cf2f | |
parent | e000ae4a5a2a9564a550a44f56abe48eaaccd9fd (diff) | |
download | scala-082a427ff9572e002bb1fc5c71e129e857f0aa81.tar.gz scala-082a427ff9572e002bb1fc5c71e129e857f0aa81.tar.bz2 scala-082a427ff9572e002bb1fc5c71e129e857f0aa81.zip |
missing test cases for #2261, #2293, #2421
-rw-r--r-- | test/files/pos/t2261.scala | 9 | ||||
-rw-r--r-- | test/files/pos/t2293.scala | 5 | ||||
-rw-r--r-- | test/pending/pos/t2421.scala | 14 | ||||
-rw-r--r-- | test/pending/pos/t2421_delitedsl.scala | 37 |
4 files changed, 65 insertions, 0 deletions
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 |