WIP

Author: nicolasstucki

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2009,6 +2009,7 @@ class Typer extends Namer
             fun = ref(defn.InternalQuotedMatcher_unapplyR).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
             implicits =
               ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
+              Literal(Constant(typeBindings.nonEmpty)) ::
               implicitArgTree(defn.TastyReflectionType, tree.span) :: Nil,
             patterns = splicePat :: Nil,
             proto = pt)

library/src-3.x/scala/internal/quoted/Matcher.scala

@@ -27,10 +27,11 @@ object Matcher {
    *
    *  @param scrutineeExpr `Expr[_]` on which we are pattern matching
    *  @param patternExpr `Expr[_]` containing the pattern tree
+   *  @param hasTypeSplices `Boolean` notify if the pattern has type splices (if so we use a GADT context)
    *  @param reflection instance of the reflection API (implicitly provided by the macro)
    *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]``
    */
-  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] = {
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], hasTypeSplices: Boolean, reflection: Reflection): Option[Tup] = {
     // TODO improve performance
     import reflection.{Bind => BindPattern, _}
     import Matching._
@@ -335,18 +336,24 @@ object Matcher {
 
     implied for Env = Set.empty
 
-    {
-      // TODO only set GADT context when needed
-      implicit val ctx2 = reflection.kernel.Context_GADT_setFreshGADTBounds(rootContext)
-      val matchings = scrutineeExpr.unseal.underlyingArgument =#= patternExpr.unseal.underlyingArgument
-      val res = matchings.asOptionOfTuple.map { tup =>
-        Tuple.fromArray(tup.toArray.map { // TODO improve code
-          case x: SymBinding => reflection.kernel.Context_GADT_approximation(ctx2)(x.sym, true).seal
-          case x => x
-        })
+    val res = {
+      if (hasTypeSplices) {
+        implied for Context = reflection.kernel.Context_GADT_setFreshGADTBounds(rootContext)
+        val matchings = scrutineeExpr.unseal.underlyingArgument =#= patternExpr.unseal.underlyingArgument
+        // After matching and doing all subtype check, we have to aproximate all the type bindings
+        // that we have found and seal them in a quoted.Type
+        matchings.asOptionOfTuple.map { tup =>
+          Tuple.fromArray(tup.toArray.map { // TODO improve performace
+            case x: SymBinding => kernel.Context_GADT_approximation(the[Context])(x.sym, true).seal
+            case x => x
+          })
+        }
+      }
+      else {
+        scrutineeExpr.unseal.underlyingArgument =#= patternExpr.unseal.underlyingArgument
       }
-      res.asInstanceOf[Option[Tup]]
     }
+    res.asInstanceOf[Option[Tup]]
   }
 
   /** Result of matching a part of an expression */

tests/run-macros/quote-matcher-runtime/quoted_1.scala

@@ -10,7 +10,7 @@ object Macros {
   private def impl[A, B](a: Expr[A], b: Expr[B])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect.{Bind => _, _}
 
-    val res = scala.internal.quoted.Matcher.unapply[Tuple, Tuple](a)(b, reflect).map { tup =>
+    val res = scala.internal.quoted.Matcher.unapply[Tuple, Tuple](a)(b, true, reflect).map { tup =>
       tup.toArray.toList.map {
         case r: Expr[_] =>
           s"Expr(${r.unseal.show})"