review fix: Manage generics from Interface in shadow mode

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

@@ -45,6 +45,7 @@
 import spoon.support.visitor.java.JavaReflectionTreeBuilder;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.TypeVariable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -314,19 +315,31 @@ public <T> CtArrayTypeReference<T> createArrayReference(String qualifiedName) {
 		return array;
 	}
 
+	public <T> CtTypeReference<T> createReference(Class<T> type) {
+		return createReference(type, false);
+	}
+
 	/**
 	 * Creates a reference to a simple type
 	 */
-	public <T> CtTypeReference<T> createReference(Class<T> type) {
+	public <T> CtTypeReference<T> createReference(Class<T> type, boolean includingFormalTypeParameter) {
 		if (type == null) {
 			return null;
 		}
 		if (type.isArray()) {
 			CtArrayTypeReference<T> array = factory.Core().createArrayTypeReference();
-			array.setComponentType(createReference(type.getComponentType()));
+			array.setComponentType(createReference(type.getComponentType(), includingFormalTypeParameter));
 			return array;
 		}
-		return createReference(type.getName());
+		CtTypeReference typeReference = createReference(type.getName());
+
+		if (includingFormalTypeParameter) {
+			for (TypeVariable<Class<T>> generic : type.getTypeParameters()) {
+				typeReference.addActualTypeArgument(createTypeParameterReference(generic.getName()));
+			}
+		}
+
+		return typeReference;
 	}
 
 	/**

src/main/java/spoon/support/reflect/reference/CtTypeParameterReferenceImpl.java

@@ -204,12 +204,21 @@ public CtTypeParameter getDeclaration() {
 
 		CtElement e = this;
 		CtElement parent = getParent();
+
 		if (parent instanceof CtTypeReference) {
-			if (parent.isParentInitialized() == false) {
-				return null;
+			if (!parent.isParentInitialized()) {
+				// we might enter in that case because of a call
+				// of getSuperInterfaces() for example
+				CtTypeReference typeReference = (CtTypeReference) parent;
+				e = typeReference.getTypeDeclaration();
+				if (e == null) {
+					return null;
+				}
+			} else {
+				parent = parent.getParent();
 			}
-			parent = parent.getParent();
 		}
+
 		if (parent instanceof CtExecutableReference) {
 			CtExecutableReference parentExec = (CtExecutableReference) parent;
 			if (!parentExec.getDeclaringType().equals(e)) {
@@ -222,9 +231,10 @@ public CtTypeParameter getDeclaration() {
 			} else {
 				e = e.getParent(CtFormalTypeDeclarer.class);
 			}
-
 		} else {
-			e = e.getParent(CtFormalTypeDeclarer.class);
+			if (!(e instanceof CtFormalTypeDeclarer)) {
+				e = e.getParent(CtFormalTypeDeclarer.class);
+			}
 		}
 
 		// case #1: we're a type of a method parameter, a local variable, ...

src/main/java/spoon/support/reflect/reference/CtTypeReferenceImpl.java

@@ -41,7 +41,6 @@
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.SpoonClassNotFoundException;
 import spoon.support.reflect.declaration.CtElementImpl;
-import spoon.support.util.QualifiedNameBasedSortedSet;
 import spoon.support.util.RtHelper;
 import spoon.support.visitor.ClassTypingContext;
 
@@ -507,21 +506,12 @@ public CtTypeReference<?> getSuperclass() {
 
 	@Override
 	public Set<CtTypeReference<?>> getSuperInterfaces() {
-		CtType<?> t = getDeclaration();
+		//we need a interface type references whose parent is connected to CtType, otherwise TypeParameterReferences cannot be resolved well
+		CtType<?> t = getTypeDeclaration();
 		if (t != null) {
 			return t.getSuperInterfaces();
-		} else {
-			Class<?> c = getActualClass();
-			Class<?>[] sis = c.getInterfaces();
-			if ((sis != null) && (sis.length > 0)) {
-				Set<CtTypeReference<?>> set = new QualifiedNameBasedSortedSet<CtTypeReference<?>>();
-				for (Class<?> si : sis) {
-					set.add(getFactory().Type().createReference(si));
-				}
-				return set;
-			}
 		}
-		return Collections.emptySet();
+		throw new SpoonException("Cannot provide CtType for " + getQualifiedName());
 	}
 
 	@Override

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

@@ -468,6 +468,9 @@ private List<CtTypeReference<?>> resolveTypeParameters(List<CtTypeReference<?>>
 			if (typeRef instanceof CtTypeParameterReference) {
 				CtTypeParameterReference typeParamRef = (CtTypeParameterReference) typeRef;
 				CtTypeParameter typeParam = typeParamRef.getDeclaration();
+				if (typeParam == null) {
+					throw new SpoonException("The typeParam " + typeRef.getQualifiedName() + " declaration cannot be resolved");
+				}
 				CtFormalTypeDeclarer declarer = typeParam.getTypeParameterDeclarer();
 				typeRef = resolveTypeParameter(declarer, typeParamRef, typeParam, typeRef);
 			}

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

@@ -438,6 +438,18 @@ public void addArrayReference(CtArrayTypeReference<?> typeReference) {
 		contexts.peek().addArrayReference(arrayTypeReference);
 	}
 
+	@Override
+	public <T> void visitClassReference(ParameterizedType type) {
+		final CtTypeReference<Object> typeReference = factory.Core().createTypeReference();
+		typeReference.setSimpleName(((Class) type.getRawType()).getSimpleName());
+
+		enter(new TypeReferenceRuntimeBuilderContext(typeReference));
+		super.visitClassReference(type);
+		exit();
+
+		contexts.peek().addClassReference(typeReference);
+	}
+
 	@Override
 	public <T> void visitClassReference(Class<T> clazz) {
 		final CtTypeReference<Object> typeReference = factory.Core().createTypeReference();
@@ -462,6 +474,18 @@ public <T> void visitInterfaceReference(Class<T> anInterface) {
 		contexts.peek().addInterfaceReference(typeReference);
 	}
 
+	@Override
+	public <T> void visitInterfaceReference(ParameterizedType anInterface) {
+		final CtTypeReference<Object> typeReference = factory.Core().createTypeReference();
+		typeReference.setSimpleName(((Class) anInterface.getRawType()).getSimpleName());
+
+		enter(new TypeReferenceRuntimeBuilderContext(typeReference));
+		super.visitInterfaceReference(anInterface);
+		exit();
+
+		contexts.peek().addInterfaceReference(typeReference);
+	}
+
 	private void setModifier(CtModifiable ctModifiable, int modifiers) {
 		if (Modifier.isAbstract(modifiers)) {
 			ctModifiable.addModifier(ModifierKind.ABSTRACT);

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

@@ -84,9 +84,20 @@ interface JavaReflectionVisitor {
 	/** Visits a class as an array reference */
 	<T> void visitArrayReference(Class<T> typeArray);
 
+	/** Visits a type as a class reference */
+	<T> void visitClassReference(ParameterizedType type);
+
 	/** Visits a class as a class reference */
 	<T> void visitClassReference(Class<T> clazz);
 
+	<T> void visitClassReference(Type type);
+
 	/** Visits a class as an interface reference */
 	<T> void visitInterfaceReference(Class<T> anInterface);
+
+	/** Visits a {@link ParameterizedType} representing an interface with a type parameter. */
+	<T> void visitInterfaceReference(ParameterizedType parameterizedType);
+
+	/** Visits a {@link Type} representing an interface. */
+	<T> void visitInterfaceReference(Type type);
 }

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

