New instantiation strategy for various things

Despite being a dynamic build service, Gradle has static service
registries for objects that have already been instantiated. Working
around this by taking advantage of the project when available. This only
affects configuration time and does not cause caching issues.

Author: Jonathing

gradleutils-shared/src/main/java/net/minecraftforge/gradleutils/shared/EnhancedPlugin.java

@@ -16,12 +16,14 @@
 import org.gradle.api.plugins.ExtensionAware;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.provider.ProviderFactory;
+import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnknownNullability;
 
 import javax.inject.Inject;
 import java.io.File;
 import java.util.Objects;
+import java.util.concurrent.Callable;
 
 /// The enhanced plugin contains several helper members to assist in making Gradle plugins as clean as possible without
 /// needing to duplicate code across projects.
@@ -33,7 +35,7 @@ public abstract class EnhancedPlugin<T> implements Plugin<T>, EnhancedPluginAddi
     private final @Nullable String toolsExtName;
 
     private @UnknownNullability T target;
-    private ToolsExtensionImpl tools = this.getObjects().newInstance(ToolsExtensionImpl.class);
+    private ToolsExtensionImpl tools = this.getObjects().newInstance(ToolsExtensionImpl.class, (Callable<? extends JavaToolchainService>) this::toolchainsForTools);
     private final EnhancedProblems problemsInternal;
 
     /// The object factory provided by Gradle services.
@@ -64,6 +66,11 @@ public abstract class EnhancedPlugin<T> implements Plugin<T>, EnhancedPluginAddi
     /// Service Injection</a>
     protected abstract @Inject ProviderFactory getProviders();
 
+    /// The Java toolchain service provided by Gradle services.
+    ///
+    /// @return The Java toolchain service
+    protected abstract @Inject JavaToolchainService getJavaToolchains();
+
     /// This constructor must be called by all subclasses using a public constructor annotated with [Inject]. The name
     /// and display name passed in are used in a minimal instance of [EnhancedProblems], which is used to set up the
     /// plugin's [global][#globalCaches()] and [local][#localCaches()] caches. Additionally, the name is used to
@@ -98,7 +105,9 @@ public final void apply(T target) {
         this.setup(this.target = target);
 
         if (this.toolsExtName != null && target instanceof ExtensionAware)
-            this.tools = ((ExtensionAware) target).getExtensions().create(this.toolsExtName, ToolsExtensionImpl.class);
+            this.tools = ((ExtensionAware) target).getExtensions().create(this.toolsExtName, ToolsExtensionImpl.class, (Callable<? extends JavaToolchainService>) this::toolchainsForTools);
+//        else
+//            this.tools = this.getObjects().newInstance(ToolsExtensionImpl.class, (Callable<? extends JavaToolchainService>) this::toolchainsForTools);
     }
 
     /// Called when this plugin is applied to do setup work.
