Add regression test

The issue was that an uninstantiated type variable escaped the implicit
search and was then affected by the quote pattern match.

Fixes #15779
Fixes #16636

Author: nicolasstucki

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2398,6 +2398,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         import tpd.TreeOps
         val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span)
         // Make sure that we do not have any uninstantiated type variables.
+        // See tests/pos-macros/i16636.
         // See tests/pos-macros/exprSummonWithTypeVar with -Xcheck-macros.
         implicitTree.foreachSubTree(tree => dotc.typer.Inferencing.fullyDefinedType(tree.tpe, "", tree))
         implicitTree

tests/pos-macros/i15779/Macro_1.scala

@@ -0,0 +1,30 @@
+import scala.quoted._
+import scala.deriving.Mirror
+
+trait Encoder[-A]
+
+trait PrimitiveEncoder[A] extends Encoder[A]
+
+given intOpt: PrimitiveEncoder[Option[Int]] with {}
+
+given primitiveNotNull[T](using e: Encoder[Option[T]]): PrimitiveEncoder[T] =
+  new PrimitiveEncoder[T] {}
+
+transparent inline given fromMirror[A]: Any = ${ fromMirrorImpl[A] }
+
+def fromMirrorImpl[A : Type](using q: Quotes): Expr[Any] =
+  Expr.summon[Mirror.Of[A]].get match
+    case '{ ${mirror}: Mirror.ProductOf[A] { type MirroredElemTypes = elementTypes } } =>
+      val encoder = Type.of[elementTypes] match
+        case '[tpe *: EmptyTuple] =>
+          Expr.summon[Encoder[tpe]].get
+
+      encoder match
+        case '{ ${encoder}: Encoder[tpe] } => // ok
+        case _ => ???
+
+      encoder match
+        case '{ ${encoder}: Encoder[tpe] } => // ok
+        case _ => ???
+
+      encoder

tests/pos-macros/i15779/Test_2.scala

@@ -0,0 +1,3 @@
+case class JustInt(i: Int)
+
+val x = fromMirror[JustInt]

tests/pos-macros/i16636/Macro_1.scala

@@ -0,0 +1,30 @@
+import scala.quoted.*
+
+trait ReproTransformer[A, B] {
+  def transform(from: A): B
+}
+
+object ReproTransformer {
+  final class Identity[A, B >: A] extends ReproTransformer[A, B] {
+    def transform(from: A): B = from
+  }
+
+  given identity[A, B >: A]: Identity[A, B] = Identity[A, B]
+
+  inline def getTransformer[A, B]: ReproTransformer[A, B] = ${ getTransformerMacro[A, B] }
+
+  def getTransformerMacro[A, B](using quotes: Quotes, A: Type[A], B: Type[B]) = {
+    import quotes.reflect.*
+
+    val transformer = (A -> B) match {
+      case '[a] -> '[b] =>
+        val summoned = Expr.summon[ReproTransformer[a, b]].get
+// ----------- INTERESTING STUFF STARTS HERE
+        summoned match {
+          case '{ $t: ReproTransformer[src, dest] } => t
+        }
+// ----------- INTERESTING STUFF ENDS HERE
+    }
+    transformer.asExprOf[ReproTransformer[A, B]]
+  }
+}

tests/pos-macros/i16636/Test_2.scala

@@ -0,0 +1,9 @@
+object A {
+  case class AnotherCaseClass(name: String)
+
+  val errorsOut1 = ReproTransformer.getTransformer[A.AnotherCaseClass, AnotherCaseClass]
+  val errorsOu2 = ReproTransformer.getTransformer[AnotherCaseClass, A.AnotherCaseClass]
+
+  val works1 = ReproTransformer.getTransformer[A.AnotherCaseClass, A.AnotherCaseClass]
+  val works2 = ReproTransformer.getTransformer[AnotherCaseClass, AnotherCaseClass]
+}