Merge pull request #18572 Test portback of fix #15637

subprojects/configuration-cache/src/main/kotlin/org/gradle/configurationcache/serialization/codecs/LocalFileDependencyBackedArtifactSetCodec.kt

@@ -44,6 +44,7 @@ import org.gradle.api.internal.artifacts.transform.TransformUpstreamDependencies
 import org.gradle.api.internal.artifacts.transform.Transformation
 import org.gradle.api.internal.artifacts.transform.TransformationStep
 import org.gradle.api.internal.artifacts.transform.TransformedVariantFactory
+import org.gradle.api.internal.artifacts.transform.VariantDefinition
 import org.gradle.api.internal.artifacts.transform.VariantSelector
 import org.gradle.api.internal.artifacts.type.DefaultArtifactTypeRegistry
 import org.gradle.api.internal.attributes.AttributeContainerInternal
@@ -197,7 +198,7 @@ class RecordingVariantSet(
         throw UnsupportedOperationException("Should not be called")
     }
 
-    override fun visitLocalArtifacts(visitor: ResolvedArtifactSet.LocalArtifactVisitor) {
+    override fun visitTransformSources(visitor: ResolvedArtifactSet.TransformSourceVisitor) {
         throw UnsupportedOperationException("Should not be called")
     }
 
@@ -211,13 +212,12 @@ class RecordingVariantSet(
 
     override fun asTransformed(
         sourceVariant: ResolvedVariant,
-        targetAttributes: ImmutableAttributes,
-        transformation: Transformation,
+        variantDefinition: VariantDefinition,
         dependenciesResolver: ExtraExecutionGraphDependenciesResolverFactory,
         transformedVariantFactory: TransformedVariantFactory
     ): ResolvedArtifactSet {
-        this.transformation = transformation
-        this.targetAttributes = targetAttributes
+        this.transformation = variantDefinition.transformation
+        this.targetAttributes = variantDefinition.targetAttributes
         return sourceVariant.artifacts
     }
 }
@@ -228,7 +228,23 @@ sealed class MappingSpec
 
 
 private
-class TransformMapping(val targetAttributes: ImmutableAttributes, val transformation: Transformation) : MappingSpec()
+class TransformMapping(private val targetAttributes: ImmutableAttributes, private val transformation: Transformation) : MappingSpec(), VariantDefinition {
+    override fun getTargetAttributes(): ImmutableAttributes {
+        return targetAttributes
+    }
+
+    override fun getTransformation(): Transformation {
+        return transformation
+    }
+
+    override fun getTransformationStep(): TransformationStep {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getSourceVariant(): VariantDefinition? {
+        throw UnsupportedOperationException()
+    }
+}
 
 
 private
@@ -257,7 +273,7 @@ class FixedVariantSelector(
                     variant.artifacts
                 }
             is IdentityMapping -> variant.artifacts
-            is TransformMapping -> factory.asTransformed(variant, spec.targetAttributes, spec.transformation, EmptyDependenciesResolverFactory(fileCollectionFactory), transformedVariantFactory)
+            is TransformMapping -> factory.asTransformed(variant, spec, EmptyDependenciesResolverFactory(fileCollectionFactory), transformedVariantFactory)
         }
     }
 }
