Fix #3847: Splice type splices in TypeTrees

Author: nicolasstucki

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

@@ -113,6 +113,8 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      */
     val importedTags = new mutable.LinkedHashMap[TypeRef, Tree]()
 
+    val explicitTags = new mutable.LinkedHashSet[TypeRef]()
+
     /** A stack of entered symbols, to be unwound after scope exit */
     var enteredSyms: List[Symbol] = Nil
 
@@ -129,23 +131,69 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      *  as splices to `embedded`.
      */
     private def addTags(expr: Tree)(implicit ctx: Context): Tree =
-      if (importedTags.isEmpty) expr
+      if (importedTags.isEmpty && explicitTags.isEmpty) expr
       else {
         val itags = importedTags.toList
+
+        println("addTags: expr: " + expr)
+        println("addTags: tags: ")
+        itags.foreach(println)
+
         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
           val local = original.copy(
             owner = ctx.owner,
+            name = (original.name + "$$").toTypeName,
             flags = Synthetic,
-            info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)))
-          ctx.typeAssigner.assignType(untpd.TypeDef(original.name, alias), local)
+            info = TypeAlias(tag.tpe.select(tpnme.UNARY_~))).asType
+
+          ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
         }
         importedTags.clear()
-        Block(typeDefs,
-          new TreeTypeMap(substFrom = itags.map(_._1.symbol), substTo = typeDefs.map(_.symbol))
+
+
+        val explicitTypeDefs = for (tref <- explicitTags) yield {
+          val tag = ref(tref.prefix.termSymbol)
+          val rhs = transform(tag.select(tpnme.UNARY_~))
+
+          val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
+
+          val local = ctx.newSymbol(
+            owner = ctx.owner,
+            name = UniqueName.fresh("ttt".toTermName).toTypeName,
+            flags = Synthetic,
+            info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)),
+            coord = tref.prefix.termSymbol.coord).asType
+
+          (tref, ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local))
+        }
+        val map: Map[Type, Type] = explicitTypeDefs.map(x => (x._1, x._2.symbol.typeRef)).toMap
+
+        println()
+        println(map)
+        println()
+        println()
+
+        val tMap = new TypeMap() {
+          override def apply(tp: Type): Type = {
+            if (map.contains(tp))
+              map.apply(tp)
+            else
+              mapOver(tp)
+          }
+        }
+
+        val ret = Block(typeDefs ++ explicitTypeDefs.map(_._2),
+          new TreeTypeMap(typeMap = tMap,
+            substFrom = itags.map(_._1.symbol), substTo = typeDefs.map(_.symbol))
             .apply(expr))
+
+        println("addTags: ret: " + ret)
+        println(ret.show)
+        println()
+        ret
       }
 
     /** Enter staging level of symbol defined by `tree`, if applicable. */
