review: feat: add support for module imports

src/main/java/spoon/reflect/declaration/CtImportKind.java

@@ -13,6 +13,7 @@ public enum CtImportKind {
 	ALL_STATIC_MEMBERS, // import static my.package.Type.*;
 	FIELD, // import static my.package.Type.f;
 	METHOD, // import static my.package.Type.m;
-	UNRESOLVED // Any of the above when in mode no classpath and the reference cannot be resolved.
+	UNRESOLVED, // Any of the above when in mode no classpath and the reference cannot be resolved.
 	// It is then stored as a pure String that will be printed as is when pretty printed.
+	MODULE
 }

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

@@ -10,6 +10,7 @@
 import spoon.experimental.CtUnresolvedImport;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
+import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.reference.CtPackageReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.reference.CtTypeMemberWildcardImportReference;
@@ -41,4 +42,8 @@ public <T> void visitAllStaticMembersImport(CtTypeMemberWildcardImportReference
 	@Override
 	public <T> void visitUnresolvedImport(CtUnresolvedImport unresolvedImport) {
 	}
+
+	@Override
+	public void visitModuleImport(CtModuleReference moduleReference) {
+	}
 }

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

@@ -10,6 +10,7 @@
 import spoon.experimental.CtUnresolvedImport;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
+import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.reference.CtPackageReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.reference.CtTypeMemberWildcardImportReference;
@@ -48,4 +49,11 @@ public interface CtImportVisitor {
 	 * Called for unresolved import
 	 */
 	<T> void visitUnresolvedImport(CtUnresolvedImport ctUnresolvedImport);
+
+	/**
+	 * Called for import like:
+	 * <code>import module my.module.name;</code>
+	 * @param moduleReference the module reference
+	 */
+	void visitModuleImport(CtModuleReference moduleReference);
 }

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

@@ -1106,6 +1106,13 @@ public <T> void visitUnresolvedImport(CtUnresolvedImport ctUnresolvedImport) {
 					}
 					printer.writeCodeSnippet(ctUnresolvedImport.getUnresolvedReference());
 				}
+
+				@Override
+				public void visitModuleImport(CtModuleReference moduleReference) {
+					printer.writeKeyword("module");
+					printer.writeSpace();
+					printer.writeIdentifier(moduleReference.getSimpleName());
+				}
 			});
 			printer.writeSeparator(";");
 		}

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

