Optimize annotation processor I/O operations and improve environment compatibility (#1368)

* refactor: Optimize validateUnusedSqlFiles to reduce unnecessary I/O operations

Replace nested loops with stream operations and add early returns to avoid
redundant file system access when there are no query files to validate.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

* refactor: Improve resource handling for environments without directory path support

- Add canAcceptDirectoryPath check to prevent directory operations when not supported
- Make JavaFileManager location configurable with fallback to CLASS_OUTPUT
- Skip unused SQL file validation when directory paths cannot be accepted

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: nakamura-to

doma-processor/src/main/java/org/seasar/doma/internal/apt/ProcessingContext.java

@@ -20,6 +20,8 @@
 import javax.annotation.processing.RoundEnvironment;
 import javax.lang.model.util.Elements;
 import javax.lang.model.util.Types;
+import javax.tools.JavaFileManager;
+import javax.tools.StandardLocation;
 
 public class ProcessingContext {
 
@@ -38,25 +40,32 @@ private void init() {
     if (initialized) {
       throw new AptIllegalStateException("already initialized");
     }
+    var envClassName = env.getClass().getName();
+    var isRunningOnEcj = envClassName.startsWith("org.eclipse.");
+    var resourceDir = env.getOptions().get(Options.RESOURCES_DIR);
+    var canAcceptDirectoryPath = isRunningOnEcj || resourceDir != null;
+    var location = determineLocation(isRunningOnEcj);
+
     reporter = new Reporter(env.getMessager());
     resources =
         new Resources(
-            env.getFiler(),
-            reporter,
-            env.getOptions().get(Options.RESOURCES_DIR),
-            isRunningOnEclipse(env),
-            isDebug(env));
+            env.getFiler(), reporter, resourceDir, canAcceptDirectoryPath, location, isDebug(env));
     options = new Options(env.getOptions(), resources);
     initialized = true;
   }
 
-  private boolean isRunningOnEclipse(ProcessingEnvironment env) {
-    var envClassName = env.getClass().getName();
+  private JavaFileManager.Location determineLocation(boolean isRunningOnEcj) {
     var unitTest = env.getOptions().get(Options.TEST_UNIT);
     var integrationTest = env.getOptions().get(Options.TEST_INTEGRATION);
-    return envClassName.startsWith("org.eclipse.")
+    if (isRunningOnEcj
         && !Boolean.parseBoolean(unitTest)
-        && !Boolean.parseBoolean(integrationTest);
+        && !Boolean.parseBoolean(integrationTest)) {
+      // Eclipse doesn’t support SOURCE_PATH, use CLASS_OUTPUT.
+      return StandardLocation.CLASS_OUTPUT;
+    }
+    // To leverage Gradle’s incremental annotation processing, we recommend using the --source-path
+    // option of javac.
+    return StandardLocation.SOURCE_PATH;
   }
 
   private boolean isDebug(ProcessingEnvironment env) {

doma-processor/src/main/java/org/seasar/doma/internal/apt/Resources.java

@@ -25,6 +25,7 @@
 import javax.annotation.processing.Filer;
 import javax.lang.model.element.Element;
 import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardLocation;
 
@@ -36,21 +37,27 @@ public class Resources {
 
   private final String resourcesDir;
 
-  private final boolean isRunningOnEclipse;
+  private final boolean canAcceptDirectoryPath;
+
+  private final JavaFileManager.Location location;
+
+  private final JavaFileManager.Location fallbackLocation = StandardLocation.CLASS_OUTPUT;
 
   private final boolean isDebug;
 
   Resources(
       Filer filer,
       Reporter reporter,
       String resourcesDir,
-      boolean isRunningOnEclipse,
+      boolean canAcceptDirectoryPath,
+      JavaFileManager.Location location,
       boolean isDebug) {
     assertNotNull(filer, reporter);
     this.filer = filer;
     this.reporter = reporter;
     this.resourcesDir = resourcesDir;
-    this.isRunningOnEclipse = isRunningOnEclipse;
+    this.canAcceptDirectoryPath = canAcceptDirectoryPath;
+    this.location = location;
     this.isDebug = isDebug;
   }
 
@@ -59,6 +66,23 @@ public JavaFileObject createSourceFile(CharSequence name, Element... originating
     return filer.createSourceFile(name, originatingElements);
   }
 
+  /**
+   * Indicates whether directory paths can be accepted in the {@code #getResource} method.
+   *
+   * @return {@code true} if directory paths can be accepted; {@code false} otherwise
+   */
+  public boolean canAcceptDirectoryPath() {
+    return canAcceptDirectoryPath;
+  }
+
+  /**
+   * Attempts to retrieve a resource file based on the specified relative path.
+   *
+   * @param relativePath the relative path to the desired resource; must not be null
+   * @return a {@code FileObject} representing the resource located at the given relative path
+   * @throws IOException if an I/O error occurs during resource retrieval
+   * @throws AssertionError if the {@code relativePath} parameter is null
+   */
   public FileObject getResource(String relativePath) throws IOException {
     assertNotNull(relativePath);
 
@@ -68,22 +92,21 @@ public FileObject getResource(String relativePath) throws IOException {
       return new FileObjectImpl(path);
     }
 
-    // Since Eclipse doesn’t support SOURCE_PATH, use CLASS_OUTPUT.
-    if (isRunningOnEclipse) {
-      return filer.getResource(StandardLocation.CLASS_OUTPUT, "", relativePath);
-    }
-
-    // To leverage Gradle’s incremental annotation processing, we recommend using the --source-path
-    // option of javac.
     try {
-      return filer.getResource(StandardLocation.SOURCE_PATH, "", relativePath);
+      return filer.getResource(location, "", relativePath);
     } catch (Exception e) {
-      if (isDebug) {
-        reporter.debug(
-            "Fall back from SOURCE_PATH to CLASS_OUTPUT: " + relativePath + ", exception: " + e);
+      if (location != fallbackLocation) {
+        if (isDebug) {
+          var message =
+              String.format(
+                  "Fall back from %s to %s: %s, exception: %s",
+                  location, fallbackLocation, relativePath, e);
+          reporter.debug(message);
+        }
+        // If a file cannot be found in the default location, use the fallbackLocation.
+        return filer.getResource(fallbackLocation, "", relativePath);
       }
-      // If a file cannot be found in SOURCE_PATH, fall back to CLASS_OUTPUT.
-      return filer.getResource(StandardLocation.CLASS_OUTPUT, "", relativePath);
+      throw e;
     }
   }
 

doma-processor/src/main/java/org/seasar/doma/internal/apt/meta/dao/DaoMetaFactory.java

@@ -28,6 +28,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.ExecutableElement;
@@ -336,16 +337,30 @@ private void validateFiles(TypeElement interfaceElement, DaoMeta daoMeta) {
     if (daoMeta.isError()) {
       return;
     }
+
     if (!ctx.getOptions().getSqlValidation()) {
       return;
     }
+
+    if (!ctx.getResources().canAcceptDirectoryPath()) {
+      return;
+    }
+
+    var queryFileNames =
+        daoMeta.getQueryMetas().stream()
+            .flatMap(it -> it.getFileNames().stream())
+            .collect(Collectors.toSet());
+    if (queryFileNames.isEmpty()) {
+      return;
+    }
+
     String dirPath = SqlFileUtil.buildPath(interfaceElement.getQualifiedName().toString());
     Set<String> fileNames = getFileNames(dirPath);
-    for (QueryMeta queryMeta : daoMeta.getQueryMetas()) {
-      for (String fileName : queryMeta.getFileNames()) {
-        fileNames.remove(fileName);
-      }
+    fileNames.removeAll(queryFileNames);
+    if (fileNames.isEmpty()) {
+      return;
     }
+
     Suppress suppress = interfaceElement.getAnnotation(Suppress.class);
     Message message = Message.DOMA4220;
     if (!isSuppressed(suppress, message)) {