Fix #876: Allow implicit conversions from singleton types

I found a way to make this efficient (hopefully).

Author: odersky

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

@@ -598,15 +598,6 @@ trait Checking {
         defn.ObjectType
     }
 
-  /** Check that a non-implicit parameter making up the first parameter section of an
-   *  implicit conversion is not a singleton type.
-   */
-  def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = vparamss match {
-    case (vparam :: Nil) :: _ if !(vparam.symbol is Implicit) =>
-      checkNotSingleton(vparam.tpt, " to be parameter type of an implicit conversion")
-    case _ =>
-  }
-
   /** If `sym` is an implicit conversion, check that implicit conversions are enabled.
    *  @pre  sym.is(Implicit)
    */
@@ -948,7 +939,6 @@ trait NoChecking extends ReChecking {
   override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree
   override def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkClassType(tp: Type, pos: Position, traitReq: Boolean, stablePrefixReq: Boolean)(implicit ctx: Context): Type = tp
-  override def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = ()
   override def checkImplicitConversionDefOK(sym: Symbol)(implicit ctx: Context): Unit = ()
   override def checkImplicitConversionUseOK(sym: Symbol, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp

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

@@ -80,15 +80,17 @@ object Implicits {
           case mt: MethodType =>
             mt.isImplicitMethod ||
             mt.paramInfos.lengthCompare(1) != 0 ||
-            !ctx.test(implicit ctx => argType relaxed_<:< mt.paramInfos.head)
+            !ctx.test(implicit ctx =>
+              argType relaxed_<:< mt.paramInfos.head.widenSingleton)
           case poly: PolyType =>
             // We do not need to call ProtoTypes#constrained on `poly` because
             // `refMatches` is always called with mode TypevarsMissContext enabled.
             poly.resultType match {
               case mt: MethodType =>
                 mt.isImplicitMethod ||
                 mt.paramInfos.length != 1 ||
-                !ctx.test(implicit ctx => argType relaxed_<:< wildApprox(mt.paramInfos.head, null, Set.empty))
+                !ctx.test(implicit ctx =>
+                  argType relaxed_<:< wildApprox(mt.paramInfos.head.widenSingleton, null, Set.empty))
               case rtp =>
                 discardForView(wildApprox(rtp, null, Set.empty), argType)
             }
@@ -132,14 +134,37 @@ object Implicits {
           case _ => false
         }
 
+        /** Widen singleton arguments of implicit conversions to their underlying type.
+         *  This is necessary so that they can be found eligible for the argument type.
+         *  Note that we always take the underlying type of a singleton type as the argument
+         *  type, so that we get a reasonable implicit cache hit ratio.
+         */
+        def adjustSingletonArg(tp: Type): Type = tp match {
+          case tp: PolyType =>
+            val res = adjustSingletonArg(tp.resType)
+            if (res `eq` tp.resType) tp else tp.derivedLambdaType(resType = res)
+          case tp: MethodType =>
+            tp.paramInfos match {
+              case (single: SingletonType) :: Nil =>
+                tp.derivedLambdaType(paramInfos = single.widenSingleton :: Nil)
+              case _ =>
+                tp
+            }
+          case _ => tp
+        }
+
         (ref.symbol isAccessibleFrom ref.prefix) && {
           if (discard) {
             record("discarded eligible")
             false
           }
           else {
             val ptNorm = normalize(pt, pt) // `pt` could be implicit function types, check i2749
-            NoViewsAllowed.isCompatible(normalize(ref, pt), ptNorm)
+            val refAdjusted =
+              if (pt.isInstanceOf[ViewProto]) adjustSingletonArg(ref.widenSingleton)
+              else ref
+            val refNorm = normalize(refAdjusted, pt)
+            NoViewsAllowed.isCompatible(refNorm, ptNorm)
           }
         }
       }

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

@@ -1413,10 +1413,7 @@ class Typer extends Namer
     val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
     vparamss1.foreach(checkNoForwardDependencies)
-    if (sym is Implicit) {
-      checkImplicitParamsNotSingletons(vparamss1)
-      checkImplicitConversionDefOK(sym)
-    }
+    if (sym is Implicit) checkImplicitConversionDefOK(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
 
     var rhsCtx = ctx