finally get everything to compile

Author: Wyvest

buildSrc/build.gradle.kts

@@ -5,4 +5,11 @@ plugins {
 repositories {
     mavenCentral()
     maven("https://repo.polyfrost.org/releases")
+}
+
+dependencies {
+    // Mirroring https://github.com/EssentialGG/essential-gradle-toolkit/blob/master/build.gradle.kts
+    implementation("org.ow2.asm:asm-commons:9.6")
+    implementation("com.google.guava:guava:33.0.0-jre")
+    implementation("org.jetbrains.kotlinx:kotlinx-metadata-jvm:0.9.0")
 }

buildSrc/src/main/kotlin/gg/essential/gradle/util/RelocationTransform.kt

@@ -0,0 +1,180 @@
+/*
+ * This file is part of essential-gradle-toolkit, licensed under the GPL-3.0.
+ *
+ * Copyright (C) 2025 EssentialGG and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package gg.essential.gradle.util
+
+import gg.essential.gradle.util.relocate.KotlinMetadataRemappingClassVisitor
+import org.gradle.api.Project
+import org.gradle.api.artifacts.transform.InputArtifact
+import org.gradle.api.artifacts.transform.TransformAction
+import org.gradle.api.artifacts.transform.TransformOutputs
+import org.gradle.api.artifacts.transform.TransformParameters
+import org.gradle.api.attributes.Attribute
+import org.gradle.api.file.FileSystemLocation
+import org.gradle.api.provider.Provider
+import org.gradle.api.provider.SetProperty
+import org.gradle.api.tasks.Input
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassWriter
+import org.objectweb.asm.commons.ClassRemapper
+import org.objectweb.asm.commons.Remapper
+import java.io.Closeable
+import java.io.File
+import java.io.Serializable
+import java.util.jar.JarInputStream
+import java.util.jar.JarOutputStream
+import java.util.zip.ZipEntry
+
+/**
+ * Relocates packages and single files in an artifact.
+ *
+ * If a package is relocated, the folder containing it will be relocated as a whole.
+ * File renames take priority over package relocations.
+ *
+ * The packages do not have to be part of the artifact, e.g. a completely valid use case would be relocating guava
+ * packages in an artifact using guava (for actual use, you'd of course also have to relocate the guava artifact itself,
+ * otherwise the classes referred to after the relocation will not exist). This can be used together with [prebundle] to
+ * create fat jars which apply at dev time (to e.g. use two different versions of the same library).
+ *
+ * To simplify setup, use [registerRelocationAttribute].
+ */
+abstract class RelocationTransform : TransformAction<RelocationTransform.Parameters> {
+    interface Parameters : TransformParameters {
+        @get:Input
+        val relocations: SetProperty<Relocation>
+
+        @get:Input
+        val remapStringsIn: SetProperty<String>
+
+        @get:Input
+        val renames: SetProperty<Rename>
+
+        fun relocate(sourcePackage: String, targetPackage: String) =
+            relocations.add(Relocation(sourcePackage, targetPackage))
+
+        fun remapStringsIn(cls: String) =
+            remapStringsIn.add(cls)
+
+        fun rename(sourceFile: String, targetFile: String) =
+            renames.add(Rename(sourceFile, targetFile))
+    }
+
+    data class Relocation(val sourcePackage: String, val targetPackage: String) : Serializable
+    data class Rename(val sourceFile: String, val targetFile: String) : Serializable
+
+    @get:InputArtifact
+    abstract val input: Provider<FileSystemLocation>
+
+    override fun transform(outputs: TransformOutputs) {
+        val fileMap = parameters.renames.get().associate { it.sourceFile to it.targetFile }
+
+        val jvmPackageMap = parameters.relocations.get().associate {
+            it.sourcePackage.replace('.', '/') + '/' to it.targetPackage.replace('.', '/') + '/'
+        }
+        val javaPackageMap = jvmPackageMap.map { (source, target) ->
+            source.replace('/', '.') to target.replace('/', '.')
+        }.toMap()
+        val absoluteFolderMap = jvmPackageMap.map { (source, target) ->
+            "/$source" to "/$target"
+        }.toMap()
+
+        val remapStringsInFiles = parameters.remapStringsIn.get().map {
+            it.replace('.', '/') + ".class"
+        }
+
+        open class ClassPrefixRemapper : Remapper() {
+            override fun map(typeName: String): String = map(jvmPackageMap, typeName)
+
+            protected fun map(mappings: Map<String, String>, typeName: String): String {
+                for ((sourcePackage, targetPackage) in mappings) {
+                    if (typeName.startsWith(sourcePackage)) {
+                        return targetPackage + typeName.substring(sourcePackage.length)
+                    }
+                }
+                return typeName
+            }
+        }
+        val baseRemapper = ClassPrefixRemapper()
+
+        class ClassPrefixAndStringsRemapper : ClassPrefixRemapper() {
+            override fun mapValue(value: Any?): Any {
+                if (value is String) {
+                    return map(absoluteFolderMap, map(jvmPackageMap, map(javaPackageMap, value)))
+                }
+                return super.mapValue(value)
+            }
+        }
+        val stringRemapper = ClassPrefixAndStringsRemapper()
+
+        val input = input.get().asFile
+        val output = outputs.file(input.nameWithoutExtension + "-relocated.jar")
+        (input to output).useInOut { jarIn, jarOut ->
+            while (true) {
+                val entry = jarIn.nextJarEntry ?: break
+                val originalBytes = jarIn.readBytes()
+                val remapper = if (entry.name in remapStringsInFiles) stringRemapper else baseRemapper
+
+                val modifiedBytes = if (entry.name.endsWith(".class")) {
+                    val reader = ClassReader(originalBytes)
+                    // Not copying the constant pool cause that leaves references to the old classes which, while any
+                    // lazy tool will never end up resolving them, do get resolved by e.g. proguard.
+                    val writer = ClassWriter(0)
+                    reader.accept(ClassRemapper(KotlinMetadataRemappingClassVisitor(remapper, writer), remapper), 0)
+                    writer.toByteArray()
+                } else if (entry.name.startsWith("META-INF/services/")) {
+                    String(originalBytes).replace('.', '/').lines().map(remapper::map).joinToString("\n").replace('/','.').encodeToByteArray()
+                } else {
+                    originalBytes
+                }
+
+                jarOut.putNextEntry(ZipEntry(fileMap[entry.name] ?: remapper.map(entry.name)))
+                jarOut.write(modifiedBytes)
+                jarOut.closeEntry()
+            }
+        }
+    }
+
+    private inline fun Pair<File, File>.useInOut(block: (jarIn: JarInputStream, jarOut: JarOutputStream) -> Unit) =
+        first.inputStream().nestedUse(::JarInputStream) { jarIn ->
+            second.outputStream().nestedUse(::JarOutputStream) { jarOut ->
+                block(jarIn, jarOut)
+            }
+        }
+
+    private inline fun <T: Closeable, U: Closeable> T.nestedUse(nest: (T) -> U, block: (U) -> Unit) =
+        use { nest(it).use(block) }
+
+    companion object {
+        fun Project.registerRelocationAttribute(name: String, configure: Parameters.() -> Unit): Attribute<Boolean> {
+            val attribute = Attribute.of(name, Boolean::class.javaObjectType)
+
+            dependencies.registerTransform(RelocationTransform::class.java) {
+                from.attribute(attribute, false)
+                to.attribute(attribute, true)
+                parameters(configure)
+            }
+
+            dependencies.artifactTypes.all {
+                attributes.attribute(attribute, false)
+            }
+
+            return attribute
+        }
+    }
+}

buildSrc/src/main/kotlin/gg/essential/gradle/util/prebundle.kt

@@ -0,0 +1,126 @@
+/*
+ * This file is part of essential-gradle-toolkit, licensed under the GPL-3.0.
+ *
+ * Copyright (C) 2025 EssentialGG and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package gg.essential.gradle.util
+
+import com.google.common.base.Stopwatch
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.FileCollection
+import org.gradle.api.logging.Logger
+import org.gradle.api.tasks.util.PatternFilterable
+import org.gradle.api.tasks.util.PatternSet
+import java.io.File
+import java.io.OutputStream
+import java.security.MessageDigest
+import java.util.jar.JarOutputStream
+import java.util.zip.ZipEntry
+
+/**
+ * Bundles all dependencies from the given [configuration] into a single, dedicated jar and returns a file collection
+ * containing that jar.
+ * Primarily for use in dependency declarations, so fat jars of certain dependencies (with potentially relocated
+ * transitive dependencies) can be created and then depended upon as usual. Compared to simply relocating in a later
+ * shadow task, this has the advantage that IDEA will see the relocated dependency rather than the original, which e.g.
+ * allows one to use two different versions of the same dependency at dev time.
+ *
+ * If [jijName] is provided, the fat jar will additionally be wrapped in an outer jar, such that the classes are not
+ * actually visible if the file collection is put onto the classpath. This may be useful when the jar is never meant to
+ * directly be on the classpath but rather only in a dedicated class loader or JVM.
+ * The given [jijName] determines the path+name of the inner jar within the outer jar.
+ */
+fun Project.prebundle(configuration: Configuration, jijName: String? = null, configure: PatternFilterable.() -> Unit = {}): FileCollection {
+    val output = projectDir
+        .resolve(".gradle")
+        .resolve("prebundled-jars")
+        .resolve("${configuration.name}.jar")
+
+    val filter = PatternSet().apply(configure)
+
+    // Delay resolving the configuration in case it is not yet fully configured
+    afterEvaluate {
+        bundle(configuration, filter, jijName, output, logger)
+    }
+
+    return files(output)
+}
+
+private fun Project.bundle(configuration: Configuration, filter: PatternSet, jijName: String?, output: File, logger: Logger) {
+    output.parentFile.mkdirs()
+
+    val hash = configuration.computeHash().apply {
+        update(filter.hashCode().toBigInteger().toByteArray())
+        update(jijName?.toByteArray() ?: byteArrayOf())
+        update(byteArrayOf(0, 0, 0, 2)) // code version, incremented with each semantic change
+    }.digest()
+    val hashFile = output.resolveSibling(output.name + ".md5")
+    if (hashFile.exists() && hashFile.readBytes().contentEquals(hash) && output.exists()) {
+        return
+    }
+    hashFile.delete()
+    output.delete()
+
+    val stopwatch = Stopwatch.createStarted()
+    logger.lifecycle(":preparing ${configuration.name} jar")
+
+    val spec = filter.asSpec
+    val visitedEntries = mutableSetOf<String>()
+    output.outputStream().use { fileOut_ ->
+        var fileOut: OutputStream = fileOut_
+        if (jijName != null) {
+            fileOut = JarOutputStream(fileOut).apply {
+                putNextEntry(ZipEntry(jijName))
+            }
+        }
+        JarOutputStream(fileOut).use { jarOut ->
+            for (sourceFile in configuration.files) {
+                project.zipTree(sourceFile).visit {
+                    if (!visitedEntries.add(path)) return@visit
+                    if (!spec.isSatisfiedBy(this)) return@visit
+
+                    jarOut.putNextEntry(ZipEntry(if (isDirectory) "$path/" else path).apply { time = CONSTANT_TIME_FOR_ZIP_ENTRIES })
+                    open().use { copyTo(jarOut) }
+                    jarOut.closeEntry()
+                }
+            }
+        }
+    }
+    hashFile.writeBytes(hash)
+
+    logger.lifecycle(":prepared ${configuration.name} jar in $stopwatch")
+}
+
+private fun Configuration.computeHash(): MessageDigest = files
+    .sortedBy { it.name }
+    .fold(MessageDigest.getInstance("MD5")) { digest, file ->
+        // if the file path already contains a hash, that's good enough, otherwise we need to read its contents
+        digest.update(file.findHashInPath()?.toByteArray() ?: file.readBytes())
+        digest
+    }
+
+private fun File.findHashInPath(): String? {
+    val path = absolutePath.replace('\\', '/')
+    if ("/caches/modules-2/files-2.1/" in path && parentFile.name.length == 40) {
+        return parentFile.name
+    }
+    if ("/caches/transforms-3/" in path && parentFile.parentFile.name.length == 32) {
+        return parentFile.parentFile.name
+    }
+    return null
+}