Fix #23096 on release

gradle · Dec 19, 2022 · 213fe27 · 213fe27
1 parent 6abc8d2
commit 213fe27
Show file tree

Hide file tree

Showing 13 changed files with 230 additions and 58 deletions.
diff --git a/subprojects/base-services/build.gradle.kts b/subprojects/base-services/build.gradle.kts
@@ -24,6 +24,7 @@ tasks.named<JavaCompile>("jmhCompileGeneratedClasses") {
 moduleIdentity.createBuildReceipt()
 
 dependencies {
+    api(libs.jetbrainsAnnotations)
     api(project(":base-annotations"))
     api(project(":worker-services"))
     api(project(":hashing"))

diff --git a/subprojects/base-services/src/main/java/org/gradle/util/internal/GUtil.java b/subprojects/base-services/src/main/java/org/gradle/util/internal/GUtil.java
@@ -24,6 +24,7 @@
 import org.gradle.internal.InternalTransformer;
 import org.gradle.internal.IoActions;
 import org.gradle.internal.UncheckedException;
+import org.jetbrains.annotations.Contract;
 
 import javax.annotation.Nullable;
 import java.io.File;
@@ -157,6 +158,7 @@ public static boolean isTrue(@Nullable Object object) {
      * would trigger early configuration.
      */
     @Nullable
+    @Contract("!null, _ -> param1; null, !null -> param2; null, null -> null")
     public static <T> T elvis(@Nullable T object, @Nullable T defaultValue) {
         return isTrue(object) ? object : defaultValue;
     }

diff --git a/...ects/core-api/src/main/java/org/gradle/api/artifacts/MinimalExternalModuleDependency.java b/...ects/core-api/src/main/java/org/gradle/api/artifacts/MinimalExternalModuleDependency.java
@@ -26,4 +26,10 @@
 public interface MinimalExternalModuleDependency extends ExternalModuleDependency {
     ModuleIdentifier getModule();
     VersionConstraint getVersionConstraint();
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    MinimalExternalModuleDependency copy();
 }
diff --git a/...in/java/org/gradle/api/internal/artifacts/dsl/dependencies/DependencyFactoryInternal.java b/...in/java/org/gradle/api/internal/artifacts/dsl/dependencies/DependencyFactoryInternal.java
@@ -47,4 +47,5 @@ enum ClassPathNotation {
     DependencyConstraint createDependencyConstraint(Object dependencyNotation);
     ClientModule createModule(Object dependencyNotation, Closure configureClosure);
     ProjectDependency createProjectDependencyFromMap(ProjectFinder projectFinder, Map<? extends String, ? extends Object> map);
+    void injectServices(Dependency dependency);
 }
diff --git a/...egTest/groovy/org/gradle/integtests/resolve/api/ArtifactDeclarationIntegrationTest.groovy b/...egTest/groovy/org/gradle/integtests/resolve/api/ArtifactDeclarationIntegrationTest.groovy
@@ -500,4 +500,52 @@ classes.attributes.keySet().collect { it.name } == ['usage', 'format']
             }
         }
     }
+
+    def 'artifacts are copied when declaring dependency on existing version catalog dependency with artifact'() {
+        given:
+        buildFile << """
+            configurations {
+                implementation
+                destination1
+                destination2
+            }
+
+            dependencies {
+                implementation(libs.test) {
+                    artifact {
+                        classifier = "alternative"
+                    }
+                }
+            }
+
+            task copyAndPrintDependencies {
+                doLast {
+                    configurations.implementation.dependencies.each {
+                        project.dependencies.add("destination1", it)
+                        configurations.destination2.dependencies.add(it)
+                    }
+                    configurations.implementation.dependencies.each {
+                        println("implementation " + it + " " + it.artifacts*.classifier)
+                    }
+                    configurations.destination1.dependencies.each {
+                        println("destination1 " + it + " " + it.artifacts*.classifier)
+                    }
+                    configurations.destination2.dependencies.each {
+                        println("destination2 " + it + " " + it.artifacts*.classifier)
+                    }
+                }
+            }
+        """
+        file("gradle/libs.versions.toml") << """[libraries]
+test = { module = 'org:test', version = '1.0' }
+"""
+
+        when:
+        succeeds "copyAndPrintDependencies"
+
+        then:
+        outputContains("""implementation org:test:1.0 [alternative]
+destination1 org:test:1.0 [alternative]
+destination2 org:test:1.0 [alternative]""")
+    }
 }
