big refactor to better model class/method mappings with no deobf name

9 files changed, 276 insertions, 155 deletions

diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java
index d15c25f9..526534da 100644
--- a/src/cuchaz/enigma/Deobfuscator.java
+++ b/src/cuchaz/enigma/Deobfuscator.java
@@ -192,7 +192,7 @@ public class Deobfuscator
                 // we need to tell the decompiler the deobfuscated name so it doesn't get freaked out
                 // the decompiler only sees the deobfuscated class, so we need to load it by the deobfuscated name
                 ClassMapping classMapping = m_mappings.getClassByObf( className );
-                if( classMapping != null )
+                if( classMapping != null && classMapping.getDeobfName() != null )
                 {
                         className = classMapping.getDeobfName();
                 }
diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java
index c0fb2e40..5057db2d 100644
--- a/src/cuchaz/enigma/gui/GuiController.java
+++ b/src/cuchaz/enigma/gui/GuiController.java
@@ -167,6 +167,8 @@ public class GuiController
         
         public boolean entryHasMapping( Entry deobfEntry )
         {
+                // TEMP
+                System.out.println( deobfEntry + " -> " + m_deobfuscator.obfuscateEntry( deobfEntry ) );
                 return m_deobfuscator.hasMapping( m_deobfuscator.obfuscateEntry( deobfEntry ) );
         }
         
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 5faaf2a1..bce16cc5 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -29,7 +29,11 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         private Map<String,MethodMapping> m_methodsByObf;
         private Map<String,MethodMapping> m_methodsByDeobf;
         
-        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ClassMapping( String obfName )
+        {
+                this( obfName, null );
+        }
+        
         public ClassMapping( String obfName, String deobfName )
         {
                 m_obfName = obfName;
@@ -60,14 +64,19 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         
         public Iterable<ClassMapping> innerClasses( )
         {
-                assert( m_innerClassesByObf.size() == m_innerClassesByDeobf.size() );
+                assert( m_innerClassesByObf.size() >= m_innerClassesByDeobf.size() );
                 return m_innerClassesByObf.values();
         }
         
-        protected void addInnerClassMapping( ClassMapping classMapping )
+        public void addInnerClassMapping( ClassMapping classMapping )
         {
-                m_innerClassesByObf.put( classMapping.getObfName(), classMapping );
-                m_innerClassesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                boolean obfWasAdded = m_innerClassesByObf.put( classMapping.getObfName(), classMapping ) == null;
+                assert( obfWasAdded );
+                if( classMapping.getDeobfName() != null )
+                {
+                        boolean deobfWasAdded = m_innerClassesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null;
+                        assert( deobfWasAdded );
+                }
         }
         
         public ClassMapping getOrCreateInnerClass( String obfName )
@@ -75,9 +84,9 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 ClassMapping classMapping = m_innerClassesByObf.get( obfName );
                 if( classMapping == null )
                 {
-                        classMapping = new ClassMapping( obfName, obfName );
-                        m_innerClassesByObf.put( obfName, classMapping );
-                        m_innerClassesByDeobf.put( obfName, classMapping );
+                        classMapping = new ClassMapping( obfName );
+                        boolean wasAdded = m_innerClassesByObf.put( obfName, classMapping ) == null;
+                        assert( wasAdded );
                 }
                 return classMapping;
         }
@@ -115,9 +124,11 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
         public void setInnerClassName( String obfName, String deobfName )
         {
                 ClassMapping classMapping = getOrCreateInnerClass( obfName );
-                m_innerClassesByDeobf.remove( classMapping.getDeobfName() );
+                boolean wasRemoved = m_innerClassesByDeobf.remove( classMapping.getDeobfName() ) != null;
+                assert( wasRemoved );
                 classMapping.setDeobfName( deobfName );
-                m_innerClassesByDeobf.put( deobfName, classMapping );
+                boolean wasAdded = m_innerClassesByDeobf.put( deobfName, classMapping ) == null;
+                assert( wasAdded );
         }
         
         //// FIELDS ////////
@@ -128,7 +139,7 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 return m_fieldsByObf.values();
         }
         
