cleanup and fix more

unimined · Dec 20, 2023 · 2e0ff0a · 2e0ff0a
1 parent d028ab5
commit 2e0ff0a
Show file tree

Hide file tree

Showing 6 changed files with 91 additions and 203 deletions.
diff --git a/src/api/kotlin/xyz/wagyourtail/unimined/api/mapping/MappingDepConfig.kt b/src/api/kotlin/xyz/wagyourtail/unimined/api/mapping/MappingDepConfig.kt
@@ -71,12 +71,13 @@ interface ContainedMapping {
     /**
      * insert forward visitor that converts class names to the ClassNs
      */
+    @Deprecated(message = "use memberNameReplacer", replaceWith = ReplaceWith("memberNameReplacer(targetNs, classNs, setOf(MappedElementKind.CLASS))"))
     fun classNameReplacer(targetNs: String, classNs: String)
 
     /**
      * insert forward visitor that converts srg to searge names.
      */
-    fun memberNameReplacer(targetNs: String, classNs: String,  types: Set<String>)
+    fun memberNameReplacer(targetNs: String, memberNs: String,  types: Set<String>)
 
     /**
      * insert forward visitor that only allows existing src names.

diff --git a/src/api/kotlin/xyz/wagyourtail/unimined/api/mapping/MappingsConfig.kt b/src/api/kotlin/xyz/wagyourtail/unimined/api/mapping/MappingsConfig.kt
@@ -507,14 +507,14 @@ abstract class MappingsConfig(val project: Project, val minecraft: MinecraftConf
     @JvmOverloads
     abstract fun spigotDev(
         mcVersion: String = minecraft.version,
-        key: String = "spigot-dev",
+        key: String = "spigot_dev",
         action: MappingDepConfig.() -> Unit = {}
     )
 
     @JvmOverloads
     fun spigotDev(
         mcVersion: String = minecraft.version,
-        key: String = "spigot-dev",
+        key: String = "spigot_dev",
         @DelegatesTo(value = MappingDepConfig::class, strategy = Closure.DELEGATE_FIRST)
         action: Closure<*>
     ) {

diff --git a/src/mapping/kotlin/net/fabricmc/mappingio/format/ClassNameReplacer.kt b/src/mapping/kotlin/net/fabricmc/mappingio/format/ClassNameReplacer.kt
diff --git a/src/mapping/kotlin/net/fabricmc/mappingio/format/MemberNameReplacer.kt b/src/mapping/kotlin/net/fabricmc/mappingio/format/MemberNameReplacer.kt
diff --git a/src/mapping/kotlin/xyz/wagyourtail/unimined/internal/mapping/MappingDepConfigImpl.kt b/src/mapping/kotlin/xyz/wagyourtail/unimined/internal/mapping/MappingDepConfigImpl.kt
@@ -105,39 +105,86 @@ class ContainedMappingImpl() : ContainedMapping {
 
     override fun classNameReplacer(targetNs: String, classNs: String) {
         checkFinalized()
-        inputActions.add {
-            forwardVisitor { v, tree ->
-                ClassNameReplacer(
-                    v,
-                    targetNs,
-                    classNs,
-                    tree
-                )
-            }
-        }
+        memberNameReplacer(targetNs, classNs, setOf(MappedElementKind.CLASS))
     }
 
-    override fun memberNameReplacer(targetNs: String, classNs: String, types: Set<String>) {
+    override fun memberNameReplacer(targetNs: String, memberNs: String, types: Set<String>) {
         memberNameReplacer(
             targetNs,
-            classNs,
+            memberNs,
             types.map { MappedElementKind.valueOf(it.uppercase()) }.toSet()
         )
     }
 
     @JvmName("memberNameReplacerIntl")
     @ApiStatus.Internal
-    fun memberNameReplacer(targetNs: String, classNs: String, types: Set<MappedElementKind>) {
+    fun memberNameReplacer(targetNs: String, memberNs: String, types: Set<MappedElementKind>) {
         checkFinalized()
         inputActions.add {
-            forwardVisitor { v, tree ->
-                MemberNameReplacer(
-                    v,
-                    targetNs,
-                    classNs,
-                    tree,
-                    types
-                )
+            afterRemap {
+                val targetKey = it.getNamespaceId(targetNs)
+
+                if (targetKey == MappingTreeView.NULL_NAMESPACE_ID) {
+                    throw IllegalStateException("Target namespace $targetNs does not exist")
+                }
+
+                val memberKey = it.getNamespaceId(memberNs)
+
+                if (memberKey == MappingTreeView.NULL_NAMESPACE_ID) {
+                    throw IllegalStateException("Member namespace $memberNs does not exist")
+                }
+
+                for (classMapping in it.classes) {
+                    if (types.contains(MappedElementKind.CLASS)) {
+                        val className = classMapping.getName(memberKey)
+                        if (className != null) {
+                            classMapping.setDstName(className, targetKey)
+                        }
+                    }
+                    if (types.contains(MappedElementKind.METHOD) || types.contains(MappedElementKind.METHOD_ARG) || types.contains(MappedElementKind.METHOD_VAR)) {
+                        for (method in classMapping.methods) {
+                            if (types.contains(MappedElementKind.METHOD)) {
+                                val mojmapName = method.getName(memberKey)
+                                if (mojmapName != null) {
+                                    if (method.getName(targetKey) == null) {
+                                        method.setDstName(mojmapName, targetKey)
+                                    }
+                                }
+                            }
+                            if (types.contains(MappedElementKind.METHOD_ARG)) {
+                                for (arg in method.args) {
+                                    val mojmapName = arg.getName(memberKey)
+                                    if (mojmapName != null) {
+                                        if (arg.getName(targetKey) == null) {
+                                            arg.setDstName(mojmapName, targetKey)
+                                        }
+                                    }
+                                }
+                            }
+                            if (types.contains(MappedElementKind.METHOD_VAR)) {
+                                for (local in method.vars) {
+                                    val mojmapName = local.getName(memberKey)
+                                    if (mojmapName != null) {
+                                        if (local.getName(targetKey) == null) {
+                                            local.setDstName(mojmapName, targetKey)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (types.contains(MappedElementKind.FIELD)) {
+                        for (field in classMapping.fields) {
+                            val mojmapName = field.getName(memberKey)
+                            if (mojmapName != null) {
+                                if (field.getName(targetKey) == null) {
+                                    field.setDstName(mojmapName, targetKey)
+                                }
+                            }
+                        }
+                    }
+                }
+
             }
         }
     }

diff --git a/src/mapping/kotlin/xyz/wagyourtail/unimined/internal/mapping/MappingsProvider.kt b/src/mapping/kotlin/xyz/wagyourtail/unimined/internal/mapping/MappingsProvider.kt
@@ -27,7 +27,7 @@ import java.nio.file.Path
 import java.security.MessageDigest
 import kotlin.io.path.*
 
-class MappingsProvider(project: Project, minecraft: MinecraftConfig): MappingsConfig(project, minecraft) {
+class MappingsProvider(project: Project, minecraft: MinecraftConfig, val mappingKey: String = "mappings"): MappingsConfig(project, minecraft) {
 
     override var side: EnvType by FinalizeOnRead(LazyMutable { minecraft.side })
 
@@ -429,12 +429,20 @@ class MappingsProvider(project: Project, minecraft: MinecraftConfig): MappingsCo
         }
 
         mapping(project.files(buildDataZip), key) {
-            outputs("spigot", false) { listOf("official") }
             contains({ n, _  ->
                 n.endsWith("-members.csrg")
             }) {
                 exclude()
             }
+            // so it can be valid to remap directly from dev...
+            memberNameReplacer("spigot", "official", setOf("method", "field", "method_arg", "method_var"))
+            outputs("spigot", false) {
+                if ("spigot_dev" in getNamespaces()) {
+                    listOf("official", "spigot_dev")
+                } else {
+                    listOf("official")
+                }
+            }
             renest()
             action()
         }
@@ -482,31 +490,31 @@ class MappingsProvider(project: Project, minecraft: MinecraftConfig): MappingsCo
 
         if (layerMojmap) {
             project.logger.lifecycle("[Unimined/MappingsProvider] Layering mojmap on top of spigot")
-            postProcess("spigot", {
+            postProcess(key, {
                 mojmap()
                 mapping(project.files(buildDataZip), key) {
-                    mapNamespace("spigot", "spigot-dev")
-                    outputs("spigot-dev", true) { listOf("official", "mojmap") }
+                    mapNamespace("spigot", "spigot_dev")
+                    outputs("spigot_dev", true) { listOf("official", "mojmap") }
                     dependsOn("mojmap")
-                    memberNameReplacer("spigot-dev", "mojmap", if (hasMembers) setOf("field") else setOf("method", "field", "method_arg", "method_var"))
+                    memberNameReplacer("spigot_dev", "mojmap", if (hasMembers) setOf("field") else setOf("method", "field", "method_arg", "method_var"))
                     renest()
                 }
             }) {
-                outputs("spigot-dev", true) { listOf("official") }
+                outputs("spigot_dev", true) { listOf("official") }
                 action()
             }
         } else {
             mapping(project.files(buildDataZip), key) {
-                mapNamespace("spigot", "spigot-dev")
-                outputs("spigot-dev", true) { listOf("official") }
+                mapNamespace("spigot", "spigot_dev")
+                outputs("spigot_dev", true) { listOf("official") }
                 renest()
                 action()
             }
         }
     }
 
     override fun postProcess(key: String, mappings: MappingsConfig.() -> Unit, merger: MappingDepConfig.() -> Unit) {
-        val mappingsConfig = MappingsProvider(project, minecraft)
+        val mappingsConfig = MappingsProvider(project, minecraft, "postProcess-$key")
         mappingsConfig.mappings()
         mappingsConfig.resolveMappingTree()
         mapping(project.dependencies.create(
@@ -639,7 +647,7 @@ class MappingsProvider(project: Project, minecraft: MinecraftConfig): MappingsCo
 
     private fun mappingCacheFile(): Path =
         (if (hasStubs) minecraft.localCache else project.unimined.getGlobalCache())
-            .resolve("mappings").resolve("mappings-${side}-${combinedNames}.tiny")
+            .resolve("mappings").resolve("${mappingKey}-${side}-${combinedNames}.tiny")
 
 
     override val combinedNames: String by lazy {