refactor: Use get/setType methods in executable in CtNewClass.

In CtNewClass#getType(), we use getExecutable().getType. In CtNewClass#setType(), we throw an UnsupportedOperationException.
INRIA · Nov 20, 2015 · 8a0927b · 8a0927b
1 parent 1b99d90
commit 8a0927b
Show file tree

Hide file tree

Showing 3 changed files with 38 additions and 24 deletions.
diff --git a/src/main/java/spoon/support/compiler/jdt/JDTTreeBuilder.java b/src/main/java/spoon/support/compiler/jdt/JDTTreeBuilder.java
@@ -316,10 +316,14 @@ void enter(CtElement e, ASTNode node) {
 				((CtStatement) current).setLabel(context.label.pop());
 			}
 
-			if (e instanceof CtTypedElement && node instanceof Expression) {
-				if (((CtTypedElement<?>) e).getType() == null && !(e instanceof CtInvocation)) {
-					((CtTypedElement<Object>) e).setType(references.getTypeReference(((Expression) node).resolvedType));
+			try {
+				if (e instanceof CtTypedElement && node instanceof Expression) {
+					if (((CtTypedElement<?>) e).getType() == null) {
+						((CtTypedElement<Object>) e).setType(references.getTypeReference(((Expression) node).resolvedType));
+					}
 				}
+			} catch (UnsupportedOperationException ignore) {
+				// For some element, we throw an UnsupportedOperationException when we call setType().
 			}
 
 		}
@@ -1654,6 +1658,22 @@ public boolean visit(AllocationExpression allocationExpression, BlockScope scope
 	}
 
 	private <T extends CtConstructorCall<Object>> T buildCommonPartForCtNewClassAndCtConstructorCall(AllocationExpression allocationExpression, BlockScope scope, T constructorCall) {
+		if (allocationExpression.binding != null) {
+			constructorCall.setExecutable(references.getExecutableReference(allocationExpression.binding));
+		} else {
+			final CtExecutableReference<Object> ref = factory.Core().createExecutableReference();
+			ref.setSimpleName(CtExecutableReference.CONSTRUCTOR_NAME);
+			ref.setType(references.getTypeReference(null, allocationExpression.type));
+			ref.setDeclaringType(references.getTypeReference(null, allocationExpression.type));
+
+			final List<CtTypeReference<?>> parameters = new ArrayList<CtTypeReference<?>>(allocationExpression.argumentTypes.length);
+			for (TypeBinding b : allocationExpression.argumentTypes) {
+				parameters.add(references.getTypeReference(b));
+			}
+			ref.setParameters(parameters);
+			constructorCall.setExecutable(ref);
+		}
+
 		if (allocationExpression.type != null) {
 			final TypeReference[][] typeArguments = allocationExpression.type.getTypeArguments();
 			// If typeArguments are null or empty, we have an element with a generic type.
@@ -1668,28 +1688,10 @@ private <T extends CtConstructorCall<Object>> T buildCommonPartForCtNewClassAndC
 					}
 				}
 			}
-			constructorCall.setType(references.getTypeReference(allocationExpression.type.resolvedType));
+			constructorCall.getExecutable().setType(references.getTypeReference(allocationExpression.type.resolvedType));
 			context.isGenericTypeExplicit = true;
 		} else if (allocationExpression.expectedType() != null) {
-			constructorCall.setType(references.getTypeReference(allocationExpression.expectedType()));
-		}
-		if (allocationExpression.binding != null) {
-			constructorCall.setExecutable(references.getExecutableReference(allocationExpression.binding));
-		} else {
-			final CtExecutableReference<Object> ref = factory.Core().createExecutableReference();
-			ref.setSimpleName(CtExecutableReference.CONSTRUCTOR_NAME);
-			ref.setType(references.getTypeReference(null, allocationExpression.type));
-			ref.setDeclaringType(references.getTypeReference(null, allocationExpression.type));
-
-			final List<CtTypeReference<?>> parameters = new ArrayList<CtTypeReference<?>>(allocationExpression.argumentTypes.length);
-			for (TypeBinding b : allocationExpression.argumentTypes) {
-				parameters.add(references.getTypeReference(b));
-			}
-			ref.setParameters(parameters);
-			constructorCall.setExecutable(ref);
-		}
-		if (constructorCall.getExecutable() != null) {
-			constructorCall.getExecutable().setType(constructorCall.getType());
+			constructorCall.getExecutable().setType(references.getTypeReference(allocationExpression.expectedType()));
 		}
 
 		if (allocationExpression.genericTypeArguments() != null) {

diff --git a/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java b/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java
@@ -6,6 +6,7 @@
 import spoon.reflect.code.CtStatement;
 import spoon.reflect.code.CtStatementList;
 import spoon.reflect.declaration.CtElement;
+import spoon.reflect.declaration.CtTypedElement;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtGenericElementReference;
 import spoon.reflect.reference.CtTypeReference;
@@ -152,4 +153,14 @@ public boolean removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) {
 		return actualTypeArguments != CtElementImpl.<CtTypeReference<?>>emptyList()
 				&& actualTypeArguments.remove(actualTypeArgument);
 	}
+
+	@Override
+	public CtTypeReference<T> getType() {
+		return getExecutable() == null ? null : getExecutable().getType();
+	}
+
+	@Override
+	public <C extends CtTypedElement> C setType(CtTypeReference<T> type) {
+		throw new UnsupportedOperationException("Uses getExecutable().setType(CtTypeReference<T>)");
+	}
 }
diff --git a/src/test/java/spoon/test/executable/ExecutableRefTest.java b/src/test/java/spoon/test/executable/ExecutableRefTest.java
@@ -80,8 +80,9 @@ public void testSameTypeInConstructorCallBetweenItsObjectAndItsExecutable() {
 
 		for (CtConstructorCall constructorCall : ctConstructorCalls) {
 			assertNotNull(constructorCall.getExecutable());
-			assertEquals(constructorCall.getExecutable().getType(), constructorCall.getType());
 		}
+
+		TestUtils.canBeBuilt("./target/executable", 8, true);
 	}
 
 	private CtAbstractInvocation<?> getInvocationFromMethod(String methodName) throws Exception {