Implement alternative seal API

This version allow sealing terms even if the type is not statically known while keeping the type safty guaratees on quoted expressions.

Added reflective tpe on `quoted.Expr[T]` to get its `quoted.Type[T]` even when `T` is just an existential type.

Added `asExprOf` to cast an `Expr[_]` to an `Expr[U]`. Fails if the exression is not a subtype of `U`.

Author: nicolasstucki

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

@@ -6,12 +6,32 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.quoted.PickledQuotes
-import dotty.tools.dotc.core.Types
+import dotty.tools.dotc.core.{Contexts, Types}
+
+import scala.quoted.Expr
 
 trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
 
-  def QuotedExprDeco[T](x: scala.quoted.Expr[T]): QuotedExprAPI = new QuotedExprAPI {
-    def unseal(implicit ctx: Context): Term = PickledQuotes.quotedExprToTree(x)
+  def QuotedExprDeco[T](thisExpr: scala.quoted.Expr[T]) = new QuotedExprAPI {
+    type Tpe = T
+
+    def unseal(implicit ctx: Context): Term = PickledQuotes.quotedExprToTree(thisExpr)
+
+    def asExprOf[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] = {
+      val expectedType = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal.tpe
+      if (unseal.tpe <:< expectedType) thisExpr.asInstanceOf[scala.quoted.Expr[T]]
+      else throw new scala.tasty.TastyTypecheckError(
+        s"""Expr: ${unseal.show}
+           |did not conform to type: ${expectedType.show}
+           |""".stripMargin
+      )
+    }
+
+    def tpe(implicit ctx: Context): quoted.Type[T] = {
+      val tree = unseal
+      val tpt = tpd.TypeTree(tree.tpe).withPos(tree.pos)
+      new scala.quoted.Types.TreeType(tpt).asInstanceOf[quoted.Type[T]]
+    }
   }
 
   def QuotedTypeDeco[T](x: scala.quoted.Type[T]): QuotedTypeAPI = new QuotedTypeAPI {
@@ -20,10 +40,10 @@ 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] = {
-
-      val expectedType = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal.tpe
+    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 etaExpand(term: Term): Term = term.tpe.widen match {
         case mtpe: Types.MethodType if !mtpe.isParamDependent =>
           val closureResType = mtpe.resType match {
@@ -37,22 +57,8 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
       }
 
       val expanded = etaExpand(term)
-      if (expanded.tpe <:< expectedType) {
-        new scala.quoted.Exprs.TastyTreeExpr(expanded).asInstanceOf[scala.quoted.Expr[T]]
-      } else {
-        throw new scala.tasty.TastyTypecheckError(
-          s"""Term: ${term.show}
-             |did not conform to type: ${expectedType.show}
-             |""".stripMargin
-        )
-      }
+      new scala.quoted.Exprs.TastyTreeExpr(expanded).asInstanceOf[scala.quoted.Expr[Tpe]]
     }
   }
 
-  def TypeToQuoteDeco(tpe: Types.Type): TypeToQuotedAPI = new TypeToQuotedAPI {
-    def seal(implicit ctx: Context): quoted.Type[_] = {
-      val dummyPos = ctx.owner.pos // FIXME
-      new scala.quoted.Types.TreeType(tpd.TypeTree(tpe).withPos(dummyPos))
-    }
-  }
 }

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

@@ -9,12 +9,11 @@ trait TreeUtils {
   import reflect._
 
   def let(rhs: Term)(in: Term.Ident => Term): Term = {
-    type T // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
-    implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
-    val rhsExpr = rhs.seal[T]
+    val rhsExpr = rhs.seal2
+    val rhsTpe = rhsExpr.tpe
     val expr = '{
-      val x = ~rhsExpr
-      ~in(('(x)).unseal.asInstanceOf[Term.Ident]).seal[Any]
+      val x: ~rhsTpe = ~rhsExpr
+      ~in(('(x)).unseal.asInstanceOf[Term.Ident]).seal2
     }
     expr.unseal
   }

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

@@ -1,13 +1,34 @@
 package scala.tasty.reflect
 
-/** Extension methods on scala.quoted.{Expr|Type} to convert to scala.tasty.Tasty objects */
+/** Extension methods on scala.quoted.{Expr|Type} to convert to scala.tasty.Tasty objects
+ *
+ *    +------+     .unseal      +------------------+
+ *    | Term | <--------------- |  quoted.Expr[T]  |
+ *    +------+                  |------------------|
+ *           \                  |    ^             |
+ *            \                 |    |.asExprOf[T] |
+ *             \   .seal2       |    |             |
+ *              +-----------------> quoted.Expr[_] |
+ *                              +------------------+
+ */
 trait QuotedOps extends Core {
 
   trait QuotedExprAPI {
+    /** Type of this expression */
+    type Tpe
+
     /** 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` */
+    def asExprOf[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T]
+
+    /** Get the quoted.Type of this expression */
+    def tpe(implicit ctx: Context): quoted.Type[Tpe]
+  }
+  implicit def QuotedExprDeco[T](expr: quoted.Expr[T]): QuotedExprAPI {
+    type Tpe = T
   }
-  implicit def QuotedExprDeco[T](expr: quoted.Expr[T]): QuotedExprAPI
 
   trait QuotedTypeAPI {
     /** View this expression `Type[T]` as a `TypeTree` */
@@ -18,12 +39,13 @@ trait QuotedOps extends Core {
   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]
   }
   implicit def TermToQuoteDeco(term: Term): TermToQuotedAPI
 
-  trait TypeToQuotedAPI {
-    /** Convert `Type` to an `quoted.Type[T]` */
-    def seal(implicit ctx: Context): scala.quoted.Type[_]
-  }
-  implicit def TypeToQuoteDeco(tpe: Type): TypeToQuotedAPI
 }