rewrite source remapper to use tiny-mappings-parser

src/main/java/net/fabricmc/loom/task/RemapJar.java

@@ -26,18 +26,30 @@ package net.fabricmc.loom.task;
 
 import net.fabricmc.loom.util.ModRemapper;
 import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.TaskAction;
 
 import java.io.File;
 
 public class RemapJar extends DefaultLoomTask {
 	public File jar;
+	public File backupTo;
 
 	@Input
 	public File getJar() {
 		return jar;
 	}
 
+	@OutputFile
+	public File getBackupTo() {
+		if (backupTo == null) {
+			String s = jar.getAbsolutePath();
+			return new File(s.substring(0, s.length() - 4) + "-dev.jar");
+		}
+
+		return backupTo;
+	}
+
 	@TaskAction
 	public void remap() {
 		ModRemapper.remap(this);

src/main/java/net/fabricmc/loom/task/RemapSourcesJar.java

@@ -26,12 +26,14 @@ package net.fabricmc.loom.task;
 
 import net.fabricmc.loom.util.SourceRemapper;
 import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.TaskAction;
 
 import java.io.File;
 
 public class RemapSourcesJar extends DefaultLoomTask {
 	public File jar;
+	public File destinationJar;
 	public String direction = "intermediary";
 
 	@Input
@@ -39,8 +41,17 @@ public class RemapSourcesJar extends DefaultLoomTask {
 		return jar;
 	}
 
+	@OutputFile
+	public File getDestinationJar() {
+		if (destinationJar == null) {
+			return jar;
+		}
+
+		return destinationJar;
+	}
+
 	@TaskAction
 	public void remap() throws Exception {
-		SourceRemapper.remapSources(getProject(), jar, jar, direction.equals("named"));
+		SourceRemapper.remapSources(getProject(), getJar(), getDestinationJar(), direction.equals("named"));
 	}
 }

src/main/java/net/fabricmc/loom/util/ModRemapper.java

@@ -45,7 +45,7 @@ public class ModRemapper {
 		Project project = task.getProject();
 		LoomGradleExtension extension = project.getExtensions().getByType(LoomGradleExtension.class);
 
-		File modJar = task.jar;
+		File modJar = task.getJar();
 
 		if (!modJar.exists()) {
 			project.getLogger().error("Source .JAR not found!");
@@ -78,7 +78,7 @@ public class ModRemapper {
 		File modJarOutput = new File(s.substring(0, s.length() - 4) + ".remapped.jar");
 		Path modJarOutputPath = modJarOutput.toPath();
 
-		File modJarUnmappedCopy = new File(s.substring(0, s.length() - 4) + "-dev.jar");
+		File modJarUnmappedCopy = task.getBackupTo();
 		if (modJarUnmappedCopy.exists()) {
 			modJarUnmappedCopy.delete();
 		}

src/main/java/net/fabricmc/loom/util/SourceRemapper.java

@@ -27,11 +27,13 @@ package net.fabricmc.loom.util;
 import com.google.common.collect.ImmutableMap;
 import net.fabricmc.loom.LoomGradleExtension;
 import net.fabricmc.loom.providers.MappingsProvider;
+import net.fabricmc.mappings.*;
 import net.fabricmc.stitch.util.Pair;
 import net.fabricmc.stitch.util.StitchUtil;
 import org.cadixdev.lorenz.MappingSet;
 import org.cadixdev.lorenz.io.MappingsReader;
 import org.cadixdev.lorenz.io.TextMappingsReader;
+import org.cadixdev.lorenz.model.Mapping;
 import org.cadixdev.mercury.Mercury;
 import org.cadixdev.mercury.remapper.MercuryRemapper;
 import org.gradle.api.Project;
@@ -56,18 +58,13 @@ public class SourceRemapper {
 	}
 
 	private static void remapSourcesInner(Project project, File source, File destination, boolean toNamed) throws Exception {
-
 		LoomGradleExtension extension = project.getExtensions().getByType(LoomGradleExtension.class);
 		MappingsProvider mappingsProvider = extension.getMappingsProvider();
 
 		MappingSet mappings = extension.getOrCreateSrcMappingCache(toNamed ? 1 : 0, () -> {
-			try {
+			try (FileInputStream stream = new FileInputStream(mappingsProvider.MAPPINGS_TINY)) {
 				project.getLogger().lifecycle(":loading " + (toNamed ? "intermediary -> named" : "named -> intermediary") + " source mappings");
-
+				return new TinyReader(stream, toNamed ? "intermediary" : "named", toNamed ? "named" : "intermediary").read();
-				FileReader mappingsReader = new FileReader(mappingsProvider.MAPPINGS_TINY);
-				MappingSet mappingsOut = new TinyReader(mappingsReader, toNamed ? "intermediary" : "named", toNamed ? "named" : "intermediary").read();
-				mappingsReader.close();
-				return mappingsOut;
 			} catch (Exception e) {
 				throw new RuntimeException(e);
 			}
@@ -142,110 +139,41 @@ public class SourceRemapper {
 		}
 	}
 
-	static class SimpleClassMapper extends Remapper {
-		final Map<String, String> classMap;
-
-		public SimpleClassMapper(Map<String, String> map) {
-			this.classMap = map;
-		}
-
-		public String map(String typeName) {
-			return this.classMap.getOrDefault(typeName, typeName);
-		}
-	}
-
-	// With help from jamierocks; heavily modified
 	public static class TinyReader extends MappingsReader {
-		private final Reader reader;
+		private final InputStream stream;
-		private final String to;
+		private final String from, to;
-		private final String from;
 
-		private int toOffset = 0;
+		public TinyReader(InputStream stream, String from, String to) {
-		private int fromOffset = 1;
+			this.stream = stream;
-		private int lineNumber = 0;
-
-		public TinyReader(Reader reader, String from, String to) {
-			this.reader = reader;
 			this.from = from;
 			this.to = to;
 		}
 
-		//This looks at the first line of the tiny file and finds the column of the mappings, horrible but works.
-		public Pair<Integer, Integer> getMappingOffset(String to, String from, String line){
-			int toOffset = -1;
-			int fromOffset = -1;
-			String[] split = line.split("\t");
-			for (int i = 0; i < split.length; i++) {
-				String mapping = split[i];
-				if(mapping.equalsIgnoreCase(to)){
-					fromOffset = i -1;
-				}
-				if(mapping.equalsIgnoreCase(from)){
-					toOffset = i -1;
-				}
-			}
-			return Pair.of(toOffset, fromOffset);
-		}
-
 		@Override
 		public MappingSet read(final MappingSet mappings) throws IOException {
-			// As TinyV1 stores descriptors in obfuscated format always, we need to take a two-step approach.
+			Mappings m = net.fabricmc.mappings.MappingsProvider.readTinyMappings(stream, false);
-			Map<String, String> classNames = new HashMap<>();
-			List<String[]> otherNames = new ArrayList<>();
-			SimpleClassMapper classMapper = new SimpleClassMapper(classNames);
-			BufferedReader br = new BufferedReader(reader);
 
-			br.lines().forEach((line) -> {
+			for (ClassEntry entry : m.getClassEntries()) {
-				final String[] params = line.split("\t");
+				mappings.getOrCreateClassMapping(entry.get(from))
-				if ((lineNumber++) == 0) {
+						.setDeobfuscatedName(entry.get(to));
-					if (params.length < 1) {
+			}
-						throw new RuntimeException("Invalid mapping file!");
-					} else if (params.length < 3 || !params[0].equals("v1")) {
-						throw new RuntimeException("Invalid mapping version: '" + params[0] + "'!");
-					}
 
-					Pair<Integer, Integer> offset = getMappingOffset(to, from, line);
+			for (FieldEntry entry : m.getFieldEntries()) {
-					// System.out.println("To: " + to + " From: " + from + " toOffset:" + offset.getLeft() + " from:" + offset.getRight());
+				EntryTriple fromEntry = entry.get(from);
-					toOffset = offset.getLeft();
+				EntryTriple toEntry = entry.get(to);
-					fromOffset = offset.getRight();
-				} else {
-					switch (params[0]) {
-						case "CLASS": {
-							mappings.getOrCreateClassMapping(params[1 + toOffset])
-									.setDeobfuscatedName(params[1 + fromOffset]);
-							classNames.put(params[1], params[1 + toOffset]);
-							// System.out.println("Class " + params[1 + toOffset] + " -> " + params[1 + fromOffset]);
-							return;
-						}
-						case "FIELD":
-						case "METHOD": {
-							otherNames.add(params);
-							return;
-						}
-					}
-				}
-			});
-			br.close();
 
-			for (String[] params : otherNames) {
+				mappings.getOrCreateClassMapping(fromEntry.getOwner())
-				switch (params[0]) {
+						.getOrCreateFieldMapping(fromEntry.getName(), fromEntry.getDesc())
-					case "FIELD": {
+						.setDeobfuscatedName(toEntry.getName());
-						mappings.getOrCreateClassMapping(classMapper.map(params[1]))
+			}
-								.getOrCreateFieldMapping(params[3 + toOffset], classMapper.mapDesc(params[2]))
-								.setDeobfuscatedName(params[3 + fromOffset]);
 
-						// System.out.println("Field " + params[3 + toOffset] + classMapper.mapDesc(params[2]) + " -> " + params[3 + fromOffset]);
+			for (MethodEntry entry : m.getMethodEntries()) {
-						break;
+				EntryTriple fromEntry = entry.get(from);
-					}
+				EntryTriple toEntry = entry.get(to);
-					case "METHOD": {
-						mappings.getOrCreateClassMapping(classMapper.map(params[1]))
-								.getOrCreateMethodMapping(params[3 + toOffset], classMapper.mapMethodDesc(params[2]))
-								.setDeobfuscatedName(params[3 + fromOffset]);
 
-						// System.out.println("Method " + params[3 + toOffset] + classMapper.mapMethodDesc(params[2]) + " -> " + params[3 + fromOffset]);
+				mappings.getOrCreateClassMapping(fromEntry.getOwner())
-						break;
+						.getOrCreateMethodMapping(fromEntry.getName(), fromEntry.getDesc())
-					}
+						.setDeobfuscatedName(toEntry.getName());
-				}
 			}
 
 			return mappings;