Dependent type isn't inferred correctly in the body

Compiler version

3.2.0

Minimized code

type LeafElem[X] = X match
  case String => Char
  case Array[t] => LeafElem[t]
  case Iterable[t] => LeafElem[t]
  case AnyVal => X

def leafElem[X](x: X): LeafElem[X] = x match
  case x: String      => x.charAt(0)
  case x: Array[t]    => leafElem(x(0))
  case x: Iterable[t] => leafElem(x.head)
  case x: AnyVal      => {
    val p: LeafElem[X] = x
    p
  }

Output

the p is not inferred correctly

Expectation

p, which has the same type signature as the return type, gets inferred correctly.

[markehammons]

To illustrate why this isn’t actually a bug:

type LeafElem[X] = X match
  case String => Char
  case Int => Float


def leafElem[X](x: X, y: X): LeafElem[X] = x match
  case x: String      => x.charAt(0)
  case x: Int           => {
     val p: LeafElem[Int] = y.asInstanceOf[Int].toFloat
     p
  }

//class cast exception: Class java.lang.String cannot be cast to Integer
leafElem(4, "hello")

With the match type, we are providing proof of a refined type for a shadowed value x. That refined type does not automatically correspond to X, as evidenced by both x and y in my modified code having type X but having different concrete types.

[som-snytt]

   |                           trying to reduce  LeafElem[X]
   |                           failed since selector  X
   |                           does not match  case String => Char
   |                           and cannot be shown to be disjoint from it either.

Intersectionless Scala 2 disallows the pattern match on AnyVal.

In Scala 3, the pattern match really means Any, but it doesn’t warn me about that.