Merge pull request #7404 from dotty-staging/disambiguate-quoted-type-and-reflection-type

Disambiguate quoted and tasty Type

Author: biboudis

community-build/community-projects/scalatest

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

community-build/community-projects/shapeless

@@ -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.QuotedTypeClass))
+      val baseType = tree.tpe.baseType(defn.QuotedExprClass).orElse(tree.tpe.baseType(defn.QuotedTypeTagClass))
       val argType =
         if (baseType != NoType) baseType.argTypesHi.head
         else defn.NothingType

community-build/community-projects/sourcecode

@@ -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 InternalQuotedTypeModule: Symbol = ctx.requiredModule("scala.internal.quoted.Type")
-    @tu lazy val InternalQuotedType_unapply: Symbol = InternalQuotedTypeModule.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 QuotedTypeClass: ClassSymbol = ctx.requiredClass("scala.quoted.Type")
-    @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.splice)
+  @tu lazy val QuotedTypeTagClass: ClassSymbol = ctx.requiredClass("scala.quoted.TypeTag")
+    @tu lazy val QuotedTypeTag_splice: Symbol = QuotedTypeTagClass.requiredType(tpnme.splice)
 
-  @tu lazy val QuotedTypeModule: Symbol = QuotedTypeClass.companionModule
+  @tu lazy val QuotedTypeTagModule: Symbol = QuotedTypeTagClass.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/ast/Desugar.scala

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

compiler/src/dotty/tools/dotc/ast/tpd.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] => quoted.Type[?]](reifiedArgs)
+        val quotedType = splice.asInstanceOf[Seq[Any] => scala.quoted.TypeTag[?]](reifiedArgs)
         PickledQuotes.quotedTypeToTree(quotedType)
       }
       else {

compiler/src/dotty/tools/dotc/core/Definitions.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.QuotedType_splice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")
+        if (!printDebug && tree.hasType && tree.symbol == defn.QuotedTypeTag_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.Type in quote patterns (not pickled)
+        keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.TypeTag in quote patterns (not pickled)
         changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }
       case Alternative(trees) =>
         changePrec(OrPrec) { toText(trees, " | ") }

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

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