What causes "rawType must be of type Class, but was " + rawType" in google/gson?

Pass the raw Class as the first argument, e.g. TypeToken.getParameterized(Map.class, keyType, valueType).

google/gson · error · IllegalArgumentException

rawType must be of type Class, but was " + rawType

Error message

rawType must be of type Class, but was " + rawType

What it means

Thrown by TypeToken.getParameterized when the first argument (rawType) is not an instance of java.lang.Class. The API contract requires a Class so it can read its type parameters; passing any other Type (ParameterizedType, GenericArrayType, TypeVariable, WildcardType) is rejected. This mirrors OpenJDK bug JDK-8250659 referenced in the source.

Source

Thrown at gson/src/main/java/com/google/gson/reflect/TypeToken.java:393

   *
   * As seen here the result is a {@code TypeToken<?>}; this method cannot provide any type-safety,
   * and care must be taken to pass in the correct number of type arguments.
   *
   * <p>If {@code rawType} is a non-generic class and no type arguments are provided, this method
   * simply delegates to {@link #get(Class)} and creates a {@code TypeToken(Class)}.
   *
   * @throws IllegalArgumentException If {@code rawType} is not of type {@code Class}, or if the
   *     type arguments are invalid for the raw type
   */
  public static TypeToken<?> getParameterized(Type rawType, Type... typeArguments) {
    Objects.requireNonNull(rawType);
    Objects.requireNonNull(typeArguments);

    // Perform basic validation here because this is the only public API where users
    // can create malformed parameterized types
    if (!(rawType instanceof Class)) {
      // See also https://bugs.openjdk.org/browse/JDK-8250659
      throw new IllegalArgumentException("rawType must be of type Class, but was " + rawType);
    }
    Class<?> rawClass = (Class<?>) rawType;
    TypeVariable<?>[] typeVariables = rawClass.getTypeParameters();

    int expectedArgsCount = typeVariables.length;
    int actualArgsCount = typeArguments.length;
    if (actualArgsCount != expectedArgsCount) {
      throw new IllegalArgumentException(
          rawClass.getName()
              + " requires "
              + expectedArgsCount
              + " type arguments, but got "
              + actualArgsCount);
    }

    // For legacy reasons create a TypeToken(Class) if the type is not generic
    if (typeArguments.length == 0) {
      return get(rawClass);

View on GitHub (pinned to 8b8628c656)

Solutions

Pass the raw Class as the first argument, e.g. TypeToken.getParameterized(Map.class, keyType, valueType).
If you already have a full Type (including type arguments), use TypeToken.get(type) instead of getParameterized.
Extract the raw class with GsonTypes.getRawType(type) and pass that to getParameterized.
For owner-type-bearing nested generics, use GsonTypes.newParameterizedTypeWithOwner directly.

Example fix

// before
Type mapType = ...; // a ParameterizedType
TypeToken.getParameterized(mapType, String.class); // throws

// after
TypeToken.getParameterized(Map.class, String.class, valueType);

Defensive patterns

Strategy: validation

Validate before calling

import java.lang.reflect.Type;

TypeToken<?> safeGetParameterized(Type rawType, Type... args) {
  if (!(rawType instanceof Class)) {
    // Either extract the raw class or use TypeToken.get for a fully-formed Type
    Class<?> rawClass = com.google.gson.internal.GsonTypes.getRawType(rawType);
    return TypeToken.getParameterized(rawClass, args);
  }
  return TypeToken.getParameterized(rawType, args);
}

Type guard

static boolean isRawClassType(Type t) {
  return t instanceof Class;
}

Prevention

Always pass a Class as the first argument to TypeToken.getParameterized.
If you hold a full Type, use TypeToken.get(type) instead.
Use GsonTypes.getRawType(type) to coerce a Type to its raw Class when needed.
Document the rawType-is-Class contract on wrappers around getParameterized.

When it happens

Trigger: Calling TypeToken.getParameterized(someParameterizedType, ...) where someParameterizedType is itself a ParameterizedType or a Type obtained reflectively rather than a raw Class. The instanceof Class check at TypeToken.java:391 fails.

Common situations: Programmatically building nested generic types from reflectively-obtained Type objects; passing List.class vs a TypeToken's full getType() by mistake; copy-pasting from code that used GsonTypes.newParameterizedTypeWithOwner (which accepts Type) into getParameterized.

Related errors

AI-assisted analysis of google/gson@8b8628c656 (2026-08-04). Data as JSON: /data/errors/448868e961ce3558.json. Report an issue: GitHub.