Fix #6152: dotc requires override to implement abstract java method

The reason is that bridges are allowed to participate in overriding
relationships. This commit does the same scalac does, that is,
prevent bridges from participation in such relationships. This is applied
in all cases except from when bridges are generated: bridges are allowed
to override other bridges. This is necessary to support abstract overrides
where such bridges are generated when type parameters are involved in the
return types of the overridden method.

Author: anatoliykmetyuk

compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala

@@ -341,7 +341,7 @@ object ClassfileConstants {
       case JAVA_ACC_PRIVATE    => Private
       case JAVA_ACC_PROTECTED  => Protected
       case JAVA_ACC_FINAL      => Final
-      case JAVA_ACC_SYNTHETIC  => Synthetic
+      case JAVA_ACC_SYNTHETIC  => Synthetic | Artifact
       case JAVA_ACC_STATIC     => JavaStatic
       case JAVA_ACC_ABSTRACT   => if (isClass) Abstract else Deferred
       case JAVA_ACC_INTERFACE  => PureInterfaceCreationFlags | JavaDefined

compiler/src/dotty/tools/dotc/transform/Bridges.scala

@@ -19,7 +19,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   private val preErasureCtx = ctx.withPhase(ctx.erasurePhase)
   private val elimErasedCtx = ctx.withPhase(ctx.elimErasedValueTypePhase.next)
 
-  private class BridgesCursor(implicit ctx: Context) extends OverridingPairs.Cursor(root) {
+  private class BridgesCursor(implicit ctx: Context) extends OverridingPairs.Cursor(root, excludeArtifacts = false) {
 
     /** Only use the superclass of `root` as a parent class. This means
      *  overriding pairs that have a common implementation in a trait parent

compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala

@@ -20,14 +20,15 @@ object OverridingPairs {
   /** The cursor class
    *  @param base   the base class that contains the overriding pairs
    */
-  class Cursor(base: Symbol)(implicit ctx: Context) {
+  class Cursor(base: Symbol, excludeArtifacts: Boolean = true)(implicit ctx: Context) {
 
     private val self = base.thisType
 
     /** Symbols to exclude: Here these are constructors and private locals.
      *  But it may be refined in subclasses.
      */
-    protected def exclude(sym: Symbol): Boolean = !sym.memberCanMatchInheritedSymbols
+    protected def exclude(sym: Symbol): Boolean =
+      !sym.memberCanMatchInheritedSymbols || (excludeArtifacts && sym.is(Artifact))
 
     /** The parents of base that are checked when deciding whether an overriding
      *  pair has already been treated in a parent class.

tests/pos/i6152/A_1.java

@@ -0,0 +1,8 @@
+abstract class A {
+  public abstract Object f();
+
+  public static abstract class B extends A {
+    @Override
+    public abstract String f();
+  }
+}

tests/pos/i6152/Test_2.scala

@@ -0,0 +1,8 @@
+class C extends A.B {
+  def f() = "hello"
+}
+
+object Main extends App {
+  val c: A = new C
+  println(c.f())
+}