Add isExpr, asExpr, asExprOf and asTerm

These replace the methods `seal`, `sealOpt` and `unseal` with equivalent method with more intuitive names.
Insead of `sealOpt` we provide a more flexible `isExpr`. All these methods are defined directly on `Tree`
insead of `Term` to avoid the need to perform type test to a `Term` first.

Author: nicolasstucki

library/src-bootstrapped/dotty/internal/StringContextMacro.scala

@@ -59,7 +59,7 @@ object StringContextMacro {
    */
   private def interpolate(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
-    val sourceFile = strCtxExpr.unseal.pos.sourceFile
+    val sourceFile = strCtxExpr.asTerm.pos.sourceFile
 
     val (partsExpr, parts) = strCtxExpr match {
       case Expr.StringContext(p1 @ Consts(p2)) => (p1.toList, p2.toList)
@@ -76,28 +76,28 @@ object StringContextMacro {
       private[this] var oldReported = false
       def partError(message : String, index : Int, offset : Int) : Unit = {
         reported = true
-        val positionStart = partsExpr(index).unseal.pos.start + offset
+        val positionStart = partsExpr(index).asTerm.pos.start + offset
         error(message, sourceFile, positionStart, positionStart)
       }
       def partWarning(message : String, index : Int, offset : Int) : Unit = {
         reported = true
-        val positionStart = partsExpr(index).unseal.pos.start + offset
+        val positionStart = partsExpr(index).asTerm.pos.start + offset
         warning(message, sourceFile, positionStart, positionStart)
       }
 
       def argError(message : String, index : Int) : Unit = {
         reported = true
-        error(message, args(index).unseal.pos)
+        error(message, args(index).asTerm.pos)
       }
 
       def strCtxError(message : String) : Unit = {
         reported = true
-        val positionStart = strCtxExpr.unseal.pos.start
+        val positionStart = strCtxExpr.asTerm.pos.start
         error(message, sourceFile, positionStart, positionStart)
       }
       def argsError(message : String) : Unit = {
         reported = true
-        error(message, argsExpr.unseal.pos)
+        error(message, argsExpr.asTerm.pos)
       }
 
       def hasReported() : Boolean = {
@@ -658,7 +658,7 @@ object StringContextMacro {
           case Some(argIndex, arg) => {
             val (hasArgumentIndex, argumentIndex, flags, hasWidth, width, hasPrecision, precision, hasRelative, relativeIndex, conversion) = getFormatSpecifiers(part, argIndex, argIndex + 1, false, formattingStart)
             if (!reporter.hasReported()){
-              val conversionWithType = checkFormatSpecifiers(argIndex + 1, hasArgumentIndex, argumentIndex, Some(argIndex + 1), start == 0, maxArgumentIndex, hasRelative, hasWidth, width, hasPrecision, precision, flags, conversion, Some(arg.unseal.tpe), part)
+              val conversionWithType = checkFormatSpecifiers(argIndex + 1, hasArgumentIndex, argumentIndex, Some(argIndex + 1), start == 0, maxArgumentIndex, hasRelative, hasWidth, width, hasPrecision, precision, flags, conversion, Some(arg.asTerm.tpe), part)
               nextStart = conversion + 1
               conversionWithType :: checkPart(part, nextStart, argument, maxArgumentIndex)
             } else checkPart(part, conversion + 1, argument, maxArgumentIndex)

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

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

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

@@ -7,11 +7,11 @@ abstract class Expr[+T] private[scala] {
 
   /** Show a source code like representation of this expression without syntax highlight */
   def show(using qctx: QuoteContext): String =
-    this.unseal.showWith(SyntaxHighlight.plain)
+    this.asTerm.showWith(SyntaxHighlight.plain)
 
   /** Show a source code like representation of this expression */
   def showWith(syntaxHighlight: SyntaxHighlight)(using qctx: QuoteContext): String =
-    this.unseal.showWith(syntaxHighlight)
+    this.asTerm.showWith(syntaxHighlight)
 
   /** Return the unlifted value of this expression.
    *
@@ -41,11 +41,15 @@ abstract class Expr[+T] private[scala] {
     !scala.internal.quoted.Expr.unapply[EmptyTuple, EmptyTuple](this)(using that, false, qctx).isEmpty
 
   /** Checked cast to a `quoted.Expr[U]` */
-  def cast[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] = {
-    val tree = this.unseal
+  @deprecated("Replaced with `asExprOf`", "0.27.0")
+  def cast[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] = asExprOf[U]
+
+  /** Convert to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */
+  def asExprOf[X](using tp: scala.quoted.Type[X])(using qctx: QuoteContext): scala.quoted.Expr[X] = {
+    val tree = this.asTerm
     val expectedType = tp.unseal.tpe
     if (tree.tpe <:< expectedType)
-      this.asInstanceOf[scala.quoted.Expr[U]]
+      this.asInstanceOf[scala.quoted.Expr[X]]
     else
       throw new scala.tasty.reflect.ExprCastError(
         s"""Expr: ${tree.show}
@@ -55,7 +59,11 @@ abstract class Expr[+T] private[scala] {
   }
 
   /** View this expression `quoted.Expr[T]` as a `Term` */
-  def unseal(using qctx: QuoteContext): qctx.tasty.Term
+  @deprecated("Replaced with `asTerm`", "0.27.0")
+  def unseal(using qctx: QuoteContext): qctx.tasty.Term = asTerm
+
+  /** View this expression `quoted.Expr[T]` as a `Term` */
+  def asTerm(using qctx: QuoteContext): qctx.tasty.Term
 
 }
 
@@ -67,20 +75,20 @@ object Expr {
    *   Otherwise returns `expr`.
    */
   def betaReduce[T](expr: Expr[T])(using qctx: QuoteContext): Expr[T] =
-    qctx.tasty.internal.betaReduce(expr.unseal) match
-      case Some(expr1) => expr1.seal.asInstanceOf[Expr[T]]
+    qctx.tasty.internal.betaReduce(expr.asTerm) match
+      case Some(expr1) => expr1.asExpr.asInstanceOf[Expr[T]]
       case _ => expr
 
   /** Returns a null expresssion equivalent to `'{null}` */
   def nullExpr: QuoteContext ?=> Expr[Null] = qctx ?=> {
     import qctx.tasty._
-    Literal(Constant(null)).seal.asInstanceOf[Expr[Null]]
+    Literal(Constant(null)).asExpr.asInstanceOf[Expr[Null]]
   }
 
   /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
   def unitExpr: QuoteContext ?=> Expr[Unit] = qctx ?=> {
     import qctx.tasty._
-    Literal(Constant(())).seal.asInstanceOf[Expr[Unit]]
+    Literal(Constant(())).asExpr.asInstanceOf[Expr[Unit]]
   }
 
   /** Returns an expression containing a block with the given statements and ending with the expresion
@@ -89,7 +97,7 @@ object Expr {
    */
   def block[T](statements: List[Expr[Any]], expr: Expr[T])(using qctx: QuoteContext): Expr[T] = {
     import qctx.tasty._
-    Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
+    Block(statements.map(_.asTerm), expr.asTerm).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Lift a value into an expression containing the construction of that value */
@@ -178,7 +186,7 @@ object Expr {
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */
   def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using qctx: QuoteContext): Expr[Tuple.InverseMap[T, Expr]] = {
     val elems: Seq[Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[Expr[Any]]]
-    ofTupleFromSeq(elems).cast[Tuple.InverseMap[T, Expr]]
+    ofTupleFromSeq(elems).asExprOf[Tuple.InverseMap[T, Expr]]
   }
 
   /** Find an implicit of type `T` in the current scope given by `qctx`.
@@ -192,7 +200,7 @@ object Expr {
   def summon[T](using tpe: Type[T])(using qctx: QuoteContext): Option[Expr[T]] = {
     import qctx.tasty._
     searchImplicit(tpe.unseal.tpe) match {
-      case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
+      case iss: ImplicitSearchSuccess => Some(iss.tree.asExpr.asInstanceOf[Expr[T]])
       case isf: ImplicitSearchFailure => None
     }
   }

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

@@ -19,9 +19,9 @@ object Lambda {
     import qctx.tasty._
     val argTypes = functionType.unseal.tpe match
       case AppliedType(_, functionArguments) => functionArguments.init.asInstanceOf[List[Type]]
-    qctx.tasty.internal.lambdaExtractor(expr.unseal, argTypes).map { fn =>
+    qctx.tasty.internal.lambdaExtractor(expr.asTerm, argTypes).map { fn =>
       def f(args: Tuple.Map[Args, Expr]): Expr[Res] =
-        fn(args.toArray.toList.map(_.asInstanceOf[Expr[Any]].unseal)).seal.asInstanceOf[Expr[Res]]
+        fn(args.toArray.toList.map(_.asInstanceOf[Expr[Any]].asTerm)).asExpr.asInstanceOf[Expr[Res]]
       tg.untupled(f)
     }
 

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

@@ -33,15 +33,15 @@ object Liftable {
     /** Lift a primitive value `n` into `'{ n }` */
     def toExpr(x: T) = qctx ?=> {
       import qctx.tasty._
-      Literal(Constant(x)).seal.asInstanceOf[Expr[T]]
+      Literal(Constant(x)).asExpr.asInstanceOf[Expr[T]]
     }
   }
 
   given ClassIsLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
     /** Lift a `Class[T]` into `'{ classOf[T] }` */
     def toExpr(x: Class[T]) = qctx ?=> {
       import qctx.tasty._
-      Ref(defn.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
+      Ref(defn.Predef_classOf).appliedToType(Type(x)).asExpr.asInstanceOf[Expr[Class[T]]]
     }
   }
 

library/src-bootstrapped/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.tasty._
-    Repeated(xs.map[Term](_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
+    Repeated(xs.map[Term](_.asTerm).toList, tp.unseal).asExpr.asInstanceOf[Expr[Seq[T]]]
   }
 
   /** Matches a literal sequence of expressions and return a sequence of expressions.
@@ -35,12 +35,12 @@ object Varargs {
   def unapply[T](expr: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[Expr[T]]] = {
     import qctx.tasty._
     def rec(tree: Term): Option[Seq[Expr[T]]] = tree match {
-      case Typed(Repeated(elems, _), _) => Some(elems.map(x => x.seal.asInstanceOf[Expr[T]]))
+      case Typed(Repeated(elems, _), _) => Some(elems.map(x => x.asExpr.asInstanceOf[Expr[T]]))
       case Block(Nil, e) => rec(e)
       case Inlined(_, Nil, e) => rec(e)
       case _  => None
     }
-    rec(expr.unseal)
+    rec(expr.asTerm)
   }
 
 }

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

@@ -8,7 +8,7 @@ object report:
 
   /** Report an error at the on the position of `expr` */
   def error(msg: => String, expr: Expr[Any])(using qctx: QuoteContext): Unit =
-    qctx.tasty.error(msg, expr.unseal.pos)
+    qctx.tasty.error(msg, expr.asTerm.pos)
 
   /** Report an error at the position of the macro expansion and throws a StopQuotedContext */
   def throwError(msg: => String)(using qctx: QuoteContext): Nothing = {
@@ -27,7 +27,7 @@ object report:
 
   /** Report a warning at the on the position of `expr` */
   def warning(msg: => String, expr: Expr[_])(using qctx: QuoteContext): Unit =
-    qctx.tasty.warning(msg, expr.unseal.pos)
+    qctx.tasty.warning(msg, expr.asTerm.pos)
 
   /** Throwable used to stop the expansion of a macro after an error was reported */
   class StopQuotedContext extends Throwable

library/src-bootstrapped/scala/quoted/unsafe/UnsafeExpr.scala

@@ -20,7 +20,7 @@ object UnsafeExpr {
   *           change the parameter semantics as by-value parameter could be re-evaluated.
   */
   def underlyingArgument[T](expr: Expr[T])(using qctx: QuoteContext): Expr[T] =
-    expr.unseal.underlyingArgument.seal.asInstanceOf[Expr[T]]
+    expr.asTerm.underlyingArgument.asExpr.asInstanceOf[Expr[T]]
 
   // TODO generalize for any function arity
   /** Allows inspection or transformation of the body of the expression of function.
@@ -38,23 +38,23 @@ object UnsafeExpr {
    */
   def open[T1, R, X](f: Expr[T1 => R])(content: (Expr[R], [t] => Expr[t] => Expr[T1] => Expr[t]) => X)(using qctx: QuoteContext): X = {
     val (params, bodyExpr) = paramsAndBody[R](f)
-    content(bodyExpr, [t] => (e: Expr[t]) => (v: Expr[T1]) => bodyFn[t](e.unseal, params, List(v.unseal)).seal.asInstanceOf[Expr[t]])
+    content(bodyExpr, [t] => (e: Expr[t]) => (v: Expr[T1]) => bodyFn[t](e.asTerm, params, List(v.asTerm)).asExpr.asInstanceOf[Expr[t]])
   }
 
   def open[T1, T2, R, X](f: Expr[(T1, T2) => R])(content: (Expr[R], [t] => Expr[t] => (Expr[T1], Expr[T2]) => Expr[t]) => X)(using qctx: QuoteContext)(using DummyImplicit): X = {
     val (params, bodyExpr) = paramsAndBody[R](f)
-    content(bodyExpr, [t] => (e: Expr[t]) => (v1: Expr[T1], v2: Expr[T2]) => bodyFn[t](e.unseal, params, List(v1.unseal, v2.unseal)).seal.asInstanceOf[Expr[t]])
+    content(bodyExpr, [t] => (e: Expr[t]) => (v1: Expr[T1], v2: Expr[T2]) => bodyFn[t](e.asTerm, params, List(v1.asTerm, v2.asTerm)).asExpr.asInstanceOf[Expr[t]])
   }
 
   def open[T1, T2, T3, R, X](f: Expr[(T1, T2, T3) => R])(content: (Expr[R], [t] => Expr[t] => (Expr[T1], Expr[T2], Expr[T3]) => Expr[t]) => X)(using qctx: QuoteContext)(using DummyImplicit, DummyImplicit): X = {
     val (params, bodyExpr) = paramsAndBody[R](f)
-    content(bodyExpr, [t] => (e: Expr[t]) => (v1: Expr[T1], v2: Expr[T2], v3: Expr[T3]) => bodyFn[t](e.unseal, params, List(v1.unseal, v2.unseal, v3.unseal)).seal.asInstanceOf[Expr[t]])
+    content(bodyExpr, [t] => (e: Expr[t]) => (v1: Expr[T1], v2: Expr[T2], v3: Expr[T3]) => bodyFn[t](e.asTerm, params, List(v1.asTerm, v2.asTerm, v3.asTerm)).asExpr.asInstanceOf[Expr[t]])
   }
 
   private def paramsAndBody[R](using qctx: QuoteContext)(f: Expr[Any]): (List[qctx.tasty.ValDef], Expr[R]) = {
     import qctx.tasty._
-    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = f.unseal.etaExpand
-    (params, body.seal.asInstanceOf[Expr[R]])
+    val Block(List(DefDef("$anonfun", Nil, List(params), _, Some(body))), Closure(Ident("$anonfun"), None)) = f.asTerm.etaExpand
+    (params, body.asExpr.asInstanceOf[Expr[R]])
   }
 
   private def bodyFn[t](using qctx: QuoteContext)(e: qctx.tasty.Term, params: List[qctx.tasty.ValDef], args: List[qctx.tasty.Term]): qctx.tasty.Term = {

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

@@ -107,16 +107,13 @@ trait ExprMap {
           tree
         case _: Inlined =>
           transformTermChildren(tree, tpe)
+        case _ if tree.isExpr =>
+          type X
+          val expr = tree.asExpr.asInstanceOf[Expr[X]]
+          val t = tpe.seal.asInstanceOf[quoted.Type[X]]
+          transform(expr)(using qctx, t).asTerm
         case _ =>
-          tree.tpe.widen match {
-            case _: MethodType | _: PolyType =>
-              transformTermChildren(tree, tpe)
-            case _ =>
-              type X
-              val expr = tree.seal.asInstanceOf[Expr[X]]
-              val t = tpe.seal.asInstanceOf[quoted.Type[X]]
-              transform(expr)(using qctx, t).unseal
-          }
+          transformTermChildren(tree, tpe)
       }
 
       def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree
@@ -155,7 +152,7 @@ trait ExprMap {
         trees mapConserve (transformTypeCaseDef(_))
 
     }
-    new MapChildren().transformTermChildren(e.unseal, tpe.unseal.tpe).seal.cast[T] // Cast will only fail if this implementation has a bug
+    new MapChildren().transformTermChildren(e.asTerm, tpe.unseal.tpe).asExprOf[T]
   }
 
 }

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

@@ -1,4 +1,7 @@
 package scala.quoted
 
 abstract class Expr[+T] private[scala]:
-  def unseal(using qctx: QuoteContext): qctx.tasty.Term
+  def unseal(using qctx: QuoteContext): qctx.tasty.Term = asTerm
+  def asTerm(using qctx: QuoteContext): qctx.tasty.Term
+  def asExprOf[U](using tp: scala.quoted.Type[U])(using qctx: QuoteContext): scala.quoted.Expr[U] =
+    throw new Exception("Non bootstrapped lib")

library/src/scala/internal/quoted/Expr.scala

@@ -18,7 +18,7 @@ import scala.quoted._
     case _ => false
   }
 
-  def unseal(using qctx: QuoteContext): qctx.tasty.Term =
+  def asTerm(using qctx: QuoteContext): qctx.tasty.Term =
     if (qctx.tasty.internal.compilerId != scopeId)
       throw new scala.quoted.ScopeException("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
     tree.asInstanceOf[qctx.tasty.Term]
@@ -52,7 +52,7 @@ object Expr {
    */
   def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: scala.quoted.Expr[Any])(using patternExpr: scala.quoted.Expr[Any],
         hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
-    new Matcher.QuoteMatcher[qctx.type].termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+    new Matcher.QuoteMatcher[qctx.type].termMatch(scrutineeExpr.asTerm, patternExpr.asTerm, hasTypeSplices).asInstanceOf[Option[Tup]]
   }
 
 }

library/src/scala/internal/quoted/Matcher.scala

@@ -253,14 +253,14 @@ object Matcher {
               if patternHole.symbol == internal.Definitions_InternalQuotedMatcher_patternHole &&
                  s.tpe <:< tpt.tpe &&
                  tpt2.tpe.derivesFrom(defn.RepeatedParamClass) =>
-            matched(scrutinee.seal)
+            matched(scrutinee.asExpr)
 
           /* Term hole */
           // Match a scala.internal.Quoted.patternHole and return the scrutinee tree
           case (ClosedPatternTerm(scrutinee), TypeApply(patternHole, tpt :: Nil))
               if patternHole.symbol == internal.Definitions_InternalQuotedMatcher_patternHole &&
                  scrutinee.tpe <:< tpt.tpe =>
-            matched(scrutinee.seal)
+            matched(scrutinee.asExpr)
 
           /* Higher order term hole */
           // Matches an open term and wraps it into a lambda that provides the free variables
@@ -283,7 +283,7 @@ object Matcher {
             val argTypes = args.map(x => x.tpe.widenTermRefExpr)
             val resType = pattern.tpe
             val res = Lambda(MethodType(names)(_ => argTypes, _ => resType), bodyFn)
-            matched(res.seal)
+            matched(res.asExpr)
 
           //
           // Match two equivalent trees

library/src/scala/tasty/Reflection.scala

@@ -488,7 +488,28 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       /** Shows the tree as fully typed source code */
       def showWith(syntaxHighlight: SyntaxHighlight)(using ctx: Context): String =
         new SourceCodePrinter[self.type](self)(syntaxHighlight).showTree(tree)
+
+      /** Does this tree represent a valid expression? */
+      def isExpr(using ctx: Context): Boolean =
+        tree match
+          case tree: Term =>
+            tree.tpe.widen match
+              case _: MethodType | _: PolyType => false
+              case _ => true
+          case _ => false
+
+      /** Convert to an `quoted.Expr[Any]` if the tree is a valid expression or throws */
+      def asExpr(using QuoteContext): scala.quoted.Expr[Any] =
+        assert(tree.isExpr, tree)
+        new scala.internal.quoted.Expr(tree, internal.compilerId)
+
     end extension
+
+    /** Convert to an `quoted.Expr[T]` if the tree is a valid expression or throws */
+    extension [T](tree: Tree)
+      def asExprOf(using scala.quoted.Type[T])(using QuoteContext): scala.quoted.Expr[T] =
+        tree.asExpr.asExprOf[T]
+
   end Tree
 
   given (using ctx: Context) as TypeTest[Tree, PackageClause] = internal.PackageClause_TypeTest
@@ -654,12 +675,14 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     extension (self: Term):
 
       /** Convert `Term` to an `quoted.Expr[Any]` if the term is a valid expression or throws */
+      @deprecated("Replaced with `asExpr` (or `asExprOf`)", "0.27.0")
       def seal(using ctx: Context): scala.quoted.Expr[Any] =
         sealOpt.getOrElse {
           throw new Exception("Cannot seal a partially applied Term. Try eta-expanding the term first.")
         }
 
       /** Convert `Term` to an `quoted.Expr[Any]` if the term is a valid expression */
+      @deprecated("Replaced with `isExpr` and `asExpr` (or `asExprOf`)", "0.27.0")
       def sealOpt(using ctx: Context): Option[scala.quoted.Expr[Any]] =
         self.tpe.widen match
           case _: MethodType | _: PolyType => None