Rename isContextual -> isContextualMethod

Author: odersky

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

@@ -231,7 +231,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
         def valueParam(name: TermName, origInfo: Type): TermSymbol = {
           val maybeImplicit =
-            if (tp.isContextual) Given
+            if (tp.isContextualMethod) Given
             else if (tp.isImplicitMethod) Implicit
             else EmptyFlags
           val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags

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

@@ -340,7 +340,7 @@ object Types {
     def isImplicitMethod: Boolean = false
 
     /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
-    def isContextual: Boolean = false
+    def isContextualMethod: Boolean = false
 
     /** Is this a MethodType for which the parameters will not be used? */
     def isErasedMethod: Boolean = false
@@ -1504,7 +1504,7 @@ 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 isContextual = mt.isContextual && !ctx.erasedTypes
+        val isContextual = mt.isContextualMethod && !ctx.erasedTypes
         val isErased = mt.isErasedMethod && !ctx.erasedTypes
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType()
@@ -3185,12 +3185,12 @@ object Types {
     final override def isImplicitMethod: Boolean =
       companion.eq(ImplicitMethodType) ||
       companion.eq(ErasedImplicitMethodType) ||
-      isContextual
+      isContextualMethod
     final override def isErasedMethod: Boolean =
       companion.eq(ErasedMethodType) ||
       companion.eq(ErasedImplicitMethodType) ||
       companion.eq(ErasedContextualMethodType)
-    final override def isContextual: Boolean =
+    final override def isContextualMethod: Boolean =
       companion.eq(ContextualMethodType) ||
       companion.eq(ErasedContextualMethodType)
 
@@ -3384,7 +3384,7 @@ object Types {
 
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
-    override def isContextual = resType.isContextual
+    override def isContextualMethod = resType.isContextualMethod
     override def isImplicitMethod = resType.isImplicitMethod
 
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported

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

@@ -260,8 +260,8 @@ class TreePickler(pickler: TastyPickler) {
       pickleMethodic(POLYtype, tpe)
     case tpe: MethodType if richTypes =>
       val tag = methodTypeTag(
-        isContextual = tpe.isContextual,
-        isImplicit = tpe.isImplicitMethod && !tpe.isContextual,
+        isContextual = tpe.isContextualMethod,
+        isImplicit = tpe.isImplicitMethod && !tpe.isContextualMethod,
         isErased = tpe.isErasedMethod)
       pickleMethodic(tag, tpe)
     case tpe: ParamRef =>

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

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

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

@@ -232,7 +232,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case dummyTreeOfType(tp) :: Nil if !(tp isRef defn.NullClass) => "null: " ~ toText(tp)
           case _ => toTextGlobal(args, ", ")
         }
-        return "[applied to " ~ (Str("given ") provided tp.isContextual) ~ (Str("erased ") provided tp.isErasedMethod) ~ "(" ~ argsText ~ ") returning " ~ toText(resultType) ~ "]"
+        return "[applied to " ~ (Str("given ") provided tp.isContextualMethod) ~ (Str("erased ") provided tp.isErasedMethod) ~ "(" ~ argsText ~ ") returning " ~ toText(resultType) ~ "]"
       case IgnoredProto(ignored) =>
         return "?" ~ (("(ignored: " ~ toText(ignored) ~ ")") provided ctx.settings.verbose.value)
       case tp @ PolyProto(targs, resType) =>

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

@@ -208,18 +208,18 @@ 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.isContextual) paramFlag |= Given
+    if (mt.isContextualMethod) paramFlag |= Given
     else if (mt.isImplicitMethod) paramFlag |= Implicit
     val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) =>
       ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withSpan(tree.span.startPos))
     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)
     val app = Apply(lifted, ids)
-    if (mt.isContextual) app.setGivenApply()
+    if (mt.isContextualMethod) 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))
+      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given))
       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/Typer.scala

@@ -2589,7 +2589,7 @@ class Typer extends Namer
             adapt(tree, pt.tupled, locked)
           else
             tree
-        else if (wtp.isContextual)
+        else if (wtp.isContextualMethod)
           adaptNoArgs(wtp)  // insert arguments implicitly
         else if (tree.symbol.isPrimaryConstructor && tree.symbol.info.firstParamTypes.isEmpty)
           readapt(tree.appliedToNone) // insert () to primary constructors
@@ -2687,7 +2687,7 @@ class Typer extends Namer
             }
             tryEither { implicit ctx =>
               val app = cpy.Apply(tree)(untpd.TypedSplice(tree), namedArgs)
-              if (wtp.isContextual) app.setGivenApply()
+              if (wtp.isContextualMethod) app.setGivenApply()
               typr.println(i"try with default implicit args $app")
               typed(app, pt, locked)
             } { (_, _) =>
@@ -3113,7 +3113,7 @@ 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.isGivenApply ||
+    methType.isContextualMethod == 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