Use dependency substitution rules instead of constraints

Dependency substitutions are only considered and applied for incoming
configurations. Consumable configurations are not affected and thus the
attributes used to enforce AccessTransformers will not pollute the
Gradle Module Metadata.

This is important because it is theoretically possible for stray
AccessTransformer attributes to either:
1. Cause a dependency lock-up for dependencies that have weird variants
or complex resolutions.
2. Cause an incoming dependency with those attributes to have unwanted
AccessTransformers applied to them.

Author: Jonathing

at-gradle-demo/build.gradle

@@ -1,8 +1,11 @@
 plugins {
     id 'java'
+    id 'maven-publish'
     id 'net.minecraftforge.accesstransformers'
 }
 
+group = 'net.minecraftforge'
+
 java.toolchain.languageVersion = JavaLanguageVersion.of(17)
 
 dependencies {
@@ -11,5 +14,12 @@ dependencies {
             config = project.file('accesstransformer.cfg')
         }
     }
+
     compileOnly libs.log4j.api
 }
+
+publishing {
+    publications.register('mavenJava', MavenPublication) {
+        from components.java
+    }
+}

at-gradle-demo/settings.gradle

@@ -5,13 +5,13 @@ pluginManagement {
         mavenCentral()
         gradlePluginPortal()
         maven { url = 'https://maven.minecraftforge.net' }
-        //mavenLocal()
+        mavenLocal()
     }
 }
 
 plugins {
     id 'org.gradle.toolchains.foojay-resolver-convention' version '1.0.0'
-    id 'net.minecraftforge.gradleutils' version '3.3.12'
+    id 'net.minecraftforge.gradleutils' version '3.3.13'
 }
 
 rootProject.name = 'at-gradle-demo'

at-gradle/settings.gradle

