add tracking for mismatched fields/methods

4 files changed, 141 insertions, 65 deletions

diff --git a/src/cuchaz/enigma/ConvertMain.java b/src/cuchaz/enigma/ConvertMain.java
index 975cdcc8..2afd9ca9 100644
--- a/src/cuchaz/enigma/ConvertMain.java
+++ b/src/cuchaz/enigma/ConvertMain.java
@@ -10,8 +10,8 @@ import cuchaz.enigma.convert.MappingsConverter;
 import cuchaz.enigma.convert.Matches;
 import cuchaz.enigma.convert.MatchesReader;
 import cuchaz.enigma.convert.MatchesWriter;
-import cuchaz.enigma.gui.MatchingGui;
-import cuchaz.enigma.gui.MatchingGui.SaveListener;
+import cuchaz.enigma.gui.ClassMatchingGui;
+import cuchaz.enigma.gui.ClassMatchingGui.SaveListener;
 import cuchaz.enigma.mapping.MappingParseException;
 import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MappingsReader;
@@ -58,11 +58,11 @@ public class ConvertMain {
                 Matches matches = MatchesReader.read(matchingFile);
                 System.out.println("Indexing source jar...");
                 Deobfuscator sourceDeobfuscator = new Deobfuscator(sourceJar);
-                sourceDeobfuscator.setMappings(mappings, false);
+                sourceDeobfuscator.setMappings(mappings);
                 System.out.println("Indexing dest jar...");
                 Deobfuscator destDeobfuscator = new Deobfuscator(destJar);
                 System.out.println("Starting GUI...");
-                new MatchingGui(matches, sourceDeobfuscator, destDeobfuscator).setSaveListener(new SaveListener() {
+                new ClassMatchingGui(matches, sourceDeobfuscator, destDeobfuscator).setSaveListener(new SaveListener() {
                         @Override
                         public void save(Matches matches) {
                                 try {
diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 9b0d3db4..35cfd0b6 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -26,7 +26,6 @@ import java.util.jar.JarOutputStream;
 import javassist.CtClass;
 import javassist.bytecode.Descriptor;
 
-import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.strobel.assembler.metadata.MetadataSystem;
@@ -43,7 +42,6 @@ import com.strobel.decompiler.languages.java.ast.InsertParenthesesVisitor;
 import cuchaz.enigma.analysis.EntryReference;
 import cuchaz.enigma.analysis.JarClassIterator;
 import cuchaz.enigma.analysis.JarIndex;
-import cuchaz.enigma.analysis.RelatedMethodChecker;
 import cuchaz.enigma.analysis.SourceIndex;
 import cuchaz.enigma.analysis.SourceIndexVisitor;
 import cuchaz.enigma.analysis.Token;
@@ -53,10 +51,10 @@ import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.ClassMapping;
 import cuchaz.enigma.mapping.ConstructorEntry;
 import cuchaz.enigma.mapping.Entry;
-import cuchaz.enigma.mapping.EntryFactory;
 import cuchaz.enigma.mapping.FieldEntry;
 import cuchaz.enigma.mapping.FieldMapping;
 import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsChecker;
 import cuchaz.enigma.mapping.MappingsRenamer;
 import cuchaz.enigma.mapping.MethodEntry;
 import cuchaz.enigma.mapping.MethodMapping;
@@ -125,19 +123,26 @@ public class Deobfuscator {
                 }
                 
                 // drop mappings that don't match the jar
-                RelatedMethodChecker relatedMethodChecker = new RelatedMethodChecker(m_jarIndex);
-                for (ClassMapping classMapping : Lists.newArrayList(val.classes())) {
-                        if (!checkClassMapping(relatedMethodChecker, classMapping, warnAboutDrops)) {
-                                if (warnAboutDrops) {
-                                        System.err.println("WARNING: unable to find class " + classMapping.getObfFullName() + ". dropping mapping");
-                                }
-                                val.removeClassMapping(classMapping);
+                MappingsChecker checker = new MappingsChecker(m_jarIndex);
+                checker.dropBrokenMappings(val);
+                if (warnAboutDrops) {
+                        for (java.util.Map.Entry<ClassEntry,ClassMapping> mapping : checker.getDroppedClassMappings().entrySet()) {
+                                System.out.println("WARNING: Couldn't find class entry " + mapping.getKey() + " (" + mapping.getValue().getDeobfName() + ") in jar. Mapping was dropped.");
+                        }
+                        for (java.util.Map.Entry<ClassEntry,ClassMapping> mapping : checker.getDroppedInnerClassMappings().entrySet()) {
+                                System.out.println("WARNING: Couldn't find inner class entry " + mapping.getKey() + " (" + mapping.getValue().getDeobfName() + ") in jar. Mapping was dropped.");
+                        }
+                        for (java.util.Map.Entry<FieldEntry,FieldMapping> mapping : checker.getDroppedFieldMappings().entrySet()) {
+                                System.out.println("WARNING: Couldn't find field entry " + mapping.getKey() + " (" + mapping.getValue().getDeobfName() + ") in jar. Mapping was dropped.");
+                        }
+                        for (java.util.Map.Entry<BehaviorEntry,MethodMapping> mapping : checker.getDroppedMethodMappings().entrySet()) {
+                                System.out.println("WARNING: Couldn't find behavior entry " + mapping.getKey() + " (" + mapping.getValue().getDeobfName() + ") in jar. Mapping was dropped.");
                         }
                 }
                 
                 // check for related method inconsistencies
-                if (relatedMethodChecker.hasProblems()) {
-                        throw new Error("Related methods are inconsistent! Need to fix the mappings manually.\n" + relatedMethodChecker.getReport());
+                if (checker.getRelatedMethodChecker().hasProblems()) {
+                        throw new Error("Related methods are inconsistent! Need to fix the mappings manually.\n" + checker.getRelatedMethodChecker().getReport());
                 }
                 
                 m_mappings = val;
@@ -145,51 +150,6 @@ public class Deobfuscator {
                 m_translatorCache.clear();
         }
         
-        private boolean checkClassMapping(RelatedMethodChecker relatedMethodChecker, ClassMapping classMapping, boolean warnAboutDrops) {
-                
-                // check the class
-                ClassEntry classEntry = EntryFactory.getObfClassEntry(m_jarIndex, classMapping);
-                if (!m_jarIndex.getObfClassEntries().contains(classEntry)) {
-                        return false;
-                }
-                
-                // check the fields
-                for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
-                        FieldEntry fieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
-                        if (!m_jarIndex.containsObfField(fieldEntry)) {
-                                if (warnAboutDrops) {
-                                        System.err.println("WARNING: unable to find field " + fieldEntry + ". dropping mapping.");
-                                }
-                                classMapping.removeFieldMapping(fieldMapping);
-                        }
-                }
-                
-                // check methods
-                for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
-                        BehaviorEntry obfBehaviorEntry = EntryFactory.getObfBehaviorEntry(classEntry, methodMapping);
-                        if (!m_jarIndex.containsObfBehavior(obfBehaviorEntry)) {
-                                if (warnAboutDrops) {
-                                        System.err.println("WARNING: unable to find behavior " + obfBehaviorEntry + ". dropping mapping.");
-                                }
-                                classMapping.removeMethodMapping(methodMapping);
-                        }
-                        
-                        relatedMethodChecker.checkMethod(classEntry, methodMapping);
-                }
-                
-                // check inner classes
-                for (ClassMapping innerClassMapping : Lists.newArrayList(classMapping.innerClasses())) {
-                        if (!checkClassMapping(relatedMethodChecker, innerClassMapping, warnAboutDrops)) {
-                                if (warnAboutDrops) {
-                                        System.err.println("WARNING: unable to find inner class " + EntryFactory.getObfClassEntry(m_jarIndex, classMapping) + ". dropping mapping.");
-                                }
-                                classMapping.removeInnerClassMapping(innerClassMapping);
-                        }
-                }
-                
-                return true;
-        }
-        
         public Translator getTranslator(TranslationDirection direction) {
                 Translator translator = m_translatorCache.get(direction);
                 if (translator == null) {
diff --git a/src/cuchaz/enigma/gui/MatchingGui.java b/src/cuchaz/enigma/gui/ClassMatchingGui.java
index 85842c12..ff7cda99 100644
--- a/src/cuchaz/enigma/gui/MatchingGui.java
+++ b/src/cuchaz/enigma/gui/ClassMatchingGui.java
@@ -44,10 +44,12 @@ import cuchaz.enigma.convert.Matches;
 import cuchaz.enigma.gui.ClassSelector.ClassSelectionListener;
 import cuchaz.enigma.mapping.ClassEntry;
 import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.Mappings;
+import cuchaz.enigma.mapping.MappingsChecker;
 import de.sciss.syntaxpane.DefaultSyntaxKit;
 
 
-public class MatchingGui {
+public class ClassMatchingGui {
         
         private static enum SourceType {
                 Matched {
@@ -112,7 +114,7 @@ public class MatchingGui {
         private SourceType m_sourceType;
         private SaveListener m_saveListener;
 
-        public MatchingGui(Matches matches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) {
+        public ClassMatchingGui(Matches matches, Deobfuscator sourceDeobfuscator, Deobfuscator destDeobfuscator) {
                 
                 m_matches = matches;
                 m_sourceDeobfuscator = sourceDeobfuscator;
@@ -263,12 +265,29 @@ public class MatchingGui {
         }
 
         private void updateDestMappings() {
-                m_destDeobfuscator.setMappings(MappingsConverter.newMappings(
+                
+                Mappings newMappings = MappingsConverter.newMappings(
                         m_matches,
                         m_sourceDeobfuscator.getMappings(),
                         m_sourceDeobfuscator,
                         m_destDeobfuscator
-                ), false);
+                );
+                
+                // look for dropped mappings
+                MappingsChecker checker = new MappingsChecker(m_destDeobfuscator.getJarIndex());
+                checker.dropBrokenMappings(newMappings);
+                
+                // count them
+                int numDroppedFields = checker.getDroppedFieldMappings().size();
+                int numDroppedMethods = checker.getDroppedMethodMappings().size();
+                System.out.println(String.format(
+                        "%d mappings from matched classes don't match the dest jar:\n\t%5d fields\n\t%5d methods",
+                        numDroppedFields + numDroppedMethods,
+                        numDroppedFields,
+                        numDroppedMethods
+                ));
+                
+                m_destDeobfuscator.setMappings(newMappings);
         }
 
         protected void setSourceType(SourceType val) {
diff --git a/src/cuchaz/enigma/mapping/MappingsChecker.java b/src/cuchaz/enigma/mapping/MappingsChecker.java
new file mode 100644
index 00000000..c5ff7a7e
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/MappingsChecker.java
@@ -0,0 +1,97 @@
+package cuchaz.enigma.mapping;
+
+import java.util.Map;
+
+import com.beust.jcommander.internal.Maps;
+import com.google.common.collect.Lists;
+
+import cuchaz.enigma.analysis.JarIndex;
+import cuchaz.enigma.analysis.RelatedMethodChecker;
+
+
+public class MappingsChecker {
+        
+        private JarIndex m_index;
+        private RelatedMethodChecker m_relatedMethodChecker;
+        private Map<ClassEntry,ClassMapping> m_droppedClassMappings;
+        private Map<ClassEntry,ClassMapping> m_droppedInnerClassMappings;
+        private Map<FieldEntry,FieldMapping> m_droppedFieldMappings;
+        private Map<BehaviorEntry,MethodMapping> m_droppedMethodMappings;
+        
+        public MappingsChecker(JarIndex index) {
+                m_index = index;
+                m_relatedMethodChecker = new RelatedMethodChecker(m_index);
+                m_droppedClassMappings = Maps.newHashMap();
+                m_droppedInnerClassMappings = Maps.newHashMap();
+                m_droppedFieldMappings = Maps.newHashMap();
+                m_droppedMethodMappings = Maps.newHashMap();
+        }
+        
+        public RelatedMethodChecker getRelatedMethodChecker() {
+                return m_relatedMethodChecker;
+        }
+        
+        public Map<ClassEntry,ClassMapping> getDroppedClassMappings() {
+                return m_droppedClassMappings;
+        }
+        
+        public Map<ClassEntry,ClassMapping> getDroppedInnerClassMappings() {
+                return m_droppedInnerClassMappings;
+        }
+        
+        public Map<FieldEntry,FieldMapping> getDroppedFieldMappings() {
+                return m_droppedFieldMappings;
+        }
+        
+        public Map<BehaviorEntry,MethodMapping> getDroppedMethodMappings() {
+                return m_droppedMethodMappings;
+        }
+        
+        public void dropBrokenMappings(Mappings mappings) {
+                for (ClassMapping classMapping : Lists.newArrayList(mappings.classes())) {
+                        if (!checkClassMapping(classMapping)) {
+                                mappings.removeClassMapping(classMapping);
+                                m_droppedClassMappings.put(EntryFactory.getObfClassEntry(m_index, classMapping), classMapping);
+                        }
+                }
+        }
+        
+        private boolean checkClassMapping(ClassMapping classMapping) {
+                
+                // check the class
+                ClassEntry classEntry = EntryFactory.getObfClassEntry(m_index, classMapping);
+                if (!m_index.getObfClassEntries().contains(classEntry)) {
+                        return false;
+                }
+                
+                // check the fields
+                for (FieldMapping fieldMapping : Lists.newArrayList(classMapping.fields())) {
+                        FieldEntry obfFieldEntry = new FieldEntry(classEntry, fieldMapping.getObfName(), fieldMapping.getObfType());
+                        if (!m_index.containsObfField(obfFieldEntry)) {
+                                classMapping.removeFieldMapping(fieldMapping);
+                                m_droppedFieldMappings.put(obfFieldEntry, fieldMapping);
+                        }
+                }
+                
+                // check methods
+                for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
+                        BehaviorEntry obfBehaviorEntry = EntryFactory.getObfBehaviorEntry(classEntry, methodMapping);
+                        if (!m_index.containsObfBehavior(obfBehaviorEntry)) {
+                                classMapping.removeMethodMapping(methodMapping);
+                                m_droppedMethodMappings.put(obfBehaviorEntry, methodMapping);
+                        }
+                        
+                        m_relatedMethodChecker.checkMethod(classEntry, methodMapping);
+                }
+                
+                // check inner classes
+                for (ClassMapping innerClassMapping : Lists.newArrayList(classMapping.innerClasses())) {
+                        if (!checkClassMapping(innerClassMapping)) {
+                                classMapping.removeInnerClassMapping(innerClassMapping);
+                                m_droppedInnerClassMappings.put(EntryFactory.getObfClassEntry(m_index, innerClassMapping), innerClassMapping);
+                        }
+                }
+                
+                return true;
+        }
+}