Remove splice pickling type workaround

`scala.internal.Quoted.exprSplice` can be used for the same purpose by explicily setting
the type parameter of `exprSplice` to a phase correct type alias.

Author: nicolasstucki

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

@@ -52,13 +52,14 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
   protected def transformSplice(body: Tree, splice: Tree)(implicit ctx: Context): Tree = {
     if (level >= 1) {
       val body1 = transform(body)(spliceContext)
-      val splice1 = splice match {
-        case splice: Apply => cpy.Apply(splice)(splice.fun, body1 :: Nil)
+      splice match {
+        case Apply(fun: TypeApply, _) if splice.isTerm =>
+          // Type of the splice itsel must also be healed
+          // internal.Quoted.expr[F[T]](... T ...)  -->  internal.Quoted.expr[F[$t]](... T ...)
+          val tp = checkType(splice.sourcePos).apply(splice.tpe.widenTermRefExpr)
+          cpy.Apply(splice)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), body1 :: Nil)
         case splice: Select => cpy.Select(splice)(body1, splice.name)
       }
-
-      if (splice1.isType) splice1
-      else addSpliceCast(splice1)
     }
     else {
       assert(!enclosingInlineds.nonEmpty, "unexpanded macro")
@@ -76,15 +77,6 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     }
   }
 
-
-  /** Add cast to force boundaries where T and $t (an alias of T) are used to ensure PCP.
-   *  '{   ${...: T}  }  -->  '{   ${...: T}.asInstanceOf[T]  } --> '{   ${...: T}.asInstanceOf[$t]  }
-   */
-  protected def addSpliceCast(tree: Tree)(implicit ctx: Context): Tree = {
-    val tp = checkType(tree.sourcePos).apply(tree.tpe.widenTermRefExpr)
-    tree.cast(tp).withSpan(tree.span)
-  }
-
   /** If `tree` refers to a locally defined symbol (either directly, or in a pickled type),
    *  check that its staging level matches the current level. References to types
    *  that are phase-incorrect can still be healed as follows:

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

@@ -170,7 +170,7 @@ class ReifyQuotes extends MacroTransform {
      */
     override protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree = {
       val isType = quote.symbol eq defn.InternalQuoted_typeQuote
-      assert(!body.symbol.isSplice)
+      assert(!(body.symbol.isSplice && (body.isInstanceOf[GenericApply[_]] || body.isInstanceOf[Select])))
       if (level > 0) {
         val body1 = nested(isQuote = true).transform(body)(quoteContext)
         super.transformQuotation(body1, quote)
@@ -349,12 +349,6 @@ class ReifyQuotes extends MacroTransform {
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       reporting.trace(i"Reifier.transform $tree at $level", show = true) {
         tree match {
-          case TypeApply(Select(spliceTree @ Spliced(spliced), _), tp) if tree.symbol.isTypeCast =>
-            // TODO this branch should be removable with the new splice
-            // Splice term which should be in the form `${x}.asInstanceOf[T]` where T is an artifact of
-            // typer to allow pickling/unpickling phase consistent types
-            transformSplice(spliced, spliceTree)
-
           case tree: RefTree if isCaptured(tree.symbol, level) =>
             val body = capturers(tree.symbol).apply(tree)
             val splice: Tree =

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

@@ -44,8 +44,6 @@ class Staging extends MacroTransform {
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
           val checker = new PCPCheckAndHeal(freshStagingContext) {
-            override protected def addSpliceCast(tree: Tree)(implicit ctx: Context): Tree = tree
-
             override protected def tryHeal(sym: Symbol, tp: Type, pos: SourcePosition)(implicit ctx: Context): Option[tpd.Tree] = {
               def symStr =
                 if (!tp.isInstanceOf[ThisType]) sym.show

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1929,7 +1929,7 @@ class Typer extends Namer
     }
   }
 
-  /** Translate '{ t }` into `scala.quoted.Expr.apply(t)` and `'[T]` into `scala.quoted.Type.apply[T]`
+  /** Translate `'{ t }` into `scala.quoted.Expr.apply(t)` and `'[T]` into `scala.quoted.Type.apply[T]`
    *  while tracking the quotation level in the context.
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
@@ -1941,11 +1941,34 @@ class Typer extends Namer
     tree1.withSpan(tree.span)
   }
 
-  /** Translate `${ t: Expr[T] }` into expresiion `t.splice` while tracking the quotation level in the context */
+  /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
   def typedSplice(tree: untpd.Splice, pt: Type)(implicit ctx: Context): Tree = track("typedSplice") {
     checkSpliceOutsideQuote(tree)
-    if (tree.isType) typedSelect(untpd.Select(tree.expr, nme.splice), pt)(spliceContext).withSpan(tree.span)
-    else typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext)
+    val direct = true
+    if (direct) {
+      // fails: tests/pos/quote-whitebox
+      typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext)
+    } else {
+      // Compile dotty with `direct = true` before switching this branch
+
+      // fails
+      //  src from tastyBootstrap/lib
+      //  tests/neg/i4493-b.scala
+      //  tests/neg/i4493.scala
+      //  tests/neg/quote-interpolator-core-old.scala
+      //  tests/run/quote-change-owner
+      //  tests/pos/i4493-c.scala
+      //  tests/pos/i3912-2
+      val spliced = typed(tree.expr, defn.QuotedExprType.appliedTo(pt))(spliceContext)
+      spliced.tpe.widenTermRefExpr match {
+        case exprTpe: AppliedType =>
+          assert(exprTpe.classSymbol == defn.QuotedExprClass)
+          tpd.ref(defn.InternalQuoted_exprSpliceR).appliedToTypes(exprTpe.args).appliedTo(spliced).withSpan(tree.span)
+        case tp: ErrorType =>
+          tree.withType(tp)
+      }
+    }
+
   }
 
   /** Translate ${ t: Type[T] }` into type `t.splice` while tracking the quotation level in the context */