Drop special case around Function1

Now only Scala2 mode treats Function1's as implicit conversions. Instead we introduce
a new subclass ImplicitConverter of Function1, instances of which are turned into
implicit conversions.

2 files changed, 90 insertions, 0 deletions

diff --git a/tests/pos-scala2/typerep-stephane.scala b/tests/pos-scala2/typerep-stephane.scala
new file mode 100644
index 000000000..2cb899591
--- /dev/null
+++ b/tests/pos-scala2/typerep-stephane.scala
@@ -0,0 +1,48 @@
+object typerep {
+
+ class TypeRep[T] {
+   def getType: TypeRep[T] = this
+ }
+
+ object BooleanRep extends TypeRep[Boolean] {
+   override def toString = "Boolean"
+ }
+ object CharRep extends TypeRep[Char] {
+   override def toString = "Char"
+ }
+ object IntRep  extends TypeRep[Int] {
+   override def toString = "Int"
+ }
+ object LongRep extends TypeRep[Long] {
+   override def toString = "Long"
+ }
+ object FloatRep extends TypeRep[Float] {
+   override def toString = "Float"
+ }
+ object DoubleRep extends TypeRep[Double] {
+   override def toString = "Double"
+ }
+ class ListRep[U, T <: List[U]](val elemRep: TypeRep[U]) extends TypeRep[T] {
+   override def toString = "List[" + elemRep + "]"
+ }
+
+ implicit def typeRep(x: Boolean): TypeRep[Boolean] = BooleanRep
+ implicit def typeRep(x: Char   ): TypeRep[Char   ] = CharRep
+ implicit def typeRep(x: Long   ): TypeRep[Long   ] = LongRep
+ implicit def typeRep(x: Float  ): TypeRep[Float  ] = FloatRep
+ implicit def typeRep(x: Double ): TypeRep[Double ] = DoubleRep
+ implicit def typeRep(x: Int    ): TypeRep[Int    ] = IntRep
+/*
+ implicit def typeRep[T](xs: List[T])(implicit rep: T => TypeRep[T]): TypeRep[List[T]] =
+   new ListRep(rep(xs.head))
+*/
+ implicit def typeRep[T <% TypeRep[T]](xs: List[T]): TypeRep[List[T]] =
+   new ListRep(xs.head)
+
+}
+
+object test extends App {
+ import typerep._
+ println(3.getType)
+ println(List(3).getType)
+}
diff --git a/tests/pos-scala2/viewtest1.scala b/tests/pos-scala2/viewtest1.scala
new file mode 100644
index 000000000..38945ad2f
--- /dev/null
+++ b/tests/pos-scala2/viewtest1.scala
@@ -0,0 +1,42 @@
+package test
+
+trait Ordered[a] {
+  def < (x: a): Boolean
+}
+
+object O {
+  implicit def view (x: String): Ordered[String] = new Ordered[String] {
+    def < (y: String) = x.compareTo(y) < 0
+  }
+}
+
+object Empty extends Tree[Nothing]
+case class Node[c <% Ordered[c]](elem: c, l: Tree[c], r: Tree[c]) extends Tree[c]
+
+abstract class Tree[+a <% Ordered[a]] {
+  def insert[b >: a <% Ordered[b]](x: b): Tree[b] = this match {
+    case Empty =>
+      new Node(x, Empty, Empty)
+    case Node(elem, l, r) =>
+      if (x == elem) this
+      else if (x < elem) Node(elem, l insert x, r)
+      else Node(elem, l, r insert x)
+  }
+  def elements: List[a] = this match {
+    case Empty => List()
+    case Node(elem, l, r) =>
+      l.elements ::: List(elem) ::: r.elements
+  }
+}
+
+object Test {
+  import O.view
+
+  def main(args: Array[String]): Unit = {
+    var t: Tree[String] = Empty
+    for (s <- args) {
+      t = t insert s
+    }
+    println(t.elements)
+  }
+}