Unify source tracking with SourceHandlingContext (#11632)

- Replace boolean flags (hasMain, hasTest, etc.) with flexible set-based tracking for all language/scope combinations.
- Rename ResourceHandlingContext to SourceHandlingContext
- Add duplicate detection with WARNING for enabled sources
- Add hasSources() method for checking language/scope combinations
- Rename 'src' variable to 'sourceRoot' for clarity
- Replace Collectors.toList() with .toList() in DefaultProjectBuilder
- Use Java 17+ Stream.toList() instead of Collectors.toList().
- Fix Windows path separator issue in ProjectBuilderTest
- Implement validation rules for modular source handling (#11612):
- AC6: ERROR when mixing modular (with module) and classic (without module) sources within <sources>
- AC7: WARNING when legacy <sourceDirectory>/<testSourceDirectory> are used in modular projects (both explicit config and filesystem existence)
- Add validateNoMixedModularAndClassicSources() to SourceHandlingContext
- Add warnIfExplicitLegacyDirectory() to DefaultProjectBuilder
- Update tests to verify AC6 and AC7 behavior
- Update test project comments to reflect correct behavior

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: ascheman

impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java

@@ -27,6 +27,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.AbstractMap;
 import java.util.ArrayList;
@@ -525,7 +526,7 @@ List<ProjectBuildingResult> doBuild(List<File> pomFiles, boolean recursive) {
                 return pomFiles.stream()
                         .map(pomFile -> build(pomFile, recursive))
                         .flatMap(List::stream)
-                        .collect(Collectors.toList());
+                        .toList();
             } finally {
                 Thread.currentThread().setContextClassLoader(oldContextClassLoader);
             }
@@ -571,7 +572,7 @@ private List<ProjectBuildingResult> build(File pomFile, boolean recursive) {
                     project.setCollectedProjects(results(r)
                             .filter(cr -> cr != r && cr.getEffectiveModel() != null)
                             .map(cr -> projectIndex.get(cr.getEffectiveModel().getId()))
-                            .collect(Collectors.toList()));
+                            .toList());
 
                     DependencyResolutionResult resolutionResult = null;
                     if (request.isResolveDependencies()) {
@@ -665,65 +666,75 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
                         return build.getDirectory();
                     }
                 };
-                boolean hasScript = false;
-                boolean hasMain = false;
-                boolean hasTest = false;
-                boolean hasMainResources = false;
-                boolean hasTestResources = false;
+                // Extract modules from sources to detect modular projects
+                Set<String> modules = extractModules(sources);
+                boolean isModularProject = !modules.isEmpty();
+
+                logger.trace(
+                        "Module detection for project {}: found {} module(s) {} - modular project: {}.",
+                        project.getId(),
+                        modules.size(),
+                        modules,
+                        isModularProject);
+
+                // Create source handling context for unified tracking of all lang/scope combinations
+                SourceHandlingContext sourceContext =
+                        new SourceHandlingContext(project, baseDir, modules, isModularProject, result);
+
+                // Process all sources, tracking enabled ones and detecting duplicates
                 for (var source : sources) {
-                    var src = DefaultSourceRoot.fromModel(session, baseDir, outputDirectory, source);
-                    project.addSourceRoot(src);
-                    Language language = src.language();
-                    if (Language.JAVA_FAMILY.equals(language)) {
-                        ProjectScope scope = src.scope();
-                        if (ProjectScope.MAIN.equals(scope)) {
-                            hasMain = true;
-                        } else {
-                            hasTest |= ProjectScope.TEST.equals(scope);
-                        }
-                    } else if (Language.RESOURCES.equals(language)) {
-                        ProjectScope scope = src.scope();
-                        if (ProjectScope.MAIN.equals(scope)) {
-                            hasMainResources = true;
-                        } else if (ProjectScope.TEST.equals(scope)) {
-                            hasTestResources = true;
-                        }
-                    } else {
-                        hasScript |= Language.SCRIPT.equals(language);
+                    var sourceRoot = DefaultSourceRoot.fromModel(session, baseDir, outputDirectory, source);
+                    // Track enabled sources for duplicate detection and hasSources() queries
+                    // Only add source if it's not a duplicate enabled source (first enabled wins)
+                    if (sourceContext.shouldAddSource(sourceRoot)) {
+                        project.addSourceRoot(sourceRoot);
                     }
                 }
+
                 /*
                  * `sourceDirectory`, `testSourceDirectory` and `scriptSourceDirectory`
-                 * are ignored if the POM file contains at least one <source> element
+                 * are ignored if the POM file contains at least one enabled <source> element
                  * for the corresponding scope and language. This rule exists because
                  * Maven provides default values for those elements which may conflict
                  * with user's configuration.
+                 *
+                 * Additionally, for modular projects, legacy directories are unconditionally
+                 * ignored because it is not clear how to dispatch their content between
+                 * different modules. A warning is emitted if these properties are explicitly set.
                  */
-                if (!hasScript) {
+                if (!sourceContext.hasSources(Language.SCRIPT, ProjectScope.MAIN)) {
                     project.addScriptSourceRoot(build.getScriptSourceDirectory());
                 }
-                if (!hasMain) {
-                    project.addCompileSourceRoot(build.getSourceDirectory());
-                }
-                if (!hasTest) {
-                    project.addTestCompileSourceRoot(build.getTestSourceDirectory());
+                if (isModularProject) {
+                    // Modular projects: unconditionally ignore legacy directories, warn if explicitly set
+                    warnIfExplicitLegacyDirectory(
+                            build.getSourceDirectory(),
+                            baseDir.resolve("src/main/java"),
+                            "<sourceDirectory>",
+                            project.getId(),
+                            result);
+                    warnIfExplicitLegacyDirectory(
+                            build.getTestSourceDirectory(),
+                            baseDir.resolve("src/test/java"),
+                            "<testSourceDirectory>",
+                            project.getId(),
+                            result);
+                } else {
+                    // Classic projects: use legacy directories if no sources defined in <sources>
+                    if (!sourceContext.hasSources(Language.JAVA_FAMILY, ProjectScope.MAIN)) {
+                        project.addCompileSourceRoot(build.getSourceDirectory());
+                    }
+                    if (!sourceContext.hasSources(Language.JAVA_FAMILY, ProjectScope.TEST)) {
+                        project.addTestCompileSourceRoot(build.getTestSourceDirectory());
+                    }
                 }
-                // Extract modules from sources to detect modular projects
-                Set<String> modules = extractModules(sources);
-                boolean isModularProject = !modules.isEmpty();
 
-                logger.trace(
-                        "Module detection for project {}: found {} module(s) {} - modular project: {}.",
-                        project.getId(),
-                        modules.size(),
-                        modules,
-                        isModularProject);
+                // Validate that modular and classic sources are not mixed within <sources>
+                sourceContext.validateNoMixedModularAndClassicSources();
 
-                // Handle main and test resources
-                ResourceHandlingContext resourceContext =
-                        new ResourceHandlingContext(project, baseDir, modules, isModularProject, result);
-                resourceContext.handleResourceConfiguration(ProjectScope.MAIN, hasMainResources);
-                resourceContext.handleResourceConfiguration(ProjectScope.TEST, hasTestResources);
+                // Handle main and test resources using unified source handling
+                sourceContext.handleResourceConfiguration(ProjectScope.MAIN);
+                sourceContext.handleResourceConfiguration(ProjectScope.TEST);
             }
 
             project.setActiveProfiles(
@@ -894,6 +905,49 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
             project.setRemoteArtifactRepositories(remoteRepositories);
         }
 
+        /**
+         * Warns about legacy directory usage in a modular project. Two cases are handled:
+         * <ul>
+         *   <li>Case 1: The default legacy directory exists on the filesystem (e.g., src/main/java exists)</li>
+         *   <li>Case 2: An explicit legacy directory is configured that differs from the default</li>
+         * </ul>
+         * Legacy directories are unconditionally ignored in modular projects because it is not clear
+         * how to dispatch their content between different modules.
+         */
+        private void warnIfExplicitLegacyDirectory(
+                String configuredDir,
+                Path defaultDir,
+                String elementName,
+                String projectId,
+                ModelBuilderResult result) {
+            if (configuredDir != null) {
+                Path configuredPath = Path.of(configuredDir).toAbsolutePath().normalize();
+                Path defaultPath = defaultDir.toAbsolutePath().normalize();
+                if (!configuredPath.equals(defaultPath)) {
+                    // Case 2: Explicit configuration differs from default - always warn
+                    String message = String.format(
+                            "Legacy %s is ignored in modular project %s. "
+                                    + "In modular projects, source directories must be defined via <sources> "
+                                    + "with a module element for each module.",
+                            elementName, projectId);
+                    logger.warn(message);
+                    result.getProblemCollector()
+                            .reportProblem(new org.apache.maven.impl.model.DefaultModelProblem(
+                                    message, Severity.WARNING, Version.V41, null, -1, -1, null));
+                } else if (Files.isDirectory(defaultPath)) {
+                    // Case 1: Default configuration, but the default directory exists on filesystem
+                    String message = String.format(
+                            "Legacy %s '%s' exists but is ignored in modular project %s. "
+                                    + "In modular projects, source directories must be defined via <sources>.",
+                            elementName, defaultPath, projectId);
+                    logger.warn(message);
+                    result.getProblemCollector()
+                            .reportProblem(new org.apache.maven.impl.model.DefaultModelProblem(
+                                    message, Severity.WARNING, Version.V41, null, -1, -1, null));
+                }
+            }
+        }
+
         private void initParent(MavenProject project, ModelBuilderResult result) {
             Model parentModel = result.getParentModel();
 
@@ -1035,8 +1089,8 @@ private DependencyResolutionResult resolveDependencies(MavenProject project) {
         }
     }
 
-    private List<String> getProfileIds(List<Profile> profiles) {
-        return profiles.stream().map(Profile::getId).collect(Collectors.toList());
+    private static List<String> getProfileIds(List<Profile> profiles) {
+        return profiles.stream().map(Profile::getId).toList();
     }
 
     private static ModelSource createStubModelSource(Artifact artifact) {