There is a loophole in the type system that is present because
we made getSuperclass() return a Class with an argument of a generic
type. This comes about because of a cast() operation we recently
added to class Class:

2384 /**
2385 * Casts an object to the class or interface represented
2386 * by this <tt>Class</tt> object.
2387 *
2388 * @param obj the object to be cast
2389 * @return the object after casting, or null if obj is null
2390 *
2391 * @throws ClassCastException if the object is not
2392 * null and is not assignable to the type T.
2393 *
2394 * @since 1.5
2395 */
2396 public T cast(Object obj) {
2397 if (obj != null && !isInstance(obj))
2398 throw new ClassCastException();
2399 return (T) obj;
2400 }

The loophole works like this:

    class A extends List<Integer> {}

    List<String> ls = new List<String>();
    List<Integer> li =
                  A.class.getSuperclass() // Class<List<Integer>>
                  .cast(ls);
    li.add(1);
    String s = ls.get() // BANG!

We can either remove the cast() operator (which would be a shame - it
is really useful - see 4881275) or make the class type returned by
A.class.getSuperclass be Class<List> instead of Class<List<Integer>>.


----------------
See Evaluation section for corrected type loophole snippet.

###@###.### 2004-04-02