debugging class matcher... almost got it!

1 files changed, 183 insertions, 82 deletions

diff --git a/src/cuchaz/enigma/convert/ClassMapper.java b/src/cuchaz/enigma/convert/ClassMatcher.java
index fd6ab92..ac07a5b 100644
--- a/src/cuchaz/enigma/convert/ClassMapper.java
+++ b/src/cuchaz/enigma/convert/ClassMatcher.java
@@ -14,8 +14,12 @@ import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.util.AbstractMap;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -23,12 +27,15 @@ import java.util.Set;
 import java.util.TreeMap;
 import java.util.jar.JarFile;
 
+import javassist.CtBehavior;
 import javassist.CtClass;
 
+import com.beust.jcommander.internal.Lists;
 import com.beust.jcommander.internal.Sets;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
 import com.google.common.collect.Maps;
 
-import cuchaz.enigma.Constants;
 import cuchaz.enigma.TranslatingTypeLoader;
 import cuchaz.enigma.analysis.JarIndex;
 import cuchaz.enigma.convert.ClassNamer.SidedClassNamer;
@@ -38,73 +45,107 @@ import cuchaz.enigma.mapping.MappingParseException;
 import cuchaz.enigma.mapping.Mappings;
 import cuchaz.enigma.mapping.MappingsReader;
 import cuchaz.enigma.mapping.MappingsWriter;
+import cuchaz.enigma.mapping.MethodEntry;
+import cuchaz.enigma.mapping.MethodMapping;
 
