Convert core classes (5)

Author: odersky

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

@@ -326,7 +326,7 @@ object Contexts {
     /** Run `op` as if it was run in a fresh explore typer state, but possibly
      *  optimized to re-use the current typer state.
      */
-    final def test[T](op: Context ?=> T): T = typerState.test(op)(this)
+    final def test[T](op: Context ?=> T): T = typerState.test(op)(using this)
 
     /** Is this a context for the members of a class definition? */
     def isClassDefContext: Boolean =

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

@@ -34,20 +34,20 @@ object TypeApplications {
    *  @param tycon     C
    */
   object EtaExpansion {
-    def apply(tycon: Type)(implicit ctx: Context): Type = {
+    def apply(tycon: Type)(using Context): Type = {
       assert(tycon.typeParams.nonEmpty, tycon)
       tycon.EtaExpand(tycon.typeParamSymbols)
     }
 
-    def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = tp match {
+    def unapply(tp: Type)(using Context): Option[TypeRef] = tp match {
       case tp @ HKTypeLambda(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.paramRef)) => Some(fn)
       case _ => None
     }
   }
 
    /** Adapt all arguments to possible higher-kinded type parameters using etaExpandIfHK
    */
-  def EtaExpandIfHK(tparams: List[TypeParamInfo], args: List[Type])(implicit ctx: Context): List[Type] =
+  def EtaExpandIfHK(tparams: List[TypeParamInfo], args: List[Type])(using Context): List[Type] =
     if (tparams.isEmpty) args
     else args.zipWithConserve(tparams)((arg, tparam) => arg.EtaExpandIfHK(tparam.paramInfoOrCompleter))
 
@@ -86,7 +86,7 @@ object TypeApplications {
    *  result type. Using this mode, we can guarantee that `appliedTo` will never
    *  produce a higher-kinded application with a type lambda as type constructor.
    */
-  class Reducer(tycon: TypeLambda, args: List[Type])(implicit ctx: Context) extends TypeMap {
+  class Reducer(tycon: TypeLambda, args: List[Type])(using Context) extends TypeMap {
     private var available = (0 until args.length).toSet
     var allReplaced: Boolean = true
     def hasWildcardArg(p: TypeParamRef): Boolean =
@@ -143,7 +143,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  For a refinement type, the type parameters of its parent, dropping
    *  any type parameter that is-rebound by the refinement.
    */
-  final def typeParams(implicit ctx: Context): List[TypeParamInfo] = {
+  final def typeParams(using Context): List[TypeParamInfo] = {
     record("typeParams")
     def isTrivial(prefix: Type, tycon: Symbol) = prefix match {
       case prefix: ThisType =>
@@ -184,22 +184,22 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */
-  final def hkTypeParams(implicit ctx: Context): List[TypeParamInfo] =
+  final def hkTypeParams(using Context): List[TypeParamInfo] =
     if (isLambdaSub) typeParams else Nil
 
   /** If `self` is a generic class, its type parameter symbols, otherwise Nil */
-  final def typeParamSymbols(implicit ctx: Context): List[TypeSymbol] = typeParams match {
+  final def typeParamSymbols(using Context): List[TypeSymbol] = typeParams match {
     case (_: Symbol) :: _ =>
       assert(typeParams.forall(_.isInstanceOf[Symbol]))
       typeParams.asInstanceOf[List[TypeSymbol]]
     case _ => Nil
   }
 
   /** Is self type bounded by a type lambda or AnyKind? */
-  def isLambdaSub(implicit ctx: Context): Boolean = hkResult.exists
+  def isLambdaSub(using Context): Boolean = hkResult.exists
 
   /** Is self type of kind "*"? */
-  def hasSimpleKind(implicit ctx: Context): Boolean =
+  def hasSimpleKind(using Context): Boolean =
     typeParams.isEmpty && !self.hasAnyKind || {
       val alias = self.dealias
       (alias ne self) && alias.hasSimpleKind
@@ -208,7 +208,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** If self type is higher-kinded, its result type, otherwise NoType.
    *  Note: The hkResult of an any-kinded type is again AnyKind.
    */
-  def hkResult(implicit ctx: Context): Type = self.dealias match {
+  def hkResult(using Context): Type = self.dealias match {
     case self: TypeRef =>
       if (self.symbol == defn.AnyKindClass) self else self.info.hkResult
     case self: AppliedType =>
@@ -227,7 +227,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Do self and other have the same kinds (not counting bounds and variances)?
    *  Note: An any-kinded type "has the same kind" as any other type.
    */
-  def hasSameKindAs(other: Type)(implicit ctx: Context): Boolean = {
+  def hasSameKindAs(other: Type)(using Context): Boolean = {
     def isAnyKind(tp: Type) = tp match {
       case tp: TypeRef => tp.symbol == defn.AnyKindClass
       case _ => false
@@ -245,7 +245,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** Dealias type if it can be done without forcing the TypeRef's info */
-  def safeDealias(implicit ctx: Context): Type = self match {
+  def safeDealias(using Context): Type = self match {
     case self: TypeRef if self.denot.exists && self.symbol.isAliasType =>
       self.superType.stripTypeVar.safeDealias
     case _ =>
@@ -255,16 +255,16 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Convert a type constructor `TC` which has type parameters `X1, ..., Xn`
    *  to `[X1, ..., Xn] -> TC[X1, ..., Xn]`.
    */
-  def EtaExpand(tparams: List[TypeParamInfo])(implicit ctx: Context): Type =
+  def EtaExpand(tparams: List[TypeParamInfo])(using Context): Type =
     HKTypeLambda.fromParams(tparams, self.appliedTo(tparams.map(_.paramRef)))
       //.ensuring(res => res.EtaReduce =:= self, s"res = $res, core = ${res.EtaReduce}, self = $self, hc = ${res.hashCode}")
 
   /** If self is not lambda-bound, eta expand it. */
-  def ensureLambdaSub(implicit ctx: Context): Type =
+  def ensureLambdaSub(using Context): Type =
     if (isLambdaSub) self else EtaExpansion(self)
 
   /** Eta expand if `self` is a (non-lambda) class reference and `bound` is a higher-kinded type */
-  def EtaExpandIfHK(bound: Type)(implicit ctx: Context): Type = {
+  def EtaExpandIfHK(bound: Type)(using Context): Type = {
     val hkParams = bound.hkTypeParams
     if (hkParams.isEmpty) self
     else self match {
@@ -282,7 +282,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  @param  self   = `T`
    *  @param  args   = `U1,...,Un`
    */
-  final def appliedTo(args: List[Type])(implicit ctx: Context): Type = {
+  final def appliedTo(args: List[Type])(using Context): Type = {
     record("appliedTo")
     val typParams = self.typeParams
     val stripped = self.stripTypeVar
@@ -347,18 +347,18 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
-  final def appliedTo(arg: Type)(implicit ctx: Context): Type = appliedTo(arg :: Nil)
-  final def appliedTo(arg1: Type, arg2: Type)(implicit ctx: Context): Type = appliedTo(arg1 :: arg2 :: Nil)
+  final def appliedTo(arg: Type)(using Context): Type = appliedTo(arg :: Nil)
+  final def appliedTo(arg1: Type, arg2: Type)(using Context): Type = appliedTo(arg1 :: arg2 :: Nil)
 
-  final def applyIfParameterized(args: List[Type])(implicit ctx: Context): Type =
+  final def applyIfParameterized(args: List[Type])(using Context): Type =
     if (typeParams.nonEmpty) appliedTo(args) else self
 
   /** A cycle-safe version of `appliedTo` where computing type parameters do not force
    *  the typeconstructor. Instead, if the type constructor is completing, we make
    *  up hk type parameters matching the arguments. This is needed when unpickling
    *  Scala2 files such as `scala.collection.generic.Mapfactory`.
    */
-  final def safeAppliedTo(args: List[Type])(implicit ctx: Context): Type = self match {
+  final def safeAppliedTo(args: List[Type])(using Context): Type = self match {
     case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
       AppliedType(self, args)
     case _ =>
@@ -369,7 +369,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  A (possible lambda abstracted) match type is turned into a match alias.
    *  Every other type is turned into a type alias
    */
-  final def toBounds(implicit ctx: Context): TypeBounds = self match {
+  final def toBounds(using Context): TypeBounds = self match {
     case self: TypeBounds => self // this can happen for wildcard args
     case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
   }
@@ -378,7 +378,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(implicit ctx: Context): Type = self match {
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
@@ -439,37 +439,37 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  otherwise return Nil.
    *  Existential types in arguments are returned as TypeBounds instances.
    */
-  final def argInfos(implicit ctx: Context): List[Type] = self.stripTypeVar.stripAnnots match {
+  final def argInfos(using Context): List[Type] = self.stripTypeVar.stripAnnots match {
     case AppliedType(tycon, args) => args
     case _ => Nil
   }
 
   /** Argument types where existential types in arguments are disallowed */
-  def argTypes(implicit ctx: Context): List[Type] = argInfos mapConserve noBounds
+  def argTypes(using Context): List[Type] = argInfos mapConserve noBounds
 
   /** Argument types where existential types in arguments are approximated by their lower bound */
-  def argTypesLo(implicit ctx: Context): List[Type] = argInfos.mapConserve(_.loBound)
+  def argTypesLo(using Context): List[Type] = argInfos.mapConserve(_.loBound)
 
   /** Argument types where existential types in arguments are approximated by their upper bound  */
-  def argTypesHi(implicit ctx: Context): List[Type] = argInfos.mapConserve(_.hiBound)
+  def argTypesHi(using Context): List[Type] = argInfos.mapConserve(_.hiBound)
 
   /** If this is the image of a type argument; recover the type argument,
    *  otherwise NoType.
    */
-  final def argInfo(implicit ctx: Context): Type = self match {
+  final def argInfo(using Context): Type = self match {
     case self: TypeAlias => self.alias
     case self: TypeBounds => self
     case _ => NoType
   }
 
   /** If this is a type alias, its underlying type, otherwise the type itself */
-  def dropAlias(implicit ctx: Context): Type = self match {
+  def dropAlias(using Context): Type = self match {
     case TypeAlias(alias) => alias
     case _ => self
   }
 
   /** The element type of a sequence or array */
-  def elemType(implicit ctx: Context): Type = self.widenDealias match {
+  def elemType(using Context): Type = self.widenDealias match {
     case defn.ArrayOf(elemtp) => elemtp
     case JavaArrayType(elemtp) => elemtp
     case _ => self.baseType(defn.SeqClass).argInfos.headOption.getOrElse(NoType)

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

@@ -119,11 +119,11 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     true
   }
 
-  protected def gadtBounds(sym: Symbol)(implicit ctx: Context) = ctx.gadt.bounds(sym)
+  protected def gadtBounds(sym: Symbol)(using Context) = ctx.gadt.bounds(sym)
   protected def gadtAddLowerBound(sym: Symbol, b: Type): Boolean = ctx.gadt.addBound(sym, b, isUpper = false)
   protected def gadtAddUpperBound(sym: Symbol, b: Type): Boolean = ctx.gadt.addBound(sym, b, isUpper = true)
 
-  protected def typeVarInstance(tvar: TypeVar)(implicit ctx: Context): Type = tvar.underlying
+  protected def typeVarInstance(tvar: TypeVar)(using Context): Type = tvar.underlying
 
   // Subtype testing `<:<`
 
@@ -1860,7 +1860,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   /** The greatest lower bound of a list types */
   final def glb(tps: List[Type]): Type = tps.foldLeft(AnyType: Type)(glb)
 
-  def widenInUnions(implicit ctx: Context): Boolean =
+  def widenInUnions(using Context): Boolean =
     migrateTo3 || ctx.erasedTypes
 
   /** The least upper bound of two types
@@ -2175,7 +2175,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
   }
 
   /** Show type, handling type types better than the default */
-  private def showType(tp: Type)(implicit ctx: Context) = tp match {
+  private def showType(tp: Type)(using Context) = tp match {
     case ClassInfo(_, cls, _, _, _) => cls.showLocated
     case bounds: TypeBounds => "type bounds" + bounds.show
     case _ => tp.show
@@ -2231,7 +2231,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     }
 
   /** Show subtype goal that led to an assertion failure */
-  def showGoal(tp1: Type, tp2: Type)(implicit ctx: Context): Unit = {
+  def showGoal(tp1: Type, tp2: Type)(using Context): Unit = {
     ctx.echo(i"assertion failure for ${show(tp1)} <:< ${show(tp2)}, frozen = $frozenConstraint")
     def explainPoly(tp: Type) = tp match {
       case tp: TypeParamRef => ctx.echo(s"TypeParamRef ${tp.show} found in ${tp.binder.show}")
@@ -2310,7 +2310,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  property that in all possible contexts, the same match type expression
    *  is either stuck or reduces to the same case.
    */
-  def provablyDisjoint(tp1: Type, tp2: Type)(implicit ctx: Context): Boolean = {
+  def provablyDisjoint(tp1: Type, tp2: Type)(using Context): Boolean = {
     // println(s"provablyDisjoint(${tp1.show}, ${tp2.show})")
     /** Can we enumerate all instantiations of this type? */
     def isClosedSum(tp: Symbol): Boolean =
@@ -2432,7 +2432,7 @@ object TypeComparer {
     var tpe: Type = NoType
   }
 
-  private[core] def show(res: Any)(implicit ctx: Context): String = res match {
+  private[core] def show(res: Any)(using Context): String = res match {
     case res: printing.Showable if !ctx.settings.YexplainLowlevel.value => res.show
     case _ => String.valueOf(res)
   }
@@ -2467,14 +2467,14 @@ object TypeComparer {
   val FreshApprox: ApproxState = new ApproxState(4)
 
   /** Show trace of comparison operations when performing `op` */
-  def explaining[T](say: String => Unit)(op: Context ?=> T)(implicit ctx: Context): T = {
+  def explaining[T](say: String => Unit)(op: Context ?=> T)(using Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
     val res = try { op(using nestedCtx) } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 
   /** Like [[explaining]], but returns the trace instead */
-  def explained[T](op: Context ?=> T)(implicit ctx: Context): String = {
+  def explained[T](op: Context ?=> T)(using Context): String = {
     var trace: String = null
     try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace
@@ -2496,7 +2496,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     super.addOneBound(param, bound, isUpper)
   }
 
-  override def gadtBounds(sym: Symbol)(implicit ctx: Context): TypeBounds = {
+  override def gadtBounds(sym: Symbol)(using Context): TypeBounds = {
     if (sym.exists) footprint += sym.typeRef
     super.gadtBounds(sym)
   }
@@ -2511,12 +2511,12 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     super.gadtAddUpperBound(sym, b)
   }
 
-  override def typeVarInstance(tvar: TypeVar)(implicit ctx: Context): Type = {
+  override def typeVarInstance(tvar: TypeVar)(using Context): Type = {
     footprint += tvar
     super.typeVarInstance(tvar)
   }
 
-  def matchCases(scrut: Type, cases: List[Type])(implicit ctx: Context): Type = {
+  def matchCases(scrut: Type, cases: List[Type])(using Context): Type = {
     def paramInstances = new TypeAccumulator[Array[Type]] {
       def apply(inst: Array[Type], t: Type) = t match {
         case t @ TypeParamRef(b, n) if b `eq` caseLambda =>