Fix #7142: Detect scope extrusions in macros and run

Author: nicolasstucki

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

@@ -500,7 +500,6 @@ object StdNames {
     val lang: N                 = "lang"
     val length: N               = "length"
     val lengthCompare: N        = "lengthCompare"
-    val `macro` : N             = "macro"
     val macroThis : N           = "_this"
     val macroContext : N        = "c"
     val main: N                 = "main"

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

@@ -37,14 +37,17 @@ object Splicer {
    *
    *  See: `Staging`
    */
-  def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
+  def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(given ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
     case _ =>
       val interpreter = new Interpreter(pos, classLoader)
+      val macroOwner = ctx.newSymbol(ctx.owner, NameKinds.UniqueName.fresh(nme.MACROkw), Synthetic, defn.AnyType, coord = tree.span)
       try {
+        given Context = ctx.withOwner(macroOwner)
         // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
         val interpretedExpr = interpreter.interpret[scala.quoted.QuoteContext => scala.quoted.Expr[Any]](tree)
-        interpretedExpr.fold(tree)(macroClosure => PickledQuotes.quotedExprToTree(macroClosure(QuoteContext())))
+        val interpretedTree = interpretedExpr.fold(tree)(macroClosure => PickledQuotes.quotedExprToTree(macroClosure(QuoteContext())))
+        checkEscapedVariables(interpretedTree, macroOwner).changeOwner(macroOwner, ctx.owner)
       }
       catch {
         case ex: CompilationUnit.SuspendException =>
@@ -63,6 +66,50 @@ object Splicer {
       }
   }
 
+  /** Checks that no symbol that whas generated within the macro expansion has an out of scope reference */
+  def checkEscapedVariables(tree: Tree, expansionOwner: Symbol)(given ctx: Context): tree.type =
+    new TreeTraverser {
+      private[this] var locals = Set.empty[Symbol]
+      private def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
+        case tree: DefTree =>
+          val sym = tree.symbol
+          if (!locals.contains(sym))
+            locals = locals + sym
+        case _ =>
+      }
+      def traverse(tree: Tree)(given ctx: Context): Unit =
+        def traverseOver(lastEntered: Set[Symbol]) =
+          try traverseChildren(tree)
+          finally locals = lastEntered
+        tree match
+          case tree: Ident if isEscapedVariable(tree.symbol) =>
+            val sym = tree.symbol
+            ctx.error(em"While expanding a macro, a reference to $sym was used outside the scope where it was defined", tree.sourcePos)
+          case Block(stats, _) =>
+            val last = locals
+            stats.foreach(markDef)
+            traverseOver(last)
+          case CaseDef(pat, guard, body) =>
+            val last = locals
+            // mark all bindings
+            new TreeTraverser {
+              def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+                markDef(tree)
+                traverseChildren(tree)
+              }
+            }.traverse(pat)
+            traverseOver(last)
+          case _ =>
+            markDef(tree)
+            traverseChildren(tree)
+      private def isEscapedVariable(sym: Symbol)(given ctx: Context): Boolean =
+        sym.exists && !sym.is(Package)
+        && sym.owner.ownersIterator.contains(expansionOwner) // symbol was generated within the macro expansion
+        && !locals.contains(sym) // symbol is not in current scope
+    }.traverse(tree)
+    tree
+
+
   /** Check that the Tree can be spliced. `${'{xyz}}` becomes `xyz`
     *  and for `$xyz` the tree of `xyz` is interpreted for which the
     *  resulting expression is returned as a `Tree`

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

@@ -1273,7 +1273,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
   private def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {
     assert(level == 0)
     val inlinedFrom = enclosingInlineds.last
-    val ctx1 = tastyreflect.MacroExpansion.context(inlinedFrom)
     val dependencies = macroDependencies(body)
 
     if dependencies.nonEmpty && !ctx.reporter.errorsReported then
@@ -1284,8 +1283,10 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           ctx.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", call.sourcePos)
       ctx.compilationUnit.suspend() // this throws a SuspendException
 
-    val evaluatedSplice = Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)(ctx1)
-
+    val evaluatedSplice = {
+      given Context = tastyreflect.MacroExpansion.context(inlinedFrom)(given ctx)
+      Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)
+    }
     val inlinedNormailizer = new TreeMap {
       override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
         case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)

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

@@ -16,6 +16,7 @@ import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.Types.ExprType
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.tastyreflect.ReflectionImpl
+import dotty.tools.dotc.transform.Splicer.checkEscapedVariables
 import dotty.tools.dotc.transform.ReifyQuotes
 import dotty.tools.dotc.util.Spans.Span
 import dotty.tools.dotc.util.SourceFile
@@ -67,8 +68,12 @@ private class QuoteCompiler extends Compiler {
           cls.enter(unitCtx.newDefaultConstructor(cls), EmptyScope)
           val meth = unitCtx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
 
-          val qctx = dotty.tools.dotc.quoted.QuoteContext()
-          val quoted = PickledQuotes.quotedExprToTree(exprUnit.exprBuilder.apply(qctx))(unitCtx.withOwner(meth))
+          val quoted = {
+            given Context = unitCtx.withOwner(meth)
+            val qctx = dotty.tools.dotc.quoted.QuoteContext()
+            val quoted = PickledQuotes.quotedExprToTree(exprUnit.exprBuilder.apply(qctx))
+            checkEscapedVariables(quoted, meth)
+          }
 
           getLiteral(quoted) match {
             case Some(value) =>

tests/neg-macros/i7142/Macro_1.scala

@@ -0,0 +1,9 @@
+package macros
+import scala.quoted._
+
+def oops(given QuoteContext) = {
+  var v = '{0};
+  val q = '{ (x: Int) => ${ v = '{x}; v } }
+  '{$q($v)}
+}
+inline def test = ${oops}

tests/neg-macros/i7142/Test_2.scala

@@ -0,0 +1,4 @@
+
+object Test {
+  macros.test // error
+}

tests/neg-macros/i7142b/Macro_1.scala

@@ -0,0 +1,8 @@
+package macros
+import scala.quoted._
+import scala.util.control.NonLocalReturns._
+
+def oops(given QuoteContext): Expr[Int] =
+  returning('{ { (x: Int) => ${ throwReturn('x) }} apply 0 })
+
+inline def test = ${oops}

tests/neg-macros/i7142b/Test_2.scala

@@ -0,0 +1,4 @@
+
+object Test {
+  macros.test // error
+}

tests/neg-macros/i7142c/Macro_1.scala

@@ -0,0 +1,9 @@
+package macros
+import scala.quoted._
+
+def oops(given QuoteContext) = {
+  var v = '{0};
+  val q = '{ val x: Int = 8; ${ v = '{x}; v } }
+  v
+}
+inline def test = ${oops}

tests/neg-macros/i7142c/Test_2.scala

@@ -0,0 +1,4 @@
+
+object Test {
+  macros.test // error
+}