@@ -264,8 +264,11 @@ void onCompilationUnitProcessed(CtCompilationUnit compilationUnit) {
 			ModelList<CtImport> existingImports = compilationUnit.getImports();
 			Set<CtImport> computedImports = new HashSet<>(this.computedImports.values());
 			topfor: for (CtImport oldImport : new ArrayList<>(existingImports)) {
+				if (oldImport.getImportKind() == CtImportKind.MODULE) {
+					//never remove module imports
+					continue;
+				}
 				if (!removeImport(oldImport, computedImports)) {
-
 					// case: import is required in Javadoc
 					for (CtType type: compilationUnit.getDeclaredTypes()) {
 						for (CtJavaDoc element: type.getElements(new TypeFilter<>(CtJavaDoc.class))) {

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

@@ -24,6 +24,7 @@
 import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
+import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.reference.CtPackageReference;
 import spoon.reflect.reference.CtTypeMemberWildcardImportReference;
 import spoon.reflect.reference.CtTypeReference;
@@ -164,6 +165,11 @@ public <T> void visitAllStaticMembersImport(CtTypeMemberWildcardImportReference
 				public <T> void visitUnresolvedImport(CtUnresolvedImport ctUnresolvedImport) {
 					//there is no usable type member under unresolved import
 				}
+
+				@Override
+				public void visitModuleImport(CtModuleReference moduleReference) {
+					//modules are not relevant for type members
+				}
 			});
 		});
 		//names of all types of same package are visible too, but with lower priority then explicitly imported elements

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

@@ -9,15 +9,18 @@
 
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ImportReference;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 
 import spoon.reflect.cu.CompilationUnit;
 import spoon.reflect.declaration.CtImport;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtModule;
 import spoon.reflect.declaration.CtNamedElement;
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
+import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.reference.CtReference;
 
 import java.util.Arrays;
@@ -73,6 +76,12 @@ void build() {
 						}
 					}
 
+				} else if ((importRef.modifiers & ClassFileConstants.AccModule) != 0) { // this check is copied from JDT's ImportReference
+					// import of a module
+					String moduleName = JDTTreeBuilderHelper.createQualifiedTypeName(importRef.getImportName());
+					CtModule ctModule = factory.Module().getOrCreate(moduleName);
+					CtModuleReference moduleRef = factory.Module().createReference(ctModule).setSimpleName(moduleName);
+					this.imports.add(createImportWithPosition(moduleRef, importRef));
 				} else {
 					CtType klass = this.getOrLoadClass(importName);
 					if (klass != null) {

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

@@ -14,6 +14,7 @@
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.declaration.CtImport;
+import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.reference.CtPackageReference;
 import spoon.reflect.reference.CtReference;
 import spoon.reflect.declaration.CtImportKind;
@@ -50,8 +51,10 @@ private CtImportKind getImportKindFor(CtReference ref) {
 			return CtImportKind.ALL_STATIC_MEMBERS;
 		} else if (ref instanceof CtTypeReference) {
 			return CtImportKind.TYPE;
+		} else if (ref instanceof CtModuleReference) {
+			return CtImportKind.MODULE;
 		} else {
-			throw new SpoonException("Only CtFieldReference, CtExecutableReference, CtPackageReference and CtTypeReference are accepted reference types. Given " + ref.getClass());
+			throw new SpoonException("Only CtFieldReference, CtExecutableReference, CtPackageReference, CtTypeReference and CtModuleReference are accepted reference types. Given " + ref.getClass());
 		}
 	}
 
@@ -82,30 +85,14 @@ public void accept(CtVisitor visitor) {
 	@Override
 	public void accept(CtImportVisitor visitor) {
 		switch (getImportKind()) {
-		case TYPE:
-			visitor.visitTypeImport((CtTypeReference<?>) localReference);
-			break;
-
-		case METHOD:
-			visitor.visitMethodImport((CtExecutableReference<?>) localReference);
-			break;
-
-		case FIELD:
-			visitor.visitFieldImport((CtFieldReference<?>) localReference);
-			break;
-
-		case ALL_TYPES:
-			visitor.visitAllTypesImport((CtPackageReference) localReference);
-			break;
-
-		case ALL_STATIC_MEMBERS:
-			visitor.visitAllStaticMembersImport((CtTypeMemberWildcardImportReference) localReference);
-			break;
-		case UNRESOLVED:
-			visitor.visitUnresolvedImport((CtUnresolvedImport) localReference);
-			break;
-		default:
-			throw new SpoonException("Unexpected import kind: " + getImportKind());
+			case TYPE -> visitor.visitTypeImport((CtTypeReference<?>) localReference);
+			case METHOD -> visitor.visitMethodImport((CtExecutableReference<?>) localReference);
+			case FIELD -> visitor.visitFieldImport((CtFieldReference<?>) localReference);
+			case ALL_TYPES -> visitor.visitAllTypesImport((CtPackageReference) localReference);
+			case ALL_STATIC_MEMBERS -> visitor.visitAllStaticMembersImport((CtTypeMemberWildcardImportReference) localReference);
+			case MODULE -> visitor.visitModuleImport((CtModuleReference) localReference);
+			case UNRESOLVED -> visitor.visitUnresolvedImport((CtUnresolvedImport) localReference);
+			default -> throw new SpoonException("Unexpected import kind: " + getImportKind());
 		}
 	}
 

src/test/java/spoon/reflect/visitor/DefaultJavaPrettyPrinterTest.java

@@ -5,6 +5,8 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
+
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtensionContext;
@@ -39,6 +41,7 @@
 import spoon.support.reflect.reference.CtArrayTypeReferenceImpl;
 import spoon.test.SpoonTestHelpers;
 import spoon.testing.assertions.SpoonAssertions;
+import spoon.testing.utils.BySimpleName;
 import spoon.testing.utils.GitHubIssue;
 import spoon.testing.utils.ModelTest;
 
@@ -474,4 +477,12 @@ void printAnnotationsInOrphanTypeReference(Factory factory) {
     private @interface TypeUseAnnotation {
 
     }
+
+	@ModelTest(value = {"src/test/resources/imports/ModuleImport.java"}, autoImport = true, complianceLevel = 25)
+	void moduleImportsArePrinted(@BySimpleName("ModuleImport") CtType<?> type, Launcher launcher) {
+		PrettyPrinter prettyPrinter = launcher.createPrettyPrinter();
+		String output = prettyPrinter.prettyprint(type.getPosition().getCompilationUnit());
+		Assertions.assertThat(output).contains("import module java.base");
+	}
+
 }