@@ -43,9 +43,9 @@ public <T> void visitClass(Class<T> clazz) {
 			clazz.getPackage();
 		}
 		if (clazz.getSuperclass() != null) {
-			visitClassReference(clazz.getSuperclass());
+			visitClassReference(clazz.getGenericSuperclass());
 		}
-		for (Class<?> anInterface : clazz.getInterfaces()) {
+		for (Type anInterface : clazz.getGenericInterfaces()) {
 			visitInterfaceReference(anInterface);
 		}
 		for (Annotation annotation : clazz.getDeclaredAnnotations()) {
@@ -82,7 +82,7 @@ public <T> void visitInterface(Class<T> clazz) {
 		if (clazz.getPackage() != null) {
 			clazz.getPackage();
 		}
-		for (Class<?> anInterface : clazz.getInterfaces()) {
+		for (Type anInterface : clazz.getGenericInterfaces()) {
 			visitInterfaceReference(anInterface);
 		}
 		for (Annotation annotation : clazz.getDeclaredAnnotations()) {
@@ -338,6 +338,32 @@ public <T> void visitArrayReference(Class<T> typeArray) {
 		}
 	}
 
+	@Override
+	public <T> void visitClassReference(ParameterizedType type) {
+		Type rawType = type.getRawType();
+
+		if (!(rawType instanceof Class)) {
+			throw new UnsupportedOperationException("Rawtype of the parameterized type should be a class.");
+		}
+
+		@SuppressWarnings("unchecked")
+		Class<T> classRaw = (Class<T>) rawType;
+		if (classRaw.getPackage() != null) {
+			visitPackage(classRaw.getPackage());
+		}
+		if (classRaw.getEnclosingClass() != null) {
+			visitClassReference(classRaw.getEnclosingClass());
+		}
+
+		for (Type generic : type.getActualTypeArguments()) {
+			if (generic instanceof TypeVariable) {
+				visitTypeParameter((TypeVariable<?>) generic);
+			} else {
+				visitType(generic);
+			}
+		}
+	}
+
 	@Override
 	public <T> void visitClassReference(Class<T> clazz) {
 		if (clazz.getPackage() != null && clazz.getEnclosingClass() == null) {
@@ -348,6 +374,17 @@ public <T> void visitClassReference(Class<T> clazz) {
 		}
 	}
 
+	@Override
+	public <T> void visitClassReference(Type type) {
+		if (type instanceof Class) {
+			visitClassReference((Class) type);
+		} else if (type instanceof ParameterizedType) {
+			visitClassReference((ParameterizedType) type);
+		} else {
+			throw new UnsupportedOperationException("Only type with class or ParameterizedType are supported.");
+		}
+	}
+
 	@Override
 	public <T> void visitInterfaceReference(Class<T> type) {
 		if (type.getPackage() != null) {
@@ -356,6 +393,48 @@ public <T> void visitInterfaceReference(Class<T> type) {
 		if (type.getEnclosingClass() != null) {
 			visitClassReference(type.getEnclosingClass());
 		}
+
+		for (TypeVariable<Class<T>> generic : type.getTypeParameters()) {
+			visitTypeParameter(generic);
+		}
+	}
+
+	@Override
+	public <T> void visitInterfaceReference(ParameterizedType type) {
+		Type rawType = type.getRawType();
+
+		if (!(rawType instanceof Class)) {
+			throw new UnsupportedOperationException("Rawtype of the parameterized type should be a class.");
+		}
+
+		@SuppressWarnings("unchecked")
+		Class<T> classRaw = (Class<T>) rawType;
+
+		if (classRaw.getPackage() != null) {
+			visitPackage(classRaw.getPackage());
+		}
+		if (classRaw.getEnclosingClass() != null) {
+			visitClassReference(classRaw.getEnclosingClass());
+		}
+
+		for (Type generic : type.getActualTypeArguments()) {
+			if (generic instanceof TypeVariable) {
+				visitTypeParameter((TypeVariable<?>) generic);
+			} else {
+				visitType(generic);
+			}
+		}
+	}
+
+	@Override
+	public <T> void visitInterfaceReference(Type type) {
+		if (type instanceof Class) {
+			visitInterfaceReference((Class) type);
+		} else if (type instanceof ParameterizedType) {
+			visitInterfaceReference((ParameterizedType) type);
+		} else {
+			throw new UnsupportedOperationException("Only type with class or ParameterizedType are supported.");
+		}
 	}
 
 	private <T> List<RtMethod> getDeclaredMethods(Class<T> clazz) {

src/main/java/spoon/support/visitor/java/internal/TypeReferenceRuntimeBuilderContext.java

@@ -18,6 +18,7 @@
 
 import spoon.reflect.declaration.CtAnnotation;
 import spoon.reflect.declaration.CtPackage;
+import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.reference.CtTypeParameterReference;
 import spoon.reflect.reference.CtTypeReference;
 
@@ -54,4 +55,9 @@ public void addTypeName(CtTypeReference<?> ctTypeReference) {
 	public void addAnnotation(CtAnnotation<Annotation> ctAnnotation) {
 		typeReference.addAnnotation(ctAnnotation);
 	}
+
+	@Override
+	public void addFormalType(CtTypeParameter parameterRef) {
+		typeReference.addActualTypeArgument(parameterRef.getReference());
+	}
 }