Move level tracking into StagingLevel

nicolasstucki · nicolasstucki · commit 540277bdb16d · 2023-03-13T21:15:50.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/core/StagingContext.scala b/compiler/src/dotty/tools/dotc/core/StagingContext.scala
@@ -5,36 +5,21 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.StagingLevel.*
 
 object StagingContext {
 
-  /** A key to be used in a context property that tracks the quotation level */
-  private val QuotationLevel = new Property.Key[Int]
-
   /** A key to be used in a context property that tracks the quotation stack.
    *  Stack containing the Quotes references received by the surrounding quotes.
    */
   private val QuotesStack = new Property.Key[List[tpd.Tree]]
 
   private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
 
-  /** All enclosing calls that are currently inlined, from innermost to outermost. */
-  def level(using Context): Int =
-    ctx.property(QuotationLevel).getOrElse(0)
-
-  /** Context with an incremented quotation level. */
-  def quoteContext(using Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level + 1)
-
   /** Context with an incremented quotation level and pushes a reference to a Quotes on the quote context stack */
   def pushQuotes(qctxRef: tpd.Tree)(using Context): Context =
     val old = ctx.property(QuotesStack).getOrElse(List.empty)
-    ctx.fresh.setProperty(QuotationLevel, level + 1)
-             .setProperty(QuotesStack, qctxRef :: old)
-
-  /** Context with a decremented quotation level. */
-  def spliceContext(using Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level - 1)
+    quoteContext.setProperty(QuotesStack, qctxRef :: old)
 
   def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Context) =
     ctx.fresh.setProperty(TaggedTypes, taggedTypes)
@@ -46,7 +31,7 @@ object StagingContext {
    *  The quotation stack could be empty if we are in a top level splice or an erroneous splice directly within a top level splice.
    */
   def popQuotes()(using Context): (Option[tpd.Tree], Context) =
-    val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
+    val ctx1 = spliceContext
     val head =
       ctx.property(QuotesStack) match
         case Some(x :: xs) =>
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -23,6 +23,7 @@ import util.Spans.Span
 import dotty.tools.dotc.transform.Splicer
 import dotty.tools.dotc.transform.BetaReduce
 import quoted.QuoteUtils
+import staging.StagingLevel
 import scala.annotation.constructorOnly
 
 /** General support for inlining */
@@ -814,7 +815,7 @@ class Inliner(val call: tpd.Tree)(using Context):
       val locked = ctx.typerState.ownedVars
       val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
         case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
-                        && StagingContext.level == 0
+                        && StagingLevel.level == 0
                         && !hasInliningErrors =>
           val expanded = expandMacro(res.args.head, tree.srcPos)
           transform.TreeChecker.checkMacroGeneratedTree(res, expanded)
@@ -1026,7 +1027,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   }
 
   private def expandMacro(body: Tree, splicePos: SrcPos)(using Context) = {
-    assert(StagingContext.level == 0)
+    assert(StagingLevel.level == 0)
     val inlinedFrom = enclosingInlineds.last
     val dependencies = macroDependencies(body)
     val suspendable = ctx.compilationUnit.isSuspendable
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
@@ -14,6 +14,7 @@ import ErrorReporting.errorTree
 import dotty.tools.dotc.util.{SourceFile, SourcePosition, SrcPos}
 import parsing.Parsers.Parser
 import transform.{PostTyper, Inlining, CrossVersionChecks}
+import staging.StagingLevel
 
 import collection.mutable
 import reporting.trace
@@ -56,7 +57,7 @@ object Inlines:
     case _ =>
       isInlineable(tree.symbol)
       && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly]
