Changes to implicit function types

 - Introduce `|=>` syntax for implicit function types and implicit closures
 - Drop old `implicit A => B` syntax
 - Make implicit function types contextual, i.e. parameters have to be passed
   with `with`.

Author: odersky

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

@@ -150,11 +150,11 @@ object desugar {
     else vdef
   }
 
-  def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
+  def makeImplicitParameters(tpts: List[Tree], contextualFlag: FlagSet = EmptyFlags, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
        val epname = EvidenceParamName.fresh()
-       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
+       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit | contextualFlag)
     }
 
   /** 1. Expand context bounds to evidence params. E.g.,
@@ -189,7 +189,7 @@ object desugar {
     val epbuf = new ListBuffer[ValDef]
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
       case ContextBounds(tbounds, cxbounds) =>
-        epbuf ++= makeImplicitParameters(cxbounds, isPrimaryConstructor)
+        epbuf ++= makeImplicitParameters(cxbounds, forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
         cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))
@@ -957,10 +957,10 @@ object desugar {
    *      def $anonfun(params) = body
    *      Closure($anonfun)
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isImplicit: Boolean)(implicit ctx: Context): Block =
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isContextual: Boolean)(implicit ctx: Context): Block =
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic | Artifact),
-      Closure(Nil, Ident(nme.ANON_FUN), if (isImplicit) ImplicitEmptyTree else EmptyTree))
+      Closure(Nil, Ident(nme.ANON_FUN), if (isContextual) ContextualEmptyTree else EmptyTree))
 
   /** If `nparams` == 1, expand partial function
    *
@@ -1013,9 +1013,9 @@ object desugar {
     Function(param :: Nil, Block(vdefs, body))
   }
 
-  def makeImplicitFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
-    val params = makeImplicitParameters(formals.map(TypeTree))
-    new FunctionWithMods(params, body, Modifiers(Implicit))
+  def makeContextualFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
+    val params = makeImplicitParameters(formals.map(TypeTree), Contextual)
+    new FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
   }
 
   /** Add annotation to tree:

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

@@ -330,15 +330,15 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     functionWithUnknownParamType(tree).isDefined
 
   /** 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)
+  def isContextualClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    case tree: FunctionWithMods => tree.mods.is(Contextual)
+    case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Contextual)
     case Closure(_, meth, _) => true
-    case Block(Nil, expr) => isImplicitClosure(expr)
+    case Block(Nil, expr) => isContextualClosure(expr)
     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 param :: _ => param.mods.is(Contextual)
+        case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
       }
     case _ => false
   }

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

@@ -937,7 +937,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
+    @sharable val ContextualEmptyTree: Thicket = Thicket(Nil) // an empty tree marking a contextual closure
 
     // ----- Auxiliary creation methods ------------------
 

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

@@ -98,8 +98,8 @@ class Definitions {
    *
    *  ImplicitFunctionN traits follow this template:
    *
-   *      trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object with FunctionN[T0,...,T{N-1}, R] {
-   *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
+   *        def apply with ($x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    *
    *  ErasedFunctionN traits follow this template:
@@ -110,8 +110,8 @@ class Definitions {
    *
    *  ErasedImplicitFunctionN traits follow this template:
    *
-   *      trait ErasedImplicitFunctionN[T0,...,T{N-1}, R] extends Object with ErasedFunctionN[T0,...,T{N-1}, R] {
-   *        def apply(erased implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      trait ErasedImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
+   *        def apply with (erased $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    *
    *  ErasedFunctionN and ErasedImplicitFunctionN erase to Function0.
@@ -127,13 +127,14 @@ class Definitions {
           enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
         }
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
-        val methodType = MethodType.maker(isJava = false, name.isImplicitFunction, name.isErasedFunction)
-        val parentTraits =
-          if (!name.isImplicitFunction) Nil
-          else FunctionType(arity, isErased = name.isErasedFunction).appliedTo(argParamRefs ::: resParamRef :: Nil) :: Nil
+        val methodType = MethodType.maker(
+          isJava = false,
+          isImplicit = name.isImplicitFunction,
+          isContextual = name.isImplicitFunction,
+          isErased = name.isErasedFunction)
         decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
         denot.info =
-          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
+          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
       }
     }
     newClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
@@ -830,9 +831,8 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    // TODO: make implicit function types contextual
-    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Type =
-      FunctionType(args.length, isImplicit, isErased).appliedTo(args ::: resultType :: Nil)
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Type =
+      FunctionType(args.length, isContextual, isErased).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context): Option[(List[Type], Type, Boolean, Boolean)] = {
       val tsym = ft.typeSymbol
       if (isFunctionClass(tsym)) {
@@ -920,10 +920,10 @@ class Definitions {
 
   lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
-  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Symbol =
-    if (isImplicit && isErased)
+  def FunctionClass(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Symbol =
+    if (isContextual && isErased)
       ctx.requiredClass("scala.ErasedImplicitFunction" + n.toString)
-    else if (isImplicit)
+    else if (isContextual)
       ctx.requiredClass("scala.ImplicitFunction" + n.toString)
     else if (isErased)
       ctx.requiredClass("scala.ErasedFunction" + n.toString)
@@ -935,9 +935,9 @@ class Definitions {
     lazy val Function0_applyR: TermRef = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
     def Function0_apply(implicit ctx: Context): Symbol = Function0_applyR.symbol
 
-  def FunctionType(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
-    if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
-    else FunctionClass(n, isImplicit, isErased).typeRef
+  def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
+    if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
+    else FunctionClass(n, isContextual, isErased).typeRef
 
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =

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

@@ -337,6 +337,9 @@ object Types {
     /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
     def isContextual: Boolean = false
 
+    /** Is this a Method or PolyType which has implicit parameters as first value parameter list? */
+    def isImplicit: Boolean = false
+
     /** Is this a MethodType for which the parameters will not be used */
     def isErasedMethod: Boolean = false
 
