Drop requirement that implicit/erased functions must be non-empty

It's the kind of trivial requirement we should not do. In the case of implicit
function types, it turns out that it even blocks something that would be useful!

Also, rename NonEmptyFunction to FunctionWithMods.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -869,7 +869,7 @@ object desugar {
 
   def makeImplicitFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
     val params = makeImplicitParameters(formals.map(TypeTree))
-    new NonEmptyFunction(params, body, Modifiers(Implicit))
+    new FunctionWithMods(params, body, Modifiers(Implicit))
   }
 
   /** Add annotation to tree:

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -56,13 +56,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType = body.isType
   }
 
-  /** A function type that should have non empty args */
-  class NonEmptyFunction(args: List[Tree], body: Tree, val mods: Modifiers) extends Function(args, body)
+  /** A function type with `implicit` or `erased` modifiers */
+  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers) extends Function(args, body)
 
   /** A function created from a wildcard expression
    *  @param  placeholderParams  a list of definitions of synthetic parameters.
    *  @param  body               the function body where wildcards are replaced by
    *                             references to synthetic parameters.
+   *  This is equivalent to Function, except that forms a special case for the overlapping
+   *  positions tests.
    */
   class WildcardFunction(placeholderParams: List[ValDef], body: Tree) extends Function(placeholderParams, body)
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -732,7 +732,7 @@ object Parsers {
       def functionRest(params: List[Tree]): Tree =
         atPos(start, accept(ARROW)) {
           val t = typ()
-          if (imods.is(Implicit) || imods.is(Erased)) new NonEmptyFunction(params, t, imods)
+          if (imods.is(Implicit) || imods.is(Erased)) new FunctionWithMods(params, t, imods)
           else Function(params, t)
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
@@ -800,7 +800,7 @@ object Parsers {
         case ARROW => functionRest(t :: Nil)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
-          if (imods.is(Implicit) && !t.isInstanceOf[NonEmptyFunction])
+          if (imods.is(Implicit) && !t.isInstanceOf[FunctionWithMods])
             syntaxError("Types with implicit keyword can only be function types", Position(start, start + nme.IMPLICITkw.asSimpleName.length))
           t
       }

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1722,26 +1722,6 @@ object messages {
     }
   }
 
-  case class FunctionTypeNeedsNonEmptyParameterList(isImplicit: Boolean, isErased: Boolean)(implicit ctx: Context)
-    extends Message(FunctionTypeNeedsNonEmptyParameterListID) {
-    assert(isImplicit || isErased)
-    val kind = "Syntax"
-    val mods = ((isErased, "erased") :: (isImplicit, "implicit") :: Nil).collect { case (true, mod) => mod }.mkString(" ")
-    val msg = mods + " function type needs non-empty parameter list"
-    val explanation = {
-      val code1 = s"type Transactional[T] = $mods Transaction => T"
-      val code2 = "val cl: implicit A => B"
-      hl"""It is not allowed to leave $mods function parameter list empty.
-         |Possible ways to define $mods function type:
-         |
-         |$code1
-         |
-         |or
-         |
-         |$code2""".stripMargin
-    }
-  }
-
   case class WrongNumberOfParameters(expected: Int)(implicit ctx: Context)
     extends Message(WrongNumberOfParametersID) {
     val kind = "Syntax"

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

@@ -761,13 +761,8 @@ class Typer extends Namer
   def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
     val untpd.Function(args, body) = tree
     val (isImplicit, isErased) = tree match {
-      case tree: untpd.NonEmptyFunction =>
-        if (args.nonEmpty) (tree.mods.is(Implicit), tree.mods.is(Erased))
-        else {
-          ctx.error(FunctionTypeNeedsNonEmptyParameterList(tree.mods.is(Implicit), tree.mods.is(Erased)), tree.pos)
-          (false, false)
-        }
-      case _ => (false, false)
+      case tree: untpd.FunctionWithMods => (tree.mods.is(Implicit), tree.mods.is(Erased))
+     case _ => (false, false)
     }
     val funCls = defn.FunctionClass(args.length, isImplicit, isErased)
 

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -873,20 +873,6 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals(err, WildcardOnTypeArgumentNotAllowedOnNew())
     }
 
-  @Test def implicitFunctionTypeNeedsNonEmptyParameterList =
-    checkMessagesAfter(RefChecks.name) {
-      """abstract class Foo {
-        |  type Contextual[T] = implicit () => T
-        |  val x: implicit () => Int
-        |}""".stripMargin
-    }
-    .expect { (ictx, messages) =>
-      implicit val ctx: Context = ictx
-
-      assertMessageCount(2, messages)
-      messages.foreach(assertEquals(_, FunctionTypeNeedsNonEmptyParameterList(isImplicit = true, isErased = false)))
-    }
-
   @Test def wrongNumberOfParameters =
     checkMessagesAfter(RefChecks.name) {
       """object NumberOfParams {
@@ -1310,48 +1296,6 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals(symbol.name.mangledString, "a")
   }
 
-  @Test def i4127a =
-    checkMessagesAfter(FrontEnd.name) {
-      """
-        |class Foo {
-        |  val x: implicit () => Int = () => 1
-        |}
-      """.stripMargin
-    }.expect { (ictx, messages) =>
-      implicit val ctx: Context = ictx
-      assertMessageCount(1, messages)
-      val (msg @ FunctionTypeNeedsNonEmptyParameterList(_, _)) :: Nil = messages
-      assertEquals(msg.mods, "implicit")
-    }
-
-  @Test def i4127b =
-    checkMessagesAfter(FrontEnd.name) {
-      """
-        |class Foo {
-        |  val x: erased () => Int = () => 1
-        |}
-      """.stripMargin
-    }.expect { (ictx, messages) =>
-      implicit val ctx: Context = ictx
-      assertMessageCount(1, messages)
-      val (msg @ FunctionTypeNeedsNonEmptyParameterList(_, _)) :: Nil = messages
-      assertEquals(msg.mods, "erased")
-    }
-
-  @Test def i4127c =
-    checkMessagesAfter(FrontEnd.name) {
-      """
-        |class Foo {
-        |  val x: erased implicit () => Int = () => 1
-        |}
-      """.stripMargin
-    }.expect { (ictx, messages) =>
-      implicit val ctx: Context = ictx
-      assertMessageCount(1, messages)
-      val (msg @ FunctionTypeNeedsNonEmptyParameterList(_, _)) :: Nil = messages
-      assertEquals(msg.mods, "erased implicit")
-    }
-
   @Test def renameImportTwice =
     checkMessagesAfter(PostTyper.name) {
       """