Merge pull request #4549 from dotty-staging/change-inline-untpd

Drop requirement that implicit functions must be non-empty

Author: odersky

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

@@ -813,12 +813,12 @@ object desugar {
    *
    *  If `inlineable` is true, tag $anonfun with an @inline annotation.
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), inlineable: Boolean)(implicit ctx: Context) = {
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isInlineable: Boolean, isImplicit: Boolean)(implicit ctx: Context) = {
     var mods = synthetic | Artifact
-    if (inlineable) mods |= Inline
+    if (isInlineable) mods |= Inline
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(mods),
-      Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
+      Closure(Nil, Ident(nme.ANON_FUN), if (isImplicit) ImplicitEmptyTree else EmptyTree))
   }
 
   /** If `nparams` == 1, expand partial function
@@ -863,7 +863,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/TreeInfo.scala

@@ -298,11 +298,15 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
   def isImplicitClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    case tree: FunctionWithMods => tree.mods.is(Implicit)
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Implicit)
     case Closure(_, meth, _) => true
     case Block(Nil, expr) => isImplicitClosure(expr)
-    case Block(DefDef(nme.ANON_FUN, _, (param :: _) :: _, _, _) :: Nil, _: Closure) =>
-      param.mods.is(Implicit)
+    case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
+      params match {
+        case param :: _ => param.mods.is(Implicit)
+        case Nil => cl.tpt.eq(untpd.ImplicitEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
+      }
     case _ => false
   }
 

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

@@ -884,6 +884,7 @@ object Trees {
 
     @sharable val EmptyTree: Thicket = genericEmptyTree
     @sharable val EmptyValDef: ValDef = genericEmptyValDef
+    @sharable val ImplicitEmptyTree: Thicket = Thicket(Nil) // an empty tree marking an implicit closure
 
     // ----- Auxiliary creation methods ------------------
 

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/core/Definitions.scala

@@ -861,22 +861,17 @@ class Definitions {
 
   lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
 
-  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context) = {
-    if (isImplicit && isErased) {
-      require(n > 0)
+  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context) =
+    if (isImplicit && isErased)
       ctx.requiredClass("scala.ErasedImplicitFunction" + n.toString)
-    }
-    else if (isImplicit) {
-      require(n > 0)
+    else if (isImplicit)
       ctx.requiredClass("scala.ImplicitFunction" + n.toString)
-    }
-    else if (isErased) {
-      require(n > 0)
+    else if (isErased)
       ctx.requiredClass("scala.ErasedFunction" + n.toString)
-    }
-    else if (n <= MaxImplementedFunctionArity) FunctionClassPerRun()(ctx)(n)
-    else ctx.requiredClass("scala.Function" + n.toString)
-  }
+    else if (n <= MaxImplementedFunctionArity)
+      FunctionClassPerRun()(ctx)(n)
+    else
+      ctx.requiredClass("scala.Function" + n.toString)
 
     lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
     def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
@@ -907,14 +902,14 @@ class Definitions {
 
   /** Is a function class.
    *   - FunctionN for N >= 0
-   *   - ImplicitFunctionN for N > 0
+   *   - ImplicitFunctionN for N >= 0
    *   - ErasedFunctionN for N > 0
    *   - ErasedImplicitFunctionN for N > 0
    */
   def isFunctionClass(cls: Symbol) = scalaClassName(cls).isFunction
 
   /** Is an implicit function class.
-   *   - ImplicitFunctionN for N > 0
+   *   - ImplicitFunctionN for N >= 0
    *   - ErasedImplicitFunctionN for N > 0
    */
   def isImplicitFunctionClass(cls: Symbol) = scalaClassName(cls).isImplicitFunction
