Split type/term splices and type them

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -51,23 +51,23 @@ object PickledQuotes {
   }
 
   /** Unpickle the tree contained in the TastyExpr */
-  def unpickleTerm(pickled: String | List[String], fillHole: Int => Seq[Any] => Any)(using Context): Tree = {
+  def unpickleTerm(pickled: String | List[String], typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => scala.quoted.QuoteContext => scala.quoted.Expr[?])(using Context): Tree = {
     val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = false))
     val Inlined(call, Nil, expnasion) = unpickled
     val inlineCtx = inlineContext(call)
-    val expansion1 = spliceTypes(expnasion, fillHole)(using inlineCtx)
-    val expansion2 = spliceTerms(expansion1, fillHole)(using inlineCtx)
+    val expansion1 = spliceTypes(expnasion, typeHole, termHole)(using inlineCtx)
+    val expansion2 = spliceTerms(expansion1, typeHole, termHole)(using inlineCtx)
     cpy.Inlined(unpickled)(call, Nil, expansion2)
   }
 
   /** Unpickle the tree contained in the TastyType */
-  def unpickleTypeTree(pickled: String | List[String], fillHole: Int => Seq[Any] => Any)(using Context): Tree = {
+  def unpickleTypeTree(pickled: String | List[String], typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => scala.quoted.QuoteContext => scala.quoted.Expr[?])(using Context): Tree = {
     val unpickled = withMode(Mode.ReadPositions)(unpickle(pickled, isType = true))
-    spliceTypes(unpickled, fillHole)
+    spliceTypes(unpickled, typeHole, termHole)
   }
 
   /** Replace all term holes with the spliced terms */
-  private def spliceTerms(tree: Tree, fillHole: Int => Seq[Any] => Any)(using Context): Tree = {
+  private def spliceTerms(tree: Tree, typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => scala.quoted.QuoteContext => scala.quoted.Expr[?])(using Context): Tree = {
     val evaluateHoles = new TreeMap {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Hole(isTerm, idx, args) =>
@@ -76,7 +76,7 @@ object PickledQuotes {
             else new scala.internal.quoted.Type(arg, QuoteContextImpl.scopeId)
           }
           if isTerm then
-            val quotedExpr = fillHole(idx)(reifiedArgs).asInstanceOf[QuoteContext => scala.quoted.Expr[Any]](dotty.tools.dotc.quoted.QuoteContextImpl())
+            val quotedExpr = termHole(idx)(reifiedArgs)(dotty.tools.dotc.quoted.QuoteContextImpl())
             val filled = PickledQuotes.quotedExprToTree(quotedExpr)
 
             // We need to make sure a hole is created with the source file of the surrounding context, even if
@@ -86,7 +86,7 @@ object PickledQuotes {
           else
             // Replaces type holes generated by ReifyQuotes (non-spliced types).
             // These are types defined in a quote and used at the same level in a nested quote.
-            val quotedType = fillHole(idx)(reifiedArgs).asInstanceOf[scala.quoted.Type[?]]
+            val quotedType = typeHole(idx)(reifiedArgs)
             PickledQuotes.quotedTypeToTree(quotedType)
         case tree: Select =>
           // Retain selected members
@@ -121,15 +121,15 @@ object PickledQuotes {
   }
 
   /** Replace all type holes generated with the spliced types */
-  private def spliceTypes(tree: Tree, fillHole: Int => Seq[Any] => Any)(using Context): Tree = {
+  private def spliceTypes(tree: Tree, typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => Any)(using Context): Tree = {
     tree match
       case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
         val typeSpliceMap = (stat :: rest).iterator.map {
           case tdef: TypeDef =>
             assert(tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot))
             val tree = tdef.rhs match
               case TypeBoundsTree(_, Hole(_, idx, args), _) =>
-                val quotedType = fillHole(idx)(args).asInstanceOf[scala.quoted.Type[?]]
+                val quotedType = typeHole(idx)(args)
                 PickledQuotes.quotedTypeToTree(quotedType)
               case TypeBoundsTree(_, tpt, _) =>
                 tpt

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -2630,12 +2630,12 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
 
   end reflect
 
-  def unpickleExpr[T](pickled: String | List[String], fillHole: Int => Seq[Any] => Any): scala.quoted.Expr[T] =
-    val tree = PickledQuotes.unpickleTerm(pickled, fillHole)(using reflect.rootContext)
+  def unpickleExpr[T](pickled: String | List[String], typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => scala.quoted.QuoteContext => scala.quoted.Expr[?]): scala.quoted.Expr[T] =
+    val tree = PickledQuotes.unpickleTerm(pickled, typeHole, termHole)(using reflect.rootContext)
     new scala.internal.quoted.Expr(tree, hash).asInstanceOf[scala.quoted.Expr[T]]
 
-  def unpickleType[T <: AnyKind](pickled: String | List[String], fillHole: Int => Seq[Any] => Any): scala.quoted.Type[T] =
-    val tree = PickledQuotes.unpickleTypeTree(pickled, fillHole)(using reflect.rootContext)
+  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: Int => Seq[Any] => scala.quoted.Type[?], termHole: Int => Seq[Any] => scala.quoted.QuoteContext => scala.quoted.Expr[?]): scala.quoted.Type[T] =
+    val tree = PickledQuotes.unpickleTypeTree(pickled, typeHole, termHole)(using reflect.rootContext)
     new scala.internal.quoted.Type(tree, hash).asInstanceOf[scala.quoted.Type[T]]
 
   object ExprMatch extends ExprMatchModule:

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -204,16 +204,38 @@ class ReifyQuotes extends MacroTransform {
         val pickledQuoteStrings = pickleQuote match
           case x :: Nil => Literal(Constant(x))
           case xs => liftList(xs.map(x => Literal(Constant(x))), defn.StringType)
+
+
+        val (typeSplices, termSplices) = splices.partition { splice =>
+          splice.tpe match
+            case defn.FunctionOf(_, res, _, _) => res.typeSymbol == defn.QuotedTypeClass
+            case _ => false
+        }
+        // TODO encode this in a more efficient way.
+        // - Create one function that takes the index, the args, and the context directly.
+        // - Take advantage of beta reduction to avoid the creation of the inner closures.
+        // - Remove typeHoles/termHoles casts.
         val splicesList = liftList(splices, defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), defn.AnyType))
+        val holes = SyntheticValDef("holes".toTermName, splicesList)
+        val typeHoles = ref(holes.symbol).asInstance(
+          defn.FunctionType(1).appliedTo(defn.IntType,
+            defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType),
+              defn.QuotedTypeClass.typeRef.appliedTo(defn.AnyType))))
+        val termHoles = ref(holes.symbol).asInstance(
+          defn.FunctionType(1).appliedTo(defn.IntType,
+            defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType),
+              defn.FunctionType(1).appliedTo(defn.QuoteContextClass.typeRef,
+                defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)))))
+
         val quoteClass = if isType then defn.QuotedTypeClass else defn.QuotedExprClass
         val quotedType = quoteClass.typeRef.appliedTo(originalTp)
         val lambdaTpe = MethodType(defn.QuoteContextClass.typeRef :: Nil, quotedType)
         def callUnpickle(ts: List[Tree]) = {
           val qctx = ts.head.asInstance(defn.QuoteContextInternalClass.typeRef)
           val unpickleMeth = if isType then defn.QuoteContextInternal_unpickleType else defn.QuoteContextInternal_unpickleExpr
-          qctx.select(unpickleMeth).appliedToType(originalTp).appliedTo(pickledQuoteStrings, splicesList)
+          qctx.select(unpickleMeth).appliedToType(originalTp).appliedTo(pickledQuoteStrings, typeHoles, termHoles)
         }
