Add Expr.asTerm

* Add `Expr.asTerm` under `reflect`
* Deprecate `Tree.of` and `Term.of` for simpler migration from M2 to M3

This change make the intent of the operation clearer. We call `asTerm` to see the expression as a `Term` just like we call `asExpr` make the `Term` and `Expr[Any]`.
t It will simplify code that needs to acceess the trees.

As these are extension methods, they can also be accessed explicilty using `reflect.asTerm(expr)`  which can be useful in some situations.

Remove asTree

Author: nicolasstucki

community-build/src/scala/dotty/communitybuild/FieldsImpl.scala

@@ -11,7 +11,7 @@ object FieldsImpl:
     val retType = TypeTree.of[T].tpe
     def isProjectField(s: Symbol) =
       s.isValDef && s.tree.asInstanceOf[ValDef].tpt.tpe <:< retType
-    val projectsTree = Term.of(from)
+    val projectsTree = from.asTerm
     val symbols = TypeTree.of[V].symbol.memberMethods.filter(isProjectField)
     val selects = symbols.map(Select(projectsTree, _).asExprOf[T])
     '{ println(${Expr(retType.show)}); ${Varargs(selects)} }

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

@@ -48,17 +48,17 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   extension [T](self: scala.quoted.Expr[T]):
     def show: String =
-      reflect.Printer.TreeCode.show(reflect.Term.of(self))
+      reflect.Printer.TreeCode.show(reflect.asTerm(self))
 
     def matches(that: scala.quoted.Expr[Any]): Boolean =
