Move internal.quoted.CompileTime into scala.quoted.internal

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -812,11 +812,12 @@ class Definitions {
     @tu lazy val LiftableModule_CharLiftable: Symbol = LiftableModule.requiredMethod("CharLiftable")
     @tu lazy val LiftableModule_StringLiftable: Symbol = LiftableModule.requiredMethod("StringLiftable")
 
-  @tu lazy val InternalQuotedModule: Symbol = requiredModule("scala.internal.quoted.CompileTime")
-    @tu lazy val InternalQuoted_exprQuote  : Symbol = InternalQuotedModule.requiredMethod("exprQuote")
-    @tu lazy val InternalQuoted_exprSplice : Symbol = InternalQuotedModule.requiredMethod("exprSplice")
-    @tu lazy val InternalQuoted_exprNestedSplice : Symbol = InternalQuotedModule.requiredMethod("exprNestedSplice")
-    @tu lazy val InternalQuoted_QuoteTypeTagAnnot: ClassSymbol = InternalQuotedModule.requiredClass("quoteTypeTag")
+  @tu lazy val InternalQuotedModule: Symbol = requiredModule("scala.quoted.internal.Expr")
+    @tu lazy val InternalQuoted_exprQuote  : Symbol = InternalQuotedModule.requiredMethod("quote")
+    @tu lazy val InternalQuoted_exprSplice : Symbol = InternalQuotedModule.requiredMethod("splice")
+    @tu lazy val InternalQuoted_exprNestedSplice : Symbol = InternalQuotedModule.requiredMethod("nestedSplice")
+
+  @tu lazy val InternalQuoted_SplicedTypeAnnot: ClassSymbol = requiredClass("scala.quoted.internal.SplicedType")
 
   @tu lazy val InternalQuotedPatterns: Symbol = requiredModule("scala.quoted.internal.Patterns")
     @tu lazy val InternalQuotedPatterns_patternHole: Symbol = InternalQuotedPatterns.requiredMethod("patternHole")

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

@@ -123,10 +123,10 @@ object PickledQuotes {
   /** Replace all type holes generated with the spliced types */
   private def spliceTypes(tree: Tree, typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Int], scala.quoted.QuoteContext) => Any)(using Context): Tree = {
     tree match
-      case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+      case Block(stat :: rest, expr1) if stat.symbol.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot) =>
         val typeSpliceMap = (stat :: rest).iterator.map {
           case tdef: TypeDef =>
-            assert(tdef.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot))
+            assert(tdef.symbol.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot))
             val tree = tdef.rhs match
               case TypeBoundsTree(_, Hole(_, idx, args), _) =>
                 val quotedType = typeHole(idx, args)
@@ -141,7 +141,7 @@ object PickledQuotes {
               tp.derivedClassInfo(classParents = tp.classParents.map(apply))
             case tp: TypeRef =>
               typeSpliceMap.get(tp.symbol) match
-                case Some(t) if tp.typeSymbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) => mapOver(t)
+                case Some(t) if tp.typeSymbol.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot) => mapOver(t)
                 case _ => mapOver(tp)
             case _ =>
               mapOver(tp)

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

@@ -174,7 +174,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       tp match
         case tp: TypeRef =>
           tp.prefix match
-            case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+            case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot) =>
               val tp1 = tp.dealias
               if tp1 != tp then apply(tp1)
               else tryHeal(tp.symbol, tp, pos)
@@ -279,7 +279,7 @@ object PCPCheckAndHeal {
         flags = Synthetic,
         info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
         coord = span).asType
-      local.addAnnotation(Annotation(defn.InternalQuoted_QuoteTypeTagAnnot))
+      local.addAnnotation(Annotation(defn.InternalQuoted_SplicedTypeAnnot))
       ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
     }
 

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

@@ -82,7 +82,7 @@ class PickleQuotes extends MacroTransform {
         assert(!tree.symbol.isQuote)
         assert(!tree.symbol.isExprSplice)
       case _ : TypeDef =>
-        assert(!tree.symbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot),
+        assert(!tree.symbol.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot),
           s"${tree.symbol} should have been removed by PickledQuotes because it has a @quoteTypeTag")
       case _ =>
     }

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

@@ -49,7 +49,7 @@ class Staging extends MacroTransform {
                 else i"${sym.name}.this"
               val errMsg = s"\nin ${ctx.owner.fullName}"
               assert(
-                ctx.owner.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) ||
+                ctx.owner.hasAnnotation(defn.InternalQuoted_SplicedTypeAnnot) ||
                 (sym.isType && levelOf(sym) > 0),
                 em"""access to $symStr from wrong staging level:
                     | - the definition is at level ${levelOf(sym)},

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

@@ -1,4 +1,24 @@
-package scala.quoted.internal
+package scala.quoted
+package internal
+
+import scala.annotation.{Annotation, compileTimeOnly}
 
 /** Implementation of scala.quoted.Expr that sould only be extended by the implementation of `QuoteContext` */
 abstract class Expr[+T] extends scala.quoted.Expr[T]
+
+@compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr`")
+object Expr:
+
+  /** A term quote is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.quote`")
+  def quote[T](x: T): QuoteContext ?=> scala.quoted.Expr[T] = ???
+
+  /** A term splice is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.splice`")
+  def splice[T](x: QuoteContext ?=> scala.quoted.Expr[T]): T = ???
+
+  /** A term splice nested within a quote is desugared by the compiler into a call to this method.
+  *  `ctx` is the `QuoteContext` that the quote of this splice uses.
+  */
+  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.nestedSplice`")
+  def nestedSplice[T](ctx: QuoteContext)(x: ctx.Nested ?=> scala.quoted.Expr[T]): T = ???

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

@@ -2,6 +2,7 @@ package scala.quoted.internal
 
 import scala.annotation.{Annotation, compileTimeOnly}
 
+@compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns`")
 object Patterns {
 
   /** A splice in a quoted pattern is desugared by the compiler into a call to this method */

library/src/scala/quoted/internal/Patterns.scala

@@ -0,0 +1,14 @@
+package scala.quoted.internal
+
+import scala.annotation.{Annotation, compileTimeOnly}
+
+/** Artifact of pickled type splices
+ *
+ *  During quote reification a quote `'{ ... F[t.Underlying] ... }` will be transformed into
+ *  `'{ @SplicedType type T$1 = t.Underlying ... F[T$1] ... }` to have a tree for `t.Underlying`.
+ *  This artifact is removed during quote unpickling.
+ *
+ *  See PickleQuotes.scala and PickledQuotes.scala
+ */
+@compileTimeOnly("Illegal reference to `scala.quoted.internal.SplicedType`")
+class SplicedType extends Annotation

library/src/scala/quoted/internal/SplicedType.scala

@@ -1,4 +1,4 @@
 ((qctx: scala.quoted.QuoteContext) ?=> {
-  val a: scala.quoted.Expr[scala.Int] = scala.internal.quoted.CompileTime.exprQuote[scala.Int](4).apply(using qctx)
+  val a: scala.quoted.Expr[scala.Int] = scala.quoted.internal.Expr.quote[scala.Int](4).apply(using qctx)
   ((qctx2: scala.quoted.QuoteContext) ?=> ((evidence$3: qctx2.Nested) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.QuoteContext, scala.quoted.Expr[scala.Int]]].apply(using qctx2)).apply(using qctx)
 })