Cleanup MinecraftJarConfiguration (#1070)

* Cleanup MinecraftJarConfiguration

* Fixes

* Fixes

src/main/java/net/fabricmc/loom/api/LoomGradleExtensionAPI.java

@@ -204,7 +204,7 @@ public interface LoomGradleExtensionAPI {
 	 */
 	Property<String> getIntermediaryUrl();
 
-	Property<MinecraftJarConfiguration> getMinecraftJarConfiguration();
+	Property<MinecraftJarConfiguration<?, ?, ?>> getMinecraftJarConfiguration();
 
 	default void serverOnlyMinecraftJar() {
 		getMinecraftJarConfiguration().set(MinecraftJarConfiguration.SERVER_ONLY);

src/main/java/net/fabricmc/loom/configuration/CompileConfiguration.java

@@ -63,7 +63,6 @@ import net.fabricmc.loom.configuration.processors.MinecraftJarProcessorManager;
 import net.fabricmc.loom.configuration.processors.ModJavadocProcessor;
 import net.fabricmc.loom.configuration.providers.mappings.LayeredMappingsFactory;
 import net.fabricmc.loom.configuration.providers.mappings.MappingConfiguration;
-import net.fabricmc.loom.configuration.providers.minecraft.MinecraftJarConfiguration;
 import net.fabricmc.loom.configuration.providers.minecraft.MinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.MinecraftSourceSets;
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.AbstractMappedMinecraftProvider;
@@ -152,10 +151,10 @@ public abstract class CompileConfiguration implements Runnable {
 	private synchronized void setupMinecraft(ConfigContext configContext) throws Exception {
 		final Project project = configContext.project();
 		final LoomGradleExtension extension = configContext.extension();
-		final MinecraftJarConfiguration jarConfiguration = extension.getMinecraftJarConfiguration().get();
+		final var jarConfiguration = extension.getMinecraftJarConfiguration().get();
 
 		// Provide the vanilla mc jars -- TODO share across getProject()s.
-		final MinecraftProvider minecraftProvider = jarConfiguration.getMinecraftProviderFunction().apply(configContext);
+		final MinecraftProvider minecraftProvider = jarConfiguration.createMinecraftProvider(configContext);
 		extension.setMinecraftProvider(minecraftProvider);
 		minecraftProvider.provide();
 
@@ -168,15 +167,15 @@ public abstract class CompileConfiguration implements Runnable {
 		mappingConfiguration.applyToProject(getProject(), mappingsDep);
 
 		// Provide the remapped mc jars
-		final IntermediaryMinecraftProvider<?> intermediaryMinecraftProvider = jarConfiguration.getIntermediaryMinecraftProviderBiFunction().apply(project, minecraftProvider);
-		NamedMinecraftProvider<?> namedMinecraftProvider = jarConfiguration.getNamedMinecraftProviderBiFunction().apply(project, minecraftProvider);
+		final IntermediaryMinecraftProvider<?> intermediaryMinecraftProvider = jarConfiguration.createIntermediaryMinecraftProvider(project);
+		NamedMinecraftProvider<?> namedMinecraftProvider = jarConfiguration.createNamedMinecraftProvider(project);
 
 		registerGameProcessors(configContext);
 		MinecraftJarProcessorManager minecraftJarProcessorManager = MinecraftJarProcessorManager.create(getProject());
 
 		if (minecraftJarProcessorManager != null) {
 			// Wrap the named MC provider for one that will provide the processed jars
-			namedMinecraftProvider = jarConfiguration.getProcessedNamedMinecraftProviderBiFunction().apply(namedMinecraftProvider, minecraftJarProcessorManager);
+			namedMinecraftProvider = jarConfiguration.createProcessedNamedMinecraftProvider(namedMinecraftProvider, minecraftJarProcessorManager);
 		}
 
 		final var provideContext = new AbstractMappedMinecraftProvider.ProvideContext(true, extension.refreshDeps(), configContext);
@@ -237,8 +236,7 @@ public abstract class CompileConfiguration implements Runnable {
 		final LoomGradleExtension extension = configContext.extension();
 
 		extension.getMinecraftJarConfiguration().get()
-				.getDecompileConfigurationBiFunction()
-				.apply(configContext.project(), extension.getNamedMinecraftProvider())
+				.createDecompileConfiguration(getProject())
 				.afterEvaluation();
 	}
 

src/main/java/net/fabricmc/loom/configuration/ide/idea/DownloadSourcesHook.java

@@ -116,8 +116,7 @@ record DownloadSourcesHook(Project project, Task task) {
 	private String getGenSourcesTaskName(MinecraftJar.Type jarType) {
 		LoomGradleExtension extension = LoomGradleExtension.get(project);
 		return extension.getMinecraftJarConfiguration().get()
-				.getDecompileConfigurationBiFunction()
-				.apply(project, extension.getNamedMinecraftProvider())
+				.createDecompileConfiguration(project)
 				.getTaskName(jarType);
 	}
 

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftJarConfiguration.java

@@ -25,11 +25,10 @@
 package net.fabricmc.loom.configuration.providers.minecraft;
 
 import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.Function;
 
 import org.gradle.api.Project;
 
+import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.configuration.ConfigContext;
 import net.fabricmc.loom.configuration.decompile.DecompileConfiguration;
 import net.fabricmc.loom.configuration.decompile.SingleJarDecompileConfiguration;
@@ -40,85 +39,111 @@ import net.fabricmc.loom.configuration.providers.minecraft.mapped.MappedMinecraf
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.NamedMinecraftProvider;
 import net.fabricmc.loom.configuration.providers.minecraft.mapped.ProcessedNamedMinecraftProvider;
 
-public enum MinecraftJarConfiguration {
-	MERGED(
-		MergedMinecraftProvider::new,
-		IntermediaryMinecraftProvider.MergedImpl::new,
-		NamedMinecraftProvider.MergedImpl::new,
-		ProcessedNamedMinecraftProvider.MergedImpl::new,
-		SingleJarDecompileConfiguration::new,
-		List.of("client", "server")
-	),
-	SERVER_ONLY(
-		SingleJarMinecraftProvider::server,
-		IntermediaryMinecraftProvider.SingleJarImpl::server,
-		NamedMinecraftProvider.SingleJarImpl::server,
-		ProcessedNamedMinecraftProvider.SingleJarImpl::server,
-		SingleJarDecompileConfiguration::new,
-		List.of("server")
-	),
-	CLIENT_ONLY(
-		SingleJarMinecraftProvider::client,
-		IntermediaryMinecraftProvider.SingleJarImpl::client,
-		NamedMinecraftProvider.SingleJarImpl::client,
-		ProcessedNamedMinecraftProvider.SingleJarImpl::client,
-		SingleJarDecompileConfiguration::new,
-		List.of("client")
-	),
-	SPLIT(
-		SplitMinecraftProvider::new,
-		IntermediaryMinecraftProvider.SplitImpl::new,
-		NamedMinecraftProvider.SplitImpl::new,
-		ProcessedNamedMinecraftProvider.SplitImpl::new,
-		SplitDecompileConfiguration::new,
-		List.of("client", "server")
-	);
+public record MinecraftJarConfiguration<
+		M extends MinecraftProvider,
+		N extends NamedMinecraftProvider<M>,
+		Q extends MappedMinecraftProvider>(
+				MinecraftProviderFactory<M> minecraftProviderFactory,
+				IntermediaryMinecraftProviderFactory<M> intermediaryMinecraftProviderFactory,
+				NamedMinecraftProviderFactory<M> namedMinecraftProviderFactory,
+				ProcessedNamedMinecraftProviderFactory<M, N> processedNamedMinecraftProviderFactory,
+				DecompileConfigurationFactory<Q> decompileConfigurationFactory,
+				List<String> supportedEnvironments) {
+	public static final MinecraftJarConfiguration<
+			MergedMinecraftProvider,
+			NamedMinecraftProvider.MergedImpl,
+			MappedMinecraftProvider> MERGED = new MinecraftJarConfiguration<>(
+				MergedMinecraftProvider::new,
+				IntermediaryMinecraftProvider.MergedImpl::new,
+				NamedMinecraftProvider.MergedImpl::new,
+				ProcessedNamedMinecraftProvider.MergedImpl::new,
+				SingleJarDecompileConfiguration::new,
+				List.of("client", "server")
+			);
+	public static final MinecraftJarConfiguration<
+			SingleJarMinecraftProvider,
+			NamedMinecraftProvider.SingleJarImpl,
+			MappedMinecraftProvider> SERVER_ONLY = new MinecraftJarConfiguration<>(
+				SingleJarMinecraftProvider::server,
+				IntermediaryMinecraftProvider.SingleJarImpl::server,
+				NamedMinecraftProvider.SingleJarImpl::server,
+				ProcessedNamedMinecraftProvider.SingleJarImpl::server,
+				SingleJarDecompileConfiguration::new,
+				List.of("server")
+			);
+	public static final MinecraftJarConfiguration<
+			SingleJarMinecraftProvider,
+			NamedMinecraftProvider.SingleJarImpl,
+			MappedMinecraftProvider> CLIENT_ONLY = new MinecraftJarConfiguration<>(
+				SingleJarMinecraftProvider::client,
+				IntermediaryMinecraftProvider.SingleJarImpl::client,
+				NamedMinecraftProvider.SingleJarImpl::client,
+				ProcessedNamedMinecraftProvider.SingleJarImpl::client,
+				SingleJarDecompileConfiguration::new,
+				List.of("client")
+			);
+	public static final MinecraftJarConfiguration<
+			SplitMinecraftProvider,
+			NamedMinecraftProvider.SplitImpl,
+			MappedMinecraftProvider.Split> SPLIT = new MinecraftJarConfiguration<>(
+				SplitMinecraftProvider::new,
+				IntermediaryMinecraftProvider.SplitImpl::new,
+				NamedMinecraftProvider.SplitImpl::new,
+				ProcessedNamedMinecraftProvider.SplitImpl::new,
+				SplitDecompileConfiguration::new,
+				List.of("client", "server")
+			);
 
-	private final Function<ConfigContext, MinecraftProvider> minecraftProviderFunction;
-	private final BiFunction<Project, MinecraftProvider, IntermediaryMinecraftProvider<?>> intermediaryMinecraftProviderBiFunction;
-	private final BiFunction<Project, MinecraftProvider, NamedMinecraftProvider<?>> namedMinecraftProviderBiFunction;
-	private final BiFunction<NamedMinecraftProvider<?>, MinecraftJarProcessorManager, ProcessedNamedMinecraftProvider<?, ?>> processedNamedMinecraftProviderBiFunction;
-	private final BiFunction<Project, MappedMinecraftProvider, DecompileConfiguration<?>> decompileConfigurationBiFunction;
-	private final List<String> supportedEnvironments;
-
-	@SuppressWarnings("unchecked") // Just a bit of a generic mess :)
-	<M extends MinecraftProvider, P extends NamedMinecraftProvider<M>, Q extends MappedMinecraftProvider> MinecraftJarConfiguration(
-			Function<ConfigContext, M> minecraftProviderFunction,
-			BiFunction<Project, M, IntermediaryMinecraftProvider<M>> intermediaryMinecraftProviderBiFunction,
-			BiFunction<Project, M, P> namedMinecraftProviderBiFunction,
-			BiFunction<P, MinecraftJarProcessorManager, ProcessedNamedMinecraftProvider<M, P>> processedNamedMinecraftProviderBiFunction,
-			BiFunction<Project, Q, DecompileConfiguration<?>> decompileConfigurationBiFunction,
-			List<String> supportedEnvironments
-	) {
-		this.minecraftProviderFunction = (Function<ConfigContext, MinecraftProvider>) minecraftProviderFunction;
-		this.intermediaryMinecraftProviderBiFunction = (BiFunction<Project, MinecraftProvider, IntermediaryMinecraftProvider<?>>) (Object) intermediaryMinecraftProviderBiFunction;
-		this.namedMinecraftProviderBiFunction = (BiFunction<Project, MinecraftProvider, NamedMinecraftProvider<?>>) namedMinecraftProviderBiFunction;
-		this.processedNamedMinecraftProviderBiFunction = (BiFunction<NamedMinecraftProvider<?>, MinecraftJarProcessorManager, ProcessedNamedMinecraftProvider<?, ?>>) (Object) processedNamedMinecraftProviderBiFunction;
-		this.decompileConfigurationBiFunction = (BiFunction<Project, MappedMinecraftProvider, DecompileConfiguration<?>>) decompileConfigurationBiFunction;
-		this.supportedEnvironments = supportedEnvironments;
+	public MinecraftProvider createMinecraftProvider(ConfigContext context) {
+		return minecraftProviderFactory.create(context);
 	}
 
-	public Function<ConfigContext, MinecraftProvider> getMinecraftProviderFunction() {
-		return minecraftProviderFunction;
+	public IntermediaryMinecraftProvider<M> createIntermediaryMinecraftProvider(Project project) {
+		return intermediaryMinecraftProviderFactory.create(project, getMinecraftProvider(project));
 	}
 
-	public BiFunction<Project, MinecraftProvider, IntermediaryMinecraftProvider<?>> getIntermediaryMinecraftProviderBiFunction() {
-		return intermediaryMinecraftProviderBiFunction;
+	public NamedMinecraftProvider<M> createNamedMinecraftProvider(Project project) {
+		return namedMinecraftProviderFactory.create(project, getMinecraftProvider(project));
 	}
 
-	public BiFunction<Project, MinecraftProvider, NamedMinecraftProvider<?>> getNamedMinecraftProviderBiFunction() {
-		return namedMinecraftProviderBiFunction;
+	public ProcessedNamedMinecraftProvider<M, N> createProcessedNamedMinecraftProvider(NamedMinecraftProvider<?> namedMinecraftProvider, MinecraftJarProcessorManager jarProcessorManager) {
+		return processedNamedMinecraftProviderFactory.create((N) namedMinecraftProvider, jarProcessorManager);
 	}
 
-	public BiFunction<NamedMinecraftProvider<?>, MinecraftJarProcessorManager, ProcessedNamedMinecraftProvider<?, ?>> getProcessedNamedMinecraftProviderBiFunction() {
-		return processedNamedMinecraftProviderBiFunction;
+	public DecompileConfiguration<Q> createDecompileConfiguration(Project project) {
+		return decompileConfigurationFactory.create(project, getMappedMinecraftProvider(project));
 	}
 
-	public BiFunction<Project, MappedMinecraftProvider, DecompileConfiguration<?>> getDecompileConfigurationBiFunction() {
-		return decompileConfigurationBiFunction;
+	private M getMinecraftProvider(Project project) {
+		LoomGradleExtension extension = LoomGradleExtension.get(project);
+		//noinspection unchecked
+		return (M) extension.getMinecraftProvider();
 	}
 
-	public List<String> getSupportedEnvironments() {
-		return supportedEnvironments;
+	private Q getMappedMinecraftProvider(Project project) {
+		LoomGradleExtension extension = LoomGradleExtension.get(project);
+		//noinspection unchecked
+		return (Q) extension.getNamedMinecraftProvider();
+	}
+
+	// Factory interfaces:
+	private interface MinecraftProviderFactory<M extends MinecraftProvider> {
+		M create(ConfigContext configContext);
+	}
+
+	private interface IntermediaryMinecraftProviderFactory<M extends MinecraftProvider> {
+		IntermediaryMinecraftProvider<M> create(Project project, M minecraftProvider);
+	}
+
+	private interface NamedMinecraftProviderFactory<M extends MinecraftProvider> {
+		NamedMinecraftProvider<M> create(Project project, M minecraftProvider);
+	}
+
+	private interface ProcessedNamedMinecraftProviderFactory<M extends MinecraftProvider, N extends NamedMinecraftProvider<M>> {
+		ProcessedNamedMinecraftProvider<M, N> create(N namedMinecraftProvider, MinecraftJarProcessorManager jarProcessorManager);
+	}
+
+	private interface DecompileConfigurationFactory<M extends MappedMinecraftProvider> {
+		DecompileConfiguration<M> create(Project project, M minecraftProvider);
 	}
 }

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/MinecraftLibraryProvider.java

@@ -82,8 +82,8 @@ public class MinecraftLibraryProvider {
 		final LoomGradleExtension extension = LoomGradleExtension.get(project);
 		final MinecraftJarConfiguration jarConfiguration = extension.getMinecraftJarConfiguration().get();
 
-		final boolean provideClient = jarConfiguration.getSupportedEnvironments().contains("client");
-		final boolean provideServer = jarConfiguration.getSupportedEnvironments().contains("server");
+		final boolean provideClient = jarConfiguration.supportedEnvironments().contains("client");
+		final boolean provideServer = jarConfiguration.supportedEnvironments().contains("server");
 		assert provideClient || provideServer;
 
 		if (provideClient) {

src/main/java/net/fabricmc/loom/configuration/providers/minecraft/SingleJarMinecraftProvider.java

@@ -34,29 +34,26 @@ import net.fabricmc.tinyremapper.NonClassCopyMode;
 import net.fabricmc.tinyremapper.OutputConsumerPath;
 import net.fabricmc.tinyremapper.TinyRemapper;
 
-public final class SingleJarMinecraftProvider extends MinecraftProvider {
-	private final Environment environment;
-
+public abstract sealed class SingleJarMinecraftProvider extends MinecraftProvider permits SingleJarMinecraftProvider.Server, SingleJarMinecraftProvider.Client {
 	private Path minecraftEnvOnlyJar;
 
-	private SingleJarMinecraftProvider(ConfigContext configContext, Environment environment) {
+	private SingleJarMinecraftProvider(ConfigContext configContext) {
 		super(configContext);
-		this.environment = environment;
 	}
 
-	public static SingleJarMinecraftProvider server(ConfigContext configContext) {
-		return new SingleJarMinecraftProvider(configContext, new Server());
+	public static SingleJarMinecraftProvider.Server server(ConfigContext configContext) {
+		return new SingleJarMinecraftProvider.Server(configContext);
 	}
 
-	public static SingleJarMinecraftProvider client(ConfigContext configContext) {
-		return new SingleJarMinecraftProvider(configContext, new Client());
+	public static SingleJarMinecraftProvider.Client client(ConfigContext configContext) {
+		return new SingleJarMinecraftProvider.Client(configContext);
 	}
 
 	@Override
 	protected void initFiles() {
 		super.initFiles();
 
-		minecraftEnvOnlyJar = path("minecraft-%s-only.jar".formatted(environment.type()));
+		minecraftEnvOnlyJar = path("minecraft-%s-only.jar".formatted(type()));
 	}
 
 	@Override
@@ -79,7 +76,7 @@ public final class SingleJarMinecraftProvider extends MinecraftProvider {
 			return;
 		}
 
-		final Path inputJar = environment.getInputJar(this);
+		final Path inputJar = getInputJar(this);
 
 		TinyRemapper remapper = null;
 
@@ -96,7 +93,7 @@ public final class SingleJarMinecraftProvider extends MinecraftProvider {
 			}
 		} catch (Exception e) {
 			Files.deleteIfExists(minecraftEnvOnlyJar);
-			throw new RuntimeException("Failed to process %s only jar".formatted(environment.type()), e);
+			throw new RuntimeException("Failed to process %s only jar".formatted(type()), e);
 		} finally {
 			if (remapper != null) {
 				remapper.finish();
@@ -104,27 +101,19 @@ public final class SingleJarMinecraftProvider extends MinecraftProvider {
 		}
 	}
 
-	@Override
-	protected boolean provideClient() {
-		return environment instanceof Client;
-	}
-
-	@Override
-	protected boolean provideServer() {
-		return environment instanceof Server;
-	}
-
 	public Path getMinecraftEnvOnlyJar() {
 		return minecraftEnvOnlyJar;
 	}
 
-	private interface Environment {
-		SingleJarEnvType type();
+	abstract SingleJarEnvType type();
 
-		Path getInputJar(SingleJarMinecraftProvider provider) throws Exception;
-	}
+	abstract Path getInputJar(SingleJarMinecraftProvider provider) throws Exception;
+
+	public static final class Server extends SingleJarMinecraftProvider {
+		private Server(ConfigContext configContext) {
+			super(configContext);
+		}
 
-	private static final class Server implements Environment {
 		@Override
 		public SingleJarEnvType type() {
 			return SingleJarEnvType.SERVER;
@@ -141,9 +130,23 @@ public final class SingleJarMinecraftProvider extends MinecraftProvider {
 			provider.extractBundledServerJar();
 			return provider.getMinecraftExtractedServerJar().toPath();
 		}
+
+		@Override
+		protected boolean provideServer() {
+			return true;
+		}
+
+		@Override
+		protected boolean provideClient() {
+			return false;
+		}
 	}
 
-	private static final class Client implements Environment {
+	public static final class Client extends SingleJarMinecraftProvider {
+		private Client(ConfigContext configContext) {
+			super(configContext);
+		}
+
 		@Override
 		public SingleJarEnvType type() {
 			return SingleJarEnvType.CLIENT;
@@ -153,5 +156,15 @@ public final class SingleJarMinecraftProvider extends MinecraftProvider {
 		public Path getInputJar(SingleJarMinecraftProvider provider) throws Exception {
 			return provider.getMinecraftClientJar().toPath();
 		}
+
+		@Override
+		protected boolean provideServer() {
+			return false;
+		}
+
+		@Override
+		protected boolean provideClient() {
+			return true;
+		}
 	}
 }

src/main/java/net/fabricmc/loom/extension/LoomGradleExtensionApiImpl.java

@@ -91,7 +91,7 @@ public abstract class LoomGradleExtensionApiImpl implements LoomGradleExtensionA
 	protected final Property<IntermediateMappingsProvider> intermediateMappingsProvider;
 	private final Property<Boolean> runtimeOnlyLog4j;
 	private final Property<Boolean> splitModDependencies;
-	private final Property<MinecraftJarConfiguration> minecraftJarConfiguration;
+	private final Property<MinecraftJarConfiguration<?, ?, ?>> minecraftJarConfiguration;
 	private final Property<Boolean> splitEnvironmentalSourceSet;
 	private final InterfaceInjectionExtensionAPI interfaceInjectionExtension;
 
@@ -144,7 +144,8 @@ public abstract class LoomGradleExtensionApiImpl implements LoomGradleExtensionA
 		this.minecraftJarProcessors = (ListProperty<MinecraftJarProcessor<?>>) (Object) project.getObjects().listProperty(MinecraftJarProcessor.class);
 		this.minecraftJarProcessors.finalizeValueOnRead();
 
-		this.minecraftJarConfiguration = project.getObjects().property(MinecraftJarConfiguration.class).convention(MinecraftJarConfiguration.MERGED);
+		//noinspection unchecked
+		this.minecraftJarConfiguration = project.getObjects().property((Class<MinecraftJarConfiguration<?, ?, ?>>) (Class<?>) MinecraftJarConfiguration.class).convention(MinecraftJarConfiguration.MERGED);
 		this.minecraftJarConfiguration.finalizeValueOnRead();
 
 		this.accessWidener.finalizeValueOnRead();
@@ -341,7 +342,7 @@ public abstract class LoomGradleExtensionApiImpl implements LoomGradleExtensionA
 	}
 
 	@Override
-	public Property<MinecraftJarConfiguration> getMinecraftJarConfiguration() {
+	public Property<MinecraftJarConfiguration<?, ?, ?>> getMinecraftJarConfiguration() {
 		return minecraftJarConfiguration;
 	}
 

src/main/java/net/fabricmc/loom/task/LoomTasks.java

@@ -164,13 +164,18 @@ public abstract class LoomTasks implements Runnable {
 
 		// Remove the client or server run config when not required. Done by name to not remove any possible custom run configs
 		GradleUtils.afterSuccessfulEvaluation(getProject(), () -> {
-			String taskName = switch (extension.getMinecraftJarConfiguration().get()) {
-			case SERVER_ONLY -> "client";
-			case CLIENT_ONLY -> "server";
-			default -> null;
-			};
+			String taskName;
 
-			if (taskName == null) {
+			boolean serverOnly = extension.getMinecraftJarConfiguration().get() == MinecraftJarConfiguration.SERVER_ONLY;
+			boolean clientOnly = extension.getMinecraftJarConfiguration().get() == MinecraftJarConfiguration.CLIENT_ONLY;
+
+			if (serverOnly) {
+				// Server only, remove the client run config
+				taskName = "client";
+			} else if (clientOnly) {
+				// Client only, remove the server run config
+				taskName = "server";
+			} else {
 				return;
 			}