Merge pull request #10332 from dotty-staging/add-Tree.of

Add `Tree.of` and `Term.of` to transform `Expr` into `Tree`

Author: nicolasstucki

compiler/src/scala/quoted/internal/impl/QuoteContextImpl.scala

@@ -47,25 +47,20 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
 
   extension [T](self: scala.quoted.Expr[T]):
     def show: String =
-      reflect.TreeMethodsImpl.show(self.asReflectTree)
+      reflect.TreeMethodsImpl.show(reflect.Term.of(self))
 
     def showAnsiColored: String =
-      reflect.TreeMethodsImpl.showAnsiColored(self.asReflectTree)
+      reflect.TreeMethodsImpl.showAnsiColored(reflect.Term.of(self))
 
     def matches(that: scala.quoted.Expr[Any]): Boolean =
-      treeMatch(self.asReflectTree, that.asReflectTree).nonEmpty
-
-    def asReflectTree: reflect.Term =
-      val expr = self.asInstanceOf[ExprImpl]
-      expr.checkScopeId(QuoteContextImpl.this.hashCode)
-      expr.tree
+      treeMatch(reflect.Term.of(self), reflect.Term.of(that)).nonEmpty
 
   end extension
 
   extension [X](self: scala.quoted.Expr[Any]):
     /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */
     def isExprOf(using scala.quoted.Type[X]): Boolean =
