Fix overriding checks involving Scala and Java methods

To check which methods are in an overriding relationship, we rely on
denotation matching which checks that the methods have matching
signatures, but because Scala and Java have different erasure rules,
seemingly valid overrides might not be seen as such because they end up
with different signatures. To compensate for this we change
SingleDenotation#matchesLoosely to use the Scala signatures of both
methods when comparing a Scala and a Java method. This works even though
the methods end up with different erased types because Erasure will
insert bridges.

Note that even after this change, we cannot simply override a Java
generic `Array[T]` with a Scala `Array[T]`, because we intentionally
parse these Java types as `Array[T & Object]`, see
`TypeApplications.translateJavaArrayElementType` for details and
tests/{neg,pos}/i1747.scala for examples.

Author: smarter

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

@@ -595,10 +595,17 @@ object Denotations {
      *    SingleDenotations will have distinct signatures (cf #9050).
      */
     final def signature(using Context): Signature =
+      signature(isJava = !isType && symbol.is(JavaDefined))
+
+    /** Overload of `signature` which lets the caller pick between the Java and
+     *  Scala signature of the info. Useful to match denotations defined in
+     *  different classes (see `matchesLoosely`).
+     */
+    def signature(isJava: Boolean)(using Context): Signature =
       if (isType) Signature.NotAMethod // don't force info if this is a type denotation
       else info match {
         case info: MethodOrPoly =>
-          try info.signature(isJava = symbol.is(JavaDefined))
+          try info.signature(isJava)
           catch { // !!! DEBUG
             case scala.util.control.NonFatal(ex) =>
               report.echo(s"cannot take signature of $info")
@@ -1004,34 +1011,45 @@ object Denotations {
       symbol.hasTargetName(other.symbol.targetName)
       && matchesLoosely(other)
 
-    /** matches without a target name check */
+    /** `matches` without a target name check.
+     *
+     *  We consider a Scala method and a Java method to match if they have
+     *  matching Scala signatures. This allows us to override some Java
+     *  definitions even if they have a different 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 =
-      val d = signature.matchDegree(other.signature)
-      d match
-        case FullMatch =>
-          true
-        case MethodNotAMethodMatch =>
-          !ctx.erasedTypes && {
-            val isJava = symbol.is(JavaDefined)
-            val otherIsJava = other.symbol.is(JavaDefined)
-            // A Scala zero-parameter method and a Scala non-method always match.
-            if !isJava && !otherIsJava then
-              true
-            // Java allows defining both a field and a zero-parameter method with the same name,
-            // so they must not match.
-            else if isJava && otherIsJava then
-              false
-            // A Java field never matches a Scala method.
-            else if isJava then
-              symbol.is(Method)
-            else // otherIsJava
-              other.symbol.is(Method)
-          }
-        case ParamMatch =>
-          // The signatures do not tell us enough to be sure about matching
-          !ctx.erasedTypes && info.matches(other.info)
-        case noMatch =>
-          false
+      if isType then true
+      else
+        val isJava = symbol.is(JavaDefined)
+        val otherIsJava = other.symbol.is(JavaDefined)
+        val useJavaSig = isJava && otherIsJava
+        val sig = signature(isJava = useJavaSig)
+        val otherSig = other.signature(isJava = useJavaSig)
+        sig.matchDegree(otherSig) match
+          case FullMatch =>
+            true
+          case MethodNotAMethodMatch =>
+            !ctx.erasedTypes && {
+              // A Scala zero-parameter method and a Scala non-method always match.
+              if !isJava && !otherIsJava then
+                true
+              // Java allows defining both a field and a zero-parameter method with the same name,
+              // so they must not match.
+              else if isJava && otherIsJava then
+                false
+              // A Java field never matches a Scala method.
+              else if isJava then
+                symbol.is(Method)
+              else // otherIsJava
+                other.symbol.is(Method)
+            }
+          case ParamMatch =>
+            // The signatures do not tell us enough to be sure about matching
+            !ctx.erasedTypes && info.matches(other.info)
+          case noMatch =>
+            false
 
     def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(using Context): SingleDenotation =
       if hasUniqueSym && prevDenots.containsSym(symbol) then NoDenotation

tests/pos-java-interop/i9109b/A.java

@@ -0,0 +1,3 @@
+public class A {
+  public <T extends Object & Intf> void foo(T x) {}
+}

tests/pos-java-interop/i9109b/B.scala

@@ -0,0 +1,3 @@
+class B extends A {
+  override def foo[T <: Object with Intf](x: T): Unit = {}
+}

tests/pos-java-interop/i9109b/Intf.java

@@ -0,0 +1 @@
+public interface Intf {}

tests/pos/i8615b.scala

@@ -0,0 +1,26 @@
+class ArrayOrdering[N] extends Comparable[Array[N]] {
+  override def compareTo(x: Array[N]): Int = 0
+
+  compareTo(???)
+}
+
+class ArrayIntOrdering extends Comparable[Array[Int]] {
+  override def compareTo(x: Array[Int]): Int = 0
+
+  compareTo(???)
+}
+
+class ArrayOrdering2[N] extends Comparable[Array[N]] {
+  self: Serializable =>
+  override def compareTo(x: Array[N]): Int = 0
+
+  compareTo(???)
+}
+
+class ArrayIntOrdering2 extends Comparable[Array[Int]] {
+  self: Serializable =>
+
+  override def compareTo(x: Array[Int]): Int = 0
+
+  compareTo(???)
+}