@@ -13,8 +13,8 @@ dependencyResolutionManagement {
     repositories {
         mavenCentral()
         maven gradleutils.forgeMaven
+        mavenLocal()
         maven { url = 'https://maven.moddinglegacy.com/maven' } // Gradle API
-        //mavenLocal()
     }
 
     //@formatter:off
@@ -35,7 +35,7 @@ dependencyResolutionManagement {
         library 'gradle', 'name.remal.gradle-api', 'gradle-api'  versionRef 'gradle'
 
         // GradleUtils Shared Base
-        library 'gradleutils-shared', 'net.minecraftforge', 'gradleutils-shared' version '3.3.12'
+        library 'gradleutils-shared', 'net.minecraftforge', 'gradleutils-shared' version '3.3.13'
 
         // Utils
         library 'utils-hash', 'net.minecraftforge', 'hash-utils' version '0.1.9'

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainer.java

@@ -5,9 +5,6 @@
 package net.minecraftforge.accesstransformers.gradle;
 
 import org.gradle.api.Action;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.attributes.HasConfigurableAttributes;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.logging.LogLevel;
@@ -19,21 +16,11 @@
 /// Represents a container of dependencies that will be access transformed.
 ///
 /// Containers are created with [AccessTransformersExtension#register(Action)]. Dependencies can be registered to it
-/// inside their configuring closures using [#configure(Dependency)].
+/// inside their configuring closures using [#configure].
 ///
 /// @apiNote This interface is effectively sealed and [must not be extended][ApiStatus.NonExtendable].
 /// @see AccessTransformersExtension
 public sealed interface AccessTransformersContainer permits AccessTransformersContainerInternal, AccessTransformersExtension {
-    /// Registers a new container using the given attribute and options.
-    ///
-    /// @param project The project to make the container for]
-    /// @param options The options to apply
-    /// @return The registered container
-    /// @see AccessTransformersContainer.Options
-    static AccessTransformersContainer register(Project project, Action<? super AccessTransformersContainer.Options> options) {
-        return AccessTransformersContainerInternal.register(project, options);
-    }
-
     /// Gets the access transformer options.
     ///
     /// @return The options
@@ -51,15 +38,15 @@ default void options(Action<? super AccessTransformersContainer.Options> action)
     /// Configures the given dependency to use this AccessTransformers container.
     ///
     /// @param dependency The dependency to configure AccessTransformers for
-    default void configure(Dependency dependency) {
+    default void configure(Object dependency) {
         this.configure(dependency, it -> { });
     }
 
     /// Configures the given dependency to use this AccessTransformers container.
     ///
     /// @param dependency The dependency to configure AccessTransformers for
     /// @param action A configuring action to modify dependency-level AccessTransformer options
-    void configure(Dependency dependency, Action<? super AccessTransformersConfiguration> action);
+    void configure(Object dependency, Action<? super AccessTransformersConfiguration> action);
 
     /// When initially registering an AccessTransformers container, the consumer should define key information regarding
     /// how AccessTransformers will be used. This interface is used to define that information.

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainerImpl.java

@@ -6,8 +6,6 @@
 
 import org.gradle.api.Action;
 import org.gradle.api.Project;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.attributes.HasConfigurableAttributes;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.logging.LogLevel;
@@ -22,8 +20,6 @@
 import java.util.List;
 
 abstract class AccessTransformersContainerImpl implements AccessTransformersContainerInternal {
-    private final AccessTransformersProblems problems;
-
     private final OptionsImpl options;
 
     protected abstract @Inject ObjectFactory getObjects();
@@ -33,8 +29,6 @@ public AccessTransformersContainerImpl(
         Project project,
         Action<? super AccessTransformersContainer.Options> options
     ) {
-        this.problems = this.getObjects().newInstance(AccessTransformersProblems.class);
-
         options.execute(this.options = this.getObjects().newInstance(OptionsImpl.class, project));
     }
 
@@ -44,11 +38,7 @@ public AccessTransformersContainer.Options getOptions() {
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public void configure(Dependency dependency, Action<? super AccessTransformersConfiguration> action) {
-        if (!(dependency instanceof HasConfigurableAttributes))
-            this.problems.reportIllegalTargetDependency(dependency);
-
+    public void configure(Object dependency, Action<? super AccessTransformersConfiguration> action) {
         var ext = ((ExtensionAware) dependency).getExtensions().getExtraProperties();
         var attributes = ext.has("__accessTransformers_configs")
             ? (List<AccessTransformersConfigurationImpl>) ext.get("__accessTransformers_configs")

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainerInternal.java

@@ -5,13 +5,16 @@
 package net.minecraftforge.accesstransformers.gradle;
 
 import org.gradle.api.Action;
+import org.gradle.api.DomainObjectSet;
+import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Project;
+import org.gradle.api.artifacts.DependencyScopeConfiguration;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;
 
 non-sealed interface AccessTransformersContainerInternal extends AccessTransformersContainer, HasPublicType {
     static AccessTransformersContainer register(Project project, Action<? super Options> options) {
-        return project.getObjects().newInstance(AccessTransformersContainerImpl.class, options);
+        return project.getObjects().newInstance(AccessTransformersContainerImpl.class, project, options);
     }
 
     @Override

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersExtensionImpl.java

@@ -6,25 +6,22 @@
 
 import net.minecraftforge.gradleutils.shared.Closures;
 import org.gradle.api.Action;
-import org.gradle.api.InvalidUserDataException;
-import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.artifacts.DependencyScopeConfiguration;
-import org.gradle.api.artifacts.MinimalExternalModuleDependency;
+import org.gradle.api.artifacts.DependencySubstitutions;
 import org.gradle.api.artifacts.ModuleVersionSelector;
 import org.gradle.api.artifacts.ProjectDependency;
+import org.gradle.api.artifacts.component.ComponentSelector;
 import org.gradle.api.artifacts.dsl.DependencyHandler;
 import org.gradle.api.artifacts.type.ArtifactTypeDefinition;
 import org.gradle.api.attributes.Attribute;
 import org.gradle.api.attributes.AttributeContainer;
-import org.gradle.api.attributes.HasConfigurableAttributes;
 import org.gradle.api.file.ProjectLayout;
 import org.gradle.api.file.RegularFile;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.plugins.ExtensionAware;
-import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.provider.ProviderFactory;
 import org.jetbrains.annotations.Nullable;
 
@@ -33,15 +30,15 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 abstract class AccessTransformersExtensionImpl implements AccessTransformersExtensionInternal {
     private final Project project;
 
     private final AccessTransformersPlugin plugin;
     private final AccessTransformersProblems problems = this.getObjects().newInstance(AccessTransformersProblems.class);
 
-    private final NamedDomainObjectProvider<DependencyScopeConfiguration> constraintsConfiguration;
-
     private @Nullable AccessTransformersContainer container;
 
     protected abstract @Inject ObjectFactory getObjects();
@@ -56,56 +53,83 @@ public AccessTransformersExtensionImpl(AccessTransformersPlugin plugin, Project
         this.plugin = plugin;
 
         var configurations = project.getConfigurations();
-        {
-            NamedDomainObjectProvider<DependencyScopeConfiguration> c;
-            try {
-                c = configurations.dependencyScope("accessTransformersDependencyConstraints", configuration -> {
-                    configuration.setDescription("Dependency constraints to enforce access transformer usage.");
-                });
-            } catch (InvalidUserDataException e) {
-                c = configurations.named("accessTransformerDependencyConstraints", DependencyScopeConfiguration.class);
+        configurations.configureEach(configuration -> configuration.withDependencies(dependencies -> {
+            var constraints = configurations
+                .stream()
+                .flatMap(c -> c.getDependencyConstraints().matching(it ->
+                    ((ExtensionAware) it).getExtensions().getExtraProperties().has("__accessTransformers_configs")
+                ).stream())
+                .collect(Collectors.toMap(ModuleVersionSelector::getModule, Function.identity()));
+
+            for (var c : configurations) {
+                for (var dependency : c.getDependencies().matching(it ->
+                    ((ExtensionAware) it).getExtensions().getExtraProperties().has("__accessTransformers_configs")
+                )) {
+                    var configs = (List<AccessTransformersConfigurationImpl>) ((ExtensionAware) dependency).getExtensions().getExtraProperties().get("__accessTransformers_configs");
+                    var attributes = new ArrayList<Attribute<Boolean>>(configs.size());
+                    for (var config : configs) {
+                        attributes.add(this.register(dependency, config));
+                    }
+
+                    if (dependency instanceof ModuleVersionSelector m) {
+                        var constraint = constraints.remove(m.getModule());
+                        if (constraint != null) {
+                            var constraintConfigs = (List<AccessTransformersConfigurationImpl>) ((ExtensionAware) constraint).getExtensions().getExtraProperties().get("__accessTransformers_configs");
+                            for (var config : constraintConfigs) {
+                                attributes.add(this.register(constraint, config));
+                            }
+                        }
+                    }
+
+                    Function<DependencySubstitutions, ComponentSelector> componentSelector;
+                    if (dependency instanceof ProjectDependency p) {
+                        var path = p.getPath();
+                        componentSelector = s -> s.project(path);
+                    } else if (dependency instanceof ModuleVersionSelector m) {
+                        var module = "%s%s".formatted(m.getModule().toString(), m.getVersion() != null ? ":" + m.getVersion() : "");
+                        componentSelector = s -> s.module(module);
+                    } else {
+                        this.problems.reportIllegalTargetDependency(dependency);
+                        return;
+                    }
+
+                    this.apply(configuration, componentSelector, attributes);
+                }
             }
-            this.constraintsConfiguration = c;
-        }
 
-        // FUCK
-        project.getGradle().projectsEvaluated(gradle -> this.finish(project));
-    }
-
-    @SuppressWarnings({"unchecked", "DataFlowIssue"})
-    private void finish(Project project) {
-        project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets().forEach(sourceSet ->
-            Util.forEachClasspath(project.getConfigurations(), sourceSet, c -> c.extendsFrom(this.constraintsConfiguration.get()))
-        );
-
-        project.getConfigurations().forEach(c -> c.getDependencies().matching(it ->
-            ((ExtensionAware) it).getExtensions().getExtraProperties().has("__accessTransformers_configs")
-        ).forEach(dependency -> {
-            Object dependencyNotation = dependency;
-            if (!(dependencyNotation instanceof MinimalExternalModuleDependency)
-                && !(dependencyNotation instanceof ProjectDependency)
-                && dependencyNotation instanceof ModuleVersionSelector module) {
-                dependencyNotation = module.getModule().toString();
-            }
+            for (var constraint : constraints.values()) {
+                var configs = (List<AccessTransformersConfigurationImpl>) ((ExtensionAware) constraint).getExtensions().getExtraProperties().get("__accessTransformers_configs");
+                var attributes = new ArrayList<Attribute<Boolean>>(configs.size());
+                for (var config : configs) {
+                    attributes.add(this.register(constraint, config));
+                }
 
-            var configs = (List<AccessTransformersConfigurationImpl>) ((ExtensionAware) dependency).getExtensions().getExtraProperties().get("__accessTransformers_configs");
-            var attributes = new ArrayList<Attribute<Boolean>>(configs.size());
-            for (var i = 0; i < configs.size(); i++) {
-                var config = configs.get(i);
-                attributes.add(this.register(i, dependency, config));
+                var module = "%s%s".formatted(constraint.getModule().toString(), constraint.getVersion() != null ? ":" + constraint.getVersion() : "");
+                this.apply(configuration, s -> s.module(module), attributes);
             }
-
-            this.constraintsConfiguration.get().getDependencyConstraints().add(this.project.getDependencies().getConstraints().create(dependencyNotation, constraint ->
-                constraint.attributes(a -> {
-                    for (var attribute : attributes) a.attribute(attribute, true);
-                })
-            ));
         }));
     }
 
-    private Attribute<Boolean> register(int index, Dependency dependency, AccessTransformersConfigurationImpl config) {
+    private void apply(Configuration configuration, Function<DependencySubstitutions, ComponentSelector> componentSelector, Iterable<Attribute<Boolean>> attributes) {
+        configuration.getResolutionStrategy().dependencySubstitution(s -> {
+            var component = componentSelector.apply(s);
+            s.substitute(component).using(s.variant(component, variant -> {
+                variant.attributes(a -> {
+                    for (var attribute : attributes) {
+                        a.attribute(attribute, true);
+                    }
+                });
+            }));
+        });
+    }
+
+    private Attribute<Boolean> register(Object dependency, AccessTransformersConfigurationImpl config) {
         this.validateATFile(dependency, config.getConfig());
 
+        var ext = this.project.getGradle().getExtensions().getExtraProperties();
+        int index = ext.has("__accessTransformers_automatic_index") ? (int) ext.get("__accessTransformers_automatic_index") + 1 : 0;
+        this.project.getGradle().getExtensions().getExtraProperties().set("__accessTransformers_automatic_index", index);
+
         var attribute = Attribute.of("net.minecraftforge.accesstransformers.automatic." + index, Boolean.class);
         this.project.dependencies(Closures.<DependencyHandler>consumer(this, dependencies -> {
             dependencies.attributesSchema(attributesSchema -> {
@@ -145,39 +169,41 @@ private static void setAttributes(AttributeContainer attributes, Attribute<Boole
                   .attribute(attribute, value);
     }
 
-    private void validateATFile(Dependency dependency, RegularFileProperty atFileProperty) {
+    private void validateATFile(Object dependency, RegularFileProperty atFileProperty) {
+        var dependencyToString = dependency instanceof Dependency d ? Util.toString(d) : dependency.toString();
+
         // check that consumer has defined the config
         RegularFile atFileSource;
         try {
             atFileSource = atFileProperty.get();
         } catch (IllegalStateException e) {
-            throw this.problems.accessTransformerConfigNotDefined(new RuntimeException("Failed to resolve config file property", e), dependency);
+            throw this.problems.accessTransformerConfigNotDefined(new RuntimeException("Failed to resolve config file property", e), dependencyToString);
         }
 
         // check that the file exists
         var atFile = atFileSource.getAsFile();
         var atFilePath = this.getLayout().getProjectDirectory().getAsFile().toPath().relativize(atFile.toPath()).toString();
         if (!atFile.exists())
-            throw this.problems.accessTransformerConfigMissing(new RuntimeException(new FileNotFoundException("Config file does not exist at " + atFilePath)), dependency, atFilePath);
+            throw this.problems.accessTransformerConfigMissing(new RuntimeException(new FileNotFoundException("Config file does not exist at " + atFilePath)), dependencyToString, atFilePath);
 
         // check that the file can be read and isn't empty
         String atFileContents;
         try {
             atFileContents = this.getProviders().fileContents(atFileSource).getAsText().get();
         } catch (Throwable e) {
-            throw this.problems.accessTransformerConfigUnreadable(new RuntimeException(new IOException("Failed to read config file at " + atFilePath, e)), dependency, atFilePath);
+            throw this.problems.accessTransformerConfigUnreadable(new RuntimeException(new IOException("Failed to read config file at " + atFilePath, e)), dependencyToString, atFilePath);
         }
         if (atFileContents.isBlank())
-            throw this.problems.accessTransformerConfigEmpty(new IllegalStateException("Config file must not be blank at " + atFilePath), dependency, atFilePath);
+            throw this.problems.accessTransformerConfigEmpty(new IllegalStateException("Config file must not be blank at " + atFilePath), dependencyToString, atFilePath);
     }
 
     @Override
     public AccessTransformersContainer register(Action<? super AccessTransformersContainer.Options> options) {
-        return this.container = AccessTransformersContainer.register(this.project, options);
+        return this.container = AccessTransformersContainerInternal.register(this.project, options);
     }
 
     private AccessTransformersContainer getContainer() {
-        return this.container == null ? this.container = AccessTransformersContainer.register(this.project, it -> { }) : this.container;
+        return this.container == null ? this.container = AccessTransformersContainerInternal.register(this.project, it -> { }) : this.container;
     }
 
     @Override
@@ -191,7 +217,7 @@ public void options(Action<? super Options> action) {
     }
 
     @Override
-    public void configure(Dependency dependency, Action<? super AccessTransformersConfiguration> action) {
+    public void configure(Object dependency, Action<? super AccessTransformersConfiguration> action) {
         this.getContainer().configure(dependency, action);
     }
 }