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.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -338,6 +338,8 @@ class Definitions {
   def DottyPredefModule(implicit ctx: Context) = DottyPredefModuleRef.symbol
 
     def Predef_eqAny(implicit ctx: Context) = DottyPredefModule.requiredMethod(nme.eqAny)
+    lazy val Predef_ImplicitConverterR = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
+    def Predef_ImplicitConverter(implicit ctx: Context) = Predef_ImplicitConverterR.symbol
 
   lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
   def DottyArraysModule(implicit ctx: Context) = DottyArraysModuleRef.symbol

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -86,35 +86,25 @@ object Implicits {
             // However, Predef.$conforms is not eligible, because it is a no-op.
             //
             // In principle, it would be cleanest if only implicit methods qualified
-            // as implicit conversions. The reasons for deviating are as follows:
-            // Keeping Function1: It's still used quite often (for instance, view
-            // bounds map to implicits of function types) and there is no feasible workaround.
-            // One tempting workaround would be to add a global def
-            //
-            //    implicit def convertIfFuntion1[A, B](x: A)(implicit ev: A => B): B = ev(a)
-            //
-            // But that would throw out the baby with the bathwater. Now, every subtype of
-            // function gives again rise to an implicit conversion. So it's better to just accept
-            // function types in their dual roles.
-            //
-            // The reason for the treatment of <:< and conforms is similar. We could
-            // avoid the clause by having a standard conversion like this in Predef:
+            // as implicit conversions. We could achieve that by having standard conversions like
+            // this in Predef:
             //
             //    implicit def convertIfConforms[A, B](x: A)(implicit ev: A <:< B): B = ev(a)
+            //    implicit def convertIfConverter[A, B](x: A)(implicit ev: ImplicitConverter[A, B]): B = ev(a)
             //
-            // But that would slow down implicit search a lot, because this conversion is
-            // eligible for all pairs of types, and therefore is tried a lot. So we
-            // emulate the existence of a such a conversion directly in the search.
+            // (Once `<:<` inherits from `ImplicitConverter` we only need the 2nd one.)
+            // But clauses like this currently slow down implicit search a lot, because
+            // they are eligible for all pairs of types, and therefore are tried too often.
+            // We emulate instead these conversions directly in the search.
             // The reason for leaving out `Predef_conforms` is that we know it adds
             // nothing since it only relates subtype with supertype.
             //
             // We keep the old behavior under -language:Scala2.
-            val isFunction =
-              if (ctx.scala2Mode) tpw.derivesFrom(defn.FunctionClass(1))
-              else tpw.isRef(defn.FunctionClass(1))
+            val isFunctionInS2 = ctx.scala2Mode && tpw.derivesFrom(defn.FunctionClass(1))
+            val isImplicitConverter = tpw.derivesFrom(defn.Predef_ImplicitConverter)
             val isConforms =
               tpw.derivesFrom(defn.Predef_Conforms) && ref.symbol != defn.Predef_conforms
-            !(isFunction || isConforms)
+            !(isFunctionInS2 || isImplicitConverter || isConforms)
         }
 
         def discardForValueType(tpw: Type): Boolean = tpw match {

library/src/dotty/DottyPredef.scala

@@ -36,4 +36,24 @@ object DottyPredef {
   implicit def eqNumFloat : Eq[Number, Float]  = Eq
   implicit def eqDoubleNum: Eq[Double, Number] = Eq
   implicit def eqNumDouble: Eq[Number, Double] = Eq
+
+  /** A class for implicit values that can serve as implicit conversions
+   *  The implicit resolution algorithm will act as if there existed
+   *  the additional implicit definition:
+   *
+   *    def $implicitConversion[T, U](x: T)(c: ImplicitConverter[T, U]): U = c(x)
+   *
+   *  However, the presence of this definition would slow down implicit search since
+   *  its outermost type matches any pair of types. Therefore, implicit search
+   *  contains a special case in `Implicits#discardForView` which emulates the
+   *  conversion in a more efficient way.
+   *
+   *  Note that this is a SAM class - function literals are automatically converted
+   *  to `ImplicitConverter` values.
+   *
+   *  Also note that in bootstrapped dotty, `Predef.<:<` should inherit from
+   *  `ImplicitConverter`. This would cut the number of special cases in
+   *  `discardForView` from two to one.
+   */
+  abstract class ImplicitConverter[-T, +U] extends Function1[T, U]
 }

tests/pos/typerep-stephane.scala renamed to tests/pos-scala2/typerep-stephane.scala

@@ -15,7 +15,7 @@ object ImplicitProblem {
     def eval = f(nullval[T]).eval + 1
   }
 
-  def depth[T](n: T)(implicit ev: T => Rep[T]) = n.eval
+  def depth[T](n: T)(implicit ev: T => Rep[T]) = ev(n).eval
 
   def main(args: Array[String]): Unit = {
     println(depth(nullval[M[Int]]))  // (1) this works

tests/pos/viewtest1.scala renamed to tests/pos-scala2/viewtest1.scala

@@ -11,7 +11,9 @@ object Test extends dotty.runtime.LegacyApp {
   val maxKey = 50
   val maxValue = 50
 
-  def testSet[A <% Ordered[A]](set: SortedSet[A], list: List[A]): Unit = {
+  implicit def convertIfView[A](x: A)(implicit view: A => Ordered[A]): Ordered[A] = view(x)
+
+  def testSet[A: Ordering](set: SortedSet[A], list: List[A]): Unit = {
     val distinctSorted = list.distinct.sorted
     assertEquals("Set size wasn't the same as list sze", set.size, distinctSorted.size)
 
@@ -24,7 +26,7 @@ object Test extends dotty.runtime.LegacyApp {
     }
   }
 
-  def testMap[A <% Ordered[A], B](map: SortedMap[A, B], list: List[(A, B)]): Unit = {
+  def testMap[A: Ordering, B](map: SortedMap[A, B], list: List[(A, B)]): Unit = {
     val distinctSorted = distinctByKey(list).sortBy(_._1)
     assertEquals("Map size wasn't the same as list sze", map.size, distinctSorted.size)
 

tests/pos/t0786.scala

@@ -74,14 +74,14 @@ object Moop3 {
       // Dotty deviation. This fails for Dotty with ambiguity error for similar reasons as ob1.
   }
   object ob2 {
-    implicit val f1: Int => String  = _ => "Int"
+    implicit val f1: ImplicitConverter[Int, String]  = _ => "Int"
     implicit def f2(x: Long): String = "Long"
 
     println(5: String)
   }
   object ob3 {
-    implicit val f1: Int => String  = _ => "Int"
-    implicit val f2: Long => String = _ => "Long"
+    implicit val f1: ImplicitConverter[Int, String]  = _ => "Int"
+    implicit val f2: ImplicitConverter[Long, String] = _ => "Long"
 
     println(5: String)
   }