Move internal Expr and Type implementations into the compiler

Author: nicolasstucki

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

@@ -39,14 +39,14 @@ object PickledQuotes {
 
   /** Transform the expression into its fully spliced Tree */
   def quotedExprToTree[T](expr: quoted.Expr[T])(using Context): Tree = {
-    val expr1 = expr.asInstanceOf[scala.internal.quoted.Expr[Tree]]
+    val expr1 = expr.asInstanceOf[scala.quoted.internal.Expr[Tree]]
     expr1.checkScopeId(QuoteContextImpl.scopeId)
     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[scala.internal.quoted.Type[Tree]]
+    val tpe1 = tpe.asInstanceOf[scala.quoted.internal.Type[Tree]]
     tpe1.checkScopeId(QuoteContextImpl.scopeId)
     changeOwnerOfTree(tpe1.typeTree, ctx.owner)
   }
@@ -75,8 +75,8 @@ object PickledQuotes {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Hole(isTerm, idx, args) =>
           val reifiedArgs = args.map { arg =>
-            if (arg.isTerm) (using qctx: QuoteContext) => new scala.internal.quoted.Expr(arg, QuoteContextImpl.scopeId)
-            else new scala.internal.quoted.Type(arg, QuoteContextImpl.scopeId)
+            if (arg.isTerm) (using qctx: QuoteContext) => new scala.quoted.internal.Expr(arg, QuoteContextImpl.scopeId)
+            else new scala.quoted.internal.Type(arg, QuoteContextImpl.scopeId)
           }
           if isTerm then
             val quotedExpr = pickledQuote.exprSplice(idx)(reifiedArgs)(dotty.tools.dotc.quoted.QuoteContextImpl())

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

@@ -72,7 +72,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
             case _ => false
         def asExpr: scala.quoted.Expr[Any] =
           if self.isExpr then
-            new scala.internal.quoted.Expr(self, QuoteContextImpl.this.hashCode)
+            new scala.quoted.internal.Expr(self, QuoteContextImpl.this.hashCode)
           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)
@@ -316,11 +316,11 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
     object TermMethodsImpl extends TermMethods:
       extension (self: Term):
         def seal: scala.quoted.Expr[Any] =
-          if self.isExpr then new scala.internal.quoted.Expr(self, QuoteContextImpl.this.hashCode)
+          if self.isExpr then new scala.quoted.internal.Expr(self, QuoteContextImpl.this.hashCode)
           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 scala.internal.quoted.Expr(self, QuoteContextImpl.this.hashCode))
+          if self.isExpr then Some(new scala.quoted.internal.Expr(self, QuoteContextImpl.this.hashCode))
           else None
 
         def tpe: TypeRepr = self.tpe
@@ -1003,7 +1003,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
 
     object TypeTree extends TypeTreeModule:
       def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree =
-        tp.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree
+        tp.asInstanceOf[scala.quoted.internal.Type[TypeTree]].typeTree
     end TypeTree
 
     object TypeTreeMethodsImpl extends TypeTreeMethods:
@@ -1572,7 +1572,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
 
     object TypeRepr extends TypeReprModule:
       def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeRepr =
-        tp.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree.tpe
+        tp.asInstanceOf[scala.quoted.internal.Type[TypeTree]].typeTree.tpe
       def typeConstructorOf(clazz: Class[?]): TypeRepr =
         if (clazz.isPrimitive)
           if (clazz == classOf[Boolean]) dotc.core.Symbols.defn.BooleanType
@@ -1609,7 +1609,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
         def seal: scala.quoted.Type[_] = self.asType
 
         def asType: scala.quoted.Type[?] =
-          new scala.internal.quoted.Type(Inferred(self), QuoteContextImpl.this.hashCode)
+          new scala.quoted.internal.Type(Inferred(self), QuoteContextImpl.this.hashCode)
 
         def =:=(that: TypeRepr): Boolean = self =:= that
         def <:<(that: TypeRepr): Boolean = self <:< that
@@ -2633,11 +2633,11 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
 
   def unpickleExpr[T](pickledQuote: PickledQuote): scala.quoted.Expr[T] =
     val tree = PickledQuotes.unpickleTerm(pickledQuote)(using reflect.rootContext)
-    new scala.internal.quoted.Expr(tree, hash).asInstanceOf[scala.quoted.Expr[T]]
+    new scala.quoted.internal.Expr(tree, hash).asInstanceOf[scala.quoted.Expr[T]]
 
   def unpickleType[T <: AnyKind](pickledQuote: PickledQuote): scala.quoted.Type[T] =
     val tree = PickledQuotes.unpickleTypeTree(pickledQuote)(using reflect.rootContext)
-    new scala.internal.quoted.Type(tree, hash).asInstanceOf[scala.quoted.Type[T]]
+    new scala.quoted.internal.Type(tree, hash).asInstanceOf[scala.quoted.Type[T]]
 
   def exprMatch(scrutinee: scala.quoted.Expr[Any], pattern: scala.quoted.Expr[Any]): Option[Tuple] =
     treeMatch(scrutinee.unseal(using this), pattern.unseal(using this))

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

