Fix scala#7110

wip

WIP

wip

Author: nicolasstucki

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

@@ -16,6 +16,7 @@ import dotty.tools.dotc.core.tasty.{ PositionPickler, TastyPickler, TastyPrinter
 import dotty.tools.dotc.core.tasty.TreeUnpickler.UnpickleMode
 import dotty.tools.dotc.quoted.QuoteContext
 import dotty.tools.dotc.tastyreflect.{ReflectionImpl, TastyTreeExpr, TreeType}
+import dotty.tools.dotc.util.Spans.NoSpan
 
 import dotty.tools.tasty.TastyString
 
@@ -61,19 +62,91 @@ object PickledQuotes {
   }.apply(tp)
 
   /** Unpickle the tree contained in the TastyExpr */
-  def unpickleExpr(tasty: PickledQuote, args: PickledArgs)(implicit ctx: Context): Tree = {
+  def unpickleExpr(tasty: PickledQuote, splices: PickledArgs)(implicit ctx: Context): Tree = {
     val tastyBytes = TastyString.unpickle(tasty)
-    val unpickled = unpickle(tastyBytes, args, isType = false)(ctx.addMode(Mode.ReadPositions))
+    val unpickled = unpickle(tastyBytes, splices, isType = false)(ctx.addMode(Mode.ReadPositions))
     /** Force unpickling of the tree, removes the spliced type `@quotedTypeTag type` definitions and dealiases references to `@quotedTypeTag type` */
-    val forceAndCleanArtefacts = new TreeMap {
-      override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+
+    if ctx.settings.YprintDebug.value then
+
+
+      val Inlined(call, Nil, expnasion) = unpickled
+
+      val (typeSpliceMap, expnasion1) = expnasion match
         case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
-          assert(rest.forall { case tdef: TypeDef => tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) })
-          transform(expr1)
-        case tree => super.transform(tree).withType(dealiasTypeTags(tree.tpe))
+          val map = (stat :: rest).iterator.map {
+            case tdef: TypeDef =>
+              assert(tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot))
+              val TypeBoundsTree(_, Hole(_, idx, args), _) = tdef.rhs
+              val quotedType = splices(idx).asInstanceOf[Seq[Any] => quoted.Type[?]](args)
+              val tree = PickledQuotes.quotedTypeToTree(quotedType)
+              (tdef.symbol, tree.tpe)
+          }.toMap
+          (map, expr1)
+        case _ => (Map.empty, expnasion)
+
+      def spliceTypes(tp: Type)(implicit ctx: Context): Type = new TypeMap() {
+        override def apply(tp: Type): Type = {
+          val tp1 = tp match {
+            case tp: TypeRef if tp.typeSymbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+              typeSpliceMap(tp.symbol)
+            case _ => tp
+          }
+          mapOver(tp1)
+        }
+      }.apply(tp)
+      // println("::::::::::::::::::::::::::::::::::::")
+      // println(typeSpliceMap)
+      // println()
+      // println()
+
+      val evaluateHoles = new TreeMap {
+        // private var typeSpliceMap = Map.empty[Symbol, Type]
+        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+          // case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+          //   val splicedTypes = (stat :: rest).map {
+          //     case tdef: TypeDef =>
+          //       assert(tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot))
+          //       val TypeBoundsTree(_, hi, _) = transform(tdef.rhs)
+          //       (tdef.symbol, hi.tpe)
+          //   }
+          //   typeSpliceMap = splicedTypes.toMap
+          //   transform(expr1)
+          case Hole(isType, idx, args) =>
+            assert(!isType)
+            val splice = splices(idx)
+            def wrap(arg: Tree) =
+              if (arg.isTerm) (qctx: scala.quoted.QuoteContext) ?=> new TastyTreeExpr(arg, QuoteContext.scopeId)
+              else new TreeType(arg, QuoteContext.scopeId)
+            val reifiedArgs = args.map(wrap)
+
+            val splice1 = splice.asInstanceOf[Seq[Any] => scala.quoted.QuoteContext ?=> quoted.Expr[?]]
+            val quotedExpr = splice1(reifiedArgs)(using dotty.tools.dotc.quoted.QuoteContext())
+            val filled = PickledQuotes.quotedExprToTree(quotedExpr)
+
+            // We need to make sure a hole is created with the source file of the surrounding context, even if
+            // it filled with contents a different source file.
+            if (filled.source == ctx.source) filled
+            else filled.cloneIn(ctx.source)
+
+            // super.transform(tree).withType(dealiasTypeTags(tree.tpe))
+          case tree =>
+            super.transform(tree).withType(spliceTypes(tree.tpe))
+        }
       }
-    }
-    forceAndCleanArtefacts.transform(unpickled)
+      val evaluatedExpansion = evaluateHoles.transform(expnasion1)(inlineContext(call))
+      cpy.Inlined(unpickled)(call, Nil, evaluatedExpansion)
+    else
+      val forceAndCleanArtefacts = new TreeMap {
+        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+          case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+            assert(rest.forall { case tdef: TypeDef => tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) })
+            transform(expr1)
+          case tree => super.transform(tree).withType(dealiasTypeTags(tree.tpe))
+        }
+      }
+      forceAndCleanArtefacts.transform(unpickled)
+
   }
 
   /** Unpickle the tree contained in the TastyType */

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -599,6 +599,15 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(alias)
           }
         case Hole(_, idx, args) =>