-        protected void addFieldMapping( FieldMapping fieldMapping )
+        public void addFieldMapping( FieldMapping fieldMapping )
         {
                 if( m_fieldsByObf.containsKey( fieldMapping.getObfName() ) )
                 {
@@ -138,8 +149,10 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 {
                         throw new Error( "Already have mapping for " + m_deobfName + "." + fieldMapping.getDeobfName() );
                 }
-                m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping );
-                m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping );
+                boolean obfWasAdded = m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping ) == null;
+                assert( obfWasAdded );
+                boolean deobfWasAdded = m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping ) == null;
+                assert( deobfWasAdded );
                 assert( m_fieldsByObf.size() == m_fieldsByDeobf.size() );
         }
 
@@ -169,38 +182,47 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 if( fieldMapping == null )
                 {
                         fieldMapping = new FieldMapping( obfName, deobfName );
-                        m_fieldsByObf.put( obfName, fieldMapping );
-                        m_fieldsByDeobf.put( deobfName, fieldMapping );
+                        boolean obfWasAdded = m_fieldsByObf.put( obfName, fieldMapping ) == null;
+                        assert( obfWasAdded );
+                }
+                else
+                {
+                        boolean wasRemoved = m_fieldsByDeobf.remove( fieldMapping.getDeobfName() ) != null;
+                        assert( wasRemoved );
                 }
-                
-                m_fieldsByDeobf.remove( fieldMapping.getDeobfName() );
                 fieldMapping.setDeobfName( deobfName );
-                m_fieldsByDeobf.put( deobfName, fieldMapping );
+                boolean wasAdded = m_fieldsByDeobf.put( deobfName, fieldMapping ) == null;
+                assert( wasAdded );
         }
         
         //// METHODS ////////
         
         public Iterable<MethodMapping> methods( )
         {
-                assert( m_methodsByObf.size() == m_methodsByDeobf.size() );
+                assert( m_methodsByObf.size() >= m_methodsByDeobf.size() );
                 return m_methodsByObf.values();
         }
         
-        protected void addMethodMapping( MethodMapping methodMapping )
+        public void addMethodMapping( MethodMapping methodMapping )
         {
                 String obfKey = getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() );
-                String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() );
                 if( m_methodsByObf.containsKey( obfKey ) )
                 {
                         throw new Error( "Already have mapping for " + m_obfName + "." + obfKey );
                 }
-                if( m_methodsByDeobf.containsKey( deobfKey ) )
+                boolean wasAdded = m_methodsByObf.put( obfKey, methodMapping ) == null;
+                assert( wasAdded );
+                if( methodMapping.getDeobfName() != null )
                 {
-                        throw new Error( "Already have mapping for " + m_deobfName + "." + deobfKey );
+                        String deobfKey = getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() );
+                        if( m_methodsByDeobf.containsKey( deobfKey ) )
+                        {
+                                throw new Error( "Already have mapping for " + m_deobfName + "." + deobfKey );
+                        }
+                        boolean deobfWasAdded = m_methodsByDeobf.put( deobfKey, methodMapping ) == null;
+                        assert( deobfWasAdded );
                 }
-                m_methodsByObf.put( obfKey, methodMapping );
-                m_methodsByDeobf.put( deobfKey, methodMapping );
-                assert( m_methodsByObf.size() == m_methodsByDeobf.size() );
+                assert( m_methodsByObf.size() >= m_methodsByDeobf.size() );
         }
         
         public MethodMapping getMethodByObf( String obfName, String signature )
@@ -231,13 +253,17 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 MethodMapping methodMapping = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
                 if( methodMapping == null )
                 {
-                        methodMapping = createMethodIndex( obfName, obfSignature );
+                        methodMapping = createMethodMapping( obfName, obfSignature );
+                }
+                else
+                {
+                        boolean wasRemoved = m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ) ) != null;
+                        assert( wasRemoved );
                 }
-                
-                m_methodsByDeobf.remove( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ) );
                 methodMapping.setDeobfName( deobfName );
                 methodMapping.setDeobfSignature( deobfSignature );
-                m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodMapping );
+                boolean wasAdded = m_methodsByDeobf.put( getMethodKey( deobfName, deobfSignature ), methodMapping ) == null;
+                assert( wasAdded );
         }
         
         public void updateDeobfMethodSignatures( Translator translator )
@@ -255,17 +281,16 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) );
                 if( methodIndex == null )
                 {
-                        methodIndex = createMethodIndex( obfMethodName, obfMethodSignature );
+                        methodIndex = createMethodMapping( obfMethodName, obfMethodSignature );
                 }
                 methodIndex.setArgumentName( argumentIndex, argumentName );
         }
 
