diff --git a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractJavadocMojo.java b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractJavadocMojo.java
index b6ecbe0..171736e 100644
--- a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractJavadocMojo.java
+++ b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/AbstractJavadocMojo.java
@@ -23,7 +23,6 @@
 import static org.apache.maven.plugins.javadoc.JavadocUtil.isNotEmpty;
 import static org.apache.maven.plugins.javadoc.JavadocUtil.toList;
 import static org.apache.maven.plugins.javadoc.JavadocUtil.toRelative;
-import static org.codehaus.plexus.util.IOUtil.close;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -46,6 +45,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -61,6 +61,7 @@
 import org.apache.commons.lang3.JavaVersion;
 import org.apache.commons.lang3.SystemUtils;
 import org.apache.maven.artifact.Artifact;
+import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.artifact.handler.ArtifactHandler;
 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
 import org.apache.maven.artifact.repository.ArtifactRepository;
@@ -1977,9 +1978,9 @@
             throw new MavenReportException( "Failed to generate javadoc options file: " + e.getMessage(), e );
         }
 
-        Collection<Collection<String>> sourcePaths = getSourcePaths();
+        Map<String, Collection<String>> sourcePaths = getSourcePaths();
         
-        Collection<String> collectedSourcePaths = collect( sourcePaths );
+        Collection<String> collectedSourcePaths = collect( sourcePaths.values() );
         
         List<String> files = getFiles( collectedSourcePaths );
         if ( !canGenerateReport( files ) )
@@ -2224,10 +2225,10 @@
      * @throws MavenReportException {@link MavenReportException}
      * @see JavadocUtil#pruneDirs(MavenProject, List)
      */
-    protected Collection<Collection<String>> getSourcePaths()
+    protected Map<String, Collection<String>> getSourcePaths()
         throws MavenReportException
     {
-        Collection<Collection<String>> allSourcePaths = new ArrayList<>();
+        Map<String, Collection<String>> mappedSourcePaths = new LinkedHashMap<>();
 
         if ( StringUtils.isEmpty( sourcepath ) )
         {
@@ -2255,11 +2256,13 @@
                     sourcePaths.addAll( l );
                 }
             }
+            mappedSourcePaths.put( ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ),
+                                   sourcePaths );
+            
             if ( includeDependencySources )
             {
-                sourcePaths.addAll( getDependencySourcePaths() );
+                mappedSourcePaths.putAll( getDependencySourcePaths() );
             }
-            allSourcePaths.add( sourcePaths );
 
             if ( isAggregator() && project.isExecutionRoot() )
             {
@@ -2295,7 +2298,9 @@
                                 additionalSourcePaths.addAll( l );
                             }
                         }
-                        allSourcePaths.add( additionalSourcePaths );
+                        mappedSourcePaths.put( ArtifactUtils.versionlessKey( subProject.getGroupId(),
+                                                                             subProject.getArtifactId() ),
+                                               additionalSourcePaths );
                     }
                 }
             }
@@ -2310,10 +2315,11 @@
                     getJavadocDirectory().getAbsolutePath() ) );
                 sourcePaths.addAll( l );
             }
-            allSourcePaths.add( sourcePaths );
+            mappedSourcePaths.put( ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ),
+                                   sourcePaths );
         }
 
-        return allSourcePaths;
+        return mappedSourcePaths;
     }
 
     /**
@@ -2333,7 +2339,7 @@
      * @return List of source paths.
      * @throws MavenReportException {@link MavenReportException}
      */
-    protected final List<String> getDependencySourcePaths()
+    protected final Map<String, Collection<String>> getDependencySourcePaths()
         throws MavenReportException
     {
         try
@@ -4641,10 +4647,10 @@
      * @throws MavenReportException if any
      * @see <a href="http://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#javadocoptions">http://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#javadocoptions</a>
      */
-    private void addJavadocOptions( List<String> arguments, Collection<Collection<String>> allSourcePaths )
+    private void addJavadocOptions( List<String> arguments, Map<String, Collection<String>> allSourcePaths )
         throws MavenReportException
     {
-        Collection<String> sourcePaths = collect( allSourcePaths );
+        Collection<String> sourcePaths = collect( allSourcePaths.values() );
         
         validateJavadocOptions();
 
@@ -6039,16 +6045,11 @@
         }
 
         File optionsFile = getJavadocOptionsFile();
-        Writer writer = null;
-        try
+        
+        try ( Writer writer = WriterFactory.newXmlWriter( optionsFile ) )
         {
-            writer = WriterFactory.newXmlWriter( optionsFile );
             new JavadocOptionsXpp3Writer().write( writer, options );
         }
-        finally
-        {
-            close( writer );
-        }
 
         return options;
     }
