review 1: feature: CtTypeParameter#getTypeDeclarer()

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

@@ -34,6 +34,12 @@ public interface CtTypeParameter extends CtType<Object> {
 	@DerivedProperty
 	CtTypeParameterReference getReference();
 
+	/**
+	 * @return the {@link CtFormalTypeDeclarer}, which declares this {@link CtTypeParameter}
+	 */
+	@DerivedProperty
+	CtFormalTypeDeclarer getTypeParameterDeclarer();
+
 	// override the return type
 	@Override
 	CtTypeParameter clone();

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

@@ -342,6 +342,8 @@ public CtTypeParameterReference createReference(CtTypeParameter type) {
 			ref.addAnnotation(ctAnnotation.clone());
 		}
 		ref.setSimpleName(type.getSimpleName());
+		//TypeParameter reference without parent is unusable. It lost information about it's declarer
+		ref.setParent(type);
 		return ref;
 	}
 

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

@@ -17,12 +17,14 @@
 package spoon.support.reflect.declaration;
 
 import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtModifiable;
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.ModifierKind;
+import spoon.reflect.declaration.ParentNotInitializedException;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.reference.CtTypeParameterReference;
@@ -78,6 +80,15 @@ public CtTypeParameter clone() {
 		return (CtTypeParameter) super.clone();
 	}
 
+	@Override
+	public CtFormalTypeDeclarer getTypeParameterDeclarer() {
+		try {
+			return getParent(CtFormalTypeDeclarer.class);
+		} catch (ParentNotInitializedException e) {
+			return null;
+		}
+	}
+
 	@Override
 	@UnsettableProperty
 	public <F, C extends CtType<Object>> C addFieldAtTop(CtField<F> field) {

src/test/java/spoon/test/generics/ClassThatBindsAGenericType.java

@@ -4,13 +4,10 @@
 import java.util.ArrayList;
 
 @SuppressWarnings("serial")
-public class ClassThatBindsAGenericType extends ArrayList<File> {
+class ClassThatBindsAGenericType extends ArrayList<File> {
 
 	public static void main(String[] args) throws Exception {
 	}
 
 }
 
-class ClassThatDefinesANewTypeArgument<T> {
-	void foo(T t){}
-}

src/test/java/spoon/test/generics/ClassThatDefinesANewTypeArgument.java

@@ -0,0 +1,5 @@
+package spoon.test.generics;
+
+public class ClassThatDefinesANewTypeArgument<T> {
+	void foo(T t){}
+}

src/test/java/spoon/test/generics/GenericsTest.java

@@ -4,6 +4,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertSame;
 import static spoon.testing.utils.ModelUtils.build;
 import static spoon.testing.utils.ModelUtils.buildClass;
 import static spoon.testing.utils.ModelUtils.buildNoClasspath;
@@ -29,6 +30,7 @@
 import spoon.reflect.declaration.CtConstructor;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtNamedElement;
@@ -141,8 +143,9 @@ public void testModelBuildingSimilarSignatureMethods() throws Exception {
 
 	@Test
 	public void testTypeParameterReference() throws Exception {
-		CtClass<?> classThatBindsAGenericType = build("spoon.test.generics", "ClassThatBindsAGenericType");
-		CtClass<?> classThatDefinesANewTypeArgument = classThatBindsAGenericType.getPackage().getElements(new NameFilter<CtClass<?>>("ClassThatDefinesANewTypeArgument")).get(0);
+		Factory factory = build(ClassThatBindsAGenericType.class, ClassThatDefinesANewTypeArgument.class);
+		CtClass<?> classThatBindsAGenericType = factory.Class().get(ClassThatBindsAGenericType.class);
+		CtClass<?> classThatDefinesANewTypeArgument = factory.Class().get(ClassThatDefinesANewTypeArgument.class);
 
 		CtTypeReference<?> tr1 = classThatBindsAGenericType.getSuperclass();
 		CtTypeReference<?> trExtends = tr1.getActualTypeArguments().get(0);
@@ -161,6 +164,15 @@ public void testTypeParameterReference() throws Exception {
 		assertEquals("T", tr3.getSimpleName());
 	}
 
+	@Test
+	public void testTypeParameterDeclarer() throws Exception {
+		// contract: one can navigate to the declarer of a type parameter
+		CtClass<?> classThatDefinesANewTypeArgument = build("spoon.test.generics", "ClassThatDefinesANewTypeArgument");
+		CtTypeParameter typeParam = classThatDefinesANewTypeArgument.getFormalCtTypeParameters().get(0);
+		assertSame(classThatDefinesANewTypeArgument, typeParam.getTypeParameterDeclarer());
+		assertSame(typeParam, typeParam.getReference().getDeclaration());
+	}
+
 	@Test
 	public void testGenericMethodCallWithExtend() throws Exception {
 		CtClass<?> type = build("spoon.test.generics", "GenericMethodCallWithExtend");