Switch to (using Context) in more files in typer

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -60,7 +60,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       .setTyperState(new TyperState(ctx.typerState))
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, rootRef: ImportInfo.RootRef) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef)(ctx))
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(rootRef))
     defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 

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

@@ -493,7 +493,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     def hasImport = {
       val owner1 = if (!owner.exists) defn.LanguageModule.moduleClass else owner
       ctx.importInfo != null &&
-      ctx.importInfo.featureImported(feature, owner1)(ctx.withPhase(ctx.typerPhase))
+      ctx.importInfo.featureImported(feature, owner1)(using ctx.withPhase(ctx.typerPhase))
     }
     val hasOption = {
       def toPrefix(sym: Symbol): String =

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

@@ -21,7 +21,7 @@ object ImportInfo {
   )
 
   /** The import info for a root import from given symbol `sym` */
-  def rootImport(rootRef: RootRef)(implicit ctx: Context): ImportInfo =
+  def rootImport(rootRef: RootRef)(using Context): ImportInfo =
     val (refFn, isPredef) = rootRef
     var selectors =
       untpd.ImportSelector(untpd.Ident(nme.WILDCARD))  // import all normal members...
@@ -30,8 +30,8 @@ object ImportInfo {
     if isPredef then                                   // do not import any2stringadd
       selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD))
         :: selectors
-    def expr(implicit ctx: Context) = tpd.Ident(refFn())
-    def imp(implicit ctx: Context) = tpd.Import(expr, selectors)
+    def expr(using Context) = tpd.Ident(refFn())
+    def imp(using Context) = tpd.Import(expr, selectors)
     ImportInfo(imp.symbol, selectors, None, isRootImport = true)
 }
 
