Java implement multiple interfaces results in compilation error - maven

Question

I'm building an application using Spring webmvc + data jpa with Java 8. I have entities inheritance like:
public class BaseEntity {...}
public class Report extends BaseEntity {...}
public class BlahBlah extends BaseEntity {...}
On the other hand, to enable CRUD operations on the entities, some repository interfaces are created as below:
/**
* Read-only repository.
* See reference article
*/
#NoRepositoryBean
public interface BaseRepository<T extends BaseEntity> extends Repository<T, Long> {
T findOne(Long id);
Iterable<T> findAll();
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pagable);
}
And for each inherited entity class there's a repository interface:
public interface ReportRepository extends BaseRepository<Report>, PagingAndSortingRepository<Report, Long> { }
The client code looks like this: (ReportController.java)
Report entity = reportRepo.findOne(id);
The application compiles and runs as we expected in eclipse. However when I try to package it using maven, there're several compilation errors, which are all similar to:
ReportController.java:[66,43] reference to findOne is ambiguous
both method findOne(ID) in org.springframework.data.repository.CrudRepository
and method findOne(java.lang.Long) in com.myapp.repositories.BaseRepository
match
I don't quite understand the problem here. Yes, there's Type Erasure. But I also remember that if class BaseRepository<T> extends Repository<T, Long>, then BaseRepository will carry some information about the Type Argument passed to Repository. Isn't it?
If no, then how does JDK provides methods java.lang.Class.getGenericSuperclass() and java.lang.reflect.ParameterizedType.getActualTypeArguments()?
If yes, then there should not be ambiguous methods because both interfaces have the same method findOne(Long)...
Any explaination? Thanks.
Updated:
For you to reproduce the issue with ease, I created a tiny project at https://github.com/guogin/problemapp. Please checkout.

Answer 1

OK, I'm back to answer the question myself.
Inspired by comment from Didier L, I tried to look up in the JLS. And now I have the answer.
First, jls-§9.4.1 states:
An interface I inherits from its direct superinterfaces all abstract and default methods m for which all of the following are true:
m is a member of a direct superinterface, J, of I.
No method declared in I has a signature that is a subsignature (§8.4.2) of the signature of m.
There exists no method m' that is a member of a direct superinterface, J', of I (m distinct from m', J distinct from J'), such that m' overrides from J' the declaration of the method m.
In my sample code:
I = ReportRepository
J1 = BaseRepository<Report>
m1 = findOne(Long) from J1
J2 = PagingAndSortingRepository<Report, Long>
m2 = findOne(Long) from J2
Because J2 is not superinterface of J1 - So I actually inherits both m1 and m2 - that is to say, one findOne(Long) from BaseRepository<Report>, the other from PagingAndSortingRepository<Report, Long>.
The interface ReportRepository is itself syntax correct because both methods are inherit from super interfaces:
jls-§9.4
It is a compile-time error for the body of an interface to declare, explicitly or implicitly, two methods with override-equivalent signatures (§8.4.2). However, an interface may inherit several abstract methods with such signatures (§9.4.1).
And no clashes occurs.
In my example, the compilation error actually occurs at the caller method. So I further refer to jls-§15.12.2.5: Choosing the Most Specific Method.
It turns out that, when compiling the code ReportController especially the call to ReportRepository.findOne(Long), the compiler must find the more specific method between m1 and m2. But then it find both are equally specific. Thus a compile-time error of 'ambiguous method call' occurs. That's what happened.
It turns out the eclipse compilation is not as standard as maven.