Drop more occurrences

Author: odersky

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

@@ -105,7 +105,7 @@ trait ImportSuggestions:
       case ref: TermRef => rootsIn(ref) ::: rootsOnPath(ref.prefix)
       case _ => Nil
 
-    def recur(using ctx: Context): List[TermRef] =
+    def recur(using Context): List[TermRef] =
       if ctx.owner.exists then
         val defined =
           if ctx.owner.isClass then
@@ -140,7 +140,7 @@ trait ImportSuggestions:
    *   return instead a list of all possible references to extension methods named
    *   `name` that are applicable to `T`.
    */
-  private def importSuggestions(pt: Type)(using ctx: Context): (List[TermRef], List[TermRef]) =
+  private def importSuggestions(pt: Type)(using Context): (List[TermRef], List[TermRef]) =
     val timer = new Timer()
     val deadLine = System.currentTimeMillis() + suggestImplicitTimeOut
 
@@ -241,7 +241,7 @@ trait ImportSuggestions:
    *  The addendum suggests given imports that might fix the problem.
    *  If there's nothing to suggest, an empty string is returned.
    */
-  override def importSuggestionAddendum(pt: Type)(using ctx: Context): String =
+  override def importSuggestionAddendum(pt: Type)(using Context): String =
     val (fullMatches, headMatches) =
       importSuggestions(pt)(using ctx.fresh.setExploreTyperState())
     implicits.println(i"suggestions for $pt in ${ctx.owner} = ($fullMatches%, %, $headMatches%, %)")

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

@@ -178,7 +178,7 @@ object Inliner {
    *  where the call `f(x)` is inline-expanded. This body is then transferred
    *  back to `f` at erasure, using method addRetainedInlineBodies.
    */
-  def bodyRetainer(mdef: DefDef)(using ctx: Context): DefDef =
+  def bodyRetainer(mdef: DefDef)(using Context): DefDef =
     val meth = mdef.symbol.asTerm
 
     val retainer = meth.copy(
@@ -264,7 +264,7 @@ object Inliner {
     private enum ErrorKind:
       case Parser, Typer
 
-    private def compileForErrors(tree: Tree, stopAfterParser: Boolean)(using ctx: Context): List[(ErrorKind, Error)] =
+    private def compileForErrors(tree: Tree, stopAfterParser: Boolean)(using Context): List[(ErrorKind, Error)] =
       assert(tree.symbol == defn.CompiletimeTesting_typeChecks || tree.symbol == defn.CompiletimeTesting_typeCheckErrors)
       def stripTyped(t: Tree): Tree = t match {
         case Typed(t2, _) => stripTyped(t2)
@@ -1220,7 +1220,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     override def newLikeThis: Typer = new InlineTyper(initialErrorCount)
 
     /** Suppress further inlining if this inline typer has already issued errors */
-    override def suppressInline(using ctx: Context) =
+    override def suppressInline(using Context) =
       ctx.reporter.errorCount > initialErrorCount || super.suppressInline
   }
 

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

@@ -272,7 +272,7 @@ class Namer { typer: Typer =>
    *  The logic here is very subtle and fragile due to the fact that
    *  we are not allowed to force anything.
    */
-  def checkNoConflict(name: Name, isPrivate: Boolean, span: Span)(using ctx: Context): Name =
+  def checkNoConflict(name: Name, isPrivate: Boolean, span: Span)(using Context): Name =
     val owner = ctx.owner
     var conflictsDetected = false
 

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

@@ -142,15 +142,15 @@ object Nullables:
   /** The nullability context to be used after a case that matches pattern `pat`.
    *  If `pat` is `null`, this will assert that the selector `sel` is not null afterwards.
    */
-  def afterPatternContext(sel: Tree, pat: Tree)(using ctx: Context) = (sel, pat) match
+  def afterPatternContext(sel: Tree, pat: Tree)(using Context) = (sel, pat) match
     case (TrackedRef(ref), Literal(Constant(null))) => ctx.addNotNullRefs(Set(ref))
     case _ => ctx
 
   /** The nullability context to be used for the guard and rhs of a case with
    *  given pattern `pat`. If the pattern can only match non-null values, this
    *  will assert that the selector `sel` is not null in these regions.
    */
-  def caseContext(sel: Tree, pat: Tree)(using ctx: Context): Context = sel match
+  def caseContext(sel: Tree, pat: Tree)(using Context): Context = sel match
     case TrackedRef(ref) if matchesNotNull(pat) => ctx.addNotNullRefs(Set(ref))
     case _ => ctx
 
@@ -462,7 +462,7 @@ object Nullables:
    *  flow assumptions about mutable variables and suggest that it is enclosed
    *  in a `byName(...)` call instead.
    */
-  def postProcessByNameArgs(fn: TermRef, app: Tree)(using ctx: Context): Tree =
+  def postProcessByNameArgs(fn: TermRef, app: Tree)(using Context): Tree =
     fn.widen match
       case mt: MethodType
       if mt.paramInfos.exists(_.isInstanceOf[ExprType]) && !fn.symbol.is(Inline) =>

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

@@ -874,7 +874,7 @@ object RefChecks {
    *  surprising names at runtime. E.g. in neg/i4564a.scala, a private
    *  case class `apply` method would have to be renamed to something else.
    */
-  def checkNoPrivateOverrides(tree: Tree)(using ctx: Context): Unit =
+  def checkNoPrivateOverrides(tree: Tree)(using Context): Unit =
     val sym = tree.symbol
     if sym.owner.isClass
        && sym.is(Private)

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

@@ -3286,7 +3286,7 @@ class Typer extends Namer
   }
 
   // Overridden in InlineTyper
-  def suppressInline(using ctx: Context): Boolean = ctx.isAfterTyper
+  def suppressInline(using Context): Boolean = ctx.isAfterTyper
 
   /** Does the "contextuality" of the method type `methType` match the one of the prototype `pt`?
    *  This is the case if