Add add informative scope extrusion check

Author: nicolasstucki

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

@@ -42,13 +42,15 @@ object PickledQuotes {
   def quotedExprToTree[T](expr: quoted.Expr[T])(using Context): Tree = {
     val expr1 = expr.asInstanceOf[ExprImpl]
     expr1.checkScopeId(QuotesImpl.scopeId)
+    ScopeException.checkInCorrectScope(expr1.scope, SpliceScope.getCurrent, expr1.tree, "Expr")
     changeOwnerOfTree(expr1.tree, ctx.owner)
   }
 
   /** Transform the expression into its fully spliced TypeTree */
   def quotedTypeToTree(tpe: quoted.Type[?])(using Context): Tree = {
     val tpe1 = tpe.asInstanceOf[TypeImpl]
     tpe1.checkScopeId(QuotesImpl.scopeId)
+    ScopeException.checkInCorrectScope(tpe1.scope, SpliceScope.getCurrent, tpe1.typeTree, "Type")
     changeOwnerOfTree(tpe1.typeTree, ctx.owner)
   }
 
@@ -73,23 +75,25 @@ object PickledQuotes {
     val evaluateHoles = new TreeMap {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Hole(isTerm, idx, args) =>
-          val reifiedArgs = args.map { arg =>
-            if (arg.isTerm) (q: Quotes) ?=> new ExprImpl(arg, QuotesImpl.scopeId)
-            else new TypeImpl(arg, QuotesImpl.scopeId)
+          inContext(SpliceScope.contextWithNewSpliceScope(tree.sourcePos)) {
+            val reifiedArgs = args.map { arg =>
+              if (arg.isTerm) (q: Quotes) ?=> new ExprImpl(arg, QuotesImpl.scopeId, SpliceScope.getCurrent)
+              else new TypeImpl(arg, QuotesImpl.scopeId, SpliceScope.getCurrent)
+            }
+            if isTerm then
+              val quotedExpr = termHole(idx, reifiedArgs, QuotesImpl())
+              val filled = PickledQuotes.quotedExprToTree(quotedExpr)
+
+              // We need to make sure a hole is created with the source file of the surrounding context, even if
+              // it filled with contents a different source file.
+              if filled.source == ctx.source then filled
+              else filled.cloneIn(ctx.source).withSpan(tree.span)
+            else
+              // Replaces type holes generated by PickleQuotes (non-spliced types).
+              // These are types defined in a quote and used at the same level in a nested quote.
+              val quotedType = typeHole(idx, reifiedArgs)
+              PickledQuotes.quotedTypeToTree(quotedType)
           }
-          if isTerm then
-            val quotedExpr = termHole(idx, reifiedArgs, QuotesImpl())
-            val filled = PickledQuotes.quotedExprToTree(quotedExpr)
-
-            // We need to make sure a hole is created with the source file of the surrounding context, even if
-            // it filled with contents a different source file.
-            if filled.source == ctx.source then filled
-            else filled.cloneIn(ctx.source).withSpan(tree.span)
-          else
-            // Replaces type holes generated by PickleQuotes (non-spliced types).
-            // These are types defined in a quote and used at the same level in a nested quote.
-            val quotedType = typeHole(idx, reifiedArgs)
-            PickledQuotes.quotedTypeToTree(quotedType)
         case tree: Select =>
           // Retain selected members
           val qual = transform(tree.qualifier)

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

@@ -39,16 +39,17 @@ object Splicer {
    *
    *  See: `Staging`
    */
-  def splice(tree: Tree, pos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
+  def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
-        inContext(ctx.withOwner(macroOwner)) {
+        val sliceContext = SpliceScope.contextWithNewSpliceScope(splicePos.sourcePos).withOwner(macroOwner)
+        inContext(sliceContext) {
           val oldContextClassLoader = Thread.currentThread().getContextClassLoader
           Thread.currentThread().setContextClassLoader(classLoader)
           try {
-            val interpreter = new Interpreter(pos, classLoader)
+            val interpreter = new Interpreter(spliceExpansionPos, classLoader)
 
             // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
             val interpretedExpr = interpreter.interpret[Quotes => scala.quoted.Expr[Any]](tree)
@@ -74,7 +75,7 @@ object Splicer {
                |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
                |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").drop(1).mkString("\n    ")}
              """.stripMargin
-          report.error(msg, pos)
+          report.error(msg, spliceExpansionPos)
           ref(defn.Predef_undefined).withType(ErrorType(msg))
       }
   }
@@ -325,10 +326,10 @@ object Splicer {
     }
 
     private def interpretQuote(tree: Tree)(implicit env: Env): Object =
-      new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), QuotesImpl.scopeId)
+      new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), QuotesImpl.scopeId, SpliceScope.getCurrent)
 
     private def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
-      new TypeImpl(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), QuotesImpl.scopeId)
+      new TypeImpl(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), QuotesImpl.scopeId, SpliceScope.getCurrent)
 
     private def interpretLiteral(value: Any)(implicit env: Env): Object =
       value.asInstanceOf[Object]

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

@@ -1303,7 +1303,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
         case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
                         && level == 0
                         && !hasInliningErrors =>
-          val expanded = expandMacro(res.args.head, tree.span)
+          val expanded = expandMacro(res.args.head, tree.srcPos)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
         case res =>
           inlineIfNeeded(res)
@@ -1488,7 +1488,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     }
   }
 
-  private def expandMacro(body: Tree, span: Span)(using Context) = {
+  private def expandMacro(body: Tree, splicePos: SrcPos)(using Context) = {
     assert(level == 0)
     val inlinedFrom = enclosingInlineds.last
     val dependencies = macroDependencies(body)
@@ -1503,7 +1503,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
         ctx.compilationUnit.suspend() // this throws a SuspendException
 
     val evaluatedSplice = inContext(quoted.MacroExpansion.context(inlinedFrom)) {
-      Splicer.splice(body, inlinedFrom.srcPos, MacroClassLoader.fromContext)
+      Splicer.splice(body, splicePos, inlinedFrom.srcPos, MacroClassLoader.fromContext)
     }
     val inlinedNormailizer = new TreeMap {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
@@ -1513,7 +1513,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     }
     val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
     if (normalizedSplice.isEmpty) normalizedSplice
-    else normalizedSplice.withSpan(span)
+    else normalizedSplice.withSpan(splicePos.span)
   }
 
   /** Return the set of symbols that are referred at level -1 by the tree and defined in the current run.

compiler/src/scala/quoted/runtime/impl/ExprImpl.scala

@@ -10,7 +10,7 @@ import dotty.tools.dotc.ast.tpd
  *
  *  May contain references to code defined outside this Expr instance.
  */
-final class ExprImpl(val tree: tpd.Tree, val scopeId: Int) extends Expr[Any] {
+final class ExprImpl(val tree: tpd.Tree, val scopeId: Int, val scope: Scope) extends Expr[Any] {
   override def equals(that: Any): Boolean = that match {
     case that: ExprImpl =>
       // Expr are wrappers around trees, therefore they are equals if their trees are equal.

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -105,7 +105,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case _ => false
         def asExpr: scala.quoted.Expr[Any] =
           if self.isExpr then
-            new ExprImpl(self, QuotesImpl.this.hashCode)
+            new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent)
           else self match
             case TermTypeTest(self) => throw new Exception("Expected an expression. This is a partially applied Term. Try eta-expanding the term first.")
             case _ => throw new Exception("Expected a Term but was: " + self)
@@ -372,11 +372,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     given TermMethods: TermMethods with
       extension (self: Term)
         def seal: scala.quoted.Expr[Any] =
-          if self.isExpr then new ExprImpl(self, QuotesImpl.this.hashCode)
+          if self.isExpr then new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent)
           else throw new Exception("Cannot seal a partially applied Term. Try eta-expanding the term first.")
 
         def sealOpt: Option[scala.quoted.Expr[Any]] =
-          if self.isExpr then Some(new ExprImpl(self, QuotesImpl.this.hashCode))
+          if self.isExpr then Some(new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent))
           else None
 
         def tpe: TypeRepr = self.tpe
@@ -1666,7 +1666,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def seal: scala.quoted.Type[_] = self.asType
 
         def asType: scala.quoted.Type[?] =
-          new TypeImpl(Inferred(self), QuotesImpl.this.hashCode)
+          new TypeImpl(Inferred(self), QuotesImpl.this.hashCode, SpliceScope.getCurrent)
 
         def =:=(that: TypeRepr): Boolean = self =:= that
         def <:<(that: TypeRepr): Boolean = self <:< that
@@ -2877,11 +2877,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Expr[T] =
     val tree = PickledQuotes.unpickleTerm(pickled, typeHole, termHole)
-    new ExprImpl(tree, hash).asInstanceOf[scala.quoted.Expr[T]]
+    new ExprImpl(tree, hash, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Expr[T]]
 
   def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Type[T] =
     val tree = PickledQuotes.unpickleTypeTree(pickled, typeHole, termHole)
-    new TypeImpl(tree, hash).asInstanceOf[scala.quoted.Type[T]]
+    new TypeImpl(tree, hash, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]]
 
   object ExprMatch extends ExprMatchModule:
     def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =

compiler/src/scala/quoted/runtime/impl/ScopeException.scala

@@ -1,3 +1,34 @@
 package scala.quoted.runtime.impl
 
+import dotty.tools.dotc.ast.tpd.Tree
+import dotty.tools.dotc.core.Contexts._
+
 class ScopeException(msg: String) extends Exception(msg)
+
+object ScopeException:
+  def checkInCorrectScope(scope: Scope, currentScope: Scope, tree: Tree, kind: String)(using Context): Unit =
+    val yCheck = ctx.settings.Ycheck.value(using ctx).exists(x => x == "all" || x == "macros")
+    if yCheck && !scope.isOuterScopeOf(currentScope) then
+      throw new ScopeException(
+        if scope.atSameLocation(currentScope) then
+          s"""Type created in a splice, extruded from that splice and then used in a subsequent evaluation of that same splice.
+          |Splice: $scope
+          |$kind: ${tree.show}
+          |
+          |
+          |Splice stack:
+          |${scope.stack.mkString("\t", "\n\t", "\n")}
+          """.stripMargin
+        else
+          s"""Expression created in a splice was used outside of that splice.
+            |Created in: $scope
+            |Used in: $currentScope
+            |$kind: ${tree.show}
+            |
+            |
+            |Creation stack:
+            |${scope.stack.mkString("\t", "\n\t", "\n")}
+            |
+            |Use stack:
+            |${currentScope.stack.mkString("\t", "\n\t", "\n")}
+          """.stripMargin)

compiler/src/scala/quoted/runtime/impl/SpliceScope.scala

@@ -0,0 +1,62 @@
+package scala.quoted
+package runtime.impl
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.util.SourcePosition
+
+/** Unique identifier of the evaluation of a splice.
+ *
+ *  A nested splice gets a new Scope with the outer one as an owner.
+ *  This also applies for recursive splices.
+ */
+trait Scope {
+  /** Outer scope that was used to create the quote containing this splice.
+   *  NoScope if there is no scope
+   */
+  def outer: Scope = NoScope
+  /** Is this is a outer scope of the given scope */
+  def isOuterScopeOf(scope: Scope): Boolean =
+    this.eq(scope) || (scope.ne(NoScope) && isOuterScopeOf(scope.outer))
+  /** Stack of locations where scopes where evaluated */
+  def stack: List[String] =
+    this.toString :: (if outer.eq(NoScope) then Nil else outer.stack)
+  /** If the two scopes correspond to the same splice in source. */
+  def atSameLocation(scope: Scope): Boolean = false
+}
+
+/** Only used for outer scope of top level splice and staging `run` */
+object NoScope extends Scope:
+  override def outer: Scope = throw UnsupportedOperationException("NoScope.outer")
+
+class SpliceScope(val pos: SourcePosition, override val outer: Scope) extends Scope:
+
+  override def atSameLocation(scope: Scope): Boolean = scope match
+    case scope: SpliceScope => this.pos == scope.pos
+    case _ => false
+
+  override def toString =
+    if pos.exists then
+      s"${pos.source.toString}:${pos.startLine + 1} at column ${pos.startColumn + 1}"
+    else
+      "Unknown location"
+
+end SpliceScope
+
+
+object SpliceScope:
+
+  /** A key to be used in a context property that tracks current splices we are evaluating */
+  private val ScopeKey = new Property.Key[Scope]
+
+  def setSpliceScope(scope: Scope)(using Context): Context =
+    ctx.fresh.setProperty(ScopeKey, scope)
+
+  def contextWithNewSpliceScope(pos: SourcePosition)(using Context): Context =
+    ctx.fresh.setProperty(ScopeKey, new SpliceScope(pos, getCurrent))
+
+    /** Context with an incremented quotation level. */
+  def getCurrent(using Context): Scope =
+      ctx.property(ScopeKey).getOrElse(null)
+
+end SpliceScope

compiler/src/scala/quoted/runtime/impl/TypeImpl.scala

@@ -4,7 +4,7 @@ package runtime.impl
 import dotty.tools.dotc.ast.tpd
 
 /** Quoted type (or kind) `T` backed by a tree */
-final class TypeImpl(val typeTree: tpd.Tree, val scopeId: Int) extends Type[?] {
+final class TypeImpl(val typeTree: tpd.Tree, val scopeId: Int, val scope: Scope) extends Type[?] {
   override def equals(that: Any): Boolean = that match {
     case that: TypeImpl => typeTree ==
       // TastyTreeExpr are wrappers around trees, therfore they are equals if their trees are equal.

staging/src/scala/quoted/staging/QuoteCompiler.scala

@@ -18,10 +18,10 @@ import dotty.tools.dotc.quoted.PickledQuotes
 import dotty.tools.dotc.transform.Splicer.checkEscapedVariables
 import dotty.tools.dotc.transform.{Inlining, PickleQuotes}
 import dotty.tools.dotc.util.Spans.Span
-import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dotc.util.{SourceFile, NoSourcePosition}
 import dotty.tools.io.{Path, VirtualFile}
 
-import scala.quoted.runtime.impl.QuotesImpl
+import scala.quoted.runtime.impl._
 
 import scala.annotation.tailrec
 import scala.concurrent.Promise
@@ -49,6 +49,10 @@ private class QuoteCompiler extends Compiler:
 
   def outputClassName: TypeName = "Generated$Code$From$Quoted".toTypeName
 
+  class RunScope extends Scope {
+    override def toString: String = "scala.quoted.staging"
+  }
+
   /** Frontend that receives a scala.quoted.Expr or scala.quoted.Type as input */
   class QuotedFrontend extends Phase:
     import tpd._
@@ -58,7 +62,8 @@ private class QuoteCompiler extends Compiler:
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
       units.flatMap {
         case exprUnit: ExprCompilationUnit =>
-          implicit val unitCtx: Context = ctx.fresh.setPhase(this.start).setCompilationUnit(exprUnit)
+          val ctx1 = ctx.fresh.setPhase(this.start).setCompilationUnit(exprUnit)
+          implicit val unitCtx: Context = SpliceScope.setSpliceScope(new RunScope)(using ctx1)
 
           val pos = Span(0)
           val assocFile = new VirtualFile("<quote>")

tests/neg-macros/i8216/Macro_1.scala

@@ -0,0 +1,12 @@
+package macros
+import scala.quoted._
+
+var saved = Option.empty[Expr[Any]]
+
+def oops(c: Expr[Any])(using Quotes) = {
+  if saved.isEmpty then
+    saved = Some(c)
+    c
+  else saved.get
+}
+inline def test(c: Any) = ${oops('c)}