@@ -325,8 +341,7 @@ object NoOpTransformedVariantFactory : TransformedVariantFactory {
     override fun transformedExternalArtifacts(
         componentIdentifier: ComponentIdentifier,
         sourceVariant: ResolvedVariant,
-        target: ImmutableAttributes,
-        transformation: Transformation,
+        variantDefinition: VariantDefinition,
         dependenciesResolverFactory: ExtraExecutionGraphDependenciesResolverFactory
     ): ResolvedArtifactSet {
         throw UnsupportedOperationException("Should not be called")
@@ -335,8 +350,7 @@ object NoOpTransformedVariantFactory : TransformedVariantFactory {
     override fun transformedProjectArtifacts(
         componentIdentifier: ComponentIdentifier,
         sourceVariant: ResolvedVariant,
-        target: ImmutableAttributes,
-        transformation: Transformation,
+        variantDefinition: VariantDefinition,
         dependenciesResolverFactory: ExtraExecutionGraphDependenciesResolverFactory
     ): ResolvedArtifactSet {
         throw UnsupportedOperationException("Should not be called")

subprojects/configuration-cache/src/main/kotlin/org/gradle/configurationcache/serialization/codecs/transform/CalculateArtifactsCodec.kt

@@ -92,7 +92,7 @@ class CalculateArtifactsCodec(
             }
         }
 
-        override fun visitLocalArtifacts(visitor: ResolvedArtifactSet.LocalArtifactVisitor) {
+        override fun visitTransformSources(visitor: ResolvedArtifactSet.TransformSourceVisitor) {
             throw UnsupportedOperationException("should not be called")
         }
 

subprojects/dependency-management/src/integTest/groovy/org/gradle/integtests/resolve/transform/ArtifactTransformWithDependenciesIntegrationTest.groovy

@@ -166,6 +166,65 @@ allprojects {
 """
     }
 
+    void setupBuildWithMultipleGraphsPerProject() {
+        setupBuildWithColorAttributes()
+        setupTransformerTypes()
+
+        buildFile << """
+            allprojects {
+                repositories {
+                    maven {
+                        url = '${mavenHttpRepo.uri}'
+                        metadataSources { gradleMetadata() }
+                    }
+                }
+                configurations {
+                    testImplementation {
+                        extendsFrom implementation
+                        canBeResolved = true
+                        canBeConsumed = false
+                        attributes.attribute(color, 'blue')
+                    }
+                }
+                task resolveTest(type: ShowFileCollection) {
+                    def view = configurations.testImplementation.incoming.artifactView {
+                        attributes.attribute(color, 'green')
+                    }.files
+                    files.from(view)
+                }
+            }
+        """
+    }
+
+    void setupSingleStepTransform() {
+        buildFile << """
+            allprojects {
+                dependencies {
+                    registerTransform(TestTransform) {
+                        from.attribute(color, 'blue')
+                        to.attribute(color, 'green')
+                        parameters {
+                            transformName = 'Single step transform'
+                        }
+                    }
+                }
+            }
+        """
+    }
+
+    void setupTransformWithNoDependencies() {
+        buildFile << """
+            allprojects {
+                dependencies {
+                    registerTransform(SimpleTransform) {
+                        from.attribute(color, 'blue')
+                        to.attribute(color, 'green')
+                    }
+                }
+            }
+        """
+    }
+
     void setupBuildWithFirstStepThatDoesNotUseDependencies() {
         setupBuildWithNoSteps()
         buildFile << """
@@ -1002,7 +1061,7 @@ abstract class ClasspathTransform implements TransformAction<TransformParameters
         classpathAnnotation << [Classpath, CompileClasspath]
     }
 
-    def "transforms with different dependencies in multiple dependency graphs are executed"() {
+    def "transforms with different dependencies in multiple dependency graphs in different projects are executed"() {
         given:
         withColorVariants(mavenHttpRepo.module("org.slf4j", "slf4j-api", "1.7.26")).publish().allowAll()
         settingsFile << "include('app2')"
@@ -1060,6 +1119,131 @@ abstract class ClasspathTransform implements TransformAction<TransformParameters
         assert libTransformWithNewSlf4j < app2Resolve
     }
 
+    @Issue("https://github.com/gradle/gradle/issues/15536")
+    def "transform of project dependency with different upstream dependencies in multiple dependency graphs in the same project are executed"() {
+        given:
+        setupBuildWithMultipleGraphsPerProject()
+        setupSingleStepTransform()
+
+        buildFile << """
+            project(':app') {
+                dependencies {
+                    implementation project(':lib')
+                    testImplementation 'org.slf4j:slf4j-api:1.7.25'
+                }
+            }
+            project(':lib') {
+                dependencies {
+                    implementation 'org.slf4j:slf4j-api:1.7.24'
+                }
+            }
+        """
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 4
+        output.contains("result = [lib.jar.txt, slf4j-api-1.7.24.jar.txt]")
+        output.contains("result = [lib.jar.txt, slf4j-api-1.7.25.jar.txt]")
+        output.count('Single step transform received dependencies files [] for processing slf4j-api-1.7.24.jar') == 1
+        output.count('Single step transform received dependencies files [] for processing slf4j-api-1.7.25.jar') == 1
+        output.count('Single step transform received dependencies files [slf4j-api-1.7.24.jar] for processing lib.jar') == 1
+        output.count('Single step transform received dependencies files [slf4j-api-1.7.25.jar] for processing lib.jar') == 1
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 0
+        output.contains("result = [lib.jar.txt, slf4j-api-1.7.24.jar.txt]")
+        output.contains("result = [lib.jar.txt, slf4j-api-1.7.25.jar.txt]")
+    }
+
+    @Issue("https://github.com/gradle/gradle/issues/15536")
+    def "transform of external dependency with different upstream dependencies in multiple dependency graphs in the same project are executed"() {
+        given:
+        def lib1 = withColorVariants(mavenHttpRepo.module("test", "lib1", "1.2")).publish().allowAll()
+        withColorVariants(mavenHttpRepo.module("test", "lib1", "1.3")).publish().allowAll()
+        withColorVariants(mavenHttpRepo.module("test", "lib2", "5.6"))
+            .dependsOn(lib1)
+            .publish()
+            .allowAll()
+
+        setupBuildWithMultipleGraphsPerProject()
+        setupSingleStepTransform()
+
+        buildFile << """
+            project(':app') {
+                dependencies {
+                    implementation 'test:lib2:5.6'
+                    testImplementation 'test:lib1:1.3'
+                }
+            }
+        """
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 4
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.2.jar.txt]")
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.3.jar.txt]")
+        output.count('Single step transform received dependencies files [] for processing lib1-1.2.jar') == 1
+        output.count('Single step transform received dependencies files [] for processing lib1-1.3.jar') == 1
+        output.count('Single step transform received dependencies files [lib1-1.2.jar] for processing lib2-5.6.jar') == 1
+        output.count('Single step transform received dependencies files [lib1-1.3.jar] for processing lib2-5.6.jar') == 1
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 0
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.2.jar.txt]")
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.3.jar.txt]")
+    }
+
+    def "reuses result of transform of external dependency with different upstream dependencies when transform does not consume upstream dependencies"() {
+        given:
+        def lib1 = withColorVariants(mavenHttpRepo.module("test", "lib1", "1.2")).publish().allowAll()
+        withColorVariants(mavenHttpRepo.module("test", "lib1", "1.3")).publish().allowAll()
+        withColorVariants(mavenHttpRepo.module("test", "lib2", "5.6"))
+            .dependsOn(lib1)
+            .publish()
+            .allowAll()
+
+        setupBuildWithMultipleGraphsPerProject()
+        setupTransformWithNoDependencies()
+
+        buildFile << """
+            project(':app') {
+                dependencies {
+                    implementation 'test:lib2:5.6'
+                    testImplementation 'test:lib1:1.3'
+                }
+            }
+        """
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 3
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.2.jar.txt]")
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.3.jar.txt]")
+        output.count('Transforming without dependencies lib2-5.6.jar to lib2-5.6.jar.txt') == 1
+        output.count('Transforming without dependencies lib1-1.2.jar to lib1-1.2.jar.txt') == 1
+        output.count('Transforming without dependencies lib1-1.3.jar to lib1-1.3.jar.txt') == 1
+
+        when:
+        run ":app:resolve", ":app:resolveTest"
+
+        then:
+        output.count('Transforming') == 0
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.2.jar.txt]")
+        output.contains("result = [lib2-5.6.jar.txt, lib1-1.3.jar.txt]")
+    }
+
     @ToBeFixedForConfigurationCache(because = "treating file collection visit failures as a configuration cache problem adds an additional failure to the build summary")
     def "transform does not execute when dependencies cannot be found"() {
         given:

subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/DefaultDependencyManagementServices.java

@@ -86,7 +86,6 @@
 import org.gradle.api.internal.artifacts.transform.DefaultVariantTransformRegistry;
 import org.gradle.api.internal.artifacts.transform.ImmutableTransformationWorkspaceServices;
 import org.gradle.api.internal.artifacts.transform.MutableTransformationWorkspaceServices;
-import org.gradle.api.internal.artifacts.transform.TransformationNodeRegistry;
 import org.gradle.api.internal.artifacts.transform.TransformationRegistrationFactory;
 import org.gradle.api.internal.artifacts.transform.TransformedVariantFactory;
 import org.gradle.api.internal.artifacts.transform.TransformerInvocationFactory;
@@ -191,10 +190,6 @@ public void afterTransformerInvocation(Describable transformer, Describable subj
                 }
             };
         }