diff --git a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/JavadocReport.java b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/JavadocReport.java
index 76b68c7..f431114 100644
--- a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/JavadocReport.java
+++ b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/JavadocReport.java
@@ -240,7 +240,7 @@
             List<String> files;
             try
             {
-                sourcePaths = collect( getSourcePaths() );
+                sourcePaths = collect( getSourcePaths().values() );
                 files = getFiles( sourcePaths );
             }
             catch ( MavenReportException e )
diff --git a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/resolver/ResourceResolver.java b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/resolver/ResourceResolver.java
index e47aa99..b4d331f 100644
--- a/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/resolver/ResourceResolver.java
+++ b/maven-javadoc-plugin/src/main/java/org/apache/maven/plugins/javadoc/resolver/ResourceResolver.java
@@ -24,13 +24,17 @@
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
@@ -144,11 +148,11 @@
      * @throws ArtifactResolutionException {@link ArtifactResolutionException}
      * @throws ArtifactNotFoundException {@link ArtifactNotFoundException}
      */
-    public List<String> resolveDependencySourcePaths( final SourceResolverConfig config )
+    public Map<String, Collection<String>> resolveDependencySourcePaths( final SourceResolverConfig config )
         throws ArtifactResolutionException, ArtifactNotFoundException
     {
-        final List<String> dirs = new ArrayList<>();
-
+        final Map<String, Collection<String>> mappedDirs = new LinkedHashMap<>();
+        
         final Map<String, MavenProject> projectMap = new HashMap<>();
         if ( config.reactorProjects() != null )
         {
@@ -167,7 +171,7 @@
             final MavenProject p = projectMap.get( key );
             if ( p != null )
             {
-                dirs.addAll( resolveFromProject( config, p, artifact ) );
+                mappedDirs.put( key, resolveFromProject( config, p, artifact ) );
             }
             else
             {
@@ -175,9 +179,12 @@
             }
         }
 
-        dirs.addAll( resolveFromArtifacts( config, forResourceResolution ) );
+        for ( Map.Entry<String, String> entry : resolveFromArtifacts( config, forResourceResolution ) )
+        {
+            mappedDirs.put( entry.getKey(), Collections.singletonList( entry.getValue() ) );
+        }
 
-        return dirs;
+        return mappedDirs;
     }
 
     private static List<JavadocBundle> resolveBundleFromProject( SourceResolverConfig config, MavenProject project,
@@ -263,10 +270,14 @@
             }
         }
 
