Fix scala#3847

Author: biboudis

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

@@ -130,51 +130,41 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      *  defined versions. As a side effect, prepend the expressions `tag1, ..., `tagN`
      *  as splices to `embedded`.
      */
-    private def addTags(expr: Tree)(implicit ctx: Context): Tree =
+    private def addTags(expr: Tree)(implicit ctx: Context): Tree = {
+
+      def mkTagSymbolAndAssign(typeRef: TypeRef, tag: Tree): Tree = {
+        val rhs = transform(tag.select(tpnme.UNARY_~))
+        val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs)
+
+        val original = typeRef.symbol.asType
+
+        val local = ctx.newSymbol(
+          owner = ctx.owner,
+          name = UniqueName.fresh("T".toTermName).toTypeName,
+          flags = Synthetic,
+          info = TypeAlias(tag.tpe.select(tpnme.UNARY_~)),
+          coord = typeRef.prefix.termSymbol.coord).asType
+
+        ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
+      }
+
       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_~))).asType
-
-          ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
+          mkTagSymbolAndAssign(tref, tag)
         }
         importedTags.clear()
 
-
         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))
+          mkTagSymbolAndAssign(tref, tag)
         }
-        val map: Map[Type, Type] = explicitTypeDefs.map(x => (x._1, x._2.symbol.typeRef)).toMap
 
-        println()
-        println(map)
-        println()
-        println()
+        val tagsExplicitTypeDefsPairs = explicitTags.zip(explicitTypeDefs)
+
+        val map: Map[Type, Type] = tagsExplicitTypeDefsPairs.map(x => (x._1, x._2.symbol.typeRef)).toMap
 
         val tMap = new TypeMap() {
           override def apply(tp: Type): Type = {
@@ -185,16 +175,14 @@ class ReifyQuotes extends MacroTransformWithImplicits {
           }
         }
 
-        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
+        Block(typeDefs ++ tagsExplicitTypeDefsPairs.map(_._2),
+          new TreeTypeMap(
+            typeMap = tMap,
+            substFrom = itags.map(_._1.symbol),
+            substTo = typeDefs.map(_.symbol)
+          ).apply(expr))
       }
+    }
 
     /** Enter staging level of symbol defined by `tree`, if applicable. */
     def markDef(tree: Tree)(implicit ctx: Context) = tree match {
@@ -501,18 +489,11 @@ class ReifyQuotes extends MacroTransformWithImplicits {
           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
+            val splicedType = tree.tpe.asInstanceOf[TypeRef].prefix.termSymbol
+            splice(ref(splicedType).select(tpnme.UNARY_~))
           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)

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

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

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

@@ -3,8 +3,8 @@ 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)
+  implicit def ArrayIsLiftable[T: Liftable](implicit t: Type[T]): Liftable[Array[List[T]]] = (arr: Array[List[T]]) => '{
+    new Array[List[~t]](~(arr.length: Expr[Int]))
     // TODO add elements
   }
 }

tests/run-with-compiler/i3847.check

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