Fix two problems related to match types as array elements

 1. The erasure of an array of matchtypes should sometimes be Object
    instead of Object[]
 2. Classtags of matchtypes can be created only if all alternatives
    produce the same classtag.

About 1: If a matchtype with alternative types A_1, ... A_n is an array element,
it should be treated in the same way as the type ? <: A_1 | ... | A_n. It's an
_unknown_ subtype of A_1 | ... | A_n. That can cause the erasure of the underlying
array to be Object.

Fixes #15618

Author: odersky

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

@@ -328,6 +328,9 @@ object TypeErasure {
         isGenericArrayElement(tp.alias, isScala2)
       case tp: TypeBounds =>
         !fitsInJVMArray(tp.hi)
+      case tp: MatchType =>
+        val alts = tp.alternatives
+        alts.nonEmpty && !fitsInJVMArray(alts.reduce(OrType(_, _, soft = true)))
       case tp: TypeProxy =>
         isGenericArrayElement(tp.translucentSuperType, isScala2)
       case tp: AndType =>

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

@@ -40,11 +40,28 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
               val classTag = ref(defn.ClassTagModule)
               val tag =
                 if defn.SpecialClassTagClasses.contains(sym) then
-                  classTag.select(sym.name.toTermName)
+                  classTag.select(sym.name.toTermName).withSpan(span)
                 else
-                  val clsOfType = escapeJavaArray(erasure(tp))
-                  classTag.select(nme.apply).appliedToType(tp).appliedTo(clsOf(clsOfType))
-              withNoErrors(tag.withSpan(span))
+                  def clsOfType(tp: Type): Type =
+                    val tp1 = tp.dealias
+                    if tp1.isMatch then
+                      val matchTp = tp1.underlyingIterator.collect {
+                          case mt: MatchType => mt
+                        }.next
+                      matchTp.alternatives.map(clsOfType) match
+                        case ct1 :: cts if cts.forall(ct1 == _) => ct1
+                        case _ => NoType
+                    else
+                      escapeJavaArray(erasure(tp))
+                  val ctype = clsOfType(tp)
+                  if ctype.exists then
+                    classTag.select(nme.apply)
+                      .appliedToType(tp)
+                      .appliedTo(clsOf(ctype))
+                      .withSpan(span)
+                  else
+                    EmptyTree
+              withNoErrors(tag)
             case tp => EmptyTreeNoError
         else EmptyTreeNoError
       case _ => EmptyTreeNoError

tests/neg/i15618.check

@@ -0,0 +1,18 @@
+-- Error: tests/neg/i15618.scala:17:44 ---------------------------------------------------------------------------------
+17 |  def toArray: Array[ScalaType[T]] = Array() // error
+   |                                            ^
+   |                                            No ClassTag available for ScalaType[T]
+   |
+   |                                            where:    T is a type in class Tensor with bounds <: DType
+   |
+   |
+   |                                            Note: a match type could not be fully reduced:
+   |
+   |                                              trying to reduce  ScalaType[T]
+   |                                              failed since selector  T
+   |                                              does not match  case Float16 => Float
+   |                                              and cannot be shown to be disjoint from it either.
+   |                                              Therefore, reduction cannot advance to the remaining cases
+   |
+   |                                                case Float32 => Float
+   |                                                case Int32 => Int

tests/neg/i15618.scala

@@ -0,0 +1,23 @@
+sealed abstract class DType
+sealed class Float16 extends DType
+sealed class Float32 extends DType
+sealed class Int32 extends DType
+
+object Float16 extends Float16
+object Float32 extends Float32
+object Int32 extends Int32
+
+type ScalaType[U <: DType] <: Int | Float = U match
+  case Float16 => Float
+  case Float32 => Float
+  case Int32 => Int
+
+class Tensor[T <: DType](dtype: T):
+  def toSeq: Seq[ScalaType[T]] = Seq()
+  def toArray: Array[ScalaType[T]] = Array() // error
+
+@main
+def Test =
+  val t = Tensor(Float32) // Tensor[Float32]
+  println(t.toSeq.headOption) // works, Seq[Float]
+  println(t.toArray.headOption) // ClassCastException

tests/run/i15618.check

@@ -0,0 +1,2 @@
+None
+None

tests/run/i15618.scala

@@ -0,0 +1,24 @@
+sealed abstract class DType
+sealed class Float16 extends DType
+sealed class Float32 extends DType
+sealed class Int32 extends DType
+
+object Float16 extends Float16
+object Float32 extends Float32
+object Int32 extends Int32
+
+type ScalaType[U <: DType] <: Int | Float = U match
+  case Float16 => Float
+  case Float32 => Float
+  case Int32 => Int
+
+abstract class Tensor[T <: DType]:
+  def toArray: Array[ScalaType[T]]
+
+object FloatTensor extends Tensor[Float16]:
+  def toArray: Array[Float] = Array(1, 2, 3)
+
+@main
+def Test =
+  val t = FloatTensor: Tensor[Float16] // Tensor[Float32]
+  println(t.toArray.headOption) // was ClassCastException