add small enigma plugin to suggest name automatically

Lulu13022002 · Lulu13022002 · commit b8f9dc8d07c3 · 2025-10-16T19:30:00.000+02:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -11,6 +11,7 @@ import org.parchmentmc.validation.MethodStandardsValidatorV2
 
 plugins {
     java
+    `kotlin-dsl`
     `maven-publish`
     id("org.parchmentmc.compass")
 }
@@ -36,7 +37,11 @@ repositories {
     }
 }
 
-val enigma by configurations.registering
+val enigmaPlugin by sourceSets.creating
+
+val enigma by configurations.registering {
+    extendsFrom(configurations.getByName(enigmaPlugin.implementationConfigurationName))
+}
 val remapper by configurations.registering
 val minecraft by configurations.registering
 
@@ -62,6 +67,11 @@ dependencies {
     enigma("cuchaz:enigma-swing:2.5.2")
     enigma("org.vineflower:vineflower:1.11.1") // sync with mache
 
+    enigma(enigmaPlugin.output)
+
+    enigmaPlugin.implementationConfigurationName(gradleKotlinDsl())
+    enigmaPlugin.implementationConfigurationName("cuchaz:enigma:2.5.2")
+
     // ParchmentJAM, JAMMER integration for migrating mapping data
     jammer("org.parchmentmc.jam:jam-parchment:0.1.0")
 
@@ -118,6 +128,7 @@ tasks.register<EnigmaRunner>("enigma") {
     mainClass = "cuchaz.enigma.gui.Main"
     inputJar = remapJar.flatMap { it.outputJar }
     mappings = project.compass.productionData
+    profile = project.layout.projectDirectory.file("enigma_profile.json")
 }
 
 tasks.withType<ValidateData>().configureEach {
diff --git a/buildSrc/src/main/kotlin/org/parchmentmc/BlackstonePlugin.kt b/buildSrc/src/main/kotlin/org/parchmentmc/BlackstonePlugin.kt
@@ -30,13 +30,13 @@ class BlackstonePlugin : Plugin<Project> {
             dependencies.add(target.dependencyFactory.create(cfc))
         }
         // Fix faulty task wiring
-        target.tasks.withType(SanitizeData::class.java).configureEach {
+        target.tasks.withType<SanitizeData>().configureEach {
             inputs.files(blackstoneConfig)
         }
-        target.tasks.withType(ValidateData::class.java).configureEach {
+        target.tasks.withType<ValidateData>().configureEach {
             inputs.files(blackstoneConfig)
         }
-        target.tasks.withType(GenerateExport::class.java).configureEach {
+        target.tasks.withType<GenerateExport>().configureEach {
             inputs.files(blackstoneConfig)
         }
 
@@ -64,7 +64,7 @@ class BlackstonePlugin : Plugin<Project> {
         val downloadVersionMeta by target.tasks.registering(DownloadVersionMetadata::class) {
             group = PLUGIN_TASK_GROUP
             input = downloadLauncherMeta.flatMap { it.output }
-            output = target.layout.buildDirectory.file(name + ".json") // Remove subdir to fix caching
+            output = target.layout.buildDirectory.file("$name.json") // Remove subdir to fix caching
             outputs.cacheIf { true }
         }
 
diff --git a/buildSrc/src/main/kotlin/org/parchmentmc/tasks/EnigmaRunner.kt b/buildSrc/src/main/kotlin/org/parchmentmc/tasks/EnigmaRunner.kt
@@ -20,11 +20,15 @@ abstract class EnigmaArgumentProvider : CommandLineArgumentProvider {
     @get:InputDirectory
     abstract val mappings: DirectoryProperty
 
+    @get:InputFile
+    abstract val profile: RegularFileProperty
+
     override fun asArguments(): Iterable<String> {
         val args = mutableListOf("--no-edit-all", "--edit-parameters", "--edit-javadocs", "--single-class-tree")
 
         args.add("--jar=${inputJar.get().asFile.absolutePath}")
         args.add("--mappings=${mappings.get().asFile.absolutePath}")
+        args.add("--profile=${profile.get().asFile.absolutePath}")
 
         return args.toList()
     }
@@ -41,10 +45,14 @@ abstract class EnigmaRunner @Inject constructor(
     @get:InputDirectory
     abstract val mappings: DirectoryProperty
 
+    @get:InputFile
+    abstract val profile: RegularFileProperty
+
     init {
         val provider = objects.newInstance<EnigmaArgumentProvider>()
         provider.inputJar.set(inputJar)
         provider.mappings.set(mappings)
+        provider.profile.set(profile)
         argumentProviders.add(provider)
 
         // Enigma runs on Java 17. If the Gradle JVM supports Java 17, then we are fine
diff --git a/buildSrc/src/main/kotlin/org/parchmentmc/validation/MemberExistenceValidatorV2.kt b/buildSrc/src/main/kotlin/org/parchmentmc/validation/MemberExistenceValidatorV2.kt
@@ -14,7 +14,7 @@ class MemberExistenceValidatorV2 : MemberExistenceValidator() {
         super.visitField(classData, fieldData, classMetadata, fieldMetadata)
         if (fieldMetadata != null) {
             if (fieldMetadata.descriptor.mojangName.orElseThrow() != fieldData.descriptor) {
-                error("Field descriptor does not match according to metadata");
+                error("Field descriptor does not match according to metadata.")
             }
         } else {
             // Fields existence are already checked in MemberExistenceValidator
diff --git a/buildSrc/src/main/kotlin/org/parchmentmc/validation/MethodStandardsValidatorV2.kt b/buildSrc/src/main/kotlin/org/parchmentmc/validation/MethodStandardsValidatorV2.kt
@@ -7,11 +7,13 @@ import org.parchmentmc.feather.metadata.MethodMetadata
 
 class MethodStandardsValidatorV2 : MethodStandardsValidator() {
 
+    data class ParamInfo(val lvtIndex: Byte, val name: String)
+
     private val standardMethods: Map<String, Array<ParamInfo>> = mapOf(
         "equals (Ljava/lang/Object;)Z" to arrayOf(
             ParamInfo(1, "other")
         ),
-        "compareTo (<owner>)I" to arrayOf(
+        "compareTo (<owner>)I" to arrayOf( // doesn't work well for FriendlyByteBuf and LinkFSPath
             ParamInfo(1, "other")
         )
     )
@@ -22,18 +24,14 @@ class MethodStandardsValidatorV2 : MethodStandardsValidator() {
     ): Boolean {
         val standardParams = standardMethods[methodData.name + " " + methodData.descriptor.replace("L${classData.name};", "<owner>")]
         if (standardParams != null) {
-            methodData.parameters.forEachIndexed { index, paramData ->
-                val standardParam = standardParams[index]
+            methodData.parameters.zip(standardParams) { paramData, standardParam ->
                 if (paramData.index == standardParam.lvtIndex && paramData.name != standardParam.name) {
-                    error("Parameter #${paramData.index} doesn't match the expected name: ${standardParam.name}")
+                    error("Parameter #${paramData.index} doesn't match the expected name: ${standardParam.name}.")
                     return false
                 }
             }
-
         }
 
         return super.visitMethod(classData, methodData, classMetadata, methodMetadata)
     }
-
-    data class ParamInfo(val lvtIndex: Byte, val name: String)
 }
diff --git a/enigma_profile.json b/enigma_profile.json
@@ -0,0 +1,10 @@
+{
+  "services": {
+    "name_proposal": {
+      "id": "paper:name_proposal"
+    },
+    "jar_indexer": {
+      "id": "paper:jar_indexer"
+    }
+  }
+}
diff --git a/src/enigmaPlugin/kotlin/org/parchmentmc/enigma/EnigmaNameProposalService.kt b/src/enigmaPlugin/kotlin/org/parchmentmc/enigma/EnigmaNameProposalService.kt
@@ -0,0 +1,137 @@
+package org.parchmentmc.enigma
+
+import cuchaz.enigma.analysis.index.JarIndex
+import cuchaz.enigma.api.service.JarIndexerService
+import cuchaz.enigma.api.service.NameProposalService
+import cuchaz.enigma.classprovider.ClassProvider
+import cuchaz.enigma.translation.mapping.EntryRemapper
+import cuchaz.enigma.translation.representation.MethodDescriptor
+import cuchaz.enigma.translation.representation.entry.ClassEntry
+import cuchaz.enigma.translation.representation.entry.Entry
+import cuchaz.enigma.translation.representation.entry.LocalVariableEntry
+import cuchaz.enigma.translation.representation.entry.MethodEntry
+import java.util.*
+import javax.lang.model.SourceVersion
+
+class EnigmaNameProposalService() : JarIndexerService, NameProposalService {
+
+    lateinit var indexer: JarIndex
+
+    val suggestions = mapOf(
+        // client
+        "Lcom/mojang/blaze3d/vertex/VertexConsumer;" to "consumer",
+        "Lnet/minecraft/client/renderer/MultiBufferSource;" to "bufferSource",
+        "Lnet/minecraft/client/renderer/SubmitNodeCollector;" to "nodeCollector",
+        "Lnet/minecraft/client/renderer/SubmitNodeCollection;" to "nodeCollection",
+        "Lnet/minecraft/client/renderer/SubmitNodeStorage;" to "nodeStorage",
+        "Lnet/minecraft/client/gui/ActiveTextCollector;" to "textCollector",
+        // server
+        "Lcom/mojang/authlib/GameProfile;" to "profile",
+
+        "Lnet/minecraft/world/item/ItemStack;" to "stack",
+        "Lnet/minecraft/world/level/ItemLike;" to "item",
+        "Lnet/minecraft/world/level/block/state/BlockState;" to "state",
+        "Lnet/minecraft/core/BlockPos;" to "pos",
+        $$"Lnet/minecraft/core/BlockPos$MutableBlockPos;" to "pos",
+        "Lnet/minecraft/resources/ResourceLocation;" to "location",
+
+        "Lnet/minecraft/server/level/WorldGenRegion;" to "region",
+        "Lnet/minecraft/server/level/ServerLevel;" to "level",
+        "Lnet/minecraft/world/level/LevelReader;" to "level",
+        "Lnet/minecraft/world/level/LevelHeightAccessor;" to "level",
+        "Lnet/minecraft/world/level/BlockGetter;" to "level",
+        // "Lnet/minecraft/world/level/CollisionGetter;" to "level",
+
+        "Lnet/minecraft/server/level/ServerPlayer;" to "player",
+        "Lnet/minecraft/world/entity/animal/nautilus/AbstractNautilus;" to "nautilus",
+        "Lnet/minecraft/world/entity/projectile/AbstractArrow;" to "arrow",
+        "Lnet/minecraft/world/entity/monster/AbstractSkeleton;" to "skeleton",
+        "Lnet/minecraft/world/entity/animal/horse/AbstractHorse;" to "horse",
+        "Lnet/minecraft/world/entity/HumanoidArm;" to "arm",
+        "Lnet/minecraft/util/debug/DebugValueAccess;" to "valueAccess",
+    )
+
+    override fun acceptJar(scope: Set<String>, classProvider: ClassProvider, jarIndex: JarIndex) {
+        indexer = jarIndex
+    }
+
+    private fun paramCanConflict(startIndex: Int, methodDesc: MethodDescriptor, entry: ClassEntry): Boolean {
+        var alreadyFound = false
+        for (index in startIndex..methodDesc.argumentDescs.lastIndex) {
+            val desc = methodDesc.argumentDescs[index]
+            if (desc.containsType() && desc.typeEntry.equals(entry)) {
+                if (alreadyFound) {
+                    return true
+                }
+                alreadyFound = true
+            }
+        }
+        return false
+    }
+
+    private fun isEnumConstructor(method: MethodEntry): Boolean {
+        if (!method.isConstructor) {
+            return false
+        }
+
+        return indexer.entryIndex.getClassAccess(method.parent)?.isEnum ?: false
+    }
+
+    override fun proposeName(obfEntry: Entry<*>, remapper: EntryRemapper): Optional<String> {
+        if (obfEntry is LocalVariableEntry && obfEntry.isArgument) {
+            val parent = obfEntry.parent
+            if (parent != null && !parent.name.startsWith("lambda$")) { // todo handle lambda
+                val isStatic = indexer.entryIndex.getMethodAccess(parent)?.isStatic ?: false
+
+                var offsetLvtIndex = 0
+                if (!isStatic) {
+                    offsetLvtIndex++ // (this, ...)
+                }
+                var descStartIndex = 0 // ignore implicit argument in descriptors for conflict check
+                if (isEnumConstructor(parent)) {
+                    descStartIndex += 2 // (name, ordinal, ...)
+                }
+
+                val paramIndex = fromLvtToParamIndex(obfEntry.index, parent, offsetLvtIndex)
+                val desc = parent.desc.argumentDescs[paramIndex]
+                if (desc.isPrimitive) {
+                    return Optional.empty()
+                }
+
+                val strDesc = desc.toString()
+                var name = suggestions[strDesc] ?: strDesc.substringAfterLast('/').substringAfterLast('$').dropLast(1).replaceFirstChar { it.lowercase() } // relevant type
+                if (paramCanConflict(descStartIndex, parent.desc, desc.typeEntry)) {
+                    name += (paramIndex + 1)
+                }
+                if (SourceVersion.isKeyword(name)) {
+                    name += '_'
+                }
+
+                return Optional.of(name)
+            }
+        }
+        return Optional.empty()
+    }
+
+    /*
+     * Transform the given LVT index into a parameter index.
+     */
+    fun fromLvtToParamIndex(lvtIndex: Int, method: MethodEntry, offsetLvtIndex: Int): Int {
+        var currentParamIndex = 0
+        var currentLvtIndex = offsetLvtIndex
+
+        for (param in method.desc.argumentDescs) {
+            if (currentLvtIndex == lvtIndex) {
+                return currentParamIndex
+            }
+
+            currentParamIndex++
+            currentLvtIndex++
+
+            if (param.toString() == "J" || param.toString() == "D") { // long / double take two slots
+                currentLvtIndex++
+            }
+        }
+        return -1
+    }
+}
diff --git a/src/enigmaPlugin/kotlin/org/parchmentmc/enigma/NameProposalServiceEnigmaPlugin.kt b/src/enigmaPlugin/kotlin/org/parchmentmc/enigma/NameProposalServiceEnigmaPlugin.kt
@@ -0,0 +1,15 @@
+package org.parchmentmc.enigma
+
+import cuchaz.enigma.api.EnigmaPlugin
+import cuchaz.enigma.api.EnigmaPluginContext
+import cuchaz.enigma.api.service.JarIndexerService
+import cuchaz.enigma.api.service.NameProposalService
+
+class NameProposalServiceEnigmaPlugin : EnigmaPlugin {
+
+    override fun init(ctx: EnigmaPluginContext) {
+        val service = EnigmaNameProposalService()
+        ctx.registerService("paper:name_proposal", NameProposalService.TYPE) { _ -> service }
+        ctx.registerService("paper:jar_indexer", JarIndexerService.TYPE) { _ -> service }
+    }
+}
diff --git a/src/enigmaPlugin/resources/META-INF/services/cuchaz.enigma.api.EnigmaPlugin b/src/enigmaPlugin/resources/META-INF/services/cuchaz.enigma.api.EnigmaPlugin
@@ -0,0 +1 @@
+org.parchmentmc.enigma.NameProposalServiceEnigmaPlugin

Original file line number	Diff line number	Diff line change
`@@ -30,13 +30,13 @@ class BlackstonePlugin : Plugin<Project> {`
`30`	`30`	`dependencies.add(target.dependencyFactory.create(cfc))`
`31`	`31`	`}`
`32`	`32`	`// Fix faulty task wiring`
`33`		`- target.tasks.withType(SanitizeData::class.java).configureEach {`
	`33`	`+ target.tasks.withType<SanitizeData>().configureEach {`
`34`	`34`	`inputs.files(blackstoneConfig)`
`35`	`35`	`}`
`36`		`- target.tasks.withType(ValidateData::class.java).configureEach {`
	`36`	`+ target.tasks.withType<ValidateData>().configureEach {`
`37`	`37`	`inputs.files(blackstoneConfig)`
`38`	`38`	`}`
`39`		`- target.tasks.withType(GenerateExport::class.java).configureEach {`
	`39`	`+ target.tasks.withType<GenerateExport>().configureEach {`
`40`	`40`	`inputs.files(blackstoneConfig)`
`41`	`41`	`}`
`42`	`42`
`@@ -64,7 +64,7 @@ class BlackstonePlugin : Plugin<Project> {`
`64`	`64`	`val downloadVersionMeta by target.tasks.registering(DownloadVersionMetadata::class) {`
`65`	`65`	`group = PLUGIN_TASK_GROUP`
`66`	`66`	`input = downloadLauncherMeta.flatMap { it.output }`
`67`		`- output = target.layout.buildDirectory.file(name + ".json") // Remove subdir to fix caching`
	`67`	`+ output = target.layout.buildDirectory.file("$name.json") // Remove subdir to fix caching`
`68`	`68`	`outputs.cacheIf { true }`
`69`	`69`	`}`
`70`	`70`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ class MemberExistenceValidatorV2 : MemberExistenceValidator() {`
`14`	`14`	`super.visitField(classData, fieldData, classMetadata, fieldMetadata)`
`15`	`15`	`if (fieldMetadata != null) {`
`16`	`16`	`if (fieldMetadata.descriptor.mojangName.orElseThrow() != fieldData.descriptor) {`
`17`		`- error("Field descriptor does not match according to metadata");`
	`17`	`+ error("Field descriptor does not match according to metadata.")`
`18`	`18`	`}`
`19`	`19`	`} else {`
`20`	`20`	`// Fields existence are already checked in MemberExistenceValidator`
Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,13 @@ import org.parchmentmc.feather.metadata.MethodMetadata`
`7`	`7`
`8`	`8`	`class MethodStandardsValidatorV2 : MethodStandardsValidator() {`
`9`	`9`
	`10`	`+ data class ParamInfo(val lvtIndex: Byte, val name: String)`
	`11`	`+`
`10`	`12`	`private val standardMethods: Map<String, Array<ParamInfo>> = mapOf(`
`11`	`13`	`"equals (Ljava/lang/Object;)Z" to arrayOf(`
`12`	`14`	`ParamInfo(1, "other")`
`13`	`15`	`),`
`14`		`- "compareTo (<owner>)I" to arrayOf(`
	`16`	`+ "compareTo (<owner>)I" to arrayOf( // doesn't work well for FriendlyByteBuf and LinkFSPath`
`15`	`17`	`ParamInfo(1, "other")`
`16`	`18`	`)`
`17`	`19`	`)`
`@@ -22,18 +24,14 @@ class MethodStandardsValidatorV2 : MethodStandardsValidator() {`
`22`	`24`	`): Boolean {`
`23`	`25`	`val standardParams = standardMethods[methodData.name + " " + methodData.descriptor.replace("L${classData.name};", "<owner>")]`
`24`	`26`	`if (standardParams != null) {`
`25`		`- methodData.parameters.forEachIndexed { index, paramData ->`
`26`		`- val standardParam = standardParams[index]`
	`27`	`+ methodData.parameters.zip(standardParams) { paramData, standardParam ->`
`27`	`28`	`if (paramData.index == standardParam.lvtIndex && paramData.name != standardParam.name) {`
`28`		`- error("Parameter #${paramData.index} doesn't match the expected name: ${standardParam.name}")`
	`29`	`+ error("Parameter #${paramData.index} doesn't match the expected name: ${standardParam.name}.")`
`29`	`30`	`return false`
`30`	`31`	`}`
`31`	`32`	`}`
`32`		`-`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`return super.visitMethod(classData, methodData, classMetadata, methodMetadata)`
`36`	`36`	`}`
`37`		`-`
`38`		`- data class ParamInfo(val lvtIndex: Byte, val name: String)`
`39`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+org.parchmentmc.enigma.NameProposalServiceEnigmaPlugin`