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)
  }