@@ -323,10 +323,10 @@ object Splicer {
     }
 
     private def interpretQuote(tree: Tree)(implicit env: Env): Object =
-      new scala.internal.quoted.Expr(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), QuoteContextImpl.scopeId)
+      new scala.quoted.internal.Expr(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(tree, ctx.owner)).withSpan(tree.span), QuoteContextImpl.scopeId)
 
     private def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
-      new scala.internal.quoted.Type(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), QuoteContextImpl.scopeId)
+      new scala.quoted.internal.Type(QuoteUtils.changeOwnerOfTree(tree, ctx.owner), QuoteContextImpl.scopeId)
 
     private def interpretLiteral(value: Any)(implicit env: Env): Object =
       value.asInstanceOf[Object]

compiler/src/scala/quoted/internal/Expr.scala

@@ -0,0 +1,31 @@
+package scala.quoted.internal
+
+import scala.quoted._
+
+/** An Expr backed by a tree. Only the current compiler trees are allowed.
+ *
+ *  These expressions are used for arguments of macros. They contain and actual tree
+ *  from the program that is being expanded by the macro.
+ *
+ *  May contain references to code defined outside this Expr instance.
+ */
+final class Expr[Tree](val tree: Tree, val scopeId: Int) extends scala.quoted.Expr[Any] {
+  override def equals(that: Any): Boolean = that match {
+    case that: Expr[_] =>
+      // 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
+    case _ => false
+  }
+
+  def unseal(using qctx: QuoteContext): qctx.reflect.Term =
+    checkScopeId(qctx.hashCode)
+    tree.asInstanceOf[qctx.reflect.Term]
+
+  def checkScopeId(expectedScopeId: Int): Unit =
+    if expectedScopeId != scopeId then
+      throw new Exception("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/internal/Type.scala

@@ -0,0 +1,26 @@
+package scala.quoted.internal
+
+import scala.quoted._
+
+/** Quoted type (or kind) `T` backed by a tree */
+final class Type[Tree](val typeTree: Tree, val scopeId: Int) extends scala.quoted.Type[Any] {
+  override def equals(that: Any): Boolean = that match {
+    case that: Type[_] => 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
+    case _ => false
+  }
+
+  /** View this expression `quoted.Type[T]` as a `TypeTree` */
+  def unseal(using qctx: QuoteContext): qctx.reflect.TypeTree =
+    checkScopeId(qctx.hashCode)
+    typeTree.asInstanceOf[qctx.reflect.TypeTree]
+
+  def checkScopeId(expectedScopeId: Int): Unit =
+    if expectedScopeId != scopeId then
+      throw new Exception("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
+
+  override def hashCode: Int = typeTree.hashCode
+  override def toString: String = "'[ ... ]"
+}

library/src-bootstrapped/scala/internal/quoted/Expr.scala

@@ -2,34 +2,6 @@ package scala.internal.quoted
 
 import scala.quoted._
 
-/** An Expr backed by a tree. Only the current compiler trees are allowed.
- *
- *  These expressions are used for arguments of macros. They contain and actual tree
- *  from the program that is being expanded by the macro.
- *
- *  May contain references to code defined outside this Expr instance.
- */
-final class Expr[Tree](val tree: Tree, val scopeId: Int) extends scala.quoted.Expr[Any] {
-  override def equals(that: Any): Boolean = that match {
-    case that: Expr[_] =>
-      // 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
-    case _ => false
-  }
-
-  def unseal(using qctx: QuoteContext): qctx.reflect.Term =
-    checkScopeId(qctx.hashCode)
-    tree.asInstanceOf[qctx.reflect.Term]
-
-  def checkScopeId(expectedScopeId: Int): Unit =
-    if expectedScopeId != scopeId then
-      throw new Exception("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
-
-  override def hashCode: Int = tree.hashCode
-  override def toString: String = "'{ ... }"
-}
-
 object Expr {
 
   /** Pattern matches an the scrutineeExpr against the patternExpr and returns a tuple

library/src-bootstrapped/scala/internal/quoted/Type.scala

@@ -2,29 +2,6 @@ package scala.internal.quoted
 
 import scala.quoted._
 
-/** Quoted type (or kind) `T` backed by a tree */
-final class Type[Tree](val typeTree: Tree, val scopeId: Int) extends scala.quoted.Type[Any] {
-  override def equals(that: Any): Boolean = that match {
-    case that: Type[_] => 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
-    case _ => false
-  }
-
-  /** View this expression `quoted.Type[T]` as a `TypeTree` */
-  def unseal(using qctx: QuoteContext): qctx.reflect.TypeTree =
-    checkScopeId(qctx.hashCode)
-    typeTree.asInstanceOf[qctx.reflect.TypeTree]
-
-  def checkScopeId(expectedScopeId: Int): Unit =
-    if expectedScopeId != scopeId then
-      throw new Exception("Cannot call `scala.quoted.staging.run(...)` within a macro or another `run(...)`")
-
-  override def hashCode: Int = typeTree.hashCode
-  override def toString: String = "'[ ... ]"
-}
-
 object Type {
 
   /** Pattern matches an the scrutineeType against the patternType and returns a tuple