Convert to using clauses

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

@@ -78,7 +78,6 @@ object Contexts {
    */
   abstract class Context(val base: ContextBase)
     extends Periods
-       with Substituters
        with Phases
        with Printers
        with Symbols

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

@@ -5,9 +5,9 @@ import Types._, Symbols._, Contexts._
 /** Substitution operations on types. See the corresponding `subst` and
  *  `substThis` methods on class Type for an explanation.
  */
-trait Substituters { this: Context =>
+object Substituters:
 
-  final def subst(tp: Type, from: BindingType, to: BindingType, theMap: SubstBindingMap): Type =
+  final def subst(tp: Type, from: BindingType, to: BindingType, theMap: SubstBindingMap)(using Context): Type =
     tp match {
       case tp: BoundType =>
         if (tp.binder eq from) tp.copyBoundType(to.asInstanceOf[tp.BT]) else tp
@@ -21,7 +21,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map): Type =
+  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map)(using Context): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -35,7 +35,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map): Type =
+  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map)(using Context): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -50,7 +50,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap): Type =
+  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap)(using Context): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -70,7 +70,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substSym(tp: Type, from: List[Symbol], to: List[Symbol], theMap: SubstSymMap): Type =
+  final def substSym(tp: Type, from: List[Symbol], to: List[Symbol], theMap: SubstSymMap)(using Context): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -101,7 +101,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substThis(tp: Type, from: ClassSymbol, to: Type, theMap: SubstThisMap): Type =
+  final def substThis(tp: Type, from: ClassSymbol, to: Type, theMap: SubstThisMap)(using Context): Type =
     tp match {
       case tp: ThisType =>
         if (tp.cls eq from) to else tp
@@ -115,7 +115,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap): Type =
+  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap)(using Context): Type =
     tp match {
       case tp @ RecThis(binder) =>
         if (binder eq from) to else tp
@@ -129,7 +129,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substParam(tp: Type, from: ParamRef, to: Type, theMap: SubstParamMap): Type =
+  final def substParam(tp: Type, from: ParamRef, to: Type, theMap: SubstParamMap)(using Context): Type =
     tp match {
       case tp: BoundType =>
         if (tp == from) to else tp
@@ -143,7 +143,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substParams(tp: Type, from: BindingType, to: List[Type], theMap: SubstParamsMap): Type =
+  final def substParams(tp: Type, from: BindingType, to: List[Type], theMap: SubstParamsMap)(using Context): Type =
     tp match {
       case tp: ParamRef =>
         if (tp.binder == from) to(tp.paramNum) else tp
@@ -157,44 +157,44 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final class SubstBindingMap(from: BindingType, to: BindingType) extends DeepTypeMap {
+  final class SubstBindingMap(from: BindingType, to: BindingType)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = subst(tp, from, to, this)
   }
 
-  final class Subst1Map(from: Symbol, to: Type) extends DeepTypeMap {
+  final class Subst1Map(from: Symbol, to: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = subst1(tp, from, to, this)
   }
 
-  final class Subst2Map(from1: Symbol, to1: Type, from2: Symbol, to2: Type) extends DeepTypeMap {
+  final class Subst2Map(from1: Symbol, to1: Type, from2: Symbol, to2: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = subst2(tp, from1, to1, from2, to2, this)
   }
 
-  final class SubstMap(from: List[Symbol], to: List[Type]) extends DeepTypeMap {
+  final class SubstMap(from: List[Symbol], to: List[Type])(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = subst(tp, from, to, this)
   }
 
-  final class SubstSymMap(from: List[Symbol], to: List[Symbol]) extends DeepTypeMap {
+  final class SubstSymMap(from: List[Symbol], to: List[Symbol])(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substSym(tp, from, to, this)
   }
 
-  final class SubstThisMap(from: ClassSymbol, to: Type) extends DeepTypeMap {
+  final class SubstThisMap(from: ClassSymbol, to: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substThis(tp, from, to, this)
   }
 
-  final class SubstRecThisMap(from: Type, to: Type) extends DeepTypeMap {
+  final class SubstRecThisMap(from: Type, to: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substRecThis(tp, from, to, this)
   }
 
-  final class SubstParamMap(from: ParamRef, to: Type) extends DeepTypeMap {
+  final class SubstParamMap(from: ParamRef, to: Type)(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substParam(tp, from, to, this)
   }
 
-  final class SubstParamsMap(from: BindingType, to: List[Type]) extends DeepTypeMap {
+  final class SubstParamsMap(from: BindingType, to: List[Type])(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substParams(tp, from, to, this)
   }
 
   /** An approximating substitution that can handle wildcards in the `to` list */
-  final class SubstApproxMap(from: List[Symbol], to: List[Type])(implicit ctx: Context) extends ApproximatingTypeMap {
+  final class SubstApproxMap(from: List[Symbol], to: List[Type])(using Context) extends ApproximatingTypeMap {
     def apply(tp: Type): Type = tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -216,4 +216,4 @@ trait Substituters { this: Context =>
         mapOver(tp)
     }
   }
-}
+end Substituters

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

@@ -337,7 +337,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case dealiased: TypeBounds =>
         dealiased.derivedTypeBounds(dealiased.lo.appliedTo(args), dealiased.hi.appliedTo(args))
       case dealiased: LazyRef =>
-        LazyRef(c => dealiased.ref(c).appliedTo(args)(using c))
+        LazyRef(c => dealiased.ref(using c).appliedTo(args)(using c))
       case dealiased: WildcardType =>
         WildcardType(dealiased.optBounds.orElse(TypeBounds.empty).appliedTo(args).bounds)
       case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>