Convert other dotc classes (2)

Author: odersky

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -41,7 +41,7 @@ import scala.collection.mutable
 class ExtractAPI extends Phase {
   override def phaseName: String = "sbt-api"
 
-  override def isRunnable(implicit ctx: Context): Boolean = {
+  override def isRunnable(using Context): Boolean = {
     def forceRun = ctx.settings.YdumpSbtInc.value || ctx.settings.YforceSbtPhases.value
     super.isRunnable && (ctx.sbtCallback != null || forceRun)
   }
@@ -56,7 +56,7 @@ class ExtractAPI extends Phase {
   // definitions, and `PostTyper` does not change definitions).
   override def runsAfter: Set[String] = Set(transform.PostTyper.name)
 
-  override def run(implicit ctx: Context): Unit = {
+  override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     val sourceFile = unit.source.file
     if (ctx.sbtCallback != null)
@@ -124,7 +124,7 @@ class ExtractAPI extends Phase {
  *  without going through an intermediate representation, see
  *  http://www.scala-sbt.org/0.13/docs/Understanding-Recompilation.html#Hashing+an+API+representation
  */
-private class ExtractAPICollector(implicit ctx: Context) extends ThunkHolder {
+private class ExtractAPICollector(using Context) extends ThunkHolder {
   import tpd._
   import xsbti.api
 

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -49,7 +49,7 @@ class ExtractDependencies extends Phase {
 
   override def phaseName: String = "sbt-deps"
 
-  override def isRunnable(implicit ctx: Context): Boolean = {
+  override def isRunnable(using Context): Boolean = {
     def forceRun = ctx.settings.YdumpSbtInc.value || ctx.settings.YforceSbtPhases.value
     super.isRunnable && (ctx.sbtCallback != null || forceRun)
   }
@@ -62,7 +62,7 @@ class ExtractDependencies extends Phase {
   // See the scripted test `constants` for an example where this matters.
   // TODO: Add a `Phase#runsBefore` method ?
 
-  override def run(implicit ctx: Context): Unit = {
+  override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     val collector = new ExtractDependenciesCollector
     collector.traverse(unit.tpdTree)
@@ -105,7 +105,7 @@ class ExtractDependencies extends Phase {
    * that is coming from either source code (not necessarily compiled in this compilation
    * run) or from class file and calls respective callback method.
    */
-  def recordDependency(dep: ClassDependency)(implicit ctx: Context): Unit = {
+  def recordDependency(dep: ClassDependency)(using Context): Unit = {
     val fromClassName = classNameAsString(dep.from)
     val sourceFile = ctx.compilationUnit.source.file.file
 
@@ -161,7 +161,7 @@ class ExtractDependencies extends Phase {
 }
 
 object ExtractDependencies {
-  def classNameAsString(sym: Symbol)(implicit ctx: Context): String =
+  def classNameAsString(sym: Symbol)(using Context): String =
     sym.fullName.stripModuleClassSuffix.toString
 }
 
@@ -217,10 +217,10 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
    *  class/trait/object declared in the compilation unit. If none exists, issue warning.
    */
   private var _responsibleForImports: Symbol = _
-  private def responsibleForImports(implicit ctx: Context) = {
+  private def responsibleForImports(using Context) = {
     def firstClassOrModule(tree: Tree) = {
       val acc = new TreeAccumulator[Symbol] {
-        def apply(x: Symbol, t: Tree)(implicit ctx: Context) =
+        def apply(x: Symbol, t: Tree)(using Context) =
           t match {
             case typeDef: TypeDef =>
               typeDef.symbol
@@ -250,7 +250,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
    * Resolves dependency source (that is, the closest non-local enclosing
    * class from a given `ctx.owner`
    */
-  private def resolveDependencySource(implicit ctx: Context): Symbol = {
+  private def resolveDependencySource(using Context): Symbol = {
     def nonLocalEnclosingClass = {
       var clazz = ctx.owner.enclosingClass
       var owner = clazz
@@ -280,7 +280,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
     usedName.update(name, scope)
   }
 
-  private def addUsedName(name: Name, scope: UseScope)(implicit ctx: Context): Unit = {
+  private def addUsedName(name: Name, scope: UseScope)(using Context): Unit = {
     val fromClass = resolveDependencySource
     if (fromClass.exists) { // can happen when visiting imports
       assert(fromClass.isClass)
@@ -289,14 +289,14 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
   }
 
   /** Mangle a JVM symbol name in a format better suited for internal uses by sbt. */
-  private def mangledName(sym: Symbol)(implicit ctx: Context): Name = {
+  private def mangledName(sym: Symbol)(using Context): Name = {
     def constructorName = sym.owner.fullName ++ ";init;"
 
     if (sym.isConstructor) constructorName
     else sym.name.stripModuleClassSuffix
   }
 
-  private def addMemberRefDependency(sym: Symbol)(implicit ctx: Context): Unit =
+  private def addMemberRefDependency(sym: Symbol)(using Context): Unit =
     if (!ignoreDependency(sym)) {
       val enclOrModuleClass = if (sym.is(ModuleVal)) sym.moduleClass else sym.enclosingClass
       assert(enclOrModuleClass.isClass, s"$enclOrModuleClass, $sym")
@@ -313,7 +313,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
       }
     }
 
-  private def addInheritanceDependencies(tree: Template)(implicit ctx: Context): Unit =
+  private def addInheritanceDependencies(tree: Template)(using Context): Unit =
     if (tree.parents.nonEmpty) {
       val depContext =
         if (tree.symbol.owner.isLocal) LocalDependencyByInheritance
@@ -324,7 +324,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
       }
     }
 
-  private def ignoreDependency(sym: Symbol)(implicit ctx: Context) =
+  private def ignoreDependency(sym: Symbol)(using Context) =
     !sym.exists ||
     sym.isAbsent(canForce = false) || // ignore dependencies that have a symbol but do not exist.
                                       // e.g. java.lang.Object companion object
@@ -335,7 +335,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
   /** Traverse the tree of a source file and record the dependencies and used names which
    *  can be retrieved using `dependencies` and`usedNames`.
    */
-  override def traverse(tree: Tree)(implicit ctx: Context): Unit = try {
+  override def traverse(tree: Tree)(using Context): Unit = try {
     tree match {
       case Match(selector, _) =>
         addPatMatDependency(selector.tpe)
@@ -415,7 +415,7 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
    *  The tests in sbt `types-in-used-names-a`, `types-in-used-names-b`,
    *  `as-seen-from-a` and `as-seen-from-b` rely on this.
    */
-  private abstract class TypeDependencyTraverser(implicit ctx: Context) extends TypeTraverser()(using ctx) {
+  private abstract class TypeDependencyTraverser(using Context) extends TypeTraverser()(using ctx) {
     protected def addDependency(symbol: Symbol): Unit
 
     val seen = new mutable.HashSet[Type]
@@ -442,14 +442,14 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
     }
   }
 
-  def addTypeDependency(tpe: Type)(implicit ctx: Context): Unit = {
+  def addTypeDependency(tpe: Type)(using Context): Unit = {
     val traverser = new TypeDependencyTraverser {
       def addDependency(symbol: Symbol) = addMemberRefDependency(symbol)
     }
     traverser.traverse(tpe)
   }
 
-  def addPatMatDependency(tpe: Type)(implicit ctx: Context): Unit = {
+  def addPatMatDependency(tpe: Type)(using Context): Unit = {
     val traverser = new TypeDependencyTraverser {
       def addDependency(symbol: Symbol) =
         if (!ignoreDependency(symbol) && symbol.is(Sealed)) {

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -35,13 +35,13 @@ class ExtractSemanticDB extends Phase:
 
   override val phaseName: String = ExtractSemanticDB.name
 
-  override def isRunnable(implicit ctx: Context) =
+  override def isRunnable(using Context) =
     super.isRunnable && ctx.settings.Ysemanticdb.value
 
   // Check not needed since it does not transform trees
   override def isCheckable: Boolean = false
 
-  override def run(implicit ctx: Context): Unit =
+  override def run(using Context): Unit =
     val unit = ctx.compilationUnit
     val extract = Extractor()
     extract.traverse(unit.tpdTree)

compiler/src/dotty/tools/dotc/tastyreflect/FromSymbol.scala

@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Types._
 
 object FromSymbol {
 
-  def definitionFromSym(sym: Symbol)(implicit ctx: Context): tpd.Tree = {
+  def definitionFromSym(sym: Symbol)(using Context): tpd.Tree = {
     assert(sym.exists)
     if (sym.is(Package)) packageDefFromSym(sym)
     else if (sym.isClass) classDef(sym.asClass)
@@ -21,9 +21,9 @@ object FromSymbol {
     else valDefFromSym(sym.asTerm)
   }
 
-  def packageDefFromSym(sym: Symbol)(implicit ctx: Context): PackageDefinition = PackageDefinitionImpl(sym)
+  def packageDefFromSym(sym: Symbol)(using Context): PackageDefinition = PackageDefinitionImpl(sym)
 
-  def classDef(cls: ClassSymbol)(implicit ctx: Context): tpd.TypeDef = cls.defTree match {
+  def classDef(cls: ClassSymbol)(using Context): tpd.TypeDef = cls.defTree match {
     case tree: tpd.TypeDef => tree
     case tpd.EmptyTree =>
       val constrSym = cls.unforcedDecls.find(_.isPrimaryConstructor).orElse(
@@ -36,27 +36,27 @@ object FromSymbol {
       tpd.ClassDefWithParents(cls, constr, parents, body)
   }
 
-  def typeDefFromSym(sym: TypeSymbol)(implicit ctx: Context): tpd.TypeDef = sym.defTree match {
+  def typeDefFromSym(sym: TypeSymbol)(using Context): tpd.TypeDef = sym.defTree match {
     case tree: tpd.TypeDef => tree
     case tpd.EmptyTree => tpd.TypeDef(sym)
   }
 
-  def defDefFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.DefDef = sym.defTree match {
+  def defDefFromSym(sym: TermSymbol)(using Context): tpd.DefDef = sym.defTree match {
     case tree: tpd.DefDef => tree
     case tpd.EmptyTree => tpd.DefDef(sym)
   }
 
-  def valDefFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.ValDef = sym.defTree match {
+  def valDefFromSym(sym: TermSymbol)(using Context): tpd.ValDef = sym.defTree match {
     case tree: tpd.ValDef => tree
     case tpd.EmptyTree => tpd.ValDef(sym)
   }
 
-  def bindFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.Bind = sym.defTree match {
+  def bindFromSym(sym: TermSymbol)(using Context): tpd.Bind = sym.defTree match {
     case tree: tpd.Bind => tree
     case tpd.EmptyTree => tpd.Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.typeRef))
   }
 
-  def typeBindFromSym(sym: TypeSymbol)(implicit ctx: Context): tpd.Bind = sym.defTree match {
+  def typeBindFromSym(sym: TypeSymbol)(using Context): tpd.Bind = sym.defTree match {
     case tree: tpd.Bind => tree
     case tpd.EmptyTree => tpd.Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.typeRef))
   }

compiler/src/dotty/tools/dotc/tastyreflect/MacroExpansion.scala

@@ -10,10 +10,10 @@ object MacroExpansion {
 
   private val MacroExpansionPosition = new Property.Key[SourcePosition]
 
-  def position(implicit ctx: Context): Option[SourcePosition] =
+  def position(using Context): Option[SourcePosition] =
     ctx.property(MacroExpansionPosition)
 
-  def context(inlinedFrom: tpd.Tree)(implicit ctx: Context): Context =
+  def context(inlinedFrom: tpd.Tree)(using Context): Context =
     ctx.fresh.setProperty(MacroExpansionPosition, SourcePosition(inlinedFrom.source, inlinedFrom.span)).setTypeAssigner(new Typer).withSource(inlinedFrom.source)
 }
 

compiler/src/dotty/tools/dotc/tastyreflect/package.scala

@@ -16,7 +16,7 @@ package object tastyreflect {
   case class PackageDefinitionImpl[-T >: Untyped] private[tastyreflect] (sym: Symbol)(implicit @constructorOnly src: SourceFile) extends Tree[T] {
     type ThisTree[-T >: Untyped] = PackageDefinitionImpl[T]
 
-    override def denot(implicit ctx: Context): SymDenotation = sym.denot
+    override def denot(using Context): SymDenotation = sym.denot
   }
 }
 

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

@@ -19,7 +19,7 @@ object ConstFold {
   import tpd._
 
   /** If tree is a constant operation, replace with result. */
-  def apply[T <: Tree](tree: T)(implicit ctx: Context): T = finish(tree) {
+  def apply[T <: Tree](tree: T)(using Context): T = finish(tree) {
     tree match {
       case Apply(Select(xt, op), yt :: Nil) =>
         xt.tpe.widenTermRefExpr.normalized match
@@ -45,15 +45,15 @@ object ConstFold {
   /** If tree is a constant value that can be converted to type `pt`, perform
    *  the conversion.
    */
-  def apply[T <: Tree](tree: T, pt: Type)(implicit ctx: Context): T =
+  def apply[T <: Tree](tree: T, pt: Type)(using Context): T =
     finish(apply(tree)) {
       tree.tpe.widenTermRefExpr.normalized match {
         case ConstantType(x) => x convertTo pt
         case _ => null
       }
     }
 
-  inline private def finish[T <: Tree](tree: T)(compX: => Constant)(implicit ctx: Context): T =
+  inline private def finish[T <: Tree](tree: T)(compX: => Constant)(using Context): T =
     try {
       val x = compX
       if (x ne null) tree.withType(ConstantType(x)).asInstanceOf[T]

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

@@ -28,7 +28,7 @@ trait Deriving {
    *                   synthesized infrastructure code that is not connected with a
    *                   `derives` instance.
    */
-  class Deriver(cls: ClassSymbol, codePos: SourcePosition)(implicit ctx: Context) {
+  class Deriver(cls: ClassSymbol, codePos: SourcePosition)(using Context) {
 
     /** A buffer for synthesized symbols for type class instances */
     private var synthetics = new mutable.ListBuffer[Symbol]
@@ -268,7 +268,7 @@ trait Deriving {
       import tpd._
 
       /** The type class instance definition with symbol `sym` */
-      def typeclassInstance(sym: Symbol)(implicit ctx: Context): List[Type] => (List[List[tpd.Tree]] => tpd.Tree) = {
+      def typeclassInstance(sym: Symbol)(using Context): List[Type] => (List[List[tpd.Tree]] => tpd.Tree) = {
         (tparamRefs: List[Type]) => (paramRefss: List[List[tpd.Tree]]) =>
           val tparams = tparamRefs.map(_.typeSymbol.asType)
           val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
@@ -291,8 +291,9 @@ trait Deriving {
           typed(rhs, resultType)
       }
 
-      def syntheticDef(sym: Symbol): Tree =
-        tpd.polyDefDef(sym.asTerm, typeclassInstance(sym)(ctx.fresh.setOwner(sym).setNewScope))
+      def syntheticDef(sym: Symbol): Tree = inContext(ctx.fresh.setOwner(sym).setNewScope) {
+        tpd.polyDefDef(sym.asTerm, typeclassInstance(sym))
+      }
 
       synthetics.map(syntheticDef).toList
     }

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

@@ -56,7 +56,7 @@ object Docstrings {
     newComment
   }
 
-  private def expandComment(sym: Symbol)(implicit ctx: Context, docCtx: ContextDocstrings): Option[Comment] =
+  private def expandComment(sym: Symbol)(using Context)(using docCtx: ContextDocstrings): Option[Comment] =
     if (sym eq NoSymbol) None
     else
       for {

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

@@ -164,7 +164,7 @@ object Inferencing {
       )
   }
 
-  def approximateGADT(tp: Type)(implicit ctx: Context): Type = {
+  def approximateGADT(tp: Type)(using Context): Type = {
     val map = new ApproximateGadtAccumulator
     val res = map(tp)
     assert(!map.failed)
@@ -174,7 +174,7 @@ object Inferencing {
   /** This class is mostly based on IsFullyDefinedAccumulator.
     * It tries to approximate the given type based on the available GADT constraints.
     */
-  private class ApproximateGadtAccumulator(implicit ctx: Context) extends TypeMap {
+  private class ApproximateGadtAccumulator(using Context) extends TypeMap {
 
     var failed = false
 
@@ -184,7 +184,7 @@ object Inferencing {
       inst
     }
 
-    private def instDirection2(sym: Symbol)(implicit ctx: Context): Int = {
+    private def instDirection2(sym: Symbol)(using Context): Int = {
       val constrained = ctx.gadt.fullBounds(sym)
       val original = sym.info.bounds
       val cmp = ctx.typeComparer

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

@@ -502,7 +502,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
    *    of a containing object so they are merely idempotent.
    */
   object isElideableExpr {
-    def isStatElideable(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    def isStatElideable(tree: Tree)(using Context): Boolean = unsplice(tree) match {
       case EmptyTree
          | TypeDef(_, _)
          | Import(_, _)