-        private MethodMapping createMethodIndex( String obfName, String obfSignature )
+        private MethodMapping createMethodMapping( String obfName, String obfSignature )
         {
-                MethodMapping methodMapping = new MethodMapping( obfName, obfName, obfSignature, obfSignature );
-                String key = getMethodKey( obfName, obfSignature );
-                m_methodsByObf.put( key, methodMapping );
-                m_methodsByDeobf.put( key, methodMapping );
+                MethodMapping methodMapping = new MethodMapping( obfName, obfSignature );
+                boolean wasAdded = m_methodsByObf.put( getMethodKey( obfName, obfSignature ), methodMapping ) == null;
+                assert( wasAdded );
                 return methodMapping;
         }
 
@@ -308,9 +333,10 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 {
                         if( innerClassMapping.renameObfClass( oldObfClassName, newObfClassName ) )
                         {
-                                m_innerClassesByObf.remove( oldObfClassName );
-                                m_innerClassesByObf.put( newObfClassName, innerClassMapping );
-                                assert( m_innerClassesByObf.size() == m_innerClassesByDeobf.size() );
+                                boolean wasRemoved = m_innerClassesByObf.remove( oldObfClassName ) != null;
+                                assert( wasRemoved );
+                                boolean wasAdded = m_innerClassesByObf.put( newObfClassName, innerClassMapping ) == null;
+                                assert( wasAdded );
                         }
                 }
                 
@@ -320,9 +346,10 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                         String oldMethodKey = getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() );
                         if( methodMapping.renameObfClass( oldObfClassName, newObfClassName ) )
                         {
-                                m_methodsByObf.remove( oldMethodKey );
-                                m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping );
-                                assert( m_methodsByObf.size() == m_methodsByDeobf.size() );
+                                boolean wasRemoved = m_methodsByObf.remove( oldMethodKey ) != null;
+                                assert( wasRemoved );
+                                boolean wasAdded = m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping ) == null;
+                                assert( wasAdded );
                         }
                 }
                 
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
index f52094fd..99cb85f0 100644
--- a/src/cuchaz/enigma/mapping/Mappings.java
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -47,7 +47,10 @@ public class Mappings implements Serializable
                 for( ClassMapping classMapping : classes )
                 {
                         m_classesByObf.put( classMapping.getObfName(), classMapping );
-                        m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                        if( classMapping.getDeobfName() != null )
+                        {
+                                m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                        }
                 }
         }
         
@@ -68,23 +71,27 @@ public class Mappings implements Serializable
         
         public Collection<ClassMapping> classes( )
         {
-                assert( m_classesByObf.size() == m_classesByDeobf.size() );
+                assert( m_classesByObf.size() >= m_classesByDeobf.size() );
                 return m_classesByObf.values();
         }
         
-        protected void addClassMapping( ClassMapping classMapping )
+        public void addClassMapping( ClassMapping classMapping )
         {
                 if( m_classesByObf.containsKey( classMapping.getObfName() ) )
                 {
                         throw new Error( "Already have mapping for " + classMapping.getObfName() );
                 }
-                if( m_classesByDeobf.containsKey( classMapping.getDeobfName() ) )
+                boolean obfWasAdded = m_classesByObf.put( classMapping.getObfName(), classMapping ) == null;
+                assert( obfWasAdded );
+                if( classMapping.getDeobfName() != null )
                 {
-                        throw new Error( "Already have mapping for " + classMapping.getDeobfName() );
+                        if( m_classesByDeobf.containsKey( classMapping.getDeobfName() ) )
+                        {
+                                throw new Error( "Already have mapping for " + classMapping.getDeobfName() );
+                        }
+                        boolean deobfWasAdded = m_classesByDeobf.put( classMapping.getDeobfName(), classMapping ) == null;
+                        assert( deobfWasAdded );
                 }
-                m_classesByObf.put( classMapping.getObfName(), classMapping );
-                m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
-                assert( m_classesByObf.size() == m_classesByDeobf.size() );
         }
         
         public ClassMapping getClassByObf( ClassEntry entry )
@@ -99,7 +106,7 @@ public class Mappings implements Serializable
         
         public ClassMapping getClassByDeobf( ClassEntry entry )
         {
-                return getClassByObf( entry.getName() );
+                return getClassByDeobf( entry.getName() );
         }
         
         public ClassMapping getClassByDeobf( String deobfName )
