Drop more occurrences

Author: odersky

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

@@ -270,7 +270,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
 object PCPCheckAndHeal {
   import tpd._
 
-  class QuoteTypeTags(span: Span)(using ctx: Context) {
+  class QuoteTypeTags(span: Span)(using Context) {
 
     private val tags = collection.mutable.LinkedHashMap.empty[Symbol, TypeDef]
 

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

@@ -38,7 +38,7 @@ class ParamForwarding extends MiniPhase with IdentityDenotTransformer:
 
   val phaseName: String = "paramForwarding"
 
-  def transformIfParamAlias(mdef: ValOrDefDef)(using ctx: Context): Tree =
+  def transformIfParamAlias(mdef: ValOrDefDef)(using Context): Tree =
 
     def inheritedAccessor(sym: Symbol)(using Context): Symbol =
       val candidate = sym.owner.asClass.superClass

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

@@ -149,7 +149,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case _ =>
       processMemberDef(tree)
 
-    private def checkInferredWellFormed(tree: Tree)(using ctx: Context): Unit = tree match
+    private def checkInferredWellFormed(tree: Tree)(using Context): Unit = tree match
       case tree: TypeTree
       if tree.span.isZeroExtent
           // don't check TypeTrees with non-zero extent;

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

@@ -987,7 +987,7 @@ trait Applications extends Compatibility {
   }
 
   /** Typecheck an Apply node with a typed function and possibly-typed arguments coming from `proto` */
-  def ApplyTo(app: untpd.Apply, fun: tpd.Tree, methRef: TermRef, proto: FunProto, resultType: Type)(using ctx: Context): tpd.Tree =
+  def ApplyTo(app: untpd.Apply, fun: tpd.Tree, methRef: TermRef, proto: FunProto, resultType: Type)(using Context): tpd.Tree =
     val typer = ctx.typer
     if (proto.allArgTypesAreCurrent())
       typer.ApplyToTyped(app, fun, methRef, proto.typedArgs(), resultType).result

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

@@ -47,7 +47,7 @@ object Checking {
    *   1. the full inferred type is a TypeTree node
    *   2. the applied type causing the error, if different from (1)
    */
-  private def showInferred(msg: Message, app: Type, tpt: Tree)(using ctx: Context): Message =
+  private def showInferred(msg: Message, app: Type, tpt: Tree)(using Context): Message =
     if tpt.isInstanceOf[TypeTree] then
       def subPart = if app eq tpt.tpe then "" else i" subpart $app of"
       msg.append(i" in$subPart inferred type ${tpt}")
@@ -91,7 +91,7 @@ object Checking {
    *  @param tpt  If `tree` is synthesized from a type in a TypeTree,
    *              the original TypeTree, or EmptyTree otherwise.
    */
-  def checkAppliedType(tree: AppliedTypeTree, tpt: Tree = EmptyTree)(using ctx: Context): Unit = {
+  def checkAppliedType(tree: AppliedTypeTree, tpt: Tree = EmptyTree)(using Context): Unit = {
     val AppliedTypeTree(tycon, args) = tree
     // If `args` is a list of named arguments, return corresponding type parameters,
     // otherwise return type parameters unchanged
@@ -629,7 +629,7 @@ object Checking {
   }
 
   /** Check that an enum case extends its enum class */
-  def checkEnumParentOK(cls: Symbol)(using ctx: Context): Unit =
+  def checkEnumParentOK(cls: Symbol)(using Context): Unit =
     val enumCase =
       if cls.isAllOf(EnumCase) then cls
       else if cls.isAnonymousClass && cls.owner.isAllOf(EnumCase) then cls.owner
@@ -1151,7 +1151,7 @@ trait Checking {
   }
 
   /** check that annotation `annot` is applicable to symbol `sym` */
-  def checkAnnotApplicable(annot: Tree, sym: Symbol)(using ctx: Context): Boolean =
+  def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean =
     !ctx.reporter.reportsErrorsFor { implicit ctx =>
       val annotCls = Annotations.annotClass(annot)
       val pos = annot.sourcePos
@@ -1185,7 +1185,7 @@ trait ReChecking extends Checking {
   override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(implicit ctx: Context): Unit = ()
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(implicit ctx: Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(implicit ctx: Context): Unit = ()
-  override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using ctx: Context): Boolean = true
+  override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
 }
 
 trait NoChecking extends ReChecking {