Revert "Disambiguate quoted and tasty Type"

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -292,7 +292,7 @@ object desugar {
     }
   }
 
-  /** Transforms a definition with a name starting with a `$` in a quoted pattern into a `scala.quoted.binding.Binding` splice.
+  /** Transforms a definition with a name starting with a `$` in a quoted pattern into a `quoted.binding.Binding` splice.
    *
    *  The desugaring consists in adding the `@patternBindHole` annotation. This annotation is used during typing to perform the full transformation.
    *

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1207,7 +1207,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** An extractor for typed splices */
   object Splice {
     def apply(tree: Tree)(implicit ctx: Context): Tree = {
-      val baseType = tree.tpe.baseType(defn.QuotedExprClass).orElse(tree.tpe.baseType(defn.QuotedTypeTagClass))
+      val baseType = tree.tpe.baseType(defn.QuotedExprClass).orElse(tree.tpe.baseType(defn.QuotedTypeClass))
       val argType =
         if (baseType != NoType) baseType.argTypesHi.head
         else defn.NothingType

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

@@ -659,13 +659,13 @@ class Definitions {
   @tu lazy val InternalQuotedExprModule: Symbol = ctx.requiredModule("scala.internal.quoted.Expr")
     @tu lazy val InternalQuotedExpr_unapply: Symbol = InternalQuotedExprModule.requiredMethod(nme.unapply)
 
-  @tu lazy val InternalQuotedTypeTagModule: Symbol = ctx.requiredModule("scala.internal.quoted.TypeTag")
-    @tu lazy val InternalQuotedTypeTag_unapply: Symbol = InternalQuotedTypeTagModule.requiredMethod(nme.unapply)
+  @tu lazy val InternalQuotedTypeModule: Symbol = ctx.requiredModule("scala.internal.quoted.Type")
+    @tu lazy val InternalQuotedType_unapply: Symbol = InternalQuotedTypeModule.requiredMethod(nme.unapply)
 
-  @tu lazy val QuotedTypeTagClass: ClassSymbol = ctx.requiredClass("scala.quoted.TypeTag")
-    @tu lazy val QuotedTypeTag_splice: Symbol = QuotedTypeTagClass.requiredType(tpnme.splice)
+  @tu lazy val QuotedTypeClass: ClassSymbol = ctx.requiredClass("scala.quoted.Type")
+    @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.splice)
 
-  @tu lazy val QuotedTypeTagModule: Symbol = QuotedTypeTagClass.companionModule
+  @tu lazy val QuotedTypeModule: Symbol = QuotedTypeClass.companionModule
 
   @tu lazy val QuotedMatchingSymClass: ClassSymbol = ctx.requiredClass("scala.quoted.matching.Sym")
   @tu lazy val TastyReflectionClass: ClassSymbol = ctx.requiredClass("scala.tasty.Reflection")

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

@@ -35,14 +35,14 @@ object PickledQuotes {
     }
 
   /** Transform the expression into its fully spliced Tree */
-  def quotedExprToTree[T](expr: scala.quoted.Expr[T])(implicit ctx: Context): Tree = {
+  def quotedExprToTree[T](expr: quoted.Expr[T])(implicit ctx: Context): Tree = {
     val expr1 = expr.asInstanceOf[TastyTreeExpr[Tree]]
     QuoteContext.checkScopeId(expr1.scopeId)
     healOwner(expr1.tree)
   }
 
   /** Transform the expression into its fully spliced TypeTree */
-  def quotedTypeToTree(tpe: scala.quoted.TypeTag[?])(implicit ctx: Context): Tree = {
+  def quotedTypeToTree(tpe: quoted.Type[?])(implicit ctx: Context): Tree = {
     val tpe1 = tpe.asInstanceOf[TreeType[Tree]]
     QuoteContext.checkScopeId(tpe1.scopeId)
     healOwner(tpe1.typeTree)

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

@@ -1275,7 +1275,7 @@ class TreeUnpickler(reader: TastyReader,
         else new TreeType(arg, QuoteContext.scopeId)
       val reifiedArgs = args.map(wrap)
       val filled = if (isType) {
-        val quotedType = splice.asInstanceOf[Seq[Any] => scala.quoted.TypeTag[?]](reifiedArgs)
+        val quotedType = splice.asInstanceOf[Seq[Any] => quoted.Type[?]](reifiedArgs)
         PickledQuotes.quotedTypeToTree(quotedType)
       }
       else {

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -374,7 +374,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>
-        if (!printDebug && tree.hasType && tree.symbol == defn.QuotedTypeTag_splice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")
+        if (!printDebug && tree.hasType && tree.symbol == defn.QuotedType_splice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")
         else if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
         else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided (name != nme.CONSTRUCTOR || printDebug))
       case tree: This =>
@@ -499,7 +499,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (lo eq hi) optText(lo)(" = " ~ _)
         else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _)
       case Bind(name, body) =>
-        keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.TypeTag in quote patterns (not pickled)
+        keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
         changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }
       case Alternative(trees) =>
         changePrec(OrPrec) { toText(trees, " | ") }

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

@@ -18,8 +18,6 @@ import dotty.tools.dotc.util.{SourceFile, SourcePosition, Spans}
 import scala.runtime.quoted.Unpickler
 import scala.tasty.reflect.CompilerInterface
 
-import scala.quoted.{Expr, TypeTag}
-
 class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extends CompilerInterface {
   import tpd._
 
@@ -34,10 +32,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   // QUOTE UNPICKLING
   //
 
-  def unpickleExpr(repr: Unpickler.PickledQuote, args: Unpickler.PickledExprArgs): Expr[?] =
+  def unpickleExpr(repr: Unpickler.PickledQuote, args: Unpickler.PickledExprArgs): scala.quoted.Expr[?] =
     new scala.internal.quoted.TastyTreeExpr(PickledQuotes.unpickleExpr(repr, args), compilerId)
 
-  def unpickleType(repr: Unpickler.PickledQuote, args: Unpickler.PickledTypeArgs): TypeTag[?] =
+  def unpickleType(repr: Unpickler.PickledQuote, args: Unpickler.PickledTypeArgs): scala.quoted.Type[?] =
     new scala.internal.quoted.TreeType(PickledQuotes.unpickleType(repr, args), compilerId)
 
   //
@@ -1582,16 +1580,16 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   // QUOTED SEAL/UNSEAL
   //
 
-  /** View this expression `scala.quoted.Expr[?]` as a `Term` */
-  def QuotedExpr_unseal(self: Expr[?])(given Context): Term =
+  /** View this expression `quoted.Expr[?]` as a `Term` */
+  def QuotedExpr_unseal(self: scala.quoted.Expr[?])(given Context): Term =
     PickledQuotes.quotedExprToTree(self)
 
-  /** View this expression `scala.quoted.TypeTag[?]` as a `TypeTree` */
-  def QuotedType_unseal(self: TypeTag[?])(given Context): TypeTree =
+  /** View this expression `quoted.Type[?]` as a `TypeTree` */
+  def QuotedType_unseal(self: scala.quoted.Type[?])(given Context): TypeTree =
     PickledQuotes.quotedTypeToTree(self)
 
-  /** Convert `Term` to an `scala.quoted.Expr[Any]`  */
-  def QuotedExpr_seal(self: Term)(given ctx: Context): Expr[Any] = {
+  /** Convert `Term` to an `quoted.Expr[Any]`  */
+  def QuotedExpr_seal(self: Term)(given ctx: Context): scala.quoted.Expr[Any] = {
     def etaExpand(term: Term): Term = term.tpe.widen match {
       case mtpe: Types.MethodType if !mtpe.isParamDependent =>
         val closureResType = mtpe.resType match {
@@ -1606,12 +1604,12 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     new scala.internal.quoted.TastyTreeExpr(etaExpand(self), compilerId)
   }
 
-  /** Checked cast to a `scala.quoted.Expr[U]` */
-  def QuotedExpr_cast[U](self: Expr[?])(given tp: TypeTag[U], ctx: Context): Expr[U] = {
+  /** Checked cast to a `quoted.Expr[U]` */
+  def QuotedExpr_cast[U](self: scala.quoted.Expr[?])(given tp: scala.quoted.Type[U], ctx: Context): scala.quoted.Expr[U] = {
     val tree = QuotedExpr_unseal(self)
-    val expectedType = QuotedType_unseal(tp.asInstanceOf[TypeTag[U]]).tpe
+    val expectedType = QuotedType_unseal(tp).tpe
     if (tree.tpe <:< expectedType)
-      self.asInstanceOf[Expr[U]]
+      self.asInstanceOf[scala.quoted.Expr[U]]
     else
       throw new scala.tasty.reflect.ExprCastError(
         s"""Expr: ${tree.show}
@@ -1620,8 +1618,8 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       )
   }
 
-  /** Convert `Type` to an `scala.quoted.TypeTag[?]` */
-  def QuotedType_seal(self: Type)(given ctx: Context): TypeTag[?] = {
+  /** 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), compilerId)
   }

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

@@ -82,7 +82,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  that are phase-incorrect can still be healed as follows:
    *
    *  If `T` is a reference to a type at the wrong level, try to heal it by replacing it with
-   *  `${implicitly[scala.quoted.TypeTag[T]]}`.
+   *  `${implicitly[quoted.Type[T]]}`.
    */
   protected def checkLevel(tree: Tree)(implicit ctx: Context): Tree = {
     def checkTp(tp: Type): Type = checkType(tree.sourcePos).apply(tp)
@@ -123,8 +123,8 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
           if (tp.isTerm)
             ctx.error(i"splice outside quotes", pos)
           tp
-        case tp: TypeRef if tp.symbol == defn.QuotedTypeTagClass.typeParams.head =>
-          // Adapt direct references to the type of the type parameter T of a scala.quoted.TypeTag[T].
+        case tp: TypeRef if tp.symbol == defn.QuotedTypeClass.typeParams.head =>
+          // Adapt direct references to the type of the type parameter T of a quoted.Type[T].
           // Replace it with a properly encoded type splice. This is the normal for expected for type splices.
           tp.prefix.select(tpnme.splice)
         case tp: NamedType =>
@@ -147,7 +147,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  by which we refer to `sym`. If it is an inconsistent type try construct a healed type for it.
    *
    *  @return `None` if the phase is correct or cannot be healed
-   *          `Some(tree)` with the `tree` of the healed type tree for `${implicitly[scala.quoted.TypeTag[T]]}`
+   *          `Some(tree)` with the `tree` of the healed type tree for `${implicitly[quoted.Type[T]]}`
    */
   private def checkSymLevel(sym: Symbol, tp: Type, pos: SourcePosition)(implicit ctx: Context): Option[Tree] = {
     /** Is a reference to a class but not `this.type` */
@@ -196,7 +196,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
           None
         }
         else {
-          val reqType = defn.QuotedTypeTagClass.typeRef.appliedTo(tp)
+          val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
           val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
           tag.tpe match {
             case _: TermRef =>

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

@@ -229,15 +229,15 @@ class ReifyQuotes extends MacroTransform {
           if (isType) ref(defn.Unpickler_unpickleType).appliedToType(originalTp)
           else ref(defn.Unpickler_unpickleExpr).appliedToType(originalTp.widen)
         val spliceResType =
-          if (isType) defn.QuotedTypeTagClass.typeRef.appliedTo(WildcardType)
-          else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)) | defn.QuotedTypeTagClass.typeRef.appliedTo(WildcardType)
+          if (isType) defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)
+          else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)) | defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)
         val pickledQuoteStrings = liftList(PickledQuotes.pickleQuote(body).map(x => Literal(Constant(x))), defn.StringType)
         val splicesList = liftList(splices, defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), spliceResType))
         meth.appliedTo(pickledQuoteStrings, splicesList)
       }
 
       if (isType) {
-        def tag(tagName: String) = ref(defn.QuotedTypeTagModule).select(tagName.toTermName).appliedTo(qctx)
+        def tag(tagName: String) = ref(defn.QuotedTypeModule).select(tagName.toTermName).appliedTo(qctx)
         if (splices.isEmpty && body.symbol.isPrimitiveValueClass) tag(s"${body.symbol.name}Tag")
         else pickleAsTasty().select(nme.apply).appliedTo(qctx)
       }
@@ -311,7 +311,7 @@ class ReifyQuotes extends MacroTransform {
                 }
                 assert(tpw.isInstanceOf[ValueType])
                 val argTpe =
-                  if (tree.isType) defn.QuotedTypeTagClass.typeRef.appliedTo(tpw)
+                  if (tree.isType) defn.QuotedTypeClass.typeRef.appliedTo(tpw)
                   else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpw))
                 val selectArg = arg.select(nme.apply).appliedTo(Literal(Constant(i))).cast(argTpe)
                 val capturedArg = SyntheticValDef(UniqueName.fresh(tree.symbol.name.toTermName).toTermName, selectArg)

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

@@ -63,9 +63,9 @@ class Staging extends MacroTransform {
       }
 
       tree.tpe match {
-        case tpe @ TypeRef(prefix, _) if tpe.typeSymbol eq defn.QuotedTypeTag_splice =>
+        case tpe @ TypeRef(prefix, _) if tpe.typeSymbol eq defn.QuotedType_splice =>
           // Type splices must have a know term ref, usually to an implicit argument
-          // This is mostly intended to catch `scala.quoted.TypeTag[T]#splice` types which should just be `T`
+          // This is mostly intended to catch `quoted.Type[T]#splice` types which should just be `T`
           assert(prefix.isInstanceOf[TermRef] || prefix.isInstanceOf[ThisType], prefix)
         case _ =>
           // OK

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

@@ -213,5 +213,5 @@ class SymUtils(val self: Symbol) extends AnyVal {
 
   /** Is symbol a splice operation? */
   def isSplice(implicit ctx: Context): Boolean =
-    self == defn.InternalQuoted_exprSplice || self == defn.QuotedTypeTag_splice
+    self == defn.InternalQuoted_exprSplice || self == defn.QuotedType_splice
 }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -705,7 +705,7 @@ trait Implicits { self: Typer =>
         EmptyTree
     }
 
-  /** Synthesize the tree for `'[T]` for an implicit `scala.quoted.TypeTag[T]`.
+  /** Synthesize the tree for `'[T]` for an implicit `scala.quoted.Type[T]`.
    *  `T` is deeply dealiased to avoid references to local type aliases.
    */
   lazy val synthesizedTypeTag: SpecialHandler = {
@@ -1076,7 +1076,7 @@ trait Implicits { self: Typer =>
     if (mySpecialHandlers == null)
       mySpecialHandlers = List(
         defn.ClassTagClass        -> synthesizedClassTag,
-        defn.QuotedTypeTagClass   -> synthesizedTypeTag,
+        defn.QuotedTypeClass      -> synthesizedTypeTag,
         defn.QuoteContextClass    -> synthesizedQuoteContext,
         defn.EqlClass             -> synthesizedEq,
         defn.TupledFunctionClass  -> synthesizedTupleFunction,

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -32,7 +32,7 @@ trait QuotesAndSplices {
 
   import tpd._
 
-  /** Translate `'{ t }` into `scala.quoted.Expr.apply(t)` and `'[T]` into `scala.quoted.TypeTag.apply[T]`
+  /** Translate `'{ t }` into `scala.quoted.Expr.apply(t)` and `'[T]` into `scala.quoted.Type.apply[T]`
    *  while tracking the quotation level in the context.
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = {
@@ -113,7 +113,7 @@ trait QuotesAndSplices {
         }
         val typeSym = ctx.newSymbol(spliceOwner(ctx), name, EmptyFlags, TypeBounds.empty, NoSymbol, tree.expr.span)
         typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(tree.expr.span)))
-        val pat = typedPattern(tree.expr, defn.QuotedTypeTagClass.typeRef.appliedTo(typeSym.typeRef))(
+        val pat = typedPattern(tree.expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
             spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
         pat.select(tpnme.splice)
       }
@@ -190,7 +190,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case Select(pat, _) if tree.symbol == defn.QuotedTypeTag_splice =>
+        case Select(pat, _) if tree.symbol == defn.QuotedType_splice =>
           val sym = tree.tpe.dealias.typeSymbol.asType
           val tdef = TypeDef(sym).withSpan(sym.span)
           freshTypeBindingsBuff += transformTypeBindingTypeDef(tdef, freshTypePatBuf)
@@ -232,7 +232,7 @@ trait QuotesAndSplices {
         if (variance == -1)
           tdef.symbol.addAnnotation(Annotation(New(ref(defn.InternalQuoted_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
         val bindingType = getBinding(tdef.symbol).symbol.typeRef
-        val bindingTypeTpe = AppliedType(defn.QuotedTypeTagClass.typeRef, bindingType :: Nil)
+        val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
         assert(tdef.name.startsWith("$"))
         val bindName = tdef.name.toString.stripPrefix("$").toTermName
         val sym = ctx0.newPatternBoundSymbol(bindName, bindingTypeTpe, tdef.span, flags = ImplicitTerm)
@@ -254,7 +254,7 @@ trait QuotesAndSplices {
         val isFreshTypeBindings = freshTypeBindings.map(_.symbol).toSet
         val typeMap = new TypeMap() {
           def apply(tp: Type): Type = tp match {
-            case tp: TypeRef if tp.typeSymbol == defn.QuotedTypeTag_splice =>
+            case tp: TypeRef if tp.typeSymbol == defn.QuotedType_splice =>
               val tp1 = tp.dealias
               if (isFreshTypeBindings(tp1.typeSymbol)) tp1
               else tp
@@ -331,7 +331,7 @@ trait QuotesAndSplices {
     class ReplaceBindings extends TypeMap() {
       override def apply(tp: Type): Type = tp match {
         case tp: TypeRef =>
-          val tp1 = if (tp.typeSymbol == defn.QuotedTypeTag_splice) tp.dealias else tp
+          val tp1 = if (tp.typeSymbol == defn.QuotedType_splice) tp.dealias else tp
           typeBindings.get(tp1.typeSymbol).fold(tp)(_.symbol.typeRef)
         case tp => mapOver(tp)
       }
@@ -364,8 +364,8 @@ trait QuotesAndSplices {
 
     val splicePat = typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
 
-    val unapplySym = if (tree.quoted.isTerm) defn.InternalQuotedExpr_unapply else defn.InternalQuotedTypeTag_unapply
-    val quoteClass = if (tree.quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeTagClass
+    val unapplySym = if (tree.quoted.isTerm) defn.InternalQuotedExpr_unapply else defn.InternalQuotedType_unapply
+    val quoteClass = if (tree.quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
       if (tree.quoted.isTerm) ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(defn.AnyType).appliedTo(shape).select(nme.apply).appliedTo(qctx)
       else ref(defn.InternalQuoted_typeQuote.termRef).appliedToTypeTrees(shape :: Nil)

compiler/test-resources/pending/repl/i4539

@@ -1,7 +1,7 @@
 scala> val a = '[Int]
-val a: quoted.TypeTag[Int] = TypeTag(Int)
+val a: quoted.Type[Int] = Type(Int)
 scala> '[Int]
-val res0: quoted.TypeTag[Int] = TypeTag(Int)
+val res0: quoted.Type[Int] = Type(Int)
 scala> '[Int]; '[Int]
-val res1: quoted.TypeTag[Int] = TypeTag(Int)
-val res2: quoted.TypeTag[Int] = TypeTag(Int)
+val res1: quoted.Type[Int] = Type(Int)
+val res2: quoted.Type[Int] = Type(Int)