-
-        TransformationNodeRegistry createTransformationNodeRegistry() {
-            return TransformationNodeRegistry.EMPTY;
-        }
     }
 
     private static class DependencyResolutionScopeServices {
@@ -465,7 +460,7 @@ ArtifactHandler createArtifactHandler(Instantiator instantiator, DependencyMetaD
             return instantiator.newInstance(DefaultArtifactHandler.class, configurationContainer, publishArtifactNotationParser);
         }
 
-        ComponentMetadataProcessorFactory createComponentMetadataProcessorFactory(ComponentMetadataHandlerInternal componentMetadataHandler, DependencyResolutionManagementInternal dependencyResolutionManagement,  DomainObjectContext context) {
+        ComponentMetadataProcessorFactory createComponentMetadataProcessorFactory(ComponentMetadataHandlerInternal componentMetadataHandler, DependencyResolutionManagementInternal dependencyResolutionManagement, DomainObjectContext context) {
             if (context.isScript()) {
                 return componentMetadataHandler::createComponentMetadataProcessor;
             }

subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/DependencyServices.java

@@ -18,12 +18,8 @@
 
 import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ArtifactSetToFileCollectionFactory;
 import org.gradle.api.internal.artifacts.transform.ArtifactTransformListener;
-import org.gradle.api.internal.artifacts.transform.DefaultTransformationNodeRegistry;
 import org.gradle.api.internal.artifacts.transform.TransformationNodeDependencyResolver;
-import org.gradle.api.internal.artifacts.transform.TransformationNodeRegistry;
 import org.gradle.internal.event.ListenerManager;
-import org.gradle.internal.model.CalculatedValueContainerFactory;
-import org.gradle.internal.operations.BuildOperationExecutor;
 import org.gradle.internal.service.ServiceRegistration;
 import org.gradle.internal.service.scopes.AbstractPluginServiceRegistry;
 
@@ -64,10 +60,6 @@ ArtifactTransformListener createArtifactTransformListener(ListenerManager listen
             return listenerManager.getBroadcaster(ArtifactTransformListener.class);
         }
 
-        TransformationNodeRegistry createTransformationNodeRegistry(BuildOperationExecutor buildOperationExecutor, CalculatedValueContainerFactory calculatedValueContainerFactory) {
-            return new DefaultTransformationNodeRegistry(buildOperationExecutor, calculatedValueContainerFactory);
-        }
-
         TransformationNodeDependencyResolver createTransformationNodeDependencyResolver() {
             return new TransformationNodeDependencyResolver();
         }

subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/configurations/DefaultConfiguration.java

@@ -234,6 +234,7 @@ public class DefaultConfiguration extends AbstractFileCollection implements Conf
 
     private ConfigurationInternal consistentResolutionSource;
     private String consistentResolutionReason;
+    private ExtraExecutionGraphDependenciesResolverFactory dependenciesResolverFactory;
 
     public DefaultConfiguration(DomainObjectContext domainObjectContext,
                                 String name,
@@ -810,8 +811,11 @@ private ResolveState resolveArtifactsIfRequired(ResolveState currentState) {
 
     @Override
     public ExtraExecutionGraphDependenciesResolverFactory getDependenciesResolver() {
-        return new DefaultExtraExecutionGraphDependenciesResolverFactory(new DefaultResolutionResultProvider(), owner, calculatedValueContainerFactory,
-            (attributes, filter) -> new ConfigurationFileCollection(new SelectedArtifactsProvider(), Specs.satisfyAll(), attributes, filter, false, false, new DefaultResolutionHost()));
+        if (dependenciesResolverFactory == null) {
+            dependenciesResolverFactory = new DefaultExtraExecutionGraphDependenciesResolverFactory(new DefaultResolutionResultProvider(), owner, calculatedValueContainerFactory,
+                (attributes, filter) -> new ConfigurationFileCollection(new SelectedArtifactsProvider(), Specs.satisfyAll(), attributes, filter, false, false, new DefaultResolutionHost()));
+        }
+        return dependenciesResolverFactory;
     }
 
     private ResolverResults getResultsForBuildDependencies() {

subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/ivyservice/resolveengine/artifact/ArtifactBackedResolvedVariant.java

@@ -136,7 +136,7 @@ public void visit(ArtifactVisitor visitor) {
         }
 
         @Override
-        public void visitLocalArtifacts(LocalArtifactVisitor visitor) {
+        public void visitTransformSources(TransformSourceVisitor visitor) {
             if (artifact.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier) {
                 visitor.visitArtifact(artifact);
             }

subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/ivyservice/resolveengine/artifact/BrokenResolvedArtifactSet.java

@@ -40,7 +40,7 @@ public void visit(Visitor visitor) {
     }
 
     @Override
-    public void visitLocalArtifacts(LocalArtifactVisitor visitor) {
+    public void visitTransformSources(TransformSourceVisitor visitor) {
         throw UncheckedException.throwAsUncheckedException(failure);
     }