GH-354: Fail if no compilation units are found/filtered classes not found

- Add new method: PathFileObject#getBinaryName
- JctCompilationFactoryImpl will now error if no initial compilation units
  were found with a clearer error message.
- JctCompilationFactoryImpl will now error if any of the explicitly provided
  class names are not found as compilation units.
- JctCompilationFactoryImpl will now error if the list of provided class
  names is non-null but empty.

Author: ascopes

java-compiler-testing/src/main/java/io/github/ascopes/jct/compilers/JctCompilationFactory.java

@@ -43,7 +43,9 @@ public interface JctCompilationFactory {
    *                       should be discovered automatically.
    * @return the compilation result that contains whether the compiler succeeded or failed, amongst
    *     other information.
-   * @throws JctCompilerException if compiler raises an unhandled exception and cannot complete.
+   * @throws JctCompilerException if any prerequisites fail, such as no compilation units being
+   *    found, or if the underlying JSR-199 compiler raises an unhandled exception and cannot
+   *    complete when invoked.
    */
   JctCompilation createCompilation(
       List<String> flags,

java-compiler-testing/src/main/java/io/github/ascopes/jct/compilers/impl/JctCompilationFactoryImpl.java

@@ -16,6 +16,7 @@
 package io.github.ascopes.jct.compilers.impl;
 
 import static java.util.Objects.requireNonNull;
+import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.toList;
 
 import io.github.ascopes.jct.compilers.JctCompilation;
@@ -27,15 +28,13 @@
 import io.github.ascopes.jct.filemanagers.JctFileManager;
 import io.github.ascopes.jct.filemanagers.LoggingMode;
 import io.github.ascopes.jct.filemanagers.PathFileObject;
-import io.github.ascopes.jct.utils.FileUtils;
 import io.github.ascopes.jct.utils.IterableUtils;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
@@ -92,6 +91,12 @@ private JctCompilation createCheckedCompilation(
   ) throws Exception {
     var compilationUnits = findFilteredCompilationUnits(fileManager, classNames);
 
+    if (compilationUnits.isEmpty()) {
+      throw classNames == null
+          ? new JctCompilerException("No compilation units were found in the given workspace")
+          : new JctCompilerException("No compilation units were found for the given class names");
+    }
+
     // Do not close stdout, it breaks test engines, especially IntellIJ.
     var writer = new TeeWriter(new OutputStreamWriter(System.out, compiler.getLogCharset()));
 
@@ -163,10 +168,11 @@ private Set<JavaFileObject> findFilteredCompilationUnits(
       return compilationUnits;
     }
 
-    return compilationUnits
-        .stream()
-        .filter(pathFileObjectIn(classNames))
-        .collect(Collectors.toSet());
+    if (classNames.isEmpty()) {
+      throw new JctCompilerException("The list of explicit class names to compile is empty");
+    }
+
+    return filterCompilationUnitsByBinaryNames(compilationUnits, classNames);
   }
 
   private Set<JavaFileObject> findCompilationUnits(JctFileManager fileManager) throws IOException {
@@ -190,20 +196,43 @@ private Set<JavaFileObject> findCompilationUnits(JctFileManager fileManager) thr
       objects.addAll(fileManager.list(location, "", Set.of(Kind.SOURCE), true));
     }
 
-    if (objects.isEmpty()) {
-      throw new JctCompilerException(
-          "No compilation units were found. Did you forget to add something?"
-      );
-    }
-
     return objects;
   }
 
-  private Predicate<JavaFileObject> pathFileObjectIn(Collection<String> classNames) {
-    return fileObject -> {
-      var pathFileObject = (PathFileObject) fileObject;
-      var binaryName = FileUtils.pathToBinaryName(pathFileObject.getRelativePath());
-      return classNames.contains(binaryName);
-    };
+  private Set<JavaFileObject> filterCompilationUnitsByBinaryNames(
+      Set<JavaFileObject> compilationUnits,
+      Collection<String> classNames
+  ) {
+    var binaryNamesToCompilationUnits = compilationUnits
+        .stream()
+        // Assumption that we always use this class internally. Technically unsafe, but we don't
+        // care too much as the implementation should conform to this anyway. We just cannot enforce
+        // it due to covariance rules.
+        .map(PathFileObject.class::cast)
+        .collect(Collectors.toMap(
+            PathFileObject::getBinaryName,
+            identity()
+        ));
+
+    var filteredCompilationUnits = new HashSet<JavaFileObject>();
+
+    for (var className : classNames) {
+      var compilationUnit = binaryNamesToCompilationUnits.get(className);
+      if (compilationUnit == null) {
+        throw new JctCompilerException(
+            "No compilation unit matching " + className + " found in the provided sources"
+        );
+      }
+
+      filteredCompilationUnits.add(compilationUnit);
+    }
+
+    LOGGER.atDebug()
+        .setMessage("Filtered {} candidate compilation units down to {} final compilation units")
+        .addArgument(compilationUnits::size)
+        .addArgument(filteredCompilationUnits::size)
+        .log();
+
+    return filteredCompilationUnits;
   }
 }

java-compiler-testing/src/main/java/io/github/ascopes/jct/filemanagers/PathFileObject.java

@@ -150,6 +150,17 @@ public Modifier getAccessLevel() {
     return unknown();
   }
 
+  /**
+   * Get the inferred binary name of the file object.
+   *
+   * @return the inferred binary name.
+   * @since 0.2.1
+   */
+  @API(since = "0.2.1", status = Status.STABLE)
+  public String getBinaryName() {
+    return FileUtils.pathToBinaryName(relativePath);
+  }
+
   /**
    * Read the character content of the file into memory and decode it using the default character
    * set.

java-compiler-testing/src/test/java/io/github/ascopes/jct/tests/unit/filemanagers/PathFileObjectTest.java

@@ -27,6 +27,7 @@
 import static org.mockito.Mockito.mock;
 
 import io.github.ascopes.jct.filemanagers.PathFileObject;
+import io.github.ascopes.jct.utils.FileUtils;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.nio.charset.MalformedInputException;
@@ -224,6 +225,19 @@ void getAccessLevelReturnsNull() {
     assertThat(fileObject.getAccessLevel()).isNull();
   }
 
+  @DisplayName(".getBinaryName() gets the binary name of the relative path")
+  @Test
+  void getBinaryNameGetsTheBinaryNameOfTheRelativePath() {
+    // Given
+    var relativePath = someRelativePath().resolve("Cat.java");
+    var expectedBinaryName = FileUtils.pathToBinaryName(relativePath);
+    var fileObject = new PathFileObject(someLocation(), someAbsolutePath(), relativePath);
+
+    // Then
+    assertThat(fileObject.getBinaryName())
+        .isEqualTo(expectedBinaryName);
+  }
+
   @DisplayName(".getCharContent(...) returns the character content")
   @ValueSource(booleans = {true, false})
   @ParameterizedTest(name = "for ignoreEncodingErrors={0}")