Fix rebase breakage due to new shadowing check

New master checks for inherited symbols shadowing definitions, so it contained
a number of changes where `ctx` in a map or an accumulator was renamed to `this.ctx`.
All of these broke because we renamed `ctx` in map to `mapCtx`. Before, all these
occurrences of `ctx` silently rebound in this PR to the enclosing `ctx` which is
mostly OK, since the two contexts tend to be the same, but could also be wrong.
So, the additional check has already apid for itself in increased robustness of
refactorings!

Author: odersky

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

@@ -112,7 +112,7 @@ object desugar {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
-            val defctx = this.ctx.outersIterator.dropWhile(_.scope eq this.ctx.scope).next()
+            val defctx = mapCtx.outersIterator.dropWhile(_.scope eq mapCtx.scope).next()
             var local = defctx.denotNamed(tp.name).suchThat(_.isParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealiasKeepAnnots
             else {

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -250,13 +250,13 @@ object messages {
     // these are usually easier to analyze.
     object reported extends TypeMap:
       def setVariance(v: Int) = variance = v
-      val constraint = this.ctx.typerState.constraint
+      val constraint = mapCtx.typerState.constraint
       def apply(tp: Type): Type = tp match
         case tp: TypeParamRef =>
           constraint.entry(tp) match
             case bounds: TypeBounds =>
-              if variance < 0 then apply(this.ctx.typeComparer.fullUpperBound(tp))
-              else if variance > 0 then apply(this.ctx.typeComparer.fullLowerBound(tp))
+              if variance < 0 then apply(mapCtx.typeComparer.fullUpperBound(tp))
+              else if variance > 0 then apply(mapCtx.typeComparer.fullLowerBound(tp))
               else tp
             case NoType => tp
             case instType => apply(instType)

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

@@ -138,7 +138,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       tp match {
         case tp: TypeRef if tp.symbol.isSplice =>
           if (tp.isTerm)
-            this.ctx.error(i"splice outside quotes", pos)
+            mapCtx.error(i"splice outside quotes", pos)
           if level > 0 then getQuoteTypeTags.getTagRef(tp.prefix.asInstanceOf[TermRef])
           else tp
         case tp: TypeRef if tp.symbol == defn.QuotedTypeClass.typeParams.head =>

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

@@ -414,7 +414,7 @@ object Implicits {
             case t: TypeParamRef =>
               constraint.entry(t) match {
                 case NoType => t
-                case bounds: TypeBounds => this.ctx.typeComparer.fullBounds(t)
+                case bounds: TypeBounds => mapCtx.typeComparer.fullBounds(t)
                 case t1 => t1
               }
             case t: TypeVar =>

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

@@ -67,7 +67,7 @@ object Inferencing {
       def apply(tvars: Set[TypeVar], tp: Type) = tp match {
         case tp: TypeVar
         if !tp.isInstantiated &&
-            this.ctx.typeComparer.bounds(tp.origin)
+            accCtx.typeComparer.bounds(tp.origin)
               .namedPartsWith(ref => params.contains(ref.symbol))
               .nonEmpty =>
           tvars + tp
@@ -172,13 +172,13 @@ object Inferencing {
       def traverse(tp: Type): Unit = {
         tp match {
           case param: TypeParamRef =>
-            val constraint = this.ctx.typerState.constraint
+            val constraint = accCtx.typerState.constraint
             constraint.entry(param) match {
               case TypeBounds(lo, hi)
               if (hi frozen_<:< lo) =>
-                val inst = this.ctx.typeComparer.approximation(param, fromBelow = true)
+                val inst = accCtx.typeComparer.approximation(param, fromBelow = true)
                 typr.println(i"replace singleton $param := $inst")
-                this.ctx.typerState.constraint = constraint.replace(param, inst)
+                accCtx.typerState.constraint = constraint.replace(param, inst)
               case _ =>
             }
           case _ =>
@@ -333,7 +333,7 @@ object Inferencing {
       def setVariance(v: Int) = variance = v
       def apply(vmap: VarianceMap, t: Type): VarianceMap = t match {
         case t: TypeVar
-        if !t.isInstantiated && this.ctx.typerState.constraint.contains(t) =>
+        if !t.isInstantiated && accCtx.typerState.constraint.contains(t) =>
           val v = vmap(t)
           if (v == null) vmap.updated(t, variance)
           else if (v == variance || v == 0) vmap

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

@@ -123,8 +123,8 @@ trait TypeAssigner {
           range(defn.NothingType, apply(classBound(tp.cls.classInfo)))
         case tp: SkolemType if partsToAvoid(mutable.Set.empty, tp.info).nonEmpty =>
           range(defn.NothingType, apply(tp.info))
-        case tp: TypeVar if this.ctx.typerState.constraint.contains(tp) =>
-          val lo = this.ctx.typeComparer.instanceType(
+        case tp: TypeVar if mapCtx.typerState.constraint.contains(tp) =>
+          val lo = mapCtx.typeComparer.instanceType(
             tp.origin, fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound)
           val lo1 = apply(lo)
           if (lo1 ne lo) lo1 else tp

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

@@ -44,7 +44,7 @@ object VarianceChecker {
               .find(_.name.toTermName == paramName)
               .map(_.sourcePos)
               .getOrElse(tree.sourcePos)
-            this.ctx.error(em"${paramVarianceStr}variant type parameter $paramName occurs in ${occursStr}variant position in ${tl.resType}", pos)
+            accCtx.error(em"${paramVarianceStr}variant type parameter $paramName occurs in ${occursStr}variant position in ${tl.resType}", pos)
           }
           def apply(x: Boolean, t: Type) = x && {
             t match {
@@ -115,10 +115,10 @@ class VarianceChecker()(implicit ctx: Context) {
         val required = compose(relative, this.variance)
         def tvar_s = s"$tvar (${varianceLabel(tvar.flags)} ${tvar.showLocated})"
         def base_s = s"$base in ${base.owner}" + (if (base.owner.isClass) "" else " in " + base.owner.enclosingClass)
-        this.ctx.log(s"verifying $tvar_s is ${varianceLabel(required)} at $base_s")
-        this.ctx.log(s"relative variance: ${varianceLabel(relative)}")
-        this.ctx.log(s"current variance: ${this.variance}")
-        this.ctx.log(s"owner chain: ${base.ownersIterator.toList}")
+        accCtx.log(s"verifying $tvar_s is ${varianceLabel(required)} at $base_s")
+        accCtx.log(s"relative variance: ${varianceLabel(relative)}")
+        accCtx.log(s"current variance: ${this.variance}")
+        accCtx.log(s"owner chain: ${base.ownersIterator.toList}")
         if (tvar.isOneOf(required)) None
         else Some(VarianceError(tvar, required))
       }