signature-based override check is too restrictive

[smarter]

This compiles with Scala 2, but not with Dotty:

class A {
  def foo[T <: Cloneable with Serializable](x: T): Unit = {}
}

class B extends A {
  override def foo[T <: Serializable](x: T): Unit = {}
}

error overriding method foo in class A of type [T <: Cloneable & Serializable](x: T): Unit;
  method foo of type [T <: Serializable](x: T): Unit has incompatible type

This happens because TypeComparer requires matching signatures for subtypes:
https://github.com/lampepfl/dotty/blob/b0147ea5e44ce34a986b2858532fc390e4625f61/compiler/src/dotty/tools/dotc/core/TypeComparer.scala#L656
https://github.com/lampepfl/dotty/blob/b0147ea5e44ce34a986b2858532fc390e4625f61/compiler/src/dotty/tools/dotc/core/TypeComparer.scala#L666

This particular example is perhaps not very important, but the same issue can happen when overriding a Java method which is much more problematic: because Java erases some types differently, in some situation it might not be possible to write a method with a matching signature that is also a valid override.

To fix this, I think that we can just remove the consistentParams checks from TypeComparer. As far as I can tell, the subsequent matchingPolyParams/matchingMethodParams should be enough to guarantee soundness, so it's just a (hopefully insignificant) performance hit. /cc @odersky

[smarter]

Ah, I spoke too soon, if overrides have non-matching signature then they're not considered overrides at use-site:

object Test {
  def test(x: B) = x.foo(???)
}

-- [E051] Reference Error: try/B.scala:13:21 -----------------------------------
13 |  def test(x: B) = x.foo(???)
   |                   ^^^^^
   |Ambiguous overload. The overloaded alternatives of method foo in class B with types
   | [T <: Serializable](x: T): Unit
   | [T <: Cloneable & Serializable](x: T): Unit
   |both match arguments ((??? : => Nothing))

Because denotation matching requires that parameter matches:
https://github.com/lampepfl/dotty/blob/b0147ea5e44ce34a986b2858532fc390e4625f61/compiler/src/dotty/tools/dotc/core/Denotations.scala#L1126
So the d != Signature.NoMatch check would have to be removed, which might be more expensive.

Alternatively, we could keep the check but only in situations where a Scala method is not overriding a Java method. That way we can still have a fast-path without compromising interop. WDYT?

[smarter]

(Note that the same sort of issues can arise when overriding Scala 2 methods from Dotty, which is what motivated me looking into this in the first place)

[smarter]

Closing now that #9139 is merged:

Note that our treatment of polymorphic methods differs from Scala 2
which seems to consider that two polymorphic methods with the same
number of type and term parameters always match and cannot be
overloads (see #8929), but it's closer to what Java does and allows us
to override some Java methods which scalac can't.