Abstract override compilation error when all inherited methods are implemented

[jto]

Minimized code

You will need the following dependency: "org.apache.beam" % "beam-sdks-java-core" % "2.25.0"

object Demo {
  import java.io.{InputStream, OutputStream}
  import scala.reflect.ClassTag
  import org.apache.beam.sdk.coders.{Coder => BCoder, IterableCoder => BIterableCoder, _}
  import org.apache.beam.sdk.util.common.ElementByteSizeObserver
  import scala.collection.{ mutable => m }

  abstract private class BaseSeqLikeCoder[M[_], T](val elemCoder: BCoder[T]) extends AtomicCoder[M[T]] {
    override def getCoderArguments: java.util.List[_ <: BCoder[_]] = ???
    override def verifyDeterministic(): Unit = ???
    override def consistentWithEquals(): Boolean = ???
    override def isRegisterByteSizeObserverCheap(value: M[T]): Boolean = ???
    override def registerByteSizeObserver(value: M[T], observer: ElementByteSizeObserver): Unit = ???
  }

  abstract private class SeqLikeCoder[M[_], T](bc: BCoder[T])(implicit
    ev: M[T] => IterableOnce[T]
  ) extends BaseSeqLikeCoder[M, T](bc) {
    override def encode(value: M[T], outStream: OutputStream): Unit = ???
    def decode(inStream: InputStream, builder: m.Builder[T, M[T]]): M[T] = ???
    override def structuralValue(value: M[T]): AnyRef = ???
    override def toString: String = s"SeqLikeCoder($bc)"
  }

  private class ArrayCoder[T: ClassTag](
    bc: BCoder[T]
  ) extends SeqLikeCoder[Array, T](bc) {
    override def decode(inStream: InputStream): Array[T] = ???
    override def consistentWithEquals(): Boolean = ???
  }
}

Output

private class ArrayCoder[T: ClassTag](
   |                ^
   |class ArrayCoder needs to be abstract, since there is a deferred declaration of method encode in class Coder of type (x$0: Array[T], x$1: java.io.OutputStream): Unit which is not implemented in a subclass

Note that (re)implementing encode in ArrayCoder does not fix the issue:

private class ArrayCoder[T: ClassTag](
    bc: BCoder[T]
  ) extends SeqLikeCoder[Array, T](bc) {
    override def encode(value: Array[T], outStream: OutputStream): Unit = ???
    override def decode(inStream: InputStream): Array[T] = ???
    override def consistentWithEquals(): Boolean = ???
  }

However, if we remove the override modifier, this happens:

28 |    def encode(value: Array[T], outStream: OutputStream): Unit = ???
   |        ^
   |error overriding method encode in class SeqLikeCoder of type (value: Array[T], outStream: java.io.OutputStream): Unit;
   |  method encode of type (value: Array[T], outStream: java.io.OutputStream): Unit needs `override` modifier
25 |  private class ArrayCoder[T: ClassTag](
   |                ^
   |class ArrayCoder needs to be abstract, since there is a deferred declaration of method encode in class Coder of type (x$0: Array[T], x$1: java.io.OutputStream): Unit which is not implemented in a subclass

Expectation

The code should compile (it does with Scala 2.x).

[b-studios]

I could reproduce the issue. The problem can be minimized a little bit further to the following:

  abstract private class Base[M[_], T] extends AtomicCoder[M[T]] {
    override def getCoderArguments: java.util.List[_ <: BCoder[_]] = ???
    override def verifyDeterministic(): Unit = ???
    override def consistentWithEquals(): Boolean = ???
    override def isRegisterByteSizeObserverCheap(value: M[T]): Boolean = ???
    override def registerByteSizeObserver(value: M[T], observer: ElementByteSizeObserver): Unit = ???
    override def decode(inStream: InputStream): M[T] = ???
    override def encode(value: M[T], outStream: OutputStream): Unit = ???
  }

  private class ArrayCoder[T] extends Base[Array, T] // doesn't compile
  private class ListCoder[T] extends Base[List, T] // does compile

It appears that instantiated with List the code compiles. Also defining AtomicCoder within Scala does compile.

[changvvb]

Further minimize without dependency

A.java

public abstract class A<T> {
    public abstract void foo(T value);
    public void foo(T value, Object obj) { return; }
}

Test.scala

abstract class Base[M[_], T] extends A[M[T]] {
  override def foo(value: M[T]): Unit = ???
}

class ArrayTest[T] extends Base[Array, T] // doesn't compile

class ListTest[T] extends Base[List, T] // does compile

[odersky]

This might also be fixable by the changes to signatures prototyped by @smarter