-public class ClassMapper
+public class ClassMatcher
 {
         public static void main( String[] args )
         throws IOException, MappingParseException
         {
                 // TEMP
-                JarFile fromJar = new JarFile( new File( "input/1.8-pre1.jar" ) );
-                JarFile toJar = new JarFile( new File( "input/1.8-pre3.jar" ) );
+                JarFile sourceJar = new JarFile( new File( "input/1.8-pre1.jar" ) );
+                JarFile destJar = new JarFile( new File( "input/1.8-pre2.jar" ) );
                 File inMappingsFile = new File( "../minecraft-mappings/1.8-pre.mappings" );
-                File outMappingsFile = new File( "../minecraft-mappings/1.8-pre3.mappings" );
+                File outMappingsFile = new File( "../minecraft-mappings/1.8-pre2.mappings" );
                 
+                // do the conversion
+                Mappings mappings = new MappingsReader().read( new FileReader( inMappingsFile ) );
+                convertMappings( sourceJar, destJar, mappings );
+                
+                // write out the convert mappings
+                FileWriter writer = new FileWriter( outMappingsFile );
+                new MappingsWriter().write( writer, mappings );
+                writer.close();
+                System.out.println( "Wrote converted mappings to:\n\t" + outMappingsFile.getAbsolutePath() );
+        }
+        
+        private static void convertMappings( JarFile sourceJar, JarFile destJar, Mappings mappings )
+        {
+                // index jars
+                System.out.println( "Indexing source jar..." );
+                JarIndex sourceIndex = new JarIndex();
+                sourceIndex.indexJar( sourceJar, false );
+                System.out.println( "Indexing dest jar..." );
+                JarIndex destIndex = new JarIndex();
+                destIndex.indexJar( destJar, false );
+                TranslatingTypeLoader sourceLoader = new TranslatingTypeLoader( sourceJar, sourceIndex );
+                TranslatingTypeLoader destLoader = new TranslatingTypeLoader( destJar, destIndex );
+
                 // compute the matching
-                ClassMatching matching = ClassMapper.computeMatching( fromJar, toJar );
+                ClassMatching matching = ClassMatcher.computeMatching( sourceIndex, sourceLoader, destIndex, destLoader );
                 
-                // use the matching to convert the mappings
-                Mappings mappings = new MappingsReader().read( new FileReader( inMappingsFile ) );
+                // start the class conversion map with the unique and ambiguous matchings
                 Map<String,Map.Entry<ClassIdentity,List<ClassIdentity>>> conversionMap = matching.getConversionMap();
-                Map<String,String> finalConversion = Maps.newHashMap();
+                
+                // probabilistically match the unmatched source classes
+                for( ClassIdentity sourceClass : new ArrayList<ClassIdentity>( matching.getUnmatchedSourceClasses() ) )
+                {
+                        System.out.println( "No exact match for source class " + sourceClass.getClassEntry() );
+                        
+                        // find the closest classes
+                        TreeMap<Integer,ClassIdentity> scoredMatches = Maps.newTreeMap( Collections.reverseOrder() );
+                        for( ClassIdentity c : matching.getUnmatchedDestClasses() )
+                        {
+                                scoredMatches.put( sourceClass.getMatchScore( c ), c );
+                        }
+                        Iterator<Map.Entry<Integer,ClassIdentity>> iter = scoredMatches.entrySet().iterator();
+                        for( int i=0; i<10 && iter.hasNext(); i++ )
+                        {
+                                Map.Entry<Integer,ClassIdentity> score = iter.next();
+                                System.out.println( String.format( "\tScore: %3d   %s", score.getKey(), score.getValue().getClassEntry().getName() ) );
+                        }
+                        
+                        // does the best match have a non-zero score and the same name?
+                        Map.Entry<Integer,ClassIdentity> bestMatch = scoredMatches.firstEntry();
+                        if( bestMatch.getKey() > 0 && bestMatch.getValue().getClassEntry().equals( sourceClass.getClassEntry() ) )
+                        {
+                                // use it
+                                System.out.println( "\tAutomatically choosing likely match: " + bestMatch.getValue().getClassEntry().getName() );
+                                conversionMap.put(
+                                        sourceClass.getClassEntry().getName(),
+                                        new AbstractMap.SimpleEntry<ClassIdentity,List<ClassIdentity>>( sourceClass, Arrays.asList( bestMatch.getValue() ) )
+                                );
+                        }
+                }
+                
+                // use the matching to convert the mappings
+                BiMap<String,String> classConversion = HashBiMap.create();
                 Set<String> unmatchedSourceClasses = Sets.newHashSet();
-                for( ClassMapping classMapping : mappings.classes() )
+                for( String className : mappings.getAllObfClassNames() )
                 {
                         // is there a match for this class?
-                        Map.Entry<ClassIdentity,List<ClassIdentity>> entry = conversionMap.get( classMapping.getObfName() );
+                        Map.Entry<ClassIdentity,List<ClassIdentity>> entry = conversionMap.get( className );
                         ClassIdentity sourceClass = entry.getKey();
                         List<ClassIdentity> matches = entry.getValue();
                         
                         if( matches.isEmpty() )
                         {
                                 // no match! =(
-                                System.out.println( "No exact match for source class " + classMapping.getObfName() );
-                                
-                                // find the closest classes
-                                TreeMap<Integer,ClassIdentity> scoredMatches = Maps.newTreeMap( Collections.reverseOrder() );
-                                for( ClassIdentity c : matching.getUnmatchedDestClasses() )
-                                {
-                                        scoredMatches.put( sourceClass.getMatchScore( c ), c );
-                                }
-                                Iterator<Map.Entry<Integer,ClassIdentity>> iter = scoredMatches.entrySet().iterator();
-                                for( int i=0; i<10 && iter.hasNext(); i++ )
-                                {
-                                        Map.Entry<Integer,ClassIdentity> score = iter.next();
-                                        System.out.println( String.format( "\tScore: %3d   %s", score.getKey(), score.getValue().getClassEntry().getName() ) );
-                                }
-                                
-                                // does the best match have a non-zero score and the same name?
-                                Map.Entry<Integer,ClassIdentity> bestMatch = scoredMatches.firstEntry();
-                                if( bestMatch.getKey() > 0 && bestMatch.getValue().getClassEntry().equals( sourceClass.getClassEntry() ) )
-                                {
-                                        // use it
-                                        System.out.println( "\tAutomatically choosing likely match: " + bestMatch.getValue().getClassEntry().getName() );
-                                        addFinalConversion( finalConversion, sourceClass, bestMatch.getValue() );
-                                }
-                                else
-                                {
-                                        unmatchedSourceClasses.add( classMapping.getObfName() );
-                                }
+                                unmatchedSourceClasses.add( className );
                         }
-                        if( matches.size() == 1 )
+                        else if( matches.size() == 1 )
                         {
                                 // unique match! We're good to go!
-                                addFinalConversion( finalConversion, sourceClass, matches.get( 0 ) );
+                                classConversion.put(
+                                        sourceClass.getClassEntry().getName(),
+                                        matches.get( 0 ).getClassEntry().getName()
+                                );
                         }
                         else if( matches.size() > 1 )
                         {
                                 // too many matches! =(
-                                unmatchedSourceClasses.add( classMapping.getObfName() );
+                                unmatchedSourceClasses.add( className );
                         }
                 }
                 
@@ -121,39 +162,85 @@ public class ClassMapper
                 }
                 
                 // show the class name changes
-                for( Map.Entry<String,String> entry : finalConversion.entrySet() )
+                for( Map.Entry<String,String> entry : classConversion.entrySet() )
                 {
                         if( !entry.getKey().equals( entry.getValue() ) )
                         {
                                 System.out.println( String.format( "Class change: %s -> %s", entry.getKey(), entry.getValue() ) );
+                                /* DEBUG
+                                System.out.println( String.format( "\n%s\n%s",
+                                        new ClassIdentity( sourceLoader.loadClass( entry.getKey() ), null, sourceIndex, false, false ),
+                                        new ClassIdentity( destLoader.loadClass( entry.getValue() ), null, destIndex, false, false )
+                                ) );
+                                */
                         }
                 }
                 
-                // do the final conversion
-                mappings.renameObfClasses( finalConversion );
-                FileWriter writer = new FileWriter( outMappingsFile );
-                new MappingsWriter().write( writer, mappings );
-                writer.close();
-                System.out.println( "Wrote converted mappings to:\n\t" + outMappingsFile.getAbsolutePath() );
+                // TEMP: show some classes
+                for( String className : Arrays.asList( "none/em", "none/ej", "none/en" ) )
+                {
+                        System.out.println( String.format( "check: %s -> %s", className, classConversion.get( className ) ) );
+                }
+                
+                // convert the classes
+                mappings.renameObfClasses( classConversion );
+                
+                // look for method matches
+                System.out.println( "Matching methods..." );
+                for( ClassMapping classMapping : mappings.classes() )
+                {
+                        ClassEntry classEntry = new ClassEntry( classMapping.getObfName() );
+                        for( MethodMapping methodMapping : classMapping.methods() )
+                        {
+                                // skip constructors
+                                if( methodMapping.getObfName().equals( "<init>" ) )
+                                {
+                                        continue;
+                                }
+                                
+                                MethodEntry methodEntry = new MethodEntry(
+                                        classEntry,
+                                        methodMapping.getObfName(),
+                                        methodMapping.getObfSignature()
+                                );
+                                if( !destIndex.isMethodImplemented( methodEntry ) )
+                                {
+                                        System.err.println( "WARNING: method doesn't match: " + methodEntry );
+                                        
+                                        // show the available methods
+                                        System.err.println( "\tAvailable dest methods:" );
+                                        CtClass c = destLoader.loadClass( classMapping.getObfName() );
+                                        for( CtBehavior behavior : c.getDeclaredBehaviors() )
+                                        {
+                                                MethodEntry declaredMethodEntry = new MethodEntry(
+                                                        new ClassEntry( classMapping.getObfName() ),
+                                                        behavior.getName(),
+                                                        behavior.getSignature()
+                                                );
+                                                System.err.println( "\t\t" + declaredMethodEntry );
+                                        }
+                                        
+                                        System.err.println( "\tAvailable source methods:" );
+                                        c = sourceLoader.loadClass( classConversion.inverse().get( classMapping.getObfName() ) );
+                                        for( CtBehavior behavior : c.getDeclaredBehaviors() )
+                                        {
+                                                MethodEntry declaredMethodEntry = new MethodEntry(
+                                                        new ClassEntry( classMapping.getObfName() ),
+                                                        behavior.getName(),
+                                                        behavior.getSignature()
+                                                );
+                                                System.err.println( "\t\t" + declaredMethodEntry );
+                                        }
+                                }
+                        }
+                }
         }
         
