Fix 573 597 600

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

@@ -90,6 +90,11 @@ public interface CtTypeInformation {
 	 */
 	boolean isAnnotationType();
 
+	/**
+	 * Returns true if this element is a generics (eg "T") and false if it is an actual type (eg 'Book" or "String")
+	 */
+	boolean isGenerics();
+
 	/**
 	 * Returns true if the referenced type is a sub-type of the given type.
 	 */

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

@@ -60,6 +60,4 @@ public interface Factory {
 	EvalFactory Eval(); // used 4 times
 
 	ConstructorFactory Constructor(); // used 3 times
-
-	InternalFactory Internal();
 }

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

@@ -31,7 +31,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtType;
 import spoon.support.DefaultCoreFactory;
-import spoon.support.DefaultInternalFactory;
 import spoon.support.StandardEnvironment;
 
 import java.io.Serializable;
@@ -256,16 +255,6 @@ public TypeFactory Type() {
 		return type;
 	}
 
-	private transient InternalFactory internal;
-
-	@Override
-	public InternalFactory Internal() {
-		if (internal == null) {
-			internal = new DefaultInternalFactory(this);
-		}
-		return internal;
-	}
-
 	/**
 	 * A constructor that takes the parent factory
 	 */

src/main/java/spoon/reflect/reference/CtTypeParameterReference.java

@@ -16,6 +16,8 @@
  */
 package spoon.reflect.reference;
 
+import spoon.reflect.declaration.CtTypeParameter;
+
 import java.util.List;
 
 /**
@@ -68,6 +70,11 @@ public interface CtTypeParameterReference extends CtTypeReference<Object> {
 	 */
 	<T extends CtTypeParameterReference> T setBoundingType(CtTypeReference<?> superType);
 
+	// override the return
+	@Override
+	CtTypeParameter getDeclaration();
+
+	// override the return
 	@Override
 	CtTypeParameterReference clone();
 }

src/main/java/spoon/reflect/visitor/CtAbstractVisitor.java

@@ -76,7 +76,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.declaration.CtTypeParameter;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -393,11 +392,6 @@ public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
 
 	}
 
