refactor: getBoundingType returns Object by default (#1672)

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

@@ -655,4 +655,11 @@ public <T> CtIntersectionTypeReference<T> createIntersectionTypeReferenceWithBou
 		return intersectionRef;
 	}
 
+	/**
+	 * Returns the default bounding type value
+	 */
+	public CtTypeReference getDefaultBoundingType() {
+		return OBJECT;
+	}
+
 }

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

@@ -99,4 +99,10 @@ public interface CtTypeParameterReference extends CtTypeReference<Object> {
 	@Override
 	@UnsettableProperty
 	<T extends CtActualTypeContainer> T setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments);
+
+	/**
+	 * Returns true if this has the default bounding type that is java.lang.Object (which basically means that there is no bound)
+	 */
+	@DerivedProperty
+	boolean isDefaultBoundingType();
 }

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

@@ -618,7 +618,7 @@ public void visitCtTypeParameter(CtTypeParameter typeParameter) {
 		} else {
 			printer.writeIdentifier(ref.getSimpleName());
 		}
-		if (ref.getBoundingType() != null) {
+		if (!ref.isDefaultBoundingType() || !ref.getBoundingType().isImplicit()) {
 			if (ref.isUpper()) {
 				printer.writeSpace().writeKeyword("extends").writeSpace();
 			} else {
@@ -1570,7 +1570,8 @@ public void visitCtWildcardReference(CtWildcardReference wildcardReference) {
 		}
 		elementPrinterHelper.writeAnnotations(wildcardReference);
 		printer.writeSeparator("?");
-		if (wildcardReference.getBoundingType() != null) {
+		// we ignore printing "extends Object" except if it's explicit
+		if (!wildcardReference.isDefaultBoundingType() || !wildcardReference.getBoundingType().isImplicit()) {
 			if (wildcardReference.isUpper()) {
 				printer.writeSpace().writeKeyword("extends").writeSpace();
 			} else {

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

@@ -305,12 +305,12 @@ CtReference getDeclaringReferenceFromImports(char[] expectedName) {
 						char[][] packageName = CharOperation.subarray(anImport.getImportName(), 0, anImport.getImportName().length - indexDeclaring);
 						char[][] className = CharOperation.subarray(anImport.getImportName(), anImport.getImportName().length - indexDeclaring, anImport.getImportName().length - (indexDeclaring - 1));
 						PackageBinding aPackage;
-						if (packageName.length != 0) {
-							aPackage = environment.createPackage(packageName);
-						} else {
-							aPackage = null;
-						}
 						try {
+							if (packageName.length != 0) {
+								aPackage = environment.createPackage(packageName);
+							} else {
+								aPackage = null;
+							}
 							final MissingTypeBinding declaringType = environment.createMissingType(aPackage, className);
 							this.jdtTreeBuilder.getContextBuilder().ignoreComputeImports = true;
 							final CtTypeReference<Object> typeReference = getTypeReference(declaringType);
@@ -765,8 +765,9 @@ <T> CtTypeReference<T> getTypeReference(TypeBinding binding) {
 				bounds = false;
 				bindingCache.put(binding, ref);
 				List<CtTypeReference<?>> bounds = new ArrayList<>();
-				if (((CtTypeParameterReference) ref).getBoundingType() != null) {
-					bounds.add(((CtTypeParameterReference) ref).getBoundingType());
+				CtTypeParameterReference typeParameterReference = (CtTypeParameterReference) ref;
+				if (!(typeParameterReference.isDefaultBoundingType())) { // if it's object we can ignore it
+					bounds.add(typeParameterReference.getBoundingType());
 				}
 				for (ReferenceBinding superInterface : b.superInterfaces) {
 					bounds.add(getTypeReference(superInterface));

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

@@ -51,6 +51,13 @@ public class CtTypeParameterReferenceImpl extends CtTypeReferenceImpl<Object> im
 
 	public CtTypeParameterReferenceImpl() {
 		super();
+		// calling null will set the default value of boundingType
+		this.setBoundingType(null);
+	}
+
+	@Override
+	public boolean isDefaultBoundingType() {
+		return (getBoundingType().equals(getFactory().Type().getDefaultBoundingType()));
 	}
 
 	@Override
@@ -97,7 +104,7 @@ public boolean isPrimitive() {
 	@SuppressWarnings("unchecked")
 	public Class<Object> getActualClass() {
 		if (isUpper()) {
-			if (getBoundingType() == null) {
+			if (isDefaultBoundingType()) {
 				return (Class<Object>) getTypeErasure().getActualClass();
 			}
 			return (Class<Object>) getBoundingType().getActualClass();
@@ -134,7 +141,7 @@ public <T extends CtTypeParameterReference> T addBound(CtTypeReference<?> bound)
 		if (bound == null) {
 			return (T) this;
 		}
-		if (getBoundingType() == null) {
+		if (isDefaultBoundingType()) {
 			setBoundingType(bound);
 		} else if (getBoundingType() instanceof CtIntersectionTypeReference<?>) {
 			getBoundingType().asCtIntersectionTypeReference().addBound(bound);
@@ -149,7 +156,7 @@ public <T extends CtTypeParameterReference> T addBound(CtTypeReference<?> bound)
 
 	@Override
 	public boolean removeBound(CtTypeReference<?> bound) {
-		if (bound == null || getBoundingType() == null) {
+		if (bound == null || isDefaultBoundingType()) {
 			return false;
 		}
 		if (getBoundingType() instanceof CtIntersectionTypeReference<?>) {
@@ -162,16 +169,6 @@ public boolean removeBound(CtTypeReference<?> bound) {
 
 	@Override
 	public CtTypeReference<?> getBoundingType() {
-		if (superType != null) {
-			/*
-			 * Spoon expects that superType is null on many places.
-			 * But sometime  there is Object in it, which has same meaning like null in this case
-			 * But EqualsVisitor returns false that it is not equal
-			 */
-			if (Object.class.getName().equals(superType.getQualifiedName())) {
-				return null;
-			}
-		}
 		return superType;
 	}
 
@@ -180,6 +177,14 @@ public <T extends CtTypeParameterReference> T setBoundingType(CtTypeReference<?>
 		if (superType != null) {
 			superType.setParent(this);
 		}
+
+		// ugly but else make testSetterInNodes failed
+		if (superType == null) { // if null, set bounding type to object
+			superType = getFactory().Type().objectType();
+			superType.setImplicit(true);
+			superType.setParent(this);
+		}
+
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BOUNDING_TYPE, superType, this.superType);
 		this.superType = superType;
 		return (T) this;

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

@@ -79,7 +79,7 @@ private CtTypeReference<?> adaptTypeParameterReference(CtTypeParameterReference
 	private CtTypeReference<?> adaptTypeParameterReferenceBoundingType(CtTypeParameterReference typeParamRef, CtTypeReference<?> boundingType) {
 		CtTypeParameterReference typeParamRefAdapted = typeParamRef.clone();
 		typeParamRefAdapted.setParent(typeParamRef.getParent());
-		typeParamRefAdapted.setBoundingType(boundingType == null ? null : adaptType(boundingType));
+		typeParamRefAdapted.setBoundingType(boundingType.equals(boundingType.getFactory().Type().getDefaultBoundingType()) ? null : adaptType(boundingType));
 		return typeParamRefAdapted;
 	}
 

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

@@ -572,14 +572,14 @@ private boolean isSubTypeArg(CtTypeReference<?> subArg, CtTypeReference<?> super
 		if (superArg instanceof CtWildcardReference) {
 			CtWildcardReference wr = (CtWildcardReference) superArg;
 			CtTypeReference<?> superBound = wr.getBoundingType();
-			if (superBound == null) {
+			if (superBound.equals(wr.getFactory().Type().OBJECT)) {
 				//everything extends from object, nothing is super of Object
 				return wr.isUpper();
 			}
 			if (subArg instanceof CtWildcardReference) {
 				CtWildcardReference subWr = (CtWildcardReference) subArg;
 				CtTypeReference<?> subBound = subWr.getBoundingType();
-				if (subBound == null) {
+				if (subBound.equals(wr.getFactory().Type().OBJECT)) {
 					//nothing is super of object
 					return false;
 				}
@@ -690,7 +690,8 @@ private boolean isSameSignatureLikeScopeMethod(CtExecutable<?> thatExecutable, b
 				if (thisType.getActualTypeArguments().isEmpty() && thatType.getActualTypeArguments().size() == 1) {
 					CtTypeReference actualTA = thatType.getActualTypeArguments().get(0);
 					if (actualTA instanceof CtWildcardReference) {
-						if (((CtWildcardReference) actualTA).getBoundingType() == null) {
+						CtWildcardReference wildcardReference = (CtWildcardReference) actualTA;
+						if (wildcardReference.isDefaultBoundingType()) {
 							thatType.setActualTypeArguments(Collections.EMPTY_LIST);
 						}
 					}

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

@@ -84,7 +84,7 @@ public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
 	@Override
 	public void visitCtTypeParameterReference(CtTypeParameterReference ref) {
 		write(ref.getQualifiedName());
-		if (ref.getBoundingType() != null) {
+		if (!ref.isDefaultBoundingType() || !ref.getBoundingType().isImplicit()) {
 			if (ref.isUpper()) {
 				write(" extends ");
 			} else {

src/test/java/spoon/test/factory/FactoryTest.java

@@ -200,5 +200,4 @@ public void specificationCoreFactoryCreate() throws Exception {
 			assertTrue(itf.getActualClass().isInstance(o));
 		}
 	}
-
 }

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

@@ -2,6 +2,7 @@
 
 import org.junit.Test;
 import spoon.Launcher;
+import spoon.MavenLauncher;
 import spoon.SpoonModelBuilder;
 import spoon.compiler.SpoonResourceHelper;
 import spoon.reflect.code.BinaryOperatorKind;
@@ -502,7 +503,7 @@ public void testGenericWithExtendsInDeclaration() throws Exception {
 
 		final CtMethod<?> apply = panini.getMethodsByName("apply").get(0);
 		assertEquals(1, apply.getType().getActualTypeArguments().size());
-		assertEquals("?", apply.getType().getActualTypeArguments().get(0).toString());
+		assertEquals("? super java.lang.Object", apply.getType().getActualTypeArguments().get(0).toString());
 
 		assertEquals(1, apply.getParameters().get(0).getType().getActualTypeArguments().size());
 		assertEquals("? extends java.lang.Long", apply.getParameters().get(0).getType().getActualTypeArguments().get(0).toString());
@@ -1206,7 +1207,7 @@ public void testDiamondComplexGenericsRxJava() {
 				CtTypeReference actualTA = call.getType().getActualTypeArguments().get(0);
 				assertTrue(actualTA instanceof CtWildcardReference);
 				assertEquals("?", actualTA.getSimpleName());
-				assertTrue( ((CtWildcardReference)actualTA).getBoundingType() == null );
+				assertTrue( ((CtWildcardReference)actualTA).isDefaultBoundingType() );
 				invocationDetected = true;
 			}
 		}
@@ -1402,5 +1403,4 @@ public void testIsGenericTypeEqual() {
 		MainTest.checkParentConsistency(launcher.getFactory().getModel().getRootPackage());
 		MainTest.checkParentConsistency(adaptedMethod);
 	}
-
 }

src/test/java/spoon/test/reference/ExecutableReferenceGenericTest.java

@@ -119,7 +119,7 @@ public void testMultiReferenceBetweenMethodsWithGenericInSameClass() throws Exce
 
 		//T has more information in the invocation than its declaration because of the argument type
 		//assertEquals(expectedMethod1, refsMethod2.get(0).getDeclaration());
-		assertEquals(execRefsMethods2.getSignature(), "method1(T extends java.lang.String)");
+		assertEquals("method1(T extends java.lang.String)", execRefsMethods2.getSignature());
 		assertEquals(expectedMethod1, refsMethod2.get(1).getDeclaration());
 		assertEquals(expectedMethod5, refsMethod2.get(2).getDeclaration());
 	}

src/test/java/spoon/test/reference/TypeReferenceTest.java

@@ -510,15 +510,17 @@ public void testClearBoundsForTypeParameterReference() throws Exception {
 
 		reference.setBounds(null);
 
-		assertNull(reference.getBoundingType());
+		assertEquals(factory.Type().OBJECT, reference.getBoundingType());
+		assertTrue(reference.isDefaultBoundingType());
 
 		reference.addBound(factory.Type().createReference(String.class));
 
 		assertNotNull(reference.getBoundingType());
 
 		reference.setBounds(new ArrayList<>());
 
-		assertNull(reference.getBoundingType());
+		assertEquals(factory.Type().OBJECT, reference.getBoundingType());
+		assertTrue(reference.isDefaultBoundingType());
 	}
 
 	@Test