Add AC6 and AC7 validation for modular sources

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)

Changes:
- 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;
@@ -696,17 +697,41 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
                  * 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 (!sourceContext.hasSources(Language.SCRIPT, ProjectScope.MAIN)) {
                     project.addScriptSourceRoot(build.getScriptSourceDirectory());
                 }
-                if (!sourceContext.hasSources(Language.JAVA_FAMILY, ProjectScope.MAIN)) {
-                    project.addCompileSourceRoot(build.getSourceDirectory());
-                }
-                if (!sourceContext.hasSources(Language.JAVA_FAMILY, ProjectScope.TEST)) {
-                    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());
+                    }
                 }
 
+                // Validate that modular and classic sources are not mixed within <sources>
+                sourceContext.validateNoMixedModularAndClassicSources();
+
                 // Handle main and test resources using unified source handling
                 sourceContext.handleResourceConfiguration(ProjectScope.MAIN);
                 sourceContext.handleResourceConfiguration(ProjectScope.TEST);
@@ -880,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 attribute 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();
 

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

@@ -65,7 +65,7 @@ record SourceKey(Language language, ProjectScope scope, String module, Path dire
     private final Set<String> modules;
     private final boolean modularProject;
     private final ModelBuilderResult result;
-    private final Set<SourceKey> declaredSources = new HashSet<>();
+    private final Set<SourceKey> declaredSources;
 
     SourceHandlingContext(
             MavenProject project,
@@ -78,6 +78,8 @@ record SourceKey(Language language, ProjectScope scope, String module, Path dire
         this.modules = modules;
         this.modularProject = modularProject;
         this.result = result;
+        // Each module typically has main, test, main resources, test resources = 4 sources
+        this.declaredSources = new HashSet<>(4 * modules.size());
     }
 
     /**
@@ -96,7 +98,7 @@ record SourceKey(Language language, ProjectScope scope, String module, Path dire
     boolean shouldAddSource(SourceRoot sourceRoot) {
         if (!sourceRoot.enabled()) {
             // Disabled sources are always added - they're filtered out by getEnabledSourceRoots()
-            LOGGER.debug(
+            LOGGER.trace(
                     "Adding disabled source (will be filtered by getEnabledSourceRoots): lang={}, scope={}, module={}, dir={}",
                     sourceRoot.language(),
                     sourceRoot.scope(),
@@ -105,8 +107,10 @@ boolean shouldAddSource(SourceRoot sourceRoot) {
             return true;
         }
 
+        // Normalize path for consistent duplicate detection (handles symlinks, relative paths)
+        Path normalizedDir = sourceRoot.directory().toAbsolutePath().normalize();
         SourceKey key = new SourceKey(
-                sourceRoot.language(), sourceRoot.scope(), sourceRoot.module().orElse(null), sourceRoot.directory());
+                sourceRoot.language(), sourceRoot.scope(), sourceRoot.module().orElse(null), normalizedDir);
 
         if (declaredSources.contains(key)) {
             String message = String.format(
@@ -147,6 +151,48 @@ boolean hasSources(Language language, ProjectScope scope) {
         return declaredSources.stream().anyMatch(key -> language.equals(key.language()) && scope.equals(key.scope()));
     }
 
+    /**
+     * Validates that a project does not mix modular and classic (non-modular) sources.
+     * <p>
+     * A project must be either fully modular (all sources have a module) or fully classic
+     * (no sources have a module). Mixing modular and non-modular sources within the same
+     * project is not supported because the compiler plugin cannot handle such configurations.
+     * <p>
+     * This validation checks each (language, scope) combination and reports an ERROR if
+     * both modular and non-modular sources are found.
+     */
+    void validateNoMixedModularAndClassicSources() {
+        for (ProjectScope scope : List.of(ProjectScope.MAIN, ProjectScope.TEST)) {
+            for (Language language : List.of(Language.JAVA_FAMILY, Language.RESOURCES)) {
+                boolean hasModular = declaredSources.stream()
+                        .anyMatch(key ->
+                                language.equals(key.language()) && scope.equals(key.scope()) && key.module() != null);
+                boolean hasClassic = declaredSources.stream()
+                        .anyMatch(key ->
+                                language.equals(key.language()) && scope.equals(key.scope()) && key.module() == null);
+
+                if (hasModular && hasClassic) {
+                    String message = String.format(
+                            "Mixed modular and classic sources detected for lang=%s, scope=%s. "
+                                    + "A project must be either fully modular (all sources have a module) "
+                                    + "or fully classic (no sources have a module). "
+                                    + "The compiler plugin cannot handle mixed configurations.",
+                            language.id(), scope.id());
+                    LOGGER.error(message);
+                    result.getProblemCollector()
+                            .reportProblem(new DefaultModelProblem(
+                                    message,
+                                    Severity.ERROR,
+                                    Version.V41,
+                                    project.getModel().getDelegate(),
+                                    -1,
+                                    -1,
+                                    null));
+                }
+            }
+        }
+    }
+
     /**
      * Handles resource configuration for a given scope (main or test).
      * This method applies the resource priority rules:

impl/maven-core/src/test/java/org/apache/maven/project/ProjectBuilderTest.java

@@ -480,24 +480,52 @@ void testModularSourcesWithExplicitResourcesIssuesWarning() throws Exception {
     }
 
     /**
-     * Tests mixed source configuration where:
-     * - Modular sources are defined for main Java (should override sourceDirectory)
-     * - Classic testSourceDirectory is used (should be preserved since no modular test sources)
+     * Tests that legacy sourceDirectory and testSourceDirectory are ignored in modular projects.
+     * <p>
+     * In 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 (differ from Super POM defaults).
      * <p>
      * This verifies:
-     * - sourceDirectory is ignored when modular main sources exist
-     * - testSourceDirectory is used when no modular test sources are defined
+     * - WARNINGs are emitted for explicitly set legacy directories in modular projects
+     * - sourceDirectory and testSourceDirectory are both ignored
+     * - Only modular sources from {@code <sources>} are used
      * <p>
-     * Acceptance Criterion: AC1 (boolean flags eliminated - uses hasSources() for main/test detection)
+     * Acceptance Criteria:
+     * - AC1 (boolean flags eliminated - uses hasSources() for main/test detection)
+     * - AC7 (legacy directories warning - {@code <sourceDirectory>} and {@code <testSourceDirectory>}
+     *   are unconditionally ignored with a WARNING in modular projects)
      *
      * @see <a href="https://github.com/apache/maven/issues/11612">Issue #11612</a>
      */
     @Test
     void testMixedSourcesModularMainClassicTest() throws Exception {
         File pom = getProject("mixed-sources");
 
-        MavenSession session = createMavenSession(pom);
-        MavenProject project = session.getCurrentProject();
+        MavenSession mavenSession = createMavenSession(null);
+        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
+        configuration.setRepositorySession(mavenSession.getRepositorySession());
+
+        ProjectBuildingResult result = getContainer()
+                .lookup(org.apache.maven.project.ProjectBuilder.class)
+                .build(pom, configuration);
+
+        MavenProject project = result.getProject();
+
+        // Verify WARNINGs are emitted for explicitly set legacy directories
+        List<ModelProblem> warnings = result.getProblems().stream()
+                .filter(p -> p.getSeverity() == ModelProblem.Severity.WARNING)
+                .filter(p -> p.getMessage().contains("Legacy") && p.getMessage().contains("ignored in modular project"))
+                .toList();
+
+        // Should have 2 warnings: one for sourceDirectory, one for testSourceDirectory
+        assertEquals(2, warnings.size(), "Should have 2 warnings for ignored legacy directories");
+        assertTrue(
+                warnings.stream().anyMatch(w -> w.getMessage().contains("<sourceDirectory>")),
+                "Should warn about ignored <sourceDirectory>");
+        assertTrue(
+                warnings.stream().anyMatch(w -> w.getMessage().contains("<testSourceDirectory>")),
+                "Should warn about ignored <testSourceDirectory>");
 
         // Get main Java source roots - should have modular sources, not classic sourceDirectory
         List<SourceRoot> mainJavaRoots = project.getEnabledSourceRoots(ProjectScope.MAIN, Language.JAVA_FAMILY)
@@ -521,77 +549,51 @@ void testMixedSourcesModularMainClassicTest() throws Exception {
                 .anyMatch(sr -> sr.directory().toString().replace('\\', '/').contains("src/classic/main/java"));
         assertTrue(!hasClassicMainSource, "Classic sourceDirectory should be ignored");
 
-        // Get test Java source roots - should use classic testSourceDirectory since no modular test sources
+        // Test sources should NOT be added (legacy testSourceDirectory is ignored in modular projects)
         List<SourceRoot> testJavaRoots = project.getEnabledSourceRoots(ProjectScope.TEST, Language.JAVA_FAMILY)
                 .toList();
-
-        // Should have 1 test source (from classic testSourceDirectory)
-        assertEquals(1, testJavaRoots.size(), "Should have 1 test Java source root (classic)");
-
-        // The test source should be the classic one (no module)
-        SourceRoot testRoot = testJavaRoots.get(0);
-        assertTrue(testRoot.module().isEmpty(), "Classic test source should not have a module");
-        assertTrue(
-                testRoot.directory().toString().replace('\\', '/').contains("src/classic/test/java"),
-                "Should use classic testSourceDirectory");
+        assertEquals(0, testJavaRoots.size(), "Should have no test Java sources (legacy is ignored)");
     }
 
     /**
-     * Tests mixed modular/non-modular sources within the same {@code <sources>} element.
+     * Tests that mixing modular and non-modular sources within {@code <sources>} is not allowed.
+     * <p>
+     * A project must be either fully modular (all sources have a module) or fully classic
+     * (no sources have a module). Mixing them within the same project is not supported
+     * because the compiler plugin cannot handle such configurations.
      * <p>
      * This verifies:
-     * - Both modular sources (with module attribute) are added
-     * - Non-modular sources (without module attribute) are added
+     * - An ERROR is reported when both modular and non-modular sources exist in {@code <sources>}
      * - sourceDirectory is ignored because {@code <source scope="main" lang="java">} exists
      * <p>
-     * Acceptance Criterion: AC1 (boolean flags eliminated - uses hasSources() for source detection)
+     * Acceptance Criteria:
+     * - AC1 (boolean flags eliminated - uses hasSources() for source detection)
+     * - AC6 (mixed sources error - mixing modular and classic sources within {@code <sources>}
+     *   triggers an ERROR)
      *
      * @see <a href="https://github.com/apache/maven/issues/11612">Issue #11612</a>
      */
     @Test
     void testSourcesMixedModulesWithinSources() throws Exception {
         File pom = getProject("sources-mixed-modules");
 
-        MavenSession session = createMavenSession(pom);
-        MavenProject project = session.getCurrentProject();
-
-        // Get main Java source roots
-        List<SourceRoot> mainJavaRoots = project.getEnabledSourceRoots(ProjectScope.MAIN, Language.JAVA_FAMILY)
-                .toList();
-
-        // Should have 2 main sources: 1 modular (moduleA) + 1 non-modular
-        assertEquals(2, mainJavaRoots.size(), "Should have 2 main Java source roots (1 modular + 1 non-modular)");
-
-        // Count modular vs non-modular sources
-        long modularCount =
-                mainJavaRoots.stream().filter(sr -> sr.module().isPresent()).count();
-        long nonModularCount =
-                mainJavaRoots.stream().filter(sr -> sr.module().isEmpty()).count();
-
-        assertEquals(1, modularCount, "Should have 1 modular main source");
-        assertEquals(1, nonModularCount, "Should have 1 non-modular main source");
-
-        // Verify the modular source is moduleA
-        Set<String> mainModules = mainJavaRoots.stream()
-                .map(SourceRoot::module)
-                .filter(opt -> opt.isPresent())
-                .map(opt -> opt.get())
-                .collect(Collectors.toSet());
-
-        assertTrue(mainModules.contains("org.foo.moduleA"), "Should have modular source for moduleA");
+        MavenSession mavenSession = createMavenSession(null);
+        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
+        configuration.setRepositorySession(mavenSession.getRepositorySession());
 
-        // Verify sourceDirectory is NOT used (should be ignored because <sources> has main java)
-        boolean hasIgnoredSource =
-                mainJavaRoots.stream().anyMatch(sr -> sr.directory().toString().contains("src/should-be-ignored"));
-        assertTrue(!hasIgnoredSource, "sourceDirectory should be ignored when <sources> has main java");
+        ProjectBuildingResult result = getContainer()
+                .lookup(org.apache.maven.project.ProjectBuilder.class)
+                .build(pom, configuration);
 
-        // Get test Java source roots - should have modular test source for moduleA
-        List<SourceRoot> testJavaRoots = project.getEnabledSourceRoots(ProjectScope.TEST, Language.JAVA_FAMILY)
+        // Verify an ERROR is reported for mixing modular and non-modular sources
+        List<ModelProblem> errors = result.getProblems().stream()
+                .filter(p -> p.getSeverity() == ModelProblem.Severity.ERROR)
+                .filter(p -> p.getMessage().contains("Mixed modular and classic sources"))
                 .toList();
 
-        assertEquals(1, testJavaRoots.size(), "Should have 1 test Java source root");
-        assertTrue(testJavaRoots.get(0).module().isPresent(), "Test source should be modular");
-        assertEquals("org.foo.moduleA", testJavaRoots.get(0).module().get(), "Test source should be for moduleA");
+        assertEquals(1, errors.size(), "Should have 1 error for mixed modular/classic configuration");
+        assertTrue(errors.get(0).getMessage().contains("lang=java"), "Error should mention java language");
+        assertTrue(errors.get(0).getMessage().contains("scope=main"), "Error should mention main scope");
     }
 
     /**