-        public static ClassMatching computeMatching( JarFile sourceJar, JarFile destJar )
+        public static ClassMatching computeMatching( JarIndex sourceIndex, TranslatingTypeLoader sourceLoader, JarIndex destIndex, TranslatingTypeLoader destLoader )
         {
-                // index jars
-                System.out.println( "Indexing source jar..." );
-                JarIndex sourceIndex = new JarIndex();
-                sourceIndex.indexJar( sourceJar );
-                System.out.println( "Indexing dest jar..." );
-                JarIndex destIndex = new JarIndex();
-                destIndex.indexJar( destJar );
-                
-                System.out.println( "Computing matching..." );
-                
-                TranslatingTypeLoader sourceLoader = new TranslatingTypeLoader( sourceJar, sourceIndex );
-                TranslatingTypeLoader destLoader = new TranslatingTypeLoader( destJar, destIndex );
-
+                System.out.println( "Matching classes..." );
                 ClassMatching matching = null;
-                for( boolean useRawNames : Arrays.asList( false, true ) )
+                for( boolean useRawNames : Arrays.asList( false/*, true*/ ) )
                 {
                         for( boolean useReferences : Arrays.asList( false, true ) )
                         {
@@ -230,7 +317,28 @@ public class ClassMapper
                         }
                 }
                 
-                /* DEBUG: show some ambiguous matches
+                // DEBUG: check the class matches
+                System.out.println( "Checking class matches..." );
+                for( Map.Entry<ClassIdentity,ClassIdentity> entry : matching.getUniqueMatches().entrySet() )
+                {
+                        // check source
+                        ClassIdentity sourceClass = entry.getKey();
+                        CtClass sourceC = sourceLoader.loadClass( sourceClass.getClassEntry().getName() );
+                        assert( sourceC != null )
+                                : "Unable to load source class " + sourceClass.getClassEntry();
+                        assert( sourceClass.matches( sourceC ) )
+                                : "Source " + sourceClass + " doesn't match " + new ClassIdentity( sourceC, null, sourceIndex, false, false );
+                        
+                        // check dest
+                        ClassIdentity destClass = entry.getValue();
+                        CtClass destC = destLoader.loadClass( destClass.getClassEntry().getName() );
+                        assert( destC != null )
+                                : "Unable to load dest class " + destClass.getClassEntry();
+                        assert( destClass.matches( destC ) )
+                                : "Dest " + destClass + " doesn't match " + new ClassIdentity( destC, null, destIndex, false, false );
+                }
+                
+                // warn about the ambiguous matchings
                 List<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>> ambiguousMatches = new ArrayList<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>( matching.getAmbiguousMatches().entrySet() );
                 Collections.sort( ambiguousMatches, new Comparator<Map.Entry<List<ClassIdentity>,List<ClassIdentity>>>( )
                 {
@@ -244,12 +352,12 @@ public class ClassMapper
                 } );
                 for( Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry : ambiguousMatches )
                 {
-                        for( ClassIdentity c : entry.getKey() )
-                        {
-                                System.out.print( c.getClassEntry().getName() + " " );
-                        }
-                        System.out.println();
+                        System.out.println( "Ambiguous matching:" );
+                        System.out.println( "\tSource: " + getClassNames( entry.getKey() ) );
+                        System.out.println( "\tDest:   " + getClassNames( entry.getValue() ) );
                 }
+                
+                /* DEBUG
                 Map.Entry<List<ClassIdentity>,List<ClassIdentity>> entry = ambiguousMatches.get( 7 );
                 for( ClassIdentity c : entry.getKey() )
                 {
@@ -264,22 +372,15 @@ public class ClassMapper
                 return matching;
         }
         
-        private static void addFinalConversion( Map<String,String> finalConversion, ClassIdentity sourceClass, ClassIdentity destClass )
+        private static List<String> getClassNames( Collection<ClassIdentity> classes )
         {
-                // flatten inner classes since these are all obf classes in the none package
-                String sourceClassName = sourceClass.getClassEntry().getName();
-                if( sourceClass.getClassEntry().isInnerClass() )
+                List<String> out = Lists.newArrayList();
+                for( ClassIdentity c : classes )
                 {
-                        sourceClassName = Constants.NonePackage + "/" + sourceClass.getClassEntry().getInnerClassName();
+                        out.add( c.getClassEntry().getName() );
                 }
-                
-                String destClassName = destClass.getClassEntry().getName();
-                if( destClass.getClassEntry().isInnerClass() )
-                {
-                        destClassName = Constants.NonePackage + "/" + destClass.getClassEntry().getInnerClassName();
-                }
-                
-                finalConversion.put( sourceClassName, destClassName );
+                Collections.sort( out );
+                return out;
         }
         
         /* DEBUG