Replace seal implementation seal

Use `asExprOf[T]` when needed.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala

@@ -39,11 +39,7 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
   }
 
   def TermToQuoteDeco(term: Term): TermToQuotedAPI = new TermToQuotedAPI {
-
-    def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] =
-      QuotedExprDeco(seal2).asExprOf[T]
-
-    def seal2(implicit ctx: Context): scala.quoted.Expr[Tpe] = {
+    def seal(implicit ctx: Context): scala.quoted.Expr[Tpe] = {
       def etaExpand(term: Term): Term = term.tpe.widen match {
         case mtpe: Types.MethodType if !mtpe.isParamDependent =>
           val closureResType = mtpe.resType match {

library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala

@@ -9,11 +9,11 @@ trait TreeUtils {
   import reflect._
 
   def let(rhs: Term)(in: Term.Ident => Term): Term = {
-    val rhsExpr = rhs.seal2
+    val rhsExpr = rhs.seal
     val rhsTpe = rhsExpr.tpe
     val expr = '{
       val x: ~rhsTpe = ~rhsExpr
-      ~in(('(x)).unseal.asInstanceOf[Term.Ident]).seal2
+      ~in(('(x)).unseal.asInstanceOf[Term.Ident]).seal
     }
     expr.unseal
   }

library/src/scala/tasty/reflect/QuotedOps.scala

@@ -20,7 +20,10 @@ trait QuotedOps extends Core {
     /** View this expression `Expr[T]` as a `Term` */
     def unseal(implicit ctx: Context): Term
 
-    /** Convert any `Expr[_]` to an `Expr[T]` and check that it conforms to `T` */
+    /** Cast this `Expr` to an `Expr[T]`.
+     *
+     *  Throws if this expression does not conform to `T`.
+     */
     def asExprOf[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T]
 
     /** Get the quoted.Type of this expression */
@@ -37,14 +40,11 @@ trait QuotedOps extends Core {
   implicit def QuotedTypeDeco[T](tpe: quoted.Type[T]): QuotedTypeAPI
 
   trait TermToQuotedAPI {
-    /** Convert `Term` to an `Expr[T]` and check that it conforms to `T` */
-    def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T]
-
     /** Type of this expression */
     type Tpe
 
     /** Convert `Term` to an `Expr[Tpe]` */
-    def seal2(implicit ctx: Context): scala.quoted.Expr[Tpe]
+    def seal(implicit ctx: Context): scala.quoted.Expr[Tpe]
   }
   implicit def TermToQuoteDeco(term: Term): TermToQuotedAPI
 

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

@@ -34,7 +34,7 @@ object Asserts {
 
     tree match {
       case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
-        '(assertTrue(~left.seal[Boolean])) // Buggy code. To generate the errors
+        '(assertTrue(~left.seal.asExprOf[Boolean])) // Buggy code. To generate the errors
       case _ =>
         '(assertTrue(~cond))
     }

tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala

@@ -7,16 +7,15 @@ object Macros {
   inline def let[T](rhs: T)(body: => T => Unit): Unit =
     ~impl('(rhs), '(body))
 
-  private def impl[T](rhs: Expr[T], body: Expr[T => Unit])(implicit reflect: Reflection): Expr[Unit] = {
+  private def impl[T: Type](rhs: Expr[T], body: Expr[T => Unit])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
 
     val rhsTerm = rhs.unseal
 
     import reflect.util.{let => letTerm}
     letTerm(rhsTerm) { rhsId =>
-      body(rhsId.seal[Any].asInstanceOf[Expr[T]]).unseal // Dangerous uncheked cast!
-    }.seal[Unit]
+      body(rhsId.seal.asExprOf[T]).unseal
+    }.seal.asExprOf[Unit]
   }
 
-
 }

tests/run/f-interpolation-1/FQuote_1.scala

@@ -14,7 +14,7 @@ object FQuote {
 
     def liftListOfAny(lst: List[Term]): Expr[List[Any]] = lst match {
       case x :: xs  =>
-        val head = x.seal[Any]
+        val head: Expr[Any] = x.seal
         val tail = liftListOfAny(xs)
         '{ ~head :: ~tail }
       case Nil => '(Nil)

tests/run/i5533/Macro_1.scala

@@ -13,7 +13,7 @@ object scalatest {
 
     val tree = condition.unseal
 
-    val expr = tree.seal[Boolean]
+    val expr = tree.seal.asExprOf[Boolean]
 
     '(println(~expr))
   }

tests/run/i5533b/Macro_1.scala

@@ -16,8 +16,8 @@ object scalatest {
 
     tree.underlyingArgument match {
       case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
-        val left = lhs.seal[Any]
-        val right = rhs.seal[Any]
+        val left: Expr[Any] = lhs.seal
+        val right: Expr[Any] = rhs.seal
         op match {
           case "==" =>
         '{

tests/run/i5536/Macro_1.scala

@@ -13,8 +13,8 @@ object scalatest {
 
     tree.underlyingArgument match {
       case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
-        val left = lhs.seal[Any]
-        val right = rhs.seal[Any]
+        val left: Expr[Any] = lhs.seal
+        val right: Expr[Any] = rhs.seal
         op match {
           case "===" =>
             '{

tests/run/reflect-select-copy/assert_1.scala

@@ -12,7 +12,7 @@ object scalatest {
     cond.unseal.underlyingArgument match {
       case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
         val Term.IsSelect(select) = sel
-        val cond = Term.Apply(Term.Select.copy(select)(lhs, ">"), rhs :: Nil).seal[Boolean]
+        val cond = Term.Apply(Term.Select.copy(select)(lhs, ">"), rhs :: Nil).seal.asExprOf[Boolean]
         '{ scala.Predef.assert(~cond) }
       case _ =>
         '{ scala.Predef.assert(~cond) }

tests/run/tasty-interpolation-1/Macro.scala

@@ -59,19 +59,19 @@ abstract class MacroStringInterpolator[T] {
       case Term.Select(Term.Typed(Term.Apply(_, List(Term.Apply(_, List(Term.Typed(Term.Repeated(strCtxArgTrees, _), TypeTree.Inferred()))))), _), _) =>
         val strCtxArgs = strCtxArgTrees.map {
           case Term.Literal(Constant.String(str)) => str
-          case tree => throw new NotStaticlyKnownError("Expected statically known StringContext", tree.seal[Any])
+          case tree => throw new NotStaticlyKnownError("Expected statically known StringContext", tree.seal)
         }
         StringContext(strCtxArgs: _*)
       case tree =>
-        throw new NotStaticlyKnownError("Expected statically known StringContext", tree.seal[Any])
+        throw new NotStaticlyKnownError("Expected statically known StringContext", tree.seal)
     }
   }
 
   protected def getArgsList(argsExpr: Expr[Seq[Any]])(implicit reflect: Reflection): List[Expr[Any]] = {
     import reflect._
     argsExpr.unseal.underlyingArgument match {
-      case Term.Typed(Term.Repeated(args, _), _) => args.map(_.seal[Any])
-      case tree => throw new NotStaticlyKnownError("Expected statically known argument list", tree.seal[Any])
+      case Term.Typed(Term.Repeated(args, _), _) => args.map(_.seal)
+      case tree => throw new NotStaticlyKnownError("Expected statically known argument list", tree.seal)
     }
   }
 

tests/run/tasty-macro-assert/quoted_1.scala

@@ -35,8 +35,8 @@ object Asserts {
     tree match {
       case Term.Inlined(_, Nil, Term.Apply(Term.Select(OpsTree(left), op), right :: Nil)) =>
         op match {
-          case "===" => '(assertEquals(~left.seal[Any], ~right.seal[Any]))
-          case "!==" => '(assertNotEquals(~left.seal[Any], ~right.seal[Any]))
+          case "===" => '(assertEquals[Any](~left.seal, ~right.seal))
+          case "!==" => '(assertNotEquals[Any](~left.seal, ~right.seal))
         }
       case _ =>
         '(assertTrue(~cond))

tests/run/tasty-macro-const/quoted_1.scala

@@ -12,7 +12,7 @@ object Macros {
       case Term.Literal(Constant.Int(n)) =>
         if (n <= 0)
           throw new QuoteError("Parameter must be natural number")
-        xTree.seal[Int]
+        xTree.seal.asExprOf[Int]
       case _ =>
         throw new QuoteError("Parameter must be a known constant")
     }

tests/run/tasty-seal-method/quoted_1.scala

@@ -16,10 +16,10 @@ object Asserts {
         fn.tpe.widen match {
           case Type.IsMethodType(_) =>
             args.size match {
-              case 0 => fn.seal[() => Int].apply()
-              case 1 => fn.seal[Int => Int].apply('(0))
-              case 2 => fn.seal[(Int, Int) => Int].apply('(0), '(0))
-              case 3 => fn.seal[(Int, Int, Int) => Int].apply('(0), '(0), '(0))
+              case 0 => fn.seal.asExprOf[() => Int].apply()
+              case 1 => fn.seal.asExprOf[Int => Int].apply('(0))
+              case 2 => fn.seal.asExprOf[(Int, Int) => Int].apply('(0), '(0))
+              case 3 => fn.seal.asExprOf[(Int, Int, Int) => Int].apply('(0), '(0), '(0))
             }
         }
       case _ => x
@@ -37,15 +37,15 @@ object Asserts {
       case Term.Apply(fn, args) =>
         val pre = rec(fn)
         args.size match {
-          case 0 => pre.seal[() => Any].apply().unseal
-          case 1 => pre.seal[Int => Any].apply('(0)).unseal
-          case 2 => pre.seal[(Int, Int) => Any].apply('(0), '(0)).unseal
-          case 3 => pre.seal[(Int, Int, Int) => Any].apply('(0), '(0), '(0)).unseal
+          case 0 => pre.seal.asExprOf[() => Any].apply().unseal
+          case 1 => pre.seal.asExprOf[Int => Any].apply('(0)).unseal
+          case 2 => pre.seal.asExprOf[(Int, Int) => Any].apply('(0), '(0)).unseal
+          case 3 => pre.seal.asExprOf[(Int, Int, Int) => Any].apply('(0), '(0), '(0)).unseal
         }
       case _ => term
     }
 
-    rec(x.unseal.underlyingArgument).seal[Int]
+    rec(x.unseal.underlyingArgument).seal.asExprOf[Int]
   }
 
 }

tests/run/tasty-tree-map/quoted_1.scala

@@ -8,7 +8,7 @@ object Macros {
   def impl[T: Type](x: Expr[T])(implicit reflection: Reflection): Expr[T] = {
     import reflection._
     val identityMap = new TreeMap { }
-    val transformed = identityMap.transformTerm(x.unseal).seal[T]
+    val transformed = identityMap.transformTerm(x.unseal).seal.asExprOf[T]
     transformed
   }
 

tests/run/xml-interpolation-1/XmlQuote_1.scala

@@ -27,7 +27,7 @@ object XmlQuote {
 
     def liftListOfAny(lst: List[Term]): Expr[List[Any]] = lst match {
       case x :: xs  =>
-        val head = x.seal[Any]
+        val head: Expr[Any] = x.seal
         val tail = liftListOfAny(xs)
         '{ ~head :: ~tail }
       case Nil => '(Nil)

tests/run/xml-interpolation-2/XmlQuote_1.scala

@@ -56,7 +56,7 @@ object XmlQuote {
     // [a0, ...]: Any*
     val args2: Expr[List[Any]] = args.unseal.underlyingArgument match {
       case Typed(Repeated(args0, _), _) => // statically known args, make list directly
-        args0.map(_.seal[Any]).toExprOfList
+        args0.map(_.seal.asExprOf[Any]).toExprOfList
       case _ =>
         '((~args).toList)