some performance improvements

wagyourtail · wagyourtail · commit 452a5bad1435 · 2025-03-28T00:51:14.000-05:00
diff --git a/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/jvms/four/seven/nine/one/reference/PackageSpecifier.kt b/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/jvms/four/seven/nine/one/reference/PackageSpecifier.kt
@@ -26,9 +26,15 @@ value class PackageSpecifier private constructor(val value: String) : Type {
         }
 
         override fun read(reader: CharReader<*>, append: (Any) -> Unit) {
-            while (shouldRead(reader.copy())) {
-                append(Identifier.read(reader))
-                append(reader.expect('/'))
+            while (true) {
+                reader.mark()
+                val id = Identifier.read(reader)
+                if (reader.take() != '/') {
+                    reader.reset()
+                    break
+                }
+                append(id)
+                append('/')
             }
         }
 
diff --git a/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/jvms/four/two.one/InternalName.kt b/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/jvms/four/two.one/InternalName.kt
@@ -20,8 +20,16 @@ value class InternalName private constructor(val value: String) : Type {
         }
 
         override fun read(reader: CharReader<*>, append: (Any) -> Unit) {
-            append(PackageName.read(reader))
-            append(UnqualifiedName.read(reader))
+            val cname = reader.takeUntil { it in JVMS.unqualifiedNameIllegalChars && it != '/' }
+            if (cname.isEmpty() || cname.contains("//")) {
+                throw IllegalArgumentException("Invalid internal name")
+            }
+            if (!cname.contains("/")) {
+                append(UnqualifiedName.unchecked(cname))
+            } else {
+                append(PackageName.unchecked(cname.substringBeforeLast("/") + "/"))
+                append(UnqualifiedName.unchecked(cname.substringAfterLast("/")))
+            }
         }
 
         override fun unchecked(value: String) = InternalName(value)
diff --git a/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/propagator/CachedInheritanceTree.kt b/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/propagator/CachedInheritanceTree.kt
@@ -99,7 +99,7 @@ class CachedInheritanceTree(tree: AbstractMappingTree, data: CharReader<*>): Inh
                 ci = ClassInfo(InternalName.read(cls), sup?.let { InternalName.read(it) }, intf)
                 classes[ci!!.name] = ci!!
             } else {
-                val acc = data.takeNextUMF()!!.split("|").map { AccessFlag.valueOf(it.uppercase()) }
+                val acc = data.takeNextUMF()!!.split("|").filter { it.isNotBlank() }.map { AccessFlag.valueOf(it.uppercase()) }
                 val name = data.takeNextUMF()!!
                 val desc = FieldOrMethodDescriptor.read(data.takeNextUMF()!!)
 
diff --git a/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/resolver/MappingResolver.kt b/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/resolver/MappingResolver.kt
@@ -212,10 +212,7 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
                                 entry.mapNs.map { it.key.name to it.value.name }.toMap()
                             )
                             if (target != visitor) {
-                                target as MemoryMappingTree
-                                for (it in entry.preProcess) {
-                                    it(target)
-                                }
+                                entry.preProcess(target as MemoryMappingTree)
                                 target.accept(visitor)
                             }
                         } catch (e: Throwable) {
@@ -228,14 +225,6 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
 
                 afterLoad(resolved)
 
-                LOGGER.info { "Resolving fields and methods..." }
-
-                measureTime {
-                    resolved.resolveLazyResolvables()
-                }.also {
-                    LOGGER.info { "Resolved lazy resolvables in $it" }
-                }
-
                 LOGGER.info { "Propagating..." }
 
                 measureTime {
@@ -252,18 +241,11 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
                 }
                 for ((key, value) in renest) {
                     if (value.isNotEmpty()) {
+                        LOGGER.info { "Renesting $key -> ${value.joinToString(", ")}" }
                         resolved!!.renest(key, value)
                     }
                 }
 
-                LOGGER.info { "Re-resolving fields and methods..." }
-
-                measureTime {
-                    resolved!!.resolveLazyResolvables()
-                }.also {
-                    LOGGER.info { "Re-resolved lazy resolvables in $it" }
-                }
-
                 LOGGER.info { "Filling in missing names..." }
 
                 measureTime {
@@ -282,12 +264,12 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
                     LOGGER.info { "Filled in missing names in $it" }
                 }
 
-                LOGGER.info { "Re-resolving fields and methods..." }
+                LOGGER.info { "Resolving fields and methods..." }
 
                 measureTime {
                     resolved!!.resolveLazyResolvables()
                 }.also {
-                    LOGGER.info { "Re-resolved lazy resolvables in $it" }
+                    LOGGER.info { "Resolved lazy resolvables in $it" }
                 }
 
                 LOGGER.info { "Writing to cache" }
@@ -358,7 +340,7 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
         var skip by FinalizeOnRead(false)
 
         val insertInto = finalizableSetOf<(MappingVisitor) -> MappingVisitor>()
-        val preProcess = finalizableSetOf<(AbstractMappingTree) -> Unit>()
+        val preProcess = finalizableSetOf<(AbstractMappingTree, FormatProvider, ContentProvider) -> Unit>()
 
         var provider by FinalizeOnRead(LazyMutable {
             val format = FormatRegistry.autodetectFormat(envType, content.fileName(), content.content())
@@ -393,12 +375,20 @@ abstract class MappingResolver<T : MappingResolver<T>>(val name: String) {
             renest.addAll(ns.map { Namespace(it) })
         }
 
+        internal fun preProcess(mappings: AbstractMappingTree) {
+            for (pre in preProcess) {
+                pre(mappings, provider, content)
+            }
+        }
+
         fun combineWith(other: MappingConfig) {
             requires = other.requires
             provides.addAll(other.provides)
             mapNs.putAll(other.mapNs)
             skip = other.skip
             insertInto.addAll(other.insertInto)
+            preProcess.addAll(other.preProcess)
+            renest.addAll(other.renest)
         }
 
         open suspend fun finalize() {
diff --git a/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/MemoryMappingTree.kt b/src/commonMain/kotlin/xyz/wagyourtail/unimined/mapping/tree/MemoryMappingTree.kt
@@ -32,19 +32,7 @@ class MemoryMappingTree : AbstractMappingTree() {
     private val byNamespace = defaultedMapOf<Namespace, MutableMap<InternalName, ClassNode>> { mutableMapOf() }
 
     override fun getClass(namespace: Namespace, name: InternalName): ClassNode? {
-        val cacheHit = byNamespace[namespace][name]
-        if (cacheHit != null) {
-            if (cacheHit.getName(namespace) == name) {
-                return cacheHit
-            } else {
-                byNamespace[namespace].remove(name)
-            }
-        }
-        val cacheMiss = classes.firstOrNull { it.getName(namespace) == name }
-        if (cacheMiss != null) {
-            byNamespace[namespace][name] = cacheMiss
-        }
-        return cacheMiss
+        return byNamespace[namespace][name]
     }
 
     override fun classesIter(): Iterator<Pair<Map<Namespace, InternalName>, () -> ClassNode>> = _classes.iterator().asSequence().map {
@@ -115,13 +103,22 @@ class MemoryMappingTree : AbstractMappingTree() {
             // check if exists
             val existing = getClass(ns, names[ns]!!)
             if (existing != null) {
+                for ((ns, name) in existing.names.filter { it.key in names && it.value != names[it.key] }) {
+                    byNamespace[ns].remove(name)
+                }
                 // add other names
                 existing.setNames(names)
+                for ((ns, name) in names) {
+                    byNamespace[ns].put(name, existing)
+                }
                 return existing
             }
         }
         val node = ClassNode(this)
         node.setNames(names)
+        for ((ns, name) in names) {
+            byNamespace[ns].put(name, node)
+        }
         _classes.add(node)
         return node
     }

Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,15 @@ value class PackageSpecifier private constructor(val value: String) : Type {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`override fun read(reader: CharReader<*>, append: (Any) -> Unit) {`
`29`		`- while (shouldRead(reader.copy())) {`
`30`		`- append(Identifier.read(reader))`
`31`		`- append(reader.expect('/'))`
	`29`	`+ while (true) {`
	`30`	`+ reader.mark()`
	`31`	`+ val id = Identifier.read(reader)`
	`32`	`+ if (reader.take() != '/') {`
	`33`	`+ reader.reset()`
	`34`	`+ break`
	`35`	`+ }`
	`36`	`+ append(id)`
	`37`	`+ append('/')`
`32`	`38`	`}`
`33`	`39`	`}`
`34`	`40`