Allow nested Quotes with a different owners

This makes it possible to create `Expr`s with different owners to avoid
a call to `changeOwner`.

Closes #13922

Author: nicolasstucki

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

@@ -2625,6 +2625,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def show(using printer: Printer[Symbol]): String = printer.show(self)
 
+        def asQuotes: Nested = new QuotesImpl(using ctx.withOwner(self))
+
       end extension
 
       private def appliedTypeRef(sym: Symbol): TypeRepr =
@@ -2915,6 +2917,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
                    |which has the AST representation
                    |${Printer.TreeStructure.show(tree)}
                    |
+                   |
+                   |
+                   |Tip: The owner of a tree can be changed using method `Tree.changeOwner`.
+                   |Tip: The default owner of definitions created in quotes can be changed using method `Symbol.asQuotes`.
                    |""".stripMargin)
             case _ => traverseChildren(t)
       }.traverse(tree)

library/src/scala/quoted/Quotes.scala

@@ -607,14 +607,45 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef
       def unapply(vdef: ValDef): (String, TypeTree, Option[Term])
 
-      /** Creates a block `{ val <name> = <rhs: Term>; <body(x): Term> }` */
+      /** Creates a block `{ val <name> = <rhs: Term>; <body(x): Term> }`
+       *
+       *  Usage:
+       *  ```
+       *  ValDef.let(owner, "x", rhs1) { x =>
+       *    ValDef.let(x.symbol.owner, "y", rhs2) { y =>
+       *      // use `x` and `y`
+       *    }
+       *  }
+       *  ```
+       *  @syntax markdown
+       */
       def let(owner: Symbol, name: String, rhs: Term)(body: Ref => Term): Term
 
-      /** Creates a block `{ val x = <rhs: Term>; <body(x): Term> }` */
+      /** Creates a block `{ val x = <rhs: Term>; <body(x): Term> }`
+       *
+       *  Usage:
+       *  ```
+       *  ValDef.let(owner, rhs1) { x =>
+       *    ValDef.let(owner, rhs2) { y =>
+       *      // use `x` and `y`
+       *    }
+       *  }
+       *  ```
+       *  @syntax markdown
+       */
       def let(owner: Symbol, rhs: Term)(body: Ref => Term): Term =
         let(owner, "x", rhs)(body)
 
-      /** Creates a block `{ val x1 = <terms(0): Term>; ...; val xn = <terms(n-1): Term>; <body(List(x1, ..., xn)): Term> }` */
+      /** Creates a block `{ val x1 = <terms(0): Term>; ...; val xn = <terms(n-1): Term>; <body(List(x1, ..., xn)): Term> }`
+       *
+       *  Usage:
+       *  ```
+       *  ValDef.let(owner, rhsList) { xs =>
+       *     ...
+       *  }
+       *  ```
+       *  @syntax markdown
+       */
       def let(owner: Symbol, terms: List[Term])(body: List[Ref] => Term): Term
     }
 
@@ -1327,6 +1358,28 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *  ```scala sc:nocompile
        *  Block((DefDef(_, _, params :: Nil, _, Some(rhsFn(meth, paramRefs)))) :: Nil, Closure(meth, _))
        *  ```
+       *
+       * Usage:
+       *  ```
+       *  val mtpe = MethodType(List("arg1"))(_ => List(TypeRepr.of[Int]), _ => TypeRepr.of[Int])
+       *  Lambda(owner, mtpe, {
+       *    case (methSym, List(arg1: Term)) =>
+       *      ValDef.let(methSym, f(arg1)) { ... }
+       *    }
+       *  )
+       *  ```
+       *
+       *  Usage with quotes:
+       *  ```
+       *  val mtpe = MethodType(List("arg1"))(_ => List(TypeRepr.of[Int]), _ => TypeRepr.of[Int])
+       *  Lambda(owner, mtpe, {
+       *    case (methSym, List(arg1: Term)) =>
+       *      given Quotes = methSym.asQuotes
+       *      '{ ... }
+       *    }
+       *  )
+       *  ```
+       *
        *  @param owner: owner of the generated `meth` symbol
        *  @param tpe: Type of the definition
        *  @param rhsFn: Function that receives the `meth` symbol and the a list of references to the `params`
@@ -3792,6 +3845,27 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
         /** Case class or case object children of a sealed trait or cases of an `enum`. */
         def children: List[Symbol]
+
+        /** Returns a nested quote with this symbol as splice owner (`Symbol.spliceOwner`).
+         *
+         *  Changes the owner under which the definition in a quote are created.
+         *
+         *  Usage:
+         *  ```scala
+         *  new TreeMap:
+         *    override def transformTerm(tree: Term)(owner: Symbol): Term =
+         *      tree match
+         *        case tree: Ident =>
+         *          given Quotes = owner.asQuotes
+         *          // Definitions contained in the quote will be owned by `owner`.
+         *          // No need to use `changeOwner` in this case.
+         *          '{ val x = ???; x }.asTerm
+         *  ```
+         *  @syntax markdown
+         */
+        @experimental
+        def asQuotes: Nested
+
       end extension
     }
 

project/MiMaFilters.scala

@@ -7,6 +7,8 @@ object MiMaFilters {
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.Tuples.init"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.Tuples.last"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.runtime.Tuples.append"),
+    ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.asQuotes"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.quoted.Quotes#reflectModule#SymbolMethods.asQuotes"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeReprMethods.substituteTypes"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeReprMethods.substituteTypes"),
     ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#TypeReprMethods.typeArgs"),

tests/pos-macros/i13571/Macro_1.scala

@@ -0,0 +1,20 @@
+import scala.quoted.*
+
+inline def checked2[A](inline n: A): A =
+  ${ checkedImpl2[A]('{n}) }
+
+private def checkedImpl2[A](n: Expr[A])(using Quotes, Type[A]): Expr[A] =
+  import quotes.reflect.*
+  val tree: Term = n.asTerm
+  val acc = new TreeMap:
+    override def transformTerm(tree: Term)(owner: Symbol): Term =
+      tree match
+        case Apply(Select(x, "*"), List(y)) =>
+          given Quotes = owner.asQuotes
+          '{
+            val xt = ${x.asExprOf[Long]}
+            xt
+          }.asTerm
+        case _ =>
+          super.transformTerm(tree)(owner)
+  acc.transformTerm(tree)(Symbol.spliceOwner).asExprOf[A]

tests/pos-macros/i13571/Test_2.scala

@@ -0,0 +1,6 @@
+  def test = {
+    val u = 3L
+    checked2(List(1L, 2L).map { k =>
+       u * 2L
+     })
+  }

tests/pos-macros/i13571b/Macro_1.scala

@@ -0,0 +1,22 @@
+import scala.quoted.*
+
+inline def checked2[A](inline n: A): A =
+  ${ checkedImpl2[A]('{n}) }
+
+private def checkedImpl2[A](n: Expr[A])(using Quotes, Type[A]): Expr[A] =
+  import quotes.reflect.*
+  val tree: Term = n.asTerm
+  val acc = new TreeMap:
+    override def transformTerm(tree: Term)(owner: Symbol): Term =
+      tree match
+        case Apply(Select(x, "*"), List(y)) =>
+          bindLong(x.asExprOf[Long])(using owner.asQuotes).asTerm
+        case _ =>
+          super.transformTerm(tree)(owner)
+  acc.transformTerm(tree)(Symbol.spliceOwner).asExprOf[A]
+
+def bindLong(expr: Expr[Long])(using Quotes): Expr[Long] =
+  '{
+    val xt = $expr
+    xt
+  }

tests/pos-macros/i13571b/Test_2.scala

@@ -0,0 +1,6 @@
+  def test = {
+    val u = 3L
+    checked2(List(1L, 2L).map { k =>
+       u * 2L
+     })
+  }

tests/pos-macros/i13922/Macro_1.scala

@@ -0,0 +1,34 @@
+import scala.quoted.*
+
+inline def optPrettyPrinter[T]: Option[T] => Option[T] =
+  ${ optPrettyPrinterImpl[T] }
+
+private def optPrettyPrinterImpl[T: Type](using Quotes): Expr[Option[T] => Option[T]] = {
+  import quotes.reflect.*
+
+  val tpe = TypeRepr.of[T]
+
+  val fn = Lambda(
+    Symbol.spliceOwner,
+    MethodType(List("macroVal"))(
+      _ => List(tpe),
+      _ => tpe
+    ),
+    {
+      case (m, List(arg: Term)) =>
+        given Quotes = m.asQuotes
+        ValDef.let(m, "v", arg) { v =>
+          '{
+            val vv = ${ v.asExprOf[T] }
+            println("v=" + vv.toString())
+            vv
+          }.asTerm
+        }
+
+      case _ =>
+        report.errorAndAbort("Fails compile")
+    }
+  ).asExprOf[T => T]
+
+  '{ (_: Option[T]).map(${ fn }) }
+}

tests/pos-macros/i13922/Test_2.scala

@@ -0,0 +1 @@
+def test = optPrettyPrinter(Some("foo"))