This is an automated email from the ASF dual-hosted git repository.

slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-dependency-analyzer.git


The following commit(s) were added to refs/heads/master by this push:
     new 1cabc68  Expose used dependency classes and candidate artifacts for 
duplicate-class cases (#280) (#320)
1cabc68 is described below

commit 1cabc68aa316f52f19611490e1defc88fa3163b3
Author: Sylwester Lachiewicz <[email protected]>
AuthorDate: Tue Nov 10 19:43:40 2026 +0100

    Expose used dependency classes and candidate artifacts for duplicate-class 
cases (#280) (#320)
    
    * Add proposal for duplicate-class visibility (#280)
    
    Propose exposing raw used classes and candidate artifacts alongside
    current single-artifact mapping, preserving existing analysis behavior.
    
    * Expose used dependency classes and candidate artifacts (#280)
    
    Record referenced dependency class names, all providing artifacts per
    used class, and the selected artifact in ProjectDependencyAnalysis while
    keeping existing used/unused artifact results unchanged.
    
    * Move design notes from docs/ into PR description
---
 .../analyzer/DefaultProjectDependencyAnalyzer.java |  50 +++++++-
 .../analyzer/ProjectDependencyAnalysis.java        | 142 ++++++++++++++++++++-
 .../DefaultProjectDependencyAnalyzerTest.java      |  34 +++++
 .../analyzer/ProjectDependencyAnalysisTest.java    |  50 ++++++++
 4 files changed, 272 insertions(+), 4 deletions(-)

diff --git 
a/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
 
b/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
index e903b52..f381112 100644
--- 
a/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
+++ 
b/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
@@ -170,9 +170,20 @@ public class DefaultProjectDependencyAnalyzer implements 
ProjectDependencyAnalyz
 
             Set<Artifact> testArtifactsWithNonTestScope = 
getTestArtifactsWithNonTestScope(project, testOnlyArtifacts);
 
+            Set<String> usedDependencyClasses = 
buildUsedDependencyClasses(dependencyClasses);
+            Map<String, Set<Artifact>> candidateArtifactsByUsedClass =
+                    buildCandidateArtifactsByUsedClass(artifactClassMap, 
usedDependencyClasses);
+            Map<String, Artifact> selectedArtifactByUsedClass =
+                    buildSelectedArtifactByUsedClass(classToArtifactMap, 
usedDependencyClasses);
+
             return new ProjectDependencyAnalysis(
-                    usedDeclaredArtifactsWithClasses, 
usedUndeclaredArtifactsWithClasses,
-                    unusedDeclaredArtifacts, testArtifactsWithNonTestScope);
+                    usedDeclaredArtifactsWithClasses,
+                    usedUndeclaredArtifactsWithClasses,
+                    unusedDeclaredArtifacts,
+                    testArtifactsWithNonTestScope,
+                    usedDependencyClasses,
+                    candidateArtifactsByUsedClass,
+                    selectedArtifactByUsedClass);
         } catch (IOException exception) {
             throw new ProjectDependencyAnalyzerException("Cannot analyze 
dependencies", exception);
         }
@@ -472,6 +483,41 @@ public class DefaultProjectDependencyAnalyzer implements 
ProjectDependencyAnalyz
         return usedArtifacts;
     }
 
+    static Set<String> buildUsedDependencyClasses(Set<DependencyUsage> 
dependencyClasses) {
+        Set<String> usedDependencyClasses = new LinkedHashSet<>();
+        for (DependencyUsage usage : dependencyClasses) {
+            usedDependencyClasses.add(usage.getDependencyClass());
+        }
+        return usedDependencyClasses;
+    }
+
+    static Map<String, Set<Artifact>> buildCandidateArtifactsByUsedClass(
+            Map<Artifact, Set<String>> artifactClassMap, Set<String> 
usedDependencyClasses) {
+        Map<String, Set<Artifact>> candidatesByClass = new LinkedHashMap<>();
+        for (String className : usedDependencyClasses) {
+            Set<Artifact> candidates = new LinkedHashSet<>();
+            for (Map.Entry<Artifact, Set<String>> entry : 
artifactClassMap.entrySet()) {
+                if (entry.getValue().contains(className)) {
+                    candidates.add(entry.getKey());
+                }
+            }
+            candidatesByClass.put(className, candidates);
+        }
+        return candidatesByClass;
+    }
+
+    static Map<String, Artifact> buildSelectedArtifactByUsedClass(
+            Map<String, Artifact> classToArtifactMap, Set<String> 
usedDependencyClasses) {
+        Map<String, Artifact> selectedByClass = new LinkedHashMap<>();
+        for (String className : usedDependencyClasses) {
+            Artifact artifact = classToArtifactMap.get(className);
+            if (artifact != null) {
+                selectedByClass.put(className, artifact);
+            }
+        }
+        return selectedByClass;
+    }
+
     /**
      * Treats a declared artifact without classes of its own (for example 
{@code junit-jupiter}, which only carries
      * {@code module-info.class}) as used when one of the artifacts it brings 
in directly is used. The used artifacts
diff --git 
a/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
 
b/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
index 2132c3b..2579d31 100644
--- 
a/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
+++ 
b/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
@@ -47,6 +47,12 @@ public class ProjectDependencyAnalysis {
 
     private final Set<Artifact> testArtifactsWithNonTestScope;
 
+    private final Set<String> usedDependencyClasses;
+
+    private final Map<String, Set<Artifact>> candidateArtifactsByUsedClass;
+
+    private final Map<String, Artifact> selectedArtifactByUsedClass;
+
     /**
      * <p>Constructor for ProjectDependencyAnalysis.</p>
      */
@@ -101,10 +107,43 @@ public class ProjectDependencyAnalysis {
             Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
             Set<Artifact> unusedDeclaredArtifacts,
             Set<Artifact> testArtifactsWithNonTestScope) {
+        this(
+                usedDeclaredArtifacts,
+                usedUndeclaredArtifacts,
+                unusedDeclaredArtifacts,
+                testArtifactsWithNonTestScope,
+                null,
+                null,
+                null);
+    }
+
+    /**
+     * Creates an analysis result with usage details, raw used classes and 
candidate artifacts.
+     *
+     * @param usedDeclaredArtifacts artifacts both used and declared
+     * @param usedUndeclaredArtifacts artifacts used but not declared
+     * @param unusedDeclaredArtifacts artifacts declared but not used
+     * @param testArtifactsWithNonTestScope artifacts only used in tests but 
not declared with test scope
+     * @param usedDependencyClasses dependency class names referenced by the 
analyzed bytecode
+     * @param candidateArtifactsByUsedClass candidate artifacts that provide 
each used dependency class
+     * @param selectedArtifactByUsedClass artifact selected for each used 
dependency class
+     * @since 1.18.0
+     */
+    public ProjectDependencyAnalysis(
+            Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifacts,
+            Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
+            Set<Artifact> unusedDeclaredArtifacts,
+            Set<Artifact> testArtifactsWithNonTestScope,
+            Set<String> usedDependencyClasses,
+            Map<String, Set<Artifact>> candidateArtifactsByUsedClass,
+            Map<String, Artifact> selectedArtifactByUsedClass) {
         this.usedDeclaredArtifacts = safeCopy(usedDeclaredArtifacts);
         this.usedUndeclaredArtifacts = safeCopy(usedUndeclaredArtifacts);
         this.unusedDeclaredArtifacts = safeCopy(unusedDeclaredArtifacts);
         this.testArtifactsWithNonTestScope = 
safeCopy(testArtifactsWithNonTestScope);
+        this.usedDependencyClasses = safeCopyStrings(usedDependencyClasses);
+        this.candidateArtifactsByUsedClass = 
safeCopyStringArtifactSetMap(candidateArtifactsByUsedClass);
+        this.selectedArtifactByUsedClass = 
safeCopyStringArtifactMap(selectedArtifactByUsedClass);
     }
 
     /**
@@ -180,6 +219,70 @@ public class ProjectDependencyAnalysis {
         return safeCopy(testArtifactsWithNonTestScope);
     }
 
+    /**
+     * Returns dependency class names referenced by the analyzed bytecode.
+     *
+     * @return dependency class names referenced by the analyzed bytecode
+     * @since 1.18.0
+     */
+    public Set<String> getUsedDependencyClasses() {
+        return safeCopyStrings(usedDependencyClasses);
+    }
+
+    /**
+     * Returns the artifacts that provide each referenced dependency class.
+     *
+     * @return candidate artifacts per referenced dependency class
+     * @since 1.18.0
+     */
+    public Map<String, Set<Artifact>> getCandidateArtifactsByUsedClass() {
+        return safeCopyStringArtifactSetMap(candidateArtifactsByUsedClass);
+    }
+
+    /**
+     * Returns the artifact selected for each referenced dependency class.
+     *
+     * @return selected artifact per referenced dependency class
+     * @since 1.18.0
+     */
+    public Map<String, Artifact> getSelectedArtifactByUsedClass() {
+        return safeCopyStringArtifactMap(selectedArtifactByUsedClass);
+    }
+
+    /**
+     * Returns referenced dependency classes provided by more than one 
artifact.
+     *
+     * @return ambiguous referenced dependency classes
+     * @since 1.18.0
+     */
+    public Set<String> getAmbiguousUsedDependencyClasses() {
+        Set<String> ambiguous = new LinkedHashSet<>();
+        for (Map.Entry<String, Set<Artifact>> entry : 
candidateArtifactsByUsedClass.entrySet()) {
+            if (entry.getValue().size() > 1) {
+                ambiguous.add(entry.getKey());
+            }
+        }
+        return Collections.unmodifiableSet(ambiguous);
+    }
+
+    /**
+     * Returns referenced dependency classes that could not be mapped to any 
dependency artifact.
+     *
+     * @return unmapped referenced dependency classes
+     * @since 1.18.0
+     */
+    public Set<String> getUnmappedUsedDependencyClasses() {
+        Set<String> unmapped = new LinkedHashSet<>();
+        for (String className : usedDependencyClasses) {
+            if (candidateArtifactsByUsedClass
+                    .getOrDefault(className, Collections.emptySet())
+                    .isEmpty()) {
+                unmapped.add(className);
+            }
+        }
+        return Collections.unmodifiableSet(unmapped);
+    }
+
     /**
      * Filter non-compile scoped artifacts from unused declared.
      *
@@ -191,7 +294,13 @@ public class ProjectDependencyAnalysis {
         filteredUnusedDeclared.removeIf(artifact -> 
!artifact.getScope().equals(Artifact.SCOPE_COMPILE));
 
         return new ProjectDependencyAnalysis(
-                usedDeclaredArtifacts, usedUndeclaredArtifacts, 
filteredUnusedDeclared, testArtifactsWithNonTestScope);
+                usedDeclaredArtifacts,
+                usedUndeclaredArtifacts,
+                filteredUnusedDeclared,
+                testArtifactsWithNonTestScope,
+                usedDependencyClasses,
+                candidateArtifactsByUsedClass,
+                selectedArtifactByUsedClass);
     }
 
     /**
@@ -250,7 +359,10 @@ public class ProjectDependencyAnalysis {
                 mapWithKeys(forcedUsedDeclared),
                 usedUndeclaredArtifacts,
                 forcedUnusedDeclared,
-                testArtifactsWithNonTestScope);
+                testArtifactsWithNonTestScope,
+                usedDependencyClasses,
+                candidateArtifactsByUsedClass,
+                selectedArtifactByUsedClass);
     }
 
     /**
@@ -334,6 +446,10 @@ public class ProjectDependencyAnalysis {
         return (set == null) ? Collections.emptySet() : 
Collections.unmodifiableSet(new LinkedHashSet<>(set));
     }
 
+    private static Set<String> safeCopyStrings(Set<String> set) {
+        return (set == null) ? Collections.emptySet() : 
Collections.unmodifiableSet(new LinkedHashSet<>(set));
+    }
+
     private static Map<Artifact, Set<DependencyUsage>> safeCopy(Map<Artifact, 
Set<DependencyUsage>> origMap) {
         if (origMap == null) {
             return Collections.emptyMap();
@@ -348,6 +464,28 @@ public class ProjectDependencyAnalysis {
         return map;
     }
 
+    private static Map<String, Set<Artifact>> 
safeCopyStringArtifactSetMap(Map<String, Set<Artifact>> origMap) {
+        if (origMap == null) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, Set<Artifact>> map = new LinkedHashMap<>();
+
+        for (Map.Entry<String, Set<Artifact>> e : origMap.entrySet()) {
+            map.put(e.getKey(), Collections.unmodifiableSet(new 
LinkedHashSet<>(e.getValue())));
+        }
+
+        return map;
+    }
+
+    private static Map<String, Artifact> safeCopyStringArtifactMap(Map<String, 
Artifact> origMap) {
+        if (origMap == null) {
+            return Collections.emptyMap();
+        }
+
+        return Collections.unmodifiableMap(new LinkedHashMap<>(origMap));
+    }
+
     private static Map<Artifact, Set<DependencyUsage>> 
mapWithKeys(Set<Artifact> keys) {
         if (keys == null) {
             return Collections.emptyMap();
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
index d9c5f22..c56730a 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
@@ -498,4 +498,38 @@ class DefaultProjectDependencyAnalyzerTest {
     private Artifact aTestArtifact(String groupId, String artifactId, String 
scope) {
         return new DefaultArtifact(groupId, artifactId, 
VersionRange.createFromVersion("1.0"), scope, "jar", "", null);
     }
+
+    @Test
+    void buildCandidateArtifactsByUsedClassShouldReturnAllProviders() {
+        Artifact first = aTestArtifact("first");
+        Artifact second = aTestArtifact("second");
+
+        Map<Artifact, Set<String>> artifactClassMap = new LinkedHashMap<>();
+        artifactClassMap.put(first, Collections.singleton("com.example.Cls"));
+        artifactClassMap.put(second, Collections.singleton("com.example.Cls"));
+
+        Set<String> used = Collections.singleton("com.example.Cls");
+        Map<String, Set<Artifact>> candidates =
+                
DefaultProjectDependencyAnalyzer.buildCandidateArtifactsByUsedClass(artifactClassMap,
 used);
+
+        assertThat(candidates.get("com.example.Cls")).containsExactly(first, 
second);
+    }
+
+    @Test
+    void buildSelectedArtifactByUsedClassShouldKeepSelectedProvider() {
+        Artifact first = aTestArtifact("first");
+        Artifact second = aTestArtifact("second");
+
+        Map<Artifact, Set<String>> artifactClassMap = new LinkedHashMap<>();
+        artifactClassMap.put(first, Collections.singleton("com.example.Cls"));
+        artifactClassMap.put(second, Collections.singleton("com.example.Cls"));
+
+        Set<String> used = Collections.singleton("com.example.Cls");
+        Map<String, Artifact> classToArtifactMap =
+                
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(artifactClassMap);
+        Map<String, Artifact> selected =
+                
DefaultProjectDependencyAnalyzer.buildSelectedArtifactByUsedClass(classToArtifactMap,
 used);
+
+        assertThat(selected.get("com.example.Cls")).isEqualTo(first);
+    }
 }
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
index d0f9b18..d8deacd 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
@@ -19,7 +19,10 @@
 package org.apache.maven.shared.dependency.analyzer;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Map;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
@@ -75,6 +78,53 @@ class ProjectDependencyAnalysisTest {
         
assertThat(compileOnlyAnalysis.getTestArtifactsWithNonTestScope()).hasSize(3);
     }
 
+    @Test
+    void shouldExposeUsedClassesAndCandidateArtifacts() {
+        Artifact declared = aTestArtifact("declared", Artifact.SCOPE_COMPILE);
+        Artifact other = aTestArtifact("other", Artifact.SCOPE_COMPILE);
+        Set<String> used = new HashSet<>(Arrays.asList("a.B", "c.D"));
+        Map<String, Set<Artifact>> candidates = new 
java.util.LinkedHashMap<>();
+        candidates.put("a.B", new LinkedHashSet<>(Arrays.asList(declared, 
other)));
+        candidates.put("c.D", new 
LinkedHashSet<>(Collections.singleton(declared)));
+        Map<String, Artifact> selected = new java.util.LinkedHashMap<>();
+        selected.put("a.B", declared);
+        selected.put("c.D", declared);
+
+        ProjectDependencyAnalysis analysis = new ProjectDependencyAnalysis(
+                Collections.emptyMap(),
+                Collections.emptyMap(),
+                Collections.emptySet(),
+                Collections.emptySet(),
+                used,
+                candidates,
+                selected);
+
+        
assertThat(analysis.getUsedDependencyClasses()).containsExactlyInAnyOrder("a.B",
 "c.D");
+        
assertThat(analysis.getCandidateArtifactsByUsedClass().get("a.B")).containsExactly(declared,
 other);
+        
assertThat(analysis.getSelectedArtifactByUsedClass().get("a.B")).isEqualTo(declared);
+        
assertThat(analysis.getAmbiguousUsedDependencyClasses()).containsExactly("a.B");
+        assertThat(analysis.getUnmappedUsedDependencyClasses()).isEmpty();
+    }
+
+    @Test
+    void shouldReportUnmappedUsedDependencyClasses() {
+        Set<String> used = new HashSet<>(Collections.singletonList("a.B"));
+        Map<String, Set<Artifact>> candidates = new 
java.util.LinkedHashMap<>();
+        candidates.put("a.B", Collections.emptySet());
+
+        ProjectDependencyAnalysis analysis = new ProjectDependencyAnalysis(
+                Collections.emptyMap(),
+                Collections.emptyMap(),
+                Collections.emptySet(),
+                Collections.emptySet(),
+                used,
+                candidates,
+                Collections.emptyMap());
+
+        
assertThat(analysis.getUnmappedUsedDependencyClasses()).containsExactly("a.B");
+        
assertThat(analysis.getSelectedArtifactByUsedClass()).doesNotContainKey("a.B");
+    }
+
     private <T> Set<T> asSet(T... items) {
         return new HashSet<>(Arrays.asList(items));
     }

Reply via email to