Fix #2642: Disallow nullary implicit function types

Author: odersky

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

@@ -740,7 +740,10 @@ class Definitions {
   lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
 
   def FunctionClass(n: Int, isImplicit: Boolean = false)(implicit ctx: Context) =
-    if (isImplicit) ctx.requiredClass("scala.ImplicitFunction" + n.toString)
+    if (isImplicit) {
+      require(n > 0)
+      ctx.requiredClass("scala.ImplicitFunction" + n.toString)
+    }
     else if (n <= MaxImplementedFunctionArity) FunctionClassPerRun()(ctx)(n)
     else ctx.requiredClass("scala.Function" + n.toString)
 
@@ -773,12 +776,12 @@ class Definitions {
 
   /** Is a function class.
    *   - FunctionN for N >= 0
-   *   - ImplicitFunctionN for N >= 0
+   *   - ImplicitFunctionN for N > 0
    */
   def isFunctionClass(cls: Symbol) = scalaClassName(cls).isFunction
 
   /** Is an implicit function class.
-   *   - ImplicitFunctionN for N >= 0
+   *   - ImplicitFunctionN for N > 0
    */
   def isImplicitFunctionClass(cls: Symbol) = scalaClassName(cls).isImplicitFunction
 
@@ -790,7 +793,7 @@ class Definitions {
 
   /** Is a synthetic function class
    *    - FunctionN for N > 22
-   *    - ImplicitFunctionN for N >= 0
+   *    - ImplicitFunctionN for N > 0
    */
   def isSyntheticFunctionClass(cls: Symbol) = scalaClassName(cls).isSyntheticFunction
 

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

@@ -687,7 +687,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") {
     val untpd.Function(args, body) = tree
     if (ctx.mode is Mode.Type) {
-      val funCls = defn.FunctionClass(args.length, tree.isInstanceOf[untpd.ImplicitFunction])
+      val isImplicit = tree match {
+        case _: untpd.ImplicitFunction =>
+          if (args.length == 0) {
+            ctx.error(i"implicit function type needs non-empty parameter list", tree.pos)
+            false
+          }
+          else true
+        case _ => false
+      }
+      val funCls = defn.FunctionClass(args.length, isImplicit)
       typed(cpy.AppliedTypeTree(tree)(
         untpd.TypeTree(funCls.typeRef), args :+ body), pt)
     }

tests/neg/i2642.scala

@@ -0,0 +1,4 @@
+object Foo {
+  type X = implicit () => Int // error: implicit function needs parameters
+  def ff: X = () // error: found: Unit, expected: X
+}