Calling a function with unbounded generics with L-Value and R-Value

I don't fully understand why the following code, doesn't work:

package org.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public interface MyInt<E> {
    }

    public static final class MyNum<E> implements MyInt<E> {
        private E privados;
    }

    public static void f(List<? extends MyInt> l) {
        System.out.println("from List<?>");
    }

    public static void main(String[] args) {
        var m = new MyNum();
        List<MyNum> l = Arrays.asList(m);

        ArrayList<MyInt> r = l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new));
        f(r);
        f(l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new)));
    }
}

The call f(r) passing the l-value works, but the call to the r-value version in the next line doesn't.

It is clear that the constraint solving process happening in the compiler is happy when we have a specific ArrayList<MyInt> enforced by the programmer, but when we ask it to do the constraint solving end-to-end by passing the result of collect directly to f, the compiler would send an error like this:

java: incompatible types: inferred type does not conform to upper bound(s)
    inferred: java.lang.Object&java.util.List<? extends org.example.Main.MyInt>&java.util.Collection<org.example.Main.MyNum>
    upper bound(s): java.util.Collection<org.example.Main.MyNum>,java.util.List<? extends org.example.Main.MyInt>,java.lang.Object

The only differences between inferred vs upper bound (from the error message):

1. the use of & vs ,
2. The order of objects (reversed)

I am assuming that the order is unimportant (they're sets) and that the & and , have special meaning.

Someone has a more thorough less "hand-wavy" explanation of what's happening?

This inference incosistence is due to lambda expressions. You can get explanations in this mail on OpenJDK.com (subject: JDK-8219318 (???): inferred type does not conform to upper bound(s) when collecting to a HashMap).

Maybe new Java compilers (javac) have solved this problem.

That problem can be solved if you add explicit type. Examples:

f((ArrayList<? extends MyInt>) l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new)));

f((ArrayList<MyInt>) l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new)));

f((List<? extends MyInt>) l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new)));

f((List<MyInt>) l.stream().collect(Collectors.toCollection(ArrayList<MyInt>::new)));

Also, you can provide an implementation of Supplier. In this case, you don't need to add explicit type. Example of anonymous class:

f(l.stream().collect(Collectors.toCollection(new Supplier<List<MyInt>>(){
   @Override
   public List<MyInt> get() {
   return new ArrayList<MyInt>();
  }
})));