Denotation#signature: take the "Java-ness" of the prefix into account

When comparing denotations using Denotation#matches, we check if they
have matching signatures, but this could return false when comparing a
Java and non-Java methods which can happen when doing overriding checks.
Override checks are done as seen from some common prefix, but
`asSeenFrom` does not change the Java-ness of a method (that is, change
the result of MethodType#isJavaMethod). We could change `asSeenFrom` to
do that, but that would be pretty expensive in terms of allocation.
Instead, we change SingleDenotation#signature to rely on the prefix of
the current denotation to decide how to compute its signature. This
requires adding a special-case in SingleDenotation#computeAsSeenFrom to
ensure that the prefix is always available when we need it to compute
the Java-ness of a denotation.

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

@@ -585,8 +585,13 @@ object Denotations {
     final def signature(using Context): Signature =
       if (isType) Signature.NotAMethod // don't force info if this is a type SymDenotation
       else info match {
-        case info: MethodicType =>
-          try info.signature
+        case info: MethodOrPoly =>
+          val isJava =
+            if prefix eq NoPrefix then
+              symbol.is(JavaDefined)
+            else
+              prefix.classSymbol.is(JavaDefined)
+          try info.signature(isJava)
           catch { // !!! DEBUG
             case scala.util.control.NonFatal(ex) =>
               report.echo(s"cannot take signature of $info")
@@ -1058,7 +1063,10 @@ object Denotations {
         def needsPrefix =
           // For opaque types, the prefix is used in `ElimOpaques#transform`,
           // without this i7159.scala would fail when compiled from tasty.
-          symbol.is(Opaque)
+          symbol.is(Opaque) ||
+          // SingleDenotation#signature relies on the prefix to compute
+          // an appropriate signature for methods.
+          info.isInstanceOf[MethodOrPoly] && symbol.is(JavaDefined) != pre.classSymbol.is(JavaDefined)
 
         val derivedInfo = info.asSeenFrom(pre, owner)
         if Config.reuseSymDenotations && this.isInstanceOf[SymDenotation]

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

@@ -3397,12 +3397,12 @@ object Types {
         mySignature
     end signature
 
+    /** The Scala signature of this method. When comparing this signature
+     *  with signatures of Java definitions, the other overload
+     *  of `signature` should be used instead.
+     */
     final override def signature(using Context): Signature =
-      def isJava(tp: Type): Boolean = tp match
-        case tp: PolyType => isJava(tp.resultType)
-        case tp: MethodType => tp.isJavaMethod
-        case _ => false
-      signature(isJava = isJava(this))
+      signature(isJava = false)
 
     final override def hashCode: Int = System.identityHashCode(this)
 

tests/pos/i8615b.scala

@@ -0,0 +1,7 @@
+class ArrayOrdering[N] extends Comparable[Array[N]] {
+  override def compareTo(x: Array[N]): Int = 0
+}
+
+class ArrayIntOrdering extends Comparable[Array[Int]] {
+  override def compareTo(x: Array[Int]): Int = 0
+}