Adding checks for implicit definitions

1) Result type may not be empty
2) Parameters of implicit conversions may not be singletons

Reason for 2) is that we can do a much better caching for eligible implicits if we can widen singleton arguments in ViewProto. This leads to consicderable speedups in implicit search which seem to be hard to get without the restriction.

Author: odersky

src/dotty/tools/dotc/typer/Inferencing.scala

@@ -425,10 +425,28 @@ object Inferencing {
         checkStable(tp.prefix, pos)
         tp
     case _ =>
-      ctx.error(s"$tp is not a class type", pos)
+      ctx.error(i"$tp is not a class type", pos)
       defn.ObjectClass.typeRef
   }
 
+  /** Check that (return) type of implicit definition is not empty */
+  def checkImplicitTptNonEmpty(defTree: untpd.ValOrDefDef)(implicit ctx: Context): Unit = defTree.tpt match {
+    case TypeTree(original) if original.isEmpty =>
+      val resStr = if (defTree.isInstanceOf[untpd.DefDef]) "result " else ""
+      ctx.error(i"${resStr}type of implicit definition needs to be given explicitly", defTree.pos)
+    case _ =>
+  }
+
+  /** 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) =>
+      if (vparam.tpt.tpe.isInstanceOf[SingletonType])
+        ctx.error(s"implicit conversion may not have a parameter of singleton type", vparam.tpt.pos)
+    case _ =>
+  }
+
   /** Ensure that first typeref in a list of parents points to a non-trait class.
    *  If that's not already the case, add one.
    */

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

@@ -862,6 +862,7 @@ class Typer extends Namer with Applications with Implicits {
     val ValDef(mods, name, tpt, rhs) = vdef
     val mods1 = typedModifiers(mods)
     val tpt1 = typedType(tpt)
+    if (sym is Implicit) checkImplicitTptNonEmpty(vdef)
     val rhs1 = rhs match {
       case Ident(nme.WILDCARD) => rhs withType tpt1.tpe
       case _ => typedExpr(rhs, tpt1.tpe)
@@ -875,6 +876,10 @@ class Typer extends Namer with Applications with Implicits {
     val mods1 = typedModifiers(mods)
     val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
+    if (sym is Implicit) {
+      checkImplicitTptNonEmpty(ddef)
+      checkImplicitParamsNotSingletons(vparamss1)
+    }
     val tpt1 = typedType(tpt)
     val rhs1 = typedExpr(rhs, tpt1.tpe)
     cpy.DefDef(ddef, mods1, name, tparams1, vparamss1, tpt1, rhs1).withType(sym.termRefWithSig)