fix merge conflict in ParallelTesting

Author: bishabosha

community-build/community-projects/shapeless

@@ -14,6 +14,7 @@ import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.tasty.TreePickler.Hole
 import dotty.tools.dotc.core.tasty.{PositionPickler, TastyPickler, TastyPrinter, TastyString}
 import dotty.tools.dotc.core.tasty.TreeUnpickler.UnpickleMode
+import dotty.tools.dotc.quoted.ToolboxImpl
 import dotty.tools.dotc.tastyreflect.ReflectionImpl
 
 import scala.internal.quoted._
@@ -35,12 +36,18 @@ object PickledQuotes {
   }
 
   /** Transform the expression into its fully spliced Tree */
-  def quotedExprToTree[T](expr: quoted.Expr[T])(implicit ctx: Context): Tree =
-    healOwner(expr.asInstanceOf[TastyTreeExpr[Tree]].tree)
+  def quotedExprToTree[T](expr: quoted.Expr[T])(implicit ctx: Context): Tree = {
+    val expr1 = expr.asInstanceOf[TastyTreeExpr[Tree]]
+    ToolboxImpl.checkScopeId(expr1.scopeId)
+    healOwner(expr1.tree)
+  }
 
   /** Transform the expression into its fully spliced TypeTree */
-  def quotedTypeToTree(expr: quoted.Type[_])(implicit ctx: Context): Tree =
-    healOwner(expr.asInstanceOf[TreeType[Tree]].typeTree)
+  def quotedTypeToTree(tpe: quoted.Type[_])(implicit ctx: Context): Tree = {
+    val tpe1 = tpe.asInstanceOf[TreeType[Tree]]
+    ToolboxImpl.checkScopeId(tpe1.scopeId)
+    healOwner(tpe1.typeTree)
+  }
 
   private def dealiasTypeTags(tp: Type)(implicit ctx: Context): Type = new TypeMap() {
     override def apply(tp: Type): Type = {

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

@@ -31,6 +31,7 @@ import scala.collection.mutable.ListBuffer
 import scala.collection.mutable
 import config.Printers.pickling
 import core.quoted.PickledQuotes
+import dotty.tools.dotc.quoted.ToolboxImpl
 
 import scala.quoted
 import scala.internal.quoted.{TastyTreeExpr, TreeType}
@@ -1273,8 +1274,8 @@ class TreeUnpickler(reader: TastyReader,
       val args = until(end)(readTerm())
       val splice = splices(idx)
       def wrap(arg: Tree) =
-        if (arg.isTerm) given (qctx: scala.quoted.QuoteContext) => new TastyTreeExpr(arg)
-        else new TreeType(arg)
+        if (arg.isTerm) given (qctx: scala.quoted.QuoteContext) => new TastyTreeExpr(arg, ToolboxImpl.scopeId)
+        else new TreeType(arg, ToolboxImpl.scopeId)
       val reifiedArgs = args.map(wrap)
       val filled = if (isType) {
         val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[_]](reifiedArgs)

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

@@ -8,7 +8,7 @@ import dotty.tools.io.{AbstractFile, Directory, PlainDirectory, VirtualDirectory
 import dotty.tools.repl.AbstractFileClassLoader
 import dotty.tools.dotc.reporting._
 import scala.quoted._
-import scala.quoted.Toolbox
+import scala.quoted.staging.Toolbox
 import java.net.URLClassLoader
 
 /** Driver to compile quoted code

compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala

@@ -1,5 +1,7 @@
 package dotty.tools.dotc.quoted
 
+import dotty.tools.dotc.core.Contexts.Context
+
 import scala.quoted._
 
 /** Default runners for quoted expressions */
@@ -11,14 +13,34 @@ object ToolboxImpl {
     * @param settings toolbox settings
     * @return A new instance of the toolbox
     */
-  def make(settings: scala.quoted.Toolbox.Settings, appClassloader: ClassLoader): scala.quoted.Toolbox = new scala.quoted.Toolbox {
+  def make(settings: scala.quoted.staging.Toolbox.Settings, appClassloader: ClassLoader): scala.quoted.staging.Toolbox = new scala.quoted.staging.Toolbox {
 
     private[this] val driver: QuoteDriver = new QuoteDriver(appClassloader)
 
+    private[this] var running = false
+
     def run[T](exprBuilder: QuoteContext => Expr[T]): T = synchronized {
-      driver.run(exprBuilder, settings)
+      try {
+        if (running) // detected nested run
+          throw new scala.quoted.staging.RunScopeException()
+        running = true
+        driver.run(exprBuilder, settings)
+      } finally {
+        running = false
+      }
     }
+  }
 
+  type ScopeId = Int
+
+  private[dotty] def checkScopeId(id: ScopeId) given Context: Unit = {
+    if (id != scopeId)
+      throw new scala.quoted.staging.RunScopeException
   }
 
+  // TODO Explore more fine grained scope ids.
+  //      This id can only differentiate scope extrusion from one compiler instance to another.
+  private[dotty] def scopeId given Context: ScopeId =
+    the[Context].outersIterator.toList.last.hashCode()
+
 }

compiler/src/dotty/tools/dotc/quoted/ToolboxImpl.scala

@@ -34,10 +34,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   //
 
   def unpickleExpr(repr: Unpickler.PickledQuote, args: Unpickler.PickledExprArgs): scala.quoted.Expr[_] =
-    new scala.internal.quoted.TastyTreeExpr(PickledQuotes.unpickleExpr(repr, args))
+    new scala.internal.quoted.TastyTreeExpr(PickledQuotes.unpickleExpr(repr, args), compilerId)
 
   def unpickleType(repr: Unpickler.PickledQuote, args: Unpickler.PickledTypeArgs): scala.quoted.Type[_] =
-    new scala.internal.quoted.TreeType(PickledQuotes.unpickleType(repr, args))
+    new scala.internal.quoted.TreeType(PickledQuotes.unpickleType(repr, args), compilerId)
 
   //
   // CONTEXT
@@ -1752,7 +1752,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
         tpd.Closure(closureMethod, tss => etaExpand(new tpd.TreeOps(term).appliedToArgs(tss.head)))
       case _ => term
     }
-    new scala.internal.quoted.TastyTreeExpr(etaExpand(self))
+    new scala.internal.quoted.TastyTreeExpr(etaExpand(self), compilerId)
   }
 
   /** Checked cast to a `quoted.Expr[U]` */
@@ -1773,7 +1773,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   /** Convert `Type` to an `quoted.Type[_]` */
   def QuotedType_seal(self: Type) given (ctx: Context): scala.quoted.Type[_] = {
     val dummySpan = ctx.owner.span // FIXME
-    new scala.internal.quoted.TreeType(tpd.TypeTree(self).withSpan(dummySpan))
+    new scala.internal.quoted.TreeType(tpd.TypeTree(self).withSpan(dummySpan), compilerId)
   }
 
   //
@@ -1934,4 +1934,6 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   private def withDefaultPos[T <: Tree](fn: given Context => T) given (ctx: Context): T =
     (fn given ctx.withSource(rootPosition.source)).withSpan(rootPosition.span)
 
+  private def compilerId: Int = rootContext.outersIterator.toList.last.hashCode()
+
 }

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -209,7 +209,9 @@ class ReifyQuotes extends MacroTransform {
       }
 
       def liftedValue[T](value: T, name: TermName) =
-        ref(defn.LiftableModule).select(name).select("toExpr".toTermName).appliedTo(Literal(Constant(value)))
+        ref(defn.LiftableModule)
+          .select(name).appliedToType(originalTp)
+          .select("toExpr".toTermName).appliedTo(Literal(Constant(value)))
 
       def pickleAsValue[T](value: T) = {
         value match {

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

@@ -25,7 +25,7 @@ import dotty.tools.repl.AbstractFileClassLoader
 
 import scala.reflect.ClassTag
 
-import dotty.tools.dotc.quoted.QuoteContext
+import dotty.tools.dotc.quoted.{QuoteContext, ToolboxImpl}
 
 /** Utility class to splice quoted expressions */
 object Splicer {
@@ -251,10 +251,10 @@ object Splicer {
     }
 
     private def interpretQuote(tree: Tree)(implicit env: Env): Object =
-      new scala.internal.quoted.TastyTreeExpr(Inlined(EmptyTree, Nil, tree).withSpan(tree.span))
+      new scala.internal.quoted.TastyTreeExpr(Inlined(EmptyTree, Nil, tree).withSpan(tree.span), ToolboxImpl.scopeId)
 
     private def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
-      new scala.internal.quoted.TreeType(tree)
+      new scala.internal.quoted.TreeType(tree, ToolboxImpl.scopeId)
 
     private def interpretLiteral(value: Any)(implicit env: Env): Object =
       value.asInstanceOf[Object]

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

@@ -1,9 +1,10 @@
 scala> import scala.quoted._
-scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-def toolbox: quoted.Toolbox
+scala> import scala.quoted.staging._
+scala> implicit def toolbox: Toolbox = Toolbox.make(getClass.getClassLoader)
+def toolbox: quoted.staging.Toolbox
 scala> def v given QuoteContext = '{ (if true then Some(1) else None).map(v => v+1) }
 def v given (x$1: quoted.QuoteContext): quoted.Expr[Option[Int]]
-scala> scala.quoted.withQuoteContext(v.show)
+scala> scala.quoted.staging.withQuoteContext(v.show)
 val res0: String = (if (true) scala.Some.apply[scala.Int](1) else scala.None).map[scala.Int](((v: scala.Int) => v.+(1)))
-scala> scala.quoted.run(v)
+scala> scala.quoted.staging.run(v)
 val res1: Option[Int] = Some(2)

compiler/test-resources/repl-macros/i6007

@@ -1,6 +1,7 @@
 scala> import quoted._
-scala> implicit def toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
-def toolbox: quoted.Toolbox
+scala> import quoted.staging._
+scala> implicit def toolbox: Toolbox = Toolbox.make(getClass.getClassLoader)
+def toolbox: quoted.staging.Toolbox
 scala> def fn[T : Type](v : T) = println("ok")
 def fn[T](v: T)(implicit evidence$1: quoted.Type[T]): Unit
 scala> withQuoteContext { fn("foo") }