Rename ctx method in Context

odersky · odersky · commit dfd1fbe768fe · 2020-04-03T11:32:14.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -84,7 +84,7 @@ object Contexts {
        with Plugins
        with Cloneable { thiscontext =>
 
-    implicit def ctx: Context = this
+    implicit def thisContext: Context = this
 
     /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
     def outersIterator: Iterator[Context] = new Iterator[Context] {
@@ -284,10 +284,10 @@ object Contexts {
       withPhase(phase.id)
 
     final def withPhaseNoLater(phase: Phase): Context =
-      if (phase.exists && ctx.phase.id > phase.id) withPhase(phase) else ctx
+      if (phase.exists && this.phase.id > phase.id) withPhase(phase) else this
 
     final def withPhaseNoEarlier(phase: Phase): Context =
-      if (phase.exists && ctx.phase.id < phase.id) withPhase(phase) else ctx
+      if (phase.exists && this.phase.id < phase.id) withPhase(phase) else this
 
     // `creationTrace`-related code. To enable, uncomment the code below and the
     // call to `setCreationTrace()` in this file.
@@ -399,15 +399,15 @@ object Contexts {
     def exprContext(stat: Tree[? >: Untyped], exprOwner: Symbol): Context =
       if (exprOwner == this.owner) this
       else if (untpd.isSuperConstrCall(stat) && this.owner.isClass) superCallContext
-      else ctx.fresh.setOwner(exprOwner)
+      else fresh.setOwner(exprOwner)
 
     /** A new context that summarizes an import statement */
     def importContext(imp: Import[?], sym: Symbol): FreshContext = {
       val impNameOpt = imp.expr match {
         case ref: RefTree[?] => Some(ref.name.asTermName)
         case _               => None
       }
-      ctx.fresh.setImportInfo(ImportInfo(sym, imp.selectors, impNameOpt))
+      fresh.setImportInfo(ImportInfo(sym, imp.selectors, impNameOpt))
     }
 
     /** Does current phase use an erased types interpretation? */
diff --git a/compiler/src/dotty/tools/dotc/core/Periods.scala b/compiler/src/dotty/tools/dotc/core/Periods.scala
@@ -7,7 +7,7 @@ import Contexts._
  *  run ids represent compiler runs
  *  phase ids represent compiler phases
  */
-abstract class Periods { self: Context =>
+abstract class Periods { thisCtx: Context =>
   import Periods._
 
   /** The current phase identifier */
@@ -18,11 +18,11 @@ abstract class Periods { self: Context =>
 
   /** Execute `op` at given period */
   def atPeriod[T](pd: Period)(op: Context => T): T =
-    op(ctx.fresh.setPeriod(pd))
+    op(thisCtx.fresh.setPeriod(pd))
 
   /** Execute `op` at given phase id */
   def atPhase[T](pid: PhaseId)(op: Context ?=> T): T =
-    op(using ctx.withPhase(pid))
+    op(using thisCtx.withPhase(pid))
 
   /** The period containing the current period where denotations do not change.
    *  We compute this by taking as first phase the first phase less or equal to
@@ -31,19 +31,19 @@ abstract class Periods { self: Context =>
    */
   def stablePeriod: Period = {
     var first = phaseId
-    val nxTrans = ctx.base.nextDenotTransformerId(first)
-    while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans))
+    val nxTrans = thisCtx.base.nextDenotTransformerId(first)
+    while (first - 1 > NoPhaseId && (thisCtx.base.nextDenotTransformerId(first - 1) == nxTrans))
       first -= 1
     Period(runId, first, nxTrans)
   }
 
   /** Are all base types in the current period guaranteed to be the same as in period `p`? */
   def hasSameBaseTypesAs(p: Period): Boolean = {
-    val period = this.period
+    val period = thisCtx.period
     period == p ||
     period.runId == p.runId &&
-      this.phases(period.phaseId).sameBaseTypesStartId ==
-      this.phases(p.phaseId).sameBaseTypesStartId
+      thisCtx.phases(period.phaseId).sameBaseTypesStartId ==
+      thisCtx.phases(p.phaseId).sameBaseTypesStartId
   }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -27,7 +27,7 @@ import transform.TypeUtils._
 
 import scala.annotation.internal.sharable
 
-trait SymDenotations { this: Context =>
+trait SymDenotations { thisCtx: Context =>
   import SymDenotations._
 
   /** Factory method for SymDenotion creation. All creations
@@ -53,9 +53,9 @@ trait SymDenotations { this: Context =>
     if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass || denot.isImport) true
     else {
       val initial = denot.initial
-      val firstPhaseId = initial.validFor.firstPhaseId.max(ctx.typerPhase.id)
-      if ((initial ne denot) || ctx.phaseId != firstPhaseId)
-        ctx.withPhase(firstPhaseId).stillValidInOwner(initial)
+      val firstPhaseId = initial.validFor.firstPhaseId.max(thisCtx.typerPhase.id)
+      if ((initial ne denot) || thisCtx.phaseId != firstPhaseId)
+        thisCtx.withPhase(firstPhaseId).stillValidInOwner(initial)
       else
         stillValidInOwner(denot)
     }
@@ -78,15 +78,15 @@ trait SymDenotations { this: Context =>
   def traceInvalid(denot: Denotation): Boolean = {
     def show(d: Denotation) = s"$d#${d.symbol.id}"
     def explain(msg: String) = {
-      println(s"${show(denot)} is invalid at ${this.period} because $msg")
+      println(s"${show(denot)} is invalid at ${thisCtx.period} because $msg")
       false
     }
     denot match {
       case denot: SymDenotation =>
         def explainSym(msg: String) = explain(s"$msg\ndefined = ${denot.definedPeriodsString}")
         if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass) true
         else {
-          implicit val ctx = this
+          implicit val ctx = thisCtx
           val initial = denot.initial
           if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId)
             ctx.withPhase(initial.validFor.firstPhaseId).traceInvalid(initial)
@@ -116,7 +116,7 @@ trait SymDenotations { this: Context =>
   /** Possibly accept stale symbol with warning if in IDE */
   def acceptStale(denot: SingleDenotation): Boolean =
     staleOK && {
-      ctx.debugwarn(denot.staleSymbolMsg)
+      thisCtx.debugwarn(denot.staleSymbolMsg)
       true
     }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -33,7 +33,7 @@ import scala.annotation.internal.sharable
 import config.Printers.typr
 
 /** Creation methods for symbols */
-trait Symbols { this: Context =>
+trait Symbols { thisCtx: Context =>
 
 // ---- Factory methods for symbol creation ----------------------
 //
@@ -131,7 +131,7 @@ trait Symbols { this: Context =>
   }
 
   def newRefinedClassSymbol(coord: Coord = NoCoord): ClassSymbol =
-    newCompleteClassSymbol(ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil, coord = coord)
+    newCompleteClassSymbol(thisCtx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil, coord = coord)
 
   /** Create a module symbol with associated module class
    *  from its non-info fields and a function producing the info
@@ -268,7 +268,7 @@ trait Symbols { this: Context =>
 
   /** Create a symbol representing a selftype declaration for class `cls`. */
   def newSelfSym(cls: ClassSymbol, name: TermName = nme.WILDCARD, selfInfo: Type = NoType): TermSymbol =
-    ctx.newSymbol(cls, name, SelfSymFlags, selfInfo orElse cls.classInfo.selfType, coord = cls.coord)
+    newSymbol(cls, name, SelfSymFlags, selfInfo orElse cls.classInfo.selfType, coord = cls.coord)
 
   /** Create new type parameters with given owner, names, and flags.
    *  @param boundsFn  A function that, given type refs to the newly created
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -22,7 +22,7 @@ import typer.IfBottom
 
 import scala.annotation.internal.sharable
 
-trait TypeOps { this: Context => // TODO: Make standalone object.
+trait TypeOps { thisCtx: Context => // TODO: Make standalone object.
 
   /** The type `tp` as seen from prefix `pre` and owner `cls`. See the spec
    *  for what this means.
@@ -134,7 +134,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         }
       case tp: TypeParamRef =>
         if (tp.paramName.is(DepParamName)) {
-          val bounds = ctx.typeComparer.bounds(tp)
+          val bounds = thisCtx.typeComparer.bounds(tp)
           if (bounds.lo.isRef(defn.NothingClass)) bounds.hi else bounds.lo
         }
         else {
@@ -145,9 +145,9 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         tp
       case tp: AliasingBounds =>
         tp.derivedAlias(simplify(tp.alias, theMap))
-      case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
+      case AndType(l, r) if !thisCtx.mode.is(Mode.Type) =>
         simplify(l, theMap) & simplify(r, theMap)
-      case OrType(l, r) if !ctx.mode.is(Mode.Type) =>
+      case OrType(l, r) if !thisCtx.mode.is(Mode.Type) =>
         simplify(l, theMap) | simplify(r, theMap)
       case _: AppliedType | _: MatchType =>
         val normed = tp.tryNormalize
@@ -192,7 +192,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         val accu1 = if (accu exists (_ derivesFrom c)) accu else c :: accu
         if (cs == c.baseClasses) accu1 else dominators(rest, accu1)
       case Nil => // this case can happen because after erasure we do not have a top class anymore
-        assert(ctx.erasedTypes || ctx.reporter.errorsReported)
+        assert(thisCtx.erasedTypes || thisCtx.reporter.errorsReported)
         defn.ObjectClass :: Nil
     }
 
@@ -216,7 +216,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
             case AppliedType(tycon2, args2) =>
               tp1.derivedAppliedType(
                 mergeRefinedOrApplied(tycon1, tycon2),
-                ctx.typeComparer.lubArgs(args1, args2, tycon1.typeParams))
+                thisCtx.typeComparer.lubArgs(args1, args2, tycon1.typeParams))
             case _ => fallback
           }
         case tp1 @ TypeRef(pre1, _) =>
@@ -492,15 +492,15 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   def featureEnabled(feature: TermName, owner: Symbol = NoSymbol): Boolean = {
     def hasImport = {
       val owner1 = if (!owner.exists) defn.LanguageModule.moduleClass else owner
-      ctx.importInfo != null &&
-      ctx.importInfo.featureImported(feature, owner1)(ctx.withPhase(ctx.typerPhase))
+      thisCtx.importInfo != null &&
+      thisCtx.importInfo.featureImported(feature, owner1)(thisCtx.withPhase(thisCtx.typerPhase))
     }
     val hasOption = {
       def toPrefix(sym: Symbol): String =
         if (!sym.exists) ""
         else toPrefix(sym.owner) + sym.name + "."
       val featureName = toPrefix(owner) + feature
-      ctx.base.settings.language.value contains featureName
+      thisCtx.base.settings.language.value contains featureName
     }
     hasOption || hasImport
   }
@@ -527,7 +527,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    *  This test is used when we are too early in the pipeline to consider imports.
    */
   def scala2CompatSetting: Boolean =
-    ctx.settings.language.value.contains(nme.Scala2Compat.toString)
+    thisCtx.settings.language.value.contains(nme.Scala2Compat.toString)
 
   /** Refine child based on parent
    *
diff --git a/compiler/src/dotty/tools/dotc/reporting/Reporter.scala b/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
@@ -66,18 +66,18 @@ object Reporter {
   }
 }
 
-trait Reporting { this: Context =>
+trait Reporting { thisCtx: Context =>
 
   /** For sending messages that are printed only if -verbose is set */
   def inform(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    if (this.settings.verbose.value) this.echo(msg, pos)
+    if (thisCtx.settings.verbose.value) thisCtx.echo(msg, pos)
 
   def echo(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report(new Info(msg, pos))
 
   def reportWarning(warning: Warning): Unit =
-    if (!this.settings.silentWarnings.value)
-      if (this.settings.XfatalWarnings.value)
+    if (!thisCtx.settings.silentWarnings.value)
+      if (thisCtx.settings.XfatalWarnings.value)
         warning match {
           case warning: ConditionalWarning if !warning.enablingOption.value =>
             reporter.report(warning) // conditional warnings that are not enabled are not fatal
@@ -123,23 +123,23 @@ trait Reporting { this: Context =>
     reportWarning(new Warning(msg, addInlineds(pos)))
 
   def strictWarning(msg: Message, pos: SourcePosition = NoSourcePosition): Unit =
-    if (this.settings.strict.value) error(msg, pos)
+    if (thisCtx.settings.strict.value) error(msg, pos)
     else warning(msg.append("\n(This would be an error under strict mode)"), pos)
 
   def error(msg: Message, pos: SourcePosition = NoSourcePosition, sticky: Boolean = false): Unit = {
     val fullPos = addInlineds(pos)
     reporter.report(if (sticky) new StickyError(msg, fullPos) else new Error(msg, fullPos))
-    if ctx.settings.YdebugError.value then Thread.dumpStack()
+    if thisCtx.settings.YdebugError.value then Thread.dumpStack()
   }
 
   def error(ex: TypeError, pos: SourcePosition): Unit = {
     error(ex.toMessage, pos, sticky = true)
-    if (ctx.settings.YdebugTypeError.value)
+    if (thisCtx.settings.YdebugTypeError.value)
       ex.printStackTrace()
   }
 
   def errorOrMigrationWarning(msg: Message, pos: SourcePosition = NoSourcePosition): Unit =
-    if (ctx.scala2CompatMode) migrationWarning(msg, pos) else error(msg, pos)
+    if (thisCtx.scala2CompatMode) migrationWarning(msg, pos) else error(msg, pos)
 
   def restrictionError(msg: Message, pos: SourcePosition = NoSourcePosition): Unit =
     error(msg.mapMsg("Implementation restriction: " + _), pos)
@@ -152,11 +152,11 @@ trait Reporting { this: Context =>
    *  "contains" here.
    */
   def log(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    if (this.settings.Ylog.value.containsPhase(phase))
-      echo(s"[log ${ctx.phasesStack.reverse.mkString(" -> ")}] $msg", pos)
+    if (thisCtx.settings.Ylog.value.containsPhase(phase))
+      echo(s"[log ${thisCtx.phasesStack.reverse.mkString(" -> ")}] $msg", pos)
 
   def debuglog(msg: => String): Unit =
-    if (ctx.debug) log(msg)
+    if (thisCtx.debug) log(msg)
 
   def informTime(msg: => String, start: Long): Unit = {
     def elapsed = s" in ${currentTimeMillis - start}ms"
@@ -172,7 +172,7 @@ trait Reporting { this: Context =>
   }
 
   def debugwarn(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    if (this.settings.Ydebug.value) warning(msg, pos)
+    if (thisCtx.settings.Ydebug.value) warning(msg, pos)
 
   private def addInlineds(pos: SourcePosition)(implicit ctx: Context) = {
     def recur(pos: SourcePosition, inlineds: List[Trees.Tree[?]]): SourcePosition = inlineds match {
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -24,11 +24,11 @@ import transform.SymUtils._
 import reporting.messages._
 
 trait NamerContextOps {
-  this: Context =>
+  thisCtx: Context =>
 
   import NamerContextOps._
 
-  def typer: Typer = ctx.typeAssigner match {
+  def typer: Typer = this.typeAssigner match {
     case typer: Typer => typer
     case _ => new Typer
   }
@@ -39,9 +39,9 @@ trait NamerContextOps {
    *  finger prints.
    */
   def enter(sym: Symbol): Symbol = {
-    ctx.owner match {
+    thisContext.owner match {
       case cls: ClassSymbol => cls.enter(sym)
-      case _ => this.scope.openForMutations.enter(sym)
+      case _ => thisCtx.scope.openForMutations.enter(sym)
     }
     sym
   }
@@ -105,7 +105,7 @@ trait NamerContextOps {
 
   /** A new context for the interior of a class */
   def inClassContext(selfInfo: TypeOrSymbol): Context = {
-    val localCtx: Context = ctx.fresh.setNewScope
+    val localCtx: Context = thisCtx.fresh.setNewScope
     selfInfo match {
       case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
       case _ =>
@@ -114,8 +114,8 @@ trait NamerContextOps {
   }
 
   def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context =
-    if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
-    else ctx
+    if (pkg.is(Package)) thisCtx.fresh.setOwner(pkg.moduleClass).setTree(tree)
+    else thisCtx
 
   /** The given type, unless `sym` is a constructor, in which case the
    *  type of the constructed instance is returned
