review: fix issue related with overridden methods retrieved from getAllMethods

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

@@ -50,6 +50,7 @@
 import spoon.support.compiler.SnippetCompilationHelper;
 import spoon.support.util.QualifiedNameBasedSortedSet;
 import spoon.support.util.SignatureBasedSortedSet;
+import spoon.support.visitor.ClassTypingContext;
 
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
@@ -891,9 +892,16 @@ public Collection<CtExecutableReference<?>> getAllExecutables() {
 	public Set<CtMethod<?>> getAllMethods() {
 		final Set<String> distinctSignatures = new HashSet<>();
 		final Set<CtMethod<?>> l = new SignatureBasedSortedSet<>();
+		final ClassTypingContext ctc = new ClassTypingContext(this);
 		map(new AllTypeMembersFunction(CtMethod.class)).forEach(new CtConsumer<CtMethod<?>>() {
 			@Override
 			public void accept(CtMethod<?> method) {
+				for (CtMethod<?> methods : l) {
+					if (ctc.isSameSignature(methods, method)) {
+						return;
+					}
+				}
+
 				if (distinctSignatures.add(method.getSignature())) {
 					l.add(method);
 				}

src/main/java/spoon/support/visitor/ClassTypingContext.java

@@ -423,6 +423,9 @@ private CtTypeReference<?> getEnclosingType(CtTypeReference<?> typeRef) {
 	 */
 	@Override
 	protected CtTypeReference<?> adaptTypeParameter(CtTypeParameter typeParam) {
+		if (typeParam == null) {
+			return null;
+		}
 		CtFormalTypeDeclarer declarer = typeParam.getTypeParameterDeclarer();
 		if ((declarer instanceof CtType<?>) == false) {
 			return null;
@@ -643,7 +646,7 @@ private CtTypeReference<?> adaptTypeForNewMethod(CtTypeReference<?> typeRef) {
 		if (typeRef instanceof CtTypeParameterReference) {
 			CtTypeParameterReference typeParamRef = (CtTypeParameterReference) typeRef;
 			CtTypeParameter typeParam = typeParamRef.getDeclaration();
-			if (typeParam.getTypeParameterDeclarer() instanceof CtExecutable) {
+			if (typeParam != null && typeParam.getTypeParameterDeclarer() instanceof CtExecutable) {
 				//the parameter is declared in scope of Method or Constructor
 				return typeRef.clone();
 			}

src/test/java/spoon/reflect/declaration/CtTypeInformationTest.java

@@ -1,6 +1,8 @@
 package spoon.reflect.declaration;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static spoon.testing.utils.ModelUtils.build;
 
 import java.lang.reflect.Field;
@@ -140,8 +142,8 @@ public void testGetSuperclass() throws Exception {
 		final CtType<?> subClass = this.factory.Type().get(Subclass.class);
 		assertEquals(2, subClass.getMethods().size());
 
-		// the abstract method from Comparable which is overridden is also present in the model
-		assertEquals(61+3, subClass.getAllMethods().size());
+		// the abstract method from Comparable which is overridden should not be present in the model
+		assertEquals(61+2, subClass.getAllMethods().size());
 
 		CtTypeReference<?> superclass = subClass.getSuperclass();
 		Assert.assertEquals(ExtendsObject.class.getName(), superclass.getQualifiedName());
@@ -172,4 +174,22 @@ public void testGetSuperclass() throws Exception {
 				type2.getMethodsByName("foo").get(0).getSignature());
 
 	}
+
+	@Test
+	public void testGetAllMethodsWontReturnOverriddenMethod() {
+		final CtType<?> subClass = this.factory.Type().get(Subclass.class);
+		Set<CtMethod<?>> listCtMethods = subClass.getAllMethods();
+
+		boolean detectedCompareTo = false;
+		for (CtMethod<?> ctMethod : listCtMethods) {
+			if (ctMethod.getSimpleName().equals("compareTo")) {
+				assertFalse(ctMethod.hasModifier(ModifierKind.ABSTRACT));
+				assertFalse(ctMethod.getParameters().get(0).getType() instanceof CtTypeParameter);
+				assertEquals("Object", ctMethod.getParameters().get(0).getType().getSimpleName());
+				detectedCompareTo = true;
+			}
+		}
+
+		assertTrue(detectedCompareTo);
+	}
 }