diff options
Diffstat (limited to 'src/main/java/com/replaymod/gradle')
6 files changed, 326 insertions, 133 deletions
diff --git a/src/main/java/com/replaymod/gradle/remap/PsiMapper.java b/src/main/java/com/replaymod/gradle/remap/PsiMapper.java index 17d0783..c1b2d41 100644 --- a/src/main/java/com/replaymod/gradle/remap/PsiMapper.java +++ b/src/main/java/com/replaymod/gradle/remap/PsiMapper.java @@ -18,7 +18,11 @@ import com.intellij.psi.PsiPackage; import com.intellij.psi.PsiQualifiedNamedElement; import com.intellij.psi.PsiSwitchLabelStatement; import com.intellij.psi.PsiTypeElement; -import com.replaymod.gradle.remap.Transformer.Mapping; +import org.cadixdev.bombe.type.signature.MethodSignature; +import org.cadixdev.lorenz.MappingSet; +import org.cadixdev.lorenz.model.ClassMapping; +import org.cadixdev.lorenz.model.Mapping; +import org.cadixdev.lorenz.model.MethodMapping; import java.util.ArrayDeque; import java.util.Arrays; @@ -27,6 +31,8 @@ import java.util.HashMap; import java.util.Map; import java.util.TreeMap; +import static com.replaymod.gradle.remap.PsiUtils.getSignature; + class PsiMapper { private static final String CLASS_MIXIN = "org.spongepowered.asm.mixin.Mixin"; private static final String CLASS_ACCESSOR = "org.spongepowered.asm.mixin.gen.Accessor"; @@ -34,17 +40,23 @@ class PsiMapper { private static final String CLASS_INJECT = "org.spongepowered.asm.mixin.injection.Inject"; private static final String CLASS_REDIRECT = "org.spongepowered.asm.mixin.injection.Redirect"; - private final Map<String, Mapping> map; - private final Map<String, Mapping> mixinMappings = new HashMap<>(); + private final MappingSet map; + private final Map<String, ClassMapping<?, ?>> mixinMappings = new HashMap<>(); private final PsiFile file; private boolean error; private TreeMap<TextRange, String> changes = new TreeMap<>(Comparator.comparing(TextRange::getStartOffset)); - PsiMapper(Map<String, Mapping> map, PsiFile file) { + PsiMapper(MappingSet map, PsiFile file) { this.map = map; this.file = file; } + private void error(PsiElement at, String message) { + int line = StringUtil.offsetToLineNumber(file.getText(), at.getTextOffset()); + System.err.println(file.getName() + ":" + line + ": " + message); + error = true; + } + private void replace(PsiElement e, String with) { changes.put(e.getTextRange(), with); } @@ -87,12 +99,12 @@ class PsiMapper { if (declaringClass == null) return; String name = declaringClass.getQualifiedName(); if (name == null) return; - Mapping mapping = this.mixinMappings.get(name); + ClassMapping<?, ?> mapping = this.mixinMappings.get(name); if (mapping == null) { - mapping = map.get(name); + mapping = map.getClassMapping(name).orElse(null); } if (mapping == null) return; - String mapped = mapping.fields.get(field.getName()); + String mapped = mapping.getFieldMapping(field.getName()).map(Mapping::getDeobfuscatedName).orElse(null); if (mapped == null || mapped.equals(field.getName())) return; replaceIdentifier(expr, mapped); @@ -100,20 +112,20 @@ class PsiMapper { && !((PsiJavaCodeReferenceElement) expr).isQualified() // qualified access is fine && !isSwitchCase(expr) // referencing constants in case statements is fine ) { - int line = StringUtil.offsetToLineNumber(file.getText(), expr.getTextOffset()); - System.err.println(file.getName() + ":" + line + ": Implicit member reference to remapped field \"" + field.getName() + "\". " + + error(expr, "Implicit member reference to remapped field \"" + field.getName() + "\". " + "This can cause issues if the remapped reference becomes shadowed by a local variable and is therefore forbidden. " + "Use \"this." + field.getName() + "\" instead."); - error = true; } } private void map(PsiElement expr, PsiMethod method) { + if (method.isConstructor()) return; + PsiClass declaringClass = method.getContainingClass(); if (declaringClass == null) return; ArrayDeque<PsiClass> parentQueue = new ArrayDeque<>(); parentQueue.offer(declaringClass); - Mapping mapping = null; + ClassMapping<?, ?> mapping = null; String name = declaringClass.getQualifiedName(); if (name != null) { @@ -121,7 +133,7 @@ class PsiMapper { } while (true) { if (mapping != null) { - String mapped = mapping.methods.get(method.getName()); + String mapped = mapping.getMethodMapping(getSignature(method)).map(Mapping::getDeobfuscatedName).orElse(null); if (mapped != null) { if (!mapped.equals(method.getName())) { replaceIdentifier(expr, mapped); @@ -144,7 +156,7 @@ class PsiMapper { name = declaringClass.getQualifiedName(); if (name == null) continue; - mapping = map.get(name); + mapping = map.getClassMapping(name).orElse(null); } } } @@ -152,10 +164,11 @@ class PsiMapper { private void map(PsiElement expr, PsiQualifiedNamedElement resolved) { String name = resolved.getQualifiedName(); if (name == null) return; - Mapping mapping = map.get(name); + ClassMapping<?, ?> mapping = map.getClassMapping(name).orElse(null); if (mapping == null) return; - String mapped = mapping.newName; + String mapped = mapping.getDeobfuscatedName(); if (mapped.equals(name)) return; + mapped = mapped.replace('/', '.'); if (expr.getText().equals(name)) { replace(expr, mapped); @@ -189,7 +202,7 @@ class PsiMapper { return null; } - private void remapAccessors(Mapping mapping) { + private void remapAccessors(ClassMapping<?, ?> mapping) { file.accept(new JavaRecursiveElementVisitor() { @Override public void visitMethod(PsiMethod method) { @@ -218,7 +231,7 @@ class PsiMapper { throw new IllegalArgumentException("Cannot determine accessor target for " + method); } - String mapped = mapping.fields.get(target); + String mapped = mapping.getFieldMapping(target).map(Mapping::getDeobfuscatedName).orElse(null); if (mapped != null && !mapped.equals(target)) { // Update accessor target String parameterList; @@ -235,7 +248,7 @@ class PsiMapper { }); } - private void remapInjectsAndRedirects(Mapping mapping) { + private void remapInjectsAndRedirects(ClassMapping<?, ?> mapping) { file.accept(new JavaRecursiveElementVisitor() { @Override public void visitMethod(PsiMethod method) { @@ -250,7 +263,21 @@ class PsiMapper { // Note: mixin supports multiple targets, we do not (yet) String literalValue = attribute.getLiteralValue(); if (literalValue == null) continue; - String mapped = mapping.methods.get(literalValue); + String mapped; + if (literalValue.contains("(")) { + mapped = mapping.getMethodMapping(MethodSignature.of(literalValue)).map(Mapping::getDeobfuscatedName).orElse(null); + } else { + mapped = null; + for (MethodMapping methodMapping : mapping.getMethodMappings()) { + if (methodMapping.getObfuscatedName().equals(literalValue)) { + String name = methodMapping.getDeobfuscatedName(); + if (mapped != null && !mapped.equals(name)) { + error(attribute, "Ambiguous mixin method \"" + literalValue + "\" maps to \"" + mapped + "\" and \"" + name + "\""); + } + mapped = name; + } + } + } if (mapped != null && !mapped.equals(literalValue)) { PsiAnnotationMemberValue value = attribute.getValue(); assert value != null; @@ -261,12 +288,12 @@ class PsiMapper { }); } - private Mapping remapInternalType(String internalType, StringBuilder result) { + private ClassMapping<?, ?> remapInternalType(String internalType, StringBuilder result) { if (internalType.charAt(0) == 'L') { String type = internalType.substring(1, internalType.length() - 1).replace('/', '.'); - Mapping mapping = map.get(type); + ClassMapping<?, ?> mapping = map.getClassMapping(type).orElse(null); if (mapping != null) { - result.append('L').append(mapping.newName.replace('.', '/')).append(';'); + result.append('L').append(mapping.getFullDeobfuscatedName()).append(';'); return mapping; } } @@ -287,10 +314,14 @@ class PsiMapper { String returnType = signature.substring(argsEnd + 1); StringBuilder builder = new StringBuilder(signature.length() + 32); - Mapping mapping = remapInternalType(owner, builder); + ClassMapping<?, ?> mapping = remapInternalType(owner, builder); String mapped = null; if (mapping != null) { - mapped = (method ? mapping.methods : mapping.fields).get(name); + mapped = (method + ? mapping.getMethodMapping(MethodSignature.of(signature.substring(ownerEnd + 1))) + : mapping.getFieldMapping(name)) + .map(Mapping::getDeobfuscatedName) + .orElse(null); } builder.append(mapped != null ? mapped : name); if (method) { @@ -350,16 +381,18 @@ class PsiMapper { PsiClass target = getMixinTarget(annotation); if (target == null) return; + String qualifiedName = target.getQualifiedName(); + if (qualifiedName == null) return; - Mapping mapping = map.get(target.getQualifiedName()); + ClassMapping<?, ?> mapping = map.getClassMapping(qualifiedName).orElse(null); if (mapping == null) return; mixinMappings.put(psiClass.getQualifiedName(), mapping); - if (!mapping.fields.isEmpty()) { + if (!mapping.getFieldMappings().isEmpty()) { remapAccessors(mapping); } - if (!mapping.methods.isEmpty()) { + if (!mapping.getMethodMappings().isEmpty()) { remapInjectsAndRedirects(mapping); } } diff --git a/src/main/java/com/replaymod/gradle/remap/PsiUtils.java b/src/main/java/com/replaymod/gradle/remap/PsiUtils.java new file mode 100644 index 0000000..ec4d1c8 --- /dev/null +++ b/src/main/java/com/replaymod/gradle/remap/PsiUtils.java @@ -0,0 +1,61 @@ +package com.replaymod.gradle.remap; + +import com.intellij.psi.PsiArrayType; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; +import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiPrimitiveType; +import com.intellij.psi.PsiType; +import com.intellij.psi.util.TypeConversionUtil; +import org.cadixdev.bombe.type.ArrayType; +import org.cadixdev.bombe.type.FieldType; +import org.cadixdev.bombe.type.MethodDescriptor; +import org.cadixdev.bombe.type.ObjectType; +import org.cadixdev.bombe.type.Type; +import org.cadixdev.bombe.type.VoidType; +import org.cadixdev.bombe.type.signature.MethodSignature; + +import java.util.Arrays; +import java.util.stream.Collectors; + +class PsiUtils { + static MethodSignature getSignature(PsiMethod method) { + return new MethodSignature(method.getName(), getDescriptor(method)); + } + + private static MethodDescriptor getDescriptor(PsiMethod method) { + return new MethodDescriptor( + Arrays.stream(method.getParameterList().getParameters()) + .map(it -> getFieldType(it.getType())) + .collect(Collectors.toList()), + getType(method.getReturnType()) + ); + } + + private static FieldType getFieldType(PsiType type) { + type = TypeConversionUtil.erasure(type); + if (type instanceof PsiPrimitiveType) { + return FieldType.of(((PsiPrimitiveType) type).getKind().getBinaryName()); + } else if (type instanceof PsiArrayType) { + PsiArrayType array = (PsiArrayType) type; + return new ArrayType(array.getArrayDimensions(), getFieldType(array.getDeepComponentType())); + } else if (type instanceof PsiClassType) { + PsiClass resolved = ((PsiClassType) type).resolve(); + if (resolved == null) throw new NullPointerException("Failed to resolve type " + type); + String qualifiedName = resolved.getQualifiedName(); + if (qualifiedName == null) throw new NullPointerException("Type " + type + " has no qualified name."); + return new ObjectType(qualifiedName); + } else { + throw new IllegalArgumentException("Cannot translate type " + type); + } + } + + private static Type getType(PsiType type) { + if (TypeConversionUtil.isVoidType(type)) { + return VoidType.INSTANCE; + } else { + return getFieldType(type); + } + } + +} diff --git a/src/main/java/com/replaymod/gradle/remap/Transformer.java b/src/main/java/com/replaymod/gradle/remap/Transformer.java index 1cbd425..8a9ec9c 100644 --- a/src/main/java/com/replaymod/gradle/remap/Transformer.java +++ b/src/main/java/com/replaymod/gradle/remap/Transformer.java @@ -11,6 +11,8 @@ import com.intellij.openapi.vfs.VirtualFileManager; import com.intellij.openapi.vfs.local.CoreLocalFileSystem; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; +import com.replaymod.gradle.remap.legacy.LegacyMapping; +import org.cadixdev.lorenz.MappingSet; import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys; import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot; import org.jetbrains.kotlin.cli.common.messages.MessageRenderer; @@ -37,21 +39,20 @@ import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; class Transformer { - private Map<String, Mapping> map; + private MappingSet map; private String[] classpath; private boolean fail; public static void main(String[] args) throws IOException { - Map<String, Mapping> mappings; + MappingSet mappings; if (args[0].isEmpty()) { - mappings = new HashMap<>(); + mappings = MappingSet.create(); } else { - mappings = readMappings(new File(args[0]), args[1].equals("true")); + mappings = LegacyMapping.readMappingSet(new File(args[0]).toPath(), args[1].equals("true")); } Transformer transformer = new Transformer(mappings); @@ -95,7 +96,7 @@ class Transformer { } } - public Transformer(Map<String, Mapping> mappings) { + public Transformer(MappingSet mappings) { this.map = mappings; } @@ -165,104 +166,4 @@ class Transformer { } } - public static class Mapping { - public String oldName; - public String newName; - public Map<String, String> fields = new HashMap<>(); - public Map<String, String> methods = new HashMap<>(); - } - - public static Map<String, Mapping> readMappings(File mappingFile, boolean invert) throws IOException { - Map<String, Mapping> mappings = new HashMap<>(); - Map<String, Mapping> revMappings = new HashMap<>(); - int lineNumber = 0; - for (String line : Files.readAllLines(mappingFile.toPath(), StandardCharsets.UTF_8)) { - lineNumber++; - if (line.trim().startsWith("#") || line.trim().isEmpty()) continue; - - String[] parts = line.split(" "); - if (parts.length < 2 || line.contains(";")) { - throw new IllegalArgumentException("Failed to parse line " + lineNumber + " in " + mappingFile.getPath() + "."); - } - - Mapping mapping = mappings.get(parts[0]); - if (mapping == null) { - mapping = new Mapping(); - mapping.oldName = mapping.newName = parts[0]; - mappings.put(mapping.oldName, mapping); - } - - if (parts.length == 2) { - // Class mapping - mapping.newName = parts[1]; - // Possibly merge with reverse mapping - Mapping revMapping = revMappings.remove(mapping.newName); - if (revMapping != null) { - mapping.fields.putAll(revMapping.fields); - mapping.methods.putAll(revMapping.methods); - } - revMappings.put(mapping.newName, mapping); - } else if (parts.length == 3 || parts.length == 4) { - String fromName = parts[1]; - String toName; - Mapping revMapping; - if (parts.length == 4) { - toName = parts[3]; - revMapping = revMappings.get(parts[2]); - if (revMapping == null) { - revMapping = new Mapping(); - revMapping.oldName = revMapping.newName = parts[2]; - revMappings.put(revMapping.newName, revMapping); - } - } else { - toName = parts[2]; - revMapping = mapping; - } - if (fromName.endsWith("()")) { - // Method mapping - fromName = fromName.substring(0, fromName.length() - 2); - toName = toName.substring(0, toName.length() - 2); - mapping.methods.put(fromName, toName); - revMapping.methods.put(fromName, toName); - } else { - // Field mapping - mapping.fields.put(fromName, toName); - revMapping.fields.put(fromName, toName); - } - } else { - throw new IllegalArgumentException("Failed to parse line " + lineNumber + " in " + mappingFile.getPath() + "."); - } - } - if (invert) { - Stream.concat( - mappings.values().stream(), - revMappings.values().stream() - ).distinct().forEach(it -> { - String oldName = it.oldName; - it.oldName = it.newName; - it.newName = oldName; - it.fields = it.fields.entrySet().stream().collect(Collectors.toMap(Entry::getValue, Entry::getKey)); - it.methods = it.methods.entrySet().stream().collect(Collectors.toMap(Entry::getValue, Entry::getKey)); - }); - } - return Stream.concat( - mappings.values().stream(), - revMappings.values().stream() - ).collect(Collectors.toMap(mapping -> mapping.oldName, Function.identity(), (mapping, other) -> { - if (!other.oldName.equals(other.newName)) { - if (!mapping.oldName.equals(mapping.newName) - && !other.oldName.equals(mapping.oldName) - && !other.newName.equals(mapping.newName)) { - throw new IllegalArgumentException("Conflicting mappings: " - + mapping.oldName + " -> " + mapping.newName - + " and " + other.oldName + " -> " + other.newName); - } - mapping.oldName = other.oldName; - mapping.newName = other.newName; - } - mapping.fields.putAll(other.fields); - mapping.methods.putAll(other.methods); - return mapping; - })); - } } diff --git a/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMapping.java b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMapping.java new file mode 100644 index 0000000..05a85d9 --- /dev/null +++ b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMapping.java @@ -0,0 +1,118 @@ +package com.replaymod.gradle.remap.legacy; + +import org.cadixdev.lorenz.MappingSet; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class LegacyMapping { + public static MappingSet readMappingSet(Path mappingFile, boolean invert) throws IOException { + return new LegacyMappingsReader(readMappings(mappingFile, invert)).read(); + } + + public static Map<String, LegacyMapping> readMappings(Path mappingFile, boolean invert) throws IOException { + Map<String, LegacyMapping> mappings = new HashMap<>(); + Map<String, LegacyMapping> revMappings = new HashMap<>(); + int lineNumber = 0; + for (String line : Files.readAllLines(mappingFile, StandardCharsets.UTF_8)) { + lineNumber++; + if (line.trim().startsWith("#") || line.trim().isEmpty()) continue; + + String[] parts = line.split(" "); + if (parts.length < 2 || line.contains(";")) { + throw new IllegalArgumentException("Failed to parse line " + lineNumber + " in " + mappingFile + "."); + } + + LegacyMapping mapping = mappings.get(parts[0]); + if (mapping == null) { + mapping = new LegacyMapping(); + mapping.oldName = mapping.newName = parts[0]; + mappings.put(mapping.oldName, mapping); + } + + if (parts.length == 2) { + // Class mapping + mapping.newName = parts[1]; + // Possibly merge with reverse mapping + LegacyMapping revMapping = revMappings.remove(mapping.newName); + if (revMapping != null) { + mapping.fields.putAll(revMapping.fields); + mapping.methods.putAll(revMapping.methods); + } + revMappings.put(mapping.newName, mapping); + } else if (parts.length == 3 || parts.length == 4) { + String fromName = parts[1]; + String toName; + LegacyMapping revMapping; + if (parts.length == 4) { + toName = parts[3]; + revMapping = revMappings.get(parts[2]); + if (revMapping == null) { + revMapping = new LegacyMapping(); + revMapping.oldName = revMapping.newName = parts[2]; + revMappings.put(revMapping.newName, revMapping); + } + } else { + toName = parts[2]; + revMapping = mapping; + } + if (fromName.endsWith("()")) { + // Method mapping + fromName = fromName.substring(0, fromName.length() - 2); + toName = toName.substring(0, toName.length() - 2); + mapping.methods.put(fromName, toName); + revMapping.methods.put(fromName, toName); + } else { + // Field mapping + mapping.fields.put(fromName, toName); + revMapping.fields.put(fromName, toName); + } + } else { + throw new IllegalArgumentException("Failed to parse line " + lineNumber + " in " + mappingFile + "."); + } + } + if (invert) { + Stream.concat( + mappings.values().stream(), + revMappings.values().stream() + ).distinct().forEach(it -> { + String oldName = it.oldName; + it.oldName = it.newName; + it.newName = oldName; + it.fields = it.fields.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey)); + it.methods = it.methods.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey)); + }); + } + return Stream.concat( + mappings.values().stream(), + revMappings.values().stream() + ).collect(Collectors.toMap(mapping -> mapping.oldName, Function.identity(), (mapping, other) -> { + if (!other.oldName.equals(other.newName)) { + if (!mapping.oldName.equals(mapping.newName) + && !other.oldName.equals(mapping.oldName) + && !other.newName.equals(mapping.newName)) { + throw new IllegalArgumentException("Conflicting mappings: " + + mapping.oldName + " -> " + mapping.newName + + " and " + other.oldName + " -> " + other.newName); + } + mapping.oldName = other.oldName; + mapping.newName = other.newName; + } + mapping.fields.putAll(other.fields); + mapping.methods.putAll(other.methods); + return mapping; + })); + } + + public String oldName; + public String newName; + public Map<String, String> fields = new HashMap<>(); + public Map<String, String> methods = new HashMap<>(); +} diff --git a/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.java b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.java new file mode 100644 index 0000000..eb72788 --- /dev/null +++ b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingSetModelFactory.java @@ -0,0 +1,36 @@ +package com.replaymod.gradle.remap.legacy; + +import org.cadixdev.bombe.type.signature.MethodSignature; +import org.cadixdev.lorenz.MappingSet; +import org.cadixdev.lorenz.impl.MappingSetModelFactoryImpl; +import org.cadixdev.lorenz.impl.model.TopLevelClassMappingImpl; +import org.cadixdev.lorenz.model.MethodMapping; +import org.cadixdev.lorenz.model.TopLevelClassMapping; + +import java.util.Optional; + +public class LegacyMappingSetModelFactory extends MappingSetModelFactoryImpl { + @Override + public TopLevelClassMapping createTopLevelClassMapping(MappingSet parent, String obfuscatedName, String deobfuscatedName) { + return new TopLevelClassMappingImpl(parent, obfuscatedName, deobfuscatedName) { + private MethodSignature stripDesc(MethodSignature signature) { + // actual descriptor isn't included in legacy format + return MethodSignature.of(signature.getName(), "()V"); + } + + @Override + public boolean hasMethodMapping(MethodSignature signature) { + return super.hasMethodMapping(signature) || super.hasMethodMapping(stripDesc(signature)); + } + + @Override + public Optional<MethodMapping> getMethodMapping(MethodSignature signature) { + Optional<MethodMapping> maybeMapping = super.getMethodMapping(signature); + if (!maybeMapping.isPresent() || !maybeMapping.get().hasMappings()) { + maybeMapping = super.getMethodMapping(stripDesc(signature)); + } + return maybeMapping; + } + }; + } +} diff --git a/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.java b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.java new file mode 100644 index 0000000..502f7ba --- /dev/null +++ b/src/main/java/com/replaymod/gradle/remap/legacy/LegacyMappingsReader.java @@ -0,0 +1,44 @@ +package com.replaymod.gradle.remap.legacy; + +import org.cadixdev.lorenz.MappingSet; +import org.cadixdev.lorenz.io.MappingsReader; +import org.cadixdev.lorenz.model.ClassMapping; + +import java.util.Map; + +public class LegacyMappingsReader extends MappingsReader { + private final Map<String, LegacyMapping> map; + + public LegacyMappingsReader(Map<String, LegacyMapping> map) { + this.map = map; + } + + @Override + public MappingSet read() { + return read(MappingSet.create(new LegacyMappingSetModelFactory())); + } + + @Override + public MappingSet read(MappingSet mappings) { + if (!(mappings.getModelFactory() instanceof LegacyMappingSetModelFactory)) { + throw new IllegalArgumentException("legacy mappings must use legacy model factory, use read() instead"); + } + for (LegacyMapping legacyMapping : map.values()) { + ClassMapping classMapping = mappings.getOrCreateClassMapping(legacyMapping.oldName) + .setDeobfuscatedName(legacyMapping.newName); + for (Map.Entry<String, String> entry : legacyMapping.fields.entrySet()) { + classMapping.getOrCreateFieldMapping(entry.getKey()) + .setDeobfuscatedName(entry.getValue()); + } + for (Map.Entry<String, String> entry : legacyMapping.methods.entrySet()) { + classMapping.getOrCreateMethodMapping(entry.getKey(), "()V") + .setDeobfuscatedName(entry.getValue()); + } + } + return mappings; + } + + @Override + public void close() { + } +} |