-      treeMatch(reflect.Term.of(self), reflect.Term.of(that)).nonEmpty
+      treeMatch(reflect.asTerm(self), reflect.asTerm(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.TypeReprMethods.<:<(reflect.Term.of(self).tpe)(reflect.TypeRepr.of[X])
+      reflect.TypeReprMethods.<:<(reflect.asTerm(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] = {
@@ -67,7 +67,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       else
         throw Exception(
           s"""Expr cast exception: ${self.show}
-            |of type: ${reflect.Printer.TypeReprCode.show(reflect.Term.of(self).tpe)}
+            |of type: ${reflect.Printer.TypeReprCode.show(reflect.asTerm(self).tpe)}
             |did not conform to type: ${reflect.Printer.TypeReprCode.show(reflect.TypeRepr.of[X])}
             |""".stripMargin
         )
@@ -76,11 +76,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   object reflect extends reflectModule:
 
+    extension (expr: Expr[Any]):
+      def asTerm: Term =
+        val exprImpl = expr.asInstanceOf[ExprImpl]
+        exprImpl.checkScopeId(QuotesImpl.this.hashCode)
+        exprImpl.tree
+    end extension
+
     type Tree = tpd.Tree
 
-    object Tree extends TreeModule:
-        def of(expr: Expr[Any]): Tree = Term.of(expr)
-    end Tree
+    object Tree extends TreeModule
 
     given TreeMethods: TreeMethods with
       extension (self: Tree):
@@ -340,11 +345,6 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     end TermTypeTest
 
     object Term extends TermModule:
-      def of(expr: Expr[Any]): Term =
-        val exprImpl = expr.asInstanceOf[ExprImpl]
-        exprImpl.checkScopeId(QuotesImpl.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) =>
@@ -2588,7 +2588,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         dotc.report.error(msg, Position.ofMacroExpansion)
 
       def error(msg: String, expr: Expr[Any]): Unit =
-        dotc.report.error(msg, Term.of(expr).pos)
+        dotc.report.error(msg, asTerm(expr).pos)
 
       def error(msg: String, pos: Position): Unit =
         dotc.report.error(msg, pos)
@@ -2609,7 +2609,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         dotc.report.warning(msg, Position.ofMacroExpansion)
 
       def warning(msg: String, expr: Expr[Any]): Unit =
-        dotc.report.warning(msg, Term.of(expr).pos)
+        dotc.report.warning(msg, asTerm(expr).pos)
 
       def warning(msg: String, pos: Position): Unit =
         dotc.report.warning(msg, pos)
@@ -2716,8 +2716,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   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 = reflect.Term.of(scrutinee)
-      val patternTree = reflect.Term.of(pattern)
+      val scrutineeTree = reflect.asTerm(scrutinee)
+      val patternTree = reflect.asTerm(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 Quotes): Expr[Int] = {
   import quotes.reflect._
-  val xTree: Term = Term.of(x)
+  val xTree: Term = x.asTerm
   xTree match {
     case Inlined(_, _, Literal(Constant(n: Int))) =>
       if (n <= 0) {

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

@@ -19,7 +19,7 @@ object Expr {
    */
   def betaReduce[T](expr: Expr[T])(using Quotes): Expr[T] =
     import quotes.reflect._
-    Term.betaReduce(Term.of(expr)) match
+    Term.betaReduce(expr.asTerm) match
       case Some(expr1) => expr1.asExpr.asInstanceOf[Expr[T]]
       case _ => expr
 
@@ -29,7 +29,7 @@ object Expr {
    */
   def block[T](statements: List[Expr[Any]], expr: Expr[T])(using Quotes): Expr[T] = {
     import quotes.reflect._
-    Block(statements.map(Term.of), Term.of(expr)).asExpr.asInstanceOf[Expr[T]]
+    Block(statements.map(asTerm), expr.asTerm).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Creates an expression that will construct the value `x` */

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

@@ -90,7 +90,7 @@ object FromExpr {
         case Inlined(_, Nil, e) => rec(e)
         case _  => None
       }
-      rec(Term.of(expr))
+      rec(expr.asTerm)
   }
 
   /** Default implementation of `FromExpr[Option]`

library/src/scala/quoted/Const.scala

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

library/src/scala/quoted/ExprMap.scala

@@ -100,13 +100,13 @@ trait ExprMap:
             transformTermChildren(tree, tpe)(owner)
           case _ if tree.isExpr =>
             // WARNING: Never do a cast like this in user code (accepable within the stdlib).
-            // In theory we should use `tree.asExpr match { case '{ $expr: t } => Term.of(transform(expr)) }`
+            // In theory we should use `tree.asExpr match { case '{ $expr: t } => transform(expr).asTerm }`
             // This is to avoid conflicts when re-boostrapping the library.
             type X
             val expr = tree.asExpr.asInstanceOf[Expr[X]]
             val t = tpe.asType.asInstanceOf[Type[X]]
             val transformedExpr = transform(expr)(using t)
-            Term.of(transformedExpr)
+            transformedExpr.asTerm
           case _ =>
             transformTermChildren(tree, tpe)(owner)
 
@@ -145,7 +145,7 @@ trait ExprMap:
         trees.mapConserve(x => transformTypeCaseDef(x)(owner))
 
     }
-    new MapChildren().transformTermChildren(Term.of(e), TypeRepr.of[T])(Symbol.spliceOwner).asExprOf[T]
+    new MapChildren().transformTermChildren(e.asTerm, TypeRepr.of[T])(Symbol.spliceOwner).asExprOf[T]
   }
 
 end ExprMap

library/src/scala/quoted/Quotes.scala

@@ -76,7 +76,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
    *  import scala.quoted._
    *  def f(expr: Expr[Int])(using Quotes) =
    *    import quotes.reflect._
-   *    val tree: Tree = Term.of(expr)
+   *    val ast: Term = expr.asTerm
    *    ...
    *  ```
    *
@@ -201,11 +201,14 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
    */
   trait reflectModule { self: reflect.type =>
 
+    /** Returns the `Term` representation this expression */
+    extension (expr: Expr[Any])
+      def asTerm: Term
+
     ///////////////
     //   TREES   //
     ///////////////
 
-
     /** Tree representing code written in the source */
     type Tree <: AnyRef
 
@@ -215,7 +218,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Methods of the module object `val Tree` */
     trait TreeModule { this: Tree.type =>
       /** Returns the Term representation this expression */
-      def of(expr: Expr[Any]): Tree
+      @deprecated("Use `expr.asTerm` instead (must `import quotes.reflect._`). This will be removed in 3.0.0-RC1", "3.0.0-M3")
+      def of(expr: Expr[Any]): Tree = expr.asTerm
     }
 
     /** Makes extension methods on `Tree` available without any imports */
@@ -509,7 +513,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     trait TermModule { this: Term.type =>
 
       /** Returns the Term representation this expression */
-      def of(expr: Expr[Any]): Term
+      @deprecated("Use `expr.asTerm` instead (must `import quotes.reflect._`). This will be removed in 3.0.0-RC1", "3.0.0-M3")
+      def of(expr: Expr[Any]): Term = expr.asTerm
 
       /** Returns a term that is functionally equivalent to `t`,
       *  however if `t` is of the form `((y1, ..., yn) => e2)(e1, ..., en)`

library/src/scala/quoted/Varargs.scala

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

tests/neg-macros/i6432/Macro_1.scala

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