Fix errors in explicit type annotations in inline match cases

Previusly, Unapply trees would have type bindings generated inside their
body and this was the only case handled in InlineReducer. However,
this happened for inferred type parameters, and Unapply with an
explicit binding inside a type annotation was not handled, leading to
a "cannot reduce match" error. This case is now handled and a related
comment was added as well.

Author: jchyb

compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala

@@ -269,12 +269,21 @@ class InlineReducer(inliner: Inliner)(using Context):
           }
         }
 
-        // Extractors contain Bind nodes in type parameter lists, the tree looks like this:
+        // Extractors can contain Bind nodes in type parameter lists,
+        // for that case tree looks like this:
         //   UnApply[t @ t](pats)(implicits): T[t]
         // Test case is pos/inline-caseclass.scala.
+        // Alternatively, for explicitly specified type binds in type annotations like in
+        //   case A(B): A[t]
+        // the tree will look like this:
+        //   Unapply[t](pats)(implicits) : T[t @ t]
+        // and the binds will be found in the type tree instead
+        // Test case is pos-macros/i15971
+        val tptBinds = getBinds(Set.empty[TypeSymbol], tpt)
         val binds: Set[TypeSymbol] = pat match {
-          case UnApply(TypeApply(_, tpts), _, _) => getBinds(Set.empty[TypeSymbol], tpts)
-          case _ => getBinds(Set.empty[TypeSymbol], tpt)
+          case UnApply(TypeApply(_, tpts), _, _) => 
+            getBinds(Set.empty[TypeSymbol], tpts) ++ tptBinds
+          case _ => tptBinds
         }
 
         val extractBindVariance = new TypeAccumulator[TypeBindsMap] {

tests/pos-macros/i15971/macro.scala

@@ -0,0 +1,18 @@
+import scala.quoted._
+
+trait HeadTail
+object HeadTail:
+  case class Pair[H, T <: Tuple](h: H, t: T) extends HeadTail
+  object Nil extends HeadTail
+
+object MatchHeadTail {
+  transparent inline def apply[A <: Tuple](inline tup: A): HeadTail = ${ applyImpl('tup) }
+  def applyImpl[A <: Tuple](tup: Expr[A])(using q: Quotes, tpe: Type[A]): Expr[HeadTail] = {
+    import quotes.reflect._
+    tpe match
+      case '[EmptyTuple] =>
+        '{ HeadTail.Nil }
+      case '[h *: t] =>
+        '{ HeadTail.Pair[h, t]($tup.productElement(0).asInstanceOf[h], $tup.drop(1).asInstanceOf[t]) }
+  }
+}

tests/pos-macros/i15971/main.scala

@@ -0,0 +1,13 @@
+object HeadTailUse {
+
+  inline def concat[T <: Tuple](inline args: T): String =
+    inline MatchHeadTail(args) match
+      case HeadTail.Nil =>
+        ""
+      case HeadTail.Pair(head, tail): HeadTail.Pair[h, t] =>
+        head.toString + concat(tail)
+
+  def main(args: Array[String]) = {
+    println(concat("Hello" *: 42 *: EmptyTuple))
+  }
+}