update ASM/Guava, merge ASM port fixes

8 files changed, 112 insertions, 19 deletions

diff --git a/src/main/java/cuchaz/enigma/CachingClasspathTypeLoader.java b/src/main/java/cuchaz/enigma/CachingClasspathTypeLoader.java
index 58682e23..fe13321c 100644
--- a/src/main/java/cuchaz/enigma/CachingClasspathTypeLoader.java
+++ b/src/main/java/cuchaz/enigma/CachingClasspathTypeLoader.java
@@ -8,6 +8,12 @@ import com.strobel.assembler.metadata.ITypeLoader;
  * Caching version of {@link ClasspathTypeLoader}
  */
 public class CachingClasspathTypeLoader extends CachingTypeLoader {
+        private static ITypeLoader extraClassPathLoader = null;
+
+        public static void setExtraClassPathLoader(ITypeLoader loader){
+                extraClassPathLoader = loader;
+        }
+
         private final ITypeLoader classpathLoader = new ClasspathTypeLoader();
 
         protected byte[] doLoad(String className) {
@@ -15,6 +21,12 @@ public class CachingClasspathTypeLoader extends CachingTypeLoader {
                 if (classpathLoader.tryLoadType(className, parentBuf)) {
                         return parentBuf.array();
                 }
+                if (extraClassPathLoader != null){
+                        parentBuf.reset();
+                        if (extraClassPathLoader.tryLoadType(className, parentBuf)){
+                                return parentBuf.array();
+                        }
+                }
                 return EMPTY_ARRAY;//need to return *something* as null means no store
         }
 }
diff --git a/src/main/java/cuchaz/enigma/Deobfuscator.java b/src/main/java/cuchaz/enigma/Deobfuscator.java
index 5980f1fc..0c671589 100644
--- a/src/main/java/cuchaz/enigma/Deobfuscator.java
+++ b/src/main/java/cuchaz/enigma/Deobfuscator.java
@@ -15,6 +15,7 @@ import com.google.common.base.Stopwatch;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import com.strobel.assembler.metadata.ITypeLoader;
 import com.strobel.assembler.metadata.MetadataSystem;
 import com.strobel.assembler.metadata.TypeDefinition;
 import com.strobel.assembler.metadata.TypeReference;
@@ -33,14 +34,18 @@ import cuchaz.enigma.mapping.*;
 import cuchaz.enigma.mapping.entry.*;
 import cuchaz.enigma.throwables.IllegalNameException;
 import cuchaz.enigma.utils.Utils;
+import oml.ast.transformers.InvalidIdentifierFix;
+import oml.ast.transformers.Java8Generics;
 import oml.ast.transformers.ObfuscatedEnumSwitchRewriterTransform;
 import oml.ast.transformers.RemoveObjectCasts;
+import oml.ast.transformers.VarargsFixer;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.tree.ClassNode;
 
 import java.io.*;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -170,6 +175,10 @@ public class Deobfuscator {
         }
 
         public CompilationUnit getSourceTree(String className, ITranslatingTypeLoader loader) {
+                return getSourceTree(className, loader, new NoRetryMetadataSystem(loader));
+        }
+
+        public CompilationUnit getSourceTree(String className, ITranslatingTypeLoader loader, MetadataSystem metadataSystem) {
 
                 // we don't know if this class name is obfuscated or deobfuscated
                 // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
@@ -188,7 +197,7 @@ public class Deobfuscator {
                 this.settings.setTypeLoader(loader);
 
                 // see if procyon can find the desc
-                TypeReference type = new MetadataSystem(loader).lookupType(deobfClassName);
+                TypeReference type = metadataSystem.lookupType(deobfClassName);
                 if (type == null) {
                         throw new Error(String.format("Unable to find desc: %s (deobf: %s)\nTried class names: %s",
                                         className, deobfClassName, loader.getClassNamesToTry(deobfClassName)
@@ -278,6 +287,9 @@ public class Deobfuscator {
                 //synchronized to make sure the parallelStream doesn't CME with the cache
                 ITranslatingTypeLoader typeLoader = new SynchronizedTypeLoader(createTypeLoader());
 
+                MetadataSystem metadataSystem = new NoRetryMetadataSystem(typeLoader);
+                metadataSystem.setEagerMethodLoadingEnabled(true);//ensures methods are loaded on classload and prevents race conditions
+
                 // DEOBFUSCATE ALL THE THINGS!! @_@
                 Stopwatch stopwatch = Stopwatch.createStarted();
                 AtomicInteger count = new AtomicInteger();
@@ -289,7 +301,7 @@ public class Deobfuscator {
 
                         try {
                                 // get the source
-                                CompilationUnit sourceTree = getSourceTree(obfClassEntry.getName(), typeLoader);
+                                CompilationUnit sourceTree = getSourceTree(obfClassEntry.getName(), typeLoader, metadataSystem);
 
                                 // write the file
                                 File file = new File(dirOut, deobfClassEntry.getName().replace('.', '/') + ".java");
@@ -355,28 +367,28 @@ public class Deobfuscator {
         }
 
         public void rebuildMethodNames(ProgressListener progress) {
-                int i = 0;
+                final AtomicInteger i = new AtomicInteger();
                 Map<ClassMapping, Map<Entry, String>> renameClassMap = new HashMap<>();
 
                 progress.init(getMappings().classes().size() * 3, "Rebuilding method names");
 
-                for (ClassMapping classMapping : Lists.newArrayList(getMappings().classes())) {
-                        progress.onProgress(i++, classMapping.getDeobfName());
+                Lists.newArrayList(getMappings().classes()).parallelStream().forEach(classMapping -> {
+                        progress.onProgress(i.getAndIncrement(), classMapping.getDeobfName());
                         rebuildMethodNames(classMapping, renameClassMap);
-                }
+                });
 
-                for (Map.Entry<ClassMapping, Map<Entry, String>> renameClassMapEntry : renameClassMap.entrySet()) {
-                        progress.onProgress(i++, renameClassMapEntry.getKey().getDeobfName());
 
+                renameClassMap.entrySet().parallelStream().forEach(renameClassMapEntry -> {
+                        progress.onProgress(i.getAndIncrement(), renameClassMapEntry.getKey().getDeobfName());
                         for (Map.Entry<Entry, String> entry : renameClassMapEntry.getValue().entrySet()) {
                                 Entry obfEntry = entry.getKey();
 
                                 removeMapping(obfEntry);
                         }
-                }
+                });
 
-                for (Map.Entry<ClassMapping, Map<Entry, String>> renameClassMapEntry : renameClassMap.entrySet()) {
-                        progress.onProgress(i++, renameClassMapEntry.getKey().getDeobfName());
+                renameClassMap.entrySet().parallelStream().forEach(renameClassMapEntry -> {
+                        progress.onProgress(i.getAndIncrement(), renameClassMapEntry.getKey().getDeobfName());
 
                         for (Map.Entry<Entry, String> entry : renameClassMapEntry.getValue().entrySet()) {
                                 Entry obfEntry = entry.getKey();
@@ -390,7 +402,7 @@ public class Deobfuscator {
                                         }
                                 }
                         }
-                }
+                });
         }
 
         private void rebuildMethodNames(ClassMapping classMapping, Map<ClassMapping, Map<Entry, String>> renameClassMap) {
@@ -680,9 +692,12 @@ public class Deobfuscator {
         public static void runCustomTransforms(AstBuilder builder, DecompilerContext context){
                 List<IAstTransform> transformers = Arrays.asList(
                                 new ObfuscatedEnumSwitchRewriterTransform(context),
-                                new RemoveObjectCasts(context)
+                                new VarargsFixer(context),
+                                new RemoveObjectCasts(context),
+                                new Java8Generics(),
+                                new InvalidIdentifierFix()
                 );
-                for (IAstTransform transform : transformers){
+                for (IAstTransform transform : transformers) {
                         transform.run(builder.getCompilationUnit());
                 }
         }
@@ -697,4 +712,30 @@ public class Deobfuscator {
                 String transform(ClassNode node, ClassWriter writer);
         }
 
+        public static class NoRetryMetadataSystem extends MetadataSystem {
+                private final Set<String> _failedTypes = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+                public NoRetryMetadataSystem(final ITypeLoader typeLoader) {
+                        super(typeLoader);
+                }
+
+                @Override
+                protected synchronized TypeDefinition resolveType(final String descriptor, final boolean mightBePrimitive) {
+                        if (_failedTypes.contains(descriptor)) {
+                                return null;
+                        }
+
+                        final TypeDefinition result = super.resolveType(descriptor, mightBePrimitive);
+
+                        if (result == null) {
+                                _failedTypes.add(descriptor);
+                        }
+
+                        return result;
+                }
+
+                public synchronized TypeDefinition resolve(final TypeReference type) {
+                        return super.resolve(type);
+                }
+        }
 }
diff --git a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
index eb780ee9..42ceec4d 100644
--- a/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
+++ b/src/main/java/cuchaz/enigma/TranslatingTypeLoader.java
@@ -22,7 +22,10 @@ import cuchaz.enigma.mapping.entry.ReferencedEntryPool;
 import cuchaz.enigma.mapping.Translator;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
 import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
 
 import java.util.List;
 
@@ -89,6 +92,31 @@ public class TranslatingTypeLoader extends CachingTypeLoader implements ITransla
                         return null;
                 }
 
+
+                // remove <obj>.getClass() calls that are seemingly injected
+                //      DUP
+                //      INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
+                //      POP
+                for (MethodNode methodNode : node.methods){
+                        AbstractInsnNode insnNode = methodNode.instructions.getFirst();
+                        while (insnNode != null){
+                                if (insnNode instanceof MethodInsnNode && insnNode.getOpcode() == Opcodes.INVOKEVIRTUAL){
+                                        MethodInsnNode methodInsnNode = (MethodInsnNode)insnNode;
+                                        if (methodInsnNode.name.equals("getClass") && methodInsnNode.owner.equals("java/lang/Object") && methodInsnNode.desc.equals("()Ljava/lang/Class;")){
+                                                AbstractInsnNode previous = methodInsnNode.getPrevious();
+                                                AbstractInsnNode next = methodInsnNode.getNext();
+                                                if (previous.getOpcode() == Opcodes.DUP && next.getOpcode() == Opcodes.POP){
+                                                        insnNode = previous.getPrevious();//reset the iterator so it gets the new next instruction
+                                                        methodNode.instructions.remove(previous);
+                                                        methodNode.instructions.remove(methodInsnNode);
+                                                        methodNode.instructions.remove(next);
+                                                }
+                                        }
+                                }
+                                insnNode = insnNode.getNext();
+                        }
+                }
+
                 ClassWriter writer = new ClassWriter(0);
                 transformInto(node, writer);
 
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
index 14b2e768..78195cb7 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndex.java
@@ -17,15 +17,19 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
 import com.strobel.decompiler.languages.Region;
 import com.strobel.decompiler.languages.java.ast.AstNode;
+import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration;
 import com.strobel.decompiler.languages.java.ast.Identifier;
+import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
 import cuchaz.enigma.mapping.entry.Entry;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.regex.Pattern;
 
 public class SourceIndex {
+        private static Pattern ANONYMOUS_INNER = Pattern.compile("\\$\\d+$");
 
         private String source;
         private TreeMap<Token, EntryReference<Entry, Entry>> tokenToReference;
@@ -81,6 +85,14 @@ public class SourceIndex {
                         return null;
                 }
 
+                if (node instanceof Identifier && name.indexOf('$') >=0 && node.getParent() instanceof ConstructorDeclaration && name.lastIndexOf('$') >= 0 && !ANONYMOUS_INNER.matcher(name).matches()){
+                        TypeDeclaration type = node.getParent().getParent() instanceof TypeDeclaration ? (TypeDeclaration) node.getParent().getParent() : null;
+                        if (type != null){
+                                name = type.getName();
+                                token.end = token.start + name.length();
+                        }
+                }
+
                 // DEBUG
                 // System.out.println( String.format( "%s \"%s\" region: %s", node.getNodeType(), name, region ) );
 
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
index 83fe296c..83e5e04f 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
@@ -76,7 +76,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
         @Override
         public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
                 MemberReference ref = node.getUserData(Keys.MEMBER_REFERENCE);
-                if (ref != null) {
+                if (ref instanceof FieldReference) {
                         // make sure this is actually a field
                         String erasedSignature = ref.getErasedSignature();
                         if (erasedSignature.indexOf('(') >= 0) {
diff --git a/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java b/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java
index 21b24897..0bfc59bd 100644
--- a/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java
+++ b/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java
@@ -51,7 +51,7 @@ public class AccessFlags {
         }
 
         public AccessFlags setBridged() {
-                this.setVisibility(Opcodes.ACC_BRIDGE);
+                flags |= Opcodes.ACC_BRIDGE;
                 return this;
         }
 
diff --git a/src/main/java/cuchaz/enigma/config/Config.java b/src/main/java/cuchaz/enigma/config/Config.java
index 87ef3531..75ced70c 100644
--- a/src/main/java/cuchaz/enigma/config/Config.java
+++ b/src/main/java/cuchaz/enigma/config/Config.java
@@ -62,7 +62,7 @@ public class Config {
         public void loadConfig() throws IOException {
                 if (!ENIGMA_DIR.exists()) ENIGMA_DIR.mkdirs();
                 File configFile = new File(ENIGMA_DIR, "config.json");
-                if (configFile.exists()) gson.fromJson(Files.toString(configFile, Charset.defaultCharset()), Config.class);
+                if (configFile.exists()) gson.fromJson(Files.asCharSource(configFile, Charset.defaultCharset()).read(), Config.class);
                 else {
                         this.reset();
                         Files.touch(configFile);
@@ -71,7 +71,7 @@ public class Config {
         }
 
         public void saveConfig() throws IOException {
-                Files.write(gson.toJson(this), CONFIG_FILE, Charset.defaultCharset());
+                Files.asCharSink(CONFIG_FILE, Charset.defaultCharset()).write(gson.toJson(this));
         }
 
         public void reset() throws IOException {
diff --git a/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java b/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
index fd30e389..ffceae12 100644
--- a/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
+++ b/src/main/java/cuchaz/enigma/gui/panels/PanelEditor.java
@@ -56,7 +56,7 @@ public class PanelEditor extends JEditorPane {
                                                 gui.popupMenu.showCallsMenu.doClick();
                                                 break;
 
-                                        case KeyEvent.VK_T:
+                                        case KeyEvent.VK_O:
                                                 gui.popupMenu.toggleMappingMenu.doClick();
                                                 break;
                                         case KeyEvent.VK_F5: