Add modifier to NonEmptyFunction and replace ImplicitFunction

Author: nicolasstucki

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

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

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

@@ -50,29 +50,14 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    */
   case class InterpolatedString(id: TermName, segments: List[Tree]) extends TermTree
 
-  /** An function type */
+  /** A function type */
   case class Function(args: List[Tree], body: Tree) extends Tree {
     override def isTerm = body.isTerm
     override def isType = body.isType
   }
 
-  /** An function type that should have non empty args */
-  abstract class NonEmptyFunction(args: List[Tree], body: Tree) extends Function(args, body)
-
-  /** An implicit function type */
-  class ImplicitFunction(args: List[Tree], body: Tree) extends NonEmptyFunction(args, body) {
-    override def toString = s"ImplicitFunction($args, $body)"
-  }
-
-  /** An function type with unused arguments */
-  class UnusedFunction(args: List[Tree], body: Tree) extends NonEmptyFunction(args, body) {
-    override def toString = s"UnusedFunction($args, $body)"
-  }
-
-  /** An implicit function type with unused arguments */
-  class UnusedImplicitFunction(args: List[Tree], body: Tree) extends NonEmptyFunction(args, body) {
-    override def toString = s"UnusedImplicitFunction($args, $body)"
-  }
+  /** 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 created from a wildcard expression
    *  @param  placeHolderParams  a list of definitions of synthetic parameters

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

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

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

@@ -761,12 +761,12 @@ class Typer extends Namer
   def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
     val untpd.Function(args, body) = tree
     val (isImplicit, isUnused) = tree match {
-      case _: untpd.NonEmptyFunction if args.isEmpty =>
-        ctx.error(FunctionTypeNeedsNonEmptyParameterList(), tree.pos)
-        (false, false)
-      case _: untpd.UnusedImplicitFunction => (true, true)
-      case _: untpd.ImplicitFunction => (true, false)
-      case _: untpd.UnusedFunction => (false, true)
+      case tree: untpd.NonEmptyFunction =>
+        if (args.nonEmpty) (tree.mods.is(Implicit), tree.mods.is(Unused))
+        else {
+          ctx.error(FunctionTypeNeedsNonEmptyParameterList(), tree.pos)
+          (false, false)
+        }
       case _ => (false, false)
     }
     val funCls = defn.FunctionClass(args.length, isImplicit, isUnused)