Methods with pattern-matching and dependent types

Given:

  sealed trait F { type A }
  case object FI extends F { type A = Int }
  case object FS extends F { type A = String }

This snippet:

  def test1a(f: F): f.A =
    f match {
      case FI => 1
      case _: FS.type => ""
    }

fails with:

-- [E007] Type Mismatch Error: <console>:9:19 ----------------------------------
9 |        case FI => 1
  |                   ^
  |                   found:    Int(1)
  |                   required: f.A
-- [E007] Type Mismatch Error: <console>:10:27 ---------------------------------
10 |        case _: FS.type => ""
   |                           ^^
   |                           found:    String("")
   |                           required: f.A

But I can prove it works with a little hacky workaround:

  def test1b(f: F): f.A = {
    def dirtyHack[B](f: F { type A = B }): B =
      f match {
        case FI => 1
        case _: FS.type => ""
      }
    dirtyHack[f.A](f)
  }

Notice that the f match { ... } is the original implementation verbatim. It would be great if the first snippet worked.

[julienrf]

I think we should re-open this issue, especially because the “little hacky workaround” doesn’t work anymore: https://scastie.scala-lang.org/l21lZJfsThiUMJlBeSuSsg

[abgruszecki]

I’ll be looking into extending GADT constraints to also work on singleton types. I’ll keep this issue on my radar.