Fix old mappings not properly being removed

3 files changed, 96 insertions, 78 deletions

diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
index be9e7416..8f3f2b2b 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
@@ -573,6 +573,22 @@ public class ClassMapping implements Comparable<ClassMapping> {
                 return this;
         }
 
+        public ClassMapping copy() {
+                ClassMapping copied = new ClassMapping(this.obfFullName);
+                copied.obfSimpleName= this.obfSimpleName;
+                copied.modifier = this.modifier;
+                copied.deobfFullName = this.deobfFullName;
+                copied.deobfName = this.deobfName;
+                copied.innerClassesByDeobf = this.innerClassesByDeobf;
+                copied.innerClassesByObfFull = this.innerClassesByObfFull;
+                copied.innerClassesByObfSimple = this.innerClassesByObfSimple;
+                copied.fieldsByObf = this.fieldsByObf;
+                copied.fieldsByDeobf = this.fieldsByDeobf;
+                copied.methodsByObf = this.methodsByObf;
+                copied.methodsByDeobf = this.methodsByDeobf;
+                return copied;
+        }
+
         @Override
         public int hashCode() {
                 return this.obfFullName.hashCode();
diff --git a/src/main/java/cuchaz/enigma/mapping/Mappings.java b/src/main/java/cuchaz/enigma/mapping/Mappings.java
index 307b1bd4..3ef1be52 100644
--- a/src/main/java/cuchaz/enigma/mapping/Mappings.java
+++ b/src/main/java/cuchaz/enigma/mapping/Mappings.java
@@ -23,6 +23,7 @@ import cuchaz.enigma.throwables.MappingConflict;
 import java.io.File;
 import java.io.IOException;
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class Mappings {
 
@@ -47,10 +48,6 @@ public class Mappings {
         }
 
         public void addClassMapping(ClassMapping classMapping) throws MappingConflict {
-                if (classMapping.isObfuscated()) {
-                        return;
-                }
-
                 if (this.classesByObf.containsKey(classMapping.getObfFullName())) {
                         throw new MappingConflict("class", classMapping.getObfFullName(), this.classesByObf.get(classMapping.getObfFullName()).getObfFullName());
                 }
@@ -217,8 +214,14 @@ public class Mappings {
 
         public void savePreviousState() {
                 this.previousState = new Mappings(this.originMapping);
-                this.previousState.classesByDeobf = Maps.newHashMap(this.classesByDeobf);
-                this.previousState.classesByObf = Maps.newHashMap(this.classesByObf);
+                this.previousState.classesByDeobf = new HashMap<>();
+                for (Map.Entry<String, ClassMapping> entry : this.classesByDeobf.entrySet()) {
+                        this.previousState.classesByDeobf.put(entry.getKey(), entry.getValue().copy());
+                }
+                this.previousState.classesByObf = new HashMap<>();
+                for (Map.Entry<String, ClassMapping> entry : this.classesByObf.entrySet()) {
+                        this.previousState.classesByObf.put(entry.getKey(), entry.getValue().copy());
+                }
                 classesByDeobf.values().forEach(ClassMapping::resetDirty);
                 classesByObf.values().forEach(ClassMapping::resetDirty);
         }
diff --git a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
index d1d5634a..a53793d3 100644
--- a/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
+++ b/src/main/java/cuchaz/enigma/mapping/MappingsEnigmaReader.java
@@ -39,88 +39,87 @@ public class MappingsEnigmaReader {
         }
 
         public Mappings readFile(Mappings mappings, File file) throws IOException, MappingParseException {
+                try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), Charsets.UTF_8))) {
+                        Deque<Object> mappingStack = Queues.newArrayDeque();
+
+                        int lineNumber = 0;
+                        String line;
+                        while ((line = in.readLine()) != null) {
+                                lineNumber++;
+
+                                // strip comments
+                                int commentPos = line.indexOf('#');
+                                if (commentPos >= 0) {
+                                        line = line.substring(0, commentPos);
+                                }
 
-                BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), Charsets.UTF_8));
-                Deque<Object> mappingStack = Queues.newArrayDeque();
-
-                int lineNumber = 0;
-                String line;
-                while ((line = in.readLine()) != null) {
-                        lineNumber++;
-
-                        // strip comments
-                        int commentPos = line.indexOf('#');
-                        if (commentPos >= 0) {
-                                line = line.substring(0, commentPos);
-                        }
-
-                        // skip blank lines
-                        if (line.trim().length() <= 0) {
-                                continue;
-                        }
+                                // skip blank lines
+                                if (line.trim().length() <= 0) {
+                                        continue;
+                                }
 
-                        // get the indent of this line
-                        int indent = 0;
-                        for (int i = 0; i < line.length(); i++) {
-                                if (line.charAt(i) != '\t') {
-                                        break;
+                                // get the indent of this line
+                                int indent = 0;
+                                for (int i = 0; i < line.length(); i++) {
+                                        if (line.charAt(i) != '\t') {
+                                                break;
+                                        }
+                                        indent++;
                                 }
-                                indent++;
-                        }
 
-                        // handle stack pops
-                        while (indent < mappingStack.size()) {
-                                mappingStack.pop();
-                        }
+                                // handle stack pops
+                                while (indent < mappingStack.size()) {
+                                        mappingStack.pop();
+                                }
 
-                        String[] parts = line.trim().split("\\s");
-                        try {
-                                // read the first token
-                                String token = parts[0];
-
-                                if (token.equalsIgnoreCase("CLASS")) {
-                                        ClassMapping classMapping;
-                                        if (indent <= 0) {
-                                                // outer class
-                                                classMapping = readClass(parts, false);
-                                                mappings.addClassMapping(classMapping);
-                                        } else {
-
-                                                // inner class
-                                                if (!(mappingStack.peek() instanceof ClassMapping)) {
-                                                        throw new MappingParseException(file, lineNumber, "Unexpected CLASS entry here!");
+                                String[] parts = line.trim().split("\\s");
+                                try {
+                                        // read the first token
+                                        String token = parts[0];
+
+                                        if (token.equalsIgnoreCase("CLASS")) {
+                                                ClassMapping classMapping;
+                                                if (indent <= 0) {
+                                                        // outer class
+                                                        classMapping = readClass(parts, false);
+                                                        mappings.addClassMapping(classMapping);
+                                                } else {
+
+                                                        // inner class
+                                                        if (!(mappingStack.peek() instanceof ClassMapping)) {
+                                                                throw new MappingParseException(file, lineNumber, "Unexpected CLASS entry here!");
+                                                        }
+
+                                                        classMapping = readClass(parts, true);
+                                                        ((ClassMapping) mappingStack.peek()).addInnerClassMapping(classMapping);
                                                 }
-
-                                                classMapping = readClass(parts, true);
-                                                ((ClassMapping) mappingStack.peek()).addInnerClassMapping(classMapping);
-                                        }
-                                        mappingStack.push(classMapping);
-                                } else if (token.equalsIgnoreCase("FIELD")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected FIELD entry here!");
-                                        }
-                                        ((ClassMapping) mappingStack.peek()).addFieldMapping(readField(parts));
-                                } else if (token.equalsIgnoreCase("METHOD")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected METHOD entry here!");
-                                        }
-                                        MethodMapping methodMapping = readMethod(parts);
-                                        ((ClassMapping) mappingStack.peek()).addMethodMapping(methodMapping);
-                                        mappingStack.push(methodMapping);
-                                } else if (token.equalsIgnoreCase("ARG")) {
-                                        if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof MethodMapping)) {
-                                                throw new MappingParseException(file, lineNumber, "Unexpected ARG entry here!");
+                                                mappingStack.push(classMapping);
+                                        } else if (token.equalsIgnoreCase("FIELD")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(file, lineNumber, "Unexpected FIELD entry here!");
+                                                }
+                                                ((ClassMapping) mappingStack.peek()).addFieldMapping(readField(parts));
+                                        } else if (token.equalsIgnoreCase("METHOD")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof ClassMapping)) {
+                                                        throw new MappingParseException(file, lineNumber, "Unexpected METHOD entry here!");
+                                                }
+                                                MethodMapping methodMapping = readMethod(parts);
+                                                ((ClassMapping) mappingStack.peek()).addMethodMapping(methodMapping);
+                                                mappingStack.push(methodMapping);
+                                        } else if (token.equalsIgnoreCase("ARG")) {
+                                                if (mappingStack.isEmpty() || !(mappingStack.peek() instanceof MethodMapping)) {
+                                                        throw new MappingParseException(file, lineNumber, "Unexpected ARG entry here!");
+                                                }
+                                                ((MethodMapping) mappingStack.peek()).addArgumentMapping(readArgument(parts));
                                         }
-                                        ((MethodMapping) mappingStack.peek()).addArgumentMapping(readArgument(parts));
+                                } catch (ArrayIndexOutOfBoundsException | IllegalArgumentException ex) {
+                                        throw new MappingParseException(file, lineNumber, "Malformed line:\n" + line);
+                                } catch (MappingConflict e) {
+                                        throw new MappingParseException(file, lineNumber, e.getMessage());
                                 }
-                        } catch (ArrayIndexOutOfBoundsException | IllegalArgumentException ex) {
-                                throw new MappingParseException(file, lineNumber, "Malformed line:\n" + line);
-                        } catch (MappingConflict e) {
-                                throw new MappingParseException(file, lineNumber, e.getMessage());
                         }
+                        return mappings;
                 }
-                in.close();
-                return mappings;
         }
 
         private LocalVariableMapping readArgument(String[] parts) {