-      && StagingContext.level == 0
+      && StagingLevel.level == 0
       && (
         ctx.phase == Phases.inliningPhase
         || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree))
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -22,6 +22,7 @@ import staging.PCPCheckAndHeal
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
+import staging.StagingLevel
 
 object PrepareInlineable {
   import tpd._
@@ -73,7 +74,7 @@ object PrepareInlineable {
         !sym.isContainedIn(inlineSym) &&
         !(sym.isStableMember && sym.info.widenTermRefExpr.isInstanceOf[ConstantType]) &&
         !sym.isInlineMethod &&
-        (Inlines.inInlineMethod || StagingContext.level > 0)
+        (Inlines.inInlineMethod || StagingLevel.level > 0)
 
       def preTransform(tree: Tree)(using Context): Tree
 
@@ -90,8 +91,8 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: Apply if tree.symbol.isQuote => StagingContext.quoteContext
-        case tree: Apply if tree.symbol.isExprSplice => StagingContext.spliceContext
+        case tree: Apply if tree.symbol.isQuote => StagingLevel.quoteContext
+        case tree: Apply if tree.symbol.isExprSplice => StagingLevel.spliceContext
         case _ => ctx
     }
 
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -14,9 +14,24 @@ import scala.collection.mutable
 
 object StagingLevel {
 
+  /** A key to be used in a context property that tracks the staging level */
+  private val LevelKey = new Property.Key[Int]
+
   /** A key to be used in a context property that caches the `levelOf` mapping */
   private val LevelOfKey = new Property.Key[Map[Symbol, Int]]
 
+  /** All enclosing calls that are currently inlined, from innermost to outermost. */
+  def level(using Context): Int =
+    ctx.property(LevelKey).getOrElse(0)
+
+  /** Context with an incremented staging level. */
+  def quoteContext(using Context): FreshContext =
+    ctx.fresh.setProperty(LevelKey, level + 1)
+
+  /** Context with a decremented staging level. */
+  def spliceContext(using Context): FreshContext =
+    ctx.fresh.setProperty(LevelKey, level - 1)
+
   /** The quotation level of the definition of the locally defined symbol */
   def levelOf(sym: Symbol)(using Context): Int =
     ctx.property(LevelOfKey) match
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -13,6 +13,7 @@ import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.staging.StagingLevel
 
 import scala.collection.mutable.ListBuffer
 
@@ -46,10 +47,10 @@ class Inlining extends MacroTransform {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
               case _: GenericApply if tree.symbol.isQuote =>
-                traverseChildren(tree)(using StagingContext.quoteContext)
+                traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol.isExprSplice =>
-                traverseChildren(tree)(using StagingContext.spliceContext)
-              case tree: RefTree if !Inlines.inInlineMethod && StagingContext.level == 0 =>
+                traverseChildren(tree)(using StagingLevel.spliceContext)
+              case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
               case _ =>
                 traverseChildren(tree)
@@ -76,7 +77,7 @@ class Inlining extends MacroTransform {
           else if tree.symbol.is(Param) then super.transform(tree)
           else if
             !tree.symbol.isPrimaryConstructor
-            && StagingContext.level == 0
+            && StagingLevel.level == 0
             && MacroAnnotations.hasMacroAnnotation(tree.symbol)
           then
             val trees = (new MacroAnnotations).expandAnnotations(tree)
@@ -98,9 +99,9 @@ class Inlining extends MacroTransform {
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
         case _: GenericApply if tree.symbol.isQuote =>
-          super.transform(tree)(using StagingContext.quoteContext)
+          super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol.isExprSplice =>
-          super.transform(tree)(using StagingContext.spliceContext)
+          super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
             case tree1: PackageDef  =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -23,6 +23,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.StagingLevel.*
 
 import scala.annotation.constructorOnly
 
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -11,11 +11,12 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameKinds.PatMatGivenVarName
 import dotty.tools.dotc.core.Names._
-import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.core.StagingContext.*
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.inlines.PrepareInlineable
+import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits._
 import dotty.tools.dotc.typer.Inferencing._
@@ -91,7 +92,7 @@ trait QuotesAndSplices {
         tree.withType(UnspecifiedErrorType)
       }
     else {
-      if (StagingContext.level == 0) {
+      if (level == 0) {
         // Mark the first inline method from the context as a macro
         def markAsMacro(c: Context): Unit =
           if (c.owner eq c.outer.owner) markAsMacro(c.outer)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -44,6 +44,7 @@ import config.Feature
 import config.Feature.{sourceVersion, migrateTo3}
 import config.SourceVersion._
 import rewrites.Rewrites.patch
+import staging.StagingLevel
 import transform.SymUtils._
 import transform.TypeUtils._
 import reporting._
@@ -2410,7 +2411,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx))
 
     if sym.isInlineMethod then
-      if StagingContext.level > 0 then
+      if StagingLevel.level > 0 then
         report.error("inline def cannot be within quotes", sym.sourcePos)
       if sym.is(Given)
           && untpd.stripBlock(untpd.unsplice(ddef.rhs)).isInstanceOf[untpd.Function]
