feat: Add CtAbstractInvocation.addArgumentAt method (INRIA#3885)

Author: slarse

src/main/java/spoon/reflect/code/CtAbstractInvocation.java

@@ -39,6 +39,16 @@ public interface CtAbstractInvocation<T> extends CtElement {
 	@PropertySetter(role = ARGUMENT)
 	<C extends CtAbstractInvocation<T>> C addArgument(CtExpression<?> argument);
 
+	/**
+	 * Adds an argument expression to the invocation at the specified position.
+	 *
+	 * @param position position to add the argument at.
+	 * @param argument argument to add.
+	 * @return the receiver.
+	 */
+	@PropertySetter(role = ARGUMENT)
+	<C extends CtAbstractInvocation<T>> C addArgumentAt(int position, CtExpression<?> argument);
+
 	/**
 	 * Removes an argument expression from the invocation.
 	 */

src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java

@@ -123,6 +123,11 @@ public <C extends CtAbstractInvocation<T>> C addArgument(CtExpression<?> argumen
 		return addArgument(arguments.size(), argument);
 	}
 
+	@Override
+	public <C extends CtAbstractInvocation<T>> C addArgumentAt(int position, CtExpression<?> argument) {
+		return addArgument(position, argument);
+	}
+
 	@Override
 	public void removeArgument(CtExpression<?> argument) {
 		if (arguments == CtElementImpl.<CtExpression<?>>emptyList()) {

src/main/java/spoon/support/reflect/code/CtInvocationImpl.java

@@ -69,6 +69,11 @@ public <C extends CtAbstractInvocation<T>> C addArgument(CtExpression<?> argumen
 		return addArgument(arguments.size(), argument);
 	}
 
+	@Override
+	public <C extends CtAbstractInvocation<T>> C addArgumentAt(int position, CtExpression<?> argument) {
+		return addArgument(position, argument);
+	}
+
 	@Override
 	public void removeArgument(CtExpression<?> argument) {
 		if (arguments == CtElementImpl.<CtExpression<?>>emptyList()) {

src/test/java/spoon/test/constructorcallnewclass/ConstructorCallTest.java

@@ -39,6 +39,8 @@
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
@@ -179,6 +181,34 @@ public void testParameterizedConstructorCallOmittedTypeArgsResolvedTypeNoClasspa
 		assertTrue(executableType.isParameterized());
 	}
 
+	@Test
+	public void test_addArgumentAt_addsArgumentToSpecifiedPosition() {
+		// contract: addArgumentAt should add arguments to the specified position.
+
+		// arrange
+		Factory factory = new Launcher().getFactory();
+		factory.getEnvironment().setAutoImports(true);
+		CtConstructorCall<?> newLinkedHashMap = (CtConstructorCall<?>) factory
+                // make it raw on purpose to simplify assertion
+				.createCodeSnippetExpression("new java.util.LinkedHashMap()")
+				.compile();
+
+		// act
+		// LinkedHashMap has multiple constructors, we're going for:
+		// LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) by adding
+		// arguments a bit haphazardly
+
+		// 10
+		newLinkedHashMap.addArgumentAt(0, factory.createLiteral(10))
+			// 10, true
+			.addArgumentAt(1, factory.createLiteral(true))
+			// 10, 1.4, true
+			.addArgumentAt(1, factory.createLiteral(1.4));
+
+		// assert
+		assertThat(newLinkedHashMap.toString(), equalTo("new LinkedHashMap(10, 1.4, true)"));
+	}
+
 	private CtTypeReference<?> getConstructorCallTypeFrom(String simpleName, String sourceFile) {
 		final Launcher launcher = new Launcher();
 		launcher.getEnvironment().setNoClasspath(true);

src/test/java/spoon/test/invocations/InvocationTest.java

@@ -25,16 +25,20 @@
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.visitor.filter.AbstractFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
 import spoon.test.invocations.testclasses.Bar;
 import spoon.test.invocations.testclasses.Foo;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertNotNull;
@@ -97,4 +101,35 @@ public void testIssue1753() {
 		final CtExecutable exe = executables.get(0);
 		assertNotNull(exe.getReference().getDeclaration());
 	}
+
+	@Test
+	public void test_addArgumentAt_addsArgumentAtSpecifiedPosition() {
+		// contract: addArgumentAt should add arguments to the specified position.
+
+		// arrange
+		Factory factory = new Launcher().getFactory();
+		factory.getEnvironment().setAutoImports(true);;
+		CtType<?> collections = factory.Type().get(Collections.class);
+		CtInvocation<?> addAllInv = factory.createInvocation(
+				factory.createTypeAccess(collections.getReference()),
+				collections.getMethodsByName("addAll").get(0).getReference());
+
+		// act
+		// want to add the arguments new ArrayList<Integer>, 4, 99, 7, -2 s.t. they end up in that
+		// order, but we do it haphazardly with addArgumentAt.
+
+		// AL
+		addAllInv.addArgumentAt(0, factory.createCodeSnippetExpression("new java.util.ArrayList<Integer>()").compile())
+			// AL, 99
+			.addArgumentAt(1, factory.createLiteral(99))
+			// AL, 99, -2
+			.addArgumentAt(2, factory.createLiteral(-2))
+			// AL, 4, 99, -2
+			.addArgumentAt(1, factory.createLiteral(4))
+			// AL, 4, 99, 7, -2
+			.addArgumentAt(3, factory.createLiteral(7));
+
+		// assert
+		assertThat(addAllInv.toString(), equalTo("Collections.addAll(new ArrayList<Integer>(), 4, 99, 7, -2)"));
+	}
 }