Add Expr.asTree and Expr.asTerm

* Add `Expr.asTree` and `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]`.
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)` or `reflect.asTree(expr)` which can be useful in some situations.

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,20 +48,20 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   extension [T](self: scala.quoted.Expr[T]):
     def show: String =
-      reflect.TreeMethods.show(reflect.Term.of(self))
+      reflect.TreeMethods.show(reflect.asTerm(self))
 
     def showAnsiColored: String =
-      reflect.TreeMethods.showAnsiColored(reflect.Term.of(self))
+      reflect.TreeMethods.showAnsiColored(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] = {
@@ -70,7 +70,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       else
         throw Exception(
           s"""Expr cast exception: ${self.show}
-            |of type: ${reflect.TypeReprMethods.show(reflect.Term.of(self).tpe)}
+            |of type: ${reflect.TypeReprMethods.show(reflect.asTerm(self).tpe)}
             |did not conform to type: ${reflect.TypeReprMethods.show(reflect.TypeRepr.of[X])}
             |""".stripMargin
         )
@@ -79,11 +79,17 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   object reflect extends reflectModule:
 
+    extension (expr: Expr[Any]):
+      def asTree: Tree = expr.asTerm
+      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):
@@ -350,11 +356,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) =>
@@ -2624,7 +2625,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)
@@ -2645,7 +2646,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)
@@ -2717,8 +2718,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

@@ -32,7 +32,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

@@ -79,7 +79,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 // or `expr.asTree`
    *    ...
    *  ```
    *
