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

@@ -1001,7 +1001,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):
@@ -1568,8 +1571,8 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
     type TypeRepr = dotc.core.Types.Type
 
     object TypeRepr extends TypeReprModule:
-      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
@@ -2640,7 +2643,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 Exception(
         s"""Expr cast exception: ${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.