Lift only implicitly given Types

We need to come back to the earlier scheme that a lifted type
needs to refer to an implicit type tag.

Author: odersky

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

@@ -13,6 +13,7 @@ import tasty.TreePickler.Hole
 import MegaPhase.MiniPhase
 import SymUtils._
 import NameKinds.OuterSelectName
+import typer.Implicits.SearchFailureType
 
 import scala.collection.mutable
 import dotty.tools.dotc.core.StdNames._
@@ -101,7 +102,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
    *  @param  level      the current level, where quotes add one and splices subtract one level
    *  @param  levels     a stacked map from symbols to the levels in which they were defined
    */
-  private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo) extends Transformer {
+  private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo) extends ImplicitsTransformer {
     import levels._
 
     /** A nested reifier for a quote (if `isQuote = true`) or a splice (if not) */
@@ -114,29 +115,28 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     /** A list of embedded quotes (if `inSplice = true`) or splices (if `inQuote = true`) */
     val embedded = new mutable.ListBuffer[Tree]
 
-    /** A map from type ref T to "expression of type `quoted.Type[T]`".
+    /** A map from type ref T to expressions of type `quoted.Type[T]`".
      *  These will be turned into splices using `addTags`
      */
-    val importedTypes = new mutable.LinkedHashSet[TypeRef]()
+    val importedTags = new mutable.LinkedHashMap[TypeRef, Tree]()
 
-    /** Assuming typeTagOfRef = `Type1 -> tag1, ..., TypeN -> tagN`, the expression
+    /** Assuming importedTags = `Type1 -> tag1, ..., TypeN -> tagN`, the expression
      *
      *      { type <Type1> = <tag1>.unary_~
      *        ...
      *        type <TypeN> = <tagN>.unary.~
      *        <expr>
      *      }
      *
-     *  where all references to `TypeI` in `expr` are rewired to point to the locally
+     *  references to `TypeI` in `expr` are rewired to point to the locally
      *  defined versions. As a side effect, prepend the expressions `tag1, ..., `tagN`
-     *  as splices to `buf`.
+     *  as splices to `embedded`.
      */
     def addTags(expr: Tree)(implicit ctx: Context): Tree =
-      if (importedTypes.isEmpty) expr
+      if (importedTags.isEmpty) expr
       else {
-        val trefs = importedTypes.toList
-        val typeDefs = for (tref <- trefs) yield {
-          val tag = New(defn.QuotedTypeType.appliedTo(tref), Nil) // FIXME: should be an implicitly inferred defn.QuotedTypeType.appliedTo(tref)
+        val itags = importedTags.toList
+        val typeDefs = for ((tref, tag) <- itags) yield {
           val rhs = transform(tag.select(tpnme.UNARY_~))
           val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
           val original = tref.symbol.asType
@@ -146,9 +146,9 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)))
           ctx.typeAssigner.assignType(untpd.TypeDef(original.name, alias), local)
         }
-        importedTypes.clear()
+        importedTags.clear()
         Block(typeDefs,
-          new SubstMap(substFrom = trefs.map(_.symbol), substTo = typeDefs.map(_.symbol))
+          new SubstMap(substFrom = itags.map(_._1.symbol), substTo = typeDefs.map(_.symbol))
             .apply(expr))
       }
 
@@ -180,6 +180,29 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     def spliceOutsideQuotes(pos: Position)(implicit ctx: Context) =
       ctx.error(i"splice outside quotes", pos)
 
+    /** 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.
+     */
+    def tryHeal(tp: Type, pos: Position)(implicit ctx: Context): Option[String] = tp match {
+      case tp: TypeRef =>
+        val reqType = defn.QuotedTypeType.appliedTo(tp)
+        val tag = ctx.typer.inferImplicitArg(reqType, pos)
+        tag.tpe match {
+          case fail: SearchFailureType =>
+            Some(i"""
+                    |
+                    | The access would be accepted with the right type tag, but
+                    | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
+          case _ =>
+            importedTags(tp) = nested(isQuote = false).transform(tag)
+            None
+        }
+      case _ =>
+        Some("")
+    }
+
     /** Check reference to `sym` for phase consistency, where `tp` is the underlying type
      *  by which we refer to `sym`.
      */
@@ -192,14 +215,10 @@ class ReifyQuotes extends MacroTransformWithImplicits {
       if (!isThis && sym.maybeOwner.isType)
         check(sym.owner, sym.owner.thisType, pos)
       else if (sym.exists && !sym.isStaticOwner && !levelOK(sym))
-        tp match {
-          case tp: TypeRef =>
-            importedTypes += tp
-          case _ =>
-            ctx.error(em"""access to $symStr from wrong staging level:
-                          | - the definition is at level ${levelOf(sym)},
-                          | - but the access is at level $level.""", pos)
-        }
+        for (errMsg <- tryHeal(tp, pos))
+          ctx.error(em"""access to $symStr from wrong staging level:
+                        | - the definition is at level ${levelOf(sym)},
+                        | - but the access is at level $level.$errMsg""", pos)
     }
 
     /** Check all named types and this-types in a given type for phase consistency. */

tests/neg/quote-0.scala

@@ -15,7 +15,11 @@ class Test {
   '((y: Expr[Int]) => ~y )  // error: wrong staging level
 
   def f[T](t: Type[T], x: Expr[T]) = '{
-    val z2 = ~x   // OK
+    val z2 = ~x   // error: wrong staging level
+  }
+
+  def g[T](implicit t: Type[T], x: Expr[T]) = '{
+    val z2 = ~x   // ok
   }
 
 }

tests/pos/quote-1.scala

@@ -2,7 +2,7 @@ import scala.quoted._
 
 object Test {
 
-  def f[T](x: Expr[T])(t: Type[T]) = '{
+  def f[T](x: Expr[T])(implicit t: Type[T]) = '{
     val y: t.unary_~ = x.unary_~
     val z = ~x
   }
@@ -13,3 +13,4 @@ object Test {
   def g(es: Expr[String], t: Type[String]) =
     f('{ (~es + "!") :: Nil })('[List[~t]])
 }
+

tests/pos/quote-liftable.scala

@@ -17,7 +17,7 @@ object Test {
       if (b) '(true) else '(false)
   }
 
-  implicit def ListIsLiftable[T: Liftable]: Liftable[List[T]] = new {
+  implicit def ListIsLiftable[T: Liftable: Type]: Liftable[List[T]] = new {
     def toExpr(xs: List[T]): Expr[List[T]] = xs match {
       case x :: xs1 => '{ ~implicitly[Liftable[T]].toExpr(x) :: ~toExpr(xs1) }
       case Nil => '(Nil: List[T])