Be lazier in configuring Forge runs

.github/workflows/main-ci.yml

@@ -28,10 +28,13 @@ jobs:
         echo "org.gradle.daemon=false" >> ~/.gradle/gradle.properties
 
     - name: Build with Gradle
-      run: |
-        ./gradlew assemble || ./gradlew assemble
-        ./gradlew downloadAssets || ./gradlew downloadAssets
-        ./gradlew build
+      run: ./gradlew assemble || ./gradlew assemble
+
+    - name: Download assets for game tests
+      run: ./gradlew downloadAssets || ./gradlew downloadAssets
+
+    - name: Run tests and linters
+      run: ./gradlew build
 
     - name: Run client tests
       run: ./gradlew runGametestClient # Not checkClient, as no point running rendering tests.

buildSrc/src/main/kotlin/cc/tweaked/gradle/ForgeExtensions.kt

@@ -17,7 +17,7 @@ import java.nio.file.Files
 fun JavaExec.setRunConfig(config: RunConfig) {
     dependsOn("prepareRuns")
     setRunConfigInternal(project, this, config)
-    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath().parent) }
+    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath()) }
 
     javaLauncher.set(
         project.extensions.getByType(JavaToolchainService::class.java)

buildSrc/src/main/kotlin/net/minecraftforge/gradle/common/util/runs/RunConfigSetup.kt

@@ -6,8 +6,12 @@ package net.minecraftforge.gradle.common.util.runs
 
 import net.minecraftforge.gradle.common.util.RunConfig
 import org.gradle.api.Project
+import org.gradle.process.CommandLineArgumentProvider
 import org.gradle.process.JavaExecSpec
 import java.io.File
+import java.util.function.Supplier
+import java.util.stream.Collectors
+import java.util.stream.Stream
 
 /**
  * Set up a [JavaExecSpec] to execute a [RunConfig].
@@ -18,27 +22,48 @@ import java.io.File
  * Unfortunately most of the functionality we need is package-private, and so we have to put our code into the package.
  */
 internal fun setRunConfigInternal(project: Project, spec: JavaExecSpec, config: RunConfig) {
-    val originalTask = project.tasks.named(config.taskName, MinecraftRunTask::class.java).get()
-
     spec.workingDir = File(config.workingDirectory)
 
     spec.mainClass.set(config.main)
     for (source in config.allSources) spec.classpath(source.runtimeClasspath)
 
-    val lazyTokens = RunConfigGenerator.configureTokensLazy(
-        project, config,
-        RunConfigGenerator.mapModClassesToGradle(project, config),
-        originalTask.minecraftArtifacts.files,
-        originalTask.runtimeClasspathArtifacts.files,
+    val originalTask = project.tasks.named(config.taskName, MinecraftRunTask::class.java)
+
+    // Add argument and JVM argument via providers, to be as lazy as possible with fetching artifacts.
+    fun lazyTokens(): MutableMap<String, Supplier<String>> {
+        return RunConfigGenerator.configureTokensLazy(
+            project, config, RunConfigGenerator.mapModClassesToGradle(project, config),
+            originalTask.get().minecraftArtifacts.files,
+            originalTask.get().runtimeClasspathArtifacts.files,
+        )
+    }
+    spec.argumentProviders.add(
+        CommandLineArgumentProvider {
+            RunConfigGenerator.getArgsStream(config, lazyTokens(), false).toList()
+        },
+    )
+    spec.jvmArgumentProviders.add(
+        CommandLineArgumentProvider {
+            val lazyTokens = lazyTokens()
+            (if (config.isClient) config.jvmArgs + originalTask.get().additionalClientArgs.get() else config.jvmArgs).map { config.replace(lazyTokens, it) } +
+                config.properties.map { (k, v) -> "-D${k}=${config.replace(lazyTokens, v)}" }
+        },
     )
 
-    spec.args(RunConfigGenerator.getArgsStream(config, lazyTokens, false).toList())
-
-    spec.jvmArgs(
-        (if (config.isClient) config.jvmArgs + originalTask.additionalClientArgs.get() else config.jvmArgs)
-            .map { config.replace(lazyTokens, it) },
+    // We can't configure environment variables lazily, so we do these now with a more minimal lazyTokens set.
+    val lazyTokens = mutableMapOf<String, Supplier<String>>()
+    for ((k, v) in config.tokens) lazyTokens[k] = Supplier<String> { v }
+    for ((k, v) in config.lazyTokens) lazyTokens[k] = v
+    lazyTokens.compute(
+        "source_roots",
+        { key: String, sourceRoots: Supplier<String>? ->
+            Supplier<String> {
+                val modClasses = RunConfigGenerator.mapModClassesToGradle(project, config)
+                (if (sourceRoots != null) Stream.concat<String>(
+                    sourceRoots.get().split(File.pathSeparator).stream(), modClasses,
+                ) else modClasses).distinct().collect(Collectors.joining(File.pathSeparator))
+            }
+        },
     )
-
     for ((key, value) in config.environment) spec.environment(key, config.replace(lazyTokens, value))
-    for ((key, value) in config.properties) spec.systemProperty(key, config.replace(lazyTokens, value))
 }