Add MappingTree#propagateOuterClassNames (#120)

Author: NebelNidas

CHANGELOG.md

@@ -5,6 +5,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 - Added a simplified `MappingNsCompleter` constructor for completing all destination names with the source names
+- Added `MappingTree#propagateOuterClassNames` as a more efficient tree-API alternative to `OuterClassNamePropagator`
 - Made `OuterClassNamePropagator` configurable
 - Made Enigma writer always output destination names if visited explicitly, establishing consistency across all writers
 - Adjusted format detection to only return ENIGMA_DIR for non-empty directories with at least one `.mapping` file

src/main/java/net/fabricmc/mappingio/adapter/OuterClassNamePropagator.java

@@ -259,8 +259,6 @@ public boolean visitEnd() throws IOException {
 	private final boolean processRemappedDstNames;
 	private final Map<String, String[]> dstNamesBySrcName = new HashMap<>();
 	private final Set<String> modifiedClasses = new HashSet<>();
-	private String srcNamespaceToProcess;
-	private int srcNsId;
 	private List<String> dstNamespaces;
 	private Collection<String> dstNamespacesToProcess;
 	private Collection<Integer> dstNamespaceIndicesToProcess;

src/main/java/net/fabricmc/mappingio/tree/MappingTree.java

@@ -16,8 +16,10 @@
 
 package net.fabricmc.mappingio.tree;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.regex.Pattern;
 
 import org.jetbrains.annotations.Nullable;
 
@@ -110,6 +112,86 @@ default ClassMapping getClass(String name, int namespace) {
 	@Nullable
 	ClassMapping removeClass(String srcName);
 
+	/**
+	 * Searches for inner classes whose effective destination name contains outer classes referenced via their source name,
+	 * scans the tree for potential mappings for these enclosing classes, and applies the latters' destination names
+	 * to the formers' fully qualified name.
+	 *
+	 * <p>For example, it takes a class {@code class_1$class_2} that doesn't have a mapping,
+	 * tries to find {@code class_1}, which let's say has the mapping {@code SomeClass},
+	 * and changes the former's destination name to {@code SomeClass$class_2}.
+	 *
+	 * <p>Equivalent of {@link OuterClassNameInheritingVisitor}, but more efficient
+	 * since the tree's existing class map can be reused.
+	 *
+	 * @param processRemappedDstNames Whether already remapped destination names should also get their unmapped outer classes replaced.
+	 */
+	default void propagateOuterClassNames(boolean processRemappedDstNames) {
+		propagateOuterClassNames(getSrcNamespace(), getDstNamespaces(), processRemappedDstNames);
+	}
+
+	/**
+	 * Searches for inner classes whose effective destination name contains outer classes referenced via their source name,
+	 * scans the tree for potential mappings for these enclosing classes, and applies the latters' destination names
+	 * to the formers' fully qualified name.
+	 *
+	 * <p>For example, it takes a class {@code class_1$class_2} that doesn't have a mapping,
+	 * tries to find {@code class_1}, which let's say has the mapping {@code SomeClass},
+	 * and changes the former's destination name to {@code SomeClass$class_2}.
+	 *
+	 * <p>Equivalent of {@link OuterClassNameInheritingVisitor}, but more efficient
+	 * since the tree's existing class map can be reused.
+	 *
+	 * @param srcNamespace The namespace where the original/unmapped outer class names originate from.
+	 * @param dstNamespaces The namespaces where outer class names shall be propagated.
+	 * @param processRemappedDstNames Whether already remapped destination names should also get their unmapped outer classes replaced.
+	 */
+	default void propagateOuterClassNames(String srcNamespace, Collection<String> dstNamespaces, boolean processRemappedDstNames) {
+		int srcNsId = getNamespaceId(srcNamespace);
+		if (srcNsId == NULL_NAMESPACE_ID) throw new IllegalArgumentException("Namespace " + srcNsId + " does not exist");
+
+		for (ClassMapping cls : getClasses()) {
+			for (String dstNs : dstNamespaces) {
+				int dstNsId = getNamespaceId(dstNs);
+				if (dstNsId == SRC_NAMESPACE_ID) throw new UnsupportedOperationException("Cannot change source names");
+				if (dstNsId == NULL_NAMESPACE_ID) throw new IllegalArgumentException("Destination namespace " + dstNs + " does not exist");
+				if (dstNsId == srcNsId) continue;
+
+				String srcName = cls.getName(srcNsId);
+				if (srcName == null) continue;
+				String dstName = cls.getName(dstNsId);
+
+				int idx = srcName.lastIndexOf('$');
+				if (idx == -1) continue;
+
+				if (!processRemappedDstNames && dstName != null && !dstName.equals(srcName)) {
+					continue;
+				}
+
+				String[] srcParts = srcName.split(Pattern.quote("$"));
+				String[] dstParts = dstName == null ? srcParts : dstName.split(Pattern.quote("$"));
+				assert dstParts.length == srcParts.length;
+
+				for (int pos = srcParts.length - 2; pos >= 0; pos--) {
+					String outerSrcName = String.join("$", Arrays.copyOfRange(srcParts, 0, pos + 1));
+
+					if (dstName != null && !dstParts[pos].equals(srcParts[pos])) {
+						// That part already has a different mapping
+						continue;
+					}
+
+					ClassMapping outerCls = getClass(outerSrcName, srcNsId);
+					String outerDstName;
+
+					if (outerCls != null && (outerDstName = outerCls.getName(dstNsId)) != null && !outerDstName.equals(outerSrcName)) {
+						cls.setDstName(outerDstName + "$" + String.join("$", Arrays.copyOfRange(dstParts, pos + 1, dstParts.length)), dstNsId);
+						break;
+					}
+				}
+			}
+		}
+	}
+
 	@Override
 	@Nullable
 	default FieldMapping getField(String srcClsName, String srcName, @Nullable String srcDesc) {

src/test/java/net/fabricmc/mappingio/test/tests/OuterClassNamePropagationTest.java

@@ -98,6 +98,34 @@ public void visitorThroughTree() throws IOException {
 		}
 	}
 
+	@Test
+	public void tree() throws IOException {
+		for (int pass = 1; pass <= 2; pass++) {
+			boolean processRemappedDstNames = pass == 1;
+
+			VisitableMappingTree tree = acceptMappings(new MemoryMappingTree());
+			tree.propagateOuterClassNames(processRemappedDstNames);
+			tree.accept(new OuterClassNameChecker(true, dstNamespaces, processRemappedDstNames));
+
+			checkDiskEquivalence(tree, processRemappedDstNames);
+		}
+
+		VisitableMappingTree tree = acceptMappings(new MemoryMappingTree());
+
+		assertThrows(UnsupportedOperationException.class, () -> tree.propagateOuterClassNames(
+				dstNamespaces.get(0),
+				Collections.singletonList(srcNamespace),
+				false));
+		assertThrows(IllegalArgumentException.class, () -> tree.propagateOuterClassNames(
+				invalidNs,
+				tree.getDstNamespaces(),
+				false));
+		assertThrows(IllegalArgumentException.class, () -> tree.propagateOuterClassNames(
+				tree.getSrcNamespace(),
+				Collections.singletonList(invalidNs),
+				false));
+	}
+
 	private void checkDiskEquivalence(VisitableMappingTree tree, boolean processRemappedDstNames) throws IOException {
 		for (MappingFormat format : MappingFormat.values()) {
 			MappingDir dir = processRemappedDstNames