-        List<String> dirs = null;
+        List<String> dirs = new ArrayList<>( toResolve.size() );
         try
         {
-            dirs = resolveAndUnpack( toResolve, config, RESOURCE_VALID_CLASSIFIERS, false );
+            for ( Map.Entry<String, String> entry : resolveAndUnpack( toResolve, config, RESOURCE_VALID_CLASSIFIERS,
+                                                                      false ) )
+            {
+                dirs.add( entry.getValue() );
+            }
         }
         catch ( ArtifactResolutionException e )
         {
@@ -285,44 +296,35 @@
         
         List<JavadocBundle> result = new ArrayList<>();
 
-        if ( dirs != null )
+        for ( String d : dirs )
         {
-            for ( String d : dirs )
-            {
-                File dir = new File( d );
-                File resources = new File( dir, ResourcesBundleMojo.RESOURCES_DIR_PATH );
-                JavadocOptions options = null;
+            File dir = new File( d );
+            File resources = new File( dir, ResourcesBundleMojo.RESOURCES_DIR_PATH );
+            JavadocOptions options = null;
 
-                File javadocOptions = new File( dir, ResourcesBundleMojo.BUNDLE_OPTIONS_PATH );
-                if ( javadocOptions.exists() )
+            File javadocOptions = new File( dir, ResourcesBundleMojo.BUNDLE_OPTIONS_PATH );
+            if ( javadocOptions.exists() )
+            {
+                try ( FileInputStream reader = new FileInputStream( javadocOptions )  )
                 {
-                    FileInputStream reader = null;
-                    try
-                    {
-                        reader = new FileInputStream( javadocOptions );
-                        options = new JavadocOptionsXpp3Reader().read( reader );
-                    }
-                    catch ( XmlPullParserException e )
-                    {
-                        IOException error = new IOException( "Failed to parse javadoc options: " + e.getMessage() );
-                        error.initCause( e );
-                        
-                        throw error;
-                    }
-                    finally
-                    {
-                        close( reader );
-                    }
+                    options = new JavadocOptionsXpp3Reader().read( reader );
                 }
-                
-                result.add( new JavadocBundle( options, resources ) );
+                catch ( XmlPullParserException e )
+                {
+                    IOException error = new IOException( "Failed to parse javadoc options: " + e.getMessage() );
+                    error.initCause( e );
+                    
+                    throw error;
+                }
             }
+            
+            result.add( new JavadocBundle( options, resources ) );
         }
         
         return result;
     }
 
-    private List<String> resolveFromArtifacts( final SourceResolverConfig config,
+    private Collection<Entry<String, String>> resolveFromArtifacts( final SourceResolverConfig config,
                                                       final List<Artifact> artifacts )
         throws ArtifactResolutionException, ArtifactNotFoundException
     {
@@ -364,8 +366,20 @@
         return a;
     }
 
-    private List<String> resolveAndUnpack( final List<Artifact> artifacts, final SourceResolverConfig config,
-                                                  final List<String> validClassifiers, final boolean propagateErrors )
+    /**
+     * 
+     * @param artifacts the artifacts to resolve
+     * @param config the configuration
+     * @param validClassifiers 
+     * @param propagateErrors
+     * @return list of <dependencyConflictId, absolutePath>
+     * @throws ArtifactResolutionException if an exception occurs
+     * @throws ArtifactNotFoundException if an exception occurs
+     */
+    private Collection<Map.Entry<String, String>> resolveAndUnpack( final List<Artifact> artifacts,
+                                                                    final SourceResolverConfig config,
+                                                                    final List<String> validClassifiers,
+                                                                    final boolean propagateErrors )
         throws ArtifactResolutionException, ArtifactNotFoundException
     {
         // NOTE: Since these are '-sources' and '-test-sources' artifacts, they won't actually 
@@ -383,7 +397,7 @@
             filter = null;
         }
         
-        final List<String> result = new ArrayList<>( artifacts.size() );
+        final List<Map.Entry<String, String>> result = new ArrayList<>( artifacts.size() );
         for ( final Artifact a : artifactSet )
         {
             if ( !validClassifiers.contains( a.getClassifier() ) || ( filter != null && !filter.include( a ) ) )
@@ -418,7 +432,8 @@
 
                 unArchiver.extract();
 
-                result.add( d.getAbsolutePath() );
+                result.add( new AbstractMap.SimpleEntry<String, String>( a.getDependencyConflictId(),
+                                                                         d.getAbsolutePath() ) );
             }
             catch ( final NoSuchArchiverException e )
             {
diff --git a/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject1TestMavenProjectStub.java b/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject1TestMavenProjectStub.java
index def9961..68667ef 100644
--- a/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject1TestMavenProjectStub.java
+++ b/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject1TestMavenProjectStub.java
@@ -22,6 +22,7 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.model.Build;
@@ -39,9 +40,9 @@
     {
         readModel( new File( getBasedir(), "pom.xml" ) );
 
-        setGroupId( getModel().getGroupId() );
+        setGroupId( Objects.toString( getModel().getGroupId(), getModel().getParent().getGroupId() ) );
         setArtifactId( getModel().getArtifactId() );
-        setVersion( getModel().getVersion() );
+        setVersion( Objects.toString( getModel().getVersion(), getModel().getParent().getVersion() ) );
         setName( getModel().getName() );
         setUrl( getModel().getUrl() );
         setPackaging( getModel().getPackaging() );
diff --git a/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject2TestMavenProjectStub.java b/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject2TestMavenProjectStub.java
index 9283309..bbc5647 100644
--- a/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject2TestMavenProjectStub.java
+++ b/maven-javadoc-plugin/src/test/java/org/apache/maven/plugins/javadoc/stubs/AggregateResourcesProject2TestMavenProjectStub.java
@@ -22,6 +22,7 @@
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.model.Build;
@@ -39,9 +40,9 @@
     {
         readModel( new File( getBasedir(), "pom.xml" ) );
 
-        setGroupId( getModel().getGroupId() );
+        setGroupId( Objects.toString( getModel().getGroupId(), getModel().getParent().getGroupId() ) );
         setArtifactId( getModel().getArtifactId() );
-        setVersion( getModel().getVersion() );
+        setVersion( Objects.toString( getModel().getVersion(), getModel().getParent().getVersion() ) );
         setName( getModel().getName() );
         setUrl( getModel().getUrl() );
         setPackaging( getModel().getPackaging() );
