quarkusio/quarkus · error · IllegalArgumentException

Invalid argument combination ${requiredType}; ${beanType}

Error message

Invalid argument combination ${requiredType}; ${beanType}

What it means

BeanTypeAssignabilityRules.matches() compares a required parameterized type with a bean's parameterized type. If the raw types are equal but the number of actual type arguments differs (e.g. comparing `List<String>` with a raw `List` or a differently-erased generic), ArC throws IllegalArgumentException because assignability cannot be evaluated for mismatched arity. This normally indicates corrupted or improperly resolved type information.

Source

Thrown at independent-projects/arc/runtime/src/main/java/io/quarkus/arc/impl/BeanTypeAssignabilityRules.java:96

     *
     */
    private boolean matches(Class<?> type1, ParameterizedType type2) {
        if (!type1.equals(Types.getRawType(type2))) {
            return false;
        }
        return Types.isArrayOfUnboundedTypeVariablesOrObjects(type2.getActualTypeArguments());
    }

    /**
     * A parameterized bean type is considered assignable to a parameterized required type if they have identical raw type and
     * for each parameter:
     */
    private boolean matches(ParameterizedType requiredType, ParameterizedType beanType) {
        if (!requiredType.getRawType().equals(beanType.getRawType())) {
            return false;
        }
        if (requiredType.getActualTypeArguments().length != beanType.getActualTypeArguments().length) {
            throw new IllegalArgumentException("Invalid argument combination " + requiredType + "; " + beanType);
        }
        for (int i = 0; i < requiredType.getActualTypeArguments().length; i++) {
            if (!parametersMatch(requiredType.getActualTypeArguments()[i], beanType.getActualTypeArguments()[i])) {
                return false;
            }
        }
        return true;
    }

    /*
     * Actual type parameters
     */

    protected boolean parametersMatch(Type requiredParameter, Type beanParameter) {
        if (Types.isActualType(requiredParameter) && Types.isActualType(beanParameter)) {
            /*
             * the required type parameter and the bean type parameter are actual types with identical raw type, and, if the
             * type is parameterized, the bean

View on GitHub (pinned to e1c734241f)

Solutions

1. Ensure the required type you pass to BeanManager.getBeans()/injection resolution carries the same number of type arguments as the bean type (avoid raw types).
2. In portable extensions, build required types with Types utilities (e.g. Types.getParameterizedType) instead of assembling ParameterizedType by hand.
3. Check for mixed ArC/library versions that could resolve generics inconsistently; do a clean rebuild.

Example fix

// before
Type required = ArrayList.class; // raw type, 0 args vs bean's ArrayList<String>

// after
Type required = Types.getParameterizedType(ArrayList.class, String.class); // match arity

static boolean arityMatches(ParameterizedType a, ParameterizedType b) {
    return a.getRawType().equals(b.getRawType())
        && a.getActualTypeArguments().length == b.getActualTypeArguments().length;
}

static boolean isFullyParameterized(Type t) {
    return !(t instanceof ParameterizedType)
        || ((ParameterizedType) t).getActualTypeArguments().length > 0;
}

try {
    resolveBean(requiredType);
} catch (IllegalArgumentException e) {
    if (!e.getMessage().startsWith("Invalid argument combination")) throw e;
    // log malformed type and skip
}

When it happens

Trigger: Resolving/injecting beans whose required Type is a ParameterizedType whose actual-type-argument count differs from the bean's resolved ParameterizedType (e.g. raw types mixed with generics, or hand-built ParameterizedType instances).

Common situations: Custom extension/portable-extension code constructing Type instances manually; reflection-obtained types where a raw class was used instead of its generic form; classloader/version mismatches giving inconsistent generic signatures.

Related errors

• Producer method return type is a parameterized type with a t
• Event#select(Class<U>, Annotation...) cannot be used with ty
• Unsupported injection point target: <injectionPoint>
• Unable to determine if the '${unsecuredMethod}' method shoul
• Method ${method} of class ${beanClass} is not a producer met

AI-assisted analysis of quarkusio/quarkus@e1c734241f (2026-09-05). Data as JSON: /api/errors/b7609777fe70b842. Report an issue: GitHub.