wip

Author: nicolasstucki

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

@@ -127,7 +127,6 @@ class Staging extends MacroTransformWithImplicits {
      */
     val importedTags = new mutable.LinkedHashMap[TypeRef, Tree]()
 
-
     /** A stack of entered symbols, to be unwound after scope exit */
     var enteredSyms: List[Symbol] = Nil
 
@@ -267,68 +266,80 @@ class Staging extends MacroTransformWithImplicits {
      *  @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: SourcePosition)(implicit ctx: Context): Option[String] = tp match {
-      case tp: TypeRef =>
-        if (level == -1) {
-          assert(ctx.inInlineMethod)
-          None
-        } else {
-          val reqType = defn.QuotedTypeType.appliedTo(tp)
-          val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
-          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
+    def tryHeal(sym: Symbol, tp: Type, pos: SourcePosition)(implicit ctx: Context): Option[Tree] = {
+      def levelError(errMsg: String) = {
+        def symStr =
+          if (!tp.isInstanceOf[ThisType]) sym.show
+          else if (sym.is(ModuleClass)) sym.sourceModule.show
+          else i"${sym.name}.this"
+        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
+      }
+      tp match {
+        case tp: TypeRef =>
+          if (level == -1) {
+            assert(ctx.inInlineMethod)
+            None
+          } else {
+            val reqType = defn.QuotedTypeType.appliedTo(tp)
+            val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
+            tag.tpe match {
+              case fail: SearchFailureType =>
+                levelError(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) // TODO remove me
+                Some(nested(isQuote = false).transform(tag).select(tpnme.UNARY_~)) // TODO remove the transform?
+            }
           }
-        }
-      case _ =>
-        Some("")
+        case _ =>
+          levelError("")
+      }
     }
 
     /** 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: SourcePosition)(implicit ctx: Context): Unit = {
+    def check(sym: Symbol, tp: Type, pos: SourcePosition)(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))
         check(sym.owner, sym.owner.thisType, pos)
       else if (sym.exists && !sym.isStaticOwner && !levelOK(sym))
-        for (errMsg <- tryHeal(tp, pos))
-          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)
+        tryHeal(sym, tp, pos)
+      else
+        None
     }
 
     /** Check all named types and this-types in a given type for phase consistency. */
-    def checkType(pos: SourcePosition)(implicit ctx: Context): TypeAccumulator[Unit] = new TypeAccumulator[Unit] {
-      def apply(acc: Unit, tp: Type): Unit = reporting.trace(i"check type level $tp at $level") {
+    def checkType(pos: SourcePosition)(implicit ctx: Context): TypeMap = new TypeMap {
+      def apply(tp: Type): Type = reporting.trace(i"check type level $tp at $level") {
         tp match {
           case tp: TypeRef if tp.symbol.isSplice =>
             if (inQuote) {
-              outer.checkType(pos).foldOver(acc, tp)
+              // TODO add level to checkType TypeMap and avoid accessing the outer one?
+              outer.checkType(pos).mapOver(tp)
             }
             else {
               if (tp.isTerm) ctx.error(i"splice outside quotes", pos)
               tp
             }
           case tp: NamedType =>
-            check(tp.symbol, tp, tp.symbol.sourcePos)
-            if (!tp.symbol.is(Param))
-              foldOver(acc, tp)
+            check(tp.symbol, tp, tp.symbol.sourcePos) match {
+              case Some(tpRef) => tpRef.tpe
+              case _ =>
+                if (tp.symbol.is(Param)) tp
+                else mapOver(tp)
+            }
           case tp: ThisType =>
-            check(tp.cls, tp, tp.cls.sourcePos)
-            foldOver(acc, tp)
+            assert(check(tp.cls, tp, tp.cls.sourcePos).isEmpty)
+            mapOver(tp)
           case _ =>
-            foldOver(acc, tp)
+            mapOver(tp)
         }
       }
     }
@@ -348,19 +359,32 @@ class Staging extends MacroTransformWithImplicits {
      */
     private def checkLevel(tree: Tree)(implicit ctx: Context): Tree = {
       tree match {
-        case (_: Ident) | (_: This) =>
-          check(tree.symbol, tree.tpe, tree.sourcePos)
+        case _: This =>
+          assert(check(tree.symbol, tree.tpe, tree.sourcePos).isEmpty)
+          tree
+        case _: Ident =>
+          check(tree.symbol, tree.tpe, tree.sourcePos) match {
+            case Some(tpRef) => tpRef
+            case _ => tree
+          }
         case (_: UnApply)  | (_: TypeTree) =>
-          checkType(tree.sourcePos).apply((), tree.tpe)
+          checkType(tree.sourcePos).apply(tree.tpe)
+          tree
         case Select(qual, OuterSelectName(_, levels)) =>
-          checkType(tree.sourcePos).apply((), tree.tpe.widen)
+          checkType(tree.sourcePos).apply(tree.tpe.widen)
+          tree
         case _: Bind =>
-          checkType(tree.sourcePos).apply((), tree.symbol.info)
+          checkType(tree.sourcePos).apply(tree.symbol.info)
+          tree
         case _: Template =>
-          checkType(tree.sourcePos).apply((), tree.symbol.owner.asClass.givenSelfType)
+          checkType(tree.sourcePos).apply(tree.symbol.owner.asClass.givenSelfType)
+          tree
+        case tree: Typed =>
+          val tp = checkType(tree.sourcePos).apply(tree.tpe)
+          tree.withType(tp)
         case _ =>
+          tree
       }
-      tree
     }
 
     /** Split `body` into a core and a list of embedded splices.
@@ -424,7 +448,8 @@ class Staging extends MacroTransformWithImplicits {
     /** Transform `tree` followed by `addTags` transform. */
     private def transformAndAddTags(tree: Tree)(implicit ctx: Context): Tree = {
       assert(inQuote)
-      addTags(transform(tree))
+//      addTags(transform(tree))
+      transform(tree)
     }
 
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
@@ -449,11 +474,11 @@ class Staging extends MacroTransformWithImplicits {
                 if (tree.isType || level == 0) splice(tree)
                 else {
                   // TODO add comment '{   ~(...: T)  }  -->  '{   ~(...: T).asInstanceOf[T]  } --> '{   ~(...: T).asInstanceOf[~t]  }
-                  val tp = tree.tpe.widenTermRefExpr
-                  checkType(tree.sourcePos).apply((), tp)
+                  val tp = checkType(tree.sourcePos).apply(tree.tpe.widenTermRefExpr)
                   splice(tree).asInstance(tp).withSpan(tree.span)
                 }
             }
+            //TODO remove this case?
           case tree: RefTree if tree.symbol.is(Inline) && tree.symbol.is(Param) =>
             tree
           case Block(stats, _) =>
@@ -495,18 +520,17 @@ class Staging extends MacroTransformWithImplicits {
           case tree: DefDef if tree.symbol.is(Macro) && level > 0 =>
             mapOverTree(enteredSyms)
             EmptyTree
+          case tree: ValDef =>
+            markDef(tree)
+            val tree1 @ ValDef(_, tpt, _) = checkLevel(mapOverTree(enteredSyms))
+            tree1.symbol.info = tpt.tpe // TODO transform in a cleaner way
+            tree1
           case _ =>
             markDef(tree)
             checkLevel(mapOverTree(enteredSyms))
         }
       }
 
-    private def liftList(list: List[Tree], tpe: Type)(implicit ctx: Context): Tree = {
-      list.foldRight[Tree](ref(defn.NilModule)) { (x, acc) =>
-        acc.select("::".toTermName).appliedToType(tpe).appliedTo(x)
-      }
-    }
-
     /** InlineSplice is used to detect cases where the expansion
      *  consists of a (possibly multiple & nested) block or a sole expression.
      */

tests/pos/quote-liftable-list.scala

@@ -0,0 +1,9 @@
+import scala.quoted._
+
+object Test {
+
+  implicit def ListIsLiftable[T: Liftable: Type]: Liftable[List[T]] = new {
+    def toExpr(xs: List[T]): Expr[List[T]] = '(Nil: List[T])
+  }
+
+}