-        Lambda(lambdaTpe, callUnpickle).withSpan(body.span)
+        Block(List(holes), Lambda(lambdaTpe, callUnpickle)).withSpan(body.span)
       }
 
       /** Encode quote using Reflection.TypeRepr.typeConstructorOf

library/src/scala/internal/quoted/QuoteContextInternal.scala

@@ -9,12 +9,12 @@ trait QuoteContextInternal { self: QuoteContext =>
   /** Unpickle `repr` which represents a pickled `Expr` tree,
    *  replacing splice nodes with `holes`
    */
-  def unpickleExpr[T](pickled: String | List[String], fillHole: Int => Seq[Any] => Any): scala.quoted.Expr[T]
+  def unpickleExpr[T](pickled: String | List[String], typeHole: Int => Seq[Any] => Type[?], termHole: Int => Seq[Any] => QuoteContext => Expr[?]): scala.quoted.Expr[T]
 
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `holes`
    */
-  def unpickleType[T <: AnyKind](pickled: String | List[String], fillHole: Int => Seq[Any] => Any): scala.quoted.Type[T]
+  def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: Int => Seq[Any] => Type[?], termHole: Int => Seq[Any] => QuoteContext => Expr[?]): scala.quoted.Type[T]
 
   val ExprMatch: ExprMatchModule