Convert implementation and build script to Kotlin

3 files changed, 170 insertions, 0 deletions

diff --git a/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMapping.kt b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMapping.kt
new file mode 100644
index 0000000..389b1c9
--- /dev/null
+++ b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMapping.kt
@@ -0,0 +1,109 @@
+package com.replaymod.gradle.remap.legacy
+
+import org.cadixdev.lorenz.MappingSet
+
+import java.io.IOException
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import java.nio.file.Path
+import java.util.HashMap
+
+class LegacyMapping(var oldName: String, var newName: String) {
+    var fields: MutableMap<String, String> = mutableMapOf()
+    var methods: MutableMap<String, String> = mutableMapOf()
+
+    companion object {
+        @Throws(IOException::class)
+        fun readMappingSet(mappingFile: Path, invert: Boolean): MappingSet {
+            return LegacyMappingsReader(readMappings(mappingFile, invert)).read()
+        }
+
+        @Throws(IOException::class)
+        fun readMappings(mappingFile: Path, invert: Boolean): Map<String, LegacyMapping> {
+            val mappings = HashMap<String, LegacyMapping>()
+            val revMappings = HashMap<String, LegacyMapping>()
+            var lineNumber = 0
+            for (line in Files.readAllLines(mappingFile, StandardCharsets.UTF_8)) {
+                lineNumber++
+                if (line.trim { it <= ' ' }.startsWith("#") || line.trim { it <= ' ' }.isEmpty()) continue
+
+                val parts = line.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                require(!(parts.size < 2 || line.contains(";"))) { "Failed to parse line $lineNumber in $mappingFile." }
+
+                var mapping: LegacyMapping? = mappings[parts[0]]
+                if (mapping == null) {
+                    mapping = LegacyMapping(parts[0], parts[0])
+                    mappings[mapping.oldName] = mapping
+                }
+
+                if (parts.size == 2) {
+                    // Class mapping
+                    mapping.newName = parts[1]
+                    // Possibly merge with reverse mapping
+                    val revMapping = revMappings.remove(mapping.newName)
+                    if (revMapping != null) {
+                        mapping.fields.putAll(revMapping.fields)
+                        mapping.methods.putAll(revMapping.methods)
+                    }
+                    revMappings[mapping.newName] = mapping
+                } else if (parts.size == 3 || parts.size == 4) {
+                    var fromName = parts[1]
+                    var toName: String
+                    var revMapping: LegacyMapping?
+                    if (parts.size == 4) {
+                        toName = parts[3]
+                        revMapping = revMappings[parts[2]]
+                        if (revMapping == null) {
+                            revMapping = LegacyMapping(parts[2], parts[2])
+                            revMappings[revMapping.newName] = revMapping
+                        }
+                    } else {
+                        toName = parts[2]
+                        revMapping = mapping
+                    }
+                    if (fromName.endsWith("()")) {
+                        // Method mapping
+                        fromName = fromName.substring(0, fromName.length - 2)
+                        toName = toName.substring(0, toName.length - 2)
+                        mapping.methods[fromName] = toName
+                        revMapping.methods[fromName] = toName
+                    } else {
+                        // Field mapping
+                        mapping.fields[fromName] = toName
+                        revMapping.fields[fromName] = toName
+                    }
+                } else {
+                    throw IllegalArgumentException("Failed to parse line $lineNumber in $mappingFile.")
+                }
+            }
+            if (invert) {
+
+                (mappings.values + revMappings.values).distinct().forEach { mapping ->
+                    mapping.oldName = mapping.newName.also { mapping.newName = mapping.oldName }
+                    mapping.fields = mapping.fields.map { it.value to it.key }.toMap(mutableMapOf())
+                    mapping.methods = mapping.methods.map { it.value to it.key }.toMap(mutableMapOf())
+                }
+            }
+            val result = mutableMapOf<String, LegacyMapping>()
+            for (mapping in (mappings.values + revMappings.values)) {
+                val key = mapping.oldName
+                val other = result[key]
+                result[key] = if (other != null) {
+                    if (other.oldName != other.newName) {
+                        require(mapping.oldName == mapping.newName || other.oldName == mapping.oldName || other.newName == mapping.newName) {
+                            "Conflicting mappings: ${mapping.oldName} -> ${mapping.newName} and ${other.oldName} -> ${other.newName}"
+                        }
+                        mapping.oldName = other.oldName
+                        mapping.newName = other.newName
+                    }
+                    mapping.fields.putAll(other.fields)
+                    mapping.methods.putAll(other.methods)
+                    mapping
+                } else {
+                    mapping
+                }
+            }
+            return result
+        }
+    }
+}
diff --git a/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.kt b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.kt
new file mode 100644
index 0000000..7737200
--- /dev/null
+++ b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.kt
@@ -0,0 +1,33 @@
+package com.replaymod.gradle.remap.legacy
+
+import org.cadixdev.bombe.type.signature.MethodSignature
+import org.cadixdev.lorenz.MappingSet
+import org.cadixdev.lorenz.impl.MappingSetModelFactoryImpl
+import org.cadixdev.lorenz.impl.model.TopLevelClassMappingImpl
+import org.cadixdev.lorenz.model.MethodMapping
+import org.cadixdev.lorenz.model.TopLevelClassMapping
+
+import java.util.Optional
+
+class LegacyMappingSetModelFactory : MappingSetModelFactoryImpl() {
+    override fun createTopLevelClassMapping(parent: MappingSet, obfuscatedName: String, deobfuscatedName: String): TopLevelClassMapping {
+        return object : TopLevelClassMappingImpl(parent, obfuscatedName, deobfuscatedName) {
+            private fun stripDesc(signature: MethodSignature): MethodSignature {
+                // actual descriptor isn't included in legacy format
+                return MethodSignature.of(signature.name, "()V")
+            }
+
+            override fun hasMethodMapping(signature: MethodSignature): Boolean {
+                return super.hasMethodMapping(signature) || super.hasMethodMapping(stripDesc(signature))
+            }
+
+            override fun getMethodMapping(signature: MethodSignature): Optional<MethodMapping> {
+                var maybeMapping = super.getMethodMapping(signature)
+                if (!maybeMapping.isPresent || !maybeMapping.get().hasMappings()) {
+                    maybeMapping = super.getMethodMapping(stripDesc(signature))
+                }
+                return maybeMapping
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.kt b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.kt
new file mode 100644
index 0000000..8a6144e
--- /dev/null
+++ b/src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.kt
@@ -0,0 +1,28 @@
+package com.replaymod.gradle.remap.legacy
+
+import org.cadixdev.lorenz.MappingSet
+import org.cadixdev.lorenz.io.MappingsReader
+
+class LegacyMappingsReader(private val map: Map<String, LegacyMapping>) : MappingsReader() {
+
+    override fun read(): MappingSet {
+        return read(MappingSet.create(LegacyMappingSetModelFactory()))
+    }
+
+    override fun read(mappings: MappingSet): MappingSet {
+        require(mappings.modelFactory is LegacyMappingSetModelFactory) { "legacy mappings must use legacy model factory, use read() instead" }
+        for (legacyMapping in map.values) {
+            val classMapping = mappings.getOrCreateClassMapping(legacyMapping.oldName)
+                    .setDeobfuscatedName(legacyMapping.newName)
+            for ((key, value) in legacyMapping.fields) {
+                classMapping.getOrCreateFieldMapping(key).deobfuscatedName = value
+            }
+            for ((key, value) in legacyMapping.methods) {
+                classMapping.getOrCreateMethodMapping(key, "()V").deobfuscatedName = value
+            }
+        }
+        return mappings
+    }
+
+    override fun close() {}
+}