Question

Let’s say I need to provide a method with a java.lang.Class object that represents a subclass of some parent class A. I need to do this from another method that has a generic parameter with an upper type bound to A.

I thought this might work:

class A
def f(clazz: java.lang.Class[_ <: A]) = ()
def g[T <: A : Manifest] = f(classManifest[T].erasure)

But it does not:

<console>:9: error: type mismatch;
 found   : java.lang.Class[_$1(in method g)] where type _$1(in method g)
 required: java.lang.Class[_ <: A]
         def g[T <: A : Manifest] = f(classManifest[T].erasure)
                                                       ^

Why can’t the compiler figure out that T is, indeed, a subclass of A? Is there anyway I can help it? Or should I approach this in a completely different manner?

Answer 1

It does not work because erasure has the type Class[_], which is an existential type. This means that Class object erasure is parametrized by some type, but it is not important which exact type this is. The erasure does not have a type Class[T] above.

The method f expects a parameter of type Class[_ <: A] which is some type known to be a subtype of A. This upper bound is not necessarily ensured by the Class[_] type above.

Solution: you know that the erasure has a proper type, it’s just that this type is not exposed in the ClassManifest object. Simply cast it:

classManifest[T].erasure.asInstanceOf[Class[A]]

EDIT:

If you have a subclass B of A:

scala> class A

scala> def f(clazz: java.lang.Class[_ <: A]) = ()

scala> def g[T <: A : Manifest] = f(classManifest[T].erasure.asInstanceOf[Class[A]])

scala> g[A]

scala> class B extends A

scala> g[B]