fix: renaming of generics (#6458)

Author: MaxAtoms

src/main/java/spoon/refactoring/Refactoring.java

@@ -45,8 +45,7 @@ public static void changeTypeName(final CtType<?> type, String name) {
 		final List<CtTypeReference<?>> references = Query.getElements(type.getFactory(), new TypeFilter<CtTypeReference<?>>(CtTypeReference.class) {
 			@Override
 			public boolean matches(CtTypeReference<?> reference) {
-				String refFQN = reference.getQualifiedName();
-				return typeQFN.equals(refFQN);
+				return type == reference.getDeclaration();
 			}
 		});
 
@@ -79,7 +78,6 @@ public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
 	 * If the method is a CtAnnotationMethod, the references in the annotations are changed too.
 	 */
 	public static void changeMethodName(final CtMethod<?> method, String newName) {
-
 		renameExecutableReferences(method, newName);
 
 		if (method instanceof CtAnnotationMethod<?> annotationMethod) {

src/test/java/spoon/test/refactoring/RefactoringTest.java

@@ -56,11 +56,13 @@
 import spoon.support.compiler.VirtualFile;
 import spoon.test.refactoring.processors.ThisTransformationProcessor;
 import spoon.test.refactoring.testclasses.AClass;
+import spoon.test.refactoring.testclasses.GenericRenaming;
+import spoon.test.refactoring.testclasses.MethodGenericRenaming;
+import spoon.testing.utils.ModelUtils;
 import spoon.test.refactoring.testclasses.AnnotationMethodRenaming;
 import spoon.test.refactoring.testclasses.ExampleAnnotation;
 import spoon.test.refactoring.testclasses.InterfaceRenaming;
 import spoon.test.refactoring.testclasses.MethodRenaming;
-import spoon.testing.utils.ModelUtils;
 
 public class RefactoringTest {
 	@Test
@@ -223,6 +225,69 @@ void renameClassInVirtualFile() {
 		);
 	}
 
+	@Test
+	void testRenameType() throws Exception {
+		Factory factory = ModelUtils.build(GenericRenaming.class);
+		CtClass<?> clazz = factory.Class().get(GenericRenaming.class);
+		var nestedClass = clazz.getNestedType("SomeNestedType");
+		Refactoring.changeTypeName(nestedClass, "RenamedNestedType");
+
+		assertEquals("RenamedNestedType", nestedClass.getSimpleName());
+
+		var refs = clazz.getElements(new TypeFilter<>(CtTypeReference.class)).stream().filter(t -> t.getSimpleName().equals("RenamedNestedType")).toList();
+		assertEquals(2, refs.size());
+		for (var ref : refs) {
+			assertEquals(nestedClass, ref.getDeclaration());
+		}
+	}
+
+	@Test
+	void testRenameGenerics() throws Exception {
+		Factory factory = ModelUtils.build(GenericRenaming.class);
+		CtClass<?> clazz = factory.Class().get(GenericRenaming.class);
+		List<CtType<?>> types = clazz.getElements(new TypeFilter<>(CtType.class));
+
+		renameAndCheckClassGeneric(clazz, types, "SomeIdentifier", "TNew1", 15);
+		renameAndCheckClassGeneric(clazz, types, "SomeOther", "TNew2", 17);
+		renameAndCheckMethodGeneric(clazz, "doTheThing", types, "SomeMethodGeneric", "TNew3", 2);
+	}
+
+	@Test
+	void testRenameGenericsShouldRespectScope() throws Exception {
+		Factory factory = ModelUtils.build(MethodGenericRenaming.class);
+		CtClass<?> clazz = factory.Class().get(MethodGenericRenaming.class);
+		List<CtType<?>> types = clazz.getElements(new TypeFilter<>(CtType.class));
+		renameAndCheckMethodGeneric(clazz, "sort", types, "T", "TNew", 3);
+	}
+
+	private static void renameAndCheckMethodGeneric(CtClass<?> clazz, String method, List<CtType<?>> types, String oldName, String newName, int expectedRefs) {
+		var generic = clazz.getMethodsByName(method).get(0).getElements(new TypeFilter<>(CtType.class))
+				.stream().filter(t -> t.getSimpleName().equals(oldName)).findFirst().orElseThrow();
+		Refactoring.changeTypeName(generic, newName);
+		assertEquals(newName, generic.getSimpleName());
+
+		var typeRefs = clazz.getElements(new TypeFilter<>(CtTypeReference.class))
+				.stream().filter(typeRef -> typeRef.getSimpleName().equals(newName)).toList();
+		assertEquals(expectedRefs, typeRefs.size());
+		for (var typeRef : typeRefs) {
+			assertEquals(generic.getParent(CtMethod.class), typeRef.getParent(CtMethod.class));
+		}
+	}
+
+	private static void renameAndCheckClassGeneric(CtClass<?> clazz, List<CtType<?>> types, String oldName, String newName, int expectedRefs) {
+		var classGeneric = types.stream().filter((CtType<?> t) -> t.getSimpleName().equals(oldName)).findFirst().orElseThrow();
+		Refactoring.changeTypeName(classGeneric, newName);
+		assertEquals(newName, classGeneric.getSimpleName());
+
+		var typeRefs = clazz.getElements(new TypeFilter<>(CtTypeReference.class))
+				.stream().filter(typeRef -> typeRef.getSimpleName().equals(newName)).toList();
+
+		assertEquals(expectedRefs, typeRefs.size());
+		for (var typeRef : typeRefs) {
+			assertEquals(classGeneric, typeRef.getDeclaration());
+		}
+	}
+
 	@Test
 	void testChangeMethodName() throws Exception {
 		String newName = "methodRenamed";

src/test/java/spoon/test/refactoring/testclasses/GenericRenaming.java

@@ -0,0 +1,30 @@
+package spoon.test.refactoring.testclasses;
+
+public class GenericRenaming<SomeIdentifier, SomeOther> {
+	private SomeIdentifier content;
+	private SomeOther header;
+
+	public GenericRenaming() {
+		new SomeNestedType();
+	}
+
+	public void setContent(SomeIdentifier content, SomeOther header) {
+		this.content = content;
+		this.header = header;
+	}
+
+	public <SomeMethodGeneric extends SomeOther> SomeMethodGeneric doTheThing() {
+		return (SomeMethodGeneric) header;
+	}
+
+	public SomeIdentifier getContent() {
+		return content;
+	}
+
+	public SomeOther getHeader() {
+		return header;
+	}
+
+	public class SomeNestedType {
+	}
+}

src/test/java/spoon/test/refactoring/testclasses/MethodGenericRenaming.java

@@ -0,0 +1,11 @@
+package spoon.test.refactoring.testclasses;
+
+public class MethodGenericRenaming {
+	public <T> T[] sort(T[] array) {
+		return sort(array, false);
+	}
+
+	public <T> T[] sort(T[] array, boolean order) {
+		return array;
+	}
+}