Widen scrutinees in TypeComparer's compareMatch

If the skolem-widened scrutinees are the same and the cases correspond,
then the match types are the same.

Also, with inlining the type embeded in inlining's Typed expression will
be without going through type-avoidance, so they won't be skolems.  So
we look to widen inline proxy term refs, in addition to skolems.

Co-Authored-By: Matt Bovel <matthieu@bovel.net>

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

@@ -1007,7 +1007,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tp1: MatchType =>
         def compareMatch = tp2 match {
           case tp2: MatchType =>
-            isSameType(tp1.scrutinee, tp2.scrutinee) &&
+            def widen(tp: Type) = tp match
+              case tp: TermRef if tp.symbol.is(InlineProxy) => tp.info
+              case tp                                       => tp.widenSkolem
+            isSameType(widen(tp1.scrutinee), widen(tp2.scrutinee)) &&
             tp1.cases.corresponds(tp2.cases)(isSubType)
           case _ => false
         }

tests/pos/16583.scala

@@ -0,0 +1,19 @@
+import scala.compiletime.constValueTuple
+
+val ll0: Tuple3["one", "two", "three"] = constValueTuple[("one", "two", "three")]
+val ll1 = constValueTuple[("one", "two", "three")].toList
+val ll3: List["one" | ("two" | ("three" | Nothing))] = constValueTuple[("one", "two", "three")].toList
+val ll4: List["one" | ("two" | "three")] = constValueTuple[("one", "two", "three")].toList
+
+inline def labels[Labels <: Tuple](using ev: Tuple.Union[Labels] <:< String): List[String] =
+  val tmp = constValueTuple[Labels].toList
+  ev.substituteCo(tmp)
+
+def test = labels[("one", "two", "three")]
+
+def toList(x: Tuple): List[Tuple.Union[x.type]] = ???
+def test2[Labels <: Tuple] = toList((???): Labels)
+
+def i16654 =
+  def t1: Tuple = EmptyTuple
+  val t2 = t1.toList

tests/pos/16654.scala

@@ -0,0 +1,7 @@
+def toCsvFlat[A <: Product](a: A)(using m: scala.deriving.Mirror.ProductOf[A]) = {
+  def flatTuple(any: Any): Tuple = any match
+    case p: Product => p.productIterator.map(flatTuple).foldLeft(EmptyTuple: Tuple)(_ ++ _)
+    case a          => Tuple1(a)
+
+  val tuple = flatTuple(Tuple.fromProductTyped(a)).toList
+}