Match types used in methods cause issues with inheritance

[felixmulder]

Minimized code

class Foo[A, B]()

type FooSnd[X] = X match
  case Foo[_, b] => b

trait Bar[A]:
  def bar(h: FooSnd[A]): Int

val foo: Bar[Foo[String, Int]] = new Bar[Foo[String, Int]]:
  def bar(h: FooSnd[Foo[String, Int]]) = h

but it works fine if bar is pulled top-level:

- val foo: Bar[Foo[String, Int]] = new Bar[Foo[String, Int]]:
-   def bar(h: FooSnd[Foo[String, Int]]) = h
+ def bar(h: FooSnd[Foo[String, Int]]) = h

Then it compiles as expected.

Output

[error] -- Error: /Users/fixel/.src/fix-me-olivier.scala:19:6
[error] 19 |  def bar(h: FooSnd[Foo[String, Int]]) = h
[error]    |      ^
[error]    |error overriding method bar in trait Bar of type (h: FooSnd[Foo[String, Int]]): Int;
[error]    |  method bar of type (h: Int): Int has incompatible type

Expectation

Not sure - the error message needs improvement.

[felixmulder]

I guess this really messes with inheritance, since the overridden method is not necessarily the same as the super - so I'm not surprised that it doesn't compile. But the error message is perhaps not the best.

It's a bit sad though that it wouldn't be possible to use this in given 😢

[smarter]

since the overridden method is not necessarily the same as the super

That's not a new problem: you can override a method that takes an abstract A with a method that takes an Int if you instantiate A to Int. Erasure takes care of adding bridges to preserve overriding relationships in the generated code.

[smarter]

It seems that the fundamental problem here is that we don't have enough subtyping rules for match types:

scala> type Foo[A] = A match { case Int => String; case _ => Double }

scala> def foo[T](x: Foo[T]) = x
def foo[T](x: Foo[T]): Foo[T]

scala> foo("")
1 |foo("")
  |    ^^
  |    Found:    ("" : String)
  |    Required: Foo[T]
  |
  |    where:    T is a type variable

scala> foo("": Foo[Int])
1 |foo("": Foo[Int])
  |    ^^^^^^^^^^^^
  |    Found:    String
  |    Required: Foo[T]
  |
  |    where:    T is a type variable

scala> foo[Int]("")
val res0: String = ""

I think what we should do when doing the subtype check:
String <:< Foo[?T]
is to check all branches of Foo and find the branch that matches (so here the first one), and record the extra subtyping constraints from that match (?T <: Int). If multiple branches match, we need to be more careful, but we should be able to reuse the logic from TypeComparer#either

[bishabosha]

#8667 for another example

[smarter]

I think what we should do when doing the subtype check:
String <:< Foo[?T]
is to check all branches of Foo

I looked into this a bit more and I don't think that's realistic: match types can be so complicated than properly checking if a type is a subset of a match type given some type variable is going to be extremely expensive in general. On the other hand, it's really easy to check that Foo[Int] <:< Foo[?T] can return true if we set ?T := Int. The problem is that right now, we are too eager to reduce match types:

scala> type Foo[A] = A match { case Int => String }

scala> val a: Foo[Int] = ""
val a: String = ""

@OlivierBlanvillain Why is the type of a inferred to be String instead of Foo[Int] here ? We shouldn't mess with what the user wrote, type aliases don't have this problem:

scala> type Id[A] = A
// defined alias type Id[A] = A

scala> val x: Id[Int] = 1
val x: Id[Int] = 1