AbstractMethodError when implementing method with generic type of different arity

[steinybot]

reproduction steps

Initially reported as scala-js/scala-js#4454.

See reproduction here: https://github.com/steinybot/bug-reports/tree/scalajs/non-existent-method

using Scala 2.13.5

trait TwoTypeParam[X, Y]
class OneTypeParam[X] extends TwoTypeParam[X, Any]

trait Parent {
  type L = TwoTypeParam[_, _]
  def childMethod: L
  def parentMethod: Any = childMethod
}

class Child extends Parent {
  override def childMethod: OneTypeParam[_] = ???
}

object Test extends App {
  (new Child).parentMethod
}

problem

This compiles and fails at runtime:

sbt:root> fooJVM/run
[info] Compiling 1 Scala source to C:\Users\sjrdo\Documents\Projets\bug-4454\jvm\target\scala-2.13\classes ...
[info] running Child
[error] (run-main-0) java.lang.AbstractMethodError: Method Child$.childMethod()LTwoTypeParam; is abstract
[error] java.lang.AbstractMethodError: Method Child$.childMethod()LTwoTypeParam; is abstract
[error]         at Child$.childMethod(Main.scala)
[error]         at Parent.parentMethod(Main.scala:14)
[error]         at Parent.parentMethod$(Main.scala:14)
[error]         at Child$.parentMethod(Main.scala:1)
[error]         at Child$.delayedEndpoint$Child$1(Main.scala:5)
[error]         at Child$delayedInit$body.apply(Main.scala:1)
[error]         at scala.Function0.apply$mcV$sp(Function0.scala:39)
[error]         at scala.Function0.apply$mcV$sp$(Function0.scala:39)
[error]         at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:17)
[error]         at scala.App.$anonfun$main$1(App.scala:76)
[error]         at scala.App.$anonfun$main$1$adapted(App.scala:76)
[error]         at scala.collection.IterableOnceOps.foreach(IterableOnce.scala:563)
[error]         at scala.collection.IterableOnceOps.foreach$(IterableOnce.scala:561)
[error]         at scala.collection.AbstractIterable.foreach(Iterable.scala:919)
[error]         at scala.App.main(App.scala:76)
[error]         at scala.App.main$(App.scala:74)
[error]         at Child$.main(Main.scala:1)
[error]         at Child.main(Main.scala)
[error]         at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
[error]         at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
[error]         at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
[error]         at java.lang.reflect.Method.invoke(Method.java:498)
[error] stack trace is suppressed; run last fooJVM / Compile / bgRun for the full output
[error] Nonzero exit code: 1
[error] (fooJVM / Compile / run) Nonzero exit code: 1
[error] Total time: 0 s, completed 18 mars 2021 19:08:03

[SethTisue]

I spent 10 or 15 minutes trying to minimize it further, but failed -- perhaps it really is minimized.

In particular, note that the problem goes away without the intermediary of the L type alias.

Combining type aliases and existentials is often There Be Dragons territory in Scala 2, but I couldn't find an obvious duplicate ticket; a couple bugs that seem perhaps related: #10363, #8635

[SethTisue]

under Scala 2, javap shows the emitted signatures for childMethod are:

• Parent: public abstract TwoTypeParam<?, ?> childMethod();
• Child: public OneTypeParam<?> childMethod();

whereas Scala 3(.0.0-RC2) emits:

• Parent: public abstract TwoTypeParam childMethod();
• Child: public OneTypeParam<?> childMethod();

Scala 3 emits a raw type, which seems surprising, and..... surely wrong?

[SethTisue]

I initially labeled this "fixed in Dotty" since Dotty accepts the code, but (as has emerged in conversation with Dale) and I think we should explore the possibility that both compilers are wrong to even allow this to compile.

In the Scala 3 case, the fact that it compiles because a raw type is involved (see previous comment) makes me even more suspicious about the whole thing. (But I have not gone digging in the Dotty tracker and/or codebase to see if this somehow considered normal.)

[dwijnand]

Here are my notes:

def childMethod: TwoTypeParam[A, B] forSome { type A; type B >: Nothing <: Any }
def childMethod: TwoTypeParam[A, B] forSome { type A; type B >: Any     <: Any }

The first is parent's definition of childMethod and the second is Child's definition. I don't think Child's definition is a covariant-returning override, but an overload instead - because the existential type B isn't equivalent. TL;DR I don't think it should compile.

[smarter]

Why do you expect this to not compile? OneTypeParam[_] is a subtype of TwoTypeParam[_, _], and overrides are allowed to covariantly refine the result type. Also the type you get out of javap doesn't actually matter for Scala or the JVM, it's just the generic signature that javac will use, you need to use javap -v to get the actual descriptor.

[smarter]

The issue here is that scala 2 is not emitting a bridge in Child for childMethod that returns TwoTypeParam, but scala 3 is.

[SethTisue]

Ahh, bridge methods, that didn't even occur to me.

If this working as intended in Scala 3, then I'm disinclined to dig any further on the Scala 2 side, but perhaps someone else will get interested.