Add method to map descriptors and fix method mapping on partial descriptors

Author: thecatcore

src/main/java/io/github/fabriccompatibiltylayers/modremappingapi/api/MappingUtils.java

@@ -5,26 +5,64 @@
 import org.jetbrains.annotations.Nullable;
 
 public interface MappingUtils {
+    /**
+     *
+     * @param className original class name
+     * @return remapped class name
+     */
     static String mapClass(String className) {
         return MappingsUtilsImpl.mapClass(className);
     }
 
+    /**
+     *
+     * @param className remapped class name
+     * @return original class name
+     */
     static String unmapClass(String className) {
         return MappingsUtilsImpl.unmapClass(className);
     }
 
+    /**
+     *
+     * @param className original class name
+     * @param fieldName
+     * @param fieldDesc
+     * @return
+     */
     static MappingUtils.ClassMember mapField(String className, String fieldName, @Nullable String fieldDesc) {
         return MappingsUtilsImpl.mapField(className, fieldName, fieldDesc);
     }
 
+    /**
+     *
+     * @param className remapped class name
+     * @param fieldName
+     * @param fieldDesc
+     * @return
+     */
     static MappingUtils.ClassMember mapFieldFromRemappedClass(String className, String fieldName, @Nullable String fieldDesc) {
         return MappingsUtilsImpl.mapFieldFromRemappedClass(className, fieldName, fieldDesc);
     }
 
+    /**
+     *
+     * @param className original class name
+     * @param methodName
+     * @param methodDesc
+     * @return
+     */
     static MappingUtils.ClassMember mapMethod(String className, String methodName, String methodDesc) {
         return MappingsUtilsImpl.mapMethod(className, methodName, methodDesc);
     }
 
+    /**
+     *
+     * @param className remapped class name
+     * @param methodName
+     * @param methodDesc
+     * @return
+     */
     static MappingUtils.ClassMember mapMethodFromRemappedClass(String className, String methodName, String methodDesc) {
         return MappingsUtilsImpl.mapMethodFromRemappedClass(className, methodName, methodDesc);
     }
@@ -37,6 +75,15 @@ static MappingUtils.ClassMember mapMethod(Class<?> owner, String methodName, Cla
         return MappingsUtilsImpl.mapMethod(owner, methodName, parameterTypes);
     }
 
+    /**
+     *
+     * @param desc original descriptor
+     * @return remapped descriptor
+     */
+    static String mapDescriptor(String desc) {
+        return MappingsUtilsImpl.mapDescriptor(desc);
+    }
+
     class ClassMember {
         public final @NotNull String name;
         public final @Nullable String desc;

src/main/java/io/github/fabriccompatibiltylayers/modremappingapi/impl/MappingsUtilsImpl.java

@@ -233,25 +233,9 @@ public static void completeMappingsFromTr(TrEnvironment trEnvironment) {
             }
         }
 
-        int propagated = 0;
-
-        for (Map.Entry<ExtendedClassMember, List<String>> entry : classMembers.entrySet()) {
-            List<String> toAdd = new ArrayList<>(entry.getValue());
-
-            while (!toAdd.isEmpty()) {
-                TrClass trClass = trEnvironment.getClass(toAdd.remove(0));
-                if (trClass == null) continue;
-
-                List<String> children = trClass.getChildren().stream().map(TrClass::getName).collect(Collectors.toList());
+        gatherChildClassCandidates(trEnvironment, classMembers);
 
-                for (String child : children) {
-                    if (!entry.getValue().contains(child)) {
-                        toAdd.add(child);
-                        entry.getValue().add(child);
-                    }
-                }
-            }
-        }
+        int propagated = 0;
 
         for (Map.Entry<ExtendedClassMember, List<String>> entry : classMembers.entrySet()) {
             ExtendedClassMember member = entry.getKey();
@@ -294,6 +278,26 @@ public static void completeMappingsFromTr(TrEnvironment trEnvironment) {
         System.out.println("Propagated: " + propagated + " methods");
     }
 
+    private static void gatherChildClassCandidates(TrEnvironment trEnvironment, Map<ExtendedClassMember, List<String>> classMembers) {
+        for (Map.Entry<ExtendedClassMember, List<String>> entry : classMembers.entrySet()) {
+            List<String> toAdd = new ArrayList<>(entry.getValue());
+
+            while (!toAdd.isEmpty()) {
+                TrClass trClass = trEnvironment.getClass(toAdd.remove(0));
+                if (trClass == null) continue;
+
+                List<String> children = trClass.getChildren().stream().map(TrClass::getName).collect(Collectors.toList());
+
+                for (String child : children) {
+                    if (!entry.getValue().contains(child)) {
+                        toAdd.add(child);
+                        entry.getValue().add(child);
+                    }
+                }
+            }
+        }
+    }
+
     static class ExtendedClassMember extends MappingUtils.ClassMember {
         public final String owner;
         public ExtendedClassMember(String name, @Nullable String desc, String owner) {
@@ -342,6 +346,11 @@ public static MappingUtils.ClassMember mapMethod(String className, String method
 
         MappingTree.MethodMapping methodMapping = FULL_MAPPINGS.getMethod(className, methodName, methodDesc, srcNamespace);
 
+        if (methodMapping == null) {
+            MappingTree.ClassMapping classMapping = FULL_MAPPINGS.getClass(className, srcNamespace);
+            if (classMapping != null) methodMapping = mapMethodWithPartialDesc(classMapping, methodName, methodDesc, srcNamespace);
+        }
+
         return mapMember(methodName, methodDesc, targetNamespace, methodMapping);
     }
 
@@ -353,9 +362,25 @@ public static MappingUtils.ClassMember mapMethodFromRemappedClass(String classNa
         if (classMapping == null) return new MappingUtils.ClassMember(methodName, methodDesc);
 
         MappingTree.MethodMapping methodMapping = classMapping.getMethod(methodName, methodDesc, srcNamespace);
+
+        if (methodMapping == null) methodMapping = mapMethodWithPartialDesc(classMapping, methodName, methodDesc, srcNamespace);
+
         return mapMember(methodName, methodDesc, targetNamespace, methodMapping);
     }
 
+    private static MappingTree.MethodMapping mapMethodWithPartialDesc(MappingTree.ClassMapping classMapping, String methodName, String methodDesc, int namespace) {
+        for (MappingTree.MethodMapping methodMapping : classMapping.getMethods()) {
+            String name = methodMapping.getName(namespace);
+            String desc = methodMapping.getDesc(namespace);
+
+            if (name != null && name.equals(methodName) && desc != null && desc.startsWith(methodDesc)) {
+                return methodMapping;
+            }
+        }
+
+        return null;
+    }
+
     @NotNull
     private static MappingUtils.ClassMember mapMember(String memberName, @Nullable String memberDesc, int targetNamespace, MappingTree.MemberMapping memberMapping) {
         if (memberMapping == null) return new MappingUtils.ClassMember(memberName, memberDesc);
@@ -429,4 +454,11 @@ private static String classTypeToDescriptor(Class<?>[] classTypes) {
 
         return desc + ")";
     }
+
+    public static String mapDescriptor(String desc) {
+        int srcNamespace = FULL_MAPPINGS.getNamespaceId("official");
+        int targetNamespace = FULL_MAPPINGS.getNamespaceId(getTargetNamespace());
+
+        return FULL_MAPPINGS.mapDesc(desc, srcNamespace, targetNamespace);
+    }
 }