3 files changed, 66 insertions, 17 deletions

diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java
index 6ea1c40b..5980f1fc 100644
--- a/src/main/java/cuchaz/enigma/Deobfuscator.java
+++ b/src/main/java/cuchaz/enigma/Deobfuscator.java
@@ -34,6 +34,7 @@ import cuchaz.enigma.mapping.entry.*;
 import cuchaz.enigma.throwables.IllegalNameException;
 import cuchaz.enigma.utils.Utils;
 import oml.ast.transformers.ObfuscatedEnumSwitchRewriterTransform;
+import oml.ast.transformers.RemoveObjectCasts;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.tree.ClassNode;
@@ -324,6 +325,21 @@ public class Deobfuscator {
                 }
         }
 
+        public boolean isMethodProvider(MethodEntry methodEntry) {
+                Set<ClassEntry> classEntries = new HashSet<>();
+                addAllPotentialAncestors(classEntries, methodEntry.getOwnerClassEntry());
+
+                for (ClassEntry parentEntry : classEntries) {
+                        MethodEntry ancestorMethodEntry = entryPool.getMethod(parentEntry, methodEntry.getName(), methodEntry.getDesc());
+                        if (jarIndex.containsObfMethod(ancestorMethodEntry)) {
+                                return false;
+                        }
+                }
+
+                return true;
+        }
+
+        @Deprecated
         public boolean isMethodProvider(ClassEntry classObfEntry, MethodEntry methodEntry) {
                 Set<ClassEntry> classEntries = new HashSet<>();
                 addAllPotentialAncestors(classEntries, classObfEntry);
@@ -366,10 +382,12 @@ public class Deobfuscator {
                                 Entry obfEntry = entry.getKey();
                                 String name = entry.getValue();
 
-                                try {
-                                        rename(obfEntry, name);
-                                } catch (IllegalNameException exception) {
-                                        System.out.println("WARNING: " + exception.getMessage());
+                                if (name != null) {
+                                        try {
+                                                rename(obfEntry, name);
+                                        } catch (IllegalNameException exception) {
+                                                System.out.println("WARNING: " + exception.getMessage());
+                                        }
                                 }
                         }
                 }
@@ -381,15 +399,15 @@ public class Deobfuscator {
                 for (MethodMapping methodMapping : Lists.newArrayList(classMapping.methods())) {
                         ClassEntry classObfEntry = classMapping.getObfEntry();
                         MethodEntry obfEntry = methodMapping.getObfEntry(classObfEntry);
+                        boolean isProvider = isMethodProvider(obfEntry);
 
-                        if (isMethodProvider(classObfEntry, obfEntry)) {
-                                if (hasDeobfuscatedName(obfEntry)
-                                                && !(methodMapping.getDeobfName().equals(methodMapping.getObfName()))) {
-                                        renameEntries.put(obfEntry, methodMapping.getDeobfName());
-                                }
+                        if (hasDeobfuscatedName(obfEntry)
+                                        && !(methodMapping.getDeobfName().equals(methodMapping.getObfName()))) {
+                                renameEntries.put(obfEntry, isProvider ? methodMapping.getDeobfName() : null);
+                        }
 
-                                ArrayList<LocalVariableMapping> arguments = Lists.newArrayList(methodMapping.arguments());
-                                for (LocalVariableMapping localVariableMapping : arguments) {
+                        if (isProvider) {
+                                for (LocalVariableMapping localVariableMapping : methodMapping.arguments()) {
                                         Entry argObfEntry = localVariableMapping.getObfEntry(obfEntry);
                                         if (hasDeobfuscatedName(argObfEntry)) {
                                                 renameEntries.put(argObfEntry, deobfuscateEntry(argObfEntry).getName());
@@ -661,7 +679,8 @@ public class Deobfuscator {
 
         public static void runCustomTransforms(AstBuilder builder, DecompilerContext context){
                 List<IAstTransform> transformers = Arrays.asList(
-                                new ObfuscatedEnumSwitchRewriterTransform(context)
+                                new ObfuscatedEnumSwitchRewriterTransform(context),
+                                new RemoveObjectCasts(context)
                 );
                 for (IAstTransform transform : transformers){
                         transform.run(builder.getCompilationUnit());
diff --git a/src/main/java/cuchaz/enigma/analysis/JarIndex.java b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
index 5917a32f..64ea7950 100644
--- a/src/main/java/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/JarIndex.java
@@ -268,13 +268,34 @@ public class JarIndex {
         }
 
         public MethodInheritanceTreeNode getMethodInheritance(Translator deobfuscatingTranslator, MethodEntry obfMethodEntry) {
-
                 // travel to the ancestor implementation
+                LinkedList<ClassEntry> entries = new LinkedList<>();
+                entries.add(obfMethodEntry.getOwnerClassEntry());
+
+                // TODO: This could be optimized to not go through interfaces repeatedly...
+
                 ClassEntry baseImplementationClassEntry = obfMethodEntry.getOwnerClassEntry();
-                for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(obfMethodEntry.getOwnerClassEntry())) {
+
+                for (ClassEntry itf : getInterfaces(obfMethodEntry.getOwnerClassEntry().getClassName())) {
+                        MethodEntry itfMethodEntry = entryPool.getMethod(itf, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
+                        if (itfMethodEntry != null && containsObfMethod(itfMethodEntry)) {
+                                baseImplementationClassEntry = itf;
+                        }
+                }
+
+                for (ClassEntry ancestorClassEntry : this.translationIndex.getAncestry(entries.remove())) {
                         MethodEntry ancestorMethodEntry = entryPool.getMethod(ancestorClassEntry, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
-                        if (ancestorMethodEntry != null && containsObfMethod(ancestorMethodEntry)) {
-                                baseImplementationClassEntry = ancestorClassEntry;
+                        if (ancestorMethodEntry != null) {
+                                if (containsObfMethod(ancestorMethodEntry)) {
+                                        baseImplementationClassEntry = ancestorClassEntry;
+                                }
+
+                                for (ClassEntry itf : getInterfaces(ancestorClassEntry.getClassName())) {
+                                        MethodEntry itfMethodEntry = entryPool.getMethod(itf, obfMethodEntry.getName(), obfMethodEntry.getDesc().toString());
+                                        if (itfMethodEntry != null && containsObfMethod(itfMethodEntry)) {
+                                                baseImplementationClassEntry = itf;
+                                        }
+                                }
                         }
                 }
 
diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
index 8f3f2b2b..369ba8c6 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
@@ -526,7 +526,16 @@ public class ClassMapping implements Comparable<ClassMapping> {
         }
 
         public boolean isDirty() {
-                return isDirty;
+                return isDirty || areInnersDirty();
+        }
+
+        private boolean areInnersDirty(){
+                for (ClassMapping c : this.innerClasses()){
+                        if (c.isDirty()){
+                                return true;
+                        }
+                }
+                return false;
         }
 
         public void resetDirty() {