Convert Symbols to using clauses

Author: odersky

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -8,6 +8,7 @@ import scala.collection.mutable
 import scala.collection.generic.Clearable
 
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Contexts.inContext
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
@@ -228,8 +229,9 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
         if (innerClassSym.isClass) {
-          val ct = ctx.withPhase(ctx.flattenPhase.prev)
-          toDenot(innerClassSym)(ct).owner.enclosingClass(ct)
+          inContext(ctx.withPhase(ctx.flattenPhase.prev)) {
+            toDenot(innerClassSym).owner.enclosingClass
+          }
         }
         else innerClassSym.enclosingClass(ctx.withPhase(ctx.flattenPhase.prev))
       } //todo is handled specially for JavaDefined symbols in scalac
@@ -255,7 +257,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
         if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
         else {
           val original = innerClassSym.initial
-          Some(innerClassSym.name(ctx.withPhase(original.validFor.phaseId)).mangledString) // moduleSuffix for module classes
+          Some(innerClassSym.name(using ctx.withPhase(original.validFor.phaseId)).mangledString) // moduleSuffix for module classes
         }
       }
 

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -137,8 +137,9 @@ object DottyBackendInterface {
         // for example by specialization
         val original = toDenot(sym).initial
         val validity = original.validFor
-        val shiftedContext = ctx.withPhase(validity.phaseId)
-        toDenot(sym)(shiftedContext).isStatic(shiftedContext)
+        inContext(ctx.withPhase(validity.phaseId)) {
+          toDenot(sym).isStatic
+        }
       }
 
 
@@ -148,8 +149,9 @@ object DottyBackendInterface {
       // it is very tricky in presence of classes(and annonymous classes) defined inside supper calls.
       if (sym.exists) {
         val validity = toDenot(sym).initial.validFor
-        val shiftedContext = ctx.withPhase(validity.phaseId)
-        toDenot(sym)(shiftedContext).lexicallyEnclosingClass(shiftedContext)
+        inContext(ctx.withPhase(validity.phaseId)) {
+          toDenot(sym).lexicallyEnclosingClass
+        }
       } else NoSymbol
 
     /**

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -833,7 +833,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           def traverse(tree: Tree)(implicit ctx: Context) = tree match {
             case tree: DefTree =>
               val sym = tree.symbol
-              val prevDenot = sym.denot(ctx.withPhase(trans))
+              val prevDenot = sym.denot(using ctx.withPhase(trans))
               if (prevDenot.effectiveOwner == from.skipWeakOwner) {
                 val d = sym.copySymDenotation(owner = to)
                 d.installAfter(trans)

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

@@ -147,12 +147,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
   import Scala2Unpickler._
 
-  val moduleRoot: SymDenotation = moduleClassRoot.sourceModule(ictx).denot(ictx)
+  val moduleRoot: SymDenotation = inContext(ictx) { moduleClassRoot.sourceModule.denot }
   assert(moduleRoot.isTerm)
 
   checkVersion(ictx)
 
-  private val loadingMirror = defn(ictx) // was: mirrorThatLoaded(classRoot)
+  private val loadingMirror = defn(using ictx) // was: mirrorThatLoaded(classRoot)
 
   /** A map from entry numbers to array offsets */
   private val index = createIndex

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -93,7 +93,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def prepareForValDef(vdef: ValDef)(implicit ctx: Context): Context = {
     val sym = vdef.symbol(ctx.withPhase(thisPhase))
     if (captured contains sym) {
-      val newd = sym.denot(ctx.withPhase(thisPhase)).copySymDenotation(
+      val newd = sym.denot(using ctx.withPhase(thisPhase)).copySymDenotation(
         info = refClass(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef,
         initFlags = sym.flags &~ Mutable)
       newd.removeAnnotation(defn.VolatileAnnot)
@@ -117,7 +117,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def transformIdent(id: Ident)(implicit ctx: Context): Tree = {
     val vble = id.symbol
     if (captured.contains(vble))
-      id.select(nme.elem).ensureConforms(vble.denot(ctx.withPhase(thisPhase)).info)
+      id.select(nme.elem).ensureConforms(vble.denot(using ctx.withPhase(thisPhase)).info)
     else id
   }
 

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

@@ -117,7 +117,7 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
         case ClassInfo(pre, cls, _, _, _) if cls is ModuleClass =>
           cls.linkedClass match {
             case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
-              val info1 = cls.denot(ctx.withPhase(ctx.phase.next)).asClass.classInfo.derivedClassInfo(prefix = pre)
+              val info1 = cls.denot(using ctx.withPhase(ctx.phase.next)).asClass.classInfo.derivedClassInfo(prefix = pre)
               ref.derivedSingleDenotation(ref.symbol, info1)
             case _ => ref
           }

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

@@ -23,7 +23,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
 
   /** The info of the tree's symbol before it is potentially transformed in this phase */
   private def originalDenotation(tree: Tree)(implicit ctx: Context) =
-    tree.symbol.denot(ctx.withPhase(thisPhase))
+    tree.symbol.denot(using ctx.withPhase(thisPhase))
 
   /** If denotation had an ExprType before, it now gets a function type */
   protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context): Boolean =

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

@@ -327,7 +327,7 @@ object Summarization {
       cls.info match {
         case cinfo: ClassInfo =>
           val source = {
-            implicit val ctx2: Context = theCtx.withSource(cls.source(theCtx))
+            implicit val ctx2: Context = theCtx.withSource(cls.source(using theCtx))
             TypeTree(cls.typeRef).withSpan(cls.span)
           }
 

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -534,7 +534,7 @@ object RefChecks {
           // Give a specific error message for abstract vars based on why it fails:
           // It could be unimplemented, have only one accessor, or be uninitialized.
           if (underlying.is(Mutable)) {
-            val isMultiple = grouped.getOrElse(underlying.name(ctx), Nil).size > 1
+            val isMultiple = grouped.getOrElse(underlying.name, Nil).size > 1
 
             // If both getter and setter are missing, squelch the setter error.
             if (member.isSetter && isMultiple) ()

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

@@ -7,6 +7,6 @@ import dotty.tools.dotc.core.Contexts._
 
 class TC5(val ctx: Context) extends AnyVal {
   def candidates(mbr: SingleDenotation): Boolean = {
-    mbr.symbol.denot(ctx).exists
+    mbr.symbol.denot(using ctx).exists
   }
 }

tests/pos-with-compiler/i143.scala

@@ -0,0 +1,7 @@
+object Test:
+
+  def g(x: Int, y: Int) = x + y
+  inline def f(inline x: (Int, Int)) = g(x._1, x._2)
+
+  val x = f((1, 2))
+