@@ -1432,11 +1435,11 @@ object Types {
     def toFunctionType(dropLast: Int = 0)(implicit ctx: Context): Type = this match {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
-        val isImplicit = mt.isImplicitMethod && !ctx.erasedTypes
+        val isContextual = mt.isContextual && !ctx.erasedTypes
         val isErased = mt.isErasedMethod && !ctx.erasedTypes
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)),
-          mt.nonDependentResultApprox, isImplicit, isErased)
+          mt.nonDependentResultApprox, isContextual, isErased)
         if (mt.isResultDependent) RefinedType(funType, nme.apply, mt)
         else funType
     }
@@ -3056,10 +3059,17 @@ object Types {
 
     final override def isJavaMethod: Boolean = companion eq JavaMethodType
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType) || isContextual
-    final override def isErasedMethod: Boolean = companion.eq(ErasedMethodType) || companion.eq(ErasedImplicitMethodType)
+      companion.eq(ImplicitMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      isContextual
+    final override def isErasedMethod: Boolean =
+      companion.eq(ErasedMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      companion.eq(ErasedContextualMethodType)
     final override def isContextual: Boolean =
-      companion.eq(ContextualMethodType) || companion.eq(ErasedContextualMethodType)
+      companion.eq(ContextualMethodType) ||
+      companion.eq(ErasedContextualMethodType)
+    final override def isImplicit = isImplicitMethod
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
@@ -3252,6 +3262,7 @@ object Types {
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
     override def isContextual = resType.isContextual
+    override def isImplicit = resType.isImplicit
 
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.

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

@@ -352,15 +352,15 @@ object Parsers {
 
     /** Convert tree to formal parameter list
     */
-    def convertToParams(tree: Tree): List[ValDef] = tree match {
-      case Parens(t)  => convertToParam(t) :: Nil
-      case Tuple(ts)  => ts map (convertToParam(_))
-      case t          => convertToParam(t) :: Nil
+    def convertToParams(tree: Tree, mods: Modifiers): List[ValDef] = tree match {
+      case Parens(t)  => convertToParam(t, mods) :: Nil
+      case Tuple(ts)  => ts map (convertToParam(_, mods))
+      case t          => convertToParam(t, mods) :: Nil
     }
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, mods: Modifiers = Modifiers(), expected: String = "formal parameter"): ValDef = tree match {
+    def convertToParam(tree: Tree, mods: Modifiers, expected: String = "formal parameter"): ValDef = tree match {
       case Ident(name) =>
         makeParameter(name.asTermName, TypeTree(), mods) withPos tree.pos
       case Typed(Ident(name), tpt) =>
@@ -754,7 +754,7 @@ object Parsers {
      */
     def toplevelTyp(): Tree = checkWildcard(typ())
 
-    /** Type        ::=  [FunArgMods] FunArgTypes `=>' Type
+    /** Type        ::=  [‘erased’] FunArgTypes (‘=>’ | ‘|=>’) Type
      *                |  HkTypeParamClause `->' Type
      *                |  InfixType
      *  FunArgTypes ::=  InfixType
@@ -763,11 +763,20 @@ object Parsers {
      */
     def typ(): Tree = {
       val start = in.offset
-      val imods = modifiers(funArgMods)
+      val imods = modifiers(BitSet(ERASED))
       def functionRest(params: List[Tree]): Tree =
-        atPos(start, accept(ARROW)) {
+        atPos(start, in.offset) {
+          val pmods =
+            if (in.token == CARROW) {
+              in.nextToken()
+              imods | (Contextual | Implicit)
+            }
+            else {
+              accept(ARROW)
+              imods
+            }
           val t = typ()
-          if (imods.is(Implicit) || imods.is(Erased)) new FunctionWithMods(params, t, imods)
+          if (pmods.flags.is(Implicit | Contextual | Erased)) new FunctionWithMods(params, t, pmods)
           else Function(params, t)
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
@@ -801,7 +810,8 @@ object Parsers {
             }
             openParens.change(LPAREN, -1)
             accept(RPAREN)
-            if (imods.is(Implicit) || isValParamList || in.token == ARROW) functionRest(ts)
+            if (imods.is(Implicit) || isValParamList || in.token == ARROW || in.token == CARROW)
+              functionRest(ts)
             else {
               val ts1 =
                 for (t <- ts) yield {
@@ -832,7 +842,7 @@ object Parsers {
         else infixType()
 
       in.token match {
-        case ARROW => functionRest(t :: Nil)
+        case ARROW | CARROW => functionRest(t :: Nil)
         case MATCH => matchType(EmptyTree, t)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
@@ -1109,6 +1119,7 @@ object Parsers {
     }
 
     /** Expr              ::=  [FunArgMods] FunParams =>' Expr
+     *                      |  [‘erased’] FunParams ‘|=>’ Expr
      *                      |  Expr1
      *  FunParams         ::=  Bindings
      *                      |  id
@@ -1157,9 +1168,11 @@ object Parsers {
         finally placeholderParams = saved
 
         val t = expr1(location)
-        if (in.token == ARROW) {
+        if (in.token == ARROW || in.token == CARROW) {
           placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
-          wrapPlaceholders(closureRest(start, location, convertToParams(t)))
+          val impliedMods =
+            if (in.token == CARROW) Modifiers(Implicit | Contextual) else EmptyModifiers
+          wrapPlaceholders(closureRest(start, location, convertToParams(t, impliedMods)))
         }
         else if (isWildcard(t)) {
           placeholderParams = placeholderParams ::: saved
@@ -1340,16 +1353,28 @@ object Parsers {
       }
       else ident()
 
-    /** Expr         ::= implicit id `=>' Expr
+    /** Expr         ::= FunArgMods FunParams `=>' Expr
+     *                 | [‘erased’] FunParams ‘|=>’ Expr
      *  BlockResult  ::= implicit id [`:' InfixType] `=>' Block // Scala2 only
      */
     def implicitClosure(start: Int, location: Location.Value, implicitMods: Modifiers): Tree =
       closureRest(start, location, funParams(implicitMods, location))
 
     def closureRest(start: Int, location: Location.Value, params: List[Tree]): Tree =
       atPos(start, in.offset) {
-        accept(ARROW)
-        Function(params, if (location == Location.InBlock) block() else expr())
+        val params1 =
+          if (in.token == CARROW) {
+            in.nextToken()
+            params.map {
+              case param: ValDef => param.withMods(param.mods | (Implicit | Contextual))
+              case param => param
+            }
+          }
+          else {
+            accept(ARROW)
+            params
+          }
+        Function(params1, if (location == Location.InBlock) block() else expr())
       }
 
     /** PostfixExpr   ::= InfixExpr [id [nl]]
@@ -2622,7 +2647,7 @@ object Parsers {
             case Typed(tree @ This(EmptyTypeIdent), tpt) =>
               self = makeSelfDef(nme.WILDCARD, tpt).withPos(first.pos)
             case _ =>
-              val ValDef(name, tpt, _) = convertToParam(first, expected = "self type clause")
+              val ValDef(name, tpt, _) = convertToParam(first, EmptyModifiers, "self type clause")
               if (name != nme.ERROR)
                 self = makeSelfDef(name, tpt).withPos(first.pos)
           }

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

@@ -112,7 +112,8 @@ abstract class TokensCommon {
   //final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   //final val HASH = 82;             enter(HASH, "#")
   final val AT = 83;               enter(AT, "@")
-  //final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%") // TODO: deprecate
+  //final val CARROW = 84;
+  //final val VIEWBOUND = 85;        enter(VIEWBOUND, "<%") // TODO: deprecate
 
   val keywords: TokenSet
 
@@ -192,10 +193,11 @@ object Tokens extends TokensCommon {
   final val SUBTYPE = 80;          enter(SUBTYPE, "<:")
   final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   final val HASH = 82;             enter(HASH, "#")
-  final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%") // TODO: deprecate
-  final val QPAREN = 85;           enter(QPAREN, "'(")
-  final val QBRACE = 86;           enter(QBRACE, "'{")
-  final val QBRACKET = 87;         enter(QBRACKET, "'[")
+  final val CARROW = 84;           enter(CARROW, "|=>")
+  final val VIEWBOUND = 85;        enter(VIEWBOUND, "<%") // TODO: deprecate
+  final val QPAREN = 86;           enter(QPAREN, "'(")
+  final val QBRACE = 87;           enter(QBRACE, "'{")
+  final val QBRACKET = 88;         enter(QBRACKET, "'[")
 
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate