removed deobfuscated method signatures from mappings

They're too much work to maintain, and they're totally unnecessary!

7 files changed, 32 insertions, 53 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index 526534d..8944eec 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -1,5 +1,6 @@
 /*******************************************************************************
- * Copyright (c) 2014 Jeff Martin.
+ * Copyright (c) 2014 Jeff Martin.\
+ * 
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the GNU Public License v3.0
  * which accompanies this distribution, and is available at
@@ -78,7 +79,9 @@ public class Deobfuscator
                 
                 // config the decompiler
                 m_settings = DecompilerSettings.javaDefaults();
+                m_settings.setMergeVariables( true );
                 m_settings.setForceExplicitImports( true );
+                m_settings.setForceExplicitTypeArguments( true );
                 // DEBUG
                 //m_settings.setShowSyntheticMembers( true );
                 
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 6a89df7..200d9ca 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -214,7 +214,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 assert( wasAdded );
                 if( methodMapping.getDeobfName() != null )
                 {
-                        String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() );
+                        String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getObfSignature() );
                         if( m_methodsByDeobf.containsKey( deobfKey ) )
                         {
                                 throw new Error( "Already have mapping for " + m_deobfName + "." + deobfKey );
@@ -248,7 +248,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 return name + signature;
         }
         
-        public void setMethodNameAndSignature( String obfName, String obfSignature, String deobfName, String deobfSignature )
+        public void setMethodName( String obfName, String obfSignature, String deobfName )
         {
                 MethodMapping methodMapping = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
                 if( methodMapping == null )
@@ -257,23 +257,14 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 }
                 else if( methodMapping.getDeobfName() != null )
                 {
-                        boolean wasRemoved = m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ) ) != null;
+                        boolean wasRemoved = m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getObfSignature() ) ) != null;
                         assert( wasRemoved );
                 }
                 methodMapping.setDeobfName( deobfName );
-                methodMapping.setDeobfSignature( deobfSignature );
-                boolean wasAdded = m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodMapping ) == null;
+                boolean wasAdded = m_methodsByDeobf.put( getMethodKey( deobfName, obfSignature ), methodMapping ) == null;
                 assert( wasAdded );
         }
         
-        public void updateDeobfMethodSignatures( Translator translator )
-        {
-                for( MethodMapping methodIndex : m_methodsByObf.values() )
-                {
-                        methodIndex.setDeobfSignature( translator.translateSignature( methodIndex.getObfSignature() ) );
-                }
-        }
-
         //// ARGUMENTS ////////
         
         public void setArgumentName( String obfMethodName, String obfMethodSignature, int argumentIndex, String argumentName )
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
index 7888836..5cbad59 100644
--- a/src/cuchaz/enigma/mapping/MappingsReader.java
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -193,14 +193,13 @@ public class MappingsReader
                         String obfName = parts[1];
                         String deobfName = parts[2];
                         String obfSignature = moveSignatureOutOfDefaultPackage( parts[3], Constants.NonePackage );
-                        String deobfSignature = moveSignatureOutOfDefaultPackage( parts[4], Constants.NonePackage );
                         if( obfName.equals( deobfName ) )
                         {
                                 return new MethodMapping( obfName, obfSignature );
                         }
                         else
                         {
-                                return new MethodMapping( obfName, obfSignature, deobfName, deobfSignature );
+                                return new MethodMapping( obfName, obfSignature, deobfName );
                         }
                 }
         }
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
index f84b248..49e7b5f 100644
--- a/src/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -46,14 +46,15 @@ public class MappingsRenamer
                 }
                 else
                 {
-                        boolean wasRemoved = m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ) != null;
-                        assert( wasRemoved );
+                        if( classMapping.getDeobfName() != null )
+                        {
+                                boolean wasRemoved = m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ) != null;
+                                assert( wasRemoved );
+                        }
                         classMapping.setDeobfName( deobfName );
                         boolean wasAdded = m_mappings.m_classesByDeobf.put( deobfName, classMapping ) == null;
                         assert( wasAdded );
                 }
-                
-                updateDeobfMethodSignatures();
         }
         
         public void setFieldName( FieldEntry obf, String deobfName )
@@ -76,7 +77,8 @@ public class MappingsRenamer
                 deobfName = NameValidator.validateMethodName( deobfName );
                 for( MethodEntry entry : implementations )
                 {
-                        MethodEntry targetEntry = new MethodEntry( entry.getClassEntry(), deobfName, entry.getSignature() );
+                        String deobfSignature = getTranslator( TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() );
+                        MethodEntry targetEntry = new MethodEntry( entry.getClassEntry(), deobfName, deobfSignature );
                         if( m_mappings.containsDeobfMethod( entry.getClassEntry(), deobfName, entry.getSignature() ) || m_index.containsObfMethod( targetEntry ) )
                         {
                                 String deobfClassName = getTranslator( TranslationDirection.Deobfuscating ).translateClass( entry.getClassName() );
@@ -101,8 +103,7 @@ public class MappingsRenamer
                 }
                 
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() );
-                String deobfSignature = getTranslator( TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() );
-                classMapping.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature );
+                classMapping.setMethodName( obf.getName(), obf.getSignature(), deobfName );
         }
         
         public void setArgumentName( ArgumentEntry obf, String deobfName )
@@ -137,8 +138,6 @@ public class MappingsRenamer
                         classMapping = new ClassMapping( obfClassName );
                         boolean obfWasAdded = m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping ) == null;
                         assert( obfWasAdded );
-                        boolean deobfWasAdded = m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null;
-                        assert( deobfWasAdded );
                 }
                 return classMapping;
         }
@@ -153,14 +152,6 @@ public class MappingsRenamer
                 return classMapping;
         }
         
-        private void updateDeobfMethodSignatures( )
-        {
-                for( ClassMapping classMapping : m_mappings.m_classesByObf.values() )
-                {
-                        classMapping.updateDeobfMethodSignatures( getTranslator( TranslationDirection.Deobfuscating ) );
-                }
-        }
-        
         private Translator getTranslator( TranslationDirection direction )
         {
                 return m_mappings.getTranslator( m_index.getTranslationIndex(), direction );
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
index ea6e655..3c86dfc 100644
--- a/src/cuchaz/enigma/mapping/MappingsWriter.java
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -80,10 +80,10 @@ public class MappingsWriter
                 }
                 else
                 {
-                        out.format( "%sMETHOD %s %s %s %s\n",
+                        out.format( "%sMETHOD %s %s %s\n",
                                 getIndent( depth ),
                                 methodMapping.getObfName(), methodMapping.getDeobfName(),
-                                methodMapping.getObfSignature(), methodMapping.getDeobfSignature()
+                                methodMapping.getObfSignature()
                         );
                 }
                 
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
index e59cb2e..6210fd0 100644
--- a/src/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -23,20 +23,26 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
         private String m_obfName;
         private String m_deobfName;
         private String m_obfSignature;
-        private String m_deobfSignature;
         private Map<Integer,ArgumentMapping> m_arguments;
         
         public MethodMapping( String obfName, String obfSignature )
         {
-                this( obfName, obfSignature, null, null );
+                this( obfName, obfSignature, null );
         }
         
-        public MethodMapping( String obfName, String obfSignature, String deobfName, String deobfSignature )
+        public MethodMapping( String obfName, String obfSignature, String deobfName )
         {
+                if( obfName == null )
+                {
+                        throw new IllegalArgumentException( "obf name cannot be null!" );
+                }
+                if( obfSignature == null )
+                {
+                        throw new IllegalArgumentException( "obf signature cannot be null!" );
+                }
                 m_obfName = obfName;
                 m_deobfName = NameValidator.validateMethodName( deobfName );
                 m_obfSignature = obfSignature;
-                m_deobfSignature = deobfSignature;
                 m_arguments = new TreeMap<Integer,ArgumentMapping>();
         }
 
@@ -59,15 +65,6 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
                 return m_obfSignature;
         }
         
-        public String getDeobfSignature( )
-        {
-                return m_deobfSignature;
-        }
-        public void setDeobfSignature( String val )
-        {
-                m_deobfSignature = val;
-        }
-        
         public Iterable<ArgumentMapping> arguments( )
         {
                 return m_arguments.values();
@@ -127,8 +124,6 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
                 buf.append( "\n" );
                 buf.append( "\t" );
                 buf.append( m_obfSignature );
-                buf.append( " <-> " );
-                buf.append( m_deobfSignature );
                 buf.append( "\n" );
                 buf.append( "\tArguments:\n" );
                 for( ArgumentMapping argumentMapping : m_arguments.values() )
@@ -145,7 +140,7 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
         @Override
         public int compareTo( MethodMapping other )
         {
-                return ( m_obfName + m_obfSignature ).compareTo( ( other.m_obfName + other.m_obfSignature ) );
+                return ( m_obfName + m_obfSignature ).compareTo( other.m_obfName + other.m_obfSignature );
         }
 
         public boolean renameObfClass( final String oldObfClassName, final String newObfClassName )
diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java
index f5aafdd..659ce9a 100644
--- a/src/cuchaz/enigma/mapping/Translator.java
+++ b/src/cuchaz/enigma/mapping/Translator.java
@@ -180,7 +180,7 @@ public class Translator
                                 // look for the method
                                 MethodMapping methodMapping = m_direction.choose(
                                         classMapping.getMethodByObf( in.getName(), in.getSignature() ),
-                                        classMapping.getMethodByDeobf( in.getName(), in.getSignature() )
+                                        classMapping.getMethodByDeobf( in.getName(), translateSignature( in.getSignature() ) )
                                 );
                                 if( methodMapping != null )
                                 {
@@ -248,7 +248,7 @@ public class Translator
                                 // look for the method
                                 MethodMapping methodMapping = m_direction.choose(
                                         classMapping.getMethodByObf( in.getMethodName(), in.getMethodSignature() ),
-                                        classMapping.getMethodByDeobf( in.getMethodName(), in.getMethodSignature() )
+                                        classMapping.getMethodByDeobf( in.getMethodName(), translateSignature( in.getMethodSignature() ) )
                                 );
                                 if( methodMapping != null )
                                 {