-      reflect.TypeReprMethodsImpl.<:<(self.asReflectTree.tpe)(reflect.TypeRepr.of[X])
+      reflect.TypeReprMethodsImpl.<:<(reflect.Term.of(self).tpe)(reflect.TypeRepr.of[X])
 
     /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */
     def asExprOf(using scala.quoted.Type[X]): scala.quoted.Expr[X] = {
@@ -74,7 +69,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
       else
         throw Exception(
           s"""Expr cast exception: ${self.show}
-            |of type: ${reflect.TypeReprMethodsImpl.show(self.asReflectTree.tpe)}
+            |of type: ${reflect.TypeReprMethodsImpl.show(reflect.Term.of(self).tpe)}
             |did not conform to type: ${reflect.TypeReprMethodsImpl.show(reflect.TypeRepr.of[X])}
             |""".stripMargin
         )
@@ -89,7 +84,9 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
 
     type Tree = tpd.Tree
 
-    object Tree extends TreeModule
+    object Tree extends TreeModule:
+        def of(expr: Expr[Any]): Tree = Term.of(expr)
+    end Tree
 
     object TreeMethodsImpl extends TreeMethods:
       extension (self: Tree):
@@ -328,6 +325,11 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
     end TermTypeTest
 
     object Term extends TermModule:
+      def of(expr: Expr[Any]): Term =
+        val exprImpl = expr.asInstanceOf[ExprImpl]
+        exprImpl.checkScopeId(QuoteContextImpl.this.hashCode)
+        exprImpl.tree
+
       def betaReduce(tree: Term): Option[Term] =
         tree match
           case app @ tpd.Apply(tpd.Select(fn, nme.apply), args) if dotc.core.Symbols.defn.isFunctionType(fn.tpe) =>
@@ -2551,8 +2553,8 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
 
   object ExprMatch extends ExprMatchModule:
     def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =
-      val scrutineeTree = QuoteContextImpl.this.asReflectTree(scrutinee)
-      val patternTree = QuoteContextImpl.this.asReflectTree(pattern)
+      val scrutineeTree = reflect.Term.of(scrutinee)
+      val patternTree = reflect.Term.of(pattern)
       treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
   end ExprMatch
 

docs/docs/reference/metaprogramming/tasty-reflect.md

@@ -42,7 +42,7 @@ trees. For example the `Literal(_)` extractor used below.
 ```scala
 def natConstImpl(x: Expr[Int])(using qctx: QuoteContext): Expr[Int] = {
   import qctx.reflect._
-  val xTree: Term = x.unseal
+  val xTree: Term = Term.of(x)
   xTree match {
     case Inlined(_, _, Literal(Constant(n: Int))) =>
       if (n <= 0) {

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -14,7 +14,8 @@ object Expr {
    *   Some bindings may be elided as an early optimization.
    */
   def betaReduce[T](expr: Expr[T])(using qctx: QuoteContext): Expr[T] =
-    qctx.reflect.Term.betaReduce(expr.unseal) match
+    import qctx.reflect._
+    Term.betaReduce(Term.of(expr)) match
       case Some(expr1) => expr1.asExpr.asInstanceOf[Expr[T]]
       case _ => expr
 
@@ -24,7 +25,7 @@ object Expr {
    */
   def block[T](statements: List[Expr[Any]], expr: Expr[T])(using qctx: QuoteContext): Expr[T] = {
     import qctx.reflect._
-    Block(statements.map(_.unseal), expr.unseal).asExpr.asInstanceOf[Expr[T]]
+    Block(statements.map(Term.of), Term.of(expr)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Lift a value into an expression containing the construction of that value */

library/src-bootstrapped/scala/quoted/ExprMap.scala

@@ -104,7 +104,8 @@ trait ExprMap:
             type X
             val expr = tree.asExpr.asInstanceOf[Expr[X]]
             val t = tpe.asType.asInstanceOf[Type[X]]
-            transform(expr)(using qctx, t).unseal
+            val transformedExpr = transform(expr)(using qctx, t)
+            Term.of(transformedExpr)
           case _ =>
             transformTermChildren(tree, tpe)
 
@@ -144,7 +145,7 @@ trait ExprMap:
         trees mapConserve (transformTypeCaseDef(_))
 
     }
-    new MapChildren().transformTermChildren(e.unseal, TypeRepr.of[T]).asExprOf[T]
+    new MapChildren().transformTermChildren(Term.of(e), TypeRepr.of[T]).asExprOf[T]
   }
 
 end ExprMap

library/src/scala/quoted/Const.scala

@@ -23,7 +23,7 @@ object Const {
       case Inlined(_, Nil, e) => rec(e)
       case _  => None
     }
-    rec(expr.unseal)
+    rec(Term.of(expr))
   }
 
 }

library/src/scala/quoted/QuoteContext.scala

@@ -48,10 +48,13 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
       unlift.fromExpr(self)(using QuoteContext.this).getOrElse(reportError)
 
     /** View this expression `quoted.Expr[T]` as a `Term` */
+    @deprecated("Use reflect.Term.of", "")
     def unseal: reflect.Term = self.asReflectTree // TODO remove
 
     /** View this expression `quoted.Expr[T]` as a `Term` */
-    def asReflectTree: reflect.Term
+    @deprecated("Use reflect.Term.of", "")
+    def asReflectTree: reflect.Term = // TODO remove
+      reflect.Term.of(self)
   end extension
 
   // Extension methods for `Expr[Any]` that take another explicit type parameter

library/src/scala/quoted/Reflection.scala

@@ -129,7 +129,10 @@ trait Reflection { reflection =>
 
   val Tree: TreeModule
 
-  trait TreeModule { this: Tree.type => }
+  trait TreeModule { this: Tree.type =>
+    /** Returns the Term representation this expression */
+    def of(expr: Expr[Any]): Tree
+  }
 
   given TreeMethods as TreeMethods = TreeMethodsImpl
   protected val TreeMethodsImpl: TreeMethods
@@ -372,6 +375,9 @@ trait Reflection { reflection =>
 
   trait TermModule { this: Term.type =>
 
+    /** Returns the Term representation this expression */
+    def of(expr: Expr[Any]): Term
+
     /** Returns a term that is functionally equivalent to `t`,
      *  however if `t` is of the form `((y1, ..., yn) => e2)(e1, ..., en)`
      *  then it optimizes this the top most call by returning the `Some`

library/src/scala/quoted/Varargs.scala

@@ -17,7 +17,7 @@ object Varargs {
    */
   def apply[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
     import qctx.reflect._
-    Repeated(xs.map[Term](_.unseal).toList, TypeTree.of[T]).asExpr.asInstanceOf[Expr[Seq[T]]]
+    Repeated(xs.map(Term.of).toList, TypeTree.of[T]).asExpr.asInstanceOf[Expr[Seq[T]]]
   }
 
   /** Matches a literal sequence of expressions and return a sequence of expressions.
@@ -40,7 +40,7 @@ object Varargs {
       case Inlined(_, Nil, e) => rec(e)
       case _  => None
     }
-    rec(expr.unseal)
+    rec(Term.of(expr))
   }
 
 }

library/src/scala/quoted/report.scala

@@ -4,11 +4,13 @@ object report:
 
   /** Report an error at the position of the macro expansion */
   def error(msg: => String)(using qctx: QuoteContext): Unit =
-    qctx.reflect.Reporting.error(msg, qctx.reflect.Position.ofMacroExpansion)
+    import qctx.reflect._
+    Reporting.error(msg, Position.ofMacroExpansion)
 
   /** Report an error at the on the position of `expr` */
   def error(msg: => String, expr: Expr[Any])(using qctx: QuoteContext): Unit =
-    qctx.reflect.Reporting.error(msg, expr.unseal.pos)
+    import qctx.reflect._
+    Reporting.error(msg, Term.of(expr).pos)
 
   /** Report an error at the position of the macro expansion and throws a StopQuotedContext */
   def throwError(msg: => String)(using qctx: QuoteContext): Nothing = {
@@ -23,11 +25,13 @@ object report:
 
   /** Report a warning */
   def warning(msg: => String)(using qctx: QuoteContext): Unit =
-    qctx.reflect.Reporting.warning(msg, qctx.reflect.Position.ofMacroExpansion)
+    import qctx.reflect._
+    Reporting.warning(msg, Position.ofMacroExpansion)
 
   /** Report a warning at the on the position of `expr` */
-  def warning(msg: => String, expr: Expr[_])(using qctx: QuoteContext): Unit =
-    qctx.reflect.Reporting.warning(msg, expr.unseal.pos)
+  def warning(msg: => String, expr: Expr[Any])(using qctx: QuoteContext): Unit =
+    import qctx.reflect._
+    Reporting.warning(msg, Term.of(expr).pos)
 
   /** Throwable used to stop the expansion of a macro after an error was reported */
   class StopQuotedContext extends Throwable

tests/neg-macros/i6432/Macro_1.scala

@@ -10,7 +10,7 @@ object Macro {
     sc match {
       case '{ StringContext(${Varargs(parts)}: _*) } =>
         for (part @ Const(s) <- parts)
-          Reporting.error(s, part.unseal.pos)
+          Reporting.error(s, Term.of(part).pos)
     }
     '{}
   }