Make quoted.Type fully contextual

Type is designed to be a contextual value. As such we should be able to use it without needing to name it and use it explicitly. Now that quoted pattterns provide the name of the type we can do this.

* Replaced methods `show`/`showAnsiColored` by equivalent methods in `object Type`
* Remove `unseal`, it can be replaced directly with `TypeRepr.of` in most cases

__Migration__

* `Type[T].show` -> `Type.show[T]`
* `Type[T].unseal.tpe` -> `TypeRepr.of[T]`
* `Type[T].unseal` -> `TypeTree.of[T]`

Author: nicolasstucki

community-build/community-projects/PPrint

@@ -1002,7 +1002,10 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
         case _ => None
     end TypeTreeTypeTest
 
-    object TypeTree extends TypeTreeModule
+    object TypeTree extends TypeTreeModule:
+      def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree =
+        tp.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree
+    end TypeTree
 
     object TypeTreeMethodsImpl extends TypeTreeMethods:
       extension (self: TypeTree):
@@ -1569,8 +1572,8 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
     type TypeRepr = dotc.core.Types.Type
 
     object TypeRepr extends TypeModule:
-      def of[T <: AnyKind](using qtype: scala.quoted.Type[T]): TypeRepr =
-        qtype.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree.tpe
+      def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeRepr =
+        tp.asInstanceOf[scala.internal.quoted.Type[TypeTree]].typeTree.tpe
       def typeConstructorOf(clazz: Class[?]): TypeRepr =
         if (clazz.isPrimitive)
           if (clazz == classOf[Boolean]) dotc.core.Symbols.defn.BooleanType
@@ -2639,7 +2642,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
     treeMatch(scrutinee.unseal(using this), pattern.unseal(using this))
 
   def typeMatch(scrutinee: scala.quoted.Type[?], pattern: scala.quoted.Type[?]): Option[Tuple] =
