Java Ambiguous method when a method has a generic parameter and other method has a generic lambda

Consider the following:

	public void run() {
		run(o -> {});
	}

    //replace CharSequence with whatever except Object
	public <E extends CharSequence> void run(E e) {
	}
	public <E extends CharSequence> void run(Consumer<E> e){
	}

The compiler complains about java reference to run is ambiguous even that the parameter passed is clearly a lambda and only one of the two methods is lambda

The question is why this is happening? Is it a bug? what should the signature be replaced with to achieve the same behavior?

Extra:
IntelliJ says (the class Main does not matter):

Ambiguous method call. Both
run(CharSequence) in Main and
run(Consumer<CharSequence>) in Main match

Note:
replacing CharSequence with ANYTHING except java.lang.Object will produce the same issue!

Also Note:
It does not matter even if the two generics are different and don't relate to each other! As long as they are not java.lang.Object.

So, this will not compile ether:

	public void run() {
		run(o -> {});
	}
	public <E extends ArrayList> void run(E e) {
	}
	public <E extends String> void run(Consumer<E> e){
	}

> Nor a CharSequence can be declared as a lambda

Have a look.

interface WeirdCharSequence extends CharSequence {
  default int length() { return 0; }
  default char charAt(int index) { return 0; }
  default CharSequence subSequence(int start, int end) { return null; }

  void accept(CharSequence i); 
}

proves it can

WeirdCharSequence charSequence = o -> {};
run(charSequence);

o -> {} could mean many things, and there is not enough context to figure out what exactly the lambda represents. You can always help the compiler out by explicitly declaring the desired type.

this.<CharSequence>run(o -> {});

or

Consumer<CharSequence> consumer = o -> {};
run(consumer);

or (personally less preferable)

run((Consumer<CharSequence>)o -> {});

It could be that the compiler sees E as a type that is both a Consumer<CharSequence> and CharSequence.

class ReallyWeirdCharSequence implements Consumer<CharSequence>, CharSequence {
  public void accept(CharSequence i) { }
  public int length() { return 0; }
  public char charAt(int index) { return 0; }
  public CharSequence subSequence(int start, int end) { return null; }
} 

After some investigations, I realized that it is a bug in the java language.

Try that your self:

	public void run() {
		run(o -> {});
	}
	public <E extends Class> void run(E e) {
	}
	public void run(Consumer e) {
	}

Or:

	public void run() {
		run(o -> {});
	}
	public <E extends Class> void run(E e) {
	}
	public <E extends Integer> void run(Consumer<E> e) {
	}

Even that the parameters of both functions don't relate to each other. Somehow the java compiler thinks that they are.

In conclusion, creating a method with a generic parameter will make the method valid as a method that accepts lambda expression.

Guessing now, but everything has a toString method and it's kinda common to implicitly convert things to strings by having the compiler implicitly call it for you. String is of course an inheritor of CharSequence. So the compiler could be complaining that it can't decide between:

run((CharSequence)(o -> {}).toString());

and

run((Consumer<CharSequence>)(o -> {}));