From cfdc125366b756a7d164502ebcde22e2976c9319 Mon Sep 17 00:00:00 2001 From: Jonas Herzig Date: Fri, 30 Aug 2019 16:48:00 +0200 Subject: Convert implementation and build script to Kotlin --- .../com/replaymod/gradle/remap/LorenzExtensions.kt | 11 + .../kotlin/com/replaymod/gradle/remap/PsiMapper.kt | 365 +++++++++++++++++++++ .../kotlin/com/replaymod/gradle/remap/PsiUtils.kt | 41 +++ .../com/replaymod/gradle/remap/Transformer.kt | 149 +++++++++ .../replaymod/gradle/remap/legacy/LegacyMapping.kt | 109 ++++++ .../remap/legacy/LegacyMappingSetModelFactory.kt | 33 ++ .../gradle/remap/legacy/LegacyMappingsReader.kt | 28 ++ 7 files changed, 736 insertions(+) create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/LorenzExtensions.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/PsiMapper.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/PsiUtils.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/Transformer.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMapping.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.kt create mode 100644 src/main/kotlin/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.kt (limited to 'src/main/kotlin') diff --git a/src/main/kotlin/com/replaymod/gradle/remap/LorenzExtensions.kt b/src/main/kotlin/com/replaymod/gradle/remap/LorenzExtensions.kt new file mode 100644 index 0000000..cd04918 --- /dev/null +++ b/src/main/kotlin/com/replaymod/gradle/remap/LorenzExtensions.kt @@ -0,0 +1,11 @@ +package com.replaymod.gradle.remap + +import org.cadixdev.bombe.type.signature.MethodSignature +import org.cadixdev.lorenz.MappingSet +import org.cadixdev.lorenz.model.ClassMapping +import org.cadixdev.lorenz.model.FieldMapping +import org.cadixdev.lorenz.model.MethodMapping + +fun MappingSet.findClassMapping(obfuscatedName: String): ClassMapping<*, *>? = getClassMapping(obfuscatedName).orElse(null) +fun ClassMapping<*, *>.findFieldMapping(obfuscatedName: String): FieldMapping? = getFieldMapping(obfuscatedName).orElse(null) +fun ClassMapping<*, *>.findMethodMapping(signature: MethodSignature): MethodMapping? = getMethodMapping(signature).orElse(null) diff --git a/src/main/kotlin/com/replaymod/gradle/remap/PsiMapper.kt b/src/main/kotlin/com/replaymod/gradle/remap/PsiMapper.kt new file mode 100644 index 0000000..95ee858 --- /dev/null +++ b/src/main/kotlin/com/replaymod/gradle/remap/PsiMapper.kt @@ -0,0 +1,365 @@ +package com.replaymod.gradle.remap + +import com.intellij.openapi.util.TextRange +import com.intellij.openapi.util.text.StringUtil +import com.intellij.psi.* +import com.replaymod.gradle.remap.PsiUtils.getSignature +import org.cadixdev.bombe.type.signature.MethodSignature +import org.cadixdev.lorenz.MappingSet +import org.cadixdev.lorenz.model.ClassMapping +import java.util.* + +internal class PsiMapper(private val map: MappingSet, private val file: PsiFile) { + private val mixinMappings = mutableMapOf>() + private var error: Boolean = false + private val changes = TreeMap(Comparator.comparing { it.startOffset }) + + private fun error(at: PsiElement, message: String) { + val line = StringUtil.offsetToLineNumber(file.text, at.textOffset) + System.err.println(file.name + ":" + line + ": " + message) + error = true + } + + private fun replace(e: PsiElement, with: String) { + changes[e.textRange] = with + } + + private fun replaceIdentifier(parent: PsiElement, with: String) { + for (child in parent.children) { + if (child is PsiIdentifier) { + replace(child, with) + return + } + } + } + + private fun valid(e: PsiElement): Boolean { + val range = e.textRange + val before = changes.ceilingKey(range) + return before == null || !before.intersects(range) + } + + private fun getResult(text: String): String? { + if (error) { + return null + } + var result = text + for ((key, value) in changes.descendingMap()) { + result = key.replace(result, value) + } + return result + } + + private fun map(expr: PsiElement, field: PsiField) { + val fieldName = field.name ?: return + val declaringClass = field.containingClass ?: return + val name = declaringClass.qualifiedName ?: return + var mapping: ClassMapping<*, *>? = this.mixinMappings[name] + if (mapping == null) { + mapping = map.findClassMapping(name) + } + if (mapping == null) return + val mapped = mapping.findFieldMapping(fieldName)?.deobfuscatedName + if (mapped == null || mapped == fieldName) return + replaceIdentifier(expr, mapped) + + if (expr is PsiJavaCodeReferenceElement + && !expr.isQualified // qualified access is fine + && !isSwitchCase(expr) // referencing constants in case statements is fine + ) { + error(expr, "Implicit member reference to remapped field \"$fieldName\". " + + "This can cause issues if the remapped reference becomes shadowed by a local variable and is therefore forbidden. " + + "Use \"this.$fieldName\" instead.") + } + } + + private fun map(expr: PsiElement, method: PsiMethod) { + if (method.isConstructor) return + + var declaringClass: PsiClass? = method.containingClass ?: return + val parentQueue = ArrayDeque() + parentQueue.offer(declaringClass) + var mapping: ClassMapping<*, *>? = null + + var name = declaringClass!!.qualifiedName + if (name != null) { + mapping = mixinMappings[name] + } + while (true) { + if (mapping != null) { + val mapped = mapping.findMethodMapping(getSignature(method))?.deobfuscatedName + if (mapped != null) { + if (mapped != method.name) { + replaceIdentifier(expr, mapped) + } + return + } + mapping = null + } + while (mapping == null) { + declaringClass = parentQueue.poll() + if (declaringClass == null) return + + val superClass = declaringClass.superClass + if (superClass != null) { + parentQueue.offer(superClass) + } + for (anInterface in declaringClass.interfaces) { + parentQueue.offer(anInterface) + } + + name = declaringClass.qualifiedName + if (name == null) continue + mapping = map.findClassMapping(name) + } + } + } + + private fun map(expr: PsiElement, resolved: PsiQualifiedNamedElement) { + val name = resolved.qualifiedName ?: return + val mapping = map.findClassMapping(name) ?: return + var mapped = mapping.deobfuscatedName + if (mapped == name) return + mapped = mapped.replace('/', '.') + + if (expr.text == name) { + replace(expr, mapped) + return + } + replaceIdentifier(expr, mapped.substring(mapped.lastIndexOf('.') + 1)) + } + + private fun map(expr: PsiElement, resolved: PsiElement?) { + when (resolved) { + is PsiField -> map(expr, resolved) + is PsiMethod -> map(expr, resolved) + is PsiClass, is PsiPackage -> map(expr, resolved as PsiQualifiedNamedElement) + } + } + + // Note: Supports only Mixins with a single target (ignores others) and only ones specified via class literals + private fun getMixinTarget(annotation: PsiAnnotation): PsiClass? { + for (pair in annotation.parameterList.attributes) { + val name = pair.name + if (name != null && "value" != name) continue + val value = pair.value + if (value !is PsiClassObjectAccessExpression) continue + val type = value.operand + val reference = type.innermostComponentReferenceElement ?: continue + return reference.resolve() as PsiClass? + } + return null + } + + private fun remapAccessors(mapping: ClassMapping<*, *>) { + file.accept(object : JavaRecursiveElementVisitor() { + override fun visitMethod(method: PsiMethod) { + val annotation = method.getAnnotation(CLASS_ACCESSOR) ?: return + + val methodName = method.name + val targetByName = when { + methodName.startsWith("is") -> methodName.substring(2) + methodName.startsWith("get") || methodName.startsWith("set") -> methodName.substring(3) + else -> null + }?.decapitalize() + + val target = annotation.parameterList.attributes.find { + it.name == null || it.name == "value" + }?.literalValue ?: targetByName ?: throw IllegalArgumentException("Cannot determine accessor target for $method") + + val mapped = mapping.findFieldMapping(target)?.deobfuscatedName + if (mapped != null && mapped != target) { + // Update accessor target + replace(annotation.parameterList, if (mapped == targetByName) { + // Mapped name matches implied target, can just remove the explict target + "" + } else { + // Mapped name does not match implied target, need to set the target as annotation value + "(\"" + StringUtil.escapeStringCharacters(mapped) + "\")" + }) + } + } + }) + } + + private fun remapInjectsAndRedirects(mapping: ClassMapping<*, *>) { + file.accept(object : JavaRecursiveElementVisitor() { + override fun visitMethod(method: PsiMethod) { + val annotation = method.getAnnotation(CLASS_INJECT) ?: method.getAnnotation(CLASS_REDIRECT) ?: return + + for (attribute in annotation.parameterList.attributes) { + if ("method" != attribute.name) continue + // Note: mixin supports multiple targets, we do not (yet) + val literalValue = attribute.literalValue ?: continue + var mapped: String? + if (literalValue.contains("(")) { + mapped = mapping.findMethodMapping(MethodSignature.of(literalValue))?.deobfuscatedName + } else { + mapped = null + for (methodMapping in mapping.methodMappings) { + if (methodMapping.obfuscatedName == literalValue) { + val name = methodMapping.deobfuscatedName + if (mapped != null && mapped != name) { + error(attribute, "Ambiguous mixin method \"$literalValue\" maps to \"$mapped\" and \"$name\"") + } + mapped = name + } + } + } + if (mapped != null && mapped != literalValue) { + val value = attribute.value!! + replace(value, '"'.toString() + mapped + '"'.toString()) + } + } + } + }) + } + + private fun remapInternalType(internalType: String, result: StringBuilder): ClassMapping<*, *>? { + if (internalType[0] == 'L') { + val type = internalType.substring(1, internalType.length - 1).replace('/', '.') + val mapping = map.findClassMapping(type) + if (mapping != null) { + result.append('L').append(mapping.fullDeobfuscatedName).append(';') + return mapping + } + } + result.append(internalType) + return null + } + + private fun remapFullyQualifiedMethodOrField(signature: String): String { + val ownerEnd = signature.indexOf(';') + var argsBegin = signature.indexOf('(') + var argsEnd = signature.indexOf(')') + val method = argsBegin != -1 + if (!method) { + argsEnd = signature.indexOf(':') + argsBegin = argsEnd + } + val owner = signature.substring(0, ownerEnd + 1) + val name = signature.substring(ownerEnd + 1, argsBegin) + val returnType = signature.substring(argsEnd + 1) + + val builder = StringBuilder(signature.length + 32) + val mapping = remapInternalType(owner, builder) + var mapped: String? = null + if (mapping != null) { + mapped = (if (method) { + mapping.findMethodMapping(MethodSignature.of(signature.substring(ownerEnd + 1))) + } else { + mapping.findFieldMapping(name) + })?.deobfuscatedName + } + builder.append(mapped ?: name) + if (method) { + builder.append('(') + val args = signature.substring(argsBegin + 1, argsEnd) + var i = 0 + while (i < args.length) { + val c = args[i] + if (c != 'L') { + builder.append(c) + i++ + continue + } + val end = args.indexOf(';', i) + val arg = args.substring(i, end + 1) + remapInternalType(arg, builder) + i = end + i++ + } + builder.append(')') + } else { + builder.append(':') + } + remapInternalType(returnType, builder) + return builder.toString() + } + + private fun remapAtTargets() { + file.accept(object : JavaRecursiveElementVisitor() { + override fun visitAnnotation(annotation: PsiAnnotation) { + if (CLASS_AT != annotation.qualifiedName) { + super.visitAnnotation(annotation) + return + } + + for (attribute in annotation.parameterList.attributes) { + if ("target" != attribute.name) continue + val signature = attribute.literalValue ?: continue + val newSignature = remapFullyQualifiedMethodOrField(signature) + if (newSignature != signature) { + val value = attribute.value!! + replace(value, "\"$newSignature\"") + } + } + } + }) + } + + fun remapFile(): String? { + file.accept(object : JavaRecursiveElementVisitor() { + override fun visitClass(psiClass: PsiClass) { + val annotation = psiClass.getAnnotation(CLASS_MIXIN) ?: return + + remapAtTargets() + + val target = getMixinTarget(annotation) ?: return + val qualifiedName = target.qualifiedName ?: return + + val mapping = map.findClassMapping(qualifiedName) ?: return + + mixinMappings[psiClass.qualifiedName!!] = mapping + + if (!mapping.fieldMappings.isEmpty()) { + remapAccessors(mapping) + } + if (!mapping.methodMappings.isEmpty()) { + remapInjectsAndRedirects(mapping) + } + } + }) + + file.accept(object : JavaRecursiveElementVisitor() { + override fun visitField(field: PsiField) { + if (valid(field)) { + map(field, field) + } + super.visitField(field) + } + + override fun visitMethod(method: PsiMethod) { + if (valid(method)) { + map(method, method) + } + super.visitMethod(method) + } + + override fun visitReferenceElement(reference: PsiJavaCodeReferenceElement) { + if (valid(reference)) { + map(reference, reference.resolve()) + } + super.visitReferenceElement(reference) + } + }) + + return getResult(file.text) + } + + companion object { + private const val CLASS_MIXIN = "org.spongepowered.asm.mixin.Mixin" + private const val CLASS_ACCESSOR = "org.spongepowered.asm.mixin.gen.Accessor" + private const val CLASS_AT = "org.spongepowered.asm.mixin.injection.At" + private const val CLASS_INJECT = "org.spongepowered.asm.mixin.injection.Inject" + private const val CLASS_REDIRECT = "org.spongepowered.asm.mixin.injection.Redirect" + + private fun isSwitchCase(e: PsiElement): Boolean { + if (e is PsiSwitchLabelStatement) { + return true + } + val parent = e.parent + return parent != null && isSwitchCase(parent) + } + } +} diff --git a/src/main/kotlin/com/replaymod/gradle/remap/PsiUtils.kt b/src/main/kotlin/com/replaymod/gradle/remap/PsiUtils.kt new file mode 100644 index 0000000..de29956 --- /dev/null +++ b/src/main/kotlin/com/replaymod/gradle/remap/PsiUtils.kt @@ -0,0 +1,41 @@ +package com.replaymod.gradle.remap + +import com.intellij.psi.* +import com.intellij.psi.util.TypeConversionUtil +import org.cadixdev.bombe.type.ArrayType +import org.cadixdev.bombe.type.FieldType +import org.cadixdev.bombe.type.MethodDescriptor +import org.cadixdev.bombe.type.ObjectType +import org.cadixdev.bombe.type.Type +import org.cadixdev.bombe.type.VoidType +import org.cadixdev.bombe.type.signature.MethodSignature + +internal object PsiUtils { + fun getSignature(method: PsiMethod): MethodSignature = MethodSignature(method.name, getDescriptor(method)) + + private fun getDescriptor(method: PsiMethod): MethodDescriptor = MethodDescriptor( + method.parameterList.parameters.map { getFieldType(it.type) }, + getType(method.returnType) + ) + + private fun getFieldType(type: PsiType?): FieldType = when (val erasedType = TypeConversionUtil.erasure(type)) { + is PsiPrimitiveType -> FieldType.of(erasedType.kind.binaryName) + is PsiArrayType -> { + val array = erasedType as PsiArrayType? + ArrayType(array!!.arrayDimensions, getFieldType(array.deepComponentType)) + } + is PsiClassType -> { + val resolved = erasedType.resolve() ?: throw NullPointerException("Failed to resolve type $erasedType") + val qualifiedName = resolved.qualifiedName + ?: throw NullPointerException("Type $erasedType has no qualified name.") + ObjectType(qualifiedName) + } + else -> throw IllegalArgumentException("Cannot translate type " + erasedType!!) + } + + private fun getType(type: PsiType?): Type = if (TypeConversionUtil.isVoidType(type)) { + VoidType.INSTANCE + } else { + getFieldType(type) + } +} diff --git a/src/main/kotlin/com/replaymod/gradle/remap/Transformer.kt b/src/main/kotlin/com/replaymod/gradle/remap/Transformer.kt new file mode 100644 index 0000000..303ee42 --- /dev/null +++ b/src/main/kotlin/com/replaymod/gradle/remap/Transformer.kt @@ -0,0 +1,149 @@ +package com.replaymod.gradle.remap + +import com.intellij.codeInsight.CustomExceptionHandler +import com.intellij.mock.MockProject +import com.intellij.openapi.extensions.ExtensionPoint +import com.intellij.openapi.extensions.Extensions +import com.intellij.openapi.util.Disposer +import com.intellij.openapi.vfs.StandardFileSystems +import com.intellij.openapi.vfs.VirtualFileManager +import com.intellij.openapi.vfs.local.CoreLocalFileSystem +import com.intellij.psi.PsiManager +import com.intellij.psi.search.GlobalSearchScope +import com.replaymod.gradle.remap.legacy.LegacyMapping +import org.cadixdev.lorenz.MappingSet +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.cli.common.config.ContentRoot +import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.cli.common.messages.MessageRenderer +import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot +import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.CompilerConfiguration +import java.io.BufferedReader +import java.io.File +import java.io.IOException +import java.io.InputStreamReader +import java.nio.charset.StandardCharsets +import java.nio.file.Files +import java.nio.file.StandardOpenOption +import java.util.* +import kotlin.system.exitProcess + +class Transformer(private val map: MappingSet) { + var classpath: Array? = null + private var fail: Boolean = false + + @Throws(IOException::class) + fun remap(sources: Map): Map { + val tmpDir = Files.createTempDirectory("remap") + try { + for ((unitName, source) in sources) { + val path = tmpDir.resolve(unitName) + Files.createDirectories(path.parent) + Files.write(path, source.toByteArray(StandardCharsets.UTF_8), StandardOpenOption.CREATE) + } + + val config = CompilerConfiguration() + config.put(CommonConfigurationKeys.MODULE_NAME, "main") + config.add(CLIConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(tmpDir.toFile(), "")) + config.add(CLIConfigurationKeys.CONTENT_ROOTS, KotlinSourceRoot(tmpDir.toAbsolutePath().toString(), false)) + config.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector(System.err, MessageRenderer.GRADLE_STYLE, true)) + + val environment = KotlinCoreEnvironment.createForProduction( + Disposer.newDisposable(), + config, + EnvironmentConfigFiles.JVM_CONFIG_FILES + ) + val rootArea = Extensions.getRootArea() + if (!rootArea.hasExtensionPoint(CustomExceptionHandler.KEY)) { + rootArea.registerExtensionPoint(CustomExceptionHandler.KEY.name, CustomExceptionHandler::class.java.name, ExtensionPoint.Kind.INTERFACE) + } + + val project = environment.project as MockProject + + environment.updateClasspath(classpath!!.map { JvmClasspathRoot(File(it)) }) + + TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( + project, + emptyList(), + NoScopeRecordCliBindingTrace(), + environment.configuration, + { scope: GlobalSearchScope -> environment.createPackagePartProvider(scope) } + ) + + val vfs = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem + val results = HashMap() + for (name in sources.keys) { + val file = vfs.findFileByIoFile(tmpDir.resolve(name).toFile())!! + val psiFile = PsiManager.getInstance(project).findFile(file)!! + + val mapped = PsiMapper(map, psiFile).remapFile() + if (mapped == null) { + fail = true + continue + } + results[name] = mapped + } + return results + } finally { + Files.walk(tmpDir).map { it.toFile() }.sorted(Comparator.reverseOrder()).forEach { it.delete() } + } + } + + companion object { + + @Throws(IOException::class) + @JvmStatic + fun main(args: Array) { + val mappings: MappingSet = if (args[0].isEmpty()) { + MappingSet.create() + } else { + LegacyMapping.readMappingSet(File(args[0]).toPath(), args[1] == "true") + } + val transformer = Transformer(mappings) + + val reader = BufferedReader(InputStreamReader(System.`in`)) + + transformer.classpath = (1..Integer.parseInt(args[2])).map { reader.readLine() }.toTypedArray() + + val sources = mutableMapOf() + while (true) { + val name = reader.readLine() + if (name == null || name.isEmpty()) { + break + } + + val lines = arrayOfNulls(Integer.parseInt(reader.readLine())) + for (i in lines.indices) { + lines[i] = reader.readLine() + } + val source = lines.joinToString("\n") + + sources[name] = source + } + + val results = transformer.remap(sources) + + for (name in sources.keys) { + println(name) + val lines = results.getValue(name).split("\n").dropLastWhile { it.isEmpty() }.toTypedArray() + println(lines.size) + for (line in lines) { + println(line) + } + } + + if (transformer.fail) { + exitProcess(1) + } + } + } + +} 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 = mutableMapOf() + var methods: MutableMap = 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 { + val mappings = HashMap() + val revMappings = HashMap() + 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() + 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 { + 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) : 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() {} +} -- cgit