-    treeMatch(scrutinee.unseal(using this), pattern.unseal(using this))
+    treeMatch(reflect.TypeTree.of(using scrutinee), reflect.TypeTree.of(using pattern))
 
   private def treeMatch(scrutinee: reflect.Tree, pattern: reflect.Tree): Option[Tuple] = {
     import reflect._

community-build/community-projects/munit

@@ -25,7 +25,7 @@ abstract class Expr[+T] private[scala] {
 
   /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */
   def isExprOf[X](using tp: scala.quoted.Type[X])(using qctx: QuoteContext): Boolean =
-    this.unseal.tpe <:< tp.unseal.tpe
+    this.unseal.tpe <:< qctx.reflect.TypeRepr.of[X]
 
   /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */
   def asExprOf[X](using tp: scala.quoted.Type[X])(using qctx: QuoteContext): scala.quoted.Expr[X] = {
@@ -35,7 +35,7 @@ abstract class Expr[+T] private[scala] {
       throw new tasty.reflect.ExprCastError(
         s"""Expr: ${this.show}
            |of type: ${this.unseal.tpe.show}
-           |did not conform to type: ${tp.unseal.tpe.show}
+           |did not conform to type: ${qctx.reflect.TypeRepr.of[X].show}
            |""".stripMargin
       )
   }
@@ -189,7 +189,7 @@ object Expr {
    */
   def summon[T](using tpe: Type[T])(using qctx: QuoteContext): Option[Expr[T]] = {
     import qctx.reflect._
-    Implicits.search(tpe.unseal.tpe) match {
+    Implicits.search(TypeRepr.of[T]) match {
       case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
       case isf: ImplicitSearchFailure => None
     }

community-build/community-projects/scalatest

@@ -144,7 +144,7 @@ trait ExprMap:
         trees mapConserve (transformTypeCaseDef(_))
 
     }
-    new MapChildren().transformTermChildren(e.unseal, tpe.unseal.tpe).asExprOf[T]
+    new MapChildren().transformTermChildren(e.unseal, TypeRepr.of[T]).asExprOf[T]
   }
 
 end ExprMap

community-build/community-projects/upickle

@@ -3,27 +3,24 @@ package scala.quoted
 import scala.annotation.compileTimeOnly
 
 /** Quoted type (or kind) `T` */
-abstract class Type[T <: AnyKind] private[scala] {
-
+abstract class Type[T <: AnyKind] private[scala]:
   /** The type represented `Type` */
   type Underlying = T
+end Type
+
+/** Some basic type tags, currently incomplete */
+object Type:
 
   /** Show a source code like representation of this type without syntax highlight */
-  def show(using qctx: QuoteContext): String = this.unseal.show
+  def show[T](using tp: Type[T])(using qctx: QuoteContext): String =
+    qctx.reflect.TypeTree.of[T].show
 
   /** Shows the tree as fully typed source code colored with ANSI */
-  def showAnsiColored(using qctx: QuoteContext): String = this.unseal.showAnsiColored
-
-  /** View this expression `quoted.Type[T]` as a `TypeTree` */
-  def unseal(using qctx: QuoteContext): qctx.reflect.TypeTree
-
-}
-
-/** Some basic type tags, currently incomplete */
-object Type {
+  def showAnsiColored[T](using tp: Type[T])(using qctx: QuoteContext): String =
+    qctx.reflect.TypeTree.of[T].showAnsiColored
 
   /** Return a quoted.Type with the given type */
   @compileTimeOnly("Reference to `scala.quoted.Type.apply` was not handled by ReifyQuotes")
   given apply[T <: AnyKind] as (QuoteContext ?=> Type[T]) = ???
 
-}
+end Type

community-build/community-projects/utest

@@ -17,7 +17,7 @@ object Varargs {
    */
   def apply[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
     import qctx.reflect._
-    Repeated(xs.map[Term](_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
+    Repeated(xs.map[Term](_.unseal).toList, TypeTree.of[T]).seal.asInstanceOf[Expr[Seq[T]]]
   }
 
   /** Matches a literal sequence of expressions and return a sequence of expressions.

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

@@ -5,8 +5,6 @@ import scala.annotation.compileTimeOnly
 abstract class Type[T <: AnyKind] private[scala]:
   type Underlying = T
 
-  def unseal(using qctx: QuoteContext): qctx.reflect.TypeTree
-
 object Type:
   @compileTimeOnly("Reference to `scala.quoted.Type.apply` was not handled by ReifyQuotes")
   given apply[T <: AnyKind] as (QuoteContext ?=> Type[T]) = ???

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

@@ -1158,7 +1158,10 @@ trait Reflection { reflection =>
 
   val TypeTree: TypeTreeModule
 
-  trait TypeTreeModule { this: TypeTree.type => }
+  trait TypeTreeModule { this: TypeTree.type =>
+    /** Returns the tree of type or kind (TypeTree) of T */
+    def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree
+  }
 
   given TypeTreeMethods as TypeTreeMethods = TypeTreeMethodsImpl
   protected val TypeTreeMethodsImpl: TypeTreeMethods
@@ -1741,7 +1744,7 @@ trait Reflection { reflection =>
 
   trait TypeModule { this: TypeRepr.type =>
     /** Returns the type or kind (TypeRepr) of T */
-    def of[T <: AnyKind](using qtype: scala.quoted.Type[T]): TypeRepr
+    def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeRepr
 
     /** Returns the type constructor of the runtime (erased) class */
     def typeConstructorOf(clazz: Class[?]): TypeRepr

library/src-bootstrapped/scala/quoted/ExprMap.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext): Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search((Type[A]).unseal.tpe) match {
+  Implicits.search(TypeRepr.of[A]) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

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

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl (using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search((Type[A]).unseal.tpe) match {
+  Implicits.search(TypeRepr.of[A]) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

library/src-bootstrapped/scala/quoted/Varargs.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search((Type[A]).unseal.tpe) match {
+  Implicits.search(TypeRepr.of[A]) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

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

@@ -14,7 +14,7 @@ abstract class Test {
     {
       val t: Test = this
       import t.given
-      println(summon[Type[t.T]].show)
+      println(Type.show[t.T])
       // val r = '{Option.empty[t.T]} // access to value t from wrong staging level
       val r2 = '{Option.empty[t.T.Underlying]} // works
     }

library/src/scala/tasty/Reflection.scala

@@ -4,7 +4,6 @@ object Test {
   def staged[T](using qctx: QuoteContext) = {
     import qctx.reflect._
     given typeT as Type[T] // error
-    val tTypeTree = typeT.unseal
     val tt = TypeRepr.of[T]
     '{ "in staged" }
   }

tests/neg-macros/delegate-match-1/Macro_1.scala

@@ -14,7 +14,7 @@ abstract class Test {
     {
       val t: Test = this
       import t.given
-      println(summon[Type[t.T]].show)
+      println(Type.show[t.T])
       // val r = '{Option.empty[t.T]} // access to value t from wrong staging level
       val r2 = '{Option.empty[t.T.Underlying]}
     }

tests/neg-macros/delegate-match-2/Macro_1.scala

@@ -11,7 +11,7 @@ object Foo {
         packageToName(sym.owner)
     }
 
-    val sym = implicitly[Type[T]].unseal.symbol
+    val sym = TypeRepr.of[T].typeSymbol
     if (!sym.isNoSymbol) {
       sym.tree match {
         case c: ClassDef =>

tests/neg-macros/delegate-match-3/Macro_1.scala

@@ -26,9 +26,9 @@ object Async {
       case Inlined(_,_,Block(_,Apply(TypeApply(Select(q,n),tparams),List(param)))) =>
         param.tpe match
           case AppliedType(tp,tparams1) =>
-            val fType = Type[F]
+            val fType = TypeRepr.of[F]
             val ptp = tparams1.tail.head
-            val ptpTree = Inferred(fType.unseal.tpe.appliedTo(ptp))
+            val ptpTree = Inferred(fType.appliedTo(ptp))
             '{ println(${Expr(ptpTree.show)}) }
 
 }

tests/neg-macros/i7048e.scala

@@ -8,11 +8,11 @@ inline def shift : Unit = ${ shiftTerm }
 def shiftTerm(using QuoteContext): Expr[Unit] = {
   import qctx.reflect._
   val nTree = '{ ??? : CB[Int] }.unseal
-  val tp1 = Type[CB[Int]].unseal.tpe
-  val tp2 = Type[([X] =>> CB[X])[Int]].unseal.tpe
+  val tp1 = TypeRepr.of[CB[Int]]
+  val tp2 = TypeRepr.of[([X] =>> CB[X])[Int]]
   val ta = Type[[X] =>> CB[X]]
-  val tp3 = Type[ta.Underlying[Int]].unseal.tpe
-  val tp4 = Type[CB].unseal.tpe.appliedTo(TypeRepr.of[Int])
+  val tp3 = TypeRepr.of(using Type[ta.Underlying[Int]])
+  val tp4 = TypeRepr.of[CB].appliedTo(TypeRepr.of[Int])
   assert(nTree.tpe <:< tp1)
   assert(nTree.tpe <:< tp2)
   assert(nTree.tpe <:< tp3)

tests/neg-macros/i7919.scala

@@ -45,7 +45,7 @@ object X:
           case lt@Lambda(params, body) =>
             val paramTypes = params.map(_.tpt.tpe)
             val paramNames = params.map(_.name)
-            val mt = MethodType(paramNames)(_ => paramTypes, _ => Type[CB].unseal.tpe.appliedTo(body.tpe.widen) )
+            val mt = MethodType(paramNames)(_ => paramTypes, _ => TypeRepr.of[CB].appliedTo(body.tpe.widen) )
             val r = Lambda(mt, args => changeArgs(params,args,transform(body)) )
             r
           case _ =>

tests/pos-macros/i7048e.scala

@@ -1,33 +1,33 @@
 import scala.quoted._
 
 
-inline def isFunctionType[T]: Boolean = ${ isFunctionTypeImpl(Type[T]) }
+inline def isFunctionType[T]: Boolean = ${ isFunctionTypeImpl[T] }
 
-def isFunctionTypeImpl[T](tp: Type[T])(using qctx: QuoteContext) : Expr[Boolean] = {
+def isFunctionTypeImpl[T: Type](using qctx: QuoteContext) : Expr[Boolean] = {
   import qctx.reflect._
-  Expr(tp.unseal.tpe.isFunctionType)
+  Expr(TypeRepr.of[T].isFunctionType)
 }
 
 
-inline def isContextFunctionType[T]: Boolean = ${ isContextFunctionTypeImpl(Type[T]) }
+inline def isContextFunctionType[T]: Boolean = ${ isContextFunctionTypeImpl[T] }
 
-def isContextFunctionTypeImpl[T](tp: Type[T])(using qctx: QuoteContext) : Expr[Boolean] = {
+def isContextFunctionTypeImpl[T: Type](using qctx: QuoteContext) : Expr[Boolean] = {
   import qctx.reflect._
-  Expr(tp.unseal.tpe.isContextFunctionType)
+  Expr(TypeRepr.of[T].isContextFunctionType)
 }
 
 
-inline def isErasedFunctionType[T]: Boolean = ${ isErasedFunctionTypeImpl(Type[T]) }
+inline def isErasedFunctionType[T]: Boolean = ${ isErasedFunctionTypeImpl[T] }
 
-def isErasedFunctionTypeImpl[T](tp: Type[T])(using qctx: QuoteContext) : Expr[Boolean] = {
+def isErasedFunctionTypeImpl[T: Type](using qctx: QuoteContext) : Expr[Boolean] = {
   import qctx.reflect._
-  Expr(tp.unseal.tpe.isErasedFunctionType)
+  Expr(TypeRepr.of[T].isErasedFunctionType)
 }
 
-inline def isDependentFunctionType[T]: Boolean = ${ isDependentFunctionTypeImpl(Type[T]) }
+inline def isDependentFunctionType[T]: Boolean = ${ isDependentFunctionTypeImpl[T] }
 
-def isDependentFunctionTypeImpl[T](tp: Type[T])(using qctx: QuoteContext) : Expr[Boolean] = {
+def isDependentFunctionTypeImpl[T: Type](using qctx: QuoteContext) : Expr[Boolean] = {
   import qctx.reflect._
-  Expr(tp.unseal.tpe.isDependentFunctionType)
+  Expr(TypeRepr.of[T].isDependentFunctionType)
 }
 

tests/pos-macros/i8521/Macro_1.scala

@@ -59,17 +59,17 @@ class CheckedTransformation(transform: PartialFunction[Expr[Any], Expr[Any]]) ex
   def apply[T: Type](e: Expr[T])(using QuoteContext): Expr[T] = {
     transform.applyOrElse(e, identity) match {
       case '{ $e2: T } => e2
-      case '{ $e2: $T } =>
+      case '{ $e2: $T2 } =>
         throw new Exception(
           s"""Transformed
             |${e.show}
             |into
             |${e2.show}
             |
             |Expected type to be
-            |${summon[Type[T]].show}
+            |${Type.show[T]}
             |but was
-            |${Type[T].show}
+            |${Type.show[T2]}
           """.stripMargin)
     }
   }

tests/pos-macros/i9251/Macro_1.scala

@@ -47,9 +47,9 @@ private class Rewriter(preTransform: Expr[Any] => Expr[Any], postTransform: Expr
            |${x.show}
            |
            |Expected type to be
-           |${summon[Type[T]].show}
+           |${Type.show[T]}
            |but was
-           |${Type[t].show}
+           |${Type.show[t]}
          """.stripMargin)
     }
   }