diff --git a/...-management/src/main/java/org/gradle/api/internal/artifacts/DefaultDependencyFactory.java b/...-management/src/main/java/org/gradle/api/internal/artifacts/DefaultDependencyFactory.java
@@ -79,14 +79,15 @@ public Dependency createDependency(Object dependencyNotation) {
         Dependency dependency;
         if (dependencyNotation instanceof Dependency && !(dependencyNotation instanceof MinimalExternalModuleDependency)) {
             dependency = (Dependency) dependencyNotation;
+            injectServices(dependency);
         } else {
             dependency = dependencyNotationParser.getNotationParser().parseNotation(dependencyNotation);
         }
-        injectServices(dependency);
         return dependency;
     }
 
-    private void injectServices(Dependency dependency) {
+    @Override
+    public void injectServices(Dependency dependency) {
         if (dependency instanceof AbstractModuleDependency) {
             AbstractModuleDependency moduleDependency = (AbstractModuleDependency) dependency;
             moduleDependency.setAttributesFactory(attributesFactory);

diff --git a/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultExternalModuleDependency.java b/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultExternalModuleDependency.java
@@ -36,7 +36,7 @@ public DefaultExternalModuleDependency(ModuleIdentifier id, MutableVersionConstr
     }
 
     @Override
-    public DefaultExternalModuleDependency copy() {
+    public ExternalModuleDependency copy() {
         DefaultExternalModuleDependency copiedModuleDependency = new DefaultExternalModuleDependency(getGroup(), getName(), getVersion(), getTargetConfiguration());
         copyTo(copiedModuleDependency);
         return copiedModuleDependency;

diff --git a/...rc/main/java/org/gradle/api/internal/artifacts/dependencies/DefaultMinimalDependency.java b/...rc/main/java/org/gradle/api/internal/artifacts/dependencies/DefaultMinimalDependency.java
@@ -15,13 +15,12 @@
  */
 package org.gradle.api.internal.artifacts.dependencies;
 
-import org.gradle.api.artifacts.MinimalExternalModuleDependency;
 import org.gradle.api.artifacts.ModuleIdentifier;
 import org.gradle.api.artifacts.MutableVersionConstraint;
 
 import java.io.Serializable;
 
-public class DefaultMinimalDependency extends DefaultExternalModuleDependency implements MinimalExternalModuleDependency, Serializable {
+public class DefaultMinimalDependency extends DefaultExternalModuleDependency implements MinimalExternalModuleDependencyInternal, Serializable {
     public DefaultMinimalDependency(ModuleIdentifier module, MutableVersionConstraint versionConstraint) {
         super(module, versionConstraint);
     }
@@ -41,6 +40,11 @@ protected void validateMutation(Object currentValue, Object newValue) {
         validateMutation();
     }
 
+    @Override
+    public void copyTo(AbstractExternalModuleDependency target) {
+        super.copyTo(target);
+    }
+
     // Intentionally changes to the mutable version.
     @Override
     public DefaultMutableMinimalDependency copy() {

diff --git a/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultMinimalDependencyVariant.java b/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultMinimalDependencyVariant.java
@@ -18,38 +18,96 @@
 import org.gradle.api.Action;
 import org.gradle.api.artifacts.MinimalExternalModuleDependency;
 import org.gradle.api.artifacts.ModuleDependencyCapabilitiesHandler;
+import org.gradle.api.artifacts.ModuleIdentifier;
+import org.gradle.api.artifacts.MutableVersionConstraint;
 import org.gradle.api.attributes.AttributeContainer;
+import org.gradle.api.internal.artifacts.dsl.dependencies.ModuleFactoryHelper;
 import org.gradle.internal.Actions;
+import org.gradle.util.internal.GUtil;
 
 import javax.annotation.Nullable;
 
-public class DefaultMinimalDependencyVariant extends DefaultExternalModuleDependency implements MinimalExternalModuleDependency, DependencyVariant {
-    private final MinimalExternalModuleDependency delegate;
-    private final Action<? super AttributeContainer> attributesMutator;
-    private final Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator;
-    private final String classifier;
-    private final String artifactType;
-
-    public DefaultMinimalDependencyVariant(MinimalExternalModuleDependency delegate,
-                                           @Nullable Action<? super AttributeContainer> attributesMutator,
-                                           @Nullable Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator,
-                                           @Nullable String classifier,
-                                           @Nullable String artifactType) {
-        super(delegate.getModule(), new DefaultMutableVersionConstraint(delegate.getVersionConstraint()));
-        this.delegate = delegate;
-        boolean delegateIsVariant = delegate instanceof DefaultMinimalDependencyVariant;
-        this.attributesMutator = delegateIsVariant ? Actions.composite(((DefaultMinimalDependencyVariant) delegate).attributesMutator, attributesMutator == null ? Actions.doNothing() : attributesMutator) : attributesMutator;
-        this.capabilitiesMutator = delegateIsVariant ? Actions.composite(((DefaultMinimalDependencyVariant) delegate).capabilitiesMutator, capabilitiesMutator == null ? Actions.doNothing() : capabilitiesMutator) : capabilitiesMutator;
-        if (classifier == null && delegateIsVariant) {
-            classifier = ((DefaultMinimalDependencyVariant) delegate).getClassifier();
-        }
-        if (artifactType == null && delegateIsVariant) {
-            artifactType = ((DefaultMinimalDependencyVariant) delegate).getArtifactType();
+public class DefaultMinimalDependencyVariant extends DefaultExternalModuleDependency implements MinimalExternalModuleDependencyInternal, DependencyVariant {
+    private Action<? super AttributeContainer> attributesMutator;
+    private Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator;
+    private String classifier;
+    private String artifactType;
+
+    public static DefaultMinimalDependencyVariant create(
+        MinimalExternalModuleDependency delegate,
+        @Nullable Action<? super AttributeContainer> attributesMutator,
+        @Nullable Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator,
+        @Nullable String classifier,
+        @Nullable String artifactType
+    ) {
+        attributesMutator = GUtil.elvis(attributesMutator, Actions.doNothing());
+        capabilitiesMutator = GUtil.elvis(capabilitiesMutator, Actions.doNothing());
+
+        if (delegate instanceof DefaultMinimalDependencyVariant) {
+            DefaultMinimalDependencyVariant defaultDelegate = (DefaultMinimalDependencyVariant) delegate;
+            return new DefaultMinimalDependencyVariant(
+                delegate.getModule(),
+                new DefaultMutableVersionConstraint(delegate.getVersionConstraint()),
+                Actions.composite(defaultDelegate.attributesMutator, attributesMutator),
+                Actions.composite(defaultDelegate.capabilitiesMutator, capabilitiesMutator),
+                classifier == null ? defaultDelegate.getClassifier() : classifier,
+                artifactType == null ? defaultDelegate.getArtifactType() : artifactType
+            );
+        } else {
+            return new DefaultMinimalDependencyVariant(
+                delegate.getModule(),
+                new DefaultMutableVersionConstraint(delegate.getVersionConstraint()),
+                attributesMutator,
+                capabilitiesMutator,
+                classifier,
+                artifactType
+            );
         }
+    }
+
+    private DefaultMinimalDependencyVariant(
+        ModuleIdentifier id,
+        MutableVersionConstraint versionConstraint,
+        Action<? super AttributeContainer> attributesMutator,
+        Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator,
+        @Nullable String classifier,
+        @Nullable String artifactType
+    ) {
+        super(id, versionConstraint);
+        this.attributesMutator = attributesMutator;
+        this.capabilitiesMutator = capabilitiesMutator;
         this.classifier = classifier;
         this.artifactType = artifactType;
     }
 
+    @Override
+    public void copyTo(AbstractExternalModuleDependency target) {
+        super.copyTo(target);
+        if (target instanceof DefaultMinimalDependencyVariant) {
+            DefaultMinimalDependencyVariant depVariant = (DefaultMinimalDependencyVariant) target;
+            depVariant.attributesMutator = attributesMutator;
+            depVariant.capabilitiesMutator = capabilitiesMutator;
+            depVariant.classifier = classifier;
+            depVariant.artifactType = artifactType;
+        } else {
+            target.attributes(attributesMutator);
+            target.capabilities(capabilitiesMutator);
+            if (classifier != null || artifactType != null) {
+                ModuleFactoryHelper.addExplicitArtifactsIfDefined(target, artifactType, classifier);
+            }
+        }
+    }
+
+    @Override
+    public MinimalExternalModuleDependency copy() {
+        DefaultMinimalDependencyVariant dependency = new DefaultMinimalDependencyVariant(
+            getModule(), new DefaultMutableVersionConstraint(getVersionConstraint()),
+            attributesMutator, capabilitiesMutator, classifier, artifactType
+        );
+        copyTo(dependency);
+        return dependency;
+    }
+
     @Override
     public void because(String reason) {
         validateMutation();
@@ -67,16 +125,12 @@ protected void validateMutation(Object currentValue, Object newValue) {
 
     @Override
     public void mutateAttributes(AttributeContainer attributes) {
-        if (attributesMutator!= null) {
-            attributesMutator.execute(attributes);
-        }
+        attributesMutator.execute(attributes);
     }
 
     @Override
     public void mutateCapabilities(ModuleDependencyCapabilitiesHandler capabilitiesHandler) {
-        if (capabilitiesMutator != null) {
-            capabilitiesMutator.execute(capabilitiesHandler);
-        }
+        capabilitiesMutator.execute(capabilitiesHandler);
     }
 
     @Nullable
@@ -93,6 +147,11 @@ public String getArtifactType() {
 
     @Override
     public String toString() {
-        return delegate.toString();
+        return "DefaultMinimalDependencyVariant{" +
+            ", attributesMutator=" + attributesMutator +
+            ", capabilitiesMutator=" + capabilitiesMutator +
+            ", classifier='" + classifier + '\'' +
+            ", artifactType='" + artifactType + '\'' +
+            "} " + super.toString();
     }
 }
diff --git a/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultMutableMinimalDependency.java b/.../java/org/gradle/api/internal/artifacts/dependencies/DefaultMutableMinimalDependency.java
@@ -15,13 +15,12 @@
  */
 package org.gradle.api.internal.artifacts.dependencies;
 
-import org.gradle.api.artifacts.MinimalExternalModuleDependency;
 import org.gradle.api.artifacts.ModuleIdentifier;
 import org.gradle.api.artifacts.MutableVersionConstraint;
 
 import java.io.Serializable;
 
-public class DefaultMutableMinimalDependency extends DefaultExternalModuleDependency implements MinimalExternalModuleDependency, Serializable {
+public class DefaultMutableMinimalDependency extends DefaultExternalModuleDependency implements MinimalExternalModuleDependencyInternal, Serializable {
     public DefaultMutableMinimalDependency(ModuleIdentifier module, MutableVersionConstraint versionConstraint) {
         super(module, versionConstraint);
     }
@@ -33,6 +32,11 @@ public DefaultMutableMinimalDependency copy() {
         return dependency;
     }
 
+    @Override
+    public void copyTo(AbstractExternalModuleDependency target) {
+        super.copyTo(target);
+    }
+
     public String toString() {
         String versionConstraintAsString = getVersionConstraint().toString();
         return versionConstraintAsString.isEmpty()

diff --git a/...g/gradle/api/internal/artifacts/dependencies/MinimalExternalModuleDependencyInternal.java b/...g/gradle/api/internal/artifacts/dependencies/MinimalExternalModuleDependencyInternal.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradle.api.internal.artifacts.dependencies;
+
+import org.gradle.api.artifacts.MinimalExternalModuleDependency;
+
+public interface MinimalExternalModuleDependencyInternal extends MinimalExternalModuleDependency {
+    void copyTo(AbstractExternalModuleDependency target);
+}
diff --git a/...ain/java/org/gradle/api/internal/artifacts/dsl/dependencies/DefaultDependencyHandler.java b/...ain/java/org/gradle/api/internal/artifacts/dsl/dependencies/DefaultDependencyHandler.java
@@ -400,7 +400,9 @@ public Provider<MinimalExternalModuleDependency> variantOf(Provider<MinimalExter
         return dependencyProvider.map(dep -> {
             DefaultExternalModuleDependencyVariantSpec spec = objects.newInstance(DefaultExternalModuleDependencyVariantSpec.class, objects, dep);
             variantSpec.execute(spec);
-            return new DefaultMinimalDependencyVariant(dep, spec.attributesAction, spec.capabilitiesMutator, spec.classifier, spec.artifactType);
+            DefaultMinimalDependencyVariant newDep = DefaultMinimalDependencyVariant.create(dep, spec.attributesAction, spec.capabilitiesMutator, spec.classifier, spec.artifactType);
+            dependencyFactory.injectServices(newDep);
+            return newDep;
         });
     }