WIP Fix scala#5247: Splice typed directly in the tree

Remove addTags logic

Author: nicolasstucki

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

@@ -32,7 +32,7 @@ object PickledQuotes {
   def pickleQuote(tree: Tree)(implicit ctx: Context): scala.runtime.quoted.Unpickler.Pickled = {
     if (ctx.reporter.hasErrors) Nil
     else {
-      assert(!tree.isInstanceOf[Hole]) // Should not be pickled as it represents `'(~x)` which should be optimized to `x`
+      // assert(!tree.isInstanceOf[Hole], "missed optimization opportunity") // Should not be pickled as it represents `'(~x)` which should be optimized to `x`
       val pickled = pickle(tree)
       TastyString.pickle(pickled)
     }

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

@@ -253,10 +253,10 @@ class ReifyQuotes extends MacroTransformWithImplicits {
 
     /** Try to heal phase-inconsistent reference to type `T` using a local type definition.
      *  @return None      if successful
-     *  @return Some(msg) if unsuccessful where `msg` is a potentially empty error message
-     *                    to be added to the "inconsistent phase" message.
+     *  @return Some(Left(msg)) if unsuccessful where `msg` is a potentially empty error message
+     *  @return Some(Right(ttag)) the type tag that heals the inconcistency
      */
-    def tryHeal(tp: Type, pos: Position)(implicit ctx: Context): Option[String] = tp match {
+    def tryHeal(tp: Type, pos: Position)(implicit ctx: Context): Option[Either[String, Tree]] = tp match {
       case tp: TypeRef =>
         if (level == -1) {
           assert(ctx.inInlineMethod)
@@ -266,37 +266,43 @@ class ReifyQuotes extends MacroTransformWithImplicits {
           val tag = ctx.typer.inferImplicitArg(reqType, pos)
           tag.tpe match {
             case fail: SearchFailureType =>
-              Some(i"""
+              Some(Left(i"""
                       |
                       | The access would be accepted with the right type tag, but
-                      | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
+                      | ${ctx.typer.missingArgMsg(tag, reqType, "")}"""))
             case _ =>
-              importedTags(tp) = nested(isQuote = false).transform(tag)
-              None
+              Some(Right(nested(isQuote = false).transform(tag)))
+
           }
         }
       case _ =>
-        Some("")
+        Some(Left(""))
     }
 
     /** Check reference to `sym` for phase consistency, where `tp` is the underlying type
      *  by which we refer to `sym`.
      */
-    def check(sym: Symbol, tp: Type, pos: Position)(implicit ctx: Context): Unit = {
+    def check(sym: Symbol, tp: Type, pos: Position)(implicit ctx: Context): Option[Tree] = {
       val isThis = tp.isInstanceOf[ThisType]
       def symStr =
         if (!isThis) sym.show
         else if (sym.is(ModuleClass)) sym.sourceModule.show
         else i"${sym.name}.this"
-      if (!isThis && sym.maybeOwner.isType && !sym.is(Param))
+      if (!isThis && sym.maybeOwner.isType && !sym.is(Param)) {
         check(sym.owner, sym.owner.thisType, pos)
-      else if (level == 1 && sym.isType && sym.is(Param) && sym.owner.isInlineMethod && !outer.isRoot)
-        importedTags(sym.typeRef) = capturers(sym)(ref(sym))
-      else if (sym.exists && !sym.isStaticOwner && !levelOK(sym))
-        for (errMsg <- tryHeal(tp, pos))
-          ctx.error(em"""access to $symStr from wrong staging level:
+      } else if (level == 1 && sym.isType && sym.is(Param) && sym.owner.isInlineMethod && !outer.isRoot) {
+        Some(capturers(sym)(ref(sym)))
+      } else if (sym.exists && !sym.isStaticOwner && !levelOK(sym)) {
+        tryHeal(tp, pos) match {
+          case Some(Left(errMsg)) =>
+            ctx.error(em"""access to $symStr from wrong staging level:
                         | - the definition is at level ${levelOf.getOrElse(sym, 0)},
                         | - but the access is at level $level.$errMsg""", pos)
+            None
+          case Some(Right(ttag)) => Some(ttag)
+          case None => None
+        }
+      } else None
     }
 
     /** Check all named types and this-types in a given type for phase consistency. */
@@ -341,18 +347,26 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     private def checkLevel(tree: Tree)(implicit ctx: Context): Tree = {
       tree match {
         case (_: Ident) | (_: This) =>
-          check(tree.symbol, tree.tpe, tree.pos)
+          check(tree.symbol, tree.tpe, tree.pos) match {
+            case Some(ttag) =>
+              transform(ttag.select(tpnme.UNARY_~))
+            case _ => tree
+          }
         case (_: UnApply)  | (_: TypeTree) =>
           checkType(tree.pos).apply((), tree.tpe)
+          tree
         case Select(qual, OuterSelectName(_, levels)) =>
           checkType(tree.pos).apply((), tree.tpe.widen)
+          tree
         case _: Bind =>
           checkType(tree.pos).apply((), tree.symbol.info)
+          tree
         case _: Template =>
           checkType(tree.pos).apply((), tree.symbol.owner.asClass.givenSelfType)
+          tree
         case _ =>
+          tree
       }
-      tree
     }
 
     /** Split `body` into a core and a list of embedded splices.

tests/run-with-compiler/i5247.check

@@ -0,0 +1 @@
+null.asInstanceOf[java.lang.Object]

tests/run-with-compiler/i5247.scala

@@ -0,0 +1,11 @@
+import scala.quoted._
+object Test {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+  def main(args: Array[String]): Unit = {
+    println(foo[Object].show)
+  }
+  def foo[H : Type]: Expr[H] = {
+    val t = '[H]
+    '{ null.asInstanceOf[~t] }
+  }
+}

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

@@ -0,0 +1,14 @@
+import scala.quoted._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
+    foo[Object].show
+  }
+
+  def foo[H](implicit t0: Type[H]): Expr[Tuple1[H]] = {
+    val t = '[H]
+    '{ null.asInstanceOf[~t] }
+  }
+
+}