Fix #3823: Unpickle type holes

Author: nicolasstucki

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

@@ -7,12 +7,11 @@ import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
 import dotty.tools.dotc.interpreter.RawQuoted
 
-import scala.runtime.quoted.Unpickler.Pickled
-
 object PickledQuotes {
   import tpd._
 
@@ -42,26 +41,24 @@ object PickledQuotes {
     val tastyBytes = TastyString.unpickle(expr.tasty)
     val unpickled = unpickle(tastyBytes, expr.args)
     unpickled match {
-      case PackageDef(_, (vdef: ValDef) :: Nil) => vdef.rhs
-      case PackageDef(_, (tdef: TypeDef) :: Nil) => tdef.rhs
+      case PackageDef(_, (vdef: ValDef) :: Nil) =>
+        if (vdef.name == "quote".toTermName) vdef.rhs
+        else vdef.rhs.asInstanceOf[TypeApply].args.head
     }
   }
 
   /** Encapsulate the tree in a top level `val` or `type`
-   *    `<tree>` ==> `package _root_ { val ': Any = <tree> }`
+   *    `<tree>` ==> `package _root_ { val quote: Any = <tree> }`
    *    or
-   *    `<type tree>` ==> `package _root_ { type ' = <tree tree> }`
+   *    `<type tree>` ==> `package _root_ { val typeQuote: Any = null.asInstanceOf[<tree>] }`
    */
   private def encapsulateQuote(tree: Tree)(implicit ctx: Context): Tree = {
-    def encapsulatedTerm = {
-      val sym = ctx.newSymbol(ctx.owner, "'".toTermName, Synthetic, defn.AnyType, coord = tree.pos)
-      ValDef(sym, tree).withPos(tree.pos)
-    }
-
-    def encapsulatedType =
-      untpd.TypeDef("'".toTypeName, tree).withPos(tree.pos).withType(defn.AnyType)
-
-    val quoted = if (tree.isTerm) encapsulatedTerm else encapsulatedType
+    val name = (if (tree.isTerm) "quote" else "typeQuote").toTermName
+    val sym = ctx.newSymbol(ctx.owner, name, Synthetic, defn.AnyType, coord = tree.pos)
+    val encoded =
+      if (tree.isTerm) tree
+      else Literal(Constant(null)).select(nme.asInstanceOf_).appliedToTypeTrees(tree :: Nil)
+    val quoted = ValDef(sym, encoded).withPos(tree.pos)
     PackageDef(ref(defn.RootPackage).asInstanceOf[Ident], quoted :: Nil).withPos(tree.pos)
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -21,7 +21,7 @@ import typer.Checking
 import config.Config
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.interpreter.RawQuoted
-import scala.quoted.Expr
+import scala.quoted
 
 /** Unpickler for typed trees
  *  @param reader          the reader from which to unpickle
@@ -287,6 +287,8 @@ class TreeUnpickler(reader: TastyReader,
               ConstantType(Constant(readType()))
             case ENUMconst =>
               ConstantType(Constant(readTermRef().termSymbol))
+            case HOLE =>
+              readHole(end).tpe
           }
         assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
@@ -1030,13 +1032,7 @@ class TreeUnpickler(reader: TastyReader,
             case TYPEBOUNDStpt =>
               TypeBoundsTree(readTpt(), readTpt())
             case HOLE =>
-              val idx = readNat()
-              val args = until(end)(readTerm())
-              val splice = splices(idx)
-              val expr =
-                if (args.isEmpty) splice.asInstanceOf[Expr[_]]
-                else splice.asInstanceOf[Seq[Any] => Expr[_]](args.map(RawQuoted.apply))
-              PickledQuotes.quotedToTree(expr)
+              readHole(end)
             case _ =>
               readPathTerm()
           }
@@ -1083,6 +1079,16 @@ class TreeUnpickler(reader: TastyReader,
       new LazyReader(localReader, op)
     }
 
+    def readHole(end: Addr)(implicit ctx: Context): Tree = {
+      val idx = readNat()
+      val args = until(end)(readTerm())
+      val splice = splices(idx)
+      val quotedType =
+        if (args.isEmpty) splice.asInstanceOf[quoted.Quoted]
+        else splice.asInstanceOf[Seq[Any] => quoted.Quoted](args.map(RawQuoted.apply))
+      PickledQuotes.quotedToTree(quotedType)
+    }
+
 // ------ Setting positions ------------------------------------------------
 
     /** Pickled position for `addr`. */

tests/run-with-compiler/quote-run-type.check

@@ -0,0 +1,4 @@
+{
+  val z: Int = 2
+  ()
+}

tests/run-with-compiler/quote-run-type.scala

@@ -0,0 +1,10 @@
+import dotty.tools.dotc.quoted.Runners._
+import scala.quoted._
+object Test {
+  def main(args: Array[String]): Unit = {
+    def f[T](x: Expr[T])(t: Type[T]) = '{
+      val z: t.unary_~ = ~x
+    }
+    println(f('(2))('[Int]).show)
+  }
+}