param merging, auto add lvord during propagation

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/formats/umf/UMFReader.kt

@@ -18,7 +18,6 @@ import xyz.wagyourtail.unimined.mapping.tree.node._class.member.WildcardNode
 import xyz.wagyourtail.unimined.mapping.tree.node._constant.ConstantGroupNode
 import xyz.wagyourtail.commonskt.reader.CharReader
 import xyz.wagyourtail.commonskt.utils.filterNotNullValues
-import xyz.wagyourtail.unimined.mapping.formats.mcp.MCPExceptionReader.sep
 import xyz.wagyourtail.unimined.mapping.visitor.*
 
 /**

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/propagator/InheritanceTree.kt

@@ -8,10 +8,12 @@ import xyz.wagyourtail.commonskt.utils.coroutines.parallelMap
 import xyz.wagyourtail.unimined.mapping.Namespace
 import xyz.wagyourtail.unimined.mapping.jvms.four.AccessFlag
 import xyz.wagyourtail.unimined.mapping.jvms.four.ElementType
+import xyz.wagyourtail.unimined.mapping.jvms.four.contains
 import xyz.wagyourtail.unimined.mapping.jvms.four.three.three.MethodDescriptor
 import xyz.wagyourtail.unimined.mapping.jvms.four.three.two.FieldDescriptor
 import xyz.wagyourtail.unimined.mapping.jvms.four.two.one.InternalName
 import xyz.wagyourtail.unimined.mapping.tree.AbstractMappingTree
+import xyz.wagyourtail.unimined.mapping.visitor.use
 
 abstract class InheritanceTree(val tree: AbstractMappingTree, val fns: Namespace) {
     val LOGGER = KotlinLogging.logger {  }
@@ -58,7 +60,13 @@ abstract class InheritanceTree(val tree: AbstractMappingTree, val fns: Namespace
                 interfaceClasses.parallelMap { it.propagate(targets) }
 
                 for (method in methods) {
-                    clsNode?.visitMethod(mapOf(fns to (method.name to method.descriptor)))?.visitEnd()
+                    clsNode?.visitMethod(mapOf(fns to (method.name to method.descriptor)))?.use {
+                        var lvOrd = if (AccessFlag.STATIC in method.access) 0 else 1
+                        method.descriptor.getParts().second.forEachIndexed { i, p ->
+                            visitParameter(i, lvOrd, emptyMap())?.visitEnd()
+                            lvOrd += p.value.getWidth()
+                        }
+                    }
                 }
 
                 val methods = methods.filter { md ->
@@ -68,10 +76,9 @@ abstract class InheritanceTree(val tree: AbstractMappingTree, val fns: Namespace
                     methods?.flatMap { it.access }?.forEach {
                         it.apply(acc)
                     }
-                    AccessFlag.isInheritable(acc)
+                    AccessFlag.isInheritable(acc) && !md.name.startsWith("<")
                 }.parallelMap { md ->
                     md to (clsNode?.getMethods(fns, md.name, md.descriptor)?.firstOrNull()?.names?.filterKeys { it in targets } ?: emptyMap()).toMutableMap()
-//                }.parallelMap { (md, names) ->
                 }.parallelMap { (md, names) ->
                     // traverse parents, retrieve matching mappings
                     val superNames = superClass?.methodData?.get(md)

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/node/_class/member/FieldMethodResolvable.kt

@@ -1,5 +1,6 @@
 package xyz.wagyourtail.unimined.mapping.tree.node._class.member
 
+import io.github.oshai.kotlinlogging.KotlinLogging
 import xyz.wagyourtail.unimined.mapping.Namespace
 import xyz.wagyourtail.unimined.mapping.jvms.ext.FieldOrMethodDescriptor
 import xyz.wagyourtail.unimined.mapping.tree.MemoryMappingTree
@@ -9,6 +10,7 @@ import xyz.wagyourtail.unimined.mapping.visitor.MemberVisitor
 
 abstract class FieldMethodResolvable<T: FieldMethodResolvable<T, U>, U: MemberVisitor<U>>(parent: ClassNode, val create: (ClassNode) -> T) : AbstractFieldMethodNode<U>(parent),
     LazyResolvableEntry<T, U> {
+    val LOGGER = KotlinLogging.logger {  }
 
     fun MemoryMappingTree.getDescriptor(namespace: Namespace): FieldOrMethodDescriptor? {
         if (descs.isEmpty()) return null
@@ -34,10 +36,13 @@ abstract class FieldMethodResolvable<T: FieldMethodResolvable<T, U>, U: MemberVi
         }
 
         var matched = false
+        var notMatched = false
         for ((ns, nameVal) in names) {
             val elementNameVal = element.names[ns] ?: continue
             if (elementNameVal == nameVal) {
                 matched = true
+            } else {
+                notMatched = true
             }
         }
 
@@ -46,6 +51,17 @@ abstract class FieldMethodResolvable<T: FieldMethodResolvable<T, U>, U: MemberVi
             return null
         }
 
+        // warn if a method name is getting implicitly overridden
+        if (notMatched) {
+            LOGGER.warn {
+                """
+                    Joining different names, second will take priority
+                    $element
+                    $this
+                """.trimIndent()
+            }
+        }
+
         return if (element.hasDescriptor()) {
             if (descs.isNotEmpty()) {
                 val descNs = descs.keys.first()

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/node/_class/member/MethodNode.kt

@@ -1,10 +1,12 @@
 package xyz.wagyourtail.unimined.mapping.tree.node._class.member
 
+import io.github.oshai.kotlinlogging.KotlinLogging
 import xyz.wagyourtail.unimined.mapping.Namespace
 import xyz.wagyourtail.unimined.mapping.formats.umf.UMFWriter
 import xyz.wagyourtail.unimined.mapping.jvms.ext.FieldOrMethodDescriptor
 import xyz.wagyourtail.unimined.mapping.jvms.four.three.three.MethodDescriptor
 import xyz.wagyourtail.unimined.mapping.jvms.four.two.one.InternalName
+import xyz.wagyourtail.unimined.mapping.tree.node.LazyResolvables
 import xyz.wagyourtail.unimined.mapping.tree.node.SignatureNode
 import xyz.wagyourtail.unimined.mapping.tree.node._class.ClassNode
 import xyz.wagyourtail.unimined.mapping.tree.node._class.member.method.ExceptionNode
@@ -13,13 +15,15 @@ import xyz.wagyourtail.unimined.mapping.tree.node._class.member.method.Parameter
 import xyz.wagyourtail.unimined.mapping.visitor.*
 
 class MethodNode(parent: ClassNode) : FieldMethodResolvable<MethodNode, MethodVisitor>(parent, ::MethodNode), MethodVisitor {
+
     private val _signatures = mutableSetOf<SignatureNode<MethodVisitor>>()
-    private val _params: MutableList<ParameterNode<MethodVisitor>> = mutableListOf()
     private val _locals: MutableList<LocalNode<MethodVisitor>> = mutableListOf()
     private val _exceptions: MutableList<ExceptionNode<MethodVisitor>> = mutableListOf()
 
     val signatures: Set<SignatureNode<MethodVisitor>> get() = _signatures
-    val params: List<ParameterNode<MethodVisitor>> get() = _params
+    val params = LazyResolvables<ParameterVisitor, ParameterNode<MethodVisitor>>(root) {
+        ParameterNode(this, null, null)
+    }
     val locals: List<LocalNode<MethodVisitor>> get() = _locals
     val exceptions: List<ExceptionNode<MethodVisitor>> get() = _exceptions
 
@@ -45,19 +49,9 @@ class MethodNode(parent: ClassNode) : FieldMethodResolvable<MethodNode, MethodVi
     }
 
     override fun visitParameter(index: Int?, lvOrd: Int?, names: Map<Namespace, String>): ParameterVisitor {
-        for (param in params) {
-            if (index != null && param.index == index) {
-                param.setNames(names)
-                return param
-            }
-            if (lvOrd != null && param.lvOrd == lvOrd) {
-                param.setNames(names)
-                return param
-            }
-        }
         val newParam = ParameterNode(this, index, lvOrd)
         newParam.setNames(names)
-        _params.add(newParam)
+        params.addUnresolved(newParam)
         return newParam
     }
 
@@ -100,7 +94,7 @@ class MethodNode(parent: ClassNode) : FieldMethodResolvable<MethodNode, MethodVi
         for (exception in exceptions) {
             exception.accept(visitor, nsFilter)
         }
-        for (param in params) {
+        for (param in params.resolve()) {
             param.accept(visitor, nsFilter)
         }
         for (local in locals) {
@@ -113,6 +107,7 @@ class MethodNode(parent: ClassNode) : FieldMethodResolvable<MethodNode, MethodVi
         // override to merge disperate constructor methods
         val name = names.values.first()
         if (merged == null && (name == "<init>" || name == "<clinit>") && name == element.names.values.first()) {
+
             // test desc
             if (descs.isNotEmpty() && element.descs.isNotEmpty()) {
                 val descNs = descs.keys.first()

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/node/_class/member/method/ParameterNode.kt

@@ -1,15 +1,29 @@
 package xyz.wagyourtail.unimined.mapping.tree.node._class.member.method
 
+import io.github.oshai.kotlinlogging.KotlinLogging
 import xyz.wagyourtail.unimined.mapping.Namespace
 import xyz.wagyourtail.unimined.mapping.formats.umf.UMFWriter
 import xyz.wagyourtail.unimined.mapping.tree.node.BaseNode
+import xyz.wagyourtail.unimined.mapping.tree.node.LazyResolvableEntry
 import xyz.wagyourtail.unimined.mapping.tree.node._class.member.MemberNode
+import xyz.wagyourtail.unimined.mapping.tree.node._class.member.WildcardNode
 import xyz.wagyourtail.unimined.mapping.visitor.EmptyMethodVisitor
 import xyz.wagyourtail.unimined.mapping.visitor.InvokableVisitor
 import xyz.wagyourtail.unimined.mapping.visitor.ParameterVisitor
+import xyz.wagyourtail.unimined.mapping.visitor.WildcardVisitor
+
+class ParameterNode<T: InvokableVisitor<T>>(
+    parent: BaseNode<T, *>,
+    index: Int?,
+    lvOrd: Int?
+) : MemberNode<ParameterVisitor, T>(parent), ParameterVisitor, LazyResolvableEntry<ParameterNode<T>, ParameterVisitor> {
+    val LOGGER = KotlinLogging.logger {  }
+
+    var index = index
+        private set
+    var lvOrd = lvOrd
+        private set
 
-class ParameterNode<T: InvokableVisitor<T>>(parent: BaseNode<T, *>, val index: Int?, val lvOrd: Int?) : MemberNode<ParameterVisitor, T>(parent),
-    ParameterVisitor {
     private val _names: MutableMap<Namespace, String> = mutableMapOf()
     val names: Map<Namespace, String> get() = _names
 
@@ -31,4 +45,35 @@ class ParameterNode<T: InvokableVisitor<T>>(parent: BaseNode<T, *>, val index: I
 //        acceptInner(DelegateParameterVisitor(EmptyParameterVisitor(), delegator), root.namespaces)
     }
 
-}
+    fun doMerge(target: ParameterNode<T>) {
+        acceptInner(target, root.namespaces)
+    }
+
+    override fun merge(element: ParameterNode<T>): ParameterNode<T>? {
+        if (element.index == null && element.lvOrd == null) {
+            doMerge(element)
+            return element
+        }
+        if (element.index != null && element.index == index) {
+            if (element.lvOrd != null && lvOrd != null && lvOrd != element.lvOrd) {
+                LOGGER.warn {
+                    """
+                        Attempted to join params with same index but different lvOrd's
+                        $element
+                        $this
+                    """.trimIndent()
+                }
+                return null
+            }
+            doMerge(element)
+            return element
+        }
+        if (element.lvOrd != null && element.lvOrd == lvOrd) {
+            if (index != null) element.index = index
+            doMerge(element)
+            return element
+        }
+        return null
+    }
+
+}

src/jvmMain/kotlin/xyz/wagyourtail/unimined/mapping/propogator/Propagator.kt

@@ -13,12 +13,8 @@ import xyz.wagyourtail.unimined.mapping.tree.AbstractMappingTree
 import java.io.InputStream
 import java.nio.file.Files
 import java.nio.file.Path
-import java.util.*
-import java.util.stream.Collectors
-import java.util.stream.Stream
 import kotlin.streams.asSequence
 import kotlin.streams.asStream
-import kotlin.streams.toList
 
 class Propagator(tree: AbstractMappingTree, fns: Namespace, jars: Set<Path>): InheritanceTree(tree, fns) {
 
@@ -50,7 +46,6 @@ class Propagator(tree: AbstractMappingTree, fns: Namespace, jars: Set<Path>): In
 
         return className to ClassInfo(className, InternalName.read(node.superName), node.interfaces.map(InternalName::read)).apply {
             for (method in node.methods) {
-                if (method.name.startsWith("<")) continue
                 methods.add(MethodInfo(method.name, MethodDescriptor.read(method.desc), method.access))
             }
             for (field in node.fields) {