feature: CtMethod#isOverriding(CtMethod)

src/main/java/spoon/reflect/declaration/CtMethod.java

@@ -29,6 +29,12 @@ public interface CtMethod<T> extends CtExecutable<T>, CtTypeMember, CtFormalType
 	 */
 	boolean isSameSignature(CtMethod<?> thatMethod, boolean canTypeErasure);
 
+	/**
+	 * @param superMethod to be checked method
+	 * @return true if this method overrides `superMethod`
+	 */
+	boolean isOverriding(CtMethod<?> superMethod);
+
 	/**
 	 * Checks if the method is a default method. Default method can be in interfaces from
 	 * Java 8: http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html.

src/main/java/spoon/reflect/visitor/filter/OverriddenMethodFilter.java

@@ -40,8 +40,7 @@ public OverriddenMethodFilter(CtMethod<?> method) {
 	public boolean matches(CtMethod<?> element) {
 		final CtType expectedParent = method.getParent(CtType.class);
 		final CtType<?> currentParent = element.getParent(CtType.class);
-		return expectedParent.isSubtypeOf(currentParent.getReference()) //
-				&& !currentParent.equals(expectedParent) //
-				&& method.getReference().isOverriding(element.getReference());
+		return !currentParent.equals(expectedParent) //
+				&& method.isOverriding(element);
 	}
 }

src/main/java/spoon/reflect/visitor/filter/OverridingMethodFilter.java

@@ -40,8 +40,7 @@ public OverridingMethodFilter(CtMethod<?> method) {
 	public boolean matches(CtMethod<?> element) {
 		final CtType expectedParent = method.getParent(CtType.class);
 		final CtType<?> currentParent = element.getParent(CtType.class);
-		return currentParent.isSubtypeOf(expectedParent.getReference()) //
-				&& !currentParent.equals(expectedParent) //
-				&& element.getReference().isOverriding(method.getReference());
+		return !currentParent.equals(expectedParent) //
+				&& element.isOverriding(method);
 	}
 }

src/main/java/spoon/support/reflect/declaration/CtMethodImpl.java

@@ -252,6 +252,24 @@ public boolean isSameSignature(CtMethod<?> thatMethod, boolean canTypeErasure) {
 		return true;
 	}
 
+	@Override
+	public boolean isOverriding(CtMethod<?> superMethod) {
+		if (this == superMethod) {
+			return true;
+		}
+		if (isSameSignature(superMethod, true) == false) {
+			return false;
+		}
+		CtType<?> thisDeclType = getDeclaringType();
+		CtType<?> superDeclType = superMethod.getDeclaringType();
+		if (thisDeclType == superDeclType) {
+			//if two different methods are declared in the same type then they cannot override
+			return false;
+		}
+		//methods override if thisDeclType is subtype of superDeclType
+		return thisDeclType.isSubtypeOf(superDeclType.getReference());
+	}
+
 	/**
 	 * adapt all CtTypeParameterReference to targetType
 	 * @param types list of to be adapted types

src/test/java/spoon/test/filters/FilterTest.java

@@ -538,6 +538,7 @@ class Context {
 		// actual evaluation
 		q.forEach((CtMethod<?> method) -> {
 			assertTrue(context.method.getReference().isOverriding(method.getReference()));
+			assertTrue(context.method.isOverriding(method));
 			context.count++;
 		});
 		// sanity check

src/test/java/spoon/test/method_overriding/MethodOverriddingTest.java

@@ -0,0 +1,74 @@
+package spoon.test.method_overriding;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import org.junit.Test;
+
+import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.factory.Factory;
+import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.testing.utils.ModelUtils;
+
+import static org.junit.Assert.*;
+
+public class MethodOverriddingTest {
+
+	@Test
+	public void testMethodOverride() {
+		checkMethodOverride((m1, m2)->m1.isOverriding(m2));
+	}
+	@Test
+	public void testMethodOverrideByReference() {
+		checkMethodOverride((m1, m2)->m1.getReference().isOverriding(m2.getReference()));
+	}
+
+	private void checkMethodOverride(BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		Factory factory = ModelUtils.build(new File("src/test/java/spoon/test/method_overriding/testclasses").listFiles());
+		Map<String, List<CtMethod>> methodsByName = new HashMap<>();
+		factory.getModel().getRootPackage().filterChildren(new TypeFilter<>(CtMethod.class)).forEach((CtMethod m)->{
+			List<CtMethod> methods = methodsByName.get(m.getSimpleName());
+			if(methods==null) {
+				methods = new ArrayList<>();
+				methodsByName.put(m.getSimpleName(), methods);
+			}
+			methods.add(m);
+		});
+		for (Map.Entry<String, List<CtMethod>> e : methodsByName.entrySet()) {
+			combine(e.getValue(), 0, isOverriding);
+		}
+	}
+
+	private void combine(List<CtMethod> value, int start, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		CtMethod m1 = value.get(start);
+		if(start+1<value.size()) {
+			for (CtMethod m2 : value.subList(start+1, value.size())) {
+				if(m1.getDeclaringType().isSubtypeOf(m2.getDeclaringType().getReference())) {
+					checkOverride(m1, m2, isOverriding);
+				} else if(m2.getDeclaringType().isSubtypeOf(m1.getDeclaringType().getReference())) {
+					checkOverride(m2, m1, isOverriding);
+				} else {
+					checkNotOverride(m1, m2, isOverriding);
+				}
+			}
+			combine(value, start+1, isOverriding);
+		}
+	}
+
+	private void checkOverride(CtMethod m1, CtMethod m2, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		assertTrue(descr(m1)+" overriding "+descr(m2), 		isOverriding.apply(m1, m2));
+		assertFalse(descr(m2)+" NOT overriding "+descr(m1), isOverriding.apply(m2, m1));
+	}
+	private void checkNotOverride(CtMethod m1, CtMethod m2, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		assertFalse(descr(m1)+" NOT overriding "+descr(m2), isOverriding.apply(m1, m2));
+		assertFalse(descr(m2)+" NOT overriding "+descr(m1), isOverriding.apply(m2, m1));
+	}
+
+	private String descr(CtMethod m) {
+		return m.getDeclaringType().getSimpleName()+"#"+m.getSimpleName();
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/A.java

@@ -0,0 +1,24 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class A<U> {
+
+	public A() {
+	}
+
+	A<U> m1(C c){
+		return null;
+	}
+
+	<T extends A<U>> T m2(C c){
+		return null;
+	}
+
+	void m3(List<? super C> c){
+	}
+	void m4(List<? extends A<U>> c){
+	}
+	void m5(U u) {
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/B.java

@@ -0,0 +1,32 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class B<S, R extends S> extends A<S> {
+
+	public B() {
+	}
+
+	@Override
+	B<S, R> m1(C c){
+		return null;
+	}
+
+	@Override
+	<T extends A<S>> T m2(C c){
+		return null;
+	}
+
+	@Override
+	void m3(List<? super C> c){
+	}
+
+	@Override
+	void m5(S u) {
+		super.m5(u);
+	}
+
+	@Override
+	void m4(List<? extends A<S>> c) {
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/C.java

@@ -0,0 +1,30 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.io.FilterInputStream;
+import java.io.InputStream;
+import java.util.List;
+
+public class C extends B<InputStream, FilterInputStream> {
+
+	public C() {
+	}
+
+	@Override
+	B m1(C c){
+		return null;
+	}
+
+	@Override
+	B<InputStream, FilterInputStream> m2(C c){
+		return null;
+	}
+	@Override
+	void m4(List<? extends A<InputStream>> c){
+	}
+
+	@Override
+	void m5(InputStream u) {
+		super.m5(u);
+	}
+
+}

src/test/java/spoon/test/method_overriding/testclasses/D.java

@@ -0,0 +1,24 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class D extends B<Integer, Integer> {
+
+	public D() {
+	}
+
+	@Override
+	B<Integer, Integer> m1(C c){
+		return null;
+	}
+
+	@Override
+	D m2(C c){
+		return null;
+	}
+
+	@Override
+	void m4(List<? extends A<Integer>> c){
+	}
+
+}

src/test/java/spoon/test/method_overriding/testclasses/IA.java

@@ -0,0 +1,5 @@
+package spoon.test.method_overriding.testclasses;
+
+public interface IA {
+
+}