@@ -109,26 +116,52 @@ public class Mappings implements Serializable
         
         public Translator getTranslator( TranslationIndex index, TranslationDirection direction )
         {
-                if( direction == TranslationDirection.Obfuscating )
+                switch( direction )
                 {
-                        // deobfuscate the index
-                        index = new TranslationIndex( index );
-                        Map<String,String> renames = Maps.newHashMap();
-                        for( ClassMapping classMapping : classes() )
-                        {
-                                renames.put( classMapping.getObfName(), classMapping.getDeobfName() );
-                                for( ClassMapping innerClassMapping : classMapping.innerClasses() )
+                        case Deobfuscating:
+                                
+                                return new Translator( direction, m_classesByObf, index );
+                                
+                        case Obfuscating:
+                                
+                                // deobfuscate the index
+                                index = new TranslationIndex( index );
+                                Map<String,String> renames = Maps.newHashMap();
+                                for( ClassMapping classMapping : classes() )
                                 {
-                                        renames.put( innerClassMapping.getObfName(), innerClassMapping.getDeobfName() );
+                                        if( classMapping.getDeobfName() != null )
+                                        {
+                                                renames.put( classMapping.getObfName(), classMapping.getDeobfName() );
+                                        }
+                                        for( ClassMapping innerClassMapping : classMapping.innerClasses() )
+                                        {
+                                                if( innerClassMapping.getDeobfName() != null )
+                                                {
+                                                        renames.put( innerClassMapping.getObfName(), innerClassMapping.getDeobfName() );
+                                                }
+                                        }
                                 }
-                        }
-                        index.renameClasses( renames );
+                                index.renameClasses( renames );
+                                
+                                // fill in the missing deobf class entries with obf entries
+                                Map<String,ClassMapping> classes = Maps.newHashMap();
+                                for( ClassMapping classMapping : classes() )
+                                {
+                                        if( classMapping.getDeobfName() != null )
+                                        {
+                                                classes.put( classMapping.getDeobfName(), classMapping );
+                                        }
+                                        else
+                                        {
+                                                classes.put( classMapping.getObfName(), classMapping );
+                                        }
+                                }
+                                
+                                return new Translator( direction, classes, index );
+                                
+                        default:
+                                throw new Error( "Invalid translation direction!" );
                 }
-                return new Translator(
-                        direction,
-                        direction.choose( m_classesByObf, m_classesByDeobf ),
-                        index
-                );
         }
         
         public static Mappings newFromStream( InputStream in )
@@ -162,9 +195,10 @@ public class Mappings implements Serializable
                 {
                         if( classMapping.renameObfClass( oldObfName, newObfName ) )
                         {
-                                m_classesByObf.remove( oldObfName );
-                                m_classesByObf.put( newObfName, classMapping );
-                                assert( m_classesByObf.size() == m_classesByDeobf.size() );
+                                boolean wasRemoved = m_classesByObf.remove( oldObfName ) != null;
+                                assert( wasRemoved );
+                                boolean wasAdded = m_classesByObf.put( newObfName, classMapping ) == null;
+                                assert( wasAdded );
                         }
                 }
         }
diff --git a/src/cuchaz/enigma/mapping/MappingsReader.java b/src/cuchaz/enigma/mapping/MappingsReader.java
index 9f42b42c..7888836e 100644
--- a/src/cuchaz/enigma/mapping/MappingsReader.java
+++ b/src/cuchaz/enigma/mapping/MappingsReader.java
@@ -14,13 +14,10 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;
 import java.util.Deque;
-import java.util.NoSuchElementException;
-import java.util.Scanner;
 
 import com.google.common.collect.Queues;
 
 import cuchaz.enigma.Constants;
-import cuchaz.enigma.Util;
 import cuchaz.enigma.mapping.SignatureUpdater.ClassNameUpdater;
 
 public class MappingsReader
@@ -73,89 +70,99 @@ public class MappingsReader
                                 mappingStack.pop();
                         }
                         
-                        Scanner scanner = new Scanner( line );
+                        String[] parts = line.trim().split( "\\s" );
                         try
                         {
-                                while( scanner.hasNext() )
+                                // read the first token
+                                String token = parts[0];
+                                
+                                if( token.equalsIgnoreCase( "CLASS" ) )
                                 {
-                                        // read the first token
-                                        String token = scanner.next();
-                                        
-                                        if( token.equalsIgnoreCase( "CLASS" ) )
+                                        ClassMapping classMapping = readClass( parts );
+                                        if( indent == 0 )
                                         {
-                                                ClassMapping classMapping = readClass( scanner );
-                                                if( indent == 0 )
-                                                {
-                                                        // outer class
-                                                        mappings.addClassMapping( classMapping );
-                                                }
-                                                else if( indent == 1 )
-                                                {
-                                                        // inner class
-                                                        if( !( mappingStack.getFirst() instanceof ClassMapping ) )
-                                                        {
-                                                                throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" );
-                                                        }
-                                                        ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping( classMapping );
-                                                }
-                                                else
+                                                // outer class
+                                                mappings.addClassMapping( classMapping );
+                                        }
+                                        else if( indent == 1 )
+                                        {
+                                                // inner class
+                                                if( !( mappingStack.getFirst() instanceof ClassMapping ) )
                                                 {
                                                         throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" );
                                                 }
-                                                mappingStack.push( classMapping );
+                                                ((ClassMapping)mappingStack.getFirst()).addInnerClassMapping( classMapping );
                                         }
-                                        else if( token.equalsIgnoreCase( "FIELD" ) )
+                                        else
                                         {
-                                                if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) )
-                                                {
-                                                        throw new MappingParseException( lineNumber, "Unexpected FIELD entry here!" );
-                                                }
-                                                ((ClassMapping)mappingStack.getFirst()).addFieldMapping( readField( scanner ) );
+                                                throw new MappingParseException( lineNumber, "Unexpected CLASS entry here!" );
                                         }
-                                        else if( token.equalsIgnoreCase( "METHOD" ) )
+                                        mappingStack.push( classMapping );
+                                }
+                                else if( token.equalsIgnoreCase( "FIELD" ) )
+                                {
+                                        if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) )
                                         {
-                                                if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) )
-                                                {
-                                                        throw new MappingParseException( lineNumber, "Unexpected METHOD entry here!" );
-                                                }
-                                                MethodMapping methodMapping = readMethod( scanner );
-                                                ((ClassMapping)mappingStack.getFirst()).addMethodMapping( methodMapping );
-                                                mappingStack.push( methodMapping );
+                                                throw new MappingParseException( lineNumber, "Unexpected FIELD entry here!" );
                                         }
-                                        else if( token.equalsIgnoreCase( "ARG" ) )
+                                        ((ClassMapping)mappingStack.getFirst()).addFieldMapping( readField( parts ) );
+                                }
+                                else if( token.equalsIgnoreCase( "METHOD" ) )
+                                {
+                                        if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof ClassMapping) )
                                         {
-                                                if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof MethodMapping) )
-                                                {
-                                                        throw new MappingParseException( lineNumber, "Unexpected ARG entry here!" );
-                                                }
-                                                ((MethodMapping)mappingStack.getFirst()).addArgumentMapping( readArgument( scanner ) );
+                                                throw new MappingParseException( lineNumber, "Unexpected METHOD entry here!" );
+                                        }
+                                        MethodMapping methodMapping = readMethod( parts );
+                                        ((ClassMapping)mappingStack.getFirst()).addMethodMapping( methodMapping );
+                                        mappingStack.push( methodMapping );
+                                }
+                                else if( token.equalsIgnoreCase( "ARG" ) )
+                                {
+                                        if( mappingStack.isEmpty() || !(mappingStack.getFirst() instanceof MethodMapping) )
+                                        {
+                                                throw new MappingParseException( lineNumber, "Unexpected ARG entry here!" );
                                         }
+                                        ((MethodMapping)mappingStack.getFirst()).addArgumentMapping( readArgument( parts ) );
                                 }
                         }
-                        catch( NoSuchElementException ex )
+                        catch( ArrayIndexOutOfBoundsException | NumberFormatException ex )
                         {
                                 throw new MappingParseException( lineNumber, "Malformed line!" );
                         }
-                        finally
-                        {
-                                Util.closeQuietly( scanner );
-                        }
                 }
                 
                 return mappings;
         }
 
-        private ArgumentMapping readArgument( Scanner scanner )
+        private ArgumentMapping readArgument( String[] parts )
         {
-                return new ArgumentMapping( scanner.nextInt(), scanner.next() );
+                return new ArgumentMapping( Integer.parseInt( parts[1] ), parts[2] );
         }
 