@@ -128,7 +137,19 @@ final EnhancedProblems getProblemsInternal() {
 
     @Override
     public Tool.Resolved getTool(Tool tool) {
-        return ((ToolInternal) tool).get(this.globalCaches(), this.tools);
+        ProviderFactory providers;
+        try {
+            providers = this.target instanceof Project ? this.getProviders() : ((Gradle) InvokerHelper.getProperty(this.target, "gradle")).getRootProject().getProviders();
+        } catch (Throwable ignored) {
+            providers = this.getProviders();
+        }
+
+        return ((ToolInternal) tool).get(this.globalCaches(), providers, this.tools);
+    }
+
+    // NOTE: Use this in Tool implementations. Enhanced plugins do not enforce application on projects.
+    JavaToolchainService toolchainsForTools() {
+        return this.target instanceof Project ? this.getJavaToolchains() : ((Gradle) InvokerHelper.getProperty(this.target, "gradle")).getRootProject().getExtensions().getByType(JavaToolchainService.class);
     }
 
 

gradleutils-shared/src/main/java/net/minecraftforge/gradleutils/shared/ToolExecBase.java

@@ -16,6 +16,7 @@
 import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.JavaExec;
 import org.gradle.api.tasks.Optional;
+import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
 import org.jetbrains.annotations.UnknownNullability;
@@ -24,6 +25,7 @@
 import java.io.File;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.Callable;
 
 /// This tool execution task is a template on top of [JavaExec] to make executing [tools][Tool] much easier and more
 /// consistent between plugins.
@@ -75,7 +77,8 @@ protected ToolExecBase(Class<P> problemsType, Tool tool) {
             this.getProject().afterEvaluate(project -> this.getProblems().reportToolExecNotEnhanced(this));
             resolved = ((ToolInternal) tool).get(
                 this.getProjectLayout().getBuildDirectory().dir("minecraftforge/tools/" + tool.getName().toLowerCase(Locale.ENGLISH)).map(this.ensureFileLocationInternal()),
-                this.getObjectFactory().newInstance(ToolsExtensionImpl.class)
+                this.getProviderFactory(),
+                this.getObjectFactory().newInstance(ToolsExtensionImpl.class, (Callable<? extends JavaToolchainService>) this::getJavaToolchainService)
             );
 
             this.defaultToolDir.value(

gradleutils-shared/src/main/java/net/minecraftforge/gradleutils/shared/ToolImpl.java

@@ -14,6 +14,7 @@
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.Property;
 import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.ProviderFactory;
 import org.gradle.api.provider.ValueSource;
 import org.gradle.api.provider.ValueSourceParameters;
 import org.gradle.jvm.toolchain.JavaLauncher;
@@ -69,12 +70,12 @@ public int getJavaVersion() {
     }
 
     @Override
-    public Tool.Resolved get(Provider<? extends Directory> cachesDir, ToolsExtensionImpl toolsExt) {
+    public Tool.Resolved get(Provider<? extends Directory> cachesDir, ProviderFactory providers, ToolsExtensionImpl toolsExt) {
         Tool.Definition definition = toolsExt.definitions.maybeCreate(this.name);
         FileCollection classpath = definition.getClasspath();
         if (classpath.isEmpty()) {
             classpath = toolsExt.getObjects().fileCollection().from(
-                toolsExt.getProviders().of(Source.class, spec -> spec.parameters(parameters -> {
+                providers.of(Source.class, spec -> spec.parameters(parameters -> {
                     parameters.getInputFile().set(cachesDir.map(d -> d.file("tools/" + this.fileName)));
                     parameters.getDownloadUrl().set(this.downloadUrl);
                 }))
@@ -84,8 +85,8 @@ public Tool.Resolved get(Provider<? extends Directory> cachesDir, ToolsExtension
         return new ResolvedImpl(
             toolsExt.getObjects(),
             classpath,
-            definition.getMainClass().orElse(toolsExt.getProviders().provider(this::getMainClass)),
-            definition.getJavaLauncher().orElse(SharedUtil.launcherForStrictly(toolsExt.getJavaToolchains(), this.getJavaVersion()))
+            definition.getMainClass().orElse(providers.provider(this::getMainClass)),
+            definition.getJavaLauncher().orElse(providers.provider(() -> SharedUtil.launcherForStrictly(toolsExt.javaToolchains.call(), this.getJavaVersion()).get()))
         );
     }
 

gradleutils-shared/src/main/java/net/minecraftforge/gradleutils/shared/ToolInternal.java

@@ -6,6 +6,7 @@
 
 import org.gradle.api.file.Directory;
 import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.ProviderFactory;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;
 
@@ -20,14 +21,14 @@ default TypeOf<?> getPublicType() {
     /// @param cachesDir The caches directory to store the downloaded tool in
     /// @param toolsExt  The plugin's tools extension, which may contain overrides for the tool definition
     /// @return The provider to the tool file
-    Tool.Resolved get(Provider<? extends Directory> cachesDir, ToolsExtensionImpl toolsExt);
+    Tool.Resolved get(Provider<? extends Directory> cachesDir, ProviderFactory providers, ToolsExtensionImpl toolsExt);
 
     /// Gets this tool and returns a provider for the downloaded/cached file.
     ///
     /// @param cachesDir The caches directory to store the downloaded tool in
     /// @param toolsExt  The plugin's tools extension, which may contain overrides for the tool definition
     /// @return The provider to the tool file
-    default Tool.Resolved get(Directory cachesDir, ToolsExtensionImpl toolsExt) {
-        return this.get(toolsExt.getProviders().provider(() -> cachesDir), toolsExt);
+    default Tool.Resolved get(Directory cachesDir, ProviderFactory providers, ToolsExtensionImpl toolsExt) {
+        return this.get(providers.provider(() -> cachesDir), providers, toolsExt);
     }
 }

gradleutils-shared/src/main/java/net/minecraftforge/gradleutils/shared/ToolsExtensionImpl.java

@@ -9,25 +9,23 @@
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.Property;
-import org.gradle.api.provider.ProviderFactory;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;
 import org.gradle.jvm.toolchain.JavaLauncher;
 import org.gradle.jvm.toolchain.JavaToolchainService;
 
 import javax.inject.Inject;
+import java.util.concurrent.Callable;
 
 abstract class ToolsExtensionImpl implements ToolsExtensionInternal {
+    final Callable<? extends JavaToolchainService> javaToolchains;
     final NamedDomainObjectContainer<? extends Tool.Definition> definitions;
 
     protected abstract @Inject ObjectFactory getObjects();
 
-    protected abstract @Inject ProviderFactory getProviders();
-
-    protected abstract @Inject JavaToolchainService getJavaToolchains();
-
     @Inject
-    public ToolsExtensionImpl() {
+    public ToolsExtensionImpl(Callable<? extends JavaToolchainService> javaToolchains) {
+        this.javaToolchains = javaToolchains;
         this.definitions = this.getObjects().domainObjectContainer(DefinitionImpl.class);
     }