Rename internals to new terminologu

Token: INSTANCE -> IMPLIED
Flag: Contextual -> Given

Author: odersky

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

@@ -1086,8 +1086,8 @@ object desugar {
   }
 
   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))
+    val params = makeImplicitParameters(formals.map(TypeTree), Given)
+    new FunctionWithMods(params, body, Modifiers(Implicit | Given))
   }
 
   /** Add annotation to tree:

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

@@ -331,13 +331,13 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
   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 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(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
       params match {
-        case param :: _ => param.mods.is(Contextual)
+        case param :: _ => param.mods.is(Given)
         case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
       }
     case _ => false

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

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

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

@@ -132,7 +132,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Implicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.ImplicitCommon)
 
-    case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.ImplicitCommon | Flags.Contextual)
+    case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.ImplicitCommon | Flags.Given)
 
     case class Erased()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Erased)
 

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

@@ -347,8 +347,8 @@ object Flags {
   /** An extension method */
   final val Extension = termFlag(28, "<extension>")
 
-  /** A contextual (with) parameter */
-  final val Contextual = commonFlag(29, "<contextual>")
+  /** An inferable (`given`) parameter */
+  final val Given = commonFlag(29, "given")
 
   /** Symbol is defined by a Java class */
   final val JavaDefined: FlagSet = commonFlag(30, "<java>")

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

@@ -203,7 +203,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   DEFAULTparameterized                // Method with default parameters
                   STABLE                              // Method that is assumed to be stable
                   EXTENSION                           // An extension method
-                  CONTEXTUAL                          // new style implicit parameters, introduced with `with`
+                  GIVEN                               // new style implicit parameters, introduced with `given`
                   PARAMsetter                         // A setter without a body named `x_=` where `x` is pickled as a PARAM
                   Annotation
 
@@ -323,7 +323,7 @@ object TastyFormat {
   final val ERASED = 34
   final val OPAQUE = 35
   final val EXTENSION = 36
-  final val CONTEXTUAL = 37
+  final val GIVEN = 37
   final val PARAMsetter = 38
 
   // Cat. 2:    tag Nat
@@ -497,7 +497,7 @@ object TastyFormat {
        | DEFAULTparameterized
        | STABLE
        | EXTENSION
-       | CONTEXTUAL
+       | GIVEN
        | PARAMsetter
        | ANNOTATION
        | PRIVATEqualified
@@ -558,7 +558,7 @@ object TastyFormat {
     case DEFAULTparameterized => "DEFAULTparameterized"
     case STABLE => "STABLE"
     case EXTENSION => "EXTENSION"
-    case CONTEXTUAL => "CONTEXTUAL"
+    case GIVEN => "GIVEN"
     case PARAMsetter => "PARAMsetter"
 
     case SHAREDterm => "SHAREDterm"

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

@@ -655,7 +655,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       if (flags is StableRealizable) writeByte(STABLE)
       if (flags is Extension) writeByte(EXTENSION)
-      if (flags is Contextual) writeByte(CONTEXTUAL)
+      if (flags is Given) writeByte(GIVEN)
       if (flags is ParamAccessor) writeByte(PARAMsetter)
       assert(!(flags is Label))
     } else {

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

@@ -632,7 +632,7 @@ class TreeUnpickler(reader: TastyReader,
           case DEFAULTparameterized => addFlag(DefaultParameterized)
           case STABLE => addFlag(StableRealizable)
           case EXTENSION => addFlag(Extension)
-          case CONTEXTUAL => addFlag(Contextual)
+          case GIVEN => addFlag(Given)
           case PARAMsetter =>
             addFlag(ParamAccessor)
           case PRIVATEqualified =>

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

@@ -783,7 +783,7 @@ object Parsers {
       def functionRest(params: List[Tree]): Tree =
         atSpan(start, accept(ARROW)) {
           val t = typ()
-          if (imods.is(Implicit | Contextual | Erased)) new FunctionWithMods(params, t, imods)
+          if (imods.is(Implicit | Given | Erased)) new FunctionWithMods(params, t, imods)
           else Function(params, t)
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
@@ -2090,7 +2090,7 @@ object Parsers {
 
       // begin paramClause
       inParens {
-      	val isContextual = impliedMods.is(Contextual)
+      	val isContextual = impliedMods.is(Given)
         if (in.token == RPAREN && !prefix && !isContextual) Nil
         else {
           def funArgMods(mods: Modifiers): Modifiers =
@@ -2123,10 +2123,10 @@ object Parsers {
         val initialMods =
           if (in.token == GIVEN) {
             in.nextToken()
-            Modifiers(Contextual | Implicit)
+            Modifiers(Given | Implicit)
           }
           else EmptyModifiers
-        val isContextual = initialMods.is(Contextual)
+        val isContextual = initialMods.is(Given)
         newLineOptWhenFollowedBy(LPAREN)
         if (in.token == LPAREN) {
           if (ofInstance && !isContextual)
@@ -2137,14 +2137,14 @@ object Parsers {
               firstClause = firstClause,
               initialMods = initialMods)
           val lastClause =
-            params.nonEmpty && params.head.mods.flags.is(Implicit, butNot = Contextual)
+            params.nonEmpty && params.head.mods.flags.is(Implicit, butNot = Given)
           params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length))
         }
         else if (isContextual) {
           val tps = commaSeparated(refinedType)
           var counter = nparams
           def nextIdx = { counter += 1; counter }
-          val params = tps.map(makeSyntheticParameter(nextIdx, _, Contextual | Implicit))
+          val params = tps.map(makeSyntheticParameter(nextIdx, _, Given | Implicit))
           params :: recur(firstClause = false, nparams + params.length)
         }
         else Nil
@@ -2438,7 +2438,7 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           enumDef(start, mods, atSpan(in.skipToken()) { Mod.Enum() })
-        case INSTANCE =>
+        case IMPLIED =>
           instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Instance() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())

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

@@ -178,7 +178,7 @@ object Tokens extends TokensCommon {
   final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
-  final val INSTANCE = 64;         enter(INSTANCE, "implied")
+  final val IMPLIED = 64;          enter(IMPLIED, "implied")
   final val GIVEN = 65;            enter(GIVEN, "given")
 
   /** special symbols */
@@ -223,7 +223,7 @@ object Tokens extends TokensCommon {
 
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, INSTANCE)
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, IMPLIED)
 
   final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
 
@@ -251,7 +251,7 @@ object Tokens extends TokensCommon {
 
   final val numericLitTokens: TokenSet = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
 
-  final val scala3keywords = BitSet(ENUM, ERASED, GIVEN, INSTANCE)
+  final val scala3keywords = BitSet(ENUM, ERASED, GIVEN, IMPLIED)
 
   final val softModifierNames = Set(nme.inline, nme.opaque)
 }