Rename more usages of Contextual

Author: odersky

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

@@ -1121,7 +1121,7 @@ object desugar {
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, if (tpt == null) TypeTree() else tpt, body)
         .withMods(synthetic | Artifact),
-      Closure(Nil, Ident(nme.ANON_FUN), if (isGiven) ContextualEmptyTree else EmptyTree))
+      Closure(Nil, Ident(nme.ANON_FUN), if (isGiven) GivenClosureEmptyTree else EmptyTree))
 
   /** If `nparams` == 1, expand partial function
    *
@@ -1174,7 +1174,7 @@ object desugar {
     Function(param :: Nil, Block(vdefs, body))
   }
 
-  def makeContextualFunction(formals: List[Type], body: Tree, isErased: Boolean)(implicit ctx: Context): Tree = {
+  def makeGivenFunction(formals: List[Type], body: Tree, isErased: Boolean)(implicit ctx: Context): Tree = {
     val mods = if (isErased) Given | Erased else Given
     val params = makeImplicitParameters(formals.map(TypeTree), mods)
     new FunctionWithMods(params, body, Modifiers(mods))

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

@@ -327,15 +327,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 isContextualClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+  def isGivenClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
     case tree: FunctionWithMods => tree.mods.is(Given)
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Given)
     case Closure(_, meth, _) => true
-    case Block(Nil, expr) => isContextualClosure(expr)
+    case Block(Nil, expr) => isGivenClosure(expr)
     case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
       params match {
         case param :: _ => param.mods.is(Given)
-        case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
+        case Nil => cl.tpt.eq(untpd.GivenClosureEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
       }
     case _ => false
   }

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

@@ -992,7 +992,7 @@ object Trees {
 
     @sharable val EmptyTree: Thicket = genericEmptyTree
     @sharable val EmptyValDef: ValDef = genericEmptyValDef
-    @sharable val ContextualEmptyTree: Thicket = new EmptyTree // an empty tree marking a contextual closure
+    @sharable val GivenClosureEmptyTree: Thicket = new EmptyTree // an empty tree marking a contextual closure
 
     // ----- Auxiliary creation methods ------------------
 

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

@@ -71,8 +71,9 @@ object Types {
    *        +- GroundType -+- AndType
    *                       +- OrType
    *                       +- MethodOrPoly ---+-- PolyType
-   *                                          +-- MethodType ---+- ImplicitMethodType
-   *                                                            +- ContextualMethodType
+   *                       |                  +-- MethodType ---+- ImplicitMethodType
+   *                       |                                    +- GivenMethodType
+   *                       |                                    +- ErasedMethodType
    *                       |                                    +- JavaMethodType
    *                       +- ClassInfo
    *                       |
@@ -3189,10 +3190,10 @@ object Types {
     final override def isErasedMethod: Boolean =
       companion.eq(ErasedMethodType) ||
       companion.eq(ErasedImplicitMethodType) ||
-      companion.eq(ErasedContextualMethodType)
+      companion.eq(ErasedGivenMethodType)
     final override def isGivenMethod: Boolean =
-      companion.eq(ContextualMethodType) ||
-      companion.eq(ErasedContextualMethodType)
+      companion.eq(GivenMethodType) ||
+      companion.eq(ErasedGivenMethodType)
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
@@ -3293,7 +3294,7 @@ object Types {
         JavaMethodType
       }
       else if (isGiven)
-        if (isErased) ErasedContextualMethodType else ContextualMethodType
+        if (isErased) ErasedGivenMethodType else GivenMethodType
       else if (isOldImplicit)
         if (isErased) ErasedImplicitMethodType else ImplicitMethodType
       else
@@ -3302,8 +3303,8 @@ object Types {
   }
   object JavaMethodType extends MethodTypeCompanion("JavaMethodType")
   object ErasedMethodType extends MethodTypeCompanion("ErasedMethodType")
-  object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
-  object ErasedContextualMethodType extends MethodTypeCompanion("ErasedContextualMethodType")
+  object GivenMethodType extends MethodTypeCompanion("GivenMethodType")
+  object ErasedGivenMethodType extends MethodTypeCompanion("ErasedGivenMethodType")
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
   object ErasedImplicitMethodType extends MethodTypeCompanion("ErasedImplicitMethodType")
 

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

@@ -352,9 +352,9 @@ class TreeUnpickler(reader: TastyReader,
             case ERASEDMETHODtype =>
               readMethodic(ErasedMethodType, _.toTermName)
             case GIVENMETHODtype =>
-              readMethodic(ContextualMethodType, _.toTermName)
+              readMethodic(GivenMethodType, _.toTermName)
             case ERASEDGIVENMETHODtype =>
-              readMethodic(ErasedContextualMethodType, _.toTermName)
+              readMethodic(ErasedGivenMethodType, _.toTermName)
             case IMPLICITMETHODtype =>
               readMethodic(ImplicitMethodType, _.toTermName)
             case TYPELAMBDAtype =>

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

@@ -1000,7 +1000,7 @@ class Typer extends Namer
                      |because it has internal parameter dependencies,
                      |position = ${tree.span}, raw type = ${mt.toString}""") // !!! DEBUG. Eventually, convert to an error?
                 }
-                else if ((tree.tpt `eq` untpd.ContextualEmptyTree) && mt.paramNames.isEmpty)
+                else if ((tree.tpt `eq` untpd.GivenClosureEmptyTree) && mt.paramNames.isEmpty)
                   // Note implicitness of function in target type since there are no method parameters that indicate it.
                   TypeTree(defn.FunctionOf(Nil, mt.resType, isGiven = true, isErased = false))
                 else
@@ -2179,10 +2179,10 @@ class Typer extends Namer
         val ifpt = defn.asImplicitFunctionType(pt)
         val result = if (ifpt.exists &&
             xtree.isTerm &&
-            !untpd.isContextualClosure(xtree) &&
+            !untpd.isGivenClosure(xtree) &&
             !ctx.mode.is(Mode.Pattern) &&
             !ctx.isAfterTyper)
-          makeContextualFunction(xtree, ifpt)
+          makeGivenFunction(xtree, ifpt)
         else xtree match {
           case xtree: untpd.NameTree => typedNamed(xtree, pt)
           case xtree => typedUnnamed(xtree)
@@ -2203,9 +2203,9 @@ class Typer extends Namer
     tree
   }
 
-  protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
+  protected def makeGivenFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
     val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement
-    val ifun = desugar.makeContextualFunction(formals, tree, defn.isErasedFunctionType(pt))
+    val ifun = desugar.makeGivenFunction(formals, tree, defn.isErasedFunctionType(pt))
     typr.println(i"make contextual function $tree / $pt ---> $ifun")
     typed(ifun, pt)
   }
@@ -2779,7 +2779,7 @@ class Typer extends Namer
     def adaptNoArgsOther(wtp: Type): Tree = {
       ctx.typeComparer.GADTused = false
       if (isImplicitFunctionRef(wtp) &&
-          !untpd.isContextualClosure(tree) &&
+          !untpd.isGivenClosure(tree) &&
           !isApplyProto(pt) &&
           !ctx.mode.is(Mode.Pattern) &&
           !ctx.isAfterTyper) {