Fix check whether classtag can be generated for match types (#16708)

The previous check, meant to address #15618, tested whether all
alternatives of a match type had the same classtag and only then
permitted a classtag for the match type. This was the wrong test. It did
not work for recursive match types, because it could lead to stack
overflow for them. And it did not take into account that match types
could be reduced.

A better test is to simply declare that match types themselves don't
have a stable erasure, just like TypeBounds don't have a stable erasure.
If we find an applied type with a match type as definition, we proceed
to its translucent supertype, which will try a match type reduction. If
that succeeds we produce the classtag of the redux. If not, we end up
with an unreduced matchtype and refuse to generate a classtag for it.

Fixes #16706
Fixes #16707

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

@@ -520,8 +520,9 @@ object TypeErasure {
         case _: ClassInfo => true
         case _ => false
       }
-    case tp: TypeParamRef => false
-    case tp: TypeBounds => false
+    case _: TypeParamRef => false
+    case _: TypeBounds => false
+    case _: MatchType => false
     case tp: TypeProxy => hasStableErasure(tp.translucentSuperType)
     case tp: AndType => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
     case tp: OrType  => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)

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

@@ -52,14 +52,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             if defn.SpecialClassTagClasses.contains(sym) then
               classTagModul.select(sym.name.toTermName).withSpan(span)
             else
-              def clsOfType(tp: Type): Type = tp.dealias.underlyingMatchType match
-                case matchTp: MatchType =>
-                  matchTp.alternatives.map(clsOfType) match
-                    case ct1 :: cts if cts.forall(ct1 == _) => ct1
-                    case _ => NoType
-                case _ =>
-                  escapeJavaArray(erasure(tp))
-              val ctype = clsOfType(tp)
+              val ctype = escapeJavaArray(erasure(tp))
               if ctype.exists then
                 classTagModul.select(nme.apply)
                   .appliedToType(tp)

tests/neg/i15618.check

@@ -16,3 +16,9 @@
    |
    |                                                case Float32 => Float
    |                                                case Int32 => Int
+-- [E172] Type Error: tests/neg/i15618.scala:21:33 ---------------------------------------------------------------------
+21 |  def toArray: Array[T] = Array() // error
+   |                                 ^
+   |                                 No ClassTag available for T
+   |
+   |                                 where:    T is a type in class Tensor2 with bounds <: Int | Float

tests/neg/i15618.scala

@@ -16,8 +16,16 @@ class Tensor[T <: DType](dtype: T):
   def toSeq: Seq[ScalaType[T]] = Seq()
   def toArray: Array[ScalaType[T]] = Array() // error
 
+class Tensor2[T <: Int | Float](dtype: T):
+  def toSeq: Seq[T] = Seq()
+  def toArray: Array[T] = Array() // error
+
 @main
 def Test =
   val t = Tensor(Float32) // Tensor[Float32]
   println(t.toSeq.headOption) // works, Seq[Float]
   println(t.toArray.headOption) // ClassCastException
+
+  val t2 = Tensor2(0.0f) // Tensor2[Float]
+  println(t.toSeq.headOption)
+  println(t.toArray.headOption)

tests/pos/i16706.scala

@@ -0,0 +1,17 @@
+import scala.deriving.Mirror
+import scala.reflect.ClassTag
+
+type TupleUnionLub[T <: Tuple, Lub, Acc <: Lub] <: Lub = T match {
+  case (h & Lub) *: t => TupleUnionLub[t, Lub, Acc | h]
+  case EmptyTuple     => Acc
+}
+
+transparent inline given derived[A](
+    using m: Mirror.SumOf[A],
+    idClassTag: ClassTag[TupleUnionLub[m.MirroredElemTypes, A, Nothing]]
+): Unit = ()
+
+sealed trait Foo
+case class FooA(a: Int) extends Foo
+
+val instance = derived[Foo] // error

tests/pos/i16707.scala

@@ -0,0 +1,11 @@
+import scala.deriving.Mirror
+import scala.reflect.ClassTag
+
+transparent inline given derived[A](
+      using m: Mirror.ProductOf[A],
+      idClassTag: ClassTag[Tuple.Union[m.MirroredElemTypes]]
+  ): Unit = ???
+
+case class Foo(a: Int)
+
+val instance = derived[Foo] // error