Add scala.internal.quoted.Type.unapply

Author: nicolasstucki

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

@@ -654,6 +654,9 @@ 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 QuotedTypeClass: ClassSymbol = ctx.requiredClass("scala.quoted.Type")
     @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.splice)
 

library/src/scala/internal/quoted/Matcher.scala

@@ -41,7 +41,7 @@ private[quoted] object Matcher {
     }
 
     // TODO factor out common logic with `termMatch`
-    def typeTreeMatch(scrutineeTypeTree: Term, patternTypeTree: Term, hasTypeSplices: Boolean): Option[Tuple] = {
+    def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree, hasTypeSplices: Boolean): Option[Tuple] = {
       implicit val env: Env = Set.empty
       if (hasTypeSplices) {
         implicit val ctx: Context = internal.Context_GADT_setFreshGADTBounds(rootContext)

library/src/scala/internal/quoted/Type.scala

@@ -0,0 +1,26 @@
+package scala.internal.quoted
+
+import scala.quoted._
+
+object Type {
+
+  /** Pattern matches an the scrutineeType against the patternType and returns a tuple
+   *  with the matched holes if successful.
+   *
+   *  Holes:
+   *    - scala.internal.Quoted.patternHole[T]: hole that matches an expression `x` of type `Type[U]`
+   *                                            if `U <:< T` and returns `x` as part of the match.
+   *
+   *  @param scrutineeType `Type[_]` on which we are pattern matching
+   *  @param patternType `Type[_]` containing the pattern tree
+   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
+   *  @param qctx the current QuoteContext
+   *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Type[Ti]``
+   */
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeType: Type[_])(implicit patternType: Type[_],
+        hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
+    import qctx.tasty._
+    new Matcher.QuoteMatcher[qctx.type].typeTreeMatch(scrutineeType.unseal, patternType.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+  }
+
+}