How to correctly parameterize non-static method with upper bound?

I need to write parameterized method that would return collection of type T, where T can be object of any class that inherits I. It's trivial if T is defined on class level, but I need generic non-static method. Can't understand compiler, anything below seems logical to me.

public class Foo {

    public <T extends I> Collection<T> test(Class<T> clazz) {
        List<B> list = new ArrayList<>();
        list.add(new B());
        return list; // compilation error: required type Collection<T>
                     //                    provided List<B>
    }

    interface I {}

    interface A extends I {}

    class B implements A {}
}

It's not the compiler that's confusing you, it's the concepts themselves.

Let's make this very pragmatic: We have a class type hierarchy: Apple and Pear both extend Fruit, and Fruit extends Object.

Here's the key realization:

A List<Apple> cannot just be treated as a List<Fruit>.

Imagine you could do that:

List<Apple> apples = new ArrayList<Apple>();
List<Fruit> fruits = apples; // This is not legal
fruits.add(new Pear());
Apple apple = apples.get(0); // but apples.get(0) is.. a pear???

That's why you can't do that. The difference is: You can 'write' apples and pears INTO a collection.

If you want to learn all about it, it's called 'variance'. Something like Fruit fruit = new Apple(); is covariance in action (the type itself and any subtype thereof is fine). But generics is invariant, because it has to be, see above example. There's even contravariance, where a type or any supertype thereof is fine. In generics you have to explicitly choose variance:

List<? extends Fruit> fruits = new ArrayList<Apple>(); // covariance
List<? super Apple> apples = new ArrayList<Fruit>(); // contravariance
List<Fruit> fruits = new ArrayList<Fruit>(); // invariance (Default)

When you have a 'covariant fruits' list, you cannot add anything to it. At all*.

When you have a 'contravariant fruits' list, you can add just fine, but you cannot get anything from it. Or rather, whenever you get results out, their type is just Object, that works only because everything is guaranteed to be an Object.

With an 'invariant fruits' list, you can add and get just fine.

Change your code to read: public <T extends I> Collection<? extends T> test(... and it'll work. But test(B.class).add(new B()); wouldn't. You can't have both work, because fundamentally that cannot work.

*) Except literally null because its every type. Irrelevant for the general principle of variance.