@@ -204,11 +204,22 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
    */
   trait reflectModule { self: reflect.type =>
 
+    extension (expr: Expr[Any]):
+
+      /** Returns the `Tree` representation this expression.
+       *  Same as `asTerm` but typed as a `Tree`.
+       */
+      def asTree: Tree
+
+      /** Returns the `Term` representation this expression */
+      def asTerm: Term
+
+    end extension
+
     ///////////////
     //   TREES   //
     ///////////////
 
-
     /** Tree representing code written in the source */
     type Tree <: AnyRef
 
@@ -218,7 +229,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.asTree` 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.asTree
     }
 
     /** Makes extension methods on `Tree` available without any imports */
@@ -521,7 +533,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.asTree.pos)
     }
     '{}
   }

tests/neg-macros/i6432b/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.asTree.pos)
     }
     '{}
   }

tests/neg-macros/i6976/Macro_1.scala

@@ -7,6 +7,6 @@ object macros {
 
   def mcrImpl(body: Expr[Any])(using ctx: Quotes) : Expr[Any] = {
     import ctx.reflect._
-    Term.of(body) match { case Block(_, _) => '{2} }
+    body.asTree match { case Block(_, _) => '{2} }
   }
 }

tests/neg-macros/i7698.scala

@@ -6,7 +6,7 @@ trait Show[T] {
 
 def showInterpolatorImpl(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes): Expr[String] =
   import quotes.reflect._
-  Term.of(argsExpr) match
+  argsExpr.asTree match
     case '{ $arg: $t } => // error
     case '[ Int ] => // error
   ???

tests/neg-macros/i9801/Macro_1.scala

@@ -16,6 +16,6 @@ def impl(prog: Expr[Double])(using Quotes) : Expr[Double] =
     triggerStackOverflow(0)
   } catch {
     case e =>
-      quotes.reflect.report.error(e.getMessage, Term.of(prog).pos)
+      quotes.reflect.report.error(e.getMessage, prog.asTree.pos)
       '{ 42.0 }
   }

tests/neg-macros/tasty-macro-assert-1/quoted_1.scala

@@ -15,7 +15,7 @@ object Asserts {
   def impl(cond: Expr[Boolean])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
 
-    val tree = Term.of(cond)
+    val tree = cond.asTree
 
     def isOps(tpe: TypeRepr): Boolean = tpe match {
       case tpe: TermRef => tpe.termSymbol.isDefDef && tpe.name == "Ops"// TODO check that the parent is Asserts

tests/neg-macros/tasty-macro-assert-2/quoted_1.scala

@@ -15,7 +15,7 @@ object Asserts {
   def impl(cond: Expr[Boolean])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
 
-    val tree = Term.of(cond)
+    val tree = cond.asTree
 
     def isOps(tpe: TypeRepr): Boolean = tpe match {
       case tpe: TermRef => tpe.termSymbol.isDefDef && tpe.name == "Ops"// TODO check that the parent is Asserts

tests/neg-macros/tasty-macro-error/quoted_1.scala

@@ -6,7 +6,7 @@ object Macros {
 
   def impl(x: Expr[Any])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
-    report.error("here is the the argument is " + Term.of(x).underlyingArgument.show, Term.of(x).underlyingArgument.pos)
+    report.error("here is the the argument is " + x.asTerm.underlyingArgument.show, x.asTerm.underlyingArgument.pos)
     '{}
   }
 

tests/neg-macros/tasty-macro-positions/quoted_1.scala

@@ -6,9 +6,9 @@ object Macros {
 
   def impl(x: Expr[Any])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
-    val pos = Term.of(x).underlyingArgument.pos
-    report.error("here is the the argument is " + Term.of(x).underlyingArgument.show, pos)
-    report.error("here (+5) is the the argument is " + Term.of(x).underlyingArgument.show, Position(pos.sourceFile, pos.start + 5, pos.end + 5))
+    val pos = x.asTerm.underlyingArgument.pos
+    report.error("here is the the argument is " + x.asTerm.underlyingArgument.show, pos)
+    report.error("here (+5) is the the argument is " + x.asTerm.underlyingArgument.show, Position(pos.sourceFile, pos.start + 5, pos.end + 5))
     '{}
   }
 

tests/neg-macros/tasty-string-interpolator-position-a/Macro_1.scala

@@ -11,7 +11,7 @@ object FIntepolator {
 
   def apply(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes) : Expr[String] = {
     import quotes.reflect._
-    report.error("there are no parts", Term.of(strCtxExpr).underlyingArgument.pos)
+    report.error("there are no parts", strCtxExpr.asTerm.underlyingArgument.pos)
     '{ ($strCtxExpr).s($argsExpr: _*) }
   }
 

tests/neg-macros/tasty-string-interpolator-position-b/Macro_1.scala

@@ -10,7 +10,7 @@ object Macro {
 object FIntepolator {
   def apply(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes) : Expr[String] = {
     import quotes.reflect._
-    report.error("there are no args", Term.of(argsExpr).underlyingArgument.pos)
+    report.error("there are no args", argsExpr.asTerm.underlyingArgument.pos)
     '{ ($strCtxExpr).s($argsExpr: _*) }
   }
 

tests/neg-staging/i5941/macro_1.scala

@@ -17,10 +17,10 @@ object Lens {
     import util._
     // obj.copy(field = value)
     def setterBody(obj: Expr[S], value: Expr[T], field: String): Expr[S] =
-      Select.overloaded(Term.of(obj), "copy", Nil, NamedArg(field, Term.of(value)) :: Nil, TypeBounds.empty).asExprOf[S]
+      Select.overloaded(obj.asTerm, "copy", Nil, NamedArg(field, value.asTerm) :: Nil, TypeBounds.empty).asExprOf[S]
 
     // exception: Term.of(getter).underlyingArgument
-    Term.of(getter) match {
+    getter.asTerm match {
       case Inlined(
         None, Nil,
         Block(

tests/pending/run/tasty-comments/quoted_1.scala

@@ -9,7 +9,7 @@ object Macros {
   def impl[T](x: Expr[T])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
 
-    val tree = Term.of(x)
+    val tree = x.asTree
     tree.symbol.comment.map(_.raw) match {
       case Some(str) => '{ println(${str}) }
       case None => '{ println() }

tests/pos-macros/i10151/Macro_1.scala

@@ -60,7 +60,7 @@ object X:
         case l@Literal(x) =>
            l.asExpr match
              case '{ $l: lit } =>
-                Term.of('{ CBM.pure(${term.asExprOf[lit]}) })
+                '{ CBM.pure(${term.asExprOf[lit]}) }.asTerm
         case other =>
              throw RuntimeException(s"Not supported $other")
 
@@ -89,5 +89,5 @@ object X:
          }
          changes.transformTerm(body)(Symbol.spliceOwner)
 
-   val r = transform(Term.of(f)).asExprOf[CB[T]]
+   val r = transform(f.asTerm).asExprOf[CB[T]]
    r