@@ -948,7 +943,7 @@ class Definitions {
    *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
    *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
-   *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - ImplicitFunctionN for N <= 22 becomes FunctionN
    *    - ErasedFunctionN becomes Function0
    *    - ImplicitErasedFunctionN becomes Function0
    *    - anything else becomes a NoSymbol
@@ -965,7 +960,7 @@ class Definitions {
    *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
    *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
-   *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - ImplicitFunctionN for N <= 22 becomes FunctionN
    *    - ErasedFunctionN becomes Function0
    *    - ImplicitErasedFunctionN becomes Function0
    *    - anything else becomes a NoType

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

@@ -167,59 +167,42 @@ object NameOps {
       }
     }
 
-    /** Is a synthetic function name
-     *    - N for FunctionN
-     *    - N for ImplicitFunctionN (N >= 1)
-      *   - (-1) otherwise
-     */
     def functionArity: Int =
-      functionArityFor(str.Function) max {
+      functionArityFor(str.Function) max
+      functionArityFor(str.ImplicitFunction) max {
         val n =
-          functionArityFor(str.ImplicitFunction) max
           functionArityFor(str.ErasedFunction) max
           functionArityFor(str.ErasedImplicitFunction)
         if (n == 0) -1 else n
       }
 
-    /** Is a function name
-     *    - FunctionN for N >= 0
-     *    - ImplicitFunctionN for N >= 1
-     *    - ErasedFunctionN for N >= 1
-     *    - ErasedImplicitFunctionN for N >= 1
-     *    - false otherwise
+    /** Is a function name, i.e one of FunctionN, ImplicitFunctionN for N >= 0 or ErasedFunctionN, ErasedImplicitFunctionN for N > 0
      */
     def isFunction: Boolean = functionArity >= 0
 
-    /** Is a implicit function name
-     *    - ImplicitFunctionN for N >= 1
-     *    - ErasedImplicitFunctionN for N >= 1
-     *    - false otherwise
+    /** Is an implicit function name, i.e one of ImplicitFunctionN for N >= 0 or ErasedImplicitFunctionN for N > 0
      */
     def isImplicitFunction: Boolean = {
-      functionArityFor(str.ImplicitFunction) >= 1 ||
-      functionArityFor(str.ErasedImplicitFunction) >= 1
+      functionArityFor(str.ImplicitFunction) >= 0 ||
+      functionArityFor(str.ErasedImplicitFunction) > 0
     }
 
-    /** Is a implicit function name
-      *    - ErasedFunctionN for N >= 1
-      *    - ErasedImplicitFunctionN for N >= 1
-      *    - false otherwise
+    /** Is an erased function name, i.e. one of ErasedFunctionN, ErasedImplicitFunctionN for N > 0
       */
     def isErasedFunction: Boolean = {
-      functionArityFor(str.ErasedFunction) >= 1 ||
-      functionArityFor(str.ErasedImplicitFunction) >= 1
+      functionArityFor(str.ErasedFunction) > 0 ||
+      functionArityFor(str.ErasedImplicitFunction) > 0
     }
 
-    /** Is a synthetic function name
+    /** Is a synthetic function name, i.e. one of
      *    - FunctionN for N > 22
-     *    - ImplicitFunctionN for N >= 1
-     *    - ErasedFunctionN for N >= 1
-     *    - ErasedImplicitFunctionN for N >= 1
-     *    - false otherwise
+     *    - ImplicitFunctionN for N >= 0
+     *    - ErasedFunctionN for N > 0
+     *    - ErasedImplicitFunctionN for N > 0
      */
     def isSyntheticFunction: Boolean = {
       functionArityFor(str.Function) > MaxImplementedFunctionArity ||
-      functionArityFor(str.ImplicitFunction) >= 1 ||
+      functionArityFor(str.ImplicitFunction) >= 0 ||
       isErasedFunction
     }
 

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

@@ -2893,7 +2893,6 @@ object Types {
     final override def isImplicitMethod: Boolean = companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType)
     final override def isErasedMethod: Boolean = companion.eq(ErasedMethodType) || companion.eq(ErasedImplicitMethodType)
 
-
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
       resultSignature.prepend(params, isJavaMethod)

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

@@ -1720,26 +1720,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/transform/ExpandSAMs.scala

@@ -15,12 +15,14 @@ import dotty.tools.dotc.util.Positions.Position
  *  These fall into five categories
  *
  *   1. Partial function closures, we need to generate isDefinedAt and applyOrElse methods for these.
- *   2. Closures implementing non-trait classes.
+ *   2. Closures implementing non-trait classes
  *   3. Closures implementing classes that inherit from a class other than Object
  *      (a lambda cannot not be a run-time subtype of such a class)
  *   4. Closures that implement traits which run initialization code.
  *   5. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
  *      (1) superaccessors, (2) outer references, (3) accessors for fields.
+ *
+ *  However, implicit function types do not count as SAM types.
  */
 class ExpandSAMs extends MiniPhase {
   override def phaseName = "expandSAMs"
@@ -34,7 +36,10 @@ class ExpandSAMs extends MiniPhase {
   override def transformBlock(tree: Block)(implicit ctx: Context): Tree = tree match {
     case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
       tpt.tpe match {
-        case NoType => tree // it's a plain function
+        case NoType =>
+          tree // it's a plain function
+        case tpe if defn.isImplicitFunctionType(tpe) =>
+          tree
         case tpe @ SAMType(_) if tpe.isRef(defn.PartialFunctionClass) =>
           val tpe1 = checkRefinements(tpe, fn.pos)
           toPartialFunction(tree, tpe1)