@@ -181,26 +229,30 @@ class ReifyQuotes 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: Position)(implicit ctx: Context): Option[String] = tp match {
-      case tp: TypeRef =>
-        if (level == 0) {
-          None
-        } else {
-          val reqType = defn.QuotedTypeType.appliedTo(tp)
-          val tag = ctx.typer.inferImplicitArg(reqType, pos)
-          tag.tpe match {
-            case fail: SearchFailureType =>
-              Some(i"""
-                      |
+    def tryHeal(tp: Type, pos: Position)(implicit ctx: Context): Option[String] = {
+     // println("tryHeal: " + tp)
+      tp match {
+        case tp: TypeRef =>
+          if (level == 0) {
+            None
+          } else {
+            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
+                     | ${ctx.typer.missingArgMsg(tag, reqType, "")}""")
+              case _ =>
+                importedTags(tp) = nested(isQuote = false).transform(tag)
+                None
+            }
           }
-        }
-      case _ =>
-        Some("")
+        case _ =>
+          Some("")
+      }
     }
 
     /** Check reference to `sym` for phase consistency, where `tp` is the underlying type
@@ -225,8 +277,11 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     def checkType(pos: Position)(implicit ctx: Context): TypeAccumulator[Unit] = new TypeAccumulator[Unit] {
       def apply(acc: Unit, tp: Type): Unit = reporting.trace(i"check type level $tp at $level") {
         tp match {
-          case tp: NamedType if tp.symbol.isSplice =>
-            if (inQuote) outer.checkType(pos).foldOver(acc, tp)
+          case tp: TypeRef if tp.symbol.isSplice =>
+            if (inQuote) {
+              explicitTags += tp
+              outer.checkType(pos).foldOver(acc, tp)
+            }
             else {
               if (tp.isTerm) spliceOutsideQuotes(pos)
               tp
@@ -291,6 +346,13 @@ class ReifyQuotes extends MacroTransformWithImplicits {
       }
       else {
         val (body1, splices) = nested(isQuote = true).split(body)
+
+//        println()
+//        println("for quote: " + quote)
+//        println("body: " + body1)
+//        println("bodys: " + body1.show)
+
+        //splices.foreach(println)
         pickledQuote(body1, splices, isType).withPos(quote.pos)
       }
     }
@@ -333,6 +395,12 @@ class ReifyQuotes extends MacroTransformWithImplicits {
       }
       else {
         val (body1, quotes) = nested(isQuote = false).split(splice.qualifier)
+//        println()
+//        println("for splice: " + splice)
+//        println("body: " + body1)
+//        println("bodys: " + body1.show)
+//
+//        quotes.foreach(println)
         makeHole(body1, quotes, splice.tpe).withPos(splice.pos)
       }
     }
@@ -432,7 +500,19 @@ class ReifyQuotes extends MacroTransformWithImplicits {
         tree match {
           case Quoted(quotedTree) =>
             quotation(quotedTree, tree)
+          case tree: TypeTree if tree.tpe.typeSymbol.isSplice =>
+              val splicedType = tree.tpe.asInstanceOf[TypeRef].prefix.termSymbol
+              val ret = splice(ref(splicedType).select(tpnme.UNARY_~))
+//              println()
+//              println("TypeTree: " + tree)
+//              println("TypeTrees: " + tree.show)
+//              println("TypeTree ret: " + ret)
+//              println("TypeTree rets: " + ret.show)
+              ret
+          case tree: TypeApply =>
+            super.transform(tree)
           case tree: Select if tree.symbol.isSplice =>
+//            println("Select: " + tree)
             splice(tree)
           case tree: RefTree if needsLifting(tree) =>
             val lift = lifters(tree.symbol)
@@ -441,7 +521,6 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-
           case Inlined(call, bindings, InlineSplice(expansion @ Select(body, name))) =>
             // To maintain phase consistency, we move the binding of the this parameter into the spliced code
             val (splicedBindings, stagedBindings) = bindings.partition {

project/Build.scala

@@ -64,7 +64,7 @@ object Build {
 
 
   val agentOptions = List(
-    // "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"
+//     "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"
     // "-agentpath:/home/dark/opt/yjp-2013-build-13072/bin/linux-x86-64/libyjpagent.so"
     // "-agentpath:/Applications/YourKit_Java_Profiler_2015_build_15052.app/Contents/Resources/bin/mac/libyjpagent.jnilib",
     // "-XX:+HeapDumpOnOutOfMemoryError", "-Xmx1g", "-Xss2m"

tests/run-with-compiler/i3847-b.check

@@ -0,0 +1,3 @@
+{
+  dotty.runtime.Arrays.newGenericArray[Int](3)(reflect.ClassTag.Int)
+}

tests/run-with-compiler/i3847-b.scala

@@ -0,0 +1,19 @@
+import dotty.tools.dotc.quoted.Toolbox._
+import scala.quoted._
+import scala.reflect.ClassTag
+
+object Arrays {
+  implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T], ct: Expr[ClassTag[T]]): Liftable[Array[List[T]]] = (arr: Array[List[T]]) => '{
+    new Array[List[~t]](3)
+    // TODO add elements
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    import Arrays._
+    implicit val ct: Expr[ClassTag[Int]] = '(ClassTag.Int)
+    val arr: Expr[Array[List[Int]]] = Array[List[Int]](List(1, 2, 3))
+    println(arr.show)
+  }
+}

tests/run-with-compiler/i3847.check

@@ -0,0 +1,3 @@
+{
+  dotty.runtime.Arrays.newGenericArray[Int](3)(reflect.ClassTag.Int)
+}

tests/run-with-compiler/i3847.scala

@@ -0,0 +1,19 @@
+import dotty.tools.dotc.quoted.Toolbox._
+import scala.quoted._
+import scala.reflect.ClassTag
+
+object Arrays {
+  implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T], ct: Expr[ClassTag[T]]): Liftable[Array[T]] = (arr: Array[T]) => '{
+    new Array[~t](~(arr.length: Expr[Int]))(~ct)
+    // TODO add elements
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    import Arrays._
+    implicit val ct: Expr[ClassTag[Int]] = '(ClassTag.Int)
+    val arr: Expr[Array[Int]] = Array[Int](1, 2, 3)
+    println(arr.show)
+  }
+}