review: fix toMethod() implementation of CtRecordComponent to return useful spoon classes

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

@@ -27,6 +27,7 @@
 import spoon.reflect.code.CtLocalVariable;
 import spoon.reflect.code.CtNewArray;
 import spoon.reflect.code.CtNewClass;
+import spoon.reflect.code.CtReturn;
 import spoon.reflect.code.CtStatement;
 import spoon.reflect.code.CtStatementList;
 import spoon.reflect.code.CtTextBlock;
@@ -647,6 +648,19 @@ public <A extends Annotation> CtAnnotation<A> createAnnotation(CtTypeReference<A
 		return a;
 	}
 
+	/**
+	 * Creates a return statement.
+	 *
+	 * @param expression the expression to be returned.
+	 * @param <T> the type of the expression
+	 * @return a return.
+	 */
+	public <T> CtReturn<T> createCtReturn(CtExpression<T> expression) {
+		final CtReturn<T> result = factory.Core().createReturn();
+		result.setReturnedExpression(expression);
+		return result;
+	}
+
 	/**
 	 * Gets a list of references from a list of elements.
 	 *

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

@@ -321,6 +321,14 @@ public interface Factory {
 	 */
 	<T> CtLocalVariableReference<T> createLocalVariableReference(CtLocalVariable<T> localVariable);
 
+	/**
+	 * @param expression the expression to return
+	 * @param <T> the type of the expression
+	 * @return a return statement
+	 * @see CodeFactory#createCtReturn(CtExpression)
+	 */
+	<T> CtReturn<T> createCtReturn(CtExpression<T> expression);
+
 	/**
 	 *  @see CodeFactory#createLocalVariableReference(CtTypeReference,String)
 	 */

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

@@ -509,6 +509,11 @@ public <T> CtLocalVariable<T> createLocalVariable(CtTypeReference<T> type, Strin
 		return Code().createLocalVariable(type, name, defaultExpression);
 	}
 
