Support latest loom 0.9.0 with api loom extension

Signed-off-by: shedaniel <daniel@shedaniel.me>

build.gradle

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
     id "org.jetbrains.kotlin.jvm" version "1.3.72"
     id "java"
@@ -33,18 +35,38 @@ repositories {
 
 apply plugin: 'java-gradle-plugin'
 
+sourceSets {
+    loom06 {
+        java {
+            compileClasspath += main.compileClasspath
+            runtimeClasspath += main.runtimeClasspath
+            compileClasspath += main.output
+            runtimeClasspath += main.output
+        }
+    }
+    loom09 {
+        java {
+            compileClasspath += main.compileClasspath
+            runtimeClasspath += main.runtimeClasspath
+            compileClasspath += main.output
+            runtimeClasspath += main.output
+        }
+    }
+}
+
 dependencies {
     implementation gradleApi()
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.72"
     implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.72"
     implementation "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.10"
     implementation "dev.architectury:architectury-transformer:$transformer_version"
-    compileOnly "me.shedaniel:forgified-fabric-loom:$loom_version"
+    loom06CompileOnly "me.shedaniel:forgified-fabric-loom:$loom_version_old"
+    loom09CompileOnly "dev.architectury:architectury-loom:$loom_version_new"
     implementation "dev.architectury:tiny-remapper:1.1.0"
     implementation "com.google.code.gson:gson:2.8.5"
 }
 
-compileKotlin {
+tasks.withType(KotlinCompile) {
     kotlinOptions {
         jvmTarget = "1.8"
         freeCompilerArgs = ['-Xjvm-default=compatibility']
@@ -55,6 +77,8 @@ jar {
     manifest {
         attributes 'Implementation-Version': project.version
     }
+
+    from sourceSets.loom06.output + sourceSets.loom09.output
 }
 
 gradlePlugin {

gradle.properties

@@ -1,4 +1,5 @@
 kotlin.code.style=official
-loom_version=0.6.96
+loom_version_old=0.6.96
+loom_version_new=0.9.0.158
 transformer_version=4.0.49
 base_version=3.2

src/loom06/kotlin/dev/architectury/plugin/loom/LoomInterface06.kt

@@ -0,0 +1,64 @@
+package dev.architectury.plugin.loom
+
+import net.fabricmc.loom.LoomGradleExtension
+import net.fabricmc.loom.configuration.ide.RunConfig
+import net.fabricmc.loom.task.RemapJarTask
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
+import org.gradle.jvm.tasks.Jar
+import java.io.File
+import java.nio.file.Path
+import java.util.function.Consumer
+
+class LoomInterface06(private val project: Project) : LoomInterface {
+    private val extension: LoomGradleExtension
+        get() = project.extensions.getByType(LoomGradleExtension::class.java)
+
+    override val allMixinMappings: Collection<File>
+        get() = extension.allMixinMappings
+
+    override val tinyMappingsWithSrg: Path
+        get() {
+            val mappingsProvider = LoomGradleExtension::class.java.getDeclaredMethod("getMappingsProvider").invoke(this)
+            return mappingsProvider.javaClass.getField("tinyMappingsWithSrg").get(mappingsProvider) as Path
+        }
+
+    override val refmapName: String
+        get() = extension.refmapName
+
+    override var generateSrgTiny: Boolean
+        get() = extension.generateSrgTiny
+        set(value) {
+            extension.generateSrgTiny = value
+        }
+
+    override fun settingsPostEdit(action: (config: LoomInterface.LoomRunConfig) -> Unit) {
+        extension.settingsPostEdit.add(Consumer { c -> action(LoomRunConfigImpl(c)) })
+    }
+
+    override fun setIdeConfigGenerated() {
+        extension.runConfigs.forEach { it.isIdeConfigGenerated = true }
+        extension.runConfigs.whenObjectAdded { it.isIdeConfigGenerated = true }
+        extension.addTaskBeforeRun("\$PROJECT_DIR\$/${project.name}:classes")
+    }
+
+    override fun setRemapJarInput(task: Jar, archiveFile: Provider<RegularFile>) {
+        task as RemapJarTask
+        task.input.set(archiveFile)
+    }
+
+    class LoomRunConfigImpl(private val config: RunConfig) : LoomInterface.LoomRunConfig {
+        override var mainClass: String
+            get() = config.mainClass
+            set(value) {
+                config.mainClass = value
+            }
+
+        override var vmArgs: String
+            get() = config.vmArgs
+            set(value) {
+                config.vmArgs = value
+            }
+    }
+}

src/loom09/kotlin/dev/architectury/plugin/loom/LoomInterface09.kt

@@ -0,0 +1,61 @@
+package dev.architectury.plugin.loom
+
+import net.fabricmc.loom.LoomGradleExtension
+import net.fabricmc.loom.configuration.ide.RunConfig
+import net.fabricmc.loom.task.RemapJarTask
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
+import org.gradle.jvm.tasks.Jar
+import java.io.File
+import java.nio.file.Path
+import java.util.function.Consumer
+
+class LoomInterface09(private val project: Project) : LoomInterface {
+    private val extension: LoomGradleExtension
+        get() = LoomGradleExtension.get(project)
+
+    override val allMixinMappings: Collection<File>
+        get() = extension.allMixinMappings
+
+    override val tinyMappingsWithSrg: Path
+        get() = extension.mappingsProvider.tinyMappingsWithSrg
+
+    override val refmapName: String
+        get() = extension.refmapName
+
+    override var generateSrgTiny: Boolean
+        get() = extension.shouldGenerateSrgTiny()
+        set(value) {
+            extension.setGenerateSrgTiny(value)
+        }
+
+    override fun settingsPostEdit(action: (config: LoomInterface.LoomRunConfig) -> Unit) {
+        extension.settingsPostEdit.add(Consumer { c -> action(LoomRunConfigImpl(c)) })
+    }
+
+    override fun setIdeConfigGenerated() {
+        extension.runConfigs.forEach { it.isIdeConfigGenerated = true }
+        extension.runConfigs.whenObjectAdded { it.isIdeConfigGenerated = true }
+        extension.addTaskBeforeRun("\$PROJECT_DIR\$/${project.name}:classes")
+    }
+
+    override fun setRemapJarInput(task: Jar, archiveFile: Provider<RegularFile>) {
+        task as RemapJarTask
+        task.input.set(archiveFile)
+    }
+
+    class LoomRunConfigImpl(private val config: RunConfig) : LoomInterface.LoomRunConfig {
+        override var mainClass: String
+            get() = config.mainClass
+            set(value) {
+                config.mainClass = value
+            }
+
+        override var vmArgs: String
+            get() = config.vmArgs
+            set(value) {
+                config.vmArgs = value
+            }
+    }
+}

src/main/kotlin/dev/architectury/plugin/ArchitecturyPlugin.kt

@@ -2,7 +2,7 @@ package dev.architectury.plugin
 
 import dev.architectury.plugin.transformers.AddRefmapName
 import dev.architectury.transformer.transformers.*
-import net.fabricmc.loom.util.LoggerFilter
+import dev.architectury.transformer.util.LoggerFilter
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.ExtensionAware

src/main/kotlin/dev/architectury/plugin/ArchitecturyPluginExtension.kt

@@ -2,19 +2,18 @@
 
 package dev.architectury.plugin
 
+import dev.architectury.plugin.loom.LoomInterface
 import dev.architectury.transformer.Transformer
 import dev.architectury.transformer.input.OpenedOutputInterface
 import dev.architectury.transformer.transformers.*
-import net.fabricmc.loom.LoomGradleExtension
-import net.fabricmc.loom.task.RemapJarTask
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.gradle.jvm.tasks.Jar
 import java.io.File
 import java.nio.file.Path
 import java.util.*
-import java.util.function.Consumer
 import java.util.jar.JarOutputStream
 import java.util.jar.Manifest
 
@@ -46,6 +45,17 @@ open class ArchitectPluginExtension(val project: Project) {
             it.parentFile.mkdirs()
         }
     }
+    
+    private val loom: LoomInterface by lazy {
+        try {
+            Class.forName("net.fabricmc.loom.api.LoomGradleExtensionAPI")
+            return@lazy Class.forName("dev.architectury.plugin.loom.LoomInterface09").getDeclaredConstructor(Project::class.java)
+                .newInstance(project) as LoomInterface
+        } catch (ignored: ClassNotFoundException) {
+            return@lazy Class.forName("dev.architectury.plugin.loom.LoomInterface06").getDeclaredConstructor(Project::class.java)
+                .newInstance(project) as LoomInterface
+        }
+    }
 
     init {
         project.afterEvaluate {
@@ -74,7 +84,6 @@ open class ArchitectPluginExtension(val project: Project) {
     }
 
     fun properties(platform: String): Map<String, String> {
-        val loom = project.extensions.findByType(LoomGradleExtension::class.java) ?: return mapOf()
         return mutableMapOf(
             BuiltinProperties.MIXIN_MAPPINGS to loom.allMixinMappings.joinToString(File.pathSeparator),
             BuiltinProperties.INJECT_INJECTABLES to injectInjectables.toString(),
@@ -87,12 +96,6 @@ open class ArchitectPluginExtension(val project: Project) {
         )
     }
 
-    private val LoomGradleExtension.tinyMappingsWithSrg: Path
-        get() {
-            val mappingsProvider = LoomGradleExtension::class.java.getDeclaredMethod("getMappingsProvider").invoke(this)
-            return mappingsProvider.javaClass.getField("tinyMappingsWithSrg").get(mappingsProvider) as Path
-        }
-
     private fun getCompileClasspath(): Iterable<File> {
         return project.configurations.findByName("architecturyTransformerClasspath") ?: project.configurations.getByName("compileClasspath")
     }
@@ -126,8 +129,7 @@ open class ArchitectPluginExtension(val project: Project) {
                         }
                     }
 
-                    val loom = project.extensions.getByType(LoomGradleExtension::class.java)
+                    loom.settingsPostEdit { config ->
-                    loom.settingsPostEdit.add(Consumer { config ->
                         val s = config.mainClass
                         config.mainClass = "dev.architectury.transformer.TransformerRuntime"
                         mainClassTransformerFile.writeText(s)
@@ -146,7 +148,7 @@ open class ArchitectPluginExtension(val project: Project) {
                                     .joinToString(", ")
                             )
                         }
-                    })
+                    }
                 }
             }
         }.also {
@@ -186,10 +188,7 @@ open class ArchitectPluginExtension(val project: Project) {
     )
 
     fun platformSetupLoomIde() {
-        val loomExtension = project.extensions.getByType(LoomGradleExtension::class.java)
+        loom.setIdeConfigGenerated()
-        loomExtension.runConfigs.forEach { it.isIdeConfigGenerated = true }
-        loomExtension.runConfigs.whenObjectAdded { it.isIdeConfigGenerated = true }
-        loomExtension.addTaskBeforeRun("\$PROJECT_DIR\$/${project.name}:classes")
     }
 
     fun common(forgeEnabled: Boolean) {
@@ -248,10 +247,10 @@ open class ArchitectPluginExtension(val project: Project) {
         } as TransformingTask
 
         val remapJarTask = project.tasks.getByName("remapJar") {
-            it as RemapJarTask
+            it as Jar
 
             it.archiveClassifier.set("")
-            it.input.set(jarTask.archiveFile)
+            loom.setRemapJarInput(it, jarTask.archiveFile)
             it.dependsOn(jarTask)
             it.doLast { _ ->
                 if (addCommonMarker) {
@@ -266,7 +265,7 @@ open class ArchitectPluginExtension(val project: Project) {
                     }
                 }
             }
-        } as RemapJarTask
+        } as Jar
 
         if (settings.forgeEnabled) {
             val transformProductionForgeTask = project.tasks.getByName("transformProductionForge") {
@@ -282,7 +281,7 @@ open class ArchitectPluginExtension(val project: Project) {
 
             transformProductionForgeTask.archiveFile.get().asFile.takeUnless { it.exists() }?.createEmptyJar()
 
-            project.extensions.getByType(LoomGradleExtension::class.java).generateSrgTiny = true
+            loom.generateSrgTiny = true
         }
 
         transformProductionFabricTask.archiveFile.get().asFile.takeUnless { it.exists() }?.createEmptyJar()

src/main/kotlin/dev/architectury/plugin/loom/LoomInterface.kt

@@ -0,0 +1,23 @@
+package dev.architectury.plugin.loom
+
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
+import org.gradle.jvm.tasks.Jar
+import java.io.File
+import java.nio.file.Path
+
+interface LoomInterface {
+    val allMixinMappings: Collection<File>
+    val tinyMappingsWithSrg: Path
+    val refmapName: String
+    var generateSrgTiny: Boolean
+
+    fun settingsPostEdit(action: (config: LoomRunConfig) -> Unit)
+    fun setIdeConfigGenerated()
+    fun setRemapJarInput(task: Jar, archiveFile: Provider<RegularFile>)
+
+    interface LoomRunConfig {
+        var mainClass: String
+        var vmArgs: String
+    }
+}

src/main/kotlin/dev/architectury/plugin/transformers/AddRefmapName.kt

@@ -1,5 +1,6 @@
 package dev.architectury.plugin.transformers
 
+import com.google.gson.GsonBuilder
 import com.google.gson.JsonObject
 import dev.architectury.transformer.Transform
 import dev.architectury.transformer.input.OutputInterface
@@ -7,10 +8,10 @@ import dev.architectury.transformer.transformers.BuiltinProperties
 import dev.architectury.transformer.transformers.base.AssetEditTransformer
 import dev.architectury.transformer.transformers.base.edit.TransformerContext
 import dev.architectury.transformer.util.Logger
-import net.fabricmc.loom.LoomGradlePlugin
 import java.io.ByteArrayInputStream
 
 class AddRefmapName : AssetEditTransformer {
+    val gson = GsonBuilder().setPrettyPrinting().create()
     override fun doEdit(context: TransformerContext, output: OutputInterface) {
         val mixins = mutableSetOf<String>()
         output.handle { path, bytes ->
@@ -20,8 +21,7 @@ class AddRefmapName : AssetEditTransformer {
             ) {
                 Logger.debug("Checking whether $path is a mixin config.")
                 try {
-                    val json =
+                    val json = gson.fromJson(ByteArrayInputStream(bytes).reader(), JsonObject::class.java)
-                        LoomGradlePlugin.GSON.fromJson(ByteArrayInputStream(bytes).reader(), JsonObject::class.java)
                     if (json != null) {
                         val hasMixins = json.has("mixins") && json["mixins"].isJsonArray
                         val hasClient = json.has("client") && json["client"].isJsonArray
@@ -42,7 +42,7 @@ class AddRefmapName : AssetEditTransformer {
         val refmap = System.getProperty(BuiltinProperties.REFMAP_NAME)
         mixins.forEach { path ->
             output.modifyFile(path) {
-                val json: JsonObject = LoomGradlePlugin.GSON.fromJson<JsonObject>(
+                val json: JsonObject = gson.fromJson<JsonObject>(
                     ByteArrayInputStream(it).reader(),
                     JsonObject::class.java
                 )
@@ -52,7 +52,7 @@ class AddRefmapName : AssetEditTransformer {
                     json.addProperty("refmap", refmap)
                 }
 
-                LoomGradlePlugin.GSON.toJson(json).toByteArray()
+                gson.toJson(json).toByteArray()
             }
         }
     }