Fix scala#9392: Allow overriding a Java method when a same-named field is present

In scala#9126, Java fields were marked effectively finals to prevent false
overrides. This poses a problem when a Java field and method of the same
name are present, because a Scala val or def will match both of these
according to Denotation#matches. This commit changes `matches` to
prevent Java field from matching any Scala method, but we can't prevent
them from matching Scala definitions with NotAMethod signature without
introducing more complexity, so the following still doesn't compile
unlike Scala 2:

```java
package pkg;

public class J {
    int i = 0;
    public int i() { return 1; }
}
```

```scala
class S2 extends pkg.J {
  override def i: Int = 2 // error
}
```

I have an alternative fix at scala#9412 which doesn't have this issue but is
more hacky.

Author: smarter

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

@@ -976,8 +976,22 @@ object Denotations {
         case FullMatch =>
           true
         case MethodNotAMethodMatch =>
-          // Java allows defining both a field and a zero-parameter method with the same name
-          !ctx.erasedTypes && !(symbol.is(JavaDefined) && other.symbol.is(JavaDefined))
+          !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)

tests/neg/i9115/B.scala

@@ -1,3 +1,3 @@
 class B extends A {
   override val foo: String = "B" // error
-}
+}

tests/pos/i9392/J.java

@@ -0,0 +1,6 @@
+package pkg;
+
+public class J {
+    int i = 0;
+    public int i() { return 1; }
+}

tests/pos/i9392/S.scala

@@ -0,0 +1,20 @@
+class S1 extends pkg.J {
+  override def i(): Int = 2
+}
+
+// Unlike Scala 2 this doesn't compile, because this override of `i()`
+// also matches the non-overridable field `i`.
+// class S2 extends pkg.J {
+//   override def i: Int = 2
+// }
+
+object Test {
+  val s1 = new S1
+
+  val i1 = s1.i
+  val i2 = s1.i()
+
+  // val s2 = new S2
+
+  // val i3 = s2.i
+}