Use SpliceScope instead of ScopeId and remove it

Author: nicolasstucki

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

@@ -41,15 +41,13 @@ object PickledQuotes {
   /** Transform the expression into its fully spliced Tree */
   def quotedExprToTree[T](expr: quoted.Expr[T])(using Context): Tree = {
     val expr1 = expr.asInstanceOf[ExprImpl]
-    expr1.checkScopeId(QuotesImpl.scopeId)
     ScopeException.checkInCorrectScope(expr1.scope, SpliceScope.getCurrent, expr1.tree, "Expr")
     changeOwnerOfTree(expr1.tree, ctx.owner)
   }
 
   /** Transform the expression into its fully spliced TypeTree */
   def quotedTypeToTree(tpe: quoted.Type[?])(using Context): Tree = {
     val tpe1 = tpe.asInstanceOf[TypeImpl]
-    tpe1.checkScopeId(QuotesImpl.scopeId)
     ScopeException.checkInCorrectScope(tpe1.scope, SpliceScope.getCurrent, tpe1.typeTree, "Type")
     changeOwnerOfTree(tpe1.typeTree, ctx.owner)
   }
@@ -77,8 +75,8 @@ object PickledQuotes {
         case Hole(isTerm, idx, args) =>
           inContext(SpliceScope.contextWithNewSpliceScope(tree.sourcePos)) {
             val reifiedArgs = args.map { arg =>
-              if (arg.isTerm) (q: Quotes) ?=> new ExprImpl(arg, QuotesImpl.scopeId, SpliceScope.getCurrent)
-              else new TypeImpl(arg, QuotesImpl.scopeId, SpliceScope.getCurrent)
+              if (arg.isTerm) (q: Quotes) ?=> new ExprImpl(arg, SpliceScope.getCurrent)
+              else new TypeImpl(arg, SpliceScope.getCurrent)
             }
             if isTerm then
               val quotedExpr = termHole(idx, reifiedArgs, QuotesImpl())

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

@@ -326,10 +326,10 @@ object Splicer {
     }
 
     private def interpretQuote(tree: Tree)(implicit env: Env): Object =
-      new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), QuotesImpl.scopeId, SpliceScope.getCurrent)
+      new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), SpliceScope.getCurrent)
 
     private def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
-      new TypeImpl(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), QuotesImpl.scopeId, SpliceScope.getCurrent)
+      new TypeImpl(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), SpliceScope.getCurrent)
 
     private def interpretLiteral(value: Any)(implicit env: Env): Object =
       value.asInstanceOf[Object]

compiler/src/scala/quoted/runtime/impl/ExprImpl.scala

@@ -10,19 +10,14 @@ import dotty.tools.dotc.ast.tpd
  *
  *  May contain references to code defined outside this Expr instance.
  */
-final class ExprImpl(val tree: tpd.Tree, val scopeId: Int, val scope: Scope) extends Expr[Any] {
+final class ExprImpl(val tree: tpd.Tree, val scope: Scope) extends Expr[Any] {
   override def equals(that: Any): Boolean = that match {
     case that: ExprImpl =>
       // Expr are wrappers around trees, therefore they are equals if their trees are equal.
-      // All scopeId should be equal unless two different runs of the compiler created the trees.
-      tree == that.tree && scopeId == that.scopeId
+      // All scope should be equal unless two different runs of the compiler created the trees.
+      tree == that.tree && scope == that.scope
     case _ => false
   }
 
-  def checkScopeId(expectedScopeId: Int): Unit =
-    if expectedScopeId != scopeId then
-      throw new ScopeException("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
-
-  override def hashCode: Int = tree.hashCode
   override def toString: String = "'{ ... }"
 }

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -23,8 +23,6 @@ import scala.reflect.TypeTest
 
 object QuotesImpl {
 
-  type ScopeId = Int
-
   def apply()(using Context): Quotes =
     new QuotesImpl
 
@@ -34,11 +32,6 @@ object QuotesImpl {
     if ctx.settings.color.value == "always" then TreeAnsiCode.show(tree)
     else TreeCode.show(tree)
 
-  // TODO Explore more fine grained scope ids.
-  //      This id can only differentiate scope extrusion from one compiler instance to another.
-  def scopeId(using Context): ScopeId =
-    ctx.outersIterator.toList.last.hashCode()
-
 }
 
 class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler, QuoteMatching:
@@ -81,10 +74,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     end CompilationInfo
 
     extension (expr: Expr[Any])
-      def asTerm: Term =
-        val exprImpl = expr.asInstanceOf[ExprImpl]
-        exprImpl.checkScopeId(QuotesImpl.this.hashCode)
-        exprImpl.tree
+      def asTerm: Term = expr.asInstanceOf[ExprImpl].tree
     end extension
 
     type Tree = tpd.Tree
@@ -105,7 +95,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case _ => false
         def asExpr: scala.quoted.Expr[Any] =
           if self.isExpr then
-            new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent)
+            new ExprImpl(self, SpliceScope.getCurrent)
           else self match
             case TermTypeTest(self) => throw new Exception("Expected an expression. This is a partially applied Term. Try eta-expanding the term first.")
             case _ => throw new Exception("Expected a Term but was: " + self)
@@ -372,11 +362,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     given TermMethods: TermMethods with
       extension (self: Term)
         def seal: scala.quoted.Expr[Any] =
-          if self.isExpr then new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent)
+          if self.isExpr then new ExprImpl(self, SpliceScope.getCurrent)
           else throw new Exception("Cannot seal a partially applied Term. Try eta-expanding the term first.")
 
         def sealOpt: Option[scala.quoted.Expr[Any]] =
-          if self.isExpr then Some(new ExprImpl(self, QuotesImpl.this.hashCode, SpliceScope.getCurrent))
+          if self.isExpr then Some(new ExprImpl(self, SpliceScope.getCurrent))
           else None
 
         def tpe: TypeRepr = self.tpe
@@ -1666,7 +1656,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def seal: scala.quoted.Type[_] = self.asType
 
         def asType: scala.quoted.Type[?] =
-          new TypeImpl(Inferred(self), QuotesImpl.this.hashCode, SpliceScope.getCurrent)
+          new TypeImpl(Inferred(self), SpliceScope.getCurrent)
 
         def =:=(that: TypeRepr): Boolean = self =:= that
         def <:<(that: TypeRepr): Boolean = self <:< that
@@ -2877,11 +2867,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
   def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Expr[T] =
     val tree = PickledQuotes.unpickleTerm(pickled, typeHole, termHole)
-    new ExprImpl(tree, hash, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Expr[T]]
+    new ExprImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Expr[T]]
 
   def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Type[T] =
     val tree = PickledQuotes.unpickleTypeTree(pickled, typeHole, termHole)
