Wildcard type parameter causes java.lang.AbstractMethodError

[ocadaruma]

I tried following snippet on REPL.

trait Foo[A, B]
object Foo {
  type Bar[A] = Foo[A, _]
}

trait Base[M[_]] {
  def method(in: M[_]): Unit
}

class Concrete extends Base[Foo.Bar] {
  def method(in: Foo.Bar[_]): Unit = {}
}

trait Template[M[_]] {
  def toBeImplemented: Base[M]
  def mark[A]: M[A]

  def method2(): Unit = {
    toBeImplemented.method(mark[Nothing])
  }
}

class Impl extends Template[Foo.Bar] {
  def toBeImplemented: Base[Foo.Bar] = new Concrete
  def mark[A]: Foo.Bar[A] = new Foo[A, Nothing] {}
}

(new Impl).method2()

This compiles and causes java.lang.AbstractMethodError: Concrete.method(Ljava/lang/Object;)V .

However, If I change type Bar[A] = Foo[A, _] to type Bar[A] = Foo[A, Nothing], the snippet run successfully. (no error occured)

I think the first snippet should not compile.

environment

• Scala version: 2.11.8 and 2.12.2
• Java version: 1.8.0_77

possibly related

#8681, #10345

[estsauver]

I agree that this should not compile. I dug up the spec and I believe, if I'm reading this correctly, that wildcard types have to be part of the type parameters:

"A wildcard type must appear as type argument of a parameterized type. Let T=p.c[targs,T,targs′]T=p.c[targs,T,targs′] be a parameterized type where targs,targs′targs,targs′ may be empty and TT is a wildcard type _>:LL<:UU. Then TT is equivalent to the existential type"

So, that seems like it shouldn't compile.

[som-snytt]

I think it should compile, but it's just failing to emit the Base.method bridge, which it does do in the working case which avoids the existential. Maybe it's confused on the back end.

To me, the definitions of Concrete and mark looked odd at first, but it makes sense because nothing relies on the B arg to Foo. Everything conforms, nobody cares about the underscore.

Sample thing you can't do, even though C looks like a dummy parameter:

scala> class Paired[+A, +B, C](x: A, y: B) extends Tuple2(x, y)
defined class Paired

scala> type P[+A, +B] = Paired[A, B, _]
defined type alias P

scala> new P(42, "world")
<console>:13: error: class type required but Paired[A, B, _] found
       new P(42, "world")
           ^

scala> def f(vs: (Int, String)) = vs._1 + vs._2.length
f: (vs: (Int, String))Int

scala> f(new Paired(5, "world"): P[Int, String])
res3: Int = 10

[SethTisue]

Scala 3:

7 |  def method(in: M[_]): Unit
  |                 ^^^^
  |     unreducible application of higher-kinded type M to wildcard arguments

if I add a type parameter to both def methods declarations, it compiles and there is no error at runtime, so I guess that's a "fixed in Dotty"

[som-snytt]

I don't know if it's just unsupported in dotty, but until they correct it to say "irreducible", then you definitely can't call it fixed.

[joroKr21]

Existentials just don't exist in dotty so it's fixed in the sense of "no existentials, no problem"

[som-snytt]

That is also how they took care of existential angst.

[joroKr21]

Does it mean that method2 is trying to call a bridge method which doesn't exist?