Rename isContextual -> isGivenApply

Rename isContextual -> isGivenApply in Apply nodes and FunProtos

Author: odersky

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

@@ -503,10 +503,9 @@ object desugar {
       val nu = (makeNew(classTypeRef) /: vparamss) { (nu, vparams) =>
         val app = Apply(nu, vparams.map(refOfDef))
         vparams match {
-          case vparam :: _ if vparam.mods.is(Given) => app.pushAttachment(ApplyGiven, ())
-          case _ =>
+          case vparam :: _ if vparam.mods.is(Given) => app.setGivenApply()
+          case _ => app
         }
-        app
       }
       ensureApplied(nu)
         //.reporting(res => i"CREATE $cdef = $res")

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

@@ -436,7 +436,8 @@ object Trees {
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
 
-    def isContextual = getAttachment(untpd.ApplyGiven).nonEmpty
+    def isGivenApply = getAttachment(untpd.ApplyGiven).nonEmpty
+    def setGivenApply() = { pushAttachment(untpd.ApplyGiven, ()); this }
   }
 
   /** fun[args] */

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

@@ -589,15 +589,12 @@ object Parsers {
       recur(first)
     }
 
-    def applyGiven(t: Tree, operand: () => Tree): Tree = {
-      val app = atSpan(startOffset(t), in.offset) {
+    def applyGiven(t: Tree, operand: () => Tree): Tree =
+      atSpan(startOffset(t), in.offset) {
         in.nextToken()
         val args = if (in.token == LPAREN) parArgumentExprs() else operand() :: Nil
         Apply(t, args)
-      }
-      app.pushAttachment(ApplyGiven, ())
-      app
-    }
+      }.setGivenApply()
 
 /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
 

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

@@ -341,7 +341,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         optDotPrefix(tree) ~ keywordStr("this") ~ idText(tree)
       case Super(qual: This, mix) =>
         optDotPrefix(qual) ~ keywordStr("super") ~ optText(mix)("[" ~ _ ~ "]")
-      case Apply(fun, args) =>
+      case app @ Apply(fun, args) =>
         if (fun.hasType && fun.symbol == defn.throwMethod)
           changePrec (GlobalPrec) {
             keywordStr("throw ") ~ toText(args.head)
@@ -350,7 +350,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           keywordStr("'{") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
         else if (!ctx.settings.YprintDebug.value && fun.hasType && fun.symbol == defn.InternalQuoted_exprSplice)
           keywordStr("${") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
-        else if (tree.getAttachment(untpd.ApplyGiven).isDefined && !homogenizedView)
+        else if (app.isGivenApply && !homogenizedView)
           changePrec(InfixPrec) {
             toTextLocal(fun) ~ " given " ~
             (if (args.length == 1) toTextLocal(args.head) else "(" ~ toTextGlobal(args, ", ") ~ ")")

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

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

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

@@ -802,7 +802,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isContextual)(argCtx(tree))
+      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isGivenApply)(argCtx(tree))
       record("typedApply")
       val fun1 = typedFunPart(tree.fun, originalProto)
 

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

@@ -215,9 +215,9 @@ object EtaExpansion extends LiftImpure {
     var ids: List[Tree] = mt.paramNames map (name => Ident(name).withSpan(tree.span.startPos))
     if (mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam)
       ids = ids.init :+ repeated(ids.last)
-    var body: Tree = Apply(lifted, ids)
-    if (mt.isContextual) body.pushAttachment(ApplyGiven, ())
-    if (!isLastApplication) body = PostfixOp(body, Ident(nme.WILDCARD))
+    val app = Apply(lifted, ids)
+    if (mt.isContextual) app.setGivenApply()
+    val body = if (isLastApplication) app else PostfixOp(app, Ident(nme.WILDCARD))
     val fn =
       if (mt.isContextual) new untpd.FunctionWithMods(params, body, Modifiers(Given))
       else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(OldImplicit))

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

@@ -244,7 +244,7 @@ object ProtoTypes {
    *  [](args): resultType
    */
   case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
-    override val isContextual: Boolean, state: FunProtoState = new FunProtoState)(implicit val ctx: Context)
+    val isGivenApply: Boolean, state: FunProtoState = new FunProtoState)(implicit val ctx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(implicit ctx: Context): Type = resType
 
@@ -258,7 +258,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, isContextual)
+      else new FunProto(args, resultType)(typer, isGivenApply)
 
     override def notApplied: Type = WildcardType
 
@@ -342,7 +342,7 @@ object ProtoTypes {
       case pt: FunProto =>
         pt
       case _ =>
-        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, isContextual)
+        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, isGivenApply)
         tupled
     }
 
@@ -377,14 +377,14 @@ object ProtoTypes {
 
     override def withContext(newCtx: Context): ProtoType =
       if (newCtx `eq` ctx) this
-      else new FunProto(args, resType)(typer, isContextual, state)(newCtx)
+      else new FunProto(args, resType)(typer, isGivenApply, 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, isContextual: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isContextual)(ctx) {
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isGivenApply: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isGivenApply)(ctx) {
     override def unforcedTypedArgs(implicit ctx: Context): List[tpd.Tree] = args
     override def withContext(ctx: Context): FunProtoTyped = this
   }
@@ -431,7 +431,7 @@ object ProtoTypes {
   }
 
   class UnapplyFunProto(argType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(
-    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer, isContextual = false)
+    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer, isGivenApply = false)
 
   /** A prototype for expressions [] that are type-parameterized:
    *

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

@@ -912,7 +912,7 @@ class Typer extends Namer
               expr1.tpe
             case _ =>
               val protoArgs = args map (_ withType WildcardType)
-              val callProto = FunProto(protoArgs, WildcardType)(this, isContextual = app.isContextual)
+              val callProto = FunProto(protoArgs, WildcardType)(this, app.isGivenApply)
               val expr1 = typedExpr(expr, callProto)
               fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
               expr1.tpe
@@ -2551,7 +2551,7 @@ class Typer extends Namer
             errorTree(tree, NoMatchingOverload(altDenots, pt)(err))
           def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
           pt match {
-            case pt: FunProto if !pt.isContextual =>
+            case pt: FunProto if !pt.isGivenApply =>
               // insert apply or convert qualifier only for a regular application
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
@@ -2687,7 +2687,7 @@ class Typer extends Namer
             }
             tryEither { implicit ctx =>
               val app = cpy.Apply(tree)(untpd.TypedSplice(tree), namedArgs)
-              if (wtp.isContextual) app.pushAttachment(untpd.ApplyGiven, ())
+              if (wtp.isContextual) app.setGivenApply()
               typr.println(i"try with default implicit args $app")
               typed(app, pt, locked)
             } { (_, _) =>
@@ -3113,8 +3113,8 @@ class Typer extends Namer
    *  Overridden in `ReTyper`, where all applications are treated the same
    */
   protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(implicit ctx: Context): Boolean =
-    methType.isContextual == pt.isContextual ||
-    methType.isImplicitMethod && pt.isContextual // for a transition allow `with` arguments for regular implicit parameters
+    methType.isContextual == pt.isGivenApply ||
+    methType.isImplicitMethod && pt.isGivenApply // for a transition allow `with` arguments for regular implicit parameters
 
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
    *  against a selector of type `pt`. This implementation accounts for