+	@Override
+	public <T> CtReturn<T> createCtReturn(CtExpression<T> expression) {
+		return Code().createCtReturn(expression);
+	}
+
 	@SuppressWarnings(value = "unchecked")
 	@Override
 	public <T> CtNewArray<T[]> createLiteralArray(T[] value) {

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

@@ -251,8 +251,13 @@ public <T> void scanCtType(CtType<T> type) {
 			return;
 		} else if (child instanceof CtEnumValue && type instanceof CtEnum) {
 			((CtEnum) type).addEnumValue((CtEnumValue) child);
-		} else if (child instanceof CtField) {
-			type.addField((CtField<?>) child);
+		} else if (child instanceof CtField<?> field) {
+			// We add the field in addRecordComponent. Afterward, however, JDT visits the Field itself -> Duplication.
+			// To combat this, we delete the existing field and trust JDTs version.
+			if (type instanceof CtRecord record) {
+				record.removeField(record.getField(field.getSimpleName()));
+			}
+			type.addField(field);
 			return;
 		} else if (child instanceof CtConstructor) {
 			return;

src/main/java/spoon/support/reflect/declaration/CtRecordComponentImpl.java

@@ -10,17 +10,24 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
+
+import org.jspecify.annotations.Nullable;
 import spoon.JLSViolation;
 import spoon.reflect.annotations.MetamodelPropertyField;
+import spoon.reflect.code.CtFieldAccess;
+import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtNamedElement;
+import spoon.reflect.declaration.CtRecord;
 import spoon.reflect.declaration.CtRecordComponent;
 import spoon.reflect.declaration.CtShadowable;
 import spoon.reflect.declaration.CtTypedElement;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.path.CtRole;
+import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.reference.CtTypeReference;
+import spoon.reflect.visitor.CtScanner;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.reflect.CtExtendedModifier;
 
@@ -36,31 +43,58 @@ public class CtRecordComponentImpl extends CtNamedElementImpl implements CtRecor
 	public CtMethod<?> toMethod() {
 		CtMethod<?> method = this.getFactory().createMethod();
 		method.setSimpleName(getSimpleName());
-		method.setType((CtTypeReference) getType());
+		method.setType(getClonedType());
 		method.setExtendedModifiers(Collections.singleton(new CtExtendedModifier(ModifierKind.PUBLIC, true)));
-		method.setImplicit(true);
-		method.setBody(getFactory().createCodeSnippetStatement("return " + getSimpleName()));
-		return method;
+
+		CtFieldAccess<?> ctVariableAccess = (CtFieldAccess<?>) getFactory().Code()
+			.createVariableRead(getRecordFieldReference(), false);
+
+		method.setBody(getFactory().Code().createCtReturn(ctVariableAccess));
+
+		return makeTreeImplicit(method);
+	}
+
+	private CtFieldReference<?> getRecordFieldReference() {
+		CtRecord parent = isParentInitialized() ? (CtRecord) getParent() : null;
+
+		// Reference the field we think should exist. It might be added to the record later on, so do not directly
+		// query for it.
+		CtFieldReference<?> reference = getFactory().createFieldReference()
+			.setFinal(true)
+			.setStatic(false)
+			.setType(getClonedType())
+			.setSimpleName(getSimpleName());
+
+		// We have a parent record, make the field refer to it. Ideally we could do this all the time, but if we
+		// do not yet have a parent that doesn't work.
+		if (parent != null) {
+			reference.setDeclaringType(parent.getReference());
+		}
+
+		return reference;
 	}
 
 	@Override
 	public CtField<?> toField() {
 		CtField<?> field = this.getFactory().createField();
 		field.setSimpleName(getSimpleName());
-		field.setType((CtTypeReference) getType());
+		field.setType(getClonedType());
 		Set<CtExtendedModifier> modifiers = new HashSet<>();
 		modifiers.add(new CtExtendedModifier(ModifierKind.PRIVATE, true));
 		modifiers.add(new CtExtendedModifier(ModifierKind.FINAL, true));
 		field.setExtendedModifiers(modifiers);
-		field.setImplicit(true);
-		return field;
+		return makeTreeImplicit(field);
 	}
 
 	@Override
 	public boolean isImplicit() {
 		return true;
 	}
 
+	private @Nullable CtTypeReference<?> getClonedType() {
+		return getType() != null ? getType().clone() : null;
+	}
+
 	@Override
 	public CtTypeReference<Object> getType() {
 		return type;
@@ -92,17 +126,15 @@ private void checkName(String simpleName) {
 			JLSViolation.throwIfSyntaxErrorsAreNotIgnored(this, "The name '" + simpleName + "' is not allowed as record component name.");
 		}
 	}
+
 	private static Set<String> createForbiddenNames() {
 		return Set.of("clone", "finalize", "getClass", "notify", "notifyAll", "equals", "hashCode", "toString", "wait");
 	}
-
 	@Override
 	public CtRecordComponent clone() {
 		return (CtRecordComponent) super.clone();
 	}
 
-
-
 	@Override
 	public boolean isShadow() {
 		return isShadow;
@@ -114,5 +146,14 @@ public <E extends CtShadowable> E setShadow(boolean isShadow) {
 		this.isShadow = isShadow;
 		return (E) this;
 	}
-}
 
+	private static <T extends CtElement> T makeTreeImplicit(T element) {
+		element.accept(new CtScanner() {
+			@Override
+			protected void enter(CtElement e) {
+				e.setImplicit(true);
+			}
+		});
+		return element;
+	}
+}

src/main/java/spoon/support/reflect/declaration/CtRecordImpl.java

@@ -66,6 +66,10 @@ public CtRecord addRecordComponent(CtRecordComponent component) {
 		component.setParent(this);
 		getFactory().getEnvironment().getModelChangeListener().onSetAdd(this, CtRole.RECORD_COMPONENT, components, component);
 		components.add(component);
+
+		if (getField(component.getSimpleName()) == null) {
+			addField(component.toField());
+		}
 		if (!hasMethodWithSameNameAndNoParameter(component)) {
 			addMethod(component.toMethod());
 		}
@@ -100,12 +104,14 @@ public void accept(CtVisitor v) {
 	public <C extends CtType<Object>> C addTypeMemberAt(int position, CtTypeMember member) {
 		// a record can have only implicit instance fields and this is the best point to preserve the invariant
 		// because there are multiple ways to add a field to a record
+		String memberName = member.getSimpleName();
+
 		if (member instanceof CtField && !member.isStatic()) {
 			member.setImplicit(true);
-			getAnnotationsWithName(member.getSimpleName(), ElementType.FIELD).forEach(member::addAnnotation);
+			getAnnotationsWithName(memberName, ElementType.FIELD).forEach(member::addAnnotation);
 		}
 		if (member instanceof CtMethod && member.isImplicit()) {
-			getAnnotationsWithName(member.getSimpleName(), ElementType.METHOD).forEach(member::addAnnotation);
+			getAnnotationsWithName(memberName, ElementType.METHOD).forEach(member::addAnnotation);
 		}
 		if (member instanceof CtConstructor && member.isImplicit()) {
 			for (CtParameter<?> parameter : ((CtConstructor<?>) member).getParameters()) {
@@ -115,7 +121,7 @@ public <C extends CtType<Object>> C addTypeMemberAt(int position, CtTypeMember m
 		}
 		if (member instanceof CtMethod && (member.isAbstract() || member.isNative())) {
 			JLSViolation.throwIfSyntaxErrorsAreNotIgnored(this, String.format("%s method is native or abstract, both is not allowed",
-					member.getSimpleName()));
+				memberName));
 		}
 		if (member instanceof CtAnonymousExecutable && !member.isStatic()) {
 			JLSViolation.throwIfSyntaxErrorsAreNotIgnored(this, "Instance initializer is not allowed in a record (JLS 17 $8.10.2)");

src/test/java/spoon/test/record/CtRecordTest.java

@@ -1,12 +1,13 @@
 package spoon.test.record;
 
 import static java.lang.System.lineSeparator;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static spoon.testing.assertions.SpoonAssertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
@@ -15,17 +16,25 @@
 import java.util.stream.Collectors;
 import javax.validation.constraints.NotNull;
 
+import org.assertj.core.api.InstanceOfAssertFactory;
 import org.junit.jupiter.api.Test;
 import spoon.Launcher;
 import spoon.reflect.CtModel;
+import spoon.reflect.code.CtFieldRead;
+import spoon.reflect.code.CtReturn;
+import spoon.reflect.code.CtStatement;
 import spoon.reflect.declaration.CtAnonymousExecutable;
 import spoon.reflect.declaration.CtConstructor;
+import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtRecord;
+import spoon.reflect.declaration.CtRecordComponent;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
+import spoon.reflect.visitor.CtScanner;
 import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.testing.assertions.SpoonAssertions;
 import spoon.testing.utils.ModelTest;
 
 public class CtRecordTest {
@@ -76,24 +85,33 @@ public void testMultipleParameterRecord() {
 
 		assertEquals(1, records.size());
 		assertEquals("public record MultiParameter(int first, float second) {}", head(records).toString());
-		
+
 		// test fields
 		assertEquals(
 				Arrays.asList(
-						"private final int first;", 
+						"private final int first;",
 						"private final float second;"
-				), 
+				),
 				head(records).getFields().stream().map(String::valueOf).collect(Collectors.toList())
 		);
-
+
+		// Make them explicit so we can print them (but assert they were implicit initially)
+		assertThat(head(records)).getMethods().allSatisfy(CtElement::isImplicit);
+		head(records).getMethods().forEach(it -> it.accept(new CtScanner() {
+			@Override
+			protected void enter(CtElement e) {
+				e.setImplicit(false);
+			}
+		}));
+
 		// test methods
 		assertEquals(
 				Arrays.asList(
 						"int first() {\n" +
-					    "    return first;\n" +
-					    "}", 
+					    "    return this.first;\n" +
+					    "}",
 						"float second() {\n" +
-					    "    return second;\n" +
+					    "    return this.second;\n" +
 					    "}"
 				),
 				head(records).getMethods().stream()
@@ -211,7 +229,7 @@ private CtModel createModelFromPath(String code) {
 
 	@Test
 	void testGenericTypeParametersArePrintedBeforeTheFunctionParameters() {
-		// contract: a record with generic type arguments should be printed correctly 
+		// contract: a record with generic type arguments should be printed correctly
 		String code = "src/test/resources/records/GenericRecord.java";
 		CtModel model = createModelFromPath(code);
 		Collection<CtRecord> records = model.getElements(new TypeFilter<>(CtRecord.class));
@@ -225,7 +243,7 @@ void testBuildRecordModelWithStaticInitializer() {
 		String code = "src/test/resources/records/WithStaticInitializer.java";
 		CtModel model = assertDoesNotThrow(() -> createModelFromPath(code));
 		List<CtAnonymousExecutable> execs = model.getElements(new TypeFilter<>(CtAnonymousExecutable.class));
-		assertThat(execs.size(), equalTo(2));
+		assertThat(execs).hasSize(2);
 	}
 
 	@ModelTest(value = "./src/test/resources/records/MultipleConstructors.java", complianceLevel = 16)
@@ -275,8 +293,29 @@ void testNonCompactCanonicalConstructor(Factory factory) {
 		assertEquals(constructor.getParameters().get(0).getSimpleName(), "x");
 	}
 
+	@ModelTest(value = "./src/test/resources/records/GenericRecord.java", complianceLevel = 16)
+	void testProperReturnInRecordAccessor(Factory factory) {
+		// contract: the return statement in the accessor method should return a field read expression to the correct
+		// field
+		CtRecord record = head(factory.getModel().getElements(new TypeFilter<>(CtRecord.class)));
+
+		assertThat(record.getRecordComponents()).isNotEmpty();
+		for (CtRecordComponent component : record.getRecordComponents()) {
+			CtMethod<?> method = component.toMethod();
+
+			assertThat(method.getBody().<CtStatement>getLastStatement())
+				.asInstanceOf(new InstanceOfAssertFactory<>(CtReturn.class, SpoonAssertions::assertThat))
+				.getReturnedExpression()
+				.self()
+				.asInstanceOf(new InstanceOfAssertFactory<>(CtFieldRead.class, SpoonAssertions::assertThat))
+				.getVariable()
+				.getDeclaringType()
+				.getSimpleName()
+				.isEqualTo(record.getSimpleName());
+		}
+	}
+
 	private <T> T head(Collection<T> collection) {
 		return collection.iterator().next();
 	}
-
 }