-        private ClassMapping readClass( Scanner scanner )
+        private ClassMapping readClass( String[] parts )
         {
-                return new ClassMapping(
-                        moveClassOutOfDefaultPackage( scanner.next(), Constants.NonePackage ),
-                        moveClassOutOfDefaultPackage( scanner.next(), Constants.NonePackage )
-                );
+                if( parts.length == 2 )
+                {
+                        String obfName = parts[1];
+                        return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) );
+                }
+                else
+                {
+                        String obfName = parts[1];
+                        String deobfName = parts[2];
+                        if( obfName.equals( deobfName ) )
+                        {
+                                return new ClassMapping( moveClassOutOfDefaultPackage( obfName, Constants.NonePackage ) );
+                        }
+                        else
+                        {
+                                return new ClassMapping(
+                                        moveClassOutOfDefaultPackage( parts[1], Constants.NonePackage ),
+                                        moveClassOutOfDefaultPackage( parts[2], Constants.NonePackage )
+                                );
+                        }
+                }
         }
         
         private String moveClassOutOfDefaultPackage( String className, String newPackageName )
@@ -168,18 +175,34 @@ public class MappingsReader
                 return className;
         }
 
-        private FieldMapping readField( Scanner scanner )
+        private FieldMapping readField( String[] parts )
         {
-                return new FieldMapping( scanner.next(), scanner.next() );
+                return new FieldMapping( parts[1], parts[2] );
         }
         
-        private MethodMapping readMethod( Scanner scanner )
+        private MethodMapping readMethod( String[] parts )
         {
-                return new MethodMapping(
-                        scanner.next(), scanner.next(),
-                        moveSignatureOutOfDefaultPackage( scanner.next(), Constants.NonePackage ),
-                        moveSignatureOutOfDefaultPackage( scanner.next(), Constants.NonePackage )
-                );
+                if( parts.length == 3 )
+                {
+                        String obfName = parts[1];
+                        String obfSignature = moveSignatureOutOfDefaultPackage( parts[2], Constants.NonePackage );
+                        return new MethodMapping( obfName, obfSignature );
+                }
+                else
+                {
+                        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 );
+                        }
+                }
         }
 
         private String moveSignatureOutOfDefaultPackage( String signature, final String newPackageName )
diff --git a/src/cuchaz/enigma/mapping/MappingsRenamer.java b/src/cuchaz/enigma/mapping/MappingsRenamer.java
index 9d036d8f..f84b2489 100644
--- a/src/cuchaz/enigma/mapping/MappingsRenamer.java
+++ b/src/cuchaz/enigma/mapping/MappingsRenamer.java
@@ -46,9 +46,11 @@ public class MappingsRenamer
                 }
                 else
                 {
-                        m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() );
+                        boolean wasRemoved = m_mappings.m_classesByDeobf.remove( classMapping.getDeobfName() ) != null;
+                        assert( wasRemoved );
                         classMapping.setDeobfName( deobfName );
-                        m_mappings.m_classesByDeobf.put( deobfName, classMapping );
+                        boolean wasAdded = m_mappings.m_classesByDeobf.put( deobfName, classMapping ) == null;
+                        assert( wasAdded );
                 }
                 
                 updateDeobfMethodSignatures();
@@ -132,9 +134,11 @@ public class MappingsRenamer
                 ClassMapping classMapping = m_mappings.m_classesByObf.get( obfClassName );
                 if( classMapping == null )
                 {
-                        classMapping = new ClassMapping( obfClassName, obfClassName );
-                        m_mappings.m_classesByObf.put( classMapping.getObfName(), classMapping );
-                        m_mappings.m_classesByDeobf.put( classMapping.getDeobfName(), classMapping );
+                        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;
         }
