Systematize treatement of trueMatch

Refchecks now decouples overriding from signature matching. A signature match is in essence a pre-check that two members might override, but if the two members are methods we also need to compare their parameter types. This has three consequences:

 1. Before emitting an override error, test that parameter types match. If not, we have a false override and no error should be reported.
 2. Before emitting a bridge, do the same test and omit the generation if the test fails
 3. When checking whether a class is fully implemented, check that any implementation also agrees completely in its parameter types.

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1021,7 +1021,7 @@ object Denotations {
      *  erasure (see i8615b, i9109b), Erasure takes care of adding any necessary
      *  bridge to make this work at runtime.
      */
-    def matchesLoosely(other: SingleDenotation)(using Context): Boolean =
+    def matchesLoosely(other: SingleDenotation, alwaysCompareParams: Boolean = false)(using Context): Boolean =
       if isType then true
       else
         val thisLanguage = SourceLanguage(symbol)
@@ -1031,7 +1031,7 @@ object Denotations {
         val otherSig = other.signature(commonLanguage)
         sig.matchDegree(otherSig) match
           case FullMatch =>
-            true
+            !alwaysCompareParams || info.matches(other.info)
           case MethodNotAMethodMatch =>
             !ctx.erasedTypes && {
               // A Scala zero-parameter method and a Scala non-method always match.

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -323,12 +323,13 @@ object RefChecks {
             overrideErrorMsg("no longer has compatible type"),
             (if (member.owner == clazz) member else clazz).srcPos))
 
-      /** Do types of `member` and `other` as seen from `self` match?
+      /** Do types of term members `member` and `other` as seen from `self` match?
        *  If not we treat them as not a real override and don't issue certain
        *  error messages. Also, bridges are not generated in this case.
+       *  Type members are always assumed to match.
        */
       def trueMatch: Boolean =
-        memberTp(self).matches(otherTp(self))
+        member.isType || memberTp(self).matches(otherTp(self))
 
       def emitOverrideError(fullmsg: Message) =
         if (!(hasErrors && member.is(Synthetic) && member.is(Module))) {
@@ -340,7 +341,7 @@ object RefChecks {
         }
 
       def overrideError(msg: String, compareTypes: Boolean = false) =
-        if (noErrorType)
+        if trueMatch && noErrorType then
           emitOverrideError(overrideErrorMsg(msg, compareTypes))
 
       def autoOverride(sym: Symbol) =
@@ -401,7 +402,7 @@ object RefChecks {
         overrideError("cannot be used here - class definitions cannot be overridden")
       else if (!other.is(Deferred) && member.isClass)
         overrideError("cannot be used here - classes can only override abstract types")
-      else if other.isEffectivelyFinal && trueMatch then // (1.2)
+      else if other.isEffectivelyFinal then // (1.2)
         overrideError(i"cannot override final member ${other.showLocated}")
       else if (member.is(ExtensionMethod) && !other.is(ExtensionMethod)) // (1.3)
         overrideError("is an extension method, cannot override a normal method")
@@ -425,15 +426,14 @@ object RefChecks {
         else if member.owner != clazz
              && other.owner != clazz
              && !other.owner.derivesFrom(member.owner)
-             && trueMatch
         then
-          emitOverrideError(
+          overrideError(
             s"$clazz inherits conflicting members:\n  "
               + infoStringWithLocation(other) + "  and\n  " + infoStringWithLocation(member)
               + "\n(Note: this can be resolved by declaring an override in " + clazz + ".)")
         else if member.is(Exported) then
           overrideError("cannot override since it comes from an export")
-        else if trueMatch then
+        else
           overrideError("needs `override` modifier")
       else if (other.is(AbsOverride) && other.isIncompleteIn(clazz) && !member.is(AbsOverride))
         overrideError("needs `abstract override` modifiers")
@@ -578,7 +578,8 @@ object RefChecks {
         def isConcrete(sym: Symbol) = sym.exists && !sym.isOneOf(NotConcrete)
         clazz.nonPrivateMembersNamed(mbr.name)
           .filterWithPredicate(
-            impl => isConcrete(impl.symbol) && mbrDenot.matchesLoosely(impl))
+            impl => isConcrete(impl.symbol)
+              && mbrDenot.matchesLoosely(impl, alwaysCompareParams = true))
           .exists
 
       /** The term symbols in this class and its baseclasses that are

tests/neg/OpaqueEscape.scala

@@ -7,7 +7,7 @@ def unwrap(i:Wrapped):Int
   def wrap(i:Int):Wrapped
 }
 class Escaper extends EscaperBase{  // error: needs to be abstract
-  override def unwrap(i:Int):Int = i // error overriding method unwrap
+  override def unwrap(i:Int):Int = i // was error overriding method unwrap, now OK
   override def wrap(i:Int):Int = i  // error overriding method wrap
 }
 val e = new Escaper:EscaperBase

tests/neg/i11828.check

@@ -0,0 +1,8 @@
+-- Error: tests/neg/i12828.scala:7:7 -----------------------------------------------------------------------------------
+7 |object Baz extends Bar[Int] // error overriding foo: incompatible type
+  |       ^
+  |       object creation impossible, since def foo(x: A): Unit in trait Foo is not defined 
+  |       (Note that
+  |        parameter A in def foo(x: A): Unit in trait Foo does not match
+  |        parameter Int & String in def foo(x: A & String): Unit in trait Bar
+  |        )

tests/neg/i12828.check

@@ -1,7 +1,8 @@
--- [E163] Declaration Error: tests/neg/i12828.scala:7:7 ----------------------------------------------------------------
-7 |object Baz extends Bar[Int] // error overriding foo: incompatible type
+-- Error: tests/neg/i12828.scala:7:7 -----------------------------------------------------------------------------------
+7 |object Baz extends Bar[Int] // error: not implemented
   |       ^
-  |       error overriding method foo in trait Foo of type (x: Int): Unit;
-  |         method foo in trait Bar of type (x: Int & String): Unit has incompatible type
-
-longer explanation available when compiling with `-explain`
+  |       object creation impossible, since def foo(x: A): Unit in trait Foo is not defined 
+  |       (Note that
+  |        parameter A in def foo(x: A): Unit in trait Foo does not match
+  |        parameter Int & String in def foo(x: A & String): Unit in trait Bar
+  |        )

tests/neg/i12828.scala

@@ -4,6 +4,6 @@ trait Foo[A]:
 trait Bar[A] extends Foo[A]:
   def foo(x: A & String): Unit = println(x.toUpperCase)
 
-object Baz extends Bar[Int] // error overriding foo: incompatible type
+object Baz extends Bar[Int] // error: not implemented
 
 @main def run() = Baz.foo(42)

tests/neg/i7597.scala

@@ -6,8 +6,8 @@ object Test extends App {
     def apply(x: A): B
   }
 
-  class C[S <: String] extends Fn[String, Int] {
-    def apply(s: S): Int = 0 // error
+  class C[S <: String] extends Fn[String, Int] { // error
+    def apply(s: S): Int = 0
   }
 
   foo("")