Well, it passes all my tests.  Here is one, if you wanna try it also:

<sscce>
import java.lang.reflect.*;
import java.util.*;

public class RawTypeTest {
    static List<String> list = new ArrayList<String>();

    public static void main(String[] args) throws Exception {
        ParameterizedType type
                = (ParameterizedType)RawTypeTest.class
                        .getDeclaredField("list").getGenericType();
        Class rawType = (Class)type.getRawType();
        System.out.println("raw type of " + type + " is " + rawType);
    }
}
</sscce>

In addition to that, I've even checked Sun's implementation of
ParameterizedType
(sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl), and the
getRawType() method's return type is declared as Class<?> there.

The following added to the above example shows that:

    System.out.println("getRawType() return type is "
            + type.getClass()
                    .getMethod("getRawType", (Class<?>[]) null)
                    .getGenericReturnType());

However, all the observations above, doesn't solve my problem.

I'm writing a generic utility for reflective retrieval of actual type
arguments based on a given class type hierarchy.  And I'm not sure if
the above assumption is valid for all possible parameterized types Java
runtime may create?

On the other hand, assuming that there is no other possibility to
represent a raw type in runtime, why getRawType() return type is not
declared as a Class<?> in ParameterizedType interface (as in its
internal implementation)?  It would be easier to use declared that way.

piotr