Type checking of contextual applications

Author: odersky

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

@@ -444,6 +444,8 @@ object Trees {
   case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
+
+    def isContextual = getAttachment(untpd.WithApply).nonEmpty
   }
 
   /** fun[args] */

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

@@ -227,7 +227,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
         def valueParam(name: TermName, origInfo: Type): TermSymbol = {
           val maybeImplicit =
-            if (tp.isContextualMethod) Implicit | Contextual
+            if (tp.isContextual) Implicit | Contextual
             else if (tp.isImplicitMethod) Implicit
             else EmptyFlags
           val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags
@@ -1030,9 +1030,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type], expectedType: Type)(implicit ctx: Context): Tree = {
+  def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type],
+                      expectedType: Type, isContextual: Boolean = false)(implicit ctx: Context): Tree = {
     val typer = ctx.typer
-    val proto = new FunProtoTyped(args, expectedType)(typer)
+    val proto = new FunProtoTyped(args, expectedType)(typer, isContextual)
     val denot = receiver.tpe.member(method)
     assert(denot.exists, i"no member $receiver . $method, members = ${receiver.tpe.decls}")
     val selected =

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

@@ -334,8 +334,8 @@ object Types {
     /** Is this a MethodType which has implicit or contextual parameters */
     def isImplicitMethod: Boolean = false
 
-    /** Is this a MethodType which has contextual parameters */
-    def isContextualMethod: Boolean = false
+    /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
+    def isContextual: Boolean = false
 
     /** Is this a MethodType for which the parameters will not be used */
     def isErasedMethod: Boolean = false
@@ -3056,10 +3056,10 @@ object Types {
 
     final override def isJavaMethod: Boolean = companion eq JavaMethodType
     final override def isImplicitMethod: Boolean =
-      companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType) || isContextualMethod
-    final override def isContextualMethod: Boolean =
-      companion.eq(ContextualMethodType) || companion.eq(ErasedContextualMethodType)
+      companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType) || isContextual
     final override def isErasedMethod: Boolean = companion.eq(ErasedMethodType) || companion.eq(ErasedImplicitMethodType)
+    final override def isContextual: Boolean =
+      companion.eq(ContextualMethodType) || companion.eq(ErasedContextualMethodType)
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
@@ -3251,6 +3251,8 @@ object Types {
 
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
+    override def isContextual = resType.isContextual
+
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.
      */

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -255,7 +255,7 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: PolyType if richTypes =>
       pickleMethodic(POLYtype, tpe)
     case tpe: MethodType if richTypes =>
-      pickleMethodic(methodType(tpe.isContextualMethod, tpe.isImplicitMethod, tpe.isErasedMethod), tpe)
+      pickleMethodic(methodType(tpe.isContextual, tpe.isImplicitMethod, tpe.isErasedMethod), tpe)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
     case tpe: LazyRef =>

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -181,9 +181,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         "<noprefix>"
       case tp: MethodType =>
         changePrec(GlobalPrec) {
-          (if (tp.isContextualMethod) " with " else "") ~
+          (if (tp.isContextual) " with " else "") ~
           ("(" + (if (tp.isErasedMethod)   "erased "   else "")
-               + (if (tp.isImplicitMethod && !tp.isContextualMethod) "implicit " else "")
+               + (if (tp.isImplicitMethod && !tp.isContextual) "implicit " else "")
           ) ~ paramsText(tp) ~
           (if (tp.resultType.isInstanceOf[MethodType]) ")" else "): ") ~
           toText(tp.resultType)

compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala

@@ -14,7 +14,7 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
   def MethodTypeDeco(tpe: MethodType): MethodTypeAPI = new MethodTypeAPI {
     def isErased: Boolean = tpe.isErasedMethod
     def isImplicit: Boolean = tpe.isImplicitMethod
-    def isContextual: Boolean = tpe.isContextualMethod
+    def isContextual: Boolean = tpe.isContextual
     def paramNames(implicit ctx: Context): List[String] = tpe.paramNames.map(_.toString)
     def paramTypes(implicit ctx: Context): List[Type] = tpe.paramInfos
     def resultTpe(implicit ctx: Context): Type = tpe.resType

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -502,7 +502,7 @@ object Erasure {
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)
-      else typedExpr(fun, FunProto(args, pt)(this)) match {
+      else typedExpr(fun, FunProto(args, pt)(this, isContextual = false)) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1
         case fun1 =>

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

@@ -743,10 +743,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  Block node.
    */
   def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
-    val isContextual = tree.getAttachment(untpd.WithApply).nonEmpty
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this)(argCtx(tree))
+      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isContextual)(argCtx(tree))
       val fun1 = typedExpr(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as

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

@@ -206,7 +206,7 @@ object EtaExpansion extends LiftImpure {
       if (isLastApplication && mt.paramInfos.length == xarity) mt.paramInfos map (_ => TypeTree())
       else mt.paramInfos map TypeTree
     var paramFlag = Synthetic | Param
-    if (mt.isContextualMethod) paramFlag |= Contextual
+    if (mt.isContextual) paramFlag |= Contextual
     if (mt.isImplicitMethod) paramFlag |= Implicit
     val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) =>
       ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withPos(tree.pos.startPos))
@@ -216,7 +216,7 @@ object EtaExpansion extends LiftImpure {
     var body: Tree = Apply(lifted, ids)
     if (!isLastApplication) body = PostfixOp(body, Ident(nme.WILDCARD))
     val fn =
-      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
+      if (mt.isContextual) new untpd.FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
       else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
       else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn

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

@@ -224,7 +224,8 @@ object ProtoTypes {
    *
    *  [](args): resultType
    */
-  case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
+  case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
+    override val isContextual: Boolean, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(implicit ctx: Context): Type = resType
 
@@ -233,7 +234,7 @@ object ProtoTypes {
 
     def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer): FunProto =
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
-      else new FunProto(args, resultType)(typer)
+      else new FunProto(args, resultType)(typer, isContextual)
 
     override def notApplied: Type = WildcardType
 
@@ -317,7 +318,7 @@ object ProtoTypes {
       case pt: FunProto =>
         pt
       case _ =>
-        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer)
+        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, isContextual)
         tupled
     }
 
@@ -352,14 +353,14 @@ object ProtoTypes {
 
     override def withContext(newCtx: Context): ProtoType =
       if (newCtx `eq` ctx) this
-      else new FunProto(args, resType)(typer, state)(newCtx)
+      else new FunProto(args, resType)(typer, isContextual, state)(newCtx)
   }
 
   /** A prototype for expressions that appear in function position
    *
    *  [](args): resultType, where args are known to be typed
    */
-  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer)(implicit ctx: Context) extends FunProto(args, resultType)(typer)(ctx) {
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isContextual: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isContextual)(ctx) {
     override def typedArgs: List[tpd.Tree] = args
     override def withContext(ctx: Context): FunProtoTyped = this
   }
@@ -406,7 +407,7 @@ object ProtoTypes {
   }
 
   class UnapplyFunProto(argType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(
-    untpd.TypedSplice(dummyTreeOfType(argType))(ctx) :: Nil, WildcardType)(typer)
+    untpd.TypedSplice(dummyTreeOfType(argType))(ctx) :: Nil, WildcardType)(typer, isContextual = false)
 
   /** A prototype for expressions [] that are type-parameterized:
    *

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

@@ -857,7 +857,7 @@ class Typer extends Namer
       *         every parameter in `params`.
       */
     def calleeType: Type = fnBody match {
-      case Apply(expr, args) =>
+      case app @ Apply(expr, args) =>
         paramIndex = {
           for (param <- params; idx <- paramIndices(param, args))
           yield param.name -> idx
@@ -868,7 +868,7 @@ class Typer extends Namer
               expr1.tpe
             case _ =>
               val protoArgs = args map (_ withType WildcardType)
-              val callProto = FunProto(protoArgs, WildcardType)(this)
+              val callProto = FunProto(protoArgs, WildcardType)(this, isContextual = app.isContextual)
               val expr1 = typedExpr(expr, callProto)
               fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
               expr1.tpe
@@ -2239,7 +2239,8 @@ class Typer extends Namer
               errorTree(tree, NoMatchingOverload(altDenots, pt)(err))
             def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
             pt match {
-              case pt: FunProto =>
+              case pt: FunProto if !pt.isContextual =>
+              	// insert apply or convert qualifier only for a regular application
                 tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
               case _ =>
                 if (altDenots exists (_.info.paramInfoss == ListOfNil))
@@ -2269,11 +2270,16 @@ class Typer extends Namer
       }
 
       def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
-        case _: MethodOrPoly =>
-          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
-            adapt(tree, pt.tupled, locked)
+        case wtp: MethodOrPoly =>
+          if (wtp.isContextual == pt.isContextual)
+            if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
+              adapt(tree, pt.tupled, locked)
+            else
+              tree
+          else if (wtp.isContextual)
+            adaptNoArgs(wtp)  // insert arguments implicitly
           else
-            tree
+            errorTree(tree, em"Missing arguments for ${methPart(tree).symbol.showLocated}")
         case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
           errorTree(tree, MethodDoesNotTakeParameters(tree))
         }