-    new TypeImpl(tree, hash, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]]
+    new TypeImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]]
 
   object ExprMatch extends ExprMatchModule:
     def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =
@@ -2948,7 +2938,4 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     }
   }
 
-  private[this] val hash = QuotesImpl.scopeId(using ctx)
-  override def hashCode: Int = hash
-
 end QuotesImpl

compiler/src/scala/quoted/runtime/impl/ScopeException.scala

@@ -7,6 +7,9 @@ class ScopeException(msg: String) extends Exception(msg)
 
 object ScopeException:
   def checkInCorrectScope(scope: Scope, currentScope: Scope, tree: Tree, kind: String)(using Context): Unit =
+    if scope.root != currentScope.root then
+      throw new ScopeException(s"Cannot use $kind oustide of the macro splice `$${...}` or the scala.quoted.staging.run(...)` where it was defined")
+
     val yCheck = ctx.settings.Ycheck.value(using ctx).exists(x => x == "all" || x == "macros")
     if yCheck && !scope.isOuterScopeOf(currentScope) then
       throw new ScopeException(

compiler/src/scala/quoted/runtime/impl/SpliceScope.scala

@@ -18,6 +18,9 @@ trait Scope {
   /** Is this is a outer scope of the given scope */
   def isOuterScopeOf(scope: Scope): Boolean =
     this.eq(scope) || (scope.ne(NoScope) && isOuterScopeOf(scope.outer))
+  /** Scope of he top level splice or staging `run` */
+  def root: Scope =
+    if outer.eq(NoScope) then this else outer.root
   /** Stack of locations where scopes where evaluated */
   def stack: List[String] =
     this.toString :: (if outer.eq(NoScope) then Nil else outer.stack)
@@ -27,6 +30,7 @@ trait Scope {
 
 /** Only used for outer scope of top level splice and staging `run` */
 object NoScope extends Scope:
+  override def root: Scope = this
   override def outer: Scope = throw UnsupportedOperationException("NoScope.outer")
 
 class SpliceScope(val pos: SourcePosition, override val outer: Scope) extends Scope:
@@ -57,6 +61,6 @@ object SpliceScope:
 
     /** Context with an incremented quotation level. */
   def getCurrent(using Context): Scope =
-      ctx.property(ScopeKey).getOrElse(null)
+      ctx.property(ScopeKey).getOrElse(NoScope)
 
 end SpliceScope

compiler/src/scala/quoted/runtime/impl/TypeImpl.scala

@@ -4,24 +4,14 @@ package runtime.impl
 import dotty.tools.dotc.ast.tpd
 
 /** Quoted type (or kind) `T` backed by a tree */
-final class TypeImpl(val typeTree: tpd.Tree, val scopeId: Int, val scope: Scope) extends Type[?] {
+final class TypeImpl(val typeTree: tpd.Tree, val scope: Scope) extends Type[?] {
   override def equals(that: Any): Boolean = that match {
     case that: TypeImpl => typeTree ==
-      // TastyTreeExpr are wrappers around trees, therfore they are equals if their trees are equal.
-      // All scopeId should be equal unless two different runs of the compiler created the trees.
-      that.typeTree && scopeId == that.scopeId
+      // TastyTreeExpr are wrappers around trees, therefore they are equals if their trees are equal.
+      // All scope should be equal unless two different runs of the compiler created the trees.
+      that.typeTree && scope == that.scope
     case _ => false
   }
 
-  /** View this expression `q.Type[T]` as a `TypeTree` */
-  def unseal(using q: Quotes): q.reflect.TypeTree =
-    checkScopeId(q.hashCode)
-    typeTree.asInstanceOf[q.reflect.TypeTree]
-
-  def checkScopeId(expectedScopeId: Int): Unit =
-    if expectedScopeId != scopeId then
-      throw new ScopeException("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
-
-  override def hashCode: Int = typeTree.hashCode
   override def toString: String = "Type.of[...]"
 }