Inferred type K in Map[K, V] does not match or roundtrip

[mcanlas]

Compiler version

3.3.1

Minimized code

object TestApp extends App {
  enum PersonEnum:
    case First
    case Second
    case Third

  sealed trait PersonSealedTrait

  object PersonSealedTrait:
    case object First extends PersonSealedTrait
    case object Second extends PersonSealedTrait
    case object Third extends PersonSealedTrait

  // minimization seems to be:
  // a) the key side of the map needs to be two fields (a tuple2)
  // b) one member of the tuple must be a sealed trait; not at enum
  lazy val tupleKeyMap = Map(
    ("apple", PersonSealedTrait.First) -> "apple",
    ("notapple", PersonSealedTrait.Third) -> "zapple"
  )

  // possible bug or confusing intuition:
  //   - inferred type of map's key does not match type given to pattern in case match
  //   - scala3 compiler complains that union of first | third is required, but person sealed trait was given from `p`
  tupleKeyMap.map { case ((n, p), _) =>
    tupleKeyMap.apply(n -> p)
  }
}

Output

Found:    (p : TestApp.PersonSealedTrait)
Required: TestApp.PersonSealedTrait.First.type | TestApp.PersonSealedTrait.Third.type
    tupleKeyMap.apply(n -> p)

Expectation

[mbovel]

The pattern matching is the culprit here; it widens First | Third to PersonSealedTrait, which does not play well with Map keys invariance:

tupleKeyMap.keysIterator.map(key =>
    key match
        case (a, b) => tupleKeyMap(a -> b)
            // Error
            // Found:    (b : MdocApp.this.PersonSealedTrait)
            // Required: MdocApp.this.PersonSealedTrait.First.type | MdocApp.this.PersonSealedTrait.Third.type
)

tupleKeyMap.keysIterator.map(key => tupleKeyMap(key)) // Okay

[mbovel]

Inferred type for tupleKeyMap:

enum PersonEnum:
    case First
    case Second
    case Third

sealed trait PersonSealedTrait

object PersonSealedTrait:
    case object First extends PersonSealedTrait
    case object Second extends PersonSealedTrait
    case object Third extends PersonSealedTrait

val tupleKeyMap = Map(
    ("apple", PersonSealedTrait.First) -> "apple",
    ("notapple", PersonSealedTrait.Third) -> "zapple"
)
// tupleKeyMap: Map[Tuple2[String, First | Third], String] = Map((apple,First) -> apple, (notapple,Third) -> zapple)

[dwijnand]

I can't find a fix for this that doesn't break other tests, like i14494:

class TOP
class STR(s: String) extends TOP
class INT(i: Int) extends TOP

class Test:
  def t1: Unit =
    val res: Seq[STR | INT] = (??? : Seq[Int]).collect {
      case 1 => Seq(STR(""))
      case 2 => Seq(INT(1))
    }.flatten

Here we would like to keep the soft inferred STR | INT which is good, because we end up wanting to return Seq[STR | INT]. But in the minimisation of the original here (using my copy):

sealed trait Foo
case object Bar extends Foo
case object Baz extends Foo

class Test:
  def t1: Unit =
    val tupleKeyMap = Map(
      (1, Bar) -> "bar",
      (2, Baz) -> "baz",
    )

    tupleKeyMap.map { case ((n, p), _) =>
      tupleKeyMap.apply((n, p))
    }

Here we end up only widening the union (Int, Bar.type) || (Int, Baz.type) into (Int, Bar.type || Baz.type) (|| means soft or), but when inferring p we end up widening to Foo. In some sense I think it's the fault of only doing a shallow widen.