+          lazy val erasedSplicesType = new TypeMap() {
+            override def apply(tp: Type): Type = tp match {
+              case tp: TypeRef if tp.typeSymbol.isSplice || tp.typeSymbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) => tp.dealias.typeSymbol.info.hiBound
+              case tp =>
+                mapOver(tp)
+            }
+          }
+          val tpe = erasedSplicesType(tree.tpe)
+
           writeByte(HOLE)
           withLength {
             writeNat(idx)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1291,33 +1291,45 @@ class TreeUnpickler(reader: TastyReader,
     }
 
     def readHole(end: Addr, isType: Boolean)(implicit ctx: Context): Tree = {
-      val idx = readNat()
-      val tpe = readType()
-      val args = until(end)(readTerm())
-      val splice = splices(idx)
-      def wrap(arg: Tree) =
-        if (arg.isTerm) (qctx: scala.quoted.QuoteContext) ?=> new TastyTreeExpr(arg, QuoteContext.scopeId)
-        else new TreeType(arg, QuoteContext.scopeId)
-      val reifiedArgs = args.map(wrap)
-      val filled = if (isType) {
-        val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[?]](reifiedArgs)
-        PickledQuotes.quotedTypeToTree(quotedType)
-      }
-      else {
-        val splice1 = splice.asInstanceOf[Seq[Any] => scala.quoted.QuoteContext ?=> quoted.Expr[?]]
-        val quotedExpr = splice1(reifiedArgs)(using dotty.tools.dotc.quoted.QuoteContext())
-        PickledQuotes.quotedExprToTree(quotedExpr)
-      }
-      // We need to make sure a hole is created with the source file of the surrounding context, even if
-      // it filled with contents a different source file. Otherwise nodes containing holes might end
-      // up without a position. PositionPickler makes sure that holes always get spans assigned,
-      // so we can just return the filler tree with the new source and no span here.
-      if (filled.source == ctx.source) filled
-      else {
-        val filled1 = filled.cloneIn(ctx.source)
-        filled1.span = NoSpan
-        filled1
-      }
+      if ctx.settings.YprintDebug.value then
+        val idx = readNat()
+        val tpe = readType()
+        val args = until(end)(readTerm())
+        TreePickler.Hole(isType, idx, args).withType(tpe)
+      else
+        val idx = readNat()
+        val tpe = readType() // FIXME use to set type to the unpickled tree
+        val args = until(end)(readTerm())
+        val splice = splices(idx)
+        // println("++++++++++++++++++++++++++++++=")
+        // println(tpe.show)
+        // println(isType)
+        // println()
+        // println()
+        def wrap(arg: Tree) =
+          if (arg.isTerm) (qctx: scala.quoted.QuoteContext) ?=> new TastyTreeExpr(arg, QuoteContext.scopeId)
+          else new TreeType(arg, QuoteContext.scopeId)
+        val reifiedArgs = args.map(wrap)
+        val filled = if (isType) {
+          val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[?]](reifiedArgs)
+          PickledQuotes.quotedTypeToTree(quotedType)
+        }
+        else {
+          val splice1 = splice.asInstanceOf[Seq[Any] => scala.quoted.QuoteContext ?=> quoted.Expr[?]]
+          val quotedExpr = splice1(reifiedArgs)(using dotty.tools.dotc.quoted.QuoteContext())
+          val a = PickledQuotes.quotedExprToTree(quotedExpr)
+          a.ensureConforms(tpe).withSpan(a.span)
+        }
+        // We need to make sure a hole is created with the source file of the surrounding context, even if
+        // it filled with contents a different source file. Otherwise nodes containing holes might end
+        // up without a position. PositionPickler makes sure that holes always get spans assigned,
+        // so we can just return the filler tree with the new source and no span here.
+        if (filled.source == ctx.source) filled
+        else {
+          val filled1 = filled.cloneIn(ctx.source)
+          filled1.span = NoSpan
+          filled1
+        }
     }
 
 // ------ Setting positions ------------------------------------------------

compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala

@@ -100,7 +100,7 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
 
   @Test def negMacros: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileNegWithCompiler")
-    compileFilesInDir("tests/neg-macros", defaultOptions).checkExpectedErrors()
+    compileFilesInDir("tests/neg-macros", defaultOptions and "-Yprint-debug").checkExpectedErrors()
   }
 
   @Test def negWithCompiler: Unit = {
@@ -116,17 +116,17 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
   @Test def runMacros: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runMacros")
     aggregateTests(
-      compileFilesInDir("tests/run-macros", defaultOptions),
-      compileFilesInDir("tests/run-custom-args/Yretain-trees", defaultOptions and "-Yretain-trees"),
-      compileFilesInDir("tests/run-custom-args/run-macros-erased", defaultOptions and "-Yerased-terms"),
+      compileFilesInDir("tests/run-macros", defaultOptions and "-Yprint-debug"),
+      compileFilesInDir("tests/run-custom-args/Yretain-trees", defaultOptions and "-Yretain-trees" and "-Yprint-debug"),
+      compileFilesInDir("tests/run-custom-args/run-macros-erased", defaultOptions and "-Yerased-terms" and "-Yprint-debug"),
     )
   }.checkRuns()
 
   @Test def runWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runWithCompiler")
     aggregateTests(
       compileFilesInDir("tests/run-with-compiler", withCompilerOptions),
-      compileFilesInDir("tests/run-staging", withStagingOptions),
+      compileFilesInDir("tests/run-staging", withStagingOptions and "-Yprint-debug"),
       compileFilesInDir("tests/run-custom-args/tasty-inspector", withTastyInspectorOptions),
       compileDir("tests/run-custom-args/tasty-interpreter", withTastyInspectorOptions),
     ).checkRuns()

tests/neg-macros/delegate-match-1.check

@@ -3,5 +3,5 @@
 6 |  f // error
   |  ^
   |  AmbiguousImplicits
-  |  both value a1 in class Test1 and value a2 in class Test1 match type A
+  |  both value a1 in class Test1 and value a2 in class Test1 match type <empty>.this.A
   | This location contains code that was inlined from Test_2.scala:6

tests/neg-macros/delegate-match-2.check

@@ -3,5 +3,5 @@
 5 |  f // error
   |  ^
   |  DivergingImplicit
