Refactor level checking / type healing logic

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

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))

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
     }
 

compiler/src/dotty/tools/dotc/quoted/Interpreter.scala

@@ -19,12 +19,12 @@ import dotty.tools.dotc.core.Denotations.staticRef
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameKinds.FlatName
 import dotty.tools.dotc.core.Names._
-import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.TypeErasure
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.quoted._
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.reporting.Message

compiler/src/dotty/tools/dotc/staging/HealType.scala

@@ -0,0 +1,99 @@
+package dotty.tools.dotc
+package staging
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.staging.QuoteContext.*
+import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.staging.QuoteTypeTags.*
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Implicits.SearchFailureType
+import dotty.tools.dotc.util.SrcPos
+
+class HealType(pos: SrcPos)(using Context) extends TypeMap {
+
+  /** If the type refers to a locally defined symbol (either directly, or in a pickled type),
+   *  check that its staging level matches the current level.
+   *  - Static types and term are allowed at any level.
+   *  - If a type reference is used a higher level, then it is inconsistent.
+   *    Will attempt to heal before failing.
+   *  - If a term reference is used a higher level, then it is inconsistent.
+   *    It cannot be healed because the term will not exist in any future stage.
+   *
+   *  If `T` is a reference to a type at the wrong level, try to heal it by replacing it with
+   *  a type tag of type `quoted.Type[T]`.
+   *  The tag is generated by an instance of `QuoteTypeTags` directly if the splice is explicit
+   *  or indirectly by `tryHeal`.
+   */
+  def apply(tp: Type): Type =
+    tp match
+      case tp: TypeRef =>
+        healTypeRef(tp)
+      case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
+        levelError(tp.symbol, tp, pos)
+      case tp: AnnotatedType =>
+        derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
+      case _ =>
+        mapOver(tp)
+
+  private def healTypeRef(tp: TypeRef): Type =
+    tp.prefix match
+      case prefix: TermRef if tp.symbol.isTypeSplice =>
+        checkNotWildcardSplice(tp)
+        if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
+      case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
+        dealiasAndTryHeal(prefix.symbol, tp, pos)
+      case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+        dealiasAndTryHeal(tp.symbol, tp, pos)
+      case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
+        dealiasAndTryHeal(tp.symbol, tp, pos)
+      case _ =>
+        mapOver(tp)
+
+  private def checkNotWildcardSplice(splice: TypeRef): Unit =
+    splice.prefix.termSymbol.info.argInfos match
+      case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
+      case _ =>
+
+  private def dealiasAndTryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): Type =
+    val tp1 = tp.dealias
+    if tp1 != tp then apply(tp1)
+    else tryHeal(tp.symbol, tp, pos)
+
+  /** Try to heal reference to type `T` used in a higher level than its definition.
+   *  Returns a reference to a type tag generated by `QuoteTypeTags` that contains a
+   *  reference to a type alias containing the equivalent of `${summon[quoted.Type[T]]}`.
+   *  Emits and error if `T` cannot be healed and returns `T`.
+   */
+  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): TypeRef = {
+    val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
+    val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
+    tag.tpe match
+      case tp: TermRef =>
+        ctx.typer.checkStable(tp, pos, "type witness")
+        getQuoteTypeTags.getTagRef(tp)
+      case _: SearchFailureType =>
+        report.error(
+          ctx.typer.missingArgMsg(tag, reqType, "")
+            .prepend(i"Reference to $tp within quotes requires a given $reqType in scope.\n")
+            .append("\n"),
+            pos)
+        tp
+      case _ =>
+        report.error(em"""Reference to $tp within quotes requires a given $reqType in scope.
+                      |
+                      |""", pos)
+        tp
+  }
+
+  private def levelError(sym: Symbol, tp: Type, pos: SrcPos): tp.type = {
+    report.error(
+      em"""access to $sym from wrong staging level:
+          | - the definition is at level ${levelOf(sym)},
+          | - but the access is at level $level""", pos)
+    tp
+  }
+}