@@ -50,7 +50,7 @@ class ImportInfo(symf: Context ?=> Symbol,
 
   // Dotty deviation: we cannot use a lazy val here for the same reason
   // that we cannot use one for `DottyPredefModuleRef`.
-  def sym(implicit ctx: Context): Symbol = {
+  def sym(using Context): Symbol = {
     if (mySym == null) {
       mySym = symf(using ctx)
       assert(mySym != null)
@@ -60,7 +60,7 @@ class ImportInfo(symf: Context ?=> Symbol,
   private var mySym: Symbol = _
 
   /** The (TermRef) type of the qualifier of the import clause */
-  def site(implicit ctx: Context): Type = sym.info match {
+  def site(using Context): Type = sym.info match {
     case ImportType(expr) => expr.tpe
     case _ => NoType
   }
@@ -105,19 +105,19 @@ class ImportInfo(symf: Context ?=> Symbol,
           myReverseMapping = myReverseMapping.updated(sel.rename, sel.name)
 
   /** The upper bound for `given` wildcards, or `Nothing` if there are none */
-  def givenBound(implicit ctx: Context) =
+  def givenBound(using Context) =
     if !myGivenBound.exists then
       myGivenBound = ctx.typer.importBound(selectors, isGiven = true)
     myGivenBound
 
   /** The upper bound for `_` wildcards, or `Nothing` if there are none */
-  def wildcardBound(implicit ctx: Context) =
+  def wildcardBound(using Context) =
     if !myWildcardBound.exists then
       myWildcardBound = ctx.typer.importBound(selectors, isGiven = false)
     myWildcardBound
 
   /** The implicit references imported by this import clause */
-  def importedImplicits(implicit ctx: Context): List[ImplicitRef] =
+  def importedImplicits(using Context): List[ImplicitRef] =
     val pre = site
     if isWildcardImport then
       pre.implicitMembers.flatMap { ref =>
@@ -157,7 +157,7 @@ class ImportInfo(symf: Context ?=> Symbol,
    *      override import Predef.{any2stringAdd => _, StringAdd => _, _} // disables String +
    *      override import java.lang.{}                                   // disables all imports
    */
-  def unimported(implicit ctx: Context): Symbol =
+  def unimported(using Context): Symbol =
     if myUnimported == null then
       lazy val sym = site.termSymbol
       def maybeShadowsRoot = symNameOpt match
@@ -172,7 +172,7 @@ class ImportInfo(symf: Context ?=> Symbol,
   private var myUnimported: Symbol = _
 
   /** Does this import clause or a preceding import clause import `owner.feature`? */
-  def featureImported(feature: TermName, owner: Symbol)(implicit ctx: Context): Boolean =
+  def featureImported(feature: TermName, owner: Symbol)(using Context): Boolean =
 
     def compute =
       val isImportOwner = site.widen.typeSymbol.eq(owner)
@@ -181,7 +181,7 @@ class ImportInfo(symf: Context ?=> Symbol,
       else
         var c = ctx.outer
         while c.importInfo eq ctx.importInfo do c = c.outer
-        (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(c)
+        (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c)
 
     if (lastOwner.ne(owner) || !lastResults.contains(feature)) {
       lastOwner = owner

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

@@ -29,17 +29,17 @@ object Inferencing {
    *  but only if the overall result of `isFullyDefined` is `true`.
    *  Variables that are successfully minimized do not count as uninstantiated.
    */
-  def isFullyDefined(tp: Type, force: ForceDegree.Value)(implicit ctx: Context): Boolean = {
+  def isFullyDefined(tp: Type, force: ForceDegree.Value)(using Context): Boolean = {
     val nestedCtx = ctx.fresh.setNewTyperState()
-    val result = new IsFullyDefinedAccumulator(force)(nestedCtx).process(tp)
+    val result = new IsFullyDefinedAccumulator(force)(using nestedCtx).process(tp)
     if (result) nestedCtx.typerState.commit()
     result
   }
 
   /** The fully defined type, where all type variables are forced.
    *  Throws an error if type contains wildcards.
    */
-  def fullyDefinedType(tp: Type, what: String, span: Span)(implicit ctx: Context): Type =
+  def fullyDefinedType(tp: Type, what: String, span: Span)(using Context): Type =
     if (isFullyDefined(tp, ForceDegree.all)) tp
     else throw new Error(i"internal error: type of $what $tp is not fully defined, pos = $span") // !!! DEBUG
 
@@ -52,7 +52,7 @@ object Inferencing {
    *  If none of (1) - (4) applies, the type variable is left uninstantiated.
    *  The method is called to instantiate type variables before an implicit search.
    */
-  def instantiateSelected(tp: Type, tvars: List[Type])(implicit ctx: Context): Unit =
+  def instantiateSelected(tp: Type, tvars: List[Type])(using Context): Unit =
     if (tvars.nonEmpty)
       IsFullyDefinedAccumulator(
         ForceDegree.Value(tvars.contains, IfBottom.flip), minimizeSelected = true
@@ -61,7 +61,7 @@ object Inferencing {
   /** Instantiate any type variables in `tp` whose bounds contain a reference to
    *  one of the parameters in `tparams` or `vparamss`.
    */
-  def instantiateDependent(tp: Type, tparams: List[Symbol], vparamss: List[List[Symbol]])(implicit ctx: Context): Unit = {
+  def instantiateDependent(tp: Type, tparams: List[Symbol], vparamss: List[List[Symbol]])(using Context): Unit = {
     val dependentVars = new TypeAccumulator[Set[TypeVar]] {
       @threadUnsafe lazy val params = (tparams :: vparamss).flatten
       def apply(tvars: Set[TypeVar], tp: Type) = tp match {
@@ -108,7 +108,7 @@ object Inferencing {
    *  to their upper bound.
    */
   private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeSelected: Boolean = false)
-    (implicit ctx: Context) extends TypeAccumulator[Boolean] {
+    (using Context) extends TypeAccumulator[Boolean] {
 
     private def instantiate(tvar: TypeVar, fromBelow: Boolean): Type = {
       val inst = tvar.instantiate(fromBelow)
@@ -167,7 +167,7 @@ object Inferencing {
    *  instantiate the type parameter to the lower bound's approximation
    *  (approximation because of possible F-bounds).
    */
-  def replaceSingletons(tp: Type)(implicit ctx: Context): Unit = {
+  def replaceSingletons(tp: Type)(using Context): Unit = {
     val tr = new TypeTraverser {
       def traverse(tp: Type): Unit = {
         tp match {
@@ -190,7 +190,7 @@ object Inferencing {
   }
 
   /** If `tree` has a type lambda type, infer its type parameters by comparing with expected type `pt` */
-  def inferTypeParams(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree.tpe match {
+  def inferTypeParams(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match {
     case tl: TypeLambda =>
       val (tl1, tvars) = constrained(tl, tree)
       var tree1 = AppliedTypeTree(tree.withType(tl1), tvars)
@@ -201,7 +201,7 @@ object Inferencing {
       tree
   }
 
-  def isSkolemFree(tp: Type)(implicit ctx: Context): Boolean =
+  def isSkolemFree(tp: Type)(using Context): Boolean =
     !tp.existsPart(_.isInstanceOf[SkolemType])
 
   /** The list of uninstantiated type variables bound by some prefix of type `T` which
@@ -212,7 +212,7 @@ object Inferencing {
    *    - The prefix `p` of a selection `p.f`.
    *    - The result expression `e` of a block `{s1; .. sn; e}`.
    */
-  def tvarsInParams(tree: Tree, locked: TypeVars)(implicit ctx: Context): List[TypeVar] = {
+  def tvarsInParams(tree: Tree, locked: TypeVars)(using Context): List[TypeVar] = {
     @tailrec def boundVars(tree: Tree, acc: List[TypeVar]): List[TypeVar] = tree match {
       case Apply(fn, _) => boundVars(fn, acc)
       case TypeApply(fn, targs) =>
@@ -252,7 +252,7 @@ object Inferencing {
    *           -1 (minimize) if constraint is uniformly from below,
    *            0 if unconstrained, or constraint is from below and above.
    */
-  private def instDirection(param: TypeParamRef)(implicit ctx: Context): Int = {
+  private def instDirection(param: TypeParamRef)(using Context): Int = {
     val constrained = ctx.typeComparer.fullBounds(param)
     val original = param.binder.paramInfos(param.paramNum)
     val cmp = ctx.typeComparer
@@ -267,7 +267,7 @@ object Inferencing {
    *  class type reference where the class has a companion module, a reference to
    *  that companion module. Otherwise NoType
    */
-  def companionRef(tp: Type)(implicit ctx: Context): Type =
+  def companionRef(tp: Type)(using Context): Type =
     tp.underlyingClassRef(refinementOK = true) match {
       case tp: TypeRef =>
         val companion = tp.classSymbol.companionModule
@@ -281,7 +281,7 @@ object Inferencing {
    *  @return   The list of type symbols that were created
    *            to instantiate undetermined type variables that occur non-variantly
    */
-  def maximizeType(tp: Type, span: Span, fromScala2x: Boolean)(implicit ctx: Context): List[Symbol] = {
+  def maximizeType(tp: Type, span: Span, fromScala2x: Boolean)(using Context): List[Symbol] = {
     Stats.record("maximizeType")
     val vs = variances(tp)
     val patternBound = new mutable.ListBuffer[Symbol]
@@ -325,7 +325,7 @@ object Inferencing {
    *
    *  we want to instantiate U to x.type right away. No need to wait further.
    */
-  private def variances(tp: Type)(implicit ctx: Context): VarianceMap = {
+  private def variances(tp: Type)(using Context): VarianceMap = {
     Stats.record("variances")
     val constraint = ctx.typerState.constraint
 
@@ -400,7 +400,7 @@ trait Inferencing { this: Typer =>
    *  Then `Y` also occurs co-variantly in `T` because it needs to be minimized in order to constrain
    *  `T` the least. See `variances` for more detail.
    */
-  def interpolateTypeVars(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): tree.type = {
+  def interpolateTypeVars(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = {
     val state = ctx.typerState
 
     // Note that some variables in `locked` might not be in `state.ownedVars`

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

@@ -935,7 +935,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
         def searchImplicit(sym: TermSymbol, tpt: Tree) = {
           val evTyper = new Typer
           val evCtx = ctx.fresh.setTyper(evTyper)
-          val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)(evCtx)
+          val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)(using evCtx)
           evidence.tpe match {
             case fail: Implicits.AmbiguousImplicits =>
               ctx.error(evTyper.missingArgMsg(evidence, tpt.tpe, ""), tpt.sourcePos)

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

@@ -738,7 +738,7 @@ class Typer extends Namer
     case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper && !(tref =:= pt) =>
       require(ctx.mode.is(Mode.Pattern))
       inferImplicit(defn.ClassTagClass.typeRef.appliedTo(tref),
-                    EmptyTree, tree.tpt.span)(ctx.retractMode(Mode.Pattern)) match {
+                    EmptyTree, tree.tpt.span)(using ctx.retractMode(Mode.Pattern)) match {
         case SearchSuccess(clsTag, _, _) =>
           typed(untpd.Apply(untpd.TypedSplice(clsTag), untpd.TypedSplice(tree.expr)), pt)
         case _ =>