Replace the convolved hack (which was moving files around) by symbolic link.

This hack is needed only when we want to simulate the Maven 3 behaviour for compatibility reasons.

This hack is fragile to the case where a module name is a single name (without dot)
and that name is the same as the package name. This ambiguity breaks two tests.
For allowing the tests to pass, this commit renames "foo" module as "foo.bar".

Author: desruisseaux

src/it/jpms_compile-main-foo-test-bar/src/main/java/module-info.java

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-module foo {
+module foo.bar {
     requires org.apache.commons.lang3;
 
     exports foo;

src/it/jpms_compile-main-foo-test-bar/src/test/java/bar/BarTests.java

@@ -30,6 +30,6 @@ void constructor() {
     @Test
     void moduleNameIsFoo() {
         Assertions.assertTrue(Foo.class.getModule().isNamed(), "Foo resides in a named module");
-        Assertions.assertEquals("foo", Foo.class.getModule().getName());
+        Assertions.assertEquals("foo.bar", Foo.class.getModule().getName());
     }
 }

src/it/jpms_compile-main-foo-test-bar/src/test/java/module-info.java

@@ -17,8 +17,8 @@
  * under the License.
  */
 
-open module bar {
-    requires foo;
+open module bar.biz {
+    requires foo.bar;
     requires java.scripting;
     requires org.junit.jupiter.api;
 }

src/it/jpms_compile-main-foo-test-foo/src/main/java/module-info.java

@@ -17,6 +17,6 @@
  * under the License.
  */
 
-module foo {
+module foo.bar {
     requires org.apache.commons.lang3;
 }

src/it/jpms_compile-main-foo-test-foo/src/test/java/foo/FooTests.java

@@ -29,6 +29,6 @@ void constructor() {
     @Test
     void moduleNameIsFoo() {
         Assertions.assertTrue(Foo.class.getModule().isNamed(), "Foo resides in a named module");
-        Assertions.assertEquals("foo", Foo.class.getModule().getName());
+        Assertions.assertEquals("foo.bar", Foo.class.getModule().getName());
     }
 }

src/it/jpms_compile-main-foo-test-foo/src/test/java/module-info.java

@@ -17,7 +17,7 @@
  * under the License.
  */
 
-open module foo {
+open module foo.bar {
     // main
     requires org.apache.commons.lang3;
 

src/main/java/org/apache/maven/plugin/compiler/ToolExecutorForTest.java

@@ -24,14 +24,10 @@
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.UncheckedIOException;
 import java.io.Writer;
 import java.lang.module.ModuleDescriptor;
-import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -40,7 +36,6 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.StringJoiner;
-import java.util.stream.Stream;
 
 import org.apache.maven.api.Dependency;
 import org.apache.maven.api.JavaPathType;
@@ -86,6 +81,13 @@ class ToolExecutorForTest extends ToolExecutor {
      */
     private final boolean hasTestModuleInfo;
 
+    /**
+     * Whether the tests are declared in their own module. If {@code true},
+     * then the {@code module-info.java} file of the test declares a name
+     * different than the {@code module-info.java} file of the main code.
+     */
+    private boolean testInItsOwnModule;
+
     /**
      * Whether the {@code module-info} of the tests overwrites the main {@code module-info}.
      * This is a deprecated practice, but is accepted if {@link #SUPPORT_LEGACY} is true.
@@ -154,6 +156,7 @@ class ToolExecutorForTest extends ToolExecutor {
                     if (testModuleName != null) {
                         overwriteMainModuleInfo = testModuleName.equals(getMainModuleName());
                         if (!overwriteMainModuleInfo) {
+                            testInItsOwnModule = true;
                             continue; // The test classes are in their own module.
                         }
                     }
@@ -191,10 +194,12 @@ class ToolExecutorForTest extends ToolExecutor {
             PathType pathType = JavaPathType.CLASSES;
             if (hasModuleDeclaration) {
                 pathType = JavaPathType.MODULES;
-                String moduleToPatch = getMainModuleName();
-                if (!moduleToPatch.isEmpty()) {
-                    pathType = JavaPathType.patchModule(moduleToPatch);
-                    directoryLevelToRemove = outputDirectory.resolve(moduleToPatch);
+                if (!testInItsOwnModule) {
+                    String moduleToPatch = getMainModuleName();
+                    if (!moduleToPatch.isEmpty()) {
+                        pathType = JavaPathType.patchModule(moduleToPatch);
+                        directoryLevelToRemove = outputDirectory.resolve(moduleToPatch);
+                    }
                 }
             }
             dependencies.computeIfAbsent(pathType, (key) -> new ArrayList<>()).add(0, mainOutputDirectory);
@@ -226,7 +231,7 @@ private String getMainModuleName() throws IOException {
      */
     @Override
     final String inferModuleNameIfMissing(String moduleName) throws IOException {
-        return moduleName.isEmpty() ? getMainModuleName() : moduleName;
+        return (!testInItsOwnModule && moduleName.isEmpty()) ? getMainModuleName() : moduleName;
     }
 
     /**
@@ -334,53 +339,19 @@ public boolean applyIncrementalBuild(AbstractCompilerMojo mojo, Options configur
     @Override
     public boolean compile(JavaCompiler compiler, Options configuration, Writer otherOutput) throws IOException {
         addModuleOptions(configuration); // Effective only once.
+        Path delete = null;
         try {
+            if (directoryLevelToRemove != null) {
+                delete = Files.createSymbolicLink(directoryLevelToRemove, directoryLevelToRemove.getParent());
+            }
             return super.compile(compiler, configuration, otherOutput);
         } finally {
-            if (directoryLevelToRemove != null && Files.exists(directoryLevelToRemove)) {
-                Path target = directoryLevelToRemove.getParent();
-                try (Stream<Path> files = Files.list(directoryLevelToRemove)) {
-                    files.forEach((path) -> {
-                        try {
-                            Files.move(path, deleteRecursively(target.resolve(path.getFileName())));
-                        } catch (IOException e) {
-                            throw new UncheckedIOException(e);
-                        }
-                    });
-                } catch (UncheckedIOException e) {
-                    throw e.getCause();
-                }
-                Files.delete(directoryLevelToRemove);
+            if (delete != null) {
+                Files.delete(delete);
             }
         }
     }
 
-    /**
-     * Deletes the specified directory recursively.
-     *
-     * @param delete the directory to delete
-     * @return the given directory
-     */
-    private static Path deleteRecursively(Path delete) throws IOException {
-        if (Files.notExists(delete)) {
-            return delete;
-        }
-        return Files.walkFileTree(delete, new SimpleFileVisitor<Path>() {
-            @Override
-            public FileVisitResult postVisitDirectory(Path dir, IOException error) throws IOException {
-                var result = super.postVisitDirectory(dir, error);
-                Files.delete(dir);
-                return result;
-            }
-
-            @Override
-            public FileVisitResult visitFile(Path file, BasicFileAttributes attributes) throws IOException {
-                Files.delete(file);
-                return super.visitFile(file, attributes);
-            }
-        });
-    }
-
     /**
      * Separates the compilation of {@code module-info} from other classes. This is needed when the
      * {@code module-info} of the test classes overwrite the {@code module-info} of the main classes.