diff --git a/src/cuchaz/enigma/mapping/MappingsWriter.java b/src/cuchaz/enigma/mapping/MappingsWriter.java
index 62035713..ea6e6558 100644
--- a/src/cuchaz/enigma/mapping/MappingsWriter.java
+++ b/src/cuchaz/enigma/mapping/MappingsWriter.java
@@ -37,7 +37,14 @@ public class MappingsWriter
         private void write( PrintWriter out, ClassMapping classMapping, int depth )
         throws IOException
         {
-                out.format( "%sCLASS %s %s\n", getIndent( depth ), classMapping.getObfName(), classMapping.getDeobfName() );
+                if( classMapping.getDeobfName() == null )
+                {
+                        out.format( "%sCLASS %s\n", getIndent( depth ), classMapping.getObfName() );
+                }
+                else
+                {
+                        out.format( "%sCLASS %s %s\n", getIndent( depth ), classMapping.getObfName(), classMapping.getDeobfName() );
+                }
                 
                 for( ClassMapping innerClassMapping : sorted( classMapping.innerClasses() ) )
                 {
@@ -64,11 +71,21 @@ public class MappingsWriter
         private void write( PrintWriter out, MethodMapping methodMapping, int depth )
         throws IOException
         {
-                out.format( "%sMETHOD %s %s %s %s\n",
-                        getIndent( depth ),
-                        methodMapping.getObfName(), methodMapping.getDeobfName(),
-                        methodMapping.getObfSignature(), methodMapping.getDeobfSignature()
-                );
+                if( methodMapping.getDeobfName() == null )
+                {
+                        out.format( "%sMETHOD %s %s\n",
+                                getIndent( depth ),
+                                methodMapping.getObfName(), methodMapping.getObfSignature()
+                        );
+                }
+                else
+                {
+                        out.format( "%sMETHOD %s %s %s %s\n",
+                                getIndent( depth ),
+                                methodMapping.getObfName(), methodMapping.getDeobfName(),
+                                methodMapping.getObfSignature(), methodMapping.getDeobfSignature()
+                        );
+                }
                 
                 for( ArgumentMapping argumentMapping : sorted( methodMapping.arguments() ) )
                 {
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
index bf83bd21..e59cb2eb 100644
--- a/src/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -26,8 +26,12 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
         private String m_deobfSignature;
         private Map<Integer,ArgumentMapping> m_arguments;
         
-        // NOTE: this argument order is important for the MethodReader/MethodWriter
-        public MethodMapping( String obfName, String deobfName, String obfSignature, String deobfSignature )
+        public MethodMapping( String obfName, String obfSignature )
+        {
+                this( obfName, obfSignature, null, null );
+        }
+        
+        public MethodMapping( String obfName, String obfSignature, String deobfName, String deobfSignature )
         {
                 m_obfName = obfName;
                 m_deobfName = NameValidator.validateMethodName( deobfName );
@@ -69,9 +73,10 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
                 return m_arguments.values();
         }
         
-        protected void addArgumentMapping( ArgumentMapping argumentMapping )
+        public void addArgumentMapping( ArgumentMapping argumentMapping )
         {
-                m_arguments.put( argumentMapping.getIndex(), argumentMapping );
+                boolean wasAdded = m_arguments.put( argumentMapping.getIndex(), argumentMapping ) == null;
+                assert( wasAdded );
         }
         
         public String getObfArgumentName( int index )
@@ -102,7 +107,8 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
                 if( argumentMapping == null )
                 {
                         argumentMapping = new ArgumentMapping( index, name );
-                        m_arguments.put( index, argumentMapping );
+                        boolean wasAdded = m_arguments.put( index, argumentMapping ) == null;
+                        assert( wasAdded );
                 }
                 else
                 {
diff --git a/src/cuchaz/enigma/mapping/NameValidator.java b/src/cuchaz/enigma/mapping/NameValidator.java
index 6df893fb..9adf1ac1 100644
--- a/src/cuchaz/enigma/mapping/NameValidator.java
+++ b/src/cuchaz/enigma/mapping/NameValidator.java
@@ -57,7 +57,11 @@ public class NameValidator
         
         public static String validateClassName( String name )
         {
-                if( name == null || !ClassPattern.matcher( name ).matches() || ReservedWords.contains( name ) )
+                if( name == null )
+                {
+                        return null;
+                }
+                if( !ClassPattern.matcher( name ).matches() || ReservedWords.contains( name ) )
                 {
                         throw new IllegalNameException( name, "This doesn't look like a legal class name" );
                 }
@@ -70,7 +74,11 @@ public class NameValidator
         
         public static String validateFieldName( String name )
         {
-                if( name == null || !IdentifierPattern.matcher( name ).matches() || ReservedWords.contains( name ) )
+                if( name == null )
+                {
+                        return null;
+                }
+                if( !IdentifierPattern.matcher( name ).matches() || ReservedWords.contains( name ) )
                 {
                         throw new IllegalNameException( name, "This doesn't look like a legal identifier" );
                 }