added checks to prevent renaming classes/fields/methods/arguments to the same name as other classes/fields/methods/arguments

5 files changed, 122 insertions, 1 deletions

diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java
index fc19e7bc..e7c92bea 100644
--- a/src/cuchaz/enigma/analysis/JarIndex.java
+++ b/src/cuchaz/enigma/analysis/JarIndex.java
@@ -891,4 +891,19 @@ public class JarIndex
                 }
                 return thing;
         }
+
+        public boolean containsObfClass( ClassEntry obfClassEntry )
+        {
+                return m_obfClassEntries.contains( obfClassEntry );
+        }
+
+        public boolean containsObfField( FieldEntry obfFieldEntry )
+        {
+                return m_access.containsKey( obfFieldEntry );
+        }
+
+        public boolean containsObfMethod( MethodEntry obfMethodEntry )
+        {
+                return m_access.containsKey( obfMethodEntry );
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 1219e7ca..5faaf2a1 100644
--- a/src/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -334,4 +334,24 @@ public class ClassMapping implements Serializable, Comparable<ClassMapping>
                 }
                 return false;
         }
+
+        public boolean containsDeobfField( String name )
+        {
+                return m_fieldsByDeobf.containsKey( name );
+        }
+
+        public boolean containsDeobfMethod( String name, String signature )
+        {
+                return m_methodsByDeobf.containsKey( getMethodKey( name, signature ) );
+        }
+
+        public boolean containsArgument( MethodEntry obfMethodEntry, String name )
+        {
+                MethodMapping methodMapping = m_methodsByObf.get( getMethodKey( obfMethodEntry.getName(), obfMethodEntry.getSignature() ) );
+                if( methodMapping != null )
+                {
+                        return methodMapping.containsArgument( name );
+                }
+                return false;
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java
index 0b03abb0..378d4c0a 100644
--- a/src/cuchaz/enigma/mapping/Mappings.java
+++ b/src/cuchaz/enigma/mapping/Mappings.java
@@ -179,4 +179,39 @@ public class Mappings implements Serializable
                 }
                 return classNames;
         }
+
+        public boolean containsDeobfClass( String deobfName )
+        {
+                return m_classesByDeobf.containsKey( deobfName );
+        }
+        
+        public boolean containsDeobfField( ClassEntry obfClassEntry, String deobfName )
+        {
+                ClassMapping classMapping = m_classesByObf.get( obfClassEntry.getName() );
+                if( classMapping != null )
+                {
+                        return classMapping.containsDeobfField( deobfName );
+                }
+                return false;
+        }
+
+        public boolean containsDeobfMethod( ClassEntry obfClassEntry, String deobfName, String deobfSignature )
+        {
+                ClassMapping classMapping = m_classesByObf.get( obfClassEntry.getName() );
+                if( classMapping != null )
+                {
+                        return classMapping.containsDeobfMethod( deobfName, deobfSignature );
+                }
+                return false;
+        }
+
+        public boolean containsArgument( MethodEntry obfMethodEntry, String name )
+        {
+                ClassMapping classMapping = m_classesByObf.get( obfMethodEntry.getClassName() );
+                if( classMapping != null )
+                {
+                        return classMapping.containsArgument( obfMethodEntry, name );
+                }
+                return false;
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java
index b0f7ba84..bf83bd21 100644
--- a/src/cuchaz/enigma/mapping/MethodMapping.java
+++ b/src/cuchaz/enigma/mapping/MethodMapping.java
@@ -165,4 +165,16 @@ public class MethodMapping implements Serializable, Comparable<MethodMapping>
                 }
                 return false;
         }
+
+        public boolean containsArgument( String name )
+        {
+                for( ArgumentMapping argumentMapping : m_arguments.values() )
+                {
+                        if( argumentMapping.getName().equals( name ) )
+                        {
+                                return true;
+                        }
+                }
+                return false;
+        }
 }
diff --git a/src/cuchaz/enigma/mapping/Renamer.java b/src/cuchaz/enigma/mapping/Renamer.java
index 79cbd30d..15d9af4d 100644
--- a/src/cuchaz/enigma/mapping/Renamer.java
+++ b/src/cuchaz/enigma/mapping/Renamer.java
@@ -13,6 +13,7 @@ package cuchaz.enigma.mapping;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.io.OutputStream;
+import java.util.Set;
 import java.util.zip.GZIPOutputStream;
 
 import cuchaz.enigma.analysis.JarIndex;
@@ -31,6 +32,12 @@ public class Renamer
         public void setClassName( ClassEntry obf, String deobfName )
         {
                 deobfName = NameValidator.validateClassName( deobfName );
+                ClassEntry targetEntry = new ClassEntry( deobfName );
+                if( m_mappings.containsDeobfClass( deobfName ) || m_index.containsObfClass( targetEntry ) )
+                {
+                        throw new IllegalNameException( deobfName, "There is already a class with that name" );
+                }
+                
                 ClassMapping classMapping = getOrCreateClassMapping( obf );
                 
                 if( obf.isInnerClass() )
@@ -50,13 +57,32 @@ public class Renamer
         public void setFieldName( FieldEntry obf, String deobfName )
         {
                 deobfName = NameValidator.validateFieldName( deobfName );
+                FieldEntry targetEntry = new FieldEntry( obf.getClassEntry(), deobfName );
+                if( m_mappings.containsDeobfField( obf.getClassEntry(), deobfName ) || m_index.containsObfField( targetEntry ) )
+                {
+                        throw new IllegalNameException( deobfName, "There is already a field with that name" );
+                }
+                
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() );
                 classMapping.setFieldName( obf.getName(), deobfName );
         }
         
         public void setMethodTreeName( MethodEntry obf, String deobfName )
         {
-                for( MethodEntry entry : m_index.getRelatedMethodImplementations( obf ) )
+                Set<MethodEntry> implementations = m_index.getRelatedMethodImplementations( obf );
+                
+                deobfName = NameValidator.validateMethodName( deobfName );
+                for( MethodEntry entry : implementations )
+                {
+                        MethodEntry targetEntry = new MethodEntry( entry.getClassEntry(), deobfName, entry.getSignature() );
+                        if( m_mappings.containsDeobfMethod( entry.getClassEntry(), deobfName, entry.getSignature() ) || m_index.containsObfMethod( targetEntry ) )
+                        {
+                                String className = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateClass( entry.getClassName() );
+                                throw new IllegalNameException( deobfName, "There is already a method with that name and signature in class " + className );
+                        }
+                }
+                
+                for( MethodEntry entry : implementations )
                 {
                         setMethodName( entry, deobfName );
                 }
@@ -65,6 +91,13 @@ public class Renamer
         public void setMethodName( MethodEntry obf, String deobfName )
         {
                 deobfName = NameValidator.validateMethodName( deobfName );
+                MethodEntry targetEntry = new MethodEntry( obf.getClassEntry(), deobfName, obf.getSignature() );
+                if( m_mappings.containsDeobfMethod( obf.getClassEntry(), deobfName, obf.getSignature() ) || m_index.containsObfMethod( targetEntry ) )
+                {
+                        String className = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateClass( obf.getClassName() );
+                        throw new IllegalNameException( deobfName, "There is already a method with that name and signature in class " + className );
+                }
+                
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() );
                 String deobfSignature = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() );
                 classMapping.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature );
@@ -73,6 +106,12 @@ public class Renamer
         public void setArgumentName( ArgumentEntry obf, String deobfName )
         {
                 deobfName = NameValidator.validateArgumentName( deobfName );
+                // NOTE: don't need to check arguments for name collisions with names determined by Procyon
+                if( m_mappings.containsArgument( obf.getMethodEntry(), deobfName ) )
+                {
+                        throw new IllegalNameException( deobfName, "There is already an argument with that name" );
+                }
+                
                 ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() );
                 classMapping.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName );
         }