Fix Interface method handling

src/main/java/spoon/reflect/factory/MethodFactory.java

@@ -27,17 +27,20 @@
 import spoon.template.Substitution;
 
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.ArrayList;
+import java.util.Arrays;
 
 /**
  * The {@link CtMethod} sub-factory.
  */
 public class MethodFactory extends ExecutableFactory {
 
+	public final Set<CtMethod<?>> OBJECT_METHODS = Collections.unmodifiableSet(factory.Class().get(Object.class).getMethods());
+
 	/**
 	 * Creates a new method sub-factory.
 	 *

src/main/java/spoon/support/reflect/code/CtLambdaImpl.java

@@ -23,11 +23,11 @@
 import spoon.reflect.code.CtExpression;
 import spoon.reflect.code.CtLambda;
 import spoon.reflect.code.CtStatement;
-import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtNamedElement;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.declaration.CtType;
+import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.path.CtRole;
 import spoon.reflect.reference.CtExecutableReference;
@@ -124,6 +124,9 @@ public <R> CtMethod<R> getOverriddenMethod() {
 			lambdaExecutableMethod = lambdaTypeMethods.iterator().next();
 		} else {
 			for (CtMethod<?> method : lambdaTypeMethods) {
+				if (getFactory().Method().OBJECT_METHODS.stream().anyMatch(method::isOverriding)) {
+					continue;
+				}
 				if (method.isDefaultMethod() || method.hasModifier(ModifierKind.PRIVATE) || method.hasModifier(ModifierKind.STATIC)) {
 					continue;
 				}

src/test/java/spoon/test/lambda/LambdaTest.java

@@ -10,7 +10,6 @@
 import spoon.reflect.code.CtLambda;
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.declaration.CtClass;
-import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtParameter;
@@ -403,6 +402,19 @@ public void testLambdaFilter() throws Exception {
 		assertHasStrings(methodNames, "m2", "m4", "m7", "m8");
 	}
 
+	@Test
+	public void testInterfaceWithObjectMethods() throws Exception {
+		// contract Lambda expression works on interfaces with methods inherited from java.lang.Object
+		CtInterface<?> checkPersons = factory.Interface().get(Foo.CheckPersons.class);
+		List<CtLambda<?>> lambdas = foo.filterChildren(new LambdaFilter(checkPersons)).list();
+		assertEquals(2, lambdas.size());
+		CtLambda<?> lambda = lambdas.get(0);
+		assertEquals(2, lambda.getParameters().size());
+		CtMethod<?> method = lambda.getOverriddenMethod();
+		assertTrue(checkPersons.getMethods().contains(method));
+		assertEquals("test", method.getSimpleName());
+	}
+
 	private void assertHasStrings(List<String> methodNames, String... strs) {
 		for (String str : strs) {
 			assertTrue("List should contain "+str+" but it is missing.", methodNames.remove(str));

src/test/java/spoon/test/lambda/testclasses/Foo.java

@@ -1,6 +1,7 @@
 package spoon.test.lambda.testclasses;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
@@ -110,5 +111,6 @@ public interface Check {
 
 	public interface CheckPersons {
 		boolean test(Person p1, Person p2);
+		boolean equals(Object other);
 	}
 }