6 files changed, 48 insertions, 80 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java b/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java
index 649ce254..8a9b4593 100644
--- a/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/index/BridgeMethodIndex.java
@@ -17,8 +17,8 @@ public class BridgeMethodIndex implements JarIndexer {
         private final InheritanceIndex inheritanceIndex;
         private final ReferenceIndex referenceIndex;
 
-        private final Set<MethodEntry> bridgeMethods = Sets.newHashSet();
-        private final Map<MethodEntry, MethodEntry> accessedToBridge = Maps.newHashMap();
+        private final Set<MethodEntry> bridgeToSpecialized = Sets.newHashSet();
+        private final Map<MethodEntry, MethodEntry> specializedToBridge = Maps.newHashMap();
 
         public BridgeMethodIndex(EntryIndex entryIndex, InheritanceIndex inheritanceIndex, ReferenceIndex referenceIndex) {
                 this.entryIndex = entryIndex;
@@ -42,34 +42,34 @@ public class BridgeMethodIndex implements JarIndexer {
 
         @Override
         public void processIndex(JarIndex index) {
-                Map<MethodEntry, MethodEntry> copiedAccessToBridge = new HashMap<>(accessedToBridge);
+                Map<MethodEntry, MethodEntry> copiedAccessToBridge = new HashMap<>(specializedToBridge);
 
                 for (Map.Entry<MethodEntry, MethodEntry> entry : copiedAccessToBridge.entrySet()) {
-                        MethodEntry accessedEntry = entry.getKey();
+                        MethodEntry specializedEntry = entry.getKey();
                         MethodEntry bridgeEntry = entry.getValue();
-                        if (bridgeEntry.getName().equals(accessedEntry.getName())) {
+                        if (bridgeEntry.getName().equals(specializedEntry.getName())) {
                                 continue;
                         }
 
-                        MethodEntry renamedAccessedEntry = accessedEntry.withName(bridgeEntry.getName());
-                        bridgeMethods.add(renamedAccessedEntry);
-                        accessedToBridge.put(renamedAccessedEntry, accessedToBridge.get(accessedEntry));
+                        MethodEntry renamedSpecializedEntry = specializedEntry.withName(bridgeEntry.getName());
+                        bridgeToSpecialized.add(renamedSpecializedEntry);
+                        specializedToBridge.put(renamedSpecializedEntry, specializedToBridge.get(specializedEntry));
                 }
         }
 
         private void indexSyntheticMethod(MethodDefEntry syntheticMethod, AccessFlags access) {
-                MethodEntry accessedMethod = findAccessMethod(syntheticMethod);
-                if (accessedMethod == null) {
+                MethodEntry specializedMethod = findSpecializedMethod(syntheticMethod);
+                if (specializedMethod == null) {
                         return;
                 }
 
-                if (access.isBridge() || isPotentialBridge(syntheticMethod, accessedMethod)) {
-                        bridgeMethods.add(syntheticMethod);
-                        accessedToBridge.put(accessedMethod, syntheticMethod);
+                if (access.isBridge() || isPotentialBridge(syntheticMethod, specializedMethod)) {
+                        bridgeToSpecialized.add(syntheticMethod);
+                        specializedToBridge.put(specializedMethod, syntheticMethod);
                 }
         }
 
-        private MethodEntry findAccessMethod(MethodEntry method) {
+        private MethodEntry findSpecializedMethod(MethodEntry method) {
                 // we want to find all compiler-added methods that directly call another with no processing
 
                 // get all the methods that we call
@@ -83,7 +83,7 @@ public class BridgeMethodIndex implements JarIndexer {
                 return referencedMethods.stream().findFirst().orElse(null);
         }
 
-        private boolean isPotentialBridge(MethodDefEntry bridgeMethod, MethodEntry accessedMethod) {
+        private boolean isPotentialBridge(MethodDefEntry bridgeMethod, MethodEntry specializedMethod) {
                 // Bridge methods only exist for inheritance purposes, if we're private, final, or static, we cannot be inherited
                 AccessFlags bridgeAccess = bridgeMethod.getAccess();
                 if (bridgeAccess.isPrivate() || bridgeAccess.isFinal() || bridgeAccess.isStatic()) {
@@ -91,35 +91,35 @@ public class BridgeMethodIndex implements JarIndexer {
                 }
 
                 MethodDescriptor bridgeDesc = bridgeMethod.getDesc();
-                MethodDescriptor accessedDesc = accessedMethod.getDesc();
+                MethodDescriptor specializedDesc = specializedMethod.getDesc();
                 List<TypeDescriptor> bridgeArguments = bridgeDesc.getArgumentDescs();
-                List<TypeDescriptor> accessedArguments = accessedDesc.getArgumentDescs();
+                List<TypeDescriptor> specializedArguments = specializedDesc.getArgumentDescs();
 
                 // A bridge method will always have the same number of arguments
-                if (bridgeArguments.size() != accessedArguments.size()) {
+                if (bridgeArguments.size() != specializedArguments.size()) {
                         return false;
                 }
 
                 // Check that all argument types are bridge-compatible
                 for (int i = 0; i < bridgeArguments.size(); i++) {
-                        if (!areTypesBridgeCompatible(bridgeArguments.get(i), accessedArguments.get(i))) {
+                        if (!areTypesBridgeCompatible(bridgeArguments.get(i), specializedArguments.get(i))) {
                                 return false;
                         }
                 }
 
                 // Check that the return type is bridge-compatible
-                return areTypesBridgeCompatible(bridgeDesc.getReturnDesc(), accessedDesc.getReturnDesc());
+                return areTypesBridgeCompatible(bridgeDesc.getReturnDesc(), specializedDesc.getReturnDesc());
         }
 
-        private boolean areTypesBridgeCompatible(TypeDescriptor bridgeDesc, TypeDescriptor accessedDesc) {
-                if (bridgeDesc.equals(accessedDesc)) {
+        private boolean areTypesBridgeCompatible(TypeDescriptor bridgeDesc, TypeDescriptor specializedDesc) {
+                if (bridgeDesc.equals(specializedDesc)) {
                         return true;
                 }
 
                 // Either the descs will be equal, or they are both types and different through a generic
-                if (bridgeDesc.isType() && accessedDesc.isType()) {
+                if (bridgeDesc.isType() && specializedDesc.isType()) {
                         ClassEntry bridgeType = bridgeDesc.getTypeEntry();
-                        ClassEntry accessedType = accessedDesc.getTypeEntry();
+                        ClassEntry accessedType = specializedDesc.getTypeEntry();
 
                         // If the given types are completely unrelated to each other, this can't be bridge compatible
                         InheritanceIndex.Relation relation = inheritanceIndex.computeClassRelation(accessedType, bridgeType);
@@ -130,19 +130,19 @@ public class BridgeMethodIndex implements JarIndexer {
         }
 
         public boolean isBridgeMethod(MethodEntry entry) {
-                return bridgeMethods.contains(entry);
+                return bridgeToSpecialized.contains(entry);
         }
 
-        public boolean isAccessedByBridge(MethodEntry entry) {
-                return accessedToBridge.containsKey(entry);
+        public boolean isSpecializedMethod(MethodEntry entry) {
+                return specializedToBridge.containsKey(entry);
         }
 
         @Nullable
-        public MethodEntry getBridgeFromAccessed(MethodEntry entry) {
-                return accessedToBridge.get(entry);
+        public MethodEntry getBridgeFromSpecialized(MethodEntry specialized) {
+                return specializedToBridge.get(specialized);
         }
 
-        public Map<MethodEntry, MethodEntry> getAccessedToBridge() {
-                return Collections.unmodifiableMap(accessedToBridge);
+        public Map<MethodEntry, MethodEntry> getSpecializedToBridge() {
+                return Collections.unmodifiableMap(specializedToBridge);
         }
 }
diff --git a/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java b/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java
index 645110a7..773eaf18 100644
--- a/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/index/EntryIndex.java
@@ -28,18 +28,6 @@ public class EntryIndex implements JarIndexer {
                 fields.put(fieldEntry, fieldEntry.getAccess());
         }
 
-        @Override
-        public void processIndex(JarIndex index) {
-                Map<MethodEntry, MethodEntry> accessedToBridge = index.getBridgeMethodIndex().getAccessedToBridge();
-                for (Map.Entry<MethodEntry, MethodEntry> entry : accessedToBridge.entrySet()) {
-                        MethodEntry accessedEntry = entry.getKey();
-                        MethodEntry bridgeEntry = entry.getValue();
-
-                        MethodEntry renamedAccessedEntry = accessedEntry.withName(bridgeEntry.getName());
-                        methods.put(renamedAccessedEntry, methods.remove(accessedEntry));
-                }
-        }
-
         public boolean hasClass(ClassEntry entry) {
                 return classes.containsKey(entry);
         }
diff --git a/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java b/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java
index ee28b3e7..2b63c5d4 100644
--- a/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java
+++ b/src/main/java/cuchaz/enigma/analysis/index/ReferenceIndex.java
@@ -8,7 +8,6 @@ import cuchaz.enigma.translation.representation.entry.*;
 
 import java.util.Collection;
 import java.util.Map;
-import java.util.Optional;
 
 public class ReferenceIndex implements JarIndexer {
         private Multimap<MethodEntry, MethodEntry> methodReferences = HashMultimap.create();
@@ -58,30 +57,11 @@ public class ReferenceIndex implements JarIndexer {
         }
 
         private <E extends Entry<?>> E remap(JarIndex index, E entry) {
-                E resolvedEntry = index.getEntryResolver().resolveFirstEntry(entry, ResolutionStrategy.RESOLVE_CLOSEST);
-
-                Optional<E> remappedBridge = getRemappedBridge(index, resolvedEntry);
-                return remappedBridge.orElse(resolvedEntry);
+                return index.getEntryResolver().resolveFirstEntry(entry, ResolutionStrategy.RESOLVE_CLOSEST);
         }
 
         private <E extends Entry<?>, C extends Entry<?>> EntryReference<E, C> remap(JarIndex index, EntryReference<E, C> reference) {
-                EntryReference<E, C> resolvedReference = index.getEntryResolver().resolveFirstReference(reference, ResolutionStrategy.RESOLVE_CLOSEST);
-
-                getRemappedBridge(index, resolvedReference.entry).ifPresent(e -> resolvedReference.entry = e);
-                getRemappedBridge(index, resolvedReference.context).ifPresent(e -> resolvedReference.context = e);
-
-                return resolvedReference;
-        }
-
-        @SuppressWarnings("unchecked")
-        private <E extends Entry<?>> Optional<E> getRemappedBridge(JarIndex index, E entry) {
-                if (entry instanceof MethodEntry) {
-                        MethodEntry bridgeEntry = index.getBridgeMethodIndex().getBridgeFromAccessed((MethodEntry) entry);
-                        if (bridgeEntry != null) {
-                                return Optional.of((E) entry.withName(bridgeEntry.getName()));
-                        }
-                }
-                return Optional.empty();
+                return index.getEntryResolver().resolveFirstReference(reference, ResolutionStrategy.RESOLVE_CLOSEST);
         }
 
         public Collection<MethodEntry> getMethodsReferencedBy(MethodEntry entry) {
diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java b/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java
index 99eef6ae..735a65f2 100644
--- a/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java
+++ b/src/main/java/cuchaz/enigma/bytecode/translators/SourceFixVisitor.java
@@ -4,7 +4,6 @@ import cuchaz.enigma.analysis.index.BridgeMethodIndex;
 import cuchaz.enigma.analysis.index.JarIndex;
 import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
 import cuchaz.enigma.translation.representation.entry.MethodDefEntry;
-import cuchaz.enigma.translation.representation.entry.MethodEntry;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
@@ -31,11 +30,6 @@ public class SourceFixVisitor extends ClassVisitor {
                 BridgeMethodIndex bridgeIndex = index.getBridgeMethodIndex();
                 if (bridgeIndex.isBridgeMethod(methodEntry)) {
                         access |= Opcodes.ACC_BRIDGE;
-                } else {
-                        MethodEntry bridgeMethod = bridgeIndex.getBridgeFromAccessed(methodEntry);
-                        if (bridgeMethod != null) {
-                                name = bridgeMethod.getName();
-                        }
                 }
 
                 return super.visitMethod(access, name, descriptor, signature, exceptions);
diff --git a/src/main/java/cuchaz/enigma/gui/GuiController.java b/src/main/java/cuchaz/enigma/gui/GuiController.java
index e6ecc548..4155062e 100644
--- a/src/main/java/cuchaz/enigma/gui/GuiController.java
+++ b/src/main/java/cuchaz/enigma/gui/GuiController.java
@@ -50,8 +50,8 @@ import java.util.stream.Collectors;
 public class GuiController {
         private static final ExecutorService DECOMPILER_SERVICE = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().setDaemon(true).setNameFormat("decompiler-thread").build());
 
+        private final Gui gui;
         private Deobfuscator deobfuscator;
-        private Gui gui;
         private DecompiledClassSource currentSource;
         private Deque<EntryReference<Entry<?>, Entry<?>>> referenceStack;
 
@@ -60,12 +60,13 @@ public class GuiController {
 
         public GuiController(Gui gui) {
                 this.gui = gui;
-                this.deobfuscator = null;
-                this.currentSource = null;
                 this.referenceStack = Queues.newArrayDeque();
         }
 
         public boolean isDirty() {
+                if (deobfuscator == null) {
+                        return false;
+                }
                 return deobfuscator.getMapper().isDirty();
         }
 
@@ -82,6 +83,7 @@ public class GuiController {
         }
 
         public void openMappings(MappingFormat format, Path path) {
+                if (deobfuscator == null) return;
                 ProgressDialog.runInThread(this.gui.getFrame(), progress -> {
                         try {
                                 EntryTree<EntryMapping> mappings = format.read(path, progress);
@@ -104,6 +106,7 @@ public class GuiController {
         }
 
         public void saveMappings(MappingFormat format, Path path) {
+                if (deobfuscator == null) return;
                 EntryRemapper mapper = deobfuscator.getMapper();
 
                 MappingDelta<EntryMapping> delta = mapper.takeMappingDelta();
@@ -122,6 +125,7 @@ public class GuiController {
         }
 
         public void closeMappings() {
+                if (deobfuscator == null) return;
                 this.deobfuscator.setMappings(null);
                 this.gui.setMappingsFile(null);
                 refreshClasses();
@@ -129,10 +133,12 @@ public class GuiController {
         }
 
         public void exportSource(final File dirOut) {
+                if (deobfuscator == null) return;
                 ProgressDialog.runInThread(this.gui.getFrame(), progress -> this.deobfuscator.writeSources(dirOut.toPath(), progress));
         }
 
         public void exportJar(final File fileOut) {
+                if (deobfuscator == null) return;
                 ProgressDialog.runInThread(this.gui.getFrame(), progress -> this.deobfuscator.writeTransformedJar(fileOut, progress));
         }
 
@@ -164,7 +170,7 @@ public class GuiController {
         }
 
         public boolean entryIsInJar(Entry<?> entry) {
-                if (entry == null) return false;
+                if (entry == null || deobfuscator == null) return false;
                 return this.deobfuscator.isRenamable(entry);
         }
 
diff --git a/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java b/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
index 6c8ed76d..78231ddd 100644
--- a/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
+++ b/src/main/java/cuchaz/enigma/translation/mapping/IndexEntryResolver.java
@@ -86,7 +86,7 @@ public class IndexEntryResolver implements EntryResolver {
                 ClassEntry ownerClass = entry.getParent();
 
                 if (entry instanceof MethodEntry) {
-                        MethodEntry bridgeMethod = bridgeMethodIndex.getBridgeFromAccessed((MethodEntry) entry);
+                        MethodEntry bridgeMethod = bridgeMethodIndex.getBridgeFromSpecialized((MethodEntry) entry);
                         if (bridgeMethod != null && ownerClass.equals(bridgeMethod.getParent())) {
                                 Set<Entry<ClassEntry>> resolvedBridge = resolveChildEntry(bridgeMethod, strategy);
                                 if (!resolvedBridge.isEmpty()) {
@@ -183,10 +183,10 @@ public class IndexEntryResolver implements EntryResolver {
                 }
 
                 // look at bridge methods!
-                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromAccessed(methodEntry);
+                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(methodEntry);
                 while (bridgedMethod != null) {
                         methodEntries.addAll(resolveEquivalentMethods(bridgedMethod));
-                        bridgedMethod = bridgeMethodIndex.getBridgeFromAccessed(bridgedMethod);
+                        bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(bridgedMethod);
                 }
 
                 // look at interface methods too
@@ -209,10 +209,10 @@ public class IndexEntryResolver implements EntryResolver {
                 }
 
                 // look at bridge methods!
-                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromAccessed(methodEntry);
+                MethodEntry bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(methodEntry);
                 while (bridgedMethod != null) {
                         methodEntries.addAll(resolveEquivalentMethods(bridgedMethod));
-                        bridgedMethod = bridgeMethodIndex.getBridgeFromAccessed(bridgedMethod);
+                        bridgedMethod = bridgeMethodIndex.getBridgeFromSpecialized(bridgedMethod);
                 }
 
                 // recurse