dont actually lazy

Author: wagyourtail

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

@@ -152,34 +152,12 @@ 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,22 +6,25 @@ 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> {
-        if (unresolved.isEmpty()) return resolved
+        return resolved.toList()
+    }
+
+    fun addUnresolved(element: U) {
         synchronized(lock) {
-            if (unresolved.isEmpty()) return resolved
-            while (unresolved.isNotEmpty()) {
-                val u = unresolved.removeFirst()
+            var unresolved: U? = element
+            while (unresolved != null) {
+                val u = unresolved
+                unresolved = null
                 var merged = false
                 for (entry in resolved) {
                     if (u.merge(entry)) {
                         merged = true
-                        unresolved.add(0, entry)
+                        unresolved = entry
                         resolved.remove(entry)
                         break
                     }
@@ -30,13 +33,7 @@ class LazyResolvables<T: BaseVisitor<T>, U>(val mappings: AbstractMappingTree) w
                     resolved.add(u)
                 }
             }
-            unresolved.clear()
         }
-        return resolved
-    }
-
-    fun addUnresolved(element: U) {
-        unresolved.add(element)
     }
 
 }