-	@Override
-	public void visitCtCircularTypeReference(CtCircularTypeReference reference) {
-
-	}
-
 	@Override
 	public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) {
 

src/main/java/spoon/reflect/visitor/CtBiScannerDefault.java

@@ -626,7 +626,6 @@ public void visitCtTypeParameterReference(final spoon.reflect.reference.CtTypePa
 		enter(ref);
 		biScan(ref.getPackage(), other.getPackage());
 		biScan(ref.getDeclaringType(), other.getDeclaringType());
-		biScan(ref.getActualTypeArguments(), other.getActualTypeArguments());
 		biScan(ref.getAnnotations(), other.getAnnotations());
 		biScan(ref.getBoundingType(), other.getBoundingType());
 		exit(ref);
@@ -660,13 +659,6 @@ public <T> void visitCtTypeReference(final spoon.reflect.reference.CtTypeReferen
 		exit(reference);
 	}
 
-	@java.lang.Override
-	public void visitCtCircularTypeReference(final spoon.reflect.internal.CtCircularTypeReference reference) {
-		spoon.reflect.internal.CtCircularTypeReference other = ((spoon.reflect.internal.CtCircularTypeReference) (stack.peek()));
-		enter(reference);
-		exit(reference);
-	}
-
 	@java.lang.Override
 	public <T> void visitCtTypeAccess(final spoon.reflect.code.CtTypeAccess<T> typeAccess) {
 		spoon.reflect.code.CtTypeAccess other = ((spoon.reflect.code.CtTypeAccess) (stack.peek()));

src/main/java/spoon/reflect/visitor/CtInheritanceScanner.java

@@ -97,7 +97,6 @@
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.CtTypedElement;
 import spoon.reflect.declaration.CtVariable;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
@@ -805,11 +804,6 @@ public <T> void visitCtTypeReference(CtTypeReference<T> e) {
 		scanCtVisitable(e);
 	}
 
-	@Override
-	public void visitCtCircularTypeReference(CtCircularTypeReference e) {
-		visitCtTypeParameterReference(e);
-	}
-
 	@Override
 	public <T> void visitCtTypeAccess(CtTypeAccess<T> e) {
 		scanCtExpression(e);

src/main/java/spoon/reflect/visitor/CtScanner.java

@@ -78,7 +78,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.declaration.CtTypeParameter;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -720,7 +719,6 @@ public void visitCtTypeParameterReference(final CtTypeParameterReference ref) {
 		enter(ref);
 		scan(ref.getPackage());
 		scan(ref.getDeclaringType());
-		scan(ref.getActualTypeArguments());
 		scan(ref.getAnnotations());
 		scan(ref.getBoundingType());
 		exit(ref);
@@ -751,12 +749,6 @@ public <T> void visitCtTypeReference(final CtTypeReference<T> reference) {
 		exit(reference);
 	}
 
-	@Override
-	public void visitCtCircularTypeReference(final CtCircularTypeReference reference) {
-		enter(reference);
-		exit(reference);
-	}
-
 	@Override
 	public <T> void visitCtTypeAccess(final CtTypeAccess<T> typeAccess) {
 		enter(typeAccess);

src/main/java/spoon/reflect/visitor/CtVisitor.java

@@ -76,7 +76,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.declaration.CtTypeParameter;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -406,11 +405,6 @@ <T, A extends T> void visitCtOperatorAssignment(
 	 */
 	<T> void visitCtTypeReference(CtTypeReference<T> reference);
 
-	/**
-	 * Visits a circular reference.
-	 */
-	void visitCtCircularTypeReference(CtCircularTypeReference reference);
-
 	/**
 	 * Visits a type access.
 	 */

src/main/java/spoon/reflect/visitor/DefaultJavaPrettyPrinter.java

@@ -89,7 +89,6 @@
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.declaration.ParentNotInitializedException;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -1644,11 +1643,6 @@ public <T> void visitCtTypeReference(CtTypeReference<T> ref) {
 		visitCtTypeReference(ref, true);
 	}
 
-	@Override
-	public void visitCtCircularTypeReference(CtCircularTypeReference reference) {
-		visitCtTypeReference(reference);
-	}
-
 	@Override
 	public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) {
 		if (typeAccess.isImplicit()) {

src/main/java/spoon/support/compiler/jdt/ReferenceBuilder.java

@@ -69,7 +69,6 @@
 import spoon.reflect.code.CtLocalVariable;
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.ModifierKind;
-import spoon.reflect.internal.CtCircularTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -464,7 +463,6 @@ CtTypeReference<Object> getTypeParameterReference(TypeBinding binding, TypeRefer
 				typeParameterRef.setSimpleName(ctRef.getSimpleName());
 				typeParameterRef.setDeclaringType(ctRef.getDeclaringType());
 				typeParameterRef.setPackage(ctRef.getPackage());
-				typeParameterRef.setActualTypeArguments(ctRef.getActualTypeArguments());
 				ctRef = typeParameterRef;
 			}
 			insertGenericTypesInNoClasspathFromJDTInSpoon(ref, ctRef);
@@ -580,16 +578,17 @@ private <T> CtTypeReference<T> getTypeReference(String name) {
 	 * Try to build a CtTypeParameterReference from a single name with specified generic types but
 	 * keep in mind that if you give wrong data in the strong, reference will be wrong.
 	 */
-	private CtTypeParameterReference getTypeParameterReference(String name) {
-		CtTypeParameterReference param = this.jdtTreeBuilder.getFactory().Core().createTypeParameterReference();
+	private CtTypeReference<Object> getTypeParameterReference(String name) {
+		CtTypeReference<Object> param = null;
 		if (name.contains("extends") || name.contains("super")) {
 			String[] split = name.contains("extends") ? name.split("extends") : name.split("super");
 			param = getTypeParameterReference(split[0].trim());
-			param.setBoundingType(getTypeReference(split[split.length - 1].trim()));
+			((CtTypeParameterReference) param).setBoundingType(getTypeReference(split[split.length - 1].trim()));
 		} else if (name.matches(".*(<.+>)")) {
 			Pattern pattern = Pattern.compile("([^<]+)<(.+)>");
 			Matcher m = pattern.matcher(name);
 			if (m.find()) {
+				param = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
 				param.setSimpleName(m.group(1));
 				final String[] split = m.group(2).split(",");
 				for (String parameter : split) {
@@ -599,6 +598,7 @@ private CtTypeParameterReference getTypeParameterReference(String name) {
 		} else if (name.contains("?")) {
 			param = this.jdtTreeBuilder.getFactory().Core().createWildcardReference();
 		} else {
+			param = this.jdtTreeBuilder.getFactory().Core().createTypeParameterReference();
 			param.setSimpleName(name);
 		}
 		return param;
@@ -717,8 +717,7 @@ <T> CtTypeReference<T> getTypeReference(TypeBinding binding) {
 
 			if (((WildcardBinding) binding).bound != null && ref instanceof CtTypeParameterReference) {
 				if (bindingCache.containsKey(((WildcardBinding) binding).bound)) {
-					final CtCircularTypeReference circularRef = getCtCircularTypeReference(((WildcardBinding) binding).bound);
-					((CtTypeParameterReference) ref).setBoundingType(circularRef);
+					((CtTypeParameterReference) ref).setBoundingType(getCtCircularTypeReference(((WildcardBinding) binding).bound));
 				} else {
 					((CtTypeParameterReference) ref).setBoundingType(getTypeReference(((WildcardBinding) binding).bound));
 				}
@@ -790,15 +789,8 @@ <T> CtTypeReference<T> getTypeReference(TypeBinding binding) {
 		return (CtTypeReference<T>) ref;
 	}
 
-	private CtCircularTypeReference getCtCircularTypeReference(TypeBinding b) {
-		final CtCircularTypeReference circularRef = this.jdtTreeBuilder.getFactory().Internal().createCircularTypeReference();
-		final CtTypeReference originalRef = bindingCache.get(b).clone();
-		circularRef.setPackage(originalRef.getPackage());
-		circularRef.setSimpleName(originalRef.getSimpleName());
-		circularRef.setDeclaringType(originalRef.getDeclaringType());
-		circularRef.setActualTypeArguments(originalRef.getActualTypeArguments());
-		circularRef.setAnnotations(originalRef.getAnnotations());
-		return circularRef;
+	private CtTypeReference<?> getCtCircularTypeReference(TypeBinding b) {
+		return bindingCache.get(b).clone();
 	}
 
 	@SuppressWarnings("unchecked")