Revert "dont actually lazy"

This reverts commit 5769d2d.

Author: wagyourtail

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/MemoryMappingTree.kt

@@ -152,12 +152,34 @@ class MemoryMappingTree : AbstractMappingTree() {
                         val nameMap = it.names.toMutableMap()
                         NameCopyDelegate.fillAllNames(toFill, nameMap)
                         it.setNames(nameMap)
+                        listOf(
+                            async {
+                                it.fields.resolve()
+                            },
+                            async {
+                                it.methods.resolve()
+                            },
+                            async {
+                                it.wildcards.resolve()
+                            }
+                        ).awaitAll()
                         for (fill in toFill) {
                             it.acceptInner(
                                 DelegateClassVisitor(it, NameCopyDelegate(fill)),
                                 namespaces,
                                 false
                             )
+                            listOf(
+                                async {
+                                    it.fields.resolve()
+                                },
+                                async {
+                                    it.methods.resolve()
+                                },
+                                async {
+                                    it.wildcards.resolve()
+                                }
+                            ).awaitAll()
                         }
                     }
                 }

src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/node/LazyResolvables.kt

@@ -6,25 +6,22 @@ import xyz.wagyourtail.unimined.mapping.tree.AbstractMappingTree
 import xyz.wagyourtail.unimined.mapping.visitor.BaseVisitor
 
 class LazyResolvables<T: BaseVisitor<T>, U>(val mappings: AbstractMappingTree) where U: LazyResolvableEntry<U, T>, U: BaseNode<T, *> {
+    private val unresolved = mutableListOf<U>()
     private val resolved = mutableListOf<U>()
 
     val lock = SynchronizedObject()
 
     fun resolve(): List<U> {
-        return resolved.toList()
-    }
-
-    fun addUnresolved(element: U) {
+        if (unresolved.isEmpty()) return resolved
         synchronized(lock) {
-            var unresolved: U? = element
-            while (unresolved != null) {
-                val u = unresolved
-                unresolved = null
+            if (unresolved.isEmpty()) return resolved
+            while (unresolved.isNotEmpty()) {
+                val u = unresolved.removeFirst()
                 var merged = false
                 for (entry in resolved) {
                     if (u.merge(entry)) {
                         merged = true
-                        unresolved = entry
+                        unresolved.add(0, entry)
                         resolved.remove(entry)
                         break
                     }
@@ -33,7 +30,13 @@ class LazyResolvables<T: BaseVisitor<T>, U>(val mappings: AbstractMappingTree) w
                     resolved.add(u)
                 }
             }
+            unresolved.clear()
         }
+        return resolved
+    }
+
+    fun addUnresolved(element: U) {
+        unresolved.add(element)
     }
 
 }