-  |  method a1 in class Test produces a diverging implicit search when trying to match type A
+  |  method a1 in class Test produces a diverging implicit search when trying to match type <empty>.this.A
   | This location contains code that was inlined from Test_2.scala:5

tests/neg-macros/delegate-match-3.check

@@ -3,5 +3,5 @@
 3 |  f // error
   |  ^
   |  NoMatchingImplicits
-  |  no implicit values were found that match type A
+  |  no implicit values were found that match type <empty>.this.A
   | This location contains code that was inlined from Test_2.scala:3

tests/pos-macros/i7110a/Macro_1.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def m[R](sym: Symantics[R]) : R = ${  mImpl[R]('{sym}) }
+
+  def mImpl[R: Type](using qctx: QuoteContext)(sym: Expr[Symantics[R]]): Expr[R] =  '{
+    $sym.Meth(42)
+  }
+}
+
+trait Symantics[R]  {
+  def Meth(exp: Int): R
+  def Meth(): R
+}

tests/pos-macros/i7110a/Test_2.scala

@@ -0,0 +1,14 @@
+import scala.quoted._
+import Macros._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    val sym = new Symantics[Int] {
+      def Meth(exp: Int): Int = exp
+      def Meth(): Int = 42
+    }
+
+    val test = m[Int](sym)
+  }
+}

tests/pos-macros/i7110b/Macro_1.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def m[T](sym: Symantics {type R = T}) : T = ${  mImpl[T]('{sym}) }
+
+  def mImpl[T: Type](using qctx: QuoteContext)(sym: Expr[Symantics { type R = T }]): Expr[T] =  '{
+    $sym.Meth(42)
+  }
+}
+
+trait Symantics {
+  type R
+  def Meth(exp: Int): R
+  def Meth(): R
+}

tests/pos-macros/i7110b/Test_2.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+import Macros._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    val sym = new Symantics {
+      type R = Int
+      def Meth(exp: Int): Int = exp
+      def Meth(): Int = 42
+    }
+
+    val test = m(sym)
+  }
+}

tests/pos-macros/i7110c/Macro_1.scala

@@ -0,0 +1,14 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def m[R](sym: Symantics[R]) : R = ${  mImpl[R]('{sym}) }
+
+  def mImpl[R: Type](using qctx: QuoteContext)(sym: Expr[Symantics[R]]): Expr[R] =  '{
+    $sym.Meth(42)
+  }
+}
+
+trait Symantics[R]  {
+  def Meth(exp: Int): R
+}

tests/pos-macros/i7110c/Test_2.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+import Macros._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    val sym = new Symantics2
+
+    val test = m[Int](sym)
+  }
+}
+
+class Symantics2 extends Symantics[Int] {
+  def Meth(exp: Int): Int = exp
+  def Meth(): Int = 42
+}

tests/pos-macros/i7110d/Macro_1.scala

@@ -0,0 +1,14 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def m(sym: Symantics) : Int = ${  mImpl('sym) }
+
+  def mImpl(using qctx: QuoteContext)(sym: Expr[Symantics]): Expr[Int] = '{
+    $sym.Meth(42)
+  }
+}
+
+trait Symantics  {
+  def Meth(exp: Int): Int
+}

tests/pos-macros/i7110d/Test_2.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+import Macros._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    val sym = new Symantics2
+
+    val test = m(sym)
+  }
+}
+
+class Symantics2 extends Symantics {
+  def Meth(exp: Int): Int = exp
+  def Meth(): Int = 42
+}

tests/pos-macros/i7110e/Macro_1.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def m(sym: Symantics, x: Int) : Int = ${  mImpl('sym, 'x) }
+
+  def mImpl(using qctx: QuoteContext)(sym: Expr[Symantics], x: Expr[Int]): Expr[Int] = '{
+    $sym.Meth($x)
+  }
+}
+
+trait Symantics  {
+  def Meth[R](exp: R): Int
+  def Meth(): Int
+}