Casting generic class is warning in eclipse but error in javac

Question

I'm seeing a major difference in behavior between Eclipse and javac for the following code:

public class TestIncompatibleTypes {

    private static <V> void libraryMethod(Class<? extends List<V>> in) {}

    public static void main(String[] args) {
        // Eclipse warns about 'Unchecked cast'
        // Maven fails with 'incompatible types'
        Class<? extends List<String>> l = (Class<? extends List<String>>) ArrayList.class;
        libraryMethod(l);
    }
}

Eclipse issues an 'unchecked cast' warning for the above code, but it successfully compiles. Javac generates an error:

$ java -version
openjdk version "1.8.0_72-internal"
OpenJDK Runtime Environment (build 1.8.0_72-internal-b15)
OpenJDK 64-Bit Server VM (build 25.72-b15, mixed mode)
$ javac -version
javac 1.8.0_72-internal
$ javac -source 8 TestIncompatibleTypes.java
TestIncompatibleTypes.java:13: error: incompatible types: Class<ArrayList> cannot be converted to Class<? extends List<String>>
        Class<? extends List<String>> l = (Class<? extends List<String>>) ArrayList.class;
                                                                                   ^
1 error

Can anyone explain why javac disallows the cast? My understanding is that they should be completely equivalent after type erasure.

Is there a workaround to get this to compile on both compilers?

As long as you're using unchecked casting anyway, what about `Class extends List> l = (Class) ArrayList.class;` ? — khelwood, Apr 21 '16 at 15:38

score 3 · Accepted Answer · edited May 23 '17 at 12:15

Is there a workaround to get this to compile on both compilers?

Class<? extends List<String>> clazz;
// casting to interim type
clazz = (Class<? extends List<String>>) (Class<? extends List>) ArrayList.class;
// raw types .......
clazz = (Class) ArrayList.class;

HOWEVER! This code deserves an explanation of why it works and when it might not be safe:

java.util.ArrayList has no particular constraints for its type variable.
java.lang.Class is immutable and can only be used to create new instances.

If you use different types besides ArrayList and Class, this same casting can cause heap pollution by e.g. casting away important information:

class IntegerList extends ArrayList<Integer> {}
// now we can create a new instance and put String in a List<Integer>
Class<? extends List<String>> clazz =
    (Class<? extends List<String>>) (Class<? extends List>) IntegerList.class;

(I'm also going to make the caveat that it could still be possible to cause heap pollution using ArrayList.class and I just haven't thought hard enough about it.)

In Java 8, we should prefer lambdas to reflection for instance creation, which avoids this entire problem:

static <V> void libraryMethod(Supplier<? extends List<V>> in) {}
void somewhere() {
    Supplier<? extends List<String>> supplier = ArrayList::new;
    libraryMethod(supplier);
}

Of course if you can't use this for some reason, then you are a little stuck doing the occasional kludgy thing with Class.

Can anyone explain why javac disallows the cast?

Java doesn't allow "sideways" casts, e.g.:

Number n = ...;
String s = (Number) n; // compiler error

I explained how this works for the raw type argument here and here.

The short explanation is that there is a subtyping relationship like this:

           Class<? extends List>
            ╱                 ╲
Class<? extends List<String>>  Class<ArrayList>

Both are subtypes of Class<? extends List> and neither one is a subtype nor a supertype of the other.

Excellent response. Your subtyping tree makes the reason for the error quite clear, although the prohibition against sideways casting seems odd considering that a cast is something inherently risky (at least from the compiler's perspective). — Quantum7, Apr 22 '16 at 07:59
Sideways casts don't compile for non-generic types because you can determine that the cast will always fail (except for `null`). It's true that this is not always the case for generic types. — Radiodef, Apr 22 '16 at 16:04

score 1 · Answer 2 · answered Apr 21 '16 at 15:40

1

Looks like you're casting a Class<ArrayList>> to Class<? extends List<String>>, but the ArrayList class doesn't have that kind of generic. I'm not sure if you need the <String> generic for your Class<? extends List>

answered Apr 21 '16 at 15:40

Zircon

4,677
15
32

2

@JoopEggen Try that and see if it works. It would work for `libraryMethod(Class extends List>)` but it does not work for `libraryMethod(Class extends List>)` – khelwood Apr 21 '16 at 15:47

Casting generic class is warning in eclipse but error in javac

2 Answers2